diff --git a/.gitattributes b/.gitattributes index 2bf5ee6fbbb87bcac9a44d2f41f3d657a170f49c..efdd65c5a6524e13a2ab4c4c50c9abb88455ce0f 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text data/imagenet_train_hr_indices.p filter=lfs diff=lfs merge=lfs -text +src/taming-transformers/assets/birddrawnbyachild.png filter=lfs diff=lfs merge=lfs -text +src/taming-transformers/assets/first_stage_mushrooms.png filter=lfs diff=lfs merge=lfs -text +src/taming-transformers/assets/first_stage_squirrels.png filter=lfs diff=lfs merge=lfs -text +src/taming-transformers/assets/imagenet.png filter=lfs diff=lfs merge=lfs -text +src/taming-transformers/data/open_images_annotations_100/train/000b1b3b85edd850.jpg filter=lfs diff=lfs merge=lfs -text +src/taming-transformers/data/open_images_annotations_100/validation/0a600f1148d1023c.jpg filter=lfs diff=lfs merge=lfs -text +src/taming-transformers/scripts/reconstruction_usage.ipynb filter=lfs diff=lfs merge=lfs -text diff --git a/src/CLIP/.github/workflows/test.yml b/src/CLIP/.github/workflows/test.yml new file mode 100644 index 0000000000000000000000000000000000000000..570a54198bb0d012a585c3999d5281c07cd339e9 --- /dev/null +++ b/src/CLIP/.github/workflows/test.yml @@ -0,0 +1,33 @@ +name: test +on: + push: + branches: + - main + pull_request: + branches: + - main +jobs: + CLIP-test: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: [3.8] + pytorch-version: [1.7.1, 1.9.1, 1.10.1] + include: + - python-version: 3.8 + pytorch-version: 1.7.1 + torchvision-version: 0.8.2 + - python-version: 3.8 + pytorch-version: 1.9.1 + torchvision-version: 0.10.1 + - python-version: 3.8 + pytorch-version: 1.10.1 + torchvision-version: 0.11.2 + steps: + - uses: conda-incubator/setup-miniconda@v2 + - run: conda install -n test python=${{ matrix.python-version }} pytorch=${{ matrix.pytorch-version }} torchvision=${{ matrix.torchvision-version }} cpuonly -c pytorch + - uses: actions/checkout@v2 + - run: echo "$CONDA/envs/test/bin" >> $GITHUB_PATH + - run: pip install pytest + - run: pip install . + - run: pytest diff --git a/src/CLIP/.gitignore b/src/CLIP/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..321f181f917b03529a05fc27aee81a0bd6fba32d --- /dev/null +++ b/src/CLIP/.gitignore @@ -0,0 +1,10 @@ +__pycache__/ +*.py[cod] +*$py.class +*.egg-info +.pytest_cache +.ipynb_checkpoints + +thumbs.db +.DS_Store +.idea diff --git a/src/CLIP/CLIP.png b/src/CLIP/CLIP.png new file mode 100644 index 0000000000000000000000000000000000000000..a1b5ec9171fd7a51e36e845a02304eb837142ba1 Binary files /dev/null and b/src/CLIP/CLIP.png differ diff --git a/src/CLIP/LICENSE b/src/CLIP/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..4e97f0b45803b7c04ae89548934af4f257a97501 --- /dev/null +++ b/src/CLIP/LICENSE @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2021 OpenAI + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/src/CLIP/MANIFEST.in b/src/CLIP/MANIFEST.in new file mode 100644 index 0000000000000000000000000000000000000000..effd8d995ff1842a48c69d2a0f7c8dce4423d7a2 --- /dev/null +++ b/src/CLIP/MANIFEST.in @@ -0,0 +1 @@ +include clip/bpe_simple_vocab_16e6.txt.gz diff --git a/src/CLIP/README.md b/src/CLIP/README.md new file mode 100644 index 0000000000000000000000000000000000000000..abc8a347e095c11c31b6a42a117f21630fa52bda --- /dev/null +++ b/src/CLIP/README.md @@ -0,0 +1,193 @@ +# CLIP + +[[Blog]](https://openai.com/blog/clip/) [[Paper]](https://arxiv.org/abs/2103.00020) [[Model Card]](model-card.md) [[Colab]](https://colab.research.google.com/github/openai/clip/blob/master/notebooks/Interacting_with_CLIP.ipynb) + +CLIP (Contrastive Language-Image Pre-Training) is a neural network trained on a variety of (image, text) pairs. It can be instructed in natural language to predict the most relevant text snippet, given an image, without directly optimizing for the task, similarly to the zero-shot capabilities of GPT-2 and 3. We found CLIP matches the performance of the original ResNet50 on ImageNet “zero-shot” without using any of the original 1.28M labeled examples, overcoming several major challenges in computer vision. + + + +## Approach + +![CLIP](CLIP.png) + + + +## Usage + +First, [install PyTorch 1.7.1](https://pytorch.org/get-started/locally/) (or later) and torchvision, as well as small additional dependencies, and then install this repo as a Python package. On a CUDA GPU machine, the following will do the trick: + +```bash +$ conda install --yes -c pytorch pytorch=1.7.1 torchvision cudatoolkit=11.0 +$ pip install ftfy regex tqdm +$ pip install git+https://github.com/openai/CLIP.git +``` + +Replace `cudatoolkit=11.0` above with the appropriate CUDA version on your machine or `cpuonly` when installing on a machine without a GPU. + +```python +import torch +import clip +from PIL import Image + +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load("ViT-B/32", device=device) + +image = preprocess(Image.open("CLIP.png")).unsqueeze(0).to(device) +text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device) + +with torch.no_grad(): + image_features = model.encode_image(image) + text_features = model.encode_text(text) + + logits_per_image, logits_per_text = model(image, text) + probs = logits_per_image.softmax(dim=-1).cpu().numpy() + +print("Label probs:", probs) # prints: [[0.9927937 0.00421068 0.00299572]] +``` + + +## API + +The CLIP module `clip` provides the following methods: + +#### `clip.available_models()` + +Returns the names of the available CLIP models. + +#### `clip.load(name, device=..., jit=False)` + +Returns the model and the TorchVision transform needed by the model, specified by the model name returned by `clip.available_models()`. It will download the model as necessary. The `name` argument can also be a path to a local checkpoint. + +The device to run the model can be optionally specified, and the default is to use the first CUDA device if there is any, otherwise the CPU. When `jit` is `False`, a non-JIT version of the model will be loaded. + +#### `clip.tokenize(text: Union[str, List[str]], context_length=77)` + +Returns a LongTensor containing tokenized sequences of given text input(s). This can be used as the input to the model + +--- + +The model returned by `clip.load()` supports the following methods: + +#### `model.encode_image(image: Tensor)` + +Given a batch of images, returns the image features encoded by the vision portion of the CLIP model. + +#### `model.encode_text(text: Tensor)` + +Given a batch of text tokens, returns the text features encoded by the language portion of the CLIP model. + +#### `model(image: Tensor, text: Tensor)` + +Given a batch of images and a batch of text tokens, returns two Tensors, containing the logit scores corresponding to each image and text input. The values are cosine similarities between the corresponding image and text features, times 100. + + + +## More Examples + +### Zero-Shot Prediction + +The code below performs zero-shot prediction using CLIP, as shown in Appendix B in the paper. This example takes an image from the [CIFAR-100 dataset](https://www.cs.toronto.edu/~kriz/cifar.html), and predicts the most likely labels among the 100 textual labels from the dataset. + +```python +import os +import clip +import torch +from torchvision.datasets import CIFAR100 + +# Load the model +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load('ViT-B/32', device) + +# Download the dataset +cifar100 = CIFAR100(root=os.path.expanduser("~/.cache"), download=True, train=False) + +# Prepare the inputs +image, class_id = cifar100[3637] +image_input = preprocess(image).unsqueeze(0).to(device) +text_inputs = torch.cat([clip.tokenize(f"a photo of a {c}") for c in cifar100.classes]).to(device) + +# Calculate features +with torch.no_grad(): + image_features = model.encode_image(image_input) + text_features = model.encode_text(text_inputs) + +# Pick the top 5 most similar labels for the image +image_features /= image_features.norm(dim=-1, keepdim=True) +text_features /= text_features.norm(dim=-1, keepdim=True) +similarity = (100.0 * image_features @ text_features.T).softmax(dim=-1) +values, indices = similarity[0].topk(5) + +# Print the result +print("\nTop predictions:\n") +for value, index in zip(values, indices): + print(f"{cifar100.classes[index]:>16s}: {100 * value.item():.2f}%") +``` + +The output will look like the following (the exact numbers may be slightly different depending on the compute device): + +``` +Top predictions: + + snake: 65.31% + turtle: 12.29% + sweet_pepper: 3.83% + lizard: 1.88% + crocodile: 1.75% +``` + +Note that this example uses the `encode_image()` and `encode_text()` methods that return the encoded features of given inputs. + + +### Linear-probe evaluation + +The example below uses [scikit-learn](https://scikit-learn.org/) to perform logistic regression on image features. + +```python +import os +import clip +import torch + +import numpy as np +from sklearn.linear_model import LogisticRegression +from torch.utils.data import DataLoader +from torchvision.datasets import CIFAR100 +from tqdm import tqdm + +# Load the model +device = "cuda" if torch.cuda.is_available() else "cpu" +model, preprocess = clip.load('ViT-B/32', device) + +# Load the dataset +root = os.path.expanduser("~/.cache") +train = CIFAR100(root, download=True, train=True, transform=preprocess) +test = CIFAR100(root, download=True, train=False, transform=preprocess) + + +def get_features(dataset): + all_features = [] + all_labels = [] + + with torch.no_grad(): + for images, labels in tqdm(DataLoader(dataset, batch_size=100)): + features = model.encode_image(images.to(device)) + + all_features.append(features) + all_labels.append(labels) + + return torch.cat(all_features).cpu().numpy(), torch.cat(all_labels).cpu().numpy() + +# Calculate the image features +train_features, train_labels = get_features(train) +test_features, test_labels = get_features(test) + +# Perform logistic regression +classifier = LogisticRegression(random_state=0, C=0.316, max_iter=1000, verbose=1) +classifier.fit(train_features, train_labels) + +# Evaluate using the logistic regression classifier +predictions = classifier.predict(test_features) +accuracy = np.mean((test_labels == predictions).astype(np.float)) * 100. +print(f"Accuracy = {accuracy:.3f}") +``` + +Note that the `C` value should be determined via a hyperparameter sweep using a validation split. diff --git a/src/CLIP/clip/__init__.py b/src/CLIP/clip/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dcc5619538c0f7c782508bdbd9587259d805e0d9 --- /dev/null +++ b/src/CLIP/clip/__init__.py @@ -0,0 +1 @@ +from .clip import * diff --git a/src/CLIP/clip/bpe_simple_vocab_16e6.txt.gz b/src/CLIP/clip/bpe_simple_vocab_16e6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..36a15856e00a06a9fbed8cdd34d2393fea4a3113 --- /dev/null +++ b/src/CLIP/clip/bpe_simple_vocab_16e6.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:924691ac288e54409236115652ad4aa250f48203de50a9e4722a6ecd48d6804a +size 1356917 diff --git a/src/CLIP/clip/clip.py b/src/CLIP/clip/clip.py new file mode 100644 index 0000000000000000000000000000000000000000..257511e1d40c120e0d64a0f1562d44b2b8a40a17 --- /dev/null +++ b/src/CLIP/clip/clip.py @@ -0,0 +1,237 @@ +import hashlib +import os +import urllib +import warnings +from typing import Any, Union, List +from pkg_resources import packaging + +import torch +from PIL import Image +from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize +from tqdm import tqdm + +from .model import build_model +from .simple_tokenizer import SimpleTokenizer as _Tokenizer + +try: + from torchvision.transforms import InterpolationMode + BICUBIC = InterpolationMode.BICUBIC +except ImportError: + BICUBIC = Image.BICUBIC + + +if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): + warnings.warn("PyTorch version 1.7.1 or higher is recommended") + + +__all__ = ["available_models", "load", "tokenize"] +_tokenizer = _Tokenizer() + +_MODELS = { + "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt", + "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt", + "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt", + "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt", + "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt", + "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt", + "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt", + "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt", + "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt", +} + + +def _download(url: str, root: str): + os.makedirs(root, exist_ok=True) + filename = os.path.basename(url) + + expected_sha256 = url.split("/")[-2] + download_target = os.path.join(root, filename) + + if os.path.exists(download_target) and not os.path.isfile(download_target): + raise RuntimeError(f"{download_target} exists and is not a regular file") + + if os.path.isfile(download_target): + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256: + return download_target + else: + warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file") + + with urllib.request.urlopen(url) as source, open(download_target, "wb") as output: + with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True, unit_divisor=1024) as loop: + while True: + buffer = source.read(8192) + if not buffer: + break + + output.write(buffer) + loop.update(len(buffer)) + + if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256: + raise RuntimeError("Model has been downloaded but the SHA256 checksum does not not match") + + return download_target + + +def _convert_image_to_rgb(image): + return image.convert("RGB") + + +def _transform(n_px): + return Compose([ + Resize(n_px, interpolation=BICUBIC), + CenterCrop(n_px), + _convert_image_to_rgb, + ToTensor(), + Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + +def available_models() -> List[str]: + """Returns the names of available CLIP models""" + return list(_MODELS.keys()) + + +def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit: bool = False, download_root: str = None): + """Load a CLIP model + + Parameters + ---------- + name : str + A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict + + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + if name in _MODELS: + model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip")) + elif os.path.isfile(name): + model_path = name + else: + raise RuntimeError(f"Model {name} not found; available models = {available_models()}") + + with open(model_path, 'rb') as opened_file: + try: + # loading JIT archive + model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval() + state_dict = None + except RuntimeError: + # loading saved state dict + if jit: + warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead") + jit = False + state_dict = torch.load(opened_file, map_location="cpu") + + if not jit: + model = build_model(state_dict or model.state_dict()).to(device) + if str(device) == "cpu": + model.float() + return model, _transform(model.visual.input_resolution) + + # patch the device names + device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[]) + device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1] + + def patch_device(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("prim::Constant"): + if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"): + node.copyAttributes(device_node) + + model.apply(patch_device) + patch_device(model.encode_image) + patch_device(model.encode_text) + + # patch dtype to float32 on CPU + if str(device) == "cpu": + float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[]) + float_input = list(float_holder.graph.findNode("aten::to").inputs())[1] + float_node = float_input.node() + + def patch_float(module): + try: + graphs = [module.graph] if hasattr(module, "graph") else [] + except RuntimeError: + graphs = [] + + if hasattr(module, "forward1"): + graphs.append(module.forward1.graph) + + for graph in graphs: + for node in graph.findAllNodes("aten::to"): + inputs = list(node.inputs()) + for i in [1, 2]: # dtype can be the second or third argument to aten::to() + if inputs[i].node()["value"] == 5: + inputs[i].node().copyAttributes(float_node) + + model.apply(patch_float) + patch_float(model.encode_image) + patch_float(model.encode_text) + + model.float() + + return model, _transform(model.input_resolution.item()) + + +def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[torch.IntTensor, torch.LongTensor]: + """ + Returns the tokenized representation of given input string(s) + + Parameters + ---------- + texts : Union[str, List[str]] + An input string or a list of input strings to tokenize + + context_length : int + The context length to use; all CLIP models use 77 as the context length + + truncate: bool + Whether to truncate the text in case its encoding is longer than the context length + + Returns + ------- + A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length]. + We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long. + """ + if isinstance(texts, str): + texts = [texts] + + sot_token = _tokenizer.encoder["<|startoftext|>"] + eot_token = _tokenizer.encoder["<|endoftext|>"] + all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts] + if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"): + result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + else: + result = torch.zeros(len(all_tokens), context_length, dtype=torch.int) + + for i, tokens in enumerate(all_tokens): + if len(tokens) > context_length: + if truncate: + tokens = tokens[:context_length] + tokens[-1] = eot_token + else: + raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}") + result[i, :len(tokens)] = torch.tensor(tokens) + + return result diff --git a/src/CLIP/clip/model.py b/src/CLIP/clip/model.py new file mode 100644 index 0000000000000000000000000000000000000000..232b7792eb97440642547bd462cf128df9243933 --- /dev/null +++ b/src/CLIP/clip/model.py @@ -0,0 +1,436 @@ +from collections import OrderedDict +from typing import Tuple, Union + +import numpy as np +import torch +import torch.nn.functional as F +from torch import nn + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1): + super().__init__() + + # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1 + self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.relu1 = nn.ReLU(inplace=True) + + self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + self.relu2 = nn.ReLU(inplace=True) + + self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity() + + self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False) + self.bn3 = nn.BatchNorm2d(planes * self.expansion) + self.relu3 = nn.ReLU(inplace=True) + + self.downsample = None + self.stride = stride + + if stride > 1 or inplanes != planes * Bottleneck.expansion: + # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1 + self.downsample = nn.Sequential(OrderedDict([ + ("-1", nn.AvgPool2d(stride)), + ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)), + ("1", nn.BatchNorm2d(planes * self.expansion)) + ])) + + def forward(self, x: torch.Tensor): + identity = x + + out = self.relu1(self.bn1(self.conv1(x))) + out = self.relu2(self.bn2(self.conv2(out))) + out = self.avgpool(out) + out = self.bn3(self.conv3(out)) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu3(out) + return out + + +class AttentionPool2d(nn.Module): + def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None): + super().__init__() + self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5) + self.k_proj = nn.Linear(embed_dim, embed_dim) + self.q_proj = nn.Linear(embed_dim, embed_dim) + self.v_proj = nn.Linear(embed_dim, embed_dim) + self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim) + self.num_heads = num_heads + + def forward(self, x): + x = x.flatten(start_dim=2).permute(2, 0, 1) # NCHW -> (HW)NC + x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (HW+1)NC + x = x + self.positional_embedding[:, None, :].to(x.dtype) # (HW+1)NC + x, _ = F.multi_head_attention_forward( + query=x[:1], key=x, value=x, + embed_dim_to_check=x.shape[-1], + num_heads=self.num_heads, + q_proj_weight=self.q_proj.weight, + k_proj_weight=self.k_proj.weight, + v_proj_weight=self.v_proj.weight, + in_proj_weight=None, + in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]), + bias_k=None, + bias_v=None, + add_zero_attn=False, + dropout_p=0, + out_proj_weight=self.c_proj.weight, + out_proj_bias=self.c_proj.bias, + use_separate_proj_weight=True, + training=self.training, + need_weights=False + ) + return x.squeeze(0) + + +class ModifiedResNet(nn.Module): + """ + A ResNet class that is similar to torchvision's but contains the following changes: + - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool. + - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1 + - The final pooling layer is a QKV attention instead of an average pool + """ + + def __init__(self, layers, output_dim, heads, input_resolution=224, width=64): + super().__init__() + self.output_dim = output_dim + self.input_resolution = input_resolution + + # the 3-layer stem + self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(width // 2) + self.relu1 = nn.ReLU(inplace=True) + self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(width // 2) + self.relu2 = nn.ReLU(inplace=True) + self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False) + self.bn3 = nn.BatchNorm2d(width) + self.relu3 = nn.ReLU(inplace=True) + self.avgpool = nn.AvgPool2d(2) + + # residual layers + self._inplanes = width # this is a *mutable* variable used during construction + self.layer1 = self._make_layer(width, layers[0]) + self.layer2 = self._make_layer(width * 2, layers[1], stride=2) + self.layer3 = self._make_layer(width * 4, layers[2], stride=2) + self.layer4 = self._make_layer(width * 8, layers[3], stride=2) + + embed_dim = width * 32 # the ResNet feature dimension + self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim) + + def _make_layer(self, planes, blocks, stride=1): + layers = [Bottleneck(self._inplanes, planes, stride)] + + self._inplanes = planes * Bottleneck.expansion + for _ in range(1, blocks): + layers.append(Bottleneck(self._inplanes, planes)) + + return nn.Sequential(*layers) + + def forward(self, x): + def stem(x): + x = self.relu1(self.bn1(self.conv1(x))) + x = self.relu2(self.bn2(self.conv2(x))) + x = self.relu3(self.bn3(self.conv3(x))) + x = self.avgpool(x) + return x + + x = x.type(self.conv1.weight.dtype) + x = stem(x) + x = self.layer1(x) + x = self.layer2(x) + x = self.layer3(x) + x = self.layer4(x) + x = self.attnpool(x) + + return x + + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm to handle fp16.""" + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + ret = super().forward(x.type(torch.float32)) + return ret.type(orig_type) + + +class QuickGELU(nn.Module): + def forward(self, x: torch.Tensor): + return x * torch.sigmoid(1.702 * x) + + +class ResidualAttentionBlock(nn.Module): + def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None): + super().__init__() + + self.attn = nn.MultiheadAttention(d_model, n_head) + self.ln_1 = LayerNorm(d_model) + self.mlp = nn.Sequential(OrderedDict([ + ("c_fc", nn.Linear(d_model, d_model * 4)), + ("gelu", QuickGELU()), + ("c_proj", nn.Linear(d_model * 4, d_model)) + ])) + self.ln_2 = LayerNorm(d_model) + self.attn_mask = attn_mask + + def attention(self, x: torch.Tensor): + self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None + return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0] + + def forward(self, x: torch.Tensor): + x = x + self.attention(self.ln_1(x)) + x = x + self.mlp(self.ln_2(x)) + return x + + +class Transformer(nn.Module): + def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None): + super().__init__() + self.width = width + self.layers = layers + self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)]) + + def forward(self, x: torch.Tensor): + return self.resblocks(x) + + +class VisionTransformer(nn.Module): + def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int): + super().__init__() + self.input_resolution = input_resolution + self.output_dim = output_dim + self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False) + + scale = width ** -0.5 + self.class_embedding = nn.Parameter(scale * torch.randn(width)) + self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width)) + self.ln_pre = LayerNorm(width) + + self.transformer = Transformer(width, layers, heads) + + self.ln_post = LayerNorm(width) + self.proj = nn.Parameter(scale * torch.randn(width, output_dim)) + + def forward(self, x: torch.Tensor): + x = self.conv1(x) # shape = [*, width, grid, grid] + x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2] + x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width] + x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1) # shape = [*, grid ** 2 + 1, width] + x = x + self.positional_embedding.to(x.dtype) + x = self.ln_pre(x) + + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + + x = self.ln_post(x[:, 0, :]) + + if self.proj is not None: + x = x @ self.proj + + return x + + +class CLIP(nn.Module): + def __init__(self, + embed_dim: int, + # vision + image_resolution: int, + vision_layers: Union[Tuple[int, int, int, int], int], + vision_width: int, + vision_patch_size: int, + # text + context_length: int, + vocab_size: int, + transformer_width: int, + transformer_heads: int, + transformer_layers: int + ): + super().__init__() + + self.context_length = context_length + + if isinstance(vision_layers, (tuple, list)): + vision_heads = vision_width * 32 // 64 + self.visual = ModifiedResNet( + layers=vision_layers, + output_dim=embed_dim, + heads=vision_heads, + input_resolution=image_resolution, + width=vision_width + ) + else: + vision_heads = vision_width // 64 + self.visual = VisionTransformer( + input_resolution=image_resolution, + patch_size=vision_patch_size, + width=vision_width, + layers=vision_layers, + heads=vision_heads, + output_dim=embed_dim + ) + + self.transformer = Transformer( + width=transformer_width, + layers=transformer_layers, + heads=transformer_heads, + attn_mask=self.build_attention_mask() + ) + + self.vocab_size = vocab_size + self.token_embedding = nn.Embedding(vocab_size, transformer_width) + self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width)) + self.ln_final = LayerNorm(transformer_width) + + self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim)) + self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07)) + + self.initialize_parameters() + + def initialize_parameters(self): + nn.init.normal_(self.token_embedding.weight, std=0.02) + nn.init.normal_(self.positional_embedding, std=0.01) + + if isinstance(self.visual, ModifiedResNet): + if self.visual.attnpool is not None: + std = self.visual.attnpool.c_proj.in_features ** -0.5 + nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std) + nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std) + + for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]: + for name, param in resnet_block.named_parameters(): + if name.endswith("bn3.weight"): + nn.init.zeros_(param) + + proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5) + attn_std = self.transformer.width ** -0.5 + fc_std = (2 * self.transformer.width) ** -0.5 + for block in self.transformer.resblocks: + nn.init.normal_(block.attn.in_proj_weight, std=attn_std) + nn.init.normal_(block.attn.out_proj.weight, std=proj_std) + nn.init.normal_(block.mlp.c_fc.weight, std=fc_std) + nn.init.normal_(block.mlp.c_proj.weight, std=proj_std) + + if self.text_projection is not None: + nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5) + + def build_attention_mask(self): + # lazily create causal attention mask, with full attention between the vision tokens + # pytorch uses additive attention mask; fill with -inf + mask = torch.empty(self.context_length, self.context_length) + mask.fill_(float("-inf")) + mask.triu_(1) # zero out the lower diagonal + return mask + + @property + def dtype(self): + return self.visual.conv1.weight.dtype + + def encode_image(self, image): + return self.visual(image.type(self.dtype)) + + def encode_text(self, text): + x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model] + + x = x + self.positional_embedding.type(self.dtype) + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + x = self.ln_final(x).type(self.dtype) + + # x.shape = [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection + + return x + + def forward(self, image, text): + image_features = self.encode_image(image) + text_features = self.encode_text(text) + + # normalized features + image_features = image_features / image_features.norm(dim=1, keepdim=True) + text_features = text_features / text_features.norm(dim=1, keepdim=True) + + # cosine similarity as logits + logit_scale = self.logit_scale.exp() + logits_per_image = logit_scale * image_features @ text_features.t() + logits_per_text = logits_per_image.t() + + # shape = [global_batch_size, global_batch_size] + return logits_per_image, logits_per_text + + +def convert_weights(model: nn.Module): + """Convert applicable model parameters to fp16""" + + def _convert_weights_to_fp16(l): + if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)): + l.weight.data = l.weight.data.half() + if l.bias is not None: + l.bias.data = l.bias.data.half() + + if isinstance(l, nn.MultiheadAttention): + for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]: + tensor = getattr(l, attr) + if tensor is not None: + tensor.data = tensor.data.half() + + for name in ["text_projection", "proj"]: + if hasattr(l, name): + attr = getattr(l, name) + if attr is not None: + attr.data = attr.data.half() + + model.apply(_convert_weights_to_fp16) + + +def build_model(state_dict: dict): + vit = "visual.proj" in state_dict + + if vit: + vision_width = state_dict["visual.conv1.weight"].shape[0] + vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")]) + vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] + grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5) + image_resolution = vision_patch_size * grid_size + else: + counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]] + vision_layers = tuple(counts) + vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0] + output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5) + vision_patch_size = None + assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0] + image_resolution = output_width * 32 + + embed_dim = state_dict["text_projection"].shape[1] + context_length = state_dict["positional_embedding"].shape[0] + vocab_size = state_dict["token_embedding.weight"].shape[0] + transformer_width = state_dict["ln_final.weight"].shape[0] + transformer_heads = transformer_width // 64 + transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith("transformer.resblocks"))) + + model = CLIP( + embed_dim, + image_resolution, vision_layers, vision_width, vision_patch_size, + context_length, vocab_size, transformer_width, transformer_heads, transformer_layers + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + if key in state_dict: + del state_dict[key] + + convert_weights(model) + model.load_state_dict(state_dict) + return model.eval() diff --git a/src/CLIP/clip/simple_tokenizer.py b/src/CLIP/clip/simple_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..0a66286b7d5019c6e221932a813768038f839c91 --- /dev/null +++ b/src/CLIP/clip/simple_tokenizer.py @@ -0,0 +1,132 @@ +import gzip +import html +import os +from functools import lru_cache + +import ftfy +import regex as re + + +@lru_cache() +def default_bpe(): + return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz") + + +@lru_cache() +def bytes_to_unicode(): + """ + Returns list of utf-8 byte and a corresponding list of unicode strings. + The reversible bpe codes work on unicode strings. + This means you need a large # of unicode characters in your vocab if you want to avoid UNKs. + When you're at something like a 10B token dataset you end up needing around 5K for decent coverage. + This is a signficant percentage of your normal, say, 32K bpe vocab. + To avoid that, we want lookup tables between utf-8 bytes and unicode strings. + And avoids mapping to whitespace/control characters the bpe code barfs on. + """ + bs = list(range(ord("!"), ord("~")+1))+list(range(ord("¡"), ord("¬")+1))+list(range(ord("®"), ord("ÿ")+1)) + cs = bs[:] + n = 0 + for b in range(2**8): + if b not in bs: + bs.append(b) + cs.append(2**8+n) + n += 1 + cs = [chr(n) for n in cs] + return dict(zip(bs, cs)) + + +def get_pairs(word): + """Return set of symbol pairs in a word. + Word is represented as tuple of symbols (symbols being variable-length strings). + """ + pairs = set() + prev_char = word[0] + for char in word[1:]: + pairs.add((prev_char, char)) + prev_char = char + return pairs + + +def basic_clean(text): + text = ftfy.fix_text(text) + text = html.unescape(html.unescape(text)) + return text.strip() + + +def whitespace_clean(text): + text = re.sub(r'\s+', ' ', text) + text = text.strip() + return text + + +class SimpleTokenizer(object): + def __init__(self, bpe_path: str = default_bpe()): + self.byte_encoder = bytes_to_unicode() + self.byte_decoder = {v: k for k, v in self.byte_encoder.items()} + merges = gzip.open(bpe_path).read().decode("utf-8").split('\n') + merges = merges[1:49152-256-2+1] + merges = [tuple(merge.split()) for merge in merges] + vocab = list(bytes_to_unicode().values()) + vocab = vocab + [v+'' for v in vocab] + for merge in merges: + vocab.append(''.join(merge)) + vocab.extend(['<|startoftext|>', '<|endoftext|>']) + self.encoder = dict(zip(vocab, range(len(vocab)))) + self.decoder = {v: k for k, v in self.encoder.items()} + self.bpe_ranks = dict(zip(merges, range(len(merges)))) + self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'} + self.pat = re.compile(r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""", re.IGNORECASE) + + def bpe(self, token): + if token in self.cache: + return self.cache[token] + word = tuple(token[:-1]) + ( token[-1] + '',) + pairs = get_pairs(word) + + if not pairs: + return token+'' + + while True: + bigram = min(pairs, key = lambda pair: self.bpe_ranks.get(pair, float('inf'))) + if bigram not in self.bpe_ranks: + break + first, second = bigram + new_word = [] + i = 0 + while i < len(word): + try: + j = word.index(first, i) + new_word.extend(word[i:j]) + i = j + except: + new_word.extend(word[i:]) + break + + if word[i] == first and i < len(word)-1 and word[i+1] == second: + new_word.append(first+second) + i += 2 + else: + new_word.append(word[i]) + i += 1 + new_word = tuple(new_word) + word = new_word + if len(word) == 1: + break + else: + pairs = get_pairs(word) + word = ' '.join(word) + self.cache[token] = word + return word + + def encode(self, text): + bpe_tokens = [] + text = whitespace_clean(basic_clean(text)).lower() + for token in re.findall(self.pat, text): + token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8')) + bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' ')) + return bpe_tokens + + def decode(self, tokens): + text = ''.join([self.decoder[token] for token in tokens]) + text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('', ' ') + return text diff --git a/src/CLIP/data/country211.md b/src/CLIP/data/country211.md new file mode 100644 index 0000000000000000000000000000000000000000..4cd096005c8e5777e0706d97d182c3bd87b651a9 --- /dev/null +++ b/src/CLIP/data/country211.md @@ -0,0 +1,12 @@ +# The Country211 Dataset + +In the paper, we used an image classification dataset called Country211, to evaluate the model's capability on geolocation. To do so, we filtered the YFCC100m dataset that have GPS coordinate corresponding to a [ISO-3166 country code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) and created a balanced dataset by sampling 150 train images, 50 validation images, and 100 test images images for each country. + +The following command will download an 11GB archive countaining the images and extract into a subdirectory `country211`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/country211.tgz +tar zxvf country211.tgz +``` + +These images are a subset of the YFCC100m dataset. Use of the underlying media files is subject to the Creative Commons licenses chosen by their creators/uploaders. For more information about the YFCC100M dataset, visit [the official website](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/). \ No newline at end of file diff --git a/src/CLIP/data/prompts.md b/src/CLIP/data/prompts.md new file mode 100644 index 0000000000000000000000000000000000000000..6d8aaf7b13f04031e7ea00d58a1c131b98bdfe20 --- /dev/null +++ b/src/CLIP/data/prompts.md @@ -0,0 +1,3401 @@ +# Prompts for Image Classification + +Below are the class names and templates that are used for collecting the zero-shot classification scores in the paper. Each dataset has two lists `classes` and `templates`, where the string `{}` in the template is to be replaced with the corresponding class names. For the Facial Emotion Recognition 2013 dataset specifically, we used multiple class names for certain classes. + +This file contains prompt data for 26 of the 27 datasets shown in Table 9 of the paper; the text prompts for ImageNet (as well as other [ImageNet Testbed](https://modestyachts.github.io/imagenet-testbed/) datasets in Figure 13) can be found in [this notebook](https://github.com/openai/CLIP/blob/main/notebooks/Prompt_Engineering_for_ImageNet.ipynb), as well as how to ensemble predictions from multiple prompts using these templates. + +If you are viewing this document on GitHub, use the table of contents icon at the upper left to browse the datasets. + + +## Birdsnap + +```bash +classes = [ + 'Acadian Flycatcher', + 'Acorn Woodpecker', + 'Alder Flycatcher', + 'Allens Hummingbird', + 'Altamira Oriole', + 'American Avocet', + 'American Bittern', + 'American Black Duck', + 'American Coot', + 'American Crow', + 'American Dipper', + 'American Golden Plover', + 'American Goldfinch', + 'American Kestrel', + 'American Oystercatcher', + 'American Pipit', + 'American Redstart', + 'American Robin', + 'American Three toed Woodpecker', + 'American Tree Sparrow', + 'American White Pelican', + 'American Wigeon', + 'American Woodcock', + 'Anhinga', + 'Annas Hummingbird', + 'Arctic Tern', + 'Ash throated Flycatcher', + 'Audubons Oriole', + 'Bairds Sandpiper', + 'Bald Eagle', + 'Baltimore Oriole', + 'Band tailed Pigeon', + 'Barn Swallow', + 'Barred Owl', + 'Barrows Goldeneye', + 'Bay breasted Warbler', + 'Bells Vireo', + 'Belted Kingfisher', + 'Bewicks Wren', + 'Black Guillemot', + 'Black Oystercatcher', + 'Black Phoebe', + 'Black Rosy Finch', + 'Black Scoter', + 'Black Skimmer', + 'Black Tern', + 'Black Turnstone', + 'Black Vulture', + 'Black and white Warbler', + 'Black backed Woodpecker', + 'Black bellied Plover', + 'Black billed Cuckoo', + 'Black billed Magpie', + 'Black capped Chickadee', + 'Black chinned Hummingbird', + 'Black chinned Sparrow', + 'Black crested Titmouse', + 'Black crowned Night Heron', + 'Black headed Grosbeak', + 'Black legged Kittiwake', + 'Black necked Stilt', + 'Black throated Blue Warbler', + 'Black throated Gray Warbler', + 'Black throated Green Warbler', + 'Black throated Sparrow', + 'Blackburnian Warbler', + 'Blackpoll Warbler', + 'Blue Grosbeak', + 'Blue Jay', + 'Blue gray Gnatcatcher', + 'Blue headed Vireo', + 'Blue winged Teal', + 'Blue winged Warbler', + 'Boat tailed Grackle', + 'Bobolink', + 'Bohemian Waxwing', + 'Bonapartes Gull', + 'Boreal Chickadee', + 'Brandts Cormorant', + 'Brant', + 'Brewers Blackbird', + 'Brewers Sparrow', + 'Bridled Titmouse', + 'Broad billed Hummingbird', + 'Broad tailed Hummingbird', + 'Broad winged Hawk', + 'Bronzed Cowbird', + 'Brown Creeper', + 'Brown Pelican', + 'Brown Thrasher', + 'Brown capped Rosy Finch', + 'Brown crested Flycatcher', + 'Brown headed Cowbird', + 'Brown headed Nuthatch', + 'Bufflehead', + 'Bullocks Oriole', + 'Burrowing Owl', + 'Bushtit', + 'Cackling Goose', + 'Cactus Wren', + 'California Gull', + 'California Quail', + 'California Thrasher', + 'California Towhee', + 'Calliope Hummingbird', + 'Canada Goose', + 'Canada Warbler', + 'Canvasback', + 'Canyon Towhee', + 'Canyon Wren', + 'Cape May Warbler', + 'Carolina Chickadee', + 'Carolina Wren', + 'Caspian Tern', + 'Cassins Finch', + 'Cassins Kingbird', + 'Cassins Sparrow', + 'Cassins Vireo', + 'Cattle Egret', + 'Cave Swallow', + 'Cedar Waxwing', + 'Cerulean Warbler', + 'Chestnut backed Chickadee', + 'Chestnut collared Longspur', + 'Chestnut sided Warbler', + 'Chihuahuan Raven', + 'Chimney Swift', + 'Chipping Sparrow', + 'Cinnamon Teal', + 'Clapper Rail', + 'Clarks Grebe', + 'Clarks Nutcracker', + 'Clay colored Sparrow', + 'Cliff Swallow', + 'Common Black Hawk', + 'Common Eider', + 'Common Gallinule', + 'Common Goldeneye', + 'Common Grackle', + 'Common Ground Dove', + 'Common Loon', + 'Common Merganser', + 'Common Murre', + 'Common Nighthawk', + 'Common Raven', + 'Common Redpoll', + 'Common Tern', + 'Common Yellowthroat', + 'Connecticut Warbler', + 'Coopers Hawk', + 'Cordilleran Flycatcher', + 'Costas Hummingbird', + 'Couchs Kingbird', + 'Crested Caracara', + 'Curve billed Thrasher', + 'Dark eyed Junco', + 'Dickcissel', + 'Double crested Cormorant', + 'Downy Woodpecker', + 'Dunlin', + 'Dusky Flycatcher', + 'Dusky Grouse', + 'Eared Grebe', + 'Eastern Bluebird', + 'Eastern Kingbird', + 'Eastern Meadowlark', + 'Eastern Phoebe', + 'Eastern Screech Owl', + 'Eastern Towhee', + 'Eastern Wood Pewee', + 'Elegant Trogon', + 'Elf Owl', + 'Eurasian Collared Dove', + 'Eurasian Wigeon', + 'European Starling', + 'Evening Grosbeak', + 'Ferruginous Hawk', + 'Ferruginous Pygmy Owl', + 'Field Sparrow', + 'Fish Crow', + 'Florida Scrub Jay', + 'Forsters Tern', + 'Fox Sparrow', + 'Franklins Gull', + 'Fulvous Whistling Duck', + 'Gadwall', + 'Gambels Quail', + 'Gila Woodpecker', + 'Glaucous Gull', + 'Glaucous winged Gull', + 'Glossy Ibis', + 'Golden Eagle', + 'Golden crowned Kinglet', + 'Golden crowned Sparrow', + 'Golden fronted Woodpecker', + 'Golden winged Warbler', + 'Grasshopper Sparrow', + 'Gray Catbird', + 'Gray Flycatcher', + 'Gray Jay', + 'Gray Kingbird', + 'Gray cheeked Thrush', + 'Gray crowned Rosy Finch', + 'Great Black backed Gull', + 'Great Blue Heron', + 'Great Cormorant', + 'Great Crested Flycatcher', + 'Great Egret', + 'Great Gray Owl', + 'Great Horned Owl', + 'Great Kiskadee', + 'Great tailed Grackle', + 'Greater Prairie Chicken', + 'Greater Roadrunner', + 'Greater Sage Grouse', + 'Greater Scaup', + 'Greater White fronted Goose', + 'Greater Yellowlegs', + 'Green Jay', + 'Green tailed Towhee', + 'Green winged Teal', + 'Groove billed Ani', + 'Gull billed Tern', + 'Hairy Woodpecker', + 'Hammonds Flycatcher', + 'Harlequin Duck', + 'Harriss Hawk', + 'Harriss Sparrow', + 'Heermanns Gull', + 'Henslows Sparrow', + 'Hepatic Tanager', + 'Hermit Thrush', + 'Herring Gull', + 'Hoary Redpoll', + 'Hooded Merganser', + 'Hooded Oriole', + 'Hooded Warbler', + 'Horned Grebe', + 'Horned Lark', + 'House Finch', + 'House Sparrow', + 'House Wren', + 'Huttons Vireo', + 'Iceland Gull', + 'Inca Dove', + 'Indigo Bunting', + 'Killdeer', + 'King Rail', + 'Ladder backed Woodpecker', + 'Lapland Longspur', + 'Lark Bunting', + 'Lark Sparrow', + 'Laughing Gull', + 'Lazuli Bunting', + 'Le Contes Sparrow', + 'Least Bittern', + 'Least Flycatcher', + 'Least Grebe', + 'Least Sandpiper', + 'Least Tern', + 'Lesser Goldfinch', + 'Lesser Nighthawk', + 'Lesser Scaup', + 'Lesser Yellowlegs', + 'Lewiss Woodpecker', + 'Limpkin', + 'Lincolns Sparrow', + 'Little Blue Heron', + 'Loggerhead Shrike', + 'Long billed Curlew', + 'Long billed Dowitcher', + 'Long billed Thrasher', + 'Long eared Owl', + 'Long tailed Duck', + 'Louisiana Waterthrush', + 'Magnificent Frigatebird', + 'Magnolia Warbler', + 'Mallard', + 'Marbled Godwit', + 'Marsh Wren', + 'Merlin', + 'Mew Gull', + 'Mexican Jay', + 'Mississippi Kite', + 'Monk Parakeet', + 'Mottled Duck', + 'Mountain Bluebird', + 'Mountain Chickadee', + 'Mountain Plover', + 'Mourning Dove', + 'Mourning Warbler', + 'Muscovy Duck', + 'Mute Swan', + 'Nashville Warbler', + 'Nelsons Sparrow', + 'Neotropic Cormorant', + 'Northern Bobwhite', + 'Northern Cardinal', + 'Northern Flicker', + 'Northern Gannet', + 'Northern Goshawk', + 'Northern Harrier', + 'Northern Hawk Owl', + 'Northern Mockingbird', + 'Northern Parula', + 'Northern Pintail', + 'Northern Rough winged Swallow', + 'Northern Saw whet Owl', + 'Northern Shrike', + 'Northern Waterthrush', + 'Nuttalls Woodpecker', + 'Oak Titmouse', + 'Olive Sparrow', + 'Olive sided Flycatcher', + 'Orange crowned Warbler', + 'Orchard Oriole', + 'Osprey', + 'Ovenbird', + 'Pacific Golden Plover', + 'Pacific Loon', + 'Pacific Wren', + 'Pacific slope Flycatcher', + 'Painted Bunting', + 'Painted Redstart', + 'Palm Warbler', + 'Pectoral Sandpiper', + 'Peregrine Falcon', + 'Phainopepla', + 'Philadelphia Vireo', + 'Pied billed Grebe', + 'Pigeon Guillemot', + 'Pileated Woodpecker', + 'Pine Grosbeak', + 'Pine Siskin', + 'Pine Warbler', + 'Piping Plover', + 'Plumbeous Vireo', + 'Prairie Falcon', + 'Prairie Warbler', + 'Prothonotary Warbler', + 'Purple Finch', + 'Purple Gallinule', + 'Purple Martin', + 'Purple Sandpiper', + 'Pygmy Nuthatch', + 'Pyrrhuloxia', + 'Red Crossbill', + 'Red Knot', + 'Red Phalarope', + 'Red bellied Woodpecker', + 'Red breasted Merganser', + 'Red breasted Nuthatch', + 'Red breasted Sapsucker', + 'Red cockaded Woodpecker', + 'Red eyed Vireo', + 'Red headed Woodpecker', + 'Red naped Sapsucker', + 'Red necked Grebe', + 'Red necked Phalarope', + 'Red shouldered Hawk', + 'Red tailed Hawk', + 'Red throated Loon', + 'Red winged Blackbird', + 'Reddish Egret', + 'Redhead', + 'Ring billed Gull', + 'Ring necked Duck', + 'Ring necked Pheasant', + 'Rock Pigeon', + 'Rock Ptarmigan', + 'Rock Sandpiper', + 'Rock Wren', + 'Rose breasted Grosbeak', + 'Roseate Tern', + 'Rosss Goose', + 'Rough legged Hawk', + 'Royal Tern', + 'Ruby crowned Kinglet', + 'Ruby throated Hummingbird', + 'Ruddy Duck', + 'Ruddy Turnstone', + 'Ruffed Grouse', + 'Rufous Hummingbird', + 'Rufous crowned Sparrow', + 'Rusty Blackbird', + 'Sage Thrasher', + 'Saltmarsh Sparrow', + 'Sanderling', + 'Sandhill Crane', + 'Sandwich Tern', + 'Says Phoebe', + 'Scaled Quail', + 'Scarlet Tanager', + 'Scissor tailed Flycatcher', + 'Scotts Oriole', + 'Seaside Sparrow', + 'Sedge Wren', + 'Semipalmated Plover', + 'Semipalmated Sandpiper', + 'Sharp shinned Hawk', + 'Sharp tailed Grouse', + 'Short billed Dowitcher', + 'Short eared Owl', + 'Snail Kite', + 'Snow Bunting', + 'Snow Goose', + 'Snowy Egret', + 'Snowy Owl', + 'Snowy Plover', + 'Solitary Sandpiper', + 'Song Sparrow', + 'Sooty Grouse', + 'Sora', + 'Spotted Owl', + 'Spotted Sandpiper', + 'Spotted Towhee', + 'Spruce Grouse', + 'Stellers Jay', + 'Stilt Sandpiper', + 'Summer Tanager', + 'Surf Scoter', + 'Surfbird', + 'Swainsons Hawk', + 'Swainsons Thrush', + 'Swallow tailed Kite', + 'Swamp Sparrow', + 'Tennessee Warbler', + 'Thayers Gull', + 'Townsends Solitaire', + 'Townsends Warbler', + 'Tree Swallow', + 'Tricolored Heron', + 'Tropical Kingbird', + 'Trumpeter Swan', + 'Tufted Titmouse', + 'Tundra Swan', + 'Turkey Vulture', + 'Upland Sandpiper', + 'Varied Thrush', + 'Veery', + 'Verdin', + 'Vermilion Flycatcher', + 'Vesper Sparrow', + 'Violet green Swallow', + 'Virginia Rail', + 'Wandering Tattler', + 'Warbling Vireo', + 'Western Bluebird', + 'Western Grebe', + 'Western Gull', + 'Western Kingbird', + 'Western Meadowlark', + 'Western Sandpiper', + 'Western Screech Owl', + 'Western Scrub Jay', + 'Western Tanager', + 'Western Wood Pewee', + 'Whimbrel', + 'White Ibis', + 'White breasted Nuthatch', + 'White crowned Sparrow', + 'White eyed Vireo', + 'White faced Ibis', + 'White headed Woodpecker', + 'White rumped Sandpiper', + 'White tailed Hawk', + 'White tailed Kite', + 'White tailed Ptarmigan', + 'White throated Sparrow', + 'White throated Swift', + 'White winged Crossbill', + 'White winged Dove', + 'White winged Scoter', + 'Wild Turkey', + 'Willet', + 'Williamsons Sapsucker', + 'Willow Flycatcher', + 'Willow Ptarmigan', + 'Wilsons Phalarope', + 'Wilsons Plover', + 'Wilsons Snipe', + 'Wilsons Warbler', + 'Winter Wren', + 'Wood Stork', + 'Wood Thrush', + 'Worm eating Warbler', + 'Wrentit', + 'Yellow Warbler', + 'Yellow bellied Flycatcher', + 'Yellow bellied Sapsucker', + 'Yellow billed Cuckoo', + 'Yellow billed Magpie', + 'Yellow breasted Chat', + 'Yellow crowned Night Heron', + 'Yellow eyed Junco', + 'Yellow headed Blackbird', + 'Yellow rumped Warbler', + 'Yellow throated Vireo', + 'Yellow throated Warbler', + 'Zone tailed Hawk', +] + +templates = [ + 'a photo of a {}, a type of bird.', +] +``` + + + +## CIFAR10 + +```bash +classes = [ + 'airplane', + 'automobile', + 'bird', + 'cat', + 'deer', + 'dog', + 'frog', + 'horse', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CIFAR100 + +```bash +classes = [ + 'apple', + 'aquarium fish', + 'baby', + 'bear', + 'beaver', + 'bed', + 'bee', + 'beetle', + 'bicycle', + 'bottle', + 'bowl', + 'boy', + 'bridge', + 'bus', + 'butterfly', + 'camel', + 'can', + 'castle', + 'caterpillar', + 'cattle', + 'chair', + 'chimpanzee', + 'clock', + 'cloud', + 'cockroach', + 'couch', + 'crab', + 'crocodile', + 'cup', + 'dinosaur', + 'dolphin', + 'elephant', + 'flatfish', + 'forest', + 'fox', + 'girl', + 'hamster', + 'house', + 'kangaroo', + 'keyboard', + 'lamp', + 'lawn mower', + 'leopard', + 'lion', + 'lizard', + 'lobster', + 'man', + 'maple tree', + 'motorcycle', + 'mountain', + 'mouse', + 'mushroom', + 'oak tree', + 'orange', + 'orchid', + 'otter', + 'palm tree', + 'pear', + 'pickup truck', + 'pine tree', + 'plain', + 'plate', + 'poppy', + 'porcupine', + 'possum', + 'rabbit', + 'raccoon', + 'ray', + 'road', + 'rocket', + 'rose', + 'sea', + 'seal', + 'shark', + 'shrew', + 'skunk', + 'skyscraper', + 'snail', + 'snake', + 'spider', + 'squirrel', + 'streetcar', + 'sunflower', + 'sweet pepper', + 'table', + 'tank', + 'telephone', + 'television', + 'tiger', + 'tractor', + 'train', + 'trout', + 'tulip', + 'turtle', + 'wardrobe', + 'whale', + 'willow tree', + 'wolf', + 'woman', + 'worm', +] + +templates = [ + 'a photo of a {}.', + 'a blurry photo of a {}.', + 'a black and white photo of a {}.', + 'a low contrast photo of a {}.', + 'a high contrast photo of a {}.', + 'a bad photo of a {}.', + 'a good photo of a {}.', + 'a photo of a small {}.', + 'a photo of a big {}.', + 'a photo of the {}.', + 'a blurry photo of the {}.', + 'a black and white photo of the {}.', + 'a low contrast photo of the {}.', + 'a high contrast photo of the {}.', + 'a bad photo of the {}.', + 'a good photo of the {}.', + 'a photo of the small {}.', + 'a photo of the big {}.', +] +``` + + + +## CLEVRCounts + +```bash +classes = [ + '10', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of {} objects.', +] +``` + + + +## Caltech101 + +```bash +classes = [ + 'background', + 'off-center face', + 'centered face', + 'leopard', + 'motorbike', + 'accordion', + 'airplane', + 'anchor', + 'ant', + 'barrel', + 'bass', + 'beaver', + 'binocular', + 'bonsai', + 'brain', + 'brontosaurus', + 'buddha', + 'butterfly', + 'camera', + 'cannon', + 'side of a car', + 'ceiling fan', + 'cellphone', + 'chair', + 'chandelier', + 'body of a cougar cat', + 'face of a cougar cat', + 'crab', + 'crayfish', + 'crocodile', + 'head of a crocodile', + 'cup', + 'dalmatian', + 'dollar bill', + 'dolphin', + 'dragonfly', + 'electric guitar', + 'elephant', + 'emu', + 'euphonium', + 'ewer', + 'ferry', + 'flamingo', + 'head of a flamingo', + 'garfield', + 'gerenuk', + 'gramophone', + 'grand piano', + 'hawksbill', + 'headphone', + 'hedgehog', + 'helicopter', + 'ibis', + 'inline skate', + 'joshua tree', + 'kangaroo', + 'ketch', + 'lamp', + 'laptop', + 'llama', + 'lobster', + 'lotus', + 'mandolin', + 'mayfly', + 'menorah', + 'metronome', + 'minaret', + 'nautilus', + 'octopus', + 'okapi', + 'pagoda', + 'panda', + 'pigeon', + 'pizza', + 'platypus', + 'pyramid', + 'revolver', + 'rhino', + 'rooster', + 'saxophone', + 'schooner', + 'scissors', + 'scorpion', + 'sea horse', + 'snoopy (cartoon beagle)', + 'soccer ball', + 'stapler', + 'starfish', + 'stegosaurus', + 'stop sign', + 'strawberry', + 'sunflower', + 'tick', + 'trilobite', + 'umbrella', + 'watch', + 'water lilly', + 'wheelchair', + 'wild cat', + 'windsor chair', + 'wrench', + 'yin and yang symbol', +] + +templates = [ + 'a photo of a {}.', + 'a painting of a {}.', + 'a plastic {}.', + 'a sculpture of a {}.', + 'a sketch of a {}.', + 'a tattoo of a {}.', + 'a toy {}.', + 'a rendition of a {}.', + 'a embroidered {}.', + 'a cartoon {}.', + 'a {} in a video game.', + 'a plushie {}.', + 'a origami {}.', + 'art of a {}.', + 'graffiti of a {}.', + 'a drawing of a {}.', + 'a doodle of a {}.', + 'a photo of the {}.', + 'a painting of the {}.', + 'the plastic {}.', + 'a sculpture of the {}.', + 'a sketch of the {}.', + 'a tattoo of the {}.', + 'the toy {}.', + 'a rendition of the {}.', + 'the embroidered {}.', + 'the cartoon {}.', + 'the {} in a video game.', + 'the plushie {}.', + 'the origami {}.', + 'art of the {}.', + 'graffiti of the {}.', + 'a drawing of the {}.', + 'a doodle of the {}.', +] +``` + + + +## Country211 + +```bash +classes = [ + 'Andorra', + 'United Arab Emirates', + 'Afghanistan', + 'Antigua and Barbuda', + 'Anguilla', + 'Albania', + 'Armenia', + 'Angola', + 'Antarctica', + 'Argentina', + 'Austria', + 'Australia', + 'Aruba', + 'Aland Islands', + 'Azerbaijan', + 'Bosnia and Herzegovina', + 'Barbados', + 'Bangladesh', + 'Belgium', + 'Burkina Faso', + 'Bulgaria', + 'Bahrain', + 'Benin', + 'Bermuda', + 'Brunei Darussalam', + 'Bolivia', + 'Bonaire, Saint Eustatius and Saba', + 'Brazil', + 'Bahamas', + 'Bhutan', + 'Botswana', + 'Belarus', + 'Belize', + 'Canada', + 'DR Congo', + 'Central African Republic', + 'Switzerland', + "Cote d'Ivoire", + 'Cook Islands', + 'Chile', + 'Cameroon', + 'China', + 'Colombia', + 'Costa Rica', + 'Cuba', + 'Cabo Verde', + 'Curacao', + 'Cyprus', + 'Czech Republic', + 'Germany', + 'Denmark', + 'Dominica', + 'Dominican Republic', + 'Algeria', + 'Ecuador', + 'Estonia', + 'Egypt', + 'Spain', + 'Ethiopia', + 'Finland', + 'Fiji', + 'Falkland Islands', + 'Faeroe Islands', + 'France', + 'Gabon', + 'United Kingdom', + 'Grenada', + 'Georgia', + 'French Guiana', + 'Guernsey', + 'Ghana', + 'Gibraltar', + 'Greenland', + 'Gambia', + 'Guadeloupe', + 'Greece', + 'South Georgia and South Sandwich Is.', + 'Guatemala', + 'Guam', + 'Guyana', + 'Hong Kong', + 'Honduras', + 'Croatia', + 'Haiti', + 'Hungary', + 'Indonesia', + 'Ireland', + 'Israel', + 'Isle of Man', + 'India', + 'Iraq', + 'Iran', + 'Iceland', + 'Italy', + 'Jersey', + 'Jamaica', + 'Jordan', + 'Japan', + 'Kenya', + 'Kyrgyz Republic', + 'Cambodia', + 'St. Kitts and Nevis', + 'North Korea', + 'South Korea', + 'Kuwait', + 'Cayman Islands', + 'Kazakhstan', + 'Laos', + 'Lebanon', + 'St. Lucia', + 'Liechtenstein', + 'Sri Lanka', + 'Liberia', + 'Lithuania', + 'Luxembourg', + 'Latvia', + 'Libya', + 'Morocco', + 'Monaco', + 'Moldova', + 'Montenegro', + 'Saint-Martin', + 'Madagascar', + 'Macedonia', + 'Mali', + 'Myanmar', + 'Mongolia', + 'Macau', + 'Martinique', + 'Mauritania', + 'Malta', + 'Mauritius', + 'Maldives', + 'Malawi', + 'Mexico', + 'Malaysia', + 'Mozambique', + 'Namibia', + 'New Caledonia', + 'Nigeria', + 'Nicaragua', + 'Netherlands', + 'Norway', + 'Nepal', + 'New Zealand', + 'Oman', + 'Panama', + 'Peru', + 'French Polynesia', + 'Papua New Guinea', + 'Philippines', + 'Pakistan', + 'Poland', + 'Puerto Rico', + 'Palestine', + 'Portugal', + 'Palau', + 'Paraguay', + 'Qatar', + 'Reunion', + 'Romania', + 'Serbia', + 'Russia', + 'Rwanda', + 'Saudi Arabia', + 'Solomon Islands', + 'Seychelles', + 'Sudan', + 'Sweden', + 'Singapore', + 'St. Helena', + 'Slovenia', + 'Svalbard and Jan Mayen Islands', + 'Slovakia', + 'Sierra Leone', + 'San Marino', + 'Senegal', + 'Somalia', + 'South Sudan', + 'El Salvador', + 'Sint Maarten', + 'Syria', + 'Eswatini', + 'Togo', + 'Thailand', + 'Tajikistan', + 'Timor-Leste', + 'Turkmenistan', + 'Tunisia', + 'Tonga', + 'Turkey', + 'Trinidad and Tobago', + 'Taiwan', + 'Tanzania', + 'Ukraine', + 'Uganda', + 'United States', + 'Uruguay', + 'Uzbekistan', + 'Vatican', + 'Venezuela', + 'British Virgin Islands', + 'United States Virgin Islands', + 'Vietnam', + 'Vanuatu', + 'Samoa', + 'Kosovo', + 'Yemen', + 'South Africa', + 'Zambia', + 'Zimbabwe', +] + +templates = [ + 'a photo i took in {}.', + 'a photo i took while visiting {}.', + 'a photo from my home country of {}.', + 'a photo from my visit to {}.', + 'a photo showing the country of {}.', +] +``` + + + +## DescribableTextures + +```bash +classes = [ + 'banded', + 'blotchy', + 'braided', + 'bubbly', + 'bumpy', + 'chequered', + 'cobwebbed', + 'cracked', + 'crosshatched', + 'crystalline', + 'dotted', + 'fibrous', + 'flecked', + 'freckled', + 'frilly', + 'gauzy', + 'grid', + 'grooved', + 'honeycombed', + 'interlaced', + 'knitted', + 'lacelike', + 'lined', + 'marbled', + 'matted', + 'meshed', + 'paisley', + 'perforated', + 'pitted', + 'pleated', + 'polka-dotted', + 'porous', + 'potholed', + 'scaly', + 'smeared', + 'spiralled', + 'sprinkled', + 'stained', + 'stratified', + 'striped', + 'studded', + 'swirly', + 'veined', + 'waffled', + 'woven', + 'wrinkled', + 'zigzagged', +] + +templates = [ + 'a photo of a {} texture.', + 'a photo of a {} pattern.', + 'a photo of a {} thing.', + 'a photo of a {} object.', + 'a photo of the {} texture.', + 'a photo of the {} pattern.', + 'a photo of the {} thing.', + 'a photo of the {} object.', +] +``` + + + +## EuroSAT + +```bash +classes = [ + 'forest', + 'permanent crop land', + 'residential buildings or homes or apartments', + 'river', + 'pasture land', + 'lake or sea', + 'brushland or shrubland', + 'annual crop land', + 'industrial buildings or commercial buildings', + 'highway or road', +] + +templates = [ + 'a centered satellite photo of {}.', + 'a centered satellite photo of a {}.', + 'a centered satellite photo of the {}.', +] +``` + + + +## FGVCAircraft + +```bash +classes = [ + '707-320', + '727-200', + '737-200', + '737-300', + '737-400', + '737-500', + '737-600', + '737-700', + '737-800', + '737-900', + '747-100', + '747-200', + '747-300', + '747-400', + '757-200', + '757-300', + '767-200', + '767-300', + '767-400', + '777-200', + '777-300', + 'A300B4', + 'A310', + 'A318', + 'A319', + 'A320', + 'A321', + 'A330-200', + 'A330-300', + 'A340-200', + 'A340-300', + 'A340-500', + 'A340-600', + 'A380', + 'ATR-42', + 'ATR-72', + 'An-12', + 'BAE 146-200', + 'BAE 146-300', + 'BAE-125', + 'Beechcraft 1900', + 'Boeing 717', + 'C-130', + 'C-47', + 'CRJ-200', + 'CRJ-700', + 'CRJ-900', + 'Cessna 172', + 'Cessna 208', + 'Cessna 525', + 'Cessna 560', + 'Challenger 600', + 'DC-10', + 'DC-3', + 'DC-6', + 'DC-8', + 'DC-9-30', + 'DH-82', + 'DHC-1', + 'DHC-6', + 'DHC-8-100', + 'DHC-8-300', + 'DR-400', + 'Dornier 328', + 'E-170', + 'E-190', + 'E-195', + 'EMB-120', + 'ERJ 135', + 'ERJ 145', + 'Embraer Legacy 600', + 'Eurofighter Typhoon', + 'F-16A/B', + 'F/A-18', + 'Falcon 2000', + 'Falcon 900', + 'Fokker 100', + 'Fokker 50', + 'Fokker 70', + 'Global Express', + 'Gulfstream IV', + 'Gulfstream V', + 'Hawk T1', + 'Il-76', + 'L-1011', + 'MD-11', + 'MD-80', + 'MD-87', + 'MD-90', + 'Metroliner', + 'Model B200', + 'PA-28', + 'SR-20', + 'Saab 2000', + 'Saab 340', + 'Spitfire', + 'Tornado', + 'Tu-134', + 'Tu-154', + 'Yak-42', +] + +templates = [ + 'a photo of a {}, a type of aircraft.', + 'a photo of the {}, a type of aircraft.', +] +``` + + + +## FacialEmotionRecognition2013 + +```bash +classes = [ + ['angry'], + ['disgusted'], + ['fearful'], + ['happy', 'smiling'], + ['sad', 'depressed'], + ['surprised', 'shocked', 'spooked'], + ['neutral', 'bored'], +] + +templates = [ + 'a photo of a {} looking face.', + 'a photo of a face showing the emotion: {}.', + 'a photo of a face looking {}.', + 'a face that looks {}.', + 'they look {}.', + 'look at how {} they are.', +] +``` + + + +## Flowers102 + +```bash +classes = [ + 'pink primrose', + 'hard-leaved pocket orchid', + 'canterbury bells', + 'sweet pea', + 'english marigold', + 'tiger lily', + 'moon orchid', + 'bird of paradise', + 'monkshood', + 'globe thistle', + 'snapdragon', + "colt's foot", + 'king protea', + 'spear thistle', + 'yellow iris', + 'globe flower', + 'purple coneflower', + 'peruvian lily', + 'balloon flower', + 'giant white arum lily', + 'fire lily', + 'pincushion flower', + 'fritillary', + 'red ginger', + 'grape hyacinth', + 'corn poppy', + 'prince of wales feathers', + 'stemless gentian', + 'artichoke', + 'sweet william', + 'carnation', + 'garden phlox', + 'love in the mist', + 'mexican aster', + 'alpine sea holly', + 'ruby-lipped cattleya', + 'cape flower', + 'great masterwort', + 'siam tulip', + 'lenten rose', + 'barbeton daisy', + 'daffodil', + 'sword lily', + 'poinsettia', + 'bolero deep blue', + 'wallflower', + 'marigold', + 'buttercup', + 'oxeye daisy', + 'common dandelion', + 'petunia', + 'wild pansy', + 'primula', + 'sunflower', + 'pelargonium', + 'bishop of llandaff', + 'gaura', + 'geranium', + 'orange dahlia', + 'pink and yellow dahlia', + 'cautleya spicata', + 'japanese anemone', + 'black-eyed susan', + 'silverbush', + 'californian poppy', + 'osteospermum', + 'spring crocus', + 'bearded iris', + 'windflower', + 'tree poppy', + 'gazania', + 'azalea', + 'water lily', + 'rose', + 'thorn apple', + 'morning glory', + 'passion flower', + 'lotus', + 'toad lily', + 'anthurium', + 'frangipani', + 'clematis', + 'hibiscus', + 'columbine', + 'desert-rose', + 'tree mallow', + 'magnolia', + 'cyclamen', + 'watercress', + 'canna lily', + 'hippeastrum', + 'bee balm', + 'air plant', + 'foxglove', + 'bougainvillea', + 'camellia', + 'mallow', + 'mexican petunia', + 'bromelia', + 'blanket flower', + 'trumpet creeper', + 'blackberry lily', +] + +templates = [ + 'a photo of a {}, a type of flower.', +] +``` + + + +## Food101 + +```bash +classes = [ + 'apple pie', + 'baby back ribs', + 'baklava', + 'beef carpaccio', + 'beef tartare', + 'beet salad', + 'beignets', + 'bibimbap', + 'bread pudding', + 'breakfast burrito', + 'bruschetta', + 'caesar salad', + 'cannoli', + 'caprese salad', + 'carrot cake', + 'ceviche', + 'cheese plate', + 'cheesecake', + 'chicken curry', + 'chicken quesadilla', + 'chicken wings', + 'chocolate cake', + 'chocolate mousse', + 'churros', + 'clam chowder', + 'club sandwich', + 'crab cakes', + 'creme brulee', + 'croque madame', + 'cup cakes', + 'deviled eggs', + 'donuts', + 'dumplings', + 'edamame', + 'eggs benedict', + 'escargots', + 'falafel', + 'filet mignon', + 'fish and chips', + 'foie gras', + 'french fries', + 'french onion soup', + 'french toast', + 'fried calamari', + 'fried rice', + 'frozen yogurt', + 'garlic bread', + 'gnocchi', + 'greek salad', + 'grilled cheese sandwich', + 'grilled salmon', + 'guacamole', + 'gyoza', + 'hamburger', + 'hot and sour soup', + 'hot dog', + 'huevos rancheros', + 'hummus', + 'ice cream', + 'lasagna', + 'lobster bisque', + 'lobster roll sandwich', + 'macaroni and cheese', + 'macarons', + 'miso soup', + 'mussels', + 'nachos', + 'omelette', + 'onion rings', + 'oysters', + 'pad thai', + 'paella', + 'pancakes', + 'panna cotta', + 'peking duck', + 'pho', + 'pizza', + 'pork chop', + 'poutine', + 'prime rib', + 'pulled pork sandwich', + 'ramen', + 'ravioli', + 'red velvet cake', + 'risotto', + 'samosa', + 'sashimi', + 'scallops', + 'seaweed salad', + 'shrimp and grits', + 'spaghetti bolognese', + 'spaghetti carbonara', + 'spring rolls', + 'steak', + 'strawberry shortcake', + 'sushi', + 'tacos', + 'takoyaki', + 'tiramisu', + 'tuna tartare', + 'waffles', +] + +templates = [ + 'a photo of {}, a type of food.', +] +``` + + + +## GTSRB + +```bash +classes = [ + 'red and white circle 20 kph speed limit', + 'red and white circle 30 kph speed limit', + 'red and white circle 50 kph speed limit', + 'red and white circle 60 kph speed limit', + 'red and white circle 70 kph speed limit', + 'red and white circle 80 kph speed limit', + 'end / de-restriction of 80 kph speed limit', + 'red and white circle 100 kph speed limit', + 'red and white circle 120 kph speed limit', + 'red and white circle red car and black car no passing', + 'red and white circle red truck and black car no passing', + 'red and white triangle road intersection warning', + 'white and yellow diamond priority road', + 'red and white upside down triangle yield right-of-way', + 'stop', + 'empty red and white circle', + 'red and white circle no truck entry', + 'red circle with white horizonal stripe no entry', + 'red and white triangle with exclamation mark warning', + 'red and white triangle with black left curve approaching warning', + 'red and white triangle with black right curve approaching warning', + 'red and white triangle with black double curve approaching warning', + 'red and white triangle rough / bumpy road warning', + 'red and white triangle car skidding / slipping warning', + 'red and white triangle with merging / narrow lanes warning', + 'red and white triangle with person digging / construction / road work warning', + 'red and white triangle with traffic light approaching warning', + 'red and white triangle with person walking warning', + 'red and white triangle with child and person walking warning', + 'red and white triangle with bicyle warning', + 'red and white triangle with snowflake / ice warning', + 'red and white triangle with deer warning', + 'white circle with gray strike bar no speed limit', + 'blue circle with white right turn arrow mandatory', + 'blue circle with white left turn arrow mandatory', + 'blue circle with white forward arrow mandatory', + 'blue circle with white forward or right turn arrow mandatory', + 'blue circle with white forward or left turn arrow mandatory', + 'blue circle with white keep right arrow mandatory', + 'blue circle with white keep left arrow mandatory', + 'blue circle with white arrows indicating a traffic circle', + 'white circle with gray strike bar indicating no passing for cars has ended', + 'white circle with gray strike bar indicating no passing for trucks has ended', +] + +templates = [ + 'a zoomed in photo of a "{}" traffic sign.', + 'a centered photo of a "{}" traffic sign.', + 'a close up photo of a "{}" traffic sign.', +] +``` + + + +## HatefulMemes + +```bash +classes = [ + 'meme', + 'hatespeech meme', +] + +templates = [ + 'a {}.', +] +``` + + + +## KITTI + +```bash +classes = [ + 'a photo i took of a car on my left or right side.', + 'a photo i took with a car nearby.', + 'a photo i took with a car in the distance.', + 'a photo i took with no car.', +] + +templates = [ + '{}', +] +``` + + + +## Kinetics700 + +```bash +classes = [ + 'abseiling', + 'acting in play', + 'adjusting glasses', + 'air drumming', + 'alligator wrestling', + 'answering questions', + 'applauding', + 'applying cream', + 'archaeological excavation', + 'archery', + 'arguing', + 'arm wrestling', + 'arranging flowers', + 'arresting', + 'assembling bicycle', + 'assembling computer', + 'attending conference', + 'auctioning', + 'baby waking up', + 'backflip (human)', + 'baking cookies', + 'bandaging', + 'barbequing', + 'bartending', + 'base jumping', + 'bathing dog', + 'battle rope training', + 'beatboxing', + 'bee keeping', + 'being excited', + 'being in zero gravity', + 'belly dancing', + 'bench pressing', + 'bending back', + 'bending metal', + 'biking through snow', + 'blasting sand', + 'blending fruit', + 'blowdrying hair', + 'blowing bubble gum', + 'blowing glass', + 'blowing leaves', + 'blowing nose', + 'blowing out candles', + 'bobsledding', + 'bodysurfing', + 'bookbinding', + 'bottling', + 'bouncing ball (not juggling)', + 'bouncing on bouncy castle', + 'bouncing on trampoline', + 'bowling', + 'braiding hair', + 'breading or breadcrumbing', + 'breakdancing', + 'breaking boards', + 'breaking glass', + 'breathing fire', + 'brush painting', + 'brushing floor', + 'brushing hair', + 'brushing teeth', + 'building cabinet', + 'building lego', + 'building sandcastle', + 'building shed', + 'bulldozing', + 'bungee jumping', + 'burping', + 'busking', + 'calculating', + 'calligraphy', + 'canoeing or kayaking', + 'capoeira', + 'capsizing', + 'card stacking', + 'card throwing', + 'carrying baby', + 'carrying weight', + 'cartwheeling', + 'carving ice', + 'carving marble', + 'carving pumpkin', + 'carving wood with a knife', + 'casting fishing line', + 'catching fish', + 'catching or throwing baseball', + 'catching or throwing frisbee', + 'catching or throwing softball', + 'celebrating', + 'changing gear in car', + 'changing oil', + 'changing wheel (not on bike)', + 'chasing', + 'checking tires', + 'checking watch', + 'cheerleading', + 'chewing gum', + 'chiseling stone', + 'chiseling wood', + 'chopping meat', + 'chopping wood', + 'clam digging', + 'clapping', + 'clay pottery making', + 'clean and jerk', + 'cleaning gutters', + 'cleaning pool', + 'cleaning shoes', + 'cleaning toilet', + 'cleaning windows', + 'climbing a rope', + 'climbing ladder', + 'climbing tree', + 'closing door', + 'coloring in', + 'combing hair', + 'contact juggling', + 'contorting', + 'cooking chicken', + 'cooking egg', + 'cooking on campfire', + 'cooking sausages (not on barbeque)', + 'cooking scallops', + 'cosplaying', + 'coughing', + 'counting money', + 'country line dancing', + 'cracking back', + 'cracking knuckles', + 'cracking neck', + 'crawling baby', + 'crocheting', + 'crossing eyes', + 'crossing river', + 'crying', + 'cumbia', + 'curling (sport)', + 'curling eyelashes', + 'curling hair', + 'cutting apple', + 'cutting cake', + 'cutting nails', + 'cutting orange', + 'cutting pineapple', + 'cutting watermelon', + 'dancing ballet', + 'dancing charleston', + 'dancing gangnam style', + 'dancing macarena', + 'deadlifting', + 'dealing cards', + 'decorating the christmas tree', + 'decoupage', + 'delivering mail', + 'digging', + 'dining', + 'directing traffic', + 'disc golfing', + 'diving cliff', + 'docking boat', + 'dodgeball', + 'doing aerobics', + 'doing jigsaw puzzle', + 'doing laundry', + 'doing nails', + 'doing sudoku', + 'drawing', + 'dribbling basketball', + 'drinking shots', + 'driving car', + 'driving tractor', + 'drooling', + 'drop kicking', + 'drumming fingers', + 'dumpster diving', + 'dunking basketball', + 'dyeing eyebrows', + 'dyeing hair', + 'eating burger', + 'eating cake', + 'eating carrots', + 'eating chips', + 'eating doughnuts', + 'eating hotdog', + 'eating ice cream', + 'eating nachos', + 'eating spaghetti', + 'eating watermelon', + 'egg hunting', + 'embroidering', + 'entering church', + 'exercising arm', + 'exercising with an exercise ball', + 'extinguishing fire', + 'faceplanting', + 'falling off bike', + 'falling off chair', + 'feeding birds', + 'feeding fish', + 'feeding goats', + 'fencing (sport)', + 'fidgeting', + 'filling cake', + 'filling eyebrows', + 'finger snapping', + 'fixing bicycle', + 'fixing hair', + 'flint knapping', + 'flipping bottle', + 'flipping pancake', + 'fly tying', + 'flying kite', + 'folding clothes', + 'folding napkins', + 'folding paper', + 'front raises', + 'frying vegetables', + 'gargling', + 'geocaching', + 'getting a haircut', + 'getting a piercing', + 'getting a tattoo', + 'giving or receiving award', + 'gold panning', + 'golf chipping', + 'golf driving', + 'golf putting', + 'gospel singing in church', + 'grinding meat', + 'grooming cat', + 'grooming dog', + 'grooming horse', + 'gymnastics tumbling', + 'hammer throw', + 'hand washing clothes', + 'head stand', + 'headbanging', + 'headbutting', + 'helmet diving', + 'herding cattle', + 'high fiving', + 'high jump', + 'high kick', + 'historical reenactment', + 'hitting baseball', + 'hockey stop', + 'holding snake', + 'home roasting coffee', + 'hopscotch', + 'hoverboarding', + 'huddling', + 'hugging (not baby)', + 'hugging baby', + 'hula hooping', + 'hurdling', + 'hurling (sport)', + 'ice climbing', + 'ice fishing', + 'ice skating', + 'ice swimming', + 'inflating balloons', + 'installing carpet', + 'ironing', + 'ironing hair', + 'javelin throw', + 'jaywalking', + 'jetskiing', + 'jogging', + 'juggling balls', + 'juggling fire', + 'juggling soccer ball', + 'jumping bicycle', + 'jumping into pool', + 'jumping jacks', + 'jumping sofa', + 'jumpstyle dancing', + 'karaoke', + 'kicking field goal', + 'kicking soccer ball', + 'kissing', + 'kitesurfing', + 'knitting', + 'krumping', + 'land sailing', + 'laughing', + 'lawn mower racing', + 'laying bricks', + 'laying concrete', + 'laying decking', + 'laying stone', + 'laying tiles', + 'leatherworking', + 'letting go of balloon', + 'licking', + 'lifting hat', + 'lighting candle', + 'lighting fire', + 'listening with headphones', + 'lock picking', + 'long jump', + 'longboarding', + 'looking at phone', + 'looking in mirror', + 'luge', + 'lunge', + 'making a cake', + 'making a sandwich', + 'making balloon shapes', + 'making bubbles', + 'making cheese', + 'making horseshoes', + 'making jewelry', + 'making latte art', + 'making paper aeroplanes', + 'making pizza', + 'making slime', + 'making snowman', + 'making sushi', + 'making tea', + 'making the bed', + 'marching', + 'marriage proposal', + 'massaging back', + 'massaging feet', + 'massaging legs', + 'massaging neck', + "massaging person's head", + 'metal detecting', + 'milking cow', + 'milking goat', + 'mixing colours', + 'moon walking', + 'mopping floor', + 'mosh pit dancing', + 'motorcycling', + 'mountain climber (exercise)', + 'moving baby', + 'moving child', + 'moving furniture', + 'mowing lawn', + 'mushroom foraging', + 'needle felting', + 'news anchoring', + 'opening bottle (not wine)', + 'opening coconuts', + 'opening door', + 'opening present', + 'opening refrigerator', + 'opening wine bottle', + 'packing', + 'paragliding', + 'parasailing', + 'parkour', + 'passing American football (in game)', + 'passing American football (not in game)', + 'passing soccer ball', + 'peeling apples', + 'peeling banana', + 'peeling potatoes', + 'person collecting garbage', + 'petting animal (not cat)', + 'petting cat', + 'petting horse', + 'photobombing', + 'photocopying', + 'picking apples', + 'picking blueberries', + 'pillow fight', + 'pinching', + 'pirouetting', + 'planing wood', + 'planting trees', + 'plastering', + 'playing accordion', + 'playing american football', + 'playing badminton', + 'playing bagpipes', + 'playing basketball', + 'playing bass guitar', + 'playing beer pong', + 'playing billiards', + 'playing blackjack', + 'playing cards', + 'playing cello', + 'playing checkers', + 'playing chess', + 'playing clarinet', + 'playing controller', + 'playing cricket', + 'playing cymbals', + 'playing darts', + 'playing didgeridoo', + 'playing dominoes', + 'playing drums', + 'playing field hockey', + 'playing flute', + 'playing gong', + 'playing guitar', + 'playing hand clapping games', + 'playing harmonica', + 'playing harp', + 'playing ice hockey', + 'playing keyboard', + 'playing kickball', + 'playing laser tag', + 'playing lute', + 'playing mahjong', + 'playing maracas', + 'playing marbles', + 'playing monopoly', + 'playing netball', + 'playing nose flute', + 'playing oboe', + 'playing ocarina', + 'playing organ', + 'playing paintball', + 'playing pan pipes', + 'playing piano', + 'playing piccolo', + 'playing pinball', + 'playing ping pong', + 'playing poker', + 'playing polo', + 'playing recorder', + 'playing road hockey', + 'playing rounders', + 'playing rubiks cube', + 'playing saxophone', + 'playing scrabble', + 'playing shuffleboard', + 'playing slot machine', + 'playing squash or racquetball', + 'playing tennis', + 'playing trombone', + 'playing trumpet', + 'playing ukulele', + 'playing violin', + 'playing volleyball', + 'playing with trains', + 'playing xylophone', + 'poaching eggs', + 'poking bellybutton', + 'pole vault', + 'polishing furniture', + 'polishing metal', + 'popping balloons', + 'pouring beer', + 'pouring milk', + 'pouring wine', + 'preparing salad', + 'presenting weather forecast', + 'pretending to be a statue', + 'pull ups', + 'pulling espresso shot', + 'pulling rope (game)', + 'pumping fist', + 'pumping gas', + 'punching bag', + 'punching person (boxing)', + 'push up', + 'pushing car', + 'pushing cart', + 'pushing wheelbarrow', + 'pushing wheelchair', + 'putting in contact lenses', + 'putting on eyeliner', + 'putting on foundation', + 'putting on lipstick', + 'putting on mascara', + 'putting on sari', + 'putting on shoes', + 'putting wallpaper on wall', + 'raising eyebrows', + 'reading book', + 'reading newspaper', + 'recording music', + 'repairing puncture', + 'riding a bike', + 'riding camel', + 'riding elephant', + 'riding mechanical bull', + 'riding mule', + 'riding or walking with horse', + 'riding scooter', + 'riding snow blower', + 'riding unicycle', + 'ripping paper', + 'roasting marshmallows', + 'roasting pig', + 'robot dancing', + 'rock climbing', + 'rock scissors paper', + 'roller skating', + 'rolling eyes', + 'rolling pastry', + 'rope pushdown', + 'running on treadmill', + 'sailing', + 'salsa dancing', + 'saluting', + 'sanding floor', + 'sanding wood', + 'sausage making', + 'sawing wood', + 'scrambling eggs', + 'scrapbooking', + 'scrubbing face', + 'scuba diving', + 'seasoning food', + 'separating eggs', + 'setting table', + 'sewing', + 'shaking hands', + 'shaking head', + 'shaping bread dough', + 'sharpening knives', + 'sharpening pencil', + 'shaving head', + 'shaving legs', + 'shearing sheep', + 'shining flashlight', + 'shining shoes', + 'shoot dance', + 'shooting basketball', + 'shooting goal (soccer)', + 'shooting off fireworks', + 'shopping', + 'shot put', + 'shouting', + 'shoveling snow', + 'shredding paper', + 'shucking oysters', + 'shuffling cards', + 'shuffling feet', + 'side kick', + 'sieving', + 'sign language interpreting', + 'silent disco', + 'singing', + 'sipping cup', + 'situp', + 'skateboarding', + 'ski ballet', + 'ski jumping', + 'skiing crosscountry', + 'skiing mono', + 'skiing slalom', + 'skipping rope', + 'skipping stone', + 'skydiving', + 'slacklining', + 'slapping', + 'sled dog racing', + 'sleeping', + 'slicing onion', + 'smashing', + 'smelling feet', + 'smoking', + 'smoking hookah', + 'smoking pipe', + 'snatch weight lifting', + 'sneezing', + 'snorkeling', + 'snowboarding', + 'snowkiting', + 'snowmobiling', + 'somersaulting', + 'spelunking', + 'spinning plates', + 'spinning poi', + 'splashing water', + 'spray painting', + 'spraying', + 'springboard diving', + 'square dancing', + 'squat', + 'squeezing orange', + 'stacking cups', + 'stacking dice', + 'standing on hands', + 'staring', + 'steer roping', + 'steering car', + 'sticking tongue out', + 'stomping grapes', + 'stretching arm', + 'stretching leg', + 'sucking lolly', + 'surfing crowd', + 'surfing water', + 'surveying', + 'sweeping floor', + 'swimming backstroke', + 'swimming breast stroke', + 'swimming butterfly stroke', + 'swimming front crawl', + 'swimming with dolphins', + 'swimming with sharks', + 'swing dancing', + 'swinging baseball bat', + 'swinging on something', + 'sword fighting', + 'sword swallowing', + 'tackling', + 'tagging graffiti', + 'tai chi', + 'taking photo', + 'talking on cell phone', + 'tango dancing', + 'tap dancing', + 'tapping guitar', + 'tapping pen', + 'tasting beer', + 'tasting food', + 'tasting wine', + 'testifying', + 'texting', + 'threading needle', + 'throwing axe', + 'throwing ball (not baseball or American football)', + 'throwing discus', + 'throwing knife', + 'throwing snowballs', + 'throwing tantrum', + 'throwing water balloon', + 'tickling', + 'tie dying', + 'tightrope walking', + 'tiptoeing', + 'tobogganing', + 'tossing coin', + 'tossing salad', + 'training dog', + 'trapezing', + 'treating wood', + 'trimming or shaving beard', + 'trimming shrubs', + 'trimming trees', + 'triple jump', + 'twiddling fingers', + 'tying bow tie', + 'tying knot (not on a tie)', + 'tying necktie', + 'tying shoe laces', + 'unboxing', + 'uncorking champagne', + 'unloading truck', + 'using a microscope', + 'using a paint roller', + 'using a power drill', + 'using a sledge hammer', + 'using a wrench', + 'using atm', + 'using bagging machine', + 'using circular saw', + 'using inhaler', + 'using megaphone', + 'using puppets', + 'using remote controller (not gaming)', + 'using segway', + 'vacuuming car', + 'vacuuming floor', + 'visiting the zoo', + 'wading through mud', + 'wading through water', + 'waiting in line', + 'waking up', + 'walking on stilts', + 'walking the dog', + 'walking through snow', + 'walking with crutches', + 'washing dishes', + 'washing feet', + 'washing hair', + 'washing hands', + 'watching tv', + 'water skiing', + 'water sliding', + 'watering plants', + 'waving hand', + 'waxing armpits', + 'waxing back', + 'waxing chest', + 'waxing eyebrows', + 'waxing legs', + 'weaving basket', + 'weaving fabric', + 'welding', + 'whistling', + 'windsurfing', + 'winking', + 'wood burning (art)', + 'wrapping present', + 'wrestling', + 'writing', + 'yarn spinning', + 'yawning', + 'yoga', + 'zumba' +] + +templates = [ + 'a photo of {}.', + 'a photo of a person {}.', + 'a photo of a person using {}.', + 'a photo of a person doing {}.', + 'a photo of a person during {}.', + 'a photo of a person performing {}.', + 'a photo of a person practicing {}.', + 'a video of {}.', + 'a video of a person {}.', + 'a video of a person using {}.', + 'a video of a person doing {}.', + 'a video of a person during {}.', + 'a video of a person performing {}.', + 'a video of a person practicing {}.', + 'a example of {}.', + 'a example of a person {}.', + 'a example of a person using {}.', + 'a example of a person doing {}.', + 'a example of a person during {}.', + 'a example of a person performing {}.', + 'a example of a person practicing {}.', + 'a demonstration of {}.', + 'a demonstration of a person {}.', + 'a demonstration of a person using {}.', + 'a demonstration of a person doing {}.', + 'a demonstration of a person during {}.', + 'a demonstration of a person performing {}.', + 'a demonstration of a person practicing {}.', +] +``` + + + +## MNIST + +```bash +classes = [ + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', +] + +templates = [ + 'a photo of the number: "{}".', +] +``` + + + +## OxfordPets + +```bash +classes = [ + 'Abyssinian', + 'Bengal', + 'Birman', + 'Bombay', + 'British Shorthair', + 'Egyptian Mau', + 'Maine Coon', + 'Persian', + 'Ragdoll', + 'Russian Blue', + 'Siamese', + 'Sphynx', + 'american bulldog', + 'american pit bull terrier', + 'basset hound', + 'beagle', + 'boxer', + 'chihuahua', + 'english cocker spaniel', + 'english setter', + 'german shorthaired', + 'great pyrenees', + 'havanese', + 'japanese chin', + 'keeshond', + 'leonberger', + 'miniature pinscher', + 'newfoundland', + 'pomeranian', + 'pug', + 'saint bernard', + 'samoyed', + 'scottish terrier', + 'shiba inu', + 'staffordshire bull terrier', + 'wheaten terrier', + 'yorkshire terrier', +] + +templates = [ + 'a photo of a {}, a type of pet.', +] +``` + + + +## PascalVOC2007 + +```bash +classes = [ + 'aeroplane', + 'bicycle', + 'bird', + 'boat', + 'bottle', + 'bus', + 'car', + 'cat', + 'chair', + 'cow', + 'dog', + 'horse', + 'motorbike', + 'person', + 'sheep', + 'sofa', + 'diningtable', + 'pottedplant', + 'train', + 'tvmonitor', +] + +templates = [ + 'a photo of a {}.', +] +``` + + + +## PatchCamelyon + +```bash +classes = [ + 'lymph node', + 'lymph node containing metastatic tumor tissue', +] + +templates = [ + 'this is a photo of {}', +] +``` + + + +## RESISC45 + +```bash +classes = [ + 'airplane', + 'airport', + 'baseball diamond', + 'basketball court', + 'beach', + 'bridge', + 'chaparral', + 'church', + 'circular farmland', + 'cloud', + 'commercial area', + 'dense residential', + 'desert', + 'forest', + 'freeway', + 'golf course', + 'ground track field', + 'harbor', + 'industrial area', + 'intersection', + 'island', + 'lake', + 'meadow', + 'medium residential', + 'mobile home park', + 'mountain', + 'overpass', + 'palace', + 'parking lot', + 'railway', + 'railway station', + 'rectangular farmland', + 'river', + 'roundabout', + 'runway', + 'sea ice', + 'ship', + 'snowberg', + 'sparse residential', + 'stadium', + 'storage tank', + 'tennis court', + 'terrace', + 'thermal power station', + 'wetland', +] + +templates = [ + 'satellite imagery of {}.', + 'aerial imagery of {}.', + 'satellite photo of {}.', + 'aerial photo of {}.', + 'satellite view of {}.', + 'aerial view of {}.', + 'satellite imagery of a {}.', + 'aerial imagery of a {}.', + 'satellite photo of a {}.', + 'aerial photo of a {}.', + 'satellite view of a {}.', + 'aerial view of a {}.', + 'satellite imagery of the {}.', + 'aerial imagery of the {}.', + 'satellite photo of the {}.', + 'aerial photo of the {}.', + 'satellite view of the {}.', + 'aerial view of the {}.', +] +``` + + + +## SST2 + +```bash +classes = [ + 'negative', + 'positive', +] + +templates = [ + 'a {} review of a movie.', +] +``` + + + +## STL10 + +```bash +classes = [ + 'airplane', + 'bird', + 'car', + 'cat', + 'deer', + 'dog', + 'horse', + 'monkey', + 'ship', + 'truck', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## SUN397 + +```bash +classes = [ + 'abbey', + 'airplane cabin', + 'airport terminal', + 'alley', + 'amphitheater', + 'amusement arcade', + 'amusement park', + 'anechoic chamber', + 'apartment building outdoor', + 'apse indoor', + 'aquarium', + 'aqueduct', + 'arch', + 'archive', + 'arrival gate outdoor', + 'art gallery', + 'art school', + 'art studio', + 'assembly line', + 'athletic field outdoor', + 'atrium public', + 'attic', + 'auditorium', + 'auto factory', + 'badlands', + 'badminton court indoor', + 'baggage claim', + 'bakery shop', + 'balcony exterior', + 'balcony interior', + 'ball pit', + 'ballroom', + 'bamboo forest', + 'banquet hall', + 'bar', + 'barn', + 'barndoor', + 'baseball field', + 'basement', + 'basilica', + 'basketball court outdoor', + 'bathroom', + 'batters box', + 'bayou', + 'bazaar indoor', + 'bazaar outdoor', + 'beach', + 'beauty salon', + 'bedroom', + 'berth', + 'biology laboratory', + 'bistro indoor', + 'boardwalk', + 'boat deck', + 'boathouse', + 'bookstore', + 'booth indoor', + 'botanical garden', + 'bow window indoor', + 'bow window outdoor', + 'bowling alley', + 'boxing ring', + 'brewery indoor', + 'bridge', + 'building facade', + 'bullring', + 'burial chamber', + 'bus interior', + 'butchers shop', + 'butte', + 'cabin outdoor', + 'cafeteria', + 'campsite', + 'campus', + 'canal natural', + 'canal urban', + 'candy store', + 'canyon', + 'car interior backseat', + 'car interior frontseat', + 'carrousel', + 'casino indoor', + 'castle', + 'catacomb', + 'cathedral indoor', + 'cathedral outdoor', + 'cavern indoor', + 'cemetery', + 'chalet', + 'cheese factory', + 'chemistry lab', + 'chicken coop indoor', + 'chicken coop outdoor', + 'childs room', + 'church indoor', + 'church outdoor', + 'classroom', + 'clean room', + 'cliff', + 'cloister indoor', + 'closet', + 'clothing store', + 'coast', + 'cockpit', + 'coffee shop', + 'computer room', + 'conference center', + 'conference room', + 'construction site', + 'control room', + 'control tower outdoor', + 'corn field', + 'corral', + 'corridor', + 'cottage garden', + 'courthouse', + 'courtroom', + 'courtyard', + 'covered bridge exterior', + 'creek', + 'crevasse', + 'crosswalk', + 'cubicle office', + 'dam', + 'delicatessen', + 'dentists office', + 'desert sand', + 'desert vegetation', + 'diner indoor', + 'diner outdoor', + 'dinette home', + 'dinette vehicle', + 'dining car', + 'dining room', + 'discotheque', + 'dock', + 'doorway outdoor', + 'dorm room', + 'driveway', + 'driving range outdoor', + 'drugstore', + 'electrical substation', + 'elevator door', + 'elevator interior', + 'elevator shaft', + 'engine room', + 'escalator indoor', + 'excavation', + 'factory indoor', + 'fairway', + 'fastfood restaurant', + 'field cultivated', + 'field wild', + 'fire escape', + 'fire station', + 'firing range indoor', + 'fishpond', + 'florist shop indoor', + 'food court', + 'forest broadleaf', + 'forest needleleaf', + 'forest path', + 'forest road', + 'formal garden', + 'fountain', + 'galley', + 'game room', + 'garage indoor', + 'garbage dump', + 'gas station', + 'gazebo exterior', + 'general store indoor', + 'general store outdoor', + 'gift shop', + 'golf course', + 'greenhouse indoor', + 'greenhouse outdoor', + 'gymnasium indoor', + 'hangar indoor', + 'hangar outdoor', + 'harbor', + 'hayfield', + 'heliport', + 'herb garden', + 'highway', + 'hill', + 'home office', + 'hospital', + 'hospital room', + 'hot spring', + 'hot tub outdoor', + 'hotel outdoor', + 'hotel room', + 'house', + 'hunting lodge outdoor', + 'ice cream parlor', + 'ice floe', + 'ice shelf', + 'ice skating rink indoor', + 'ice skating rink outdoor', + 'iceberg', + 'igloo', + 'industrial area', + 'inn outdoor', + 'islet', + 'jacuzzi indoor', + 'jail cell', + 'jail indoor', + 'jewelry shop', + 'kasbah', + 'kennel indoor', + 'kennel outdoor', + 'kindergarden classroom', + 'kitchen', + 'kitchenette', + 'labyrinth outdoor', + 'lake natural', + 'landfill', + 'landing deck', + 'laundromat', + 'lecture room', + 'library indoor', + 'library outdoor', + 'lido deck outdoor', + 'lift bridge', + 'lighthouse', + 'limousine interior', + 'living room', + 'lobby', + 'lock chamber', + 'locker room', + 'mansion', + 'manufactured home', + 'market indoor', + 'market outdoor', + 'marsh', + 'martial arts gym', + 'mausoleum', + 'medina', + 'moat water', + 'monastery outdoor', + 'mosque indoor', + 'mosque outdoor', + 'motel', + 'mountain', + 'mountain snowy', + 'movie theater indoor', + 'museum indoor', + 'music store', + 'music studio', + 'nuclear power plant outdoor', + 'nursery', + 'oast house', + 'observatory outdoor', + 'ocean', + 'office', + 'office building', + 'oil refinery outdoor', + 'oilrig', + 'operating room', + 'orchard', + 'outhouse outdoor', + 'pagoda', + 'palace', + 'pantry', + 'park', + 'parking garage indoor', + 'parking garage outdoor', + 'parking lot', + 'parlor', + 'pasture', + 'patio', + 'pavilion', + 'pharmacy', + 'phone booth', + 'physics laboratory', + 'picnic area', + 'pilothouse indoor', + 'planetarium outdoor', + 'playground', + 'playroom', + 'plaza', + 'podium indoor', + 'podium outdoor', + 'pond', + 'poolroom establishment', + 'poolroom home', + 'power plant outdoor', + 'promenade deck', + 'pub indoor', + 'pulpit', + 'putting green', + 'racecourse', + 'raceway', + 'raft', + 'railroad track', + 'rainforest', + 'reception', + 'recreation room', + 'residential neighborhood', + 'restaurant', + 'restaurant kitchen', + 'restaurant patio', + 'rice paddy', + 'riding arena', + 'river', + 'rock arch', + 'rope bridge', + 'ruin', + 'runway', + 'sandbar', + 'sandbox', + 'sauna', + 'schoolhouse', + 'sea cliff', + 'server room', + 'shed', + 'shoe shop', + 'shopfront', + 'shopping mall indoor', + 'shower', + 'skatepark', + 'ski lodge', + 'ski resort', + 'ski slope', + 'sky', + 'skyscraper', + 'slum', + 'snowfield', + 'squash court', + 'stable', + 'stadium baseball', + 'stadium football', + 'stage indoor', + 'staircase', + 'street', + 'subway interior', + 'subway station platform', + 'supermarket', + 'sushi bar', + 'swamp', + 'swimming pool indoor', + 'swimming pool outdoor', + 'synagogue indoor', + 'synagogue outdoor', + 'television studio', + 'temple east asia', + 'temple south asia', + 'tennis court indoor', + 'tennis court outdoor', + 'tent outdoor', + 'theater indoor procenium', + 'theater indoor seats', + 'thriftshop', + 'throne room', + 'ticket booth', + 'toll plaza', + 'topiary garden', + 'tower', + 'toyshop', + 'track outdoor', + 'train railway', + 'train station platform', + 'tree farm', + 'tree house', + 'trench', + 'underwater coral reef', + 'utility room', + 'valley', + 'van interior', + 'vegetable garden', + 'veranda', + 'veterinarians office', + 'viaduct', + 'videostore', + 'village', + 'vineyard', + 'volcano', + 'volleyball court indoor', + 'volleyball court outdoor', + 'waiting room', + 'warehouse indoor', + 'water tower', + 'waterfall block', + 'waterfall fan', + 'waterfall plunge', + 'watering hole', + 'wave', + 'wet bar', + 'wheat field', + 'wind farm', + 'windmill', + 'wine cellar barrel storage', + 'wine cellar bottle storage', + 'wrestling ring indoor', + 'yard', + 'youth hostel', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', +] +``` + + + +## StanfordCars + +```bash +classes = [ + 'AM General Hummer SUV 2000', + 'Acura RL Sedan 2012', + 'Acura TL Sedan 2012', + 'Acura TL Type-S 2008', + 'Acura TSX Sedan 2012', + 'Acura Integra Type R 2001', + 'Acura ZDX Hatchback 2012', + 'Aston Martin V8 Vantage Convertible 2012', + 'Aston Martin V8 Vantage Coupe 2012', + 'Aston Martin Virage Convertible 2012', + 'Aston Martin Virage Coupe 2012', + 'Audi RS 4 Convertible 2008', + 'Audi A5 Coupe 2012', + 'Audi TTS Coupe 2012', + 'Audi R8 Coupe 2012', + 'Audi V8 Sedan 1994', + 'Audi 100 Sedan 1994', + 'Audi 100 Wagon 1994', + 'Audi TT Hatchback 2011', + 'Audi S6 Sedan 2011', + 'Audi S5 Convertible 2012', + 'Audi S5 Coupe 2012', + 'Audi S4 Sedan 2012', + 'Audi S4 Sedan 2007', + 'Audi TT RS Coupe 2012', + 'BMW ActiveHybrid 5 Sedan 2012', + 'BMW 1 Series Convertible 2012', + 'BMW 1 Series Coupe 2012', + 'BMW 3 Series Sedan 2012', + 'BMW 3 Series Wagon 2012', + 'BMW 6 Series Convertible 2007', + 'BMW X5 SUV 2007', + 'BMW X6 SUV 2012', + 'BMW M3 Coupe 2012', + 'BMW M5 Sedan 2010', + 'BMW M6 Convertible 2010', + 'BMW X3 SUV 2012', + 'BMW Z4 Convertible 2012', + 'Bentley Continental Supersports Conv. Convertible 2012', + 'Bentley Arnage Sedan 2009', + 'Bentley Mulsanne Sedan 2011', + 'Bentley Continental GT Coupe 2012', + 'Bentley Continental GT Coupe 2007', + 'Bentley Continental Flying Spur Sedan 2007', + 'Bugatti Veyron 16.4 Convertible 2009', + 'Bugatti Veyron 16.4 Coupe 2009', + 'Buick Regal GS 2012', + 'Buick Rainier SUV 2007', + 'Buick Verano Sedan 2012', + 'Buick Enclave SUV 2012', + 'Cadillac CTS-V Sedan 2012', + 'Cadillac SRX SUV 2012', + 'Cadillac Escalade EXT Crew Cab 2007', + 'Chevrolet Silverado 1500 Hybrid Crew Cab 2012', + 'Chevrolet Corvette Convertible 2012', + 'Chevrolet Corvette ZR1 2012', + 'Chevrolet Corvette Ron Fellows Edition Z06 2007', + 'Chevrolet Traverse SUV 2012', + 'Chevrolet Camaro Convertible 2012', + 'Chevrolet HHR SS 2010', + 'Chevrolet Impala Sedan 2007', + 'Chevrolet Tahoe Hybrid SUV 2012', + 'Chevrolet Sonic Sedan 2012', + 'Chevrolet Express Cargo Van 2007', + 'Chevrolet Avalanche Crew Cab 2012', + 'Chevrolet Cobalt SS 2010', + 'Chevrolet Malibu Hybrid Sedan 2010', + 'Chevrolet TrailBlazer SS 2009', + 'Chevrolet Silverado 2500HD Regular Cab 2012', + 'Chevrolet Silverado 1500 Classic Extended Cab 2007', + 'Chevrolet Express Van 2007', + 'Chevrolet Monte Carlo Coupe 2007', + 'Chevrolet Malibu Sedan 2007', + 'Chevrolet Silverado 1500 Extended Cab 2012', + 'Chevrolet Silverado 1500 Regular Cab 2012', + 'Chrysler Aspen SUV 2009', + 'Chrysler Sebring Convertible 2010', + 'Chrysler Town and Country Minivan 2012', + 'Chrysler 300 SRT-8 2010', + 'Chrysler Crossfire Convertible 2008', + 'Chrysler PT Cruiser Convertible 2008', + 'Daewoo Nubira Wagon 2002', + 'Dodge Caliber Wagon 2012', + 'Dodge Caliber Wagon 2007', + 'Dodge Caravan Minivan 1997', + 'Dodge Ram Pickup 3500 Crew Cab 2010', + 'Dodge Ram Pickup 3500 Quad Cab 2009', + 'Dodge Sprinter Cargo Van 2009', + 'Dodge Journey SUV 2012', + 'Dodge Dakota Crew Cab 2010', + 'Dodge Dakota Club Cab 2007', + 'Dodge Magnum Wagon 2008', + 'Dodge Challenger SRT8 2011', + 'Dodge Durango SUV 2012', + 'Dodge Durango SUV 2007', + 'Dodge Charger Sedan 2012', + 'Dodge Charger SRT-8 2009', + 'Eagle Talon Hatchback 1998', + 'FIAT 500 Abarth 2012', + 'FIAT 500 Convertible 2012', + 'Ferrari FF Coupe 2012', + 'Ferrari California Convertible 2012', + 'Ferrari 458 Italia Convertible 2012', + 'Ferrari 458 Italia Coupe 2012', + 'Fisker Karma Sedan 2012', + 'Ford F-450 Super Duty Crew Cab 2012', + 'Ford Mustang Convertible 2007', + 'Ford Freestar Minivan 2007', + 'Ford Expedition EL SUV 2009', + 'Ford Edge SUV 2012', + 'Ford Ranger SuperCab 2011', + 'Ford GT Coupe 2006', + 'Ford F-150 Regular Cab 2012', + 'Ford F-150 Regular Cab 2007', + 'Ford Focus Sedan 2007', + 'Ford E-Series Wagon Van 2012', + 'Ford Fiesta Sedan 2012', + 'GMC Terrain SUV 2012', + 'GMC Savana Van 2012', + 'GMC Yukon Hybrid SUV 2012', + 'GMC Acadia SUV 2012', + 'GMC Canyon Extended Cab 2012', + 'Geo Metro Convertible 1993', + 'HUMMER H3T Crew Cab 2010', + 'HUMMER H2 SUT Crew Cab 2009', + 'Honda Odyssey Minivan 2012', + 'Honda Odyssey Minivan 2007', + 'Honda Accord Coupe 2012', + 'Honda Accord Sedan 2012', + 'Hyundai Veloster Hatchback 2012', + 'Hyundai Santa Fe SUV 2012', + 'Hyundai Tucson SUV 2012', + 'Hyundai Veracruz SUV 2012', + 'Hyundai Sonata Hybrid Sedan 2012', + 'Hyundai Elantra Sedan 2007', + 'Hyundai Accent Sedan 2012', + 'Hyundai Genesis Sedan 2012', + 'Hyundai Sonata Sedan 2012', + 'Hyundai Elantra Touring Hatchback 2012', + 'Hyundai Azera Sedan 2012', + 'Infiniti G Coupe IPL 2012', + 'Infiniti QX56 SUV 2011', + 'Isuzu Ascender SUV 2008', + 'Jaguar XK XKR 2012', + 'Jeep Patriot SUV 2012', + 'Jeep Wrangler SUV 2012', + 'Jeep Liberty SUV 2012', + 'Jeep Grand Cherokee SUV 2012', + 'Jeep Compass SUV 2012', + 'Lamborghini Reventon Coupe 2008', + 'Lamborghini Aventador Coupe 2012', + 'Lamborghini Gallardo LP 570-4 Superleggera 2012', + 'Lamborghini Diablo Coupe 2001', + 'Land Rover Range Rover SUV 2012', + 'Land Rover LR2 SUV 2012', + 'Lincoln Town Car Sedan 2011', + 'MINI Cooper Roadster Convertible 2012', + 'Maybach Landaulet Convertible 2012', + 'Mazda Tribute SUV 2011', + 'McLaren MP4-12C Coupe 2012', + 'Mercedes-Benz 300-Class Convertible 1993', + 'Mercedes-Benz C-Class Sedan 2012', + 'Mercedes-Benz SL-Class Coupe 2009', + 'Mercedes-Benz E-Class Sedan 2012', + 'Mercedes-Benz S-Class Sedan 2012', + 'Mercedes-Benz Sprinter Van 2012', + 'Mitsubishi Lancer Sedan 2012', + 'Nissan Leaf Hatchback 2012', + 'Nissan NV Passenger Van 2012', + 'Nissan Juke Hatchback 2012', + 'Nissan 240SX Coupe 1998', + 'Plymouth Neon Coupe 1999', + 'Porsche Panamera Sedan 2012', + 'Ram C/V Cargo Van Minivan 2012', + 'Rolls-Royce Phantom Drophead Coupe Convertible 2012', + 'Rolls-Royce Ghost Sedan 2012', + 'Rolls-Royce Phantom Sedan 2012', + 'Scion xD Hatchback 2012', + 'Spyker C8 Convertible 2009', + 'Spyker C8 Coupe 2009', + 'Suzuki Aerio Sedan 2007', + 'Suzuki Kizashi Sedan 2012', + 'Suzuki SX4 Hatchback 2012', + 'Suzuki SX4 Sedan 2012', + 'Tesla Model S Sedan 2012', + 'Toyota Sequoia SUV 2012', + 'Toyota Camry Sedan 2012', + 'Toyota Corolla Sedan 2012', + 'Toyota 4Runner SUV 2012', + 'Volkswagen Golf Hatchback 2012', + 'Volkswagen Golf Hatchback 1991', + 'Volkswagen Beetle Hatchback 2012', + 'Volvo C30 Hatchback 2012', + 'Volvo 240 Sedan 1993', + 'Volvo XC90 SUV 2007', + 'smart fortwo Convertible 2012', +] + +templates = [ + 'a photo of a {}.', + 'a photo of the {}.', + 'a photo of my {}.', + 'i love my {}!', + 'a photo of my dirty {}.', + 'a photo of my clean {}.', + 'a photo of my new {}.', + 'a photo of my old {}.', +] +``` + + + +## UCF101 + +```bash +classes = [ + 'Apply Eye Makeup', + 'Apply Lipstick', + 'Archery', + 'Baby Crawling', + 'Balance Beam', + 'Band Marching', + 'Baseball Pitch', + 'Basketball', + 'Basketball Dunk', + 'Bench Press', + 'Biking', + 'Billiards', + 'Blow Dry Hair', + 'Blowing Candles', + 'Body Weight Squats', + 'Bowling', + 'Boxing Punching Bag', + 'Boxing Speed Bag', + 'Breast Stroke', + 'Brushing Teeth', + 'Clean And Jerk', + 'Cliff Diving', + 'Cricket Bowling', + 'Cricket Shot', + 'Cutting In Kitchen', + 'Diving', + 'Drumming', + 'Fencing', + 'Field Hockey Penalty', + 'Floor Gymnastics', + 'Frisbee Catch', + 'Front Crawl', + 'Golf Swing', + 'Haircut', + 'Hammer Throw', + 'Hammering', + 'Hand Stand Pushups', + 'Handstand Walking', + 'Head Massage', + 'High Jump', + 'Horse Race', + 'Horse Riding', + 'Hula Hoop', + 'Ice Dancing', + 'Javelin Throw', + 'Juggling Balls', + 'Jump Rope', + 'Jumping Jack', + 'Kayaking', + 'Knitting', + 'Long Jump', + 'Lunges', + 'Military Parade', + 'Mixing', + 'Mopping Floor', + 'Nunchucks', + 'Parallel Bars', + 'Pizza Tossing', + 'Playing Cello', + 'Playing Daf', + 'Playing Dhol', + 'Playing Flute', + 'Playing Guitar', + 'Playing Piano', + 'Playing Sitar', + 'Playing Tabla', + 'Playing Violin', + 'Pole Vault', + 'Pommel Horse', + 'Pull Ups', + 'Punch', + 'Push Ups', + 'Rafting', + 'Rock Climbing Indoor', + 'Rope Climbing', + 'Rowing', + 'Salsa Spin', + 'Shaving Beard', + 'Shotput', + 'Skate Boarding', + 'Skiing', + 'Skijet', + 'Sky Diving', + 'Soccer Juggling', + 'Soccer Penalty', + 'Still Rings', + 'Sumo Wrestling', + 'Surfing', + 'Swing', + 'Table Tennis Shot', + 'Tai Chi', + 'Tennis Swing', + 'Throw Discus', + 'Trampoline Jumping', + 'Typing', + 'Uneven Bars', + 'Volleyball Spiking', + 'Walking With Dog', + 'Wall Pushups', + 'Writing On Board', + 'Yo Yo', +] + +templates = [ + 'a photo of a person {}.', + 'a video of a person {}.', + 'a example of a person {}.', + 'a demonstration of a person {}.', + 'a photo of the person {}.', + 'a video of the person {}.', + 'a example of the person {}.', + 'a demonstration of the person {}.', + 'a photo of a person using {}.', + 'a video of a person using {}.', + 'a example of a person using {}.', + 'a demonstration of a person using {}.', + 'a photo of the person using {}.', + 'a video of the person using {}.', + 'a example of the person using {}.', + 'a demonstration of the person using {}.', + 'a photo of a person doing {}.', + 'a video of a person doing {}.', + 'a example of a person doing {}.', + 'a demonstration of a person doing {}.', + 'a photo of the person doing {}.', + 'a video of the person doing {}.', + 'a example of the person doing {}.', + 'a demonstration of the person doing {}.', + 'a photo of a person during {}.', + 'a video of a person during {}.', + 'a example of a person during {}.', + 'a demonstration of a person during {}.', + 'a photo of the person during {}.', + 'a video of the person during {}.', + 'a example of the person during {}.', + 'a demonstration of the person during {}.', + 'a photo of a person performing {}.', + 'a video of a person performing {}.', + 'a example of a person performing {}.', + 'a demonstration of a person performing {}.', + 'a photo of the person performing {}.', + 'a video of the person performing {}.', + 'a example of the person performing {}.', + 'a demonstration of the person performing {}.', + 'a photo of a person practicing {}.', + 'a video of a person practicing {}.', + 'a example of a person practicing {}.', + 'a demonstration of a person practicing {}.', + 'a photo of the person practicing {}.', + 'a video of the person practicing {}.', + 'a example of the person practicing {}.', + 'a demonstration of the person practicing {}.', +] +``` + + diff --git a/src/CLIP/data/rendered-sst2.md b/src/CLIP/data/rendered-sst2.md new file mode 100644 index 0000000000000000000000000000000000000000..d27454caf046d8d699f87b8cb8404a05e488dbef --- /dev/null +++ b/src/CLIP/data/rendered-sst2.md @@ -0,0 +1,11 @@ +# The Rendered SST2 Dataset + +In the paper, we used an image classification dataset called Rendered SST2, to evaluate the model's capability on optical character recognition. To do so, we rendered the sentences in the [Standford Sentiment Treebank v2](https://nlp.stanford.edu/sentiment/treebank.html) dataset and used those as the input to the CLIP image encoder. + +The following command will download a 131MB archive countaining the images and extract into a subdirectory `rendered-sst2`: + +```bash +wget https://openaipublic.azureedge.net/clip/data/rendered-sst2.tgz +tar zxvf rendered-sst2.tgz +``` + diff --git a/src/CLIP/data/yfcc100m.md b/src/CLIP/data/yfcc100m.md new file mode 100644 index 0000000000000000000000000000000000000000..06083ef9a613b5d360e87c3f395c2a16c6e9208e --- /dev/null +++ b/src/CLIP/data/yfcc100m.md @@ -0,0 +1,14 @@ +# The YFCC100M Subset + +In the paper, we performed a dataset ablation using a subset of the YFCC100M dataset and showed that the performance remained largely similar. + +The subset contains 14,829,396 images, about 15% of the full dataset, which have been filtered to only keep those with natural languag titles and/or descriptions in English. + +We provide the list of (line number, photo identifier, photo hash) of each image contained in this subset. These correspond to the first three columns in the dataset's metadata TSV file. + +```bash +wget https://openaipublic.azureedge.net/clip/data/yfcc100m_subset_data.tsv.bz2 +bunzip2 yfcc100m_subset_data.tsv.bz2 +``` + +Use of the underlying media files is subject to the Creative Commons licenses chosen by their creators/uploaders. For more information about the YFCC100M dataset, visit [the official website](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/). \ No newline at end of file diff --git a/src/CLIP/hubconf.py b/src/CLIP/hubconf.py new file mode 100644 index 0000000000000000000000000000000000000000..520b354b62ab4d199d49462e9c65890d924c69e6 --- /dev/null +++ b/src/CLIP/hubconf.py @@ -0,0 +1,42 @@ +from clip.clip import tokenize as _tokenize, load as _load, available_models as _available_models +import re +import string + +dependencies = ["torch", "torchvision", "ftfy", "regex", "tqdm"] + +# For compatibility (cannot include special characters in function name) +model_functions = { model: re.sub(f'[{string.punctuation}]', '_', model) for model in _available_models()} + +def _create_hub_entrypoint(model): + def entrypoint(**kwargs): + return _load(model, **kwargs) + + entrypoint.__doc__ = f"""Loads the {model} CLIP model + + Parameters + ---------- + device : Union[str, torch.device] + The device to put the loaded model + + jit : bool + Whether to load the optimized JIT model or more hackable non-JIT model (default). + + download_root: str + path to download the model files; by default, it uses "~/.cache/clip" + + Returns + ------- + model : torch.nn.Module + The {model} CLIP model + + preprocess : Callable[[PIL.Image], torch.Tensor] + A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input + """ + return entrypoint + +def tokenize(): + return _tokenize + +_entrypoints = {model_functions[model]: _create_hub_entrypoint(model) for model in _available_models()} + +globals().update(_entrypoints) \ No newline at end of file diff --git a/src/CLIP/model-card.md b/src/CLIP/model-card.md new file mode 100644 index 0000000000000000000000000000000000000000..6db1ca46f0706d2276e0c95578f4aa4dc0136e58 --- /dev/null +++ b/src/CLIP/model-card.md @@ -0,0 +1,120 @@ +# Model Card: CLIP + +Inspired by [Model Cards for Model Reporting (Mitchell et al.)](https://arxiv.org/abs/1810.03993) and [Lessons from Archives (Jo & Gebru)](https://arxiv.org/pdf/1912.10389.pdf), we’re providing some accompanying information about the multimodal model. + +## Model Details + +The CLIP model was developed by researchers at OpenAI to learn about what contributes to robustness in computer vision tasks. The model was also developed to test the ability of models to generalize to arbitrary image classification tasks in a zero-shot manner. It was not developed for general model deployment - to deploy models like CLIP, researchers will first need to carefully study their capabilities in relation to the specific context they’re being deployed within. + +### Model Date + +January 2021 + +### Model Type + +The base model uses a ResNet50 with several modifications as an image encoder and uses a masked self-attention Transformer as a text encoder. These encoders are trained to maximize the similarity of (image, text) pairs via a contrastive loss. There is also a variant of the model where the ResNet image encoder is replaced with a Vision Transformer. + +### Model Versions + +Initially, we’ve released one CLIP model based on the Vision Transformer architecture equivalent to ViT-B/32, along with the RN50 model, using the architecture equivalent to ResNet-50. + +As part of the staged release process, we have also released the RN101 model, as well as RN50x4, a RN50 scaled up 4x according to the [EfficientNet](https://arxiv.org/abs/1905.11946) scaling rule. In July 2021, we additionally released the RN50x16 and ViT-B/16 models, and in January 2022, the RN50x64 and ViT-L/14 models were released. Lastly, the ViT-L/14@336px model was released in April 2022. + +Please see the paper linked below for further details about their specification. + +### Documents + +- [Blog Post](https://openai.com/blog/clip/) +- [CLIP Paper](https://arxiv.org/abs/2103.00020) + + + +## Model Use + +### Intended Use + +The model is intended as a research output for research communities. We hope that this model will enable researchers to better understand and explore zero-shot, arbitrary image classification. We also hope it can be used for interdisciplinary studies of the potential impact of such models - the CLIP paper includes a discussion of potential downstream impacts to provide an example for this sort of analysis. + +#### Primary intended uses + +The primary intended users of these models are AI researchers. + +We primarily imagine the model will be used by researchers to better understand robustness, generalization, and other capabilities, biases, and constraints of computer vision models. + +### Out-of-Scope Use Cases + +**Any** deployed use case of the model - whether commercial or not - is currently out of scope. Non-deployed use cases such as image search in a constrained environment, are also not recommended unless there is thorough in-domain testing of the model with a specific, fixed class taxonomy. This is because our safety assessment demonstrated a high need for task specific testing especially given the variability of CLIP’s performance with different class taxonomies. This makes untested and unconstrained deployment of the model in any use case currently potentially harmful. + +Certain use cases which would fall under the domain of surveillance and facial recognition are always out-of-scope regardless of performance of the model. This is because the use of artificial intelligence for tasks such as these can be premature currently given the lack of testing norms and checks to ensure its fair use. + +Since the model has not been purposefully trained in or evaluated on any languages other than English, its use should be limited to English language use cases. + + + +## Data + +The model was trained on publicly available image-caption data. This was done through a combination of crawling a handful of websites and using commonly-used pre-existing image datasets such as [YFCC100M](http://projects.dfki.uni-kl.de/yfcc100m/). A large portion of the data comes from our crawling of the internet. This means that the data is more representative of people and societies most connected to the internet which tend to skew towards more developed nations, and younger, male users. + +### Data Mission Statement + +Our goal with building this dataset was to test out robustness and generalizability in computer vision tasks. As a result, the focus was on gathering large quantities of data from different publicly-available internet data sources. The data was gathered in a mostly non-interventionist manner. However, we only crawled websites that had policies against excessively violent and adult images and allowed us to filter out such content. We do not intend for this dataset to be used as the basis for any commercial or deployed model and will not be releasing the dataset. + + + +## Performance and Limitations + +### Performance + +We have evaluated the performance of CLIP on a wide range of benchmarks across a variety of computer vision datasets such as OCR to texture recognition to fine-grained classification. The paper describes model performance on the following datasets: + +- Food101 +- CIFAR10 +- CIFAR100 +- Birdsnap +- SUN397 +- Stanford Cars +- FGVC Aircraft +- VOC2007 +- DTD +- Oxford-IIIT Pet dataset +- Caltech101 +- Flowers102 +- MNIST +- SVHN +- IIIT5K +- Hateful Memes +- SST-2 +- UCF101 +- Kinetics700 +- Country211 +- CLEVR Counting +- KITTI Distance +- STL-10 +- RareAct +- Flickr30 +- MSCOCO +- ImageNet +- ImageNet-A +- ImageNet-R +- ImageNet Sketch +- ObjectNet (ImageNet Overlap) +- Youtube-BB +- ImageNet-Vid + +## Limitations + +CLIP and our analysis of it have a number of limitations. CLIP currently struggles with respect to certain tasks such as fine grained classification and counting objects. CLIP also poses issues with regards to fairness and bias which we discuss in the paper and briefly in the next section. Additionally, our approach to testing CLIP also has an important limitation- in many cases we have used linear probes to evaluate the performance of CLIP and there is evidence suggesting that linear probes can underestimate model performance. + +### Bias and Fairness + +We find that the performance of CLIP - and the specific biases it exhibits - can depend significantly on class design and the choices one makes for categories to include and exclude. We tested the risk of certain kinds of denigration with CLIP by classifying images of people from [Fairface](https://arxiv.org/abs/1908.04913) into crime-related and non-human animal categories. We found significant disparities with respect to race and gender. Additionally, we found that these disparities could shift based on how the classes were constructed. (Details captured in the Broader Impacts Section in the paper). + +We also tested the performance of CLIP on gender, race and age classification using the Fairface dataset (We default to using race categories as they are constructed in the Fairface dataset.) in order to assess quality of performance across different demographics. We found accuracy >96% across all races for gender classification with ‘Middle Eastern’ having the highest accuracy (98.4%) and ‘White’ having the lowest (96.5%). Additionally, CLIP averaged ~93% for racial classification and ~63% for age classification. Our use of evaluations to test for gender, race and age classification as well as denigration harms is simply to evaluate performance of the model across people and surface potential risks and not to demonstrate an endorsement/enthusiasm for such tasks. + + + +## Feedback + +### Where to send questions or comments about the model + +Please use [this Google Form](https://forms.gle/Uv7afRH5dvY34ZEs9) diff --git a/src/CLIP/notebooks/Interacting_with_CLIP.ipynb b/src/CLIP/notebooks/Interacting_with_CLIP.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..1043f2389d3aa8dde666036ce7221bea2cce6754 --- /dev/null +++ b/src/CLIP/notebooks/Interacting_with_CLIP.ipynb @@ -0,0 +1,925 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Interacting with CLIP.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "1369964d45004b5e95a058910b2a33e6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_12e23e2819094ee0a079d4eb77cfc4f9", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_7a5f52e56ede4ac3abe37a3ece007dc9", + "IPY_MODEL_ce8b0faa1a1340b5a504d7b3546b3ccb" + ] + } + }, + "12e23e2819094ee0a079d4eb77cfc4f9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "7a5f52e56ede4ac3abe37a3ece007dc9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_5e6adc4592124a4581b85f4c1f3bab4d", + "_dom_classes": [], + "description": "", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 169001437, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 169001437, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_4a61c10fc00c4f04bb00b82e942da210" + } + }, + "ce8b0faa1a1340b5a504d7b3546b3ccb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_b597cd6f6cd443aba4bf4491ac7f957e", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 169001984/? [00:06<00:00, 25734958.25it/s]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_161969cae25a49f38aacd1568d3cac6c" + } + }, + "5e6adc4592124a4581b85f4c1f3bab4d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "4a61c10fc00c4f04bb00b82e942da210": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "b597cd6f6cd443aba4bf4491ac7f957e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "161969cae25a49f38aacd1568d3cac6c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "YPHN7PJgKOzb" + }, + "source": [ + "# Interacting with CLIP\n", + "\n", + "This is a self-contained notebook that shows how to download and run CLIP models, calculate the similarity between arbitrary image and text inputs, and perform zero-shot image classifications." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "53N4k0pj_9qL" + }, + "source": [ + "# Preparation for Colab\n", + "\n", + "Make sure you're running a GPU runtime; if not, select \"GPU\" as the hardware accelerator in Runtime > Change Runtime Type in the menu. The next cells will install the `clip` package and its dependencies, and check if PyTorch 1.7.1 or later is installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0BpdJkdBssk9", + "outputId": "4d9b51f8-d255-4868-97f6-be0a67dadfae" + }, + "source": [ + "! pip install ftfy regex tqdm\n", + "! pip install git+https://github.com/openai/CLIP.git" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting ftfy\n", + " Downloading ftfy-6.0.3.tar.gz (64 kB)\n", + "\u001b[?25l\r\u001b[K |█████ | 10 kB 34.6 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 20 kB 20.7 MB/s eta 0:00:01\r\u001b[K |███████████████▎ | 30 kB 16.4 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 40 kB 15.2 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▌ | 51 kB 7.0 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 61 kB 8.2 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 64 kB 2.6 MB/s \n", + "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy) (0.2.5)\n", + "Building wheels for collected packages: ftfy\n", + " Building wheel for ftfy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ftfy: filename=ftfy-6.0.3-py3-none-any.whl size=41934 sha256=ce00f21233e5e1a5c3e84204d651ae0c17403484418c330c69ebae7297ca7003\n", + " Stored in directory: /root/.cache/pip/wheels/19/f5/38/273eb3b5e76dfd850619312f693716ac4518b498f5ffb6f56d\n", + "Successfully built ftfy\n", + "Installing collected packages: ftfy\n", + "Successfully installed ftfy-6.0.3\n", + "Collecting git+https://github.com/openai/CLIP.git\n", + " Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-tbmjxrgj\n", + " Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-tbmjxrgj\n", + "Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (6.0.3)\n", + "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (4.41.1)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (1.9.0+cu102)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (0.10.0+cu102)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->clip==1.0) (0.2.5)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->clip==1.0) (3.7.4.3)\n", + "Requirement already satisfied: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\n", + "Building wheels for collected packages: clip\n", + " Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369080 sha256=9059060f3a406b8268cfcbbf03647ab9b59e660d03f86c6120a9dd06f2b82cec\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-7v3mrcvj/wheels/fd/b9/c3/5b4470e35ed76e174bff77c92f91da82098d5e35fd5bc8cdac\n", + "Successfully built clip\n", + "Installing collected packages: clip\n", + "Successfully installed clip-1.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C1hkDT38hSaP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "70a44964-883d-4fd0-b95a-2c7f2b19aca9" + }, + "source": [ + "import numpy as np\n", + "import torch\n", + "from pkg_resources import packaging\n", + "\n", + "print(\"Torch version:\", torch.__version__)\n" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Torch version: 1.9.0+cu102\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eFxgLV5HAEEw" + }, + "source": [ + "# Loading the model\n", + "\n", + "`clip.available_models()` will list the names of available CLIP models." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uLFS29hnhlY4", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "11779e1e-8bdd-4167-c18e-d26bdd6b67db" + }, + "source": [ + "import clip\n", + "\n", + "clip.available_models()" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IBRVTY9lbGm8", + "outputId": "f06fd2fd-6126-475b-87d0-b10aa3b7da49" + }, + "source": [ + "model, preprocess = clip.load(\"ViT-B/32\")\n", + "model.cuda().eval()\n", + "input_resolution = model.visual.input_resolution\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Input resolution:\", input_resolution)\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.0MiB/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Model parameters: 151,277,313\n", + "Input resolution: 224\n", + "Context length: 77\n", + "Vocab size: 49408\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "21slhZGCqANb" + }, + "source": [ + "# Image Preprocessing\n", + "\n", + "We resize the input images and center-crop them to conform with the image resolution that the model expects. Before doing so, we will normalize the pixel intensity using the dataset mean and standard deviation.\n", + "\n", + "The second return value from `clip.load()` contains a torchvision `Transform` that performs this preprocessing.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "d6cpiIFHp9N6", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "880cb98e-1e5e-430e-8b59-4bf35fa554f9" + }, + "source": [ + "preprocess" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Compose(\n", + " Resize(size=224, interpolation=bicubic, max_size=None, antialias=None)\n", + " CenterCrop(size=(224, 224))\n", + " . at 0x7f3a24ffb440>\n", + " ToTensor()\n", + " Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))\n", + ")" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xwSB5jZki3Cj" + }, + "source": [ + "# Text Preprocessing\n", + "\n", + "We use a case-insensitive tokenizer, which can be invoked using `clip.tokenize()`. By default, the outputs are padded to become 77 tokens long, which is what the CLIP models expects." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qGom156-i2kL", + "outputId": "050b0ce1-caba-47e1-f4ac-dba994599718" + }, + "source": [ + "clip.tokenize(\"Hello World!\")" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[49406, 3306, 1002, 256, 49407, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4W8ARJVqBJXs" + }, + "source": [ + "# Setting up input images and texts\n", + "\n", + "We are going to feed 8 example images and their textual descriptions to the model, and compare the similarity between the corresponding features.\n", + "\n", + "The tokenizer is case-insensitive, and we can freely give any suitable textual descriptions." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tMc1AXzBlhzm" + }, + "source": [ + "import os\n", + "import skimage\n", + "import IPython.display\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "from collections import OrderedDict\n", + "import torch\n", + "\n", + "%matplotlib inline\n", + "%config InlineBackend.figure_format = 'retina'\n", + "\n", + "# images in skimage to use and their textual descriptions\n", + "descriptions = {\n", + " \"page\": \"a page of text about segmentation\",\n", + " \"chelsea\": \"a facial photo of a tabby cat\",\n", + " \"astronaut\": \"a portrait of an astronaut with the American flag\",\n", + " \"rocket\": \"a rocket standing on a launchpad\",\n", + " \"motorcycle_right\": \"a red motorcycle standing in a garage\",\n", + " \"camera\": \"a person looking at a camera on a tripod\",\n", + " \"horse\": \"a black-and-white silhouette of a horse\", \n", + " \"coffee\": \"a cup of coffee on a saucer\"\n", + "}" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "NSSrLY185jSf", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 368 + }, + "outputId": "06451963-5ecb-4ddc-d0a8-24e9b110af7d" + }, + "source": [ + "original_images = []\n", + "images = []\n", + "texts = []\n", + "plt.figure(figsize=(16, 5))\n", + "\n", + "for filename in [filename for filename in os.listdir(skimage.data_dir) if filename.endswith(\".png\") or filename.endswith(\".jpg\")]:\n", + " name = os.path.splitext(filename)[0]\n", + " if name not in descriptions:\n", + " continue\n", + "\n", + " image = Image.open(os.path.join(skimage.data_dir, filename)).convert(\"RGB\")\n", + " \n", + " plt.subplot(2, 4, len(images) + 1)\n", + " plt.imshow(image)\n", + " plt.title(f\"{filename}\\n{descriptions[name]}\")\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + "\n", + " original_images.append(image)\n", + " images.append(preprocess(image))\n", + " texts.append(descriptions[name])\n", + "\n", + "plt.tight_layout()\n" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1116, + "height": 351 + } + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WEVKsji6WOIX" + }, + "source": [ + "## Building features\n", + "\n", + "We normalize the images, tokenize each text input, and run the forward pass of the model to get the image and text features." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "HBgCanxi8JKw" + }, + "source": [ + "image_input = torch.tensor(np.stack(images)).cuda()\n", + "text_tokens = clip.tokenize([\"This is \" + desc for desc in texts]).cuda()" + ], + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZN9I0nIBZ_vW" + }, + "source": [ + "with torch.no_grad():\n", + " image_features = model.encode_image(image_input).float()\n", + " text_features = model.encode_text(text_tokens).float()" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cuxm2Gt4Wvzt" + }, + "source": [ + "## Calculating cosine similarity\n", + "\n", + "We normalize the features and calculate the dot product of each pair." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yKAxkQR7bf3A" + }, + "source": [ + "image_features /= image_features.norm(dim=-1, keepdim=True)\n", + "text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "similarity = text_features.cpu().numpy() @ image_features.cpu().numpy().T" + ], + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "C5zvMxh8cU6m", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 831 + }, + "outputId": "22bca748-ab42-4888-c9da-8f22c21c6185" + }, + "source": [ + "count = len(descriptions)\n", + "\n", + "plt.figure(figsize=(20, 14))\n", + "plt.imshow(similarity, vmin=0.1, vmax=0.3)\n", + "# plt.colorbar()\n", + "plt.yticks(range(count), texts, fontsize=18)\n", + "plt.xticks([])\n", + "for i, image in enumerate(original_images):\n", + " plt.imshow(image, extent=(i - 0.5, i + 0.5, -1.6, -0.6), origin=\"lower\")\n", + "for x in range(similarity.shape[1]):\n", + " for y in range(similarity.shape[0]):\n", + " plt.text(x, y, f\"{similarity[y, x]:.2f}\", ha=\"center\", va=\"center\", size=12)\n", + "\n", + "for side in [\"left\", \"top\", \"right\", \"bottom\"]:\n", + " plt.gca().spines[side].set_visible(False)\n", + "\n", + "plt.xlim([-0.5, count - 0.5])\n", + "plt.ylim([count + 0.5, -2])\n", + "\n", + "plt.title(\"Cosine similarity between text and image features\", size=20)" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Cosine similarity between text and image features')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 12 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 1038, + "height": 796 + }, + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "alePijoXy6AH" + }, + "source": [ + "# Zero-Shot Image Classification\n", + "\n", + "You can classify images using the cosine similarity (times 100) as the logits to the softmax operation." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Nqu4GlfPfr-p", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102, + "referenced_widgets": [ + "1369964d45004b5e95a058910b2a33e6", + "12e23e2819094ee0a079d4eb77cfc4f9", + "7a5f52e56ede4ac3abe37a3ece007dc9", + "ce8b0faa1a1340b5a504d7b3546b3ccb", + "5e6adc4592124a4581b85f4c1f3bab4d", + "4a61c10fc00c4f04bb00b82e942da210", + "b597cd6f6cd443aba4bf4491ac7f957e", + "161969cae25a49f38aacd1568d3cac6c" + ] + }, + "outputId": "ca7a0e3c-e267-4e6e-8a1b-bbab3c0a2462" + }, + "source": [ + "from torchvision.datasets import CIFAR100\n", + "\n", + "cifar100 = CIFAR100(os.path.expanduser(\"~/.cache\"), transform=preprocess, download=True)" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Downloading https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz to /root/.cache/cifar-100-python.tar.gz\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1369964d45004b5e95a058910b2a33e6", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=169001437.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "Extracting /root/.cache/cifar-100-python.tar.gz to /root/.cache\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C4S__zCGy2MT" + }, + "source": [ + "text_descriptions = [f\"This is a photo of a {label}\" for label in cifar100.classes]\n", + "text_tokens = clip.tokenize(text_descriptions).cuda()" + ], + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "c4z1fm9vCpSR" + }, + "source": [ + "with torch.no_grad():\n", + " text_features = model.encode_text(text_tokens).float()\n", + " text_features /= text_features.norm(dim=-1, keepdim=True)\n", + "\n", + "text_probs = (100.0 * image_features @ text_features.T).softmax(dim=-1)\n", + "top_probs, top_labels = text_probs.cpu().topk(5, dim=-1)" + ], + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 931 + }, + "id": "T6Ju_6IBE2Iz", + "outputId": "e1a155dc-474d-409c-e03d-d41b804648c3" + }, + "source": [ + "plt.figure(figsize=(16, 16))\n", + "\n", + "for i, image in enumerate(original_images):\n", + " plt.subplot(4, 4, 2 * i + 1)\n", + " plt.imshow(image)\n", + " plt.axis(\"off\")\n", + "\n", + " plt.subplot(4, 4, 2 * i + 2)\n", + " y = np.arange(top_probs.shape[-1])\n", + " plt.grid()\n", + " plt.barh(y, top_probs[i])\n", + " plt.gca().invert_yaxis()\n", + " plt.gca().set_axisbelow(True)\n", + " plt.yticks(y, [cifar100.classes[index] for index in top_labels[i].numpy()])\n", + " plt.xlabel(\"probability\")\n", + "\n", + "plt.subplots_adjust(wspace=0.5)\n", + "plt.show()" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "image/png": { + "width": 917, + "height": 914 + }, + "needs_background": "light" + } + } + ] + } + ] +} diff --git a/src/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb b/src/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..dba7fb654f4bed7adff1da1e7d4297670ea51469 --- /dev/null +++ b/src/CLIP/notebooks/Prompt_Engineering_for_ImageNet.ipynb @@ -0,0 +1,1107 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Prompt Engineering for ImageNet.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "66a1639713ae441d8a9b873381f9d774": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_610b775178c645e2b4663b77cc0c67b6", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_412dd15f0d8542f5ab2730f8616fb582", + "IPY_MODEL_5e6315f36b4e4eeea5c6294b024e0c97" + ] + } + }, + "610b775178c645e2b4663b77cc0c67b6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "412dd15f0d8542f5ab2730f8616fb582": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_085d5388abda4202bfa66d0c088452f8", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 1000, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 1000, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_f75124b64aa147c693c67a78f8e3a231" + } + }, + "5e6315f36b4e4eeea5c6294b024e0c97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_6e5676a054874243b55fc6d120a07d01", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 1000/1000 [16:51<00:00, 1.01s/it]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_dc6d1416c01a4047935ee15c3fd2eb1c" + } + }, + "085d5388abda4202bfa66d0c088452f8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "f75124b64aa147c693c67a78f8e3a231": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "6e5676a054874243b55fc6d120a07d01": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "dc6d1416c01a4047935ee15c3fd2eb1c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "84f80a7f3e764346969a347b0f71b24e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_392656f01b2945f3bd7903783ed8cc96", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_8e47a435519b4ce090879b4be2f61f99", + "IPY_MODEL_41b1ed6b0a9745c1a595377670b15ff4" + ] + } + }, + "392656f01b2945f3bd7903783ed8cc96": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "8e47a435519b4ce090879b4be2f61f99": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_179b8ae1eb7f4a828f953e889b141725", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 313, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 313, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_d8708e8414fd44f4abd6590c9b57996f" + } + }, + "41b1ed6b0a9745c1a595377670b15ff4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_800e30f5b4f24475a2b0046da0703631", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 313/313 [02:31<00:00, 2.07it/s]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_8764308b948745f1a677332fd21fcaf0" + } + }, + "179b8ae1eb7f4a828f953e889b141725": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "d8708e8414fd44f4abd6590c9b57996f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "800e30f5b4f24475a2b0046da0703631": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "8764308b948745f1a677332fd21fcaf0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "53N4k0pj_9qL" + }, + "source": [ + "# Preparation for Colab\n", + "\n", + "Make sure you're running a GPU runtime; if not, select \"GPU\" as the hardware accelerator in Runtime > Change Runtime Type in the menu. The next cells will install the `clip` package and its dependencies, and check if PyTorch 1.7.1 or later is installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0BpdJkdBssk9", + "outputId": "41a4070f-5321-4fc4-bd4d-0b5c1f476d56" + }, + "source": [ + "! pip install ftfy regex tqdm\n", + "! pip install git+https://github.com/openai/CLIP.git" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting ftfy\n", + " Downloading ftfy-6.0.3.tar.gz (64 kB)\n", + "\u001b[?25l\r\u001b[K |█████ | 10 kB 14.9 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 20 kB 18.7 MB/s eta 0:00:01\r\u001b[K |███████████████▎ | 30 kB 9.0 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 40 kB 4.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▌ | 51 kB 4.6 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 61 kB 4.7 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 64 kB 1.3 MB/s \n", + "\u001b[?25hRequirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (4.41.1)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy) (0.2.5)\n", + "Building wheels for collected packages: ftfy\n", + " Building wheel for ftfy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ftfy: filename=ftfy-6.0.3-py3-none-any.whl size=41934 sha256=90ec193331444b2c4ff1cd81935e7de42065b89d304db7efac67bcfd87c27873\n", + " Stored in directory: /root/.cache/pip/wheels/19/f5/38/273eb3b5e76dfd850619312f693716ac4518b498f5ffb6f56d\n", + "Successfully built ftfy\n", + "Installing collected packages: ftfy\n", + "Successfully installed ftfy-6.0.3\n", + "Collecting git+https://github.com/openai/CLIP.git\n", + " Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-hqnbveqi\n", + " Running command git clone -q https://github.com/openai/CLIP.git /tmp/pip-req-build-hqnbveqi\n", + "Requirement already satisfied: ftfy in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (6.0.3)\n", + "Requirement already satisfied: regex in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (2019.12.20)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (4.41.1)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (1.9.0+cu102)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from clip==1.0) (0.10.0+cu102)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.7/dist-packages (from ftfy->clip==1.0) (0.2.5)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->clip==1.0) (3.7.4.3)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (1.19.5)\n", + "Requirement already satisfied: pillow>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->clip==1.0) (7.1.2)\n", + "Building wheels for collected packages: clip\n", + " Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369080 sha256=fda43d2b80cfb2b33c2d43e23ea5f53293a9a8b48d5f9e341de527f6adfbf5a3\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-kmmplf44/wheels/fd/b9/c3/5b4470e35ed76e174bff77c92f91da82098d5e35fd5bc8cdac\n", + "Successfully built clip\n", + "Installing collected packages: clip\n", + "Successfully installed clip-1.0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "C1hkDT38hSaP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e10d4f17-8fa6-4b75-a18f-f0c38990b5a3" + }, + "source": [ + "import numpy as np\n", + "import torch\n", + "import clip\n", + "from tqdm.notebook import tqdm\n", + "from pkg_resources import packaging\n", + "\n", + "print(\"Torch version:\", torch.__version__)\n" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Torch version: 1.9.0+cu102\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eFxgLV5HAEEw" + }, + "source": [ + "# Loading the model\n", + "\n", + "Download and instantiate a CLIP model using the `clip` module that we just installed." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uLFS29hnhlY4", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "09abb234-693e-4efb-953f-e1847ba95758" + }, + "source": [ + "clip.available_models()" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['RN50', 'RN101', 'RN50x4', 'RN50x16', 'ViT-B/32', 'ViT-B/16']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "cboKZocQlSYX", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "240acdd0-ca62-45db-8418-9e4ef73e8aff" + }, + "source": [ + "model, preprocess = clip.load(\"ViT-B/32\")" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 63.6MiB/s]\n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IBRVTY9lbGm8", + "outputId": "785019a1-1f40-45b0-e349-b0d4ec3173bf" + }, + "source": [ + "input_resolution = model.visual.input_resolution\n", + "context_length = model.context_length\n", + "vocab_size = model.vocab_size\n", + "\n", + "print(\"Model parameters:\", f\"{np.sum([int(np.prod(p.shape)) for p in model.parameters()]):,}\")\n", + "print(\"Input resolution:\", input_resolution)\n", + "print(\"Context length:\", context_length)\n", + "print(\"Vocab size:\", vocab_size)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Model parameters: 151,277,313\n", + "Input resolution: 224\n", + "Context length: 77\n", + "Vocab size: 49408\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LhO3OtOmF8M4" + }, + "source": [ + "# Preparing ImageNet labels and prompts\n", + "\n", + "The following cell contains the 1,000 labels for the ImageNet dataset, followed by the text templates we'll use as \"prompt engineering\"." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "R2HbOZrqa0jF" + }, + "source": [ + "imagenet_classes = [\"tench\", \"goldfish\", \"great white shark\", \"tiger shark\", \"hammerhead shark\", \"electric ray\", \"stingray\", \"rooster\", \"hen\", \"ostrich\", \"brambling\", \"goldfinch\", \"house finch\", \"junco\", \"indigo bunting\", \"American robin\", \"bulbul\", \"jay\", \"magpie\", \"chickadee\", \"American dipper\", \"kite (bird of prey)\", \"bald eagle\", \"vulture\", \"great grey owl\", \"fire salamander\", \"smooth newt\", \"newt\", \"spotted salamander\", \"axolotl\", \"American bullfrog\", \"tree frog\", \"tailed frog\", \"loggerhead sea turtle\", \"leatherback sea turtle\", \"mud turtle\", \"terrapin\", \"box turtle\", \"banded gecko\", \"green iguana\", \"Carolina anole\", \"desert grassland whiptail lizard\", \"agama\", \"frilled-necked lizard\", \"alligator lizard\", \"Gila monster\", \"European green lizard\", \"chameleon\", \"Komodo dragon\", \"Nile crocodile\", \"American alligator\", \"triceratops\", \"worm snake\", \"ring-necked snake\", \"eastern hog-nosed snake\", \"smooth green snake\", \"kingsnake\", \"garter snake\", \"water snake\", \"vine snake\", \"night snake\", \"boa constrictor\", \"African rock python\", \"Indian cobra\", \"green mamba\", \"sea snake\", \"Saharan horned viper\", \"eastern diamondback rattlesnake\", \"sidewinder rattlesnake\", \"trilobite\", \"harvestman\", \"scorpion\", \"yellow garden spider\", \"barn spider\", \"European garden spider\", \"southern black widow\", \"tarantula\", \"wolf spider\", \"tick\", \"centipede\", \"black grouse\", \"ptarmigan\", \"ruffed grouse\", \"prairie grouse\", \"peafowl\", \"quail\", \"partridge\", \"african grey parrot\", \"macaw\", \"sulphur-crested cockatoo\", \"lorikeet\", \"coucal\", \"bee eater\", \"hornbill\", \"hummingbird\", \"jacamar\", \"toucan\", \"duck\", \"red-breasted merganser\", \"goose\", \"black swan\", \"tusker\", \"echidna\", \"platypus\", \"wallaby\", \"koala\", \"wombat\", \"jellyfish\", \"sea anemone\", \"brain coral\", \"flatworm\", \"nematode\", \"conch\", \"snail\", \"slug\", \"sea slug\", \"chiton\", \"chambered nautilus\", \"Dungeness crab\", \"rock crab\", \"fiddler crab\", \"red king crab\", \"American lobster\", \"spiny lobster\", \"crayfish\", \"hermit crab\", \"isopod\", \"white stork\", \"black stork\", \"spoonbill\", \"flamingo\", \"little blue heron\", \"great egret\", \"bittern bird\", \"crane bird\", \"limpkin\", \"common gallinule\", \"American coot\", \"bustard\", \"ruddy turnstone\", \"dunlin\", \"common redshank\", \"dowitcher\", \"oystercatcher\", \"pelican\", \"king penguin\", \"albatross\", \"grey whale\", \"killer whale\", \"dugong\", \"sea lion\", \"Chihuahua\", \"Japanese Chin\", \"Maltese\", \"Pekingese\", \"Shih Tzu\", \"King Charles Spaniel\", \"Papillon\", \"toy terrier\", \"Rhodesian Ridgeback\", \"Afghan Hound\", \"Basset Hound\", \"Beagle\", \"Bloodhound\", \"Bluetick Coonhound\", \"Black and Tan Coonhound\", \"Treeing Walker Coonhound\", \"English foxhound\", \"Redbone Coonhound\", \"borzoi\", \"Irish Wolfhound\", \"Italian Greyhound\", \"Whippet\", \"Ibizan Hound\", \"Norwegian Elkhound\", \"Otterhound\", \"Saluki\", \"Scottish Deerhound\", \"Weimaraner\", \"Staffordshire Bull Terrier\", \"American Staffordshire Terrier\", \"Bedlington Terrier\", \"Border Terrier\", \"Kerry Blue Terrier\", \"Irish Terrier\", \"Norfolk Terrier\", \"Norwich Terrier\", \"Yorkshire Terrier\", \"Wire Fox Terrier\", \"Lakeland Terrier\", \"Sealyham Terrier\", \"Airedale Terrier\", \"Cairn Terrier\", \"Australian Terrier\", \"Dandie Dinmont Terrier\", \"Boston Terrier\", \"Miniature Schnauzer\", \"Giant Schnauzer\", \"Standard Schnauzer\", \"Scottish Terrier\", \"Tibetan Terrier\", \"Australian Silky Terrier\", \"Soft-coated Wheaten Terrier\", \"West Highland White Terrier\", \"Lhasa Apso\", \"Flat-Coated Retriever\", \"Curly-coated Retriever\", \"Golden Retriever\", \"Labrador Retriever\", \"Chesapeake Bay Retriever\", \"German Shorthaired Pointer\", \"Vizsla\", \"English Setter\", \"Irish Setter\", \"Gordon Setter\", \"Brittany dog\", \"Clumber Spaniel\", \"English Springer Spaniel\", \"Welsh Springer Spaniel\", \"Cocker Spaniel\", \"Sussex Spaniel\", \"Irish Water Spaniel\", \"Kuvasz\", \"Schipperke\", \"Groenendael dog\", \"Malinois\", \"Briard\", \"Australian Kelpie\", \"Komondor\", \"Old English Sheepdog\", \"Shetland Sheepdog\", \"collie\", \"Border Collie\", \"Bouvier des Flandres dog\", \"Rottweiler\", \"German Shepherd Dog\", \"Dobermann\", \"Miniature Pinscher\", \"Greater Swiss Mountain Dog\", \"Bernese Mountain Dog\", \"Appenzeller Sennenhund\", \"Entlebucher Sennenhund\", \"Boxer\", \"Bullmastiff\", \"Tibetan Mastiff\", \"French Bulldog\", \"Great Dane\", \"St. Bernard\", \"husky\", \"Alaskan Malamute\", \"Siberian Husky\", \"Dalmatian\", \"Affenpinscher\", \"Basenji\", \"pug\", \"Leonberger\", \"Newfoundland dog\", \"Great Pyrenees dog\", \"Samoyed\", \"Pomeranian\", \"Chow Chow\", \"Keeshond\", \"brussels griffon\", \"Pembroke Welsh Corgi\", \"Cardigan Welsh Corgi\", \"Toy Poodle\", \"Miniature Poodle\", \"Standard Poodle\", \"Mexican hairless dog (xoloitzcuintli)\", \"grey wolf\", \"Alaskan tundra wolf\", \"red wolf or maned wolf\", \"coyote\", \"dingo\", \"dhole\", \"African wild dog\", \"hyena\", \"red fox\", \"kit fox\", \"Arctic fox\", \"grey fox\", \"tabby cat\", \"tiger cat\", \"Persian cat\", \"Siamese cat\", \"Egyptian Mau\", \"cougar\", \"lynx\", \"leopard\", \"snow leopard\", \"jaguar\", \"lion\", \"tiger\", \"cheetah\", \"brown bear\", \"American black bear\", \"polar bear\", \"sloth bear\", \"mongoose\", \"meerkat\", \"tiger beetle\", \"ladybug\", \"ground beetle\", \"longhorn beetle\", \"leaf beetle\", \"dung beetle\", \"rhinoceros beetle\", \"weevil\", \"fly\", \"bee\", \"ant\", \"grasshopper\", \"cricket insect\", \"stick insect\", \"cockroach\", \"praying mantis\", \"cicada\", \"leafhopper\", \"lacewing\", \"dragonfly\", \"damselfly\", \"red admiral butterfly\", \"ringlet butterfly\", \"monarch butterfly\", \"small white butterfly\", \"sulphur butterfly\", \"gossamer-winged butterfly\", \"starfish\", \"sea urchin\", \"sea cucumber\", \"cottontail rabbit\", \"hare\", \"Angora rabbit\", \"hamster\", \"porcupine\", \"fox squirrel\", \"marmot\", \"beaver\", \"guinea pig\", \"common sorrel horse\", \"zebra\", \"pig\", \"wild boar\", \"warthog\", \"hippopotamus\", \"ox\", \"water buffalo\", \"bison\", \"ram (adult male sheep)\", \"bighorn sheep\", \"Alpine ibex\", \"hartebeest\", \"impala (antelope)\", \"gazelle\", \"arabian camel\", \"llama\", \"weasel\", \"mink\", \"European polecat\", \"black-footed ferret\", \"otter\", \"skunk\", \"badger\", \"armadillo\", \"three-toed sloth\", \"orangutan\", \"gorilla\", \"chimpanzee\", \"gibbon\", \"siamang\", \"guenon\", \"patas monkey\", \"baboon\", \"macaque\", \"langur\", \"black-and-white colobus\", \"proboscis monkey\", \"marmoset\", \"white-headed capuchin\", \"howler monkey\", \"titi monkey\", \"Geoffroy's spider monkey\", \"common squirrel monkey\", \"ring-tailed lemur\", \"indri\", \"Asian elephant\", \"African bush elephant\", \"red panda\", \"giant panda\", \"snoek fish\", \"eel\", \"silver salmon\", \"rock beauty fish\", \"clownfish\", \"sturgeon\", \"gar fish\", \"lionfish\", \"pufferfish\", \"abacus\", \"abaya\", \"academic gown\", \"accordion\", \"acoustic guitar\", \"aircraft carrier\", \"airliner\", \"airship\", \"altar\", \"ambulance\", \"amphibious vehicle\", \"analog clock\", \"apiary\", \"apron\", \"trash can\", \"assault rifle\", \"backpack\", \"bakery\", \"balance beam\", \"balloon\", \"ballpoint pen\", \"Band-Aid\", \"banjo\", \"baluster / handrail\", \"barbell\", \"barber chair\", \"barbershop\", \"barn\", \"barometer\", \"barrel\", \"wheelbarrow\", \"baseball\", \"basketball\", \"bassinet\", \"bassoon\", \"swimming cap\", \"bath towel\", \"bathtub\", \"station wagon\", \"lighthouse\", \"beaker\", \"military hat (bearskin or shako)\", \"beer bottle\", \"beer glass\", \"bell tower\", \"baby bib\", \"tandem bicycle\", \"bikini\", \"ring binder\", \"binoculars\", \"birdhouse\", \"boathouse\", \"bobsleigh\", \"bolo tie\", \"poke bonnet\", \"bookcase\", \"bookstore\", \"bottle cap\", \"hunting bow\", \"bow tie\", \"brass memorial plaque\", \"bra\", \"breakwater\", \"breastplate\", \"broom\", \"bucket\", \"buckle\", \"bulletproof vest\", \"high-speed train\", \"butcher shop\", \"taxicab\", \"cauldron\", \"candle\", \"cannon\", \"canoe\", \"can opener\", \"cardigan\", \"car mirror\", \"carousel\", \"tool kit\", \"cardboard box / carton\", \"car wheel\", \"automated teller machine\", \"cassette\", \"cassette player\", \"castle\", \"catamaran\", \"CD player\", \"cello\", \"mobile phone\", \"chain\", \"chain-link fence\", \"chain mail\", \"chainsaw\", \"storage chest\", \"chiffonier\", \"bell or wind chime\", \"china cabinet\", \"Christmas stocking\", \"church\", \"movie theater\", \"cleaver\", \"cliff dwelling\", \"cloak\", \"clogs\", \"cocktail shaker\", \"coffee mug\", \"coffeemaker\", \"spiral or coil\", \"combination lock\", \"computer keyboard\", \"candy store\", \"container ship\", \"convertible\", \"corkscrew\", \"cornet\", \"cowboy boot\", \"cowboy hat\", \"cradle\", \"construction crane\", \"crash helmet\", \"crate\", \"infant bed\", \"Crock Pot\", \"croquet ball\", \"crutch\", \"cuirass\", \"dam\", \"desk\", \"desktop computer\", \"rotary dial telephone\", \"diaper\", \"digital clock\", \"digital watch\", \"dining table\", \"dishcloth\", \"dishwasher\", \"disc brake\", \"dock\", \"dog sled\", \"dome\", \"doormat\", \"drilling rig\", \"drum\", \"drumstick\", \"dumbbell\", \"Dutch oven\", \"electric fan\", \"electric guitar\", \"electric locomotive\", \"entertainment center\", \"envelope\", \"espresso machine\", \"face powder\", \"feather boa\", \"filing cabinet\", \"fireboat\", \"fire truck\", \"fire screen\", \"flagpole\", \"flute\", \"folding chair\", \"football helmet\", \"forklift\", \"fountain\", \"fountain pen\", \"four-poster bed\", \"freight car\", \"French horn\", \"frying pan\", \"fur coat\", \"garbage truck\", \"gas mask or respirator\", \"gas pump\", \"goblet\", \"go-kart\", \"golf ball\", \"golf cart\", \"gondola\", \"gong\", \"gown\", \"grand piano\", \"greenhouse\", \"radiator grille\", \"grocery store\", \"guillotine\", \"hair clip\", \"hair spray\", \"half-track\", \"hammer\", \"hamper\", \"hair dryer\", \"hand-held computer\", \"handkerchief\", \"hard disk drive\", \"harmonica\", \"harp\", \"combine harvester\", \"hatchet\", \"holster\", \"home theater\", \"honeycomb\", \"hook\", \"hoop skirt\", \"gymnastic horizontal bar\", \"horse-drawn vehicle\", \"hourglass\", \"iPod\", \"clothes iron\", \"carved pumpkin\", \"jeans\", \"jeep\", \"T-shirt\", \"jigsaw puzzle\", \"rickshaw\", \"joystick\", \"kimono\", \"knee pad\", \"knot\", \"lab coat\", \"ladle\", \"lampshade\", \"laptop computer\", \"lawn mower\", \"lens cap\", \"letter opener\", \"library\", \"lifeboat\", \"lighter\", \"limousine\", \"ocean liner\", \"lipstick\", \"slip-on shoe\", \"lotion\", \"music speaker\", \"loupe magnifying glass\", \"sawmill\", \"magnetic compass\", \"messenger bag\", \"mailbox\", \"tights\", \"one-piece bathing suit\", \"manhole cover\", \"maraca\", \"marimba\", \"mask\", \"matchstick\", \"maypole\", \"maze\", \"measuring cup\", \"medicine cabinet\", \"megalith\", \"microphone\", \"microwave oven\", \"military uniform\", \"milk can\", \"minibus\", \"miniskirt\", \"minivan\", \"missile\", \"mitten\", \"mixing bowl\", \"mobile home\", \"ford model t\", \"modem\", \"monastery\", \"monitor\", \"moped\", \"mortar and pestle\", \"graduation cap\", \"mosque\", \"mosquito net\", \"vespa\", \"mountain bike\", \"tent\", \"computer mouse\", \"mousetrap\", \"moving van\", \"muzzle\", \"metal nail\", \"neck brace\", \"necklace\", \"baby pacifier\", \"notebook computer\", \"obelisk\", \"oboe\", \"ocarina\", \"odometer\", \"oil filter\", \"pipe organ\", \"oscilloscope\", \"overskirt\", \"bullock cart\", \"oxygen mask\", \"product packet / packaging\", \"paddle\", \"paddle wheel\", \"padlock\", \"paintbrush\", \"pajamas\", \"palace\", \"pan flute\", \"paper towel\", \"parachute\", \"parallel bars\", \"park bench\", \"parking meter\", \"railroad car\", \"patio\", \"payphone\", \"pedestal\", \"pencil case\", \"pencil sharpener\", \"perfume\", \"Petri dish\", \"photocopier\", \"plectrum\", \"Pickelhaube\", \"picket fence\", \"pickup truck\", \"pier\", \"piggy bank\", \"pill bottle\", \"pillow\", \"ping-pong ball\", \"pinwheel\", \"pirate ship\", \"drink pitcher\", \"block plane\", \"planetarium\", \"plastic bag\", \"plate rack\", \"farm plow\", \"plunger\", \"Polaroid camera\", \"pole\", \"police van\", \"poncho\", \"pool table\", \"soda bottle\", \"plant pot\", \"potter's wheel\", \"power drill\", \"prayer rug\", \"printer\", \"prison\", \"missile\", \"projector\", \"hockey puck\", \"punching bag\", \"purse\", \"quill\", \"quilt\", \"race car\", \"racket\", \"radiator\", \"radio\", \"radio telescope\", \"rain barrel\", \"recreational vehicle\", \"fishing casting reel\", \"reflex camera\", \"refrigerator\", \"remote control\", \"restaurant\", \"revolver\", \"rifle\", \"rocking chair\", \"rotisserie\", \"eraser\", \"rugby ball\", \"ruler measuring stick\", \"sneaker\", \"safe\", \"safety pin\", \"salt shaker\", \"sandal\", \"sarong\", \"saxophone\", \"scabbard\", \"weighing scale\", \"school bus\", \"schooner\", \"scoreboard\", \"CRT monitor\", \"screw\", \"screwdriver\", \"seat belt\", \"sewing machine\", \"shield\", \"shoe store\", \"shoji screen / room divider\", \"shopping basket\", \"shopping cart\", \"shovel\", \"shower cap\", \"shower curtain\", \"ski\", \"balaclava ski mask\", \"sleeping bag\", \"slide rule\", \"sliding door\", \"slot machine\", \"snorkel\", \"snowmobile\", \"snowplow\", \"soap dispenser\", \"soccer ball\", \"sock\", \"solar thermal collector\", \"sombrero\", \"soup bowl\", \"keyboard space bar\", \"space heater\", \"space shuttle\", \"spatula\", \"motorboat\", \"spider web\", \"spindle\", \"sports car\", \"spotlight\", \"stage\", \"steam locomotive\", \"through arch bridge\", \"steel drum\", \"stethoscope\", \"scarf\", \"stone wall\", \"stopwatch\", \"stove\", \"strainer\", \"tram\", \"stretcher\", \"couch\", \"stupa\", \"submarine\", \"suit\", \"sundial\", \"sunglasses\", \"sunglasses\", \"sunscreen\", \"suspension bridge\", \"mop\", \"sweatshirt\", \"swim trunks / shorts\", \"swing\", \"electrical switch\", \"syringe\", \"table lamp\", \"tank\", \"tape player\", \"teapot\", \"teddy bear\", \"television\", \"tennis ball\", \"thatched roof\", \"front curtain\", \"thimble\", \"threshing machine\", \"throne\", \"tile roof\", \"toaster\", \"tobacco shop\", \"toilet seat\", \"torch\", \"totem pole\", \"tow truck\", \"toy store\", \"tractor\", \"semi-trailer truck\", \"tray\", \"trench coat\", \"tricycle\", \"trimaran\", \"tripod\", \"triumphal arch\", \"trolleybus\", \"trombone\", \"hot tub\", \"turnstile\", \"typewriter keyboard\", \"umbrella\", \"unicycle\", \"upright piano\", \"vacuum cleaner\", \"vase\", \"vaulted or arched ceiling\", \"velvet fabric\", \"vending machine\", \"vestment\", \"viaduct\", \"violin\", \"volleyball\", \"waffle iron\", \"wall clock\", \"wallet\", \"wardrobe\", \"military aircraft\", \"sink\", \"washing machine\", \"water bottle\", \"water jug\", \"water tower\", \"whiskey jug\", \"whistle\", \"hair wig\", \"window screen\", \"window shade\", \"Windsor tie\", \"wine bottle\", \"airplane wing\", \"wok\", \"wooden spoon\", \"wool\", \"split-rail fence\", \"shipwreck\", \"sailboat\", \"yurt\", \"website\", \"comic book\", \"crossword\", \"traffic or street sign\", \"traffic light\", \"dust jacket\", \"menu\", \"plate\", \"guacamole\", \"consomme\", \"hot pot\", \"trifle\", \"ice cream\", \"popsicle\", \"baguette\", \"bagel\", \"pretzel\", \"cheeseburger\", \"hot dog\", \"mashed potatoes\", \"cabbage\", \"broccoli\", \"cauliflower\", \"zucchini\", \"spaghetti squash\", \"acorn squash\", \"butternut squash\", \"cucumber\", \"artichoke\", \"bell pepper\", \"cardoon\", \"mushroom\", \"Granny Smith apple\", \"strawberry\", \"orange\", \"lemon\", \"fig\", \"pineapple\", \"banana\", \"jackfruit\", \"cherimoya (custard apple)\", \"pomegranate\", \"hay\", \"carbonara\", \"chocolate syrup\", \"dough\", \"meatloaf\", \"pizza\", \"pot pie\", \"burrito\", \"red wine\", \"espresso\", \"tea cup\", \"eggnog\", \"mountain\", \"bubble\", \"cliff\", \"coral reef\", \"geyser\", \"lakeshore\", \"promontory\", \"sandbar\", \"beach\", \"valley\", \"volcano\", \"baseball player\", \"bridegroom\", \"scuba diver\", \"rapeseed\", \"daisy\", \"yellow lady's slipper\", \"corn\", \"acorn\", \"rose hip\", \"horse chestnut seed\", \"coral fungus\", \"agaric\", \"gyromitra\", \"stinkhorn mushroom\", \"earth star fungus\", \"hen of the woods mushroom\", \"bolete\", \"corn cob\", \"toilet paper\"]" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eMQSCuBta2G6" + }, + "source": [ + "A subset of these class names are modified from the default ImageNet class names sourced from Anish Athalye's imagenet-simple-labels.\n", + "\n", + "These edits were made via trial and error and concentrated on the lowest performing classes according to top_1 and top_5 accuracy on the ImageNet training set for the RN50, RN101, and RN50x4 models. These tweaks improve top_1 by 1.5% on ViT-B/32 over using the default class names. Alec got bored somewhere along the way as gains started to diminish and never finished updating / tweaking the list. He also didn't revisit this with the better performing RN50x16, RN50x64, or any of the ViT models. He thinks it's likely another 0.5% to 1% top_1 could be gained from further work here. It'd be interesting to more rigorously study / understand this.\n", + "\n", + "Some examples beyond the crane/crane -> construction crane / bird crane issue mentioned in Section 3.1.4 of the paper include:\n", + "\n", + "- CLIP interprets \"nail\" as \"fingernail\" so we changed the label to \"metal nail\".\n", + "- ImageNet kite class refers to the bird of prey, not the flying toy, so we changed \"kite\" to \"kite (bird of prey)\"\n", + "- The ImageNet class for red wolf seems to include a lot of mislabeled maned wolfs so we changed \"red wolf\" to \"red wolf or maned wolf\"" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "toGtcd-Ji_MD", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b6eb0753-2bee-4144-abe3-fbd23f35f555" + }, + "source": [ + "imagenet_templates = [\n", + " 'a bad photo of a {}.',\n", + " 'a photo of many {}.',\n", + " 'a sculpture of a {}.',\n", + " 'a photo of the hard to see {}.',\n", + " 'a low resolution photo of the {}.',\n", + " 'a rendering of a {}.',\n", + " 'graffiti of a {}.',\n", + " 'a bad photo of the {}.',\n", + " 'a cropped photo of the {}.',\n", + " 'a tattoo of a {}.',\n", + " 'the embroidered {}.',\n", + " 'a photo of a hard to see {}.',\n", + " 'a bright photo of a {}.',\n", + " 'a photo of a clean {}.',\n", + " 'a photo of a dirty {}.',\n", + " 'a dark photo of the {}.',\n", + " 'a drawing of a {}.',\n", + " 'a photo of my {}.',\n", + " 'the plastic {}.',\n", + " 'a photo of the cool {}.',\n", + " 'a close-up photo of a {}.',\n", + " 'a black and white photo of the {}.',\n", + " 'a painting of the {}.',\n", + " 'a painting of a {}.',\n", + " 'a pixelated photo of the {}.',\n", + " 'a sculpture of the {}.',\n", + " 'a bright photo of the {}.',\n", + " 'a cropped photo of a {}.',\n", + " 'a plastic {}.',\n", + " 'a photo of the dirty {}.',\n", + " 'a jpeg corrupted photo of a {}.',\n", + " 'a blurry photo of the {}.',\n", + " 'a photo of the {}.',\n", + " 'a good photo of the {}.',\n", + " 'a rendering of the {}.',\n", + " 'a {} in a video game.',\n", + " 'a photo of one {}.',\n", + " 'a doodle of a {}.',\n", + " 'a close-up photo of the {}.',\n", + " 'a photo of a {}.',\n", + " 'the origami {}.',\n", + " 'the {} in a video game.',\n", + " 'a sketch of a {}.',\n", + " 'a doodle of the {}.',\n", + " 'a origami {}.',\n", + " 'a low resolution photo of a {}.',\n", + " 'the toy {}.',\n", + " 'a rendition of the {}.',\n", + " 'a photo of the clean {}.',\n", + " 'a photo of a large {}.',\n", + " 'a rendition of a {}.',\n", + " 'a photo of a nice {}.',\n", + " 'a photo of a weird {}.',\n", + " 'a blurry photo of a {}.',\n", + " 'a cartoon {}.',\n", + " 'art of a {}.',\n", + " 'a sketch of the {}.',\n", + " 'a embroidered {}.',\n", + " 'a pixelated photo of a {}.',\n", + " 'itap of the {}.',\n", + " 'a jpeg corrupted photo of the {}.',\n", + " 'a good photo of a {}.',\n", + " 'a plushie {}.',\n", + " 'a photo of the nice {}.',\n", + " 'a photo of the small {}.',\n", + " 'a photo of the weird {}.',\n", + " 'the cartoon {}.',\n", + " 'art of the {}.',\n", + " 'a drawing of the {}.',\n", + " 'a photo of the large {}.',\n", + " 'a black and white photo of a {}.',\n", + " 'the plushie {}.',\n", + " 'a dark photo of a {}.',\n", + " 'itap of a {}.',\n", + " 'graffiti of the {}.',\n", + " 'a toy {}.',\n", + " 'itap of my {}.',\n", + " 'a photo of a cool {}.',\n", + " 'a photo of a small {}.',\n", + " 'a tattoo of the {}.',\n", + "]\n", + "\n", + "print(f\"{len(imagenet_classes)} classes, {len(imagenet_templates)} templates\")" + ], + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "text": [ + "1000 classes, 80 templates\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aRB5OzgpHwqQ" + }, + "source": [ + "A similar, intuition-guided trial and error based on the ImageNet training set was used for templates. This list is pretty haphazard and was gradually made / expanded over the course of about a year of the project and was revisited / tweaked every few months. A surprising / weird thing was adding templates intended to help ImageNet-R performance (specifying different possible renditions of an object) improved standard ImageNet accuracy too.\n", + "\n", + "After the 80 templates were \"locked\" for the paper, we ran sequential forward selection over the list of 80 templates. The search terminated after ensembling 7 templates and selected them in the order below.\n", + "\n", + "1. itap of a {}.\n", + "2. a bad photo of the {}.\n", + "3. a origami {}.\n", + "4. a photo of the large {}.\n", + "5. a {} in a video game.\n", + "6. art of the {}.\n", + "7. a photo of the small {}.\n", + "\n", + "Speculating, we think it's interesting to see different scales (large and small), a difficult view (a bad photo), and \"abstract\" versions (origami, video game, art), were all selected for, but we haven't studied this in any detail. This subset performs a bit better than the full 80 ensemble reported in the paper, especially for the smaller models." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4W8ARJVqBJXs" + }, + "source": [ + "# Loading the Images\n", + "\n", + "The ILSVRC2012 datasets are no longer available for download publicly. We instead download the ImageNet-V2 dataset by [Recht et al.](https://arxiv.org/abs/1902.10811).\n", + "\n", + "If you have the ImageNet dataset downloaded, you can replace the dataset with the official torchvision loader, e.g.:\n", + "\n", + "```python\n", + "images = torchvision.datasets.ImageNet(\"path/to/imagenet\", split='val', transform=preprocess)\n", + "```" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "moHR4UlHKsDc", + "outputId": "40731297-edc7-4cd0-be75-ed426c8fb005" + }, + "source": [ + "! pip install git+https://github.com/modestyachts/ImageNetV2_pytorch\n", + "\n", + "from imagenetv2_pytorch import ImageNetV2Dataset\n", + "\n", + "images = ImageNetV2Dataset(transform=preprocess)\n", + "loader = torch.utils.data.DataLoader(images, batch_size=32, num_workers=2)" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/modestyachts/ImageNetV2_pytorch\n", + " Cloning https://github.com/modestyachts/ImageNetV2_pytorch to /tmp/pip-req-build-0kih0kn2\n", + " Running command git clone -q https://github.com/modestyachts/ImageNetV2_pytorch /tmp/pip-req-build-0kih0kn2\n", + "Building wheels for collected packages: imagenetv2-pytorch\n", + " Building wheel for imagenetv2-pytorch (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for imagenetv2-pytorch: filename=imagenetv2_pytorch-0.1-py3-none-any.whl size=2663 sha256=ac31e0ed9c61afc5e0271eed315d3a82844a79ae64f8ce43fc1c98928cec129f\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-745b5n1m/wheels/ab/ee/f4/73bce5c7f68d28ce632ef33ae87ce60aaca021eb2b3b31a6fa\n", + "Successfully built imagenetv2-pytorch\n", + "Installing collected packages: imagenetv2-pytorch\n", + "Successfully installed imagenetv2-pytorch-0.1\n", + "Dataset matched-frequency not found on disk, downloading....\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "100%|██████████| 1.26G/1.26G [01:02<00:00, 20.2MiB/s]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Extracting....\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fz6D-F-Wbrtp" + }, + "source": [ + "# Creating zero-shot classifier weights" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 67, + "referenced_widgets": [ + "66a1639713ae441d8a9b873381f9d774", + "610b775178c645e2b4663b77cc0c67b6", + "412dd15f0d8542f5ab2730f8616fb582", + "5e6315f36b4e4eeea5c6294b024e0c97", + "085d5388abda4202bfa66d0c088452f8", + "f75124b64aa147c693c67a78f8e3a231", + "6e5676a054874243b55fc6d120a07d01", + "dc6d1416c01a4047935ee15c3fd2eb1c" + ] + }, + "id": "sRqDoz1Gbsii", + "outputId": "312b8ebf-3961-4903-d8cb-3b7a94cc97b6" + }, + "source": [ + "def zeroshot_classifier(classnames, templates):\n", + " with torch.no_grad():\n", + " zeroshot_weights = []\n", + " for classname in tqdm(classnames):\n", + " texts = [template.format(classname) for template in templates] #format with class\n", + " texts = clip.tokenize(texts).cuda() #tokenize\n", + " class_embeddings = model.encode_text(texts) #embed with text encoder\n", + " class_embeddings /= class_embeddings.norm(dim=-1, keepdim=True)\n", + " class_embedding = class_embeddings.mean(dim=0)\n", + " class_embedding /= class_embedding.norm()\n", + " zeroshot_weights.append(class_embedding)\n", + " zeroshot_weights = torch.stack(zeroshot_weights, dim=1).cuda()\n", + " return zeroshot_weights\n", + "\n", + "\n", + "zeroshot_weights = zeroshot_classifier(imagenet_classes, imagenet_templates)" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "66a1639713ae441d8a9b873381f9d774", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=1000.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1fZo7hG8iJP5" + }, + "source": [ + "# Zero-shot prediction" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "j4kPSZoShQxN" + }, + "source": [ + "def accuracy(output, target, topk=(1,)):\n", + " pred = output.topk(max(topk), 1, True, True)[1].t()\n", + " correct = pred.eq(target.view(1, -1).expand_as(pred))\n", + " return [float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy()) for k in topk]" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102, + "referenced_widgets": [ + "84f80a7f3e764346969a347b0f71b24e", + "392656f01b2945f3bd7903783ed8cc96", + "8e47a435519b4ce090879b4be2f61f99", + "41b1ed6b0a9745c1a595377670b15ff4", + "179b8ae1eb7f4a828f953e889b141725", + "d8708e8414fd44f4abd6590c9b57996f", + "800e30f5b4f24475a2b0046da0703631", + "8764308b948745f1a677332fd21fcaf0" + ] + }, + "id": "wKJ7YsdlkDXo", + "outputId": "ab824854-38e4-4d37-ad40-2a7ce3c5fd43" + }, + "source": [ + "with torch.no_grad():\n", + " top1, top5, n = 0., 0., 0.\n", + " for i, (images, target) in enumerate(tqdm(loader)):\n", + " images = images.cuda()\n", + " target = target.cuda()\n", + " \n", + " # predict\n", + " image_features = model.encode_image(images)\n", + " image_features /= image_features.norm(dim=-1, keepdim=True)\n", + " logits = 100. * image_features @ zeroshot_weights\n", + "\n", + " # measure accuracy\n", + " acc1, acc5 = accuracy(logits, target, topk=(1, 5))\n", + " top1 += acc1\n", + " top5 += acc5\n", + " n += images.size(0)\n", + "\n", + "top1 = (top1 / n) * 100\n", + "top5 = (top5 / n) * 100 \n", + "\n", + "print(f\"Top-1 accuracy: {top1:.2f}\")\n", + "print(f\"Top-5 accuracy: {top5:.2f}\")" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84f80a7f3e764346969a347b0f71b24e", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=313.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n", + "Top-1 accuracy: 55.93\n", + "Top-5 accuracy: 83.36\n" + ], + "name": "stdout" + } + ] + } + ] +} diff --git a/src/CLIP/requirements.txt b/src/CLIP/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..6b98c33f3a0e09ddf982606430472de3061c6e9f --- /dev/null +++ b/src/CLIP/requirements.txt @@ -0,0 +1,5 @@ +ftfy +regex +tqdm +torch +torchvision diff --git a/src/CLIP/setup.py b/src/CLIP/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..c9ea7d0d2f3d2fcf66d6f6e2aa0eb1a97a524bb6 --- /dev/null +++ b/src/CLIP/setup.py @@ -0,0 +1,21 @@ +import os + +import pkg_resources +from setuptools import setup, find_packages + +setup( + name="clip", + py_modules=["clip"], + version="1.0", + description="", + author="OpenAI", + packages=find_packages(exclude=["tests*"]), + install_requires=[ + str(r) + for r in pkg_resources.parse_requirements( + open(os.path.join(os.path.dirname(__file__), "requirements.txt")) + ) + ], + include_package_data=True, + extras_require={'dev': ['pytest']}, +) diff --git a/src/CLIP/tests/test_consistency.py b/src/CLIP/tests/test_consistency.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c6fd4fe9074143803e0eb6c99fa02a47632094 --- /dev/null +++ b/src/CLIP/tests/test_consistency.py @@ -0,0 +1,25 @@ +import numpy as np +import pytest +import torch +from PIL import Image + +import clip + + +@pytest.mark.parametrize('model_name', clip.available_models()) +def test_consistency(model_name): + device = "cpu" + jit_model, transform = clip.load(model_name, device=device, jit=True) + py_model, _ = clip.load(model_name, device=device, jit=False) + + image = transform(Image.open("CLIP.png")).unsqueeze(0).to(device) + text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device) + + with torch.no_grad(): + logits_per_image, _ = jit_model(image, text) + jit_probs = logits_per_image.softmax(dim=-1).cpu().numpy() + + logits_per_image, _ = py_model(image, text) + py_probs = logits_per_image.softmax(dim=-1).cpu().numpy() + + assert np.allclose(jit_probs, py_probs, atol=0.01, rtol=0.1) diff --git a/src/taming-transformers/License.txt b/src/taming-transformers/License.txt new file mode 100644 index 0000000000000000000000000000000000000000..57fb4153bafcd64b60377ba0ba2c79b7530efc1e --- /dev/null +++ b/src/taming-transformers/License.txt @@ -0,0 +1,19 @@ +Copyright (c) 2020 Patrick Esser and Robin Rombach and Björn Ommer + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +OR OTHER DEALINGS IN THE SOFTWARE./ diff --git a/src/taming-transformers/README.md b/src/taming-transformers/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d295fbf75703e6cd285330432785b8cdea072ba7 --- /dev/null +++ b/src/taming-transformers/README.md @@ -0,0 +1,410 @@ +# Taming Transformers for High-Resolution Image Synthesis +##### CVPR 2021 (Oral) +![teaser](assets/mountain.jpeg) + +[**Taming Transformers for High-Resolution Image Synthesis**](https://compvis.github.io/taming-transformers/)
+[Patrick Esser](https://github.com/pesser)\*, +[Robin Rombach](https://github.com/rromb)\*, +[Björn Ommer](https://hci.iwr.uni-heidelberg.de/Staff/bommer)
+\* equal contribution + +**tl;dr** We combine the efficiancy of convolutional approaches with the expressivity of transformers by introducing a convolutional VQGAN, which learns a codebook of context-rich visual parts, whose composition is modeled with an autoregressive transformer. + +![teaser](assets/teaser.png) +[arXiv](https://arxiv.org/abs/2012.09841) | [BibTeX](#bibtex) | [Project Page](https://compvis.github.io/taming-transformers/) + + +### News +#### 2022 +- More pretrained VQGANs (e.g. a f8-model with only 256 codebook entries) are available in our new work on [Latent Diffusion Models](https://github.com/CompVis/latent-diffusion). +- Added scene synthesis models as proposed in the paper [High-Resolution Complex Scene Synthesis with Transformers](https://arxiv.org/abs/2105.06458), see [this section](#scene-image-synthesis). +#### 2021 +- Thanks to [rom1504](https://github.com/rom1504) it is now easy to [train a VQGAN on your own datasets](#training-on-custom-data). +- Included a bugfix for the quantizer. For backward compatibility it is + disabled by default (which corresponds to always training with `beta=1.0`). + Use `legacy=False` in the quantizer config to enable it. + Thanks [richcmwang](https://github.com/richcmwang) and [wcshin-git](https://github.com/wcshin-git)! +- Our paper received an update: See https://arxiv.org/abs/2012.09841v3 and the corresponding changelog. +- Added a pretrained, [1.4B transformer model](https://k00.fr/s511rwcv) trained for class-conditional ImageNet synthesis, which obtains state-of-the-art FID scores among autoregressive approaches and outperforms BigGAN. +- Added pretrained, unconditional models on [FFHQ](https://k00.fr/yndvfu95) and [CelebA-HQ](https://k00.fr/2xkmielf). +- Added accelerated sampling via caching of keys/values in the self-attention operation, used in `scripts/sample_fast.py`. +- Added a checkpoint of a [VQGAN](https://heibox.uni-heidelberg.de/d/2e5662443a6b4307b470/) trained with f8 compression and Gumbel-Quantization. + See also our updated [reconstruction notebook](https://colab.research.google.com/github/CompVis/taming-transformers/blob/master/scripts/reconstruction_usage.ipynb). +- We added a [colab notebook](https://colab.research.google.com/github/CompVis/taming-transformers/blob/master/scripts/reconstruction_usage.ipynb) which compares two VQGANs and OpenAI's [DALL-E](https://github.com/openai/DALL-E). See also [this section](#more-resources). +- We now include an overview of pretrained models in [Tab.1](#overview-of-pretrained-models). We added models for [COCO](#coco) and [ADE20k](#ade20k). +- The streamlit demo now supports image completions. +- We now include a couple of examples from the D-RIN dataset so you can run the + [D-RIN demo](#d-rin) without preparing the dataset first. +- You can now jump right into sampling with our [Colab quickstart notebook](https://colab.research.google.com/github/CompVis/taming-transformers/blob/master/scripts/taming-transformers.ipynb). + +## Requirements +A suitable [conda](https://conda.io/) environment named `taming` can be created +and activated with: + +``` +conda env create -f environment.yaml +conda activate taming +``` +## Overview of pretrained models +The following table provides an overview of all models that are currently available. +FID scores were evaluated using [torch-fidelity](https://github.com/toshas/torch-fidelity). +For reference, we also include a link to the recently released autoencoder of the [DALL-E](https://github.com/openai/DALL-E) model. +See the corresponding [colab +notebook](https://colab.research.google.com/github/CompVis/taming-transformers/blob/master/scripts/reconstruction_usage.ipynb) +for a comparison and discussion of reconstruction capabilities. + +| Dataset | FID vs train | FID vs val | Link | Samples (256x256) | Comments +| ------------- | ------------- | ------------- |------------- | ------------- |------------- | +| FFHQ (f=16) | 9.6 | -- | [ffhq_transformer](https://k00.fr/yndvfu95) | [ffhq_samples](https://k00.fr/j626x093) | +| CelebA-HQ (f=16) | 10.2 | -- | [celebahq_transformer](https://k00.fr/2xkmielf) | [celebahq_samples](https://k00.fr/j626x093) | +| ADE20K (f=16) | -- | 35.5 | [ade20k_transformer](https://k00.fr/ot46cksa) | [ade20k_samples.zip](https://heibox.uni-heidelberg.de/f/70bb78cbaf844501b8fb/) [2k] | evaluated on val split (2k images) +| COCO-Stuff (f=16) | -- | 20.4 | [coco_transformer](https://k00.fr/2zz6i2ce) | [coco_samples.zip](https://heibox.uni-heidelberg.de/f/a395a9be612f4a7a8054/) [5k] | evaluated on val split (5k images) +| ImageNet (cIN) (f=16) | 15.98/15.78/6.59/5.88/5.20 | -- | [cin_transformer](https://k00.fr/s511rwcv) | [cin_samples](https://k00.fr/j626x093) | different decoding hyperparameters | +| | | | || | +| FacesHQ (f=16) | -- | -- | [faceshq_transformer](https://k00.fr/qqfl2do8) +| S-FLCKR (f=16) | -- | -- | [sflckr](https://heibox.uni-heidelberg.de/d/73487ab6e5314cb5adba/) +| D-RIN (f=16) | -- | -- | [drin_transformer](https://k00.fr/39jcugc5) +| | | | | || | +| VQGAN ImageNet (f=16), 1024 | 10.54 | 7.94 | [vqgan_imagenet_f16_1024](https://heibox.uni-heidelberg.de/d/8088892a516d4e3baf92/) | [reconstructions](https://k00.fr/j626x093) | Reconstruction-FIDs. +| VQGAN ImageNet (f=16), 16384 | 7.41 | 4.98 |[vqgan_imagenet_f16_16384](https://heibox.uni-heidelberg.de/d/a7530b09fed84f80a887/) | [reconstructions](https://k00.fr/j626x093) | Reconstruction-FIDs. +| VQGAN OpenImages (f=8), 256 | -- | 1.49 |https://ommer-lab.com/files/latent-diffusion/vq-f8-n256.zip | --- | Reconstruction-FIDs. Available via [latent diffusion](https://github.com/CompVis/latent-diffusion). +| VQGAN OpenImages (f=8), 16384 | -- | 1.14 |https://ommer-lab.com/files/latent-diffusion/vq-f8.zip | --- | Reconstruction-FIDs. Available via [latent diffusion](https://github.com/CompVis/latent-diffusion) +| VQGAN OpenImages (f=8), 8192, GumbelQuantization | 3.24 | 1.49 |[vqgan_gumbel_f8](https://heibox.uni-heidelberg.de/d/2e5662443a6b4307b470/) | --- | Reconstruction-FIDs. +| | | | | || | +| DALL-E dVAE (f=8), 8192, GumbelQuantization | 33.88 | 32.01 | https://github.com/openai/DALL-E | [reconstructions](https://k00.fr/j626x093) | Reconstruction-FIDs. + + +## Running pretrained models + +The commands below will start a streamlit demo which supports sampling at +different resolutions and image completions. To run a non-interactive version +of the sampling process, replace `streamlit run scripts/sample_conditional.py --` +by `python scripts/make_samples.py --outdir ` and +keep the remaining command line arguments. + +To sample from unconditional or class-conditional models, +run `python scripts/sample_fast.py -r `. +We describe below how to use this script to sample from the ImageNet, FFHQ, and CelebA-HQ models, +respectively. + +### S-FLCKR +![teaser](assets/sunset_and_ocean.jpg) + +You can also [run this model in a Colab +notebook](https://colab.research.google.com/github/CompVis/taming-transformers/blob/master/scripts/taming-transformers.ipynb), +which includes all necessary steps to start sampling. + +Download the +[2020-11-09T13-31-51_sflckr](https://heibox.uni-heidelberg.de/d/73487ab6e5314cb5adba/) +folder and place it into `logs`. Then, run +``` +streamlit run scripts/sample_conditional.py -- -r logs/2020-11-09T13-31-51_sflckr/ +``` + +### ImageNet +![teaser](assets/imagenet.png) + +Download the [2021-04-03T19-39-50_cin_transformer](https://k00.fr/s511rwcv) +folder and place it into logs. Sampling from the class-conditional ImageNet +model does not require any data preparation. To produce 50 samples for each of +the 1000 classes of ImageNet, with k=600 for top-k sampling, p=0.92 for nucleus +sampling and temperature t=1.0, run + +``` +python scripts/sample_fast.py -r logs/2021-04-03T19-39-50_cin_transformer/ -n 50 -k 600 -t 1.0 -p 0.92 --batch_size 25 +``` + +To restrict the model to certain classes, provide them via the `--classes` argument, separated by +commas. For example, to sample 50 *ostriches*, *border collies* and *whiskey jugs*, run + +``` +python scripts/sample_fast.py -r logs/2021-04-03T19-39-50_cin_transformer/ -n 50 -k 600 -t 1.0 -p 0.92 --batch_size 25 --classes 9,232,901 +``` +We recommended to experiment with the autoregressive decoding parameters (top-k, top-p and temperature) for best results. + +### FFHQ/CelebA-HQ + +Download the [2021-04-23T18-19-01_ffhq_transformer](https://k00.fr/yndvfu95) and +[2021-04-23T18-11-19_celebahq_transformer](https://k00.fr/2xkmielf) +folders and place them into logs. +Again, sampling from these unconditional models does not require any data preparation. +To produce 50000 samples, with k=250 for top-k sampling, +p=1.0 for nucleus sampling and temperature t=1.0, run + +``` +python scripts/sample_fast.py -r logs/2021-04-23T18-19-01_ffhq_transformer/ +``` +for FFHQ and + +``` +python scripts/sample_fast.py -r logs/2021-04-23T18-11-19_celebahq_transformer/ +``` +to sample from the CelebA-HQ model. +For both models it can be advantageous to vary the top-k/top-p parameters for sampling. + +### FacesHQ +![teaser](assets/faceshq.jpg) + +Download [2020-11-13T21-41-45_faceshq_transformer](https://k00.fr/qqfl2do8) and +place it into `logs`. Follow the data preparation steps for +[CelebA-HQ](#celeba-hq) and [FFHQ](#ffhq). Run +``` +streamlit run scripts/sample_conditional.py -- -r logs/2020-11-13T21-41-45_faceshq_transformer/ +``` + +### D-RIN +![teaser](assets/drin.jpg) + +Download [2020-11-20T12-54-32_drin_transformer](https://k00.fr/39jcugc5) and +place it into `logs`. To run the demo on a couple of example depth maps +included in the repository, run + +``` +streamlit run scripts/sample_conditional.py -- -r logs/2020-11-20T12-54-32_drin_transformer/ --ignore_base_data data="{target: main.DataModuleFromConfig, params: {batch_size: 1, validation: {target: taming.data.imagenet.DRINExamples}}}" +``` + +To run the demo on the complete validation set, first follow the data preparation steps for +[ImageNet](#imagenet) and then run +``` +streamlit run scripts/sample_conditional.py -- -r logs/2020-11-20T12-54-32_drin_transformer/ +``` + +### COCO +Download [2021-01-20T16-04-20_coco_transformer](https://k00.fr/2zz6i2ce) and +place it into `logs`. To run the demo on a couple of example segmentation maps +included in the repository, run + +``` +streamlit run scripts/sample_conditional.py -- -r logs/2021-01-20T16-04-20_coco_transformer/ --ignore_base_data data="{target: main.DataModuleFromConfig, params: {batch_size: 1, validation: {target: taming.data.coco.Examples}}}" +``` + +### ADE20k +Download [2020-11-20T21-45-44_ade20k_transformer](https://k00.fr/ot46cksa) and +place it into `logs`. To run the demo on a couple of example segmentation maps +included in the repository, run + +``` +streamlit run scripts/sample_conditional.py -- -r logs/2020-11-20T21-45-44_ade20k_transformer/ --ignore_base_data data="{target: main.DataModuleFromConfig, params: {batch_size: 1, validation: {target: taming.data.ade20k.Examples}}}" +``` + +## Scene Image Synthesis +![teaser](assets/scene_images_samples.svg) +Scene image generation based on bounding box conditionals as done in our CVPR2021 AI4CC workshop paper [High-Resolution Complex Scene Synthesis with Transformers](https://arxiv.org/abs/2105.06458) (see talk on [workshop page](https://visual.cs.brown.edu/workshops/aicc2021/#awards)). Supporting the datasets COCO and Open Images. + +### Training +Download first-stage models [COCO-8k-VQGAN](https://heibox.uni-heidelberg.de/f/78dea9589974474c97c1/) for COCO or [COCO/Open-Images-8k-VQGAN](https://heibox.uni-heidelberg.de/f/461d9a9f4fcf48ab84f4/) for Open Images. +Change `ckpt_path` in `data/coco_scene_images_transformer.yaml` and `data/open_images_scene_images_transformer.yaml` to point to the downloaded first-stage models. +Download the full COCO/OI datasets and adapt `data_path` in the same files, unless working with the 100 files provided for training and validation suits your needs already. + +Code can be run with +`python main.py --base configs/coco_scene_images_transformer.yaml -t True --gpus 0,` +or +`python main.py --base configs/open_images_scene_images_transformer.yaml -t True --gpus 0,` + +### Sampling +Train a model as described above or download a pre-trained model: + - [Open Images 1 billion parameter model](https://drive.google.com/file/d/1FEK-Z7hyWJBvFWQF50pzSK9y1W_CJEig/view?usp=sharing) available that trained 100 epochs. On 256x256 pixels, FID 41.48±0.21, SceneFID 14.60±0.15, Inception Score 18.47±0.27. The model was trained with 2d crops of images and is thus well-prepared for the task of generating high-resolution images, e.g. 512x512. + - [Open Images distilled version of the above model with 125 million parameters](https://drive.google.com/file/d/1xf89g0mc78J3d8Bx5YhbK4tNRNlOoYaO) allows for sampling on smaller GPUs (4 GB is enough for sampling 256x256 px images). Model was trained for 60 epochs with 10% soft loss, 90% hard loss. On 256x256 pixels, FID 43.07±0.40, SceneFID 15.93±0.19, Inception Score 17.23±0.11. + - [COCO 30 epochs](https://heibox.uni-heidelberg.de/f/0d0b2594e9074c7e9a33/) + - [COCO 60 epochs](https://drive.google.com/file/d/1bInd49g2YulTJBjU32Awyt5qnzxxG5U9/) (find model statistics for both COCO versions in `assets/coco_scene_images_training.svg`) + +When downloading a pre-trained model, remember to change `ckpt_path` in `configs/*project.yaml` to point to your downloaded first-stage model (see ->Training). + +Scene image generation can be run with +`python scripts/make_scene_samples.py --outdir=/some/outdir -r /path/to/pretrained/model --resolution=512,512` + + +## Training on custom data + +Training on your own dataset can be beneficial to get better tokens and hence better images for your domain. +Those are the steps to follow to make this work: +1. install the repo with `conda env create -f environment.yaml`, `conda activate taming` and `pip install -e .` +1. put your .jpg files in a folder `your_folder` +2. create 2 text files a `xx_train.txt` and `xx_test.txt` that point to the files in your training and test set respectively (for example `find $(pwd)/your_folder -name "*.jpg" > train.txt`) +3. adapt `configs/custom_vqgan.yaml` to point to these 2 files +4. run `python main.py --base configs/custom_vqgan.yaml -t True --gpus 0,1` to + train on two GPUs. Use `--gpus 0,` (with a trailing comma) to train on a single GPU. + +## Data Preparation + +### ImageNet +The code will try to download (through [Academic +Torrents](http://academictorrents.com/)) and prepare ImageNet the first time it +is used. However, since ImageNet is quite large, this requires a lot of disk +space and time. If you already have ImageNet on your disk, you can speed things +up by putting the data into +`${XDG_CACHE}/autoencoders/data/ILSVRC2012_{split}/data/` (which defaults to +`~/.cache/autoencoders/data/ILSVRC2012_{split}/data/`), where `{split}` is one +of `train`/`validation`. It should have the following structure: + +``` +${XDG_CACHE}/autoencoders/data/ILSVRC2012_{split}/data/ +├── n01440764 +│ ├── n01440764_10026.JPEG +│ ├── n01440764_10027.JPEG +│ ├── ... +├── n01443537 +│ ├── n01443537_10007.JPEG +│ ├── n01443537_10014.JPEG +│ ├── ... +├── ... +``` + +If you haven't extracted the data, you can also place +`ILSVRC2012_img_train.tar`/`ILSVRC2012_img_val.tar` (or symlinks to them) into +`${XDG_CACHE}/autoencoders/data/ILSVRC2012_train/` / +`${XDG_CACHE}/autoencoders/data/ILSVRC2012_validation/`, which will then be +extracted into above structure without downloading it again. Note that this +will only happen if neither a folder +`${XDG_CACHE}/autoencoders/data/ILSVRC2012_{split}/data/` nor a file +`${XDG_CACHE}/autoencoders/data/ILSVRC2012_{split}/.ready` exist. Remove them +if you want to force running the dataset preparation again. + +You will then need to prepare the depth data using +[MiDaS](https://github.com/intel-isl/MiDaS). Create a symlink +`data/imagenet_depth` pointing to a folder with two subfolders `train` and +`val`, each mirroring the structure of the corresponding ImageNet folder +described above and containing a `png` file for each of ImageNet's `JPEG` +files. The `png` encodes `float32` depth values obtained from MiDaS as RGBA +images. We provide the script `scripts/extract_depth.py` to generate this data. +**Please note** that this script uses [MiDaS via PyTorch +Hub](https://pytorch.org/hub/intelisl_midas_v2/). When we prepared the data, +the hub provided the [MiDaS +v2.0](https://github.com/intel-isl/MiDaS/releases/tag/v2) version, but now it +provides a v2.1 version. We haven't tested our models with depth maps obtained +via v2.1 and if you want to make sure that things work as expected, you must +adjust the script to make sure it explicitly uses +[v2.0](https://github.com/intel-isl/MiDaS/releases/tag/v2)! + +### CelebA-HQ +Create a symlink `data/celebahq` pointing to a folder containing the `.npy` +files of CelebA-HQ (instructions to obtain them can be found in the [PGGAN +repository](https://github.com/tkarras/progressive_growing_of_gans)). + +### FFHQ +Create a symlink `data/ffhq` pointing to the `images1024x1024` folder obtained +from the [FFHQ repository](https://github.com/NVlabs/ffhq-dataset). + +### S-FLCKR +Unfortunately, we are not allowed to distribute the images we collected for the +S-FLCKR dataset and can therefore only give a description how it was produced. +There are many resources on [collecting images from the +web](https://github.com/adrianmrit/flickrdatasets) to get started. +We collected sufficiently large images from [flickr](https://www.flickr.com) +(see `data/flickr_tags.txt` for a full list of tags used to find images) +and various [subreddits](https://www.reddit.com/r/sfwpornnetwork/wiki/network) +(see `data/subreddits.txt` for all subreddits that were used). +Overall, we collected 107625 images, and split them randomly into 96861 +training images and 10764 validation images. We then obtained segmentation +masks for each image using [DeepLab v2](https://arxiv.org/abs/1606.00915) +trained on [COCO-Stuff](https://arxiv.org/abs/1612.03716). We used a [PyTorch +reimplementation](https://github.com/kazuto1011/deeplab-pytorch) and include an +example script for this process in `scripts/extract_segmentation.py`. + +### COCO +Create a symlink `data/coco` containing the images from the 2017 split in +`train2017` and `val2017`, and their annotations in `annotations`. Files can be +obtained from the [COCO webpage](https://cocodataset.org/). In addition, we use +the [Stuff+thing PNG-style annotations on COCO 2017 +trainval](http://calvin.inf.ed.ac.uk/wp-content/uploads/data/cocostuffdataset/stuffthingmaps_trainval2017.zip) +annotations from [COCO-Stuff](https://github.com/nightrome/cocostuff), which +should be placed under `data/cocostuffthings`. + +### ADE20k +Create a symlink `data/ade20k_root` containing the contents of +[ADEChallengeData2016.zip](http://data.csail.mit.edu/places/ADEchallenge/ADEChallengeData2016.zip) +from the [MIT Scene Parsing Benchmark](http://sceneparsing.csail.mit.edu/). + +## Training models + +### FacesHQ + +Train a VQGAN with +``` +python main.py --base configs/faceshq_vqgan.yaml -t True --gpus 0, +``` + +Then, adjust the checkpoint path of the config key +`model.params.first_stage_config.params.ckpt_path` in +`configs/faceshq_transformer.yaml` (or download +[2020-11-09T13-33-36_faceshq_vqgan](https://k00.fr/uxy5usa9) and place into `logs`, which +corresponds to the preconfigured checkpoint path), then run +``` +python main.py --base configs/faceshq_transformer.yaml -t True --gpus 0, +``` + +### D-RIN + +Train a VQGAN on ImageNet with +``` +python main.py --base configs/imagenet_vqgan.yaml -t True --gpus 0, +``` + +or download a pretrained one from [2020-09-23T17-56-33_imagenet_vqgan](https://k00.fr/u0j2dtac) +and place under `logs`. If you trained your own, adjust the path in the config +key `model.params.first_stage_config.params.ckpt_path` of +`configs/drin_transformer.yaml`. + +Train a VQGAN on Depth Maps of ImageNet with +``` +python main.py --base configs/imagenetdepth_vqgan.yaml -t True --gpus 0, +``` + +or download a pretrained one from [2020-11-03T15-34-24_imagenetdepth_vqgan](https://k00.fr/55rlxs6i) +and place under `logs`. If you trained your own, adjust the path in the config +key `model.params.cond_stage_config.params.ckpt_path` of +`configs/drin_transformer.yaml`. + +To train the transformer, run +``` +python main.py --base configs/drin_transformer.yaml -t True --gpus 0, +``` + +## More Resources +### Comparing Different First Stage Models +The reconstruction and compression capabilities of different fist stage models can be analyzed in this [colab notebook](https://colab.research.google.com/github/CompVis/taming-transformers/blob/master/scripts/reconstruction_usage.ipynb). +In particular, the notebook compares two VQGANs with a downsampling factor of f=16 for each and codebook dimensionality of 1024 and 16384, +a VQGAN with f=8 and 8192 codebook entries and the discrete autoencoder of OpenAI's [DALL-E](https://github.com/openai/DALL-E) (which has f=8 and 8192 +codebook entries). +![firststages1](assets/first_stage_squirrels.png) +![firststages2](assets/first_stage_mushrooms.png) + +### Other +- A [video summary](https://www.youtube.com/watch?v=o7dqGcLDf0A&feature=emb_imp_woyt) by [Two Minute Papers](https://www.youtube.com/channel/UCbfYPyITQ-7l4upoX8nvctg). +- A [video summary](https://www.youtube.com/watch?v=-wDSDtIAyWQ) by [Gradient Dude](https://www.youtube.com/c/GradientDude/about). +- A [weights and biases report summarizing the paper](https://wandb.ai/ayush-thakur/taming-transformer/reports/-Overview-Taming-Transformers-for-High-Resolution-Image-Synthesis---Vmlldzo0NjEyMTY) +by [ayulockin](https://github.com/ayulockin). +- A [video summary](https://www.youtube.com/watch?v=JfUTd8fjtX8&feature=emb_imp_woyt) by [What's AI](https://www.youtube.com/channel/UCUzGQrN-lyyc0BWTYoJM_Sg). +- Take a look at [ak9250's notebook](https://github.com/ak9250/taming-transformers/blob/master/tamingtransformerscolab.ipynb) if you want to run the streamlit demos on Colab. + +### Text-to-Image Optimization via CLIP +VQGAN has been successfully used as an image generator guided by the [CLIP](https://github.com/openai/CLIP) model, both for pure image generation +from scratch and image-to-image translation. We recommend the following notebooks/videos/resources: + + - [Advadnouns](https://twitter.com/advadnoun/status/1389316507134357506) Patreon and corresponding LatentVision notebooks: https://www.patreon.com/patronizeme + - The [notebook]( https://colab.research.google.com/drive/1L8oL-vLJXVcRzCFbPwOoMkPKJ8-aYdPN) of [Rivers Have Wings](https://twitter.com/RiversHaveWings). + - A [video](https://www.youtube.com/watch?v=90QDe6DQXF4&t=12s) explanation by [Dot CSV](https://www.youtube.com/channel/UCy5znSnfMsDwaLlROnZ7Qbg) (in Spanish, but English subtitles are available) + +![txt2img](assets/birddrawnbyachild.png) + +Text prompt: *'A bird drawn by a child'* + +## Shout-outs +Thanks to everyone who makes their code and models available. In particular, + +- The architecture of our VQGAN is inspired by [Denoising Diffusion Probabilistic Models](https://github.com/hojonathanho/diffusion) +- The very hackable transformer implementation [minGPT](https://github.com/karpathy/minGPT) +- The good ol' [PatchGAN](https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix) and [Learned Perceptual Similarity (LPIPS)](https://github.com/richzhang/PerceptualSimilarity) + +## BibTeX + +``` +@misc{esser2020taming, + title={Taming Transformers for High-Resolution Image Synthesis}, + author={Patrick Esser and Robin Rombach and Björn Ommer}, + year={2020}, + eprint={2012.09841}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` diff --git a/src/taming-transformers/assets/birddrawnbyachild.png b/src/taming-transformers/assets/birddrawnbyachild.png new file mode 100644 index 0000000000000000000000000000000000000000..dec439d6f7dbf49e1d4aab94a4e5f32d52275f11 --- /dev/null +++ b/src/taming-transformers/assets/birddrawnbyachild.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:165778bb85e86f8aaaed38eee4d33f62ab1ef237d890229cfa2e0685f5064127 +size 1607893 diff --git a/src/taming-transformers/assets/coco_scene_images_training.svg b/src/taming-transformers/assets/coco_scene_images_training.svg new file mode 100644 index 0000000000000000000000000000000000000000..6793487237678a6e8f32f7421cec24af547e571c --- /dev/null +++ b/src/taming-transformers/assets/coco_scene_images_training.svg @@ -0,0 +1,2574 @@ + + + + + + + + + + 2021-10-07T13:59:09.893851 + image/svg+xml + + + Matplotlib v3.3.3, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NLL loss + Inception score + FID + SceneFID + diff --git a/src/taming-transformers/assets/drin.jpg b/src/taming-transformers/assets/drin.jpg new file mode 100644 index 0000000000000000000000000000000000000000..77ca85c8a3a68102050064e89716436d125080ba Binary files /dev/null and b/src/taming-transformers/assets/drin.jpg differ diff --git a/src/taming-transformers/assets/faceshq.jpg b/src/taming-transformers/assets/faceshq.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7a8177fb3f434323cf79041a372445d4bb3b9e45 Binary files /dev/null and b/src/taming-transformers/assets/faceshq.jpg differ diff --git a/src/taming-transformers/assets/first_stage_mushrooms.png b/src/taming-transformers/assets/first_stage_mushrooms.png new file mode 100644 index 0000000000000000000000000000000000000000..c3a521079c3bc996eb2226598bb4a67b141c04f8 --- /dev/null +++ b/src/taming-transformers/assets/first_stage_mushrooms.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:425218621d5e01ea30c9e51fa0969ad36c22063a405dc6f6ccb6dd8db64000a0 +size 1353846 diff --git a/src/taming-transformers/assets/first_stage_squirrels.png b/src/taming-transformers/assets/first_stage_squirrels.png new file mode 100644 index 0000000000000000000000000000000000000000..a1883fcee4aca3ee39d213587bcfa037caee3fd4 --- /dev/null +++ b/src/taming-transformers/assets/first_stage_squirrels.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5f234ee1566d6c537339a7110a1a1df088d527812097c19ac61f01b335cd6ae +size 1424657 diff --git a/src/taming-transformers/assets/imagenet.png b/src/taming-transformers/assets/imagenet.png new file mode 100644 index 0000000000000000000000000000000000000000..fa831a2fd75344f96eefdba3e97de2d0dd56126f --- /dev/null +++ b/src/taming-transformers/assets/imagenet.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2057d65399435ba17f265ad7ff421a9aabfb6051dec00bec5a37383dfccb2e54 +size 1029071 diff --git a/src/taming-transformers/assets/lake_in_the_mountains.png b/src/taming-transformers/assets/lake_in_the_mountains.png new file mode 100644 index 0000000000000000000000000000000000000000..a66ea43c8f1146229eb18d8ebb9f67054438bc7c Binary files /dev/null and b/src/taming-transformers/assets/lake_in_the_mountains.png differ diff --git a/src/taming-transformers/assets/mountain.jpeg b/src/taming-transformers/assets/mountain.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..3df63a15199a91367067b587e0141c1c52ad778b Binary files /dev/null and b/src/taming-transformers/assets/mountain.jpeg differ diff --git a/src/taming-transformers/assets/scene_images_samples.svg b/src/taming-transformers/assets/scene_images_samples.svg new file mode 100644 index 0000000000000000000000000000000000000000..f646d3bdb60b3bb83f97edbed265b0ad8fb062ec --- /dev/null +++ b/src/taming-transformers/assets/scene_images_samples.svg @@ -0,0 +1,453 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Open Images + COCO + diff --git a/src/taming-transformers/assets/stormy.jpeg b/src/taming-transformers/assets/stormy.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..335edab19ea17e31f318540390f4575c4ff27bf4 Binary files /dev/null and b/src/taming-transformers/assets/stormy.jpeg differ diff --git a/src/taming-transformers/assets/sunset_and_ocean.jpg b/src/taming-transformers/assets/sunset_and_ocean.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5294e8f7b889b70d0dec79cd6775878754922838 Binary files /dev/null and b/src/taming-transformers/assets/sunset_and_ocean.jpg differ diff --git a/src/taming-transformers/assets/teaser.png b/src/taming-transformers/assets/teaser.png new file mode 100644 index 0000000000000000000000000000000000000000..c485153154e2aa0fd9f08773263ba13a4139868b Binary files /dev/null and b/src/taming-transformers/assets/teaser.png differ diff --git a/src/taming-transformers/configs/coco_cond_stage.yaml b/src/taming-transformers/configs/coco_cond_stage.yaml new file mode 100644 index 0000000000000000000000000000000000000000..18a3dde147455c281a3687b1a0b42bbbc3fb2725 --- /dev/null +++ b/src/taming-transformers/configs/coco_cond_stage.yaml @@ -0,0 +1,49 @@ +model: + base_learning_rate: 4.5e-06 + target: taming.models.vqgan.VQSegmentationModel + params: + embed_dim: 256 + n_embed: 1024 + image_key: "segmentation" + n_labels: 183 + ddconfig: + double_z: false + z_channels: 256 + resolution: 256 + in_channels: 183 + out_ch: 183 + ch: 128 + ch_mult: + - 1 + - 1 + - 2 + - 2 + - 4 + num_res_blocks: 2 + attn_resolutions: + - 16 + dropout: 0.0 + + lossconfig: + target: taming.modules.losses.segmentation.BCELossWithQuant + params: + codebook_weight: 1.0 + +data: + target: main.DataModuleFromConfig + params: + batch_size: 12 + train: + target: taming.data.coco.CocoImagesAndCaptionsTrain + params: + size: 296 + crop_size: 256 + onehot_segmentation: true + use_stuffthing: true + validation: + target: taming.data.coco.CocoImagesAndCaptionsValidation + params: + size: 256 + crop_size: 256 + onehot_segmentation: true + use_stuffthing: true diff --git a/src/taming-transformers/configs/coco_scene_images_transformer.yaml b/src/taming-transformers/configs/coco_scene_images_transformer.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a03078de708182cc175f139078f8455ca3ec8a09 --- /dev/null +++ b/src/taming-transformers/configs/coco_scene_images_transformer.yaml @@ -0,0 +1,80 @@ +model: + base_learning_rate: 4.5e-06 + target: taming.models.cond_transformer.Net2NetTransformer + params: + cond_stage_key: objects_bbox + transformer_config: + target: taming.modules.transformer.mingpt.GPT + params: + vocab_size: 8192 + block_size: 348 # = 256 + 92 = dim(vqgan_latent_space,16x16) + dim(conditional_builder.embedding_dim) + n_layer: 40 + n_head: 16 + n_embd: 1408 + embd_pdrop: 0.1 + resid_pdrop: 0.1 + attn_pdrop: 0.1 + first_stage_config: + target: taming.models.vqgan.VQModel + params: + ckpt_path: /path/to/coco_epoch117.ckpt # https://heibox.uni-heidelberg.de/f/78dea9589974474c97c1/ + embed_dim: 256 + n_embed: 8192 + ddconfig: + double_z: false + z_channels: 256 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 1 + - 2 + - 2 + - 4 + num_res_blocks: 2 + attn_resolutions: + - 16 + dropout: 0.0 + lossconfig: + target: taming.modules.losses.DummyLoss + cond_stage_config: + target: taming.models.dummy_cond_stage.DummyCondStage + params: + conditional_key: objects_bbox + +data: + target: main.DataModuleFromConfig + params: + batch_size: 6 + train: + target: taming.data.annotated_objects_coco.AnnotatedObjectsCoco + params: + data_path: data/coco_annotations_100 # substitute with path to full dataset + split: train + keys: [image, objects_bbox, file_name, annotations] + no_tokens: 8192 + target_image_size: 256 + min_object_area: 0.00001 + min_objects_per_image: 2 + max_objects_per_image: 30 + crop_method: random-1d + random_flip: true + use_group_parameter: true + encode_crop: true + validation: + target: taming.data.annotated_objects_coco.AnnotatedObjectsCoco + params: + data_path: data/coco_annotations_100 # substitute with path to full dataset + split: validation + keys: [image, objects_bbox, file_name, annotations] + no_tokens: 8192 + target_image_size: 256 + min_object_area: 0.00001 + min_objects_per_image: 2 + max_objects_per_image: 30 + crop_method: center + random_flip: false + use_group_parameter: true + encode_crop: true diff --git a/src/taming-transformers/configs/custom_vqgan.yaml b/src/taming-transformers/configs/custom_vqgan.yaml new file mode 100644 index 0000000000000000000000000000000000000000..908687f38325dfe49430692d668733a8e1598375 --- /dev/null +++ b/src/taming-transformers/configs/custom_vqgan.yaml @@ -0,0 +1,43 @@ +model: + base_learning_rate: 4.5e-6 + target: taming.models.vqgan.VQModel + params: + embed_dim: 256 + n_embed: 1024 + ddconfig: + double_z: False + z_channels: 256 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: [ 1,1,2,2,4] # num_down = len(ch_mult)-1 + num_res_blocks: 2 + attn_resolutions: [16] + dropout: 0.0 + + lossconfig: + target: taming.modules.losses.vqperceptual.VQLPIPSWithDiscriminator + params: + disc_conditional: False + disc_in_channels: 3 + disc_start: 10000 + disc_weight: 0.8 + codebook_weight: 1.0 + +data: + target: main.DataModuleFromConfig + params: + batch_size: 5 + num_workers: 8 + train: + target: taming.data.custom.CustomTrain + params: + training_images_list_file: some/training.txt + size: 256 + validation: + target: taming.data.custom.CustomTest + params: + test_images_list_file: some/test.txt + size: 256 + diff --git a/src/taming-transformers/configs/drin_transformer.yaml b/src/taming-transformers/configs/drin_transformer.yaml new file mode 100644 index 0000000000000000000000000000000000000000..bead4567d2dcc3d0f1a7b8eec823df4b427cab07 --- /dev/null +++ b/src/taming-transformers/configs/drin_transformer.yaml @@ -0,0 +1,77 @@ +model: + base_learning_rate: 4.5e-06 + target: taming.models.cond_transformer.Net2NetTransformer + params: + cond_stage_key: depth + transformer_config: + target: taming.modules.transformer.mingpt.GPT + params: + vocab_size: 1024 + block_size: 512 + n_layer: 24 + n_head: 16 + n_embd: 1024 + first_stage_config: + target: taming.models.vqgan.VQModel + params: + ckpt_path: logs/2020-09-23T17-56-33_imagenet_vqgan/checkpoints/last.ckpt + embed_dim: 256 + n_embed: 1024 + ddconfig: + double_z: false + z_channels: 256 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 1 + - 2 + - 2 + - 4 + num_res_blocks: 2 + attn_resolutions: + - 16 + dropout: 0.0 + lossconfig: + target: taming.modules.losses.DummyLoss + cond_stage_config: + target: taming.models.vqgan.VQModel + params: + ckpt_path: logs/2020-11-03T15-34-24_imagenetdepth_vqgan/checkpoints/last.ckpt + embed_dim: 256 + n_embed: 1024 + ddconfig: + double_z: false + z_channels: 256 + resolution: 256 + in_channels: 1 + out_ch: 1 + ch: 128 + ch_mult: + - 1 + - 1 + - 2 + - 2 + - 4 + num_res_blocks: 2 + attn_resolutions: + - 16 + dropout: 0.0 + lossconfig: + target: taming.modules.losses.DummyLoss + +data: + target: main.DataModuleFromConfig + params: + batch_size: 2 + num_workers: 8 + train: + target: taming.data.imagenet.RINTrainWithDepth + params: + size: 256 + validation: + target: taming.data.imagenet.RINValidationWithDepth + params: + size: 256 diff --git a/src/taming-transformers/configs/faceshq_transformer.yaml b/src/taming-transformers/configs/faceshq_transformer.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b93391f9c9c41d63d28dd38dbf83615552642db3 --- /dev/null +++ b/src/taming-transformers/configs/faceshq_transformer.yaml @@ -0,0 +1,61 @@ +model: + base_learning_rate: 4.5e-06 + target: taming.models.cond_transformer.Net2NetTransformer + params: + cond_stage_key: coord + transformer_config: + target: taming.modules.transformer.mingpt.GPT + params: + vocab_size: 1024 + block_size: 512 + n_layer: 24 + n_head: 16 + n_embd: 1024 + first_stage_config: + target: taming.models.vqgan.VQModel + params: + ckpt_path: logs/2020-11-09T13-33-36_faceshq_vqgan/checkpoints/last.ckpt + embed_dim: 256 + n_embed: 1024 + ddconfig: + double_z: false + z_channels: 256 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 1 + - 2 + - 2 + - 4 + num_res_blocks: 2 + attn_resolutions: + - 16 + dropout: 0.0 + lossconfig: + target: taming.modules.losses.DummyLoss + cond_stage_config: + target: taming.modules.misc.coord.CoordStage + params: + n_embed: 1024 + down_factor: 16 + +data: + target: main.DataModuleFromConfig + params: + batch_size: 2 + num_workers: 8 + train: + target: taming.data.faceshq.FacesHQTrain + params: + size: 256 + crop_size: 256 + coord: True + validation: + target: taming.data.faceshq.FacesHQValidation + params: + size: 256 + crop_size: 256 + coord: True diff --git a/src/taming-transformers/configs/faceshq_vqgan.yaml b/src/taming-transformers/configs/faceshq_vqgan.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3960f784551bfd9caddb5b084fc592c6eed6483b --- /dev/null +++ b/src/taming-transformers/configs/faceshq_vqgan.yaml @@ -0,0 +1,42 @@ +model: + base_learning_rate: 4.5e-6 + target: taming.models.vqgan.VQModel + params: + embed_dim: 256 + n_embed: 1024 + ddconfig: + double_z: False + z_channels: 256 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: [ 1,1,2,2,4] # num_down = len(ch_mult)-1 + num_res_blocks: 2 + attn_resolutions: [16] + dropout: 0.0 + + lossconfig: + target: taming.modules.losses.vqperceptual.VQLPIPSWithDiscriminator + params: + disc_conditional: False + disc_in_channels: 3 + disc_start: 30001 + disc_weight: 0.8 + codebook_weight: 1.0 + +data: + target: main.DataModuleFromConfig + params: + batch_size: 3 + num_workers: 8 + train: + target: taming.data.faceshq.FacesHQTrain + params: + size: 256 + crop_size: 256 + validation: + target: taming.data.faceshq.FacesHQValidation + params: + size: 256 + crop_size: 256 diff --git a/src/taming-transformers/configs/imagenet_vqgan.yaml b/src/taming-transformers/configs/imagenet_vqgan.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f6dc21ff6de9a26474fa18a0d496a4a0b9bb0837 --- /dev/null +++ b/src/taming-transformers/configs/imagenet_vqgan.yaml @@ -0,0 +1,42 @@ +model: + base_learning_rate: 4.5e-6 + target: taming.models.vqgan.VQModel + params: + embed_dim: 256 + n_embed: 1024 + ddconfig: + double_z: False + z_channels: 256 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: [ 1,1,2,2,4] # num_down = len(ch_mult)-1 + num_res_blocks: 2 + attn_resolutions: [16] + dropout: 0.0 + + lossconfig: + target: taming.modules.losses.vqperceptual.VQLPIPSWithDiscriminator + params: + disc_conditional: False + disc_in_channels: 3 + disc_start: 250001 + disc_weight: 0.8 + codebook_weight: 1.0 + +data: + target: main.DataModuleFromConfig + params: + batch_size: 12 + num_workers: 24 + train: + target: taming.data.imagenet.ImageNetTrain + params: + config: + size: 256 + validation: + target: taming.data.imagenet.ImageNetValidation + params: + config: + size: 256 diff --git a/src/taming-transformers/configs/imagenetdepth_vqgan.yaml b/src/taming-transformers/configs/imagenetdepth_vqgan.yaml new file mode 100644 index 0000000000000000000000000000000000000000..88d2f34f1c0661e350899cf4229cdf60697baf0d --- /dev/null +++ b/src/taming-transformers/configs/imagenetdepth_vqgan.yaml @@ -0,0 +1,41 @@ +model: + base_learning_rate: 4.5e-6 + target: taming.models.vqgan.VQModel + params: + embed_dim: 256 + n_embed: 1024 + image_key: depth + ddconfig: + double_z: False + z_channels: 256 + resolution: 256 + in_channels: 1 + out_ch: 1 + ch: 128 + ch_mult: [ 1,1,2,2,4] # num_down = len(ch_mult)-1 + num_res_blocks: 2 + attn_resolutions: [16] + dropout: 0.0 + + lossconfig: + target: taming.modules.losses.vqperceptual.VQLPIPSWithDiscriminator + params: + disc_conditional: False + disc_in_channels: 1 + disc_start: 50001 + disc_weight: 0.75 + codebook_weight: 1.0 + +data: + target: main.DataModuleFromConfig + params: + batch_size: 3 + num_workers: 8 + train: + target: taming.data.imagenet.ImageNetTrainWithDepth + params: + size: 256 + validation: + target: taming.data.imagenet.ImageNetValidationWithDepth + params: + size: 256 diff --git a/src/taming-transformers/configs/open_images_scene_images_transformer.yaml b/src/taming-transformers/configs/open_images_scene_images_transformer.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f4e41e0d67d3e3eb17509862e063e4d626b06d4b --- /dev/null +++ b/src/taming-transformers/configs/open_images_scene_images_transformer.yaml @@ -0,0 +1,86 @@ +model: + base_learning_rate: 4.5e-06 + target: taming.models.cond_transformer.Net2NetTransformer + params: + cond_stage_key: objects_bbox + transformer_config: + target: taming.modules.transformer.mingpt.GPT + params: + vocab_size: 8192 + block_size: 348 # = 256 + 92 = dim(vqgan_latent_space,16x16) + dim(conditional_builder.embedding_dim) + n_layer: 36 + n_head: 16 + n_embd: 1536 + embd_pdrop: 0.1 + resid_pdrop: 0.1 + attn_pdrop: 0.1 + first_stage_config: + target: taming.models.vqgan.VQModel + params: + ckpt_path: /path/to/coco_oi_epoch12.ckpt # https://heibox.uni-heidelberg.de/f/461d9a9f4fcf48ab84f4/ + embed_dim: 256 + n_embed: 8192 + ddconfig: + double_z: false + z_channels: 256 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 1 + - 2 + - 2 + - 4 + num_res_blocks: 2 + attn_resolutions: + - 16 + dropout: 0.0 + lossconfig: + target: taming.modules.losses.DummyLoss + cond_stage_config: + target: taming.models.dummy_cond_stage.DummyCondStage + params: + conditional_key: objects_bbox + +data: + target: main.DataModuleFromConfig + params: + batch_size: 6 + train: + target: taming.data.annotated_objects_open_images.AnnotatedObjectsOpenImages + params: + data_path: data/open_images_annotations_100 # substitute with path to full dataset + split: train + keys: [image, objects_bbox, file_name, annotations] + no_tokens: 8192 + target_image_size: 256 + category_allow_list_target: taming.data.open_images_helper.top_300_classes_plus_coco_compatibility + category_mapping_target: taming.data.open_images_helper.open_images_unify_categories_for_coco + min_object_area: 0.0001 + min_objects_per_image: 2 + max_objects_per_image: 30 + crop_method: random-2d + random_flip: true + use_group_parameter: true + use_additional_parameters: true + encode_crop: true + validation: + target: taming.data.annotated_objects_open_images.AnnotatedObjectsOpenImages + params: + data_path: data/open_images_annotations_100 # substitute with path to full dataset + split: validation + keys: [image, objects_bbox, file_name, annotations] + no_tokens: 8192 + target_image_size: 256 + category_allow_list_target: taming.data.open_images_helper.top_300_classes_plus_coco_compatibility + category_mapping_target: taming.data.open_images_helper.open_images_unify_categories_for_coco + min_object_area: 0.0001 + min_objects_per_image: 2 + max_objects_per_image: 30 + crop_method: center + random_flip: false + use_group_parameter: true + use_additional_parameters: true + encode_crop: true diff --git a/src/taming-transformers/configs/sflckr_cond_stage.yaml b/src/taming-transformers/configs/sflckr_cond_stage.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d48b50a700c4b44098ce4f3c752d5a4d7158f8a9 --- /dev/null +++ b/src/taming-transformers/configs/sflckr_cond_stage.yaml @@ -0,0 +1,43 @@ +model: + base_learning_rate: 4.5e-06 + target: taming.models.vqgan.VQSegmentationModel + params: + embed_dim: 256 + n_embed: 1024 + image_key: "segmentation" + n_labels: 182 + ddconfig: + double_z: false + z_channels: 256 + resolution: 256 + in_channels: 182 + out_ch: 182 + ch: 128 + ch_mult: + - 1 + - 1 + - 2 + - 2 + - 4 + num_res_blocks: 2 + attn_resolutions: + - 16 + dropout: 0.0 + + lossconfig: + target: taming.modules.losses.segmentation.BCELossWithQuant + params: + codebook_weight: 1.0 + +data: + target: cutlit.DataModuleFromConfig + params: + batch_size: 12 + train: + target: taming.data.sflckr.Examples # adjust + params: + size: 256 + validation: + target: taming.data.sflckr.Examples # adjust + params: + size: 256 diff --git a/src/taming-transformers/data/ade20k_examples.txt b/src/taming-transformers/data/ade20k_examples.txt new file mode 100644 index 0000000000000000000000000000000000000000..0b5a07823cb09fea08ac676eb6da6e09fc222b83 --- /dev/null +++ b/src/taming-transformers/data/ade20k_examples.txt @@ -0,0 +1,30 @@ +ADE_val_00000636.jpg +ADE_val_00000126.jpg +ADE_val_00001412.jpg +ADE_val_00001845.jpg +ADE_val_00001200.jpg +ADE_val_00001578.jpg +ADE_val_00000880.jpg +ADE_val_00000875.jpg +ADE_val_00000123.jpg +ADE_val_00001209.jpg +ADE_val_00000203.jpg +ADE_val_00001851.jpg +ADE_val_00001583.jpg +ADE_val_00000287.jpg +ADE_val_00001947.jpg +ADE_val_00000262.jpg +ADE_val_00000603.jpg +ADE_val_00000125.jpg +ADE_val_00001698.jpg +ADE_val_00001966.jpg +ADE_val_00000532.jpg +ADE_val_00001177.jpg +ADE_val_00000734.jpg +ADE_val_00001498.jpg +ADE_val_00001766.jpg +ADE_val_00000303.jpg +ADE_val_00000509.jpg +ADE_val_00000573.jpg +ADE_val_00000289.jpg +ADE_val_00001388.jpg diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000123.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000123.jpg new file mode 100644 index 0000000000000000000000000000000000000000..774407647dfac63260246595bca7561f7e675aec Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000123.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000125.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000125.jpg new file mode 100644 index 0000000000000000000000000000000000000000..71c7cf3de0e0d7a42192782a5e65df1098954c27 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000125.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000126.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000126.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9df65d17ce65c1b0f6eebdb2652bb565f06eedbb Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000126.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000203.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000203.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ae6c97025be2af4f159fed427cdb499cb6e51635 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000203.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000262.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000262.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cf572bef07474f2ba4f20e9799b0899ef777ebc1 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000262.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000287.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000287.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7ea848ce142e3740ccabd5c679abe96d78ff0cd Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000287.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000289.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000289.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f74858ffbffac9d0d1ee28f7d7cb94f62fd16cd1 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000289.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000303.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000303.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a37aa933d234cd05ed7086239123b5f1f99d85d3 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000303.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000509.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000509.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a3e5ab26a32e692395ee0117ce36e0081615901 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000509.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000532.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000532.jpg new file mode 100644 index 0000000000000000000000000000000000000000..54c13f1c4d22d1ad358390590492b389a9076392 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000532.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000573.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000573.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7e45edd22c1e42fb2d0aaac268d23884e6b7a3dc Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000573.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000603.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000603.jpg new file mode 100644 index 0000000000000000000000000000000000000000..96d7b4fe874f23c303d8eb29b0f39ead9bac586d Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000603.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000636.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000636.jpg new file mode 100644 index 0000000000000000000000000000000000000000..39aec80ed48787d2d410bf4282e90e0e9079dca7 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000636.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000734.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000734.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a70ba1c5c9639434e079c3b1bac61c868490d938 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000734.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000875.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000875.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8d43f5234a50dcd4935c098a30730736ef72cae6 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000875.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00000880.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00000880.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c08c6203a41ab64c9a55e3828d4461ca543e468d Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00000880.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001177.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001177.jpg new file mode 100644 index 0000000000000000000000000000000000000000..422f079910d559e7792d9b4c460d356d77dcce37 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001177.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001200.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001200.jpg new file mode 100644 index 0000000000000000000000000000000000000000..910d9277a95eec22b73cf66cebd0d7099e5f0210 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001200.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001209.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001209.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c87f719f5afa0aae1a69ea8e996fbd6230f343d6 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001209.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001388.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001388.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0de8775327d18140254b8973fb951fe35e888721 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001388.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001412.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001412.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3c569ddd8e45bb60519fa7eb13365657157d97d1 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001412.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001498.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001498.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f661b40c3c0fc3a0655c9caceeccb42d5bedc19e Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001498.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001578.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001578.jpg new file mode 100644 index 0000000000000000000000000000000000000000..00621febe8fc4bbd6e9d4d86fcfa315f294593e1 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001578.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001583.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001583.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1a7946f312c05343d70b7eea723c272d6078595d Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001583.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001698.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001698.jpg new file mode 100644 index 0000000000000000000000000000000000000000..859c515a9a5e5936ce6338a4d6c4d196365ee998 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001698.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001766.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001766.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1690dee906ad750084327062eafb8e3a9d25a690 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001766.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001845.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001845.jpg new file mode 100644 index 0000000000000000000000000000000000000000..39494fdede0e8678fae5b7fe4e6385b4cff9507c Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001845.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001851.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001851.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d38c1050deeefd858e6d65a3cdb857165493e2f4 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001851.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001947.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001947.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9776d4cae49779fbe90996d01a4fb111f0f00e60 Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001947.jpg differ diff --git a/src/taming-transformers/data/ade20k_images/ADE_val_00001966.jpg b/src/taming-transformers/data/ade20k_images/ADE_val_00001966.jpg new file mode 100644 index 0000000000000000000000000000000000000000..494260bc0220ba01e70f5d54d569f78911664b0e Binary files /dev/null and b/src/taming-transformers/data/ade20k_images/ADE_val_00001966.jpg differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000123.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000123.png new file mode 100644 index 0000000000000000000000000000000000000000..f951e5f3311603f3fa6c76ca5188de5e024138de Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000123.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000125.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000125.png new file mode 100644 index 0000000000000000000000000000000000000000..91e49e228ac93aac1314e21b118c084f7a923084 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000125.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000126.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000126.png new file mode 100644 index 0000000000000000000000000000000000000000..f78143fcc1774678d1a138133ff257a46c1e68d6 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000126.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000203.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000203.png new file mode 100644 index 0000000000000000000000000000000000000000..8251aa7db06872d0f9299cfd13aa98cceed2cd09 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000203.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000262.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000262.png new file mode 100644 index 0000000000000000000000000000000000000000..1e63cc80466bd5d014b328d9b2a486b4bc26b677 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000262.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000287.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000287.png new file mode 100644 index 0000000000000000000000000000000000000000..4f23834a64636a9e8434e50ec8631811887f6b67 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000287.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000289.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000289.png new file mode 100644 index 0000000000000000000000000000000000000000..1413d5a0f757d45d3e4d14a2fd9c222c374ba1f3 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000289.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000303.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000303.png new file mode 100644 index 0000000000000000000000000000000000000000..24cc97329f11a700469c66f73926df18626e916a Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000303.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000509.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000509.png new file mode 100644 index 0000000000000000000000000000000000000000..0aa65c57f15337597cae42f8360bf4fc4b987ead Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000509.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000532.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000532.png new file mode 100644 index 0000000000000000000000000000000000000000..53a7866ce50cfbe7ee30bb8f418ea93f1ea6cae0 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000532.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000573.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000573.png new file mode 100644 index 0000000000000000000000000000000000000000..9a2b394c02b9e4bc862e73ecc96e8b7743bead40 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000573.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000603.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000603.png new file mode 100644 index 0000000000000000000000000000000000000000..d6aad36b4d328df004e7b50dbe00be919f1f9f9a Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000603.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000636.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000636.png new file mode 100644 index 0000000000000000000000000000000000000000..d037b4bb9b03ca03214853850efa42020f75b122 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000636.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000734.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000734.png new file mode 100644 index 0000000000000000000000000000000000000000..6019e31c2280e92e1164ad87eb0d41193ebf4c96 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000734.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000875.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000875.png new file mode 100644 index 0000000000000000000000000000000000000000..e81ac5bacf0fb5be81dcd150dbda8f197ea69da1 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000875.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000880.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000880.png new file mode 100644 index 0000000000000000000000000000000000000000..5b056ea99f81ea9dde14ad32d3b63eb773e7cd00 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00000880.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001177.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001177.png new file mode 100644 index 0000000000000000000000000000000000000000..37154e5087b3b5d403780012787ad9a0aa937b33 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001177.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001200.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001200.png new file mode 100644 index 0000000000000000000000000000000000000000..d71561e9ca9419e83eaa9e2fe2f8fa2da0a7082b Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001200.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001209.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001209.png new file mode 100644 index 0000000000000000000000000000000000000000..d348cfc6e58489d0d509670478dcb192f9972b44 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001209.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001388.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001388.png new file mode 100644 index 0000000000000000000000000000000000000000..5b78c30bc146d21835cee2d0ce1a42008603347a Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001388.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001412.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001412.png new file mode 100644 index 0000000000000000000000000000000000000000..09e2b9a044eb833377764ab3a19edf89a818d6f6 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001412.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001498.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001498.png new file mode 100644 index 0000000000000000000000000000000000000000..af5c7d9f5ab3c19840d157ad5633b908c8e6e506 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001498.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001578.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001578.png new file mode 100644 index 0000000000000000000000000000000000000000..cc4d9934dcabf52dca6459fc1850373b30f095a9 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001578.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001583.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001583.png new file mode 100644 index 0000000000000000000000000000000000000000..d5a5575bc48c70f99f266fcc2dbc1822c93933a7 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001583.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001698.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001698.png new file mode 100644 index 0000000000000000000000000000000000000000..859c06146e8b87753076290216ea537392cbdcd0 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001698.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001766.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001766.png new file mode 100644 index 0000000000000000000000000000000000000000..c94eae43649a9be98904fa8ca1beba65fc239bff Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001766.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001845.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001845.png new file mode 100644 index 0000000000000000000000000000000000000000..8cc120bd910c46d067c91e10df6a3b03b35bd02e Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001845.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001851.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001851.png new file mode 100644 index 0000000000000000000000000000000000000000..052a2ddbe2153d91e74948aa5ff89a01f96b8a4d Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001851.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001947.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001947.png new file mode 100644 index 0000000000000000000000000000000000000000..975a93e70715f58b1427d71124651ffd7e272593 Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001947.png differ diff --git a/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001966.png b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001966.png new file mode 100644 index 0000000000000000000000000000000000000000..bb4f76305ff9e6c2841dd12bf34468f7ec52d9ce Binary files /dev/null and b/src/taming-transformers/data/ade20k_segmentations/ADE_val_00001966.png differ diff --git a/src/taming-transformers/data/celebahqtrain.txt b/src/taming-transformers/data/celebahqtrain.txt new file mode 100644 index 0000000000000000000000000000000000000000..d508ef4bf54e12232f24542021e5d31af22f4d2c --- /dev/null +++ b/src/taming-transformers/data/celebahqtrain.txt @@ -0,0 +1,25000 @@ +imgHQ20126.npy +imgHQ29348.npy +imgHQ26284.npy +imgHQ26144.npy +imgHQ07926.npy +imgHQ22701.npy +imgHQ01851.npy +imgHQ09737.npy +imgHQ28459.npy +imgHQ12762.npy +imgHQ00347.npy +imgHQ23563.npy +imgHQ25347.npy +imgHQ09323.npy +imgHQ16876.npy +imgHQ22235.npy +imgHQ19549.npy +imgHQ12230.npy +imgHQ26515.npy +imgHQ27551.npy +imgHQ09451.npy +imgHQ24495.npy +imgHQ09204.npy +imgHQ01126.npy +imgHQ19642.npy +imgHQ26392.npy +imgHQ07815.npy +imgHQ27527.npy +imgHQ22812.npy +imgHQ21918.npy +imgHQ08976.npy +imgHQ18276.npy +imgHQ19676.npy +imgHQ09096.npy +imgHQ05013.npy +imgHQ29569.npy +imgHQ28004.npy +imgHQ02419.npy +imgHQ25129.npy +imgHQ28115.npy +imgHQ29846.npy +imgHQ10939.npy +imgHQ02503.npy +imgHQ28509.npy +imgHQ18493.npy +imgHQ01130.npy +imgHQ28731.npy +imgHQ00705.npy +imgHQ24196.npy +imgHQ03434.npy +imgHQ26750.npy +imgHQ12691.npy +imgHQ25022.npy +imgHQ01066.npy +imgHQ07896.npy +imgHQ27404.npy +imgHQ26604.npy +imgHQ01069.npy +imgHQ14486.npy +imgHQ22704.npy +imgHQ10461.npy +imgHQ20113.npy +imgHQ13444.npy +imgHQ07080.npy +imgHQ01026.npy +imgHQ19293.npy +imgHQ02648.npy +imgHQ08469.npy +imgHQ16298.npy +imgHQ18679.npy +imgHQ23792.npy +imgHQ05529.npy +imgHQ20808.npy +imgHQ26940.npy +imgHQ14302.npy +imgHQ13461.npy +imgHQ25779.npy +imgHQ22209.npy +imgHQ01588.npy +imgHQ29947.npy +imgHQ10755.npy +imgHQ08852.npy +imgHQ25689.npy +imgHQ05461.npy +imgHQ21976.npy +imgHQ15614.npy +imgHQ05502.npy +imgHQ02458.npy +imgHQ01201.npy +imgHQ12905.npy +imgHQ00974.npy +imgHQ14359.npy +imgHQ14327.npy +imgHQ29008.npy +imgHQ22501.npy +imgHQ21095.npy +imgHQ14783.npy +imgHQ15985.npy +imgHQ01565.npy +imgHQ06875.npy +imgHQ00121.npy +imgHQ04194.npy +imgHQ06316.npy +imgHQ00049.npy +imgHQ05097.npy +imgHQ15479.npy +imgHQ10945.npy +imgHQ02999.npy +imgHQ23062.npy +imgHQ16148.npy +imgHQ02792.npy +imgHQ09059.npy +imgHQ25528.npy +imgHQ23650.npy +imgHQ18597.npy +imgHQ04474.npy +imgHQ07850.npy +imgHQ27369.npy +imgHQ16764.npy +imgHQ17677.npy +imgHQ04863.npy +imgHQ26762.npy +imgHQ25088.npy +imgHQ06880.npy +imgHQ05025.npy +imgHQ19864.npy +imgHQ01076.npy +imgHQ26227.npy +imgHQ06051.npy +imgHQ10905.npy +imgHQ00815.npy +imgHQ04326.npy +imgHQ18229.npy +imgHQ12076.npy +imgHQ04896.npy +imgHQ17237.npy +imgHQ29566.npy +imgHQ09033.npy +imgHQ17835.npy +imgHQ28863.npy +imgHQ22565.npy +imgHQ03210.npy +imgHQ28730.npy +imgHQ13503.npy +imgHQ19961.npy +imgHQ18252.npy +imgHQ04138.npy +imgHQ05392.npy +imgHQ24562.npy +imgHQ14036.npy +imgHQ24186.npy +imgHQ03630.npy +imgHQ20193.npy +imgHQ02171.npy +imgHQ10407.npy +imgHQ10944.npy +imgHQ16827.npy +imgHQ00322.npy +imgHQ08846.npy +imgHQ27565.npy +imgHQ26158.npy +imgHQ14152.npy +imgHQ08369.npy +imgHQ00648.npy +imgHQ06477.npy +imgHQ17400.npy +imgHQ09080.npy +imgHQ18966.npy +imgHQ23680.npy +imgHQ02133.npy +imgHQ26954.npy +imgHQ17683.npy +imgHQ17651.npy +imgHQ13020.npy +imgHQ23228.npy +imgHQ28539.npy +imgHQ05101.npy +imgHQ10334.npy +imgHQ24700.npy +imgHQ01018.npy +imgHQ08699.npy +imgHQ05885.npy +imgHQ20599.npy +imgHQ00079.npy +imgHQ15951.npy +imgHQ19212.npy +imgHQ19466.npy +imgHQ25039.npy +imgHQ24387.npy +imgHQ11327.npy +imgHQ01371.npy +imgHQ09728.npy +imgHQ28962.npy +imgHQ07871.npy +imgHQ19452.npy +imgHQ14582.npy +imgHQ06064.npy +imgHQ24401.npy +imgHQ16053.npy +imgHQ16919.npy +imgHQ14357.npy +imgHQ17172.npy +imgHQ15879.npy +imgHQ06458.npy +imgHQ04970.npy +imgHQ04968.npy +imgHQ09641.npy +imgHQ28311.npy +imgHQ24424.npy +imgHQ16634.npy +imgHQ15861.npy +imgHQ06183.npy +imgHQ00330.npy +imgHQ15396.npy +imgHQ10258.npy +imgHQ19274.npy +imgHQ17674.npy +imgHQ13871.npy +imgHQ18495.npy +imgHQ01641.npy +imgHQ28748.npy +imgHQ14943.npy +imgHQ22667.npy +imgHQ11644.npy +imgHQ04588.npy +imgHQ22173.npy +imgHQ25226.npy +imgHQ26026.npy +imgHQ09521.npy +imgHQ06358.npy +imgHQ26615.npy +imgHQ11961.npy +imgHQ15624.npy +imgHQ01993.npy +imgHQ22035.npy +imgHQ09189.npy +imgHQ25357.npy +imgHQ09292.npy +imgHQ13911.npy +imgHQ02936.npy +imgHQ22409.npy +imgHQ06578.npy +imgHQ17242.npy +imgHQ12373.npy +imgHQ27348.npy +imgHQ07910.npy +imgHQ10707.npy +imgHQ05477.npy +imgHQ21214.npy +imgHQ08923.npy +imgHQ17288.npy +imgHQ21127.npy +imgHQ28056.npy +imgHQ13001.npy +imgHQ02166.npy +imgHQ19278.npy +imgHQ20684.npy +imgHQ07883.npy +imgHQ08945.npy +imgHQ20158.npy +imgHQ27478.npy +imgHQ14777.npy +imgHQ07232.npy +imgHQ04059.npy +imgHQ20316.npy +imgHQ01852.npy +imgHQ08892.npy +imgHQ19584.npy +imgHQ18645.npy +imgHQ21333.npy +imgHQ18347.npy +imgHQ22542.npy +imgHQ13487.npy +imgHQ28691.npy +imgHQ14691.npy +imgHQ02104.npy +imgHQ12820.npy +imgHQ00508.npy +imgHQ29036.npy +imgHQ00589.npy +imgHQ10754.npy +imgHQ17313.npy +imgHQ27349.npy +imgHQ01044.npy +imgHQ26520.npy +imgHQ15821.npy +imgHQ19453.npy +imgHQ04163.npy +imgHQ27402.npy +imgHQ25110.npy +imgHQ16374.npy +imgHQ10977.npy +imgHQ29635.npy +imgHQ13781.npy +imgHQ03021.npy +imgHQ25100.npy +imgHQ21805.npy +imgHQ05824.npy +imgHQ06861.npy +imgHQ21735.npy +imgHQ27159.npy +imgHQ23838.npy +imgHQ21773.npy +imgHQ11572.npy +imgHQ21016.npy +imgHQ29655.npy +imgHQ14529.npy +imgHQ13408.npy +imgHQ00948.npy +imgHQ23840.npy +imgHQ02080.npy +imgHQ03996.npy +imgHQ19983.npy +imgHQ10783.npy +imgHQ07311.npy +imgHQ22377.npy +imgHQ16877.npy +imgHQ07298.npy +imgHQ25313.npy +imgHQ03681.npy +imgHQ05349.npy +imgHQ01352.npy +imgHQ02764.npy +imgHQ09353.npy +imgHQ13638.npy +imgHQ19687.npy +imgHQ17948.npy +imgHQ20443.npy +imgHQ21370.npy +imgHQ05371.npy +imgHQ23284.npy +imgHQ18360.npy +imgHQ21866.npy +imgHQ04348.npy +imgHQ15893.npy +imgHQ25317.npy +imgHQ06608.npy +imgHQ11397.npy +imgHQ25539.npy +imgHQ18033.npy +imgHQ01329.npy +imgHQ19921.npy +imgHQ26199.npy +imgHQ16366.npy +imgHQ14046.npy +imgHQ18594.npy +imgHQ07387.npy +imgHQ25040.npy +imgHQ11037.npy +imgHQ01320.npy +imgHQ01727.npy +imgHQ11500.npy +imgHQ06646.npy +imgHQ05709.npy +imgHQ08902.npy +imgHQ04508.npy +imgHQ10422.npy +imgHQ08332.npy +imgHQ05154.npy +imgHQ06168.npy +imgHQ28673.npy +imgHQ00001.npy +imgHQ22212.npy +imgHQ08584.npy +imgHQ07275.npy +imgHQ18992.npy +imgHQ08524.npy +imgHQ02244.npy +imgHQ15811.npy +imgHQ19716.npy +imgHQ12922.npy +imgHQ12395.npy +imgHQ03029.npy +imgHQ20893.npy +imgHQ17748.npy +imgHQ04376.npy +imgHQ09896.npy +imgHQ22818.npy +imgHQ22396.npy +imgHQ17138.npy +imgHQ26807.npy +imgHQ03802.npy +imgHQ19389.npy +imgHQ05790.npy +imgHQ23313.npy +imgHQ12417.npy +imgHQ24295.npy +imgHQ26266.npy +imgHQ10142.npy +imgHQ07356.npy +imgHQ15168.npy +imgHQ18492.npy +imgHQ05619.npy +imgHQ22210.npy +imgHQ29075.npy +imgHQ24430.npy +imgHQ27519.npy +imgHQ13973.npy +imgHQ10443.npy +imgHQ12042.npy +imgHQ23342.npy +imgHQ14659.npy +imgHQ27090.npy +imgHQ24472.npy +imgHQ19063.npy +imgHQ28085.npy +imgHQ02032.npy +imgHQ25678.npy +imgHQ10948.npy +imgHQ21365.npy +imgHQ14354.npy +imgHQ17143.npy +imgHQ28235.npy +imgHQ08521.npy +imgHQ23739.npy +imgHQ17033.npy +imgHQ04487.npy +imgHQ07888.npy +imgHQ09775.npy +imgHQ13545.npy +imgHQ13876.npy +imgHQ24726.npy +imgHQ18288.npy +imgHQ21644.npy +imgHQ14746.npy +imgHQ27580.npy +imgHQ16562.npy +imgHQ05440.npy +imgHQ23148.npy +imgHQ07368.npy +imgHQ00382.npy +imgHQ13018.npy +imgHQ19245.npy +imgHQ27294.npy +imgHQ05942.npy +imgHQ16020.npy +imgHQ01828.npy +imgHQ28973.npy +imgHQ02481.npy +imgHQ03395.npy +imgHQ20506.npy +imgHQ19735.npy +imgHQ10245.npy +imgHQ21659.npy +imgHQ21887.npy +imgHQ10643.npy +imgHQ19417.npy +imgHQ07491.npy +imgHQ02197.npy +imgHQ15549.npy +imgHQ10577.npy +imgHQ05613.npy +imgHQ26876.npy +imgHQ12048.npy +imgHQ21369.npy +imgHQ09570.npy +imgHQ20537.npy +imgHQ15211.npy +imgHQ29347.npy +imgHQ23059.npy +imgHQ19591.npy +imgHQ17325.npy +imgHQ23560.npy +imgHQ20787.npy +imgHQ13567.npy +imgHQ00495.npy +imgHQ16302.npy +imgHQ09335.npy +imgHQ04560.npy +imgHQ20456.npy +imgHQ07927.npy +imgHQ00601.npy +imgHQ13536.npy +imgHQ22747.npy +imgHQ11047.npy +imgHQ06918.npy +imgHQ27606.npy +imgHQ13121.npy +imgHQ00253.npy +imgHQ25151.npy +imgHQ10549.npy +imgHQ09010.npy +imgHQ19811.npy +imgHQ27271.npy +imgHQ27258.npy +imgHQ03313.npy +imgHQ19294.npy +imgHQ05295.npy +imgHQ21540.npy +imgHQ11382.npy +imgHQ12924.npy +imgHQ20289.npy +imgHQ19728.npy +imgHQ27025.npy +imgHQ17718.npy +imgHQ01453.npy +imgHQ07510.npy +imgHQ27550.npy +imgHQ09667.npy +imgHQ16244.npy +imgHQ08236.npy +imgHQ20568.npy +imgHQ00759.npy +imgHQ09560.npy +imgHQ00927.npy +imgHQ15959.npy +imgHQ04391.npy +imgHQ29757.npy +imgHQ00464.npy +imgHQ01137.npy +imgHQ07929.npy +imgHQ16861.npy +imgHQ26635.npy +imgHQ24988.npy +imgHQ07317.npy +imgHQ14457.npy +imgHQ15465.npy +imgHQ10041.npy +imgHQ14630.npy +imgHQ04032.npy +imgHQ11058.npy +imgHQ02034.npy +imgHQ04431.npy +imgHQ11894.npy +imgHQ10237.npy +imgHQ21742.npy +imgHQ07410.npy +imgHQ21940.npy +imgHQ23605.npy +imgHQ28286.npy +imgHQ12067.npy +imgHQ27567.npy +imgHQ08401.npy +imgHQ05441.npy +imgHQ16494.npy +imgHQ08460.npy +imgHQ28415.npy +imgHQ25447.npy +imgHQ14714.npy +imgHQ16215.npy +imgHQ29932.npy +imgHQ15651.npy +imgHQ29151.npy +imgHQ17599.npy +imgHQ07620.npy +imgHQ07119.npy +imgHQ19161.npy +imgHQ00975.npy +imgHQ01583.npy +imgHQ08347.npy +imgHQ14548.npy +imgHQ26938.npy +imgHQ19035.npy +imgHQ13727.npy +imgHQ14234.npy +imgHQ15844.npy +imgHQ28086.npy +imgHQ22779.npy +imgHQ10695.npy +imgHQ27760.npy +imgHQ23819.npy +imgHQ04284.npy +imgHQ05391.npy +imgHQ26721.npy +imgHQ17200.npy +imgHQ27022.npy +imgHQ07983.npy +imgHQ06787.npy +imgHQ18828.npy +imgHQ29977.npy +imgHQ17220.npy +imgHQ00710.npy +imgHQ18251.npy +imgHQ22180.npy +imgHQ05730.npy +imgHQ09118.npy +imgHQ21520.npy +imgHQ15738.npy +imgHQ01801.npy +imgHQ05493.npy +imgHQ05786.npy +imgHQ14694.npy +imgHQ16753.npy +imgHQ15716.npy +imgHQ22000.npy +imgHQ14042.npy +imgHQ25773.npy +imgHQ29217.npy +imgHQ03645.npy +imgHQ12838.npy +imgHQ28535.npy +imgHQ25808.npy +imgHQ28701.npy +imgHQ11569.npy +imgHQ24133.npy +imgHQ09796.npy +imgHQ08431.npy +imgHQ14245.npy +imgHQ26421.npy +imgHQ25343.npy +imgHQ18894.npy +imgHQ23834.npy +imgHQ09065.npy +imgHQ24540.npy +imgHQ18576.npy +imgHQ06386.npy +imgHQ02875.npy +imgHQ11934.npy +imgHQ20990.npy +imgHQ29190.npy +imgHQ10069.npy +imgHQ00914.npy +imgHQ03077.npy +imgHQ01897.npy +imgHQ01450.npy +imgHQ11042.npy +imgHQ29878.npy +imgHQ19940.npy +imgHQ28208.npy +imgHQ24649.npy +imgHQ17653.npy +imgHQ08876.npy +imgHQ18717.npy +imgHQ12512.npy +imgHQ15527.npy +imgHQ08564.npy +imgHQ28491.npy +imgHQ29103.npy +imgHQ23045.npy +imgHQ00337.npy +imgHQ16986.npy +imgHQ17885.npy +imgHQ29792.npy +imgHQ16356.npy +imgHQ23705.npy +imgHQ13834.npy +imgHQ19924.npy +imgHQ21082.npy +imgHQ00150.npy +imgHQ13768.npy +imgHQ05232.npy +imgHQ13227.npy +imgHQ19776.npy +imgHQ21004.npy +imgHQ27894.npy +imgHQ29553.npy +imgHQ02963.npy +imgHQ07818.npy +imgHQ02805.npy +imgHQ29727.npy +imgHQ24006.npy +imgHQ14494.npy +imgHQ16555.npy +imgHQ12439.npy +imgHQ00762.npy +imgHQ01001.npy +imgHQ14364.npy +imgHQ29544.npy +imgHQ08594.npy +imgHQ14479.npy +imgHQ10879.npy +imgHQ18116.npy +imgHQ15571.npy +imgHQ12855.npy +imgHQ16745.npy +imgHQ22340.npy +imgHQ22764.npy +imgHQ01757.npy +imgHQ04797.npy +imgHQ12056.npy +imgHQ18367.npy +imgHQ16386.npy +imgHQ25654.npy +imgHQ06733.npy +imgHQ15634.npy +imgHQ00113.npy +imgHQ14270.npy +imgHQ08033.npy +imgHQ11015.npy +imgHQ11890.npy +imgHQ13339.npy +imgHQ24357.npy +imgHQ23759.npy +imgHQ23333.npy +imgHQ02172.npy +imgHQ29555.npy +imgHQ09678.npy +imgHQ19529.npy +imgHQ10270.npy +imgHQ06361.npy +imgHQ12535.npy +imgHQ27562.npy +imgHQ02910.npy +imgHQ23982.npy +imgHQ09781.npy +imgHQ26229.npy +imgHQ19376.npy +imgHQ27481.npy +imgHQ02597.npy +imgHQ12748.npy +imgHQ19970.npy +imgHQ06756.npy +imgHQ02699.npy +imgHQ19873.npy +imgHQ02924.npy +imgHQ09052.npy +imgHQ26516.npy +imgHQ26942.npy +imgHQ18962.npy +imgHQ19418.npy +imgHQ29853.npy +imgHQ17086.npy +imgHQ16203.npy +imgHQ25012.npy +imgHQ14622.npy +imgHQ12093.npy +imgHQ18314.npy +imgHQ07565.npy +imgHQ02035.npy +imgHQ13694.npy +imgHQ25223.npy +imgHQ27997.npy +imgHQ26829.npy +imgHQ03976.npy +imgHQ24841.npy +imgHQ02338.npy +imgHQ07804.npy +imgHQ23197.npy +imgHQ05505.npy +imgHQ13430.npy +imgHQ10894.npy +imgHQ11888.npy +imgHQ04317.npy +imgHQ11371.npy +imgHQ01285.npy +imgHQ10168.npy +imgHQ09104.npy +imgHQ26539.npy +imgHQ14011.npy +imgHQ12209.npy +imgHQ12122.npy +imgHQ03744.npy +imgHQ10048.npy +imgHQ22736.npy +imgHQ24588.npy +imgHQ00812.npy +imgHQ04257.npy +imgHQ18943.npy +imgHQ22257.npy +imgHQ20429.npy +imgHQ10678.npy +imgHQ10829.npy +imgHQ29277.npy +imgHQ18134.npy +imgHQ10616.npy +imgHQ28068.npy +imgHQ14528.npy +imgHQ00897.npy +imgHQ11523.npy +imgHQ10787.npy +imgHQ08787.npy +imgHQ06497.npy +imgHQ11104.npy +imgHQ15198.npy +imgHQ29872.npy +imgHQ13728.npy +imgHQ20152.npy +imgHQ05501.npy +imgHQ29536.npy +imgHQ13154.npy +imgHQ20546.npy +imgHQ09237.npy +imgHQ04334.npy +imgHQ29283.npy +imgHQ24033.npy +imgHQ19422.npy +imgHQ25549.npy +imgHQ23914.npy +imgHQ10617.npy +imgHQ08578.npy +imgHQ04624.npy +imgHQ27959.npy +imgHQ27916.npy +imgHQ12914.npy +imgHQ07236.npy +imgHQ00146.npy +imgHQ28001.npy +imgHQ12341.npy +imgHQ10437.npy +imgHQ12061.npy +imgHQ17522.npy +imgHQ14271.npy +imgHQ01901.npy +imgHQ29273.npy +imgHQ22333.npy +imgHQ22182.npy +imgHQ10993.npy +imgHQ18931.npy +imgHQ16848.npy +imgHQ15230.npy +imgHQ26354.npy +imgHQ11819.npy +imgHQ12149.npy +imgHQ28076.npy +imgHQ18405.npy +imgHQ15315.npy +imgHQ08073.npy +imgHQ00269.npy +imgHQ13110.npy +imgHQ20000.npy +imgHQ26518.npy +imgHQ10878.npy +imgHQ10604.npy +imgHQ00352.npy +imgHQ18083.npy +imgHQ23655.npy +imgHQ07028.npy +imgHQ00653.npy +imgHQ13165.npy +imgHQ15277.npy +imgHQ01748.npy +imgHQ06107.npy +imgHQ09897.npy +imgHQ10717.npy +imgHQ07441.npy +imgHQ24170.npy +imgHQ07494.npy +imgHQ02345.npy +imgHQ24890.npy +imgHQ13899.npy +imgHQ26541.npy +imgHQ26417.npy +imgHQ27432.npy +imgHQ21993.npy +imgHQ07839.npy +imgHQ24019.npy +imgHQ21794.npy +imgHQ29123.npy +imgHQ07335.npy +imgHQ24250.npy +imgHQ22615.npy +imgHQ01857.npy +imgHQ19348.npy +imgHQ26255.npy +imgHQ06408.npy +imgHQ06383.npy +imgHQ17957.npy +imgHQ13277.npy +imgHQ12266.npy +imgHQ05219.npy +imgHQ11178.npy +imgHQ13885.npy +imgHQ27547.npy +imgHQ02357.npy +imgHQ16856.npy +imgHQ16650.npy +imgHQ20558.npy +imgHQ05753.npy +imgHQ20815.npy +imgHQ26378.npy +imgHQ10074.npy +imgHQ00457.npy +imgHQ17368.npy +imgHQ19058.npy +imgHQ17178.npy +imgHQ05079.npy +imgHQ03033.npy +imgHQ23037.npy +imgHQ19299.npy +imgHQ22372.npy +imgHQ11622.npy +imgHQ24156.npy +imgHQ07808.npy +imgHQ00951.npy +imgHQ07376.npy +imgHQ02703.npy +imgHQ20604.npy +imgHQ08761.npy +imgHQ29795.npy +imgHQ18403.npy +imgHQ16536.npy +imgHQ23215.npy +imgHQ27274.npy +imgHQ16361.npy +imgHQ10007.npy +imgHQ17386.npy +imgHQ08331.npy +imgHQ06148.npy +imgHQ28663.npy +imgHQ18889.npy +imgHQ01873.npy +imgHQ18518.npy +imgHQ21601.npy +imgHQ28127.npy +imgHQ07509.npy +imgHQ21126.npy +imgHQ27610.npy +imgHQ26372.npy +imgHQ01039.npy +imgHQ20653.npy +imgHQ29525.npy +imgHQ10937.npy +imgHQ21983.npy +imgHQ29451.npy +imgHQ19583.npy +imgHQ10807.npy +imgHQ16112.npy +imgHQ26459.npy +imgHQ03016.npy +imgHQ24259.npy +imgHQ14315.npy +imgHQ12028.npy +imgHQ18391.npy +imgHQ18336.npy +imgHQ27449.npy +imgHQ20942.npy +imgHQ05165.npy +imgHQ06947.npy +imgHQ16853.npy +imgHQ09255.npy +imgHQ01229.npy +imgHQ17378.npy +imgHQ27033.npy +imgHQ29579.npy +imgHQ27731.npy +imgHQ19358.npy +imgHQ10274.npy +imgHQ06341.npy +imgHQ24936.npy +imgHQ27837.npy +imgHQ14833.npy +imgHQ23822.npy +imgHQ24017.npy +imgHQ22395.npy +imgHQ10281.npy +imgHQ12660.npy +imgHQ12157.npy +imgHQ18690.npy +imgHQ07433.npy +imgHQ14996.npy +imgHQ23470.npy +imgHQ20409.npy +imgHQ10498.npy +imgHQ27750.npy +imgHQ01043.npy +imgHQ10724.npy +imgHQ11004.npy +imgHQ11158.npy +imgHQ07858.npy +imgHQ11785.npy +imgHQ02958.npy +imgHQ28790.npy +imgHQ24214.npy +imgHQ29330.npy +imgHQ05385.npy +imgHQ24626.npy +imgHQ25725.npy +imgHQ08886.npy +imgHQ11182.npy +imgHQ15054.npy +imgHQ03773.npy +imgHQ01253.npy +imgHQ17016.npy +imgHQ28071.npy +imgHQ18387.npy +imgHQ26525.npy +imgHQ26163.npy +imgHQ15573.npy +imgHQ25567.npy +imgHQ25325.npy +imgHQ17537.npy +imgHQ20467.npy +imgHQ20603.npy +imgHQ21116.npy +imgHQ02381.npy +imgHQ15516.npy +imgHQ18744.npy +imgHQ21323.npy +imgHQ20420.npy +imgHQ11576.npy +imgHQ07822.npy +imgHQ15257.npy +imgHQ13725.npy +imgHQ17670.npy +imgHQ10917.npy +imgHQ12105.npy +imgHQ26489.npy +imgHQ11846.npy +imgHQ29234.npy +imgHQ09388.npy +imgHQ15285.npy +imgHQ03853.npy +imgHQ15206.npy +imgHQ23068.npy +imgHQ01487.npy +imgHQ12063.npy +imgHQ21092.npy +imgHQ03230.npy +imgHQ16938.npy +imgHQ09812.npy +imgHQ21279.npy +imgHQ08982.npy +imgHQ12637.npy +imgHQ04434.npy +imgHQ24204.npy +imgHQ27953.npy +imgHQ20164.npy +imgHQ07035.npy +imgHQ06513.npy +imgHQ14491.npy +imgHQ24501.npy +imgHQ14970.npy +imgHQ05482.npy +imgHQ07488.npy +imgHQ05859.npy +imgHQ04747.npy +imgHQ24084.npy +imgHQ07455.npy +imgHQ24396.npy +imgHQ23330.npy +imgHQ05050.npy +imgHQ02790.npy +imgHQ23372.npy +imgHQ23153.npy +imgHQ13776.npy +imgHQ04620.npy +imgHQ16570.npy +imgHQ08493.npy +imgHQ14499.npy +imgHQ09472.npy +imgHQ12156.npy +imgHQ24245.npy +imgHQ13413.npy +imgHQ19714.npy +imgHQ13225.npy +imgHQ09268.npy +imgHQ11881.npy +imgHQ15175.npy +imgHQ07597.npy +imgHQ17541.npy +imgHQ29380.npy +imgHQ27906.npy +imgHQ15664.npy +imgHQ10110.npy +imgHQ13577.npy +imgHQ02082.npy +imgHQ17589.npy +imgHQ15665.npy +imgHQ23026.npy +imgHQ22243.npy +imgHQ13806.npy +imgHQ29186.npy +imgHQ11308.npy +imgHQ14114.npy +imgHQ24732.npy +imgHQ18289.npy +imgHQ16641.npy +imgHQ08900.npy +imgHQ10599.npy +imgHQ12223.npy +imgHQ29268.npy +imgHQ05522.npy +imgHQ08267.npy +imgHQ14521.npy +imgHQ27359.npy +imgHQ15584.npy +imgHQ28760.npy +imgHQ23335.npy +imgHQ05586.npy +imgHQ08990.npy +imgHQ16787.npy +imgHQ09749.npy +imgHQ07405.npy +imgHQ00023.npy +imgHQ29290.npy +imgHQ17365.npy +imgHQ11039.npy +imgHQ04018.npy +imgHQ14665.npy +imgHQ04042.npy +imgHQ21929.npy +imgHQ11882.npy +imgHQ28275.npy +imgHQ21832.npy +imgHQ06782.npy +imgHQ18812.npy +imgHQ23620.npy +imgHQ24664.npy +imgHQ29540.npy +imgHQ23953.npy +imgHQ08434.npy +imgHQ22141.npy +imgHQ20891.npy +imgHQ08095.npy +imgHQ02847.npy +imgHQ10017.npy +imgHQ07371.npy +imgHQ12771.npy +imgHQ01336.npy +imgHQ20366.npy +imgHQ02914.npy +imgHQ07111.npy +imgHQ26960.npy +imgHQ14300.npy +imgHQ28006.npy +imgHQ13296.npy +imgHQ12530.npy +imgHQ00522.npy +imgHQ03149.npy +imgHQ28484.npy +imgHQ28273.npy +imgHQ01818.npy +imgHQ11546.npy +imgHQ20027.npy +imgHQ10692.npy +imgHQ07833.npy +imgHQ25096.npy +imgHQ22022.npy +imgHQ14063.npy +imgHQ29601.npy +imgHQ01360.npy +imgHQ15482.npy +imgHQ20450.npy +imgHQ18043.npy +imgHQ23469.npy +imgHQ15637.npy +imgHQ18829.npy +imgHQ09157.npy +imgHQ07689.npy +imgHQ11213.npy +imgHQ19587.npy +imgHQ28206.npy +imgHQ09995.npy +imgHQ13415.npy +imgHQ18309.npy +imgHQ15524.npy +imgHQ29129.npy +imgHQ11165.npy +imgHQ09379.npy +imgHQ05333.npy +imgHQ08362.npy +imgHQ24346.npy +imgHQ08682.npy +imgHQ03714.npy +imgHQ14966.npy +imgHQ26843.npy +imgHQ28233.npy +imgHQ27076.npy +imgHQ07686.npy +imgHQ21791.npy +imgHQ23615.npy +imgHQ06042.npy +imgHQ27242.npy +imgHQ09355.npy +imgHQ05655.npy +imgHQ29914.npy +imgHQ02038.npy +imgHQ11551.npy +imgHQ16358.npy +imgHQ01111.npy +imgHQ18346.npy +imgHQ08673.npy +imgHQ00640.npy +imgHQ17710.npy +imgHQ18462.npy +imgHQ12787.npy +imgHQ26300.npy +imgHQ08557.npy +imgHQ10830.npy +imgHQ03888.npy +imgHQ02662.npy +imgHQ29015.npy +imgHQ26767.npy +imgHQ26507.npy +imgHQ15199.npy +imgHQ11529.npy +imgHQ23958.npy +imgHQ29506.npy +imgHQ10904.npy +imgHQ08138.npy +imgHQ24363.npy +imgHQ29177.npy +imgHQ07594.npy +imgHQ00471.npy +imgHQ15060.npy +imgHQ03004.npy +imgHQ27329.npy +imgHQ21627.npy +imgHQ21630.npy +imgHQ17765.npy +imgHQ07396.npy +imgHQ12998.npy +imgHQ09076.npy +imgHQ19515.npy +imgHQ13438.npy +imgHQ01891.npy +imgHQ18217.npy +imgHQ28215.npy +imgHQ11782.npy +imgHQ08076.npy +imgHQ09550.npy +imgHQ13156.npy +imgHQ15183.npy +imgHQ08883.npy +imgHQ04951.npy +imgHQ17474.npy +imgHQ11071.npy +imgHQ27770.npy +imgHQ25141.npy +imgHQ03042.npy +imgHQ28683.npy +imgHQ13797.npy +imgHQ24087.npy +imgHQ13187.npy +imgHQ10457.npy +imgHQ29236.npy +imgHQ27413.npy +imgHQ12041.npy +imgHQ04004.npy +imgHQ10589.npy +imgHQ24674.npy +imgHQ01608.npy +imgHQ10550.npy +imgHQ00582.npy +imgHQ09926.npy +imgHQ20390.npy +imgHQ03005.npy +imgHQ13793.npy +imgHQ14138.npy +imgHQ13301.npy +imgHQ18514.npy +imgHQ03550.npy +imgHQ04964.npy +imgHQ07519.npy +imgHQ21546.npy +imgHQ27801.npy +imgHQ29027.npy +imgHQ16417.npy +imgHQ26100.npy +imgHQ28807.npy +imgHQ18090.npy +imgHQ29523.npy +imgHQ05075.npy +imgHQ24591.npy +imgHQ24036.npy +imgHQ16935.npy +imgHQ21002.npy +imgHQ19833.npy +imgHQ14505.npy +imgHQ07501.npy +imgHQ08679.npy +imgHQ23310.npy +imgHQ18135.npy +imgHQ14874.npy +imgHQ02147.npy +imgHQ07942.npy +imgHQ15518.npy +imgHQ27397.npy +imgHQ26050.npy +imgHQ23744.npy +imgHQ13651.npy +imgHQ13634.npy +imgHQ27552.npy +imgHQ01704.npy +imgHQ06685.npy +imgHQ00195.npy +imgHQ27026.npy +imgHQ10359.npy +imgHQ18873.npy +imgHQ24166.npy +imgHQ18547.npy +imgHQ07221.npy +imgHQ19146.npy +imgHQ25060.npy +imgHQ16435.npy +imgHQ16348.npy +imgHQ23453.npy +imgHQ05133.npy +imgHQ25716.npy +imgHQ26964.npy +imgHQ18994.npy +imgHQ24450.npy +imgHQ06592.npy +imgHQ01997.npy +imgHQ17784.npy +imgHQ19241.npy +imgHQ13130.npy +imgHQ03869.npy +imgHQ27709.npy +imgHQ06396.npy +imgHQ05626.npy +imgHQ12850.npy +imgHQ01792.npy +imgHQ07022.npy +imgHQ28474.npy +imgHQ17536.npy +imgHQ18160.npy +imgHQ00040.npy +imgHQ29237.npy +imgHQ19727.npy +imgHQ24796.npy +imgHQ29377.npy +imgHQ06104.npy +imgHQ24967.npy +imgHQ06245.npy +imgHQ17146.npy +imgHQ09165.npy +imgHQ24451.npy +imgHQ25419.npy +imgHQ01946.npy +imgHQ14000.npy +imgHQ27474.npy +imgHQ25651.npy +imgHQ04331.npy +imgHQ01407.npy +imgHQ19853.npy +imgHQ29516.npy +imgHQ12086.npy +imgHQ28685.npy +imgHQ13884.npy +imgHQ00547.npy +imgHQ22324.npy +imgHQ18978.npy +imgHQ28989.npy +imgHQ17907.npy +imgHQ04743.npy +imgHQ14586.npy +imgHQ26424.npy +imgHQ03723.npy +imgHQ21093.npy +imgHQ10144.npy +imgHQ29838.npy +imgHQ04023.npy +imgHQ03658.npy +imgHQ08847.npy +imgHQ11337.npy +imgHQ19941.npy +imgHQ22848.npy +imgHQ18845.npy +imgHQ24497.npy +imgHQ13514.npy +imgHQ18581.npy +imgHQ02298.npy +imgHQ07143.npy +imgHQ13902.npy +imgHQ18030.npy +imgHQ08899.npy +imgHQ18564.npy +imgHQ22392.npy +imgHQ14266.npy +imgHQ16410.npy +imgHQ01938.npy +imgHQ13266.npy +imgHQ20717.npy +imgHQ10455.npy +imgHQ11802.npy +imgHQ08335.npy +imgHQ21719.npy +imgHQ01620.npy +imgHQ22773.npy +imgHQ17922.npy +imgHQ06927.npy +imgHQ09544.npy +imgHQ12912.npy +imgHQ17572.npy +imgHQ16773.npy +imgHQ05450.npy +imgHQ27043.npy +imgHQ16402.npy +imgHQ06041.npy +imgHQ29477.npy +imgHQ25032.npy +imgHQ06701.npy +imgHQ13635.npy +imgHQ14352.npy +imgHQ07382.npy +imgHQ16199.npy +imgHQ20278.npy +imgHQ13039.npy +imgHQ24272.npy +imgHQ27465.npy +imgHQ00570.npy +imgHQ28619.npy +imgHQ29500.npy +imgHQ05530.npy +imgHQ05436.npy +imgHQ14476.npy +imgHQ00793.npy +imgHQ00053.npy +imgHQ02467.npy +imgHQ13896.npy +imgHQ13613.npy +imgHQ14945.npy +imgHQ21415.npy +imgHQ25397.npy +imgHQ15987.npy +imgHQ18708.npy +imgHQ08376.npy +imgHQ05221.npy +imgHQ05383.npy +imgHQ09535.npy +imgHQ25685.npy +imgHQ23916.npy +imgHQ14292.npy +imgHQ00675.npy +imgHQ01445.npy +imgHQ29384.npy +imgHQ10475.npy +imgHQ02949.npy +imgHQ27323.npy +imgHQ08271.npy +imgHQ01888.npy +imgHQ07462.npy +imgHQ16351.npy +imgHQ18270.npy +imgHQ05428.npy +imgHQ01781.npy +imgHQ05659.npy +imgHQ23711.npy +imgHQ20972.npy +imgHQ12667.npy +imgHQ21689.npy +imgHQ09087.npy +imgHQ11242.npy +imgHQ17900.npy +imgHQ18264.npy +imgHQ02497.npy +imgHQ24750.npy +imgHQ06732.npy +imgHQ27576.npy +imgHQ24998.npy +imgHQ26947.npy +imgHQ09111.npy +imgHQ12153.npy +imgHQ15559.npy +imgHQ13622.npy +imgHQ04280.npy +imgHQ15989.npy +imgHQ15521.npy +imgHQ09889.npy +imgHQ07032.npy +imgHQ04924.npy +imgHQ07018.npy +imgHQ19660.npy +imgHQ04989.npy +imgHQ22803.npy +imgHQ23259.npy +imgHQ22166.npy +imgHQ19930.npy +imgHQ02024.npy +imgHQ21474.npy +imgHQ26499.npy +imgHQ05303.npy +imgHQ09768.npy +imgHQ12204.npy +imgHQ29928.npy +imgHQ23337.npy +imgHQ14387.npy +imgHQ09971.npy +imgHQ03124.npy +imgHQ14080.npy +imgHQ20552.npy +imgHQ13112.npy +imgHQ17190.npy +imgHQ15778.npy +imgHQ26027.npy +imgHQ25557.npy +imgHQ17678.npy +imgHQ02979.npy +imgHQ03602.npy +imgHQ19072.npy +imgHQ01510.npy +imgHQ15763.npy +imgHQ05176.npy +imgHQ18305.npy +imgHQ22398.npy +imgHQ27589.npy +imgHQ05958.npy +imgHQ16476.npy +imgHQ24225.npy +imgHQ16635.npy +imgHQ18707.npy +imgHQ16552.npy +imgHQ25670.npy +imgHQ26913.npy +imgHQ07997.npy +imgHQ04679.npy +imgHQ18086.npy +imgHQ03058.npy +imgHQ18424.npy +imgHQ02640.npy +imgHQ14989.npy +imgHQ08941.npy +imgHQ25754.npy +imgHQ15574.npy +imgHQ21462.npy +imgHQ21536.npy +imgHQ07660.npy +imgHQ25703.npy +imgHQ04539.npy +imgHQ28690.npy +imgHQ15308.npy +imgHQ00769.npy +imgHQ10854.npy +imgHQ00378.npy +imgHQ26311.npy +imgHQ29274.npy +imgHQ03811.npy +imgHQ16340.npy +imgHQ07547.npy +imgHQ07706.npy +imgHQ21935.npy +imgHQ26905.npy +imgHQ14368.npy +imgHQ14794.npy +imgHQ15601.npy +imgHQ25806.npy +imgHQ00822.npy +imgHQ08495.npy +imgHQ26408.npy +imgHQ17514.npy +imgHQ17650.npy +imgHQ13842.npy +imgHQ14598.npy +imgHQ23351.npy +imgHQ00420.npy +imgHQ21439.npy +imgHQ21100.npy +imgHQ05089.npy +imgHQ14648.npy +imgHQ09367.npy +imgHQ03628.npy +imgHQ13594.npy +imgHQ21404.npy +imgHQ22556.npy +imgHQ25578.npy +imgHQ19409.npy +imgHQ12374.npy +imgHQ02541.npy +imgHQ18190.npy +imgHQ12731.npy +imgHQ14134.npy +imgHQ28743.npy +imgHQ28799.npy +imgHQ19707.npy +imgHQ24316.npy +imgHQ29463.npy +imgHQ16726.npy +imgHQ07732.npy +imgHQ03620.npy +imgHQ11231.npy +imgHQ11403.npy +imgHQ08174.npy +imgHQ04200.npy +imgHQ00413.npy +imgHQ21146.npy +imgHQ06665.npy +imgHQ10390.npy +imgHQ15502.npy +imgHQ05550.npy +imgHQ05511.npy +imgHQ18815.npy +imgHQ03345.npy +imgHQ14719.npy +imgHQ15293.npy +imgHQ06409.npy +imgHQ17635.npy +imgHQ29406.npy +imgHQ09357.npy +imgHQ29606.npy +imgHQ01232.npy +imgHQ29152.npy +imgHQ09320.npy +imgHQ17032.npy +imgHQ26623.npy +imgHQ15539.npy +imgHQ03404.npy +imgHQ05354.npy +imgHQ19965.npy +imgHQ16499.npy +imgHQ15550.npy +imgHQ17233.npy +imgHQ16583.npy +imgHQ25479.npy +imgHQ06736.npy +imgHQ24575.npy +imgHQ18301.npy +imgHQ13661.npy +imgHQ13026.npy +imgHQ25147.npy +imgHQ05751.npy +imgHQ23678.npy +imgHQ28532.npy +imgHQ10299.npy +imgHQ09558.npy +imgHQ07163.npy +imgHQ21425.npy +imgHQ15859.npy +imgHQ26697.npy +imgHQ22784.npy +imgHQ17501.npy +imgHQ21996.npy +imgHQ12037.npy +imgHQ21241.npy +imgHQ01098.npy +imgHQ02387.npy +imgHQ05041.npy +imgHQ11000.npy +imgHQ16027.npy +imgHQ23261.npy +imgHQ03236.npy +imgHQ16462.npy +imgHQ22999.npy +imgHQ24710.npy +imgHQ24628.npy +imgHQ18428.npy +imgHQ00241.npy +imgHQ11394.npy +imgHQ04517.npy +imgHQ08630.npy +imgHQ21236.npy +imgHQ29721.npy +imgHQ03975.npy +imgHQ08628.npy +imgHQ06818.npy +imgHQ11424.npy +imgHQ27310.npy +imgHQ08826.npy +imgHQ14800.npy +imgHQ06964.npy +imgHQ18784.npy +imgHQ00192.npy +imgHQ18486.npy +imgHQ08987.npy +imgHQ01188.npy +imgHQ10866.npy +imgHQ17201.npy +imgHQ05520.npy +imgHQ24860.npy +imgHQ14865.npy +imgHQ26042.npy +imgHQ04876.npy +imgHQ10317.npy +imgHQ11776.npy +imgHQ05160.npy +imgHQ21058.npy +imgHQ25938.npy +imgHQ29134.npy +imgHQ18304.npy +imgHQ23217.npy +imgHQ23166.npy +imgHQ22851.npy +imgHQ09850.npy +imgHQ21339.npy +imgHQ20502.npy +imgHQ18712.npy +imgHQ15449.npy +imgHQ04203.npy +imgHQ09629.npy +imgHQ14088.npy +imgHQ24781.npy +imgHQ15466.npy +imgHQ02193.npy +imgHQ06494.npy +imgHQ17713.npy +imgHQ06633.npy +imgHQ25737.npy +imgHQ18435.npy +imgHQ15093.npy +imgHQ12829.npy +imgHQ19778.npy +imgHQ12989.npy +imgHQ07755.npy +imgHQ01485.npy +imgHQ07101.npy +imgHQ26394.npy +imgHQ29784.npy +imgHQ26386.npy +imgHQ00539.npy +imgHQ07372.npy +imgHQ02956.npy +imgHQ14264.npy +imgHQ22023.npy +imgHQ03267.npy +imgHQ14706.npy +imgHQ25465.npy +imgHQ23950.npy +imgHQ24631.npy +imgHQ25907.npy +imgHQ23095.npy +imgHQ04299.npy +imgHQ21178.npy +imgHQ06557.npy +imgHQ24586.npy +imgHQ08629.npy +imgHQ24651.npy +imgHQ09673.npy +imgHQ14060.npy +imgHQ07247.npy +imgHQ14695.npy +imgHQ08905.npy +imgHQ04155.npy +imgHQ20549.npy +imgHQ21625.npy +imgHQ19553.npy +imgHQ23559.npy +imgHQ00058.npy +imgHQ18985.npy +imgHQ24756.npy +imgHQ05746.npy +imgHQ17995.npy +imgHQ12399.npy +imgHQ00745.npy +imgHQ06577.npy +imgHQ16110.npy +imgHQ23477.npy +imgHQ25984.npy +imgHQ27160.npy +imgHQ17387.npy +imgHQ03466.npy +imgHQ29492.npy +imgHQ22620.npy +imgHQ26047.npy +imgHQ00127.npy +imgHQ19290.npy +imgHQ07190.npy +imgHQ04593.npy +imgHQ17414.npy +imgHQ26310.npy +imgHQ01533.npy +imgHQ16097.npy +imgHQ19915.npy +imgHQ01586.npy +imgHQ25248.npy +imgHQ16905.npy +imgHQ18028.npy +imgHQ25276.npy +imgHQ10709.npy +imgHQ09215.npy +imgHQ21170.npy +imgHQ19037.npy +imgHQ22628.npy +imgHQ12411.npy +imgHQ25181.npy +imgHQ28981.npy +imgHQ18922.npy +imgHQ01978.npy +imgHQ23460.npy +imgHQ05559.npy +imgHQ25607.npy +imgHQ22984.npy +imgHQ13794.npy +imgHQ06257.npy +imgHQ07618.npy +imgHQ15887.npy +imgHQ03960.npy +imgHQ27020.npy +imgHQ27925.npy +imgHQ07714.npy +imgHQ11698.npy +imgHQ13918.npy +imgHQ18687.npy +imgHQ27165.npy +imgHQ20356.npy +imgHQ29950.npy +imgHQ03476.npy +imgHQ24771.npy +imgHQ28792.npy +imgHQ29589.npy +imgHQ22321.npy +imgHQ25123.npy +imgHQ02437.npy +imgHQ03203.npy +imgHQ01590.npy +imgHQ04511.npy +imgHQ21461.npy +imgHQ14525.npy +imgHQ07173.npy +imgHQ29199.npy +imgHQ18688.npy +imgHQ15484.npy +imgHQ05297.npy +imgHQ25500.npy +imgHQ08172.npy +imgHQ29272.npy +imgHQ11246.npy +imgHQ23086.npy +imgHQ17601.npy +imgHQ07586.npy +imgHQ06067.npy +imgHQ25424.npy +imgHQ10513.npy +imgHQ07693.npy +imgHQ06987.npy +imgHQ12934.npy +imgHQ14212.npy +imgHQ05925.npy +imgHQ21431.npy +imgHQ20030.npy +imgHQ10393.npy +imgHQ09318.npy +imgHQ09086.npy +imgHQ19311.npy +imgHQ27308.npy +imgHQ05583.npy +imgHQ14366.npy +imgHQ01427.npy +imgHQ00583.npy +imgHQ25143.npy +imgHQ11113.npy +imgHQ06363.npy +imgHQ17355.npy +imgHQ03972.npy +imgHQ10272.npy +imgHQ03771.npy +imgHQ22802.npy +imgHQ11492.npy +imgHQ13074.npy +imgHQ00318.npy +imgHQ08277.npy +imgHQ24158.npy +imgHQ18422.npy +imgHQ23625.npy +imgHQ27636.npy +imgHQ24182.npy +imgHQ25733.npy +imgHQ18990.npy +imgHQ03632.npy +imgHQ24576.npy +imgHQ11693.npy +imgHQ13282.npy +imgHQ00372.npy +imgHQ03730.npy +imgHQ15843.npy +imgHQ10182.npy +imgHQ23004.npy +imgHQ29892.npy +imgHQ03465.npy +imgHQ16186.npy +imgHQ17015.npy +imgHQ15742.npy +imgHQ04631.npy +imgHQ11354.npy +imgHQ03409.npy +imgHQ13989.npy +imgHQ13959.npy +imgHQ06050.npy +imgHQ11794.npy +imgHQ24804.npy +imgHQ16682.npy +imgHQ14219.npy +imgHQ10991.npy +imgHQ29212.npy +imgHQ10641.npy +imgHQ23273.npy +imgHQ20092.npy +imgHQ09387.npy +imgHQ17632.npy +imgHQ28650.npy +imgHQ24904.npy +imgHQ29891.npy +imgHQ07595.npy +imgHQ29571.npy +imgHQ23968.npy +imgHQ04817.npy +imgHQ28543.npy +imgHQ05091.npy +imgHQ03867.npy +imgHQ02576.npy +imgHQ19432.npy +imgHQ27347.npy +imgHQ02781.npy +imgHQ16488.npy +imgHQ20432.npy +imgHQ17219.npy +imgHQ06436.npy +imgHQ07844.npy +imgHQ17129.npy +imgHQ02952.npy +imgHQ25340.npy +imgHQ26012.npy +imgHQ19350.npy +imgHQ04080.npy +imgHQ28593.npy +imgHQ09187.npy +imgHQ25891.npy +imgHQ11160.npy +imgHQ05772.npy +imgHQ24228.npy +imgHQ10326.npy +imgHQ00743.npy +imgHQ23773.npy +imgHQ21890.npy +imgHQ26552.npy +imgHQ11132.npy +imgHQ19114.npy +imgHQ15956.npy +imgHQ01876.npy +imgHQ26694.npy +imgHQ17669.npy +imgHQ00051.npy +imgHQ29435.npy +imgHQ26817.npy +imgHQ05521.npy +imgHQ19248.npy +imgHQ05571.npy +imgHQ05667.npy +imgHQ01931.npy +imgHQ00555.npy +imgHQ26600.npy +imgHQ08855.npy +imgHQ14112.npy +imgHQ17159.npy +imgHQ27555.npy +imgHQ25950.npy +imgHQ18383.npy +imgHQ23263.npy +imgHQ16443.npy +imgHQ22264.npy +imgHQ26364.npy +imgHQ25314.npy +imgHQ28003.npy +imgHQ24546.npy +imgHQ03048.npy +imgHQ17839.npy +imgHQ27949.npy +imgHQ18034.npy +imgHQ19969.npy +imgHQ24367.npy +imgHQ04162.npy +imgHQ04848.npy +imgHQ07106.npy +imgHQ26296.npy +imgHQ18247.npy +imgHQ19491.npy +imgHQ16922.npy +imgHQ24157.npy +imgHQ13246.npy +imgHQ05763.npy +imgHQ03462.npy +imgHQ20139.npy +imgHQ05241.npy +imgHQ09819.npy +imgHQ01282.npy +imgHQ27305.npy +imgHQ00385.npy +imgHQ14904.npy +imgHQ29316.npy +imgHQ04760.npy +imgHQ08764.npy +imgHQ11775.npy +imgHQ27250.npy +imgHQ16434.npy +imgHQ16825.npy +imgHQ29738.npy +imgHQ11063.npy +imgHQ28891.npy +imgHQ08814.npy +imgHQ13624.npy +imgHQ03778.npy +imgHQ16957.npy +imgHQ06939.npy +imgHQ24144.npy +imgHQ02633.npy +imgHQ27313.npy +imgHQ08050.npy +imgHQ03474.npy +imgHQ09141.npy +imgHQ07503.npy +imgHQ16079.npy +imgHQ21648.npy +imgHQ05957.npy +imgHQ17369.npy +imgHQ17358.npy +imgHQ12761.npy +imgHQ17213.npy +imgHQ00599.npy +imgHQ17826.npy +imgHQ27377.npy +imgHQ25158.npy +imgHQ13217.npy +imgHQ00987.npy +imgHQ13309.npy +imgHQ27827.npy +imgHQ00414.npy +imgHQ22907.npy +imgHQ24654.npy +imgHQ18532.npy +imgHQ23269.npy +imgHQ06568.npy +imgHQ00030.npy +imgHQ26856.npy +imgHQ11665.npy +imgHQ29244.npy +imgHQ02063.npy +imgHQ02850.npy +imgHQ29543.npy +imgHQ27754.npy +imgHQ05970.npy +imgHQ04102.npy +imgHQ03956.npy +imgHQ12596.npy +imgHQ28022.npy +imgHQ17937.npy +imgHQ21957.npy +imgHQ25034.npy +imgHQ24931.npy +imgHQ03344.npy +imgHQ24043.npy +imgHQ11376.npy +imgHQ27942.npy +imgHQ05795.npy +imgHQ21038.npy +imgHQ00924.npy +imgHQ29844.npy +imgHQ07966.npy +imgHQ08920.npy +imgHQ20273.npy +imgHQ05434.npy +imgHQ06627.npy +imgHQ15646.npy +imgHQ18869.npy +imgHQ05670.npy +imgHQ05812.npy +imgHQ01775.npy +imgHQ08526.npy +imgHQ02030.npy +imgHQ15486.npy +imgHQ21826.npy +imgHQ26331.npy +imgHQ28950.npy +imgHQ12408.npy +imgHQ19701.npy +imgHQ18725.npy +imgHQ28511.npy +imgHQ13780.npy +imgHQ12798.npy +imgHQ11701.npy +imgHQ05743.npy +imgHQ14778.npy +imgHQ17701.npy +imgHQ18448.npy +imgHQ01309.npy +imgHQ10255.npy +imgHQ29120.npy +imgHQ05293.npy +imgHQ27167.npy +imgHQ20412.npy +imgHQ13525.npy +imgHQ23356.npy +imgHQ11634.npy +imgHQ22138.npy +imgHQ21359.npy +imgHQ06850.npy +imgHQ09399.npy +imgHQ13581.npy +imgHQ04749.npy +imgHQ05646.npy +imgHQ05519.npy +imgHQ11584.npy +imgHQ03600.npy +imgHQ20298.npy +imgHQ06123.npy +imgHQ23393.npy +imgHQ15188.npy +imgHQ26704.npy +imgHQ25483.npy +imgHQ05278.npy +imgHQ17742.npy +imgHQ21213.npy +imgHQ03604.npy +imgHQ09765.npy +imgHQ25763.npy +imgHQ23750.npy +imgHQ11870.npy +imgHQ01616.npy +imgHQ08166.npy +imgHQ11463.npy +imgHQ05453.npy +imgHQ03283.npy +imgHQ09075.npy +imgHQ17418.npy +imgHQ02710.npy +imgHQ04622.npy +imgHQ05755.npy +imgHQ10514.npy +imgHQ20595.npy +imgHQ09791.npy +imgHQ02740.npy +imgHQ10765.npy +imgHQ06984.npy +imgHQ27345.npy +imgHQ15545.npy +imgHQ16188.npy +imgHQ18895.npy +imgHQ21222.npy +imgHQ11694.npy +imgHQ27157.npy +imgHQ05175.npy +imgHQ00340.npy +imgHQ22555.npy +imgHQ08198.npy +imgHQ03914.npy +imgHQ23528.npy +imgHQ20673.npy +imgHQ15242.npy +imgHQ18316.npy +imgHQ07087.npy +imgHQ20275.npy +imgHQ03285.npy +imgHQ12198.npy +imgHQ04017.npy +imgHQ29115.npy +imgHQ24850.npy +imgHQ17870.npy +imgHQ09148.npy +imgHQ11284.npy +imgHQ08226.npy +imgHQ27514.npy +imgHQ03595.npy +imgHQ25662.npy +imgHQ05118.npy +imgHQ11726.npy +imgHQ14636.npy +imgHQ26230.npy +imgHQ06135.npy +imgHQ26755.npy +imgHQ17943.npy +imgHQ25055.npy +imgHQ23664.npy +imgHQ12458.npy +imgHQ23719.npy +imgHQ22452.npy +imgHQ10369.npy +imgHQ10835.npy +imgHQ19895.npy +imgHQ20303.npy +imgHQ09982.npy +imgHQ03676.npy +imgHQ20341.npy +imgHQ10226.npy +imgHQ15415.npy +imgHQ29030.npy +imgHQ18071.npy +imgHQ16685.npy +imgHQ27618.npy +imgHQ21275.npy +imgHQ03978.npy +imgHQ10460.npy +imgHQ01049.npy +imgHQ02153.npy +imgHQ11674.npy +imgHQ03028.npy +imgHQ24643.npy +imgHQ21729.npy +imgHQ18461.npy +imgHQ11667.npy +imgHQ17279.npy +imgHQ20707.npy +imgHQ22569.npy +imgHQ18484.npy +imgHQ01314.npy +imgHQ08689.npy +imgHQ25089.npy +imgHQ13576.npy +imgHQ06227.npy +imgHQ00851.npy +imgHQ24066.npy +imgHQ11458.npy +imgHQ14858.npy +imgHQ00767.npy +imgHQ00878.npy +imgHQ08488.npy +imgHQ10815.npy +imgHQ21943.npy +imgHQ25233.npy +imgHQ11749.npy +imgHQ07721.npy +imgHQ19705.npy +imgHQ27696.npy +imgHQ13693.npy +imgHQ21226.npy +imgHQ08459.npy +imgHQ25620.npy +imgHQ20295.npy +imgHQ09581.npy +imgHQ19596.npy +imgHQ13712.npy +imgHQ16329.npy +imgHQ14438.npy +imgHQ10452.npy +imgHQ25173.npy +imgHQ01746.npy +imgHQ11892.npy +imgHQ09020.npy +imgHQ15014.npy +imgHQ07623.npy +imgHQ04199.npy +imgHQ19932.npy +imgHQ03116.npy +imgHQ16173.npy +imgHQ07638.npy +imgHQ00417.npy +imgHQ12713.npy +imgHQ13779.npy +imgHQ29077.npy +imgHQ20763.npy +imgHQ29167.npy +imgHQ15091.npy +imgHQ16075.npy +imgHQ17927.npy +imgHQ24494.npy +imgHQ24831.npy +imgHQ21668.npy +imgHQ02293.npy +imgHQ17696.npy +imgHQ07790.npy +imgHQ01305.npy +imgHQ00321.npy +imgHQ01823.npy +imgHQ05387.npy +imgHQ14417.npy +imgHQ15107.npy +imgHQ27462.npy +imgHQ26285.npy +imgHQ27180.npy +imgHQ10109.npy +imgHQ21724.npy +imgHQ25608.npy +imgHQ12764.npy +imgHQ08618.npy +imgHQ06793.npy +imgHQ23778.npy +imgHQ05208.npy +imgHQ02005.npy +imgHQ28772.npy +imgHQ25322.npy +imgHQ19249.npy +imgHQ02342.npy +imgHQ24809.npy +imgHQ03790.npy +imgHQ16214.npy +imgHQ11186.npy +imgHQ05489.npy +imgHQ12312.npy +imgHQ26678.npy +imgHQ04801.npy +imgHQ19526.npy +imgHQ21581.npy +imgHQ08722.npy +imgHQ01847.npy +imgHQ19334.npy +imgHQ13802.npy +imgHQ17915.npy +imgHQ23248.npy +imgHQ10750.npy +imgHQ28686.npy +imgHQ05642.npy +imgHQ10318.npy +imgHQ10389.npy +imgHQ26573.npy +imgHQ04746.npy +imgHQ24252.npy +imgHQ26991.npy +imgHQ24210.npy +imgHQ23764.npy +imgHQ27205.npy +imgHQ00838.npy +imgHQ23490.npy +imgHQ23129.npy +imgHQ12340.npy +imgHQ06845.npy +imgHQ13499.npy +imgHQ09098.npy +imgHQ22095.npy +imgHQ13659.npy +imgHQ17719.npy +imgHQ14130.npy +imgHQ17731.npy +imgHQ11575.npy +imgHQ06194.npy +imgHQ00479.npy +imgHQ24797.npy +imgHQ26138.npy +imgHQ15692.npy +imgHQ27896.npy +imgHQ25167.npy +imgHQ13967.npy +imgHQ28642.npy +imgHQ20067.npy +imgHQ11230.npy +imgHQ07408.npy +imgHQ28860.npy +imgHQ05983.npy +imgHQ16995.npy +imgHQ29383.npy +imgHQ06781.npy +imgHQ08456.npy +imgHQ10715.npy +imgHQ13897.npy +imgHQ00445.npy +imgHQ14150.npy +imgHQ17581.npy +imgHQ27436.npy +imgHQ04289.npy +imgHQ28341.npy +imgHQ07914.npy +imgHQ03934.npy +imgHQ13228.npy +imgHQ16438.npy +imgHQ07229.npy +imgHQ21349.npy +imgHQ03011.npy +imgHQ27248.npy +imgHQ22168.npy +imgHQ24113.npy +imgHQ11482.npy +imgHQ29062.npy +imgHQ19955.npy +imgHQ27064.npy +imgHQ29225.npy +imgHQ24453.npy +imgHQ22743.npy +imgHQ00205.npy +imgHQ15072.npy +imgHQ17857.npy +imgHQ18218.npy +imgHQ17662.npy +imgHQ25473.npy +imgHQ17180.npy +imgHQ17340.npy +imgHQ13829.npy +imgHQ01639.npy +imgHQ09085.npy +imgHQ14744.npy +imgHQ26597.npy +imgHQ03661.npy +imgHQ13337.npy +imgHQ07152.npy +imgHQ09724.npy +imgHQ11629.npy +imgHQ15626.npy +imgHQ02959.npy +imgHQ18239.npy +imgHQ19302.npy +imgHQ19617.npy +imgHQ21759.npy +imgHQ22468.npy +imgHQ09302.npy +imgHQ26132.npy +imgHQ06878.npy +imgHQ23967.npy +imgHQ06692.npy +imgHQ26239.npy +imgHQ25921.npy +imgHQ00188.npy +imgHQ20455.npy +imgHQ19522.npy +imgHQ08730.npy +imgHQ11043.npy +imgHQ06507.npy +imgHQ28477.npy +imgHQ20560.npy +imgHQ06246.npy +imgHQ13976.npy +imgHQ28126.npy +imgHQ01804.npy +imgHQ02146.npy +imgHQ11711.npy +imgHQ19243.npy +imgHQ00422.npy +imgHQ28712.npy +imgHQ20666.npy +imgHQ15587.npy +imgHQ15391.npy +imgHQ14472.npy +imgHQ19182.npy +imgHQ18132.npy +imgHQ13405.npy +imgHQ23529.npy +imgHQ01006.npy +imgHQ00898.npy +imgHQ07344.npy +imgHQ14866.npy +imgHQ24075.npy +imgHQ29279.npy +imgHQ11951.npy +imgHQ10688.npy +imgHQ01969.npy +imgHQ27840.npy +imgHQ27004.npy +imgHQ12897.npy +imgHQ19497.npy +imgHQ07646.npy +imgHQ00281.npy +imgHQ12774.npy +imgHQ09539.npy +imgHQ18898.npy +imgHQ29165.npy +imgHQ08291.npy +imgHQ08251.npy +imgHQ11085.npy +imgHQ07784.npy +imgHQ26425.npy +imgHQ29393.npy +imgHQ06525.npy +imgHQ05923.npy +imgHQ12785.npy +imgHQ24478.npy +imgHQ09576.npy +imgHQ18358.npy +imgHQ07516.npy +imgHQ07829.npy +imgHQ15061.npy +imgHQ08101.npy +imgHQ00313.npy +imgHQ19229.npy +imgHQ16564.npy +imgHQ10300.npy +imgHQ09445.npy +imgHQ19756.npy +imgHQ04788.npy +imgHQ07946.npy +imgHQ02623.npy +imgHQ10592.npy +imgHQ02477.npy +imgHQ26696.npy +imgHQ03470.npy +imgHQ23324.npy +imgHQ26146.npy +imgHQ16503.npy +imgHQ02393.npy +imgHQ17087.npy +imgHQ17417.npy +imgHQ12941.npy +imgHQ15223.npy +imgHQ15395.npy +imgHQ20514.npy +imgHQ00323.npy +imgHQ01122.npy +imgHQ27515.npy +imgHQ13126.npy +imgHQ00300.npy +imgHQ12858.npy +imgHQ02201.npy +imgHQ25890.npy +imgHQ17485.npy +imgHQ08116.npy +imgHQ08472.npy +imgHQ11549.npy +imgHQ15701.npy +imgHQ07876.npy +imgHQ04342.npy +imgHQ29142.npy +imgHQ21192.npy +imgHQ16574.npy +imgHQ10832.npy +imgHQ05226.npy +imgHQ23949.npy +imgHQ16301.npy +imgHQ10404.npy +imgHQ09031.npy +imgHQ15753.npy +imgHQ05301.npy +imgHQ03607.npy +imgHQ17415.npy +imgHQ24413.npy +imgHQ10642.npy +imgHQ09549.npy +imgHQ04585.npy +imgHQ02185.npy +imgHQ22740.npy +imgHQ28704.npy +imgHQ19684.npy +imgHQ29592.npy +imgHQ10025.npy +imgHQ06242.npy +imgHQ19478.npy +imgHQ02455.npy +imgHQ08842.npy +imgHQ09278.npy +imgHQ20926.npy +imgHQ11647.npy +imgHQ22543.npy +imgHQ26222.npy +imgHQ05756.npy +imgHQ14814.npy +imgHQ22488.npy +imgHQ20711.npy +imgHQ01815.npy +imgHQ02438.npy +imgHQ17860.npy +imgHQ28892.npy +imgHQ27740.npy +imgHQ23048.npy +imgHQ11723.npy +imgHQ19002.npy +imgHQ15382.npy +imgHQ05270.npy +imgHQ19688.npy +imgHQ11369.npy +imgHQ15907.npy +imgHQ14693.npy +imgHQ17919.npy +imgHQ00348.npy +imgHQ21657.npy +imgHQ14100.npy +imgHQ23471.npy +imgHQ17808.npy +imgHQ21550.npy +imgHQ16052.npy +imgHQ14444.npy +imgHQ29222.npy +imgHQ10955.npy +imgHQ06840.npy +imgHQ28083.npy +imgHQ05029.npy +imgHQ22330.npy +imgHQ17101.npy +imgHQ17727.npy +imgHQ10145.npy +imgHQ16573.npy +imgHQ08082.npy +imgHQ16328.npy +imgHQ03851.npy +imgHQ20804.npy +imgHQ16448.npy +imgHQ06900.npy +imgHQ08962.npy +imgHQ05045.npy +imgHQ18330.npy +imgHQ00483.npy +imgHQ12247.npy +imgHQ01408.npy +imgHQ01090.npy +imgHQ12686.npy +imgHQ03324.npy +imgHQ13900.npy +imgHQ23758.npy +imgHQ15220.npy +imgHQ26863.npy +imgHQ22284.npy +imgHQ28300.npy +imgHQ19091.npy +imgHQ11275.npy +imgHQ29252.npy +imgHQ15399.npy +imgHQ16719.npy +imgHQ29471.npy +imgHQ20615.npy +imgHQ00925.npy +imgHQ15928.npy +imgHQ13886.npy +imgHQ23203.npy +imgHQ15883.npy +imgHQ10684.npy +imgHQ23669.npy +imgHQ14641.npy +imgHQ11651.npy +imgHQ18976.npy +imgHQ25644.npy +imgHQ13504.npy +imgHQ13558.npy +imgHQ21988.npy +imgHQ09311.npy +imgHQ20168.npy +imgHQ20589.npy +imgHQ03765.npy +imgHQ02798.npy +imgHQ21848.npy +imgHQ29198.npy +imgHQ23141.npy +imgHQ04099.npy +imgHQ00406.npy +imgHQ14788.npy +imgHQ14277.npy +imgHQ11277.npy +imgHQ22694.npy +imgHQ06202.npy +imgHQ16308.npy +imgHQ26760.npy +imgHQ15695.npy +imgHQ11094.npy +imgHQ01030.npy +imgHQ12786.npy +imgHQ15433.npy +imgHQ06039.npy +imgHQ17290.npy +imgHQ11276.npy +imgHQ10345.npy +imgHQ03060.npy +imgHQ23286.npy +imgHQ14631.npy +imgHQ20637.npy +imgHQ17351.npy +imgHQ09612.npy +imgHQ08254.npy +imgHQ21380.npy +imgHQ22967.npy +imgHQ11590.npy +imgHQ23339.npy +imgHQ05732.npy +imgHQ25318.npy +imgHQ17072.npy +imgHQ20626.npy +imgHQ15531.npy +imgHQ12363.npy +imgHQ12049.npy +imgHQ00057.npy +imgHQ04057.npy +imgHQ02830.npy +imgHQ19509.npy +imgHQ29017.npy +imgHQ16850.npy +imgHQ22977.npy +imgHQ22073.npy +imgHQ05437.npy +imgHQ29112.npy +imgHQ01924.npy +imgHQ16800.npy +imgHQ14520.npy +imgHQ11024.npy +imgHQ26671.npy +imgHQ29466.npy +imgHQ15024.npy +imgHQ14662.npy +imgHQ16860.npy +imgHQ10319.npy +imgHQ20320.npy +imgHQ05229.npy +imgHQ27493.npy +imgHQ22646.npy +imgHQ09845.npy +imgHQ22050.npy +imgHQ21874.npy +imgHQ18131.npy +imgHQ03468.npy +imgHQ27483.npy +imgHQ22405.npy +imgHQ07128.npy +imgHQ16546.npy +imgHQ04243.npy +imgHQ09383.npy +imgHQ11530.npy +imgHQ10430.npy +imgHQ15099.npy +imgHQ27445.npy +imgHQ10752.npy +imgHQ23519.npy +imgHQ05531.npy +imgHQ21256.npy +imgHQ19579.npy +imgHQ26277.npy +imgHQ09494.npy +imgHQ13456.npy +imgHQ23511.npy +imgHQ09186.npy +imgHQ20838.npy +imgHQ13527.npy +imgHQ04857.npy +imgHQ27800.npy +imgHQ18458.npy +imgHQ10304.npy +imgHQ28033.npy +imgHQ19742.npy +imgHQ18671.npy +imgHQ26340.npy +imgHQ23630.npy +imgHQ16508.npy +imgHQ02001.npy +imgHQ13706.npy +imgHQ10014.npy +imgHQ21757.npy +imgHQ22860.npy +imgHQ18552.npy +imgHQ04455.npy +imgHQ20170.npy +imgHQ13958.npy +imgHQ15623.npy +imgHQ17634.npy +imgHQ27161.npy +imgHQ07935.npy +imgHQ23272.npy +imgHQ16626.npy +imgHQ15268.npy +imgHQ21181.npy +imgHQ23562.npy +imgHQ15529.npy +imgHQ21493.npy +imgHQ10595.npy +imgHQ14522.npy +imgHQ08182.npy +imgHQ07444.npy +imgHQ28165.npy +imgHQ17492.npy +imgHQ03202.npy +imgHQ24640.npy +imgHQ25169.npy +imgHQ14635.npy +imgHQ03635.npy +imgHQ20099.npy +imgHQ10725.npy +imgHQ22496.npy +imgHQ00702.npy +imgHQ21067.npy +imgHQ14473.npy +imgHQ15431.npy +imgHQ29145.npy +imgHQ06451.npy +imgHQ20865.npy +imgHQ03896.npy +imgHQ06949.npy +imgHQ25859.npy +imgHQ16345.npy +imgHQ28306.npy +imgHQ19179.npy +imgHQ10397.npy +imgHQ14495.npy +imgHQ21690.npy +imgHQ16419.npy +imgHQ26646.npy +imgHQ14565.npy +imgHQ18296.npy +imgHQ01443.npy +imgHQ01904.npy +imgHQ19169.npy +imgHQ12610.npy +imgHQ15596.npy +imgHQ13016.npy +imgHQ13676.npy +imgHQ29974.npy +imgHQ25777.npy +imgHQ15770.npy +imgHQ11359.npy +imgHQ01251.npy +imgHQ25924.npy +imgHQ00944.npy +imgHQ20495.npy +imgHQ01731.npy +imgHQ20263.npy +imgHQ19093.npy +imgHQ29254.npy +imgHQ16706.npy +imgHQ23924.npy +imgHQ16018.npy +imgHQ05414.npy +imgHQ12742.npy +imgHQ06606.npy +imgHQ25532.npy +imgHQ02973.npy +imgHQ14316.npy +imgHQ09950.npy +imgHQ03358.npy +imgHQ17813.npy +imgHQ25764.npy +imgHQ27084.npy +imgHQ17111.npy +imgHQ01475.npy +imgHQ14593.npy +imgHQ11091.npy +imgHQ12433.npy +imgHQ24238.npy +imgHQ01099.npy +imgHQ05886.npy +imgHQ06881.npy +imgHQ22048.npy +imgHQ18077.npy +imgHQ22953.npy +imgHQ18612.npy +imgHQ28062.npy +imgHQ14759.npy +imgHQ14376.npy +imgHQ05832.npy +imgHQ05044.npy +imgHQ28572.npy +imgHQ10713.npy +imgHQ03814.npy +imgHQ09880.npy +imgHQ27869.npy +imgHQ03886.npy +imgHQ07837.npy +imgHQ12955.npy +imgHQ16694.npy +imgHQ07131.npy +imgHQ12756.npy +imgHQ07971.npy +imgHQ20694.npy +imgHQ10063.npy +imgHQ16956.npy +imgHQ27373.npy +imgHQ25135.npy +imgHQ28662.npy +imgHQ17043.npy +imgHQ05042.npy +imgHQ10308.npy +imgHQ12356.npy +imgHQ19851.npy +imgHQ16984.npy +imgHQ25930.npy +imgHQ10657.npy +imgHQ18542.npy +imgHQ07999.npy +imgHQ25131.npy +imgHQ06397.npy +imgHQ08992.npy +imgHQ12542.npy +imgHQ05615.npy +imgHQ16481.npy +imgHQ00643.npy +imgHQ07788.npy +imgHQ26764.npy +imgHQ22451.npy +imgHQ20949.npy +imgHQ01295.npy +imgHQ10749.npy +imgHQ03013.npy +imgHQ17597.npy +imgHQ11752.npy +imgHQ01396.npy +imgHQ10089.npy +imgHQ05460.npy +imgHQ14182.npy +imgHQ13941.npy +imgHQ27839.npy +imgHQ01970.npy +imgHQ16191.npy +imgHQ10803.npy +imgHQ28016.npy +imgHQ14770.npy +imgHQ26759.npy +imgHQ25656.npy +imgHQ28519.npy +imgHQ14197.npy +imgHQ16977.npy +imgHQ17120.npy +imgHQ28178.npy +imgHQ25524.npy +imgHQ04693.npy +imgHQ17584.npy +imgHQ13566.npy +imgHQ06936.npy +imgHQ15676.npy +imgHQ08349.npy +imgHQ15934.npy +imgHQ29867.npy +imgHQ15215.npy +imgHQ00813.npy +imgHQ11172.npy +imgHQ09218.npy +imgHQ26309.npy +imgHQ05247.npy +imgHQ03605.npy +imgHQ22069.npy +imgHQ12894.npy +imgHQ10216.npy +imgHQ06981.npy +imgHQ19071.npy +imgHQ25095.npy +imgHQ18758.npy +imgHQ18340.npy +imgHQ23157.npy +imgHQ17604.npy +imgHQ21836.npy +imgHQ07109.npy +imgHQ16057.npy +imgHQ01713.npy +imgHQ12971.npy +imgHQ09406.npy +imgHQ07772.npy +imgHQ29843.npy +imgHQ04223.npy +imgHQ26502.npy +imgHQ00421.npy +imgHQ01095.npy +imgHQ16381.npy +imgHQ16029.npy +imgHQ05906.npy +imgHQ07134.npy +imgHQ06643.npy +imgHQ12861.npy +imgHQ16806.npy +imgHQ24380.npy +imgHQ14925.npy +imgHQ16072.npy +imgHQ25546.npy +imgHQ19683.npy +imgHQ01783.npy +imgHQ29038.npy +imgHQ26060.npy +imgHQ15358.npy +imgHQ15015.npy +imgHQ15966.npy +imgHQ04864.npy +imgHQ01192.npy +imgHQ19992.npy +imgHQ22925.npy +imgHQ29949.npy +imgHQ00876.npy +imgHQ20446.npy +imgHQ12377.npy +imgHQ18834.npy +imgHQ19663.npy +imgHQ13257.npy +imgHQ18277.npy +imgHQ28142.npy +imgHQ15796.npy +imgHQ11333.npy +imgHQ26556.npy +imgHQ28271.npy +imgHQ09366.npy +imgHQ24976.npy +imgHQ07533.npy +imgHQ08519.npy +imgHQ16009.npy +imgHQ02248.npy +imgHQ22099.npy +imgHQ08949.npy +imgHQ04550.npy +imgHQ16924.npy +imgHQ12792.npy +imgHQ08860.npy +imgHQ03490.npy +imgHQ15656.npy +imgHQ22930.npy +imgHQ11522.npy +imgHQ17510.npy +imgHQ29107.npy +imgHQ04179.npy +imgHQ09329.npy +imgHQ20939.npy +imgHQ24185.npy +imgHQ11876.npy +imgHQ17544.npy +imgHQ02461.npy +imgHQ09631.npy +imgHQ21046.npy +imgHQ00683.npy +imgHQ10413.npy +imgHQ06699.npy +imgHQ19546.npy +imgHQ20920.npy +imgHQ18397.npy +imgHQ15700.npy +imgHQ10973.npy +imgHQ22125.npy +imgHQ26506.npy +imgHQ26397.npy +imgHQ09408.npy +imgHQ26971.npy +imgHQ18851.npy +imgHQ13611.npy +imgHQ05808.npy +imgHQ21344.npy +imgHQ04603.npy +imgHQ19995.npy +imgHQ03155.npy +imgHQ24378.npy +imgHQ11106.npy +imgHQ06967.npy +imgHQ11729.npy +imgHQ14514.npy +imgHQ04870.npy +imgHQ23354.npy +imgHQ22053.npy +imgHQ00117.npy +imgHQ00110.npy +imgHQ23108.npy +imgHQ29281.npy +imgHQ24614.npy +imgHQ05435.npy +imgHQ08137.npy +imgHQ00684.npy +imgHQ07139.npy +imgHQ04703.npy +imgHQ22026.npy +imgHQ05086.npy +imgHQ29903.npy +imgHQ07145.npy +imgHQ28019.npy +imgHQ22783.npy +imgHQ09689.npy +imgHQ24854.npy +imgHQ01344.npy +imgHQ15677.npy +imgHQ08919.npy +imgHQ22792.npy +imgHQ04877.npy +imgHQ16289.npy +imgHQ11867.npy +imgHQ11211.npy +imgHQ27496.npy +imgHQ14268.npy +imgHQ03132.npy +imgHQ05503.npy +imgHQ11784.npy +imgHQ10640.npy +imgHQ24211.npy +imgHQ21824.npy +imgHQ05463.npy +imgHQ24924.npy +imgHQ07052.npy +imgHQ01943.npy +imgHQ29144.npy +imgHQ00226.npy +imgHQ28499.npy +imgHQ18172.npy +imgHQ01920.npy +imgHQ28816.npy +imgHQ28288.npy +imgHQ12812.npy +imgHQ01803.npy +imgHQ14156.npy +imgHQ06035.npy +imgHQ18053.npy +imgHQ06259.npy +imgHQ09223.npy +imgHQ29510.npy +imgHQ05504.npy +imgHQ10103.npy +imgHQ10131.npy +imgHQ04227.npy +imgHQ10757.npy +imgHQ06440.npy +imgHQ06764.npy +imgHQ12630.npy +imgHQ07097.npy +imgHQ04072.npy +imgHQ02413.npy +imgHQ24653.npy +imgHQ15684.npy +imgHQ18523.npy +imgHQ02142.npy +imgHQ13472.npy +imgHQ02663.npy +imgHQ18933.npy +imgHQ14834.npy +imgHQ29680.npy +imgHQ10518.npy +imgHQ26137.npy +imgHQ16678.npy +imgHQ08841.npy +imgHQ14753.npy +imgHQ11468.npy +imgHQ28265.npy +imgHQ03854.npy +imgHQ04735.npy +imgHQ05189.npy +imgHQ24811.npy +imgHQ07976.npy +imgHQ07951.npy +imgHQ29362.npy +imgHQ27669.npy +imgHQ22244.npy +imgHQ21419.npy +imgHQ25595.npy +imgHQ08403.npy +imgHQ07374.npy +imgHQ24473.npy +imgHQ19197.npy +imgHQ24108.npy +imgHQ18694.npy +imgHQ13146.npy +imgHQ19225.npy +imgHQ27841.npy +imgHQ25049.npy +imgHQ27694.npy +imgHQ21416.npy +imgHQ13143.npy +imgHQ20826.npy +imgHQ29221.npy +imgHQ16671.npy +imgHQ16963.npy +imgHQ20608.npy +imgHQ24153.npy +imgHQ12559.npy +imgHQ16015.npy +imgHQ25342.npy +imgHQ09706.npy +imgHQ14240.npy +imgHQ24433.npy +imgHQ11939.npy +imgHQ27181.npy +imgHQ17991.npy +imgHQ26901.npy +imgHQ23780.npy +imgHQ21022.npy +imgHQ29208.npy +imgHQ29686.npy +imgHQ27427.npy +imgHQ25293.npy +imgHQ19640.npy +imgHQ07157.npy +imgHQ15336.npy +imgHQ29131.npy +imgHQ03068.npy +imgHQ20371.npy +imgHQ13894.npy +imgHQ21934.npy +imgHQ28223.npy +imgHQ19043.npy +imgHQ12023.npy +imgHQ09109.npy +imgHQ24216.npy +imgHQ06059.npy +imgHQ22671.npy +imgHQ17665.npy +imgHQ12457.npy +imgHQ28589.npy +imgHQ06314.npy +imgHQ11307.npy +imgHQ06814.npy +imgHQ13549.npy +imgHQ03777.npy +imgHQ06177.npy +imgHQ27973.npy +imgHQ01308.npy +imgHQ04977.npy +imgHQ03163.npy +imgHQ22412.npy +imgHQ06366.npy +imgHQ03650.npy +imgHQ16486.npy +imgHQ11405.npy +imgHQ10441.npy +imgHQ23888.npy +imgHQ00456.npy +imgHQ29973.npy +imgHQ21298.npy +imgHQ15881.npy +imgHQ11465.npy +imgHQ12446.npy +imgHQ13117.npy +imgHQ25136.npy +imgHQ08435.npy +imgHQ01742.npy +imgHQ13186.npy +imgHQ06581.npy +imgHQ16047.npy +imgHQ18189.npy +imgHQ02671.npy +imgHQ03508.npy +imgHQ18824.npy +imgHQ00211.npy +imgHQ14987.npy +imgHQ04494.npy +imgHQ28657.npy +imgHQ06010.npy +imgHQ17238.npy +imgHQ25025.npy +imgHQ09992.npy +imgHQ03497.npy +imgHQ11714.npy +imgHQ06078.npy +imgHQ14571.npy +imgHQ19712.npy +imgHQ09447.npy +imgHQ12701.npy +imgHQ21291.npy +imgHQ21891.npy +imgHQ21670.npy +imgHQ27983.npy +imgHQ22903.npy +imgHQ20308.npy +imgHQ21124.npy +imgHQ15457.npy +imgHQ10509.npy +imgHQ21113.npy +imgHQ00728.npy +imgHQ27988.npy +imgHQ03708.npy +imgHQ29202.npy +imgHQ27403.npy +imgHQ27503.npy +imgHQ00371.npy +imgHQ13954.npy +imgHQ17306.npy +imgHQ23118.npy +imgHQ28431.npy +imgHQ22471.npy +imgHQ23991.npy +imgHQ07031.npy +imgHQ14082.npy +imgHQ18253.npy +imgHQ29830.npy +imgHQ17506.npy +imgHQ03518.npy +imgHQ22597.npy +imgHQ05060.npy +imgHQ10154.npy +imgHQ02840.npy +imgHQ08285.npy +imgHQ01668.npy +imgHQ00771.npy +imgHQ03035.npy +imgHQ00505.npy +imgHQ06215.npy +imgHQ15023.npy +imgHQ07123.npy +imgHQ03188.npy +imgHQ26768.npy +imgHQ17448.npy +imgHQ01169.npy +imgHQ26470.npy +imgHQ25949.npy +imgHQ29615.npy +imgHQ24276.npy +imgHQ23441.npy +imgHQ26464.npy +imgHQ21660.npy +imgHQ24184.npy +imgHQ21402.npy +imgHQ28817.npy +imgHQ19560.npy +imgHQ20186.npy +imgHQ06992.npy +imgHQ29434.npy +imgHQ24091.npy +imgHQ27410.npy +imgHQ08640.npy +imgHQ21840.npy +imgHQ11770.npy +imgHQ09338.npy +imgHQ09173.npy +imgHQ29531.npy +imgHQ02989.npy +imgHQ23411.npy +imgHQ00746.npy +imgHQ13402.npy +imgHQ08620.npy +imgHQ19237.npy +imgHQ20780.npy +imgHQ23295.npy +imgHQ06446.npy +imgHQ14343.npy +imgHQ20211.npy +imgHQ00784.npy +imgHQ07274.npy +imgHQ06471.npy +imgHQ07793.npy +imgHQ12264.npy +imgHQ29981.npy +imgHQ29162.npy +imgHQ18465.npy +imgHQ05085.npy +imgHQ12360.npy +imgHQ15791.npy +imgHQ02990.npy +imgHQ13007.npy +imgHQ15839.npy +imgHQ08581.npy +imgHQ22121.npy +imgHQ04255.npy +imgHQ28991.npy +imgHQ05191.npy +imgHQ29373.npy +imgHQ02971.npy +imgHQ28614.npy +imgHQ23189.npy +imgHQ05432.npy +imgHQ24018.npy +imgHQ11056.npy +imgHQ13557.npy +imgHQ29125.npy +imgHQ19822.npy +imgHQ22933.npy +imgHQ21613.npy +imgHQ10960.npy +imgHQ11141.npy +imgHQ24616.npy +imgHQ12724.npy +imgHQ03757.npy +imgHQ09518.npy +imgHQ27629.npy +imgHQ05855.npy +imgHQ26994.npy +imgHQ00135.npy +imgHQ05239.npy +imgHQ22113.npy +imgHQ07224.npy +imgHQ14843.npy +imgHQ20041.npy +imgHQ16019.npy +imgHQ08447.npy +imgHQ10483.npy +imgHQ07256.npy +imgHQ26970.npy +imgHQ19577.npy +imgHQ18578.npy +imgHQ10963.npy +imgHQ09163.npy +imgHQ16396.npy +imgHQ15836.npy +imgHQ00210.npy +imgHQ25888.npy +imgHQ28929.npy +imgHQ07026.npy +imgHQ26023.npy +imgHQ13263.npy +imgHQ22363.npy +imgHQ18044.npy +imgHQ07341.npy +imgHQ13448.npy +imgHQ29095.npy +imgHQ00973.npy +imgHQ28221.npy +imgHQ26503.npy +imgHQ11105.npy +imgHQ15237.npy +imgHQ21475.npy +imgHQ00580.npy +imgHQ01351.npy +imgHQ28340.npy +imgHQ02194.npy +imgHQ08881.npy +imgHQ29824.npy +imgHQ18489.npy +imgHQ22541.npy +imgHQ02150.npy +imgHQ22883.npy +imgHQ23699.npy +imgHQ20692.npy +imgHQ09283.npy +imgHQ11898.npy +imgHQ04477.npy +imgHQ12173.npy +imgHQ14121.npy +imgHQ13913.npy +imgHQ14175.npy +imgHQ14456.npy +imgHQ11509.npy +imgHQ11034.npy +imgHQ18756.npy +imgHQ21553.npy +imgHQ08582.npy +imgHQ04702.npy +imgHQ13071.npy +imgHQ09312.npy +imgHQ26812.npy +imgHQ22539.npy +imgHQ00130.npy +imgHQ27339.npy +imgHQ04218.npy +imgHQ12642.npy +imgHQ20845.npy +imgHQ12217.npy +imgHQ27038.npy +imgHQ27132.npy +imgHQ00498.npy +imgHQ06062.npy +imgHQ03783.npy +imgHQ15085.npy +imgHQ11645.npy +imgHQ10348.npy +imgHQ07323.npy +imgHQ23147.npy +imgHQ09710.npy +imgHQ29189.npy +imgHQ06189.npy +imgHQ05685.npy +imgHQ11623.npy +imgHQ12598.npy +imgHQ07129.npy +imgHQ03737.npy +imgHQ15233.npy +imgHQ25947.npy +imgHQ18045.npy +imgHQ18726.npy +imgHQ20630.npy +imgHQ21479.npy +imgHQ27101.npy +imgHQ27560.npy +imgHQ16266.npy +imgHQ06464.npy +imgHQ22410.npy +imgHQ28599.npy +imgHQ27482.npy +imgHQ03239.npy +imgHQ02002.npy +imgHQ22387.npy +imgHQ08491.npy +imgHQ27661.npy +imgHQ06252.npy +imgHQ21395.npy +imgHQ29073.npy +imgHQ15475.npy +imgHQ11851.npy +imgHQ01052.npy +imgHQ04395.npy +imgHQ02164.npy +imgHQ20117.npy +imgHQ27814.npy +imgHQ23609.npy +imgHQ08247.npy +imgHQ09865.npy +imgHQ14192.npy +imgHQ16566.npy +imgHQ19907.npy +imgHQ06018.npy +imgHQ13929.npy +imgHQ14829.npy +imgHQ10672.npy +imgHQ01692.npy +imgHQ18487.npy +imgHQ14220.npy +imgHQ15425.npy +imgHQ20402.npy +imgHQ26745.npy +imgHQ22519.npy +imgHQ26032.npy +imgHQ09592.npy +imgHQ02219.npy +imgHQ05184.npy +imgHQ08352.npy +imgHQ17845.npy +imgHQ19540.npy +imgHQ25928.npy +imgHQ23188.npy +imgHQ11387.npy +imgHQ12152.npy +imgHQ23340.npy +imgHQ04256.npy +imgHQ19192.npy +imgHQ05995.npy +imgHQ26748.npy +imgHQ26044.npy +imgHQ22132.npy +imgHQ21765.npy +imgHQ24945.npy +imgHQ01464.npy +imgHQ21074.npy +imgHQ23505.npy +imgHQ05948.npy +imgHQ05779.npy +imgHQ21254.npy +imgHQ13522.npy +imgHQ00955.npy +imgHQ18027.npy +imgHQ27419.npy +imgHQ29056.npy +imgHQ09761.npy +imgHQ14792.npy +imgHQ26937.npy +imgHQ27954.npy +imgHQ24483.npy +imgHQ06747.npy +imgHQ13394.npy +imgHQ15929.npy +imgHQ11484.npy +imgHQ09092.npy +imgHQ01168.npy +imgHQ03456.npy +imgHQ06406.npy +imgHQ24618.npy +imgHQ19670.npy +imgHQ09669.npy +imgHQ29365.npy +imgHQ10043.npy +imgHQ19651.npy +imgHQ22454.npy +imgHQ10134.npy +imgHQ10704.npy +imgHQ14379.npy +imgHQ22614.npy +imgHQ20898.npy +imgHQ24580.npy +imgHQ13697.npy +imgHQ00392.npy +imgHQ29702.npy +imgHQ21464.npy +imgHQ21974.npy +imgHQ11617.npy +imgHQ12675.npy +imgHQ14248.npy +imgHQ24241.npy +imgHQ12123.npy +imgHQ17855.npy +imgHQ25611.npy +imgHQ00907.npy +imgHQ17986.npy +imgHQ27140.npy +imgHQ14038.npy +imgHQ20293.npy +imgHQ06474.npy +imgHQ00666.npy +imgHQ24361.npy +imgHQ24150.npy +imgHQ15173.npy +imgHQ16194.npy +imgHQ05347.npy +imgHQ28842.npy +imgHQ11090.npy +imgHQ02282.npy +imgHQ17639.npy +imgHQ22757.npy +imgHQ24232.npy +imgHQ13479.npy +imgHQ14555.npy +imgHQ22111.npy +imgHQ24093.npy +imgHQ06305.npy +imgHQ28506.npy +imgHQ09450.npy +imgHQ28563.npy +imgHQ01164.npy +imgHQ13247.npy +imgHQ17090.npy +imgHQ05040.npy +imgHQ28162.npy +imgHQ10307.npy +imgHQ02589.npy +imgHQ03908.npy +imgHQ05228.npy +imgHQ10124.npy +imgHQ16192.npy +imgHQ16041.npy +imgHQ09707.npy +imgHQ21596.npy +imgHQ27945.npy +imgHQ25273.npy +imgHQ22913.npy +imgHQ07748.npy +imgHQ27764.npy +imgHQ17846.npy +imgHQ16280.npy +imgHQ13127.npy +imgHQ18480.npy +imgHQ17831.npy +imgHQ09291.npy +imgHQ02831.npy +imgHQ21641.npy +imgHQ10930.npy +imgHQ09330.npy +imgHQ17007.npy +imgHQ00869.npy +imgHQ15165.npy +imgHQ27232.npy +imgHQ04806.npy +imgHQ16418.npy +imgHQ13924.npy +imgHQ23266.npy +imgHQ15497.npy +imgHQ03569.npy +imgHQ16300.npy +imgHQ17404.npy +imgHQ06855.npy +imgHQ18467.npy +imgHQ00105.npy +imgHQ05468.npy +imgHQ09156.npy +imgHQ05212.npy +imgHQ03973.npy +imgHQ22445.npy +imgHQ18618.npy +imgHQ28937.npy +imgHQ21149.npy +imgHQ22861.npy +imgHQ06137.npy +imgHQ09037.npy +imgHQ27846.npy +imgHQ13699.npy +imgHQ19394.npy +imgHQ20005.npy +imgHQ24469.npy +imgHQ08471.npy +imgHQ15611.npy +imgHQ21123.npy +imgHQ01789.npy +imgHQ00625.npy +imgHQ10296.npy +imgHQ18528.npy +imgHQ02151.npy +imgHQ18872.npy +imgHQ08833.npy +imgHQ17884.npy +imgHQ11292.npy +imgHQ22595.npy +imgHQ18665.npy +imgHQ02642.npy +imgHQ14526.npy +imgHQ16428.npy +imgHQ13087.npy +imgHQ20661.npy +imgHQ15528.npy +imgHQ22046.npy +imgHQ17282.npy +imgHQ15630.npy +imgHQ29403.npy +imgHQ20974.npy +imgHQ04440.npy +imgHQ17232.npy +imgHQ11314.npy +imgHQ12546.npy +imgHQ25428.npy +imgHQ16367.npy +imgHQ02459.npy +imgHQ04370.npy +imgHQ07294.npy +imgHQ05726.npy +imgHQ08748.npy +imgHQ19700.npy +imgHQ11570.npy +imgHQ20905.npy +imgHQ07573.npy +imgHQ08775.npy +imgHQ24895.npy +imgHQ13324.npy +imgHQ09869.npy +imgHQ03504.npy +imgHQ26669.npy +imgHQ15376.npy +imgHQ13280.npy +imgHQ17715.npy +imgHQ27460.npy +imgHQ08296.npy +imgHQ04815.npy +imgHQ10687.npy +imgHQ13050.npy +imgHQ24913.npy +imgHQ04899.npy +imgHQ11972.npy +imgHQ14516.npy +imgHQ22670.npy +imgHQ08400.npy +imgHQ19126.npy +imgHQ05972.npy +imgHQ12777.npy +imgHQ01880.npy +imgHQ15932.npy +imgHQ16686.npy +imgHQ01557.npy +imgHQ11336.npy +imgHQ19804.npy +imgHQ08753.npy +imgHQ28318.npy +imgHQ03215.npy +imgHQ06863.npy +imgHQ07809.npy +imgHQ04704.npy +imgHQ17094.npy +imgHQ05678.npy +imgHQ11864.npy +imgHQ01649.npy +imgHQ22639.npy +imgHQ13752.npy +imgHQ03177.npy +imgHQ02962.npy +imgHQ02311.npy +imgHQ02778.npy +imgHQ16981.npy +imgHQ29185.npy +imgHQ20384.npy +imgHQ10520.npy +imgHQ12036.npy +imgHQ01811.npy +imgHQ11443.npy +imgHQ05185.npy +imgHQ05869.npy +imgHQ29148.npy +imgHQ08065.npy +imgHQ17334.npy +imgHQ14165.npy +imgHQ03167.npy +imgHQ03417.npy +imgHQ29276.npy +imgHQ13687.npy +imgHQ28858.npy +imgHQ24335.npy +imgHQ25346.npy +imgHQ01277.npy +imgHQ11849.npy +imgHQ09793.npy +imgHQ28879.npy +imgHQ28872.npy +imgHQ14380.npy +imgHQ27461.npy +imgHQ05707.npy +imgHQ27637.npy +imgHQ11491.npy +imgHQ14961.npy +imgHQ26787.npy +imgHQ08665.npy +imgHQ10693.npy +imgHQ10293.npy +imgHQ09986.npy +imgHQ00889.npy +imgHQ14230.npy +imgHQ20988.npy +imgHQ02019.npy +imgHQ11092.npy +imgHQ06233.npy +imgHQ04215.npy +imgHQ24130.npy +imgHQ12958.npy +imgHQ28112.npy +imgHQ15279.npy +imgHQ29860.npy +imgHQ23131.npy +imgHQ21382.npy +imgHQ23091.npy +imgHQ15067.npy +imgHQ01391.npy +imgHQ26967.npy +imgHQ25677.npy +imgHQ26951.npy +imgHQ04089.npy +imgHQ17906.npy +imgHQ25255.npy +imgHQ18013.npy +imgHQ13720.npy +imgHQ26593.npy +imgHQ19485.npy +imgHQ13341.npy +imgHQ27998.npy +imgHQ17564.npy +imgHQ02173.npy +imgHQ18560.npy +imgHQ29804.npy +imgHQ02786.npy +imgHQ03590.npy +imgHQ19185.npy +imgHQ13762.npy +imgHQ12314.npy +imgHQ25732.npy +imgHQ13830.npy +imgHQ16221.npy +imgHQ22846.npy +imgHQ24045.npy +imgHQ18566.npy +imgHQ16738.npy +imgHQ18421.npy +imgHQ17598.npy +imgHQ11850.npy +imgHQ00875.npy +imgHQ28424.npy +imgHQ26399.npy +imgHQ24112.npy +imgHQ13903.npy +imgHQ02086.npy +imgHQ16845.npy +imgHQ21948.npy +imgHQ26622.npy +imgHQ08276.npy +imgHQ00379.npy +imgHQ14674.npy +imgHQ19698.npy +imgHQ17144.npy +imgHQ04219.npy +imgHQ05480.npy +imgHQ01281.npy +imgHQ08107.npy +imgHQ28824.npy +imgHQ09123.npy +imgHQ07504.npy +imgHQ28079.npy +imgHQ11993.npy +imgHQ28479.npy +imgHQ24675.npy +imgHQ02507.npy +imgHQ20781.npy +imgHQ28560.npy +imgHQ22721.npy +imgHQ22868.npy +imgHQ03003.npy +imgHQ12040.npy +imgHQ05163.npy +imgHQ15213.npy +imgHQ01077.npy +imgHQ20579.npy +imgHQ28125.npy +imgHQ23717.npy +imgHQ10596.npy +imgHQ14027.npy +imgHQ10823.npy +imgHQ25771.npy +imgHQ04698.npy +imgHQ26350.npy +imgHQ03589.npy +imgHQ00761.npy +imgHQ14173.npy +imgHQ23891.npy +imgHQ25326.npy +imgHQ06090.npy +imgHQ25194.npy +imgHQ06985.npy +imgHQ28927.npy +imgHQ04731.npy +imgHQ11995.npy +imgHQ08057.npy +imgHQ24792.npy +imgHQ03416.npy +imgHQ17987.npy +imgHQ09647.npy +imgHQ14093.npy +imgHQ05211.npy +imgHQ26685.npy +imgHQ25618.npy +imgHQ24195.npy +imgHQ28137.npy +imgHQ16297.npy +imgHQ11848.npy +imgHQ02998.npy +imgHQ29158.npy +imgHQ09871.npy +imgHQ08556.npy +imgHQ28570.npy +imgHQ09718.npy +imgHQ29794.npy +imgHQ21816.npy +imgHQ25090.npy +imgHQ14039.npy +imgHQ21784.npy +imgHQ22193.npy +imgHQ17403.npy +imgHQ05243.npy +imgHQ10453.npy +imgHQ10637.npy +imgHQ01041.npy +imgHQ11006.npy +imgHQ09934.npy +imgHQ23558.npy +imgHQ24403.npy +imgHQ18892.npy +imgHQ20919.npy +imgHQ04650.npy +imgHQ15609.npy +imgHQ15772.npy +imgHQ23363.npy +imgHQ08340.npy +imgHQ03764.npy +imgHQ24529.npy +imgHQ22973.npy +imgHQ13942.npy +imgHQ07280.npy +imgHQ12769.npy +imgHQ03447.npy +imgHQ01725.npy +imgHQ20201.npy +imgHQ16515.npy +imgHQ20575.npy +imgHQ11005.npy +imgHQ18735.npy +imgHQ25954.npy +imgHQ11511.npy +imgHQ18842.npy +imgHQ24023.npy +imgHQ15151.npy +imgHQ03025.npy +imgHQ17660.npy +imgHQ01055.npy +imgHQ06025.npy +imgHQ14569.npy +imgHQ21942.npy +imgHQ24521.npy +imgHQ29421.npy +imgHQ19754.npy +imgHQ26491.npy +imgHQ05156.npy +imgHQ06832.npy +imgHQ06642.npy +imgHQ25561.npy +imgHQ08275.npy +imgHQ00359.npy +imgHQ04113.npy +imgHQ01092.npy +imgHQ05924.npy +imgHQ04726.npy +imgHQ14817.npy +imgHQ18912.npy +imgHQ22762.npy +imgHQ24545.npy +imgHQ10107.npy +imgHQ00367.npy +imgHQ29407.npy +imgHQ22550.npy +imgHQ04308.npy +imgHQ28825.npy +imgHQ08677.npy +imgHQ28411.npy +imgHQ06304.npy +imgHQ13232.npy +imgHQ03339.npy +imgHQ01996.npy +imgHQ27689.npy +imgHQ01255.npy +imgHQ03801.npy +imgHQ25735.npy +imgHQ07487.npy +imgHQ16149.npy +imgHQ08398.npy +imgHQ22936.npy +imgHQ06134.npy +imgHQ19960.npy +imgHQ00410.npy +imgHQ03316.npy +imgHQ15598.npy +imgHQ01498.npy +imgHQ28698.npy +imgHQ26674.npy +imgHQ10635.npy +imgHQ21545.npy +imgHQ04786.npy +imgHQ23698.npy +imgHQ20559.npy +imgHQ03108.npy +imgHQ09058.npy +imgHQ07237.npy +imgHQ15903.npy +imgHQ09401.npy +imgHQ17423.npy +imgHQ19266.npy +imgHQ21797.npy +imgHQ09016.npy +imgHQ20664.npy +imgHQ18162.npy +imgHQ14856.npy +imgHQ03736.npy +imgHQ18661.npy +imgHQ28080.npy +imgHQ20811.npy +imgHQ25522.npy +imgHQ02921.npy +imgHQ14581.npy +imgHQ00699.npy +imgHQ09561.npy +imgHQ01176.npy +imgHQ10521.npy +imgHQ04345.npy +imgHQ12618.npy +imgHQ19132.npy +imgHQ09959.npy +imgHQ06006.npy +imgHQ13027.npy +imgHQ17797.npy +imgHQ00054.npy +imgHQ05038.npy +imgHQ18246.npy +imgHQ07258.npy +imgHQ14071.npy +imgHQ00841.npy +imgHQ10613.npy +imgHQ25695.npy +imgHQ15686.npy +imgHQ11670.npy +imgHQ16094.npy +imgHQ03842.npy +imgHQ17036.npy +imgHQ08520.npy +imgHQ09128.npy +imgHQ27102.npy +imgHQ25161.npy +imgHQ12475.npy +imgHQ06997.npy +imgHQ19425.npy +imgHQ10068.npy +imgHQ15974.npy +imgHQ07112.npy +imgHQ12647.npy +imgHQ15760.npy +imgHQ11073.npy +imgHQ04733.npy +imgHQ15388.npy +imgHQ27891.npy +imgHQ04689.npy +imgHQ08088.npy +imgHQ24729.npy +imgHQ23067.npy +imgHQ13785.npy +imgHQ00046.npy +imgHQ15447.npy +imgHQ02688.npy +imgHQ02327.npy +imgHQ11269.npy +imgHQ13425.npy +imgHQ11289.npy +imgHQ26792.npy +imgHQ27371.npy +imgHQ23032.npy +imgHQ09375.npy +imgHQ26836.npy +imgHQ20221.npy +imgHQ12949.npy +imgHQ06022.npy +imgHQ03192.npy +imgHQ15265.npy +imgHQ29079.npy +imgHQ18924.npy +imgHQ21972.npy +imgHQ19893.npy +imgHQ18685.npy +imgHQ26225.npy +imgHQ14578.npy +imgHQ06751.npy +imgHQ16152.npy +imgHQ18023.npy +imgHQ07261.npy +imgHQ08106.npy +imgHQ03007.npy +imgHQ19669.npy +imgHQ28765.npy +imgHQ20505.npy +imgHQ29372.npy +imgHQ19051.npy +imgHQ18350.npy +imgHQ08648.npy +imgHQ11087.npy +imgHQ11193.npy +imgHQ08805.npy +imgHQ04403.npy +imgHQ22220.npy +imgHQ03080.npy +imgHQ01380.npy +imgHQ03272.npy +imgHQ24154.npy +imgHQ17019.npy +imgHQ25404.npy +imgHQ17121.npy +imgHQ22367.npy +imgHQ00957.npy +imgHQ06777.npy +imgHQ29730.npy +imgHQ07985.npy +imgHQ27748.npy +imgHQ25591.npy +imgHQ21770.npy +imgHQ10598.npy +imgHQ21633.npy +imgHQ14257.npy +imgHQ12021.npy +imgHQ09760.npy +imgHQ07514.npy +imgHQ05580.npy +imgHQ08758.npy +imgHQ27226.npy +imgHQ18438.npy +imgHQ22797.npy +imgHQ15195.npy +imgHQ15730.npy +imgHQ17041.npy +imgHQ13096.npy +imgHQ20796.npy +imgHQ28147.npy +imgHQ02728.npy +imgHQ14178.npy +imgHQ03264.npy +imgHQ24349.npy +imgHQ08927.npy +imgHQ19327.npy +imgHQ19928.npy +imgHQ10490.npy +imgHQ02083.npy +imgHQ22030.npy +imgHQ20720.npy +imgHQ03690.npy +imgHQ16892.npy +imgHQ18747.npy +imgHQ19809.npy +imgHQ16966.npy +imgHQ02047.npy +imgHQ19069.npy +imgHQ09611.npy +imgHQ22172.npy +imgHQ11053.npy +imgHQ25460.npy +imgHQ00543.npy +imgHQ29227.npy +imgHQ10473.npy +imgHQ17065.npy +imgHQ24386.npy +imgHQ17779.npy +imgHQ02256.npy +imgHQ14209.npy +imgHQ23596.npy +imgHQ00744.npy +imgHQ09273.npy +imgHQ15561.npy +imgHQ10982.npy +imgHQ11679.npy +imgHQ09415.npy +imgHQ11539.npy +imgHQ19643.npy +imgHQ25026.npy +imgHQ28495.npy +imgHQ05975.npy +imgHQ23074.npy +imgHQ26231.npy +imgHQ04388.npy +imgHQ10385.npy +imgHQ07762.npy +imgHQ11615.npy +imgHQ12001.npy +imgHQ08872.npy +imgHQ29009.npy +imgHQ06143.npy +imgHQ12422.npy +imgHQ15519.npy +imgHQ10999.npy +imgHQ11797.npy +imgHQ05960.npy +imgHQ27614.npy +imgHQ19758.npy +imgHQ16265.npy +imgHQ11653.npy +imgHQ23317.npy +imgHQ21476.npy +imgHQ18281.npy +imgHQ07398.npy +imgHQ28440.npy +imgHQ23000.npy +imgHQ00459.npy +imgHQ05526.npy +imgHQ06938.npy +imgHQ12754.npy +imgHQ15071.npy +imgHQ13714.npy +imgHQ19180.npy +imgHQ02782.npy +imgHQ24885.npy +imgHQ00773.npy +imgHQ05941.npy +imgHQ21486.npy +imgHQ10768.npy +imgHQ28654.npy +imgHQ05757.npy +imgHQ09582.npy +imgHQ08894.npy +imgHQ23209.npy +imgHQ28007.npy +imgHQ09658.npy +imgHQ29294.npy +imgHQ07188.npy +imgHQ24851.npy +imgHQ26838.npy +imgHQ11452.npy +imgHQ03893.npy +imgHQ20899.npy +imgHQ15616.npy +imgHQ06797.npy +imgHQ20157.npy +imgHQ00098.npy +imgHQ21473.npy +imgHQ06757.npy +imgHQ16872.npy +imgHQ02014.npy +imgHQ04953.npy +imgHQ16547.npy +imgHQ28971.npy +imgHQ06849.npy +imgHQ07552.npy +imgHQ29659.npy +imgHQ06595.npy +imgHQ28193.npy +imgHQ05672.npy +imgHQ16321.npy +imgHQ20622.npy +imgHQ24728.npy +imgHQ25278.npy +imgHQ21577.npy +imgHQ11255.npy +imgHQ01266.npy +imgHQ26653.npy +imgHQ00168.npy +imgHQ14634.npy +imgHQ22271.npy +imgHQ15916.npy +imgHQ16870.npy +imgHQ29402.npy +imgHQ04207.npy +imgHQ16334.npy +imgHQ28350.npy +imgHQ18298.npy +imgHQ06444.npy +imgHQ01210.npy +imgHQ11156.npy +imgHQ29291.npy +imgHQ07908.npy +imgHQ01315.npy +imgHQ01286.npy +imgHQ15272.npy +imgHQ10968.npy +imgHQ27542.npy +imgHQ08685.npy +imgHQ03072.npy +imgHQ15098.npy +imgHQ28210.npy +imgHQ27612.npy +imgHQ11553.npy +imgHQ19516.npy +imgHQ26028.npy +imgHQ16128.npy +imgHQ00072.npy +imgHQ27416.npy +imgHQ14115.npy +imgHQ02580.npy +imgHQ01196.npy +imgHQ00795.npy +imgHQ19403.npy +imgHQ00678.npy +imgHQ12296.npy +imgHQ19308.npy +imgHQ00107.npy +imgHQ26640.npy +imgHQ03126.npy +imgHQ08325.npy +imgHQ08716.npy +imgHQ20832.npy +imgHQ29014.npy +imgHQ26757.npy +imgHQ28389.npy +imgHQ28400.npy +imgHQ19505.npy +imgHQ25874.npy +imgHQ28376.npy +imgHQ28623.npy +imgHQ12281.npy +imgHQ08625.npy +imgHQ22649.npy +imgHQ06046.npy +imgHQ15020.npy +imgHQ23214.npy +imgHQ23971.npy +imgHQ25078.npy +imgHQ27844.npy +imgHQ02849.npy +imgHQ17827.npy +imgHQ10537.npy +imgHQ22076.npy +imgHQ28768.npy +imgHQ00181.npy +imgHQ18477.npy +imgHQ10504.npy +imgHQ22761.npy +imgHQ16159.npy +imgHQ20150.npy +imgHQ17811.npy +imgHQ22991.npy +imgHQ18011.npy +imgHQ06874.npy +imgHQ26535.npy +imgHQ27124.npy +imgHQ11152.npy +imgHQ26585.npy +imgHQ22442.npy +imgHQ21634.npy +imgHQ24085.npy +imgHQ07644.npy +imgHQ05794.npy +imgHQ10898.npy +imgHQ12074.npy +imgHQ15088.npy +imgHQ16553.npy +imgHQ03113.npy +imgHQ18008.npy +imgHQ11518.npy +imgHQ03453.npy +imgHQ12835.npy +imgHQ05104.npy +imgHQ18394.npy +imgHQ12976.npy +imgHQ22224.npy +imgHQ12436.npy +imgHQ17186.npy +imgHQ28942.npy +imgHQ21930.npy +imgHQ02520.npy +imgHQ24317.npy +imgHQ05439.npy +imgHQ00094.npy +imgHQ15936.npy +imgHQ25855.npy +imgHQ02396.npy +imgHQ25094.npy +imgHQ14291.npy +imgHQ12801.npy +imgHQ14504.npy +imgHQ11804.npy +imgHQ18599.npy +imgHQ11192.npy +imgHQ10180.npy +imgHQ10266.npy +imgHQ08859.npy +imgHQ10114.npy +imgHQ26040.npy +imgHQ00956.npy +imgHQ28977.npy +imgHQ05378.npy +imgHQ02349.npy +imgHQ01532.npy +imgHQ10600.npy +imgHQ16384.npy +imgHQ26693.npy +imgHQ02103.npy +imgHQ23865.npy +imgHQ04355.npy +imgHQ14515.npy +imgHQ12303.npy +imgHQ04132.npy +imgHQ25431.npy +imgHQ05513.npy +imgHQ25818.npy +imgHQ14592.npy +imgHQ19597.npy +imgHQ06888.npy +imgHQ16288.npy +imgHQ24337.npy +imgHQ14218.npy +imgHQ14168.npy +imgHQ14311.npy +imgHQ13880.npy +imgHQ28060.npy +imgHQ28559.npy +imgHQ11136.npy +imgHQ01184.npy +imgHQ01548.npy +imgHQ07670.npy +imgHQ27601.npy +imgHQ23401.npy +imgHQ16120.npy +imgHQ29927.npy +imgHQ16755.npy +imgHQ13344.npy +imgHQ24549.npy +imgHQ27630.npy +imgHQ28302.npy +imgHQ04073.npy +imgHQ03268.npy +imgHQ03629.npy +imgHQ23370.npy +imgHQ08548.npy +imgHQ19673.npy +imgHQ14724.npy +imgHQ15439.npy +imgHQ03697.npy +imgHQ14749.npy +imgHQ13836.npy +imgHQ28324.npy +imgHQ10638.npy +imgHQ22215.npy +imgHQ20069.npy +imgHQ12733.npy +imgHQ07369.npy +imgHQ01057.npy +imgHQ03262.npy +imgHQ25102.npy +imgHQ05343.npy +imgHQ24454.npy +imgHQ03522.npy +imgHQ01981.npy +imgHQ27408.npy +imgHQ12488.npy +imgHQ22151.npy +imgHQ14123.npy +imgHQ08554.npy +imgHQ23303.npy +imgHQ11417.npy +imgHQ27946.npy +imgHQ26549.npy +imgHQ18243.npy +imgHQ07959.npy +imgHQ25157.npy +imgHQ04312.npy +imgHQ28419.npy +imgHQ26447.npy +imgHQ20612.npy +imgHQ05342.npy +imgHQ06505.npy +imgHQ29779.npy +imgHQ03298.npy +imgHQ18149.npy +imgHQ12268.npy +imgHQ22133.npy +imgHQ28140.npy +imgHQ24189.npy +imgHQ02101.npy +imgHQ24271.npy +imgHQ14099.npy +imgHQ06657.npy +imgHQ23661.npy +imgHQ24152.npy +imgHQ02766.npy +imgHQ19015.npy +imgHQ15331.npy +imgHQ02160.npy +imgHQ17124.npy +imgHQ13734.npy +imgHQ08502.npy +imgHQ26302.npy +imgHQ04127.npy +imgHQ11829.npy +imgHQ16851.npy +imgHQ26166.npy +imgHQ15087.npy +imgHQ23077.npy +imgHQ23775.npy +imgHQ28475.npy +imgHQ15833.npy +imgHQ20121.npy +imgHQ29814.npy +imgHQ22171.npy +imgHQ26107.npy +imgHQ17684.npy +imgHQ20387.npy +imgHQ01449.npy +imgHQ07383.npy +imgHQ07167.npy +imgHQ06989.npy +imgHQ09360.npy +imgHQ14464.npy +imgHQ19464.npy +imgHQ17050.npy +imgHQ04315.npy +imgHQ10961.npy +imgHQ03195.npy +imgHQ27228.npy +imgHQ25265.npy +imgHQ24334.npy +imgHQ19405.npy +imgHQ12684.npy +imgHQ03402.npy +imgHQ03274.npy +imgHQ27454.npy +imgHQ08896.npy +imgHQ21080.npy +imgHQ29232.npy +imgHQ04322.npy +imgHQ24319.npy +imgHQ26051.npy +imgHQ11852.npy +imgHQ09125.npy +imgHQ26117.npy +imgHQ18956.npy +imgHQ26139.npy +imgHQ09632.npy +imgHQ05691.npy +imgHQ23016.npy +imgHQ08146.npy +imgHQ23667.npy +imgHQ24488.npy +imgHQ17438.npy +imgHQ12191.npy +imgHQ12859.npy +imgHQ19506.npy +imgHQ10095.npy +imgHQ12192.npy +imgHQ09028.npy +imgHQ22714.npy +imgHQ16647.npy +imgHQ00288.npy +imgHQ05407.npy +imgHQ09656.npy +imgHQ26289.npy +imgHQ24400.npy +imgHQ13923.npy +imgHQ26380.npy +imgHQ15800.npy +imgHQ01223.npy +imgHQ03318.npy +imgHQ01526.npy +imgHQ26986.npy +imgHQ20260.npy +imgHQ29629.npy +imgHQ12497.npy +imgHQ28913.npy +imgHQ01844.npy +imgHQ28413.npy +imgHQ18478.npy +imgHQ17100.npy +imgHQ23735.npy +imgHQ28327.npy +imgHQ15901.npy +imgHQ19460.npy +imgHQ09108.npy +imgHQ00069.npy +imgHQ24207.npy +imgHQ12593.npy +imgHQ18250.npy +imgHQ28409.npy +imgHQ18063.npy +imgHQ10288.npy +imgHQ23757.npy +imgHQ19275.npy +imgHQ05536.npy +imgHQ18183.npy +imgHQ17118.npy +imgHQ03706.npy +imgHQ20847.npy +imgHQ16951.npy +imgHQ09296.npy +imgHQ17179.npy +imgHQ20542.npy +imgHQ12854.npy +imgHQ21138.npy +imgHQ11198.npy +imgHQ03392.npy +imgHQ29948.npy +imgHQ01303.npy +imgHQ18778.npy +imgHQ06533.npy +imgHQ08589.npy +imgHQ09444.npy +imgHQ27105.npy +imgHQ15017.npy +imgHQ28709.npy +imgHQ19124.npy +imgHQ04447.npy +imgHQ02974.npy +imgHQ01610.npy +imgHQ23136.npy +imgHQ20025.npy +imgHQ07126.npy +imgHQ23079.npy +imgHQ02565.npy +imgHQ25328.npy +imgHQ21939.npy +imgHQ02926.npy +imgHQ10320.npy +imgHQ07476.npy +imgHQ27798.npy +imgHQ27939.npy +imgHQ26112.npy +imgHQ15269.npy +imgHQ19220.npy +imgHQ21534.npy +imgHQ26925.npy +imgHQ04365.npy +imgHQ12159.npy +imgHQ25495.npy +imgHQ00362.npy +imgHQ13572.npy +imgHQ04063.npy +imgHQ05394.npy +imgHQ06011.npy +imgHQ12491.npy +imgHQ23456.npy +imgHQ11768.npy +imgHQ06159.npy +imgHQ10254.npy +imgHQ16646.npy +imgHQ06932.npy +imgHQ03782.npy +imgHQ13352.npy +imgHQ02577.npy +imgHQ16474.npy +imgHQ18417.npy +imgHQ28054.npy +imgHQ11917.npy +imgHQ22728.npy +imgHQ07629.npy +imgHQ27060.npy +imgHQ28520.npy +imgHQ27184.npy +imgHQ25787.npy +imgHQ14272.npy +imgHQ21508.npy +imgHQ03965.npy +imgHQ25535.npy +imgHQ18766.npy +imgHQ28434.npy +imgHQ16974.npy +imgHQ11483.npy +imgHQ06576.npy +imgHQ20925.npy +imgHQ27932.npy +imgHQ19078.npy +imgHQ08132.npy +imgHQ18139.npy +imgHQ09729.npy +imgHQ16224.npy +imgHQ29626.npy +imgHQ08282.npy +imgHQ09993.npy +imgHQ20276.npy +imgHQ10298.npy +imgHQ17003.npy +imgHQ08688.npy +imgHQ08428.npy +imgHQ29902.npy +imgHQ17264.npy +imgHQ05380.npy +imgHQ05404.npy +imgHQ12920.npy +imgHQ00928.npy +imgHQ12839.npy +imgHQ28055.npy +imgHQ08888.npy +imgHQ00131.npy +imgHQ26783.npy +imgHQ10609.npy +imgHQ08832.npy +imgHQ09943.npy +imgHQ09279.npy +imgHQ13221.npy +imgHQ25016.npy +imgHQ12930.npy +imgHQ09233.npy +imgHQ29777.npy +imgHQ00578.npy +imgHQ28591.npy +imgHQ17445.npy +imgHQ29342.npy +imgHQ03228.npy +imgHQ26181.npy +imgHQ26619.npy +imgHQ19746.npy +imgHQ18625.npy +imgHQ14583.npy +imgHQ13223.npy +imgHQ08129.npy +imgHQ29650.npy +imgHQ04464.npy +imgHQ04737.npy +imgHQ27543.npy +imgHQ28761.npy +imgHQ11236.npy +imgHQ09465.npy +imgHQ29138.npy +imgHQ08363.npy +imgHQ20324.npy +imgHQ09821.npy +imgHQ28850.npy +imgHQ02403.npy +imgHQ08058.npy +imgHQ28822.npy +imgHQ05839.npy +imgHQ09664.npy +imgHQ02953.npy +imgHQ04239.npy +imgHQ11422.npy +imgHQ27441.npy +imgHQ21122.npy +imgHQ13904.npy +imgHQ29760.npy +imgHQ20928.npy +imgHQ06287.npy +imgHQ05986.npy +imgHQ02493.npy +imgHQ08440.npy +imgHQ06091.npy +imgHQ15568.npy +imgHQ24027.npy +imgHQ06493.npy +imgHQ15139.npy +imgHQ18798.npy +imgHQ20197.npy +imgHQ13835.npy +imgHQ17619.npy +imgHQ12725.npy +imgHQ03865.npy +imgHQ06080.npy +imgHQ27927.npy +imgHQ19082.npy +imgHQ10080.npy +imgHQ03883.npy +imgHQ28845.npy +imgHQ14709.npy +imgHQ27238.npy +imgHQ25766.npy +imgHQ25249.npy +imgHQ15668.npy +imgHQ26210.npy +imgHQ21583.npy +imgHQ15689.npy +imgHQ26598.npy +imgHQ29333.npy +imgHQ26487.npy +imgHQ03921.npy +imgHQ17310.npy +imgHQ08937.npy +imgHQ28245.npy +imgHQ02922.npy +imgHQ27418.npy +imgHQ18062.npy +imgHQ21277.npy +imgHQ24578.npy +imgHQ20641.npy +imgHQ20302.npy +imgHQ12112.npy +imgHQ28494.npy +imgHQ25237.npy +imgHQ15284.npy +imgHQ06748.npy +imgHQ00657.npy +imgHQ29429.npy +imgHQ11126.npy +imgHQ06249.npy +imgHQ27456.npy +imgHQ28069.npy +imgHQ05167.npy +imgHQ17253.npy +imgHQ28432.npy +imgHQ05054.npy +imgHQ21060.npy +imgHQ08784.npy +imgHQ22447.npy +imgHQ09625.npy +imgHQ17886.npy +imgHQ24590.npy +imgHQ07203.npy +imgHQ17836.npy +imgHQ01973.npy +imgHQ04596.npy +imgHQ06917.npy +imgHQ05457.npy +imgHQ02141.npy +imgHQ26770.npy +imgHQ15685.npy +imgHQ20473.npy +imgHQ27725.npy +imgHQ18573.npy +imgHQ29114.npy +imgHQ08189.npy +imgHQ21304.npy +imgHQ26299.npy +imgHQ27885.npy +imgHQ00242.npy +imgHQ24394.npy +imgHQ09258.npy +imgHQ12836.npy +imgHQ01509.npy +imgHQ26202.npy +imgHQ23876.npy +imgHQ19815.npy +imgHQ19494.npy +imgHQ08241.npy +imgHQ13518.npy +imgHQ04908.npy +imgHQ26009.npy +imgHQ04192.npy +imgHQ00293.npy +imgHQ25392.npy +imgHQ12012.npy +imgHQ21542.npy +imgHQ20987.npy +imgHQ28303.npy +imgHQ02375.npy +imgHQ15954.npy +imgHQ26338.npy +imgHQ20231.npy +imgHQ21010.npy +imgHQ28648.npy +imgHQ03009.npy +imgHQ11373.npy +imgHQ10132.npy +imgHQ26785.npy +imgHQ05700.npy +imgHQ27154.npy +imgHQ18917.npy +imgHQ13955.npy +imgHQ28257.npy +imgHQ23361.npy +imgHQ16908.npy +imgHQ23808.npy +imgHQ18606.npy +imgHQ10618.npy +imgHQ04209.npy +imgHQ06492.npy +imgHQ25498.npy +imgHQ04328.npy +imgHQ13378.npy +imgHQ12726.npy +imgHQ18534.npy +imgHQ23875.npy +imgHQ04791.npy +imgHQ29003.npy +imgHQ28197.npy +imgHQ28609.npy +imgHQ24922.npy +imgHQ19770.npy +imgHQ28744.npy +imgHQ23790.npy +imgHQ26778.npy +imgHQ20746.npy +imgHQ19938.npy +imgHQ20335.npy +imgHQ09047.npy +imgHQ01903.npy +imgHQ16708.npy +imgHQ00276.npy +imgHQ03353.npy +imgHQ01429.npy +imgHQ08917.npy +imgHQ12643.npy +imgHQ26077.npy +imgHQ07034.npy +imgHQ11137.npy +imgHQ19430.npy +imgHQ26159.npy +imgHQ12091.npy +imgHQ21007.npy +imgHQ20136.npy +imgHQ04178.npy +imgHQ03587.npy +imgHQ06169.npy +imgHQ18408.npy +imgHQ29936.npy +imgHQ07653.npy +imgHQ02934.npy +imgHQ08653.npy +imgHQ08098.npy +imgHQ13278.npy +imgHQ07860.npy +imgHQ09936.npy +imgHQ14844.npy +imgHQ28880.npy +imgHQ12674.npy +imgHQ13428.npy +imgHQ07879.npy +imgHQ06968.npy +imgHQ15437.npy +imgHQ29978.npy +imgHQ10893.npy +imgHQ03346.npy +imgHQ27307.npy +imgHQ20363.npy +imgHQ17375.npy +imgHQ29595.npy +imgHQ22032.npy +imgHQ27480.npy +imgHQ17655.npy +imgHQ26445.npy +imgHQ28966.npy +imgHQ26879.npy +imgHQ28644.npy +imgHQ18323.npy +imgHQ27742.npy +imgHQ19152.npy +imgHQ08957.npy +imgHQ02088.npy +imgHQ13061.npy +imgHQ03817.npy +imgHQ23746.npy +imgHQ17363.npy +imgHQ01733.npy +imgHQ11625.npy +imgHQ28841.npy +imgHQ02015.npy +imgHQ07083.npy +imgHQ21688.npy +imgHQ00979.npy +imgHQ28179.npy +imgHQ28944.npy +imgHQ24351.npy +imgHQ04405.npy +imgHQ19948.npy +imgHQ00858.npy +imgHQ18944.npy +imgHQ10153.npy +imgHQ19737.npy +imgHQ24662.npy +imgHQ23345.npy +imgHQ17807.npy +imgHQ22570.npy +imgHQ25933.npy +imgHQ29742.npy +imgHQ04613.npy +imgHQ26126.npy +imgHQ26450.npy +imgHQ20938.npy +imgHQ14485.npy +imgHQ29382.npy +imgHQ27056.npy +imgHQ22164.npy +imgHQ00749.npy +imgHQ20106.npy +imgHQ00676.npy +imgHQ17682.npy +imgHQ01750.npy +imgHQ15227.npy +imgHQ05447.npy +imgHQ25965.npy +imgHQ28696.npy +imgHQ10055.npy +imgHQ20350.npy +imgHQ05625.npy +imgHQ21593.npy +imgHQ27170.npy +imgHQ04082.npy +imgHQ29157.npy +imgHQ20621.npy +imgHQ12221.npy +imgHQ17617.npy +imgHQ29050.npy +imgHQ09334.npy +imgHQ26283.npy +imgHQ10685.npy +imgHQ12317.npy +imgHQ26936.npy +imgHQ20681.npy +imgHQ24762.npy +imgHQ12659.npy +imgHQ09964.npy +imgHQ26702.npy +imgHQ11562.npy +imgHQ25804.npy +imgHQ19857.npy +imgHQ11155.npy +imgHQ07635.npy +imgHQ06391.npy +imgHQ15055.npy +imgHQ28909.npy +imgHQ26477.npy +imgHQ02789.npy +imgHQ16100.npy +imgHQ10207.npy +imgHQ27987.npy +imgHQ06197.npy +imgHQ28887.npy +imgHQ26979.npy +imgHQ29083.npy +imgHQ28814.npy +imgHQ14312.npy +imgHQ25213.npy +imgHQ04242.npy +imgHQ26412.npy +imgHQ21117.npy +imgHQ07355.npy +imgHQ28243.npy +imgHQ23012.npy +imgHQ05612.npy +imgHQ06831.npy +imgHQ18589.npy +imgHQ21238.npy +imgHQ24059.npy +imgHQ05359.npy +imgHQ24693.npy +imgHQ21568.npy +imgHQ11060.npy +imgHQ12255.npy +imgHQ02299.npy +imgHQ00859.npy +imgHQ25309.npy +imgHQ09407.npy +imgHQ02204.npy +imgHQ08575.npy +imgHQ16857.npy +imgHQ11298.npy +imgHQ09428.npy +imgHQ26995.npy +imgHQ10311.npy +imgHQ01900.npy +imgHQ29312.npy +imgHQ20267.npy +imgHQ18642.npy +imgHQ00515.npy +imgHQ02427.npy +imgHQ04278.npy +imgHQ02388.npy +imgHQ18393.npy +imgHQ06251.npy +imgHQ28053.npy +imgHQ00967.npy +imgHQ12966.npy +imgHQ13276.npy +imgHQ07267.npy +imgHQ17397.npy +imgHQ00899.npy +imgHQ28040.npy +imgHQ14799.npy +imgHQ03838.npy +imgHQ14913.npy +imgHQ27448.npy +imgHQ24935.npy +imgHQ04840.npy +imgHQ15034.npy +imgHQ13387.npy +imgHQ04423.npy +imgHQ26448.npy +imgHQ29873.npy +imgHQ23287.npy +imgHQ05478.npy +imgHQ23427.npy +imgHQ08514.npy +imgHQ28561.npy +imgHQ07603.npy +imgHQ22942.npy +imgHQ07986.npy +imgHQ19120.npy +imgHQ23279.npy +imgHQ20102.npy +imgHQ00718.npy +imgHQ21069.npy +imgHQ26186.npy +imgHQ06224.npy +imgHQ07283.npy +imgHQ21417.npy +imgHQ04236.npy +imgHQ08944.npy +imgHQ11692.npy +imgHQ28734.npy +imgHQ06146.npy +imgHQ23194.npy +imgHQ04357.npy +imgHQ10776.npy +imgHQ24937.npy +imgHQ10210.npy +imgHQ01910.npy +imgHQ00446.npy +imgHQ07178.npy +imgHQ21713.npy +imgHQ05563.npy +imgHQ08522.npy +imgHQ03825.npy +imgHQ20958.npy +imgHQ10406.npy +imgHQ06028.npy +imgHQ18609.npy +imgHQ29140.npy +imgHQ05523.npy +imgHQ10850.npy +imgHQ06631.npy +imgHQ20373.npy +imgHQ11742.npy +imgHQ26275.npy +imgHQ04742.npy +imgHQ22644.npy +imgHQ25281.npy +imgHQ11395.npy +imgHQ21778.npy +imgHQ00915.npy +imgHQ11258.npy +imgHQ09435.npy +imgHQ16304.npy +imgHQ07572.npy +imgHQ17142.npy +imgHQ21412.npy +imgHQ05360.npy +imgHQ02615.npy +imgHQ10324.npy +imgHQ17479.npy +imgHQ19142.npy +imgHQ01655.npy +imgHQ19825.npy +imgHQ20461.npy +imgHQ00477.npy +imgHQ16921.npy +imgHQ27330.npy +imgHQ23291.npy +imgHQ02383.npy +imgHQ05290.npy +imgHQ01256.npy +imgHQ20171.npy +imgHQ26045.npy +imgHQ16743.npy +imgHQ24939.npy +imgHQ13980.npy +imgHQ06994.npy +imgHQ16390.npy +imgHQ20328.npy +imgHQ23035.npy +imgHQ08559.npy +imgHQ15025.npy +imgHQ04336.npy +imgHQ00149.npy +imgHQ19258.npy +imgHQ14567.npy +imgHQ23387.npy +imgHQ21611.npy +imgHQ24879.npy +imgHQ28157.npy +imgHQ29452.npy +imgHQ28397.npy +imgHQ16930.npy +imgHQ24722.npy +imgHQ21334.npy +imgHQ25009.npy +imgHQ18575.npy +imgHQ09191.npy +imgHQ08312.npy +imgHQ29944.npy +imgHQ10773.npy +imgHQ22686.npy +imgHQ24802.npy +imgHQ14862.npy +imgHQ05861.npy +imgHQ14898.npy +imgHQ04191.npy +imgHQ24714.npy +imgHQ02129.npy +imgHQ21040.npy +imgHQ27139.npy +imgHQ27452.npy +imgHQ25297.npy +imgHQ15525.npy +imgHQ20019.npy +imgHQ19075.npy +imgHQ01716.npy +imgHQ11317.npy +imgHQ28592.npy +imgHQ05898.npy +imgHQ15915.npy +imgHQ27546.npy +imgHQ29861.npy +imgHQ18568.npy +imgHQ14041.npy +imgHQ29996.npy +imgHQ05973.npy +imgHQ16314.npy +imgHQ21136.npy +imgHQ06833.npy +imgHQ13932.npy +imgHQ15764.npy +imgHQ08642.npy +imgHQ00831.npy +imgHQ11282.npy +imgHQ15490.npy +imgHQ06373.npy +imgHQ06755.npy +imgHQ12631.npy +imgHQ04890.npy +imgHQ12766.npy +imgHQ03948.npy +imgHQ05931.npy +imgHQ26708.npy +imgHQ19034.npy +imgHQ05788.npy +imgHQ22105.npy +imgHQ23264.npy +imgHQ04515.npy +imgHQ18290.npy +imgHQ16460.npy +imgHQ08523.npy +imgHQ20380.npy +imgHQ07723.npy +imgHQ17712.npy +imgHQ25885.npy +imgHQ18865.npy +imgHQ18138.npy +imgHQ08410.npy +imgHQ18716.npy +imgHQ08299.npy +imgHQ19578.npy +imgHQ22421.npy +imgHQ07133.npy +imgHQ27151.npy +imgHQ18384.npy +imgHQ08988.npy +imgHQ25565.npy +imgHQ14775.npy +imgHQ27917.npy +imgHQ08533.npy +imgHQ10578.npy +imgHQ12749.npy +imgHQ18271.npy +imgHQ00906.npy +imgHQ06084.npy +imgHQ15309.npy +imgHQ21802.npy +imgHQ27006.npy +imgHQ03727.npy +imgHQ21041.npy +imgHQ00623.npy +imgHQ09254.npy +imgHQ27319.npy +imgHQ12521.npy +imgHQ02772.npy +imgHQ18680.npy +imgHQ09200.npy +imgHQ22227.npy +imgHQ00798.npy +imgHQ17207.npy +imgHQ15824.npy +imgHQ01240.npy +imgHQ04346.npy +imgHQ14971.npy +imgHQ20045.npy +imgHQ20730.npy +imgHQ18530.npy +imgHQ01458.npy +imgHQ19686.npy +imgHQ11702.npy +imgHQ22631.npy +imgHQ03678.npy +imgHQ18646.npy +imgHQ17985.npy +imgHQ03342.npy +imgHQ01178.npy +imgHQ28725.npy +imgHQ29021.npy +imgHQ22867.npy +imgHQ22790.npy +imgHQ01301.npy +imgHQ05300.npy +imgHQ13169.npy +imgHQ13132.npy +imgHQ03539.npy +imgHQ00308.npy +imgHQ01579.npy +imgHQ29888.npy +imgHQ14959.npy +imgHQ20009.npy +imgHQ09690.npy +imgHQ13469.npy +imgHQ13507.npy +imgHQ10602.npy +imgHQ18652.npy +imgHQ07654.npy +imgHQ04153.npy +imgHQ19881.npy +imgHQ09308.npy +imgHQ16078.npy +imgHQ17399.npy +imgHQ29102.npy +imgHQ00734.npy +imgHQ25993.npy +imgHQ24099.npy +imgHQ14180.npy +imgHQ17702.npy +imgHQ19374.npy +imgHQ27372.npy +imgHQ11161.npy +imgHQ25291.npy +imgHQ10101.npy +imgHQ10118.npy +imgHQ09190.npy +imgHQ18857.npy +imgHQ07857.npy +imgHQ07302.npy +imgHQ26782.npy +imgHQ13758.npy +imgHQ08605.npy +imgHQ29436.npy +imgHQ02026.npy +imgHQ22169.npy +imgHQ11537.npy +imgHQ06196.npy +imgHQ26214.npy +imgHQ18670.npy +imgHQ18505.npy +imgHQ02192.npy +imgHQ04500.npy +imgHQ15044.npy +imgHQ12335.npy +imgHQ04363.npy +imgHQ17853.npy +imgHQ29412.npy +imgHQ06205.npy +imgHQ07710.npy +imgHQ15740.npy +imgHQ02309.npy +imgHQ07016.npy +imgHQ10921.npy +imgHQ26658.npy +imgHQ11873.npy +imgHQ24594.npy +imgHQ19166.npy +imgHQ16269.npy +imgHQ23262.npy +imgHQ22424.npy +imgHQ21640.npy +imgHQ09431.npy +imgHQ16663.npy +imgHQ23030.npy +imgHQ09779.npy +imgHQ14870.npy +imgHQ22513.npy +imgHQ21950.npy +imgHQ27538.npy +imgHQ07144.npy +imgHQ17174.npy +imgHQ00215.npy +imgHQ02596.npy +imgHQ07428.npy +imgHQ24685.npy +imgHQ10052.npy +imgHQ08044.npy +imgHQ11315.npy +imgHQ08797.npy +imgHQ24340.npy +imgHQ23697.npy +imgHQ11844.npy +imgHQ28671.npy +imgHQ14139.npy +imgHQ16506.npy +imgHQ07015.npy +imgHQ03646.npy +imgHQ20368.npy +imgHQ20799.npy +imgHQ12909.npy +imgHQ26234.npy +imgHQ17881.npy +imgHQ12203.npy +imgHQ04614.npy +imgHQ19397.npy +imgHQ02970.npy +imgHQ16060.npy +imgHQ15515.npy +imgHQ28264.npy +imgHQ21591.npy +imgHQ17049.npy +imgHQ14532.npy +imgHQ04537.npy +imgHQ17371.npy +imgHQ08844.npy +imgHQ17312.npy +imgHQ18345.npy +imgHQ05664.npy +imgHQ18144.npy +imgHQ05375.npy +imgHQ23886.npy +imgHQ27174.npy +imgHQ27175.npy +imgHQ24014.npy +imgHQ19456.npy +imgHQ22093.npy +imgHQ09817.npy +imgHQ22756.npy +imgHQ10840.npy +imgHQ18022.npy +imgHQ26111.npy +imgHQ29818.npy +imgHQ26527.npy +imgHQ05617.npy +imgHQ15334.npy +imgHQ06901.npy +imgHQ11274.npy +imgHQ28192.npy +imgHQ00081.npy +imgHQ14002.npy +imgHQ25407.npy +imgHQ24637.npy +imgHQ01180.npy +imgHQ07750.npy +imgHQ26254.npy +imgHQ12780.npy +imgHQ28833.npy +imgHQ21308.npy +imgHQ12928.npy +imgHQ18434.npy +imgHQ07845.npy +imgHQ02601.npy +imgHQ19800.npy +imgHQ26621.npy +imgHQ22161.npy +imgHQ09001.npy +imgHQ13891.npy +imgHQ17350.npy +imgHQ25978.npy +imgHQ14279.npy +imgHQ15947.npy +imgHQ26485.npy +imgHQ14164.npy +imgHQ04893.npy +imgHQ07305.npy +imgHQ23374.npy +imgHQ21908.npy +imgHQ17593.npy +imgHQ12293.npy +imgHQ24242.npy +imgHQ15693.npy +imgHQ28476.npy +imgHQ17775.npy +imgHQ02364.npy +imgHQ23531.npy +imgHQ04658.npy +imgHQ28131.npy +imgHQ23491.npy +imgHQ29454.npy +imgHQ22957.npy +imgHQ07333.npy +imgHQ13574.npy +imgHQ11764.npy +imgHQ23720.npy +imgHQ23159.npy +imgHQ16167.npy +imgHQ15621.npy +imgHQ22985.npy +imgHQ09704.npy +imgHQ29832.npy +imgHQ15930.npy +imgHQ17096.npy +imgHQ15296.npy +imgHQ09835.npy +imgHQ05263.npy +imgHQ02334.npy +imgHQ15657.npy +imgHQ15006.npy +imgHQ04071.npy +imgHQ02093.npy +imgHQ27050.npy +imgHQ27355.npy +imgHQ29462.npy +imgHQ00663.npy +imgHQ22817.npy +imgHQ08553.npy +imgHQ23920.npy +imgHQ23696.npy +imgHQ03545.npy +imgHQ26850.npy +imgHQ17128.npy +imgHQ05077.npy +imgHQ25497.npy +imgHQ09171.npy +imgHQ03165.npy +imgHQ01260.npy +imgHQ15483.npy +imgHQ05723.npy +imgHQ12802.npy +imgHQ22529.npy +imgHQ15806.npy +imgHQ27214.npy +imgHQ01872.npy +imgHQ12354.npy +imgHQ11050.npy +imgHQ29133.npy +imgHQ27607.npy +imgHQ26974.npy +imgHQ03322.npy +imgHQ19191.npy +imgHQ28090.npy +imgHQ02813.npy +imgHQ09606.npy +imgHQ27536.npy +imgHQ16655.npy +imgHQ24633.npy +imgHQ21852.npy +imgHQ01455.npy +imgHQ18409.npy +imgHQ16157.npy +imgHQ28995.npy +imgHQ16282.npy +imgHQ00172.npy +imgHQ14884.npy +imgHQ01093.npy +imgHQ06175.npy +imgHQ24429.npy +imgHQ16403.npy +imgHQ29845.npy +imgHQ16816.npy +imgHQ02868.npy +imgHQ13488.npy +imgHQ29793.npy +imgHQ04368.npy +imgHQ11650.npy +imgHQ11188.npy +imgHQ25270.npy +imgHQ04884.npy +imgHQ24364.npy +imgHQ11550.npy +imgHQ07402.npy +imgHQ25534.npy +imgHQ20924.npy +imgHQ12333.npy +imgHQ20635.npy +imgHQ28659.npy +imgHQ09904.npy +imgHQ08998.npy +imgHQ10113.npy +imgHQ05195.npy +imgHQ11430.npy +imgHQ25675.npy +imgHQ20710.npy +imgHQ21310.npy +imgHQ14480.npy +imgHQ01218.npy +imgHQ14587.npy +imgHQ17046.npy +imgHQ11758.npy +imgHQ11962.npy +imgHQ20394.npy +imgHQ15380.npy +imgHQ11374.npy +imgHQ06390.npy +imgHQ23369.npy +imgHQ06364.npy +imgHQ07718.npy +imgHQ17304.npy +imgHQ25785.npy +imgHQ20284.npy +imgHQ08599.npy +imgHQ17592.npy +imgHQ19906.npy +imgHQ02713.npy +imgHQ18993.npy +imgHQ27398.npy +imgHQ22994.npy +imgHQ13627.npy +imgHQ28525.npy +imgHQ21039.npy +imgHQ10418.npy +imgHQ05852.npy +imgHQ10150.npy +imgHQ14382.npy +imgHQ09639.npy +imgHQ22892.npy +imgHQ20983.npy +imgHQ03120.npy +imgHQ19524.npy +imgHQ12059.npy +imgHQ11943.npy +imgHQ18451.npy +imgHQ27680.npy +imgHQ13889.npy +imgHQ12330.npy +imgHQ16150.npy +imgHQ18753.npy +imgHQ11149.npy +imgHQ26025.npy +imgHQ25556.npy +imgHQ07098.npy +imgHQ13241.npy +imgHQ11967.npy +imgHQ11938.npy +imgHQ05710.npy +imgHQ16420.npy +imgHQ14221.npy +imgHQ14237.npy +imgHQ07336.npy +imgHQ14163.npy +imgHQ27266.npy +imgHQ14463.npy +imgHQ12503.npy +imgHQ23087.npy +imgHQ24329.npy +imgHQ25250.npy +imgHQ24516.npy +imgHQ17263.npy +imgHQ11597.npy +imgHQ13178.npy +imgHQ21962.npy +imgHQ23172.npy +imgHQ09980.npy +imgHQ00244.npy +imgHQ01598.npy +imgHQ14106.npy +imgHQ20690.npy +imgHQ22310.npy +imgHQ10558.npy +imgHQ23912.npy +imgHQ21523.npy +imgHQ03469.npy +imgHQ22672.npy +imgHQ04352.npy +imgHQ14442.npy +imgHQ21317.npy +imgHQ26438.npy +imgHQ21747.npy +imgHQ18006.npy +imgHQ29834.npy +imgHQ10480.npy +imgHQ28333.npy +imgHQ12913.npy +imgHQ10000.npy +imgHQ06109.npy +imgHQ25819.npy +imgHQ12126.npy +imgHQ07249.npy +imgHQ16679.npy +imgHQ01340.npy +imgHQ17066.npy +imgHQ00295.npy +imgHQ26076.npy +imgHQ09392.npy +imgHQ18567.npy +imgHQ11187.npy +imgHQ04532.npy +imgHQ27337.npy +imgHQ03937.npy +imgHQ11438.npy +imgHQ19634.npy +imgHQ16055.npy +imgHQ13442.npy +imgHQ15640.npy +imgHQ02272.npy +imgHQ18042.npy +imgHQ07202.npy +imgHQ25140.npy +imgHQ17776.npy +imgHQ03471.npy +imgHQ00283.npy +imgHQ16145.npy +imgHQ16132.npy +imgHQ19251.npy +imgHQ14851.npy +imgHQ05012.npy +imgHQ25706.npy +imgHQ13965.npy +imgHQ14020.npy +imgHQ07470.npy +imgHQ27922.npy +imgHQ12796.npy +imgHQ16441.npy +imgHQ29521.npy +imgHQ27379.npy +imgHQ20190.npy +imgHQ12715.npy +imgHQ15089.npy +imgHQ14991.npy +imgHQ11552.npy +imgHQ26749.npy +imgHQ05854.npy +imgHQ10978.npy +imgHQ04141.npy +imgHQ21812.npy +imgHQ11194.npy +imgHQ18502.npy +imgHQ12218.npy +imgHQ22049.npy +imgHQ23600.npy +imgHQ18675.npy +imgHQ17234.npy +imgHQ24322.npy +imgHQ13451.npy +imgHQ05690.npy +imgHQ28546.npy +imgHQ16785.npy +imgHQ25104.npy +imgHQ05231.npy +imgHQ04408.npy +imgHQ19532.npy +imgHQ17518.npy +imgHQ27195.npy +imgHQ25841.npy +imgHQ29029.npy +imgHQ24641.npy +imgHQ02070.npy +imgHQ04233.npy +imgHQ16530.npy +imgHQ24559.npy +imgHQ26881.npy +imgHQ21620.npy +imgHQ16947.npy +imgHQ10808.npy +imgHQ02040.npy +imgHQ18315.npy +imgHQ28108.npy +imgHQ16915.npy +imgHQ26558.npy +imgHQ10847.npy +imgHQ19392.npy +imgHQ26864.npy +imgHQ23881.npy +imgHQ01603.npy +imgHQ24807.npy +imgHQ09483.npy +imgHQ10469.npy +imgHQ26548.npy +imgHQ17778.npy +imgHQ28410.npy +imgHQ22329.npy +imgHQ01921.npy +imgHQ08424.npy +imgHQ19520.npy +imgHQ02882.npy +imgHQ14261.npy +imgHQ19203.npy +imgHQ03336.npy +imgHQ09574.npy +imgHQ22939.npy +imgHQ24861.npy +imgHQ24636.npy +imgHQ10719.npy +imgHQ00919.npy +imgHQ06121.npy +imgHQ16131.npy +imgHQ24648.npy +imgHQ03487.npy +imgHQ23436.npy +imgHQ10297.npy +imgHQ07391.npy +imgHQ24031.npy +imgHQ05289.npy +imgHQ18241.npy +imgHQ23691.npy +imgHQ17854.npy +imgHQ20153.npy +imgHQ11538.npy +imgHQ08327.npy +imgHQ13302.npy +imgHQ14654.npy +imgHQ23782.npy +imgHQ02318.npy +imgHQ05721.npy +imgHQ09910.npy +imgHQ17034.npy +imgHQ22782.npy +imgHQ23862.npy +imgHQ14273.npy +imgHQ05277.npy +imgHQ01987.npy +imgHQ25069.npy +imgHQ00985.npy +imgHQ12782.npy +imgHQ02939.npy +imgHQ03281.npy +imgHQ09373.npy +imgHQ14920.npy +imgHQ10881.npy +imgHQ20726.npy +imgHQ26740.npy +imgHQ06131.npy +imgHQ03352.npy +imgHQ19650.npy +imgHQ05834.npy +imgHQ06749.npy +imgHQ12969.npy +imgHQ20353.npy +imgHQ27433.npy +imgHQ22893.npy +imgHQ13722.npy +imgHQ05579.npy +imgHQ25339.npy +imgHQ07207.npy +imgHQ26336.npy +imgHQ00934.npy +imgHQ11733.npy +imgHQ08646.npy +imgHQ11716.npy +imgHQ20515.npy +imgHQ25259.npy +imgHQ06126.npy +imgHQ01945.npy +imgHQ16256.npy +imgHQ01436.npy +imgHQ23536.npy +imgHQ01397.npy +imgHQ14053.npy +imgHQ25019.npy +imgHQ02524.npy +imgHQ02057.npy +imgHQ06862.npy +imgHQ28191.npy +imgHQ13423.npy +imgHQ06367.npy +imgHQ15160.npy +imgHQ11459.npy +imgHQ13384.npy +imgHQ16327.npy +imgHQ17600.npy +imgHQ16736.npy +imgHQ06190.npy +imgHQ21001.npy +imgHQ28552.npy +imgHQ18791.npy +imgHQ29578.npy +imgHQ29299.npy +imgHQ16544.npy +imgHQ29243.npy +imgHQ04151.npy +imgHQ29852.npy +imgHQ08960.npy +imgHQ21110.npy +imgHQ07243.npy +imgHQ20178.npy +imgHQ17552.npy +imgHQ13988.npy +imgHQ00200.npy +imgHQ24404.npy +imgHQ10910.npy +imgHQ06368.npy +imgHQ08481.npy +imgHQ11620.npy +imgHQ06421.npy +imgHQ10078.npy +imgHQ08278.npy +imgHQ15965.npy +imgHQ16858.npy +imgHQ05796.npy +imgHQ03567.npy +imgHQ03895.npy +imgHQ17031.npy +imgHQ16370.npy +imgHQ16352.npy +imgHQ20200.npy +imgHQ06343.npy +imgHQ13851.npy +imgHQ24471.npy +imgHQ05711.npy +imgHQ11261.npy +imgHQ02988.npy +imgHQ24277.npy +imgHQ15035.npy +imgHQ10305.npy +imgHQ25395.npy +imgHQ12815.npy +imgHQ26243.npy +imgHQ07932.npy +imgHQ04235.npy +imgHQ25520.npy +imgHQ04866.npy +imgHQ12811.npy +imgHQ17706.npy +imgHQ21631.npy +imgHQ18888.npy +imgHQ03452.npy +imgHQ07712.npy +imgHQ00284.npy +imgHQ10925.npy +imgHQ25943.npy +imgHQ21744.npy +imgHQ06718.npy +imgHQ20728.npy +imgHQ16936.npy +imgHQ03871.npy +imgHQ14267.npy +imgHQ14170.npy +imgHQ03159.npy +imgHQ16709.npy +imgHQ05410.npy +imgHQ03425.npy +imgHQ29085.npy +imgHQ05555.npy +imgHQ09528.npy +imgHQ18370.npy +imgHQ04180.npy +imgHQ17471.npy +imgHQ13893.npy +imgHQ24776.npy +imgHQ11365.npy +imgHQ09475.npy +imgHQ10316.npy +imgHQ12595.npy +imgHQ20076.npy +imgHQ20991.npy +imgHQ21658.npy +imgHQ24985.npy +imgHQ25238.npy +imgHQ19563.npy +imgHQ29835.npy +imgHQ23347.npy +imgHQ09773.npy +imgHQ24579.npy +imgHQ13072.npy +imgHQ24005.npy +imgHQ02752.npy +imgHQ09284.npy +imgHQ07766.npy +imgHQ21661.npy +imgHQ20545.npy +imgHQ27539.npy +imgHQ28890.npy +imgHQ28586.npy +imgHQ06113.npy +imgHQ13173.npy +imgHQ22929.npy +imgHQ28795.npy +imgHQ20523.npy +imgHQ08322.npy +imgHQ23925.npy +imgHQ02449.npy +imgHQ14604.npy +imgHQ23434.npy +imgHQ22001.npy +imgHQ05806.npy +imgHQ12175.npy +imgHQ03583.npy +imgHQ14198.npy +imgHQ27388.npy +imgHQ26651.npy +imgHQ29143.npy +imgHQ01035.npy +imgHQ23289.npy +imgHQ15478.npy +imgHQ14649.npy +imgHQ27031.npy +imgHQ17497.npy +imgHQ17024.npy +imgHQ07292.npy +imgHQ06558.npy +imgHQ27218.npy +imgHQ24381.npy +imgHQ20344.npy +imgHQ14191.npy +imgHQ08281.npy +imgHQ02681.npy +imgHQ23392.npy +imgHQ10583.npy +imgHQ28198.npy +imgHQ00857.npy +imgHQ07933.npy +imgHQ05397.npy +imgHQ06088.npy +imgHQ11168.npy +imgHQ01666.npy +imgHQ06761.npy +imgHQ29890.npy +imgHQ16668.npy +imgHQ10621.npy +imgHQ01221.npy +imgHQ16011.npy +imgHQ00918.npy +imgHQ12663.npy +imgHQ00709.npy +imgHQ02264.npy +imgHQ08040.npy +imgHQ08918.npy +imgHQ10355.npy +imgHQ19067.npy +imgHQ06119.npy +imgHQ13922.npy +imgHQ17421.npy +imgHQ10408.npy +imgHQ23837.npy +imgHQ26735.npy +imgHQ04126.npy +imgHQ28151.npy +imgHQ29913.npy +imgHQ17729.npy +imgHQ23323.npy +imgHQ26179.npy +imgHQ22342.npy +imgHQ14224.npy +imgHQ15734.npy +imgHQ17681.npy +imgHQ09824.npy +imgHQ14430.npy +imgHQ14014.npy +imgHQ09578.npy +imgHQ07116.npy +imgHQ27870.npy +imgHQ29182.npy +imgHQ05610.npy +imgHQ07447.npy +imgHQ21428.npy +imgHQ01381.npy +imgHQ24402.npy +imgHQ26890.npy +imgHQ19706.npy +imgHQ06920.npy +imgHQ25124.npy +imgHQ01318.npy +imgHQ02656.npy +imgHQ29859.npy +imgHQ11118.npy +imgHQ26852.npy +imgHQ20463.npy +imgHQ28565.npy +imgHQ16166.npy +imgHQ21849.npy +imgHQ06047.npy +imgHQ22385.npy +imgHQ18629.npy +imgHQ17296.npy +imgHQ27531.npy +imgHQ05915.npy +imgHQ23954.npy +imgHQ23763.npy +imgHQ09805.npy +imgHQ22509.npy +imgHQ12164.npy +imgHQ15771.npy +imgHQ20516.npy +imgHQ21302.npy +imgHQ17580.npy +imgHQ26313.npy +imgHQ06952.npy +imgHQ16607.npy +imgHQ25242.npy +imgHQ00938.npy +imgHQ20022.npy +imgHQ03651.npy +imgHQ29210.npy +imgHQ01813.npy +imgHQ12935.npy +imgHQ07360.npy +imgHQ17838.npy +imgHQ17069.npy +imgHQ19621.npy +imgHQ05398.npy +imgHQ29678.npy +imgHQ08953.npy +imgHQ11566.npy +imgHQ11901.npy +imgHQ24365.npy +imgHQ22247.npy +imgHQ04505.npy +imgHQ07002.npy +imgHQ20100.npy +imgHQ14072.npy +imgHQ10037.npy +imgHQ11688.npy +imgHQ26581.npy +imgHQ17198.npy +imgHQ12931.npy +imgHQ19710.npy +imgHQ07322.npy +imgHQ29426.npy +imgHQ06617.npy +imgHQ29684.npy +imgHQ05787.npy +imgHQ00425.npy +imgHQ12927.npy +imgHQ25084.npy +imgHQ24383.npy +imgHQ19004.npy +imgHQ21235.npy +imgHQ10175.npy +imgHQ20425.npy +imgHQ02460.npy +imgHQ12646.npy +imgHQ03209.npy +imgHQ08786.npy +imgHQ24815.npy +imgHQ20343.npy +imgHQ06101.npy +imgHQ12182.npy +imgHQ15412.npy +imgHQ04045.npy +imgHQ22884.npy +imgHQ22739.npy +imgHQ22444.npy +imgHQ04367.npy +imgHQ05141.npy +imgHQ09281.npy +imgHQ18124.npy +imgHQ04904.npy +imgHQ22793.npy +imgHQ12658.npy +imgHQ08926.npy +imgHQ01084.npy +imgHQ02049.npy +imgHQ08353.npy +imgHQ09776.npy +imgHQ08778.npy +imgHQ08387.npy +imgHQ06830.npy +imgHQ03343.npy +imgHQ02099.npy +imgHQ23902.npy +imgHQ07961.npy +imgHQ26274.npy +imgHQ27065.npy +imgHQ28470.npy +imgHQ08948.npy +imgHQ15643.npy +imgHQ28514.npy +imgHQ05940.npy +imgHQ21212.npy +imgHQ06521.npy +imgHQ13506.npy +imgHQ22086.npy +imgHQ23509.npy +imgHQ28361.npy +imgHQ00893.npy +imgHQ06052.npy +imgHQ26177.npy +imgHQ28451.npy +imgHQ02098.npy +imgHQ19273.npy +imgHQ03489.npy +imgHQ07925.npy +imgHQ27169.npy +imgHQ15276.npy +imgHQ25848.npy +imgHQ16970.npy +imgHQ20647.npy +imgHQ13521.npy +imgHQ00664.npy +imgHQ05142.npy +imgHQ11671.npy +imgHQ05759.npy +imgHQ16690.npy +imgHQ11185.npy +imgHQ23730.npy +imgHQ11212.npy +imgHQ23658.npy +imgHQ14111.npy +imgHQ05225.npy +imgHQ16775.npy +imgHQ10794.npy +imgHQ22109.npy +imgHQ21153.npy +imgHQ26238.npy +imgHQ05180.npy +imgHQ19165.npy +imgHQ19449.npy +imgHQ02629.npy +imgHQ08616.npy +imgHQ07673.npy +imgHQ21779.npy +imgHQ06432.npy +imgHQ27765.npy +imgHQ24175.npy +imgHQ01078.npy +imgHQ21867.npy +imgHQ25459.npy +imgHQ03394.npy +imgHQ05993.npy +imgHQ07916.npy +imgHQ08893.npy +imgHQ10900.npy +imgHQ08201.npy +imgHQ12740.npy +imgHQ10468.npy +imgHQ07342.npy +imgHQ21699.npy +imgHQ19235.npy +imgHQ26903.npy +imgHQ20757.npy +imgHQ09490.npy +imgHQ28426.npy +imgHQ29302.npy +imgHQ01383.npy +imgHQ11045.npy +imgHQ09449.npy +imgHQ06734.npy +imgHQ12594.npy +imgHQ10152.npy +imgHQ13643.npy +imgHQ24738.npy +imgHQ08032.npy +imgHQ06518.npy +imgHQ19371.npy +imgHQ28550.npy +imgHQ12814.npy +imgHQ04635.npy +imgHQ00360.npy +imgHQ08687.npy +imgHQ07675.npy +imgHQ25429.npy +imgHQ03521.npy +imgHQ22871.npy +imgHQ24743.npy +imgHQ16849.npy +imgHQ06799.npy +imgHQ02439.npy +imgHQ19310.npy +imgHQ25416.npy +imgHQ14048.npy +imgHQ12426.npy +imgHQ02398.npy +imgHQ26677.npy +imgHQ02336.npy +imgHQ27938.npy +imgHQ02081.npy +imgHQ00574.npy +imgHQ23713.npy +imgHQ23499.npy +imgHQ16629.npy +imgHQ13079.npy +imgHQ08393.npy +imgHQ02606.npy +imgHQ22460.npy +imgHQ23814.npy +imgHQ17942.npy +imgHQ14263.npy +imgHQ25205.npy +imgHQ26649.npy +imgHQ08006.npy +imgHQ14861.npy +imgHQ26429.npy +imgHQ27990.npy +imgHQ14761.npy +imgHQ25676.npy +imgHQ01642.npy +imgHQ25436.npy +imgHQ01673.npy +imgHQ08540.npy +imgHQ13584.npy +imgHQ16385.npy +imgHQ14887.npy +imgHQ09759.npy +imgHQ09903.npy +imgHQ28782.npy +imgHQ12081.npy +imgHQ06813.npy +imgHQ06867.npy +imgHQ16030.npy +imgHQ29849.npy +imgHQ29559.npy +imgHQ18233.npy +imgHQ17834.npy +imgHQ24537.npy +imgHQ04843.npy +imgHQ26583.npy +imgHQ19743.npy +imgHQ12311.npy +imgHQ05552.npy +imgHQ22060.npy +imgHQ20248.npy +imgHQ23714.npy +imgHQ08326.npy +imgHQ28212.npy +imgHQ11263.npy +imgHQ05930.npy +imgHQ23799.npy +imgHQ23874.npy +imgHQ16805.npy +imgHQ15523.npy +imgHQ29823.npy +imgHQ27717.npy +imgHQ25870.npy +imgHQ26092.npy +imgHQ14432.npy +imgHQ05840.npy +imgHQ07583.npy +imgHQ21206.npy +imgHQ14133.npy +imgHQ06804.npy +imgHQ10816.npy +imgHQ20517.npy +imgHQ13332.npy +imgHQ18718.npy +imgHQ18957.npy +imgHQ10634.npy +imgHQ21248.npy +imgHQ06029.npy +imgHQ17917.npy +imgHQ09348.npy +imgHQ07033.npy +imgHQ07251.npy +imgHQ22390.npy +imgHQ17591.npy +imgHQ12054.npy +imgHQ11886.npy +imgHQ09499.npy +imgHQ18000.npy +imgHQ15618.npy +imgHQ20165.npy +imgHQ06868.npy +imgHQ16565.npy +imgHQ20426.npy +imgHQ18426.npy +imgHQ16483.npy +imgHQ29267.npy +imgHQ28008.npy +imgHQ09485.npy +imgHQ04213.npy +imgHQ06439.npy +imgHQ17268.npy +imgHQ00302.npy +imgHQ06128.npy +imgHQ01096.npy +imgHQ02829.npy +imgHQ03712.npy +imgHQ24193.npy +imgHQ27506.npy +imgHQ08160.npy +imgHQ28615.npy +imgHQ11153.npy +imgHQ10070.npy +imgHQ26726.npy +imgHQ25623.npy +imgHQ28907.npy +imgHQ15662.npy +imgHQ14776.npy +imgHQ06187.npy +imgHQ10864.npy +imgHQ15697.npy +imgHQ29255.npy +imgHQ07545.npy +imgHQ02490.npy +imgHQ18061.npy +imgHQ28571.npy +imgHQ16446.npy +imgHQ23583.npy +imgHQ03166.npy +imgHQ10482.npy +imgHQ09564.npy +imgHQ03356.npy +imgHQ27269.npy +imgHQ29747.npy +imgHQ00557.npy +imgHQ11100.npy +imgHQ15541.npy +imgHQ01663.npy +imgHQ14501.npy +imgHQ07124.npy +imgHQ12890.npy +imgHQ11999.npy +imgHQ07617.npy +imgHQ02652.npy +imgHQ07691.npy +imgHQ14864.npy +imgHQ10938.npy +imgHQ04611.npy +imgHQ18474.npy +imgHQ13066.npy +imgHQ01346.npy +imgHQ13052.npy +imgHQ00890.npy +imgHQ00375.npy +imgHQ26385.npy +imgHQ01512.npy +imgHQ25294.npy +imgHQ15114.npy +imgHQ19909.npy +imgHQ29877.npy +imgHQ02572.npy +imgHQ20026.npy +imgHQ22625.npy +imgHQ22524.npy +imgHQ01612.npy +imgHQ06020.npy +imgHQ08361.npy +imgHQ09694.npy +imgHQ28628.npy +imgHQ09049.npy +imgHQ10767.npy +imgHQ15628.npy +imgHQ03366.npy +imgHQ03208.npy +imgHQ27545.npy +imgHQ15310.npy +imgHQ16784.npy +imgHQ28979.npy +imgHQ08306.npy +imgHQ08103.npy +imgHQ04805.npy +imgHQ01672.npy +imgHQ10970.npy +imgHQ24622.npy +imgHQ19888.npy +imgHQ11150.npy +imgHQ12258.npy +imgHQ28796.npy +imgHQ07792.npy +imgHQ27972.npy +imgHQ10756.npy +imgHQ01739.npy +imgHQ13934.npy +imgHQ23547.npy +imgHQ25781.npy +imgHQ07058.npy +imgHQ19369.npy +imgHQ00853.npy +imgHQ12891.npy +imgHQ27475.npy +imgHQ01288.npy +imgHQ05798.npy +imgHQ08613.npy +imgHQ10706.npy +imgHQ17449.npy +imgHQ17566.npy +imgHQ26519.npy +imgHQ24647.npy +imgHQ25708.npy +imgHQ11842.npy +imgHQ21065.npy +imgHQ24681.npy +imgHQ23101.npy +imgHQ06092.npy +imgHQ14789.npy +imgHQ03640.npy +imgHQ04874.npy +imgHQ09646.npy +imgHQ08158.npy +imgHQ17208.npy +imgHQ11467.npy +imgHQ04294.npy +imgHQ04800.npy +imgHQ25334.npy +imgHQ26587.npy +imgHQ06234.npy +imgHQ03535.npy +imgHQ02817.npy +imgHQ12388.npy +imgHQ29355.npy +imgHQ26948.npy +imgHQ16455.npy +imgHQ08229.npy +imgHQ04426.npy +imgHQ02380.npy +imgHQ08728.npy +imgHQ17469.npy +imgHQ08185.npy +imgHQ28467.npy +imgHQ05052.npy +imgHQ18699.npy +imgHQ08433.npy +imgHQ22837.npy +imgHQ04587.npy +imgHQ02379.npy +imgHQ12499.npy +imgHQ28465.npy +imgHQ29327.npy +imgHQ10500.npy +imgHQ07062.npy +imgHQ10438.npy +imgHQ10710.npy +imgHQ18225.npy +imgHQ17503.npy +imgHQ22414.npy +imgHQ19370.npy +imgHQ11001.npy +imgHQ20724.npy +imgHQ26191.npy +imgHQ26983.npy +imgHQ27261.npy +imgHQ23381.npy +imgHQ15774.npy +imgHQ05469.npy +imgHQ16247.npy +imgHQ02444.npy +imgHQ05474.npy +imgHQ19147.npy +imgHQ00624.npy +imgHQ14319.npy +imgHQ08179.npy +imgHQ24136.npy +imgHQ23234.npy +imgHQ22748.npy +imgHQ18109.npy +imgHQ07439.npy +imgHQ18822.npy +imgHQ29576.npy +imgHQ10705.npy +imgHQ11228.npy +imgHQ00832.npy +imgHQ27361.npy +imgHQ25568.npy +imgHQ23873.npy +imgHQ13710.npy +imgHQ20577.npy +imgHQ26481.npy +imgHQ07218.npy +imgHQ20562.npy +imgHQ10006.npy +imgHQ16065.npy +imgHQ13470.npy +imgHQ09604.npy +imgHQ23293.npy +imgHQ19303.npy +imgHQ07847.npy +imgHQ02356.npy +imgHQ25887.npy +imgHQ13846.npy +imgHQ22666.npy +imgHQ13784.npy +imgHQ18156.npy +imgHQ25105.npy +imgHQ21466.npy +imgHQ06108.npy +imgHQ14755.npy +imgHQ27517.npy +imgHQ26497.npy +imgHQ28005.npy +imgHQ20765.npy +imgHQ21511.npy +imgHQ08637.npy +imgHQ28910.npy +imgHQ07445.npy +imgHQ07239.npy +imgHQ03145.npy +imgHQ10380.npy +imgHQ12627.npy +imgHQ25833.npy +imgHQ10924.npy +imgHQ28433.npy +imgHQ11493.npy +imgHQ00481.npy +imgHQ07507.npy +imgHQ08219.npy +imgHQ22969.npy +imgHQ18856.npy +imgHQ11375.npy +imgHQ10497.npy +imgHQ25642.npy +imgHQ03396.npy +imgHQ12827.npy +imgHQ19011.npy +imgHQ10338.npy +imgHQ05770.npy +imgHQ04246.npy +imgHQ17664.npy +imgHQ25229.npy +imgHQ10940.npy +imgHQ11777.npy +imgHQ16695.npy +imgHQ11217.npy +imgHQ08419.npy +imgHQ01284.npy +imgHQ13639.npy +imgHQ24353.npy +imgHQ22898.npy +imgHQ10932.npy +imgHQ03917.npy +imgHQ26498.npy +imgHQ25193.npy +imgHQ05377.npy +imgHQ24169.npy +imgHQ06248.npy +imgHQ04356.npy +imgHQ11740.npy +imgHQ01519.npy +imgHQ26200.npy +imgHQ14169.npy +imgHQ10922.npy +imgHQ04671.npy +imgHQ17216.npy +imgHQ04888.npy +imgHQ10526.npy +imgHQ11442.npy +imgHQ26490.npy +imgHQ10149.npy +imgHQ01361.npy +imgHQ02495.npy +imgHQ01829.npy +imgHQ22326.npy +imgHQ12791.npy +imgHQ20386.npy +imgHQ19875.npy +imgHQ22610.npy +imgHQ09809.npy +imgHQ25056.npy +imgHQ25228.npy +imgHQ08223.npy +imgHQ08717.npy +imgHQ16095.npy +imgHQ13733.npy +imgHQ14330.npy +imgHQ17562.npy +imgHQ08070.npy +imgHQ14425.npy +imgHQ14309.npy +imgHQ29431.npy +imgHQ19677.npy +imgHQ15960.npy +imgHQ22651.npy +imgHQ17393.npy +imgHQ04872.npy +imgHQ25598.npy +imgHQ18664.npy +imgHQ06381.npy +imgHQ00369.npy +imgHQ08940.npy +imgHQ21271.npy +imgHQ01211.npy +imgHQ28050.npy +imgHQ01614.npy +imgHQ28030.npy +imgHQ14007.npy +imgHQ00078.npy +imgHQ00349.npy +imgHQ23654.npy +imgHQ02965.npy +imgHQ05269.npy +imgHQ04161.npy +imgHQ26099.npy +imgHQ07195.npy +imgHQ11944.npy +imgHQ29223.npy +imgHQ19931.npy +imgHQ27828.npy +imgHQ08829.npy +imgHQ03798.npy +imgHQ10195.npy +imgHQ27513.npy +imgHQ29590.npy +imgHQ25112.npy +imgHQ17851.npy +imgHQ03566.npy +imgHQ03663.npy +imgHQ29338.npy +imgHQ18987.npy +imgHQ06572.npy +imgHQ18113.npy +imgHQ26934.npy +imgHQ01827.npy +imgHQ02274.npy +imgHQ08426.npy +imgHQ19055.npy +imgHQ12383.npy +imgHQ21469.npy +imgHQ11642.npy +imgHQ27252.npy +imgHQ19438.npy +imgHQ08819.npy +imgHQ25673.npy +imgHQ27007.npy +imgHQ23825.npy +imgHQ06155.npy +imgHQ06958.npy +imgHQ29798.npy +imgHQ06333.npy +imgHQ19672.npy +imgHQ20892.npy +imgHQ07885.npy +imgHQ16080.npy +imgHQ03679.npy +imgHQ18114.npy +imgHQ21478.npy +imgHQ01460.npy +imgHQ29483.npy +imgHQ09806.npy +imgHQ13895.npy +imgHQ04415.npy +imgHQ06601.npy +imgHQ13086.npy +imgHQ04034.npy +imgHQ11583.npy +imgHQ11573.npy +imgHQ20436.npy +imgHQ09069.npy +imgHQ24737.npy +imgHQ29934.npy +imgHQ22885.npy +imgHQ07118.npy +imgHQ15142.npy +imgHQ16457.npy +imgHQ13607.npy +imgHQ12721.npy +imgHQ07562.npy +imgHQ05835.npy +imgHQ18989.npy +imgHQ07987.npy +imgHQ23127.npy +imgHQ28667.npy +imgHQ13604.npy +imgHQ20313.npy +imgHQ21920.npy +imgHQ20511.npy +imgHQ25682.npy +imgHQ12978.npy +imgHQ24128.npy +imgHQ23527.npy +imgHQ15078.npy +imgHQ08212.npy +imgHQ14299.npy +imgHQ04676.npy +imgHQ22951.npy +imgHQ12109.npy +imgHQ19849.npy +imgHQ23070.npy +imgHQ16742.npy +imgHQ03939.npy +imgHQ15912.npy +imgHQ24704.npy +imgHQ26414.npy +imgHQ18291.npy +imgHQ21869.npy +imgHQ13879.npy +imgHQ23770.npy +imgHQ24734.npy +imgHQ13684.npy +imgHQ20054.npy +imgHQ17585.npy +imgHQ22024.npy +imgHQ28912.npy +imgHQ04007.npy +imgHQ12308.npy +imgHQ16869.npy +imgHQ02624.npy +imgHQ22419.npy +imgHQ28042.npy +imgHQ12142.npy +imgHQ14921.npy +imgHQ18539.npy +imgHQ07598.npy +imgHQ04175.npy +imgHQ06695.npy +imgHQ07796.npy +imgHQ22431.npy +imgHQ17656.npy +imgHQ14428.npy +imgHQ12189.npy +imgHQ26626.npy +imgHQ19711.npy +imgHQ02410.npy +imgHQ12775.npy +imgHQ29288.npy +imgHQ00442.npy +imgHQ18848.npy +imgHQ12760.npy +imgHQ22283.npy +imgHQ28028.npy +imgHQ09731.npy +imgHQ22960.npy +imgHQ28276.npy +imgHQ19989.npy +imgHQ02809.npy +imgHQ26122.npy +imgHQ17744.npy +imgHQ03234.npy +imgHQ23486.npy +imgHQ29205.npy +imgHQ24523.npy +imgHQ00717.npy +imgHQ08091.npy +imgHQ01774.npy +imgHQ25743.npy +imgHQ12522.npy +imgHQ03517.npy +imgHQ13398.npy +imgHQ09610.npy +imgHQ17424.npy +imgHQ15666.npy +imgHQ20645.npy +imgHQ15767.npy +imgHQ27304.npy +imgHQ22794.npy +imgHQ27216.npy +imgHQ19981.npy +imgHQ28813.npy +imgHQ07400.npy +imgHQ05706.npy +imgHQ01990.npy +imgHQ14287.npy +imgHQ12540.npy +imgHQ05019.npy +imgHQ12904.npy +imgHQ11524.npy +imgHQ19866.npy +imgHQ28027.npy +imgHQ21063.npy +imgHQ26927.npy +imgHQ22525.npy +imgHQ13433.npy +imgHQ11067.npy +imgHQ05395.npy +imgHQ18627.npy +imgHQ19681.npy +imgHQ18983.npy +imgHQ09025.npy +imgHQ15946.npy +imgHQ21347.npy +imgHQ09478.npy +imgHQ00794.npy +imgHQ10831.npy +imgHQ27362.npy +imgHQ00208.npy +imgHQ27163.npy +imgHQ04273.npy +imgHQ00374.npy +imgHQ23109.npy +imgHQ14406.npy +imgHQ02609.npy +imgHQ19922.npy +imgHQ02570.npy +imgHQ15511.npy +imgHQ28800.npy +imgHQ17495.npy +imgHQ24744.npy +imgHQ03870.npy +imgHQ18036.npy +imgHQ02288.npy +imgHQ10330.npy +imgHQ02867.npy +imgHQ09638.npy +imgHQ02836.npy +imgHQ27670.npy +imgHQ00513.npy +imgHQ24071.npy +imgHQ23927.npy +imgHQ20943.npy +imgHQ28573.npy +imgHQ23357.npy +imgHQ22455.npy +imgHQ11531.npy +imgHQ06943.npy +imgHQ08169.npy +imgHQ18773.npy +imgHQ14836.npy +imgHQ25640.npy +imgHQ10215.npy +imgHQ15190.npy +imgHQ23093.npy +imgHQ28187.npy +imgHQ12688.npy +imgHQ28128.npy +imgHQ22470.npy +imgHQ03531.npy +imgHQ12031.npy +imgHQ11219.npy +imgHQ16305.npy +imgHQ15238.npy +imgHQ29444.npy +imgHQ17394.npy +imgHQ24755.npy +imgHQ16066.npy +imgHQ19739.npy +imgHQ07745.npy +imgHQ06503.npy +imgHQ04665.npy +imgHQ02136.npy +imgHQ29071.npy +imgHQ03325.npy +imgHQ02372.npy +imgHQ01939.npy +imgHQ29242.npy +imgHQ22031.npy +imgHQ04037.npy +imgHQ04821.npy +imgHQ16393.npy +imgHQ27431.npy +imgHQ21639.npy +imgHQ18674.npy +imgHQ26984.npy +imgHQ05899.npy +imgHQ21604.npy +imgHQ05569.npy +imgHQ20230.npy +imgHQ24941.npy +imgHQ15282.npy +imgHQ25175.npy +imgHQ23582.npy +imgHQ06476.npy +imgHQ09106.npy +imgHQ03721.npy +imgHQ28124.npy +imgHQ29971.npy +imgHQ09784.npy +imgHQ07330.npy +imgHQ14215.npy +imgHQ09184.npy +imgHQ24774.npy +imgHQ26707.npy +imgHQ02754.npy +imgHQ06468.npy +imgHQ04084.npy +imgHQ14262.npy +imgHQ25351.npy +imgHQ17690.npy +imgHQ23126.npy +imgHQ02008.npy +imgHQ01718.npy +imgHQ19226.npy +imgHQ24875.npy +imgHQ07393.npy +imgHQ00415.npy +imgHQ10314.npy +imgHQ16666.npy +imgHQ18039.npy +imgHQ18749.npy +imgHQ01640.npy +imgHQ13799.npy +imgHQ14679.npy +imgHQ27588.npy +imgHQ07655.npy +imgHQ28145.npy +imgHQ06488.npy +imgHQ21326.npy +imgHQ20070.npy +imgHQ28444.npy +imgHQ25323.npy +imgHQ23311.npy +imgHQ18388.npy +imgHQ17311.npy +imgHQ19021.npy +imgHQ15090.npy +imgHQ18460.npy +imgHQ29847.npy +imgHQ21125.npy +imgHQ05344.npy +imgHQ02478.npy +imgHQ15557.npy +imgHQ11210.npy +imgHQ01529.npy +imgHQ02169.npy +imgHQ21597.npy +imgHQ00218.npy +imgHQ17801.npy +imgHQ02742.npy +imgHQ24052.npy +imgHQ00039.npy +imgHQ19083.npy +imgHQ07761.npy +imgHQ11567.npy +imgHQ08555.npy +imgHQ02468.npy +imgHQ28513.npy +imgHQ09649.npy +imgHQ05220.npy +imgHQ08357.npy +imgHQ05265.npy +imgHQ17070.npy +imgHQ27272.npy +imgHQ28168.npy +imgHQ10427.npy +imgHQ02689.npy +imgHQ09565.npy +imgHQ04958.npy +imgHQ23394.npy +imgHQ06334.npy +imgHQ00025.npy +imgHQ25692.npy +imgHQ26449.npy +imgHQ16670.npy +imgHQ29897.npy +imgHQ09015.npy +imgHQ21907.npy +imgHQ17820.npy +imgHQ19125.npy +imgHQ14584.npy +imgHQ03647.npy +imgHQ28439.npy +imgHQ18525.npy +imgHQ17224.npy +imgHQ20634.npy +imgHQ01357.npy +imgHQ26149.npy +imgHQ24060.npy +imgHQ12636.npy +imgHQ16817.npy +imgHQ00655.npy +imgHQ03562.npy +imgHQ15274.npy +imgHQ05813.npy +imgHQ29495.npy +imgHQ24457.npy +imgHQ29135.npy +imgHQ14575.npy +imgHQ22702.npy +imgHQ19679.npy +imgHQ14492.npy +imgHQ05874.npy +imgHQ29909.npy +imgHQ01767.npy +imgHQ12533.npy +imgHQ00598.npy +imgHQ08420.npy +imgHQ03827.npy +imgHQ14050.npy +imgHQ15902.npy +imgHQ24981.npy +imgHQ07549.npy +imgHQ04543.npy +imgHQ02787.npy +imgHQ10933.npy +imgHQ24608.npy +imgHQ06897.npy +imgHQ24746.npy +imgHQ12729.npy +imgHQ10603.npy +imgHQ00629.npy +imgHQ17328.npy +imgHQ18257.npy +imgHQ25679.npy +imgHQ12548.npy +imgHQ05677.npy +imgHQ29538.npy +imgHQ14141.npy +imgHQ28111.npy +imgHQ07746.npy +imgHQ14481.npy +imgHQ27762.npy +imgHQ09577.npy +imgHQ29670.npy +imgHQ14911.npy +imgHQ20179.npy +imgHQ25915.npy +imgHQ05997.npy +imgHQ28342.npy +imgHQ19899.npy +imgHQ06972.npy +imgHQ13778.npy +imgHQ09400.npy +imgHQ20016.npy +imgHQ01648.npy +imgHQ17116.npy +imgHQ06283.npy +imgHQ06213.npy +imgHQ15688.npy +imgHQ04044.npy +imgHQ25718.npy +imgHQ24601.npy +imgHQ16463.npy +imgHQ29517.npy +imgHQ15851.npy +imgHQ22712.npy +imgHQ02319.npy +imgHQ25387.npy +imgHQ25406.npy +imgHQ13996.npy +imgHQ21807.npy +imgHQ07579.npy +imgHQ01341.npy +imgHQ05799.npy +imgHQ01846.npy +imgHQ02278.npy +imgHQ20556.npy +imgHQ14462.npy +imgHQ01520.npy +imgHQ09963.npy +imgHQ06193.npy +imgHQ04482.npy +imgHQ13562.npy +imgHQ18771.npy +imgHQ17618.npy +imgHQ22408.npy +imgHQ26687.npy +imgHQ16158.npy +imgHQ03664.npy +imgHQ08052.npy +imgHQ28801.npy +imgHQ03692.npy +imgHQ21285.npy +imgHQ07783.npy +imgHQ15115.npy +imgHQ09389.npy +imgHQ27866.npy +imgHQ17017.npy +imgHQ28601.npy +imgHQ29024.npy +imgHQ24233.npy +imgHQ20361.npy +imgHQ25590.npy +imgHQ05438.npy +imgHQ20768.npy +imgHQ02820.npy +imgHQ16404.npy +imgHQ29580.npy +imgHQ02810.npy +imgHQ09094.npy +imgHQ19267.npy +imgHQ00019.npy +imgHQ12134.npy +imgHQ21368.npy +imgHQ16778.npy +imgHQ10791.npy +imgHQ21330.npy +imgHQ00076.npy +imgHQ07191.npy +imgHQ01363.npy +imgHQ09042.npy +imgHQ06603.npy +imgHQ24291.npy +imgHQ05729.npy +imgHQ28358.npy +imgHQ09319.npy +imgHQ19360.npy +imgHQ13005.npy +imgHQ13883.npy +imgHQ12019.npy +imgHQ18830.npy +imgHQ02932.npy +imgHQ13180.npy +imgHQ00814.npy +imgHQ27879.npy +imgHQ21788.npy +imgHQ01374.npy +imgHQ25728.npy +imgHQ27391.npy +imgHQ09160.npy +imgHQ06453.npy +imgHQ20704.npy +imgHQ29880.npy +imgHQ15030.npy +imgHQ26791.npy +imgHQ03032.npy +imgHQ29542.npy +imgHQ04211.npy +imgHQ28163.npy +imgHQ15398.npy +imgHQ11489.npy +imgHQ00662.npy +imgHQ21783.npy +imgHQ24056.npy +imgHQ00306.npy +imgHQ22341.npy +imgHQ25527.npy +imgHQ25948.npy +imgHQ24857.npy +imgHQ13290.npy +imgHQ06340.npy +imgHQ09081.npy +imgHQ14295.npy +imgHQ00510.npy +imgHQ06154.npy +imgHQ03168.npy +imgHQ06133.npy +imgHQ08840.npy +imgHQ07454.npy +imgHQ17832.npy +imgHQ00558.npy +imgHQ20963.npy +imgHQ00124.npy +imgHQ27318.npy +imgHQ22948.npy +imgHQ25944.npy +imgHQ21284.npy +imgHQ00523.npy +imgHQ05235.npy +imgHQ09715.npy +imgHQ08966.npy +imgHQ25923.npy +imgHQ18977.npy +imgHQ29427.npy +imgHQ06834.npy +imgHQ27886.npy +imgHQ09905.npy +imgHQ01535.npy +imgHQ06802.npy +imgHQ25065.npy +imgHQ16826.npy +imgHQ26213.npy +imgHQ13608.npy +imgHQ07767.npy +imgHQ14762.npy +imgHQ25815.npy +imgHQ16623.npy +imgHQ24436.npy +imgHQ15855.npy +imgHQ18940.npy +imgHQ17852.npy +imgHQ05151.npy +imgHQ22126.npy +imgHQ26944.npy +imgHQ28703.npy +imgHQ14791.npy +imgHQ11095.npy +imgHQ26733.npy +imgHQ05307.npy +imgHQ27677.npy +imgHQ04416.npy +imgHQ01272.npy +imgHQ05760.npy +imgHQ21857.npy +imgHQ14468.npy +imgHQ08725.npy +imgHQ29091.npy +imgHQ08767.npy +imgHQ05645.npy +imgHQ13389.npy +imgHQ18764.npy +imgHQ19457.npy +imgHQ21384.npy +imgHQ24995.npy +imgHQ11544.npy +imgHQ21086.npy +imgHQ06398.npy +imgHQ14095.npy +imgHQ05717.npy +imgHQ04485.npy +imgHQ15659.npy +imgHQ26681.npy +imgHQ11123.npy +imgHQ27487.npy +imgHQ12102.npy +imgHQ07729.npy +imgHQ26874.npy +imgHQ03543.npy +imgHQ10660.npy +imgHQ10964.npy +imgHQ03199.npy +imgHQ21978.npy +imgHQ25307.npy +imgHQ00161.npy +imgHQ20127.npy +imgHQ11656.npy +imgHQ12277.npy +imgHQ01634.npy +imgHQ16218.npy +imgHQ19276.npy +imgHQ26921.npy +imgHQ12046.npy +imgHQ03121.npy +imgHQ16818.npy +imgHQ25396.npy +imgHQ29240.npy +imgHQ29972.npy +imgHQ25722.npy +imgHQ13807.npy +imgHQ29063.npy +imgHQ26577.npy +imgHQ28664.npy +imgHQ25031.npy +imgHQ13172.npy +imgHQ18025.npy +imgHQ00424.npy +imgHQ14564.npy +imgHQ12161.npy +imgHQ29271.npy +imgHQ01051.npy +imgHQ05687.npy +imgHQ29300.npy +imgHQ25241.npy +imgHQ12810.npy +imgHQ02845.npy +imgHQ21345.npy +imgHQ10795.npy +imgHQ28902.npy +imgHQ13355.npy +imgHQ13563.npy +imgHQ06839.npy +imgHQ20984.npy +imgHQ12233.npy +imgHQ11048.npy +imgHQ14768.npy +imgHQ24496.npy +imgHQ09207.npy +imgHQ12566.npy +imgHQ01259.npy +imgHQ06676.npy +imgHQ06715.npy +imgHQ05061.npy +imgHQ13877.npy +imgHQ24646.npy +imgHQ11273.npy +imgHQ05703.npy +imgHQ04701.npy +imgHQ06150.npy +imgHQ27823.npy +imgHQ09263.npy +imgHQ05254.npy +imgHQ25164.npy +imgHQ03219.npy +imgHQ19022.npy +imgHQ27961.npy +imgHQ05916.npy +imgHQ14458.npy +imgHQ13696.npy +imgHQ21717.npy +imgHQ27008.npy +imgHQ14717.npy +imgHQ02433.npy +imgHQ16068.npy +imgHQ06388.npy +imgHQ06527.npy +imgHQ09705.npy +imgHQ00714.npy +imgHQ04359.npy +imgHQ18294.npy +imgHQ01715.npy +imgHQ18641.npy +imgHQ16567.npy +imgHQ16182.npy +imgHQ17011.npy +imgHQ07948.npy +imgHQ10030.npy +imgHQ05825.npy +imgHQ10718.npy +imgHQ06000.npy +imgHQ29857.npy +imgHQ19919.npy +imgHQ29034.npy +imgHQ26841.npy +imgHQ15940.npy +imgHQ27986.npy +imgHQ07140.npy +imgHQ24458.npy +imgHQ20816.npy +imgHQ01597.npy +imgHQ01720.npy +imgHQ06680.npy +imgHQ11791.npy +imgHQ27808.npy +imgHQ16941.npy +imgHQ07363.npy +imgHQ15757.npy +imgHQ16154.npy +imgHQ28417.npy +imgHQ12528.npy +imgHQ20004.npy +imgHQ11682.npy +imgHQ15311.npy +imgHQ29211.npy +imgHQ10653.npy +imgHQ25980.npy +imgHQ24910.npy +imgHQ11856.npy +imgHQ07774.npy +imgHQ00259.npy +imgHQ23110.npy +imgHQ21217.npy +imgHQ16509.npy +imgHQ08810.npy +imgHQ25748.npy +imgHQ13166.npy +imgHQ23312.npy +imgHQ01073.npy +imgHQ29773.npy +imgHQ10432.npy +imgHQ16383.npy +imgHQ01337.npy +imgHQ18903.npy +imgHQ16294.npy +imgHQ10538.npy +imgHQ29061.npy +imgHQ21030.npy +imgHQ12661.npy +imgHQ27156.npy +imgHQ03445.npy +imgHQ01992.npy +imgHQ12386.npy +imgHQ00627.npy +imgHQ27524.npy +imgHQ20611.npy +imgHQ14278.npy +imgHQ27633.npy +imgHQ25035.npy +imgHQ12492.npy +imgHQ22941.npy +imgHQ25369.npy +imgHQ26642.npy +imgHQ14333.npy +imgHQ17620.npy +imgHQ18512.npy +imgHQ09315.npy +imgHQ20703.npy +imgHQ19338.npy +imgHQ23521.npy +imgHQ20279.npy +imgHQ11814.npy +imgHQ01687.npy +imgHQ22108.npy +imgHQ25478.npy +imgHQ10782.npy +imgHQ13103.npy +imgHQ27675.npy +imgHQ26956.npy +imgHQ07115.npy +imgHQ21538.npy +imgHQ04374.npy +imgHQ22995.npy +imgHQ12004.npy +imgHQ17648.npy +imgHQ12394.npy +imgHQ16044.npy +imgHQ16799.npy +imgHQ13350.npy +imgHQ08318.npy +imgHQ20680.npy +imgHQ01651.npy +imgHQ15159.npy +imgHQ03433.npy +imgHQ04602.npy +imgHQ25047.npy +imgHQ03816.npy +imgHQ06423.npy +imgHQ10731.npy +imgHQ08381.npy +imgHQ21026.npy +imgHQ22250.npy +imgHQ23548.npy +imgHQ04078.npy +imgHQ09079.npy +imgHQ27152.npy +imgHQ21078.npy +imgHQ23939.npy +imgHQ20886.npy +imgHQ26369.npy +imgHQ00381.npy +imgHQ18986.npy +imgHQ09598.npy +imgHQ11778.npy +imgHQ22804.npy +imgHQ09179.npy +imgHQ09208.npy +imgHQ02412.npy +imgHQ19760.npy +imgHQ24125.npy +imgHQ07285.npy +imgHQ25277.npy +imgHQ16466.npy +imgHQ26127.npy +imgHQ03477.npy +imgHQ11813.npy +imgHQ14049.npy +imgHQ17483.npy +imgHQ10631.npy +imgHQ19092.npy +imgHQ17500.npy +imgHQ00502.npy +imgHQ03082.npy +imgHQ21728.npy +imgHQ23391.npy +imgHQ09828.npy +imgHQ16412.npy +imgHQ15080.npy +imgHQ02685.npy +imgHQ12910.npy +imgHQ20249.npy +imgHQ16176.npy +imgHQ17115.npy +imgHQ11028.npy +imgHQ21006.npy +imgHQ04656.npy +imgHQ06093.npy +imgHQ08897.npy +imgHQ29275.npy +imgHQ07542.npy +imgHQ18592.npy +imgHQ21161.npy +imgHQ16962.npy +imgHQ03046.npy +imgHQ03187.npy +imgHQ26877.npy +imgHQ11810.npy +imgHQ00443.npy +imgHQ14193.npy +imgHQ11464.npy +imgHQ00219.npy +imgHQ01123.npy +imgHQ27622.npy +imgHQ06313.npy +imgHQ16888.npy +imgHQ13319.npy +imgHQ03621.npy +imgHQ06866.npy +imgHQ25671.npy +imgHQ04926.npy +imgHQ07955.npy +imgHQ05067.npy +imgHQ12648.npy +imgHQ24443.npy +imgHQ29127.npy +imgHQ13194.npy +imgHQ04577.npy +imgHQ25831.npy +imgHQ00430.npy +imgHQ06579.npy +imgHQ11166.npy +imgHQ20895.npy +imgHQ22162.npy +imgHQ20291.npy +imgHQ06765.npy +imgHQ13195.npy +imgHQ02434.npy +imgHQ05034.npy +imgHQ26569.npy +imgHQ10972.npy +imgHQ14431.npy +imgHQ27224.npy +imgHQ22552.npy +imgHQ09507.npy +imgHQ10283.npy +imgHQ12478.npy +imgHQ25378.npy +imgHQ24621.npy +imgHQ18841.npy +imgHQ24432.npy +imgHQ26713.npy +imgHQ18925.npy +imgHQ20184.npy +imgHQ28980.npy +imgHQ27791.npy +imgHQ25468.npy +imgHQ10076.npy +imgHQ12140.npy +imgHQ23567.npy +imgHQ20480.npy +imgHQ12501.npy +imgHQ21586.npy +imgHQ20907.npy +imgHQ18901.npy +imgHQ19133.npy +imgHQ20272.npy +imgHQ02028.npy +imgHQ02676.npy +imgHQ17606.npy +imgHQ29895.npy +imgHQ12229.npy +imgHQ02846.npy +imgHQ22774.npy +imgHQ15718.npy +imgHQ25172.npy +imgHQ18355.npy +imgHQ02885.npy +imgHQ08983.npy +imgHQ14160.npy +imgHQ08069.npy +imgHQ06058.npy +imgHQ24944.npy +imgHQ00963.npy +imgHQ14332.npy +imgHQ20056.npy +imgHQ10199.npy +imgHQ25191.npy +imgHQ25698.npy +imgHQ17028.npy +imgHQ01038.npy +imgHQ14785.npy +imgHQ04659.npy +imgHQ29851.npy +imgHQ18727.npy +imgHQ06005.npy +imgHQ21913.npy +imgHQ01766.npy +imgHQ21844.npy +imgHQ22891.npy +imgHQ05928.npy +imgHQ07911.npy +imgHQ23766.npy +imgHQ18803.npy +imgHQ17679.npy +imgHQ07669.npy +imgHQ24445.npy +imgHQ27634.npy +imgHQ02519.npy +imgHQ15570.npy +imgHQ25085.npy +imgHQ02004.npy +imgHQ14539.npy +imgHQ13708.npy +imgHQ10219.npy +imgHQ07266.npy +imgHQ03580.npy +imgHQ14677.npy +imgHQ24699.npy +imgHQ11488.npy +imgHQ26550.npy +imgHQ13927.npy +imgHQ29815.npy +imgHQ11728.npy +imgHQ16397.npy +imgHQ10620.npy +imgHQ20247.npy +imgHQ07414.npy +imgHQ17971.npy +imgHQ11441.npy +imgHQ08666.npy +imgHQ26845.npy +imgHQ23977.npy +imgHQ20043.npy +imgHQ06418.npy +imgHQ00885.npy +imgHQ21549.npy +imgHQ29090.npy +imgHQ19667.npy +imgHQ20367.npy +imgHQ21363.npy +imgHQ11807.npy +imgHQ20494.npy +imgHQ17057.npy +imgHQ07546.npy +imgHQ24321.npy +imgHQ02313.npy +imgHQ21860.npy +imgHQ00770.npy +imgHQ27718.npy +imgHQ08714.npy +imgHQ16423.npy +imgHQ07937.npy +imgHQ24461.npy +imgHQ03928.npy +imgHQ03847.npy +imgHQ27676.npy +imgHQ01307.npy +imgHQ11400.npy +imgHQ20292.npy +imgHQ07456.npy +imgHQ24131.npy +imgHQ12027.npy +imgHQ22801.npy +imgHQ12849.npy +imgHQ29310.npy +imgHQ13606.npy +imgHQ29122.npy +imgHQ25308.npy +imgHQ13465.npy +imgHQ15945.npy +imgHQ21526.npy +imgHQ25413.npy +imgHQ08793.npy +imgHQ20411.npy +imgHQ16937.npy +imgHQ01042.npy +imgHQ13058.npy +imgHQ03486.npy +imgHQ02717.npy +imgHQ15405.npy +imgHQ19990.npy +imgHQ28092.npy +imgHQ02631.npy +imgHQ17109.npy +imgHQ03958.npy +imgHQ17613.npy +imgHQ28762.npy +imgHQ15731.npy +imgHQ02905.npy +imgHQ18893.npy +imgHQ11635.npy +imgHQ18266.npy +imgHQ11975.npy +imgHQ16379.npy +imgHQ16953.npy +imgHQ07502.npy +imgHQ12432.npy +imgHQ19068.npy +imgHQ02255.npy +imgHQ17444.npy +imgHQ03713.npy +imgHQ05005.npy +imgHQ23895.npy +imgHQ25981.npy +imgHQ27082.npy +imgHQ22054.npy +imgHQ09818.npy +imgHQ15592.npy +imgHQ05256.npy +imgHQ19325.npy +imgHQ17787.npy +imgHQ20024.npy +imgHQ24139.npy +imgHQ21144.npy +imgHQ06735.npy +imgHQ10481.npy +imgHQ25198.npy +imgHQ02704.npy +imgHQ05113.npy +imgHQ12321.npy +imgHQ01287.npy +imgHQ24635.npy +imgHQ00380.npy +imgHQ09512.npy +imgHQ23747.npy +imgHQ26496.npy +imgHQ28764.npy +imgHQ02486.npy +imgHQ02374.npy +imgHQ24047.npy +imgHQ17231.npy +imgHQ26235.npy +imgHQ19309.npy +imgHQ05140.npy +imgHQ24673.npy +imgHQ24570.npy +imgHQ11508.npy +imgHQ19365.npy +imgHQ03532.npy +imgHQ05827.npy +imgHQ13615.npy +imgHQ02056.npy +imgHQ15459.npy +imgHQ21200.npy +imgHQ23006.npy +imgHQ17966.npy +imgHQ26244.npy +imgHQ25628.npy +imgHQ18431.npy +imgHQ21777.npy +imgHQ13375.npy +imgHQ17903.npy +imgHQ08898.npy +imgHQ24828.npy +imgHQ06684.npy +imgHQ23349.npy +imgHQ18677.npy +imgHQ12650.npy +imgHQ25266.npy +imgHQ03010.npy +imgHQ20842.npy +imgHQ18836.npy +imgHQ23543.npy +imgHQ14146.npy +imgHQ13859.npy +imgHQ04867.npy +imgHQ27941.npy +imgHQ23439.npy +imgHQ17020.npy +imgHQ24817.npy +imgHQ04985.npy +imgHQ13133.npy +imgHQ25256.npy +imgHQ26049.npy +imgHQ07698.npy +imgHQ17004.npy +imgHQ18731.npy +imgHQ17252.npy +imgHQ27148.npy +imgHQ20227.npy +imgHQ25530.npy +imgHQ04998.npy +imgHQ05443.npy +imgHQ25750.npy +imgHQ11199.npy +imgHQ24735.npy +imgHQ07293.npy +imgHQ00752.npy +imgHQ28390.npy +imgHQ21027.npy +imgHQ19777.npy +imgHQ08601.npy +imgHQ10559.npy +imgHQ27120.npy +imgHQ15416.npy +imgHQ15809.npy +imgHQ16200.npy +imgHQ12739.npy +imgHQ02691.npy +imgHQ15768.npy +imgHQ10667.npy +imgHQ21336.npy +imgHQ29395.npy +imgHQ06003.npy +imgHQ27136.npy +imgHQ02564.npy +imgHQ27926.npy +imgHQ22849.npy +imgHQ29309.npy +imgHQ20778.npy +imgHQ18410.npy +imgHQ21559.npy +imgHQ12065.npy +imgHQ26002.npy +imgHQ18363.npy +imgHQ27387.npy +imgHQ28049.npy +imgHQ29922.npy +imgHQ16750.npy +imgHQ22413.npy +imgHQ21061.npy +imgHQ29156.npy +imgHQ13368.npy +imgHQ20998.npy +imgHQ02612.npy +imgHQ27583.npy +imgHQ00809.npy +imgHQ19863.npy +imgHQ25379.npy +imgHQ11895.npy +imgHQ29023.npy +imgHQ08293.npy +imgHQ14275.npy +imgHQ29962.npy +imgHQ09628.npy +imgHQ24477.npy +imgHQ10797.npy +imgHQ07465.npy +imgHQ11377.npy +imgHQ28152.npy +imgHQ16571.npy +imgHQ18453.npy +imgHQ15761.npy +imgHQ19151.npy +imgHQ18877.npy +imgHQ11026.npy +imgHQ19744.npy +imgHQ02759.npy +imgHQ29750.npy +imgHQ16307.npy +imgHQ09162.npy +imgHQ06158.npy +imgHQ25752.npy +imgHQ01161.npy +imgHQ16153.npy +imgHQ09219.npy +imgHQ18572.npy +imgHQ01296.npy +imgHQ27787.npy +imgHQ14167.npy +imgHQ20355.npy +imgHQ15304.npy +imgHQ03599.npy +imgHQ27188.npy +imgHQ03349.npy +imgHQ20073.npy +imgHQ07832.npy +imgHQ09425.npy +imgHQ21786.npy +imgHQ04448.npy +imgHQ04638.npy +imgHQ11641.npy +imgHQ11774.npy +imgHQ00667.npy +imgHQ01024.npy +imgHQ24903.npy +imgHQ07982.npy +imgHQ25829.npy +imgHQ20454.npy +imgHQ17609.npy +imgHQ04745.npy +imgHQ24564.npy +imgHQ19979.npy +imgHQ19279.npy +imgHQ10396.npy +imgHQ01747.npy +imgHQ21795.npy +imgHQ21432.npy +imgHQ09538.npy +imgHQ23684.npy +imgHQ27584.npy +imgHQ29070.npy +imgHQ21675.npy +imgHQ26367.npy +imgHQ12412.npy +imgHQ02359.npy +imgHQ08475.npy +imgHQ16248.npy +imgHQ02745.npy +imgHQ06239.npy +imgHQ22510.npy +imgHQ20697.npy +imgHQ11880.npy +imgHQ04541.npy +imgHQ20145.npy +imgHQ21272.npy +imgHQ00520.npy +imgHQ25985.npy +imgHQ25258.npy +imgHQ14293.npy +imgHQ01327.npy +imgHQ05850.npy +imgHQ13289.npy +imgHQ17913.npy +imgHQ09840.npy +imgHQ02837.npy +imgHQ17928.npy +imgHQ13709.npy +imgHQ10517.npy +imgHQ06940.npy +imgHQ21167.npy +imgHQ16395.npy +imgHQ11977.npy +imgHQ10574.npy +imgHQ19869.npy +imgHQ01695.npy +imgHQ00942.npy +imgHQ23573.npy +imgHQ09772.npy +imgHQ15124.npy +imgHQ00193.npy +imgHQ22426.npy +imgHQ03636.npy +imgHQ25036.npy +imgHQ15458.npy +imgHQ10656.npy +imgHQ11054.npy +imgHQ10766.npy +imgHQ14673.npy +imgHQ27193.npy +imgHQ17229.npy +imgHQ10671.npy +imgHQ02899.npy +imgHQ24065.npy +imgHQ07007.npy +imgHQ00595.npy +imgHQ05171.npy +imgHQ26216.npy +imgHQ23388.npy +imgHQ23433.npy +imgHQ06254.npy +imgHQ12778.npy +imgHQ16714.npy +imgHQ16344.npy +imgHQ18352.npy +imgHQ05376.npy +imgHQ16602.npy +imgHQ03439.npy +imgHQ07558.npy +imgHQ18185.npy +imgHQ03582.npy +imgHQ26929.npy +imgHQ25021.npy +imgHQ20616.npy +imgHQ07834.npy +imgHQ18923.npy +imgHQ09166.npy +imgHQ03762.npy +imgHQ22866.npy +imgHQ03818.npy +imgHQ09178.npy +imgHQ19329.npy +imgHQ26382.npy +imgHQ11772.npy +imgHQ21966.npy +imgHQ17478.npy +imgHQ25852.npy +imgHQ26205.npy +imgHQ17887.npy +imgHQ23405.npy +imgHQ01679.npy +imgHQ18516.npy +imgHQ14243.npy +imgHQ25399.npy +imgHQ01446.npy +imgHQ25803.npy +imgHQ04029.npy +imgHQ20748.npy +imgHQ12743.npy +imgHQ03293.npy +imgHQ26665.npy +imgHQ23653.npy +imgHQ17025.npy +imgHQ04106.npy +imgHQ15993.npy +imgHQ27757.npy +imgHQ05444.npy +imgHQ11577.npy +imgHQ00197.npy +imgHQ26062.npy +imgHQ16923.npy +imgHQ20413.npy +imgHQ08253.npy +imgHQ18810.npy +imgHQ15389.npy +imgHQ26574.npy +imgHQ26834.npy +imgHQ16251.npy +imgHQ26387.npy +imgHQ06120.npy +imgHQ27994.npy +imgHQ28665.npy +imgHQ04068.npy +imgHQ12963.npy +imgHQ22304.npy +imgHQ28167.npy +imgHQ21091.npy +imgHQ08946.npy +imgHQ13440.npy +imgHQ15146.npy +imgHQ15789.npy +imgHQ16934.npy +imgHQ07168.npy +imgHQ09575.npy +imgHQ05731.npy +imgHQ14734.npy +imgHQ28713.npy +imgHQ16179.npy +imgHQ05237.npy +imgHQ16939.npy +imgHQ04086.npy +imgHQ11388.npy +imgHQ19943.npy +imgHQ21667.npy +imgHQ22691.npy +imgHQ03224.npy +imgHQ26847.npy +imgHQ02684.npy +imgHQ16759.npy +imgHQ20306.npy +imgHQ24162.npy +imgHQ24948.npy +imgHQ21237.npy +imgHQ10789.npy +imgHQ08622.npy +imgHQ22723.npy +imgHQ17463.npy +imgHQ18930.npy +imgHQ15617.npy +imgHQ08667.npy +imgHQ10172.npy +imgHQ24282.npy +imgHQ28492.npy +imgHQ23633.npy +imgHQ05934.npy +imgHQ11035.npy +imgHQ17582.npy +imgHQ03660.npy +imgHQ25674.npy +imgHQ18855.npy +imgHQ00964.npy +imgHQ11860.npy +imgHQ27131.npy +imgHQ26233.npy +imgHQ06032.npy +imgHQ24062.npy +imgHQ22820.npy +imgHQ28405.npy +imgHQ07438.npy +imgHQ02504.npy +imgHQ01898.npy +imgHQ23210.npy +imgHQ01139.npy +imgHQ07956.npy +imgHQ28521.npy +imgHQ17654.npy +imgHQ14577.npy +imgHQ16946.npy +imgHQ22485.npy +imgHQ02682.npy +imgHQ10257.npy +imgHQ11361.npy +imgHQ21405.npy +imgHQ07161.npy +imgHQ29786.npy +imgHQ29110.npy +imgHQ13038.npy +imgHQ18240.npy +imgHQ09021.npy +imgHQ15687.npy +imgHQ16490.npy +imgHQ10994.npy +imgHQ13462.npy +imgHQ02315.npy +imgHQ02777.npy +imgHQ02488.npy +imgHQ18678.npy +imgHQ25579.npy +imgHQ17898.npy +imgHQ25901.npy +imgHQ00712.npy +imgHQ05047.npy +imgHQ01233.npy +imgHQ17429.npy +imgHQ11462.npy +imgHQ08014.npy +imgHQ03894.npy +imgHQ05335.npy +imgHQ07012.npy +imgHQ06848.npy +imgHQ00524.npy +imgHQ03754.npy +imgHQ17697.npy +imgHQ00868.npy +imgHQ01497.npy +imgHQ00224.npy +imgHQ29762.npy +imgHQ00828.npy +imgHQ08932.npy +imgHQ04567.npy +imgHQ19424.npy +imgHQ19850.npy +imgHQ19724.npy +imgHQ27264.npy +imgHQ06906.npy +imgHQ03328.npy +imgHQ16161.npy +imgHQ27393.npy +imgHQ01793.npy +imgHQ02996.npy +imgHQ06033.npy +imgHQ04931.npy +imgHQ12467.npy +imgHQ01547.npy +imgHQ10996.npy +imgHQ24701.npy +imgHQ22469.npy +imgHQ18799.npy +imgHQ25900.npy +imgHQ14003.npy +imgHQ20980.npy +imgHQ07390.npy +imgHQ10384.npy +imgHQ09586.npy +imgHQ12734.npy +imgHQ26738.npy +imgHQ08861.npy +imgHQ29508.npy +imgHQ20573.npy +imgHQ29356.npy +imgHQ16250.npy +imgHQ17412.npy +imgHQ17611.npy +imgHQ27662.npy +imgHQ10952.npy +imgHQ28398.npy +imgHQ09716.npy +imgHQ12808.npy +imgHQ20259.npy +imgHQ06790.npy +imgHQ16259.npy +imgHQ13205.npy +imgHQ12921.npy +imgHQ27950.npy +imgHQ22042.npy +imgHQ07657.npy +imgHQ19028.npy +imgHQ00026.npy +imgHQ18371.npy +imgHQ26383.npy +imgHQ00576.npy +imgHQ22787.npy +imgHQ10263.npy +imgHQ29476.npy +imgHQ10394.npy +imgHQ12887.npy +imgHQ25525.npy +imgHQ14972.npy +imgHQ28368.npy +imgHQ01417.npy +imgHQ24657.npy +imgHQ07590.npy +imgHQ00325.npy +imgHQ21151.npy +imgHQ16638.npy +imgHQ11554.npy +imgHQ14493.npy +imgHQ04955.npy +imgHQ26370.npy +imgHQ27058.npy +imgHQ11449.npy +imgHQ03863.npy +imgHQ04709.npy +imgHQ28606.npy +imgHQ21162.npy +imgHQ29775.npy +imgHQ28373.npy +imgHQ23581.npy +imgHQ18196.npy +imgHQ09479.npy +imgHQ10435.npy +imgHQ17661.npy +imgHQ10758.npy +imgHQ28399.npy +imgHQ22221.npy +imgHQ22153.npy +imgHQ07851.npy +imgHQ15429.npy +imgHQ25762.npy +imgHQ09093.npy +imgHQ04282.npy +imgHQ26475.npy +imgHQ02911.npy +imgHQ26859.npy +imgHQ06303.npy +imgHQ21245.npy +imgHQ02758.npy +imgHQ01630.npy +imgHQ22303.npy +imgHQ19806.npy +imgHQ28025.npy +imgHQ01245.npy +imgHQ03406.npy +imgHQ17383.npy +imgHQ09922.npy +imgHQ07265.npy +imgHQ21565.npy +imgHQ12452.npy +imgHQ05944.npy +imgHQ16881.npy +imgHQ05742.npy +imgHQ06206.npy +imgHQ22656.npy +imgHQ25114.npy +imgHQ11588.npy +imgHQ09620.npy +imgHQ23708.npy +imgHQ29828.npy +imgHQ10478.npy +imgHQ05177.npy +imgHQ06353.npy +imgHQ18817.npy +imgHQ29917.npy +imgHQ15150.npy +imgHQ23868.npy +imgHQ23879.npy +imgHQ19996.npy +imgHQ05809.npy +imgHQ22516.npy +imgHQ09763.npy +imgHQ19335.npy +imgHQ00805.npy +imgHQ26612.npy +imgHQ14941.npy +imgHQ00873.npy +imgHQ24199.npy +imgHQ11743.npy +imgHQ24711.npy +imgHQ12944.npy +imgHQ15374.npy +imgHQ15723.npy +imgHQ25599.npy +imgHQ22678.npy +imgHQ27895.npy +imgHQ18038.npy +imgHQ12455.npy +imgHQ17867.npy +imgHQ10057.npy +imgHQ00720.npy +imgHQ12736.npy +imgHQ08890.npy +imgHQ03670.npy +imgHQ10414.npy +imgHQ13726.npy +imgHQ08474.npy +imgHQ12025.npy +imgHQ27743.npy +imgHQ11206.npy +imgHQ11839.npy +imgHQ20941.npy +imgHQ08614.npy +imgHQ09633.npy +imgHQ07989.npy +imgHQ02561.npy +imgHQ02539.npy +imgHQ28408.npy +imgHQ14136.npy +imgHQ29741.npy +imgHQ15421.npy +imgHQ09361.npy +imgHQ12514.npy +imgHQ09434.npy +imgHQ22523.npy +imgHQ08813.npy +imgHQ20759.npy +imgHQ18081.npy +imgHQ09347.npy +imgHQ04551.npy +imgHQ20532.npy +imgHQ03822.npy +imgHQ13809.npy +imgHQ15056.npy +imgHQ13740.npy +imgHQ00182.npy +imgHQ26570.npy +imgHQ08053.npy +imgHQ09046.npy +imgHQ17054.npy +imgHQ29940.npy +imgHQ02079.npy +imgHQ17333.npy +imgHQ11420.npy +imgHQ17871.npy +imgHQ27086.npy +imgHQ12857.npy +imgHQ14727.npy +imgHQ21606.npy +imgHQ24180.npy +imgHQ07461.npy +imgHQ23265.npy +imgHQ22148.npy +imgHQ05801.npy +imgHQ17732.npy +imgHQ29910.npy +imgHQ05713.npy +imgHQ15660.npy +imgHQ22730.npy +imgHQ21315.npy +imgHQ17132.npy +imgHQ18122.npy +imgHQ22474.npy +imgHQ16376.npy +imgHQ24177.npy +imgHQ03780.npy +imgHQ12077.npy +imgHQ17663.npy +imgHQ04109.npy +imgHQ03117.npy +imgHQ01083.npy +imgHQ07707.npy +imgHQ21255.npy +imgHQ02887.npy +imgHQ24892.npy +imgHQ13999.npy +imgHQ24323.npy +imgHQ10949.npy +imgHQ16151.npy +imgHQ23752.npy +imgHQ03556.npy +imgHQ23642.npy +imgHQ29386.npy +imgHQ21681.npy +imgHQ12490.npy +imgHQ13196.npy +imgHQ26436.npy +imgHQ09524.npy +imgHQ05111.npy +imgHQ02061.npy +imgHQ06776.npy +imgHQ14647.npy +imgHQ07068.npy +imgHQ03090.npy +imgHQ27236.npy +imgHQ26114.npy +imgHQ04264.npy +imgHQ01741.npy +imgHQ24148.npy +imgHQ15829.npy +imgHQ26314.npy +imgHQ09642.npy +imgHQ29119.npy +imgHQ23553.npy +imgHQ21718.npy +imgHQ22961.npy +imgHQ22417.npy +imgHQ22441.npy +imgHQ19482.npy +imgHQ04708.npy +imgHQ06746.npy +imgHQ08348.npy +imgHQ01421.npy +imgHQ29912.npy +imgHQ06937.npy +imgHQ27665.npy +imgHQ19031.npy +imgHQ26253.npy +imgHQ00052.npy +imgHQ17850.npy +imgHQ02763.npy +imgHQ04340.npy +imgHQ05109.npy +imgHQ16590.npy +imgHQ15343.npy +imgHQ27138.npy +imgHQ11978.npy +imgHQ18203.npy +imgHQ16525.npy +imgHQ20918.npy +imgHQ02245.npy +imgHQ25097.npy +imgHQ25558.npy +imgHQ23594.npy +imgHQ25512.npy +imgHQ14910.npy +imgHQ21229.npy +imgHQ06638.npy +imgHQ02607.npy +imgHQ13791.npy +imgHQ06562.npy +imgHQ14639.npy +imgHQ12287.npy +imgHQ06543.npy +imgHQ09441.npy +imgHQ03338.npy +imgHQ05386.npy +imgHQ19543.npy +imgHQ26926.npy +imgHQ04556.npy +imgHQ01658.npy +imgHQ00402.npy +imgHQ19399.npy +imgHQ09436.npy +imgHQ07110.npy +imgHQ14965.npy +imgHQ29528.npy +imgHQ29567.npy +imgHQ04512.npy +imgHQ27595.npy +imgHQ13097.npy +imgHQ00638.npy +imgHQ14073.npy +imgHQ23502.npy +imgHQ00620.npy +imgHQ16268.npy +imgHQ11480.npy +imgHQ16093.npy +imgHQ28516.npy +imgHQ25772.npy +imgHQ05849.npy +imgHQ16217.npy +imgHQ02424.npy +imgHQ20297.npy +imgHQ28284.npy +imgHQ23231.npy +imgHQ20163.npy +imgHQ02258.npy +imgHQ25103.npy +imgHQ15221.npy +imgHQ16927.npy +imgHQ10178.npy +imgHQ25284.npy +imgHQ20881.npy +imgHQ04159.npy +imgHQ12952.npy +imgHQ18772.npy +imgHQ22972.npy +imgHQ12744.npy +imgHQ04183.npy +imgHQ28848.npy +imgHQ19848.npy +imgHQ24013.npy +imgHQ23003.npy +imgHQ13975.npy +imgHQ27773.npy +imgHQ00707.npy +imgHQ13219.npy +imgHQ00399.npy +imgHQ01254.npy +imgHQ13534.npy +imgHQ12239.npy +imgHQ25551.npy +imgHQ03359.npy +imgHQ13754.npy +imgHQ22881.npy +imgHQ19255.npy +imgHQ04856.npy +imgHQ21019.npy +imgHQ01433.npy +imgHQ19690.npy +imgHQ02739.npy +imgHQ19158.npy +imgHQ22534.npy +imgHQ01874.npy +imgHQ19486.npy +imgHQ08686.npy +imgHQ15052.npy +imgHQ22795.npy +imgHQ17766.npy +imgHQ27384.npy +imgHQ29239.npy +imgHQ25516.npy +imgHQ13377.npy +imgHQ25486.npy +imgHQ03085.npy +imgHQ15582.npy +imgHQ16842.npy +imgHQ15755.npy +imgHQ11709.npy +imgHQ06384.npy +imgHQ03227.npy +imgHQ07968.npy +imgHQ25502.npy +imgHQ00104.npy +imgHQ23911.npy +imgHQ29673.npy +imgHQ14729.npy +imgHQ07081.npy +imgHQ02347.npy +imgHQ21817.npy +imgHQ10303.npy +imgHQ08668.npy +imgHQ08414.npy +imgHQ27332.npy +imgHQ28680.npy +imgHQ28668.npy +imgHQ04013.npy +imgHQ02620.npy +imgHQ12413.npy +imgHQ04647.npy +imgHQ27842.npy +imgHQ27171.npy +imgHQ20767.npy +imgHQ21391.npy +imgHQ20952.npy +imgHQ24039.npy +imgHQ19925.npy +imgHQ03377.npy +imgHQ25155.npy +imgHQ27299.npy +imgHQ18551.npy +imgHQ29296.npy +imgHQ03509.npy +imgHQ22869.npy +imgHQ15471.npy +imgHQ05862.npy +imgHQ15451.npy +imgHQ03018.npy +imgHQ18195.npy +imgHQ02418.npy +imgHQ00913.npy +imgHQ22767.npy +imgHQ24048.npy +imgHQ06979.npy +imgHQ29216.npy +imgHQ22648.npy +imgHQ24003.npy +imgHQ04734.npy +imgHQ26393.npy +imgHQ15794.npy +imgHQ25545.npy +imgHQ23598.npy +imgHQ07241.npy +imgHQ24226.npy +imgHQ06344.npy +imgHQ01636.npy +imgHQ03027.npy +imgHQ02382.npy +imgHQ07061.npy +imgHQ18847.npy +imgHQ09617.npy +imgHQ00028.npy +imgHQ25268.npy +imgHQ11610.npy +imgHQ22598.npy +imgHQ27911.npy +imgHQ25044.npy +imgHQ24882.npy +imgHQ03337.npy +imgHQ17825.npy +imgHQ00536.npy +imgHQ05581.npy +imgHQ23404.npy +imgHQ26206.npy +imgHQ08740.npy +imgHQ02716.npy +imgHQ03652.npy +imgHQ22680.npy +imgHQ25011.npy +imgHQ17504.npy +imgHQ04389.npy +imgHQ09036.npy +imgHQ22406.npy +imgHQ13358.npy +imgHQ24827.npy +imgHQ21708.npy +imgHQ23863.npy +imgHQ02918.npy +imgHQ24824.npy +imgHQ06674.npy +imgHQ05608.npy +imgHQ02033.npy +imgHQ04492.npy +imgHQ19301.npy +imgHQ21843.npy +imgHQ05224.npy +imgHQ28325.npy +imgHQ06509.npy +imgHQ10572.npy +imgHQ15543.npy +imgHQ11214.npy +imgHQ28756.npy +imgHQ03498.npy +imgHQ07019.npy +imgHQ09999.npy +imgHQ11437.npy +imgHQ08634.npy +imgHQ09831.npy +imgHQ03133.npy +imgHQ18321.npy +imgHQ19463.npy +imgHQ04019.npy +imgHQ04413.npy +imgHQ09282.npy +imgHQ09853.npy +imgHQ00926.npy +imgHQ27597.npy +imgHQ01613.npy +imgHQ09954.npy +imgHQ08155.npy +imgHQ08997.npy +imgHQ20470.npy +imgHQ08659.npy +imgHQ00043.npy +imgHQ26684.npy +imgHQ09170.npy +imgHQ18861.npy +imgHQ19713.npy +imgHQ09609.npy +imgHQ23693.npy +imgHQ07468.npy +imgHQ15011.npy +imgHQ21947.npy +imgHQ21558.npy +imgHQ10506.npy +imgHQ12352.npy +imgHQ02303.npy +imgHQ07560.npy +imgHQ10424.npy +imgHQ03809.npy +imgHQ00631.npy +imgHQ11793.npy +imgHQ10593.npy +imgHQ23704.npy +imgHQ27851.npy +imgHQ08658.npy +imgHQ28869.npy +imgHQ22043.npy +imgHQ12448.npy +imgHQ04910.npy +imgHQ19791.npy +imgHQ05783.npy +imgHQ26439.npy +imgHQ01877.npy +imgHQ29667.npy +imgHQ22450.npy +imgHQ15092.npy +imgHQ12644.npy +imgHQ10860.npy +imgHQ21961.npy +imgHQ05984.npy +imgHQ18811.npy +imgHQ05173.npy +imgHQ05551.npy +imgHQ12833.npy +imgHQ23898.npy +imgHQ01392.npy +imgHQ20031.npy +imgHQ26806.npy +imgHQ13597.npy +imgHQ13313.npy +imgHQ14531.npy +imgHQ09595.npy +imgHQ28270.npy +imgHQ04100.npy +imgHQ06293.npy +imgHQ01244.npy +imgHQ07304.npy +imgHQ07684.npy +imgHQ25941.npy +imgHQ11773.npy +imgHQ24054.npy +imgHQ16284.npy +imgHQ11799.npy +imgHQ21311.npy +imgHQ24315.npy +imgHQ23416.npy +imgHQ09666.npy +imgHQ02811.npy +imgHQ29351.npy +imgHQ11840.npy +imgHQ26920.npy +imgHQ06655.npy +imgHQ13198.npy +imgHQ08047.npy +imgHQ05540.npy +imgHQ25315.npy +imgHQ06663.npy +imgHQ28594.npy +imgHQ15868.npy +imgHQ03429.npy +imgHQ25826.npy +imgHQ02316.npy +imgHQ05773.npy +imgHQ08569.npy +imgHQ17512.npy +imgHQ11984.npy +imgHQ29387.npy +imgHQ07943.npy +imgHQ07902.npy +imgHQ27217.npy +imgHQ03745.npy +imgHQ07771.npy +imgHQ26815.npy +imgHQ11032.npy +imgHQ01853.npy +imgHQ10639.npy +imgHQ16600.npy +imgHQ09925.npy +imgHQ21876.npy +imgHQ27593.npy +imgHQ09477.npy +imgHQ00301.npy +imgHQ19558.npy +imgHQ28781.npy +imgHQ18868.npy +imgHQ25650.npy +imgHQ17571.npy +imgHQ20547.npy +imgHQ12645.npy +imgHQ15825.npy +imgHQ18866.npy +imgHQ08915.npy +imgHQ01243.npy +imgHQ12043.npy +imgHQ28545.npy +imgHQ01398.npy +imgHQ23461.npy +imgHQ25615.npy +imgHQ26715.npy +imgHQ21487.npy +imgHQ24374.npy +imgHQ20055.npy +imgHQ01678.npy +imgHQ18711.npy +imgHQ06461.npy +imgHQ27759.npy +imgHQ07781.npy +imgHQ13419.npy +imgHQ09767.npy +imgHQ15885.npy +imgHQ14412.npy +imgHQ12693.npy +imgHQ28779.npy +imgHQ17973.npy +imgHQ21823.npy +imgHQ19999.npy +imgHQ12342.npy +imgHQ13621.npy +imgHQ11135.npy +imgHQ03581.npy +imgHQ22386.npy +imgHQ05268.npy +imgHQ28894.npy +imgHQ25118.npy +imgHQ05334.npy +imgHQ03502.npy +imgHQ25207.npy +imgHQ21488.npy +imgHQ27128.npy +imgHQ18026.npy +imgHQ04077.npy +imgHQ28155.npy +imgHQ24212.npy +imgHQ24544.npy +imgHQ18402.npy +imgHQ10056.npy +imgHQ16105.npy +imgHQ17861.npy +imgHQ15605.npy +imgHQ27358.npy +imgHQ03347.npy +imgHQ01140.npy +imgHQ08909.npy +imgHQ07601.npy +imgHQ19401.npy +imgHQ27789.npy +imgHQ19759.npy +imgHQ17468.npy +imgHQ19135.npy +imgHQ21924.npy +imgHQ23230.npy +imgHQ03478.npy +imgHQ24789.npy +imgHQ17175.npy +imgHQ27821.npy +imgHQ08551.npy +imgHQ06752.npy +imgHQ28946.npy +imgHQ07671.npy +imgHQ08823.npy +imgHQ17553.npy +imgHQ10224.npy +imgHQ12169.npy +imgHQ11429.npy +imgHQ20670.npy +imgHQ24512.npy +imgHQ11041.npy +imgHQ02669.npy +imgHQ07326.npy +imgHQ15148.npy +imgHQ22145.npy +imgHQ27336.npy +imgHQ23943.npy +imgHQ04545.npy +imgHQ12200.npy +imgHQ03576.npy +imgHQ14329.npy +imgHQ06614.npy +imgHQ29551.npy +imgHQ15378.npy +imgHQ27937.npy +imgHQ29737.npy +imgHQ20837.npy +imgHQ00386.npy +imgHQ03526.npy +imgHQ29865.npy +imgHQ02348.npy +imgHQ29132.npy +imgHQ27122.npy +imgHQ00376.npy +imgHQ15509.npy +imgHQ10356.npy +imgHQ22337.npy +imgHQ01697.npy +imgHQ01300.npy +imgHQ22517.npy +imgHQ02594.npy +imgHQ19552.npy +imgHQ15262.npy +imgHQ28462.npy +imgHQ00602.npy +imgHQ06089.npy +imgHQ01758.npy +imgHQ20258.npy +imgHQ04919.npy +imgHQ05781.npy +imgHQ28035.npy +imgHQ02190.npy +imgHQ04978.npy +imgHQ17568.npy +imgHQ12211.npy +imgHQ09738.npy +imgHQ08566.npy +imgHQ18790.npy +imgHQ11558.npy +imgHQ17372.npy +imgHQ11787.npy +imgHQ27609.npy +imgHQ25324.npy +imgHQ06738.npy +imgHQ07309.npy +imgHQ12118.npy +imgHQ10405.npy +imgHQ12678.npy +imgHQ27491.npy +imgHQ18916.npy +imgHQ06803.npy +imgHQ11766.npy +imgHQ10370.npy +imgHQ27295.npy +imgHQ23524.npy +imgHQ29181.npy +imgHQ02110.npy +imgHQ03423.npy +imgHQ19167.npy +imgHQ11905.npy +imgHQ20824.npy +imgHQ24029.npy +imgHQ00719.npy +imgHQ21505.npy +imgHQ26451.npy +imgHQ11677.npy +imgHQ24989.npy +imgHQ08412.npy +imgHQ27774.npy +imgHQ00419.npy +imgHQ15953.npy +imgHQ20017.npy +imgHQ20596.npy +imgHQ26006.npy +imgHQ07259.npy +imgHQ17918.npy +imgHQ05172.npy +imgHQ10859.npy +imgHQ12278.npy +imgHQ16746.npy +imgHQ19029.npy +imgHQ28679.npy +imgHQ17810.npy +imgHQ05296.npy +imgHQ29096.npy +imgHQ29360.npy +imgHQ05258.npy +imgHQ04390.npy +imgHQ04983.npy +imgHQ27824.npy +imgHQ07877.npy +imgHQ28176.npy +imgHQ16424.npy +imgHQ15404.npy +imgHQ22435.npy +imgHQ09342.npy +imgHQ00713.npy +imgHQ09402.npy +imgHQ22875.npy +imgHQ11795.npy +imgHQ23044.npy +imgHQ21306.npy +imgHQ03314.npy +imgHQ24360.npy +imgHQ11455.npy +imgHQ13065.npy +imgHQ06720.npy +imgHQ25382.npy +imgHQ11963.npy +imgHQ08465.npy +imgHQ22150.npy +imgHQ04325.npy +imgHQ21155.npy +imgHQ15921.npy +imgHQ08078.npy +imgHQ09362.npy +imgHQ20503.npy +imgHQ20675.npy +imgHQ04793.npy +imgHQ03023.npy +imgHQ18074.npy +imgHQ10919.npy +imgHQ00758.npy +imgHQ01599.npy +imgHQ27014.npy +imgHQ15880.npy +imgHQ27206.npy +imgHQ10734.npy +imgHQ23276.npy +imgHQ18212.npy +imgHQ10576.npy +imgHQ29609.npy +imgHQ21115.npy +imgHQ25632.npy +imgHQ20063.npy +imgHQ19734.npy +imgHQ04574.npy +imgHQ15652.npy +imgHQ09132.npy +imgHQ08449.npy +imgHQ19443.npy +imgHQ15033.npy +imgHQ15174.npy +imgHQ23078.npy +imgHQ00291.npy +imgHQ04244.npy +imgHQ17189.npy +imgHQ09742.npy +imgHQ09468.npy +imgHQ16632.npy +imgHQ10801.npy +imgHQ17555.npy +imgHQ28928.npy +imgHQ21882.npy +imgHQ08100.npy +imgHQ11906.npy +imgHQ23637.npy +imgHQ09531.npy +imgHQ00506.npy +imgHQ11445.npy +imgHQ20975.npy +imgHQ28172.npy +imgHQ18200.npy +imgHQ05846.npy +imgHQ04604.npy +imgHQ13648.npy +imgHQ28747.npy +imgHQ28931.npy +imgHQ22938.npy +imgHQ19876.npy +imgHQ21021.npy +imgHQ14877.npy +imgHQ04201.npy +imgHQ21522.npy +imgHQ17343.npy +imgHQ03779.npy +imgHQ00204.npy +imgHQ15873.npy +imgHQ15599.npy +imgHQ21071.npy +imgHQ18638.npy +imgHQ16387.npy +imgHQ21503.npy +imgHQ18322.npy +imgHQ09060.npy +imgHQ04812.npy +imgHQ11506.npy +imgHQ11877.npy +imgHQ18491.npy +imgHQ13993.npy +imgHQ28864.npy +imgHQ01328.npy +imgHQ00401.npy +imgHQ23365.npy +imgHQ02886.npy +imgHQ19128.npy +imgHQ01228.npy +imgHQ24926.npy +imgHQ22110.npy +imgHQ10779.npy +imgHQ24620.npy +imgHQ17970.npy +imgHQ25897.npy +imgHQ05487.npy +imgHQ23450.npy +imgHQ21830.npy +imgHQ03501.npy +imgHQ13473.npy +imgHQ05541.npy +imgHQ09082.npy +imgHQ13804.npy +imgHQ06879.npy +imgHQ20296.npy +imgHQ11399.npy +imgHQ10242.npy +imgHQ09979.npy +imgHQ17837.npy +imgHQ18328.npy +imgHQ02993.npy +imgHQ12045.npy +imgHQ02509.npy +imgHQ14619.npy +imgHQ10610.npy +imgHQ15846.npy +imgHQ10908.npy +imgHQ25253.npy +imgHQ21617.npy +imgHQ04594.npy +imgHQ12609.npy +imgHQ26022.npy +imgHQ20569.npy +imgHQ10421.npy +imgHQ08803.npy +imgHQ08596.npy +imgHQ06023.npy +imgHQ11640.npy +imgHQ15104.npy +imgHQ21296.npy +imgHQ05126.npy +imgHQ19808.npy +imgHQ04883.npy +imgHQ29258.npy +imgHQ24269.npy +imgHQ25741.npy +imgHQ22203.npy +imgHQ16637.npy +imgHQ01788.npy +imgHQ17608.npy +imgHQ19025.npy +imgHQ07556.npy +imgHQ25664.npy +imgHQ03065.npy +imgHQ16652.npy +imgHQ28794.npy +imgHQ14999.npy +imgHQ00566.npy +imgHQ29308.npy +imgHQ24522.npy +imgHQ25384.npy +imgHQ07367.npy +imgHQ26796.npy +imgHQ15856.npy +imgHQ17405.npy +imgHQ18706.npy +imgHQ06095.npy +imgHQ26440.npy +imgHQ04820.npy +imgHQ03303.npy +imgHQ16098.npy +imgHQ04898.npy +imgHQ23281.npy +imgHQ21598.npy +imgHQ04552.npy +imgHQ09130.npy +imgHQ03718.npy +imgHQ06536.npy +imgHQ19176.npy +imgHQ01864.npy +imgHQ20110.npy +imgHQ28074.npy +imgHQ15750.npy +imgHQ05863.npy +imgHQ06686.npy +imgHQ11707.npy +imgHQ20061.npy +imgHQ18852.npy +imgHQ22439.npy +imgHQ21137.npy +imgHQ09757.npy +imgHQ12378.npy +imgHQ03220.npy +imgHQ29612.npy +imgHQ18201.npy +imgHQ13505.npy +imgHQ20884.npy +imgHQ04173.npy +imgHQ25745.npy +imgHQ14597.npy +imgHQ19163.npy +imgHQ27888.npy +imgHQ19732.npy +imgHQ15140.npy +imgHQ17302.npy +imgHQ00818.npy +imgHQ16538.npy +imgHQ11476.npy +imgHQ15187.npy +imgHQ24766.npy +imgHQ21043.npy +imgHQ24012.npy +imgHQ01587.npy +imgHQ06038.npy +imgHQ09122.npy +imgHQ04979.npy +imgHQ09232.npy +imgHQ18590.npy +imgHQ20358.npy +imgHQ24002.npy +imgHQ26837.npy +imgHQ27511.npy +imgHQ04713.npy +imgHQ18881.npy +imgHQ18356.npy +imgHQ15984.npy +imgHQ20741.npy +imgHQ21377.npy +imgHQ09377.npy +imgHQ02734.npy +imgHQ09994.npy +imgHQ20874.npy +imgHQ20329.npy +imgHQ02202.npy +imgHQ25058.npy +imgHQ07198.npy +imgHQ12763.npy +imgHQ05433.npy +imgHQ14936.npy +imgHQ03134.npy +imgHQ06712.npy +imgHQ08719.npy +imgHQ01932.npy +imgHQ16971.npy +imgHQ27383.npy +imgHQ28360.npy +imgHQ15461.npy +imgHQ15747.npy +imgHQ27965.npy +imgHQ20060.npy +imgHQ18429.npy +imgHQ12882.npy +imgHQ28186.npy +imgHQ10251.npy +imgHQ11125.npy +imgHQ03390.npy +imgHQ11454.npy +imgHQ18616.npy +imgHQ26633.npy +imgHQ24964.npy +imgHQ03785.npy +imgHQ10573.npy +imgHQ02545.npy +imgHQ04605.npy +imgHQ22654.npy +imgHQ24556.npy +imgHQ16891.npy +imgHQ05657.npy +imgHQ15784.npy +imgHQ08265.npy +imgHQ21351.npy +imgHQ10476.npy +imgHQ16689.npy +imgHQ08056.npy +imgHQ17936.npy +imgHQ13163.npy +imgHQ19066.npy +imgHQ20656.npy +imgHQ19953.npy +imgHQ08368.npy +imgHQ06974.npy +imgHQ06417.npy +imgHQ15491.npy +imgHQ14498.npy +imgHQ23083.npy +imgHQ11385.npy +imgHQ12135.npy +imgHQ27619.npy +imgHQ26914.npy +imgHQ08399.npy +imgHQ08319.npy +imgHQ15629.npy +imgHQ03156.npy +imgHQ20265.npy +imgHQ00152.npy +imgHQ23195.npy +imgHQ29339.npy +imgHQ09933.npy +imgHQ06071.npy +imgHQ00015.npy +imgHQ20572.npy +imgHQ19963.npy +imgHQ02051.npy +imgHQ06275.npy +imgHQ04362.npy +imgHQ11328.npy +imgHQ08317.npy +imgHQ07492.npy +imgHQ24870.npy +imgHQ27049.npy +imgHQ25210.npy +imgHQ10164.npy +imgHQ23186.npy +imgHQ18613.npy +imgHQ07272.npy +imgHQ26416.npy +imgHQ13207.npy +imgHQ20337.npy +imgHQ04653.npy +imgHQ23301.npy +imgHQ26291.npy +imgHQ17456.npy +imgHQ00236.npy +imgHQ07395.npy +imgHQ10116.npy +imgHQ28310.npy +imgHQ12263.npy +imgHQ28533.npy +imgHQ07008.npy +imgHQ13520.npy +imgHQ02397.npy +imgHQ21451.npy +imgHQ05977.npy +imgHQ05179.npy +imgHQ06186.npy +imgHQ16597.npy +imgHQ20415.npy +imgHQ18586.npy +imgHQ04481.npy +imgHQ29425.npy +imgHQ08741.npy +imgHQ07299.npy +imgHQ07295.npy +imgHQ05327.npy +imgHQ10367.npy +imgHQ24503.npy +imgHQ19145.npy +imgHQ24147.npy +imgHQ18052.npy +imgHQ24930.npy +imgHQ22989.npy +imgHQ17195.npy +imgHQ25899.npy +imgHQ06905.npy +imgHQ18826.npy +imgHQ14162.npy +imgHQ01136.npy +imgHQ23379.npy +imgHQ11826.npy +imgHQ17055.npy +imgHQ19559.npy +imgHQ05088.npy +imgHQ07897.npy +imgHQ23104.npy +imgHQ12670.npy +imgHQ29692.npy +imgHQ14119.npy +imgHQ03122.npy +imgHQ19159.npy +imgHQ08657.npy +imgHQ27525.npy +imgHQ27061.npy +imgHQ05546.npy +imgHQ10126.npy +imgHQ27199.npy +imgHQ29248.npy +imgHQ20607.npy +imgHQ18389.npy +imgHQ05115.npy +imgHQ24482.npy +imgHQ10463.npy +imgHQ28319.npy +imgHQ20486.npy +imgHQ24920.npy +imgHQ25219.npy +imgHQ10551.npy +imgHQ21005.npy +imgHQ19694.npy +imgHQ07042.npy +imgHQ21160.npy +imgHQ20955.npy +imgHQ08067.npy +imgHQ16673.npy +imgHQ00003.npy +imgHQ28317.npy +imgHQ00685.npy +imgHQ14434.npy +imgHQ26281.npy +imgHQ01646.npy +imgHQ27213.npy +imgHQ00921.npy +imgHQ08358.npy +imgHQ15667.npy +imgHQ17061.npy +imgHQ27000.npy +imgHQ27088.npy +imgHQ17909.npy +imgHQ16209.npy +imgHQ28723.npy +imgHQ22079.npy +imgHQ00968.npy +imgHQ19189.npy +imgHQ08908.npy +imgHQ22518.npy +imgHQ12750.npy +imgHQ05413.npy +imgHQ24563.npy +imgHQ10568.npy +imgHQ16721.npy +imgHQ27068.npy +imgHQ09746.npy +imgHQ09751.npy +imgHQ20793.npy +imgHQ26293.npy +imgHQ07977.npy +imgHQ13346.npy +imgHQ13275.npy +imgHQ07812.npy +imgHQ29535.npy +imgHQ07903.npy +imgHQ21582.npy +imgHQ25997.npy +imgHQ05722.npy +imgHQ05308.npy +imgHQ17816.npy +imgHQ00512.npy +imgHQ28238.npy +imgHQ08409.npy +imgHQ25982.npy +imgHQ29081.npy +imgHQ02436.npy +imgHQ11416.npy +imgHQ12886.npy +imgHQ21098.npy +imgHQ13336.npy +imgHQ02333.npy +imgHQ29497.npy +imgHQ14423.npy +imgHQ18041.npy +imgHQ04320.npy +imgHQ10125.npy +imgHQ21517.npy +imgHQ09193.npy +imgHQ15354.npy +imgHQ10959.npy +imgHQ14129.npy +imgHQ13493.npy +imgHQ29593.npy +imgHQ09890.npy +imgHQ18057.npy +imgHQ01236.npy +imgHQ00470.npy +imgHQ14669.npy +imgHQ18659.npy +imgHQ27430.npy +imgHQ03899.npy +imgHQ24435.npy +imgHQ02036.npy +imgHQ20020.npy +imgHQ04075.npy +imgHQ27374.npy +imgHQ07269.npy +imgHQ13145.npy +imgHQ23901.npy +imgHQ02234.npy +imgHQ01173.npy +imgHQ13042.npy +imgHQ19012.npy +imgHQ08119.npy +imgHQ27981.npy +imgHQ17123.npy +imgHQ06772.npy +imgHQ14098.npy +imgHQ28218.npy +imgHQ23116.npy +imgHQ26629.npy +imgHQ28835.npy +imgHQ29789.npy +imgHQ09480.npy +imgHQ12361.npy +imgHQ26501.npy +imgHQ13860.npy +imgHQ03564.npy +imgHQ08811.npy +imgHQ01345.npy +imgHQ29549.npy +imgHQ22780.npy +imgHQ05739.npy +imgHQ26923.npy +imgHQ10856.npy +imgHQ27028.npy +imgHQ22855.npy +imgHQ26072.npy +imgHQ14615.npy +imgHQ18082.npy +imgHQ27010.npy +imgHQ03953.npy +imgHQ17137.npy +imgHQ01849.npy +imgHQ25909.npy +imgHQ15171.npy +imgHQ27684.npy +imgHQ24615.npy +imgHQ08506.npy +imgHQ01751.npy +imgHQ22261.npy +imgHQ08536.npy +imgHQ26247.npy +imgHQ22979.npy +imgHQ21808.npy +imgHQ11486.npy +imgHQ01321.npy +imgHQ26427.npy +imgHQ28102.npy +imgHQ11574.npy +imgHQ07919.npy +imgHQ20631.npy +imgHQ04046.npy +imgHQ10728.npy +imgHQ29441.npy +imgHQ20735.npy +imgHQ15997.npy +imgHQ26992.npy +imgHQ07076.npy +imgHQ08086.npy +imgHQ20472.npy +imgHQ14566.npy +imgHQ23496.npy +imgHQ17594.npy +imgHQ16193.npy +imgHQ29359.npy +imgHQ13033.npy +imgHQ26377.npy +imgHQ15576.npy +imgHQ19341.npy +imgHQ05547.npy +imgHQ21047.npy +imgHQ24035.npy +imgHQ23643.npy +imgHQ00169.npy +imgHQ03341.npy +imgHQ09293.npy +imgHQ09887.npy +imgHQ27425.npy +imgHQ09153.npy +imgHQ19628.npy +imgHQ24418.npy +imgHQ06031.npy +imgHQ05069.npy +imgHQ13914.npy +imgHQ09226.npy +imgHQ11259.npy +imgHQ22935.npy +imgHQ27836.npy +imgHQ24437.npy +imgHQ10626.npy +imgHQ09602.npy +imgHQ13625.npy +imgHQ26732.npy +imgHQ16165.npy +imgHQ05198.npy +imgHQ06647.npy +imgHQ00129.npy +imgHQ02591.npy +imgHQ11753.npy +imgHQ01762.npy +imgHQ06264.npy +imgHQ09594.npy +imgHQ05245.npy +imgHQ20860.npy +imgHQ16734.npy +imgHQ13206.npy +imgHQ21525.npy +imgHQ01257.npy +imgHQ05623.npy +imgHQ02065.npy +imgHQ17908.npy +imgHQ25243.npy +imgHQ14422.npy +imgHQ02276.npy +imgHQ24371.npy +imgHQ21309.npy +imgHQ23029.npy +imgHQ14124.npy +imgHQ23223.npy +imgHQ15485.npy +imgHQ22727.npy +imgHQ20805.npy +imgHQ26781.npy +imgHQ01342.npy +imgHQ15288.npy +imgHQ13948.npy +imgHQ27288.npy +imgHQ24740.npy +imgHQ28906.npy +imgHQ28677.npy +imgHQ13281.npy +imgHQ22167.npy +imgHQ16144.npy +imgHQ10522.npy +imgHQ21403.npy +imgHQ08912.npy +imgHQ27352.npy +imgHQ21755.npy +imgHQ12437.npy +imgHQ27346.npy +imgHQ27807.npy +imgHQ12088.npy +imgHQ02673.npy +imgHQ09556.npy +imgHQ01556.npy +imgHQ07370.npy +imgHQ00632.npy +imgHQ04319.npy +imgHQ16400.npy +imgHQ22808.npy +imgHQ03211.npy +imgHQ18141.npy +imgHQ11762.npy +imgHQ23826.npy +imgHQ06724.npy +imgHQ05331.npy +imgHQ19542.npy +imgHQ12047.npy +imgHQ04578.npy +imgHQ19678.npy +imgHQ17507.npy +imgHQ09149.npy +imgHQ02023.npy +imgHQ06919.npy +imgHQ10387.npy +imgHQ22834.npy +imgHQ08191.npy +imgHQ27756.npy +imgHQ05274.npy +imgHQ03275.npy +imgHQ07339.npy +imgHQ11543.npy +imgHQ24377.npy +imgHQ20309.npy +imgHQ02074.npy +imgHQ25398.npy +imgHQ03769.npy +imgHQ03144.npy +imgHQ23909.npy +imgHQ22040.npy +imgHQ23455.npy +imgHQ18133.npy +imgHQ12994.npy +imgHQ26586.npy +imgHQ13327.npy +imgHQ14687.npy +imgHQ23407.npy +imgHQ22139.npy +imgHQ15857.npy +imgHQ07426.npy +imgHQ24203.npy +imgHQ14733.npy +imgHQ05768.npy +imgHQ05369.npy +imgHQ09068.npy +imgHQ29654.npy +imgHQ29266.npy +imgHQ04398.npy +imgHQ04221.npy +imgHQ19469.npy +imgHQ18770.npy +imgHQ12050.npy +imgHQ13786.npy +imgHQ29307.npy +imgHQ18331.npy +imgHQ26943.npy +imgHQ22956.npy +imgHQ10379.npy +imgHQ24745.npy +imgHQ20437.npy +imgHQ10929.npy +imgHQ13700.npy +imgHQ25521.npy +imgHQ22185.npy +imgHQ28488.npy +imgHQ11124.npy +imgHQ29472.npy +imgHQ00688.npy +imgHQ17644.npy +imgHQ22707.npy +imgHQ10001.npy +imgHQ19784.npy +imgHQ09688.npy +imgHQ18763.npy +imgHQ12295.npy +imgHQ09044.npy +imgHQ01437.npy +imgHQ27796.npy +imgHQ04880.npy +imgHQ13747.npy +imgHQ18112.npy +imgHQ09849.npy +imgHQ05791.npy +imgHQ12121.npy +imgHQ06816.npy +imgHQ15360.npy +imgHQ10622.npy +imgHQ17420.npy +imgHQ19904.npy +imgHQ01555.npy +imgHQ12344.npy +imgHQ29400.npy +imgHQ07884.npy +imgHQ04592.npy +imgHQ23629.npy +imgHQ12581.npy +imgHQ00700.npy +imgHQ12370.npy +imgHQ28403.npy +imgHQ12235.npy +imgHQ14517.npy +imgHQ18934.npy +imgHQ06404.npy +imgHQ27012.npy +imgHQ05818.npy +imgHQ04935.npy +imgHQ09753.npy +imgHQ20932.npy +imgHQ08935.npy +imgHQ14512.npy +imgHQ13906.npy +imgHQ05217.npy +imgHQ22876.npy +imgHQ15167.npy +imgHQ26831.npy +imgHQ17953.npy +imgHQ05843.npy +imgHQ16270.npy +imgHQ00189.npy +imgHQ01688.npy +imgHQ11933.npy +imgHQ22751.npy +imgHQ27660.npy +imgHQ03909.npy +imgHQ26474.npy +imgHQ26529.npy +imgHQ02464.npy +imgHQ19730.npy +imgHQ13964.npy +imgHQ04024.npy +imgHQ22545.npy +imgHQ18361.npy +imgHQ27504.npy +imgHQ27785.npy +imgHQ04496.npy +imgHQ23449.npy +imgHQ03881.npy +imgHQ27598.npy +imgHQ26341.npy +imgHQ01952.npy +imgHQ25653.npy +imgHQ09196.npy +imgHQ11129.npy +imgHQ18504.npy +imgHQ17240.npy +imgHQ16973.npy +imgHQ23610.npy +imgHQ28308.npy +imgHQ15724.npy +imgHQ10531.npy +imgHQ10466.npy +imgHQ26980.npy +imgHQ03221.npy +imgHQ27210.npy +imgHQ02638.npy +imgHQ19074.npy +imgHQ05048.npy +imgHQ02127.npy +imgHQ26513.npy +imgHQ20050.npy +imgHQ16320.npy +imgHQ21366.npy +imgHQ24862.npy +imgHQ09419.npy +imgHQ24619.npy +imgHQ07205.npy +imgHQ14128.npy +imgHQ03301.npy +imgHQ24077.npy +imgHQ13805.npy +imgHQ28372.npy +imgHQ27164.npy +imgHQ20416.npy +imgHQ02363.npy +imgHQ00024.npy +imgHQ04160.npy +imgHQ03312.npy +imgHQ20518.npy +imgHQ16498.npy +imgHQ13908.npy +imgHQ14089.npy +imgHQ06260.npy +imgHQ01843.npy +imgHQ26784.npy +imgHQ01837.npy +imgHQ01637.npy +imgHQ19819.npy +imgHQ00035.npy +imgHQ18909.npy +imgHQ04108.npy +imgHQ18624.npy +imgHQ28808.npy +imgHQ07709.npy +imgHQ04672.npy +imgHQ29841.npy +imgHQ10911.npy +imgHQ15507.npy +imgHQ22536.npy +imgHQ28924.npy +imgHQ26106.npy +imgHQ28328.npy +imgHQ28496.npy +imgHQ16350.npy +imgHQ22633.npy +imgHQ29989.npy +imgHQ10736.npy +imgHQ20855.npy +imgHQ22378.npy +imgHQ02630.npy +imgHQ06982.npy +imgHQ20166.npy +imgHQ25017.npy +imgHQ13089.npy +imgHQ21698.npy +imgHQ19769.npy +imgHQ23018.npy +imgHQ06195.npy +imgHQ00823.npy +imgHQ14697.npy +imgHQ25183.npy +imgHQ16681.npy +imgHQ03143.npy +imgHQ20521.npy +imgHQ10417.npy +imgHQ14025.npy +imgHQ27290.npy +imgHQ18635.npy +imgHQ27960.npy +imgHQ14545.npy +imgHQ01132.npy +imgHQ21169.npy +imgHQ12248.npy +imgHQ28501.npy +imgHQ26468.npy +imgHQ00405.npy +imgHQ13909.npy +imgHQ29420.npy +imgHQ27375.npy +imgHQ02196.npy +imgHQ23250.npy +imgHQ20090.npy +imgHQ25331.npy +imgHQ25279.npy +imgHQ00320.npy +imgHQ14933.npy +imgHQ23663.npy +imgHQ27715.npy +imgHQ01842.npy +imgHQ23871.npy +imgHQ06582.npy +imgHQ20488.npy +imgHQ15495.npy +imgHQ25463.npy +imgHQ09469.npy +imgHQ29192.npy +imgHQ08656.npy +imgHQ25001.npy +imgHQ27792.npy +imgHQ24634.npy +imgHQ17314.npy +imgHQ20125.npy +imgHQ26673.npy +imgHQ04457.npy +imgHQ25393.npy +imgHQ00170.npy +imgHQ05702.npy +imgHQ16129.npy +imgHQ13399.npy +imgHQ27772.npy +imgHQ05598.npy +imgHQ24106.npy +imgHQ25051.npy +imgHQ07014.npy +imgHQ03103.npy +imgHQ08270.npy +imgHQ01909.npy +imgHQ10836.npy +imgHQ18623.npy +imgHQ02159.npy +imgHQ24279.npy +imgHQ27820.npy +imgHQ10129.npy +imgHQ26910.npy +imgHQ28105.npy +imgHQ18963.npy +imgHQ05353.npy +imgHQ10484.npy +imgHQ01779.npy +imgHQ29455.npy +imgHQ04401.npy +imgHQ25807.npy +imgHQ04036.npy +imgHQ07716.npy +imgHQ14253.npy +imgHQ02930.npy +imgHQ04158.npy +imgHQ13869.npy +imgHQ03657.npy +imgHQ18776.npy +imgHQ29532.npy +imgHQ26053.npy +imgHQ21754.npy +imgHQ23143.npy +imgHQ25657.npy +imgHQ25246.npy +imgHQ18593.npy +imgHQ27366.npy +imgHQ08809.npy +imgHQ09024.npy +imgHQ04718.npy +imgHQ11987.npy +imgHQ25211.npy +imgHQ18620.npy +imgHQ17822.npy +imgHQ24163.npy +imgHQ25195.npy +imgHQ22528.npy +imgHQ22759.npy +imgHQ01423.npy +imgHQ09084.npy +imgHQ13586.npy +imgHQ15727.npy +imgHQ04565.npy +imgHQ00571.npy +imgHQ24782.npy +imgHQ19323.npy +imgHQ03110.npy +imgHQ27046.npy +imgHQ21998.npy +imgHQ15801.npy +imgHQ28266.npy +imgHQ21785.npy +imgHQ05358.npy +imgHQ22223.npy +imgHQ03974.npy +imgHQ26616.npy +imgHQ21752.npy +imgHQ01119.npy +imgHQ11869.npy +imgHQ19753.npy +imgHQ03017.npy +imgHQ09484.npy +imgHQ21101.npy +imgHQ11578.npy +imgHQ14345.npy +imgHQ07429.npy +imgHQ21916.npy +imgHQ04055.npy +imgHQ02931.npy +imgHQ29822.npy +imgHQ05696.npy +imgHQ00701.npy +imgHQ25839.npy +imgHQ11708.npy +imgHQ00234.npy +imgHQ14725.npy +imgHQ24550.npy +imgHQ08676.npy +imgHQ17879.npy +imgHQ23211.npy +imgHQ23833.npy +imgHQ04844.npy +imgHQ10885.npy +imgHQ22476.npy +imgHQ29481.npy +imgHQ13450.npy +imgHQ10462.npy +imgHQ04459.npy +imgHQ23238.npy +imgHQ02909.npy +imgHQ23432.npy +imgHQ00207.npy +imgHQ10882.npy +imgHQ21371.npy +imgHQ04750.npy +imgHQ11817.npy +imgHQ03568.npy +imgHQ05382.npy +imgHQ20583.npy +imgHQ00447.npy +imgHQ06286.npy +imgHQ13815.npy +imgHQ11607.npy +imgHQ24839.npy +imgHQ07588.npy +imgHQ09063.npy +imgHQ03748.npy +imgHQ23947.npy +imgHQ01214.npy +imgHQ28164.npy +imgHQ26456.npy +imgHQ08150.npy +imgHQ00801.npy +imgHQ03069.npy +imgHQ28402.npy +imgHQ24176.npy +imgHQ00856.npy +imgHQ12746.npy +imgHQ17114.npy +imgHQ17211.npy +imgHQ09542.npy +imgHQ09726.npy +imgHQ00393.npy +imgHQ01264.npy +imgHQ12549.npy +imgHQ00920.npy +imgHQ03233.npy +imgHQ02873.npy +imgHQ01930.npy +imgHQ26242.npy +imgHQ12225.npy +imgHQ01905.npy +imgHQ07740.npy +imgHQ28236.npy +imgHQ11378.npy +imgHQ21482.npy +imgHQ18808.npy +imgHQ18886.npy +imgHQ07125.npy +imgHQ14645.npy +imgHQ02680.npy +imgHQ04486.npy +imgHQ25240.npy +imgHQ15217.npy +imgHQ22582.npy +imgHQ15877.npy +imgHQ26664.npy +imgHQ16228.npy +imgHQ14355.npy +imgHQ29494.npy +imgHQ03997.npy +imgHQ20053.npy +imgHQ27118.npy +imgHQ14365.npy +imgHQ14177.npy +imgHQ13623.npy +imgHQ10364.npy +imgHQ13500.npy +imgHQ10841.npy +imgHQ23260.npy +imgHQ06528.npy +imgHQ25592.npy +imgHQ18569.npy +imgHQ07085.npy +imgHQ21042.npy +imgHQ13646.npy +imgHQ18760.npy +imgHQ27059.npy +imgHQ27117.npy +imgHQ05889.npy +imgHQ17286.npy +imgHQ08528.npy +imgHQ18820.npy +imgHQ09603.npy +imgHQ28639.npy +imgHQ15775.npy +imgHQ22438.npy +imgHQ05499.npy +imgHQ04026.npy +imgHQ23922.npy +imgHQ28899.npy +imgHQ13985.npy +imgHQ16036.npy +imgHQ03758.npy +imgHQ04873.npy +imgHQ18154.npy +imgHQ18166.npy +imgHQ18260.npy +imgHQ02626.npy +imgHQ28568.npy +imgHQ16691.npy +imgHQ05017.npy +imgHQ12936.npy +imgHQ08588.npy +imgHQ16335.npy +imgHQ19574.npy +imgHQ07331.npy +imgHQ25121.npy +imgHQ27146.npy +imgHQ02263.npy +imgHQ03966.npy +imgHQ09977.npy +imgHQ21652.npy +imgHQ05828.npy +imgHQ03634.npy +imgHQ01177.npy +imgHQ10799.npy +imgHQ00507.npy +imgHQ19256.npy +imgHQ00652.npy +imgHQ10495.npy +imgHQ27646.npy +imgHQ22349.npy +imgHQ11904.npy +imgHQ02661.npy +imgHQ14818.npy +imgHQ28448.npy +imgHQ29247.npy +imgHQ06602.npy +imgHQ23341.npy +imgHQ15638.npy +imgHQ07807.npy +imgHQ15898.npy +imgHQ02236.npy +imgHQ16700.npy +imgHQ19656.npy +imgHQ14075.npy +imgHQ16092.npy +imgHQ17526.npy +imgHQ25373.npy +imgHQ07169.npy +imgHQ29282.npy +imgHQ12017.npy +imgHQ06208.npy +imgHQ04641.npy +imgHQ15444.npy +imgHQ16569.npy +imgHQ28783.npy +imgHQ02579.npy +imgHQ28884.npy +imgHQ15469.npy +imgHQ29548.npy +imgHQ24519.npy +imgHQ13867.npy +imgHQ22874.npy +imgHQ21560.npy +imgHQ26478.npy +imgHQ12937.npy +imgHQ10444.npy +imgHQ22842.npy +imgHQ09339.npy +imgHQ02091.npy +imgHQ24431.npy +imgHQ24790.npy +imgHQ12402.npy +imgHQ16122.npy +imgHQ22554.npy +imgHQ28374.npy +imgHQ24947.npy +imgHQ10571.npy +imgHQ12979.npy +imgHQ28855.npy +imgHQ22143.npy +imgHQ01941.npy +imgHQ18219.npy +imgHQ00255.npy +imgHQ08821.npy +imgHQ21899.npy +imgHQ22813.npy +imgHQ26724.npy +imgHQ28575.npy +imgHQ02806.npy +imgHQ16696.npy +imgHQ02635.npy +imgHQ07029.npy +imgHQ24957.npy +imgHQ05252.npy +imgHQ11900.npy +imgHQ22983.npy +imgHQ07680.npy +imgHQ19821.npy +imgHQ11453.npy +imgHQ25827.npy +imgHQ06342.npy +imgHQ14181.npy +imgHQ24905.npy +imgHQ05080.npy +imgHQ28542.npy +imgHQ13901.npy +imgHQ21878.npy +imgHQ20923.npy +imgHQ12832.npy +imgHQ21489.npy +imgHQ06211.npy +imgHQ02731.npy +imgHQ11167.npy +imgHQ16815.npy +imgHQ01778.npy +imgHQ17135.npy +imgHQ23716.npy +imgHQ07936.npy +imgHQ24067.npy +imgHQ16090.npy +imgHQ29752.npy +imgHQ13431.npy +imgHQ10141.npy +imgHQ03383.npy +imgHQ23304.npy +imgHQ09112.npy +imgHQ24260.npy +imgHQ07616.npy +imgHQ14081.npy +imgHQ01776.npy +imgHQ22959.npy +imgHQ25013.npy +imgHQ21491.npy +imgHQ18334.npy +imgHQ14254.npy +imgHQ17045.npy +imgHQ09813.npy +imgHQ27850.npy +imgHQ16333.npy +imgHQ29329.npy +imgHQ05023.npy +imgHQ25092.npy +imgHQ17236.npy +imgHQ28116.npy +imgHQ12806.npy +imgHQ14061.npy +imgHQ09802.npy +imgHQ27668.npy +imgHQ05454.npy +imgHQ09786.npy +imgHQ11356.npy +imgHQ25417.npy +imgHQ04921.npy +imgHQ02284.npy +imgHQ06991.npy +imgHQ03819.npy +imgHQ16620.npy +imgHQ15711.npy +imgHQ23418.npy +imgHQ24652.npy +imgHQ23859.npy +imgHQ15453.npy +imgHQ24917.npy +imgHQ18127.npy +imgHQ21218.npy +imgHQ24911.npy +imgHQ10073.npy +imgHQ22058.npy +imgHQ14062.npy +imgHQ17818.npy +imgHQ16022.npy +imgHQ05157.npy +imgHQ21760.npy +imgHQ06977.npy +imgHQ17323.npy +imgHQ00686.npy +imgHQ26286.npy +imgHQ14435.npy +imgHQ23402.npy +imgHQ28886.npy +imgHQ00334.npy +imgHQ17243.npy +imgHQ00833.npy +imgHQ08395.npy +imgHQ16873.npy +imgHQ18087.npy +imgHQ17726.npy +imgHQ18300.npy +imgHQ16548.npy +imgHQ10159.npy +imgHQ29623.npy +imgHQ08483.npy +imgHQ23191.npy +imgHQ07208.npy +imgHQ13315.npy +imgHQ26046.npy +imgHQ17051.npy +imgHQ22581.npy +imgHQ28821.npy +imgHQ09077.npy +imgHQ17998.npy +imgHQ25153.npy +imgHQ02268.npy +imgHQ13715.npy +imgHQ06623.npy +imgHQ19789.npy +imgHQ15976.npy +imgHQ19094.npy +imgHQ15653.npy +imgHQ04855.npy +imgHQ26327.npy +imgHQ22199.npy +imgHQ15270.npy +imgHQ11556.npy +imgHQ09327.npy +imgHQ17192.npy +imgHQ25515.npy +imgHQ27194.npy +imgHQ11760.npy +imgHQ00222.npy +imgHQ06611.npy +imgHQ11479.npy +imgHQ06151.npy +imgHQ18167.npy +imgHQ06083.npy +imgHQ17150.npy +imgHQ01227.npy +imgHQ26198.npy +imgHQ23005.npy +imgHQ09409.npy +imgHQ14883.npy +imgHQ07030.npy +imgHQ12983.npy +imgHQ09074.npy +imgHQ28441.npy +imgHQ01807.npy +imgHQ23774.npy +imgHQ03378.npy +imgHQ11116.npy +imgHQ10827.npy +imgHQ04966.npy +imgHQ24489.npy +imgHQ28478.npy +imgHQ18745.npy +imgHQ28969.npy +imgHQ02457.npy +imgHQ12114.npy +imgHQ21066.npy +imgHQ20142.npy +imgHQ16316.npy +imgHQ15347.npy +imgHQ21335.npy +imgHQ29968.npy +imgHQ06876.npy +imgHQ04226.npy +imgHQ23944.npy +imgHQ10523.npy +imgHQ10218.npy +imgHQ04369.npy +imgHQ18506.npy +imgHQ20398.npy +imgHQ04906.npy +imgHQ22829.npy +imgHQ11411.npy +imgHQ19046.npy +imgHQ21318.npy +imgHQ14704.npy +imgHQ07831.npy +imgHQ23270.npy +imgHQ26428.npy +imgHQ21131.npy +imgHQ29100.npy +imgHQ29318.npy +imgHQ29862.npy +imgHQ26922.npy +imgHQ28745.npy +imgHQ00341.npy +imgHQ26589.npy +imgHQ23860.npy +imgHQ28156.npy +imgHQ24246.npy +imgHQ23513.npy +imgHQ17962.npy +imgHQ17849.npy +imgHQ29028.npy +imgHQ26699.npy +imgHQ17422.npy +imgHQ02972.npy +imgHQ23586.npy +imgHQ19715.npy +imgHQ05159.npy +imgHQ14398.npy +imgHQ29704.npy +imgHQ02721.npy +imgHQ18377.npy +imgHQ01962.npy +imgHQ25411.npy +imgHQ00887.npy +imgHQ23182.npy +imgHQ21188.npy +imgHQ25581.npy +imgHQ18715.npy +imgHQ09789.npy +imgHQ11627.npy +imgHQ27591.npy +imgHQ17486.npy +imgHQ02502.npy +imgHQ18610.npy +imgHQ20311.npy +imgHQ00272.npy +imgHQ25109.npy +imgHQ16543.npy +imgHQ27790.npy +imgHQ17815.npy +imgHQ01275.npy +imgHQ23054.npy +imgHQ14344.npy +imgHQ29315.npy +imgHQ29197.npy +imgHQ28718.npy +imgHQ27643.npy +imgHQ23344.npy +imgHQ15872.npy +imgHQ18001.npy +imgHQ23762.npy +imgHQ20226.npy +imgHQ04861.npy +imgHQ18111.npy +imgHQ24723.npy +imgHQ05688.npy +imgHQ28702.npy +imgHQ25914.npy +imgHQ04311.npy +imgHQ12620.npy +imgHQ09221.npy +imgHQ04615.npy +imgHQ02344.npy +imgHQ24493.npy +imgHQ27472.npy +imgHQ25477.npy +imgHQ26875.npy +imgHQ11593.npy +imgHQ29746.npy +imgHQ03829.npy +imgHQ23163.npy +imgHQ24120.npy +imgHQ29729.npy +imgHQ25937.npy +imgHQ03926.npy +imgHQ06662.npy +imgHQ17125.npy +imgHQ04645.npy +imgHQ07924.npy +imgHQ20116.npy +imgHQ08025.npy +imgHQ22036.npy +imgHQ11498.npy +imgHQ18683.npy +imgHQ03609.npy +imgHQ12421.npy +imgHQ03719.npy +imgHQ23649.npy +imgHQ13631.npy +imgHQ26522.npy +imgHQ01029.npy +imgHQ15081.npy +imgHQ16409.npy +imgHQ24280.npy +imgHQ00437.npy +imgHQ13192.npy +imgHQ15401.npy +imgHQ03400.npy +imgHQ11912.npy +imgHQ28770.npy +imgHQ04143.npy +imgHQ17085.npy +imgHQ14090.npy +imgHQ14880.npy +imgHQ11563.npy +imgHQ00366.npy +imgHQ20989.npy +imgHQ26559.npy +imgHQ05669.npy +imgHQ26628.npy +imgHQ20587.npy +imgHQ16788.npy +imgHQ10612.npy +imgHQ22280.npy +imgHQ13105.npy +imgHQ14831.npy +imgHQ12732.npy +imgHQ10804.npy +imgHQ05693.npy +imgHQ28616.npy +imgHQ01537.npy +imgHQ22601.npy +imgHQ24138.npy +imgHQ01420.npy +imgHQ22116.npy +imgHQ15222.npy +imgHQ13642.npy +imgHQ00821.npy +imgHQ24952.npy +imgHQ26030.npy +imgHQ04633.npy +imgHQ02346.npy +imgHQ04579.npy +imgHQ13571.npy +imgHQ14573.npy +imgHQ10862.npy +imgHQ25603.npy +imgHQ22005.npy +imgHQ18299.npy +imgHQ23385.npy +imgHQ18816.npy +imgHQ10012.npy +imgHQ15920.npy +imgHQ17460.npy +imgHQ07452.npy +imgHQ05110.npy +imgHQ01908.npy +imgHQ09249.npy +imgHQ25865.npy +imgHQ12592.npy +imgHQ04292.npy +imgHQ25894.npy +imgHQ04214.npy +imgHQ21649.npy +imgHQ22609.npy +imgHQ10539.npy +imgHQ20351.npy +imgHQ17929.npy +imgHQ28530.npy +imgHQ21973.npy +imgHQ03290.npy +imgHQ14786.npy +imgHQ03588.npy +imgHQ17809.npy +imgHQ17140.npy +imgHQ00695.npy +imgHQ26769.npy +imgHQ08662.npy +imgHQ00538.npy +imgHQ01193.npy +imgHQ12096.npy +imgHQ20588.npy +imgHQ00747.npy +imgHQ26125.npy +imgHQ14256.npy +imgHQ24160.npy +imgHQ07165.npy +imgHQ02654.npy +imgHQ21789.npy +imgHQ22616.npy +imgHQ00274.npy +imgHQ06670.npy +imgHQ13881.npy +imgHQ04288.npy +imgHQ12552.npy +imgHQ23718.npy +imgHQ22934.npy +imgHQ05194.npy +imgHQ24645.npy +imgHQ08991.npy +imgHQ27573.npy +imgHQ28057.npy +imgHQ29241.npy +imgHQ01885.npy +imgHQ20959.npy +imgHQ22078.npy +imgHQ05481.npy +imgHQ05988.npy +imgHQ05699.npy +imgHQ07536.npy +imgHQ27853.npy +imgHQ15045.npy +imgHQ14259.npy +imgHQ06613.npy +imgHQ04009.npy +imgHQ12210.npy +imgHQ02399.npy +imgHQ13153.npy +imgHQ29037.npy +imgHQ25573.npy +imgHQ28087.npy +imgHQ01395.npy +imgHQ04835.npy +imgHQ29057.npy +imgHQ15362.npy +imgHQ14810.npy +imgHQ19813.npy +imgHQ06330.npy +imgHQ23476.npy +imgHQ25810.npy +imgHQ20086.npy +imgHQ13616.npy +imgHQ02378.npy +imgHQ27720.npy +imgHQ16713.npy +imgHQ28726.npy +imgHQ10238.npy +imgHQ01131.npy +imgHQ28093.npy +imgHQ24548.npy +imgHQ26754.npy +imgHQ11953.npy +imgHQ09858.npy +imgHQ20761.npy +imgHQ10969.npy +imgHQ13938.npy +imgHQ11347.npy +imgHQ25832.npy +imgHQ19316.npy +imgHQ05525.npy +imgHQ18228.npy +imgHQ07625.npy +imgHQ04761.npy +imgHQ20462.npy +imgHQ05871.npy +imgHQ09298.npy +imgHQ25700.npy +imgHQ27816.npy +imgHQ22532.npy +imgHQ05593.npy +imgHQ20088.npy +imgHQ25895.npy +imgHQ25600.npy +imgHQ18125.npy +imgHQ26854.npy +imgHQ07490.npy +imgHQ14646.npy +imgHQ11021.npy +imgHQ07288.npy +imgHQ26862.npy +imgHQ12889.npy +imgHQ22888.npy +imgHQ05822.npy +imgHQ29780.npy +imgHQ06661.npy +imgHQ18951.npy +imgHQ22268.npy +imgHQ28953.npy +imgHQ29648.npy +imgHQ01964.npy +imgHQ12208.npy +imgHQ09552.npy +imgHQ08436.npy +imgHQ16475.npy +imgHQ27249.npy +imgHQ08745.npy +imgHQ05260.npy +imgHQ12752.npy +imgHQ02698.npy +imgHQ01524.npy +imgHQ00829.npy +imgHQ00780.npy +imgHQ06425.npy +imgHQ11841.npy +imgHQ19442.npy +imgHQ18522.npy +imgHQ09677.npy +imgHQ08663.npy +imgHQ09214.npy +imgHQ02337.npy +imgHQ26008.npy +imgHQ20550.npy +imgHQ06076.npy +imgHQ01949.npy +imgHQ00901.npy +imgHQ12011.npy +imgHQ16212.npy +imgHQ07539.npy +imgHQ29229.npy +imgHQ19318.npy +imgHQ21951.npy +imgHQ29371.npy +imgHQ19080.npy +imgHQ14909.npy +imgHQ02260.npy +imgHQ08421.npy +imgHQ29584.npy +imgHQ25939.npy +imgHQ10162.npy +imgHQ13152.npy +imgHQ17817.npy +imgHQ27251.npy +imgHQ14211.npy +imgHQ17880.npy +imgHQ12195.npy +imgHQ29607.npy +imgHQ21072.npy +imgHQ17038.npy +imgHQ27335.npy +imgHQ00005.npy +imgHQ25966.npy +imgHQ11404.npy +imgHQ28464.npy +imgHQ18186.npy +imgHQ27884.npy +imgHQ16281.npy +imgHQ13853.npy +imgHQ18580.npy +imgHQ26603.npy +imgHQ21289.npy +imgHQ05374.npy +imgHQ29764.npy +imgHQ05758.npy +imgHQ18446.npy +imgHQ29414.npy +imgHQ22758.npy +imgHQ22135.npy +imgHQ07915.npy +imgHQ00257.npy +imgHQ04632.npy +imgHQ28692.npy +imgHQ17194.npy +imgHQ09050.npy +imgHQ00529.npy +imgHQ05336.npy +imgHQ01172.npy +imgHQ29099.npy +imgHQ07066.npy +imgHQ15552.npy +imgHQ04444.npy +imgHQ06302.npy +imgHQ02675.npy +imgHQ17077.npy +imgHQ08800.npy +imgHQ10474.npy +imgHQ06170.npy +imgHQ06448.npy +imgHQ20686.npy +imgHQ05008.npy +imgHQ04439.npy +imgHQ06941.npy +imgHQ04134.npy +imgHQ02432.npy +imgHQ17170.npy +imgHQ00673.npy +imgHQ19570.npy +imgHQ27868.npy +imgHQ21847.npy +imgHQ06783.npy +imgHQ10659.npy +imgHQ02916.npy +imgHQ23420.npy +imgHQ25903.npy +imgHQ16653.npy +imgHQ17171.npy +imgHQ12981.npy +imgHQ06539.npy +imgHQ25731.npy +imgHQ27459.npy +imgHQ17390.npy +imgHQ10260.npy +imgHQ18805.npy +imgHQ05475.npy +imgHQ14353.npy +imgHQ15294.npy +imgHQ06411.npy +imgHQ14946.npy +imgHQ13326.npy +imgHQ08290.npy +imgHQ02009.npy +imgHQ17454.npy +imgHQ05389.npy +imgHQ21664.npy +imgHQ21456.npy +imgHQ14947.npy +imgHQ06596.npy +imgHQ11914.npy +imgHQ29669.npy +imgHQ07724.npy +imgHQ05273.npy +imgHQ16844.npy +imgHQ11003.npy +imgHQ23788.npy +imgHQ06843.npy +imgHQ08718.npy +imgHQ08652.npy +imgHQ27451.npy +imgHQ09456.npy +imgHQ09969.npy +imgHQ15566.npy +imgHQ12502.npy +imgHQ02938.npy +imgHQ11969.npy +imgHQ13742.npy +imgHQ00261.npy +imgHQ29745.npy +imgHQ19157.npy +imgHQ27605.npy +imgHQ10759.npy +imgHQ26256.npy +imgHQ26401.npy +imgHQ16252.npy +imgHQ25154.npy +imgHQ14640.npy +imgHQ22089.npy +imgHQ07694.npy +imgHQ05607.npy +imgHQ08059.npy +imgHQ03857.npy +imgHQ28315.npy +imgHQ08849.npy +imgHQ12261.npy +imgHQ27054.npy +imgHQ10869.npy +imgHQ25179.npy +imgHQ04157.npy +imgHQ05188.npy +imgHQ03305.npy +imgHQ23676.npy +imgHQ03218.npy +imgHQ02085.npy +imgHQ00101.npy +imgHQ24356.npy +imgHQ07082.npy +imgHQ05426.npy +imgHQ08834.npy +imgHQ00262.npy +imgHQ20238.npy +imgHQ06297.npy +imgHQ11721.npy +imgHQ06560.npy +imgHQ18636.npy +imgHQ17105.npy +imgHQ24716.npy +imgHQ11329.npy +imgHQ15892.npy +imgHQ15533.npy +imgHQ24514.npy +imgHQ02877.npy +imgHQ00178.npy +imgHQ10751.npy +imgHQ24983.npy +imgHQ03014.npy +imgHQ21376.npy +imgHQ02223.npy +imgHQ15955.npy +imgHQ22587.npy +imgHQ18051.npy +imgHQ25977.npy +imgHQ28960.npy +imgHQ09917.npy +imgHQ18273.npy +imgHQ19005.npy +imgHQ08196.npy +imgHQ13253.npy +imgHQ12110.npy +imgHQ20078.npy +imgHQ07388.npy +imgHQ12601.npy +imgHQ04563.npy +imgHQ21390.npy +imgHQ16452.npy +imgHQ15302.npy +imgHQ18274.npy +imgHQ25945.npy +imgHQ09250.npy +imgHQ20264.npy +imgHQ04005.npy +imgHQ03053.npy +imgHQ14078.npy +imgHQ14841.npy +imgHQ02368.npy +imgHQ04083.npy +imgHQ04409.npy +imgHQ13014.npy +imgHQ10158.npy +imgHQ02795.npy +imgHQ24644.npy +imgHQ12113.npy +imgHQ02076.npy +imgHQ09608.npy +imgHQ01045.npy +imgHQ14690.npy +imgHQ00837.npy +imgHQ10851.npy +imgHQ27962.npy +imgHQ19626.npy +imgHQ04523.npy +imgHQ12323.npy +imgHQ16768.npy +imgHQ13177.npy +imgHQ08994.npy +imgHQ07127.npy +imgHQ13239.npy +imgHQ25691.npy +imgHQ14740.npy +imgHQ02984.npy +imgHQ07401.npy +imgHQ18676.npy +imgHQ08545.npy +imgHQ21748.npy +imgHQ17472.npy +imgHQ16595.npy +imgHQ08423.npy +imgHQ14952.npy +imgHQ28101.npy +imgHQ03872.npy +imgHQ19173.npy +imgHQ09553.npy +imgHQ19355.npy +imgHQ08118.npy +imgHQ08418.npy +imgHQ17381.npy +imgHQ28930.npy +imgHQ09497.npy +imgHQ18689.npy +imgHQ20970.npy +imgHQ18639.npy +imgHQ27620.npy +imgHQ03541.npy +imgHQ18017.npy +imgHQ24889.npy +imgHQ08768.npy +imgHQ25770.npy +imgHQ04918.npy +imgHQ14223.npy +imgHQ20339.npy +imgHQ14552.npy +imgHQ14985.npy +imgHQ01826.npy +imgHQ14390.npy +imgHQ14204.npy +imgHQ17332.npy +imgHQ22255.npy +imgHQ01561.npy +imgHQ23024.npy +imgHQ22007.npy +imgHQ00608.npy +imgHQ00213.npy +imgHQ13432.npy +imgHQ24577.npy +imgHQ03606.npy +imgHQ19867.npy +imgHQ14228.npy +imgHQ13798.npy +imgHQ27505.npy +imgHQ24846.npy +imgHQ11595.npy +imgHQ28549.npy +imgHQ26526.npy +imgHQ05804.npy +imgHQ18179.npy +imgHQ20242.npy +imgHQ02530.npy +imgHQ27768.npy +imgHQ24899.npy +imgHQ22327.npy +imgHQ07934.npy +imgHQ04795.npy +imgHQ16893.npy +imgHQ05769.npy +imgHQ26993.npy +imgHQ13122.npy +imgHQ19096.npy +imgHQ00697.npy +imgHQ29527.npy +imgHQ07279.npy +imgHQ00965.npy +imgHQ18605.npy +imgHQ16593.npy +imgHQ02884.npy +imgHQ15409.npy +imgHQ10249.npy +imgHQ23738.npy +imgHQ22170.npy +imgHQ20091.npy +imgHQ17040.npy +imgHQ04900.npy +imgHQ05094.npy +imgHQ18840.npy +imgHQ12366.npy +imgHQ28347.npy +imgHQ24492.npy +imgHQ29640.npy +imgHQ26419.npy +imgHQ10193.npy +imgHQ24987.npy +imgHQ12728.npy +imgHQ18929.npy +imgHQ08729.npy +imgHQ02853.npy +imgHQ15417.npy +imgHQ23096.npy +imgHQ22425.npy +imgHQ07179.npy +imgHQ16473.npy +imgHQ07273.npy +imgHQ12271.npy +imgHQ03563.npy +imgHQ13284.npy +imgHQ28997.npy +imgHQ07365.npy +imgHQ10295.npy +imgHQ08446.npy +imgHQ20458.npy +imgHQ11414.npy +imgHQ08097.npy +imgHQ08288.npy +imgHQ09892.npy +imgHQ04442.npy +imgHQ03440.npy +imgHQ27225.npy +imgHQ07347.npy +imgHQ24240.npy +imgHQ27182.npy +imgHQ19207.npy +imgHQ25127.npy +imgHQ01662.npy +imgHQ24736.npy +imgHQ14624.npy +imgHQ05724.npy +imgHQ19801.npy +imgHQ15095.npy +imgHQ25441.npy +imgHQ07974.npy +imgHQ16195.npy +imgHQ06682.npy +imgHQ02154.npy +imgHQ24064.npy +imgHQ20829.npy +imgHQ15193.npy +imgHQ14982.npy +imgHQ11115.npy +imgHQ19633.npy +imgHQ16606.npy +imgHQ17230.npy +imgHQ04149.npy +imgHQ17151.npy +imgHQ13482.npy +imgHQ21901.npy +imgHQ18261.npy +imgHQ21134.npy +imgHQ11171.npy +imgHQ23843.npy +imgHQ15845.npy +imgHQ09356.npy +imgHQ29215.npy +imgHQ09808.npy +imgHQ29839.npy +imgHQ28267.npy +imgHQ22401.npy +imgHQ23501.npy +imgHQ24868.npy +imgHQ06407.npy +imgHQ25920.npy +imgHQ01991.npy +imgHQ06318.npy +imgHQ19314.npy +imgHQ00319.npy +imgHQ14821.npy +imgHQ07006.npy +imgHQ13429.npy +imgHQ12520.npy +imgHQ20431.npy +imgHQ14074.npy +imgHQ24803.npy +imgHQ07486.npy +imgHQ27523.npy +imgHQ23965.npy +imgHQ21295.npy +imgHQ05240.npy +imgHQ02603.npy +imgHQ10365.npy +imgHQ15379.npy +imgHQ11853.npy +imgHQ23047.npy +imgHQ21527.npy +imgHQ24609.npy +imgHQ11499.npy +imgHQ00490.npy +imgHQ11133.npy +imgHQ12347.npy +imgHQ05124.npy +imgHQ20474.npy +imgHQ18439.npy +imgHQ28582.npy +imgHQ27700.npy +imgHQ09566.npy +imgHQ20688.npy +imgHQ12284.npy +imgHQ01607.npy +imgHQ22345.npy +imgHQ20315.npy +imgHQ22295.npy +imgHQ17530.npy +imgHQ12185.npy +imgHQ16432.npy +imgHQ27641.npy +imgHQ18338.npy +imgHQ00783.npy +imgHQ10818.npy +imgHQ25425.npy +imgHQ07310.npy +imgHQ15803.npy +imgHQ05816.npy +imgHQ15553.npy +imgHQ24908.npy +imgHQ26119.npy +imgHQ08531.npy +imgHQ24178.npy +imgHQ25645.npy +imgHQ10039.npy +imgHQ25968.npy +imgHQ04116.npy +imgHQ23795.npy +imgHQ29378.npy +imgHQ14283.npy +imgHQ05174.npy +imgHQ23142.npy +imgHQ24971.npy +imgHQ21975.npy +imgHQ17247.npy +imgHQ23504.npy +imgHQ17452.npy +imgHQ02889.npy +imgHQ03991.npy +imgHQ22665.npy +imgHQ24733.npy +imgHQ20718.npy +imgHQ10209.npy +imgHQ01736.npy +imgHQ00724.npy +imgHQ12357.npy +imgHQ06944.npy +imgHQ26865.npy +imgHQ16730.npy +imgHQ23767.npy +imgHQ05337.npy +imgHQ01971.npy +imgHQ06339.npy +imgHQ20581.npy +imgHQ20438.npy +imgHQ03887.npy +imgHQ29203.npy +imgHQ13764.npy +imgHQ12864.npy +imgHQ04666.npy +imgHQ04205.npy +imgHQ28595.npy +imgHQ12083.npy +imgHQ29641.npy +imgHQ05018.npy +imgHQ02554.npy +imgHQ23288.npy +imgHQ21164.npy +imgHQ04928.npy +imgHQ24336.npy +imgHQ10601.npy +imgHQ21120.npy +imgHQ28805.npy +imgHQ01462.npy +imgHQ21968.npy +imgHQ29881.npy +imgHQ16069.npy +imgHQ21411.npy +imgHQ28248.npy +imgHQ04056.npy +imgHQ20104.npy +imgHQ07726.npy +imgHQ20038.npy +imgHQ18570.npy +imgHQ02900.npy +imgHQ20218.npy +imgHQ09103.npy +imgHQ20526.npy +imgHQ14790.npy +imgHQ10273.npy +imgHQ09591.npy +imgHQ27975.npy +imgHQ21423.npy +imgHQ13128.npy +imgHQ09571.npy +imgHQ09762.npy +imgHQ07663.npy +imgHQ18529.npy +imgHQ15591.npy +imgHQ01701.npy +imgHQ09708.npy +imgHQ24393.npy +imgHQ27289.npy +imgHQ21135.npy +imgHQ17348.npy +imgHQ07867.npy +imgHQ22106.npy +imgHQ21340.npy +imgHQ05933.npy +imgHQ10501.npy +imgHQ03633.npy +imgHQ11974.npy +imgHQ19195.npy +imgHQ29418.npy +imgHQ22422.npy +imgHQ02515.npy +imgHQ25180.npy +imgHQ00106.npy +imgHQ15430.npy +imgHQ07385.npy +imgHQ14600.npy +imgHQ09369.npy +imgHQ29513.npy +imgHQ04354.npy +imgHQ05491.npy +imgHQ17182.npy +imgHQ23510.npy +imgHQ29959.npy +imgHQ19550.npy +imgHQ26343.npy +imgHQ27219.npy +imgHQ14551.npy +imgHQ29871.npy +imgHQ14415.npy +imgHQ17496.npy +imgHQ08822.npy +imgHQ18442.npy +imgHQ10780.npy +imgHQ00525.npy +imgHQ21555.npy +imgHQ21936.npy +imgHQ09675.npy +imgHQ02549.npy +imgHQ16180.npy +imgHQ01182.npy +imgHQ05805.npy +imgHQ24763.npy +imgHQ07797.npy +imgHQ22514.npy +imgHQ05784.npy +imgHQ06635.npy +imgHQ21049.npy +imgHQ01086.npy +imgHQ03095.npy +imgHQ19726.npy +imgHQ11007.npy +imgHQ00147.npy +imgHQ27970.npy +imgHQ03201.npy +imgHQ04722.npy +imgHQ29364.npy +imgHQ13248.npy +imgHQ26886.npy +imgHQ24793.npy +imgHQ25302.npy +imgHQ03717.npy +imgHQ01174.npy +imgHQ24069.npy +imgHQ04079.npy +imgHQ04350.npy +imgHQ23587.npy +imgHQ21089.npy +imgHQ05543.npy +imgHQ25239.npy +imgHQ08611.npy +imgHQ20383.npy +imgHQ02588.npy +imgHQ22457.npy +imgHQ19838.npy +imgHQ15278.npy +imgHQ20212.npy +imgHQ17188.npy +imgHQ04499.npy +imgHQ28339.npy +imgHQ29349.npy +imgHQ06459.npy +imgHQ25071.npy +imgHQ15373.npy +imgHQ25828.npy +imgHQ07264.npy +imgHQ04557.npy +imgHQ20177.npy +imgHQ01299.npy +imgHQ27298.npy +imgHQ29059.npy +imgHQ17692.npy +imgHQ19367.npy +imgHQ04295.npy +imgHQ18197.npy +imgHQ21029.npy +imgHQ07717.npy +imgHQ13055.npy +imgHQ25646.npy +imgHQ05856.npy +imgHQ06455.npy +imgHQ03631.npy +imgHQ21539.npy +imgHQ22591.npy +imgHQ14157.npy +imgHQ12202.npy +imgHQ07235.npy +imgHQ29826.npy +imgHQ13943.npy +imgHQ29663.npy +imgHQ19719.npy +imgHQ02761.npy +imgHQ07416.npy +imgHQ00264.npy +imgHQ27758.npy +imgHQ05187.npy +imgHQ18767.npy +imgHQ27405.npy +imgHQ26810.npy +imgHQ23428.npy +imgHQ03684.npy +imgHQ10206.npy +imgHQ00280.npy +imgHQ18130.npy +imgHQ24898.npy +imgHQ28161.npy +imgHQ04148.npy +imgHQ14375.npy +imgHQ07513.npy +imgHQ24810.npy +imgHQ13930.npy +imgHQ29088.npy +imgHQ27256.npy +imgHQ10663.npy +imgHQ06329.npy +imgHQ19951.npy +imgHQ27963.npy +imgHQ24438.npy +imgHQ01919.npy +imgHQ05125.npy +imgHQ10670.npy +imgHQ20294.npy +imgHQ13925.npy +imgHQ08048.npy +imgHQ12536.npy +imgHQ12250.npy +imgHQ07181.npy +imgHQ09054.npy +imgHQ27908.npy +imgHQ01109.npy +imgHQ17309.npy +imgHQ27417.npy +imgHQ05629.npy +imgHQ16233.npy +imgHQ26294.npy +imgHQ26187.npy +imgHQ19242.npy +imgHQ10294.npy +imgHQ24008.npy +imgHQ24392.npy +imgHQ18096.npy +imgHQ11547.npy +imgHQ28021.npy +imgHQ07817.npy +imgHQ26505.npy +imgHQ24690.npy +imgHQ04912.npy +imgHQ17627.npy +imgHQ10575.npy +imgHQ11428.npy +imgHQ00090.npy +imgHQ21584.npy +imgHQ15909.npy +imgHQ00511.npy +imgHQ05059.npy +imgHQ29565.npy +imgHQ08301.npy +imgHQ15715.npy +imgHQ18571.npy +imgHQ14385.npy +imgHQ01333.npy +imgHQ25709.npy +imgHQ12441.npy +imgHQ10186.npy +imgHQ18224.npy +imgHQ28819.npy +imgHQ07485.npy +imgHQ19439.npy +imgHQ04822.npy +imgHQ20404.npy +imgHQ28031.npy +imgHQ02265.npy +imgHQ07017.npy +imgHQ23171.npy +imgHQ21725.npy +imgHQ11761.npy +imgHQ23358.npy +imgHQ14019.npy +imgHQ13858.npy +imgHQ17384.npy +imgHQ11250.npy +imgHQ12071.npy +imgHQ09513.npy +imgHQ10151.npy +imgHQ23165.npy +imgHQ10123.npy +imgHQ23321.npy +imgHQ13137.npy +imgHQ06859.npy +imgHQ28344.npy +imgHQ06479.npy +imgHQ13852.npy +imgHQ12095.npy +imgHQ03147.npy +imgHQ13766.npy +imgHQ10552.npy +imgHQ29717.npy +imgHQ15330.npy +imgHQ15327.npy +imgHQ25439.npy +imgHQ22062.npy +imgHQ15850.npy +imgHQ24117.npy +imgHQ09529.npy +imgHQ00830.npy +imgHQ12483.npy +imgHQ03135.npy +imgHQ17999.npy +imgHQ17621.npy +imgHQ25415.npy +imgHQ04599.npy +imgHQ27262.npy +imgHQ12418.npy +imgHQ17771.npy +imgHQ15847.npy +imgHQ28351.npy +imgHQ05851.npy +imgHQ07553.npy +imgHQ29336.npy +imgHQ19204.npy +imgHQ13703.npy +imgHQ10555.npy +imgHQ17964.npy +imgHQ20878.npy +imgHQ19968.npy +imgHQ13857.npy +imgHQ20947.npy +imgHQ22465.npy +imgHQ10146.npy +imgHQ22690.npy +imgHQ24109.npy +imgHQ19594.npy +imgHQ05747.npy +imgHQ07760.npy +imgHQ03244.npy +imgHQ24285.npy +imgHQ06942.npy +imgHQ21044.npy +imgHQ07189.npy +imgHQ05789.npy +imgHQ03079.npy +imgHQ20935.npy +imgHQ09797.npy +imgHQ18070.npy +imgHQ11713.npy +imgHQ05001.npy +imgHQ21009.npy +imgHQ11280.npy +imgHQ12866.npy +imgHQ27865.npy +imgHQ08606.npy +imgHQ20733.npy +imgHQ16063.npy +imgHQ15918.npy +imgHQ17225.npy +imgHQ29350.npy +imgHQ17277.npy +imgHQ16371.npy +imgHQ11389.npy +imgHQ17221.npy +imgHQ18181.npy +imgHQ13181.npy +imgHQ25345.npy +imgHQ20285.npy +imgHQ21018.npy +imgHQ00000.npy +imgHQ13073.npy +imgHQ06630.npy +imgHQ10454.npy +imgHQ11659.npy +imgHQ15590.npy +imgHQ06873.npy +imgHQ09743.npy +imgHQ23508.npy +imgHQ05914.npy +imgHQ01618.npy +imgHQ07021.npy +imgHQ20755.npy +imgHQ01700.npy +imgHQ11355.npy +imgHQ23995.npy +imgHQ17892.npy +imgHQ28096.npy +imgHQ27744.npy +imgHQ22785.npy +imgHQ07142.npy +imgHQ09722.npy +imgHQ27145.npy +imgHQ02578.npy +imgHQ09838.npy +imgHQ23597.npy +imgHQ06956.npy +imgHQ02891.npy +imgHQ21856.npy +imgHQ15473.npy +imgHQ29136.npy +imgHQ21102.npy +imgHQ24218.npy +imgHQ26853.npy +imgHQ08168.npy +imgHQ14518.npy +imgHQ09730.npy +imgHQ20174.npy +imgHQ20749.npy +imgHQ00983.npy +imgHQ00071.npy +imgHQ08092.npy +imgHQ19385.npy +imgHQ25163.npy +imgHQ14805.npy +imgHQ09266.npy +imgHQ16033.npy +imgHQ08955.npy +imgHQ25856.npy +imgHQ24689.npy +imgHQ25976.npy +imgHQ07318.npy +imgHQ18237.npy +imgHQ03480.npy +imgHQ04208.npy +imgHQ15158.npy +imgHQ16142.npy +imgHQ03329.npy +imgHQ24669.npy +imgHQ02105.npy +imgHQ19691.npy +imgHQ02140.npy +imgHQ29428.npy +imgHQ07538.npy +imgHQ24535.npy +imgHQ04590.npy +imgHQ13849.npy +imgHQ19877.npy +imgHQ11678.npy +imgHQ13495.npy +imgHQ15748.npy +imgHQ27019.npy +imgHQ14052.npy +imgHQ15513.npy +imgHQ17388.npy +imgHQ15013.npy +imgHQ17941.npy +imgHQ16141.npy +imgHQ02480.npy +imgHQ21427.npy +imgHQ09931.npy +imgHQ22165.npy +imgHQ00677.npy +imgHQ20169.npy +imgHQ27497.npy +imgHQ04720.npy +imgHQ22411.npy +imgHQ05027.npy +imgHQ11765.npy +imgHQ11636.npy +imgHQ07587.npy +imgHQ20403.npy +imgHQ10399.npy +imgHQ25149.npy +imgHQ19608.npy +imgHQ10236.npy +imgHQ28843.npy +imgHQ10253.npy +imgHQ24656.npy +imgHQ21842.npy +imgHQ19518.npy +imgHQ26069.npy +imgHQ10223.npy +imgHQ07720.npy +imgHQ27532.npy +imgHQ15424.npy +imgHQ18899.npy +imgHQ06216.npy +imgHQ15028.npy +imgHQ29987.npy +imgHQ00426.npy +imgHQ04683.npy +imgHQ13960.npy +imgHQ29020.npy +imgHQ06428.npy +imgHQ28577.npy +imgHQ28480.npy +imgHQ29807.npy +imgHQ14969.npy +imgHQ14705.npy +imgHQ13519.npy +imgHQ24813.npy +imgHQ00999.npy +imgHQ05771.npy +imgHQ15838.npy +imgHQ18721.npy +imgHQ10087.npy +imgHQ00871.npy +imgHQ02534.npy +imgHQ20676.npy +imgHQ22336.npy +imgHQ12409.npy +imgHQ10401.npy +imgHQ05207.npy +imgHQ23072.npy +imgHQ02469.npy +imgHQ00777.npy +imgHQ17398.npy +imgHQ00788.npy +imgHQ14682.npy +imgHQ26887.npy +imgHQ01737.npy +imgHQ06886.npy +imgHQ22198.npy +imgHQ15737.npy +imgHQ11029.npy +imgHQ16513.npy +imgHQ13575.npy +imgHQ08996.npy +imgHQ18089.npy +imgHQ06308.npy +imgHQ28012.npy +imgHQ04146.npy +imgHQ04323.npy +imgHQ03087.npy +imgHQ03688.npy +imgHQ29055.npy +imgHQ15202.npy +imgHQ24118.npy +imgHQ05735.npy +imgHQ26162.npy +imgHQ27092.npy +imgHQ18846.npy +imgHQ06061.npy +imgHQ02655.npy +imgHQ22844.npy +imgHQ02391.npy +imgHQ13945.npy +imgHQ29734.npy +imgHQ28103.npy +imgHQ01248.npy +imgHQ23481.npy +imgHQ29837.npy +imgHQ11755.npy +imgHQ06253.npy +imgHQ16897.npy +imgHQ02859.npy +imgHQ15371.npy +imgHQ26840.npy +imgHQ07749.npy +imgHQ28387.npy +imgHQ20496.npy +imgHQ11744.npy +imgHQ15275.npy +imgHQ23526.npy +imgHQ29408.npy +imgHQ28338.npy +imgHQ06324.npy +imgHQ03795.npy +imgHQ29176.npy +imgHQ12032.npy +imgHQ02668.npy +imgHQ02832.npy +imgHQ01822.npy +imgHQ07889.npy +imgHQ19636.npy +imgHQ04601.npy +imgHQ11683.npy +imgHQ08580.npy +imgHQ05000.npy +imgHQ23113.npy +imgHQ21085.npy +imgHQ07027.npy +imgHQ01965.npy +imgHQ19041.npy +imgHQ08683.npy +imgHQ00338.npy +imgHQ04454.npy +imgHQ01553.npy +imgHQ23185.npy +imgHQ28566.npy +imgHQ19565.npy +imgHQ29025.npy +imgHQ19625.npy +imgHQ15428.npy +imgHQ12906.npy +imgHQ16468.npy +imgHQ15002.npy +imgHQ07789.npy +imgHQ00217.npy +imgHQ07656.npy +imgHQ28750.npy +imgHQ07805.npy +imgHQ00542.npy +imgHQ13317.npy +imgHQ15869.npy +imgHQ19211.npy +imgHQ07568.npy +imgHQ28554.npy +imgHQ11357.npy +imgHQ07505.npy +imgHQ13021.npy +imgHQ06469.npy +imgHQ16982.npy +imgHQ19178.npy +imgHQ21781.npy +imgHQ27794.npy +imgHQ20617.npy +imgHQ17099.npy +imgHQ21820.npy +imgHQ02540.npy +imgHQ25609.npy +imgHQ03193.npy +imgHQ11162.npy +imgHQ15823.npy +imgHQ24808.npy +imgHQ27852.npy +imgHQ04107.npy +imgHQ11672.npy +imgHQ24721.npy +imgHQ11783.npy +imgHQ26303.npy +imgHQ07480.npy +imgHQ22912.npy +imgHQ20421.npy +imgHQ25868.npy +imgHQ09443.npy +imgHQ29048.npy +imgHQ10679.npy +imgHQ15335.npy +imgHQ04808.npy +imgHQ09572.npy +imgHQ16846.npy +imgHQ17534.npy +imgHQ16560.npy +imgHQ28089.npy +imgHQ10036.npy +imgHQ02726.npy +imgHQ07768.npy +imgHQ28711.npy +imgHQ12336.npy +imgHQ22115.npy +imgHQ23485.npy +imgHQ12940.npy +imgHQ22859.npy +imgHQ26080.npy +imgHQ05287.npy +imgHQ01356.npy +imgHQ28556.npy +imgHQ06347.npy +imgHQ09430.npy +imgHQ27303.npy +imgHQ23844.npy +imgHQ24611.npy +imgHQ09686.npy +imgHQ11815.npy +imgHQ13578.npy +imgHQ00250.npy +imgHQ14908.npy +imgHQ27325.npy +imgHQ12003.npy +imgHQ27697.npy +imgHQ29594.npy +imgHQ18526.npy +imgHQ22163.npy +imgHQ09563.npy +imgHQ05431.npy +imgHQ00735.npy +imgHQ17037.npy +imgHQ00980.npy +imgHQ06671.npy +imgHQ07895.npy +imgHQ05271.npy +imgHQ06773.npy +imgHQ19582.npy +imgHQ17336.npy +imgHQ00027.npy +imgHQ08696.npy +imgHQ06780.npy +imgHQ11478.npy +imgHQ18447.npy +imgHQ11098.npy +imgHQ16230.npy +imgHQ14537.npy +imgHQ16735.npy +imgHQ19652.npy +imgHQ06806.npy +imgHQ20269.npy +imgHQ22356.npy +imgHQ14251.npy +imgHQ01525.npy +imgHQ01430.npy +imgHQ26085.npy +imgHQ08139.npy +imgHQ15170.npy +imgHQ18827.npy +imgHQ21745.npy +imgHQ25138.npy +imgHQ13619.npy +imgHQ17823.npy +imgHQ09120.npy +imgHQ29174.npy +imgHQ16833.npy +imgHQ01338.npy +imgHQ08054.npy +imgHQ29328.npy +imgHQ18538.npy +imgHQ01947.npy +imgHQ24925.npy +imgHQ24283.npy +imgHQ04570.npy +imgHQ19913.npy +imgHQ19175.npy +imgHQ02447.npy +imgHQ05350.npy +imgHQ28219.npy +imgHQ08973.npy +imgHQ29608.npy +imgHQ00260.npy +imgHQ01273.npy +imgHQ23298.npy +imgHQ26204.npy +imgHQ21749.npy +imgHQ10953.npy +imgHQ02735.npy +imgHQ28222.npy +imgHQ06094.npy +imgHQ15079.npy +imgHQ19116.npy +imgHQ12682.npy +imgHQ04881.npy +imgHQ09540.npy +imgHQ21023.npy +imgHQ07450.npy +imgHQ27872.npy +imgHQ08380.npy +imgHQ23539.npy +imgHQ18608.npy +imgHQ01149.npy +imgHQ25091.npy +imgHQ04377.npy +imgHQ11110.npy +imgHQ03924.npy +imgHQ16715.npy +imgHQ13365.npy +imgHQ19272.npy +imgHQ02658.npy +imgHQ12401.npy +imgHQ02358.npy +imgHQ25563.npy +imgHQ17156.npy +imgHQ12946.npy +imgHQ24369.npy +imgHQ15252.npy +imgHQ02097.npy +imgHQ18700.npy +imgHQ26517.npy +imgHQ16236.npy +imgHQ19354.npy +imgHQ06890.npy +imgHQ15826.npy +imgHQ01696.npy +imgHQ10727.npy +imgHQ05962.npy +imgHQ04347.npy +imgHQ19708.npy +imgHQ28174.npy +imgHQ05627.npy +imgHQ08929.npy +imgHQ18960.npy +imgHQ00884.npy +imgHQ12139.npy +imgHQ03686.npy +imgHQ15134.npy +imgHQ02719.npy +imgHQ13801.npy +imgHQ20737.npy +imgHQ29251.npy +imgHQ23545.npy +imgHQ17005.npy +imgHQ04925.npy +imgHQ19595.npy +imgHQ11338.npy +imgHQ03585.npy +imgHQ21152.npy +imgHQ12625.npy +imgHQ14603.npy +imgHQ15366.npy +imgHQ09909.npy +imgHQ25007.npy +imgHQ13200.npy +imgHQ00674.npy +imgHQ28454.npy +imgHQ23013.npy +imgHQ06759.npy +imgHQ27644.npy +imgHQ08351.npy +imgHQ02404.npy +imgHQ00591.npy +imgHQ17924.npy +imgHQ03702.npy +imgHQ27826.npy +imgHQ21980.npy +imgHQ09452.npy +imgHQ08496.npy +imgHQ17876.npy +imgHQ16220.npy +imgHQ03558.npy +imgHQ10564.npy +imgHQ23451.npy +imgHQ23088.npy +imgHQ15472.npy +imgHQ28199.npy +imgHQ26418.npy +imgHQ22497.npy +imgHQ25261.npy +imgHQ20753.npy +imgHQ09188.npy +imgHQ01231.npy +imgHQ05857.npy +imgHQ27652.npy +imgHQ15556.npy +imgHQ26108.npy +imgHQ20906.npy +imgHQ22922.npy +imgHQ22281.npy +imgHQ12561.npy +imgHQ20395.npy +imgHQ28624.npy +imgHQ11221.npy +imgHQ06456.npy +imgHQ04489.npy +imgHQ02619.npy +imgHQ18395.npy +imgHQ10388.npy +imgHQ18510.npy +imgHQ23115.npy +imgHQ08780.npy +imgHQ18312.npy +imgHQ08828.npy +imgHQ24739.npy +imgHQ14447.npy +imgHQ07440.npy +imgHQ06220.npy +imgHQ22658.npy +imgHQ11052.npy +imgHQ29966.npy +imgHQ07798.npy +imgHQ00606.npy +imgHQ11923.npy +imgHQ06345.npy +imgHQ15322.npy +imgHQ21989.npy +imgHQ07901.npy +imgHQ07580.npy +imgHQ23942.npy +imgHQ21426.npy +imgHQ12334.npy +imgHQ27810.npy +imgHQ13855.npy +imgHQ03368.npy +imgHQ22119.npy +imgHQ08486.npy +imgHQ28217.npy +imgHQ20133.npy +imgHQ23885.npy +imgHQ05315.npy +imgHQ23325.npy +imgHQ09881.npy +imgHQ24161.npy +imgHQ00428.npy +imgHQ20722.npy +imgHQ10777.npy +imgHQ00976.npy +imgHQ02241.npy +imgHQ04553.npy +imgHQ05689.npy +imgHQ01784.npy +imgHQ19284.npy +imgHQ08255.npy +imgHQ04117.npy +imgHQ09814.npy +imgHQ21932.npy +imgHQ19826.npy +imgHQ18513.npy +imgHQ07162.npy +imgHQ28529.npy +imgHQ01148.npy +imgHQ08959.npy +imgHQ01459.npy +imgHQ29286.npy +imgHQ28847.npy +imgHQ03943.npy +imgHQ27081.npy +imgHQ01707.npy +imgHQ21468.npy +imgHQ12166.npy +imgHQ29980.npy +imgHQ24275.npy +imgHQ07120.npy +imgHQ18918.npy +imgHQ01448.npy +imgHQ11179.npy +imgHQ26189.npy +imgHQ18091.npy +imgHQ02472.npy +imgHQ12120.npy +imgHQ20539.npy +imgHQ17800.npy +imgHQ27328.npy +imgHQ11710.npy +imgHQ24812.npy +imgHQ03294.npy +imgHQ15512.npy +imgHQ22003.npy +imgHQ20758.npy +imgHQ04901.npy +imgHQ09151.npy +imgHQ24205.npy +imgHQ08933.npy +imgHQ17044.npy +imgHQ08476.npy +imgHQ22218.npy +imgHQ29515.npy +imgHQ12879.npy +imgHQ04269.npy +imgHQ28935.npy +imgHQ14685.npy +imgHQ14837.npy +imgHQ27874.npy +imgHQ16613.npy +imgHQ07418.npy +imgHQ20513.npy +imgHQ28471.npy +imgHQ00009.npy +imgHQ23611.npy +imgHQ08018.npy +imgHQ03734.npy +imgHQ06321.npy +imgHQ23823.npy +imgHQ05451.npy +imgHQ28574.npy +imgHQ14166.npy +imgHQ21655.npy +imgHQ13736.npy +imgHQ13304.npy +imgHQ19606.npy +imgHQ08413.npy +imgHQ04724.npy +imgHQ25232.npy +imgHQ05366.npy +imgHQ00597.npy +imgHQ09790.npy +imgHQ22293.npy +imgHQ02647.npy +imgHQ07495.npy +imgHQ29858.npy +imgHQ07132.npy +imgHQ00164.npy +imgHQ29803.npy +imgHQ27784.npy +imgHQ19852.npy +imgHQ00531.npy +imgHQ04305.npy +imgHQ16976.npy +imgHQ01481.npy +imgHQ18155.npy +imgHQ26900.npy +imgHQ17806.npy +imgHQ23514.npy +imgHQ23887.npy +imgHQ01950.npy +imgHQ17009.npy +imgHQ19264.npy +imgHQ18019.npy +imgHQ20770.npy +imgHQ04186.npy +imgHQ23710.npy +imgHQ21440.npy +imgHQ26232.npy +imgHQ28846.npy +imgHQ29816.npy +imgHQ20828.npy +imgHQ28758.npy +imgHQ11685.npy +imgHQ12369.npy +imgHQ23828.npy +imgHQ21433.npy +imgHQ29141.npy +imgHQ20544.npy +imgHQ13716.npy +imgHQ23769.npy +imgHQ20679.npy +imgHQ24072.npy +imgHQ09900.npy +imgHQ16741.npy +imgHQ01821.npy +imgHQ12573.npy +imgHQ16163.npy +imgHQ01271.npy +imgHQ02084.npy +imgHQ11391.npy +imgHQ08217.npy +imgHQ05161.npy +imgHQ06785.npy +imgHQ04660.npy +imgHQ16983.npy +imgHQ24816.npy +imgHQ07855.npy +imgHQ16918.npy +imgHQ05844.npy +imgHQ01899.npy +imgHQ03074.npy +imgHQ01079.npy +imgHQ21895.npy +imgHQ28915.npy +imgHQ05068.npy +imgHQ08383.npy +imgHQ05384.npy +imgHQ11440.npy +imgHQ26833.npy +imgHQ06412.npy +imgHQ27070.npy +imgHQ20464.npy +imgHQ08081.npy +imgHQ06828.npy +imgHQ03512.npy +imgHQ03261.npy +imgHQ29430.npy +imgHQ20743.npy +imgHQ22558.npy +imgHQ24752.npy +imgHQ15503.npy +imgHQ14394.npy +imgHQ01799.npy +imgHQ11533.npy +imgHQ00387.npy +imgHQ15890.npy +imgHQ11358.npy +imgHQ05351.npy +imgHQ24057.npy +imgHQ19538.npy +imgHQ12569.npy +imgHQ05449.npy +imgHQ29712.npy +imgHQ16657.npy +imgHQ15164.npy +imgHQ19103.npy +imgHQ23056.npy +imgHQ15162.npy +imgHQ20628.npy +imgHQ18310.npy +imgHQ28367.npy +imgHQ13995.npy +imgHQ14120.npy +imgHQ09886.npy +imgHQ19885.npy +imgHQ20318.npy +imgHQ18191.npy +imgHQ19198.npy +imgHQ24668.npy +imgHQ00290.npy +imgHQ29445.npy +imgHQ21579.npy +imgHQ16324.npy +imgHQ17362.npy +imgHQ08443.npy +imgHQ19477.npy +imgHQ04428.npy +imgHQ07227.npy +imgHQ01913.npy +imgHQ05442.npy +imgHQ25199.npy +imgHQ19320.npy +imgHQ00863.npy +imgHQ26090.npy +imgHQ18238.npy +imgHQ13915.npy +imgHQ09142.npy +imgHQ03137.npy +imgHQ23734.npy +imgHQ05682.npy +imgHQ20930.npy +imgHQ02872.npy +imgHQ09662.npy +imgHQ21220.npy +imgHQ04074.npy +imgHQ14955.npy +imgHQ17473.npy +imgHQ16267.npy +imgHQ05266.npy +imgHQ16175.npy +imgHQ26261.npy +imgHQ17545.npy +imgHQ23328.npy +imgHQ07233.npy +imgHQ19590.npy +imgHQ20322.npy +imgHQ27829.npy +imgHQ15822.npy +imgHQ12072.npy +imgHQ13467.npy +imgHQ13636.npy +imgHQ15063.npy +imgHQ07962.npy +imgHQ00006.npy +imgHQ04277.npy +imgHQ00154.npy +imgHQ19437.npy +imgHQ09891.npy +imgHQ29619.npy +imgHQ14208.npy +imgHQ03741.npy +imgHQ24894.npy +imgHQ15299.npy +imgHQ24105.npy +imgHQ15298.npy +imgHQ16902.npy +imgHQ03703.npy +imgHQ26212.npy +imgHQ24331.npy +imgHQ17764.npy +imgHQ13862.npy +imgHQ16979.npy +imgHQ10676.npy +imgHQ19372.npy +imgHQ23359.npy +imgHQ13258.npy +imgHQ09210.npy +imgHQ01080.npy +imgHQ19761.npy +imgHQ00553.npy +imgHQ19659.npy +imgHQ25510.npy +imgHQ21068.npy +imgHQ29206.npy +imgHQ09003.npy +imgHQ01595.npy +imgHQ21999.npy +imgHQ25880.npy +imgHQ18129.npy +imgHQ12605.npy +imgHQ23682.npy +imgHQ10891.npy +imgHQ10941.npy +imgHQ28143.npy +imgHQ23033.npy +imgHQ22059.npy +imgHQ16534.npy +imgHQ16648.npy +imgHQ22190.npy +imgHQ15026.npy +imgHQ25886.npy +imgHQ10339.npy +imgHQ27572.npy +imgHQ04956.npy +imgHQ08603.npy +imgHQ22278.npy +imgHQ20058.npy +imgHQ20071.npy +imgHQ02558.npy +imgHQ16645.npy +imgHQ04341.npy +imgHQ13314.npy +imgHQ23993.npy +imgHQ20821.npy +imgHQ20910.npy +imgHQ04694.npy +imgHQ06355.npy +imgHQ11223.npy +imgHQ19797.npy +imgHQ27611.npy +imgHQ24422.npy +imgHQ27692.npy +imgHQ13551.npy +imgHQ03807.npy +imgHQ01457.npy +imgHQ06066.npy +imgHQ13107.npy +imgHQ22251.npy +imgHQ00134.npy +imgHQ14373.npy +imgHQ13202.npy +imgHQ25778.npy +imgHQ09102.npy +imgHQ10234.npy +imgHQ16539.npy +imgHQ04115.npy +imgHQ12236.npy +imgHQ00808.npy +imgHQ05561.npy +imgHQ23046.npy +imgHQ22213.npy +imgHQ12570.npy +imgHQ19108.npy +imgHQ29658.npy +imgHQ22241.npy +imgHQ17750.npy +imgHQ05965.npy +imgHQ03505.npy +imgHQ10796.npy +imgHQ03787.npy +imgHQ27664.npy +imgHQ00804.npy +imgHQ06811.npy +imgHQ05891.npy +imgHQ14718.npy +imgHQ18117.npy +imgHQ23488.npy +imgHQ03557.npy +imgHQ16967.npy +imgHQ20305.npy +imgHQ28253.npy +imgHQ16994.npy +imgHQ24921.npy +imgHQ00467.npy +imgHQ27450.npy +imgHQ06079.npy +imgHQ22928.npy +imgHQ19292.npy +imgHQ24574.npy +imgHQ18349.npy +imgHQ29449.npy +imgHQ08516.npy +imgHQ05417.npy +imgHQ11306.npy +imgHQ18920.npy +imgHQ24835.npy +imgHQ16906.npy +imgHQ10492.npy +imgHQ17895.npy +imgHQ23883.npy +imgHQ13447.npy +imgHQ09236.npy +imgHQ15176.npy +imgHQ17841.npy +imgHQ22642.npy +imgHQ18202.npy +imgHQ07599.npy +imgHQ23094.npy +imgHQ01422.npy +imgHQ20148.npy +imgHQ23973.npy +imgHQ21201.npy +imgHQ22914.npy +imgHQ05393.npy +imgHQ26873.npy +imgHQ01729.npy +imgHQ07497.npy +imgHQ24004.npy +imgHQ22841.npy +imgHQ11827.npy +imgHQ07563.npy +imgHQ06348.npy +imgHQ01726.npy +imgHQ15586.npy +imgHQ08176.npy +imgHQ15982.npy +imgHQ13477.npy +imgHQ05066.npy +imgHQ26442.npy +imgHQ03276.npy +imgHQ25872.npy +imgHQ28052.npy +imgHQ12932.npy +imgHQ02784.npy +imgHQ09820.npy +imgHQ24513.npy +imgHQ00982.npy +imgHQ27257.npy +imgHQ03984.npy +imgHQ05883.npy +imgHQ16085.npy +imgHQ13053.npy +imgHQ18584.npy +imgHQ04120.npy +imgHQ25913.npy +imgHQ07727.npy +imgHQ05078.npy +imgHQ06884.npy +imgHQ14629.npy +imgHQ05974.npy +imgHQ28678.npy +imgHQ28013.npy +imgHQ20576.npy +imgHQ22214.npy +imgHQ03128.npy +imgHQ13810.npy +imgHQ00289.npy +imgHQ29696.npy +imgHQ24206.npy +imgHQ23561.npy +imgHQ03980.npy +imgHQ25024.npy +imgHQ28722.npy +imgHQ27370.npy +imgHQ22696.npy +imgHQ03084.npy +imgHQ06258.npy +imgHQ14938.npy +imgHQ04976.npy +imgHQ14021.npy +imgHQ23408.npy +imgHQ00895.npy +imgHQ28749.npy +imgHQ01425.npy +imgHQ09061.npy +imgHQ21894.npy +imgHQ24777.npy +imgHQ20921.npy +imgHQ15489.npy +imgHQ23492.npy +imgHQ20933.npy +imgHQ05340.npy +imgHQ03575.npy +imgHQ10127.npy +imgHQ12698.npy +imgHQ18681.npy +imgHQ19862.npy +imgHQ08796.npy +imgHQ19407.npy +imgHQ20068.npy +imgHQ20567.npy +imgHQ03180.npy +imgHQ10225.npy +imgHQ22697.npy +imgHQ25457.npy +imgHQ22816.npy +imgHQ18825.npy +imgHQ18632.npy +imgHQ12234.npy +imgHQ16184.npy +imgHQ19118.npy +imgHQ15214.npy +imgHQ06055.npy +imgHQ15163.npy +imgHQ21216.npy +imgHQ08757.npy +imgHQ02143.npy +imgHQ02756.npy +imgHQ21290.npy +imgHQ27734.npy +imgHQ29718.npy +imgHQ25908.npy +imgHQ13411.npy +imgHQ01061.npy +imgHQ25214.npy +imgHQ28746.npy +imgHQ14757.npy +imgHQ03950.npy +imgHQ17746.npy +imgHQ26332.npy +imgHQ29679.npy +imgHQ20843.npy +imgHQ06218.npy +imgHQ00645.npy +imgHQ11102.npy +imgHQ03711.npy +imgHQ28018.npy +imgHQ23516.npy +imgHQ18014.npy +imgHQ08583.npy +imgHQ02470.npy +imgHQ10111.npy +imgHQ09212.npy +imgHQ14372.npy +imgHQ07177.npy +imgHQ17933.npy +imgHQ10918.npy +imgHQ23353.npy +imgHQ27334.npy +imgHQ04195.npy +imgHQ16521.npy +imgHQ06400.npy +imgHQ24505.npy +imgHQ18789.npy +imgHQ02997.npy +imgHQ22809.npy +imgHQ25391.npy +imgHQ02295.npy +imgHQ10202.npy +imgHQ26647.npy +imgHQ14893.npy +imgHQ25742.npy +imgHQ08755.npy +imgHQ29614.npy +imgHQ14871.npy +imgHQ16852.npy +imgHQ15690.npy +imgHQ02670.npy +imgHQ11730.npy +imgHQ20729.npy +imgHQ14203.npy +imgHQ12292.npy +imgHQ26608.npy +imgHQ27202.npy +imgHQ20334.npy +imgHQ00533.npy +imgHQ23419.npy +imgHQ28452.npy +imgHQ18126.npy +imgHQ02975.npy +imgHQ26500.npy +imgHQ20074.npy +imgHQ19749.npy +imgHQ15672.npy +imgHQ04994.npy +imgHQ14626.npy +imgHQ28715.npy +imgHQ25877.npy +imgHQ13321.npy +imgHQ05250.npy +imgHQ04939.npy +imgHQ03877.npy +imgHQ13102.npy +imgHQ04527.npy +imgHQ11763.npy +imgHQ08592.npy +imgHQ29676.npy +imgHQ04463.npy +imgHQ12662.npy +imgHQ22239.npy +imgHQ15923.npy +imgHQ07245.npy +imgHQ23034.npy +imgHQ28538.npy +imgHQ03555.npy +imgHQ07226.npy +imgHQ25209.npy +imgHQ22014.npy +imgHQ25776.npy +imgHQ14459.npy +imgHQ24104.npy +imgHQ21642.npy +imgHQ29361.npy +imgHQ24281.npy +imgHQ04643.npy +imgHQ15432.npy +imgHQ25427.npy +imgHQ23076.npy +imgHQ22561.npy +imgHQ01403.npy +imgHQ19614.npy +imgHQ22466.npy +imgHQ21422.npy +imgHQ16740.npy +imgHQ28504.npy +imgHQ11181.npy +imgHQ25033.npy +imgHQ04625.npy +imgHQ25217.npy +imgHQ20554.npy +imgHQ29783.npy +imgHQ13002.npy +imgHQ12486.npy +imgHQ24603.npy +imgHQ27645.npy +imgHQ15532.npy +imgHQ03332.npy +imgHQ14625.npy +imgHQ10428.npy +imgHQ15871.npy +imgHQ26043.npy +imgHQ19566.npy +imgHQ11296.npy +imgHQ24068.npy +imgHQ20950.npy +imgHQ26217.npy +imgHQ07315.npy +imgHQ09624.npy +imgHQ01927.npy +imgHQ24767.npy +imgHQ07605.npy +imgHQ27763.npy +imgHQ17575.npy +imgHQ29326.npy +imgHQ04981.npy +imgHQ13048.npy +imgHQ15113.npy +imgHQ25523.npy +imgHQ03259.npy +imgHQ11139.npy +imgHQ24542.npy +imgHQ18647.npy +imgHQ16960.npy +imgHQ00453.npy +imgHQ22428.npy +imgHQ12953.npy +imgHQ28120.npy +imgHQ28867.npy +imgHQ16862.npy +imgHQ03075.npy +imgHQ23681.npy +imgHQ03516.npy +imgHQ13603.npy +imgHQ16295.npy +imgHQ01147.npy +imgHQ18839.npy +imgHQ23132.npy +imgHQ09734.npy +imgHQ29001.npy +imgHQ26433.npy +imgHQ29547.npy +imgHQ17346.npy +imgHQ06068.npy +imgHQ03026.npy +imgHQ17946.npy +imgHQ20693.npy +imgHQ04396.npy +imgHQ09105.npy +imgHQ26917.npy +imgHQ14562.npy +imgHQ23466.npy +imgHQ16864.npy +imgHQ07174.npy +imgHQ12272.npy +imgHQ18975.npy +imgHQ17603.npy +imgHQ14255.npy +imgHQ18056.npy +imgHQ01261.npy +imgHQ28070.npy +imgHQ18998.npy +imgHQ02305.npy +imgHQ11163.npy +imgHQ08843.npy +imgHQ21682.npy +imgHQ26776.npy +imgHQ15102.npy +imgHQ20744.npy +imgHQ03257.npy +imgHQ01071.npy +imgHQ24692.npy +imgHQ14546.npy +imgHQ07212.npy +imgHQ27508.npy +imgHQ09580.npy +imgHQ06294.npy +imgHQ01734.npy +imgHQ09830.npy +imgHQ20033.npy +imgHQ06140.npy +imgHQ20491.npy +imgHQ09744.npy +imgHQ16777.npy +imgHQ24049.npy +imgHQ12591.npy +imgHQ28916.npy +imgHQ10761.npy +imgHQ11121.npy +imgHQ01432.npy +imgHQ17119.npy +imgHQ17110.npy +imgHQ23216.npy +imgHQ12310.npy +imgHQ28225.npy +imgHQ27568.npy +imgHQ17521.npy +imgHQ18550.npy +imgHQ17027.npy +imgHQ10411.npy +imgHQ28385.npy +imgHQ13404.npy +imgHQ21917.npy +imgHQ12628.npy +imgHQ12695.npy +imgHQ18464.npy +imgHQ06851.npy +imgHQ14953.npy +imgHQ04451.npy +imgHQ05103.npy +imgHQ16985.npy +imgHQ09927.npy +imgHQ23125.npy +imgHQ19184.npy +imgHQ29424.npy +imgHQ27663.npy +imgHQ09180.npy +imgHQ08126.npy +imgHQ00879.npy +imgHQ12990.npy +imgHQ18099.npy +imgHQ09403.npy +imgHQ23268.npy +imgHQ07442.npy +imgHQ10560.npy +imgHQ27777.npy +imgHQ01362.npy +imgHQ28097.npy +imgHQ13421.npy +imgHQ19766.npy +imgHQ08539.npy +imgHQ20310.npy +imgHQ05262.npy +imgHQ20887.npy +imgHQ06315.npy +imgHQ29432.npy +imgHQ05202.npy +imgHQ00548.npy +imgHQ17792.npy +imgHQ15245.npy +imgHQ09404.npy +imgHQ13605.npy +imgHQ28213.npy +imgHQ17799.npy +imgHQ26756.npy +imgHQ28379.npy +imgHQ20487.npy +imgHQ01226.npy +imgHQ17437.npy +imgHQ19239.npy +imgHQ16126.npy +imgHQ21418.npy +imgHQ16437.npy +imgHQ04385.npy +imgHQ20481.npy +imgHQ12970.npy +imgHQ27360.npy +imgHQ12145.npy +imgHQ06864.npy +imgHQ21193.npy +imgHQ07550.npy +imgHQ00435.npy +imgHQ12538.npy +imgHQ04996.npy +imgHQ16210.npy +imgHQ06484.npy +imgHQ05146.npy +imgHQ06763.npy +imgHQ17196.npy +imgHQ07500.npy +imgHQ08792.npy +imgHQ02343.npy +imgHQ29687.npy +imgHQ14901.npy +imgHQ14143.npy +imgHQ01494.npy +imgHQ06070.npy +imgHQ29194.npy +imgHQ27813.npy +imgHQ02881.npy +imgHQ00429.npy +imgHQ15392.npy +imgHQ23613.npy +imgHQ28084.npy +imgHQ12253.npy +imgHQ24840.npy +imgHQ14296.npy +imgHQ09055.npy +imgHQ20392.npy +imgHQ12066.npy +imgHQ23334.npy +imgHQ02249.npy +imgHQ24526.npy +imgHQ04573.npy +imgHQ27095.npy +imgHQ04250.npy +imgHQ16162.npy +imgHQ01477.npy +imgHQ06136.npy +imgHQ12505.npy +imgHQ24780.npy +imgHQ04030.npy +imgHQ14216.npy +imgHQ05967.npy +imgHQ21764.npy +imgHQ09973.npy +imgHQ17502.npy +imgHQ22472.npy +imgHQ25287.npy +imgHQ15303.npy +imgHQ19277.npy +imgHQ23267.npy +imgHQ14808.npy +imgHQ02114.npy +imgHQ07862.npy +imgHQ05694.npy +imgHQ23831.npy +imgHQ26226.npy +imgHQ02296.npy +imgHQ08972.npy +imgHQ16824.npy +imgHQ01566.npy +imgHQ22481.npy +imgHQ23119.npy +imgHQ21595.npy +imgHQ10541.npy +imgHQ12813.npy +imgHQ24479.npy +imgHQ20098.npy +imgHQ04247.npy +imgHQ22187.npy +imgHQ26725.npy +imgHQ01926.npy +imgHQ03049.npy +imgHQ02994.npy +imgHQ00157.npy +imgHQ26357.npy +imgHQ05092.npy +imgHQ11924.npy +imgHQ01685.npy +imgHQ01730.npy +imgHQ13334.npy +imgHQ28660.npy +imgHQ24569.npy +imgHQ16577.npy +imgHQ04091.npy +imgHQ12604.npy +imgHQ25086.npy +imgHQ21472.npy +imgHQ00358.npy +imgHQ08022.npy +imgHQ28061.npy +imgHQ29440.npy +imgHQ05476.npy +imgHQ06556.npy +imgHQ15891.npy +imgHQ12343.npy +imgHQ09101.npy +imgHQ14384.npy +imgHQ24388.npy +imgHQ09022.npy +imgHQ22504.npy +imgHQ03277.npy +imgHQ04540.npy +imgHQ01923.npy +imgHQ29121.npy +imgHQ23050.npy +imgHQ20097.npy +imgHQ14206.npy +imgHQ18376.npy +imgHQ28437.npy +imgHQ13652.npy +imgHQ27873.npy +imgHQ15121.npy +imgHQ13660.npy +imgHQ23677.npy +imgHQ15049.npy +imgHQ15204.npy +imgHQ03191.npy +imgHQ22197.npy +imgHQ09432.npy +imgHQ02351.npy +imgHQ20965.npy +imgHQ03548.npy +imgHQ06721.npy +imgHQ19232.npy +imgHQ16702.npy +imgHQ22256.npy +imgHQ09464.npy +imgHQ06382.npy +imgHQ08503.npy +imgHQ10553.npy +imgHQ15414.npy +imgHQ21322.npy +imgHQ12249.npy +imgHQ10176.npy +imgHQ00356.npy +imgHQ15460.npy +imgHQ29929.npy +imgHQ04262.npy +imgHQ16349.npy +imgHQ05114.npy +imgHQ01279.npy +imgHQ09023.npy +imgHQ06359.npy +imgHQ02634.npy +imgHQ10902.npy +imgHQ28751.npy +imgHQ17127.npy +imgHQ00797.npy +imgHQ24083.npy +imgHQ03380.npy +imgHQ21247.npy +imgHQ13583.npy +imgHQ23952.npy +imgHQ10280.npy +imgHQ27738.npy +imgHQ05719.npy +imgHQ21650.npy +imgHQ14069.npy +imgHQ03473.npy +imgHQ12896.npy +imgHQ29246.npy +imgHQ05209.npy +imgHQ24000.npy +imgHQ06085.npy +imgHQ04780.npy +imgHQ25484.npy +imgHQ00084.npy +imgHQ01848.npy +imgHQ20271.npy +imgHQ26488.npy +imgHQ24912.npy +imgHQ27053.npy +imgHQ16325.npy +imgHQ16016.npy +imgHQ04950.npy +imgHQ09583.npy +imgHQ16025.npy +imgHQ23224.npy +imgHQ14010.npy +imgHQ29811.npy +imgHQ28014.npy +imgHQ00986.npy +imgHQ07979.npy +imgHQ29739.npy +imgHQ16319.npy +imgHQ02737.npy +imgHQ26171.npy +imgHQ06454.npy +imgHQ08411.npy +imgHQ22294.npy +imgHQ18497.npy +imgHQ02484.npy +imgHQ27857.npy +imgHQ10445.npy +imgHQ25844.npy +imgHQ06326.npy +imgHQ14605.npy +imgHQ27047.npy +imgHQ11291.npy +imgHQ02738.npy +imgHQ16699.npy +imgHQ29699.npy +imgHQ22652.npy +imgHQ29976.npy +imgHQ24524.npy +imgHQ20188.npy +imgHQ05715.npy +imgHQ19285.npy +imgHQ18780.npy +imgHQ00221.npy +imgHQ15619.npy +imgHQ20349.npy +imgHQ22222.npy +imgHQ18161.npy +imgHQ17060.npy +imgHQ00384.npy +imgHQ21810.npy +imgHQ02636.npy +imgHQ27703.npy +imgHQ17244.npy +imgHQ25585.npy +imgHQ24191.npy +imgHQ05430.npy +imgHQ08123.npy +imgHQ07863.npy +imgHQ03430.npy +imgHQ20638.npy +imgHQ25857.npy +imgHQ26771.npy +imgHQ24254.npy +imgHQ17569.npy +imgHQ23017.npy +imgHQ05087.npy +imgHQ20985.npy +imgHQ14735.npy +imgHQ02523.npy +imgHQ21463.npy +imgHQ03815.npy +imgHQ29924.npy +imgHQ03253.npy +imgHQ04130.npy +imgHQ06414.npy +imgHQ08931.npy +imgHQ15769.npy +imgHQ07996.npy +imgHQ04361.npy +imgHQ09135.npy +imgHQ28710.npy +imgHQ03335.npy +imgHQ12241.npy +imgHQ08188.npy +imgHQ24143.npy +imgHQ20999.npy +imgHQ00077.npy +imgHQ10569.npy +imgHQ11599.npy +imgHQ21343.npy +imgHQ20203.npy +imgHQ07075.npy +imgHQ20052.npy +imgHQ14144.npy +imgHQ05166.npy +imgHQ08102.npy +imgHQ03677.npy +imgHQ28856.npy +imgHQ03207.npy +imgHQ18692.npy +imgHQ20417.npy +imgHQ01536.npy +imgHQ21084.npy +imgHQ26249.npy +imgHQ17896.npy +imgHQ14400.npy +imgHQ18205.npy +imgHQ18823.npy +imgHQ24224.npy +imgHQ28380.npy +imgHQ10108.npy +imgHQ12565.npy +imgHQ23979.npy +imgHQ03643.npy +imgHQ26939.npy +imgHQ18496.npy +imgHQ07904.npy +imgHQ05472.npy +imgHQ14403.npy +imgHQ20662.npy +imgHQ03365.npy +imgHQ10471.npy +imgHQ18208.npy +imgHQ01082.npy +imgHQ01773.npy +imgHQ29097.npy +imgHQ20708.npy +imgHQ06243.npy +imgHQ22174.npy +imgHQ11600.npy +imgHQ13761.npy +imgHQ09547.npy +imgHQ05364.npy +imgHQ29690.npy +imgHQ11668.npy +imgHQ04744.npy +imgHQ21408.npy +imgHQ01686.npy +imgHQ23218.npy +imgHQ05317.npy +imgHQ22305.npy +imgHQ00144.npy +imgHQ00939.npy +imgHQ10962.npy +imgHQ07242.npy +imgHQ06995.npy +imgHQ06648.npy +imgHQ29842.npy +imgHQ17872.npy +imgHQ08167.npy +imgHQ29153.npy +imgHQ16631.npy +imgHQ06331.npy +imgHQ01929.npy +imgHQ20192.npy +imgHQ04933.npy +imgHQ07250.npy +imgHQ29896.npy +imgHQ07886.npy +imgHQ23297.npy +imgHQ09661.npy +imgHQ25305.npy +imgHQ18198.npy +imgHQ20639.npy +imgHQ02022.npy +imgHQ15577.npy +imgHQ20112.npy +imgHQ06129.npy +imgHQ26353.npy +imgHQ25045.npy +imgHQ22708.npy +imgHQ10557.npy +imgHQ00916.npy +imgHQ18819.npy +imgHQ03897.npy +imgHQ08457.npy +imgHQ24235.npy +imgHQ20447.npy +imgHQ13158.npy +imgHQ21570.npy +imgHQ06694.npy +imgHQ01015.npy +imgHQ16838.npy +imgHQ25306.npy +imgHQ17587.npy +imgHQ02537.npy +imgHQ08875.npy +imgHQ13011.npy +imgHQ28510.npy +imgHQ00726.npy +imgHQ04819.npy +imgHQ25349.npy +imgHQ10658.npy +imgHQ08558.npy +imgHQ13972.npy +imgHQ28119.npy +imgHQ03424.npy +imgHQ04811.npy +imgHQ00143.npy +imgHQ28292.npy +imgHQ20519.npy +imgHQ07602.npy +imgHQ26695.npy +imgHQ29931.npy +imgHQ12526.npy +imgHQ19803.npy +imgHQ05959.npy +imgHQ08698.npy +imgHQ28836.npy +imgHQ02512.npy +imgHQ24963.npy +imgHQ20883.npy +imgHQ13340.npy +imgHQ25571.npy +imgHQ02011.npy +imgHQ09879.npy +imgHQ10340.npy +imgHQ22260.npy +imgHQ06301.npy +imgHQ05952.npy +imgHQ05920.npy +imgHQ12244.npy +imgHQ26089.npy +imgHQ28412.npy +imgHQ09559.npy +imgHQ08543.npy +imgHQ29627.npy +imgHQ09224.npy +imgHQ13540.npy +imgHQ18603.npy +imgHQ16692.npy +imgHQ16202.npy +imgHQ18668.npy +imgHQ03506.npy +imgHQ16264.npy +imgHQ28780.npy +imgHQ20105.npy +imgHQ18498.npy +imgHQ20868.npy +imgHQ03105.npy +imgHQ24589.npy +imgHQ26712.npy +imgHQ09752.npy +imgHQ17709.npy +imgHQ03654.npy +imgHQ26395.npy +imgHQ04204.npy +imgHQ08963.npy +imgHQ14101.npy +imgHQ16408.npy +imgHQ12018.npy +imgHQ15766.npy +imgHQ27027.npy +imgHQ03369.npy +imgHQ24968.npy +imgHQ23366.npy +imgHQ26720.npy +imgHQ01157.npy +imgHQ26743.npy +imgHQ07869.npy +imgHQ15197.npy +imgHQ07325.npy +imgHQ21262.npy +imgHQ25244.npy +imgHQ14847.npy +imgHQ28849.npy +imgHQ17205.npy +imgHQ04422.npy +imgHQ25050.npy +imgHQ01100.npy +imgHQ00621.npy +imgHQ17992.npy +imgHQ26075.npy +imgHQ18640.npy +imgHQ09508.npy +imgHQ15971.npy +imgHQ18719.npy +imgHQ24707.npy +imgHQ12101.npy +imgHQ17969.npy +imgHQ11996.npy +imgHQ01156.npy +imgHQ13953.npy +imgHQ14405.npy +imgHQ02983.npy +imgHQ15615.npy +imgHQ23446.npy +imgHQ13382.npy +imgHQ25178.npy +imgHQ08485.npy +imgHQ11592.npy +imgHQ06027.npy +imgHQ07648.npy +imgHQ21253.npy +imgHQ06001.npy +imgHQ05203.npy +imgHQ01845.npy +imgHQ24765.npy +imgHQ10059.npy +imgHQ08454.npy +imgHQ10811.npy +imgHQ06604.npy +imgHQ19153.npy +imgHQ21656.npy +imgHQ05314.npy +imgHQ02246.npy +imgHQ23152.npy +imgHQ06652.npy +imgHQ15234.npy +imgHQ24977.npy +imgHQ26690.npy +imgHQ16831.npy +imgHQ12487.npy +imgHQ14912.npy +imgHQ21465.npy +imgHQ24506.npy +imgHQ04324.npy +imgHQ29470.npy +imgHQ02415.npy +imgHQ01521.npy +imgHQ18209.npy +imgHQ28122.npy +imgHQ26270.npy +imgHQ22527.npy +imgHQ29043.npy +imgHQ02270.npy +imgHQ14318.npy +imgHQ06204.npy +imgHQ07758.npy +imgHQ03094.npy +imgHQ11444.npy +imgHQ02604.npy +imgHQ05455.npy +imgHQ07406.npy +imgHQ23520.npy +imgHQ25374.npy +imgHQ01691.npy +imgHQ17551.npy +imgHQ29925.npy +imgHQ19113.npy +imgHQ04070.npy +imgHQ11936.npy +imgHQ05651.npy +imgHQ25765.npy +imgHQ21732.npy +imgHQ17267.npy +imgHQ26871.npy +imgHQ03770.npy +imgHQ25350.npy +imgHQ07703.npy +imgHQ18177.npy +imgHQ27386.npy +imgHQ15137.npy +imgHQ26000.npy +imgHQ02694.npy +imgHQ14824.npy +imgHQ20809.npy +imgHQ27197.npy +imgHQ13718.npy +imgHQ16470.npy +imgHQ15383.npy +imgHQ29126.npy +imgHQ15680.npy +imgHQ29825.npy +imgHQ15246.npy +imgHQ22063.npy +imgHQ23156.npy +imgHQ23816.npy +imgHQ27495.npy +imgHQ28818.npy +imgHQ11013.npy +imgHQ15783.npy +imgHQ16082.npy +imgHQ05003.npy +imgHQ20235.npy +imgHQ25235.npy +imgHQ22142.npy +imgHQ20674.npy +imgHQ16916.npy +imgHQ14410.npy +imgHQ11505.npy +imgHQ06589.npy +imgHQ25388.npy +imgHQ28811.npy +imgHQ19291.npy +imgHQ01895.npy +imgHQ21500.npy +imgHQ07160.npy +imgHQ19503.npy +imgHQ12874.npy +imgHQ23417.npy +imgHQ17676.npy +imgHQ29875.npy +imgHQ15897.npy +imgHQ16497.npy +imgHQ21767.npy +imgHQ18704.npy +imgHQ10181.npy +imgHQ03258.npy +imgHQ04364.npy +imgHQ19281.npy +imgHQ09007.npy +imgHQ28150.npy +imgHQ15267.npy +imgHQ23651.npy +imgHQ08037.npy +imgHQ19856.npy +imgHQ07688.npy +imgHQ27711.npy +imgHQ02667.npy +imgHQ15681.npy +imgHQ24773.npy +imgHQ12477.npy +imgHQ28897.npy +imgHQ01121.npy +imgHQ22314.npy +imgHQ09932.npy +imgHQ17487.npy +imgHQ02229.npy +imgHQ06719.npy +imgHQ19752.npy +imgHQ11874.npy +imgHQ25959.npy +imgHQ20410.npy +imgHQ01348.npy +imgHQ16782.npy +imgHQ21679.npy +imgHQ24122.npy +imgHQ15726.npy +imgHQ02901.npy +imgHQ11229.npy +imgHQ23244.npy +imgHQ02807.npy +imgHQ17700.npy +imgHQ20535.npy +imgHQ08573.npy +imgHQ07328.npy +imgHQ23241.npy +imgHQ18102.npy +imgHQ20483.npy +imgHQ03302.npy +imgHQ24592.npy +imgHQ01552.npy +imgHQ04490.npy +imgHQ10525.npy +imgHQ13320.npy +imgHQ16336.npy +imgHQ15281.npy +imgHQ24007.npy +imgHQ26563.npy +imgHQ11916.npy +imgHQ09100.npy +imgHQ03464.npy +imgHQ05998.npy +imgHQ27066.npy +imgHQ18703.npy +imgHQ08328.npy +imgHQ18667.npy +imgHQ29498.npy +imgHQ13069.npy +imgHQ25918.npy +imgHQ19757.npy +imgHQ12148.npy +imgHQ28078.npy +imgHQ12147.npy +imgHQ22734.npy +imgHQ22207.npy +imgHQ11801.npy +imgHQ26406.npy +imgHQ12390.npy +imgHQ03554.npy +imgHQ24650.npy +imgHQ19193.npy +imgHQ22325.npy +imgHQ17804.npy +imgHQ00223.npy +imgHQ00786.npy +imgHQ26999.npy +imgHQ08473.npy +imgHQ02126.npy +imgHQ06111.npy +imgHQ13032.npy +imgHQ06378.npy +imgHQ18548.npy +imgHQ02645.npy +imgHQ18777.npy +imgHQ05108.npy +imgHQ11589.npy +imgHQ22799.npy +imgHQ26560.npy +imgHQ04047.npy +imgHQ11477.npy +imgHQ15300.npy +imgHQ01031.npy +imgHQ09287.npy +imgHQ24956.npy +imgHQ17614.npy +imgHQ00996.npy +imgHQ03109.npy +imgHQ15128.npy +imgHQ17274.npy +imgHQ23701.npy +imgHQ00958.npy +imgHQ06336.npy +imgHQ22853.npy +imgHQ20836.npy +imgHQ25518.npy +imgHQ05193.npy +imgHQ12461.npy +imgHQ20658.npy +imgHQ17717.npy +imgHQ22810.npy +imgHQ23380.npy +imgHQ08061.npy +imgHQ04300.npy +imgHQ19533.npy +imgHQ17158.npy +imgHQ02593.npy +imgHQ29478.npy +imgHQ29320.npy +imgHQ01195.npy +imgHQ01717.npy +imgHQ03749.npy +imgHQ22057.npy +imgHQ12073.npy +imgHQ14848.npy +imgHQ24791.npy +imgHQ12531.npy +imgHQ00541.npy +imgHQ03536.npy +imgHQ12420.npy +imgHQ26141.npy +imgHQ13100.npy +imgHQ05785.npy +imgHQ08308.npy +imgHQ11410.npy +imgHQ17226.npy +imgHQ11732.npy +imgHQ17533.npy +imgHQ01711.npy +imgHQ08567.npy +imgHQ26547.npy +imgHQ14488.npy +imgHQ12612.npy +imgHQ04304.npy +imgHQ06823.npy +imgHQ14371.npy +imgHQ06877.npy +imgHQ11490.npy +imgHQ05639.npy +imgHQ18874.npy +imgHQ03834.npy +imgHQ01740.npy +imgHQ19977.npy +imgHQ07150.npy +imgHQ28949.npy +imgHQ28675.npy +imgHQ17402.npy +imgHQ02862.npy +imgHQ04190.npy +imgHQ17257.npy +imgHQ10863.npy +imgHQ28100.npy +imgHQ27535.npy +imgHQ03043.npy +imgHQ16102.npy +imgHQ21497.npy +imgHQ16190.npy +imgHQ14878.npy +imgHQ10213.npy +imgHQ23618.npy +imgHQ13933.npy +imgHQ06610.npy +imgHQ23192.npy +imgHQ09774.npy +imgHQ22905.npy +imgHQ01444.npy +imgHQ23884.npy +imgHQ27815.npy +imgHQ26282.npy +imgHQ07047.npy +imgHQ24420.npy +imgHQ12982.npy +imgHQ08258.npy +imgHQ20648.npy +imgHQ27958.npy +imgHQ03173.npy +imgHQ28354.npy +imgHQ24215.npy +imgHQ09877.npy +imgHQ00782.npy +imgHQ22864.npy +imgHQ24932.npy +imgHQ26918.npy +imgHQ09659.npy +imgHQ27648.npy +imgHQ01181.npy +imgHQ26898.npy +imgHQ04167.npy +imgHQ17294.npy +imgHQ03733.npy +imgHQ13729.npy +imgHQ02951.npy +imgHQ01916.npy +imgHQ20660.npy +imgHQ19554.npy +imgHQ00062.npy +imgHQ25330.npy +imgHQ01003.npy +imgHQ28965.npy +imgHQ19629.npy +imgHQ05761.npy +imgHQ13695.npy +imgHQ16747.npy +imgHQ23786.npy +imgHQ18485.npy +imgHQ28269.npy +imgHQ21694.npy +imgHQ18031.npy +imgHQ26968.npy +imgHQ28138.npy +imgHQ09780.npy +imgHQ08907.npy +imgHQ16718.npy +imgHQ02672.npy +imgHQ21260.npy +imgHQ15445.npy +imgHQ01560.npy +imgHQ13113.npy +imgHQ16491.npy +imgHQ20775.npy +imgHQ01516.npy +imgHQ18724.npy +imgHQ00390.npy +imgHQ26113.npy +imgHQ23257.npy +imgHQ08194.npy +imgHQ17270.npy +imgHQ04394.npy +imgHQ13480.npy +imgHQ09294.npy +imgHQ07506.npy +imgHQ24880.npy +imgHQ07381.npy +imgHQ15157.npy +imgHQ14806.npy +imgHQ17926.npy +imgHQ05534.npy +imgHQ07791.npy +imgHQ01102.npy +imgHQ21087.npy +imgHQ02157.npy +imgHQ08702.npy +imgHQ03923.npy +imgHQ04067.npy +imgHQ26718.npy +imgHQ12884.npy +imgHQ00176.npy +imgHQ01674.npy +imgHQ01366.npy +imgHQ02117.npy +imgHQ11612.npy +imgHQ01882.npy +imgHQ20048.npy +imgHQ15083.npy +imgHQ05218.npy +imgHQ06996.npy +imgHQ23221.npy +imgHQ26276.npy +imgHQ02479.npy +imgHQ29731.npy +imgHQ07678.npy +imgHQ12119.npy +imgHQ24992.npy +imgHQ24376.npy +imgHQ11204.npy +imgHQ19349.npy +imgHQ05564.npy +imgHQ02463.npy +imgHQ01819.npy +imgHQ23213.npy +imgHQ10212.npy +imgHQ28490.npy +imgHQ24753.npy +imgHQ10459.npy +imgHQ17540.npy +imgHQ08489.npy +imgHQ00654.npy +imgHQ17557.npy +imgHQ13325.npy +imgHQ05494.npy +imgHQ00775.npy +imgHQ20252.npy +imgHQ15645.npy +imgHQ27380.npy +imgHQ02289.npy +imgHQ17330.npy +imgHQ27468.npy +imgHQ14317.npy +imgHQ04332.npy +imgHQ12445.npy +imgHQ05155.npy +imgHQ09002.npy +imgHQ16516.npy +imgHQ06959.npy +imgHQ15908.npy +imgHQ11183.npy +imgHQ04778.npy +imgHQ28541.npy +imgHQ12219.npy +imgHQ06395.npy +imgHQ00299.npy +imgHQ18080.npy +imgHQ05982.npy +imgHQ04504.npy +imgHQ06696.npy +imgHQ11822.npy +imgHQ23889.npy +imgHQ23632.npy +imgHQ24772.npy +imgHQ06666.npy +imgHQ02291.npy +imgHQ08430.npy +imgHQ10027.npy +imgHQ25282.npy +imgHQ05936.npy +imgHQ13395.npy +imgHQ13864.npy +imgHQ26209.npy +imgHQ21502.npy +imgHQ14064.npy +imgHQ27221.npy +imgHQ00191.npy +imgHQ13013.npy +imgHQ29488.npy +imgHQ00344.npy +imgHQ29916.npy +imgHQ22836.npy +imgHQ22044.npy +imgHQ08311.npy +imgHQ12996.npy +imgHQ15470.npy +imgHQ08133.npy +imgHQ15604.npy +imgHQ14779.npy +imgHQ08669.npy +imgHQ24605.npy +imgHQ07206.npy +imgHQ05620.npy +imgHQ25501.npy +imgHQ10950.npy +imgHQ00377.npy +imgHQ21111.npy +imgHQ07421.npy +imgHQ05589.npy +imgHQ22520.npy +imgHQ04343.npy +imgHQ01534.npy +imgHQ14932.npy +imgHQ19882.npy +imgHQ01967.npy +imgHQ09588.npy +imgHQ22085.npy +imgHQ17556.npy +imgHQ29054.npy +imgHQ25531.npy +imgHQ17091.npy +imgHQ26657.npy +imgHQ03538.npy +imgHQ23114.npy +imgHQ02641.npy +imgHQ11628.npy +imgHQ23797.npy +imgHQ27876.npy +imgHQ17967.npy +imgHQ29631.npy +imgHQ24844.npy +imgHQ03859.npy +imgHQ09654.npy +imgHQ24197.npy +imgHQ03288.npy +imgHQ14957.npy +imgHQ16814.npy +imgHQ23081.npy +imgHQ11806.npy +imgHQ02720.npy +imgHQ01732.npy +imgHQ21955.npy +imgHQ23850.npy +imgHQ15219.npy +imgHQ00855.npy +imgHQ18423.npy +imgHQ14596.npy +imgHQ24441.npy +imgHQ16310.npy +imgHQ22319.npy +imgHQ11811.npy +imgHQ10434.npy +imgHQ09286.npy +imgHQ19210.npy +imgHQ19014.npy +imgHQ19998.npy +imgHQ29801.npy +imgHQ08320.npy +imgHQ28637.npy +imgHQ00902.npy +imgHQ07024.npy +imgHQ27822.npy +imgHQ02471.npy +imgHQ13595.npy +imgHQ16480.npy +imgHQ09460.npy +imgHQ17625.npy +imgHQ26410.npy +imgHQ05718.npy +imgHQ28865.npy +imgHQ29287.npy +imgHQ27751.npy +imgHQ17447.npy +imgHQ04769.npy +imgHQ07146.npy +imgHQ16364.npy +imgHQ05641.npy +imgHQ28177.npy +imgHQ28700.npy +imgHQ18339.npy +imgHQ29790.npy +imgHQ25638.npy +imgHQ14568.npy +imgHQ17413.npy +imgHQ24167.npy +imgHQ03299.npy +imgHQ24787.npy +imgHQ20240.npy +imgHQ22738.npy +imgHQ02513.npy +imgHQ00959.npy +imgHQ23621.npy +imgHQ19624.npy +imgHQ04929.npy +imgHQ21495.npy +imgHQ08390.npy +imgHQ12251.npy +imgHQ08670.npy +imgHQ25749.npy +imgHQ01491.npy +imgHQ08295.npy +imgHQ06980.npy +imgHQ29708.npy +imgHQ14030.npy +imgHQ00011.npy +imgHQ00368.npy +imgHQ02794.npy +imgHQ04052.npy +imgHQ00723.npy +imgHQ01953.npy +imgHQ06729.npy +imgHQ23690.npy +imgHQ27749.npy +imgHQ19445.npy +imgHQ09862.npy +imgHQ24236.npy +imgHQ16871.npy +imgHQ23893.npy +imgHQ21276.npy +imgHQ07197.npy +imgHQ04987.npy +imgHQ14260.npy +imgHQ09129.npy +imgHQ13753.npy +imgHQ11384.npy +imgHQ13512.npy +imgHQ08776.npy +imgHQ10903.npy +imgHQ02361.npy +imgHQ22179.npy +imgHQ17052.npy +imgHQ07307.npy +imgHQ00891.npy +imgHQ22811.npy +imgHQ02838.npy +imgHQ21524.npy +imgHQ10372.npy +imgHQ06376.npy +imgHQ01158.npy +imgHQ03705.npy +imgHQ01316.npy +imgHQ01375.npy +imgHQ21267.npy +imgHQ04462.npy +imgHQ01274.npy +imgHQ28160.npy +imgHQ09277.npy +imgHQ01056.npy +imgHQ06117.npy +imgHQ12680.npy +imgHQ07425.npy +imgHQ27469.npy +imgHQ11663.npy +imgHQ23607.npy +imgHQ00177.npy +imgHQ26431.npy +imgHQ22176.npy +imgHQ00848.npy +imgHQ13650.npy +imgHQ00231.npy +imgHQ13303.npy +imgHQ25074.npy +imgHQ20548.npy +imgHQ17258.npy +imgHQ14461.npy +imgHQ07773.npy +imgHQ27354.npy +imgHQ02753.npy +imgHQ02149.npy +imgHQ08980.npy +imgHQ22980.npy +imgHQ07419.npy +imgHQ15594.npy +imgHQ19615.npy +imgHQ06954.npy +imgHQ05153.npy +imgHQ20766.npy +imgHQ24573.npy +imgHQ20362.npy +imgHQ25843.npy +imgHQ27512.npy +imgHQ12999.npy +imgHQ04674.npy +imgHQ13668.npy +imgHQ06009.npy +imgHQ01128.npy +imgHQ28727.npy +imgHQ25699.npy +imgHQ26972.npy +imgHQ14563.npy +imgHQ20325.npy +imgHQ17166.npy +imgHQ00537.npy +imgHQ03728.npy +imgHQ17877.npy +imgHQ01975.npy +imgHQ18210.npy +imgHQ23154.npy +imgHQ18503.npy +imgHQ20531.npy +imgHQ25454.npy +imgHQ13410.npy +imgHQ21610.npy +imgHQ23375.npy +imgHQ09947.npy +imgHQ18455.npy +imgHQ04225.npy +imgHQ00122.npy +imgHQ19428.npy +imgHQ10349.npy +imgHQ11681.npy +imgHQ28874.npy +imgHQ26482.npy +imgHQ24459.npy +imgHQ28803.npy +imgHQ20051.npy +imgHQ07567.npy +imgHQ03675.npy +imgHQ09035.npy +imgHQ01574.npy +imgHQ09053.npy +imgHQ19156.npy +imgHQ27992.npy +imgHQ23106.npy +imgHQ00013.npy +imgHQ09587.npy +imgHQ03190.npy +imgHQ09882.npy +imgHQ00363.npy +imgHQ01063.npy +imgHQ14771.npy +imgHQ18430.npy +imgHQ04006.npy +imgHQ16439.npy +imgHQ28425.npy +imgHQ22921.npy +imgHQ06019.npy +imgHQ20879.npy +imgHQ23957.npy +imgHQ00941.npy +imgHQ25739.npy +imgHQ17777.npy +imgHQ10269.npy +imgHQ19356.npy +imgHQ10788.npy +imgHQ15248.npy +imgHQ05549.npy +imgHQ02215.npy +imgHQ23726.npy +imgHQ15572.npy +imgHQ23789.npy +imgHQ25932.npy +imgHQ28998.npy +imgHQ22066.npy +imgHQ23656.npy +imgHQ29259.npy +imgHQ00637.npy +imgHQ23222.npy +imgHQ03083.npy +imgHQ29526.npy +imgHQ23123.npy +imgHQ25998.npy +imgHQ05676.npy +imgHQ22715.npy +imgHQ23278.npy +imgHQ03150.npy +imgHQ26024.npy +imgHQ21938.npy +imgHQ23749.npy +imgHQ19794.npy +imgHQ20507.npy +imgHQ11151.npy +imgHQ21448.npy +imgHQ12553.npy +imgHQ05049.npy +imgHQ06677.npy +imgHQ08230.npy +imgHQ19062.npy +imgHQ21059.npy +imgHQ00866.npy +imgHQ26930.npy +imgHQ19535.npy +imgHQ00668.npy +imgHQ21454.npy +imgHQ12220.npy +imgHQ12847.npy +imgHQ24253.npy +imgHQ07043.npy +imgHQ21587.npy +imgHQ28468.npy +imgHQ13366.npy +imgHQ01976.npy +imgHQ09295.npy +imgHQ19802.npy +imgHQ21571.npy +imgHQ18964.npy +imgHQ12617.npy +imgHQ24187.npy +imgHQ18739.npy +imgHQ09398.npy +imgHQ18406.npy +imgHQ17590.npy +imgHQ11303.npy +imgHQ13297.npy +imgHQ06910.npy +imgHQ05517.npy +imgHQ27396.npy +imgHQ23503.npy +imgHQ19148.npy +imgHQ21879.npy +imgHQ06504.npy +imgHQ13946.npy +imgHQ13329.npy +imgHQ17082.npy +imgHQ26551.npy +imgHQ07138.npy +imgHQ03616.npy +imgHQ14956.npy +imgHQ10928.npy +imgHQ01134.npy +imgHQ03270.npy +imgHQ15119.npy +imgHQ10477.npy +imgHQ02301.npy +imgHQ07039.npy +imgHQ05081.npy +imgHQ11956.npy +imgHQ18752.npy +imgHQ20613.npy +imgHQ14370.npy +imgHQ18317.npy +imgHQ27447.npy +imgHQ01635.npy +imgHQ10040.npy +imgHQ13360.npy +imgHQ00355.npy +imgHQ07708.npy +imgHQ09895.npy +imgHQ21969.npy +imgHQ08438.npy +imgHQ22596.npy +imgHQ12611.npy +imgHQ10819.npy +imgHQ21231.npy +imgHQ05636.npy +imgHQ28130.npy +imgHQ08510.npy +imgHQ09438.npy +imgHQ01456.npy +imgHQ24697.npy +imgHQ04216.npy +imgHQ12681.npy +imgHQ12201.npy +imgHQ00559.npy +imgHQ04154.npy +imgHQ24679.npy +imgHQ10247.npy +imgHQ22216.npy +imgHQ13548.npy +imgHQ15040.npy +imgHQ26054.npy +imgHQ20478.npy +imgHQ10035.npy +imgHQ15065.npy +imgHQ01334.npy +imgHQ00802.npy +imgHQ24485.npy +imgHQ04387.npy +imgHQ02548.npy +imgHQ10540.npy +imgHQ08089.npy +imgHQ06147.npy +imgHQ09533.npy +imgHQ29139.npy +imgHQ27904.npy +imgHQ16836.npy +imgHQ10716.npy +imgHQ15263.npy +imgHQ04476.npy +imgHQ15975.npy +imgHQ19772.npy +imgHQ04809.npy +imgHQ03813.npy +imgHQ04909.npy +imgHQ11072.npy +imgHQ19598.npy +imgHQ04634.npy +imgHQ05600.npy +imgHQ27137.npy +imgHQ26533.npy +imgHQ08602.npy +imgHQ21605.npy +imgHQ00704.npy +imgHQ24801.npy +imgHQ06963.npy +imgHQ08608.npy +imgHQ00835.npy +imgHQ27003.npy +imgHQ26700.npy +imgHQ07312.npy +imgHQ12842.npy +imgHQ22302.npy +imgHQ29689.npy +imgHQ00045.npy +imgHQ20381.npy +imgHQ12186.npy +imgHQ20008.npy +imgHQ22703.npy +imgHQ19247.npy +imgHQ02854.npy +imgHQ06008.npy +imgHQ12364.npy +imgHQ26969.npy +imgHQ24324.npy +imgHQ22742.npy +imgHQ13749.npy +imgHQ26304.npy +imgHQ21133.npy +imgHQ16477.npy +imgHQ13593.npy +imgHQ00670.npy +imgHQ27900.npy +imgHQ03127.npy +imgHQ22674.npy +imgHQ09370.npy +imgHQ03808.npy +imgHQ09685.npy +imgHQ03912.npy +imgHQ09220.npy +imgHQ05946.npy +imgHQ12313.npy +imgHQ19119.npy +imgHQ00748.npy +imgHQ15632.npy +imgHQ02184.npy +imgHQ17760.npy +imgHQ18710.npy +imgHQ09713.npy +imgHQ17407.npy +imgHQ00395.npy +imgHQ10524.npy +imgHQ08971.npy +imgHQ09416.npy +imgHQ04664.npy +imgHQ09332.npy +imgHQ00227.npy +imgHQ14609.npy +imgHQ01508.npy +imgHQ10579.npy +imgHQ10344.npy +imgHQ22766.npy +imgHQ04265.npy +imgHQ11673.npy +imgHQ04699.npy +imgHQ12841.npy +imgHQ10627.npy +imgHQ09299.npy +imgHQ18543.npy +imgHQ25456.npy +imgHQ00017.npy +imgHQ11203.npy +imgHQ06192.npy +imgHQ12672.npy +imgHQ06290.npy +imgHQ25893.npy +imgHQ00977.npy +imgHQ14131.npy +imgHQ16353.npy +imgHQ14610.npy +imgHQ25602.npy +imgHQ15722.npy +imgHQ00740.npy +imgHQ12519.npy +imgHQ22624.npy +imgHQ19832.npy +imgHQ09837.npy +imgHQ01405.npy +imgHQ03830.npy +imgHQ27683.npy +imgHQ01831.npy +imgHQ09919.npy +imgHQ09424.npy +imgHQ26848.npy +imgHQ23818.npy +imgHQ10726.npy +imgHQ23574.npy +imgHQ02559.npy +imgHQ23866.npy +imgHQ08626.npy +imgHQ27133.npy +imgHQ05727.npy +imgHQ13875.npy +imgHQ25023.npy +imgHQ20929.npy +imgHQ03000.npy +imgHQ12322.npy +imgHQ03034.npy +imgHQ11719.npy +imgHQ15691.npy +imgHQ13997.npy +imgHQ19240.npy +imgHQ20864.npy +imgHQ24366.npy +imgHQ07872.npy +imgHQ10649.npy +imgHQ11319.npy +imgHQ08587.npy +imgHQ04386.npy +imgHQ11227.npy +imgHQ09864.npy +imgHQ14668.npy +imgHQ07581.npy +imgHQ03774.npy +imgHQ28343.npy +imgHQ26643.npy +imgHQ06496.npy +imgHQ24384.npy +imgHQ12087.npy +imgHQ17148.npy +imgHQ03196.npy +imgHQ22574.npy +imgHQ14907.npy +imgHQ05244.npy +imgHQ08248.npy +imgHQ26036.npy +imgHQ13022.npy +imgHQ23706.npy +imgHQ20304.npy +imgHQ13531.npy +imgHQ10570.npy +imgHQ03064.npy +imgHQ15874.npy +imgHQ25435.npy +imgHQ27635.npy +imgHQ02815.npy +imgHQ21858.npy +imgHQ06948.npy +imgHQ27964.npy +imgHQ23346.npy +imgHQ26492.npy +imgHQ26753.npy +imgHQ21031.npy +imgHQ12965.npy +imgHQ03592.npy +imgHQ08649.npy +imgHQ00404.npy +imgHQ09498.npy +imgHQ08462.npy +imgHQ13041.npy +imgHQ15712.npy +imgHQ02053.npy +imgHQ10449.npy +imgHQ18490.npy +imgHQ10927.npy +imgHQ22013.npy +imgHQ26990.npy +imgHQ26059.npy +imgHQ01605.npy +imgHQ28617.npy +imgHQ24257.npy +imgHQ08877.npy +imgHQ01564.npy +imgHQ10106.npy +imgHQ15226.npy +imgHQ25400.npy +imgHQ11044.npy +imgHQ25046.npy +imgHQ19270.npy +imgHQ13441.npy +imgHQ29761.npy +imgHQ06639.npy +imgHQ06580.npy +imgHQ13070.npy +imgHQ19861.npy +imgHQ15663.npy +imgHQ06807.npy +imgHQ22217.npy +imgHQ27126.npy +imgHQ13492.npy +imgHQ04639.npy +imgHQ03200.npy +imgHQ09154.npy +imgHQ12624.npy +imgHQ26523.npy +imgHQ17489.npy +imgHQ29446.npy +imgHQ25474.npy +imgHQ15555.npy +imgHQ29744.npy +imgHQ14408.npy +imgHQ06714.npy +imgHQ20216.npy +imgHQ15593.npy +imgHQ16101.npy +imgHQ21449.npy +imgHQ20262.npy +imgHQ24749.npy +imgHQ15126.npy +imgHQ27919.npy +imgHQ12107.npy +imgHQ04252.npy +imgHQ06672.npy +imgHQ15580.npy +imgHQ20173.npy +imgHQ17251.npy +imgHQ20785.npy +imgHQ17863.npy +imgHQ01070.npy +imgHQ11497.npy +imgHQ15084.npy +imgHQ29756.npy +imgHQ17607.npy +imgHQ07238.npy +imgHQ25450.npy +imgHQ17844.npy +imgHQ25146.npy +imgHQ11561.npy +imgHQ08157.npy +imgHQ21191.npy +imgHQ08684.npy +imgHQ00681.npy +imgHQ19411.npy +imgHQ14769.npy +imgHQ12779.npy +imgHQ12524.npy +imgHQ03444.npy +imgHQ28558.npy +imgHQ04803.npy +imgHQ16879.npy +imgHQ24585.npy +imgHQ05105.npy +imgHQ19820.npy +imgHQ10136.npy +imgHQ08763.npy +imgHQ10587.npy +imgHQ18164.npy +imgHQ17515.npy +imgHQ12803.npy +imgHQ04644.npy +imgHQ18900.npy +imgHQ05388.npy +imgHQ17321.npy +imgHQ00461.npy +imgHQ14807.npy +imgHQ24053.npy +imgHQ14876.npy +imgHQ20981.npy +imgHQ23872.npy +imgHQ14803.npy +imgHQ19111.npy +imgHQ21195.npy +imgHQ14854.npy +imgHQ19828.npy +imgHQ28508.npy +imgHQ22463.npy +imgHQ24949.npy +imgHQ17202.npy +imgHQ17053.npy +imgHQ11868.npy +imgHQ01476.npy +imgHQ19600.npy +imgHQ05251.npy +imgHQ02940.npy +imgHQ00115.npy +imgHQ12679.npy +imgHQ04303.npy +imgHQ24504.npy +imgHQ18919.npy +imgHQ07511.npy +imgHQ18078.npy +imgHQ25159.npy +imgHQ24434.npy +imgHQ22537.npy +imgHQ09949.npy +imgHQ01163.npy +imgHQ05918.npy +imgHQ23604.npy +imgHQ18656.npy +imgHQ24607.npy +imgHQ22872.npy +imgHQ07730.npy +imgHQ15866.npy +imgHQ29253.npy +imgHQ06598.npy +imgHQ15232.npy +imgHQ09265.npy +imgHQ02042.npy +imgHQ22206.npy +imgHQ10814.npy +imgHQ29331.npy +imgHQ21157.npy +imgHQ25139.npy +imgHQ19964.npy +imgHQ10020.npy +imgHQ26347.npy +imgHQ27880.npy +imgHQ23601.npy +imgHQ09785.npy +imgHQ04491.npy +imgHQ24511.npy +imgHQ17063.npy +imgHQ25119.npy +imgHQ29035.npy +imgHQ25719.npy +imgHQ03503.npy +imgHQ16587.npy +imgHQ01934.npy +imgHQ11502.npy +imgHQ02330.npy +imgHQ03707.npy +imgHQ28153.npy +imgHQ07998.npy +imgHQ16993.npy +imgHQ28114.npy +imgHQ08512.npy +imgHQ22140.npy +imgHQ13787.npy +imgHQ04453.npy +imgHQ26035.npy +imgHQ10825.npy +imgHQ12397.npy +imgHQ00630.npy +imgHQ19593.npy +imgHQ19897.npy +imgHQ19090.npy +imgHQ14926.npy +imgHQ23556.npy +imgHQ11427.npy +imgHQ17482.npy +imgHQ11973.npy +imgHQ22506.npy +imgHQ20669.npy +imgHQ25594.npy +imgHQ08234.npy +imgHQ02744.npy +imgHQ05396.npy +imgHQ12616.npy +imgHQ12704.npy +imgHQ02366.npy +imgHQ13738.npy +imgHQ03696.npy +imgHQ04646.npy +imgHQ01194.npy +imgHQ25586.npy +imgHQ03362.npy +imgHQ13008.npy +imgHQ07023.npy +imgHQ12332.npy +imgHQ29324.npy +imgHQ16229.npy +imgHQ28363.npy +imgHQ25380.npy +imgHQ15870.npy +imgHQ14712.npy +imgHQ18544.npy +imgHQ26237.npy +imgHQ25080.npy +imgHQ24502.npy +imgHQ04231.npy +imgHQ22887.npy +imgHQ05649.npy +imgHQ03415.npy +imgHQ24916.npy +imgHQ24311.npy +imgHQ13979.npy +imgHQ06591.npy +imgHQ29965.npy +imgHQ04687.npy +imgHQ20434.npy +imgHQ08156.npy +imgHQ22288.npy +imgHQ29997.npy +imgHQ27333.npy +imgHQ01209.npy +imgHQ07821.npy +imgHQ01522.npy +imgHQ04818.npy +imgHQ07291.npy +imgHQ21862.npy +imgHQ24464.npy +imgHQ25292.npy +imgHQ24980.npy +imgHQ24354.npy +imgHQ02125.npy +imgHQ20128.npy +imgHQ20649.npy +imgHQ15410.npy +imgHQ14205.npy +imgHQ07271.npy +imgHQ18318.npy +imgHQ29002.npy +imgHQ05357.npy +imgHQ12393.npy +imgHQ15138.npy +imgHQ14092.npy +imgHQ06681.npy +imgHQ26819.npy +imgHQ15361.npy +imgHQ04561.npy +imgHQ02804.npy +imgHQ23599.npy +imgHQ03920.npy +imgHQ18092.npy +imgHQ19262.npy +imgHQ09099.npy +imgHQ01523.npy +imgHQ25482.npy +imgHQ27835.npy +imgHQ09457.npy +imgHQ09750.npy +imgHQ25018.npy +imgHQ12460.npy +imgHQ26889.npy +imgHQ29482.npy +imgHQ18472.npy +imgHQ16125.npy +imgHQ05683.npy +imgHQ08452.npy +imgHQ21020.npy +imgHQ28173.npy +imgHQ28831.npy +imgHQ14852.npy +imgHQ10764.npy +imgHQ11955.npy +imgHQ27471.npy +imgHQ02370.npy +imgHQ29419.npy +imgHQ05020.npy +imgHQ24838.npy +imgHQ07759.npy +imgHQ06605.npy +imgHQ20492.npy +imgHQ18622.npy +imgHQ27040.npy +imgHQ15696.npy +imgHQ21986.npy +imgHQ15192.npy +imgHQ24754.npy +imgHQ25633.npy +imgHQ21186.npy +imgHQ01714.npy +imgHQ03496.npy +imgHQ13471.npy +imgHQ04222.npy +imgHQ15751.npy +imgHQ26088.npy +imgHQ04327.npy +imgHQ15968.npy +imgHQ18902.npy +imgHQ26537.npy +imgHQ16416.npy +imgHQ14608.npy +imgHQ12668.npy +imgHQ23897.npy +imgHQ11585.npy +imgHQ21990.npy +imgHQ00166.npy +imgHQ23899.npy +imgHQ09385.npy +imgHQ04165.npy +imgHQ27198.npy +imgHQ24507.npy +imgHQ03993.npy +imgHQ10947.npy +imgHQ08041.npy +imgHQ03488.npy +imgHQ11928.npy +imgHQ10899.npy +imgHQ06433.npy +imgHQ03112.npy +imgHQ06824.npy +imgHQ01000.npy +imgHQ23751.npy +imgHQ07685.npy +imgHQ18697.npy +imgHQ26215.npy +imgHQ09056.npy +imgHQ00031.npy +imgHQ26211.npy +imgHQ21413.npy +imgHQ15359.npy +imgHQ13077.npy +imgHQ07064.npy +imgHQ24407.npy +imgHQ21057.npy +imgHQ02736.npy +imgHQ19971.npy +imgHQ24671.npy +imgHQ23940.npy +imgHQ02788.npy +imgHQ21437.npy +imgHQ23733.npy +imgHQ10104.npy +imgHQ16656.npy +imgHQ17848.npy +imgHQ03451.npy +imgHQ10133.npy +imgHQ07204.npy +imgHQ08148.npy +imgHQ24070.npy +imgHQ00472.npy +imgHQ13437.npy +imgHQ09532.npy +imgHQ01424.npy +imgHQ07682.npy +imgHQ20357.npy +imgHQ12689.npy +imgHQ23435.npy +imgHQ26961.npy +imgHQ17951.npy +imgHQ07838.npy +imgHQ24970.npy +imgHQ05484.npy +imgHQ18663.npy +imgHQ06485.npy +imgHQ20912.npy +imgHQ02451.npy +imgHQ22352.npy +imgHQ10044.npy +imgHQ18407.npy +imgHQ11164.npy +imgHQ04259.npy +imgHQ29514.npy +imgHQ10486.npy +imgHQ16948.npy +imgHQ24849.npy +imgHQ26788.npy +imgHQ15406.npy +imgHQ28612.npy +imgHQ19017.npy +imgHQ15979.npy +imgHQ07524.npy +imgHQ18947.npy +imgHQ05611.npy +imgHQ02031.npy +imgHQ27882.npy +imgHQ17803.npy +imgHQ14602.npy +imgHQ22662.npy +imgHQ07776.npy +imgHQ14903.npy +imgHQ27287.npy +imgHQ17152.npy +imgHQ14338.npy +imgHQ07000.npy +imgHQ22645.npy +imgHQ09939.npy +imgHQ18148.npy +imgHQ14033.npy +imgHQ01580.npy +imgHQ18969.npy +imgHQ01841.npy +imgHQ04053.npy +imgHQ25156.npy +imgHQ05527.npy +imgHQ14196.npy +imgHQ07479.npy +imgHQ17068.npy +imgHQ22286.npy +imgHQ18541.npy +imgHQ12555.npy +imgHQ22245.npy +imgHQ17980.npy +imgHQ04606.npy +imgHQ05679.npy +imgHQ22641.npy +imgHQ23355.npy +imgHQ25649.npy +imgHQ15387.npy +imgHQ25445.npy +imgHQ05058.npy +imgHQ18999.npy +imgHQ00083.npy +imgHQ08815.npy +imgHQ25423.npy +imgHQ16586.npy +imgHQ27603.npy +imgHQ11075.npy +imgHQ12805.npy +imgHQ18230.npy +imgHQ19489.npy +imgHQ22047.npy +imgHQ18072.npy +imgHQ19517.npy +imgHQ23060.npy +imgHQ12943.npy +imgHQ26388.npy +imgHQ13870.npy +imgHQ29776.npy +imgHQ25272.npy +imgHQ12865.npy +imgHQ08870.npy +imgHQ23855.npy +imgHQ07964.npy +imgHQ03821.npy +imgHQ25540.npy +imgHQ06241.npy +imgHQ14487.npy +imgHQ12918.npy +imgHQ14383.npy +imgHQ08837.npy +imgHQ22547.npy +imgHQ07219.npy +imgHQ10623.npy +imgHQ25593.npy +imgHQ25224.npy +imgHQ27934.npy +imgHQ19824.npy +imgHQ26620.npy +imgHQ02456.npy +imgHQ19105.npy +imgHQ13907.npy +imgHQ06073.npy +imgHQ15131.npy +imgHQ23145.npy +imgHQ23495.npy +imgHQ27222.npy +imgHQ23566.npy +imgHQ27952.npy +imgHQ25015.npy +imgHQ21564.npy +imgHQ09698.npy +imgHQ19328.npy +imgHQ13949.npy +imgHQ23913.npy +imgHQ01242.npy +imgHQ26786.npy +imgHQ06975.npy +imgHQ25300.npy +imgHQ21099.npy +imgHQ20823.npy +imgHQ11959.npy +imgHQ11691.npy +imgHQ08136.npy +imgHQ12837.npy +imgHQ24217.npy +imgHQ04612.npy +imgHQ05403.npy +imgHQ24764.npy +imgHQ26102.npy +imgHQ25286.npy +imgHQ16059.npy +imgHQ00811.npy +imgHQ08205.npy +imgHQ02605.npy +imgHQ11835.npy +imgHQ14978.npy +imgHQ29149.npy +imgHQ15179.npy +imgHQ23173.npy +imgHQ28522.npy +imgHQ19010.npy +imgHQ11735.npy +imgHQ00929.npy +imgHQ00545.npy +imgHQ13176.npy +imgHQ01091.npy +imgHQ01110.npy +imgHQ10662.npy +imgHQ03665.npy +imgHQ27253.npy +imgHQ05905.npy +imgHQ01369.npy +imgHQ25784.npy +imgHQ16581.npy +imgHQ15931.npy +imgHQ16765.npy +imgHQ03102.npy +imgHQ19312.npy +imgHQ25062.npy +imgHQ04522.npy +imgHQ29671.npy +imgHQ15588.npy +imgHQ11451.npy +imgHQ12770.npy +imgHQ23237.npy +imgHQ20667.npy +imgHQ02712.npy +imgHQ18037.npy +imgHQ13763.npy +imgHQ10429.npy +imgHQ19799.npy +imgHQ16283.npy +imgHQ26021.npy +imgHQ03831.npy +imgHQ16932.npy +imgHQ28330.npy +imgHQ28844.npy +imgHQ01467.npy +imgHQ17762.npy +imgHQ03852.npy +imgHQ27901.npy +imgHQ07754.npy +imgHQ06034.npy +imgHQ18015.npy +imgHQ15096.npy +imgHQ12414.npy +imgHQ08655.npy +imgHQ11503.npy +imgHQ23657.npy +imgHQ21964.npy +imgHQ07677.npy +imgHQ09898.npy +imgHQ15606.npy +imgHQ19333.npy +imgHQ03793.npy +imgHQ05024.npy +imgHQ25030.npy +imgHQ00317.npy +imgHQ05585.npy +imgHQ28038.npy +imgHQ20866.npy +imgHQ28301.npy +imgHQ15375.npy +imgHQ03695.npy +imgHQ11370.npy +imgHQ28921.npy +imgHQ20885.npy +imgHQ06762.npy +imgHQ09413.npy +imgHQ01752.npy +imgHQ23830.npy +imgHQ26071.npy +imgHQ09764.npy +imgHQ19704.npy +imgHQ22382.npy +imgHQ13243.npy +imgHQ14087.npy +imgHQ08365.npy +imgHQ09405.npy +imgHQ17013.npy +imgHQ26867.npy +imgHQ02115.npy +imgHQ03291.npy +imgHQ05802.npy +imgHQ24845.npy +imgHQ07446.npy +imgHQ26676.npy +imgHQ27674.npy +imgHQ06149.npy +imgHQ27803.npy +imgHQ18223.npy +imgHQ13845.npy +imgHQ28524.npy +imgHQ10588.npy +imgHQ09354.npy +imgHQ05686.npy +imgHQ00692.npy +imgHQ13968.npy +imgHQ16517.npy +imgHQ08617.npy +imgHQ02161.npy +imgHQ08170.npy +imgHQ04765.npy +imgHQ07614.npy +imgHQ12064.npy +imgHQ20854.npy +imgHQ27761.npy +imgHQ11982.npy +imgHQ21704.npy +imgHQ25359.npy +imgHQ07569.npy +imgHQ21787.npy +imgHQ07095.npy +imgHQ27458.npy +imgHQ17910.npy +imgHQ22475.npy +imgHQ02665.npy +imgHQ06322.npy +imgHQ07172.npy +imgHQ24425.npy +imgHQ04974.npy +imgHQ24688.npy +imgHQ20833.npy +imgHQ21965.npy +imgHQ08812.npy +imgHQ22613.npy +imgHQ11903.npy +imgHQ19764.npy +imgHQ04686.npy +imgHQ11891.npy +imgHQ07040.npy +imgHQ02176.npy +imgHQ03653.npy +imgHQ01769.npy +imgHQ27682.npy +imgHQ00790.npy +imgHQ28585.npy +imgHQ12587.npy +imgHQ03693.npy +imgHQ16929.npy +imgHQ00590.npy +imgHQ06645.npy +imgHQ19592.npy +imgHQ28988.npy +imgHQ14542.npy +imgHQ27035.npy +imgHQ00494.npy +imgHQ27338.npy +imgHQ05716.npy +imgHQ21822.npy +imgHQ20909.npy +imgHQ04959.npy +imgHQ03902.npy +imgHQ27626.npy +imgHQ28356.npy +imgHQ06730.npy +imgHQ23457.npy +imgHQ22993.npy +imgHQ29694.npy +imgHQ04061.npy +imgHQ26454.npy +imgHQ29998.npy +imgHQ25134.npy +imgHQ19459.npy +imgHQ06280.npy +imgHQ23280.npy +imgHQ20354.npy +imgHQ23984.npy +imgHQ11748.npy +imgHQ07843.npy +imgHQ21297.npy +imgHQ04773.npy +imgHQ18401.npy +imgHQ01454.npy +imgHQ17749.npy +imgHQ29087.npy +imgHQ05888.npy +imgHQ26083.npy +imgHQ21614.npy +imgHQ21609.npy +imgHQ05877.npy +imgHQ20709.npy +imgHQ07362.npy +imgHQ03426.npy +imgHQ19336.npy +imgHQ18804.npy +imgHQ25936.npy +imgHQ07046.npy +imgHQ10682.npy +imgHQ09626.npy +imgHQ10913.npy +imgHQ14116.npy +imgHQ19541.npy +imgHQ26866.npy +imgHQ25285.npy +imgHQ10871.npy +imgHQ04889.npy +imgHQ10988.npy +imgHQ01593.npy +imgHQ09365.npy +imgHQ04021.npy +imgHQ04094.npy +imgHQ16665.npy +imgHQ01689.npy +imgHQ26607.npy +imgHQ17525.npy +imgHQ05227.npy +imgHQ22718.npy +imgHQ19498.npy +imgHQ19476.npy +imgHQ25066.npy +imgHQ14451.npy +imgHQ16258.npy +imgHQ12498.npy +imgHQ15203.npy +imgHQ27440.npy +imgHQ18972.npy +imgHQ22684.npy +imgHQ26727.npy +imgHQ04629.npy +imgHQ26452.npy +imgHQ28922.npy +imgHQ08869.npy +imgHQ14917.npy +imgHQ12318.npy +imgHQ21324.npy +imgHQ03901.npy +imgHQ01504.npy +imgHQ13723.npy +imgHQ14541.npy +imgHQ28588.npy +imgHQ18481.npy +imgHQ11184.npy +imgHQ24629.npy +imgHQ03151.npy +imgHQ25152.npy +imgHQ27267.npy +imgHQ06012.npy +imgHQ03450.npy +imgHQ25738.npy +imgHQ14524.npy +imgHQ16331.npy +imgHQ03455.npy +imgHQ06103.npy +imgHQ20047.npy +imgHQ06413.npy +imgHQ28017.npy +imgHQ10946.npy +imgHQ11920.npy +imgHQ11412.npy +imgHQ11695.npy +imgHQ02903.npy +imgHQ25974.npy +imgHQ04961.npy +imgHQ08366.npy +imgHQ15236.npy +imgHQ01027.npy +imgHQ27746.npy +imgHQ24683.npy +imgHQ10122.npy +imgHQ10769.npy +imgHQ26078.npy +imgHQ16907.npy +imgHQ24783.npy +imgHQ13155.npy +imgHQ23063.npy +imgHQ03427.npy +imgHQ29520.npy +imgHQ04470.npy +imgHQ28883.npy +imgHQ06255.npy +imgHQ10472.npy +imgHQ21743.npy +imgHQ10456.npy +imgHQ25491.npy +imgHQ28463.npy +imgHQ28578.npy +imgHQ04281.npy +imgHQ23685.npy +imgHQ26130.npy +imgHQ22157.npy +imgHQ20066.npy +imgHQ06538.npy +imgHQ24975.npy +imgHQ10986.npy +imgHQ02320.npy +imgHQ24338.npy +imgHQ10983.npy +imgHQ06160.npy +imgHQ21621.npy +imgHQ05961.npy +imgHQ09140.npy +imgHQ24080.npy +imgHQ08177.npy +imgHQ05372.npy +imgHQ07626.npy +imgHQ25464.npy +imgHQ29376.npy +imgHQ15832.npy +imgHQ20469.npy +imgHQ18860.npy +imgHQ27863.npy +imgHQ05754.npy +imgHQ13362.npy +imgHQ20010.npy +imgHQ06561.npy +imgHQ11613.npy +imgHQ26805.npy +imgHQ27520.npy +imgHQ15048.npy +imgHQ22205.npy +imgHQ09227.npy +imgHQ20632.npy +imgHQ17721.npy +imgHQ13224.npy +imgHQ03683.npy +imgHQ05744.npy +imgHQ07882.npy +imgHQ08600.npy +imgHQ20162.npy +imgHQ14018.npy +imgHQ19064.npy +imgHQ20756.npy +imgHQ29146.npy +imgHQ18765.npy +imgHQ18946.npy +imgHQ15418.npy +imgHQ15441.npy +imgHQ19199.npy +imgHQ04382.npy +imgHQ29433.npy +imgHQ19860.npy +imgHQ26203.npy +imgHQ18617.npy +imgHQ29484.npy +imgHQ14988.npy +imgHQ27021.npy +imgHQ27327.npy +imgHQ19007.npy +imgHQ10516.npy +imgHQ00633.npy +imgHQ06498.npy +imgHQ11393.npy +imgHQ09134.npy +imgHQ25824.npy +imgHQ14324.npy +imgHQ10839.npy +imgHQ06282.npy +imgHQ21361.npy +imgHQ07458.npy +imgHQ22564.npy +imgHQ25401.npy +imgHQ16005.npy +imgHQ28793.npy +imgHQ13256.npy +imgHQ27509.npy +imgHQ15958.npy +imgHQ18469.npy +imgHQ01940.npy +imgHQ16146.npy +imgHQ27245.npy +imgHQ10083.npy +imgHQ20451.npy +imgHQ10289.npy +imgHQ22112.npy +imgHQ04418.npy +imgHQ19112.npy +imgHQ04862.npy +imgHQ14995.npy +imgHQ19221.npy +imgHQ10608.npy +imgHQ25433.npy +imgHQ29558.npy +imgHQ10091.npy +imgHQ20222.npy +imgHQ04598.npy +imgHQ07349.npy +imgHQ21919.npy +imgHQ06817.npy +imgHQ25227.npy +imgHQ03549.npy +imgHQ27100.npy +imgHQ29325.npy +imgHQ12716.npy +imgHQ05663.npy +imgHQ01955.npy +imgHQ10042.npy +imgHQ04393.npy +imgHQ11779.npy +imgHQ25969.npy +imgHQ10645.npy +imgHQ19510.npy +imgHQ12730.npy +imgHQ26373.npy +imgHQ03618.npy +imgHQ11495.npy +imgHQ15790.npy +imgHQ10395.npy +imgHQ14763.npy +imgHQ25125.npy +imgHQ14873.npy +imgHQ12697.npy +imgHQ13974.npy +imgHQ18669.npy +imgHQ01325.npy +imgHQ16791.npy +imgHQ21671.npy +imgHQ21886.npy +imgHQ20520.npy +imgHQ11011.npy +imgHQ00162.npy +imgHQ08422.npy +imgHQ04446.npy +imgHQ19363.npy +imgHQ22381.npy +imgHQ06306.npy +imgHQ19224.npy +imgHQ04286.npy +imgHQ10315.npy +imgHQ13240.npy +imgHQ02632.npy +imgHQ05216.npy +imgHQ08261.npy +imgHQ24300.npy +imgHQ11922.npy +imgHQ27976.npy +imgHQ05011.npy +imgHQ00271.npy +imgHQ20241.npy +imgHQ05200.npy +imgHQ20084.npy +imgHQ25660.npy +imgHQ10464.npy +imgHQ00180.npy +imgHQ22700.npy +imgHQ00351.npy +imgHQ24103.npy +imgHQ13481.npy +imgHQ24990.npy +imgHQ02092.npy +imgHQ11239.npy +imgHQ05880.npy +imgHQ01657.npy +imgHQ23530.npy +imgHQ17254.npy +imgHQ12051.npy +imgHQ16169.npy +imgHQ11981.npy +imgHQ25597.npy +imgHQ13347.npy +imgHQ15305.npy +imgHQ28258.npy +imgHQ05884.npy +imgHQ05562.npy +imgHQ19775.npy +imgHQ16717.npy +imgHQ13004.npy +imgHQ28305.npy +imgHQ11208.npy +imgHQ03472.npy +imgHQ05592.npy +imgHQ03527.npy +imgHQ06100.npy +imgHQ11609.npy +imgHQ04316.npy +imgHQ02331.npy +imgHQ15725.npy +imgHQ27282.npy +imgHQ17769.npy +imgHQ04756.npy +imgHQ12867.npy +imgHQ13236.npy +imgHQ08334.npy +imgHQ09345.npy +imgHQ03092.npy +imgHQ28636.npy +imgHQ14741.npy +imgHQ27426.npy +imgHQ03300.npy +imgHQ20108.npy +imgHQ15754.npy +imgHQ06007.npy +imgHQ21775.npy +imgHQ24727.npy +imgHQ00622.npy +imgHQ12529.npy +imgHQ16575.npy +imgHQ20625.npy +imgHQ27015.npy +imgHQ12163.npy +imgHQ08315.npy +imgHQ27142.npy +imgHQ06069.npy +imgHQ02800.npy +imgHQ05752.npy +imgHQ08207.npy +imgHQ14236.npy +imgHQ07158.npy +imgHQ14360.npy +imgHQ19019.npy +imgHQ05026.npy +imgHQ02027.npy +imgHQ28656.npy +imgHQ25956.npy +imgHQ02966.npy +imgHQ22669.npy +imgHQ19030.npy +imgHQ23133.npy +imgHQ01759.npy +imgHQ17212.npy +imgHQ07909.npy +imgHQ17955.npy +imgHQ18075.npy +imgHQ00600.npy +imgHQ19257.npy +imgHQ00305.npy +imgHQ15649.npy +imgHQ16711.npy +imgHQ01032.npy +imgHQ09014.npy +imgHQ19109.npy +imgHQ00004.npy +imgHQ19741.npy +imgHQ11144.npy +imgHQ09945.npy +imgHQ03114.npy +imgHQ13580.npy +imgHQ15041.npy +imgHQ17981.npy +imgHQ28720.npy +imgHQ22034.npy +imgHQ12974.npy +imgHQ28456.npy +imgHQ13446.npy +imgHQ10436.npy +imgHQ04616.npy +imgHQ25902.npy +imgHQ29810.npy +imgHQ06511.npy +imgHQ01258.npy +imgHQ10912.npy +imgHQ02621.npy +imgHQ21739.npy +imgHQ14930.npy +imgHQ28810.npy +imgHQ10689.npy +imgHQ05701.npy +imgHQ15448.npy +imgHQ03413.npy +imgHQ05775.npy +imgHQ02517.npy +imgHQ12294.npy +imgHQ10139.npy +imgHQ21034.npy +imgHQ07453.npy +imgHQ10833.npy +imgHQ27534.npy +imgHQ03185.npy +imgHQ19377.npy +imgHQ05483.npy +imgHQ06659.npy +imgHQ23360.npy +imgHQ21612.npy +imgHQ09908.npy +imgHQ07624.npy +imgHQ03212.npy +imgHQ16604.npy +imgHQ26915.npy +imgHQ27083.npy +imgHQ26540.npy +imgHQ21373.npy +imgHQ19818.npy +imgHQ20079.npy +imgHQ21398.npy +imgHQ04202.npy +imgHQ10049.npy +imgHQ19978.npy +imgHQ14346.npy +imgHQ05362.npy +imgHQ02895.npy +imgHQ28838.npy +imgHQ01059.npy +imgHQ08030.npy +imgHQ27107.npy +imgHQ19343.npy +imgHQ01585.npy +imgHQ08681.npy +imgHQ09940.npy +imgHQ04657.npy +imgHQ14118.npy +imgHQ15865.npy +imgHQ22719.npy +imgHQ14016.npy +imgHQ29797.npy +imgHQ15047.npy +imgHQ09119.npy +imgHQ15352.npy +imgHQ00103.npy +imgHQ29799.npy +imgHQ03364.npy +imgHQ03280.npy +imgHQ21592.npy +imgHQ24759.npy +imgHQ05594.npy +imgHQ02723.npy +imgHQ18284.npy +imgHQ19572.npy +imgHQ06437.npy +imgHQ19288.npy +imgHQ20476.npy +imgHQ14977.npy +imgHQ26825.npy +imgHQ26415.npy +imgHQ10243.npy +imgHQ02878.npy +imgHQ02025.npy +imgHQ14015.npy +imgHQ18020.npy +imgHQ23389.npy +imgHQ28852.npy +imgHQ22070.npy +imgHQ07466.npy +imgHQ21622.npy +imgHQ12260.npy +imgHQ14242.npy +imgHQ15320.npy +imgHQ00585.npy +imgHQ19779.npy +imgHQ25160.npy +imgHQ29644.npy +imgHQ13062.npy +imgHQ13383.npy +imgHQ29098.npy +imgHQ02696.npy +imgHQ24547.npy +imgHQ29084.npy +imgHQ03938.npy +imgHQ01995.npy +imgHQ16911.npy +imgHQ26888.npy +imgHQ23178.npy +imgHQ25630.npy +imgHQ22088.npy +imgHQ15963.npy +imgHQ20651.npy +imgHQ11913.npy +imgHQ06542.npy +imgHQ19880.npy +imgHQ09525.npy +imgHQ16823.npy +imgHQ09336.npy +imgHQ07424.npy +imgHQ21014.npy +imgHQ15031.npy +imgHQ13822.npy +imgHQ25589.npy +imgHQ06722.npy +imgHQ19362.npy +imgHQ07159.npy +imgHQ20510.npy +imgHQ12299.npy +imgHQ25862.npy +imgHQ14159.npy +imgHQ04618.npy +imgHQ08231.npy +imgHQ12222.npy +imgHQ28613.npy +imgHQ17865.npy +imgHQ05720.npy +imgHQ08868.npy +imgHQ16260.npy +imgHQ20968.npy +imgHQ02614.npy +imgHQ28861.npy +imgHQ09634.npy +imgHQ11705.npy +imgHQ13409.npy +imgHQ07813.npy +imgHQ27437.npy +imgHQ28185.npy +imgHQ23640.npy +imgHQ11402.npy +imgHQ25791.npy +imgHQ14760.npy +imgHQ14812.npy +imgHQ27732.npy +imgHQ20155.npy +imgHQ26004.npy +imgHQ20914.npy +imgHQ26530.npy +imgHQ23732.npy +imgHQ02893.npy +imgHQ16285.npy +imgHQ04945.npy +imgHQ22857.npy +imgHQ05010.npy +imgHQ13059.npy +imgHQ24583.npy +imgHQ04251.npy +imgHQ04973.npy +imgHQ16725.npy +imgHQ03746.npy +imgHQ08397.npy +imgHQ24557.npy +imgHQ23168.npy +imgHQ15776.npy +imgHQ27706.npy +imgHQ19117.npy +imgHQ28348.npy +imgHQ14313.npy +imgHQ23990.npy +imgHQ02367.npy +imgHQ26154.npy +imgHQ05137.npy +imgHQ23619.npy +imgHQ07084.npy +imgHQ12329.npy +imgHQ15143.npy +imgHQ29868.npy +imgHQ05807.npy +imgHQ07564.npy +imgHQ17638.npy +imgHQ03720.npy +imgHQ00698.npy +imgHQ10998.npy +imgHQ19121.npy +imgHQ13211.npy +imgHQ03788.npy +imgHQ17891.npy +imgHQ00994.npy +imgHQ27502.npy +imgHQ24305.npy +imgHQ15535.npy +imgHQ21776.npy +imgHQ15972.npy +imgHQ08754.npy +imgHQ09907.npy +imgHQ22611.npy +imgHQ22459.npy +imgHQ14549.npy +imgHQ07954.npy +imgHQ15546.npy +imgHQ02067.npy +imgHQ22584.npy +imgHQ20407.npy +imgHQ08373.npy +imgHQ21861.npy +imgHQ15551.npy +imgHQ27394.npy +imgHQ13609.npy +imgHQ15834.npy +imgHQ21409.npy +imgHQ22486.npy +imgHQ25759.npy +imgHQ22071.npy +imgHQ16895.npy +imgHQ26625.npy +imgHQ11224.npy +imgHQ01141.npy +imgHQ11582.npy +imgHQ06667.npy +imgHQ26722.npy +imgHQ12694.npy +imgHQ05947.npy +imgHQ04031.npy +imgHQ04860.npy +imgHQ14331.npy +imgHQ24372.npy +imgHQ02883.npy +imgHQ26120.npy +imgHQ22636.npy +imgHQ13759.npy +imgHQ12765.npy +imgHQ18890.npy +imgHQ26152.npy +imgHQ18585.npy +imgHQ18265.npy +imgHQ20687.npy +imgHQ17956.npy +imgHQ22175.npy +imgHQ02279.npy +imgHQ26965.npy +imgHQ21814.npy +imgHQ18297.npy +imgHQ06726.npy +imgHQ22511.npy +imgHQ12873.npy +imgHQ16793.npy +imgHQ20120.npy +imgHQ01298.npy +imgHQ06788.npy +imgHQ24288.npy +imgHQ22512.npy +imgHQ08978.npy +imgHQ12215.npy +imgHQ29457.npy +imgHQ16980.npy +imgHQ08240.npy +imgHQ20606.npy +imgHQ03529.npy +imgHQ22560.npy +imgHQ12265.npy +imgHQ17331.npy +imgHQ29507.npy +imgHQ06644.npy +imgHQ22433.npy +imgHQ01378.npy +imgHQ29184.npy +imgHQ17356.npy +imgHQ06887.npy +imgHQ06520.npy +imgHQ06508.npy +imgHQ15807.npy +imgHQ04417.npy +imgHQ11805.npy +imgHQ13825.npy +imgHQ10285.npy +imgHQ01925.npy +imgHQ14361.npy +imgHQ04969.npy +imgHQ11985.npy +imgHQ07306.npy +imgHQ21672.npy +imgHQ17260.npy +imgHQ19168.npy +imgHQ10112.npy +imgHQ10105.npy +imgHQ11418.npy +imgHQ04456.npy +imgHQ06424.npy +imgHQ21790.npy +imgHQ21096.npy +imgHQ11241.npy +imgHQ02980.npy +imgHQ22144.npy +imgHQ11245.npy +imgHQ03892.npy +imgHQ28914.npy +imgHQ00133.npy +imgHQ13705.npy +imgHQ14657.npy +imgHQ23852.npy +imgHQ06231.npy +imgHQ18859.npy +imgHQ03052.npy +imgHQ08742.npy +imgHQ02925.npy +imgHQ21669.npy +imgHQ02942.npy +imgHQ28117.npy +imgHQ11339.npy +imgHQ17389.npy +imgHQ27883.npy +imgHQ06223.npy +imgHQ11843.npy +imgHQ17239.npy +imgHQ22908.npy +imgHQ20566.npy +imgHQ22882.npy +imgHQ15991.npy +imgHQ12391.npy +imgHQ06271.npy +imgHQ12819.npy +imgHQ27235.npy +imgHQ00952.npy +imgHQ11862.npy +imgHQ23025.npy +imgHQ13573.npy +imgHQ01782.npy +imgHQ16232.npy +imgHQ28526.npy +imgHQ01937.npy +imgHQ21859.npy +imgHQ10690.npy +imgHQ06965.npy +imgHQ25336.npy +imgHQ25420.npy +imgHQ24639.npy +imgHQ27903.npy +imgHQ08705.npy +imgHQ06700.npy +imgHQ19709.npy +imgHQ19514.npy +imgHQ00672.npy +imgHQ00056.npy +imgHQ22344.npy +imgHQ18385.npy +imgHQ28241.npy +imgHQ26316.npy +imgHQ20129.npy +imgHQ09337.npy +imgHQ13850.npy +imgHQ24568.npy +imgHQ21997.npy +imgHQ06182.npy +imgHQ25686.npy +imgHQ18794.npy +imgHQ19209.npy +imgHQ16796.npy +imgHQ18308.npy +imgHQ28107.npy +imgHQ16086.npy +imgHQ08939.npy +imgHQ24800.npy +imgHQ20813.npy +imgHQ08104.npy +imgHQ25794.npy +imgHQ12154.npy +imgHQ28297.npy +imgHQ19889.npy +imgHQ00936.npy +imgHQ05793.npy +imgHQ28682.npy +imgHQ25757.npy +imgHQ03022.npy +imgHQ21250.npy +imgHQ18908.npy +imgHQ23117.npy +imgHQ23970.npy +imgHQ08266.npy +imgHQ03320.npy +imgHQ27989.npy +imgHQ14889.npy +imgHQ16050.npy +imgHQ29284.npy +imgHQ21233.npy +imgHQ20062.npy +imgHQ12179.npy +imgHQ26457.npy +imgHQ15435.npy +imgHQ16223.npy +imgHQ06564.npy +imgHQ17316.npy +imgHQ08463.npy +imgHQ00616.npy +imgHQ25003.npy +imgHQ25858.npy +imgHQ16589.npy +imgHQ21109.npy +imgHQ13550.npy +imgHQ09078.npy +imgHQ16226.npy +imgHQ08500.npy +imgHQ28945.npy +imgHQ25550.npy +imgHQ27617.npy +imgHQ17988.npy +imgHQ28290.npy +imgHQ20732.npy +imgHQ22018.npy +imgHQ05971.npy +imgHQ16913.npy +imgHQ20771.npy +imgHQ25236.npy +imgHQ05325.npy +imgHQ25836.npy +imgHQ16187.npy +imgHQ04999.npy +imgHQ05630.npy +imgHQ19562.npy +imgHQ09700.npy +imgHQ04649.npy +imgHQ21240.npy +imgHQ08274.npy +imgHQ07672.npy +imgHQ11594.npy +imgHQ11669.npy +imgHQ03355.npy +imgHQ11780.npy +imgHQ29933.npy +imgHQ23756.npy +imgHQ11062.npy +imgHQ18073.npy +imgHQ23331.npy +imgHQ17187.npy +imgHQ02852.npy +imgHQ08384.npy +imgHQ23929.npy +imgHQ15977.npy +imgHQ25693.npy +imgHQ29166.npy +imgHQ09740.npy +imgHQ09423.npy +imgHQ17337.npy +imgHQ26453.npy +imgHQ26998.npy +imgHQ15943.npy +imgHQ15184.npy +imgHQ22724.npy +imgHQ04069.npy +imgHQ11957.npy +imgHQ14614.npy +imgHQ26679.npy +imgHQ04967.npy +imgHQ17961.npy +imgHQ12158.npy +imgHQ19525.npy +imgHQ09782.npy +imgHQ03308.npy +imgHQ12558.npy +imgHQ29306.npy +imgHQ08027.npy +imgHQ20159.npy +imgHQ28009.npy +imgHQ00354.npy +imgHQ10128.npy +imgHQ10633.npy +imgHQ26631.npy +imgHQ12872.npy +imgHQ18419.npy +imgHQ09328.npy +imgHQ29893.npy +imgHQ23880.npy +imgHQ26351.npy +imgHQ24965.npy +imgHQ13771.npy +imgHQ04427.npy +imgHQ01311.npy +imgHQ22901.npy +imgHQ18501.npy +imgHQ07213.npy +imgHQ24165.npy +imgHQ06442.npy +imgHQ10826.npy +imgHQ11759.npy +imgHQ07631.npy +imgHQ10075.npy +imgHQ29937.npy +imgHQ23820.npy +imgHQ03828.npy +imgHQ04637.npy +imgHQ00229.npy +imgHQ18862.npy +imgHQ06472.npy +imgHQ05486.npy +imgHQ04420.npy +imgHQ15194.npy +imgHQ18533.npy +imgHQ19793.npy +imgHQ00644.npy +imgHQ07662.npy +imgHQ18327.npy +imgHQ29874.npy +imgHQ21746.npy +imgHQ14739.npy +imgHQ24328.npy +imgHQ24358.npy +imgHQ09727.npy +imgHQ06812.npy +imgHQ09697.npy +imgHQ11699.npy +imgHQ01820.npy +imgHQ26168.npy +imgHQ01200.npy +imgHQ20460.npy +imgHQ07102.npy +imgHQ27604.npy +imgHQ02377.npy +imgHQ18100.npy +imgHQ28146.npy +imgHQ29876.npy +imgHQ22706.npy +imgHQ20299.npy +imgHQ15905.npy +imgHQ06230.npy +imgHQ03131.npy +imgHQ03323.npy +imgHQ13226.npy +imgHQ02796.npy +imgHQ29986.npy +imgHQ24202.npy +imgHQ16058.npy +imgHQ28298.npy +imgHQ22334.npy +imgHQ05820.npy +imgHQ25208.npy +imgHQ08210.npy +imgHQ03229.npy +imgHQ20280.npy +imgHQ28646.npy +imgHQ23027.npy +imgHQ29068.npy +imgHQ02659.npy +imgHQ27316.npy +imgHQ11271.npy +imgHQ00689.npy +imgHQ08415.npy +imgHQ24587.npy +imgHQ21183.npy +imgHQ19725.npy +imgHQ02095.npy +imgHQ21159.npy +imgHQ21841.npy +imgHQ19008.npy +imgHQ08624.npy +imgHQ23472.npy +imgHQ01359.npy +imgHQ01928.npy +imgHQ02189.npy +imgHQ23639.npy +imgHQ15578.npy +imgHQ05261.npy +imgHQ03076.npy +imgHQ01966.npy +imgHQ22429.npy +imgHQ20137.npy +imgHQ16943.npy +imgHQ06429.npy +imgHQ13878.npy +imgHQ07854.npy +imgHQ08131.npy +imgHQ21872.npy +imgHQ07180.npy +imgHQ09630.npy +imgHQ09537.npy +imgHQ04832.npy +imgHQ09138.npy +imgHQ19585.npy +imgHQ10022.npy +imgHQ10654.npy +imgHQ11309.npy +imgHQ23015.npy +imgHQ26315.npy +imgHQ04140.npy +imgHQ27710.npy +imgHQ06502.npy +imgHQ26465.npy +imgHQ21269.npy +imgHQ24741.npy +imgHQ23396.npy +imgHQ12945.npy +imgHQ13670.npy +imgHQ12351.npy +imgHQ08297.npy +imgHQ17203.npy +imgHQ10161.npy +imgHQ15480.npy +imgHQ22604.npy +imgHQ08467.npy +imgHQ26400.npy +imgHQ28895.npy +imgHQ15520.npy +imgHQ02119.npy +imgHQ16904.npy +imgHQ24107.npy +imgHQ22343.npy +imgHQ21263.npy +imgHQ13630.npy +imgHQ00881.npy +imgHQ01155.npy +imgHQ25053.npy +imgHQ24826.npy +imgHQ24599.npy +imgHQ07950.npy +imgHQ07359.npy +imgHQ08850.npy +imgHQ12973.npy +imgHQ12480.npy +imgHQ29985.npy +imgHQ16954.npy +imgHQ29289.npy +imgHQ16739.npy +imgHQ13935.npy +imgHQ07473.npy +imgHQ29213.npy +imgHQ02904.npy +imgHQ16106.npy +imgHQ12098.npy +imgHQ02420.npy +imgHQ02373.npy +imgHQ18730.npy +imgHQ05096.npy +imgHQ18984.npy +imgHQ12193.npy +imgHQ16820.npy +imgHQ12550.npy +imgHQ21721.npy +imgHQ09573.npy +imgHQ08610.npy +imgHQ13905.npy +imgHQ08024.npy +imgHQ07725.npy +imgHQ21288.npy +imgHQ03297.npy +imgHQ06624.npy +imgHQ16972.npy +imgHQ26544.npy +imgHQ01944.npy +imgHQ13131.npy +imgHQ28661.npy +imgHQ13203.npy +imgHQ12852.npy +imgHQ00573.npy +imgHQ04529.npy +imgHQ04184.npy +imgHQ19246.npy +imgHQ05106.npy +imgHQ23969.npy +imgHQ01756.npy +imgHQ13537.npy +imgHQ07105.npy +imgHQ25882.npy +imgHQ11983.npy +imgHQ26031.npy +imgHQ22287.npy +imgHQ16035.npy +imgHQ00142.npy +imgHQ21312.npy +imgHQ22725.npy +imgHQ08173.npy +imgHQ09644.npy +imgHQ15498.npy +imgHQ24097.npy +imgHQ23700.npy +imgHQ05704.npy +imgHQ15610.npy +imgHQ09213.npy +imgHQ13057.npy +imgHQ11083.npy +imgHQ22368.npy +imgHQ07607.npy +imgHQ10439.npy +imgHQ10277.npy +imgHQ00394.npy +imgHQ23617.npy +imgHQ12585.npy +imgHQ03805.npy +imgHQ16624.npy +imgHQ22272.npy +imgHQ19127.npy +imgHQ25648.npy +imgHQ21446.npy +imgHQ15381.npy +imgHQ27739.npy +imgHQ21771.npy +imgHQ10505.npy +imgHQ08237.npy +imgHQ11120.npy +imgHQ14722.npy +imgHQ00256.npy +imgHQ09489.npy +imgHQ17637.npy +imgHQ08542.npy +imgHQ12800.npy +imgHQ15062.npy +imgHQ24009.npy +imgHQ03038.npy +imgHQ26578.npy +imgHQ04954.npy +imgHQ05182.npy +imgHQ15990.npy +imgHQ25041.npy +imgHQ23878.npy +imgHQ16554.npy +imgHQ02793.npy +imgHQ28956.npy +imgHQ29137.npy +imgHQ02923.npy +imgHQ14335.npy +imgHQ13047.npy +imgHQ06758.npy +imgHQ10032.npy +imgHQ11631.npy +imgHQ02664.npy +imgHQ20114.npy +imgHQ11363.npy +imgHQ01393.npy +imgHQ10561.npy +imgHQ04533.npy +imgHQ10931.npy +imgHQ25409.npy +imgHQ14079.npy +imgHQ04002.npy +imgHQ23679.npy +imgHQ12155.npy +imgHQ01089.npy +imgHQ10046.npy +imgHQ17275.npy +imgHQ01125.npy +imgHQ20644.npy +imgHQ23424.npy +imgHQ11068.npy +imgHQ27845.npy +imgHQ16401.npy +imgHQ18746.npy +imgHQ00521.npy +imgHQ00827.npy +imgHQ06181.npy +imgHQ29836.npy +imgHQ01203.npy +imgHQ28904.npy +imgHQ03994.npy +imgHQ15853.npy +imgHQ14684.npy +imgHQ02222.npy +imgHQ09709.npy +imgHQ00309.npy +imgHQ07254.npy +imgHQ00750.npy +imgHQ12795.npy +imgHQ19136.npy +imgHQ08710.npy +imgHQ25487.npy +imgHQ11466.npy +imgHQ18936.npy +imgHQ22634.npy +imgHQ00950.npy +imgHQ09231.npy +imgHQ18650.npy +imgHQ07780.npy +imgHQ25327.npy +imgHQ13486.npy +imgHQ02516.npy +imgHQ24602.npy +imgHQ13739.npy +imgHQ03340.npy +imgHQ19748.npy +imgHQ23861.npy +imgHQ00961.npy +imgHQ18365.npy +imgHQ10702.npy +imgHQ08825.npy +imgHQ08333.npy +imgHQ05098.npy +imgHQ18582.npy +imgHQ28798.npy +imgHQ10382.npy +imgHQ22178.npy +imgHQ13811.npy +imgHQ02390.npy +imgHQ25889.npy +imgHQ29480.npy +imgHQ03799.npy +imgHQ09346.npy +imgHQ01777.npy +imgHQ20214.npy +imgHQ29945.npy +imgHQ09829.npy +imgHQ21286.npy +imgHQ15894.npy +imgHQ02355.npy +imgHQ21278.npy +imgHQ00905.npy +imgHQ09209.npy +imgHQ23937.npy +imgHQ21142.npy +imgHQ12916.npy +imgHQ02839.npy +imgHQ22404.npy +imgHQ23140.npy +imgHQ07346.npy +imgHQ11281.npy +imgHQ28500.npy +imgHQ18720.npy +imgHQ02981.npy +imgHQ21357.npy +imgHQ19408.npy +imgHQ12305.npy +imgHQ17994.npy +imgHQ08286.npy +imgHQ10861.npy +imgHQ02907.npy +imgHQ21094.npy +imgHQ20894.npy +imgHQ12755.npy +imgHQ10700.npy +imgHQ00460.npy +imgHQ11781.npy +imgHQ05714.npy +imgHQ26305.npy +imgHQ08609.npy +imgHQ13213.npy +imgHQ27766.npy +imgHQ03648.npy +imgHQ24686.npy +imgHQ17780.npy +imgHQ29530.npy +imgHQ00766.npy +imgHQ25605.npy +imgHQ26641.npy +imgHQ21722.npy +imgHQ00239.npy +imgHQ02701.npy +imgHQ18069.npy +imgHQ03296.npy +imgHQ26065.npy +imgHQ22807.npy +imgHQ27187.npy +imgHQ15569.npy +imgHQ18286.npy +imgHQ00864.npy +imgHQ16388.npy +imgHQ10163.npy +imgHQ26661.npy +imgHQ13081.npy +imgHQ05606.npy +imgHQ05545.npy +imgHQ10200.npy +imgHQ12170.npy +imgHQ15069.npy +imgHQ05009.npy +imgHQ20817.npy +imgHQ28447.npy +imgHQ28503.npy +imgHQ10327.npy +imgHQ19095.npy +imgHQ12442.npy +imgHQ14997.npy +imgHQ07477.npy +imgHQ01017.npy +imgHQ00018.npy +imgHQ24953.npy +imgHQ27858.npy +imgHQ03458.npy +imgHQ10381.npy +imgHQ09380.npy +imgHQ01145.npy +imgHQ05632.npy +imgHQ14882.npy +imgHQ28640.npy +imgHQ05401.npy +imgHQ27322.npy +imgHQ16622.npy +imgHQ07403.npy +imgHQ28133.npy +imgHQ21626.npy +imgHQ22890.npy +imgHQ07308.npy +imgHQ02226.npy +imgHQ03250.npy +imgHQ04663.npy +imgHQ18449.npy +imgHQ21637.npy +imgHQ26579.npy +imgHQ09290.npy +imgHQ05879.npy +imgHQ28976.npy +imgHQ18157.npy +imgHQ10868.npy +imgHQ17505.npy +imgHQ20281.npy +imgHQ02050.npy +imgHQ00528.npy +imgHQ02191.npy +imgHQ22870.npy +imgHQ14350.npy +imgHQ04351.npy +imgHQ00285.npy +imgHQ28321.npy +imgHQ09914.npy +imgHQ13017.npy +imgHQ24278.npy +imgHQ14747.npy +imgHQ28384.npy +imgHQ16502.npy +imgHQ09253.npy +imgHQ24055.npy +imgHQ12482.npy +imgHQ04378.npy +imgHQ24822.npy +imgHQ11581.npy +imgHQ12382.npy +imgHQ13679.npy +imgHQ03689.npy +imgHQ06737.npy +imgHQ16748.npy +imgHQ13944.npy +imgHQ27613.npy +imgHQ19599.npy +imgHQ21821.npy +imgHQ05737.npy +imgHQ29417.npy +imgHQ27208.npy +imgHQ06199.npy +imgHQ20369.npy +imgHQ10284.npy +imgHQ08163.npy +imgHQ27111.npy +imgHQ28882.npy +imgHQ26342.npy +imgHQ06514.npy +imgHQ11948.npy +imgHQ14902.npy +imgHQ10542.npy +imgHQ11731.npy +imgHQ20484.npy +imgHQ20812.npy +imgHQ02783.npy +imgHQ19016.npy +imgHQ01007.npy +imgHQ29485.npy +imgHQ24326.npy +imgHQ08180.npy +imgHQ20444.npy +imgHQ18187.npy +imgHQ11789.npy +imgHQ26912.npy +imgHQ19200.npy +imgHQ09256.npy +imgHQ11089.npy +imgHQ14186.npy +imgHQ16375.npy +imgHQ03310.npy +imgHQ27590.npy +imgHQ05309.npy +imgHQ00641.npy +imgHQ21314.npy +imgHQ15462.npy +imgHQ25621.npy +imgHQ18353.npy +imgHQ16500.npy +imgHQ29942.npy +imgHQ12022.npy +imgHQ00560.npy +imgHQ26746.npy +imgHQ25508.npy +imgHQ00565.npy +imgHQ29399.npy +imgHQ29187.npy +imgHQ18973.npy +imgHQ19733.npy +imgHQ14132.npy +imgHQ26816.npy +imgHQ12823.npy +imgHQ05506.npy +imgHQ22576.npy +imgHQ03668.npy +imgHQ22515.npy +imgHQ27656.npy +imgHQ14839.npy +imgHQ25767.npy +imgHQ05083.npy +imgHQ21354.npy +imgHQ20993.npy +imgHQ29550.npy +imgHQ03740.npy +imgHQ17925.npy +imgHQ26472.npy +imgHQ12026.npy +imgHQ09861.npy +imgHQ16716.npy +imgHQ05037.npy +imgHQ12355.npy +imgHQ12472.npy +imgHQ17441.npy +imgHQ16108.npy +imgHQ26196.npy +imgHQ04419.npy +imgHQ22234.npy +imgHQ11820.npy +imgHQ03408.npy +imgHQ26736.npy +imgHQ16493.npy +imgHQ04283.npy +imgHQ22307.npy +imgHQ16949.npy +imgHQ27687.npy +imgHQ29583.npy +imgHQ20792.npy +imgHQ05881.npy +imgHQ19081.npy +imgHQ28205.npy +imgHQ21837.npy +imgHQ25613.npy +imgHQ21406.npy +imgHQ09990.npy +imgHQ28141.npy +imgHQ07991.npy +imgHQ22117.npy +imgHQ02286.npy +imgHQ14322.npy +imgHQ04833.npy +imgHQ23731.npy +imgHQ00254.npy +imgHQ25926.npy +imgHQ00067.npy +imgHQ02967.npy +imgHQ16240.npy +imgHQ03015.npy +imgHQ08853.npy +imgHQ26638.npy +imgHQ09747.npy +imgHQ28857.npy +imgHQ22265.npy +imgHQ18292.npy +imgHQ07738.npy +imgHQ04460.npy +imgHQ25898.npy +imgHQ13318.npy +imgHQ03020.npy +imgHQ16028.npy +imgHQ00725.npy +imgHQ20442.npy +imgHQ03515.npy +imgHQ10884.npy +imgHQ10488.npy +imgHQ17191.npy +imgHQ17805.npy +imgHQ20089.npy +imgHQ22926.npy +imgHQ12781.npy +imgHQ14059.npy +imgHQ14782.npy +imgHQ18263.npy +imgHQ25805.npy +imgHQ21441.npy +imgHQ29755.npy +imgHQ13035.npy +imgHQ23985.npy +imgHQ28158.npy +imgHQ24829.npy +imgHQ08607.npy +imgHQ08405.npy +imgHQ02835.npy +imgHQ24725.npy +imgHQ07117.npy +imgHQ13892.npy +imgHQ03403.npy +imgHQ26140.npy +imgHQ03139.npy +imgHQ17206.npy +imgHQ24873.npy +imgHQ05022.npy +imgHQ00998.npy +imgHQ21710.npy +imgHQ00592.npy +imgHQ01652.npy +imgHQ01942.npy +imgHQ22998.npy +imgHQ18362.npy +imgHQ01754.npy +imgHQ08914.npy +imgHQ05848.npy +imgHQ29617.npy +imgHQ25448.npy +imgHQ06247.npy +imgHQ04088.npy +imgHQ00068.npy +imgHQ08723.npy +imgHQ23049.npy +imgHQ28278.npy +imgHQ06212.npy +imgHQ16549.npy +imgHQ04421.npy +imgHQ14949.npy +imgHQ01960.npy +imgHQ04886.npy +imgHQ22230.npy +imgHQ24918.npy +imgHQ12489.npy +imgHQ06599.npy +imgHQ01143.npy +imgHQ20541.npy +imgHQ19993.npy +imgHQ22267.npy +imgHQ26512.npy +imgHQ07070.npy +imgHQ02216.npy +imgHQ08807.npy +imgHQ23039.npy +imgHQ15650.npy +imgHQ16545.npy +imgHQ26723.npy +imgHQ22277.npy +imgHQ27549.npy +imgHQ00556.npy +imgHQ07641.npy +imgHQ16155.npy +imgHQ28323.npy +imgHQ19172.npy +imgHQ15925.npy +imgHQ21941.npy +imgHQ19306.npy +imgHQ25574.npy +imgHQ22682.npy +imgHQ16925.npy +imgHQ01911.npy +imgHQ13629.npy +imgHQ14290.npy +imgHQ19721.npy +imgHQ18216.npy +imgHQ15607.npy +imgHQ01812.npy +imgHQ27653.npy +imgHQ06240.npy +imgHQ10031.npy +imgHQ24821.npy +imgHQ28249.npy +imgHQ15105.npy +imgHQ04651.npy +imgHQ24855.npy +imgHQ19131.npy +imgHQ27052.npy +imgHQ22566.npy +imgHQ03265.npy +imgHQ11689.npy +imgHQ05815.npy +imgHQ29503.npy +imgHQ24274.npy +imgHQ25552.npy +imgHQ07327.npy +imgHQ09462.npy +imgHQ10762.npy +imgHQ18262.npy +imgHQ20714.npy +imgHQ29086.npy +imgHQ02307.npy +imgHQ19441.npy +imgHQ26557.npy +imgHQ08513.npy +imgHQ13485.npy +imgHQ09041.npy +imgHQ21234.npy +imgHQ09810.npy +imgHQ07824.npy +imgHQ10528.npy +imgHQ10611.npy +imgHQ22540.npy +imgHQ27096.npy +imgHQ02505.npy +imgHQ28469.npy +imgHQ21484.npy +imgHQ29231.npy +imgHQ07764.npy +imgHQ25694.npy +imgHQ17944.npy +imgHQ15728.npy +imgHQ12563.npy +imgHQ15487.npy +imgHQ15155.npy +imgHQ07751.npy +imgHQ26116.npy +imgHQ01426.npy +imgHQ17308.npy +imgHQ14931.npy +imgHQ00327.npy +imgHQ04240.npy +imgHQ04230.npy +imgHQ01862.npy +imgHQ17197.npy +imgHQ16519.npy +imgHQ17890.npy +imgHQ14284.npy +imgHQ12509.npy +imgHQ02856.npy +imgHQ22800.npy +imgHQ21496.npy +imgHQ25606.npy +imgHQ27943.npy +imgHQ09579.npy +imgHQ28693.npy +imgHQ03311.npy +imgHQ09868.npy +imgHQ27321.npy +imgHQ15563.npy +imgHQ11439.npy +imgHQ28109.npy +imgHQ07874.npy +imgHQ18849.npy +imgHQ29632.npy +imgHQ10366.npy +imgHQ23938.npy +imgHQ01222.npy +imgHQ04802.npy +imgHQ27309.npy +imgHQ07960.npy +imgHQ11660.npy +imgHQ25986.npy +imgHQ19695.npy +imgHQ15464.npy +imgHQ21108.npy +imgHQ09410.npy +imgHQ08906.npy +imgHQ16988.npy +imgHQ15969.npy +imgHQ21519.npy +imgHQ09623.npy +imgHQ03315.npy +imgHQ00365.npy +imgHQ05553.npy +imgHQ12844.npy +imgHQ06912.npy +imgHQ12915.npy +imgHQ10834.npy +imgHQ06960.npy +imgHQ28839.npy +imgHQ19655.npy +imgHQ00465.npy +imgHQ24659.npy +imgHQ03837.npy +imgHQ12466.npy +imgHQ14976.npy +imgHQ07645.npy +imgHQ15835.npy +imgHQ27510.npy +imgHQ19616.npy +imgHQ16088.npy +imgHQ10870.npy +imgHQ25311.npy +imgHQ00486.npy +imgHQ29724.npy +imgHQ18169.npy +imgHQ13494.npy +imgHQ17703.npy +imgHQ21342.npy +imgHQ00462.npy +imgHQ22647.npy +imgHQ02302.npy +imgHQ08019.npy +imgHQ27594.npy +imgHQ12078.npy +imgHQ05573.npy +imgHQ10062.npy +imgHQ05158.npy +imgHQ00526.npy +imgHQ11513.npy +imgHQ11703.npy +imgHQ04865.npy +imgHQ06235.npy +imgHQ15008.npy +imgHQ08943.npy +imgHQ21758.npy +imgHQ23098.npy +imgHQ29113.npy +imgHQ18511.npy +imgHQ26645.npy +imgHQ10002.npy +imgHQ13951.npy +imgHQ24778.npy +imgHQ12240.npy +imgHQ08790.npy +imgHQ01631.npy +imgHQ19944.npy +imgHQ11918.npy +imgHQ24598.npy +imgHQ17338.npy +imgHQ20597.npy +imgHQ20788.npy +imgHQ03955.npy +imgHQ25846.npy +imgHQ16958.npy +imgHQ20683.npy +imgHQ08773.npy +imgHQ01385.npy +imgHQ13637.npy +imgHQ13743.npy +imgHQ21054.npy +imgHQ08372.npy +imgHQ19317.npy +imgHQ04960.npy +imgHQ10990.npy +imgHQ22583.npy +imgHQ20370.npy +imgHQ05692.npy +imgHQ25363.npy +imgHQ13839.npy +imgHQ13170.npy +imgHQ04258.npy +imgHQ20585.npy +imgHQ01451.npy +imgHQ23253.npy +imgHQ20849.npy +imgHQ19937.npy +imgHQ03940.npy +imgHQ16776.npy +imgHQ23336.npy +imgHQ07230.npy +imgHQ28968.npy +imgHQ18378.npy +imgHQ17640.npy +imgHQ27265.npy +imgHQ09376.npy +imgHQ29787.npy +imgHQ18258.npy +imgHQ29245.npy +imgHQ26987.npy +imgHQ00854.npy +imgHQ26773.npy +imgHQ03941.npy +imgHQ21963.npy +imgHQ02010.npy +imgHQ07571.npy +imgHQ18508.npy +imgHQ28118.npy +imgHQ01912.npy +imgHQ12722.npy +imgHQ13626.npy +imgHQ11734.npy +imgHQ00969.npy +imgHQ18754.npy +imgHQ26611.npy +imgHQ20185.npy +imgHQ20327.npy +imgHQ23754.npy +imgHQ14506.npy +imgHQ02132.npy +imgHQ27406.npy +imgHQ00569.npy +imgHQ15477.npy +imgHQ18867.npy +imgHQ29919.npy +imgHQ24448.npy +imgHQ02138.npy +imgHQ14853.npy +imgHQ13010.npy +imgHQ04826.npy +imgHQ29545.npy +imgHQ22769.npy +imgHQ03070.npy +imgHQ01202.npy +imgHQ00904.npy +imgHQ27153.npy +imgHQ00408.npy +imgHQ02819.npy +imgHQ12586.npy +imgHQ15153.npy +imgHQ19023.npy +imgHQ25295.npy +imgHQ27412.npy +imgHQ23907.npy +imgHQ28666.npy +imgHQ04185.npy +imgHQ23061.npy +imgHQ29453.npy +imgHQ05728.npy +imgHQ21815.npy +imgHQ00760.npy +imgHQ11792.npy +imgHQ07394.npy +imgHQ23606.npy +imgHQ07072.npy +imgHQ00731.npy +imgHQ07939.npy +imgHQ16996.npy +imgHQ23300.npy +imgHQ16789.npy +imgHQ07965.npy +imgHQ00245.npy +imgHQ10770.npy +imgHQ12544.npy +imgHQ25680.npy +imgHQ15709.npy +imgHQ22065.npy +imgHQ23292.npy +imgHQ06909.npy +imgHQ14276.npy +imgHQ21619.npy +imgHQ18614.npy +imgHQ05324.npy +imgHQ29067.npy +imgHQ25774.npy +imgHQ22477.npy +imgHQ26073.npy +imgHQ12044.npy +imgHQ03906.npy +imgHQ27685.npy +imgHQ27211.npy +imgHQ03751.npy +imgHQ10442.npy +imgHQ11878.npy +imgHQ26891.npy +imgHQ03680.npy +imgHQ26463.npy +imgHQ10121.npy +imgHQ02112.npy +imgHQ29588.npy +imgHQ19099.npy +imgHQ15683.npy +imgHQ25884.npy +imgHQ23252.npy +imgHQ06210.npy +imgHQ07701.npy +imgHQ29638.npy +imgHQ22369.npy +imgHQ26801.npy +imgHQ04066.npy +imgHQ22856.npy +imgHQ29960.npy +imgHQ14443.npy +imgHQ02514.npy +imgHQ08970.npy +imgHQ08969.npy +imgHQ29450.npy +imgHQ00755.npy +imgHQ15258.npy +imgHQ27540.npy +imgHQ20346.npy +imgHQ04353.npy +imgHQ03610.npy +imgHQ29840.npy +imgHQ16447.npy +imgHQ03091.npy +imgHQ05666.npy +imgHQ23638.npy +imgHQ24663.npy +imgHQ27283.npy +imgHQ23443.npy +imgHQ10562.npy +imgHQ28947.npy +imgHQ28763.npy +imgHQ06976.npy +imgHQ09088.npy +imgHQ23729.npy +imgHQ18591.npy +imgHQ16771.npy +imgHQ10045.npy +imgHQ26802.npy +imgHQ15178.npy +imgHQ03861.npy +imgHQ28366.npy +imgHQ12020.npy +imgHQ21714.npy +imgHQ29938.npy +imgHQ04690.npy +imgHQ19238.npy +imgHQ25823.npy +imgHQ15682.npy +imgHQ28349.npy +imgHQ27996.npy +imgHQ03289.npy +imgHQ00335.npy +imgHQ10222.npy +imgHQ29502.npy +imgHQ18418.npy +imgHQ04710.npy +imgHQ11808.npy +imgHQ25466.npy +imgHQ22312.npy +imgHQ03967.npy +imgHQ24907.npy +imgHQ04630.npy +imgHQ23981.npy +imgHQ05733.npy +imgHQ21393.npy +imgHQ24415.npy +imgHQ20769.npy +imgHQ10499.npy +imgHQ13524.npy +imgHQ22618.npy +imgHQ19101.npy +imgHQ28548.npy +imgHQ27097.npy +imgHQ06931.npy +imgHQ05878.npy +imgHQ18227.npy +imgHQ04997.npy +imgHQ18738.npy +imgHQ09057.npy +imgHQ20624.npy +imgHQ20422.npy +imgHQ26835.npy +imgHQ00789.npy +imgHQ28450.npy +imgHQ23350.npy +imgHQ29649.npy +imgHQ07498.npy +imgHQ23305.npy +imgHQ23090.npy +imgHQ11343.npy +imgHQ08904.npy +imgHQ10677.npy +imgHQ13351.npy +imgHQ23776.npy +imgHQ07231.npy +imgHQ20147.npy +imgHQ09393.npy +imgHQ21509.npy +imgHQ09470.npy +imgHQ00448.npy +imgHQ00075.npy +imgHQ03930.npy +imgHQ11234.npy +imgHQ02267.npy +imgHQ25446.npy +imgHQ26495.npy +imgHQ07864.npy +imgHQ02582.npy +imgHQ12206.npy +imgHQ25625.npy +imgHQ28742.npy +imgHQ27306.npy +imgHQ01150.npy +imgHQ17067.npy +imgHQ13868.npy +imgHQ25610.npy +imgHQ27920.npy +imgHQ00651.npy +imgHQ27444.npy +imgHQ25029.npy +imgHQ01999.npy +imgHQ22627.npy +imgHQ23900.npy +imgHQ24219.npy +imgHQ22263.npy +imgHQ17758.npy +imgHQ24871.npy +imgHQ17657.npy +imgHQ08968.npy +imgHQ29437.npy +imgHQ19368.npy +imgHQ09911.npy +imgHQ08339.npy +imgHQ25554.npy +imgHQ04763.npy +imgHQ20797.npy +imgHQ15235.npy +imgHQ21352.npy +imgHQ04714.npy +imgHQ19218.npy +imgHQ12297.npy +imgHQ05064.npy +imgHQ22825.npy +imgHQ00642.npy +imgHQ06060.npy +imgHQ20533.npy +imgHQ08838.npy +imgHQ18748.npy +imgHQ01022.npy +imgHQ01085.npy +imgHQ14728.npy +imgHQ08140.npy +imgHQ07856.npy +imgHQ10985.npy +imgHQ11725.npy +imgHQ05535.npy +imgHQ25960.npy +imgHQ01515.npy +imgHQ05131.npy +imgHQ04678.npy +imgHQ08801.npy +imgHQ01025.npy +imgHQ13826.npy +imgHQ18691.npy +imgHQ04011.npy +imgHQ10548.npy +imgHQ12307.npy +imgHQ22298.npy +imgHQ19952.npy +imgHQ13969.npy +imgHQ24355.npy +imgHQ28812.npy +imgHQ03375.npy +imgHQ07548.npy +imgHQ27389.npy +imgHQ06399.npy +imgHQ25354.npy +imgHQ18559.npy +imgHQ02251.npy +imgHQ16628.npy +imgHQ13335.npy +imgHQ26766.npy +imgHQ00776.npy +imgHQ04170.npy +imgHQ20082.npy +imgHQ13539.npy +imgHQ17519.npy +imgHQ28877.npy +imgHQ25186.npy +imgHQ22373.npy +imgHQ08303.npy +imgHQ20540.npy +imgHQ17610.npy +imgHQ08477.npy +imgHQ03579.npy +imgHQ06036.npy +imgHQ09915.npy +imgHQ28687.npy +imgHQ13049.npy +imgHQ19194.npy +imgHQ10491.npy +imgHQ20208.npy +imgHQ17543.npy +imgHQ24567.npy +imgHQ19440.npy +imgHQ04758.npy +imgHQ28885.npy +imgHQ12588.npy +imgHQ27716.npy +imgHQ28967.npy +imgHQ11248.npy +imgHQ09071.npy +imgHQ29645.npy +imgHQ06541.npy +imgHQ11302.npy +imgHQ27220.npy +imgHQ27913.npy +imgHQ05508.npy +imgHQ04640.npy +imgHQ12024.npy +imgHQ07990.npy +imgHQ05355.npy +imgHQ25726.npy +imgHQ00617.npy +imgHQ08377.npy +imgHQ11941.npy +imgHQ13713.npy +imgHQ06024.npy +imgHQ04923.npy +imgHQ17228.npy +imgHQ11954.npy +imgHQ19304.npy +imgHQ01795.npy +imgHQ10198.npy +imgHQ09185.npy +imgHQ00190.npy +imgHQ29600.npy +imgHQ27856.npy +imgHQ15385.npy +imgHQ06441.npy +imgHQ07981.npy +imgHQ15788.npy +imgHQ10098.npy +imgHQ08734.npy +imgHQ07640.npy +imgHQ26201.npy +imgHQ01914.npy +imgHQ07037.npy +imgHQ22737.npy +imgHQ11883.npy +imgHQ27296.npy +imgHQ22025.npy +imgHQ20096.npy +imgHQ09386.npy +imgHQ06649.npy +imgHQ16926.npy +imgHQ01606.npy +imgHQ08808.npy +imgHQ19140.npy +imgHQ23829.npy +imgHQ12444.npy +imgHQ20187.npy +imgHQ25203.npy +imgHQ26536.npy +imgHQ26346.npy +imgHQ06731.npy +imgHQ05887.npy +imgHQ23989.npy +imgHQ01020.npy +imgHQ23976.npy +imgHQ19326.npy +imgHQ10138.npy +imgHQ04121.npy +imgHQ16783.npy +imgHQ28316.npy +imgHQ24874.npy +imgHQ11360.npy +imgHQ09619.npy +imgHQ04502.npy +imgHQ25577.npy +imgHQ10240.npy +imgHQ27923.npy +imgHQ13570.npy +imgHQ05423.npy +imgHQ20890.npy +imgHQ19836.npy +imgHQ08406.npy +imgHQ10467.npy +imgHQ16450.npy +imgHQ07928.npy +imgHQ22402.npy +imgHQ00584.npy +imgHQ11010.npy +imgHQ29438.npy +imgHQ29260.npy +imgHQ13483.npy +imgHQ29855.npy +imgHQ10624.npy +imgHQ12579.npy +imgHQ29570.npy +imgHQ28630.npy +imgHQ27420.npy +imgHQ00171.npy +imgHQ16840.npy +imgHQ19903.npy +imgHQ22440.npy +imgHQ23429.npy +imgHQ18911.npy +imgHQ15749.npy +imgHQ02325.npy +imgHQ05422.npy +imgHQ21299.npy +imgHQ09394.npy +imgHQ26883.npy +imgHQ07186.npy +imgHQ10208.npy +imgHQ11267.npy +imgHQ25289.npy +imgHQ12621.npy +imgHQ24984.npy +imgHQ15070.npy +imgHQ28194.npy +imgHQ28553.npy +imgHQ21325.npy +imgHQ22619.npy +imgHQ10923.npy +imgHQ22158.npy +imgHQ16661.npy +imgHQ04562.npy +imgHQ16313.npy +imgHQ22500.npy +imgHQ13412.npy +imgHQ02843.npy +imgHQ13381.npy +imgHQ14109.npy +imgHQ29039.npy +imgHQ04920.npy +imgHQ20594.npy +imgHQ14591.npy +imgHQ18146.npy +imgHQ16197.npy +imgHQ22878.npy +imgHQ13392.npy +imgHQ15353.npy +imgHQ02058.npy +imgHQ06634.npy +imgHQ08004.npy +imgHQ28868.npy +imgHQ21838.npy +imgHQ15210.npy +imgHQ28629.npy +imgHQ08153.npy +imgHQ04436.npy +imgHQ21104.npy +imgHQ06771.npy +imgHQ17549.npy +imgHQ19263.npy +imgHQ25688.npy +imgHQ26747.npy +imgHQ17102.npy +imgHQ05912.npy +imgHQ29473.npy +imgHQ17079.npy +imgHQ22530.npy +imgHQ29064.npy +imgHQ12273.npy +imgHQ14244.npy +imgHQ25335.npy +imgHQ16453.npy +imgHQ10425.npy +imgHQ14558.npy +imgHQ03260.npy +imgHQ00546.npy +imgHQ18818.npy +imgHQ26236.npy +imgHQ28996.npy +imgHQ27300.npy +imgHQ11727.npy +imgHQ20424.npy +imgHQ13610.npy +imgHQ23908.npy +imgHQ14519.npy +imgHQ12683.npy +imgHQ16168.npy +imgHQ01602.npy +imgHQ08565.npy +imgHQ24881.npy +imgHQ09168.npy +imgHQ13003.npy +imgHQ11065.npy +imgHQ21696.npy +imgHQ07338.npy +imgHQ23440.npy +imgHQ28774.npy +imgHQ08220.npy +imgHQ24582.npy +imgHQ19653.npy +imgHQ22695.npy +imgHQ25925.npy +imgHQ17136.npy +imgHQ00160.npy +imgHQ16659.npy +imgHQ08818.npy +imgHQ25629.npy +imgHQ08802.npy +imgHQ13183.npy +imgHQ21197.npy +imgHQ00836.npy +imgHQ06145.npy +imgHQ28820.npy +imgHQ07301.npy +imgHQ16442.npy +imgHQ22763.npy +imgHQ19137.npy +imgHQ18961.npy +imgHQ23329.npy +imgHQ03461.npy +imgHQ23447.npy +imgHQ22290.npy +imgHQ15642.npy +imgHQ13982.npy +imgHQ17161.npy +imgHQ00297.npy +imgHQ24001.npy +imgHQ14126.npy +imgHQ00803.npy +imgHQ19887.npy +imgHQ06021.npy +imgHQ01517.npy +imgHQ28699.npy +imgHQ04449.npy +imgHQ19410.npy +imgHQ20862.npy +imgHQ24876.npy +imgHQ11020.npy +imgHQ29474.npy +imgHQ22456.npy +imgHQ24032.npy +imgHQ01207.npy +imgHQ14815.npy +imgHQ13569.npy +imgHQ13209.npy +imgHQ09181.npy +imgHQ11368.npy +imgHQ15369.npy +imgHQ17098.npy +imgHQ18343.npy +imgHQ14998.npy +imgHQ05135.npy +imgHQ02060.npy +imgHQ04754.npy +imgHQ29610.npy +imgHQ24428.npy +imgHQ12584.npy +imgHQ11624.npy +imgHQ05122.npy +imgHQ00485.npy +imgHQ02269.npy +imgHQ03655.npy +imgHQ08715.npy +imgHQ07364.npy +imgHQ12183.npy +imgHQ11937.npy +imgHQ24102.npy +imgHQ28461.npy +imgHQ22354.npy +imgHQ04972.npy +imgHQ25503.npy +imgHQ28676.npy +imgHQ10325.npy +imgHQ21956.npy +imgHQ28647.npy +imgHQ19680.npy +imgHQ23282.npy +imgHQ09417.npy +imgHQ24487.npy +imgHQ12365.npy +imgHQ28322.npy +imgHQ01280.npy +imgHQ23183.npy +imgHQ27239.npy +imgHQ14611.npy +imgHQ26039.npy +imgHQ18968.npy +imgHQ12807.npy +imgHQ28458.npy +imgHQ03537.npy +imgHQ28881.npy +imgHQ17821.npy +imgHQ16591.npy +imgHQ07621.npy +imgHQ12270.npy +imgHQ28853.npy +imgHQ08999.npy +imgHQ13135.npy +imgHQ13345.npy +imgHQ00275.npy +imgHQ26240.npy +imgHQ00796.npy +imgHQ10342.npy +imgHQ08077.npy +imgHQ28029.npy +imgHQ25076.npy +imgHQ01400.npy +imgHQ06524.npy +imgHQ14051.npy +imgHQ06438.npy +imgHQ20578.npy +imgHQ23532.npy +imgHQ01186.npy +imgHQ19720.npy +imgHQ24303.npy +imgHQ08848.npy +imgHQ13361.npy +imgHQ05402.npy +imgHQ10028.npy +imgHQ24695.npy +imgHQ24292.npy +imgHQ06537.npy +imgHQ12562.npy +imgHQ13554.npy +imgHQ11331.npy +imgHQ25120.npy +imgHQ19480.npy +imgHQ01859.npy +imgHQ04913.npy +imgHQ15346.npy +imgHQ01653.npy +imgHQ05095.npy +imgHQ15051.npy +imgHQ09147.npy +imgHQ20423.npy +imgHQ06626.npy +imgHQ21121.npy +imgHQ26566.npy +imgHQ17335.npy +imgHQ29012.npy +imgHQ20740.npy +imgHQ16271.npy +imgHQ02946.npy +imgHQ10033.npy +imgHQ03971.npy +imgHQ23666.npy +imgHQ23858.npy +imgHQ06546.npy +imgHQ25736.npy +imgHQ24050.npy +imgHQ22233.npy +imgHQ13453.npy +imgHQ01225.npy +imgHQ02842.npy +imgHQ22940.npy +imgHQ00034.npy +imgHQ01330.npy +imgHQ20600.npy +imgHQ14058.npy +imgHQ03500.npy +imgHQ07736.npy +imgHQ10082.npy +imgHQ15003.npy +imgHQ10822.npy +imgHQ06753.npy +imgHQ13803.npy +imgHQ04335.npy +imgHQ03932.npy +imgHQ02695.npy +imgHQ14550.npy +imgHQ23996.npy +imgHQ24237.npy +imgHQ15797.npy +imgHQ04982.npy +imgHQ14246.npy +imgHQ10246.npy +imgHQ17563.npy +imgHQ23675.npy +imgHQ27260.npy +imgHQ08010.npy +imgHQ22006.npy +imgHQ00791.npy +imgHQ17993.npy +imgHQ27293.npy +imgHQ15743.npy +imgHQ00032.npy +imgHQ21850.npy +imgHQ02870.npy +imgHQ10451.npy +imgHQ11140.npy +imgHQ00532.npy +imgHQ23102.npy +imgHQ07340.npy +imgHQ02407.npy +imgHQ17977.npy +imgHQ26953.npy +imgHQ20677.npy +imgHQ11470.npy +imgHQ23975.npy +imgHQ13588.npy +imgHQ10664.npy +imgHQ13197.npy +imgHQ08879.npy +imgHQ17073.npy +imgHQ11057.npy +imgHQ17959.npy +imgHQ19859.npy +imgHQ12286.npy +imgHQ14707.npy +imgHQ17728.npy +imgHQ02416.npy +imgHQ12479.npy +imgHQ15043.npy +imgHQ06660.npy +imgHQ29946.npy +imgHQ27887.npy +imgHQ22970.npy +imgHQ14174.npy +imgHQ27331.npy +imgHQ02613.npy +imgHQ29765.npy +imgHQ26262.npy +imgHQ01839.npy +imgHQ14594.npy +imgHQ24301.npy +imgHQ19765.npy +imgHQ00409.npy +imgHQ11313.npy +imgHQ14894.npy +imgHQ06523.npy +imgHQ22733.npy +imgHQ07610.npy +imgHQ15286.npy +imgHQ12719.npy +imgHQ26916.npy +imgHQ24327.npy +imgHQ20081.npy +imgHQ09663.npy +imgHQ27062.npy +imgHQ06173.npy +imgHQ13273.npy +imgHQ15313.npy +imgHQ17276.npy +imgHQ12084.npy +imgHQ16990.npy +imgHQ14502.npy +imgHQ14973.npy +imgHQ25727.npy +imgHQ27788.npy +imgHQ19982.npy +imgHQ04410.npy +imgHQ29442.npy +imgHQ28597.npy +imgHQ01220.npy +imgHQ06198.npy +imgHQ26105.npy +imgHQ00900.npy +imgHQ15999.npy +imgHQ05911.npy +imgHQ11101.npy +imgHQ08774.npy +imgHQ00751.npy +imgHQ03243.npy +imgHQ27878.npy +imgHQ27909.npy +imgHQ21846.npy +imgHQ07742.npy +imgHQ25635.npy +imgHQ10584.npy +imgHQ07187.npy +imgHQ27400.npy +imgHQ01291.npy +imgHQ09929.npy +imgHQ00646.npy +imgHQ28091.npy +imgHQ03919.npy +imgHQ22947.npy +imgHQ03176.npy +imgHQ09107.npy +imgHQ13363.npy +imgHQ28277.npy +imgHQ13863.npy +imgHQ13449.npy +imgHQ19013.npy +imgHQ03866.npy +imgHQ00988.npy +imgHQ26775.npy +imgHQ21434.npy +imgHQ26165.npy +imgHQ15729.npy +imgHQ13568.npy +imgHQ21327.npy +imgHQ19345.npy +imgHQ28993.npy +imgHQ08000.npy +imgHQ07930.npy +imgHQ09615.npy +imgHQ23158.npy +imgHQ16219.npy +imgHQ16749.npy +imgHQ25054.npy +imgHQ14944.npy +imgHQ09217.npy +imgHQ12718.npy +imgHQ12577.npy +imgHQ20738.npy +imgHQ03998.npy +imgHQ04298.npy +imgHQ19261.npy +imgHQ20640.npy +imgHQ24121.npy +imgHQ12822.npy +imgHQ18870.npy +imgHQ08213.npy +imgHQ10895.npy +imgHQ12804.npy +imgHQ11618.npy +imgHQ22028.npy +imgHQ14297.npy +imgHQ29501.npy +imgHQ29581.npy +imgHQ09243.npy +imgHQ17162.npy +imgHQ19470.npy +imgHQ26288.npy +imgHQ22992.npy +imgHQ02821.npy +imgHQ15154.npy +imgHQ22195.npy +imgHQ26443.npy +imgHQ17287.npy +imgHQ24419.npy +imgHQ12615.npy +imgHQ16639.npy +imgHQ13259.npy +imgHQ10378.npy +imgHQ20044.npy +imgHQ05365.npy +imgHQ25861.npy +imgHQ26271.npy +imgHQ10533.npy +imgHQ26553.npy +imgHQ25967.npy +imgHQ29957.npy +imgHQ14906.npy +imgHQ20852.npy +imgHQ08225.npy +imgHQ10256.npy +imgHQ28562.npy +imgHQ19155.npy +imgHQ09288.npy +imgHQ26730.npy +imgHQ29802.npy +imgHQ07799.npy +imgHQ13692.npy +imgHQ26016.npy +imgHQ17078.npy +imgHQ23483.npy +imgHQ23777.npy +imgHQ06426.npy +imgHQ15949.npy +imgHQ14433.npy +imgHQ10848.npy +imgHQ14897.npy +imgHQ16136.npy +imgHQ29352.npy +imgHQ24901.npy +imgHQ11738.npy +imgHQ20901.npy +imgHQ09991.npy +imgHQ13460.npy +imgHQ06725.npy +imgHQ04752.npy +imgHQ10837.npy +imgHQ20931.npy +imgHQ18863.npy +imgHQ21055.npy +imgHQ24286.npy +imgHQ28507.npy +imgHQ09371.npy +imgHQ25108.npy +imgHQ12977.npy +imgHQ04668.npy +imgHQ26799.npy +imgHQ00509.npy +imgHQ19149.npy +imgHQ11643.npy +imgHQ25912.npy +imgHQ28738.npy +imgHQ26855.npy +imgHQ09411.npy +imgHQ16579.npy +imgHQ14840.npy +imgHQ02491.npy +imgHQ27556.npy +imgHQ24914.npy +imgHQ20119.npy +imgHQ14784.npy +imgHQ23207.npy +imgHQ09017.npy +imgHQ16461.npy +imgHQ29563.npy +imgHQ29770.npy +imgHQ17227.npy +imgHQ02775.npy +imgHQ05705.npy +imgHQ23715.npy +imgHQ21665.npy +imgHQ07278.npy +imgHQ20846.npy +imgHQ06450.npy +imgHQ07217.npy +imgHQ22416.npy +imgHQ07253.npy +imgHQ28123.npy +imgHQ12623.npy +imgHQ14830.npy +imgHQ13843.npy +imgHQ14356.npy +imgHQ13250.npy +imgHQ20782.npy +imgHQ28834.npy +imgHQ02332.npy +imgHQ03970.npy +imgHQ02802.npy +imgHQ03614.npy +imgHQ28279.npy +imgHQ17659.npy +imgHQ18953.npy +imgHQ22729.npy +imgHQ07770.npy +imgHQ02869.npy +imgHQ01570.npy +imgHQ14942.npy +imgHQ29524.npy +imgHQ09131.npy +imgHQ26803.npy +imgHQ15427.npy +imgHQ16794.npy +imgHQ27037.npy +imgHQ08243.npy +imgHQ21615.npy +imgHQ08127.npy +imgHQ29599.npy +imgHQ04275.npy +imgHQ04548.npy +imgHQ29460.npy +imgHQ13357.npy +imgHQ04220.npy +imgHQ27726.npy +imgHQ27701.npy +imgHQ07918.npy +imgHQ28189.npy +imgHQ05420.npy +imgHQ02583.npy +imgHQ00845.npy +imgHQ15224.npy +imgHQ16944.npy +imgHQ04845.npy +imgHQ26996.npy +imgHQ15759.npy +imgHQ17931.npy +imgHQ27173.npy +imgHQ22129.npy +imgHQ16426.npy +imgHQ29305.npy +imgHQ20584.npy +imgHQ09509.npy +imgHQ20389.npy +imgHQ08023.npy +imgHQ00097.npy +imgHQ01065.npy +imgHQ13242.npy +imgHQ29204.npy +imgHQ15493.npy +imgHQ24676.npy +imgHQ13765.npy +imgHQ15283.npy +imgHQ29295.npy +imgHQ18939.npy +imgHQ21829.npy +imgHQ00661.npy +imgHQ28999.npy +imgHQ12517.npy +imgHQ26978.npy +imgHQ29154.npy +imgHQ22924.npy +imgHQ13644.npy +imgHQ28335.npy +imgHQ03597.npy +imgHQ05143.npy +imgHQ03627.npy +imgHQ09794.npy +imgHQ24348.npy +imgHQ18332.npy +imgHQ19396.npy +imgHQ07103.npy +imgHQ14094.npy +imgHQ02751.npy +imgHQ15039.npy +imgHQ21851.npy +imgHQ25099.npy +imgHQ23290.npy +imgHQ25231.npy +imgHQ28392.npy +imgHQ13599.npy +imgHQ26096.npy +imgHQ04798.npy +imgHQ14127.npy +imgHQ16422.npy +imgHQ17430.npy +imgHQ07995.npy +imgHQ08164.npy +imgHQ29698.npy +imgHQ25911.npy +imgHQ25612.npy +imgHQ22699.npy +imgHQ25332.npy +imgHQ03384.npy +imgHQ00499.npy +imgHQ03198.npy +imgHQ07687.npy +imgHQ01368.npy +imgHQ29561.npy +imgHQ19973.npy +imgHQ20435.npy +imgHQ08701.npy +imgHQ17477.npy +imgHQ02780.npy +imgHQ10433.npy +imgHQ02610.npy +imgHQ18341.npy +imgHQ13704.npy +imgHQ25185.npy +imgHQ24866.npy +imgHQ11494.npy +imgHQ00418.npy +imgHQ01469.npy +imgHQ14859.npy +imgHQ22966.npy +imgHQ06914.npy +imgHQ29831.npy +imgHQ25849.npy +imgHQ01205.npy +imgHQ14005.npy +imgHQ01572.npy +imgHQ17921.npy +imgHQ05339.npy +imgHQ00389.npy +imgHQ17740.npy +imgHQ11540.npy +imgHQ15022.npy +imgHQ21677.npy +imgHQ06689.npy +imgHQ21410.npy +imgHQ24820.npy +imgHQ12252.npy +imgHQ02465.npy +imgHQ03282.npy +imgHQ16013.npy +imgHQ25548.npy +imgHQ22906.npy +imgHQ18283.npy +imgHQ02017.npy +imgHQ05949.npy +imgHQ28312.npy +imgHQ23105.npy +imgHQ11964.npy +imgHQ11525.npy +imgHQ06392.npy +imgHQ05647.npy +imgHQ25624.npy +imgHQ19252.npy +imgHQ15678.npy +imgHQ28580.npy +imgHQ21528.npy +imgHQ05332.npy +imgHQ19298.npy +imgHQ10606.npy +imgHQ11238.npy +imgHQ02774.npy +imgHQ16147.npy +imgHQ25863.npy +imgHQ01048.npy +imgHQ28204.npy +imgHQ05329.npy +imgHQ04725.npy +imgHQ03152.npy +imgHQ07947.npy +imgHQ29398.npy +imgHQ28034.npy +imgHQ15317.npy +imgHQ18797.npy +imgHQ13101.npy +imgHQ22754.npy +imgHQ18060.npy +imgHQ21594.npy +imgHQ22858.npy +imgHQ04397.npy +imgHQ19219.npy +imgHQ10544.npy +imgHQ17303.npy +imgHQ00324.npy +imgHQ17567.npy +imgHQ12162.npy +imgHQ05328.npy +imgHQ01656.npy +imgHQ27429.npy +imgHQ22258.npy +imgHQ17517.npy +imgHQ27284.npy +imgHQ15068.npy +imgHQ25187.npy +imgHQ25422.npy +imgHQ29715.npy +imgHQ11088.npy +imgHQ07779.npy +imgHQ03540.npy +imgHQ21588.npy +imgHQ03530.npy +imgHQ10004.npy +imgHQ12513.npy +imgHQ19630.npy +imgHQ05695.npy +imgHQ09719.npy +imgHQ08756.npy +imgHQ00665.npy +imgHQ00842.npy +imgHQ23320.npy +imgHQ17705.npy +imgHQ19530.npy +imgHQ15456.npy +imgHQ28481.npy +imgHQ19685.npy +imgHQ03382.npy +imgHQ03925.npy +imgHQ09826.npy +imgHQ01154.npy +imgHQ12985.npy +imgHQ04748.npy +imgHQ01507.npy +imgHQ00883.npy +imgHQ28658.npy +imgHQ26813.npy +imgHQ23728.npy +imgHQ27087.npy +imgHQ04782.npy +imgHQ22592.npy +imgHQ21654.npy +imgHQ14556.npy +imgHQ08252.npy +imgHQ20002.npy +imgHQ00475.npy +imgHQ08598.npy +imgHQ19984.npy +imgHQ10335.npy +imgHQ20338.npy +imgHQ05913.npy +imgHQ07268.npy +imgHQ03057.npy +imgHQ19330.npy +imgHQ08470.npy +imgHQ20551.npy +imgHQ13685.npy +imgHQ08375.npy +imgHQ12925.npy +imgHQ09946.npy +imgHQ21481.npy +imgHQ19555.npy +imgHQ18374.npy +imgHQ19781.npy +imgHQ16183.npy +imgHQ08108.npy +imgHQ28515.npy +imgHQ12282.npy +imgHQ00671.npy +imgHQ29634.npy +imgHQ02599.npy +imgHQ06371.npy +imgHQ14826.npy +imgHQ22478.npy +imgHQ21731.npy +imgHQ02801.npy +imgHQ26020.npy +imgHQ05082.npy +imgHQ08344.npy +imgHQ03715.npy +imgHQ27297.npy +imgHQ12707.npy +imgHQ26307.npy +imgHQ29233.npy +imgHQ15864.npy +imgHQ05866.npy +imgHQ06531.npy +imgHQ00931.npy +imgHQ16693.npy +imgHQ15161.npy +imgHQ25274.npy +imgHQ19289.npy +imgHQ09182.npy +imgHQ25797.npy +imgHQ25917.npy +imgHQ15241.npy +imgHQ26931.npy +imgHQ04789.npy +imgHQ24713.npy +imgHQ17419.npy +imgHQ19098.npy +imgHQ05591.npy +imgHQ19736.npy +imgHQ03735.npy +imgHQ03551.npy +imgHQ17529.npy +imgHQ08612.npy +imgHQ10828.npy +imgHQ13538.npy +imgHQ25377.npy +imgHQ03432.npy +imgHQ15941.npy +imgHQ07389.npy +imgHQ04869.npy +imgHQ12033.npy +imgHQ15831.npy +imgHQ25220.npy +imgHQ22963.npy +imgHQ02987.npy +imgHQ16171.npy +imgHQ16594.npy +imgHQ02587.npy +imgHQ02214.npy +imgHQ17023.npy +imgHQ15884.npy +imgHQ16014.npy +imgHQ05466.npy +imgHQ28067.npy +imgHQ17131.npy +imgHQ28547.npy +imgHQ19980.npy +imgHQ04847.npy +imgHQ23007.npy +imgHQ23011.npy +imgHQ20028.npy +imgHQ26595.npy +imgHQ15862.npy +imgHQ23727.npy +imgHQ16322.npy +imgHQ06844.npy +imgHQ21283.npy +imgHQ06250.npy +imgHQ23555.npy +imgHQ19351.npy +imgHQ26634.npy +imgHQ12302.npy +imgHQ13458.npy +imgHQ14534.npy +imgHQ16737.npy +imgHQ21991.npy +imgHQ25760.npy +imgHQ11059.npy +imgHQ01198.npy +imgHQ03874.npy +imgHQ25983.npy +imgHQ09358.npy +imgHQ21994.npy +imgHQ15506.npy +imgHQ24474.npy +imgHQ14047.npy +imgHQ10567.npy +imgHQ10507.npy +imgHQ15492.npy +imgHQ19388.npy +imgHQ00416.npy +imgHQ08321.npy +imgHQ15344.npy +imgHQ11461.npy +imgHQ20734.npy +imgHQ17649.npy +imgHQ10352.npy +imgHQ04237.npy +imgHQ27231.npy +imgHQ10597.npy +imgHQ17646.npy +imgHQ14465.npy +imgHQ04497.npy +imgHQ16803.npy +imgHQ11809.npy +imgHQ05643.npy +imgHQ13542.npy +imgHQ07483.npy +imgHQ21215.npy +imgHQ29422.npy +imgHQ21889.npy +imgHQ15149.npy +imgHQ11148.npy +imgHQ07611.npy +imgHQ27931.npy +imgHQ10547.npy +imgHQ07630.npy +imgHQ08294.npy +imgHQ27166.npy +imgHQ04991.npy +imgHQ22600.npy +imgHQ01116.npy +imgHQ16354.npy +imgHQ17006.npy +imgHQ02986.npy +imgHQ17261.npy +imgHQ22687.npy +imgHQ17794.npy +imgHQ13832.npy +imgHQ20268.npy +imgHQ28159.npy +imgHQ21740.npy +imgHQ01780.npy +imgHQ01013.npy +imgHQ03547.npy +imgHQ03024.npy +imgHQ20196.npy +imgHQ03968.npy +imgHQ09502.npy +imgHQ00185.npy +imgHQ07920.npy +imgHQ06053.npy +imgHQ27544.npy +imgHQ22091.npy +imgHQ29370.npy +imgHQ23075.npy +imgHQ03739.npy +imgHQ19668.npy +imgHQ26374.npy +imgHQ15345.npy +imgHQ15125.npy +imgHQ24041.npy +imgHQ10722.npy +imgHQ25825.npy +imgHQ21946.npy +imgHQ19473.npy +imgHQ07100.npy +imgHQ22775.npy +imgHQ01810.npy +imgHQ01479.npy +imgHQ03890.npy +imgHQ25616.npy +imgHQ24134.npy +imgHQ14449.npy +imgHQ21015.npy +imgHQ04135.npy +imgHQ28104.npy +imgHQ05302.npy +imgHQ01806.npy +imgHQ16414.npy +imgHQ26379.npy +imgHQ21926.npy +imgHQ13476.npy +imgHQ05917.npy +imgHQ11746.npy +imgHQ01376.npy +imgHQ14034.npy +imgHQ15814.npy +imgHQ25697.npy +imgHQ02919.npy +imgHQ02016.npy +imgHQ01875.npy +imgHQ09313.npy +imgHQ08298.npy +imgHQ16609.npy +imgHQ06365.npy +imgHQ19139.npy +imgHQ20217.npy +imgHQ29264.npy +imgHQ29105.npy +imgHQ10084.npy +imgHQ00096.npy +imgHQ13665.npy +imgHQ18743.npy +imgHQ16411.npy +imgHQ14958.npy +imgHQ03306.npy +imgHQ08001.npy +imgHQ01187.npy +imgHQ00070.npy +imgHQ03217.npy +imgHQ09251.npy +imgHQ02692.npy +imgHQ14585.npy +imgHQ09091.npy +imgHQ25290.npy +imgHQ11532.npy +imgHQ27183.npy +imgHQ19918.npy +imgHQ26280.npy +imgHQ17160.npy +imgHQ24691.npy +imgHQ20807.npy +imgHQ16421.npy +imgHQ13245.npy +imgHQ20046.npy +imgHQ06405.npy +imgHQ08660.npy +imgHQ11366.npy +imgHQ27130.npy +imgHQ27023.npy +imgHQ23170.npy +imgHQ20229.npy +imgHQ21199.npy +imgHQ18955.npy +imgHQ10010.npy +imgHQ15042.npy +imgHQ28769.npy +imgHQ01575.npy +imgHQ07681.npy +imgHQ19612.npy +imgHQ03756.npy +imgHQ27285.npy +imgHQ12745.npy +imgHQ19475.npy +imgHQ05074.npy +imgHQ11863.npy +imgHQ13978.npy +imgHQ04583.npy +imgHQ01833.npy +imgHQ27185.npy +imgHQ03699.npy +imgHQ24172.npy +imgHQ26705.npy +imgHQ12462.npy +imgHQ08020.npy +imgHQ27831.npy +imgHQ01755.npy +imgHQ01246.npy +imgHQ09653.npy +imgHQ20206.npy +imgHQ12708.npy +imgHQ14149.npy +imgHQ03571.npy +imgHQ24517.npy +imgHQ03709.npy +imgHQ24126.npy +imgHQ05015.npy +imgHQ08242.npy +imgHQ07499.npy +imgHQ15101.npy +imgHQ26430.npy +imgHQ07375.npy +imgHQ13707.npy +imgHQ02494.npy +imgHQ11081.npy +imgHQ18751.npy +imgHQ26188.npy +imgHQ12425.npy +imgHQ11341.npy +imgHQ17425.npy +imgHQ20347.npy +imgHQ27892.npy +imgHQ04128.npy +imgHQ20705.npy +imgHQ07071.npy +imgHQ18982.npy +imgHQ03399.npy +imgHQ06056.npy +imgHQ09723.npy +imgHQ17301.npy +imgHQ04016.npy +imgHQ23761.npy +imgHQ02240.npy +imgHQ05007.npy +imgHQ28986.npy +imgHQ29743.npy +imgHQ15673.npy +imgHQ19845.npy +imgHQ19001.npy +imgHQ24051.npy +imgHQ02122.npy +imgHQ16999.npy +imgHQ10100.npy +imgHQ18630.npy +imgHQ11235.npy +imgHQ25352.npy +imgHQ14022.npy +imgHQ00765.npy +imgHQ08572.npy +imgHQ20668.npy +imgHQ26790.npy +imgHQ15597.npy +imgHQ21780.npy +imgHQ29894.npy +imgHQ27639.npy +imgHQ24173.npy +imgHQ01596.npy +imgHQ23236.npy +imgHQ11142.npy +imgHQ20776.npy +imgHQ22366.npy +imgHQ22098.npy +imgHQ22988.npy +imgHQ24463.npy +imgHQ10018.npy +imgHQ19817.npy +imgHQ05624.npy +imgHQ03419.npy +imgHQ01530.npy +imgHQ19398.npy +imgHQ14813.npy +imgHQ03954.npy +imgHQ09005.npy +imgHQ01866.npy +imgHQ06256.npy +imgHQ01064.npy +imgHQ18741.npy +imgHQ17169.npy +imgHQ23107.npy +imgHQ00020.npy +imgHQ02522.npy +imgHQ05638.npy +imgHQ27108.npy +imgHQ17542.npy +imgHQ17214.npy +imgHQ28246.npy +imgHQ13141.npy +imgHQ04766.npy +imgHQ02814.npy +imgHQ20922.npy +imgHQ04263.npy +imgHQ23674.npy +imgHQ17675.npy +imgHQ17830.npy +imgHQ16830.npy +imgHQ01894.npy +imgHQ08770.npy +imgHQ09276.npy +imgHQ19042.npy +imgHQ02308.npy +imgHQ04498.npy +imgHQ08039.npy +imgHQ08735.npy +imgHQ22082.npy +imgHQ27045.npy +imgHQ14188.npy +imgHQ10744.npy +imgHQ08125.npy +imgHQ12349.npy +imgHQ11859.npy +imgHQ25842.npy +imgHQ23695.npy +imgHQ01760.npy +imgHQ07522.npy +imgHQ16002.npy +imgHQ22562.npy +imgHQ18399.npy +imgHQ26048.npy +imgHQ23554.npy +imgHQ20064.npy +imgHQ03374.npy +imgHQ19052.npy +imgHQ04759.npy +imgHQ07093.npy +imgHQ09247.npy +imgHQ24486.npy +imgHQ27600.npy +imgHQ04012.npy +imgHQ00892.npy +imgHQ27204.npy +imgHQ20863.npy +imgHQ02406.npy +imgHQ04338.npy +imgHQ27747.npy +imgHQ16512.npy +imgHQ29930.npy +imgHQ01505.npy +imgHQ24444.npy +imgHQ14029.npy +imgHQ03463.npy +imgHQ12664.npy +imgHQ14535.npy +imgHQ06827.npy +imgHQ21828.npy +imgHQ11448.npy +imgHQ23202.npy +imgHQ16942.npy +imgHQ04727.npy +imgHQ13212.npy +imgHQ08744.npy +imgHQ12590.npy +imgHQ11616.npy +imgHQ25176.npy +imgHQ29013.npy +imgHQ02116.npy +imgHQ21051.npy +imgHQ07628.npy +imgHQ27881.npy +imgHQ25073.npy +imgHQ23588.npy +imgHQ29392.npy +imgHQ15496.npy +imgHQ29183.npy +imgHQ28362.npy +imgHQ03443.npy +imgHQ21831.npy +imgHQ06586.npy +imgHQ24265.npy +imgHQ12825.npy +imgHQ27918.npy +imgHQ02553.npy +imgHQ27353.npy +imgHQ25364.npy +imgHQ14125.npy +imgHQ17010.npy +imgHQ05138.npy +imgHQ15765.npy +imgHQ02445.npy +imgHQ14397.npy +imgHQ22248.npy +imgHQ02770.npy +imgHQ11093.npy +imgHQ01365.npy +imgHQ25582.npy +imgHQ15350.npy +imgHQ21877.npy +imgHQ10061.npy +imgHQ08444.npy +imgHQ28059.npy +imgHQ29774.npy +imgHQ17975.npy +imgHQ25440.npy +imgHQ09115.npy +imgHQ28331.npy +imgHQ19297.npy +imgHQ06703.npy +imgHQ04854.npy +imgHQ11940.npy +imgHQ24698.npy +imgHQ04993.npy +imgHQ26701.npy +imgHQ04060.npy +imgHQ05867.npy +imgHQ07262.npy +imgHQ08492.npy +imgHQ21863.npy +imgHQ08075.npy +imgHQ01062.npy +imgHQ11690.npy +imgHQ07282.npy +imgHQ24596.npy +imgHQ04189.npy +imgHQ01690.npy +imgHQ23397.npy +imgHQ08035.npy +imgHQ25462.npy +imgHQ16398.npy +imgHQ18858.npy +imgHQ11771.npy +imgHQ05749.npy +imgHQ18445.npy +imgHQ14951.npy +imgHQ25262.npy +imgHQ22492.npy +imgHQ01278.npy +imgHQ02941.npy +imgHQ28737.npy +imgHQ15501.npy +imgHQ03485.npy +imgHQ01115.npy +imgHQ25509.npy +imgHQ08272.npy +imgHQ05213.npy +imgHQ12160.npy +imgHQ03826.npy +imgHQ08746.npy +imgHQ19504.npy +imgHQ27340.npy +imgHQ07543.npy +imgHQ25860.npy +imgHQ06895.npy +imgHQ01297.npy +imgHQ26405.npy +imgHQ27186.npy +imgHQ24446.npy +imgHQ08538.npy +imgHQ28787.npy +imgHQ16680.npy +imgHQ14054.npy +imgHQ20961.npy +imgHQ18035.npy +imgHQ11942.npy +imgHQ23614.npy +imgHQ18348.npy +imgHQ10843.npy +imgHQ01660.npy +imgHQ21909.npy +imgHQ10805.npy +imgHQ16772.npy +imgHQ25758.npy +imgHQ03006.npy +imgHQ06510.npy +imgHQ24730.npy +imgHQ19902.npy +imgHQ29961.npy +imgHQ14227.npy +imgHQ19426.npy +imgHQ13285.npy +imgHQ08090.npy +imgHQ07044.npy +imgHQ01250.npy +imgHQ28618.npy +imgHQ17920.npy +imgHQ25145.npy +imgHQ02643.npy +imgHQ06141.npy +imgHQ03284.npy +imgHQ02003.npy +imgHQ04995.npy +imgHQ13748.npy +imgHQ27596.npy +imgHQ29923.npy +imgHQ14798.npy +imgHQ10204.npy +imgHQ23994.npy +imgHQ17130.npy +imgHQ12665.npy +imgHQ17982.npy +imgHQ12353.npy +imgHQ16007.npy +imgHQ00779.npy +imgHQ14233.npy +imgHQ17426.npy +imgHQ27344.npy +imgHQ22746.npy +imgHQ12919.npy +imgHQ21052.npy +imgHQ04022.npy +imgHQ29214.npy +imgHQ07827.npy +imgHQ29005.npy +imgHQ14068.npy +imgHQ17439.npy +imgHQ13115.npy +imgHQ05416.npy +imgHQ25994.npy +imgHQ06983.npy +imgHQ15494.npy +imgHQ26037.npy +imgHQ02408.npy +imgHQ08958.npy +imgHQ01710.npy +imgHQ22128.npy +imgHQ22830.npy +imgHQ26360.npy +imgHQ27244.npy +imgHQ11580.npy +imgHQ21032.npy +imgHQ18255.npy +imgHQ20314.npy +imgHQ07816.npy +imgHQ20574.npy +imgHQ00937.npy +imgHQ17122.npy +imgHQ29854.npy +imgHQ13168.npy +imgHQ19076.npy +imgHQ17002.npy +imgHQ11401.npy +imgHQ21898.npy +imgHQ01645.npy +imgHQ21073.npy +imgHQ20789.npy +imgHQ27055.npy +imgHQ21884.npy +imgHQ22204.npy +imgHQ11838.npy +imgHQ16237.npy +imgHQ25580.npy +imgHQ05842.npy +imgHQ17916.npy +imgHQ15962.npy +imgHQ20365.npy +imgHQ07527.npy +imgHQ07036.npy +imgHQ17000.npy +imgHQ17739.npy +imgHQ11326.npy +imgHQ01382.npy +imgHQ18067.npy +imgHQ06162.npy +imgHQ27984.npy +imgHQ26571.npy +imgHQ09374.npy +imgHQ15935.npy +imgHQ07795.npy +imgHQ24368.npy +imgHQ07154.npy +imgHQ17117.npy +imgHQ10440.npy +imgHQ29975.npy +imgHQ06281.npy +imgHQ23785.npy +imgHQ17968.npy +imgHQ17950.npy +imgHQ01191.npy +imgHQ02440.npy +imgHQ12406.npy +imgHQ02799.npy +imgHQ24092.npy +imgHQ03511.npy +imgHQ22986.npy +imgHQ20880.npy +imgHQ02400.npy +imgHQ09305.npy +imgHQ15321.npy +imgHQ00434.npy +imgHQ24900.npy +imgHQ08499.npy +imgHQ28200.npy +imgHQ04473.npy +imgHQ03019.npy +imgHQ02812.npy +imgHQ27311.npy +imgHQ07475.npy +imgHQ22320.npy +imgHQ12690.npy +imgHQ07377.npy +imgHQ09960.npy +imgHQ29616.npy +imgHQ10535.npy +imgHQ22580.npy +imgHQ29379.npy +imgHQ08099.npy +imgHQ16866.npy +imgHQ04169.npy +imgHQ14147.npy +imgHQ23251.npy +imgHQ23608.npy +imgHQ22094.npy +imgHQ01543.npy +imgHQ19855.npy +imgHQ18996.npy +imgHQ19416.npy +imgHQ07668.npy +imgHQ15732.npy +imgHQ10892.npy +imgHQ22383.npy +imgHQ06393.npy +imgHQ13750.npy +imgHQ02107.npy +imgHQ06588.npy +imgHQ25271.npy +imgHQ09551.npy +imgHQ17513.npy +imgHQ10375.npy +imgHQ28785.npy +imgHQ02722.npy +imgHQ07878.npy +imgHQ19773.npy +imgHQ20509.npy +imgHQ27811.npy +imgHQ11831.npy +imgHQ06926.npy +imgHQ15000.npy +imgHQ08724.npy +imgHQ24919.npy +imgHQ13109.npy +imgHQ06338.npy +imgHQ08072.npy +imgHQ26941.npy +imgHQ05196.npy +imgHQ20940.npy +imgHQ08355.npy +imgHQ24665.npy +imgHQ01353.npy +imgHQ04488.npy +imgHQ16723.npy +imgHQ15889.npy +imgHQ04228.npy +imgHQ27301.npy +imgHQ17698.npy +imgHQ23256.npy +imgHQ27695.npy +imgHQ02657.npy +imgHQ15530.npy +imgHQ22833.npy +imgHQ16786.npy +imgHQ14145.npy +imgHQ12300.npy +imgHQ15201.npy +imgHQ27072.npy +imgHQ03055.npy +imgHQ13645.npy +imgHQ25538.npy +imgHQ02321.npy +imgHQ10519.npy +imgHQ11036.npy +imgHQ04936.npy +imgHQ19337.npy +imgHQ22954.npy +imgHQ13056.npy +imgHQ10323.npy +imgHQ29344.npy +imgHQ26317.npy +imgHQ14835.npy +imgHQ06274.npy +imgHQ18158.npy +imgHQ03781.npy +imgHQ07769.npy +imgHQ15876.npy +imgHQ08619.npy +imgHQ14536.npy +imgHQ06702.npy +imgHQ11857.npy +imgHQ06760.npy +imgHQ27484.npy +imgHQ25979.npy +imgHQ09803.npy +imgHQ28082.npy +imgHQ15635.npy +imgHQ26246.npy +imgHQ25796.npy +imgHQ04129.npy +imgHQ15705.npy +imgHQ00940.npy +imgHQ14696.npy +imgHQ28195.npy +imgHQ29163.npy +imgHQ10301.npy +imgHQ13564.npy +imgHQ05865.npy +imgHQ01406.npy +imgHQ01786.npy +imgHQ02000.npy +imgHQ24140.npy +imgHQ14772.npy +imgHQ17912.npy +imgHQ14750.npy +imgHQ23422.npy +imgHQ13054.npy +imgHQ24375.npy +imgHQ15922.npy +imgHQ18556.npy +imgHQ04041.npy +imgHQ13721.npy +imgHQ02535.npy +imgHQ23847.npy +imgHQ02352.npy +imgHQ09987.npy +imgHQ15802.npy +imgHQ14031.npy +imgHQ08942.npy +imgHQ03662.npy +imgHQ19059.npy +imgHQ09004.npy +imgHQ02235.npy +imgHQ24757.npy +imgHQ25934.npy +imgHQ29448.npy +imgHQ17380.npy +imgHQ19461.npy +imgHQ22068.npy +imgHQ08235.npy +imgHQ07757.npy +imgHQ22770.npy +imgHQ20953.npy +imgHQ17480.npy +imgHQ06265.npy +imgHQ12582.npy +imgHQ19545.npy +imgHQ25851.npy +imgHQ03786.npy +imgHQ02569.npy +imgHQ20727.npy +imgHQ24129.npy +imgHQ27477.npy +imgHQ00966.npy +imgHQ15005.npy +imgHQ20840.npy +imgHQ19265.npy +imgHQ09519.npy +imgHQ10739.npy +imgHQ20385.npy +imgHQ27277.npy +imgHQ07060.npy +imgHQ04229.npy +imgHQ01867.npy +imgHQ22949.npy +imgHQ04076.npy +imgHQ15658.npy +imgHQ17695.npy +imgHQ02944.npy +imgHQ22839.npy +imgHQ00112.npy +imgHQ11014.npy +imgHQ10875.npy +imgHQ19244.npy +imgHQ06679.npy +imgHQ27464.npy +imgHQ27699.npy +imgHQ23712.npy +imgHQ05267.npy +imgHQ09913.npy +imgHQ18040.npy +imgHQ02144.npy +imgHQ20374.npy +imgHQ24959.npy +imgHQ21741.npy +imgHQ26034.npy +imgHQ25116.npy +imgHQ16205.npy +imgHQ08921.npy +imgHQ10681.npy +imgHQ03386.npy +imgHQ23464.npy +imgHQ18120.npy +imgHQ06048.npy +imgHQ05595.npy +imgHQ09672.npy +imgHQ08817.npy +imgHQ24630.npy +imgHQ09271.npy +imgHQ09827.npy +imgHQ01514.npy +imgHQ29597.npy +imgHQ13688.npy +imgHQ10858.npy +imgHQ18807.npy +imgHQ28154.npy +imgHQ03251.npy +imgHQ14780.npy +imgHQ25572.npy +imgHQ16263.npy +imgHQ27390.npy +imgHQ25442.npy +imgHQ03598.npy +imgHQ09242.npy +imgHQ04965.npy +imgHQ28815.npy +imgHQ15355.npy +imgHQ23023.npy +imgHQ05897.npy +imgHQ00021.npy +imgHQ07952.npy +imgHQ07649.npy +imgHQ13772.npy +imgHQ25707.npy +imgHQ05424.npy +imgHQ04942.npy +imgHQ12387.npy +imgHQ14560.npy +imgHQ26355.npy +imgHQ19958.npy +imgHQ19588.npy +imgHQ22693.npy +imgHQ21337.npy +imgHQ24296.npy +imgHQ07457.npy +imgHQ13279.npy +imgHQ02128.npy +imgHQ12968.npy +imgHQ05488.npy +imgHQ26546.npy +imgHQ21693.npy +imgHQ27854.npy +imgHQ00535.npy +imgHQ12817.npy +imgHQ03241.npy +imgHQ20348.npy +imgHQ14736.npy +imgHQ21118.npy +imgHQ18837.npy +imgHQ19829.npy +imgHQ02261.npy +imgHQ00248.npy +imgHQ00441.npy +imgHQ21364.npy +imgHQ01954.npy +imgHQ04662.npy +imgHQ03484.npy +imgHQ03059.npy +imgHQ10412.npy +imgHQ19631.npy +imgHQ06172.npy +imgHQ25634.npy +imgHQ02335.npy +imgHQ20610.npy +imgHQ14367.npy +imgHQ23856.npy +imgHQ07025.npy +imgHQ20591.npy +imgHQ06669.npy +imgHQ03063.npy +imgHQ22229.npy +imgHQ24996.npy +imgHQ09458.npy +imgHQ02897.npy +imgHQ13424.npy +imgHQ08989.npy +imgHQ12557.npy +imgHQ17586.npy +imgHQ15442.npy +imgHQ00041.npy +imgHQ10005.npy +imgHQ01531.npy +imgHQ24666.npy +imgHQ06074.npy +imgHQ00706.npy +imgHQ21750.npy +imgHQ26308.npy +imgHQ23811.npy +imgHQ24672.npy +imgHQ20331.npy +imgHQ00167.npy +imgHQ17021.npy +imgHQ27233.npy +imgHQ10846.npy +imgHQ19609.npy +imgHQ10651.npy +imgHQ15613.npy +imgHQ08359.npy +imgHQ12226.npy +imgHQ15581.npy +imgHQ18390.npy +imgHQ10647.npy +imgHQ02915.npy +imgHQ12144.npy +imgHQ13674.npy +imgHQ01213.npy +imgHQ18871.npy +imgHQ23184.npy +imgHQ29772.npy +imgHQ10738.npy +imgHQ07866.npy +imgHQ19567.npy +imgHQ22720.npy +imgHQ02955.npy +imgHQ11885.npy +imgHQ09923.npy +imgHQ19483.npy +imgHQ22495.npy +imgHQ08110.npy +imgHQ21551.npy +imgHQ03051.npy +imgHQ08901.npy +imgHQ17210.npy +imgHQ09878.npy +imgHQ25714.npy +imgHQ22379.npy +imgHQ18368.npy +imgHQ20747.npy +imgHQ14184.npy +imgHQ09874.npy +imgHQ25701.npy +imgHQ02394.npy +imgHQ22394.npy +imgHQ15073.npy +imgHQ12738.npy +imgHQ29230.npy +imgHQ12100.npy +imgHQ06004.npy +imgHQ28357.npy +imgHQ25192.npy +imgHQ07622.npy +imgHQ10786.npy +imgHQ19032.npy +imgHQ21225.npy +imgHQ13023.npy +imgHQ24307.npy +imgHQ27114.npy +imgHQ14310.npy +imgHQ09942.npy +imgHQ14057.npy +imgHQ28888.npy +imgHQ07155.npy +imgHQ16612.npy +imgHQ26252.npy +imgHQ20111.npy +imgHQ27530.npy +imgHQ16391.npy +imgHQ29018.npy +imgHQ08209.npy +imgHQ29954.npy +imgHQ20889.npy +imgHQ23130.npy +imgHQ10536.npy +imgHQ26010.npy +imgHQ26435.npy +imgHQ03162.npy +imgHQ18137.npy +imgHQ13215.npy +imgHQ15522.npy +imgHQ25542.npy +imgHQ22301.npy +imgHQ04799.npy +imgHQ20512.npy +imgHQ12951.npy +imgHQ03904.npy +imgHQ14511.npy +imgHQ05893.npy +imgHQ03761.npy +imgHQ10013.npy +imgHQ14363.npy +imgHQ20006.npy +imgHQ27190.npy +imgHQ17672.npy +imgHQ11510.npy +imgHQ13287.npy +imgHQ07544.npy +imgHQ00085.npy +imgHQ11138.npy +imgHQ07314.npy +imgHQ19671.npy +imgHQ10331.npy +imgHQ22201.npy +imgHQ25517.npy +imgHQ28304.npy +imgHQ20618.npy +imgHQ27818.npy +imgHQ16801.npy +imgHQ22911.npy +imgHQ03763.npy +imgHQ24806.npy +imgHQ12626.npy +imgHQ16061.npy +imgHQ18757.npy +imgHQ09998.npy +imgHQ14274.npy +imgHQ13445.npy +imgHQ28974.npy +imgHQ26894.npy +imgHQ14968.npy +imgHQ12468.npy +imgHQ22423.npy +imgHQ27825.npy +imgHQ20160.npy +imgHQ16909.npy +imgHQ13364.npy +imgHQ11023.npy +imgHQ25560.npy +imgHQ04465.npy +imgHQ14795.npy +imgHQ10361.npy +imgHQ29736.npy +imgHQ18702.npy +imgHQ08547.npy +imgHQ19458.npy +imgHQ14199.npy +imgHQ09239.npy +imgHQ13274.npy +imgHQ24525.npy +imgHQ14924.npy +imgHQ02808.npy +imgHQ17958.npy +imgHQ06171.npy +imgHQ13796.npy +imgHQ23442.npy +imgHQ28603.npy +imgHQ04514.npy +imgHQ09978.npy +imgHQ26777.npy +imgHQ11481.npy +imgHQ22226.npy +imgHQ04518.npy +imgHQ14314.npy +imgHQ17145.npy +imgHQ00579.npy +imgHQ02218.npy +imgHQ29369.npy +imgHQ15402.npy +imgHQ07554.npy +imgHQ11320.npy +imgHQ29833.npy +imgHQ08636.npy +imgHQ04581.npy +imgHQ20571.npy +imgHQ25506.npy +imgHQ28789.npy +imgHQ25619.npy +imgHQ09777.npy +imgHQ07559.npy +imgHQ27439.npy +imgHQ14671.npy +imgHQ10721.npy +imgHQ08147.npy +imgHQ24761.npy +imgHQ10666.npy +imgHQ13612.npy +imgHQ10771.npy +imgHQ11008.npy +imgHQ19260.npy +imgHQ13457.npy +imgHQ27907.npy +imgHQ25405.npy +imgHQ29574.npy +imgHQ14305.npy +imgHQ05479.npy +imgHQ17491.npy +imgHQ09026.npy +imgHQ13452.npy +imgHQ01578.npy +imgHQ08404.npy +imgHQ15372.npy +imgHQ22798.npy +imgHQ20962.npy +imgHQ16156.npy +imgHQ09652.npy +imgHQ11684.npy +imgHQ23364.npy +imgHQ06377.npy +imgHQ28048.npy +imgHQ19603.npy +imgHQ16003.npy +imgHQ10530.npy +imgHQ08501.npy +imgHQ15403.npy +imgHQ14086.npy +imgHQ23386.npy +imgHQ03792.npy +imgHQ09902.npy +imgHQ20825.npy +imgHQ21977.npy +imgHQ02499.npy +imgHQ27667.npy +imgHQ04521.npy +imgHQ21392.npy +imgHQ19547.npy +imgHQ11896.npy +imgHQ16760.npy +imgHQ13926.npy +imgHQ19039.npy +imgHQ05764.npy +imgHQ24724.npy +imgHQ13940.npy +imgHQ01902.npy +imgHQ25929.npy +imgHQ28957.npy +imgHQ03528.npy +imgHQ19003.npy +imgHQ06658.npy +imgHQ07988.npy +imgHQ27753.npy +imgHQ16234.npy +imgHQ19884.npy +imgHQ00540.npy +imgHQ25991.npy +imgHQ21154.npy +imgHQ09496.npy +imgHQ27129.npy +imgHQ01680.npy +imgHQ19920.npy +imgHQ23149.npy +imgHQ11364.npy +imgHQ15973.npy +imgHQ13675.npy +imgHQ24145.npy +imgHQ23930.npy +imgHQ19974.npy +imgHQ05201.npy +imgHQ08954.npy +imgHQ27378.npy +imgHQ17097.npy +imgHQ06929.npy +imgHQ20936.npy +imgHQ07873.npy +imgHQ24934.npy +imgHQ21897.npy +imgHQ03875.npy +imgHQ05510.npy +imgHQ19890.npy +imgHQ02290.npy +imgHQ08816.npy +imgHQ14460.npy +imgHQ18021.npy +imgHQ07949.npy +imgHQ11830.npy +imgHQ16360.npy +imgHQ04621.npy +imgHQ00036.npy +imgHQ16551.npy +imgHQ22149.npy +imgHQ03959.npy +imgHQ19627.npy +imgHQ18935.npy +imgHQ17770.npy +imgHQ28978.npy +imgHQ18235.npy +imgHQ28184.npy +imgHQ10563.npy +imgHQ01834.npy +imgHQ28406.npy +imgHQ16535.npy +imgHQ29116.npy +imgHQ11256.npy +imgHQ19933.npy +imgHQ27893.npy +imgHQ21804.npy +imgHQ02075.npy +imgHQ26086.npy +imgHQ25583.npy +imgHQ03659.npy +imgHQ16311.npy +imgHQ12551.npy +imgHQ14544.npy +imgHQ14590.npy +imgHQ05152.npy +imgHQ27571.npy +imgHQ22276.npy +imgHQ19020.npy +imgHQ26897.npy +imgHQ07413.npy +imgHQ15565.npy +imgHQ28688.npy +imgHQ27442.npy +imgHQ16790.npy +imgHQ02858.npy +imgHQ23552.npy +imgHQ21854.npy +imgHQ25430.npy +imgHQ11367.npy +imgHQ06795.npy +imgHQ12262.npy +imgHQ05492.npy +imgHQ14026.npy +imgHQ25269.npy +imgHQ27991.npy +imgHQ12991.npy +imgHQ28291.npy +imgHQ22254.npy +imgHQ26123.npy +imgHQ17547.npy +imgHQ01313.npy +imgHQ07289.npy +imgHQ15446.npy +imgHQ08379.npy +imgHQ20199.npy +imgHQ04607.npy +imgHQ03235.npy +imgHQ18937.npy +imgHQ11244.npy +imgHQ16139.npy +imgHQ20049.npy +imgHQ28990.npy +imgHQ24490.npy +imgHQ20093.npy +imgHQ28094.npy +imgHQ01404.npy +imgHQ02300.npy +imgHQ23092.npy +imgHQ24788.npy +imgHQ26789.npy +imgHQ04944.npy +imgHQ17249.npy +imgHQ07166.npy +imgHQ02861.npy +imgHQ22918.npy +imgHQ21163.npy +imgHQ18942.npy +imgHQ25361.npy +imgHQ19500.npy +imgHQ05197.npy +imgHQ26328.npy +imgHQ24116.npy +imgHQ07512.npy +imgHQ00066.npy +imgHQ04510.npy +imgHQ08591.npy +imgHQ11154.npy +imgHQ01390.npy +imgHQ24833.npy +imgHQ06822.npy +imgHQ29675.npy +imgHQ16040.npy +imgHQ07351.npy +imgHQ23935.npy +imgHQ14885.npy +imgHQ21875.npy +imgHQ04008.npy +imgHQ02135.npy +imgHQ06473.npy +imgHQ00225.npy +imgHQ05190.npy +imgHQ16917.npy +imgHQ15186.npy +imgHQ13138.npy +imgHQ26824.npy +imgHQ10661.npy +imgHQ12824.npy +imgHQ23988.npy +imgHQ11879.npy +imgHQ09073.npy +imgHQ12184.npy +imgHQ24475.npy +imgHQ06379.npy +imgHQ01980.npy +imgHQ23568.npy +imgHQ00722.npy +imgHQ13015.npy +imgHQ20312.npy +imgHQ18079.npy +imgHQ27013.npy +imgHQ21628.npy +imgHQ09048.npy +imgHQ27554.npy +imgHQ28684.npy +imgHQ03062.npy +imgHQ25443.npy +imgHQ25204.npy +imgHQ26352.npy +imgHQ22231.npy +imgHQ19942.npy +imgHQ19373.npy +imgHQ18295.npy +imgHQ19521.npy +imgHQ23019.npy +imgHQ19070.npy +imgHQ11111.npy +imgHQ10120.npy +imgHQ02054.npy +imgHQ25189.npy +imgHQ05030.npy +imgHQ15735.npy +imgHQ07260.npy +imgHQ09679.npy +imgHQ21806.npy +imgHQ06993.npy +imgHQ04558.npy +imgHQ20911.npy +imgHQ20085.npy +imgHQ22252.npy +imgHQ08975.npy +imgHQ11884.npy +imgHQ09505.npy +imgHQ10009.npy +imgHQ15713.npy +imgHQ18761.npy +imgHQ14055.npy +imgHQ06710.npy +imgHQ19065.npy +imgHQ01230.npy +imgHQ15820.npy +imgHQ20636.npy +imgHQ20764.npy +imgHQ16961.npy +imgHQ25082.npy +imgHQ12288.npy +imgHQ10171.npy +imgHQ01058.npy +imgHQ17357.npy +imgHQ09257.npy +imgHQ08711.npy +imgHQ08360.npy +imgHQ06427.npy +imgHQ22436.npy +imgHQ05903.npy +imgHQ05330.npy +imgHQ00785.npy +imgHQ02714.npy +imgHQ11952.npy +imgHQ03385.npy +imgHQ00636.npy +imgHQ05766.npy +imgHQ26682.npy +imgHQ17359.npy +imgHQ18267.npy +imgHQ18755.npy +imgHQ20256.npy +imgHQ27201.npy +imgHQ21130.npy +imgHQ09873.npy +imgHQ14623.npy +imgHQ18180.npy +imgHQ19790.npy +imgHQ24382.npy +imgHQ08113.npy +imgHQ24819.npy +imgHQ09161.npy +imgHQ06142.npy +imgHQ01735.npy +imgHQ25631.npy +imgHQ21303.npy +imgHQ22253.npy +imgHQ14107.npy +imgHQ21305.npy +imgHQ06819.npy +imgHQ16878.npy +imgHQ02254.npy +imgHQ26151.npy +imgHQ18864.npy +imgHQ02510.npy +imgHQ20831.npy +imgHQ10431.npy +imgHQ05310.npy +imgHQ10556.npy +imgHQ21529.npy +imgHQ10184.npy +imgHQ06369.npy +imgHQ08121.npy +imgHQ04507.npy +imgHQ11897.npy +imgHQ05853.npy +imgHQ01722.npy +imgHQ16568.npy +imgHQ12567.npy +imgHQ18259.npy +imgHQ21720.npy +imgHQ06478.npy +imgHQ19911.npy +imgHQ13649.npy +imgHQ29479.npy +imgHQ29735.npy +imgHQ15326.npy +imgHQ28289.npy +imgHQ20497.npy +imgHQ22946.npy +imgHQ29256.npy +imgHQ28992.npy +imgHQ03732.npy +imgHQ15117.npy +imgHQ12933.npy +imgHQ29958.npy +imgHQ03169.npy +imgHQ12696.npy +imgHQ03107.npy +imgHQ27723.npy +imgHQ10189.npy +imgHQ09378.npy +imgHQ26135.npy +imgHQ00954.npy +imgHQ16261.npy +imgHQ14655.npy +imgHQ18615.npy +imgHQ03242.npy +imgHQ16045.npy +imgHQ12454.npy +imgHQ05170.npy +imgHQ06269.npy +imgHQ21490.npy +imgHQ08759.npy +imgHQ06587.npy +imgHQ19206.npy +imgHQ03189.npy +imgHQ27094.npy +imgHQ28620.npy +imgHQ24468.npy +imgHQ08080.npy +imgHQ09381.npy +imgHQ08721.npy +imgHQ00577.npy +imgHQ16697.npy +imgHQ14664.npy +imgHQ10732.npy +imgHQ04626.npy +imgHQ05408.npy +imgHQ14439.npy +imgHQ29019.npy +imgHQ03056.npy +imgHQ19513.npy +imgHQ17869.npy +imgHQ07430.npy +imgHQ26175.npy +imgHQ17579.npy +imgHQ23326.npy +imgHQ14774.npy +imgHQ08269.npy +imgHQ04249.npy +imgHQ08623.npy +imgHQ27255.npy +imgHQ17256.npy +imgHQ26666.npy +imgHQ08343.npy +imgHQ22931.npy +imgHQ16038.npy +imgHQ26321.npy +imgHQ26170.npy +imgHQ12404.npy +imgHQ02044.npy +imgHQ17756.npy +imgHQ07652.npy +imgHQ16855.npy +imgHQ07922.npy +imgHQ14678.npy +imgHQ11965.npy +imgHQ12560.npy +imgHQ24266.npy +imgHQ20323.npy +imgHQ12895.npy +imgHQ02317.npy +imgHQ29456.npy +imgHQ29598.npy +imgHQ01016.npy +imgHQ13234.npy +imgHQ29337.npy +imgHQ17367.npy +imgHQ28386.npy +imgHQ12007.npy +imgHQ25639.npy +imgHQ26729.npy +imgHQ05890.npy +imgHQ24243.npy +imgHQ08951.npy +imgHQ22752.npy +imgHQ16875.npy +imgHQ27625.npy +imgHQ17812.npy +imgHQ24449.npy +imgHQ02425.npy +imgHQ03269.npy +imgHQ11798.npy +imgHQ19123.npy +imgHQ07846.npy +imgHQ19448.npy +imgHQ26872.npy +imgHQ29969.npy +imgHQ26184.npy +imgHQ27229.npy +imgHQ18468.npy +imgHQ10586.npy +imgHQ19914.npy +imgHQ18795.npy +imgHQ19571.npy +imgHQ16950.npy +imgHQ18115.npy +imgHQ11380.npy +imgHQ29491.npy +imgHQ03292.npy +imgHQ22259.npy +imgHQ17081.npy +imgHQ10877.npy +imgHQ08537.npy +imgHQ13977.npy +imgHQ04875.npy +imgHQ12315.npy +imgHQ16928.npy +imgHQ10292.npy +imgHQ13229.npy +imgHQ16051.npy +imgHQ15699.npy +imgHQ23377.npy +imgHQ04549.npy +imgHQ10503.npy +imgHQ11019.npy +imgHQ27735.npy +imgHQ25999.npy +imgHQ15010.npy +imgHQ26809.npy +imgHQ21180.npy +imgHQ18175.npy +imgHQ02170.npy +imgHQ21544.npy +imgHQ19342.npy +imgHQ28136.npy +imgHQ07130.npy +imgHQ25212.npy +imgHQ28404.npy +imgHQ23707.npy +imgHQ11960.npy +imgHQ26223.npy +imgHQ22588.npy +imgHQ09066.npy +imgHQ21576.npy +imgHQ17291.npy +imgHQ28418.npy +imgHQ17435.npy +imgHQ27385.npy +imgHQ02822.npy +imgHQ01268.npy +imgHQ21761.npy +imgHQ09454.npy +imgHQ16471.npy +imgHQ17339.npy +imgHQ07300.npy +imgHQ20803.npy +imgHQ11654.npy +imgHQ12506.npy +imgHQ15964.npy +imgHQ05698.npy +imgHQ17773.npy +imgHQ11022.npy +imgHQ26966.npy +imgHQ08479.npy +imgHQ01189.npy +imgHQ05653.npy +imgHQ08154.npy +imgHQ07225.npy +imgHQ11989.npy +imgHQ01918.npy +imgHQ08382.npy +imgHQ03642.npy +imgHQ05055.npy +imgHQ25064.npy +imgHQ21204.npy +imgHQ03479.npy +imgHQ22159.npy +imgHQ25931.npy +imgHQ18234.npy +imgHQ07900.npy +imgHQ18709.npy +imgHQ03520.npy +imgHQ27192.npy +imgHQ28717.npy +imgHQ11353.npy +imgHQ05576.npy +imgHQ16084.npy +imgHQ11446.npy +imgHQ11325.npy +imgHQ09557.npy +imgHQ29656.npy +imgHQ00615.npy +imgHQ24491.npy +imgHQ20077.npy +imgHQ14543.npy +imgHQ23245.npy +imgHQ06770.npy +imgHQ14210.npy +imgHQ06970.npy +imgHQ08364.npy +imgHQ10714.npy +imgHQ12214.npy +imgHQ20274.npy +imgHQ06110.npy +imgHQ20300.npy +imgHQ12254.npy +imgHQ12720.npy +imgHQ10416.npy +imgHQ09018.npy +imgHQ03334.npy +imgHQ18883.npy +imgHQ26521.npy +imgHQ05826.npy +imgHQ14446.npy +imgHQ05955.npy +imgHQ27782.npy +imgHQ11119.npy +imgHQ06801.npy +imgHQ19250.npy +imgHQ29768.npy +imgHQ18364.npy +imgHQ00754.npy +imgHQ24933.npy +imgHQ08354.npy +imgHQ12717.npy +imgHQ16898.npy +imgHQ08145.npy +imgHQ22602.npy +imgHQ16621.npy +imgHQ09756.npy +imgHQ22916.npy +imgHQ12090.npy +imgHQ14489.npy +imgHQ04946.npy +imgHQ00252.npy +imgHQ23008.npy +imgHQ06857.npy +imgHQ28230.npy +imgHQ04234.npy +imgHQ23794.npy +imgHQ16339.npy +imgHQ20333.npy +imgHQ14110.npy +imgHQ05567.npy +imgHQ28873.npy +imgHQ23316.npy +imgHQ07384.npy +imgHQ17576.npy +imgHQ21321.npy +imgHQ21455.npy +imgHQ20399.npy +imgHQ22462.npy +imgHQ06122.npy +imgHQ02310.npy +imgHQ20021.npy +imgHQ19236.npy +imgHQ13295.npy +imgHQ07633.npy +imgHQ16642.npy +imgHQ09856.npy +imgHQ19870.npy +imgHQ19645.npy +imgHQ19774.npy +imgHQ26150.npy +imgHQ27781.npy +imgHQ07921.npy +imgHQ02118.npy +imgHQ04293.npy +imgHQ17868.npy +imgHQ21143.npy +imgHQ01094.npy +imgHQ02350.npy +imgHQ13590.npy +imgHQ27147.npy +imgHQ17173.npy +imgHQ04597.npy +imgHQ26263.npy +imgHQ13783.npy +imgHQ02954.npy +imgHQ14618.npy +imgHQ24466.npy +imgHQ28502.npy +imgHQ28732.npy +imgHQ12908.npy +imgHQ04922.npy +imgHQ00411.npy +imgHQ06957.npy +imgHQ16049.npy +imgHQ16795.npy +imgHQ02052.npy +imgHQ26644.npy +imgHQ06836.npy +imgHQ29469.npy +imgHQ16599.npy +imgHQ25712.npy +imgHQ03499.npy +imgHQ24325.npy +imgHQ26164.npy +imgHQ03922.npy +imgHQ16116.npy +imgHQ17035.npy +imgHQ28472.npy +imgHQ29082.npy +imgHQ11344.npy +imgHQ06526.npy +imgHQ08218.npy +imgHQ25362.npy +imgHQ10306.npy +imgHQ20827.npy +imgHQ16099.npy +imgHQ29257.npy +imgHQ23465.npy +imgHQ04445.npy +imgHQ14135.npy +imgHQ29952.npy +imgHQ05658.npy +imgHQ24304.npy +imgHQ12876.npy +imgHQ26637.npy +imgHQ11107.npy +imgHQ07923.npy +imgHQ12671.npy +imgHQ21512.npy +imgHQ08068.npy +imgHQ18800.npy +imgHQ09801.npy +imgHQ10838.npy +imgHQ00037.npy +imgHQ02960.npy +imgHQ02224.npy +imgHQ10926.npy +imgHQ14395.npy +imgHQ13189.npy +imgHQ25871.npy +imgHQ20915.npy +imgHQ05996.npy +imgHQ03513.npy +imgHQ12082.npy +imgHQ26528.npy +imgHQ12227.npy +imgHQ03050.npy +imgHQ28313.npy +imgHQ25942.npy +imgHQ03977.npy +imgHQ22895.npy +imgHQ01545.npy +imgHQ03846.npy +imgHQ14651.npy +imgHQ00092.npy +imgHQ20508.npy +imgHQ29022.npy +imgHQ04493.npy +imgHQ15390.npy +imgHQ25174.npy +imgHQ02741.npy +imgHQ09593.npy +imgHQ28975.npy +imgHQ27356.npy +imgHQ26349.npy +imgHQ23494.npy +imgHQ21139.npy +imgHQ24095.npy +imgHQ11858.npy +imgHQ28721.npy +imgHQ02442.npy +imgHQ13149.npy +imgHQ13094.npy +imgHQ20800.npy +imgHQ12216.npy +imgHQ24026.npy +imgHQ03999.npy +imgHQ09534.npy +imgHQ08346.npy +imgHQ27341.npy +imgHQ21268.npy +imgHQ27812.npy +imgHQ27921.npy +imgHQ09150.npy +imgHQ10792.npy +imgHQ06475.npy +imgHQ14416.npy +imgHQ09097.npy +imgHQ22965.npy +imgHQ24481.npy +imgHQ27368.npy +imgHQ20181.npy +imgHQ18563.npy +imgHQ21300.npy +imgHQ00650.npy +imgHQ02294.npy +imgHQ17979.npy +imgHQ28064.npy +imgHQ19539.npy +imgHQ27708.npy +imgHQ04684.npy +imgHQ17686.npy +imgHQ12079.npy +imgHQ18222.npy +imgHQ06535.npy +imgHQ18838.npy +imgHQ01824.npy +imgHQ10235.npy +imgHQ27557.npy +imgHQ05587.npy +imgHQ24440.npy +imgHQ02426.npy +imgHQ27809.npy +imgHQ06179.npy +imgHQ29150.npy +imgHQ02055.npy +imgHQ24308.npy +imgHQ28982.npy +imgHQ11652.npy +imgHQ23869.npy +imgHQ28329.npy +imgHQ03158.npy +imgHQ25165.npy +imgHQ17089.npy +imgHQ07378.npy +imgHQ04241.npy +imgHQ21244.npy +imgHQ04049.npy +imgHQ05537.npy +imgHQ05255.npy +imgHQ19865.npy +imgHQ24267.npy +imgHQ22225.npy +imgHQ12099.npy +imgHQ09974.npy +imgHQ14823.npy +imgHQ05926.npy +imgHQ04905.npy +imgHQ04984.npy +imgHQ24399.npy +imgHQ27273.npy +imgHQ25800.npy +imgHQ00361.npy +imgHQ03089.npy +imgHQ29991.npy +imgHQ16854.npy +imgHQ20790.npy +imgHQ16683.npy +imgHQ04691.npy +imgHQ29297.npy +imgHQ02950.npy +imgHQ09832.npy +imgHQ07627.npy +imgHQ01738.npy +imgHQ06903.npy +imgHQ18311.npy +imgHQ10244.npy +imgHQ05819.npy +imgHQ02560.npy +imgHQ27507.npy +imgHQ21307.npy +imgHQ27476.npy +imgHQ28073.npy +imgHQ11559.npy +imgHQ15900.npy +imgHQ08882.npy +imgHQ27982.npy +imgHQ01104.npy +imgHQ10812.npy +imgHQ05004.npy +imgHQ28802.npy +imgHQ16389.npy +imgHQ23219.npy +imgHQ05652.npy +imgHQ16235.npy +imgHQ24703.npy +imgHQ22020.npy +imgHQ26728.npy +imgHQ04111.npy +imgHQ28905.npy +imgHQ07148.npy +imgHQ28002.npy +imgHQ21589.npy +imgHQ04224.npy +imgHQ08967.npy +imgHQ24194.npy +imgHQ07004.npy +imgHQ24929.npy +imgHQ04907.npy +imgHQ14105.npy +imgHQ22136.npy +imgHQ17450.npy +imgHQ06871.npy +imgHQ01538.npy +imgHQ08871.npy +imgHQ09736.npy +imgHQ00240.npy +imgHQ23813.npy +imgHQ04139.npy +imgHQ22827.npy +imgHQ19254.npy +imgHQ10723.npy +imgHQ13916.npy +imgHQ28579.npy +imgHQ16662.npy +imgHQ06229.npy +imgHQ08096.npy +imgHQ20534.npy +imgHQ21483.npy +imgHQ14816.npy +imgHQ16115.npy +imgHQ00772.npy +imgHQ21548.npy +imgHQ06716.npy +imgHQ04534.npy +imgHQ02162.npy +imgHQ08183.npy +imgHQ08455.npy +imgHQ22976.npy +imgHQ26772.npy +imgHQ25667.npy +imgHQ00423.npy +imgHQ27291.npy +imgHQ02581.npy +imgHQ13216.npy +imgHQ14414.npy +imgHQ07787.npy +imgHQ28026.npy +imgHQ14811.npy +imgHQ11833.npy +imgHQ14869.npy +imgHQ20633.npy +imgHQ11012.npy +imgHQ09885.npy +imgHQ19771.npy +imgHQ06629.npy +imgHQ08323.npy +imgHQ20896.npy +imgHQ04595.npy +imgHQ10629.npy +imgHQ13373.npy +imgHQ20007.npy +imgHQ23478.npy +imgHQ22448.npy +imgHQ07636.npy +imgHQ08889.npy +imgHQ10190.npy +imgHQ01171.npy +imgHQ15924.npy +imgHQ00126.npy +imgHQ23071.npy +imgHQ03248.npy +imgHQ07777.npy +imgHQ12938.npy +imgHQ26193.npy +imgHQ07332.npy +imgHQ00125.npy +imgHQ06808.npy +imgHQ15812.npy +imgHQ21769.npy +imgHQ08260.npy +imgHQ09888.npy +imgHQ08337.npy +imgHQ21979.npy +imgHQ22896.npy +imgHQ23668.npy +imgHQ06328.npy +imgHQ12493.npy +imgHQ21535.npy +imgHQ28878.npy +imgHQ26260.npy +imgHQ04087.npy +imgHQ22900.npy +imgHQ13970.npy +imgHQ28214.npy +imgHQ29301.npy +imgHQ13936.npy +imgHQ12571.npy +imgHQ22932.npy +imgHQ16752.npy +imgHQ15301.npy +imgHQ13333.npy +imgHQ20342.npy +imgHQ11602.npy +imgHQ28294.npy +imgHQ07702.npy +imgHQ19188.npy +imgHQ13585.npy +imgHQ29375.npy +imgHQ17377.npy +imgHQ05381.npy +imgHQ19141.npy +imgHQ05829.npy +imgHQ09854.npy +imgHQ16070.npy +imgHQ02124.npy +imgHQ20960.npy +imgHQ07493.npy +imgHQ19471.npy +imgHQ13812.npy +imgHQ27968.npy +imgHQ15950.npy +imgHQ03644.npy +imgHQ23903.npy +imgHQ05622.npy +imgHQ23926.npy +imgHQ02369.npy +imgHQ08535.npy +imgHQ00357.npy +imgHQ10748.npy +imgHQ17248.npy +imgHQ16239.npy +imgHQ20742.npy +imgHQ22975.npy +imgHQ29092.npy +imgHQ12619.npy +imgHQ13046.npy +imgHQ26063.npy +imgHQ09192.npy +imgHQ26868.npy +imgHQ26134.npy +imgHQ05901.npy +imgHQ18880.npy +imgHQ07489.npy +imgHQ22617.npy +imgHQ20428.npy +imgHQ09748.npy +imgHQ09928.npy +imgHQ08862.npy +imgHQ16619.npy +imgHQ14644.npy +imgHQ06628.npy +imgHQ19605.npy +imgHQ11330.npy +imgHQ22090.npy +imgHQ25816.npy +imgHQ04892.npy +imgHQ13270.npy +imgHQ20034.npy +imgHQ10888.npy +imgHQ06856.npy +imgHQ16952.npy +imgHQ10646.npy +imgHQ27862.npy +imgHQ29357.npy +imgHQ16625.npy +imgHQ00153.npy +imgHQ07578.npy +imgHQ19472.npy +imgHQ29820.npy +imgHQ17859.npy +imgHQ08727.npy +imgHQ16119.npy +imgHQ15191.npy +imgHQ17193.npy +imgHQ20858.npy +imgHQ09289.npy +imgHQ09340.npy +imgHQ24076.npy +imgHQ00581.npy +imgHQ10989.npy +imgHQ23246.npy +imgHQ20175.npy +imgHQ22296.npy +imgHQ14580.npy +imgHQ15848.npy +imgHQ24805.npy +imgHQ17945.npy +imgHQ09657.npy +imgHQ28407.npy +imgHQ18762.npy +imgHQ29771.npy +imgHQ29908.npy +imgHQ22621.npy +imgHQ27521.npy +imgHQ19115.npy +imgHQ09461.npy +imgHQ01379.npy +imgHQ15717.npy +imgHQ12705.npy +imgHQ19402.npy +imgHQ28263.npy +imgHQ02769.npy +imgHQ28065.npy +imgHQ11268.npy +imgHQ02252.npy +imgHQ20802.npy +imgHQ10196.npy +imgHQ27071.npy +imgHQ28827.npy +imgHQ03836.npy +imgHQ23832.npy +imgHQ09448.npy +imgHQ03619.npy +imgHQ08345.npy +imgHQ22663.npy +imgHQ15348.npy +imgHQ14004.npy +imgHQ03929.npy +imgHQ11988.npy +imgHQ26946.npy +imgHQ26356.npy +imgHQ01684.npy +imgHQ02711.npy +imgHQ15986.npy +imgHQ05178.npy +imgHQ20251.npy +imgHQ17774.npy +imgHQ05006.npy +imgHQ22996.npy +imgHQ06678.npy +imgHQ24342.npy +imgHQ06184.npy +imgHQ12962.npy +imgHQ00265.npy +imgHQ24409.npy +imgHQ25006.npy +imgHQ16511.npy +imgHQ04885.npy +imgHQ25005.npy +imgHQ04400.npy +imgHQ11568.npy +imgHQ14012.npy +imgHQ28377.npy +imgHQ17176.npy +imgHQ12298.npy +imgHQ01743.npy +imgHQ19196.npy +imgHQ04432.npy +imgHQ09139.npy +imgHQ19610.npy +imgHQ00388.npy +imgHQ18470.npy +imgHQ01388.npy +imgHQ06637.npy +imgHQ01699.npy +imgHQ19842.npy +imgHQ09137.npy +imgHQ06687.npy +imgHQ20650.npy +imgHQ12232.npy +imgHQ10400.npy +imgHQ01972.npy +imgHQ11381.npy +imgHQ29677.npy +imgHQ10821.npy +imgHQ23309.npy +imgHQ29591.npy +imgHQ03044.npy +imgHQ06463.npy +imgHQ27776.npy +imgHQ24270.npy +imgHQ09823.npy +imgHQ17498.npy +imgHQ02179.npy +imgHQ02730.npy +imgHQ08222.npy +imgHQ27871.npy +imgHQ03475.npy +imgHQ07753.npy +imgHQ03319.npy +imgHQ24465.npy +imgHQ00730.npy +imgHQ05406.npy +imgHQ22607.npy +imgHQ29651.npy +imgHQ18535.npy +imgHQ23474.npy +imgHQ09660.npy +imgHQ06530.npy +imgHQ01886.npy +imgHQ29800.npy +imgHQ14915.npy +imgHQ25569.npy +imgHQ24720.npy +imgHQ28251.npy +imgHQ14500.npy +imgHQ04137.npy +imgHQ05609.npy +imgHQ19223.npy +imgHQ00487.npy +imgHQ05943.npy +imgHQ28039.npy +imgHQ29633.npy +imgHQ13208.npy +imgHQ01435.npy +imgHQ14282.npy +imgHQ22964.npy +imgHQ13669.npy +imgHQ14703.npy +imgHQ27119.npy +imgHQ17042.npy +imgHQ01237.npy +imgHQ16343.npy +imgHQ18546.npy +imgHQ04285.npy +imgHQ18351.npy +imgHQ00203.npy +imgHQ24994.npy +imgHQ16496.npy +imgHQ14407.npy +imgHQ17107.npy +imgHQ13099.npy +imgHQ21566.npy +imgHQ02072.npy +imgHQ10019.npy +imgHQ23249.npy +imgHQ25144.npy +imgHQ11976.npy +imgHQ29026.npy +imgHQ07907.npy +imgHQ13106.npy +imgHQ22494.npy +imgHQ08178.npy +imgHQ21835.npy +imgHQ03388.npy +imgHQ25553.npy +imgHQ11218.npy +imgHQ19134.npy +imgHQ22551.npy +imgHQ15904.npy +imgHQ06214.npy +imgHQ29596.npy +imgHQ11718.npy +imgHQ05390.npy +imgHQ28220.npy +imgHQ13406.npy +imgHQ16291.npy +imgHQ19213.npy +imgHQ08115.npy +imgHQ11528.npy +imgHQ06885.npy +imgHQ00332.npy +imgHQ06778.npy +imgHQ00014.npy +imgHQ20699.npy +imgHQ29196.npy +imgHQ23239.npy +imgHQ25596.npy +imgHQ15328.npy +imgHQ18059.npy +imgHQ15108.npy +imgHQ06847.npy +imgHQ29486.npy +imgHQ14455.npy +imgHQ15122.npy +imgHQ18379.npy +imgHQ21992.npy +imgHQ24480.npy +imgHQ03226.npy +imgHQ01217.npy +imgHQ26744.npy +imgHQ12710.npy +imgHQ25962.npy +imgHQ00463.npy +imgHQ20453.npy +imgHQ24902.npy +imgHQ19991.npy +imgHQ27795.npy +imgHQ12992.npy +imgHQ09783.npy +imgHQ01644.npy +imgHQ26851.npy +imgHQ23058.npy +imgHQ29827.npy +imgHQ07752.npy +imgHQ24509.npy +imgHQ14187.npy +imgHQ04291.npy +imgHQ03918.npy +imgHQ16720.npy +imgHQ23139.npy +imgHQ17527.npy +imgHQ25280.npy +imgHQ12181.npy +imgHQ08639.npy +imgHQ22446.npy +imgHQ16222.npy +imgHQ27516.npy +imgHQ18193.npy +imgHQ18325.npy +imgHQ11288.npy +imgHQ12634.npy +imgHQ13497.npy +imgHQ17689.npy +imgHQ09852.npy +imgHQ16763.npy +imgHQ28940.npy +imgHQ02148.npy +imgHQ29389.npy +imgHQ12606.npy +imgHQ09916.npy +imgHQ16012.npy +imgHQ23809.npy +imgHQ06319.npy +imgHQ19511.npy +imgHQ21355.npy +imgHQ10024.npy +imgHQ07570.npy +imgHQ12880.npy +imgHQ05774.npy +imgHQ18651.npy +imgHQ24853.npy +imgHQ09787.npy +imgHQ20072.npy +imgHQ23373.npy +imgHQ28918.npy +imgHQ12006.npy +imgHQ06774.npy +imgHQ15029.npy +imgHQ12727.npy +imgHQ22643.npy +imgHQ13683.npy +imgHQ20934.npy +imgHQ27745.npy +imgHQ26007.npy +imgHQ04648.npy +imgHQ14474.npy +imgHQ25299.npy +imgHQ06225.npy +imgHQ14340.npy +imgHQ07994.npy +imgHQ22388.npy +imgHQ03935.npy +imgHQ09421.npy +imgHQ01412.npy +imgHQ14441.npy +imgHQ25418.npy +imgHQ23623.npy +imgHQ11812.npy +imgHQ27933.npy +imgHQ18174.npy +imgHQ00991.npy +imgHQ26514.npy +imgHQ24660.npy +imgHQ03351.npy +imgHQ23458.npy +imgHQ24786.npy +imgHQ00174.npy +imgHQ01493.npy +imgHQ04554.npy +imgHQ09957.npy +imgHQ29261.npy +imgHQ18272.npy +imgHQ03223.npy +imgHQ29397.npy +imgHQ29541.npy +imgHQ23635.npy +imgHQ13359.npy +imgHQ13831.npy +imgHQ12092.npy +imgHQ12494.npy +imgHQ08442.npy +imgHQ04988.npy +imgHQ04466.npy +imgHQ25601.npy +imgHQ09899.npy +imgHQ25171.npy +imgHQ26763.npy +imgHQ14643.npy +imgHQ09684.npy +imgHQ27805.npy +imgHQ04020.npy +imgHQ07354.npy +imgHQ05169.npy +imgHQ02077.npy +imgHQ27563.npy +imgHQ06549.npy +imgHQ29193.npy +imgHQ10673.npy +imgHQ01241.npy +imgHQ23009.npy +imgHQ01014.npy +imgHQ08985.npy +imgHQ15474.npy +imgHQ23232.npy +imgHQ08672.npy +imgHQ01675.npy +imgHQ23760.npy +imgHQ08726.npy +imgHQ10696.npy +imgHQ19976.npy +imgHQ17410.npy +imgHQ03454.npy +imgHQ26675.npy +imgHQ11487.npy +imgHQ16081.npy +imgHQ26115.npy +imgHQ22675.npy +imgHQ17862.npy +imgHQ06569.npy +imgHQ18147.npy +imgHQ04520.npy +imgHQ23721.npy +imgHQ14304.npy +imgHQ10987.npy +imgHQ20712.npy +imgHQ02365.npy +imgHQ29681.npy +imgHQ21223.npy +imgHQ09937.npy +imgHQ03525.npy +imgHQ18450.npy +imgHQ05662.npy +imgHQ18101.npy +imgHQ05633.npy +imgHQ00732.npy +imgHQ04210.npy +imgHQ11925.npy +imgHQ26228.npy +imgHQ14391.npy +imgHQ23399.npy +imgHQ16347.npy +imgHQ00816.npy +imgHQ00141.npy +imgHQ00819.npy +imgHQ28446.npy +imgHQ04792.npy +imgHQ23523.npy +imgHQ09437.npy +imgHQ24784.npy +imgHQ28870.npy +imgHQ08279.npy +imgHQ08831.npy +imgHQ14104.npy +imgHQ15888.npy +imgHQ23931.npy +imgHQ03565.npy +imgHQ25499.npy +imgHQ19586.npy +imgHQ16667.npy +imgHQ25002.npy +imgHQ03101.npy +imgHQ08874.npy +imgHQ09962.npy +imgHQ00992.npy +imgHQ29164.npy +imgHQ25375.npy +imgHQ11215.npy +imgHQ19936.npy +imgHQ22315.npy +imgHQ26268.npy +imgHQ04260.npy +imgHQ01170.npy +imgHQ05512.npy +imgHQ26147.npy +imgHQ20130.npy +imgHQ18192.npy +imgHQ18058.npy +imgHQ09766.npy +imgHQ07585.npy +imgHQ04871.npy +imgHQ01830.npy +imgHQ14154.npy +imgHQ00872.npy +imgHQ24414.npy +imgHQ09822.npy +imgHQ10760.npy +imgHQ25668.npy +imgHQ27428.npy +imgHQ21150.npy +imgHQ15510.npy +imgHQ28166.npy +imgHQ17798.npy +imgHQ02568.npy +imgHQ07575.npy +imgHQ20036.npy +imgHQ14672.npy +imgHQ13268.npy +imgHQ10191.npy +imgHQ10058.npy +imgHQ01994.npy +imgHQ04700.npy +imgHQ08635.npy +imgHQ17262.npy +imgHQ12459.npy +imgHQ04064.npy +imgHQ23052.npy +imgHQ05597.npy +imgHQ26977.npy +imgHQ17250.npy +imgHQ22852.npy +imgHQ29447.npy +imgHQ03495.npy +imgHQ09285.npy +imgHQ08130.npy +imgHQ16896.npy +imgHQ27276.npy +imgHQ20135.npy +imgHQ29710.npy +imgHQ11066.npy +imgHQ14850.npy +imgHQ28632.npy +imgHQ07038.npy +imgHQ27488.npy +imgHQ01584.npy +imgHQ26001.npy +imgHQ07467.npy +imgHQ19957.npy +imgHQ09643.npy +imgHQ01488.npy +imgHQ11426.npy +imgHQ05748.npy +imgHQ27489.npy +imgHQ06935.npy +imgHQ12629.npy +imgHQ02211.npy +imgHQ13390.npy +imgHQ08494.npy +imgHQ06768.npy +imgHQ00059.npy +imgHQ25000.npy +imgHQ13541.npy +imgHQ00311.npy +imgHQ20029.npy +imgHQ03357.npy +imgHQ21185.npy +imgHQ08093.npy +imgHQ04458.npy +imgHQ16701.npy +imgHQ23647.npy +imgHQ17012.npy +imgHQ02200.npy +imgHQ22308.npy +imgHQ13306.npy +imgHQ08244.npy +imgHQ12500.npy +imgHQ12967.npy +imgHQ12510.npy +imgHQ06908.npy +imgHQ02068.npy +imgHQ06081.npy +imgHQ01892.npy +imgHQ20564.npy +imgHQ27608.npy +imgHQ14091.npy +imgHQ13354.npy +imgHQ25663.npy +imgHQ26458.npy +imgHQ04513.npy +imgHQ18958.npy +imgHQ09872.npy +imgHQ13025.npy +imgHQ24670.npy +imgHQ06375.npy +imgHQ08324.npy +imgHQ07409.npy +imgHQ06127.npy +imgHQ23585.npy +imgHQ00870.npy +imgHQ05582.npy +imgHQ04681.npy +imgHQ06176.npy +imgHQ27116.npy +imgHQ22579.npy +imgHQ15560.npy +imgHQ23793.npy +imgHQ18921.npy +imgHQ06865.npy +imgHQ11076.npy +imgHQ26396.npy +imgHQ17029.npy +imgHQ04781.npy +imgHQ10644.npy +imgHQ03969.npy +imgHQ16241.npy +imgHQ27834.npy +imgHQ25402.npy +imgHQ28043.npy +imgHQ17271.npy +imgHQ06419.npy +imgHQ27302.npy +imgHQ13861.npy +imgHQ07972.npy +imgHQ12856.npy +imgHQ03326.npy +imgHQ06869.npy +imgHQ14857.npy +imgHQ20255.npy +imgHQ04050.npy +imgHQ25866.npy +imgHQ20601.npy +imgHQ15059.npy +imgHQ21348.npy +imgHQ01265.npy +imgHQ18577.npy +imgHQ01647.npy +imgHQ14974.npy +imgHQ28669.npy +imgHQ13755.npy +imgHQ09985.npy +imgHQ29988.npy +imgHQ08021.npy +imgHQ29366.npy +imgHQ15536.npy +imgHQ19268.npy +imgHQ06794.npy +imgHQ05976.npy +imgHQ12541.npy +imgHQ05236.npy +imgHQ13386.npy +imgHQ28809.npy +imgHQ08259.npy +imgHQ26257.npy +imgHQ23362.npy +imgHQ10554.npy +imgHQ29983.npy +imgHQ11932.npy +imgHQ06323.npy +imgHQ10809.npy +imgHQ00048.npy +imgHQ26038.npy +imgHQ26104.npy +imgHQ09501.npy +imgHQ00050.npy +imgHQ01339.npy +imgHQ17299.npy +imgHQ04152.npy +imgHQ08450.npy +imgHQ18950.npy +imgHQ28252.npy +imgHQ16274.npy +imgHQ05908.npy +imgHQ05421.npy +imgHQ17874.npy +imgHQ02602.npy +imgHQ00682.npy +imgHQ20167.npy +imgHQ15537.npy +imgHQ10410.npy +imgHQ12537.npy +imgHQ14658.npy +imgHQ06114.npy +imgHQ11630.npy +imgHQ22489.npy +imgHQ05405.npy +imgHQ02982.npy +imgHQ03348.npy +imgHQ02259.npy +imgHQ24600.npy +imgHQ10302.npy +imgHQ20501.npy +imgHQ20700.npy +imgHQ21050.npy +imgHQ26691.npy +imgHQ25793.npy +imgHQ08268.npy +imgHQ14937.npy +imgHQ14895.npy +imgHQ02511.npy +imgHQ24460.npy +imgHQ02089.npy +imgHQ22971.npy +imgHQ22850.npy +imgHQ01129.npy +imgHQ24595.npy +imgHQ16368.npy +imgHQ01933.npy +imgHQ26161.npy +imgHQ17615.npy +imgHQ21424.npy +imgHQ12783.npy +imgHQ29345.npy +imgHQ28581.npy +imgHQ13064.npy +imgHQ04503.npy +imgHQ17509.npy +imgHQ16710.npy +imgHQ06188.npy +imgHQ05932.npy +imgHQ26182.npy +imgHQ03350.npy +imgHQ01389.npy +imgHQ20405.npy +imgHQ11190.npy +imgHQ07692.npy +imgHQ09159.npy +imgHQ01771.npy +imgHQ01709.npy +imgHQ14612.npy +imgHQ11362.npy +imgHQ06565.npy +imgHQ13950.npy +imgHQ13019.npy +imgHQ01683.npy +imgHQ21239.npy +imgHQ29340.npy +imgHQ29763.npy +imgHQ21995.npy +imgHQ06164.npy +imgHQ29713.npy +imgHQ15671.npy +imgHQ13119.npy +imgHQ05496.npy +imgHQ05485.npy +imgHQ01501.npy +imgHQ19967.npy +imgHQ20772.npy +imgHQ08645.npy +imgHQ29072.npy +imgHQ01411.npy +imgHQ13931.npy +imgHQ08458.npy +imgHQ22376.npy +imgHQ00489.npy +imgHQ08709.npy +imgHQ13819.npy +imgHQ15106.npy +imgHQ26156.npy +imgHQ15499.npy +imgHQ08074.npy +imgHQ13990.npy +imgHQ25864.npy +imgHQ05283.npy +imgHQ29887.npy +imgHQ14553.npy +imgHQ09645.npy +imgHQ13672.npy +imgHQ01097.npy +imgHQ00618.npy +imgHQ05654.npy +imgHQ10403.npy +imgHQ25845.npy +imgHQ29016.npy +imgHQ09473.npy +imgHQ29490.npy +imgHQ25038.npy +imgHQ21774.npy +imgHQ00922.npy +imgHQ07992.npy +imgHQ14752.npy +imgHQ15998.npy +imgHQ10896.npy +imgHQ29529.npy +imgHQ24314.npy +imgHQ16444.npy +imgHQ29749.npy +imgHQ15018.npy +imgHQ23564.npy +imgHQ19434.npy +imgHQ10943.npy +imgHQ25564.npy +imgHQ01838.npy +imgHQ18221.npy +imgHQ01072.npy +imgHQ01629.npy +imgHQ15636.npy +imgHQ17071.npy +imgHQ24960.npy +imgHQ04538.npy +imgHQ22051.npy +imgHQ15408.npy +imgHQ14084.npy +imgHQ05446.npy +imgHQ01440.npy +imgHQ21803.npy +imgHQ19501.npy +imgHQ08197.npy +imgHQ13746.npy +imgHQ15127.npy +imgHQ09510.npy +imgHQ10376.npy +imgHQ11222.npy +imgHQ23181.npy +imgHQ25547.npy +imgHQ13372.npy +imgHQ14900.npy +imgHQ09893.npy +imgHQ04096.npy +imgHQ22152.npy +imgHQ28183.npy +imgHQ16598.npy +imgHQ18094.npy +imgHQ26197.npy +imgHQ28149.npy +imgHQ15798.npy +imgHQ00179.npy +imgHQ17458.npy +imgHQ07735.npy +imgHQ17904.npy +imgHQ15129.npy +imgHQ04794.npy +imgHQ13656.npy +imgHQ15927.npy +imgHQ08427.npy +imgHQ12481.npy +imgHQ04823.npy +imgHQ08071.npy +imgHQ03148.npy +imgHQ12451.npy +imgHQ17440.npy +imgHQ28804.npy +imgHQ13800.npy +imgHQ01772.npy +imgHQ20716.npy +imgHQ07337.npy +imgHQ29808.npy +imgHQ12484.npy +imgHQ00364.npy +imgHQ09855.npy +imgHQ25070.npy +imgHQ10565.npy +imgHQ14023.npy +imgHQ02864.npy +imgHQ15316.npy +imgHQ14201.npy +imgHQ12259.npy +imgHQ15130.npy +imgHQ03494.npy +imgHQ01558.npy +imgHQ07277.npy +imgHQ21372.npy +imgHQ23174.npy +imgHQ09637.npy +imgHQ03849.npy +imgHQ20982.npy +imgHQ01802.npy +imgHQ03225.npy +imgHQ12450.npy +imgHQ24718.npy +imgHQ28371.npy +imgHQ28741.npy +imgHQ23378.npy +imgHQ06272.npy +imgHQ02906.npy +imgHQ07423.npy +imgHQ02271.npy +imgHQ23755.npy +imgHQ24661.npy +imgHQ10053.npy +imgHQ15840.npy +imgHQ17453.npy +imgHQ18085.npy +imgHQ18600.npy +imgHQ07460.npy +imgHQ12276.npy +imgHQ18285.npy +imgHQ04092.npy +imgHQ08461.npy +imgHQ11080.npy +imgHQ00694.npy +imgHQ08737.npy +imgHQ26220.npy +imgHQ24183.npy +imgHQ16196.npy +imgHQ08350.npy +imgHQ27351.npy +imgHQ00214.npy +imgHQ21971.npy +imgHQ11475.npy +imgHQ19945.npy +imgHQ08863.npy +imgHQ23112.npy +imgHQ10873.npy +imgHQ23198.npy +imgHQ16989.npy +imgHQ22100.npy +imgHQ25329.npy +imgHQ18012.npy +imgHQ12960.npy +imgHQ19666.npy +imgHQ21984.npy +imgHQ17470.npy +imgHQ05518.npy +imgHQ29709.npy +imgHQ14171.npy +imgHQ03460.npy +imgHQ04033.npy +imgHQ03483.npy +imgHQ06385.npy +imgHQ14307.npy +imgHQ17824.npy +imgHQ24044.npy +imgHQ22358.npy +imgHQ04568.npy +imgHQ24655.npy +imgHQ03685.npy +imgHQ08062.npy +imgHQ08884.npy +imgHQ04506.npy +imgHQ02340.npy +imgHQ18809.npy +imgHQ05644.npy +imgHQ06953.npy +imgHQ05448.npy +imgHQ13533.npy +imgHQ27280.npy +imgHQ20665.npy +imgHQ29758.npy +imgHQ16945.npy +imgHQ16245.npy +imgHQ17442.npy +imgHQ17939.npy +imgHQ18831.npy +imgHQ08203.npy +imgHQ21313.npy +imgHQ21282.npy +imgHQ00454.npy +imgHQ20752.npy +imgHQ19383.npy +imgHQ21386.npy +imgHQ19322.npy +imgHQ29748.npy +imgHQ26751.npy +imgHQ01624.npy +imgHQ02175.npy +imgHQ27802.npy +imgHQ18740.npy +imgHQ12821.npy +imgHQ13422.npy +imgHQ05532.npy +imgHQ03086.npy +imgHQ21715.npy +imgHQ29821.npy +imgHQ15782.npy +imgHQ13331.npy +imgHQ18891.npy +imgHQ09238.npy +imgHQ20946.npy +imgHQ13856.npy +imgHQ23904.npy +imgHQ28755.npy +imgHQ24082.npy +imgHQ17524.npy +imgHQ09429.npy +imgHQ03672.npy +imgHQ15185.npy +imgHQ14298.npy +imgHQ06553.npy +imgHQ25444.npy +imgHQ25077.npy +imgHQ11889.npy +imgHQ05275.npy +imgHQ06030.npy +imgHQ22269.npy +imgHQ14822.npy +imgHQ18728.npy +imgHQ03624.npy +imgHQ08922.npy +imgHQ08910.npy +imgHQ05990.npy +imgHQ18634.npy +imgHQ29111.npy +imgHQ02362.npy +imgHQ09039.npy +imgHQ05345.npy +imgHQ13912.npy +imgHQ03876.npy +imgHQ06116.npy +imgHQ08186.npy +imgHQ02600.npy +imgHQ14035.npy +imgHQ06835.npy +imgHQ14008.npy +imgHQ19536.npy +imgHQ25905.npy +imgHQ19519.npy +imgHQ09495.npy +imgHQ12767.npy +imgHQ15120.npy +imgHQ14484.npy +imgHQ27912.npy +imgHQ01542.npy +imgHQ01643.npy +imgHQ14715.npy +imgHQ02666.npy +imgHQ06357.npy +imgHQ17209.npy +imgHQ22683.npy +imgHQ24500.npy +imgHQ27729.npy +imgHQ20791.npy +imgHQ02826.npy +imgHQ03030.npy +imgHQ03542.npy +imgHQ22879.npy +imgHQ03240.npy +imgHQ03171.npy +imgHQ05904.npy +imgHQ02238.npy +imgHQ02500.npy +imgHQ00102.npy +imgHQ20876.npy +imgHQ06545.npy +imgHQ29900.npy +imgHQ11496.npy +imgHQ08527.npy +imgHQ07246.npy +imgHQ25059.npy +imgHQ28893.npy +imgHQ10214.npy +imgHQ24760.npy +imgHQ02137.npy +imgHQ17899.npy +imgHQ00880.npy +imgHQ25636.npy +imgHQ09676.npy +imgHQ17139.npy +imgHQ11741.npy +imgHQ03700.npy +imgHQ07183.npy +imgHQ02748.npy +imgHQ22189.npy +imgHQ00436.npy +imgHQ15595.npy +imgHQ13701.npy +imgHQ12212.npy +imgHQ18204.npy +imgHQ14627.npy +imgHQ26532.npy +imgHQ16810.npy +imgHQ18759.npy +imgHQ19307.npy +imgHQ17755.npy +imgHQ15745.npy +imgHQ23403.npy +imgHQ04814.npy +imgHQ10262.npy +imgHQ27490.npy +imgHQ05205.npy +imgHQ19036.npy +imgHQ02531.npy +imgHQ28823.npy +imgHQ05032.npy +imgHQ15314.npy +imgHQ16330.npy +imgHQ01798.npy +imgHQ11472.npy +imgHQ28024.npy +imgHQ10785.npy +imgHQ11514.npy +imgHQ21763.npy +imgHQ29385.npy +imgHQ24717.npy +imgHQ14738.npy +imgHQ03249.npy +imgHQ26826.npy +imgHQ08713.npy +imgHQ00550.npy +imgHQ02571.npy +imgHQ17605.npy +imgHQ22538.npy +imgHQ16189.npy +imgHQ21507.npy +imgHQ20691.npy +imgHQ25107.npy +imgHQ08367.npy +imgHQ20317.npy +imgHQ23057.npy +imgHQ05872.npy +imgHQ02078.npy +imgHQ15377.npy +imgHQ26860.npy +imgHQ03982.npy +imgHQ00693.npy +imgHQ14935.npy +imgHQ12583.npy +imgHQ01483.npy +imgHQ04917.npy +imgHQ13795.npy +imgHQ26933.npy +imgHQ02937.npy +imgHQ11724.npy +imgHQ09228.npy +imgHQ13528.npy +imgHQ00839.npy +imgHQ20976.npy +imgHQ26368.npy +imgHQ05490.npy +imgHQ10092.npy +imgHQ25850.npy +imgHQ20151.npy +imgHQ05631.npy +imgHQ04757.npy +imgHQ23124.npy +imgHQ02584.npy +imgHQ09471.npy +imgHQ22122.npy +imgHQ14599.npy +imgHQ10094.npy +imgHQ20739.npy +imgHQ15413.npy +imgHQ15863.npy +imgHQ16124.npy +imgHQ22546.npy +imgHQ02616.npy +imgHQ28757.npy +imgHQ02395.npy +imgHQ17511.npy +imgHQ05363.npy +imgHQ22603.npy +imgHQ28708.npy +imgHQ00527.npy +imgHQ07092.npy +imgHQ17391.npy +imgHQ02525.npy +imgHQ10282.npy +imgHQ25838.npy +imgHQ07944.npy +imgHQ26344.npy +imgHQ22374.npy +imgHQ12578.npy +imgHQ26689.npy +imgHQ07823.npy +imgHQ02879.npy +imgHQ20822.npy +imgHQ10271.npy +imgHQ01546.npy +imgHQ28487.npy +imgHQ17167.npy +imgHQ03594.npy +imgHQ02421.npy +imgHQ02518.npy +imgHQ19795.npy +imgHQ15967.npy +imgHQ22364.npy +imgHQ07881.npy +imgHQ18775.npy +imgHQ05127.npy +imgHQ15913.npy +imgHQ01183.npy +imgHQ24715.npy +imgHQ15704.npy +imgHQ20913.npy +imgHQ05222.npy +imgHQ07099.npy +imgHQ16992.npy +imgHQ10368.npy +imgHQ01326.npy +imgHQ24886.npy +imgHQ08586.npy +imgHQ13254.npy +imgHQ26279.npy +imgHQ14708.npy +imgHQ29106.npy +imgHQ26610.npy +imgHQ06740.npy +imgHQ05246.npy +imgHQ13653.npy +imgHQ09455.npy +imgHQ04642.npy +imgHQ06872.npy +imgHQ28000.npy +imgHQ21008.npy +imgHQ11704.npy +imgHQ29643.npy +imgHQ11657.npy +imgHQ22346.npy +imgHQ20619.npy +imgHQ02743.npy +imgHQ04524.npy +imgHQ01124.npy +imgHQ23781.npy +imgHQ20330.npy +imgHQ11423.npy +imgHQ23803.npy +imgHQ15792.npy +imgHQ16415.npy +imgHQ29224.npy +imgHQ14868.npy +imgHQ11225.npy +imgHQ05919.npy +imgHQ22399.npy +imgHQ05603.npy +imgHQ21316.npy +imgHQ21819.npy +imgHQ16406.npy +imgHQ24982.npy +imgHQ24390.npy +imgHQ00091.npy +imgHQ12057.npy +imgHQ18524.npy +imgHQ22768.npy +imgHQ13546.npy +imgHQ23765.npy +imgHQ24174.npy +imgHQ15631.npy +imgHQ09938.npy +imgHQ03840.npy +imgHQ19171.npy +imgHQ19507.npy +imgHQ16064.npy +imgHQ28605.npy +imgHQ25916.npy +imgHQ27500.npy +imgHQ09996.npy +imgHQ08079.npy +imgHQ06916.npy +imgHQ12428.npy +imgHQ05028.npy +imgHQ07009.npy +imgHQ18163.npy +imgHQ27930.npy +imgHQ17699.npy +imgHQ29967.npy +imgHQ16089.npy +imgHQ29611.npy +imgHQ21768.npy +imgHQ00860.npy +imgHQ22567.npy +imgHQ27592.npy +imgHQ02546.npy +imgHQ24264.npy +imgHQ26091.npy +imgHQ12030.npy +imgHQ12597.npy +imgHQ28175.npy +imgHQ12430.npy +imgHQ21915.npy +imgHQ07953.npy +imgHQ24412.npy +imgHQ24942.npy +imgHQ12709.npy +imgHQ21521.npy +imgHQ08504.npy +imgHQ16608.npy +imgHQ22711.npy +imgHQ16529.npy +imgHQ04692.npy +imgHQ07969.npy +imgHQ07898.npy +imgHQ02158.npy +imgHQ12622.npy +imgHQ11159.npy +imgHQ16518.npy +imgHQ21733.npy +imgHQ04267.npy +imgHQ27804.npy +imgHQ28631.npy +imgHQ18182.npy +imgHQ27779.npy +imgHQ19841.npy +imgHQ26565.npy +imgHQ00588.npy +imgHQ01033.npy +imgHQ26251.npy +imgHQ13434.npy +imgHQ07056.npy +imgHQ29829.npy +imgHQ20902.npy +imgHQ18910.npy +imgHQ20144.npy +imgHQ24389.npy +imgHQ18802.npy +imgHQ10203.npy +imgHQ02557.npy +imgHQ23327.npy +imgHQ05379.npy +imgHQ16644.npy +imgHQ00432.npy +imgHQ15001.npy +imgHQ04589.npy +imgHQ15603.npy +imgHQ25434.npy +imgHQ01840.npy +imgHQ18897.npy +imgHQ03724.npy +imgHQ19934.npy +imgHQ16802.npy +imgHQ19750.npy +imgHQ05604.npy +imgHQ25513.npy +imgHQ02209.npy +imgHQ09280.npy +imgHQ11887.npy +imgHQ02213.npy +imgHQ17554.npy +imgHQ20557.npy +imgHQ00932.npy +imgHQ14508.npy +imgHQ04371.npy +imgHQ25298.npy +imgHQ25182.npy +imgHQ19481.npy +imgHQ13349.npy +imgHQ05650.npy +imgHQ02917.npy +imgHQ24896.npy +imgHQ09836.npy +imgHQ10793.npy +imgHQ27254.npy +imgHQ12948.npy +imgHQ16874.npy +imgHQ27875.npy +imgHQ02232.npy +imgHQ16792.npy +imgHQ15450.npy +imgHQ21762.npy +imgHQ28674.npy +imgHQ16143.npy +imgHQ10479.npy +imgHQ06185.npy +imgHQ29401.npy +imgHQ02851.npy +imgHQ15323.npy +imgHQ15882.npy +imgHQ05312.npy +imgHQ26259.npy +imgHQ23986.npy +imgHQ14561.npy +imgHQ05100.npy +imgHQ04838.npy +imgHQ24768.npy +imgHQ12862.npy +imgHQ18412.npy +imgHQ19201.npy +imgHQ11415.npy +imgHQ01484.npy +imgHQ04824.npy +imgHQ28626.npy +imgHQ18932.npy +imgHQ07420.npy +imgHQ26798.npy +imgHQ14117.npy +imgHQ05673.npy +imgHQ24742.npy +imgHQ29995.npy +imgHQ12231.npy +imgHQ00237.npy +imgHQ10844.npy +imgHQ23933.npy +imgHQ17720.npy +imgHQ02928.npy +imgHQ03459.npy +imgHQ13443.npy +imgHQ27651.npy +imgHQ10625.npy +imgHQ05939.npy +imgHQ02476.npy +imgHQ27647.npy +imgHQ07801.npy +imgHQ28598.npy +imgHQ16204.npy +imgHQ01661.npy +imgHQ21818.npy +imgHQ05264.npy +imgHQ28643.npy +imgHQ11535.npy +imgHQ17693.npy +imgHQ29464.npy +imgHQ10915.npy +imgHQ00659.npy +imgHQ21921.npy +imgHQ01500.npy +imgHQ15386.npy +imgHQ24192.npy +imgHQ22480.npy +imgHQ25130.npy +imgHQ17344.npy +imgHQ27935.npy +imgHQ11990.npy +imgHQ14720.npy +imgHQ16510.npy +imgHQ21140.npy +imgHQ01985.npy +imgHQ11504.npy +imgHQ15698.npy +imgHQ23111.npy +imgHQ25514.npy +imgHQ12058.npy +imgHQ01355.npy +imgHQ03900.npy +imgHQ01549.npy +imgHQ06688.npy +imgHQ26157.npy +imgHQ29926.npy +imgHQ13459.npy +imgHQ01054.npy +imgHQ27223.npy +imgHQ14984.npy +imgHQ24115.npy +imgHQ11033.npy +imgHQ03307.npy +imgHQ19045.npy +imgHQ03835.npy +imgHQ18736.npy +imgHQ05409.npy +imgHQ13872.npy +imgHQ04767.npy +imgHQ26441.npy +imgHQ17772.npy +imgHQ02453.npy +imgHQ13199.npy +imgHQ00099.npy +imgHQ22502.npy +imgHQ17490.npy +imgHQ22521.npy +imgHQ20397.npy +imgHQ00534.npy +imgHQ02231.npy +imgHQ25820.npy +imgHQ21800.npy +imgHQ08336.npy +imgHQ24859.npy +imgHQ02871.npy +imgHQ10333.npy +imgHQ28355.npy +imgHQ11757.npy +imgHQ15644.npy +imgHQ01889.npy +imgHQ10712.npy +imgHQ26554.npy +imgHQ07600.npy +imgHQ21792.npy +imgHQ10447.npy +imgHQ25014.npy +imgHQ05873.npy +imgHQ25063.npy +imgHQ21000.npy +imgHQ26219.npy +imgHQ14849.npy +imgHQ09300.npy +imgHQ28564.npy +imgHQ03041.npy +imgHQ25496.npy +imgHQ27957.npy +imgHQ09703.npy +imgHQ18065.npy +imgHQ07422.npy +imgHQ19214.npy +imgHQ06798.npy +imgHQ07690.npy +imgHQ00220.npy +imgHQ13162.npy +imgHQ16378.npy +imgHQ00433.npy +imgHQ04916.npy +imgHQ06792.npy +imgHQ24010.npy +imgHQ02168.npy +imgHQ28926.npy +imgHQ17735.npy +imgHQ29178.npy +imgHQ26981.npy +imgHQ01671.npy +imgHQ05539.npy +imgHQ20122.npy +imgHQ07700.npy +imgHQ16732.npy +imgHQ26097.npy +imgHQ26958.npy +imgHQ29439.npy +imgHQ25792.npy +imgHQ23836.npy +imgHQ21112.npy +imgHQ24141.npy +imgHQ06902.npy +imgHQ26857.npy +imgHQ20465.npy +imgHQ04654.npy +imgHQ04680.npy +imgHQ29487.npy +imgHQ18153.npy +imgHQ13587.npy +imgHQ28653.npy +imgHQ22275.npy +imgHQ00397.npy +imgHQ25494.npy +imgHQ00491.npy +imgHQ23694.npy +imgHQ01796.npy +imgHQ12143.npy +imgHQ11432.npy +imgHQ11515.npy +imgHQ25883.npy +imgHQ13956.npy +imgHQ26818.npy +imgHQ14045.npy +imgHQ29703.npy +imgHQ10016.npy +imgHQ16332.npy +imgHQ09795.npy +imgHQ14028.npy +imgHQ00010.npy +imgHQ28517.npy +imgHQ17840.npy +imgHQ26524.npy +imgHQ14963.npy +imgHQ28939.npy +imgHQ27951.npy +imgHQ12655.npy +imgHQ07859.npy +imgHQ13468.npy +imgHQ06299.npy +imgHQ20835.npy +imgHQ11300.npy +imgHQ29628.npy +imgHQ22350.npy +imgHQ05570.npy +imgHQ10155.npy +imgHQ13391.npy +imgHQ09230.npy +imgHQ26118.npy +imgHQ18734.npy +imgHQ26828.npy +imgHQ11025.npy +imgHQ16672.npy +imgHQ29782.npy +imgHQ11979.npy +imgHQ21674.npy +imgHQ06105.npy +imgHQ20266.npy +imgHQ14137.npy +imgHQ02411.npy +imgHQ21599.npy +imgHQ06057.npy +imgHQ27501.npy +imgHQ03573.npy +imgHQ26680.npy +imgHQ17409.npy +imgHQ16296.npy +imgHQ07436.npy +imgHQ05991.npy +imgHQ04852.npy +imgHQ04934.npy +imgHQ04948.npy +imgHQ20954.npy +imgHQ19901.npy +imgHQ15169.npy +imgHQ22568.npy +imgHQ17889.npy +imgHQ01884.npy +imgHQ04145.npy +imgHQ04705.npy +imgHQ22899.npy +imgHQ20586.npy +imgHQ09240.npy +imgHQ24731.npy +imgHQ13827.npy +imgHQ27479.npy +imgHQ23636.npy +imgHQ07443.npy +imgHQ29630.npy +imgHQ07003.npy +imgHQ21684.npy +imgHQ06332.npy +imgHQ19499.npy +imgHQ27783.npy +imgHQ19060.npy +imgHQ05838.npy +imgHQ19607.npy +imgHQ19886.npy +imgHQ27093.npy +imgHQ02482.npy +imgHQ10966.npy +imgHQ09884.npy +imgHQ25412.npy +imgHQ14328.npy +imgHQ20075.npy +imgHQ21603.npy +imgHQ20032.npy +imgHQ02165.npy +imgHQ06317.npy +imgHQ21709.npy +imgHQ07800.npy +imgHQ21190.npy +imgHQ08703.npy +imgHQ21870.npy +imgHQ17103.npy +imgHQ08304.npy +imgHQ16484.npy +imgHQ08749.npy +imgHQ22196.npy +imgHQ29173.npy +imgHQ25658.npy +imgHQ21429.npy +imgHQ01573.npy +imgHQ08378.npy +imgHQ05065.npy +imgHQ27158.npy +imgHQ18482.npy +imgHQ07121.npy +imgHQ25659.npy +imgHQ20570.npy +imgHQ12002.npy +imgHQ02392.npy +imgHQ18769.npy +imgHQ13530.npy +imgHQ25117.npy +imgHQ25971.npy +imgHQ10183.npy +imgHQ28959.npy +imgHQ06002.npy +imgHQ09453.npy +imgHQ07049.npy +imgHQ01167.npy +imgHQ10607.npy +imgHQ00603.npy +imgHQ22332.npy +imgHQ03601.npy +imgHQ29915.npy +imgHQ10221.npy +imgHQ28058.npy +imgHQ16279.npy +imgHQ24094.npy +imgHQ13735.npy +imgHQ06548.npy +imgHQ29512.npy +imgHQ29568.npy +imgHQ12902.npy +imgHQ11220.npy +imgHQ25576.npy +imgHQ12511.npy +imgHQ09548.npy +imgHQ22009.npy +imgHQ14040.npy +imgHQ29218.npy +imgHQ26079.npy +imgHQ22380.npy +imgHQ17319.npy +imgHQ17289.npy +imgHQ23227.npy +imgHQ21756.npy +imgHQ24034.npy +imgHQ20057.npy +imgHQ05071.npy +imgHQ07196.npy +imgHQ18047.npy +imgHQ17873.npy +imgHQ03691.npy +imgHQ06723.npy +imgHQ23791.npy +imgHQ20234.npy +imgHQ02212.npy +imgHQ24124.npy +imgHQ00586.npy +imgHQ29363.npy +imgHQ21928.npy +imgHQ12826.npy +imgHQ19468.npy +imgHQ08593.npy +imgHQ19620.npy +imgHQ16342.npy +imgHQ21379.npy +imgHQ16043.npy +imgHQ23482.npy +imgHQ24678.npy +imgHQ11994.npy +imgHQ12379.npy +imgHQ24395.npy +imgHQ19359.npy +imgHQ29519.npy +imgHQ15452.npy +imgHQ27737.npy +imgHQ20725.npy +imgHQ04164.npy +imgHQ08532.npy +imgHQ11560.npy +imgHQ19467.npy +imgHQ08934.npy +imgHQ27947.npy +imgHQ23557.npy +imgHQ14589.npy +imgHQ29920.npy +imgHQ27985.npy +imgHQ05565.npy +imgHQ14225.npy +imgHQ12700.npy +imgHQ08671.npy +imgHQ07819.npy +imgHQ11283.npy +imgHQ08162.npy +imgHQ18905.npy +imgHQ01693.npy +imgHQ28901.npy +imgHQ03246.npy +imgHQ10420.npy +imgHQ14321.npy +imgHQ23489.npy +imgHQ20439.npy +imgHQ02199.npy +imgHQ04755.npy +imgHQ27582.npy +imgHQ13690.npy +imgHQ04591.npy +imgHQ03731.npy +imgHQ04582.npy +imgHQ17628.npy +imgHQ19722.npy +imgHQ13307.npy +imgHQ13160.npy +imgHQ22805.npy +imgHQ25061.npy +imgHQ05557.npy +imgHQ09590.npy +imgHQ25746.npy +imgHQ28876.npy +imgHQ16703.npy +imgHQ11127.npy +imgHQ06691.npy +imgHQ21531.npy +imgHQ19170.npy +imgHQ25622.npy +imgHQ01968.npy +imgHQ09500.npy +imgHQ10371.npy +imgHQ19085.npy +imgHQ02732.npy +imgHQ15100.npy +imgHQ23038.npy +imgHQ27575.npy +imgHQ04110.npy +imgHQ08743.npy +imgHQ17952.npy +imgHQ09683.npy +imgHQ28281.npy +imgHQ11756.npy +imgHQ14252.npy +imgHQ07893.npy +imgHQ10211.npy +imgHQ17093.npy +imgHQ08851.npy +imgHQ07737.npy +imgHQ02622.npy +imgHQ16303.npy +imgHQ03411.npy +imgHQ04914.npy +imgHQ14828.npy +imgHQ23948.npy +imgHQ24416.npy +imgHQ08468.npy +imgHQ22822.npy +imgHQ29759.npy +imgHQ06962.npy +imgHQ25303.npy +imgHQ09833.npy +imgHQ13686.npy +imgHQ25451.npy +imgHQ17320.npy +imgHQ24719.npy +imgHQ29788.npy +imgHQ00658.npy +imgHQ08885.npy +imgHQ11680.npy +imgHQ22096.npy +imgHQ24852.npy +imgHQ17265.npy +imgHQ08836.npy +imgHQ20430.npy +imgHQ16137.npy +imgHQ25371.npy +imgHQ12809.npy +imgHQ03612.npy +imgHQ10920.npy +imgHQ21025.npy +imgHQ16054.npy +imgHQ20253.npy +imgHQ15172.npy +imgHQ22238.npy +imgHQ21070.npy +imgHQ24498.npy +imgHQ20904.npy +imgHQ26273.npy +imgHQ29219.npy +imgHQ11074.npy +imgHQ12816.npy +imgHQ09321.npy +imgHQ11077.npy +imgHQ08122.npy +imgHQ28987.npy +imgHQ05288.npy +imgHQ18110.npy +imgHQ06466.npy +imgHQ14409.npy +imgHQ02749.npy +imgHQ10775.npy +imgHQ01936.npy +imgHQ10065.npy +imgHQ07731.npy +imgHQ22958.npy +imgHQ23896.npy +imgHQ05305.npy +imgHQ05817.npy +imgHQ26324.npy +imgHQ08257.npy +imgHQ23395.npy +imgHQ06769.npy +imgHQ09754.npy +imgHQ09350.npy +imgHQ27719.npy +imgHQ12005.npy +imgHQ23041.npy +imgHQ04785.npy +imgHQ10185.npy +imgHQ05134.npy +imgHQ20035.npy +imgHQ07059.npy +imgHQ02528.npy +imgHQ05121.npy +imgHQ00022.npy +imgHQ27176.npy +imgHQ26709.npy +imgHQ07778.npy +imgHQ13403.npy +imgHQ22824.npy +imgHQ17300.npy +imgHQ03864.npy +imgHQ03983.npy +imgHQ28840.npy +imgHQ13037.npy +imgHQ24439.npy +imgHQ04528.npy +imgHQ08827.npy +imgHQ23459.npy +imgHQ10261.npy +imgHQ09526.npy +imgHQ12714.npy +imgHQ19429.npy +imgHQ02071.npy +imgHQ20609.npy +imgHQ26297.npy +imgHQ11097.npy +imgHQ23406.npy +imgHQ19366.npy +imgHQ01235.npy +imgHQ00626.npy +imgHQ05234.npy +imgHQ05680.npy +imgHQ12392.npy +imgHQ17528.npy +imgHQ03304.npy +imgHQ28534.npy +imgHQ27679.npy +imgHQ22840.npy +imgHQ29964.npy +imgHQ22075.npy +imgHQ26101.npy +imgHQ00912.npy +imgHQ23589.npy +imgHQ17373.npy +imgHQ03523.npy +imgHQ25957.npy +imgHQ03073.npy +imgHQ02803.npy +imgHQ12435.npy +imgHQ19718.npy +imgHQ28314.npy +imgHQ18324.npy +imgHQ08856.npy +imgHQ27522.npy +imgHQ23662.npy +imgHQ20499.npy +imgHQ10321.npy +imgHQ19573.npy +imgHQ04768.npy +imgHQ19693.npy +imgHQ12424.npy +imgHQ00273.npy +imgHQ26087.npy +imgHQ10515.npy +imgHQ16520.npy +imgHQ27898.npy +imgHQ28958.npy +imgHQ06325.npy +imgHQ12495.npy +imgHQ29200.npy +imgHQ01625.npy +imgHQ10086.npy +imgHQ25687.npy +imgHQ19950.npy +imgHQ10784.npy +imgHQ13682.npy +imgHQ13789.npy +imgHQ16835.npy +imgHQ20745.npy +imgHQ15324.npy +imgHQ24946.npy +imgHQ04310.npy +imgHQ05238.npy +imgHQ08508.npy +imgHQ05927.npy +imgHQ22323.npy +imgHQ18519.npy +imgHQ22017.npy +imgHQ07782.npy +imgHQ22755.npy +imgHQ19623.npy +imgHQ11512.npy +imgHQ06167.npy +imgHQ08370.npy +imgHQ00303.npy +imgHQ22192.npy +imgHQ06551.npy +imgHQ14250.npy +imgHQ13201.npy +imgHQ09172.npy +imgHQ02715.npy +imgHQ09426.npy +imgHQ02039.npy +imgHQ13040.npy +imgHQ24284.npy +imgHQ05276.npy +imgHQ06826.npy +imgHQ02727.npy +imgHQ03979.npy +imgHQ10386.npy +imgHQ18657.npy +imgHQ07540.npy +imgHQ07659.npy +imgHQ04404.npy +imgHQ22573.npy +imgHQ07743.npy +imgHQ10680.npy +imgHQ06445.npy +imgHQ20798.npy +imgHQ17064.npy +imgHQ00978.npy +imgHQ27548.npy +imgHQ09842.npy +imgHQ26924.npy +imgHQ27411.npy +imgHQ14731.npy +imgHQ13983.npy +imgHQ14628.npy +imgHQ28307.npy +imgHQ00482.npy +imgHQ07209.npy +imgHQ16541.npy +imgHQ05168.npy +imgHQ22606.npy +imgHQ20834.npy +imgHQ03913.npy +imgHQ10228.npy +imgHQ04849.npy +imgHQ15542.npy +imgHQ05671.npy +imgHQ12772.npy +imgHQ05062.npy +imgHQ29292.npy +imgHQ12124.npy +imgHQ19908.npy +imgHQ10652.npy +imgHQ17433.npy +imgHQ28908.npy +imgHQ15579.npy +imgHQ27966.npy +imgHQ13136.npy +imgHQ15944.npy +imgHQ06430.npy +imgHQ09202.npy +imgHQ08674.npy +imgHQ06124.npy +imgHQ21331.npy +imgHQ29411.npy +imgHQ11861.npy +imgHQ28963.npy +imgHQ02709.npy +imgHQ20215.npy +imgHQ15455.npy +imgHQ20844.npy +imgHQ02100.npy +imgHQ04407.npy +imgHQ11147.npy +imgHQ06632.npy +imgHQ18106.npy +imgHQ22741.npy +imgHQ00984.npy +imgHQ25704.npy +imgHQ14151.npy +imgHQ06951.npy +imgHQ13820.npy +imgHQ11316.npy +imgHQ27115.npy +imgHQ29010.npy +imgHQ04245.npy +imgHQ02324.npy +imgHQ24842.npy +imgHQ27067.npy +imgHQ16431.npy +imgHQ17707.npy +imgHQ26269.npy +imgHQ03129.npy +imgHQ07650.npy +imgHQ06422.npy +imgHQ21580.npy +imgHQ24220.npy +imgHQ18143.npy +imgHQ06673.npy +imgHQ19259.npy +imgHQ23162.npy +imgHQ07135.npy +imgHQ20482.npy +imgHQ13874.npy +imgHQ15434.npy +imgHQ15240.npy +imgHQ24299.npy +imgHQ06153.npy +imgHQ11971.npy +imgHQ16758.npy +imgHQ20213.npy +imgHQ19462.npy +imgHQ17972.npy +imgHQ09169.npy +imgHQ12111.npy +imgHQ05858.npy +imgHQ14510.npy +imgHQ07836.npy +imgHQ01350.npy +imgHQ13272.npy +imgHQ29044.npy +imgHQ15810.npy +imgHQ03172.npy +imgHQ23815.npy +imgHQ22242.npy +imgHQ06156.npy +imgHQ03586.npy +imgHQ24345.npy +imgHQ25740.npy +imgHQ01087.npy +imgHQ06480.npy +imgHQ29728.npy +imgHQ08561.npy +imgHQ02423.npy +imgHQ11143.npy +imgHQ11601.npy +imgHQ18392.npy +imgHQ18997.npy +imgHQ23644.npy +imgHQ07350.npy +imgHQ10353.npy +imgHQ11754.npy +imgHQ13204.npy +imgHQ15860.npy +imgHQ00756.npy +imgHQ16677.npy +imgHQ21575.npy +imgHQ27558.npy +imgHQ04333.npy +imgHQ23296.npy +imgHQ16617.npy +imgHQ29939.npy +imgHQ12676.npy +imgHQ19840.npy +imgHQ01600.npy +imgHQ06573.npy +imgHQ19282.npy +imgHQ25170.npy +imgHQ14085.npy +imgHQ12845.npy +imgHQ13427.npy +imgHQ06014.npy +imgHQ04098.npy +imgHQ22873.npy +imgHQ13579.npy +imgHQ08046.npy +imgHQ18792.npy +imgHQ26575.npy +imgHQ17349.npy +imgHQ14801.npy +imgHQ25989.npy +imgHQ05326.npy +imgHQ01665.npy +imgHQ08439.npy +imgHQ00530.npy +imgHQ26511.npy +imgHQ05298.npy +imgHQ11907.npy +imgHQ29809.npy +imgHQ27621.npy +imgHQ01040.npy +imgHQ03843.npy +imgHQ20627.npy +imgHQ23066.npy +imgHQ19916.npy +imgHQ09246.npy +imgHQ21602.npy +imgHQ09585.npy +imgHQ10310.npy +imgHQ26562.npy +imgHQ05253.npy +imgHQ22266.npy +imgHQ07658.npy +imgHQ20408.npy +imgHQ04103.npy +imgHQ27778.npy +imgHQ14396.npy +imgHQ00086.npy +imgHQ01364.npy +imgHQ22937.npy +imgHQ07399.npy +imgHQ27098.npy +imgHQ28590.npy +imgHQ28332.npy +imgHQ19130.npy +imgHQ24751.npy +imgHQ19568.npy +imgHQ07608.npy +imgHQ12926.npy +imgHQ19319.npy +imgHQ12429.npy +imgHQ17747.npy +imgHQ13921.npy +imgHQ29220.npy +imgHQ08084.npy +imgHQ03146.npy +imgHQ15500.npy +imgHQ22120.npy +imgHQ15878.npy +imgHQ03962.npy +imgHQ21945.npy +imgHQ28015.npy +imgHQ11078.npy +imgHQ17754.npy +imgHQ27658.npy +imgHQ15082.npy +imgHQ14554.npy +imgHQ11419.npy +imgHQ22731.npy +imgHQ20094.npy +imgHQ15504.npy +imgHQ15736.npy +imgHQ26752.npy +imgHQ15981.npy +imgHQ19446.npy +imgHQ22791.npy +imgHQ04938.npy +imgHQ09984.npy +imgHQ07065.npy +imgHQ17184.npy +imgHQ19419.npy +imgHQ03422.npy +imgHQ02611.npy +imgHQ10711.npy +imgHQ20290.npy +imgHQ10276.npy +imgHQ26295.npy +imgHQ24223.npy +imgHQ10790.npy +imgHQ23343.npy +imgHQ21922.npy +imgHQ12167.npy +imgHQ26160.npy +imgHQ21356.npy +imgHQ17535.npy +imgHQ18832.npy +imgHQ14285.npy +imgHQ11855.npy +imgHQ14796.npy +imgHQ21156.npy +imgHQ17984.npy +imgHQ17298.npy +imgHQ15739.npy +imgHQ17596.npy +imgHQ00230.npy +imgHQ28934.npy +imgHQ29124.npy +imgHQ24955.npy +imgHQ09481.npy +imgHQ09274.npy +imgHQ25935.npy +imgHQ16774.npy +imgHQ17829.npy +imgHQ16355.npy +imgHQ28900.npy +imgHQ08012.npy +imgHQ23845.npy +imgHQ01698.npy +imgHQ19006.npy +imgHQ01664.npy +imgHQ04569.npy +imgHQ25386.npy +imgHQ20851.npy +imgHQ10487.npy +imgHQ01322.npy +imgHQ04337.npy +imgHQ18928.npy +imgHQ18145.npy +imgHQ08202.npy +imgHQ27890.npy +imgHQ27104.npy +imgHQ08546.npy +imgHQ26404.npy +imgHQ23961.npy +imgHQ22498.npy +imgHQ04608.npy +imgHQ04015.npy +imgHQ20393.npy +imgHQ10493.npy +imgHQ04986.npy +imgHQ09857.npy +imgHQ06139.npy +imgHQ21172.npy +imgHQ28961.npy +imgHQ07963.npy +imgHQ12603.npy +imgHQ00945.npy +imgHQ16931.npy +imgHQ28651.npy +imgHQ27292.npy +imgHQ12129.npy +imgHQ15132.npy +imgHQ00736.npy +imgHQ07794.npy +imgHQ21727.npy +imgHQ12405.npy +imgHQ28716.npy +imgHQ15053.npy +imgHQ22274.npy +imgHQ23741.npy +imgHQ29963.npy +imgHQ10956.npy +imgHQ29956.npy +imgHQ19382.npy +imgHQ19488.npy +imgHQ13662.npy +imgHQ26588.npy +imgHQ03140.npy +imgHQ15622.npy +imgHQ01983.npy +imgHQ09245.npy +imgHQ14113.npy +imgHQ18796.npy +imgHQ22923.npy +imgHQ07343.npy +imgHQ00567.npy +imgHQ07841.npy +imgHQ14680.npy +imgHQ04652.npy +imgHQ17704.npy +imgHQ17932.npy +imgHQ09175.npy +imgHQ10701.npy +imgHQ22865.npy +imgHQ16495.npy +imgHQ28493.npy +imgHQ21893.npy +imgHQ09555.npy +imgHQ20372.npy +imgHQ04697.npy +imgHQ22955.npy +imgHQ23537.npy +imgHQ00118.npy +imgHQ23534.npy +imgHQ13666.npy +imgHQ03414.npy +imgHQ28337.npy +imgHQ01791.npy +imgHQ17133.npy +imgHQ03578.npy +imgHQ05210.npy +imgHQ29078.npy +imgHQ06594.npy +imgHQ10392.npy +imgHQ24632.npy +imgHQ23254.npy +imgHQ23923.npy +imgHQ17315.npy +imgHQ17734.npy +imgHQ24534.npy +imgHQ17745.npy +imgHQ22950.npy +imgHQ23515.npy +imgHQ26376.npy +imgHQ09205.npy +imgHQ22819.npy +imgHQ24343.npy +imgHQ04804.npy +imgHQ01234.npy +imgHQ04217.npy +imgHQ07975.npy +imgHQ29089.npy +imgHQ03331.npy +imgHQ08865.npy +imgHQ02508.npy +imgHQ15255.npy +imgHQ20243.npy +imgHQ14742.npy +imgHQ05780.npy +imgHQ00910.npy +imgHQ14721.npy +imgHQ03760.npy +imgHQ02690.npy +imgHQ26245.npy +imgHQ07434.npy +imgHQ01860.npy +imgHQ02646.npy +imgHQ21647.npy +imgHQ09613.npy +imgHQ27537.npy +imgHQ11173.npy +imgHQ15983.npy +imgHQ05538.npy +imgHQ20180.npy +imgHQ11108.npy +imgHQ11686.npy +imgHQ03181.npy +imgHQ00619.npy +imgHQ21888.npy +imgHQ28414.npy +imgHQ10897.npy +imgHQ03905.npy +imgHQ20115.npy +imgHQ29935.npy +imgHQ01667.npy +imgHQ12723.npy +imgHQ17833.npy +imgHQ22177.npy +imgHQ09303.npy +imgHQ17763.npy +imgHQ23383.npy +imgHQ09527.npy +imgHQ21252.npy +imgHQ08867.npy +imgHQ28436.npy +imgHQ07281.npy +imgHQ05635.npy +imgHQ25296.npy +imgHQ01088.npy +imgHQ26361.npy +imgHQ14301.npy +imgHQ01794.npy +imgHQ14559.npy +imgHQ18658.npy +imgHQ00427.npy +imgHQ17878.npy +imgHQ16754.npy +imgHQ26015.npy +imgHQ01878.npy +imgHQ10735.npy +imgHQ08165.npy +imgHQ05964.npy +imgHQ08772.npy +imgHQ01166.npy +imgHQ06860.npy +imgHQ21855.npy +imgHQ27940.npy +imgHQ02041.npy +imgHQ01101.npy +imgHQ06519.npy +imgHQ24024.npy +imgHQ04695.npy +imgHQ13592.npy +imgHQ11621.npy +imgHQ16185.npy +imgHQ00847.npy +imgHQ26804.npy +imgHQ24667.npy +imgHQ02430.npy +imgHQ29796.npy +imgHQ10976.npy +imgHQ12180.npy +imgHQ14743.npy +imgHQ27867.npy +imgHQ25148.npy +imgHQ10166.npy +imgHQ12130.npy +imgHQ28948.npy +imgHQ28923.npy +imgHQ26808.npy +imgHQ29045.npy +imgHQ25519.npy +imgHQ05548.npy +imgHQ02064.npy +imgHQ25783.npy +imgHQ00480.npy +imgHQ01785.npy +imgHQ05063.npy +imgHQ14478.npy +imgHQ28523.npy +imgHQ25555.npy +imgHQ19646.npy +imgHQ21129.npy +imgHQ19122.npy +imgHQ24273.npy +imgHQ12016.npy +imgHQ06913.npy +imgHQ28293.npy +imgHQ11324.npy +imgHQ04772.npy +imgHQ14437.npy +imgHQ07107.npy +imgHQ05811.npy +imgHQ06337.npy +imgHQ13051.npy +imgHQ27518.npy +imgHQ16592.npy +imgHQ07248.npy +imgHQ12987.npy +imgHQ10802.npy +imgHQ00042.npy +imgHQ17353.npy +imgHQ20598.npy +imgHQ04544.npy +imgHQ27457.npy +imgHQ13535.npy +imgHQ23467.npy +imgHQ02725.npy +imgHQ08789.npy +imgHQ21338.npy +imgHQ22493.npy +imgHQ22123.npy +imgHQ24208.npy +imgHQ10890.npy +imgHQ27579.npy +imgHQ02281.npy +imgHQ03194.npy +imgHQ10067.npy +imgHQ24758.npy +imgHQ08199.npy +imgHQ20736.npy +imgHQ17416.npy +imgHQ19871.npy +imgHQ15517.npy +imgHQ08175.npy +imgHQ13439.npy +imgHQ06889.npy +imgHQ21261.npy +imgHQ02466.npy +imgHQ15858.npy +imgHQ06600.npy +imgHQ27733.npy +imgHQ23193.npy +imgHQ11262.npy +imgHQ02920.npy +imgHQ12128.npy +imgHQ01238.npy +imgHQ20391.npy +imgHQ05616.npy +imgHQ09422.npy +imgHQ28420.npy +imgHQ16807.npy +imgHQ24878.npy +imgHQ05830.npy +imgHQ12338.npy +imgHQ24999.npy +imgHQ18782.npy +imgHQ11322.npy +imgHQ19100.npy +imgHQ23423.npy +imgHQ24770.npy +imgHQ03560.npy +imgHQ19527.npy +imgHQ24411.npy +imgHQ28925.npy +imgHQ12398.npy +imgHQ27980.npy +imgHQ12269.npy +imgHQ04014.npy +imgHQ08371.npy +imgHQ26423.npy +imgHQ06846.npy +imgHQ28512.npy +imgHQ10115.npy +imgHQ25910.npy +imgHQ06664.npy +imgHQ15147.npy +imgHQ02475.npy +imgHQ06552.npy +imgHQ17112.npy +imgHQ21552.npy +imgHQ28121.npy +imgHQ14172.npy +imgHQ26432.npy +imgHQ21711.npy +imgHQ27134.npy +imgHQ22297.npy +imgHQ26652.npy +imgHQ28383.npy +imgHQ09317.npy +imgHQ29767.npy +imgHQ15970.npy +imgHQ11392.npy +imgHQ27435.npy +imgHQ03266.npy +imgHQ18359.npy +imgHQ11252.npy +imgHQ17629.npy +imgHQ07352.npy +imgHQ23134.npy +imgHQ21077.npy +imgHQ21494.npy +imgHQ25566.npy +imgHQ23371.npy +imgHQ14934.npy +imgHQ21396.npy +imgHQ23959.npy +imgHQ09343.npy +imgHQ18307.npy +imgHQ03561.npy +imgHQ05199.npy +imgHQ15575.npy +imgHQ26371.npy +imgHQ16023.npy +imgHQ28259.npy +imgHQ22453.npy +imgHQ13491.npy +imgHQ08262.npy +imgHQ16306.npy +imgHQ11436.npy +imgHQ24536.npy +imgHQ14793.npy +imgHQ28320.npy +imgHQ07079.npy +imgHQ22788.npy +imgHQ21905.npy +imgHQ21624.npy +imgHQ05792.npy +imgHQ27109.npy +imgHQ06540.npy +imgHQ06295.npy +imgHQ26446.npy +imgHQ03482.npy +imgHQ01490.npy +imgHQ26870.npy +imgHQ05614.npy +imgHQ23894.npy +imgHQ22605.npy +imgHQ16380.npy +imgHQ19217.npy +imgHQ12324.npy +imgHQ27657.npy +imgHQ16262.npy +imgHQ18170.npy +imgHQ17366.npy +imgHQ13454.npy +imgHQ10157.npy +imgHQ25414.npy +imgHQ23410.npy +imgHQ18558.npy +imgHQ22081.npy +imgHQ24606.npy +imgHQ24423.npy +imgHQ09517.npy +imgHQ29341.npy +imgHQ02073.npy +imgHQ11114.npy +imgHQ21636.npy +imgHQ18404.npy +imgHQ23507.npy +imgHQ27320.npy +imgHQ02627.npy +imgHQ01988.npy +imgHQ08482.npy +imgHQ01012.npy +imgHQ27112.npy +imgHQ18545.npy +imgHQ12476.npy +imgHQ29573.npy +imgHQ07828.npy +imgHQ08785.npy +imgHQ25975.npy +imgHQ06675.npy +imgHQ03963.npy +imgHQ21128.npy +imgHQ02448.npy +imgHQ21543.npy +imgHQ15180.npy +imgHQ00304.npy +imgHQ27241.npy +imgHQ23974.npy +imgHQ17326.npy +imgHQ02585.npy +imgHQ14388.npy +imgHQ01324.npy +imgHQ11632.npy +imgHQ09584.npy +imgHQ12860.npy +imgHQ24030.npy +imgHQ05458.npy +imgHQ14992.npy +imgHQ26842.npy +imgHQ22147.npy +imgHQ24872.npy +imgHQ29321.npy +imgHQ07785.npy +imgHQ10426.npy +imgHQ28596.npy +imgHQ28171.npy +imgHQ25042.npy +imgHQ03373.npy +imgHQ12607.npy +imgHQ01865.npy +imgHQ29585.npy +imgHQ12172.npy +imgHQ12151.npy +imgHQ04932.npy +imgHQ15937.npy +imgHQ14765.npy +imgHQ26659.npy +imgHQ11202.npy +imgHQ11304.npy +imgHQ08680.npy +imgHQ09043.npy +imgHQ11176.npy +imgHQ21515.npy +imgHQ03231.npy +imgHQ07210.npy +imgHQ04188.npy +imgHQ21937.npy +imgHQ23851.npy +imgHQ11596.npy +imgHQ10489.npy +imgHQ12319.npy +imgHQ14426.npy +imgHQ12469.npy +imgHQ01212.npy +imgHQ13175.npy +imgHQ23602.npy +imgHQ06278.npy +imgHQ24709.npy +imgHQ07958.npy +imgHQ18032.npy +imgHQ22389.npy +imgHQ23964.npy +imgHQ13544.npy +imgHQ06709.npy +imgHQ07192.npy +imgHQ07676.npy +imgHQ00691.npy +imgHQ29249.npy +imgHQ05292.npy +imgHQ05323.npy +imgHQ16616.npy +imgHQ07199.npy +imgHQ11871.npy +imgHQ19834.npy +imgHQ22348.npy +imgHQ01836.npy +imgHQ00908.npy +imgHQ01749.npy +imgHQ21629.npy +imgHQ10729.npy +imgHQ19883.npy +imgHQ28346.npy +imgHQ16083.npy +imgHQ06907.npy +imgHQ00778.npy +imgHQ07481.npy +imgHQ03671.npy +imgHQ07899.npy +imgHQ17788.npy +imgHQ08013.npy +imgHQ27367.npy +imgHQ21189.npy +imgHQ02498.npy +imgHQ17385.npy +imgHQ21541.npy +imgHQ21912.npy +imgHQ15830.npy +imgHQ12463.npy +imgHQ21547.npy +imgHQ10512.npy +imgHQ28600.npy +imgHQ06784.npy +imgHQ09778.npy +imgHQ09636.npy +imgHQ17360.npy +imgHQ21319.npy +imgHQ26976.npy +imgHQ11247.npy +imgHQ01473.npy +imgHQ07697.npy +imgHQ27263.npy +imgHQ13185.npy +imgHQ06017.npy +imgHQ11201.npy +imgHQ06924.npy +imgHQ02225.npy +imgHQ20873.npy +imgHQ12863.npy +imgHQ17630.npy +imgHQ04739.npy +imgHQ22886.npy +imgHQ27286.npy +imgHQ08200.npy +imgHQ07013.npy +imgHQ18140.npy +imgHQ20888.npy +imgHQ25717.npy +imgHQ08083.npy +imgHQ25533.npy +imgHQ09167.npy +imgHQ24016.npy +imgHQ19492.npy +imgHQ24863.npy +imgHQ12132.npy +imgHQ08085.npy +imgHQ27240.npy +imgHQ01387.npy +imgHQ03559.npy +imgHQ27615.npy +imgHQ11079.npy +imgHQ09841.npy +imgHQ13171.npy +imgHQ24954.npy +imgHQ25964.npy +imgHQ29674.npy +imgHQ08643.npy +imgHQ29943.npy +imgHQ11712.npy +imgHQ02995.npy +imgHQ22659.npy +imgHQ17475.npy +imgHQ11017.npy +imgHQ26306.npy +imgHQ00108.npy +imgHQ26153.npy +imgHQ01004.npy +imgHQ03753.npy +imgHQ00843.npy +imgHQ20663.npy +imgHQ08143.npy +imgHQ10995.npy +imgHQ28429.npy +imgHQ16046.npy +imgHQ16407.npy +imgHQ04097.npy +imgHQ20493.npy +imgHQ11929.npy +imgHQ15256.npy +imgHQ11751.npy +imgHQ10312.npy +imgHQ26103.npy +imgHQ09325.npy +imgHQ27967.npy +imgHQ08562.npy +imgHQ24244.npy +imgHQ07074.npy +imgHQ08184.npy +imgHQ27832.npy +imgHQ06452.npy +imgHQ13193.npy +imgHQ17134.npy +imgHQ18055.npy +imgHQ15021.npy +imgHQ00614.npy +imgHQ19551.npy +imgHQ28453.npy +imgHQ09523.npy +imgHQ19305.npy +imgHQ23910.npy +imgHQ09382.npy +imgHQ11146.npy +imgHQ12613.npy +imgHQ06744.npy +imgHQ14148.npy +imgHQ14103.npy +imgHQ28608.npy +imgHQ21944.npy +imgHQ12237.npy +imgHQ22623.npy +imgHQ13601.npy +imgHQ01465.npy +imgHQ08408.npy +imgHQ05145.npy +imgHQ04478.npy +imgHQ23709.npy +imgHQ06435.npy +imgHQ24973.npy +imgHQ05814.npy +imgHQ28724.npy +imgHQ09158.npy +imgHQ23980.npy +imgHQ27376.npy +imgHQ00896.npy +imgHQ10957.npy +imgHQ12759.npy +imgHQ27649.npy +imgHQ06354.npy +imgHQ17058.npy +imgHQ01302.npy +imgHQ28970.npy +imgHQ24058.npy +imgHQ02649.npy +imgHQ08641.npy +imgHQ03546.npy +imgHQ01887.npy +imgHQ06810.npy +imgHQ21871.npy +imgHQ28903.npy +imgHQ24155.npy +imgHQ06292.npy +imgHQ18583.npy +imgHQ03903.npy +imgHQ17030.npy +imgHQ12923.npy +imgHQ08015.npy +imgHQ11474.npy +imgHQ00138.npy +imgHQ25234.npy +imgHQ22027.npy +imgHQ23905.npy +imgHQ06099.npy +imgHQ07432.npy +imgHQ02257.npy +imgHQ26839.npy +imgHQ20378.npy +imgHQ19038.npy +imgHQ19202.npy +imgHQ05280.npy +imgHQ04172.npy +imgHQ18595.npy +imgHQ27672.npy +imgHQ26997.npy +imgHQ21083.npy +imgHQ05777.npy +imgHQ10619.npy +imgHQ08864.npy +imgHQ02542.npy +imgHQ08049.npy +imgHQ14288.npy +imgHQ08330.npy +imgHQ16779.npy +imgHQ02767.npy +imgHQ24909.npy +imgHQ24447.npy +imgHQ16276.npy +imgHQ07733.npy +imgHQ20528.npy +imgHQ02563.npy +imgHQ21320.npy +imgHQ14637.npy +imgHQ22160.npy +imgHQ04775.npy +imgHQ04177.npy +imgHQ11633.npy +imgHQ05291.npy +imgHQ06267.npy +imgHQ04829.npy +imgHQ16436.npy +imgHQ01399.npy +imgHQ12368.npy +imgHQ06380.npy +imgHQ27162.npy +imgHQ10842.npy +imgHQ24858.npy +imgHQ17392.npy +imgHQ25004.npy +imgHQ24190.npy +imgHQ10350.npy +imgHQ03123.npy +imgHQ12757.npy +imgHQ04858.npy +imgHQ13565.npy +imgHQ03125.npy +imgHQ03524.npy +imgHQ29511.npy +imgHQ08529.npy +imgHQ00763.npy +imgHQ12309.npy +imgHQ09876.npy +imgHQ06387.npy +imgHQ06697.npy +imgHQ20529.npy +imgHQ02833.npy +imgHQ24350.npy +imgHQ06102.npy +imgHQ27364.npy +imgHQ18607.npy +imgHQ27655.npy +imgHQ07147.npy +imgHQ26174.npy +imgHQ08466.npy +imgHQ19412.npy +imgHQ01269.npy +imgHQ25267.npy +imgHQ22661.npy +imgHQ16769.npy +imgHQ06296.npy +imgHQ04375.npy +imgHQ09113.npy +imgHQ09304.npy +imgHQ29505.npy +imgHQ02733.npy +imgHQ02283.npy +imgHQ21457.npy +imgHQ15567.npy +imgHQ08055.npy +imgHQ22338.npy +imgHQ01267.npy +imgHQ29041.npy +imgHQ16292.npy +imgHQ00593.npy +imgHQ12245.npy +imgHQ04736.npy +imgHQ07887.npy +imgHQ19216.npy +imgHQ07917.npy +imgHQ01106.npy +imgHQ25200.npy +imgHQ19479.npy +imgHQ10566.npy +imgHQ21264.npy +imgHQ13095.npy +imgHQ14323.npy +imgHQ08484.npy +imgHQ19420.npy +imgHQ27993.npy +imgHQ01496.npy +imgHQ00888.npy +imgHQ02536.npy +imgHQ08574.npy +imgHQ18536.npy +imgHQ21736.npy +imgHQ27438.npy +imgHQ08117.npy +imgHQ03797.npy +imgHQ16076.npy +imgHQ08664.npy +imgHQ16487.npy +imgHQ08750.npy +imgHQ01540.npy +imgHQ07063.npy +imgHQ22137.npy +imgHQ02637.npy +imgHQ19061.npy +imgHQ16032.npy +imgHQ01989.npy +imgHQ16177.npy +imgHQ14440.npy +imgHQ02262.npy +imgHQ26462.npy +imgHQ07214.npy +imgHQ06998.npy +imgHQ14663.npy +imgHQ14235.npy +imgHQ24566.npy +imgHQ15046.npy +imgHQ02590.npy +imgHQ08550.npy +imgHQ17154.npy +imgHQ25197.npy +imgHQ21443.npy +imgHQ23740.npy +imgHQ11626.npy +imgHQ14377.npy +imgHQ04831.npy +imgHQ18159.npy +imgHQ29226.npy +imgHQ24096.npy +imgHQ18507.npy +imgHQ15795.npy +imgHQ00947.npy +imgHQ11722.npy +imgHQ06743.npy +imgHQ10287.npy +imgHQ22202.npy +imgHQ15805.npy +imgHQ12014.npy +imgHQ01060.npy +imgHQ05102.npy +imgHQ04878.npy +imgHQ04584.npy +imgHQ19053.npy +imgHQ03278.npy +imgHQ15896.npy +imgHQ09771.npy +imgHQ07164.npy +imgHQ26734.npy +imgHQ17108.npy +imgHQ05361.npy +imgHQ21959.npy +imgHQ26064.npy +imgHQ09491.npy +imgHQ11174.npy +imgHQ14369.npy +imgHQ19738.npy +imgHQ02908.npy +imgHQ06728.npy +imgHQ02888.npy +imgHQ18779.npy +imgHQ18733.npy +imgHQ14436.npy +imgHQ16821.npy +imgHQ24565.npy +imgHQ29522.npy +imgHQ15123.npy +imgHQ16968.npy +imgHQ18686.npy +imgHQ02700.npy +imgHQ23689.npy +imgHQ05090.npy +imgHQ25196.npy +imgHQ22370.npy +imgHQ09127.npy +imgHQ17914.npy +imgHQ11655.npy +imgHQ02414.npy +imgHQ20900.npy +imgHQ07316.npy +imgHQ19400.npy +imgHQ25837.npy +imgHQ03858.npy +imgHQ16459.npy +imgHQ19512.npy +imgHQ16887.npy +imgHQ06739.npy +imgHQ24627.npy +imgHQ15075.npy +imgHQ03387.npy +imgHQ07517.npy +imgHQ02978.npy +imgHQ17342.npy +imgHQ28428.npy +imgHQ29732.npy +imgHQ25365.npy +imgHQ20754.npy +imgHQ07200.npy +imgHQ23128.npy +imgHQ05797.npy +imgHQ05907.npy +imgHQ27057.npy +imgHQ01185.npy +imgHQ24352.npy +imgHQ06178.npy +imgHQ17266.npy +imgHQ01219.npy +imgHQ18927.npy +imgHQ29374.npy +imgHQ15758.npy +imgHQ06228.npy +imgHQ27485.npy +imgHQ16206.npy +imgHQ10849.npy +imgHQ17595.npy +imgHQ01654.npy +imgHQ23448.npy +imgHQ00163.npy +imgHQ12751.npy +imgHQ29992.npy +imgHQ24830.npy +imgHQ21793.npy +imgHQ28170.npy +imgHQ09702.npy +imgHQ06894.npy +imgHQ09859.npy +imgHQ07357.npy +imgHQ14667.npy +imgHQ03570.npy +imgHQ28375.npy +imgHQ17395.npy +imgHQ16198.npy +imgHQ12797.npy +imgHQ10865.npy +imgHQ25106.npy +imgHQ23444.npy +imgHQ28791.npy +imgHQ18588.npy +imgHQ06555.npy +imgHQ24258.npy +imgHQ14692.npy +imgHQ23787.npy +imgHQ01511.npy +imgHQ17725.npy +imgHQ27434.npy +imgHQ01611.npy +imgHQ26041.npy +imgHQ19692.npy +imgHQ12507.npy +imgHQ06045.npy +imgHQ29653.npy +imgHQ15995.npy +imgHQ18320.npy +imgHQ26272.npy +imgHQ21177.npy +imgHQ21839.npy +imgHQ23398.npy +imgHQ15244.npy +imgHQ00198.npy +imgHQ29539.npy +imgHQ23421.npy +imgHQ20996.npy +imgHQ28983.npy +imgHQ28401.npy +imgHQ14732.npy +imgHQ17546.npy +imgHQ24555.npy +imgHQ02043.npy +imgHQ04366.npy +imgHQ01165.npy +imgHQ20623.npy +imgHQ05823.npy +imgHQ12735.npy +imgHQ24028.npy +imgHQ29459.npy +imgHQ19000.npy +imgHQ23055.npy +imgHQ26194.npy +imgHQ22038.npy +imgHQ12997.npy +imgHQ19972.npy +imgHQ08517.npy +imgHQ19283.npy +imgHQ06097.npy +imgHQ07865.npy +imgHQ05734.npy +imgHQ22679.npy +imgHQ10038.npy +imgHQ05968.npy +imgHQ06745.npy +imgHQ18887.npy +imgHQ08341.npy +imgHQ14748.npy +imgHQ03213.npy +imgHQ08762.npy +imgHQ04038.npy +imgHQ24966.npy +imgHQ21280.npy +imgHQ19788.npy +imgHQ11473.npy +imgHQ29323.npy +imgHQ19947.npy +imgHQ24261.npy +imgHQ16317.npy +imgHQ29533.npy +imgHQ01506.npy +imgHQ21227.npy +imgHQ11946.npy +imgHQ16603.npy +imgHQ22943.npy +imgHQ01835.npy +imgHQ25008.npy +imgHQ26698.npy +imgHQ24476.npy +imgHQ21228.npy +imgHQ05183.npy +imgHQ10674.npy +imgHQ17843.npy +imgHQ17147.npy +imgHQ00403.npy +imgHQ07114.npy +imgHQ02506.npy +imgHQ22688.npy +imgHQ20857.npy +imgHQ02562.npy +imgHQ05073.npy +imgHQ25892.npy +imgHQ04025.npy +imgHQ22052.npy +imgHQ00137.npy +imgHQ23687.npy +imgHQ09390.npy +imgHQ11145.npy +imgHQ08448.npy +imgHQ22676.npy +imgHQ21914.npy +imgHQ20477.npy +imgHQ21445.npy +imgHQ15251.npy +imgHQ04887.npy +imgHQ29982.npy +imgHQ07849.npy +imgHQ02538.npy +imgHQ27212.npy +imgHQ23277.npy +imgHQ26348.npy +imgHQ23928.npy +imgHQ00562.npy +imgHQ07508.npy +imgHQ00279.npy +imgHQ29582.npy +imgHQ25437.npy +imgHQ06575.npy +imgHQ25348.npy +imgHQ05399.npy +imgHQ26739.npy +imgHQ02773.npy +imgHQ11260.npy +imgHQ17789.npy +imgHQ04054.npy +imgHQ02785.npy +imgHQ05938.npy +imgHQ07747.npy +imgHQ22877.npy +imgHQ00206.npy +imgHQ05056.npy +imgHQ02131.npy +imgHQ21105.npy +imgHQ26878.npy +imgHQ01468.npy +imgHQ11226.npy +imgHQ12257.npy +imgHQ27752.npy +imgHQ16559.npy +imgHQ01502.npy +imgHQ11130.npy +imgHQ04779.npy +imgHQ08788.npy +imgHQ01372.npy +imgHQ14681.npy +imgHQ00047.npy +imgHQ15422.npy +imgHQ09344.npy +imgHQ11335.npy +imgHQ24869.npy +imgHQ07530.npy +imgHQ08029.npy +imgHQ29990.npy +imgHQ10529.npy +imgHQ03617.npy +imgHQ29159.npy +imgHQ04043.npy +imgHQ03572.npy +imgHQ09126.npy +imgHQ18878.npy +imgHQ09680.npy +imgHQ25455.npy +imgHQ01276.npy +imgHQ20875.npy +imgHQ19994.npy +imgHQ01495.npy +imgHQ21232.npy +imgHQ11293.npy +imgHQ01153.npy +imgHQ03405.npy +imgHQ29060.npy +imgHQ07802.npy +imgHQ03791.npy +imgHQ25875.npy +imgHQ23571.npy +imgHQ02828.npy +imgHQ15109.npy +imgHQ27799.npy +imgHQ12485.npy +imgHQ26057.npy +imgHQ17297.npy +imgHQ06825.npy +imgHQ14588.npy +imgHQ04516.npy +imgHQ16004.npy +imgHQ01998.npy +imgHQ12929.npy +imgHQ03376.npy +imgHQ25301.npy +imgHQ18396.npy +imgHQ11196.npy +imgHQ17901.npy +imgHQ09514.npy +imgHQ05800.npy +imgHQ08109.npy +imgHQ06898.npy +imgHQ28364.npy +imgHQ18579.npy +imgHQ08736.npy +imgHQ21184.npy +imgHQ28777.npy +imgHQ02957.npy +imgHQ04536.npy +imgHQ16584.npy +imgHQ18254.npy +imgHQ19814.npy +imgHQ25922.npy +imgHQ18561.npy +imgHQ08394.npy +imgHQ28255.npy +imgHQ13237.npy +imgHQ07184.npy +imgHQ04095.npy +imgHQ26173.npy +imgHQ25367.npy +imgHQ27843.npy +imgHQ18275.npy +imgHQ01577.npy +imgHQ10743.npy +imgHQ09146.npy +imgHQ24306.npy +imgHQ07967.npy +imgHQ04349.npy +imgHQ26056.npy +imgHQ13222.npy +imgHQ17947.npy +imgHQ22974.npy +imgHQ01492.npy +imgHQ11697.npy +imgHQ00552.npy +imgHQ20973.npy +imgHQ22630.npy +imgHQ03381.npy +imgHQ07679.npy +imgHQ02275.npy +imgHQ07870.npy +imgHQ25481.npy +imgHQ12641.npy +imgHQ07240.npy +imgHQ00554.npy +imgHQ27018.npy +imgHQ03130.npy +imgHQ00156.npy +imgHQ20194.npy +imgHQ06356.npy +imgHQ19639.npy +imgHQ09674.npy +imgHQ05708.npy +imgHQ18178.npy +imgHQ06896.npy +imgHQ01289.npy +imgHQ23672.npy +imgHQ15514.npy +imgHQ20471.npy +imgHQ25537.npy +imgHQ12070.npy +imgHQ13264.npy +imgHQ19962.npy +imgHQ13388.npy +imgHQ17978.npy +imgHQ16610.npy +imgHQ18436.npy +imgHQ03855.npy +imgHQ18537.npy +imgHQ23542.npy +imgHQ01332.npy +imgHQ25940.npy +imgHQ02435.npy +imgHQ27243.npy +imgHQ05634.npy +imgHQ08031.npy +imgHQ18214.npy +imgHQ04559.npy +imgHQ23307.npy +imgHQ13300.npy +imgHQ27585.npy +imgHQ01814.npy +imgHQ00995.npy +imgHQ03119.npy +imgHQ29410.npy +imgHQ16273.npy +imgHQ12753.npy +imgHQ20689.npy +imgHQ27032.npy +imgHQ22191.npy +imgHQ04810.npy +imgHQ09605.npy +imgHQ27741.npy +imgHQ01869.npy +imgHQ02443.npy +imgHQ02243.npy +imgHQ22650.npy +imgHQ14024.npy +imgHQ07842.npy +imgHQ27001.npy +imgHQ10909.npy +imgHQ25529.npy +imgHQ18517.npy +imgHQ10820.npy +imgHQ04187.npy +imgHQ25087.npy +imgHQ10450.npy +imgHQ09439.npy +imgHQ12799.npy +imgHQ21766.npy +imgHQ24694.npy +imgHQ04212.npy +imgHQ04526.npy +imgHQ05144.npy +imgHQ05994.npy +imgHQ18293.npy +imgHQ23626.npy +imgHQ12556.npy +imgHQ11720.npy +imgHQ13917.npy +imgHQ10916.npy +imgHQ29691.npy +imgHQ10358.npy +imgHQ00314.npy +imgHQ16373.npy +imgHQ27407.npy +imgHQ16894.npy +imgHQ25372.npy +imgHQ19835.npy +imgHQ15116.npy +imgHQ01559.npy +imgHQ18232.npy +imgHQ11919.npy +imgHQ05233.npy +imgHQ24865.npy +imgHQ19269.npy +imgHQ03947.npy +imgHQ05674.npy +imgHQ26365.npy +imgHQ01854.npy +imgHQ26706.npy +imgHQ22612.npy +imgHQ26602.npy +imgHQ27110.npy +imgHQ13760.npy +imgHQ11611.npy +imgHQ04344.npy +imgHQ08760.npy +imgHQ11947.npy +imgHQ22282.npy +imgHQ12471.npy +imgHQ19404.npy +imgHQ10510.npy +imgHQ10383.npy +imgHQ08615.npy +imgHQ22772.npy +imgHQ20917.npy +imgHQ13251.npy +imgHQ26411.npy +imgHQ01935.npy +imgHQ10545.npy +imgHQ23592.npy +imgHQ29572.npy +imgHQ23454.npy +imgHQ02386.npy +imgHQ24687.npy +imgHQ12881.npy +imgHQ26493.npy +imgHQ22653.npy +imgHQ19040.npy +imgHQ27075.npy +imgHQ05712.npy +imgHQ15440.npy +imgHQ03845.npy +imgHQ03175.npy +imgHQ19208.npy +imgHQ24799.npy +imgHQ28381.npy +imgHQ16181.npy +imgHQ00990.npy +imgHQ22553.npy +imgHQ25111.npy +imgHQ24625.npy +imgHQ01513.npy +imgHQ26731.npy +imgHQ02018.npy +imgHQ00484.npy +imgHQ17245.npy +imgHQ04435.npy +imgHQ26082.npy +imgHQ29109.npy +imgHQ26667.npy +imgHQ03833.npy +imgHQ04309.npy +imgHQ05876.npy +imgHQ08314.npy +imgHQ12213.npy +imgHQ00852.npy +imgHQ11342.npy +imgHQ25115.npy +imgHQ18971.npy +imgHQ05935.npy +imgHQ02037.npy +imgHQ06707.npy +imgHQ19723.npy +imgHQ06559.npy +imgHQ29171.npy +imgHQ22311.npy +imgHQ16278.npy +imgHQ20377.npy +imgHQ05841.npy +imgHQ04774.npy +imgHQ10197.npy +imgHQ22400.npy +imgHQ23001.npy +imgHQ18499.npy +imgHQ04171.npy +imgHQ29293.npy +imgHQ27392.npy +imgHQ01868.npy +imgHQ21900.npy +imgHQ10648.npy +imgHQ00711.npy +imgHQ20657.npy +imgHQ24979.npy +imgHQ20652.npy +imgHQ13517.npy +imgHQ12692.npy +imgHQ18705.npy +imgHQ18440.npy +imgHQ21230.npy +imgHQ10230.npy +imgHQ03931.npy +imgHQ20457.npy +imgHQ09515.npy +imgHQ14056.npy +imgHQ29467.npy +imgHQ13080.npy +imgHQ08961.npy +imgHQ20176.npy +imgHQ27017.npy +imgHQ17322.npy +imgHQ18415.npy +imgHQ10737.npy +imgHQ13024.npy +imgHQ22246.npy +imgHQ27924.npy +imgHQ11847.npy +imgHQ17626.npy +imgHQ01677.npy +imgHQ28268.npy +imgHQ27155.npy +imgHQ10527.npy +imgHQ02550.npy +imgHQ23771.npy +imgHQ07891.npy +imgHQ22705.npy +imgHQ05418.npy +imgHQ09391.npy +imgHQ01409.npy +imgHQ25896.npy +imgHQ25485.npy +imgHQ12116.npy +imgHQ02768.npy +imgHQ28964.npy +imgHQ09270.npy +imgHQ11406.npy +imgHQ09235.npy +imgHQ22186.npy +imgHQ09459.npy +imgHQ13435.npy +imgHQ08845.npy +imgHQ25122.npy +imgHQ00492.npy +imgHQ10363.npy +imgHQ05467.npy +imgHQ11408.npy +imgHQ16464.npy +imgHQ06118.npy +imgHQ04297.npy +imgHQ06482.npy +imgHQ25263.npy +imgHQ18981.npy +imgHQ14804.npy +imgHQ13416.npy +imgHQ29011.npy +imgHQ11169.npy +imgHQ24484.npy +imgHQ11715.npy +imgHQ19222.npy +imgHQ12911.npy +imgHQ08273.npy +imgHQ23987.npy +imgHQ29697.npy +imgHQ08208.npy +imgHQ07861.npy +imgHQ26797.npy +imgHQ21514.npy +imgHQ26765.npy +imgHQ13937.npy +imgHQ02360.npy +imgHQ07108.npy +imgHQ23431.npy +imgHQ03823.npy +imgHQ27473.npy +imgHQ24114.npy +imgHQ19912.npy +imgHQ12008.npy +imgHQ26952.npy +imgHQ24127.npy +imgHQ21158.npy +imgHQ15443.npy +imgHQ07973.npy +imgHQ09396.npy +imgHQ23748.npy +imgHQ11564.npy +imgHQ13380.npy +imgHQ20850.npy +imgHQ23002.npy +imgHQ19827.npy +imgHQ19054.npy +imgHQ13657.npy +imgHQ05989.npy +imgHQ28518.npy +imgHQ05833.npy +imgHQ26318.npy +imgHQ26390.npy +imgHQ26614.npy +imgHQ22505.npy +imgHQ20254.npy +imgHQ06607.npy +imgHQ05427.npy +imgHQ05987.npy +imgHQ03154.npy +imgHQ27144.npy +imgHQ00911.npy +imgHQ29065.npy +imgHQ19959.npy +imgHQ17645.npy +imgHQ11265.npy +imgHQ05909.npy +imgHQ03716.npy +imgHQ23743.npy +imgHQ14158.npy +imgHQ28081.npy +imgHQ17401.npy +imgHQ01571.npy +imgHQ19107.npy +imgHQ10135.npy +imgHQ16767.npy +imgHQ14595.npy +imgHQ10217.npy +imgHQ10419.npy +imgHQ17382.npy +imgHQ10746.npy +imgHQ10774.npy +imgHQ13233.npy +imgHQ26128.npy +imgHQ01019.npy +imgHQ05524.npy +imgHQ13420.npy +imgHQ05242.npy +imgHQ15799.npy +imgHQ04868.npy +imgHQ12869.npy +imgHQ14490.npy +imgHQ12453.npy +imgHQ25221.npy +imgHQ12103.npy +imgHQ11587.npy +imgHQ28672.npy +imgHQ19537.npy +imgHQ15708.npy +imgHQ07606.npy +imgHQ20040.npy +imgHQ28282.npy +imgHQ12868.npy +imgHQ16563.npy +imgHQ19780.npy +imgHQ00093.npy +imgHQ28232.npy +imgHQ03111.npy +imgHQ05599.npy +imgHQ02120.npy +imgHQ02145.npy +imgHQ29094.npy +imgHQ12568.npy +imgHQ04330.npy +imgHQ26334.npy +imgHQ13490.npy +imgHQ17126.npy +imgHQ12197.npy +imgHQ00594.npy +imgHQ13157.npy +imgHQ10742.npy +imgHQ15118.npy +imgHQ17255.npy +imgHQ01879.npy +imgHQ16006.npy +imgHQ28649.npy +imgHQ15225.npy +imgHQ23177.npy +imgHQ14967.npy +imgHQ03987.npy +imgHQ25320.npy +imgHQ08694.npy +imgHQ22608.npy +imgHQ19892.npy +imgHQ18554.npy +imgHQ07806.npy +imgHQ18302.npy +imgHQ23612.npy +imgHQ00844.npy +imgHQ09961.npy +imgHQ28260.npy +imgHQ22503.npy +imgHQ13552.npy +imgHQ00258.npy +imgHQ26780.npy +imgHQ14875.npy +imgHQ08700.npy +imgHQ24795.npy +imgHQ15867.npy +imgHQ04841.npy +imgHQ26366.npy +imgHQ18876.npy +imgHQ03330.npy +imgHQ28229.npy +imgHQ06988.npy +imgHQ23097.npy +imgHQ01961.npy +imgHQ01431.npy +imgHQ26058.npy +imgHQ09851.npy +imgHQ28497.npy +imgHQ03533.npy +imgHQ29586.npy +imgHQ28551.npy +imgHQ22657.npy +imgHQ10698.npy +imgHQ01503.npy +imgHQ10096.npy +imgHQ21567.npy +imgHQ10279.npy +imgHQ29647.npy +imgHQ11249.npy +imgHQ27559.npy +imgHQ14616.npy +imgHQ11332.npy +imgHQ24543.npy +imgHQ06529.npy +imgHQ22118.npy +imgHQ25669.npy +imgHQ13075.npy +imgHQ04101.npy +imgHQ09363.npy +imgHQ10683.npy +imgHQ07613.npy +imgHQ25068.npy +imgHQ02866.npy +imgHQ20087.npy +imgHQ12828.npy +imgHQ23810.npy +imgHQ10511.npy +imgHQ03884.npy +imgHQ12972.npy +imgHQ18372.npy +imgHQ11557.npy +imgHQ21833.npy +imgHQ25316.npy +imgHQ20522.npy +imgHQ18788.npy +imgHQ23603.npy +imgHQ25536.npy +imgHQ24362.npy +imgHQ17858.npy +imgHQ05765.npy +imgHQ16458.npy +imgHQ00656.npy +imgHQ25587.npy +imgHQ21691.npy +imgHQ23240.npy +imgHQ24499.npy +imgHQ07551.npy +imgHQ15329.npy +imgHQ24938.npy +imgHQ15654.npy +imgHQ09599.npy +imgHQ28046.npy +imgHQ05661.npy +imgHQ22745.npy +imgHQ17047.npy +imgHQ07472.npy +imgHQ15152.npy +imgHQ02890.npy +imgHQ06221.npy +imgHQ17791.npy +imgHQ13293.npy +imgHQ02273.npy +imgHQ25368.npy +imgHQ06870.npy +imgHQ25782.npy +imgHQ00339.npy +imgHQ12554.npy +imgHQ03995.npy +imgHQ28740.npy +imgHQ18333.npy +imgHQ03393.npy +imgHQ26389.npy +imgHQ18427.npy +imgHQ21211.npy +imgHQ24530.npy +imgHQ08192.npy +imgHQ27944.npy +imgHQ13330.npy +imgHQ17842.npy +imgHQ24962.npy +imgHQ17652.npy +imgHQ23946.npy +imgHQ05495.npy +imgHQ21024.npy +imgHQ14229.npy +imgHQ26345.npy +imgHQ06217.npy +imgHQ02933.npy +imgHQ22847.npy +imgHQ19271.npy +imgHQ04770.npy +imgHQ13741.npy +imgHQ25230.npy +imgHQ28694.npy +imgHQ17548.npy +imgHQ10857.npy +imgHQ21638.npy +imgHQ05120.npy +imgHQ19332.npy +imgHQ02651.npy +imgHQ06261.npy +imgHQ27681.npy +imgHQ29322.npy +imgHQ09011.npy +imgHQ15804.npy +imgHQ20250.npy +imgHQ19837.npy +imgHQ00123.npy +imgHQ12474.npy +imgHQ07011.npy +imgHQ04740.npy +imgHQ09562.npy +imgHQ22188.npy +imgHQ20530.npy +imgHQ24642.npy +imgHQ01544.npy +imgHQ19844.npy +imgHQ04566.npy +imgHQ09968.npy +imgHQ21003.npy +imgHQ22092.npy +imgHQ06796.npy +imgHQ14964.npy +imgHQ03008.npy +imgHQ09967.npy +imgHQ10097.npy +imgHQ16505.npy +imgHQ26323.npy +imgHQ18231.npy +imgHQ26710.npy +imgHQ29147.npy +imgHQ17520.npy +imgHQ07632.npy +imgHQ16207.npy +imgHQ06550.npy +imgHQ09488.npy +imgHQ27179.npy +imgHQ27080.npy +imgHQ28295.npy +imgHQ13596.npy +imgHQ26902.npy +imgHQ25093.npy +imgHQ06200.npy +imgHQ00639.npy +imgHQ24552.npy +imgHQ05618.npy +imgHQ24551.npy +imgHQ16290.npy +imgHQ18306.npy +imgHQ17222.npy +imgHQ03182.npy +imgHQ21772.npy +imgHQ20138.npy +imgHQ19421.npy +imgHQ11541.npy +imgHQ02825.npy +imgHQ03099.npy +imgHQ06309.npy +imgHQ12224.npy +imgHQ20853.npy +imgHQ23497.npy +imgHQ17284.npy +imgHQ01917.npy +imgHQ14557.npy +imgHQ13866.npy +imgHQ22843.npy +imgHQ12706.npy +imgHQ09601.npy +imgHQ03067.npy +imgHQ01768.npy +imgHQ00753.npy +imgHQ29278.npy +imgHQ09948.npy +imgHQ26534.npy +imgHQ26479.npy +imgHQ04790.npy +imgHQ19611.npy +imgHQ10980.npy +imgHQ13547.npy +imgHQ22397.npy +imgHQ07557.npy +imgHQ22997.npy +imgHQ19444.npy +imgHQ06650.npy +imgHQ24972.npy +imgHQ24256.npy +imgHQ22821.npy +imgHQ18337.npy +imgHQ05272.npy +imgHQ28584.npy +imgHQ10730.npy +imgHQ15287.npy +imgHQ25027.npy +imgHQ29621.npy +imgHQ29714.npy +imgHQ27486.npy +imgHQ11157.npy +imgHQ00607.npy +imgHQ16017.npy +imgHQ18926.npy +imgHQ23522.npy +imgHQ03448.npy +imgHQ21573.npy +imgHQ23688.npy +imgHQ16578.npy +imgHQ19321.npy +imgHQ20301.npy +imgHQ19689.npy +imgHQ02139.npy +imgHQ25715.npy +imgHQ19783.npy +imgHQ27819.npy +imgHQ22300.npy +imgHQ20080.npy +imgHQ15540.npy +imgHQ22384.npy +imgHQ07704.npy +imgHQ00628.npy +imgHQ23921.npy +imgHQ03810.npy +imgHQ19576.npy +imgHQ16640.npy +imgHQ14140.npy +imgHQ07215.npy +imgHQ07880.npy +imgHQ13308.npy +imgHQ06166.npy +imgHQ02314.npy +imgHQ02880.npy +imgHQ22944.npy +imgHQ18781.npy +imgHQ20966.npy +imgHQ00064.npy +imgHQ01373.npy +imgHQ21036.npy +imgHQ03942.npy +imgHQ12956.npy +imgHQ22750.npy +imgHQ26561.npy +imgHQ23882.npy +imgHQ27769.npy +imgHQ00186.npy +imgHQ21358.npy +imgHQ21904.npy +imgHQ17183.npy +imgHQ23570.npy +imgHQ24040.npy +imgHQ05894.npy +imgHQ28098.npy +imgHQ27016.npy +imgHQ03431.npy +imgHQ23103.npy +imgHQ16449.npy +imgHQ04266.npy +imgHQ03832.npy +imgHQ19154.npy +imgHQ22744.npy +imgHQ02483.npy +imgHQ13681.npy +imgHQ07220.npy +imgHQ21442.npy +imgHQ29637.npy +imgHQ12907.npy +imgHQ21079.npy +imgHQ25835.npy +imgHQ17508.npy +imgHQ27861.npy +imgHQ00233.npy +imgHQ12950.npy +imgHQ09798.npy +imgHQ04035.npy +imgHQ19088.npy +imgHQ01712.npy +imgHQ04329.npy +imgHQ15216.npy +imgHQ26208.npy +imgHQ08544.npy +imgHQ13817.npy +imgHQ09668.npy +imgHQ15906.npy +imgHQ02353.npy +imgHQ04051.npy +imgHQ20332.npy +imgHQ04144.npy +imgHQ26932.npy +imgHQ06791.npy +imgHQ12038.npy +imgHQ06389.npy +imgHQ15548.npy +imgHQ14570.npy +imgHQ22045.npy +imgHQ27494.npy +imgHQ02292.npy +imgHQ16955.npy +imgHQ04314.npy +imgHQ14325.npy +imgHQ25811.npy +imgHQ03363.npy +imgHQ17708.npy +imgHQ02527.npy +imgHQ05950.npy +imgHQ20204.npy +imgHQ29562.npy +imgHQ04274.npy +imgHQ13182.npy +imgHQ16809.npy +imgHQ21293.npy +imgHQ22021.npy +imgHQ28345.npy +imgHQ15086.npy +imgHQ20156.npy +imgHQ19186.npy +imgHQ19575.npy +imgHQ20702.npy +imgHQ19987.npy +imgHQ00249.npy +imgHQ22056.npy +imgHQ12711.npy +imgHQ02287.npy +imgHQ04105.npy +imgHQ22371.npy +imgHQ24584.npy +imgHQ06955.npy +imgHQ18107.npy +imgHQ28859.npy +imgHQ23517.npy +imgHQ14533.npy +imgHQ14097.npy +imgHQ29999.npy +imgHQ14756.npy +imgHQ17974.npy +imgHQ19144.npy +imgHQ27599.npy +imgHQ26320.npy +imgHQ07077.npy +imgHQ25166.npy +imgHQ03961.npy +imgHQ27401.npy +imgHQ06969.npy +imgHQ20877.npy +imgHQ17795.npy +imgHQ15141.npy +imgHQ16722.npy +imgHQ01005.npy +imgHQ24456.npy +imgHQ19985.npy +imgHQ09264.npy +imgHQ01053.npy +imgHQ17164.npy +imgHQ18698.npy +imgHQ10264.npy +imgHQ26908.npy +imgHQ02221.npy +imgHQ11340.npy +imgHQ21902.npy +imgHQ21374.npy +imgHQ01632.npy +imgHQ07151.npy +imgHQ10047.npy +imgHQ19768.npy +imgHQ16780.npy +imgHQ22915.npy +imgHQ14547.npy +imgHQ07137.npy +imgHQ00158.npy +imgHQ21088.npy +imgHQ03141.npy +imgHQ27422.npy +imgHQ17559.npy +imgHQ21673.npy +imgHQ00329.npy +imgHQ16537.npy +imgHQ26654.npy +imgHQ18631.npy +imgHQ07041.npy +imgHQ02242.npy +imgHQ24974.npy +imgHQ21219.npy +imgHQ17459.npy +imgHQ18696.npy +imgHQ13060.npy +imgHQ18604.npy +imgHQ14102.npy +imgHQ22114.npy +imgHQ13854.npy +imgHQ09427.npy +imgHQ16837.npy +imgHQ14650.npy +imgHQ20143.npy +imgHQ15394.npy +imgHQ20527.npy +imgHQ07905.npy +imgHQ29711.npy +imgHQ05740.npy +imgHQ09420.npy +imgHQ13818.npy +imgHQ03593.npy +imgHQ26880.npy +imgHQ27029.npy +imgHQ14453.npy +imgHQ24011.npy +imgHQ22306.npy +imgHQ06532.npy +imgHQ25672.npy +imgHQ00613.npy +imgHQ21458.npy +imgHQ18076.npy +imgHQ09607.npy +imgHQ09970.npy +imgHQ12741.npy +imgHQ02985.npy +imgHQ11287.npy +imgHQ13847.npy +imgHQ05875.npy +imgHQ29155.npy +imgHQ14607.npy +imgHQ08112.npy +imgHQ06815.npy +imgHQ23772.npy +imgHQ15111.npy +imgHQ06063.npy +imgHQ22544.npy +imgHQ08385.npy +imgHQ06460.npy +imgHQ25488.npy +imgHQ05762.npy +imgHQ14286.npy +imgHQ05590.npy +imgHQ00266.npy +imgHQ00292.npy +imgHQ14452.npy +imgHQ28638.npy +imgHQ03157.npy +imgHQ19315.npy +imgHQ13091.npy +imgHQ01215.npy +imgHQ04399.npy +imgHQ13400.npy +imgHQ26542.npy +imgHQ23841.npy +imgHQ06717.npy +imgHQ21294.npy +imgHQ12196.npy +imgHQ05896.npy +imgHQ00549.npy +imgHQ22393.npy +imgHQ15534.npy +imgHQ18456.npy +imgHQ10188.npy +imgHQ11911.npy +imgHQ03946.npy +imgHQ15886.npy +imgHQ21480.npy +imgHQ13356.npy +imgHQ26169.npy +imgHQ23998.npy +imgHQ13191.npy +imgHQ24151.npy +imgHQ19049.npy +imgHQ04675.npy +imgHQ21680.npy +imgHQ15367.npy +imgHQ22968.npy +imgHQ00452.npy +imgHQ24370.npy +imgHQ19077.npy +imgHQ10543.npy +imgHQ13098.npy +imgHQ19346.npy +imgHQ03638.npy +imgHQ18729.npy +imgHQ19654.npy +imgHQ28256.npy +imgHQ09261.npy +imgHQ22418.npy +imgHQ19057.npy +imgHQ22557.npy +imgHQ21738.npy +imgHQ00696.npy +imgHQ18914.npy +imgHQ04122.npy +imgHQ29683.npy +imgHQ24100.npy +imgHQ25705.npy +imgHQ12878.npy +imgHQ02816.npy +imgHQ01021.npy +imgHQ07276.npy +imgHQ25344.npy +imgHQ16550.npy +imgHQ18104.npy +imgHQ25812.npy +imgHQ22990.npy +imgHQ03911.npy +imgHQ01478.npy +imgHQ08518.npy +imgHQ28369.npy +imgHQ22632.npy +imgHQ27024.npy +imgHQ09966.npy +imgHQ14202.npy +imgHQ15992.npy +imgHQ00609.npy +imgHQ29285.npy +imgHQ06276.npy +imgHQ21700.npy +imgHQ23906.npy +imgHQ07674.npy +imgHQ11565.npy +imgHQ19106.npy +imgHQ22200.npy +imgHQ09955.npy +imgHQ19812.npy +imgHQ19110.npy +imgHQ28837.npy +imgHQ20620.npy +imgHQ27467.npy +imgHQ14044.npy +imgHQ17741.npy +imgHQ19589.npy +imgHQ28427.npy +imgHQ13984.npy +imgHQ08211.npy +imgHQ09095.npy +imgHQ00634.npy +imgHQ11970.npy +imgHQ19531.npy +imgHQ10446.npy +imgHQ09541.npy +imgHQ04093.npy +imgHQ02834.npy +imgHQ22531.npy +imgHQ20400.npy +imgHQ23201.npy +imgHQ10470.npy +imgHQ18024.npy +imgHQ01270.npy +imgHQ02573.npy +imgHQ16804.npy +imgHQ07683.npy +imgHQ00002.npy +imgHQ14349.npy +imgHQ00768.npy +imgHQ13466.npy +imgHQ00882.npy +imgHQ15714.npy +imgHQ07321.npy +imgHQ18662.npy +imgHQ22786.npy +imgHQ14751.npy +imgHQ26779.npy +imgHQ00551.npy +imgHQ03916.npy +imgHQ13717.npy +imgHQ21518.npy +imgHQ11517.npy +imgHQ06971.npy +imgHQ09506.npy +imgHQ03371.npy +imgHQ05681.npy +imgHQ02111.npy +imgHQ12331.npy +imgHQ03097.npy +imgHQ18509.npy +imgHQ23798.npy +imgHQ07411.npy +imgHQ27350.npy +imgHQ01367.npy +imgHQ17560.npy +imgHQ01068.npy +imgHQ26662.npy +imgHQ22655.npy +imgHQ23274.npy +imgHQ15007.npy +imgHQ27034.npy +imgHQ02677.npy +imgHQ12901.npy +imgHQ13006.npy +imgHQ05341.npy +imgHQ17464.npy +imgHQ29314.npy +imgHQ28569.npy +imgHQ27528.npy +imgHQ01413.npy +imgHQ10362.npy +imgHQ03412.npy +imgHQ26407.npy +imgHQ20695.npy +imgHQ10668.npy +imgHQ29262.npy +imgHQ29901.npy +imgHQ12843.npy +imgHQ21388.npy +imgHQ15112.npy +imgHQ01518.npy +imgHQ23997.npy +imgHQ04975.npy +imgHQ24234.npy +imgHQ25963.npy +imgHQ29817.npy +imgHQ20418.npy +imgHQ07175.npy +imgHQ16091.npy +imgHQ04915.npy +imgHQ28829.npy +imgHQ19949.npy +imgHQ18226.npy +imgHQ20773.npy +imgHQ05945.npy +imgHQ20671.npy +imgHQ04842.npy +imgHQ21931.npy +imgHQ00741.npy +imgHQ25987.npy +imgHQ08752.npy +imgHQ18400.npy +imgHQ04380.npy +imgHQ09520.npy +imgHQ24961.npy +imgHQ00140.npy +imgHQ19026.npy +imgHQ11131.npy +imgHQ16485.npy +imgHQ13556.npy +imgHQ27678.npy +imgHQ15259.npy +imgHQ18420.npy +imgHQ28296.npy +imgHQ19986.npy +imgHQ20219.npy +imgHQ27654.npy +imgHQ09843.npy +imgHQ00612.npy +imgHQ01721.npy +imgHQ11321.npy +imgHQ08781.npy +imgHQ09758.npy +imgHQ01120.npy +imgHQ01050.npy +imgHQ05860.npy +imgHQ15351.npy +imgHQ08313.npy +imgHQ00065.npy +imgHQ23084.npy +imgHQ08798.npy +imgHQ28697.npy +imgHQ27455.npy +imgHQ12285.npy +imgHQ01107.npy +imgHQ02429.npy +imgHQ14892.npy +imgHQ26592.npy +imgHQ19143.npy +imgHQ03271.npy +imgHQ18814.npy +imgHQ03752.npy +imgHQ11824.npy +imgHQ06767.npy +imgHQ24310.npy +imgHQ28786.npy +imgHQ10997.npy +imgHQ08632.npy +imgHQ00212.npy +imgHQ26329.npy +imgHQ29848.npy +imgHQ27736.npy +imgHQ27767.npy +imgHQ00159.npy +imgHQ22072.npy +imgHQ20605.npy +imgHQ01870.npy +imgHQ18142.npy +imgHQ12649.npy +imgHQ22184.npy +imgHQ21498.npy +imgHQ07090.npy +imgHQ04254.npy +imgHQ11949.npy +imgHQ00493.npy +imgHQ06946.npy +imgHQ11536.npy +imgHQ10615.npy +imgHQ24209.npy +imgHQ08289.npy +imgHQ15050.npy +imgHQ21651.npy +imgHQ22771.npy +imgHQ06491.npy +imgHQ16392.npy +imgHQ29552.npy +imgHQ16882.npy +imgHQ28148.npy +imgHQ01825.npy +imgHQ23919.npy +imgHQ22559.npy +imgHQ06706.npy +imgHQ26973.npy +imgHQ17493.npy +imgHQ15181.npy +imgHQ13947.npy +imgHQ04894.npy +imgHQ28889.npy +imgHQ13844.npy +imgHQ23595.npy +imgHQ11117.npy +imgHQ17965.npy +imgHQ16660.npy +imgHQ25312.npy +imgHQ08417.npy +imgHQ26668.npy +imgHQ04480.npy +imgHQ16489.npy +imgHQ20307.npy +imgHQ20107.npy +imgHQ02247.npy +imgHQ00867.npy +imgHQ02045.npy +imgHQ02729.npy +imgHQ02227.npy +imgHQ08161.npy +imgHQ22778.npy +imgHQ05868.npy +imgHQ25562.npy +imgHQ04895.npy +imgHQ16087.npy +imgHQ15721.npy +imgHQ10465.npy +imgHQ08880.npy +imgHQ26896.npy +imgHQ28135.npy +imgHQ23051.npy +imgHQ04114.npy +imgHQ19024.npy +imgHQ04937.npy +imgHQ22835.npy +imgHQ03820.npy +imgHQ00500.npy +imgHQ05136.npy +imgHQ06841.npy +imgHQ05043.npy +imgHQ16135.npy +imgHQ14200.npy +imgHQ27005.npy +imgHQ01179.npy +imgHQ22487.npy +imgHQ21653.npy +imgHQ04555.npy +imgHQ13655.npy +imgHQ03698.npy +imgHQ22339.npy +imgHQ15562.npy +imgHQ27977.npy +imgHQ22978.npy +imgHQ21328.npy +imgHQ10585.npy +imgHQ02706.npy +imgHQ24230.npy +imgHQ19823.npy +imgHQ14183.npy +imgHQ06741.npy +imgHQ26074.npy +imgHQ28188.npy +imgHQ04706.npy +imgHQ01377.npy +imgHQ03036.npy +imgHQ03360.npy +imgHQ02776.npy +imgHQ03577.npy +imgHQ19205.npy +imgHQ06360.npy +imgHQ02454.npy +imgHQ10889.npy +imgHQ27969.npy +imgHQ18242.npy +imgHQ18335.npy +imgHQ20452.npy +imgHQ16997.npy +imgHQ00807.npy +imgHQ05206.npy +imgHQ11542.npy +imgHQ11603.npy +imgHQ13992.npy +imgHQ22904.npy +imgHQ26567.npy +imgHQ19490.npy +imgHQ08590.npy +imgHQ09006.npy +imgHQ04147.npy +imgHQ26094.npy +imgHQ21701.npy +imgHQ08402.npy +imgHQ09013.npy +imgHQ26985.npy +imgHQ11175.npy +imgHQ00610.npy +imgHQ20971.npy +imgHQ11297.npy +imgHQ23014.npy +imgHQ23199.npy +imgHQ22328.npy +imgHQ21868.npy +imgHQ17327.npy +imgHQ20189.npy +imgHQ13151.npy +imgHQ11450.npy +imgHQ13828.npy +imgHQ01621.npy +imgHQ08938.npy +imgHQ21663.npy +imgHQ18329.npy +imgHQ11796.npy +imgHQ26717.npy +imgHQ25988.npy +imgHQ11736.npy +imgHQ13370.npy +imgHQ09145.npy +imgHQ00061.npy +imgHQ25222.npy +imgHQ04834.npy +imgHQ13816.npy +imgHQ28938.npy +imgHQ16130.npy +imgHQ23137.npy +imgHQ23591.npy +imgHQ09883.npy +imgHQ00817.npy +imgHQ27499.npy +imgHQ05051.npy +imgHQ14825.npy +imgHQ01447.npy +imgHQ01808.npy +imgHQ26555.npy +imgHQ24455.npy +imgHQ16216.npy +imgHQ21827.npy +imgHQ23812.npy +imgHQ16914.npy +imgHQ27864.npy +imgHQ26018.npy +imgHQ06512.npy +imgHQ05870.npy +imgHQ24248.npy +imgHQ16369.npy +imgHQ24222.npy +imgHQ20182.npy +imgHQ16556.npy +imgHQ27278.npy +imgHQ17875.npy +imgHQ01386.npy +imgHQ17292.npy +imgHQ20870.npy +imgHQ04816.npy +imgHQ27914.npy +imgHQ01347.npy +imgHQ24426.npy +imgHQ06268.npy +imgHQ18602.npy +imgHQ04807.npy +imgHQ01850.npy +imgHQ13174.npy +imgHQ20654.npy +imgHQ15342.npy +imgHQ12013.npy +imgHQ22889.npy +imgHQ05578.npy +imgHQ25355.npy +imgHQ26375.npy +imgHQ29468.npy +imgHQ19447.npy +imgHQ00455.npy +imgHQ20731.npy +imgHQ13614.npy +imgHQ16889.npy +imgHQ27838.npy +imgHQ13338.npy +imgHQ09530.npy +imgHQ21011.npy +imgHQ26398.npy +imgHQ16249.npy +imgHQ07713.npy +imgHQ11837.npy +imgHQ17092.npy +imgHQ29864.npy +imgHQ03197.npy +imgHQ20223.npy +imgHQ15253.npy +imgHQ08627.npy +imgHQ12194.npy +imgHQ28309.npy +imgHQ22507.npy +imgHQ19604.npy +imgHQ03584.npy +imgHQ20565.npy +imgHQ21205.npy +imgHQ02183.npy +imgHQ10093.npy +imgHQ13343.npy +imgHQ01948.npy +imgHQ26066.npy +imgHQ26473.npy +imgHQ04198.npy +imgHQ19033.npy +imgHQ15793.npy +imgHQ20678.npy +imgHQ16572.npy +imgHQ25310.npy +imgHQ11836.npy +imgHQ09000.npy +imgHQ17106.npy +imgHQ22420.npy +imgHQ17667.npy +imgHQ06704.npy +imgHQ25584.npy +imgHQ00346.npy +imgHQ01527.npy +imgHQ22862.npy +imgHQ03789.npy +imgHQ10309.npy +imgHQ20555.npy +imgHQ25801.npy +imgHQ05123.npy +imgHQ29766.npy +imgHQ25188.npy +imgHQ21477.npy +imgHQ00561.npy +imgHQ26599.npy +imgHQ02618.npy +imgHQ02824.npy +imgHQ03178.npy +imgHQ07244.npy +imgHQ28625.npy +imgHQ21438.npy +imgHQ22585.npy +imgHQ07848.npy +imgHQ12788.npy +imgHQ29556.npy +imgHQ20723.npy +imgHQ16425.npy +imgHQ14450.npy +imgHQ27030.npy +imgHQ06574.npy +imgHQ23164.npy +imgHQ19767.npy +imgHQ07984.npy +imgHQ05248.npy +imgHQ26663.npy +imgHQ09203.npy +imgHQ14402.npy +imgHQ04441.npy +imgHQ19423.npy +imgHQ07993.npy +imgHQ00865.npy +imgHQ28567.npy +imgHQ19187.npy +imgHQ17427.npy +imgHQ15707.npy +imgHQ23645.npy +imgHQ28830.npy +imgHQ08644.npy +imgHQ25744.npy +imgHQ20149.npy +imgHQ00449.npy +imgHQ18151.npy +imgHQ16429.npy +imgHQ20916.npy +imgHQ16705.npy +imgHQ25802.npy +imgHQ19997.npy +imgHQ02007.npy +imgHQ24410.npy +imgHQ01551.npy +imgHQ04661.npy +imgHQ14867.npy +imgHQ21375.npy +imgHQ22526.npy +imgHQ05516.npy +imgHQ29080.npy +imgHQ19805.npy +imgHQ12900.npy +imgHQ04383.npy +imgHQ17583.npy +imgHQ06990.npy +imgHQ28045.npy +imgHQ13029.npy +imgHQ16026.npy +imgHQ00960.npy +imgHQ04729.npy +imgHQ21175.npy +imgHQ17642.npy +imgHQ10697.npy +imgHQ12504.npy +imgHQ00820.npy +imgHQ10409.npy +imgHQ15027.npy +imgHQ25790.npy +imgHQ08135.npy +imgHQ23576.npy +imgHQ24088.npy +imgHQ04402.npy +imgHQ01023.npy +imgHQ19665.npy +imgHQ11998.npy +imgHQ08464.npy +imgHQ12470.npy +imgHQ18904.npy +imgHQ28075.npy +imgHQ21702.npy +imgHQ05999.npy +imgHQ07386.npy +imgHQ22434.npy +imgHQ19384.npy +imgHQ23426.npy +imgHQ24078.npy +imgHQ16890.npy +imgHQ16174.npy +imgHQ10170.npy +imgHQ22317.npy +imgHQ16255.npy +imgHQ08771.npy +imgHQ29993.npy +imgHQ09267.npy +imgHQ13083.npy +imgHQ23487.npy +imgHQ15196.npy +imgHQ26434.npy +imgHQ12599.npy +imgHQ04547.npy +imgHQ10286.npy +imgHQ18211.npy +imgHQ09536.npy +imgHQ11548.npy +imgHQ12527.npy +imgHQ28224.npy +imgHQ16912.npy +imgHQ07053.npy +imgHQ25408.npy +imgHQ13680.npy +imgHQ16712.npy +imgHQ11845.npy +imgHQ22776.npy +imgHQ07171.npy +imgHQ16365.npy +imgHQ17666.npy +imgHQ00310.npy +imgHQ14217.npy +imgHQ23692.npy +imgHQ25449.npy +imgHQ15952.npy +imgHQ14975.npy +imgHQ25637.npy +imgHQ20336.npy +imgHQ25795.npy +imgHQ26363.npy +imgHQ21796.npy +imgHQ18774.npy +imgHQ28460.npy +imgHQ28202.npy +imgHQ25666.npy +imgHQ10130.npy +imgHQ18644.npy +imgHQ18885.npy +imgHQ26692.npy +imgHQ13316.npy +imgHQ29726.npy +imgHQ05411.npy +imgHQ16077.npy +imgHQ02155.npy +imgHQ18279.npy +imgHQ27259.npy +imgHQ23430.npy +imgHQ07529.npy +imgHQ05139.npy +imgHQ08930.npy +imgHQ16707.npy +imgHQ13367.npy +imgHQ01604.npy +imgHQ25410.npy +imgHQ24539.npy +imgHQ16225.npy +imgHQ24385.npy +imgHQ14929.npy +imgHQ27995.npy +imgHQ23229.npy +imgHQ18437.npy +imgHQ10174.npy +imgHQ28239.npy +imgHQ28382.npy +imgHQ17104.npy +imgHQ03759.npy +imgHQ04882.npy +imgHQ19160.npy +imgHQ22732.npy +imgHQ18949.npy +imgHQ13730.npy +imgHQ25319.npy +imgHQ18278.npy +imgHQ10220.npy +imgHQ22482.npy +imgHQ26110.npy +imgHQ24168.npy +imgHQ04372.npy +imgHQ02474.npy +imgHQ23099.npy +imgHQ11122.npy +imgHQ01419.npy +imgHQ04471.npy +imgHQ24079.npy +imgHQ13142.npy +imgHQ20449.npy +imgHQ13553.npy +imgHQ29899.npy +imgHQ20364.npy +imgHQ16104.npy +imgHQ09597.npy +imgHQ18693.npy +imgHQ05776.npy +imgHQ06567.npy +imgHQ11816.npy +imgHQ28485.npy +imgHQ17434.npy +imgHQ17954.npy +imgHQ07073.npy +imgHQ08310.npy +imgHQ11893.npy +imgHQ04623.npy +imgHQ21453.npy +imgHQ17494.npy +imgHQ26402.npy +imgHQ10291.npy +imgHQ17153.npy +imgHQ09019.npy +imgHQ11009.npy +imgHQ04564.npy +imgHQ28287.npy +imgHQ17411.npy +imgHQ25113.npy +imgHQ29161.npy +imgHQ27078.npy +imgHQ01009.npy +imgHQ01753.npy +imgHQ23753.npy +imgHQ26703.npy +imgHQ27533.npy +imgHQ28262.npy +imgHQ10347.npy +imgHQ21048.npy +imgHQ21666.npy +imgHQ16611.npy +imgHQ03118.npy +imgHQ04571.npy +imgHQ28767.npy +imgHQ11520.npy +imgHQ01984.npy +imgHQ16522.npy +imgHQ03492.npy +imgHQ17080.npy +imgHQ04414.npy +imgHQ06082.npy +imgHQ16048.npy +imgHQ18188.npy +imgHQ26133.npy +imgHQ07582.npy +imgHQ02544.npy +imgHQ00396.npy +imgHQ01319.npy +imgHQ16832.npy +imgHQ13092.npy +imgHQ09516.npy +imgHQ14891.npy +imgHQ11516.npy +imgHQ12464.npy +imgHQ13260.npy +imgHQ19923.npy +imgHQ02532.npy +imgHQ07348.npy +imgHQ06933.npy +imgHQ14424.npy +imgHQ06279.npy +imgHQ04090.npy +imgHQ18965.npy +imgHQ18380.npy +imgHQ22154.npy +imgHQ24227.npy +imgHQ27786.npy +imgHQ16724.npy +imgHQ23779.npy +imgHQ21692.npy +imgHQ24856.npy +imgHQ28486.npy +imgHQ08895.npy +imgHQ07361.npy +imgHQ01283.npy +imgHQ25822.npy +imgHQ25665.npy +imgHQ09627.npy +imgHQ24775.npy +imgHQ24638.npy +imgHQ27902.npy +imgHQ24785.npy +imgHQ28933.npy +imgHQ07566.npy +imgHQ11606.npy +imgHQ08215.npy +imgHQ21037.npy +imgHQ05821.npy +imgHQ21467.npy +imgHQ00810.npy +imgHQ01855.npy +imgHQ25341.npy +imgHQ20246.npy +imgHQ20956.npy +imgHQ19786.npy +imgHQ04837.npy +imgHQ23169.npy +imgHQ17218.npy +imgHQ00183.npy +imgHQ15208.npy +imgHQ07835.npy +imgHQ02339.npy +imgHQ08227.npy +imgHQ06434.npy +imgHQ18425.npy +imgHQ27123.npy +imgHQ19177.npy +imgHQ26911.npy +imgHQ07531.npy +imgHQ26055.npy +imgHQ05605.npy +imgHQ11854.npy +imgHQ19581.npy +imgHQ23736.npy +imgHQ28352.npy +imgHQ07222.npy +imgHQ25775.npy +imgHQ15978.npy +imgHQ04392.npy +imgHQ17680.npy +imgHQ03915.npy +imgHQ18088.npy +imgHQ17781.npy +imgHQ29660.npy +imgHQ01861.npy +imgHQ25215.npy +imgHQ15136.npy +imgHQ15780.npy +imgHQ29701.npy +imgHQ09825.npy +imgHQ16883.npy +imgHQ18413.npy +imgHQ12687.npy +imgHQ16863.npy +imgHQ18398.npy +imgHQ04682.npy +imgHQ12702.npy +imgHQ16113.npy +imgHQ18123.npy +imgHQ14334.npy +imgHQ21119.npy +imgHQ17949.npy +imgHQ14683.npy +imgHQ01401.npy +imgHQ23839.npy +imgHQ25724.npy +imgHQ15289.npy +imgHQ26820.npy +imgHQ14418.npy +imgHQ22012.npy +imgHQ21678.npy +imgHQ06487.npy +imgHQ04707.npy +imgHQ09144.npy +imgHQ13271.npy +imgHQ13865.npy +imgHQ11958.npy +imgHQ10402.npy +imgHQ23243.npy +imgHQ03766.npy +imgHQ28077.npy +imgHQ21949.npy +imgHQ02326.npy +imgHQ09072.npy +imgHQ00294.npy +imgHQ06515.npy +imgHQ06693.npy +imgHQ21572.npy +imgHQ15229.npy +imgHQ10630.npy +imgHQ01204.npy +imgHQ24098.npy +imgHQ11109.npy +imgHQ06416.npy +imgHQ02913.npy +imgHQ15239.npy +imgHQ25394.npy +imgHQ29006.npy +imgHQ10201.npy +imgHQ12410.npy +imgHQ21510.npy +imgHQ28254.npy +imgHQ15419.npy +imgHQ22638.npy +imgHQ01482.npy +imgHQ09951.npy +imgHQ11676.npy +imgHQ07474.npy +imgHQ21346.npy +imgHQ18471.npy +imgHQ15231.npy +imgHQ22010.npy +imgHQ21257.npy +imgHQ12168.npy +imgHQ11233.npy +imgHQ23196.npy +imgHQ14990.npy +imgHQ25206.npy +imgHQ09983.npy +imgHQ08873.npy +imgHQ17539.npy +imgHQ08585.npy +imgHQ10914.npy +imgHQ20538.npy +imgHQ00846.npy +imgHQ09482.npy +imgHQ00286.npy +imgHQ24188.npy +imgHQ06566.npy +imgHQ05981.npy +imgHQ26081.npy +imgHQ22698.npy +imgHQ07642.npy +imgHQ18655.npy +imgHQ29622.npy +imgHQ28037.npy +imgHQ26486.npy +imgHQ29313.npy +imgHQ10011.npy +imgHQ03174.npy +imgHQ08374.npy +imgHQ29049.npy +imgHQ12776.npy +imgHQ25162.npy +imgHQ04048.npy +imgHQ23314.npy +imgHQ08706.npy +imgHQ03591.npy +imgHQ20321.npy +imgHQ22831.npy +imgHQ23082.npy +imgHQ23368.npy +imgHQ29416.npy +imgHQ12516.npy +imgHQ01974.npy +imgHQ23725.npy +imgHQ14872.npy +imgHQ14538.npy +imgHQ15612.npy +imgHQ02526.npy +imgHQ15205.npy +imgHQ08697.npy +imgHQ00943.npy +imgHQ04027.npy +imgHQ12957.npy +imgHQ14621.npy +imgHQ29693.npy +imgHQ03098.npy +imgHQ19847.npy +imgHQ15032.npy +imgHQ28576.npy +imgHQ28421.npy +imgHQ03214.npy +imgHQ08525.npy +imgHQ14037.npy +imgHQ03012.npy +imgHQ16582.npy +imgHQ04990.npy +imgHQ03204.npy +imgHQ14401.npy +imgHQ24553.npy +imgHQ00729.npy +imgHQ17612.npy +imgHQ24332.npy +imgHQ25604.npy +imgHQ22473.npy +imgHQ07122.npy +imgHQ23641.npy +imgHQ24073.npy +imgHQ16293.npy +imgHQ10259.npy +imgHQ07615.npy +imgHQ27561.npy +imgHQ12947.npy +imgHQ22668.npy +imgHQ14358.npy +imgHQ22219.npy +imgHQ06372.npy +imgHQ29317.npy +imgHQ22577.npy +imgHQ02608.npy +imgHQ27470.npy +imgHQ29706.npy +imgHQ05093.npy +imgHQ24289.npy +imgHQ23235.npy +imgHQ00350.npy +imgHQ18357.npy +imgHQ11675.npy +imgHQ24883.npy +imgHQ25101.npy +imgHQ05628.npy +imgHQ29685.npy +imgHQ10071.npy +imgHQ09800.npy +imgHQ19487.npy +imgHQ02574.npy +imgHQ28023.npy +imgHQ28627.npy +imgHQ19450.npy +imgHQ01703.npy +imgHQ00501.npy +imgHQ27125.npy +imgHQ05980.npy +imgHQ28941.npy +imgHQ02533.npy +imgHQ25952.npy +imgHQ28095.npy +imgHQ16978.npy +imgHQ14675.npy +imgHQ11064.npy +imgHQ09368.npy +imgHQ16688.npy +imgHQ17157.npy +imgHQ20582.npy +imgHQ14711.npy +imgHQ07417.npy +imgHQ29496.npy +imgHQ07938.npy +imgHQ26467.npy +imgHQ28274.npy +imgHQ12207.npy +imgHQ24037.npy +imgHQ14642.npy +imgHQ02121.npy +imgHQ22131.npy +imgHQ03179.npy +imgHQ17488.npy +imgHQ06207.npy +imgHQ13702.npy +imgHQ01470.npy +imgHQ24421.npy +imgHQ29509.npy +imgHQ22535.npy +imgHQ02250.npy +imgHQ20401.npy +imgHQ24928.npy +imgHQ02297.npy +imgHQ24061.npy +imgHQ11790.npy +imgHQ15370.npy +imgHQ27897.npy +imgHQ16528.npy +imgHQ18054.npy +imgHQ18844.npy +imgHQ05509.npy +imgHQ04181.npy +imgHQ01817.npy +imgHQ05584.npy +imgHQ05810.npy +imgHQ11526.npy +imgHQ28854.npy +imgHQ00333.npy +imgHQ14781.npy +imgHQ17790.npy +imgHQ09045.npy +imgHQ12818.npy +imgHQ21881.npy +imgHQ26510.npy +imgHQ22461.npy +imgHQ17743.npy +imgHQ29235.npy +imgHQ18813.npy +imgHQ24038.npy +imgHQ20414.npy +imgHQ26301.npy +imgHQ22449.npy +imgHQ22726.npy +imgHQ02208.npy +imgHQ12085.npy +imgHQ06044.npy +imgHQ18018.npy +imgHQ22578.npy +imgHQ16601.npy +imgHQ16669.npy +imgHQ15837.npy +imgHQ03309.npy +imgHQ28237.npy +imgHQ23028.npy +imgHQ12115.npy +imgHQ23951.npy +imgHQ01832.npy +imgHQ15135.npy +imgHQ22011.npy +imgHQ24239.npy +imgHQ25946.npy +imgHQ09222.npy +imgHQ27077.npy +imgHQ19215.npy +imgHQ15988.npy +imgHQ09695.npy +imgHQ07086.npy +imgHQ26811.npy +imgHQ24843.npy +imgHQ19894.npy +imgHQ28733.npy +imgHQ09133.npy +imgHQ04197.npy +imgHQ29753.npy +imgHQ05992.npy +imgHQ15332.npy +imgHQ03804.npy +imgHQ22437.npy +imgHQ11299.npy +imgHQ08577.npy +imgHQ11739.npy +imgHQ03878.npy +imgHQ11350.npy +imgHQ02174.npy +imgHQ15247.npy +imgHQ12177.npy +imgHQ06923.npy +imgHQ09935.npy +imgHQ15627.npy +imgHQ15145.npy +imgHQ11608.npy +imgHQ10391.npy +imgHQ15808.npy +imgHQ16440.npy +imgHQ16829.npy +imgHQ16213.npy +imgHQ18003.npy +imgHQ10173.npy +imgHQ25876.npy +imgHQ02485.npy +imgHQ27666.npy +imgHQ07765.npy +imgHQ06346.npy +imgHQ05782.npy +imgHQ00298.npy +imgHQ09815.npy +imgHQ20042.npy +imgHQ11991.npy +imgHQ27215.npy +imgHQ13464.npy +imgHQ02096.npy +imgHQ07664.npy +imgHQ00800.npy +imgHQ04472.npy +imgHQ19935.npy +imgHQ18326.npy +imgHQ04287.npy +imgHQ26795.npy +imgHQ13647.npy +imgHQ19910.npy +imgHQ20986.npy +imgHQ16557.npy +imgHQ13118.npy +imgHQ09241.npy +imgHQ05046.npy +imgHQ28247.npy +imgHQ06612.npy +imgHQ08552.npy +imgHQ07739.npy +imgHQ28088.npy +imgHQ09589.npy +imgHQ02976.npy +imgHQ19380.npy +imgHQ17484.npy +imgHQ21683.npy +imgHQ03457.npy +imgHQ05320.npy +imgHQ04903.npy +imgHQ01452.npy +imgHQ22919.npy +imgHQ23010.npy +imgHQ21883.npy +imgHQ20969.npy +imgHQ18248.npy +imgHQ11290.npy +imgHQ20433.npy +imgHQ11902.npy +imgHQ15306.npy +imgHQ18732.npy +imgHQ04112.npy +imgHQ29869.npy +imgHQ06420.npy +imgHQ05750.npy +imgHQ04104.npy +imgHQ15819.npy +imgHQ08765.npy +imgHQ25869.npy +imgHQ25769.npy +imgHQ12133.npy +imgHQ22331.npy +imgHQ10580.npy +imgHQ07875.npy +imgHQ16766.npy +imgHQ09384.npy +imgHQ27421.npy +imgHQ12137.npy +imgHQ04609.npy +imgHQ14979.npy +imgHQ05902.npy +imgHQ19900.npy +imgHQ10448.npy +imgHQ06711.npy +imgHQ13986.npy +imgHQ20059.npy +imgHQ23412.npy +imgHQ02280.npy +imgHQ19331.npy +imgHQ09008.npy +imgHQ18048.npy +imgHQ10275.npy +imgHQ28621.npy +imgHQ21686.npy +imgHQ18280.npy +imgHQ23242.npy +imgHQ19097.npy +imgHQ24313.npy +imgHQ12274.npy +imgHQ17602.npy +imgHQ09009.npy +imgHQ11086.npy +imgHQ23936.npy +imgHQ02462.npy +imgHQ13265.npy +imgHQ09124.npy +imgHQ20018.npy +imgHQ25723.npy +imgHQ28438.npy +imgHQ26330.npy +imgHQ14258.npy +imgHQ21825.npy +imgHQ04655.npy +imgHQ08120.npy +imgHQ04610.npy +imgHQ26988.npy +imgHQ27541.npy +imgHQ28182.npy +imgHQ15243.npy +imgHQ12138.npy +imgHQ21561.npy +imgHQ20239.npy +imgHQ26584.npy +imgHQ12339.npy +imgHQ04851.npy +imgHQ26221.npy +imgHQ20701.npy +imgHQ01463.npy +imgHQ11351.npy +imgHQ04947.npy +imgHQ21035.npy +imgHQ16242.npy +imgHQ17022.npy +imgHQ05368.npy +imgHQ07303.npy +imgHQ24391.npy +imgHQ06362.npy +imgHQ27577.npy +imgHQ04859.npy +imgHQ21265.npy +imgHQ09699.npy +imgHQ16394.npy +imgHQ18479.npy +imgHQ12980.npy +imgHQ23722.npy +imgHQ10268.npy +imgHQ13269.npy +imgHQ28645.npy +imgHQ17574.npy +imgHQ26195.npy +imgHQ22962.npy +imgHQ11128.npy +imgHQ23593.npy +imgHQ08233.npy +imgHQ19435.npy +imgHQ13981.npy +imgHQ27628.npy +imgHQ14374.npy +imgHQ24969.npy +imgHQ17443.npy +imgHQ14389.npy +imgHQ12326.npy +imgHQ21896.npy +imgHQ06237.npy +imgHQ15012.npy +imgHQ03772.npy +imgHQ14797.npy +imgHQ07284.npy +imgHQ02860.npy +imgHQ04716.npy +imgHQ18714.npy +imgHQ29207.npy +imgHQ16558.npy +imgHQ20202.npy +imgHQ21703.npy +imgHQ26904.npy +imgHQ06522.npy +imgHQ05036.npy +imgHQ09198.npy +imgHQ13963.npy +imgHQ17714.npy +imgHQ13719.npy +imgHQ12400.npy +imgHQ13184.npy +imgHQ23348.npy +imgHQ01615.npy +imgHQ11927.npy +imgHQ22130.npy +imgHQ07193.npy +imgHQ09648.npy +imgHQ01591.npy +imgHQ21585.npy +imgHQ08799.npy +imgHQ19966.npy +imgHQ26180.npy +imgHQ02874.npy +imgHQ07104.npy +imgHQ01146.npy +imgHQ12372.npy +imgHQ06209.npy +imgHQ21530.npy +imgHQ01896.npy +imgHQ05281.npy +imgHQ15828.npy +imgHQ04358.npy +imgHQ21360.npy +imgHQ04897.npy +imgHQ06327.npy +imgHQ26928.npy +imgHQ12015.npy +imgHQ08028.npy +imgHQ05465.npy +imgHQ17641.npy +imgHQ03449.npy +imgHQ17751.npy +imgHQ01728.npy +imgHQ20132.npy +imgHQ24684.npy +imgHQ19493.npy +imgHQ24993.npy +imgHQ17084.npy +imgHQ25734.npy +imgHQ23737.npy +imgHQ24251.npy +imgHQ23425.npy +imgHQ14981.npy +imgHQ06516.npy +imgHQ02575.npy +imgHQ19661.npy +imgHQ03729.npy +imgHQ22660.npy +imgHQ17730.npy +imgHQ07153.npy +imgHQ02405.npy +imgHQ26590.npy +imgHQ00806.npy +imgHQ29791.npy +imgHQ25834.npy +imgHQ11980.npy +imgHQ15454.npy +imgHQ13560.npy +imgHQ01550.npy +imgHQ26714.npy +imgHQ24021.npy +imgHQ04688.npy +imgHQ16000.npy +imgHQ15364.npy +imgHQ27279.npy +imgHQ19796.npy +imgHQ23065.npy +imgHQ02385.npy +imgHQ07176.npy +imgHQ22084.npy +imgHQ27638.npy +imgHQ22285.npy +imgHQ21132.npy +imgHQ17361.npy +imgHQ13898.npy +imgHQ18557.npy +imgHQ13374.npy +imgHQ25072.npy +imgHQ12283.npy +imgHQ01787.npy +imgHQ07296.npy +imgHQ20237.npy +imgHQ13379.npy +imgHQ06311.npy +imgHQ00277.npy +imgHQ01809.npy +imgHQ20706.npy +imgHQ29195.npy +imgHQ19843.npy +imgHQ07201.npy +imgHQ26543.npy +imgHQ03964.npy +imgHQ00451.npy +imgHQ04124.npy +imgHQ23187.npy +imgHQ10591.npy +imgHQ28020.npy +imgHQ18722.npy +imgHQ02322.npy +imgHQ21274.npy diff --git a/src/taming-transformers/data/celebahqvalidation.txt b/src/taming-transformers/data/celebahqvalidation.txt new file mode 100644 index 0000000000000000000000000000000000000000..6f58ba090a787b5dadc7aca6ca1e5975fcd8c4c0 --- /dev/null +++ b/src/taming-transformers/data/celebahqvalidation.txt @@ -0,0 +1,5000 @@ +imgHQ05953.npy +imgHQ17723.npy +imgHQ04424.npy +imgHQ24462.npy +imgHQ21251.npy +imgHQ17523.npy +imgHQ22232.npy +imgHQ19414.npy +imgHQ20814.npy +imgHQ29033.npy +imgHQ26483.npy +imgHQ03031.npy +imgHQ17177.npy +imgHQ10165.npy +imgHQ07535.npy +imgHQ15994.npy +imgHQ28875.npy +imgHQ19703.npy +imgHQ01890.npy +imgHQ21028.npy +imgHQ03910.npy +imgHQ29104.npy +imgHQ12465.npy +imgHQ11648.npy +imgHQ08105.npy +imgHQ16246.npy +imgHQ15762.npy +imgHQ03839.npy +imgHQ17673.npy +imgHQ27623.npy +imgHQ21706.npy +imgHQ03205.npy +imgHQ13555.npy +imgHQ28932.npy +imgHQ08806.npy +imgHQ18108.npy +imgHQ22760.npy +imgHQ09333.npy +imgHQ00478.npy +imgHQ23578.npy +imgHQ08795.npy +imgHQ29662.npy +imgHQ02328.npy +imgHQ01138.npy +imgHQ18915.npy +imgHQ19622.npy +imgHQ05299.npy +imgHQ00874.npy +imgHQ01037.npy +imgHQ22102.npy +imgHQ13559.npy +imgHQ16627.npy +imgHQ13104.npy +imgHQ26248.npy +imgHQ08830.npy +imgHQ08149.npy +imgHQ23892.npy +imgHQ04509.npy +imgHQ04677.npy +imgHQ22981.npy +imgHQ23540.npy +imgHQ09769.npy +imgHQ19474.npy +imgHQ05978.npy +imgHQ21554.npy +imgHQ07223.npy +imgHQ18457.npy +imgHQ02771.npy +imgHQ29335.npy +imgHQ26504.npy +imgHQ14606.npy +imgHQ02446.npy +imgHQ10880.npy +imgHQ06298.npy +imgHQ25333.npy +imgHQ21075.npy +imgHQ03743.npy +imgHQ11968.npy +imgHQ21064.npy +imgHQ03514.npy +imgHQ13598.npy +imgHQ18199.npy +imgHQ23796.npy +imgHQ27830.npy +imgHQ18562.npy +imgHQ07525.npy +imgHQ06277.npy +imgHQ21114.npy +imgHQ06481.npy +imgHQ29381.npy +imgHQ10066.npy +imgHQ26963.npy +imgHQ00074.npy +imgHQ03889.npy +imgHQ05348.npy +imgHQ23934.npy +imgHQ28072.npy +imgHQ24101.npy +imgHQ22443.npy +imgHQ00082.npy +imgHQ27971.npy +imgHQ20209.npy +imgHQ29856.npy +imgHQ16456.npy +imgHQ08911.npy +imgHQ14386.npy +imgHQ21811.npy +imgHQ10029.npy +imgHQ22127.npy +imgHQ02156.npy +imgHQ04732.npy +imgHQ08947.npy +imgHQ23308.npy +imgHQ17624.npy +imgHQ28180.npy +imgHQ15467.npy +imgHQ20154.npy +imgHQ00412.npy +imgHQ08239.npy +imgHQ28207.npy +imgHQ01312.npy +imgHQ20872.npy +imgHQ08338.npy +imgHQ06547.npy +imgHQ06401.npy +imgHQ16073.npy +imgHQ13120.npy +imgHQ02818.npy +imgHQ26422.npy +imgHQ27041.npy +imgHQ20994.npy +imgHQ05223.npy +imgHQ06266.npy +imgHQ05648.npy +imgHQ21381.npy +imgHQ15679.npy +imgHQ26858.npy +imgHQ07141.npy +imgHQ17235.npy +imgHQ12141.npy +imgHQ10336.npy +imgHQ08675.npy +imgHQ19390.npy +imgHQ00175.npy +imgHQ25321.npy +imgHQ11383.npy +imgHQ03401.npy +imgHQ12328.npy +imgHQ18896.npy +imgHQ18596.npy +imgHQ21499.npy +imgHQ25383.npy +imgHQ07091.npy +imgHQ19138.npy +imgHQ08638.npy +imgHQ07830.npy +imgHQ06144.npy +imgHQ25904.npy +imgHQ26476.npy +imgHQ15200.npy +imgHQ06263.npy +imgHQ05316.npy +imgHQ20490.npy +imgHQ04062.npy +imgHQ01638.npy +imgHQ00894.npy +imgHQ16561.npy +imgHQ11915.npy +imgHQ15349.npy +imgHQ03891.npy +imgHQ29785.npy +imgHQ07156.npy +imgHQ05321.npy +imgHQ14214.npy +imgHQ20001.npy +imgHQ02797.npy +imgHQ06641.npy +imgHQ20795.npy +imgHQ09206.npy +imgHQ08389.npy +imgHQ24706.npy +imgHQ20379.npy +imgHQ24520.npy +imgHQ00128.npy +imgHQ29058.npy +imgHQ25081.npy +imgHQ03710.npy +imgHQ24249.npy +imgHQ10747.npy +imgHQ11286.npy +imgHQ15641.npy +imgHQ01770.npy +imgHQ00861.npy +imgHQ18952.npy +imgHQ28528.npy +imgHQ03879.npy +imgHQ20360.npy +imgHQ15338.npy +imgHQ09721.npy +imgHQ23493.npy +imgHQ07786.npy +imgHQ26437.npy +imgHQ03002.npy +imgHQ29280.npy +imgHQ06490.npy +imgHQ08221.npy +imgHQ15917.npy +imgHQ13678.npy +imgHQ13085.npy +imgHQ18801.npy +imgHQ16382.npy +imgHQ02402.npy +imgHQ16761.npy +imgHQ19696.npy +imgHQ10192.npy +imgHQ28735.npy +imgHQ26420.npy +imgHQ26955.npy +imgHQ16118.npy +imgHQ14983.npy +imgHQ03510.npy +imgHQ25492.npy +imgHQ02134.npy +imgHQ14601.npy +imgHQ23702.npy +imgHQ18786.npy +imgHQ10883.npy +imgHQ15633.npy +imgHQ13737.npy +imgHQ16111.npy +imgHQ13286.npy +imgHQ26613.npy +imgHQ29951.npy +imgHQ19674.npy +imgHQ20561.npy +imgHQ17364.npy +imgHQ26061.npy +imgHQ21865.npy +imgHQ19956.npy +imgHQ28280.npy +imgHQ15773.npy +imgHQ21933.npy +imgHQ07592.npy +imgHQ28483.npy +imgHQ27578.npy +imgHQ01670.npy +imgHQ03988.npy +imgHQ09912.npy +imgHQ08509.npy +imgHQ08597.npy +imgHQ06882.npy +imgHQ07051.npy +imgHQ11865.npy +imgHQ02013.npy +imgHQ15066.npy +imgHQ15291.npy +imgHQ21249.npy +imgHQ01633.npy +imgHQ15815.npy +imgHQ00196.npy +imgHQ10669.npy +imgHQ20719.npy +imgHQ22019.npy +imgHQ25511.npy +imgHQ00398.npy +imgHQ22087.npy +imgHQ00328.npy +imgHQ11591.npy +imgHQ09847.npy +imgHQ29921.npy +imgHQ25472.npy +imgHQ08305.npy +imgHQ11966.npy +imgHQ07576.npy +imgHQ17893.npy +imgHQ01486.npy +imgHQ12136.npy +imgHQ19751.npy +imgHQ01669.npy +imgHQ16001.npy +imgHQ27227.npy +imgHQ10374.npy +imgHQ18785.npy +imgHQ00431.npy +imgHQ04339.npy +imgHQ19234.npy +imgHQ24290.npy +imgHQ26844.npy +imgHQ26609.npy +imgHQ21880.npy +imgHQ22249.npy +imgHQ17658.npy +imgHQ25919.npy +imgHQ28129.npy +imgHQ24119.npy +imgHQ18995.npy +imgHQ03880.npy +imgHQ29722.npy +imgHQ12608.npy +imgHQ14713.npy +imgHQ29391.npy +imgHQ02187.npy +imgHQ13513.npy +imgHQ23180.npy +imgHQ15639.npy +imgHQ07913.npy +imgHQ27910.npy +imgHQ26885.npy +imgHQ16651.npy +imgHQ09930.npy +imgHQ17577.npy +imgHQ25470.npy +imgHQ24818.npy +imgHQ19745.npy +imgHQ00469.npy +imgHQ01310.npy +imgHQ14916.npy +imgHQ18483.npy +imgHQ00132.npy +imgHQ14122.npy +imgHQ00466.npy +imgHQ12367.npy +imgHQ26949.npy +imgHQ18375.npy +imgHQ10720.npy +imgHQ14341.npy +imgHQ08766.npy +imgHQ26335.npy +imgHQ12316.npy +imgHQ20856.npy +imgHQ06163.npy +imgHQ26033.npy +imgHQ16532.npy +imgHQ13190.npy +imgHQ15911.npy +imgHQ23848.npy +imgHQ27673.npy +imgHQ26950.npy +imgHQ17671.npy +imgHQ18619.npy +imgHQ29668.npy +imgHQ28622.npy +imgHQ27624.npy +imgHQ03669.npy +imgHQ06470.npy +imgHQ07637.npy +imgHQ07591.npy +imgHQ28943.npy +imgHQ22097.npy +imgHQ10605.npy +imgHQ05725.npy +imgHQ02048.npy +imgHQ14176.npy +imgHQ08066.npy +imgHQ18194.npy +imgHQ27492.npy +imgHQ06621.npy +imgHQ15297.npy +imgHQ10971.npy +imgHQ23801.npy +imgHQ04301.npy +imgHQ24848.npy +imgHQ04065.npy +imgHQ14467.npy +imgHQ28555.npy +imgHQ28455.npy +imgHQ14281.npy +imgHQ23206.npy +imgHQ18648.npy +imgHQ02354.npy +imgHQ19874.npy +imgHQ22952.npy +imgHQ00111.npy +imgHQ17246.npy +imgHQ02167.npy +imgHQ04531.npy +imgHQ29353.npy +imgHQ09867.npy +imgHQ11348.npy +imgHQ23338.npy +imgHQ12060.npy +imgHQ04696.npy +imgHQ21287.npy +imgHQ04373.npy +imgHQ00287.npy +imgHQ19433.npy +imgHQ27326.npy +imgHQ00391.npy +imgHQ13063.npy +imgHQ28826.npy +imgHQ26601.npy +imgHQ00962.npy +imgHQ27113.npy +imgHQ08480.npy +imgHQ25809.npy +imgHQ27275.npy +imgHQ02927.npy +imgHQ16885.npy +imgHQ26093.npy +imgHQ07353.npy +imgHQ22347.npy +imgHQ21798.npy +imgHQ00989.npy +imgHQ01472.npy +imgHQ14351.npy +imgHQ03742.npy +imgHQ17451.npy +imgHQ29819.npy +imgHQ23463.npy +imgHQ26716.npy +imgHQ04475.npy +imgHQ11237.npy +imgHQ03844.npy +imgHQ26460.npy +imgHQ11485.npy +imgHQ24623.npy +imgHQ15325.npy +imgHQ25881.npy +imgHQ06593.npy +imgHQ08777.npy +imgHQ04003.npy +imgHQ24708.npy +imgHQ06615.npy +imgHQ01601.npy +imgHQ01907.npy +imgHQ06829.npy +imgHQ20818.npy +imgHQ06775.npy +imgHQ01415.npy +imgHQ24020.npy +imgHQ26962.npy +imgHQ18121.npy +imgHQ14153.npy +imgHQ07612.npy +imgHQ12371.npy +imgHQ24330.npy +imgHQ09090.npy +imgHQ10887.npy +imgHQ12986.npy +imgHQ11232.npy +imgHQ20563.npy +imgHQ13294.npy +imgHQ02823.npy +imgHQ12150.npy +imgHQ29250.npy +imgHQ10855.npy +imgHQ07604.npy +imgHQ21430.npy +imgHQ22375.npy +imgHQ06654.npy +imgHQ28911.npy +imgHQ10332.npy +imgHQ19353.npy +imgHQ07094.npy +imgHQ29716.npy +imgHQ22586.npy +imgHQ21574.npy +imgHQ05456.npy +imgHQ29733.npy +imgHQ14342.npy +imgHQ06622.npy +imgHQ06571.npy +imgHQ23255.npy +imgHQ18475.npy +imgHQ08857.npy +imgHQ07463.npy +imgHQ17905.npy +imgHQ16987.npy +imgHQ23498.npy +imgHQ25730.npy +imgHQ06043.npy +imgHQ01199.npy +imgHQ14303.npy +imgHQ08342.npy +imgHQ01659.npy +imgHQ04627.npy +imgHQ09732.npy +imgHQ10582.npy +imgHQ29032.npy +imgHQ07523.npy +imgHQ04738.npy +imgHQ28216.npy +imgHQ11825.npy +imgHQ15720.npy +imgHQ05319.npy +imgHQ26639.npy +imgHQ03856.npy +imgHQ14527.npy +imgHQ08820.npy +imgHQ02898.npy +imgHQ00232.npy +imgHQ12789.npy +imgHQ28394.npy +imgHQ28557.npy +imgHQ04952.npy +imgHQ24408.npy +imgHQ27999.npy +imgHQ22322.npy +imgHQ23121.npy +imgHQ17273.npy +imgHQ13757.npy +imgHQ15249.npy +imgHQ28985.npy +imgHQ06191.npy +imgHQ28655.npy +imgHQ23590.npy +imgHQ23652.npy +imgHQ08141.npy +imgHQ28226.npy +imgHQ28443.npy +imgHQ10079.npy +imgHQ20951.npy +imgHQ05112.npy +imgHQ01370.npy +imgHQ08151.npy +imgHQ19755.npy +imgHQ20427.npy +imgHQ08316.npy +imgHQ26509.npy +imgHQ20830.npy +imgHQ07404.npy +imgHQ09901.npy +imgHQ21501.npy +imgHQ26148.npy +imgHQ26572.npy +imgHQ17352.npy +imgHQ10026.npy +imgHQ20841.npy +imgHQ26632.npy +imgHQ06291.npy +imgHQ19287.npy +imgHQ08034.npy +imgHQ21207.npy +imgHQ08224.npy +imgHQ19954.npy +imgHQ19647.npy +imgHQ01609.npy +imgHQ05864.npy +imgHQ11421.npy +imgHQ10060.npy +imgHQ29624.npy +imgHQ02876.npy +imgHQ06945.npy +imgHQ15177.npy +imgHQ01160.npy +imgHQ17428.npy +imgHQ06742.npy +imgHQ28391.npy +imgHQ04150.npy +imgHQ10981.npy +imgHQ13838.npy +imgHQ18520.npy +imgHQ09875.npy +imgHQ19648.npy +imgHQ25370.npy +imgHQ23506.npy +imgHQ07136.npy +imgHQ23080.npy +imgHQ23915.npy +imgHQ29688.npy +imgHQ11082.npy +imgHQ10650.npy +imgHQ02935.npy +imgHQ28227.npy +imgHQ16211.npy +imgHQ28972.npy +imgHQ22897.npy +imgHQ22033.npy +imgHQ09958.npy +imgHQ05002.npy +imgHQ29882.npy +imgHQ02762.npy +imgHQ05039.npy +imgHQ25817.npy +imgHQ24398.npy +imgHQ16178.npy +imgHQ12359.npy +imgHQ12848.npy +imgHQ22183.npy +imgHQ16819.npy +imgHQ12094.npy +imgHQ29805.npy +imgHQ16433.npy +imgHQ23445.npy +imgHQ19675.npy +imgHQ16901.npy +imgHQ04673.npy +imgHQ11456.npy +imgHQ03949.npy +imgHQ13770.npy +imgHQ11658.npy +imgHQ10741.npy +imgHQ18452.npy +imgHQ00145.npy +imgHQ17318.npy +imgHQ22589.npy +imgHQ00834.npy +imgHQ05533.npy +imgHQ08974.npy +imgHQ03986.npy +imgHQ18463.npy +imgHQ07471.npy +imgHQ14247.npy +imgHQ19717.npy +imgHQ01081.npy +imgHQ18411.npy +imgHQ08181.npy +imgHQ08595.npy +imgHQ29101.npy +imgHQ27314.npy +imgHQ19087.npy +imgHQ22664.npy +imgHQ21013.npy +imgHQ10015.npy +imgHQ11910.npy +imgHQ07255.npy +imgHQ21987.npy +imgHQ21056.npy +imgHQ14155.npy +imgHQ02708.npy +imgHQ27833.npy +imgHQ05966.npy +imgHQ05072.npy +imgHQ27707.npy +imgHQ13426.npy +imgHQ12666.npy +imgHQ09920.npy +imgHQ27168.npy +imgHQ00727.npy +imgHQ26192.npy +imgHQ12673.npy +imgHQ11945.npy +imgHQ23533.npy +imgHQ15426.npy +imgHQ08064.npy +imgHQ05035.npy +imgHQ23020.npy +imgHQ12127.npy +imgHQ28113.npy +imgHQ23247.npy +imgHQ16277.npy +imgHQ17888.npy +imgHQ29879.npy +imgHQ29642.npy +imgHQ13188.npy +imgHQ00012.npy +imgHQ11696.npy +imgHQ02639.npy +imgHQ11571.npy +imgHQ21399.npy +imgHQ13640.npy +imgHQ03263.npy +imgHQ10628.npy +imgHQ28936.npy +imgHQ03100.npy +imgHQ19792.npy +imgHQ04437.npy +imgHQ06713.npy +imgHQ06486.npy +imgHQ10975.npy +imgHQ21646.npy +imgHQ07584.npy +imgHQ19104.npy +imgHQ15719.npy +imgHQ07182.npy +imgHQ08979.npy +imgHQ09442.npy +imgHQ17573.npy +imgHQ15827.npy +imgHQ13084.npy +imgHQ05560.npy +imgHQ03992.npy +imgHQ02029.npy +imgHQ18574.npy +imgHQ28285.npy +imgHQ04136.npy +imgHQ22814.npy +imgHQ15468.npy +imgHQ26067.npy +imgHQ03951.npy +imgHQ18098.npy +imgHQ16377.npy +imgHQ08534.npy +imgHQ03796.npy +imgHQ18821.npy +imgHQ14326.npy +imgHQ04040.npy +imgHQ26660.npy +imgHQ25927.npy +imgHQ04827.npy +imgHQ25953.npy +imgHQ17768.npy +imgHQ13731.npy +imgHQ10763.npy +imgHQ17499.npy +imgHQ02066.npy +imgHQ05459.npy +imgHQ16031.npy +imgHQ08925.npy +imgHQ12380.npy +imgHQ16920.npy +imgHQ09143.npy +imgHQ16975.npy +imgHQ26333.npy +imgHQ16865.npy +imgHQ26136.npy +imgHQ01883.npy +imgHQ24891.npy +imgHQ14195.npy +imgHQ04313.npy +imgHQ24297.npy +imgHQ02943.npy +imgHQ28866.npy +imgHQ02496.npy +imgHQ18366.npy +imgHQ10415.npy +imgHQ16405.npy +imgHQ23285.npy +imgHQ08560.npy +imgHQ15781.npy +imgHQ17406.npy +imgHQ12473.npy +imgHQ29518.npy +imgHQ09467.npy +imgHQ16969.npy +imgHQ20195.npy +imgHQ20997.npy +imgHQ19662.npy +imgHQ19495.npy +imgHQ22002.npy +imgHQ14827.npy +imgHQ18637.npy +imgHQ23390.npy +imgHQ14513.npy +imgHQ11207.npy +imgHQ02750.npy +imgHQ17636.npy +imgHQ04461.npy +imgHQ24712.npy +imgHQ01761.npy +imgHQ23384.npy +imgHQ11031.npy +imgHQ23225.npy +imgHQ09696.npy +imgHQ19534.npy +imgHQ04542.npy +imgHQ28994.npy +imgHQ18672.npy +imgHQ00824.npy +imgHQ08720.npy +imgHQ13667.npy +imgHQ21270.npy +imgHQ24298.npy +imgHQ00247.npy +imgHQ29228.npy +imgHQ02087.npy +imgHQ09543.npy +imgHQ08570.npy +imgHQ09989.npy +imgHQ16933.npy +imgHQ07596.npy +imgHQ17616.npy +imgHQ26250.npy +imgHQ19339.npy +imgHQ25254.npy +imgHQ09816.npy +imgHQ03081.npy +imgHQ13821.npy +imgHQ25970.npy +imgHQ20978.npy +imgHQ11614.npy +imgHQ19174.npy +imgHQ10343.npy +imgHQ06625.npy +imgHQ13238.npy +imgHQ21485.npy +imgHQ21460.npy +imgHQ18565.npy +imgHQ04010.npy +imgHQ24986.npy +imgHQ11637.npy +imgHQ07574.npy +imgHQ11251.npy +imgHQ06786.npy +imgHQ14632.npy +imgHQ27079.npy +imgHQ01800.npy +imgHQ02501.npy +imgHQ17783.npy +imgHQ16728.npy +imgHQ02747.npy +imgHQ23220.npy +imgHQ08009.npy +imgHQ06986.npy +imgHQ16991.npy +imgHQ00187.npy +imgHQ21533.npy +imgHQ00296.npy +imgHQ05415.npy +imgHQ19740.npy +imgHQ09395.npy +imgHQ00444.npy +imgHQ02841.npy +imgHQ06961.npy +imgHQ18531.npy +imgHQ16834.npy +imgHQ22101.npy +imgHQ19649.npy +imgHQ12518.npy +imgHQ06978.npy +imgHQ14613.npy +imgHQ10088.npy +imgHQ20023.npy +imgHQ29000.npy +imgHQ28641.npy +imgHQ15182.npy +imgHQ20287.npy +imgHQ20191.npy +imgHQ02492.npy +imgHQ00970.npy +imgHQ10810.npy +imgHQ21435.npy +imgHQ08497.npy +imgHQ11769.npy +imgHQ03850.npy +imgHQ26648.npy +imgHQ18168.npy +imgHQ11899.npy +imgHQ22240.npy +imgHQ02130.npy +imgHQ25426.npy +imgHQ11997.npy +imgHQ26455.npy +imgHQ07263.npy +imgHQ25201.npy +imgHQ16514.npy +imgHQ07234.npy +imgHQ27955.npy +imgHQ16467.npy +imgHQ11049.npy +imgHQ15318.npy +imgHQ09064.npy +imgHQ23036.npy +imgHQ28250.npy +imgHQ10508.npy +imgHQ04836.npy +imgHQ27775.npy +imgHQ24682.npy +imgHQ27659.npy +imgHQ27209.npy +imgHQ06517.npy +imgHQ06236.npy +imgHQ13920.npy +imgHQ26241.npy +imgHQ08695.npy +imgHQ16751.npy +imgHQ18991.npy +imgHQ26224.npy +imgHQ24867.npy +imgHQ16227.npy +imgHQ20524.npy +imgHQ08903.npy +imgHQ12870.npy +imgHQ08511.npy +imgHQ08839.npy +imgHQ27526.npy +imgHQ03722.npy +imgHQ22146.npy +imgHQ15895.npy +imgHQ17668.npy +imgHQ01438.npy +imgHQ29040.npy +imgHQ29605.npy +imgHQ09197.npy +imgHQ13671.npy +imgHQ27569.npy +imgHQ06636.npy +imgHQ05129.npy +imgHQ01108.npy +imgHQ09569.npy +imgHQ24293.npy +imgHQ00497.npy +imgHQ26068.npy +imgHQ16062.npy +imgHQ07459.npy +imgHQ18515.npy +imgHQ16008.npy +imgHQ01239.npy +imgHQ09921.npy +imgHQ02489.npy +imgHQ25755.npy +imgHQ21053.npy +imgHQ23302.npy +imgHQ13231.npy +imgHQ27974.npy +imgHQ17588.npy +imgHQ14661.npy +imgHQ28044.npy +imgHQ24312.npy +imgHQ29886.npy +imgHQ12199.npy +imgHQ05282.npy +imgHQ26975.npy +imgHQ12846.npy +imgHQ15250.npy +imgHQ19846.npy +imgHQ13417.npy +imgHQ18938.npy +imgHQ26909.npy +imgHQ11821.npy +imgHQ26178.npy +imgHQ10954.npy +imgHQ21407.npy +imgHQ13124.npy +imgHQ07520.npy +imgHQ15368.npy +imgHQ14445.npy +imgHQ01528.npy +imgHQ07089.npy +imgHQ03367.npy +imgHQ19878.npy +imgHQ08016.npy +imgHQ17722.npy +imgHQ18441.npy +imgHQ17455.npy +imgHQ29870.npy +imgHQ08738.npy +imgHQ07534.npy +imgHQ23565.npy +imgHQ11294.npy +imgHQ27978.npy +imgHQ07696.npy +imgHQ26003.npy +imgHQ24171.npy +imgHQ17786.npy +imgHQ11240.npy +imgHQ25840.npy +imgHQ27399.npy +imgHQ15779.npy +imgHQ28196.npy +imgHQ14362.npy +imgHQ28784.npy +imgHQ26827.npy +imgHQ18695.npy +imgHQ20672.npy +imgHQ06086.npy +imgHQ16134.npy +imgHQ20109.npy +imgHQ21378.npy +imgHQ19431.npy +imgHQ13484.npy +imgHQ06842.npy +imgHQ13393.npy +imgHQ24359.npy +imgHQ12403.npy +imgHQ18150.npy +imgHQ01113.npy +imgHQ25142.npy +imgHQ03238.npy +imgHQ18236.npy +imgHQ29269.npy +imgHQ11002.npy +imgHQ26084.npy +imgHQ15016.npy +imgHQ00544.npy +imgHQ11279.npy +imgHQ20140.npy +imgHQ05445.npy +imgHQ20448.npy +imgHQ27103.npy +imgHQ15228.npy +imgHQ27363.npy +imgHQ15583.npy +imgHQ00877.npy +imgHQ08152.npy +imgHQ16326.npy +imgHQ26821.npy +imgHQ28051.npy +imgHQ20977.npy +imgHQ14652.npy +imgHQ07744.npy +imgHQ10137.npy +imgHQ09136.npy +imgHQ23089.npy +imgHQ23258.npy +imgHQ22927.npy +imgHQ03047.npy +imgHQ16160.npy +imgHQ09397.npy +imgHQ21203.npy +imgHQ28788.npy +imgHQ07482.npy +imgHQ13509.npy +imgHQ25780.npy +imgHQ07890.npy +imgHQ03945.npy +imgHQ17181.npy +imgHQ12959.npy +imgHQ02177.npy +imgHQ17538.npy +imgHQ22029.npy +imgHQ13543.npy +imgHQ04711.npy +imgHQ06351.npy +imgHQ07695.npy +imgHQ22262.npy +imgHQ06495.npy +imgHQ10935.npy +imgHQ11872.npy +imgHQ00953.npy +imgHQ17737.npy +imgHQ28047.npy +imgHQ13966.npy +imgHQ28695.npy +imgHQ14819.npy +imgHQ20590.npy +imgHQ21853.npy +imgHQ18967.npy +imgHQ04166.npy +imgHQ10534.npy +imgHQ19548.npy +imgHQ10229.npy +imgHQ09032.npy +imgHQ26627.npy +imgHQ27690.npy +imgHQ17633.npy +imgHQ15292.npy +imgHQ13288.npy +imgHQ04261.npy +imgHQ19898.npy +imgHQ05249.npy +imgHQ17793.npy +imgHQ15057.npy +imgHQ15852.npy +imgHQ11435.npy +imgHQ19637.npy +imgHQ29238.npy +imgHQ07211.npy +imgHQ09359.npy +imgHQ11038.npy +imgHQ27587.npy +imgHQ29358.npy +imgHQ13463.npy +imgHQ22004.npy +imgHQ04685.npy +imgHQ01623.npy +imgHQ12358.npy +imgHQ17347.npy +imgHQ28896.npy +imgHQ25132.npy +imgHQ21537.npy +imgHQ29554.npy +imgHQ16675.npy +imgHQ15307.npy +imgHQ12545.npy +imgHQ12108.npy +imgHQ24268.npy +imgHQ22548.npy +imgHQ04764.npy +imgHQ20232.npy +imgHQ21707.npy +imgHQ08437.npy +imgHQ16580.npy +imgHQ04085.npy +imgHQ04891.npy +imgHQ12174.npy +imgHQ23849.npy +imgHQ11639.npy +imgHQ15144.npy +imgHQ19387.npy +imgHQ17532.npy +imgHQ15356.npy +imgHQ26325.npy +imgHQ06651.npy +imgHQ14142.npy +imgHQ13888.npy +imgHQ16731.npy +imgHQ05937.npy +imgHQ09952.npy +imgHQ24887.npy +imgHQ28334.npy +imgHQ02452.npy +imgHQ15600.npy +imgHQ10845.npy +imgHQ01790.npy +imgHQ07478.npy +imgHQ15463.npy +imgHQ18093.npy +imgHQ06800.npy +imgHQ08647.npy +imgHQ03327.npy +imgHQ24624.npy +imgHQ16658.npy +imgHQ00886.npy +imgHQ28228.npy +imgHQ02163.npy +imgHQ16231.npy +imgHQ09463.npy +imgHQ09988.npy +imgHQ10346.npy +imgHQ28211.npy +imgHQ20172.npy +imgHQ15207.npy +imgHQ04468.npy +imgHQ17168.npy +imgHQ09906.npy +imgHQ20655.npy +imgHQ17623.npy +imgHQ05892.npy +imgHQ20014.npy +imgHQ25575.npy +imgHQ21450.npy +imgHQ16654.npy +imgHQ20659.npy +imgHQ07313.npy +imgHQ05956.npy +imgHQ06415.npy +imgHQ11407.npy +imgHQ05021.npy +imgHQ08003.npy +imgHQ12995.npy +imgHQ06285.npy +imgHQ20783.npy +imgHQ28011.npy +imgHQ03694.npy +imgHQ08690.npy +imgHQ28396.npy +imgHQ27847.npy +imgHQ12903.npy +imgHQ17516.npy +imgHQ10140.npy +imgHQ29270.npy +imgHQ08060.npy +imgHQ20468.npy +imgHQ14656.npy +imgHQ17026.npy +imgHQ15209.npy +imgHQ05767.npy +imgHQ14320.npy +imgHQ07435.npy +imgHQ26545.npy +imgHQ04168.npy +imgHQ24888.npy +imgHQ26605.npy +imgHQ27498.npy +imgHQ12640.npy +imgHQ10817.npy +imgHQ03421.npy +imgHQ26670.npy +imgHQ25878.npy +imgHQ13632.npy +imgHQ22823.npy +imgHQ28604.npy +imgHQ10167.npy +imgHQ14572.npy +imgHQ17481.npy +imgHQ10745.npy +imgHQ22134.npy +imgHQ16630.npy +imgHQ00268.npy +imgHQ27150.npy +imgHQ01765.npy +imgHQ01036.npy +imgHQ23627.npy +imgHQ12010.npy +imgHQ00331.npy +imgHQ29682.npy +imgHQ08977.npy +imgHQ27149.npy +imgHQ00109.npy +imgHQ07868.npy +imgHQ15661.npy +imgHQ01619.npy +imgHQ18684.npy +imgHQ15156.npy +imgHQ01805.npy +imgHQ17467.npy +imgHQ22838.npy +imgHQ22080.npy +imgHQ20376.npy +imgHQ00850.npy +imgHQ01354.npy +imgHQ25543.npy +imgHQ21716.npy +imgHQ13161.npy +imgHQ09635.npy +imgHQ16479.npy +imgHQ28719.npy +imgHQ15608.npy +imgHQ07464.npy +imgHQ09259.npy +imgHQ12381.npy +imgHQ02473.npy +imgHQ14905.npy +imgHQ09307.npy +imgHQ15436.npy +imgHQ29754.npy +imgHQ20161.npy +imgHQ03885.npy +imgHQ02431.npy +imgHQ10008.npy +imgHQ08747.npy +imgHQ12125.npy +imgHQ19381.npy +imgHQ25075.npy +imgHQ14413.npy +imgHQ29396.npy +imgHQ22016.npy +imgHQ02210.npy +imgHQ22427.npy +imgHQ27632.npy +imgHQ29665.npy +imgHQ01541.npy +imgHQ12187.npy +imgHQ13292.npy +imgHQ06161.npy +imgHQ18287.npy +imgHQ20141.npy +imgHQ04469.npy +imgHQ01466.npy +imgHQ24571.npy +imgHQ02285.npy +imgHQ25617.npy +imgHQ17062.npy +imgHQ10590.npy +imgHQ14700.npy +imgHQ28681.npy +imgHQ15669.npy +imgHQ03989.npy +imgHQ26469.npy +imgHQ14161.npy +imgHQ13756.npy +imgHQ06026.npy +imgHQ20245.npy +imgHQ18473.npy +imgHQ04433.npy +imgHQ14096.npy +imgHQ23648.npy +imgHQ18245.npy +imgHQ12508.npy +imgHQ24142.npy +imgHQ13882.npy +imgHQ10876.npy +imgHQ13255.npy +imgHQ14006.npy +imgHQ20810.npy +imgHQ06583.npy +imgHQ08661.npy +imgHQ23932.npy +imgHQ13401.npy +imgHQ00055.npy +imgHQ03544.npy +imgHQ21387.npy +imgHQ06853.npy +imgHQ14421.npy +imgHQ07541.npy +imgHQ00201.npy +imgHQ14726.npy +imgHQ09492.npy +imgHQ22735.npy +imgHQ16309.npy +imgHQ12532.npy +imgHQ11519.npy +imgHQ17018.npy +imgHQ01208.npy +imgHQ20553.npy +imgHQ18136.npy +imgHQ09997.npy +imgHQ11431.npy +imgHQ01745.npy +imgHQ23646.npy +imgHQ00270.npy +imgHQ21590.npy +imgHQ25505.npy +imgHQ24747.npy +imgHQ28954.npy +imgHQ24373.npy +imgHQ00400.npy +imgHQ05845.npy +imgHQ16643.npy +imgHQ08005.npy +imgHQ26814.npy +imgHQ02006.npy +imgHQ25684.npy +imgHQ19729.npy +imgHQ25647.npy +imgHQ27073.npy +imgHQ00516.npy +imgHQ04467.npy +imgHQ28283.npy +imgHQ12438.npy +imgHQ23817.npy +imgHQ16859.npy +imgHQ13043.npy +imgHQ15319.npy +imgHQ01144.npy +imgHQ03936.npy +imgHQ16039.npy +imgHQ19831.npy +imgHQ00468.npy +imgHQ14226.npy +imgHQ08195.npy +imgHQ26906.npy +imgHQ28416.npy +imgHQ03868.npy +imgHQ04902.npy +imgHQ11534.npy +imgHQ29666.npy +imgHQ16208.npy +imgHQ01959.npy +imgHQ11875.npy +imgHQ13732.npy +imgHQ07515.npy +imgHQ21470.npy +imgHQ23233.npy +imgHQ04438.npy +imgHQ14427.npy +imgHQ28449.npy +imgHQ06590.npy +imgHQ19544.npy +imgHQ22894.npy +imgHQ15547.npy +imgHQ26013.npy +imgHQ17295.npy +imgHQ02947.npy +imgHQ09687.npy +imgHQ22902.npy +imgHQ03841.npy +imgHQ19190.npy +imgHQ04525.npy +imgHQ13663.npy +imgHQ01881.npy +imgHQ11016.npy +imgHQ03104.npy +imgHQ28729.npy +imgHQ29172.npy +imgHQ12840.npy +imgHQ18128.npy +imgHQ15271.npy +imgHQ18974.npy +imgHQ08530.npy +imgHQ20236.npy +imgHQ09848.npy +imgHQ11312.npy +imgHQ02551.npy +imgHQ29046.npy +imgHQ08159.npy +imgHQ22863.npy +imgHQ23807.npy +imgHQ15038.npy +imgHQ26899.npy +imgHQ23827.npy +imgHQ11460.npy +imgHQ08678.npy +imgHQ10248.npy +imgHQ13711.npy +imgHQ25133.npy +imgHQ17990.npy +imgHQ02929.npy +imgHQ27553.npy +imgHQ20233.npy +imgHQ19658.npy +imgHQ04306.npy +imgHQ01568.npy +imgHQ06403.npy +imgHQ06077.npy +imgHQ21734.npy +imgHQ10594.npy +imgHQ13673.npy +imgHQ29906.npy +imgHQ19086.npy +imgHQ27574.npy +imgHQ14497.npy +imgHQ16698.npy +imgHQ08216.npy +imgHQ19879.npy +imgHQ03767.npy +imgHQ01719.npy +imgHQ24135.npy +imgHQ04411.npy +imgHQ00572.npy +imgHQ29618.npy +imgHQ29587.npy +imgHQ29918.npy +imgHQ21179.npy +imgHQ25389.npy +imgHQ06300.npy +imgHQ13068.npy +imgHQ24923.npy +imgHQ29332.npy +imgHQ20459.npy +imgHQ21492.npy +imgHQ27727.npy +imgHQ04118.npy +imgHQ25955.npy +imgHQ22360.npy +imgHQ29984.npy +imgHQ22237.npy +imgHQ21444.npy +imgHQ18835.npy +imgHQ09487.npy +imgHQ02102.npy +imgHQ18913.npy +imgHQ25729.npy +imgHQ21563.npy +imgHQ07852.npy +imgHQ09616.npy +imgHQ11301.npy +imgHQ01067.npy +imgHQ07185.npy +imgHQ12652.npy +imgHQ14767.npy +imgHQ06891.npy +imgHQ09671.npy +imgHQ01816.npy +imgHQ09062.npy +imgHQ14879.npy +imgHQ03247.npy +imgHQ28862.npy +imgHQ02945.npy +imgHQ13698.npy +imgHQ20261.npy +imgHQ10241.npy +imgHQ01127.npy +imgHQ01763.npy +imgHQ28010.npy +imgHQ19702.npy +imgHQ06132.npy +imgHQ03398.npy +imgHQ07287.npy +imgHQ14699.npy +imgHQ00184.npy +imgHQ14918.npy +imgHQ06244.npy +imgHQ09183.npy +imgHQ23414.npy +imgHQ08965.npy +imgHQ12304.npy +imgHQ16469.npy +imgHQ15710.npy +imgHQ02181.npy +imgHQ28106.npy +imgHQ03803.npy +imgHQ16253.npy +imgHQ27042.npy +imgHQ25028.npy +imgHQ12888.npy +imgHQ08576.npy +imgHQ12898.npy +imgHQ01304.npy +imgHQ17113.npy +imgHQ26017.npy +imgHQ28917.npy +imgHQ04058.npy +imgHQ19484.npy +imgHQ14419.npy +imgHQ12320.npy +imgHQ02529.npy +imgHQ16841.npy +imgHQ12534.npy +imgHQ08232.npy +imgHQ12117.npy +imgHQ21910.npy +imgHQ21187.npy +imgHQ25710.npy +imgHQ12651.npy +imgHQ24527.npy +imgHQ03493.npy +imgHQ06467.npy +imgHQ26650.npy +imgHQ08478.npy +imgHQ27357.npy +imgHQ29475.npy +imgHQ14523.npy +imgHQ28365.npy +imgHQ22156.npy +imgHQ25366.npy +imgHQ22637.npy +imgHQ21208.npy +imgHQ09414.npy +imgHQ14185.npy +imgHQ18215.npy +imgHQ01105.npy +imgHQ02059.npy +imgHQ16880.npy +imgHQ04484.npy +imgHQ22335.npy +imgHQ11084.npy +imgHQ16959.npy +imgHQ08451.npy +imgHQ11469.npy +imgHQ14347.npy +imgHQ29343.npy +imgHQ23535.npy +imgHQ00787.npy +imgHQ17048.npy +imgHQ21165.npy +imgHQ10177.npy +imgHQ03407.npy +imgHQ24893.npy +imgHQ02678.npy +imgHQ00228.npy +imgHQ04600.npy +imgHQ22211.npy +imgHQ03882.npy +imgHQ14660.npy +imgHQ11311.npy +imgHQ18373.npy +imgHQ18105.npy +imgHQ20220.npy +imgHQ27011.npy +imgHQ26531.npy +imgHQ14507.npy +imgHQ19393.npy +imgHQ11747.npy +imgHQ05425.npy +imgHQ01418.npy +imgHQ29907.npy +imgHQ28898.npy +imgHQ29955.npy +imgHQ13114.npy +imgHQ18945.npy +imgHQ18184.npy +imgHQ18806.npy +imgHQ01617.npy +imgHQ11935.npy +imgHQ02046.npy +imgHQ13376.npy +imgHQ12984.npy +imgHQ10496.npy +imgHQ06899.npy +imgHQ27602.npy +imgHQ23703.npy +imgHQ12993.npy +imgHQ21012.npy +imgHQ14448.npy +imgHQ27178.npy +imgHQ19230.npy +imgHQ09195.npy +imgHQ00680.npy +imgHQ07561.npy +imgHQ07705.npy +imgHQ22635.npy +imgHQ14954.npy +imgHQ20819.npy +imgHQ26508.npy +imgHQ28752.npy +imgHQ11664.npy +imgHQ14863.npy +imgHQ25458.npy +imgHQ24132.npy +imgHQ05528.npy +imgHQ25037.npy +imgHQ26494.npy +imgHQ07715.npy +imgHQ03295.npy +imgHQ02598.npy +imgHQ22362.npy +imgHQ12075.npy +imgHQ17738.npy +imgHQ00687.npy +imgHQ06563.npy +imgHQ09614.npy +imgHQ21952.npy +imgHQ22351.npy +imgHQ27566.npy +imgHQ00519.npy +imgHQ12000.npy +imgHQ18666.npy +imgHQ14716.npy +imgHQ25786.npy +imgHQ03812.npy +imgHQ05745.npy +imgHQ26830.npy +imgHQ14179.npy +imgHQ06838.npy +imgHQ14337.npy +imgHQ25288.npy +imgHQ07945.npy +imgHQ11030.npy +imgHQ25713.npy +imgHQ03093.npy +imgHQ04039.npy +imgHQ27899.npy +imgHQ05279.npy +imgHQ10351.npy +imgHQ09670.npy +imgHQ18068.npy +imgHQ06858.npy +imgHQ10373.npy +imgHQ11257.npy +imgHQ01290.npy +imgHQ25813.npy +imgHQ17558.npy +imgHQ21953.npy +imgHQ10322.npy +imgHQ19436.npy +imgHQ27423.npy +imgHQ18750.npy +imgHQ25768.npy +imgHQ03637.npy +imgHQ24309.npy +imgHQ23622.npy +imgHQ14676.npy +imgHQ24877.npy +imgHQ26339.npy +imgHQ23634.npy +imgHQ28445.npy +imgHQ20882.npy +imgHQ24341.npy +imgHQ29093.npy +imgHQ25150.npy +imgHQ07320.npy +imgHQ11706.npy +imgHQ07397.npy +imgHQ28110.npy +imgHQ03674.npy +imgHQ12669.npy +imgHQ21301.npy +imgHQ07940.npy +imgHQ08487.npy +imgHQ07980.npy +imgHQ22103.npy +imgHQ20210.npy +imgHQ09844.npy +imgHQ02277.npy +imgHQ11950.npy +imgHQ23462.npy +imgHQ08794.npy +imgHQ18103.npy +imgHQ24515.npy +imgHQ17733.npy +imgHQ14083.npy +imgHQ16605.npy +imgHQ27141.npy +imgHQ01627.npy +imgHQ06570.npy +imgHQ15476.npy +imgHQ26207.npy +imgHQ12176.npy +imgHQ12407.npy +imgHQ11396.npy +imgHQ18598.npy +imgHQ01114.npy +imgHQ08190.npy +imgHQ20498.npy +imgHQ10267.npy +imgHQ08142.npy +imgHQ01871.npy +imgHQ13928.npy +imgHQ11349.npy +imgHQ12892.npy +imgHQ05637.npy +imgHQ12306.npy +imgHQ17039.npy +imgHQ19102.npy +imgHQ08751.npy +imgHQ02341.npy +imgHQ27877.npy +imgHQ20103.npy +imgHQ18046.npy +imgHQ24748.npy +imgHQ12784.npy +imgHQ04721.npy +imgHQ14986.npy +imgHQ03170.npy +imgHQ24531.npy +imgHQ15939.npy +imgHQ15058.npy +imgHQ11334.npy +imgHQ14842.npy +imgHQ05831.npy +imgHQ14043.npy +imgHQ20388.npy +imgHQ23580.npy +imgHQ09234.npy +imgHQ06072.npy +imgHQ03656.npy +imgHQ17457.npy +imgHQ10081.npy +imgHQ27688.npy +imgHQ07055.npy +imgHQ24159.npy +imgHQ25541.npy +imgHQ16037.npy +imgHQ05668.npy +imgHQ09834.npy +imgHQ19364.npy +imgHQ09733.npy +imgHQ01922.npy +imgHQ02552.npy +imgHQ05429.npy +imgHQ20536.npy +imgHQ16636.npy +imgHQ07820.npy +imgHQ08498.npy +imgHQ22361.npy +imgHQ13677.npy +imgHQ16664.npy +imgHQ17083.npy +imgHQ15813.npy +imgHQ19228.npy +imgHQ26121.npy +imgHQ16445.npy +imgHQ02755.npy +imgHQ10148.npy +imgHQ24015.npy +imgHQ14232.npy +imgHQ16357.npy +imgHQ26131.npy +imgHQ27721.npy +imgHQ03775.npy +imgHQ23631.npy +imgHQ20762.npy +imgHQ13961.npy +imgHQ28132.npy +imgHQ06921.npy +imgHQ05322.npy +imgHQ16585.npy +imgHQ21062.npy +imgHQ04941.npy +imgHQ12576.npy +imgHQ05031.npy +imgHQ16465.npy +imgHQ02487.npy +imgHQ24263.npy +imgHQ10337.npy +imgHQ27466.npy +imgHQ16998.npy +imgHQ21224.npy +imgHQ26358.npy +imgHQ20015.npy +imgHQ14469.npy +imgHQ10708.npy +imgHQ06928.npy +imgHQ26576.npy +imgHQ23167.npy +imgHQ18948.npy +imgHQ23857.npy +imgHQ12362.npy +imgHQ25873.npy +imgHQ10753.npy +imgHQ21676.npy +imgHQ24181.npy +imgHQ25020.npy +imgHQ04825.npy +imgHQ27044.npy +imgHQ02217.npy +imgHQ25614.npy +imgHQ19632.npy +imgHQ12871.npy +imgHQ17283.npy +imgHQ06656.npy +imgHQ21107.npy +imgHQ17736.npy +imgHQ13139.npy +imgHQ10907.npy +imgHQ08866.npy +imgHQ11295.npy +imgHQ01394.npy +imgHQ22549.npy +imgHQ22309.npy +imgHQ00935.npy +imgHQ16762.npy +imgHQ26617.npy +imgHQ26774.npy +imgHQ20525.npy +imgHQ08416.npy +imgHQ22685.npy +imgHQ14509.npy +imgHQ18002.npy +imgHQ08309.npy +imgHQ09174.npy +imgHQ24610.npy +imgHQ08283.npy +imgHQ27780.npy +imgHQ06837.npy +imgHQ19810.npy +imgHQ19641.npy +imgHQ06705.npy +imgHQ25476.npy +imgHQ04751.npy +imgHQ12768.npy +imgHQ11433.npy +imgHQ24470.npy +imgHQ02827.npy +imgHQ28272.npy +imgHQ21562.npy +imgHQ00243.npy +imgHQ12415.npy +imgHQ08981.npy +imgHQ20012.npy +imgHQ10034.npy +imgHQ00635.npy +imgHQ19027.npy +imgHQ22499.npy +imgHQ16588.npy +imgHQ21685.npy +imgHQ02791.npy +imgHQ22594.npy +imgHQ21737.npy +imgHQ02329.npy +imgHQ05099.npy +imgHQ26391.npy +imgHQ07050.npy +imgHQ09651.npy +imgHQ14670.npy +imgHQ25360.npy +imgHQ25570.npy +imgHQ21421.npy +imgHQ18954.npy +imgHQ06501.npy +imgHQ05356.npy +imgHQ12656.npy +imgHQ12035.npy +imgHQ22273.npy +imgHQ23992.npy +imgHQ04575.npy +imgHQ02969.npy +imgHQ03952.npy +imgHQ08936.npy +imgHQ28806.npy +imgHQ27324.npy +imgHQ29970.npy +imgHQ26155.npy +imgHQ23208.npy +imgHQ16940.npy +imgHQ12954.npy +imgHQ03985.npy +imgHQ18354.npy +imgHQ07005.npy +imgHQ18626.npy +imgHQ11409.npy +imgHQ11992.npy +imgHQ15438.npy +imgHQ29751.npy +imgHQ23802.npy +imgHQ00596.npy +imgHQ19048.npy +imgHQ14576.npy +imgHQ23546.npy +imgHQ00679.npy +imgHQ11788.npy +imgHQ03164.npy +imgHQ26794.npy +imgHQ17376.npy +imgHQ18587.npy +imgHQ25906.npy +imgHQ13910.npy +imgHQ09944.npy +imgHQ12104.npy +imgHQ21892.npy +imgHQ27905.npy +imgHQ26484.npy +imgHQ28036.npy +imgHQ17782.npy +imgHQ24149.npy +imgHQ29564.npy +imgHQ29700.npy +imgHQ19150.npy +imgHQ14773.npy +imgHQ17476.npy +imgHQ18628.npy +imgHQ21332.npy +imgHQ00342.npy +imgHQ29813.npy +imgHQ07001.npy +imgHQ17631.npy +imgHQ28754.npy +imgHQ11737.npy +imgHQ02062.npy +imgHQ13939.npy +imgHQ23660.npy +imgHQ04193.npy +imgHQ23413.npy +imgHQ26183.npy +imgHQ02592.npy +imgHQ18906.npy +imgHQ13159.npy +imgHQ29657.npy +imgHQ02304.npy +imgHQ01439.npy +imgHQ19569.npy +imgHQ29863.npy +imgHQ23978.npy +imgHQ17828.npy +imgHQ19896.npy +imgHQ23204.npy +imgHQ11197.npy +imgHQ12069.npy +imgHQ28587.npy +imgHQ14077.npy +imgHQ26982.npy +imgHQ10906.npy +imgHQ03273.npy +imgHQ22458.npy +imgHQ18173.npy +imgHQ09870.npy +imgHQ25098.npy +imgHQ03596.npy +imgHQ09621.npy +imgHQ24593.npy +imgHQ07194.npy +imgHQ17285.npy +imgHQ07811.npy +imgHQ04777.npy +imgHQ10205.npy +imgHQ01112.npy +imgHQ14764.npy +imgHQ04963.npy +imgHQ16847.npy +imgHQ27859.npy +imgHQ21097.npy +imgHQ01028.npy +imgHQ16238.npy +imgHQ07931.npy +imgHQ12539.npy +imgHQ23226.npy +imgHQ16507.npy +imgHQ19762.npy +imgHQ26098.npy +imgHQ26822.npy +imgHQ27036.npy +imgHQ22467.npy +imgHQ22318.npy +imgHQ24814.npy +imgHQ11909.npy +imgHQ08187.npy +imgHQ17001.npy +imgHQ29723.npy +imgHQ03666.npy +imgHQ04174.npy +imgHQ21506.npy +imgHQ04628.npy +imgHQ24063.npy +imgHQ03001.npy +imgHQ12600.npy +imgHQ13305.npy +imgHQ29443.npy +imgHQ27443.npy +imgHQ17691.npy +imgHQ12097.npy +imgHQ25126.npy +imgHQ00757.npy +imgHQ18555.npy +imgHQ07978.npy +imgHQ20039.npy +imgHQ03768.npy +imgHQ04957.npy +imgHQ13792.npy +imgHQ21967.npy +imgHQ22590.npy +imgHQ03142.npy +imgHQ13031.npy +imgHQ16299.npy +imgHQ10143.npy +imgHQ24613.npy +imgHQ15508.npy +imgHQ06130.npy +imgHQ18653.npy +imgHQ12449.npy +imgHQ06320.npy +imgHQ25696.npy +imgHQ29504.npy +imgHQ23853.npy +imgHQ24991.npy +imgHQ17014.npy +imgHQ06203.npy +imgHQ26124.npy +imgHQ18010.npy +imgHQ20903.npy +imgHQ17864.npy +imgHQ09711.npy +imgHQ06054.npy +imgHQ16770.npy +imgHQ08952.npy +imgHQ06465.npy +imgHQ18443.npy +imgHQ09117.npy +imgHQ12205.npy +imgHQ20183.npy +imgHQ20839.npy +imgHQ12875.npy +imgHQ17716.npy +imgHQ21645.npy +imgHQ06335.npy +imgHQ29885.npy +imgHQ07912.npy +imgHQ21246.npy +imgHQ25879.npy +imgHQ28209.npy +imgHQ00246.npy +imgHQ12885.npy +imgHQ19787.npy +imgHQ29117.npy +imgHQ01190.npy +imgHQ20375.npy +imgHQ12496.npy +imgHQ09504.npy +imgHQ01744.npy +imgHQ07228.npy +imgHQ20146.npy +imgHQ09770.npy +imgHQ08654.npy +imgHQ18768.npy +imgHQ27650.npy +imgHQ22880.npy +imgHQ15670.npy +imgHQ00660.npy +imgHQ27414.npy +imgHQ21196.npy +imgHQ08094.npy +imgHQ15009.npy +imgHQ23479.npy +imgHQ09474.npy +imgHQ06037.npy +imgHQ17059.npy +imgHQ02441.npy +imgHQ00007.npy +imgHQ13658.npy +imgHQ16338.npy +imgHQ29201.npy +imgHQ03755.npy +imgHQ25853.npy +imgHQ06307.npy +imgHQ03608.npy +imgHQ14108.npy +imgHQ09040.npy +imgHQ05572.npy +imgHQ00315.npy +imgHQ03441.npy +imgHQ16272.npy +imgHQ03491.npy +imgHQ18084.npy +imgHQ17374.npy +imgHQ04307.npy +imgHQ23319.npy +imgHQ13418.npy +imgHQ04828.npy +imgHQ25996.npy +imgHQ22270.npy +imgHQ12703.npy +imgHQ11818.npy +imgHQ07469.npy +imgHQ28766.npy +imgHQ27203.npy +imgHQ07734.npy +imgHQ17938.npy +imgHQ12089.npy +imgHQ29941.npy +imgHQ18979.npy +imgHQ19763.npy +imgHQ02896.npy +imgHQ01622.npy +imgHQ18007.npy +imgHQ09476.npy +imgHQ18494.npy +imgHQ00080.npy +imgHQ20685.npy +imgHQ25043.npy +imgHQ15948.npy +imgHQ02894.npy +imgHQ27693.npy +imgHQ23525.npy +imgHQ07521.npy +imgHQ11921.npy +imgHQ13436.npy +imgHQ14809.npy +imgHQ17531.npy +imgHQ27705.npy +imgHQ19286.npy +imgHQ03216.npy +imgHQ21174.npy +imgHQ16684.npy +imgHQ28689.npy +imgHQ29884.npy +imgHQ05778.npy +imgHQ26011.npy +imgHQ00139.npy +imgHQ04930.npy +imgHQ13125.npy +imgHQ13369.npy +imgHQ07667.npy +imgHQ23572.npy +imgHQ23205.npy +imgHQ20037.npy +imgHQ11069.npy +imgHQ29180.npy +imgHQ01249.npy +imgHQ15875.npy +imgHQ06352.npy +imgHQ00930.npy +imgHQ28670.npy +imgHQ01764.npy +imgHQ13510.npy +imgHQ17215.npy +imgHQ13034.npy +imgHQ04268.npy +imgHQ13489.npy +imgHQ09012.npy +imgHQ20083.npy +imgHQ24287.npy +imgHQ28032.npy +imgHQ09116.npy +imgHQ02239.npy +imgHQ12589.npy +imgHQ20288.npy +imgHQ28602.npy +imgHQ00089.npy +imgHQ07437.npy +imgHQ06883.npy +imgHQ00564.npy +imgHQ29047.npy +imgHQ04576.npy +imgHQ19854.npy +imgHQ26172.npy +imgHQ20479.npy +imgHQ14475.npy +imgHQ03990.npy +imgHQ10117.npy +imgHQ23783.npy +imgHQ18313.npy +imgHQ17088.npy +imgHQ14758.npy +imgHQ25461.npy +imgHQ18682.npy +imgHQ09811.npy +imgHQ29575.npy +imgHQ05130.npy +imgHQ07448.npy +imgHQ24677.npy +imgHQ04232.npy +imgHQ02855.npy +imgHQ05070.npy +imgHQ18660.npy +imgHQ16533.npy +imgHQ21607.npy +imgHQ01589.npy +imgHQ04728.npy +imgHQ29346.npy +imgHQ03615.npy +imgHQ21148.npy +imgHQ25469.npy +imgHQ28955.npy +imgHQ05464.npy +imgHQ16341.npy +imgHQ15393.npy +imgHQ17307.npy +imgHQ10665.npy +imgHQ07496.npy +imgHQ29160.npy +imgHQ20859.npy +imgHQ10119.npy +imgHQ16811.npy +imgHQ00238.npy +imgHQ11666.npy +imgHQ22357.npy +imgHQ25137.npy +imgHQ26630.npy +imgHQ19340.npy +imgHQ27929.npy +imgHQ28505.npy +imgHQ10090.npy +imgHQ02968.npy +imgHQ01592.npy +imgHQ13244.npy +imgHQ13848.npy +imgHQ02422.npy +imgHQ12275.npy +imgHQ07449.npy +imgHQ29423.npy +imgHQ16472.npy +imgHQ06457.npy +imgHQ03481.npy +imgHQ06449.npy +imgHQ18466.npy +imgHQ16056.npy +imgHQ19618.npy +imgHQ25490.npy +imgHQ14411.npy +imgHQ01554.npy +imgHQ25190.npy +imgHQ29191.npy +imgHQ12699.npy +imgHQ26711.npy +imgHQ26095.npy +imgHQ07639.npy +imgHQ02306.npy +imgHQ17578.npy +imgHQ13009.npy +imgHQ14888.npy +imgHQ21420.npy +imgHQ12942.npy +imgHQ25475.npy +imgHQ27246.npy +imgHQ26882.npy +imgHQ27315.npy +imgHQ09301.npy +imgHQ20134.npy +imgHQ08292.npy +imgHQ14477.npy +imgHQ22987.npy +imgHQ24837.npy +imgHQ11434.npy +imgHQ01705.npy +imgHQ03898.npy +imgHQ12638.npy +imgHQ11866.npy +imgHQ09956.npy +imgHQ25751.npy +imgHQ02253.npy +imgHQ11243.npy +imgHQ21106.npy +imgHQ16478.npy +imgHQ23376.npy +imgHQ21447.npy +imgHQ19073.npy +imgHQ27135.npy +imgHQ16828.npy +imgHQ19089.npy +imgHQ27806.npy +imgHQ21401.npy +imgHQ21809.npy +imgHQ05738.npy +imgHQ08651.npy +imgHQ12243.npy +imgHQ08993.npy +imgHQ26444.npy +imgHQ23352.npy +imgHQ26413.npy +imgHQ00503.npy +imgHQ13283.npy +imgHQ28466.npy +imgHQ12635.npy +imgHQ02266.npy +imgHQ10691.npy +imgHQ08391.npy +imgHQ02617.npy +imgHQ05882.npy +imgHQ11323.npy +imgHQ02113.npy +imgHQ07853.npy +imgHQ23918.npy +imgHQ02090.npy +imgHQ17996.npy +imgHQ14820.npy +imgHQ29298.npy +imgHQ05352.npy +imgHQ21166.npy +imgHQ10232.npy +imgHQ10800.npy +imgHQ16359.npy +imgHQ06040.npy +imgHQ22077.npy +imgHQ20964.npy +imgHQ14503.npy +imgHQ28531.npy +imgHQ20750.npy +imgHQ21436.npy +imgHQ28378.npy +imgHQ23452.npy +imgHQ17076.npy +imgHQ01628.npy +imgHQ20945.npy +imgHQ00440.npy +imgHQ24604.npy +imgHQ22064.npy +imgHQ09860.npy +imgHQ20602.npy +imgHQ03361.npy +imgHQ15004.npy +imgHQ04787.npy +imgHQ03613.npy +imgHQ08733.npy +imgHQ20992.npy +imgHQ21600.npy +imgHQ09372.npy +imgHQ28359.npy +imgHQ13620.npy +imgHQ16323.npy +imgHQ26580.npy +imgHQ05192.npy +imgHQ07555.npy +imgHQ11070.npy +imgHQ17963.npy +imgHQ01856.npy +imgHQ15703.npy +imgHQ00151.npy +imgHQ04360.npy +imgHQ19697.npy +imgHQ03794.npy +imgHQ03321.npy +imgHQ11170.npy +imgHQ06506.npy +imgHQ09225.npy +imgHQ11649.npy +imgHQ19047.npy +imgHQ08956.npy +imgHQ26624.npy +imgHQ09692.npy +imgHQ11209.npy +imgHQ03534.npy +imgHQ19451.npy +imgHQ23053.npy +imgHQ07763.npy +imgHQ07526.npy +imgHQ02237.npy +imgHQ24950.npy +imgHQ19379.npy +imgHQ25641.npy +imgHQ08011.npy +imgHQ16243.npy +imgHQ02779.npy +imgHQ28706.npy +imgHQ28739.npy +imgHQ17550.npy +imgHQ17217.npy +imgHQ14392.npy +imgHQ17847.npy +imgHQ02746.npy +imgHQ12654.npy +imgHQ10984.npy +imgHQ23541.npy +imgHQ25216.npy +imgHQ00518.npy +imgHQ13498.npy +imgHQ05304.npy +imgHQ08693.npy +imgHQ05132.npy +imgHQ19613.npy +imgHQ02220.npy +imgHQ12325.npy +imgHQ19253.npy +imgHQ16523.npy +imgHQ03245.npy +imgHQ11986.npy +imgHQ26618.npy +imgHQ18500.npy +imgHQ16910.npy +imgHQ10655.npy +imgHQ09596.npy +imgHQ05929.npy +imgHQ28776.npy +imgHQ03625.npy +imgHQ11823.npy +imgHQ24884.npy +imgHQ15694.npy +imgHQ29850.npy +imgHQ24823.npy +imgHQ12456.npy +imgHQ01118.npy +imgHQ08650.npy +imgHQ05568.npy +imgHQ04156.npy +imgHQ23021.npy +imgHQ16257.npy +imgHQ22313.npy +imgHQ04443.npy +imgHQ29720.npy +imgHQ20345.npy +imgHQ09941.npy +imgHQ19164.npy +imgHQ20382.npy +imgHQ09714.npy +imgHQ29128.npy +imgHQ24541.npy +imgHQ25438.npy +imgHQ22593.npy +imgHQ26426.npy +imgHQ10942.npy +imgHQ00849.npy +imgHQ11605.npy +imgHQ26596.npy +imgHQ09310.npy +imgHQ13617.npy +imgHQ26319.npy +imgHQ14832.npy +imgHQ12419.npy +imgHQ29461.npy +imgHQ05601.npy +imgHQ28498.npy +imgHQ23438.npy +imgHQ25655.npy +imgHQ29604.npy +imgHQ25432.npy +imgHQ05922.npy +imgHQ04028.npy +imgHQ21923.npy +imgHQ27237.npy +imgHQ09316.npy +imgHQ00316.npy +imgHQ25799.npy +imgHQ03623.npy +imgHQ28633.npy +imgHQ03286.npy +imgHQ07252.npy +imgHQ08964.npy +imgHQ14922.npy +imgHQ00488.npy +imgHQ12301.npy +imgHQ06554.npy +imgHQ22083.npy +imgHQ27713.npy +imgHQ19657.npy +imgHQ08507.npy +imgHQ22490.npy +imgHQ22479.npy +imgHQ23473.npy +imgHQ00353.npy +imgHQ18459.npy +imgHQ14994.npy +imgHQ29812.npy +imgHQ26861.npy +imgHQ06310.npy +imgHQ05497.npy +imgHQ02323.npy +imgHQ07048.npy +imgHQ18381.npy +imgHQ00474.npy +imgHQ03037.npy +imgHQ07825.npy +imgHQ10169.npy +imgHQ12572.npy +imgHQ23659.npy +imgHQ19731.npy +imgHQ17565.npy +imgHQ16615.npy +imgHQ05370.npy +imgHQ12280.npy +imgHQ16633.npy +imgHQ01563.npy +imgHQ18066.npy +imgHQ08924.npy +imgHQ24864.npy +imgHQ23484.npy +imgHQ18050.npy +imgHQ00263.npy +imgHQ11379.npy +imgHQ05462.npy +imgHQ24397.npy +imgHQ12447.npy +imgHQ18382.npy +imgHQ22124.npy +imgHQ09701.npy +imgHQ01133.npy +imgHQ10360.npy +imgHQ27343.npy +imgHQ10958.npy +imgHQ25756.npy +imgHQ10806.npy +imgHQ00312.npy +imgHQ29625.npy +imgHQ04617.npy +imgHQ29557.npy +imgHQ12396.npy +imgHQ05373.npy +imgHQ22629.npy +imgHQ00764.npy +imgHQ13261.npy +imgHQ09272.npy +imgHQ26594.npy +imgHQ22710.npy +imgHQ20013.npy +imgHQ18206.npy +imgHQ00439.npy +imgHQ01977.npy +imgHQ00116.npy +imgHQ16010.npy +imgHQ27564.npy +imgHQ24906.npy +imgHQ20095.npy +imgHQ13751.npy +imgHQ09924.npy +imgHQ26892.npy +imgHQ10179.npy +imgHQ25067.npy +imgHQ23160.npy +imgHQ28203.npy +imgHQ13036.npy +imgHQ09260.npy +imgHQ07634.npy +imgHQ02389.npy +imgHQ02094.npy +imgHQ23069.npy +imgHQ01197.npy +imgHQ23161.npy +imgHQ12423.npy +imgHQ03317.npy +imgHQ03389.npy +imgHQ25854.npy +imgHQ10867.npy +imgHQ29066.npy +imgHQ03420.npy +imgHQ14653.npy +imgHQ16140.npy +imgHQ22826.npy +imgHQ07379.npy +imgHQ14633.npy +imgHQ21705.npy +imgHQ05313.npy +imgHQ19502.npy +imgHQ12346.npy +imgHQ15357.npy +imgHQ16312.npy +imgHQ10636.npy +imgHQ23963.npy +imgHQ08887.npy +imgHQ05979.npy +imgHQ28299.npy +imgHQ04971.npy +imgHQ07286.npy +imgHQ21954.npy +imgHQ08407.npy +imgHQ11545.npy +imgHQ23742.npy +imgHQ21578.npy +imgHQ29889.npy +imgHQ08228.npy +imgHQ17185.npy +imgHQ03957.npy +imgHQ08238.npy +imgHQ20340.npy +imgHQ09622.npy +imgHQ17281.npy +imgHQ06950.npy +imgHQ16362.npy +imgHQ02992.npy +imgHQ27848.npy +imgHQ17883.npy +imgHQ27196.npy +imgHQ00575.npy +imgHQ20897.npy +imgHQ23437.npy +imgHQ20774.npy +imgHQ26337.npy +imgHQ17341.npy +imgHQ18171.npy +imgHQ21389.npy +imgHQ16138.npy +imgHQ29979.npy +imgHQ03726.npy +imgHQ10772.npy +imgHQ29646.npy +imgHQ25264.npy +imgHQ25992.npy +imgHQ23073.npy +imgHQ06226.npy +imgHQ27627.npy +imgHQ10699.npy +imgHQ08307.npy +imgHQ11750.npy +imgHQ24943.npy +imgHQ06312.npy +imgHQ08913.npy +imgHQ04980.npy +imgHQ09252.npy +imgHQ07484.npy +imgHQ29725.npy +imgHQ01979.npy +imgHQ01682.npy +imgHQ26945.npy +imgHQ20786.npy +imgHQ16822.npy +imgHQ09655.npy +imgHQ08916.npy +imgHQ06238.npy +imgHQ21726.npy +imgHQ20489.npy +imgHQ09965.npy +imgHQ19406.npy +imgHQ13291.npy +imgHQ13298.npy +imgHQ29303.npy +imgHQ01034.npy +imgHQ28775.npy +imgHQ13385.npy +imgHQ06892.npy +imgHQ01461.npy +imgHQ05473.npy +imgHQ12523.npy +imgHQ06852.npy +imgHQ01723.npy +imgHQ23890.npy +imgHQ20270.npy +imgHQ12574.npy +imgHQ24560.npy +imgHQ14579.npy +imgHQ05338.npy +imgHQ00716.npy +imgHQ16127.npy +imgHQ07810.npy +imgHQ27724.npy +imgHQ29053.npy +imgHQ06115.npy +imgHQ05697.npy +imgHQ16903.npy +imgHQ13744.npy +imgHQ25493.npy +imgHQ29304.npy +imgHQ13516.npy +imgHQ26287.npy +imgHQ12440.npy +imgHQ20011.npy +imgHQ22291.npy +imgHQ12564.npy +imgHQ20820.npy +imgHQ06789.npy +imgHQ23575.npy +imgHQ25690.npy +imgHQ03860.npy +imgHQ23138.npy +imgHQ18527.npy +imgHQ22107.npy +imgHQ12883.npy +imgHQ07149.npy +imgHQ11216.npy +imgHQ04501.npy +imgHQ13813.npy +imgHQ27247.npy +imgHQ23299.npy +imgHQ21643.npy +imgHQ12345.npy +imgHQ14280.npy +imgHQ04992.npy +imgHQ15817.npy +imgHQ13600.npy +imgHQ02757.npy +imgHQ24510.npy +imgHQ10458.npy +imgHQ23100.npy +imgHQ06013.npy +imgHQ17757.npy +imgHQ09975.npy +imgHQ00173.npy +imgHQ21281.npy +imgHQ21459.npy +imgHQ28634.npy +imgHQ01159.npy +imgHQ23804.npy +imgHQ02977.npy +imgHQ00282.npy +imgHQ08051.npy +imgHQ00568.npy +imgHQ14919.npy +imgHQ06934.npy +imgHQ13082.npy +imgHQ05656.npy +imgHQ03161.npy +imgHQ10194.npy +imgHQ06805.npy +imgHQ24769.npy +imgHQ23322.npy +imgHQ10147.npy +imgHQ07407.npy +imgHQ02650.npy +imgHQ09725.npy +imgHQ10085.npy +imgHQ13230.npy +imgHQ28707.npy +imgHQ23870.npy +imgHQ15787.npy +imgHQ00993.npy +imgHQ19375.npy +imgHQ13150.npy +imgHQ06201.npy +imgHQ22074.npy +imgHQ06232.npy +imgHQ01142.npy +imgHQ08356.npy +imgHQ15996.npy +imgHQ05412.npy +imgHQ27424.npy +imgHQ29404.npy +imgHQ11717.npy +imgHQ24200.npy +imgHQ03944.npy +imgHQ23315.npy +imgHQ18783.npy +imgHQ01582.npy +imgHQ26466.npy +imgHQ24847.npy +imgHQ21414.npy +imgHQ10252.npy +imgHQ04321.npy +imgHQ29994.npy +imgHQ11745.npy +imgHQ29031.npy +imgHQ04238.npy +imgHQ10003.npy +imgHQ24320.npy +imgHQ22626.npy +imgHQ17561.npy +imgHQ22316.npy +imgHQ13147.npy +imgHQ10329.npy +imgHQ21985.npy +imgHQ25661.npy +imgHQ19361.npy +imgHQ26461.npy +imgHQ24089.npy +imgHQ15423.npy +imgHQ22796.npy +imgHQ26290.npy +imgHQ20871.npy +imgHQ22945.npy +imgHQ02178.npy +imgHQ07170.npy +imgHQ23671.npy +imgHQ25951.npy +imgHQ25683.npy +imgHQ13774.npy +imgHQ16540.npy +imgHQ15339.npy +imgHQ22622.npy +imgHQ29537.npy +imgHQ11272.npy +imgHQ09894.npy +imgHQ12758.npy +imgHQ17056.npy +imgHQ09799.npy +imgHQ05660.npy +imgHQ01489.npy +imgHQ24558.npy +imgHQ08445.npy +imgHQ06180.npy +imgHQ08392.npy +imgHQ24958.npy +imgHQ10992.npy +imgHQ29602.npy +imgHQ14339.npy +imgHQ10813.npy +imgHQ29613.npy +imgHQ18540.npy +imgHQ19044.npy +imgHQ09211.npy +imgHQ20908.npy +imgHQ03138.npy +imgHQ21076.npy +imgHQ00033.npy +imgHQ13076.npy +imgHQ08824.npy +imgHQ19415.npy +imgHQ06500.npy +imgHQ00202.npy +imgHQ00647.npy +imgHQ01982.npy +imgHQ12653.npy +imgHQ10102.npy +imgHQ06049.npy +imgHQ15260.npy +imgHQ07345.npy +imgHQ13148.npy +imgHQ28759.npy +imgHQ06015.npy +imgHQ02586.npy +imgHQ22208.npy +imgHQ23579.npy +imgHQ12853.npy +imgHQ22037.npy +imgHQ06402.npy +imgHQ28832.npy +imgHQ25052.npy +imgHQ23544.npy +imgHQ02521.npy +imgHQ01358.npy +imgHQ21182.npy +imgHQ24146.npy +imgHQ03626.npy +imgHQ14420.npy +imgHQ16286.npy +imgHQ05910.npy +imgHQ14980.npy +imgHQ04318.npy +imgHQ23146.npy +imgHQ19556.npy +imgHQ02595.npy +imgHQ13837.npy +imgHQ03354.npy +imgHQ27849.npy +imgHQ29265.npy +imgHQ01152.npy +imgHQ02848.npy +imgHQ21513.npy +imgHQ23271.npy +imgHQ09070.npy +imgHQ12747.npy +imgHQ23956.npy +imgHQ01694.npy +imgHQ22299.npy +imgHQ21243.npy +imgHQ11390.npy +imgHQ23821.npy +imgHQ28041.npy +imgHQ02206.npy +imgHQ15218.npy +imgHQ12146.npy +imgHQ08732.npy +imgHQ12939.npy +imgHQ00972.npy +imgHQ24074.npy +imgHQ29636.npy +imgHQ22430.npy +imgHQ21970.npy +imgHQ28952.npy +imgHQ23175.npy +imgHQ00119.npy +imgHQ09418.npy +imgHQ20682.npy +imgHQ07431.npy +imgHQ29705.npy +imgHQ20643.npy +imgHQ04879.npy +imgHQ16024.npy +imgHQ04962.npy +imgHQ13824.npy +imgHQ00971.npy +imgHQ26298.npy +imgHQ05084.npy +imgHQ27581.npy +imgHQ13767.npy +imgHQ00917.npy +imgHQ09511.npy +imgHQ18414.npy +imgHQ05675.npy +imgHQ23805.npy +imgHQ21198.npy +imgHQ23042.npy +imgHQ05259.npy +imgHQ15602.npy +imgHQ08204.npy +imgHQ13775.npy +imgHQ06489.npy +imgHQ11318.npy +imgHQ03066.npy +imgHQ00825.npy +imgHQ17819.npy +imgHQ14213.npy +imgHQ09567.npy +imgHQ08284.npy +imgHQ09433.npy +imgHQ20967.npy +imgHQ06820.npy +imgHQ06597.npy +imgHQ00165.npy +imgHQ22832.npy +imgHQ13455.npy +imgHQ06698.npy +imgHQ09546.npy +imgHQ27956.npy +imgHQ00458.npy +imgHQ23400.npy +imgHQ29898.npy +imgHQ10341.npy +imgHQ24832.npy +imgHQ05985.npy +imgHQ01650.npy +imgHQ03442.npy +imgHQ29409.npy +imgHQ13262.npy +imgHQ04762.npy +imgHQ06690.npy +imgHQ13414.npy +imgHQ19638.npy +imgHQ14239.npy +imgHQ21504.npy +imgHQ03115.npy +imgHQ27463.npy +imgHQ18988.npy +imgHQ09201.npy +imgHQ28422.npy +imgHQ07297.npy +imgHQ05400.npy +imgHQ00563.npy +imgHQ07957.npy +imgHQ00774.npy +imgHQ28240.npy +imgHQ05346.npy +imgHQ02683.npy +imgHQ00504.npy +imgHQ18701.npy +imgHQ17446.npy +imgHQ02203.npy +imgHQ14306.npy +imgHQ13214.npy +imgHQ14471.npy +imgHQ02644.npy +imgHQ00715.npy +imgHQ05285.npy +imgHQ23724.npy +imgHQ09164.npy +imgHQ04176.npy +imgHQ13823.npy +imgHQ07589.npy +imgHQ06065.npy +imgHQ02948.npy +imgHQ25761.npy +imgHQ20101.npy +imgHQ18884.npy +imgHQ11800.npy +imgHQ10239.npy +imgHQ20283.npy +imgHQ06165.npy +imgHQ26935.npy +imgHQ21341.npy +imgHQ01567.npy +imgHQ13111.npy +imgHQ28388.npy +imgHQ13582.npy +imgHQ07661.npy +imgHQ02228.npy +imgHQ08549.npy +imgHQ14638.npy +imgHQ28066.npy +imgHQ06157.npy +imgHQ22982.npy +imgHQ09839.npy +imgHQ21960.npy +imgHQ03256.npy +imgHQ12384.npy +imgHQ14231.npy +imgHQ09349.npy +imgHQ29175.npy +imgHQ20642.npy +imgHQ17997.npy +imgHQ00044.npy +imgHQ00370.npy +imgHQ06534.npy +imgHQ13502.npy +imgHQ26919.npy +imgHQ10965.npy +imgHQ02964.npy +imgHQ18723.npy +imgHQ00669.npy +imgHQ08579.npy +imgHQ05311.npy +imgHQ23475.npy +imgHQ29334.npy +imgHQ27312.npy +imgHQ16524.npy +imgHQ09412.npy +imgHQ01103.npy +imgHQ00903.npy +imgHQ17408.npy +imgHQ08256.npy +imgHQ15702.npy +imgHQ07518.npy +imgHQ02428.npy +imgHQ15938.npy +imgHQ20948.npy +imgHQ03437.npy +imgHQ21471.npy +imgHQ07412.npy +imgHQ22910.npy +imgHQ23972.npy +imgHQ13474.npy +imgHQ22508.npy +imgHQ04182.npy +imgHQ28714.npy +imgHQ03467.npy +imgHQ05558.npy +imgHQ22415.npy +imgHQ06349.npy +imgHQ10250.npy +imgHQ16275.npy +imgHQ06640.npy +imgHQ15818.npy +imgHQ14723.npy +imgHQ12575.npy +imgHQ09693.npy +imgHQ19858.npy +imgHQ22041.npy +imgHQ16843.npy +imgHQ22789.npy +imgHQ02686.npy +imgHQ12009.npy +imgHQ27712.npy +imgHQ24561.npy +imgHQ19129.npy +imgHQ08441.npy +imgHQ13140.npy +imgHQ02106.npy +imgHQ13144.npy +imgHQ26895.npy +imgHQ16757.npy +imgHQ02230.npy +imgHQ23306.npy +imgHQ04479.npy +imgHQ16114.npy +imgHQ11134.npy +imgHQ15926.npy +imgHQ25973.npy +imgHQ26957.npy +imgHQ17761.npy +imgHQ16531.npy +imgHQ25421.npy +imgHQ27063.npy +imgHQ04131.npy +imgHQ19162.npy +imgHQ22008.npy +imgHQ22753.npy +imgHQ17095.npy +imgHQ13220.npy +imgHQ05452.npy +imgHQ23670.npy +imgHQ29661.npy +imgHQ13691.npy +imgHQ26761.npy +imgHQ00997.npy +imgHQ24164.npy +imgHQ03933.npy +imgHQ23135.npy +imgHQ05230.npy +imgHQ09486.npy +imgHQ21171.npy +imgHQ03862.npy +imgHQ13962.npy +imgHQ16103.npy +imgHQ21958.npy +imgHQ19313.npy +imgHQ01162.npy +imgHQ24825.npy +imgHQ12389.npy +imgHQ13353.npy +imgHQ28430.npy +imgHQ06922.npy +imgHQ19050.npy +imgHQ06854.npy +imgHQ03806.npy +imgHQ04081.npy +imgHQ19347.npy +imgHQ04425.npy +imgHQ27928.npy +imgHQ23842.npy +imgHQ06016.npy +imgHQ22749.npy +imgHQ11908.npy +imgHQ09229.npy +imgHQ05542.npy +imgHQ26109.npy +imgHQ10187.npy +imgHQ07078.npy +imgHQ27889.npy +imgHQ22717.npy +imgHQ06616.npy +imgHQ13407.npy +imgHQ28261.npy +imgHQ10328.npy +imgHQ14496.npy +imgHQ18633.npy +imgHQ13618.npy +imgHQ09029.npy +imgHQ25958.npy +imgHQ15933.npy +imgHQ11096.npy +imgHQ13210.npy +imgHQ15407.npy +imgHQ08633.npy +imgHQ11253.npy +imgHQ13561.npy +imgHQ27069.npy +imgHQ04384.npy +imgHQ15785.npy +imgHQ01008.npy +imgHQ22722.npy +imgHQ09918.npy +imgHQ08490.npy +imgHQ12639.npy +imgHQ19561.npy +imgHQ12029.npy +imgHQ12385.npy +imgHQ18875.npy +imgHQ08111.npy +imgHQ27002.npy +imgHQ06925.npy +imgHQ03088.npy +imgHQ21210.npy +imgHQ08128.npy +imgHQ12525.npy +imgHQ11398.npy +imgHQ21801.npy +imgHQ02693.npy +imgHQ03160.npy +imgHQ13312.npy +imgHQ13971.npy +imgHQ00708.npy +imgHQ01539.npy +imgHQ06653.npy +imgHQ00473.npy +imgHQ03237.npy +imgHQ00136.npy +imgHQ12106.npy +imgHQ17204.npy +imgHQ00336.npy +imgHQ17259.npy +imgHQ26793.npy +imgHQ27085.npy +imgHQ08134.npy +imgHQ04796.npy +imgHQ21557.npy +imgHQ04813.npy +imgHQ01986.npy +imgHQ06152.npy +imgHQ05215.npy +imgHQ15290.npy +imgHQ01011.npy +imgHQ07894.npy +imgHQ24528.npy +imgHQ24554.npy +imgHQ22681.npy +imgHQ01349.npy +imgHQ07840.npy +imgHQ11200.npy +imgHQ24798.npy +imgHQ08396.npy +imgHQ02182.npy +imgHQ05076.npy +imgHQ02152.npy +imgHQ14194.npy +imgHQ09034.npy +imgHQ06273.npy +imgHQ17647.npy +imgHQ29489.npy +imgHQ14308.npy +imgHQ10934.npy +imgHQ08692.npy +imgHQ05419.npy +imgHQ13496.npy +imgHQ26322.npy +imgHQ23877.npy +imgHQ02371.npy +imgHQ07906.npy +imgHQ21782.npy +imgHQ08264.npy +imgHQ15910.npy +imgHQ04783.npy +imgHQ20326.npy +imgHQ11346.npy +imgHQ21873.npy +imgHQ21753.npy +imgHQ25048.npy +imgHQ00100.npy +imgHQ26959.npy +imgHQ12242.npy +imgHQ07941.npy +imgHQ23577.npy +imgHQ28244.npy +imgHQ08246.npy +imgHQ29707.npy +imgHQ01581.npy +imgHQ22491.npy +imgHQ15133.npy +imgHQ29354.npy +imgHQ09331.npy +imgHQ15273.npy +imgHQ23962.npy +imgHQ21176.npy +imgHQ08124.npy +imgHQ14404.npy +imgHQ14265.npy +imgHQ26656.npy +imgHQ16287.npy +imgHQ17465.npy +imgHQ28544.npy +imgHQ28395.npy +imgHQ18386.npy +imgHQ27234.npy +imgHQ04753.npy +imgHQ21623.npy +imgHQ24897.npy +imgHQ26005.npy +imgHQ12291.npy +imgHQ24213.npy +imgHQ26359.npy +imgHQ08835.npy +imgHQ07719.npy +imgHQ26893.npy +imgHQ00073.npy +imgHQ26655.npy +imgHQ07666.npy +imgHQ08038.npy +imgHQ16576.npy +imgHQ07334.npy +imgHQ19233.npy +imgHQ08691.npy +imgHQ23551.npy +imgHQ23955.npy +imgHQ02625.npy +imgHQ20593.npy +imgHQ05577.npy +imgHQ16430.npy +imgHQ22403.npy +imgHQ15816.npy +imgHQ14540.npy +imgHQ16337.npy +imgHQ24333.npy +imgHQ07380.npy +imgHQ29004.npy +imgHQ14249.npy +imgHQ05186.npy +imgHQ18907.npy +imgHQ08515.npy +imgHQ25627.npy +imgHQ25721.npy +imgHQ02450.npy +imgHQ24978.npy +imgHQ27586.npy +imgHQ19872.npy +imgHQ15341.npy +imgHQ09364.npy +imgHQ11205.npy +imgHQ17280.npy +imgHQ00909.npy +imgHQ03574.npy +imgHQ13164.npy +imgHQ16676.npy +imgHQ25202.npy +imgHQ09262.npy +imgHQ20957.npy +imgHQ09682.npy +imgHQ18444.npy +imgHQ05574.npy +imgHQ07722.npy +imgHQ04271.npy +imgHQ00933.npy +imgHQ29051.npy +imgHQ21329.npy +imgHQ01708.npy +imgHQ13745.npy +imgHQ18095.npy +imgHQ01306.npy +imgHQ08505.npy +imgHQ26800.npy +imgHQ14070.npy +imgHQ15648.npy +imgHQ26480.npy +imgHQ28984.npy +imgHQ16501.npy +imgHQ21712.npy +imgHQ12376.npy +imgHQ24452.npy +imgHQ04272.npy +imgHQ11055.npy +imgHQ16733.npy +imgHQ19528.npy +imgHQ03184.npy +imgHQ29806.npy +imgHQ15919.npy +imgHQ07593.npy +imgHQ24339.npy +imgHQ24344.npy +imgHQ01893.npy +imgHQ27686.npy +imgHQ24779.npy +imgHQ16618.npy +imgHQ16527.npy +imgHQ01010.npy +imgHQ27979.npy +imgHQ23040.npy +imgHQ13299.npy +imgHQ24042.npy +imgHQ20580.npy +imgHQ19868.npy +imgHQ04719.npy +imgHQ24247.npy +imgHQ14399.npy +imgHQ06284.npy +imgHQ17622.npy +imgHQ10398.npy +imgHQ17278.npy +imgHQ10502.npy +imgHQ25252.npy +imgHQ14802.npy +imgHQ24927.npy +imgHQ07415.npy +imgHQ21845.npy +imgHQ01343.npy +imgHQ21266.npy +imgHQ03279.npy +imgHQ27936.npy +imgHQ10485.npy +imgHQ26737.npy +imgHQ26265.npy +imgHQ15400.npy +imgHQ20396.npy +imgHQ02188.npy +imgHQ15554.npy +imgHQ21397.npy +imgHQ09326.npy +imgHQ29007.npy +imgHQ13511.npy +imgHQ27207.npy +imgHQ12830.npy +imgHQ16798.npy +imgHQ25504.npy +imgHQ16744.npy +imgHQ19391.npy +imgHQ00438.npy +imgHQ26869.npy +imgHQ15420.npy +imgHQ21516.npy +imgHQ08621.npy +imgHQ16363.npy +imgHQ03039.npy +imgHQ14482.npy +imgHQ08042.npy +imgHQ01293.npy +imgHQ23538.npy +imgHQ18654.npy +imgHQ23800.npy +imgHQ04430.npy +imgHQ20475.npy +imgHQ14001.npy +imgHQ25247.npy +imgHQ12877.npy +imgHQ25489.npy +imgHQ23941.npy +imgHQ12893.npy +imgHQ12375.npy +imgHQ23212.npy +imgHQ14737.npy +imgHQ02707.npy +imgHQ13218.npy +imgHQ24658.npy +imgHQ00199.npy +imgHQ00345.npy +imgHQ00946.npy +imgHQ14698.npy +imgHQ01402.npy +imgHQ01428.npy +imgHQ02628.npy +imgHQ17269.npy +imgHQ23176.npy +imgHQ28583.npy +imgHQ04667.npy +imgHQ13724.npy +imgHQ15854.npy +imgHQ11177.npy +imgHQ18029.npy +imgHQ08144.npy +imgHQ27317.npy +imgHQ11195.npy +imgHQ21292.npy +imgHQ20131.npy +imgHQ07319.npy +imgHQ17894.npy +imgHQ15752.npy +imgHQ00604.npy +imgHQ28457.npy +imgHQ18118.npy +imgHQ09863.npy +imgHQ21194.npy +imgHQ11930.npy +imgHQ27704.npy +imgHQ24680.npy +imgHQ28536.npy +imgHQ24025.npy +imgHQ22067.npy +imgHQ23415.npy +imgHQ17930.npy +imgHQ22391.npy +imgHQ07451.npy +imgHQ00649.npy +imgHQ18005.npy +imgHQ00114.npy +imgHQ18097.npy +imgHQ03553.npy +imgHQ07643.npy +imgHQ17753.npy +imgHQ25337.npy +imgHQ02198.npy +imgHQ07803.npy +imgHQ07358.npy +imgHQ24229.npy +imgHQ06930.npy +imgHQ11270.npy +imgHQ22483.npy +imgHQ14294.npy +imgHQ01294.npy +imgHQ28736.npy +imgHQ03641.npy +imgHQ13090.npy +imgHQ02857.npy +imgHQ23846.npy +imgHQ14378.npy +imgHQ11598.npy +imgHQ11803.npy +imgHQ05900.npy +imgHQ16318.npy +imgHQ13952.npy +imgHQ02702.npy +imgHQ00690.npy +imgHQ21687.npy +imgHQ08858.npy +imgHQ06410.npy +imgHQ23550.npy +imgHQ12712.npy +imgHQ22432.npy +imgHQ23784.npy +imgHQ13532.npy +imgHQ05306.npy +imgHQ08063.npy +imgHQ20760.npy +imgHQ24705.npy +imgHQ20124.npy +imgHQ09351.npy +imgHQ11638.npy +imgHQ11931.npy +imgHQ08432.npy +imgHQ01963.npy +imgHQ24597.npy +imgHQ00383.npy +imgHQ19564.npy +imgHQ08087.npy +imgHQ29695.npy +imgHQ13628.npy +imgHQ09735.npy +imgHQ08214.npy +imgHQ29672.npy +imgHQ17329.npy +imgHQ14013.npy +imgHQ27106.npy +imgHQ28201.npy +imgHQ03519.npy +imgHQ09741.npy +imgHQ07020.npy +imgHQ17911.npy +imgHQ13311.npy +imgHQ28920.npy +imgHQ21903.npy +imgHQ20995.npy +imgHQ18454.npy +imgHQ10979.npy +imgHQ24572.npy +imgHQ00981.npy +imgHQ15558.npy +imgHQ24405.npy +imgHQ25257.npy +imgHQ29904.npy +imgHQ02660.npy +imgHQ11507.npy +imgHQ17923.npy +imgHQ04717.npy +imgHQ13841.npy +imgHQ22563.npy +imgHQ26176.npy +imgHQ05640.npy +imgHQ28728.npy +imgHQ20224.npy +imgHQ18244.npy +imgHQ03927.npy +imgHQ10778.npy +imgHQ03054.npy +imgHQ09110.npy +imgHQ08707.npy +imgHQ25245.npy +imgHQ01206.npy +imgHQ29052.npy +imgHQ12614.npy +imgHQ13987.npy +imgHQ26258.npy +imgHQ25526.npy +imgHQ00923.npy +imgHQ14067.npy +imgHQ15786.npy +imgHQ14688.npy +imgHQ02556.npy +imgHQ13501.npy +imgHQ13012.npy +imgHQ17141.npy +imgHQ19917.npy +imgHQ21147.npy +imgHQ25788.npy +imgHQ11700.npy +imgHQ17796.npy +imgHQ06966.npy +imgHQ23960.npy +imgHQ16042.npy +imgHQ26019.npy +imgHQ12171.npy +imgHQ09739.npy +imgHQ12238.npy +imgHQ27172.npy +imgHQ13833.npy +imgHQ29168.npy +imgHQ21045.npy +imgHQ19946.npy +imgHQ16868.npy +imgHQ11662.npy +imgHQ27771.npy +imgHQ06462.npy +imgHQ05588.npy +imgHQ01569.npy +imgHQ05318.npy +imgHQ09807.npy +imgHQ05016.npy +imgHQ13602.npy +imgHQ06727.npy +imgHQ22289.npy +imgHQ19557.npy +imgHQ13123.npy +imgHQ14899.npy +imgHQ01224.npy +imgHQ16117.npy +imgHQ19782.npy +imgHQ05596.npy +imgHQ25559.npy +imgHQ19084.npy +imgHQ20445.npy +imgHQ13777.npy +imgHQ04196.npy +imgHQ04572.npy +imgHQ20937.npy +imgHQ08563.npy +imgHQ23945.npy +imgHQ18432.npy +imgHQ27793.npy +imgHQ24302.npy +imgHQ15340.npy +imgHQ12602.npy +imgHQ20225.npy +imgHQ20504.npy +imgHQ09755.npy +imgHQ09720.npy +imgHQ00373.npy +imgHQ09121.npy +imgHQ19927.npy +imgHQ02108.npy +imgHQ09067.npy +imgHQ03704.npy +imgHQ27268.npy +imgHQ12188.npy +imgHQ09522.npy +imgHQ01335.npy +imgHQ06288.npy +imgHQ24221.npy +imgHQ10781.npy +imgHQ00799.npy +imgHQ09155.npy +imgHQ29405.npy +imgHQ12348.npy +imgHQ21367.npy +imgHQ06098.npy +imgHQ04123.npy +imgHQ18344.npy +imgHQ08731.npy +imgHQ01676.npy +imgHQ06585.npy +imgHQ14838.npy +imgHQ27570.npy +imgHQ28423.npy +imgHQ12053.npy +imgHQ25304.npy +imgHQ25867.npy +imgHQ07711.npy +imgHQ05803.npy +imgHQ26129.npy +imgHQ15074.npy +imgHQ17223.npy +imgHQ29130.npy +imgHQ15849.npy +imgHQ07577.npy +imgHQ16254.npy +imgHQ04001.npy +imgHQ19988.npy +imgHQ25588.npy +imgHQ21556.npy +imgHQ01724.npy +imgHQ26403.npy +imgHQ09269.npy +imgHQ28393.npy +imgHQ14454.npy +imgHQ09275.npy +imgHQ09981.npy +imgHQ25507.npy +imgHQ17436.npy +imgHQ11413.npy +imgHQ00587.npy +imgHQ15841.npy +imgHQ05895.npy +imgHQ06106.npy +imgHQ14962.npy +imgHQ04830.npy +imgHQ07088.npy +imgHQ24581.npy +imgHQ25079.npy +imgHQ16201.npy +imgHQ04940.npy +imgHQ07532.npy +imgHQ11501.npy +imgHQ20257.npy +imgHQ27728.npy +imgHQ13589.npy +imgHQ09194.npy +imgHQ25814.npy +imgHQ27342.npy +imgHQ08007.npy +imgHQ02760.npy +imgHQ02312.npy +imgHQ06754.npy +imgHQ15544.npy +imgHQ21353.npy +imgHQ22917.npy +imgHQ04586.npy +imgHQ13129.npy +imgHQ26591.npy +imgHQ16413.npy +imgHQ11386.npy +imgHQ29415.npy +imgHQ16781.npy +imgHQ01562.npy +imgHQ00611.npy +imgHQ03784.npy +imgHQ00733.npy +imgHQ22236.npy +imgHQ28919.npy +imgHQ02233.npy +imgHQ21385.npy +imgHQ12039.npy +imgHQ27722.npy +imgHQ29620.npy +imgHQ22359.npy +imgHQ04771.npy +imgHQ19378.npy +imgHQ19644.npy +imgHQ06289.npy +imgHQ17643.npy +imgHQ28190.npy +imgHQ02207.npy +imgHQ04279.npy +imgHQ07290.npy +imgHQ08043.npy +imgHQ04712.npy +imgHQ06112.npy +imgHQ02567.npy +imgHQ12515.npy +imgHQ15942.npy +imgHQ28771.npy +imgHQ02912.npy +imgHQ13529.npy +imgHQ26823.npy +imgHQ06138.npy +imgHQ16399.npy +imgHQ08783.npy +imgHQ02844.npy +imgHQ13994.npy +imgHQ14701.npy +imgHQ09640.npy +imgHQ12964.npy +imgHQ12131.npy +imgHQ10233.npy +imgHQ16071.npy +imgHQ17902.npy +imgHQ04730.npy +imgHQ19798.npy +imgHQ03738.npy +imgHQ18643.npy +imgHQ19465.npy +imgHQ04846.npy +imgHQ17866.npy +imgHQ08984.npy +imgHQ29108.npy +imgHQ12256.npy +imgHQ05367.npy +imgHQ18970.npy +imgHQ13475.npy +imgHQ03391.npy +imgHQ11103.npy +imgHQ17466.npy +imgHQ03981.npy +imgHQ15647.npy +imgHQ01384.npy +imgHQ05150.npy +imgHQ22575.npy +imgHQ26218.npy +imgHQ04715.npy +imgHQ25990.npy +imgHQ27051.npy +imgHQ23367.npy +imgHQ26719.npy +imgHQ15266.npy +imgHQ21400.npy +imgHQ23294.npy +imgHQ12899.npy +imgHQ17155.npy +imgHQ17897.npy +imgHQ20751.npy +imgHQ23179.npy +imgHQ02401.npy +imgHQ13957.npy +imgHQ27714.npy +imgHQ01263.npy +imgHQ20944.npy +imgHQ17976.npy +imgHQ04142.npy +imgHQ29493.npy +imgHQ13515.npy +imgHQ23867.npy +imgHQ03649.npy +imgHQ17785.npy +imgHQ06973.npy +imgHQ04379.npy +imgHQ08891.npy +imgHQ16074.npy +imgHQ27270.npy +imgHQ21616.npy +imgHQ14923.npy +imgHQ11285.npy +imgHQ19664.npy +imgHQ02409.npy +imgHQ01046.npy +imgHQ01957.npy +imgHQ28610.npy +imgHQ24997.npy +imgHQ28527.npy +imgHQ20244.npy +imgHQ06431.npy +imgHQ28063.npy +imgHQ28353.npy +imgHQ17163.npy +imgHQ20867.npy +imgHQ22828.npy +imgHQ01863.npy +imgHQ20614.npy +imgHQ26688.npy +imgHQ24836.npy +imgHQ21723.npy +imgHQ03372.npy +imgHQ25128.npy +imgHQ23569.npy +imgHQ05514.npy +imgHQ18207.npy +imgHQ01002.npy +imgHQ18793.npy +imgHQ23745.npy +imgHQ01441.npy +imgHQ16315.npy +imgHQ02205.npy +imgHQ00063.npy +imgHQ05554.npy +imgHQ24090.npy +imgHQ06708.npy +imgHQ06779.npy +imgHQ25798.npy +imgHQ24915.npy +imgHQ19816.npy +imgHQ23200.npy +imgHQ09466.npy +imgHQ08245.npy +imgHQ19619.npy +imgHQ14429.npy +imgHQ05119.npy +imgHQ21927.npy +imgHQ01906.npy +imgHQ05621.npy +imgHQ23512.npy +imgHQ16542.npy +imgHQ20205.npy +imgHQ02718.npy +imgHQ07067.npy +imgHQ02892.npy +imgHQ03333.npy +imgHQ16123.npy +imgHQ16107.npy +imgHQ00949.npy +imgHQ29169.npy +imgHQ18742.npy +imgHQ16504.npy +imgHQ24201.npy +imgHQ02195.npy +imgHQ08878.npy +imgHQ29069.npy +imgHQ25057.npy +imgHQ20485.npy +imgHQ21145.npy +imgHQ09545.npy +imgHQ02679.npy +imgHQ14689.npy +imgHQ28482.npy +imgHQ09030.npy +imgHQ04839.npy +imgHQ02020.npy +imgHQ00737.npy +imgHQ11352.npy +imgHQ12988.npy +imgHQ08114.npy +imgHQ22365.npy +imgHQ12975.npy +imgHQ25995.npy +imgHQ08263.npy +imgHQ13249.npy +imgHQ24696.npy +imgHQ05566.npy +imgHQ06075.npy +imgHQ12052.npy +imgHQ03071.npy +imgHQ16346.npy +imgHQ20696.npy +imgHQ29388.npy +imgHQ20419.npy +imgHQ13508.npy +imgHQ14710.npy +imgHQ19975.npy +imgHQ20286.npy +imgHQ14032.npy +imgHQ29368.npy +imgHQ21452.npy +imgHQ02687.npy +imgHQ21017.npy +imgHQ26636.npy +imgHQ06999.npy +imgHQ12246.npy +imgHQ13108.npy +imgHQ03603.npy +imgHQ23382.npy +imgHQ11687.npy +imgHQ18833.npy +imgHQ18064.npy +imgHQ15280.npy +imgHQ25681.npy +imgHQ02653.npy +imgHQ13323.npy +imgHQ11834.npy +imgHQ05556.npy +imgHQ18369.npy +imgHQ09216.npy +imgHQ08302.npy +imgHQ06374.npy +imgHQ26758.npy +imgHQ03552.npy +imgHQ22104.npy +imgHQ12178.npy +imgHQ18303.npy +imgHQ29778.npy +imgHQ07054.npy +imgHQ27860.npy +imgHQ25711.npy +imgHQ10798.npy +imgHQ25847.npy +imgHQ17960.npy +imgHQ09176.npy +imgHQ20277.npy +imgHQ19056.npy +imgHQ26564.npy +imgHQ17305.npy +imgHQ09792.npy +imgHQ15019.npy +imgHQ05204.npy +imgHQ17802.npy +imgHQ20848.npy +imgHQ13342.npy +imgHQ16727.npy +imgHQ24794.npy +imgHQ15744.npy +imgHQ20441.npy +imgHQ10974.npy +imgHQ21242.npy +imgHQ06443.npy +imgHQ27143.npy +imgHQ14066.npy +imgHQ20927.npy +imgHQ03078.npy +imgHQ16900.npy +imgHQ13773.npy +imgHQ21209.npy +imgHQ20806.npy +imgHQ23122.npy +imgHQ17317.npy +imgHQ19939.npy +imgHQ12337.npy +imgHQ21697.npy +imgHQ11579.npy +imgHQ08631.npy +imgHQ09322.npy +imgHQ10313.npy +imgHQ18009.npy +imgHQ28242.npy +imgHQ19231.npy +imgHQ01416.npy +imgHQ08568.npy +imgHQ25184.npy +imgHQ01075.npy +imgHQ27631.npy +imgHQ00703.npy +imgHQ11828.npy +imgHQ22673.npy +imgHQ14189.npy +imgHQ24046.npy +imgHQ21362.npy +imgHQ12793.npy +imgHQ04406.npy +imgHQ13030.npy +imgHQ09493.npy +imgHQ04276.npy +imgHQ16812.npy +imgHQ16649.npy +imgHQ10050.npy +imgHQ27702.npy +imgHQ05128.npy +imgHQ18843.npy +imgHQ29534.npy +imgHQ01247.npy +imgHQ21090.npy +imgHQ06222.npy +imgHQ21695.npy +imgHQ00721.npy +imgHQ21730.npy +imgHQ01480.npy +imgHQ22777.npy +imgHQ12580.npy +imgHQ03725.npy +imgHQ01216.npy +imgHQ17075.npy +imgHQ13689.npy +imgHQ15488.npy +imgHQ07045.npy +imgHQ01681.npy +imgHQ16109.npy +imgHQ23686.npy +imgHQ26070.npy +imgHQ19427.npy +imgHQ05836.npy +imgHQ28134.npy +imgHQ18256.npy +imgHQ06683.npy +imgHQ26538.npy +imgHQ12685.npy +imgHQ14238.npy +imgHQ08026.npy +imgHQ16813.npy +imgHQ00148.npy +imgHQ09554.npy +imgHQ21103.npy +imgHQ04450.npy +imgHQ15166.npy +imgHQ06809.npy +imgHQ02863.npy +imgHQ24940.npy +imgHQ01471.npy +imgHQ19181.npy +imgHQ25390.npy +imgHQ22677.npy +imgHQ20713.npy +imgHQ15397.npy +imgHQ20543.npy +imgHQ22806.npy +imgHQ06219.npy +imgHQ09297.npy +imgHQ15064.npy +imgHQ00155.npy +imgHQ19357.npy +imgHQ03446.npy +imgHQ07096.npy +imgHQ24179.npy +imgHQ15094.npy +imgHQ25260.npy +imgHQ03435.npy +imgHQ04452.npy +imgHQ16729.npy +imgHQ09712.npy +imgHQ07373.npy +imgHQ12267.npy +imgHQ09976.npy +imgHQ12547.npy +imgHQ16526.npy +imgHQ23835.npy +imgHQ15295.npy +imgHQ24086.npy +imgHQ18152.npy +imgHQ04519.npy +imgHQ14065.npy +imgHQ05116.npy +imgHQ12062.npy +imgHQ15674.npy +imgHQ28144.npy +imgHQ07270.npy +imgHQ16133.npy +imgHQ28489.npy +imgHQ05684.npy +imgHQ09745.npy +imgHQ24110.npy +imgHQ13371.npy +imgHQ23824.npy +imgHQ15526.npy +imgHQ27415.npy +imgHQ10494.npy +imgHQ23500.npy +imgHQ11555.npy +imgHQ19352.npy +imgHQ26312.npy +imgHQ23806.npy +imgHQ29546.npy +imgHQ02902.npy +imgHQ14617.npy +imgHQ24518.npy +imgHQ19905.npy +imgHQ04253.npy +imgHQ27099.npy +imgHQ17149.npy +imgHQ20118.npy +imgHQ08541.npy +imgHQ29883.npy +imgHQ08804.npy +imgHQ26471.npy +imgHQ13873.npy +imgHQ19601.npy +imgHQ12961.npy +imgHQ01626.npy +imgHQ28540.npy +imgHQ17272.npy +imgHQ04125.npy +imgHQ26190.npy +imgHQ10874.npy +imgHQ08045.npy +imgHQ08300.npy +imgHQ18549.npy +imgHQ12794.npy +imgHQ17008.npy +imgHQ29866.npy +imgHQ14530.npy +imgHQ08002.npy +imgHQ16687.npy +imgHQ23616.npy +imgHQ21394.npy +imgHQ21635.npy +imgHQ05164.npy +imgHQ01442.npy +imgHQ05736.npy +imgHQ11926.npy +imgHQ24255.npy +imgHQ27089.npy +imgHQ20715.npy +imgHQ22765.npy +imgHQ18213.npy +imgHQ04927.npy +imgHQ16096.npy +imgHQ22061.npy +imgHQ11018.npy +imgHQ25467.npy +imgHQ19018.npy +imgHQ27691.npy +imgHQ21258.npy +imgHQ11305.npy +imgHQ23917.npy +imgHQ08712.npy +imgHQ13591.npy +imgHQ11447.npy +imgHQ18016.npy +imgHQ11786.npy +imgHQ14574.npy +imgHQ25789.npy +imgHQ24467.npy +imgHQ13167.npy +imgHQ14950.npy +imgHQ09244.npy +imgHQ07665.npy +imgHQ03287.npy +imgHQ01175.npy +imgHQ19602.npy +imgHQ20646.npy +imgHQ18959.npy +imgHQ13991.npy +imgHQ19280.npy +imgHQ27616.npy +imgHQ04302.npy +imgHQ26143.npy +imgHQ05471.npy +imgHQ15733.npy +imgHQ29367.npy +imgHQ26907.npy +imgHQ12431.npy +imgHQ23723.npy +imgHQ20721.npy +imgHQ27529.npy +imgHQ22572.npy +imgHQ17724.npy +imgHQ16899.npy +imgHQ10886.npy +imgHQ26384.npy +imgHQ04495.npy +imgHQ05286.npy +imgHQ13179.npy +imgHQ07427.npy +imgHQ06893.npy +imgHQ18269.npy +imgHQ11051.npy +imgHQ16021.npy +imgHQ07647.npy +imgHQ29458.npy +imgHQ27453.npy +imgHQ11027.npy +imgHQ02069.npy +imgHQ09051.npy +imgHQ11040.npy +imgHQ17694.npy +imgHQ17074.npy +imgHQ24612.npy +imgHQ27948.npy +imgHQ29179.npy +imgHQ01117.npy +imgHQ23999.npy +imgHQ27446.npy +imgHQ09199.npy +imgHQ03800.npy +imgHQ05107.npy +imgHQ17379.npy +imgHQ25251.npy +imgHQ13088.npy +imgHQ03040.npy +imgHQ17199.npy +imgHQ05507.npy +imgHQ02123.npy +imgHQ21168.npy +imgHQ06904.npy +imgHQ18476.npy +imgHQ10546.npy +imgHQ06096.npy +imgHQ02555.npy +imgHQ11586.npy +imgHQ25961.npy +imgHQ09600.npy +imgHQ00450.npy +imgHQ00517.npy +imgHQ03397.npy +imgHQ05602.npy +imgHQ08995.npy +imgHQ18787.npy +imgHQ05214.npy +imgHQ17354.npy +imgHQ22353.npy +imgHQ03639.npy +imgHQ25177.npy +imgHQ12416.npy +imgHQ10951.npy +imgHQ09177.npy +imgHQ22713.npy +imgHQ15961.npy +imgHQ16067.npy +imgHQ20406.npy +imgHQ27381.npy +imgHQ23064.npy +imgHQ01702.npy +imgHQ18176.npy +imgHQ16170.npy +imgHQ00251.npy +imgHQ26362.npy +imgHQ26014.npy +imgHQ05294.npy +imgHQ18713.npy +imgHQ01958.npy +imgHQ16492.npy +imgHQ27191.npy +imgHQ13808.npy +imgHQ16797.npy +imgHQ00862.npy +imgHQ06270.npy +imgHQ01414.npy +imgHQ04853.npy +imgHQ04741.npy +imgHQ08017.npy +imgHQ03436.npy +imgHQ20794.npy +imgHQ10532.npy +imgHQ02109.npy +imgHQ21081.npy +imgHQ08008.npy +imgHQ10901.npy +imgHQ13788.npy +imgHQ23768.npy +imgHQ03667.npy +imgHQ18416.npy +imgHQ28370.npy +imgHQ11521.npy +imgHQ14269.npy +imgHQ12034.npy +imgHQ14855.npy +imgHQ22407.npy +imgHQ03153.npy +imgHQ12190.npy +imgHQ12055.npy +imgHQ01951.npy +imgHQ22571.npy +imgHQ29076.npy +imgHQ25972.npy +imgHQ27230.npy +imgHQ08779.npy +imgHQ25403.npy +imgHQ08782.npy +imgHQ28607.npy +imgHQ07392.npy +imgHQ00029.npy +imgHQ00343.npy +imgHQ17345.npy +imgHQ18119.npy +imgHQ13267.npy +imgHQ02865.npy +imgHQ11425.npy +imgHQ13890.npy +imgHQ23283.npy +imgHQ28442.npy +imgHQ17396.npy +imgHQ09038.npy +imgHQ23673.npy +imgHQ09788.npy +imgHQ08950.npy +imgHQ17293.npy +imgHQ13116.npy +imgHQ09324.npy +imgHQ29740.npy +imgHQ02674.npy +imgHQ11264.npy +imgHQ00038.npy +imgHQ16451.npy +imgHQ16884.npy +imgHQ29188.npy +imgHQ12834.npy +imgHQ17462.npy +imgHQ01151.npy +imgHQ18049.npy +imgHQ01434.npy +imgHQ03410.npy +imgHQ08791.npy +imgHQ24318.npy +imgHQ16034.npy +imgHQ21799.npy +imgHQ28797.npy +imgHQ25376.npy +imgHQ25385.npy +imgHQ14666.npy +imgHQ27409.npy +imgHQ02724.npy +imgHQ12543.npy +imgHQ22640.npy +imgHQ07756.npy +imgHQ27091.npy +imgHQ16674.npy +imgHQ24022.npy +imgHQ22015.npy +imgHQ06447.npy +imgHQ27642.npy +imgHQ28326.npy +imgHQ10231.npy +imgHQ09866.npy +imgHQ16964.npy +imgHQ09446.npy +imgHQ24508.npy +imgHQ14948.npy +imgHQ24702.npy +imgHQ13641.npy +imgHQ24262.npy +imgHQ00088.npy +imgHQ14241.npy +imgHQ18165.npy +imgHQ26846.npy +imgHQ09314.npy +imgHQ20979.npy +imgHQ24417.npy +imgHQ10581.npy +imgHQ12080.npy +imgHQ14914.npy +imgHQ00826.npy +imgHQ10824.npy +imgHQ01047.npy +imgHQ14466.npy +imgHQ19496.npy +imgHQ25083.npy +imgHQ13328.npy +imgHQ21864.npy +imgHQ08453.npy +imgHQ05014.npy +imgHQ18268.npy +imgHQ29911.npy +imgHQ07329.npy +imgHQ14686.npy +imgHQ04580.npy +imgHQ19891.npy +imgHQ24231.npy +imgHQ04546.npy +imgHQ00605.npy +imgHQ19296.npy +imgHQ00008.npy +imgHQ17989.npy +imgHQ07528.npy +imgHQ06174.npy +imgHQ09953.npy +imgHQ10357.npy +imgHQ14745.npy +imgHQ27797.npy +imgHQ09717.npy +imgHQ14190.npy +imgHQ17711.npy +imgHQ03254.npy +imgHQ24532.npy +imgHQ13396.npy +imgHQ15261.npy +imgHQ22854.npy +imgHQ10064.npy +imgHQ00738.npy +imgHQ26849.npy +imgHQ04535.npy +imgHQ26672.npy +imgHQ09083.npy +imgHQ06370.npy +imgHQ00194.npy +imgHQ21662.npy +imgHQ18342.npy +imgHQ09114.npy +imgHQ00209.npy +imgHQ13998.npy +imgHQ10967.npy +imgHQ22709.npy +imgHQ03701.npy +imgHQ13067.npy +imgHQ29170.npy +imgHQ13348.npy +imgHQ09846.npy +imgHQ09665.npy +imgHQ04943.npy +imgHQ13028.npy +imgHQ18980.npy +imgHQ12165.npy +imgHQ21532.npy +imgHQ15980.npy +imgHQ08769.npy +imgHQ25652.npy +imgHQ24427.npy +imgHQ05181.npy +imgHQ14846.npy +imgHQ01331.npy +imgHQ21911.npy +imgHQ26167.npy +imgHQ05544.npy +imgHQ12068.npy +imgHQ18853.npy +imgHQ02417.npy +imgHQ04949.npy +imgHQ27365.npy +imgHQ09503.npy +imgHQ27189.npy +imgHQ18249.npy +imgHQ19295.npy +imgHQ07216.npy +imgHQ05284.npy +imgHQ18879.npy +imgHQ11646.npy +imgHQ07651.npy +imgHQ18882.npy +imgHQ17940.npy +imgHQ25168.npy +imgHQ21751.npy +imgHQ04911.npy +imgHQ00060.npy +imgHQ11345.npy +imgHQ05033.npy +imgHQ21273.npy +imgHQ21221.npy +imgHQ09568.npy +imgHQ22599.npy +imgHQ15097.npy +imgHQ24617.npy +imgHQ10377.npy +imgHQ05515.npy +imgHQ09681.npy +imgHQ19395.npy +imgHQ24123.npy +imgHQ28181.npy +imgHQ27200.npy +imgHQ26142.npy +imgHQ29577.npy +imgHQ05575.npy +imgHQ28828.npy +imgHQ07537.npy +imgHQ03379.npy +imgHQ09309.npy +imgHQ05257.npy +imgHQ15254.npy +imgHQ08386.npy +imgHQ03255.npy +imgHQ28139.npy +imgHQ23854.npy +imgHQ12289.npy +imgHQ15505.npy +imgHQ25480.npy +imgHQ15899.npy +imgHQ13664.npy +imgHQ17759.npy +imgHQ04296.npy +imgHQ01706.npy +imgHQ17983.npy +imgHQ18850.npy +imgHQ03747.npy +imgHQ04133.npy +imgHQ20003.npy +imgHQ23120.npy +imgHQ19079.npy +imgHQ13044.npy +imgHQ08287.npy +imgHQ14845.npy +imgHQ19807.npy +imgHQ28231.npy +imgHQ04619.npy +imgHQ02547.npy +imgHQ17685.npy +imgHQ17934.npy +imgHQ07057.npy +imgHQ12773.npy +imgHQ20779.npy +imgHQ19839.npy +imgHQ05847.npy +imgHQ17570.npy +imgHQ28611.npy +imgHQ29499.npy +imgHQ02376.npy +imgHQ23683.npy +imgHQ29603.npy +imgHQ13322.npy +imgHQ20198.npy +imgHQ04412.npy +imgHQ25643.npy +imgHQ20352.npy +imgHQ24951.npy +imgHQ08206.npy +imgHQ08329.npy +imgHQ08249.npy +imgHQ26267.npy +imgHQ28635.npy +imgHQ13045.npy +imgHQ08425.npy +imgHQ19454.npy +imgHQ29953.npy +imgHQ00739.npy +imgHQ13654.npy +imgHQ26683.npy +imgHQ22279.npy +imgHQ11310.npy +imgHQ00781.npy +imgHQ03611.npy +imgHQ02021.npy +imgHQ20466.npy +imgHQ23275.npy +imgHQ05162.npy +imgHQ11372.npy +imgHQ06544.npy +imgHQ29074.npy +imgHQ16596.npy +imgHQ09341.npy +imgHQ28336.npy +imgHQ24406.npy +imgHQ06668.npy +imgHQ17814.npy +imgHQ15706.npy +imgHQ28652.npy +imgHQ22689.npy +imgHQ11112.npy +imgHQ28099.npy +imgHQ10051.npy +imgHQ12443.npy +imgHQ01317.npy +imgHQ06584.npy +imgHQ12290.npy +imgHQ15212.npy +imgHQ23864.npy +imgHQ07728.npy +imgHQ14207.npy +imgHQ02012.npy +imgHQ05921.npy +imgHQ14483.npy +imgHQ16704.npy +imgHQ15337.npy +imgHQ00407.npy +imgHQ15746.npy +imgHQ12790.npy +imgHQ20861.npy +imgHQ23155.npy +imgHQ18737.npy +imgHQ04483.npy +imgHQ22845.npy +imgHQ08604.npy +imgHQ21885.npy +imgHQ27382.npy +imgHQ19300.npy +imgHQ16482.npy +imgHQ28473.npy +imgHQ27127.npy +imgHQ27039.npy +imgHQ21813.npy +imgHQ17324.npy +imgHQ25830.npy +imgHQ15620.npy +imgHQ23031.npy +imgHQ16867.npy +imgHQ25338.npy +imgHQ17461.npy +imgHQ03183.npy +imgHQ12434.npy +imgHQ03252.npy +imgHQ05969.npy +imgHQ03061.npy +imgHQ17935.npy +imgHQ11767.npy +imgHQ05951.npy +imgHQ07113.npy +imgHQ00742.npy +imgHQ21906.npy +imgHQ00496.npy +imgHQ13782.npy +imgHQ11527.npy +imgHQ20123.npy +imgHQ15312.npy +imgHQ28851.npy +imgHQ13769.npy +imgHQ04206.npy +imgHQ13633.npy +imgHQ23665.npy +imgHQ05963.npy +imgHQ20500.npy +imgHQ24379.npy +imgHQ03750.npy +imgHQ10054.npy +imgHQ27915.npy +imgHQ11191.npy +imgHQ13814.npy +imgHQ17165.npy +imgHQ08171.npy +imgHQ18004.npy +imgHQ29560.npy +imgHQ13093.npy +imgHQ05498.npy +imgHQ22909.npy +imgHQ26409.npy +imgHQ01576.npy +imgHQ20592.npy +imgHQ23480.npy +imgHQ08193.npy +imgHQ28773.npy +imgHQ26832.npy +imgHQ23983.npy +imgHQ21925.npy +imgHQ28234.npy +imgHQ18319.npy +imgHQ05741.npy +imgHQ26278.npy +imgHQ22181.npy +imgHQ10072.npy +imgHQ03428.npy +imgHQ06821.npy +imgHQ15538.npy +imgHQ02566.npy +imgHQ00095.npy +imgHQ03682.npy +imgHQ18601.npy +imgHQ14393.npy +imgHQ10872.npy +imgHQ28778.npy +imgHQ12350.npy +imgHQ27730.npy +imgHQ18621.npy +imgHQ07257.npy +imgHQ19699.npy +imgHQ20784.npy +imgHQ10354.npy +imgHQ05470.npy +imgHQ01956.npy +imgHQ26989.npy +imgHQ01915.npy +imgHQ23190.npy +imgHQ16614.npy +imgHQ27074.npy +imgHQ07069.npy +imgHQ11457.npy +imgHQ07609.npy +imgHQ13919.npy +imgHQ18553.npy +imgHQ24347.npy +imgHQ04670.npy +imgHQ16454.npy +imgHQ14381.npy +imgHQ29639.npy +imgHQ06766.npy +imgHQ28435.npy +imgHQ11278.npy +imgHQ00087.npy +imgHQ23468.npy +imgHQ25544.npy +imgHQ22228.npy +imgHQ19785.npy +imgHQ04850.npy +imgHQ07699.npy +imgHQ14009.npy +imgHQ03873.npy +imgHQ29719.npy +imgHQ01858.npy +imgHQ17882.npy +imgHQ10632.npy +imgHQ23332.npy +imgHQ29042.npy +imgHQ10099.npy +imgHQ21033.npy +imgHQ25453.npy +imgHQ08388.npy +imgHQ12228.npy +imgHQ28753.npy +imgHQ13526.npy +imgHQ23409.npy +imgHQ08036.npy +imgHQ16839.npy +imgHQ10265.npy +imgHQ00840.npy +imgHQ14993.npy +imgHQ09352.npy +imgHQ14939.npy +imgHQ18521.npy +imgHQ16808.npy +imgHQ27009.npy +imgHQ14754.npy +imgHQ23518.npy +imgHQ00016.npy +imgHQ02705.npy +imgHQ25283.npy +imgHQ00278.npy +imgHQ14348.npy +imgHQ01499.npy +imgHQ21202.npy +imgHQ28169.npy +imgHQ04119.npy +imgHQ00792.npy +imgHQ04248.npy +imgHQ15036.npy +imgHQ23549.npy +imgHQ24538.npy +imgHQ10023.npy +imgHQ12279.npy +imgHQ19929.npy +imgHQ15077.npy +imgHQ19635.npy +imgHQ00120.npy +imgHQ26185.npy +imgHQ13000.npy +imgHQ07814.npy +imgHQ03673.npy +imgHQ09804.npy +imgHQ20440.npy +imgHQ23150.npy +imgHQ08280.npy +imgHQ26326.npy +imgHQ10852.npy +imgHQ15110.npy +imgHQ11471.npy +imgHQ15103.npy +imgHQ13887.npy +imgHQ00307.npy +imgHQ23144.npy +imgHQ20207.npy +imgHQ29390.npy +imgHQ14730.npy +imgHQ09248.npy +imgHQ00235.npy +imgHQ19227.npy +imgHQ18649.npy +imgHQ10694.npy +imgHQ09089.npy +imgHQ18611.npy +imgHQ22464.npy +imgHQ23085.npy +imgHQ25358.npy +imgHQ24834.npy +imgHQ23151.npy +imgHQ19455.npy +imgHQ01323.npy +imgHQ06609.npy +imgHQ26029.npy +imgHQ16756.npy +imgHQ22692.npy +imgHQ01135.npy +imgHQ03824.npy +imgHQ29465.npy +imgHQ06915.npy +imgHQ06499.npy +imgHQ13078.npy +imgHQ07775.npy +imgHQ26145.npy +imgHQ29118.npy +imgHQ07826.npy +imgHQ11254.npy +imgHQ15655.npy +imgHQ14620.npy +imgHQ10227.npy +imgHQ19830.npy +imgHQ21618.npy +imgHQ10077.npy +imgHQ10675.npy +imgHQ05837.npy +imgHQ02765.npy +imgHQ09691.npy +imgHQ15756.npy +imgHQ29263.npy +imgHQ05665.npy +imgHQ10740.npy +imgHQ29209.npy +imgHQ22292.npy +imgHQ04429.npy +imgHQ20319.npy +imgHQ03907.npy +imgHQ14336.npy +imgHQ26884.npy +imgHQ12677.npy +imgHQ21981.npy +imgHQ04784.npy +imgHQ08704.npy +imgHQ23318.npy +imgHQ27048.npy +imgHQ04723.npy +imgHQ17432.npy +imgHQ08854.npy +imgHQ05149.npy +imgHQ25452.npy +imgHQ29781.npy +imgHQ00216.npy +imgHQ19009.npy +imgHQ03507.npy +imgHQ05147.npy +imgHQ24442.npy +imgHQ10290.npy +imgHQ26606.npy +imgHQ20698.npy +imgHQ10160.npy +imgHQ14470.npy +imgHQ10853.npy +imgHQ03136.npy +imgHQ01410.npy +imgHQ22355.npy +imgHQ12327.npy +imgHQ27817.npy +imgHQ06620.npy +imgHQ14886.npy +imgHQ25275.npy +imgHQ19747.npy +imgHQ15625.npy +imgHQ21608.npy +imgHQ14896.npy +imgHQ13397.npy +imgHQ01797.npy +imgHQ16427.npy +imgHQ24533.npy +imgHQ24198.npy +imgHQ17687.npy +imgHQ08739.npy +imgHQ26686.npy +imgHQ06483.npy +imgHQ25702.npy +imgHQ13235.npy +imgHQ02543.npy +imgHQ04636.npy +imgHQ15589.npy +imgHQ15957.npy +imgHQ23966.npy +imgHQ24111.npy +imgHQ11061.npy +imgHQ27640.npy +imgHQ23043.npy +imgHQ17431.npy +imgHQ03045.npy +imgHQ06911.npy +imgHQ13790.npy +imgHQ25010.npy +imgHQ14927.npy +imgHQ05053.npy +imgHQ06619.npy +imgHQ03186.npy +imgHQ20359.npy +imgHQ26292.npy +imgHQ21569.npy +imgHQ15481.npy +imgHQ03687.npy +imgHQ15914.npy +imgHQ25471.npy +imgHQ03206.npy +imgHQ07970.npy +imgHQ27395.npy +imgHQ08928.npy +imgHQ19926.npy +imgHQ26582.npy +imgHQ21350.npy +imgHQ07366.npy +imgHQ25353.npy +imgHQ18433.npy +imgHQ15384.npy +imgHQ14940.npy +imgHQ21259.npy +imgHQ06125.npy +imgHQ20228.npy +imgHQ11661.npy +imgHQ17370.npy +imgHQ16164.npy +imgHQ20801.npy +imgHQ04290.npy +imgHQ03096.npy +imgHQ23624.npy +imgHQ09306.npy +imgHQ26381.npy +imgHQ14289.npy +imgHQ20065.npy +imgHQ25381.npy +imgHQ11619.npy +imgHQ10021.npy +imgHQ03232.npy +imgHQ15564.npy +imgHQ13134.npy +imgHQ11604.npy +imgHQ19324.npy +imgHQ06750.npy +imgHQ16172.npy +imgHQ02697.npy +imgHQ15411.npy +imgHQ25356.npy +imgHQ18673.npy +imgHQ14787.npy +imgHQ11266.npy +imgHQ14928.npy +imgHQ13840.npy +imgHQ19508.npy +imgHQ15842.npy +imgHQ03776.npy +imgHQ07619.npy +imgHQ15741.npy +imgHQ22815.npy +imgHQ10614.npy +imgHQ25720.npy +imgHQ16886.npy +imgHQ27121.npy +imgHQ02991.npy +imgHQ05057.npy +imgHQ28951.npy +imgHQ19344.npy +imgHQ10733.npy +imgHQ03370.npy +imgHQ01474.npy +imgHQ14890.npy +imgHQ15675.npy +imgHQ12737.npy +imgHQ09972.npy +imgHQ27755.npy +imgHQ15365.npy +imgHQ18854.npy +imgHQ14222.npy +imgHQ20777.npy +imgHQ03622.npy +imgHQ29905.npy +imgHQ20629.npy +imgHQ02961.npy +imgHQ11046.npy +imgHQ27698.npy +imgHQ12851.npy +imgHQ05148.npy +imgHQ26741.npy +imgHQ24294.npy +imgHQ00326.npy +imgHQ22522.npy +imgHQ14017.npy +imgHQ04776.npy +imgHQ07010.npy +imgHQ22484.npy +imgHQ29413.npy +imgHQ09152.npy +imgHQ19580.npy +imgHQ08250.npy +imgHQ16965.npy +imgHQ12632.npy +imgHQ07741.npy +imgHQ01292.npy +imgHQ29769.npy +imgHQ19413.npy +imgHQ11180.npy +imgHQ09027.npy +imgHQ10703.npy +imgHQ22716.npy +imgHQ13523.npy +imgHQ01252.npy +imgHQ21141.npy +imgHQ25218.npy +imgHQ22055.npy +imgHQ08986.npy +imgHQ09440.npy +imgHQ25753.npy +imgHQ03848.npy +imgHQ06350.npy +imgHQ03418.npy +imgHQ22533.npy +imgHQ12633.npy +imgHQ00514.npy +imgHQ19386.npy +imgHQ04000.npy +imgHQ17767.npy +imgHQ01594.npy +imgHQ22781.npy +imgHQ21383.npy +imgHQ22920.npy +imgHQ17752.npy +imgHQ29311.npy +imgHQ10686.npy +imgHQ10423.npy +imgHQ26264.npy +imgHQ04381.npy +imgHQ18941.npy +imgHQ06618.npy +imgHQ20282.npy +imgHQ07324.npy +imgHQ18488.npy +imgHQ15037.npy +imgHQ29319.npy +imgHQ21982.npy +imgHQ09618.npy +imgHQ22194.npy +imgHQ18220.npy +imgHQ04270.npy +imgHQ03438.npy +imgHQ16121.npy +imgHQ27855.npy +imgHQ05954.npy +imgHQ12831.npy +imgHQ27671.npy +imgHQ27177.npy +imgHQ11189.npy +imgHQ01262.npy +imgHQ23628.npy +imgHQ08571.npy +imgHQ24137.npy +imgHQ10936.npy +imgHQ27281.npy +imgHQ00476.npy +imgHQ08429.npy +imgHQ15363.npy +imgHQ23584.npy +imgHQ21632.npy +imgHQ15264.npy +imgHQ29652.npy +imgHQ11832.npy +imgHQ19523.npy +imgHQ15076.npy +imgHQ21834.npy +imgHQ28537.npy +imgHQ02180.npy +imgHQ25225.npy +imgHQ15189.npy +imgHQ25626.npy +imgHQ03222.npy +imgHQ26742.npy +imgHQ11099.npy +imgHQ10156.npy +imgHQ05500.npy +imgHQ18282.npy +imgHQ06262.npy +imgHQ09650.npy +imgHQ14076.npy +imgHQ21173.npy +imgHQ19682.npy +imgHQ05117.npy +imgHQ00267.npy +imgHQ15585.npy +imgHQ29394.npy +imgHQ02186.npy +imgHQ22039.npy +imgHQ17241.npy +imgHQ04669.npy +imgHQ13310.npy +imgHQ03106.npy +imgHQ14881.npy +imgHQ24081.npy +imgHQ04530.npy +imgHQ12427.npy +imgHQ23022.npy +imgHQ29664.npy +imgHQ20869.npy +imgHQ26052.npy +imgHQ08708.npy +imgHQ12917.npy +imgHQ13252.npy +imgHQ22155.npy +imgHQ02384.npy +imgHQ25821.npy +imgHQ15333.npy +imgHQ10278.npy +imgHQ13478.npy +imgHQ25747.npy +imgHQ15777.npy +imgHQ17688.npy +imgHQ14960.npy +imgHQ06087.npy +imgHQ06394.npy +imgHQ16372.npy +imgHQ28705.npy +imgHQ14702.npy +imgHQ07892.npy +imgHQ26568.npy +imgHQ28871.npy +imgHQ17856.npy +imgHQ12657.npy +imgHQ14766.npy +imgHQ19183.npy +imgHQ14860.npy +imgHQ01074.npy diff --git a/src/taming-transformers/data/coco_annotations_100/annotations/instances_train2017.json b/src/taming-transformers/data/coco_annotations_100/annotations/instances_train2017.json new file mode 100644 index 0000000000000000000000000000000000000000..2b73f89679f80e8f0b3c0483ddcebcf6f5675115 --- /dev/null +++ b/src/taming-transformers/data/coco_annotations_100/annotations/instances_train2017.json @@ -0,0 +1 @@ +{"info": {"description": "COCO 2017 Dataset", "url": "http://cocodataset.org", "version": "1.0", "year": 2017, "contributor": "COCO Consortium", "date_created": "2017/09/01"}, "licenses": [{"url": "http://creativecommons.org/licenses/by-nc-sa/2.0/", "id": 1, "name": "Attribution-NonCommercial-ShareAlike License"}, {"url": "http://creativecommons.org/licenses/by-nc/2.0/", "id": 2, "name": "Attribution-NonCommercial License"}, {"url": "http://creativecommons.org/licenses/by-nc-nd/2.0/", "id": 3, "name": "Attribution-NonCommercial-NoDerivs License"}, {"url": "http://creativecommons.org/licenses/by/2.0/", "id": 4, "name": "Attribution License"}, {"url": "http://creativecommons.org/licenses/by-sa/2.0/", "id": 5, "name": "Attribution-ShareAlike License"}, {"url": "http://creativecommons.org/licenses/by-nd/2.0/", "id": 6, "name": "Attribution-NoDerivs License"}, {"url": "http://flickr.com/commons/usage/", "id": 7, "name": "No known copyright restrictions"}, {"url": "http://www.usa.gov/copyright.shtml", "id": 8, "name": "United States Government Work"}], "images": [{"license": 4, "file_name": "000000010442.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010442.jpg", "height": 426, "width": 640, "date_captured": "2013-11-19 21:00:09", "flickr_url": "http://farm4.staticflickr.com/3188/2662753853_11d673a05d_z.jpg", "id": 10442}, {"license": 1, "file_name": "000000010142.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010142.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 22:51:01", "flickr_url": "http://farm6.staticflickr.com/5171/5408281064_c3f8d3e67b_z.jpg", "id": 10142}, {"license": 1, "file_name": "000000010393.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010393.jpg", "height": 480, "width": 640, "date_captured": "2013-11-15 00:40:34", "flickr_url": "http://farm3.staticflickr.com/2743/4192626071_8f54f4578e_z.jpg", "id": 10393}, {"license": 6, "file_name": "000000010077.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010077.jpg", "height": 259, "width": 640, "date_captured": "2013-11-18 21:04:46", "flickr_url": "http://farm3.staticflickr.com/2112/2273706470_b115ccda6b_z.jpg", "id": 10077}, {"license": 3, "file_name": "000000010123.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010123.jpg", "height": 427, "width": 640, "date_captured": "2013-11-21 05:12:31", "flickr_url": "http://farm5.staticflickr.com/4085/4948947491_1c37f153fc_z.jpg", "id": 10123}, {"license": 4, "file_name": "000000010432.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010432.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 19:52:48", "flickr_url": "http://farm6.staticflickr.com/5457/9690393462_ba33edf573_z.jpg", "id": 10432}, {"license": 1, "file_name": "000000010192.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010192.jpg", "height": 497, "width": 640, "date_captured": "2013-11-14 20:22:48", "flickr_url": "http://farm9.staticflickr.com/8196/8125509122_e8348e8d89_z.jpg", "id": 10192}, {"license": 3, "file_name": "000000010039.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010039.jpg", "height": 640, "width": 428, "date_captured": "2013-11-15 14:11:21", "flickr_url": "http://farm5.staticflickr.com/4098/4751788411_7b6a63cd92_z.jpg", "id": 10039}, {"license": 2, "file_name": "000000010023.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010023.jpg", "height": 427, "width": 640, "date_captured": "2013-11-20 09:15:13", "flickr_url": "http://farm4.staticflickr.com/3397/3201363151_ea35e217e3_z.jpg", "id": 10023}, {"license": 3, "file_name": "000000010428.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010428.jpg", "height": 640, "width": 427, "date_captured": "2013-11-14 23:33:26", "flickr_url": "http://farm3.staticflickr.com/2685/4078908984_668deecc62_z.jpg", "id": 10428}, {"license": 1, "file_name": "000000010400.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010400.jpg", "height": 640, "width": 427, "date_captured": "2013-11-24 15:06:26", "flickr_url": "http://farm9.staticflickr.com/8323/8134674673_d9489c39b9_z.jpg", "id": 10400}, {"license": 5, "file_name": "000000010249.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010249.jpg", "height": 640, "width": 426, "date_captured": "2013-11-16 21:44:34", "flickr_url": "http://farm9.staticflickr.com/8335/8402579163_8363ba0c7e_z.jpg", "id": 10249}, {"license": 1, "file_name": "000000010290.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010290.jpg", "height": 640, "width": 482, "date_captured": "2013-11-15 04:16:50", "flickr_url": "http://farm6.staticflickr.com/5048/5238196330_aeeaf4d917_z.jpg", "id": 10290}, {"license": 2, "file_name": "000000010205.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010205.jpg", "height": 426, "width": 640, "date_captured": "2013-11-21 22:57:22", "flickr_url": "http://farm2.staticflickr.com/1316/1243676572_54ae68d563_z.jpg", "id": 10205}, {"license": 2, "file_name": "000000010217.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010217.jpg", "height": 480, "width": 640, "date_captured": "2013-11-24 23:26:35", "flickr_url": "http://farm8.staticflickr.com/7284/8742930563_207f40cd15_z.jpg", "id": 10217}, {"license": 5, "file_name": "000000010263.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010263.jpg", "height": 375, "width": 500, "date_captured": "2013-11-22 01:41:21", "flickr_url": "http://farm3.staticflickr.com/2602/3909329409_085a7c9f41_z.jpg", "id": 10263}, {"license": 2, "file_name": "000000010040.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010040.jpg", "height": 480, "width": 640, "date_captured": "2013-11-16 21:57:07", "flickr_url": "http://farm9.staticflickr.com/8213/8264511585_0a5e6212c2_z.jpg", "id": 10040}, {"license": 4, "file_name": "000000010324.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010324.jpg", "height": 640, "width": 425, "date_captured": "2013-11-18 15:34:49", "flickr_url": "http://farm2.staticflickr.com/1059/5150417990_0d7762864e_z.jpg", "id": 10324}, {"license": 3, "file_name": "000000010008.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010008.jpg", "height": 427, "width": 640, "date_captured": "2013-11-20 20:26:10", "flickr_url": "http://farm7.staticflickr.com/6076/6088064448_2690929cbc_z.jpg", "id": 10008}, {"license": 2, "file_name": "000000010149.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010149.jpg", "height": 484, "width": 640, "date_captured": "2013-11-14 21:39:00", "flickr_url": "http://farm8.staticflickr.com/7235/7169336131_521711d854_z.jpg", "id": 10149}, {"license": 1, "file_name": "000000010463.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010463.jpg", "height": 446, "width": 640, "date_captured": "2013-11-15 12:19:52", "flickr_url": "http://farm8.staticflickr.com/7250/6910961220_961bf73cae_z.jpg", "id": 10463}, {"license": 3, "file_name": "000000010138.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010138.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 21:12:31", "flickr_url": "http://farm9.staticflickr.com/8098/8506152881_ecf43c76c3_z.jpg", "id": 10138}, {"license": 4, "file_name": "000000010014.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010014.jpg", "height": 426, "width": 640, "date_captured": "2013-11-16 15:41:53", "flickr_url": "http://farm9.staticflickr.com/8185/8145478875_28543f87be_z.jpg", "id": 10014}, {"license": 1, "file_name": "000000010219.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010219.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 12:18:01", "flickr_url": "http://farm1.staticflickr.com/116/293545180_9be1f625c9_z.jpg", "id": 10219}, {"license": 4, "file_name": "000000010114.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010114.jpg", "height": 640, "width": 480, "date_captured": "2013-11-14 18:59:23", "flickr_url": "http://farm9.staticflickr.com/8509/8528792276_824cb10b59_z.jpg", "id": 10114}, {"license": 3, "file_name": "000000010211.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010211.jpg", "height": 424, "width": 640, "date_captured": "2013-11-17 00:23:46", "flickr_url": "http://farm4.staticflickr.com/3032/2751379693_252d3c8e44_z.jpg", "id": 10211}, {"license": 2, "file_name": "000000010216.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010216.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 03:03:18", "flickr_url": "http://farm9.staticflickr.com/8436/7926050860_db828d8494_z.jpg", "id": 10216}, {"license": 1, "file_name": "000000010115.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010115.jpg", "height": 640, "width": 427, "date_captured": "2013-11-15 03:15:50", "flickr_url": "http://farm8.staticflickr.com/7200/6854804253_f7fa6e98b8_z.jpg", "id": 10115}, {"license": 4, "file_name": "000000010440.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010440.jpg", "height": 427, "width": 640, "date_captured": "2013-11-16 05:51:18", "flickr_url": "http://farm3.staticflickr.com/2865/9443592476_3c3ce98973_z.jpg", "id": 10440}, {"license": 1, "file_name": "000000010256.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010256.jpg", "height": 360, "width": 640, "date_captured": "2013-11-16 22:33:29", "flickr_url": "http://farm9.staticflickr.com/8480/8214519939_ee9d1486b6_z.jpg", "id": 10256}, {"license": 2, "file_name": "000000010056.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010056.jpg", "height": 482, "width": 640, "date_captured": "2013-11-17 00:42:05", "flickr_url": "http://farm9.staticflickr.com/8472/8138318480_cf2cd6fa5a_z.jpg", "id": 10056}, {"license": 2, "file_name": "000000010107.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010107.jpg", "height": 640, "width": 480, "date_captured": "2013-11-18 14:17:26", "flickr_url": "http://farm5.staticflickr.com/4039/4471901818_ac8353d2e5_z.jpg", "id": 10107}, {"license": 3, "file_name": "000000010449.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010449.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 02:08:04", "flickr_url": "http://farm4.staticflickr.com/3732/9431336544_e6345159b7_z.jpg", "id": 10449}, {"license": 3, "file_name": "000000010012.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010012.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 21:21:03", "flickr_url": "http://farm2.staticflickr.com/1039/1374745468_a4cb23032f_z.jpg", "id": 10012}, {"license": 1, "file_name": "000000010395.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010395.jpg", "height": 476, "width": 500, "date_captured": "2013-11-18 11:37:47", "flickr_url": "http://farm5.staticflickr.com/4005/4468891744_00bb759e17_z.jpg", "id": 10395}, {"license": 3, "file_name": "000000010104.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010104.jpg", "height": 457, "width": 640, "date_captured": "2013-11-15 21:47:19", "flickr_url": "http://farm7.staticflickr.com/6237/6282305534_1b1fb1f8a1_z.jpg", "id": 10104}, {"license": 1, "file_name": "000000010386.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010386.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 01:56:20", "flickr_url": "http://farm4.staticflickr.com/3279/2982566887_93e5d316a9_z.jpg", "id": 10386}, {"license": 1, "file_name": "000000010046.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010046.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 11:50:10", "flickr_url": "http://farm8.staticflickr.com/7363/9675286251_78248282b6_z.jpg", "id": 10046}, {"license": 1, "file_name": "000000010430.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010430.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 07:44:21", "flickr_url": "http://farm4.staticflickr.com/3678/9477571775_99039714f4_z.jpg", "id": 10430}, {"license": 1, "file_name": "000000010166.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010166.jpg", "height": 351, "width": 470, "date_captured": "2013-11-19 21:19:23", "flickr_url": "http://farm4.staticflickr.com/3248/3015319163_b0a61a7c77_z.jpg", "id": 10166}, {"license": 2, "file_name": "000000010275.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010275.jpg", "height": 427, "width": 640, "date_captured": "2013-11-18 09:32:30", "flickr_url": "http://farm9.staticflickr.com/8177/8029583325_02172d3a6f_z.jpg", "id": 10275}, {"license": 3, "file_name": "000000010321.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010321.jpg", "height": 640, "width": 480, "date_captured": "2013-11-19 03:39:00", "flickr_url": "http://farm9.staticflickr.com/8330/8374378941_80fda27ffa_z.jpg", "id": 10321}, {"license": 2, "file_name": "000000010176.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010176.jpg", "height": 480, "width": 640, "date_captured": "2013-11-22 00:19:33", "flickr_url": "http://farm1.staticflickr.com/164/335653813_61b9a128e2_z.jpg", "id": 10176}, {"license": 1, "file_name": "000000010037.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010037.jpg", "height": 426, "width": 640, "date_captured": "2013-11-19 18:06:00", "flickr_url": "http://farm3.staticflickr.com/2602/3741919994_d9d0343f82_z.jpg", "id": 10037}, {"license": 4, "file_name": "000000010313.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010313.jpg", "height": 640, "width": 427, "date_captured": "2013-11-20 07:30:18", "flickr_url": "http://farm3.staticflickr.com/2595/3691544165_5f8f5d92de_z.jpg", "id": 10313}, {"license": 3, "file_name": "000000010421.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010421.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 11:47:35", "flickr_url": "http://farm4.staticflickr.com/3286/2704773968_ed600e2d11_z.jpg", "id": 10421}, {"license": 2, "file_name": "000000010161.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010161.jpg", "height": 427, "width": 640, "date_captured": "2013-11-25 13:54:08", "flickr_url": "http://farm9.staticflickr.com/8385/8583133395_109ca97781_z.jpg", "id": 10161}, {"license": 4, "file_name": "000000010405.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010405.jpg", "height": 453, "width": 640, "date_captured": "2013-11-18 01:11:58", "flickr_url": "http://farm6.staticflickr.com/5068/5694693358_890d562b38_z.jpg", "id": 10405}, {"license": 4, "file_name": "000000010444.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010444.jpg", "height": 500, "width": 375, "date_captured": "2013-11-20 16:02:25", "flickr_url": "http://farm3.staticflickr.com/2205/2342560721_8a9545fd1a_z.jpg", "id": 10444}, {"license": 3, "file_name": "000000010084.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010084.jpg", "height": 424, "width": 640, "date_captured": "2013-11-17 07:31:31", "flickr_url": "http://farm8.staticflickr.com/7428/9977327403_ec9211b17d_z.jpg", "id": 10084}, {"license": 3, "file_name": "000000010179.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010179.jpg", "height": 502, "width": 640, "date_captured": "2013-11-23 01:23:34", "flickr_url": "http://farm3.staticflickr.com/2753/5765793056_50a8694618_z.jpg", "id": 10179}, {"license": 4, "file_name": "000000010125.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010125.jpg", "height": 436, "width": 640, "date_captured": "2013-11-24 00:31:28", "flickr_url": "http://farm9.staticflickr.com/8051/8100436361_e70cea2ba0_z.jpg", "id": 10125}, {"license": 2, "file_name": "000000010082.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010082.jpg", "height": 425, "width": 640, "date_captured": "2013-11-24 02:46:01", "flickr_url": "http://farm6.staticflickr.com/5103/5660629949_220d6cb304_z.jpg", "id": 10082}, {"license": 3, "file_name": "000000010318.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010318.jpg", "height": 400, "width": 640, "date_captured": "2013-11-16 21:21:19", "flickr_url": "http://farm4.staticflickr.com/3730/9164843685_66a5f3834b_z.jpg", "id": 10318}, {"license": 3, "file_name": "000000010130.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010130.jpg", "height": 427, "width": 640, "date_captured": "2013-11-24 09:51:10", "flickr_url": "http://farm8.staticflickr.com/7055/6802904874_5313b371f7_z.jpg", "id": 10130}, {"license": 1, "file_name": "000000010403.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010403.jpg", "height": 416, "width": 640, "date_captured": "2013-11-19 18:10:23", "flickr_url": "http://farm5.staticflickr.com/4120/5416067648_a01a1d2872_z.jpg", "id": 10403}, {"license": 6, "file_name": "000000010041.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010041.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 21:28:20", "flickr_url": "http://farm8.staticflickr.com/7157/6791989693_84a9ec0060_z.jpg", "id": 10041}, {"license": 3, "file_name": "000000010343.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010343.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 08:20:12", "flickr_url": "http://farm4.staticflickr.com/3768/9317101988_c25e7800c3_z.jpg", "id": 10343}, {"license": 3, "file_name": "000000010388.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010388.jpg", "height": 426, "width": 640, "date_captured": "2013-11-14 21:36:08", "flickr_url": "http://farm8.staticflickr.com/7376/9612632350_fe5f9d2e02_z.jpg", "id": 10388}, {"license": 2, "file_name": "000000010414.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010414.jpg", "height": 420, "width": 500, "date_captured": "2013-11-19 20:53:38", "flickr_url": "http://farm1.staticflickr.com/68/187106012_c60041a5fa_z.jpg", "id": 10414}, {"license": 2, "file_name": "000000010265.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010265.jpg", "height": 427, "width": 640, "date_captured": "2013-11-23 04:52:56", "flickr_url": "http://farm2.staticflickr.com/1153/1340250930_630cae707b_z.jpg", "id": 10265}, {"license": 3, "file_name": "000000010222.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010222.jpg", "height": 333, "width": 500, "date_captured": "2013-11-16 17:51:33", "flickr_url": "http://farm1.staticflickr.com/145/406189235_49af59f7aa_z.jpg", "id": 10222}, {"license": 1, "file_name": "000000010241.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010241.jpg", "height": 480, "width": 640, "date_captured": "2013-11-16 16:15:07", "flickr_url": "http://farm5.staticflickr.com/4034/4618195712_406d349d8c_z.jpg", "id": 10241}, {"license": 4, "file_name": "000000010239.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010239.jpg", "height": 360, "width": 640, "date_captured": "2013-11-16 22:41:38", "flickr_url": "http://farm9.staticflickr.com/8527/8640248164_346015db59_z.jpg", "id": 10239}, {"license": 6, "file_name": "000000010369.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010369.jpg", "height": 424, "width": 640, "date_captured": "2013-11-18 16:30:42", "flickr_url": "http://farm6.staticflickr.com/5210/5279959659_617eb40ec2_z.jpg", "id": 10369}, {"license": 3, "file_name": "000000010136.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010136.jpg", "height": 640, "width": 316, "date_captured": "2013-11-24 12:57:39", "flickr_url": "http://farm1.staticflickr.com/48/143700223_df3abd2533_z.jpg", "id": 10136}, {"license": 3, "file_name": "000000010445.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010445.jpg", "height": 349, "width": 500, "date_captured": "2013-11-19 17:56:31", "flickr_url": "http://farm2.staticflickr.com/1133/973971082_0524b5a07c_z.jpg", "id": 10445}, {"license": 3, "file_name": "000000010015.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010015.jpg", "height": 633, "width": 640, "date_captured": "2013-11-19 18:15:10", "flickr_url": "http://farm4.staticflickr.com/3422/3393927411_26ab4342e9_z.jpg", "id": 10015}, {"license": 1, "file_name": "000000010434.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010434.jpg", "height": 426, "width": 640, "date_captured": "2013-11-15 11:54:59", "flickr_url": "http://farm1.staticflickr.com/8/7845077_9cbe3bd89d_z.jpg", "id": 10434}, {"license": 2, "file_name": "000000010097.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010097.jpg", "height": 360, "width": 640, "date_captured": "2013-11-14 20:26:22", "flickr_url": "http://farm5.staticflickr.com/4018/4255629097_9a832c6dae_z.jpg", "id": 10097}, {"license": 2, "file_name": "000000010058.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010058.jpg", "height": 426, "width": 640, "date_captured": "2013-11-17 19:16:50", "flickr_url": "http://farm9.staticflickr.com/8349/8197861619_93df634c02_z.jpg", "id": 10058}, {"license": 3, "file_name": "000000010108.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010108.jpg", "height": 453, "width": 640, "date_captured": "2013-11-17 02:20:45", "flickr_url": "http://farm4.staticflickr.com/3360/3444049112_fc8b6acf6e_z.jpg", "id": 10108}, {"license": 3, "file_name": "000000010232.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010232.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 15:38:00", "flickr_url": "http://farm4.staticflickr.com/3675/9453111678_c2cb8874d9_z.jpg", "id": 10232}, {"license": 4, "file_name": "000000010069.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010069.jpg", "height": 640, "width": 427, "date_captured": "2013-11-16 16:09:44", "flickr_url": "http://farm8.staticflickr.com/7229/7167720922_420895b285_z.jpg", "id": 10069}, {"license": 3, "file_name": "000000010024.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010024.jpg", "height": 640, "width": 480, "date_captured": "2013-11-19 20:21:14", "flickr_url": "http://farm9.staticflickr.com/8528/8463731510_53f79a717b_z.jpg", "id": 10024}, {"license": 3, "file_name": "000000010327.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010327.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 14:53:56", "flickr_url": "http://farm5.staticflickr.com/4025/4461943910_f88106188f_z.jpg", "id": 10327}, {"license": 1, "file_name": "000000010337.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010337.jpg", "height": 640, "width": 480, "date_captured": "2013-11-15 06:08:56", "flickr_url": "http://farm8.staticflickr.com/7064/6801977878_94d6095195_z.jpg", "id": 10337}, {"license": 1, "file_name": "000000010248.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010248.jpg", "height": 427, "width": 640, "date_captured": "2013-11-18 17:00:29", "flickr_url": "http://farm7.staticflickr.com/6013/6015945247_2d03377c4c_z.jpg", "id": 10248}, {"license": 2, "file_name": "000000010276.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010276.jpg", "height": 426, "width": 640, "date_captured": "2013-11-18 19:59:57", "flickr_url": "http://farm4.staticflickr.com/3746/9895771396_45554292ba_z.jpg", "id": 10276}, {"license": 6, "file_name": "000000010196.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010196.jpg", "height": 443, "width": 640, "date_captured": "2013-11-19 19:58:23", "flickr_url": "http://farm9.staticflickr.com/8505/8405340354_90e8d1757d_z.jpg", "id": 10196}, {"license": 2, "file_name": "000000010145.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010145.jpg", "height": 427, "width": 640, "date_captured": "2013-11-22 00:21:49", "flickr_url": "http://farm5.staticflickr.com/4118/4740387609_ce9bb3f14a_z.jpg", "id": 10145}, {"license": 1, "file_name": "000000010407.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010407.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 07:19:18", "flickr_url": "http://farm3.staticflickr.com/2037/2071235362_a8f850624b_z.jpg", "id": 10407}, {"license": 3, "file_name": "000000010243.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010243.jpg", "height": 500, "width": 375, "date_captured": "2013-11-20 13:39:40", "flickr_url": "http://farm3.staticflickr.com/2212/2416407264_ca4e59c12e_z.jpg", "id": 10243}, {"license": 4, "file_name": "000000010230.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010230.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 19:40:06", "flickr_url": "http://farm5.staticflickr.com/4094/4788218715_e64dbe9bb7_z.jpg", "id": 10230}, {"license": 6, "file_name": "000000010245.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010245.jpg", "height": 427, "width": 640, "date_captured": "2013-11-21 01:16:08", "flickr_url": "http://farm8.staticflickr.com/7253/7459060240_5e24c744f6_z.jpg", "id": 10245}, {"license": 1, "file_name": "000000010319.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010319.jpg", "height": 427, "width": 640, "date_captured": "2013-11-22 22:31:20", "flickr_url": "http://farm3.staticflickr.com/2521/4128276778_bb74ec1296_z.jpg", "id": 10319}, {"license": 4, "file_name": "000000010229.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010229.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 20:53:03", "flickr_url": "http://farm6.staticflickr.com/5312/6915913274_7d268c51fd_z.jpg", "id": 10229}, {"license": 4, "file_name": "000000010073.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010073.jpg", "height": 469, "width": 640, "date_captured": "2013-11-21 05:37:17", "flickr_url": "http://farm5.staticflickr.com/4038/4663314869_680cc1b4c9_z.jpg", "id": 10073}, {"license": 1, "file_name": "000000010342.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010342.jpg", "height": 640, "width": 478, "date_captured": "2013-11-16 14:34:19", "flickr_url": "http://farm9.staticflickr.com/8436/7984397533_7a232d7e44_z.jpg", "id": 10342}, {"license": 3, "file_name": "000000010244.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010244.jpg", "height": 640, "width": 475, "date_captured": "2013-11-16 16:56:12", "flickr_url": "http://farm9.staticflickr.com/8453/8055076139_cd811120a4_z.jpg", "id": 10244}, {"license": 5, "file_name": "000000010005.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010005.jpg", "height": 400, "width": 500, "date_captured": "2013-11-18 11:09:03", "flickr_url": "http://farm3.staticflickr.com/2558/4197396435_45d477dc72_z.jpg", "id": 10005}, {"license": 5, "file_name": "000000010083.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010083.jpg", "height": 480, "width": 640, "date_captured": "2013-11-22 00:56:30", "flickr_url": "http://farm3.staticflickr.com/2033/2033435444_1b91e9988c_z.jpg", "id": 10083}, {"license": 5, "file_name": "000000010420.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010420.jpg", "height": 375, "width": 500, "date_captured": "2013-11-17 06:42:55", "flickr_url": "http://farm2.staticflickr.com/1213/1165637087_cf1cc6a168_z.jpg", "id": 10420}, {"license": 2, "file_name": "000000010281.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010281.jpg", "height": 427, "width": 640, "date_captured": "2013-11-22 14:50:06", "flickr_url": "http://farm9.staticflickr.com/8337/8244811136_bd49523ae1_z.jpg", "id": 10281}, {"license": 3, "file_name": "000000010175.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010175.jpg", "height": 480, "width": 640, "date_captured": "2013-11-14 20:17:42", "flickr_url": "http://farm9.staticflickr.com/8103/8549598429_22f161d92e_z.jpg", "id": 10175}, {"license": 5, "file_name": "000000010303.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010303.jpg", "height": 468, "width": 640, "date_captured": "2013-11-19 21:21:59", "flickr_url": "http://farm3.staticflickr.com/2509/4198054407_db61df57cc_z.jpg", "id": 10303}, {"license": 6, "file_name": "000000010346.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010346.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 20:02:54", "flickr_url": "http://farm4.staticflickr.com/3498/3456906266_7257a4a061_z.jpg", "id": 10346}, {"license": 4, "file_name": "000000010309.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010309.jpg", "height": 500, "width": 333, "date_captured": "2013-11-19 21:48:30", "flickr_url": "http://farm1.staticflickr.com/71/191429048_ad837c4f93_z.jpg", "id": 10309}, {"license": 5, "file_name": "000000010094.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010094.jpg", "height": 500, "width": 500, "date_captured": "2013-11-22 20:54:17", "flickr_url": "http://farm3.staticflickr.com/2289/2461849747_8a952aac05_z.jpg", "id": 10094}, {"license": 3, "file_name": "000000010358.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010358.jpg", "height": 640, "width": 478, "date_captured": "2013-11-18 15:08:37", "flickr_url": "http://farm7.staticflickr.com/6188/6135058772_4d7a2c78c7_z.jpg", "id": 10358}], "annotations": [{"segmentation": [[411.45, 288.12, 377.89, 293.54, 374.64, 196.09, 388.72, 184.18, 384.38, 165.77, 406.04, 164.69, 407.12, 185.26, 422.28, 193.92, 424.45, 289.21]], "area": 5224.604, "iscrowd": 0, "image_id": 10149, "bbox": [374.64, 164.69, 49.81, 128.85], "category_id": 44, "id": 81885}, {"segmentation": [[495.45, 170.7, 491.29, 189.44, 484.0, 197.76, 471.51, 212.34, 472.55, 233.15, 474.63, 286.24, 536.04, 292.48, 541.25, 284.15, 540.21, 227.95, 539.17, 204.01, 522.51, 189.44, 517.31, 177.99, 517.31, 170.7, 513.14, 167.58]], "area": 6900.9613500000005, "iscrowd": 0, "image_id": 10149, "bbox": [471.51, 167.58, 69.74, 124.9], "category_id": 44, "id": 87365}, {"segmentation": [[555.66, 161.87, 559.1, 181.1, 553.6, 202.38, 549.48, 223.67, 547.42, 246.33, 550.17, 261.44, 552.23, 282.04, 554.98, 288.91, 574.89, 287.54, 588.62, 286.85, 591.37, 281.36, 591.37, 212.69, 588.62, 197.58, 581.07, 182.47, 578.32, 165.99, 573.52, 158.44, 564.59, 157.75]], "area": 4584.169500000003, "iscrowd": 0, "image_id": 10149, "bbox": [547.42, 157.75, 43.95, 131.16], "category_id": 44, "id": 90634}, {"segmentation": [[602.27, 163.7, 591.8, 199.75, 591.8, 228.25, 594.13, 284.65, 599.94, 290.46, 605.18, 252.67, 606.34, 213.13, 605.76, 169.52, 605.76, 153.24, 600.52, 152.66, 602.27, 163.12]], "area": 1422.607900000004, "iscrowd": 0, "image_id": 10149, "bbox": [591.8, 152.66, 14.54, 137.8], "category_id": 44, "id": 91251}, {"segmentation": [[37.78, 483.24, 38.74, 516.35, 43.3, 517.07, 49.54, 517.79, 54.1, 519.71, 54.58, 524.27, 54.1, 533.15, 54.1, 534.59, 57.46, 530.03, 57.46, 489.47, 56.5, 488.27, 51.46, 486.6, 50.98, 482.52, 49.3, 480.12, 48.34, 478.44, 45.7, 477.0, 50.26, 472.44, 56.5, 473.4, 50.02, 468.36, 43.78, 465.96, 41.38, 466.44, 38.74, 468.36, 41.14, 470.76, 41.14, 476.28, 41.14, 479.4, 38.26, 482.52]], "area": 833.6604000000004, "iscrowd": 0, "image_id": 10290, "bbox": [37.78, 465.96, 19.68, 68.63], "category_id": 44, "id": 92202}, {"segmentation": [[88.39, 472.46, 92.51, 447.79, 108.95, 417.99, 138.76, 391.26, 165.48, 380.99, 195.29, 376.87, 232.29, 376.87, 240.51, 364.54, 244.63, 341.93, 217.9, 321.37, 211.73, 313.15, 203.51, 316.23, 190.15, 330.62, 189.12, 330.62, 189.12, 341.93, 213.79, 360.43, 231.26, 363.51, 227.15, 374.82, 187.07, 360.43, 174.73, 345.01, 172.68, 317.26, 164.45, 310.06, 160.34, 327.54, 160.34, 330.62, 156.23, 338.84, 144.93, 347.07, 139.79, 343.98, 148.01, 331.65, 155.2, 302.87, 152.12, 278.2, 162.4, 276.15, 171.65, 276.15, 176.79, 285.4, 180.9, 299.79, 195.29, 305.95, 199.4, 296.7, 188.09, 276.15, 201.46, 268.95, 211.73, 278.2, 214.82, 286.42, 217.9, 300.81, 226.12, 305.95, 242.57, 302.87, 265.18, 290.54, 281.63, 302.87, 274.43, 331.65, 278.54, 334.73, 345.35, 335.76, 342.27, 348.09, 287.79, 352.21, 280.6, 357.34, 294.99, 380.99, 324.8, 403.6, 374.13, 456.02, 386.47, 476.57, 388.52, 478.63, 89.42, 478.63, 89.42, 478.63], [452.25, 355.29, 456.36, 361.46, 448.14, 392.29, 473.83, 417.99, 515.97, 446.77, 528.31, 459.1, 515.97, 477.6, 571.48, 479.66, 640.0, 478.63, 639.31, 388.18, 609.51, 375.85, 561.2, 370.71, 512.89, 380.99, 499.53, 390.24, 470.75, 343.98, 473.83, 335.76, 470.75, 333.7, 451.22, 351.18], [435.8, 425.18, 452.25, 436.49, 440.94, 480.0, 422.44, 480.0, 437.86, 430.32]], "area": 49315.70765, "iscrowd": 0, "image_id": 10393, "bbox": [88.39, 268.95, 551.61, 211.05], "category_id": 2, "id": 129872}, {"segmentation": [[23.93, 448.38, 9.79, 378.77, 4.35, 357.02, 7.61, 355.93, 4.35, 309.16, 8.7, 259.13, 3.26, 147.1, 20.67, 139.49, 38.07, 128.61, 53.29, 115.56, 65.26, 103.6, 79.4, 76.41, 106.59, 47.04, 127.25, 41.6, 150.09, 49.22, 166.41, 62.27, 174.02, 85.11, 168.58, 114.47, 160.97, 134.05, 156.62, 155.8, 151.18, 161.24, 147.92, 163.42, 145.74, 164.51, 152.27, 202.57, 171.85, 258.04, 199.04, 299.37, 239.28, 336.35, 250.16, 347.23, 254.51, 371.16, 255.6, 387.47, 247.98, 387.47, 226.23, 367.89, 209.91, 343.97, 203.39, 323.3, 160.97, 299.37, 137.04, 280.88, 145.74, 383.12, 164.23, 396.17, 158.8, 404.87, 153.36, 423.36, 155.53, 454.91, 154.44, 477.75, 60.91, 478.83, 39.16, 472.31, 34.8, 471.22, 26.1, 434.24, 15.23, 400.52, 7.61, 364.63]], "area": 60447.9789, "iscrowd": 0, "image_id": 10149, "bbox": [3.26, 41.6, 252.34, 437.23], "category_id": 1, "id": 191566}, {"segmentation": [[248.96, 301.31, 271.98, 279.19, 277.85, 275.58, 294.1, 271.06, 299.52, 265.65, 299.52, 261.58, 353.69, 207.41, 362.71, 216.89, 372.64, 221.41, 379.87, 222.76, 382.12, 223.21, 385.28, 226.82, 393.41, 231.79, 398.37, 237.66, 399.28, 240.37, 406.95, 245.78, 407.85, 246.23, 410.56, 252.55, 414.17, 251.2, 415.53, 257.52, 416.43, 266.1, 415.08, 269.71, 411.01, 272.87, 403.34, 275.58, 396.57, 279.19, 390.7, 282.8, 383.48, 290.02, 379.87, 293.18, 375.8, 297.69, 370.39, 301.76, 355.94, 317.1, 350.53, 325.68, 345.56, 334.71, 342.4, 344.19, 341.5, 346.9, 344.66, 352.31, 363.62, 368.56, 379.87, 382.56, 388.44, 432.66, 390.7, 455.68, 389.8, 478.25, 424.56, 476.45, 429.07, 415.06, 469.24, 453.88, 476.01, 464.71, 468.34, 477.35, 518.45, 475.55, 528.38, 457.04, 451.64, 389.78, 451.19, 359.08, 460.67, 342.38, 521.15, 308.08, 536.5, 274.67, 537.41, 265.65, 533.34, 243.98, 533.34, 235.4, 501.29, 197.94, 508.97, 177.62, 507.16, 146.48, 457.51, 110.36, 442.61, 103.59, 419.59, 89.6, 385.28, 74.25, 351.43, 86.89, 341.5, 77.41, 329.76, 77.41, 329.31, 81.02, 325.25, 69.29, 321.19, 65.68, 317.57, 51.68, 314.41, 44.01, 307.64, 36.79, 295.46, 32.27, 287.33, 31.37, 278.75, 30.92, 268.37, 34.53, 259.34, 42.2, 253.48, 47.62, 249.41, 55.74, 248.06, 64.32, 250.77, 70.19, 255.28, 73.8, 257.09, 85.09, 265.66, 95.47, 271.53, 102.24, 274.24, 111.72, 283.27, 122.55, 286.43, 125.26, 289.59, 130.68, 291.39, 135.19, 300.87, 141.51, 303.13, 144.22, 303.58, 147.38, 303.13, 150.54, 290.94, 173.56, 285.07, 184.39, 265.66, 199.74, 257.09, 215.09, 255.28, 224.12, 250.32, 234.5, 245.8, 242.62, 242.64, 249.39, 238.58, 257.07, 236.32, 258.87, 232.26, 264.74, 228.65, 270.16, 225.04, 272.42, 212.4, 285.06, 207.43, 291.37, 204.27, 299.05, 206.08, 300.4, 220.52, 300.4, 222.33, 300.4, 227.75, 303.56, 230.45, 305.82, 227.29, 307.63, 224.59, 308.53, 223.23, 309.43, 222.33, 310.78, 235.42, 318.01, 239.48, 309.43, 241.74, 307.17]], "area": 65796.14955, "iscrowd": 0, "image_id": 10393, "bbox": [204.27, 30.92, 333.14, 447.33], "category_id": 1, "id": 207348}, {"segmentation": [[263.8, 396.69, 265.04, 408.54, 265.67, 417.88, 267.53, 422.87, 278.75, 422.87, 291.84, 422.87, 301.19, 418.51, 299.32, 407.29, 301.19, 395.45, 300.56, 387.97, 302.43, 385.48, 306.17, 382.98, 311.16, 381.11, 315.52, 379.24, 314.9, 374.88, 318.01, 369.9, 321.13, 361.17, 317.39, 352.45, 314.9, 351.2, 309.91, 341.85, 305.55, 338.74, 300.56, 337.49, 295.58, 335.0, 289.97, 335.62, 286.85, 335.0, 279.38, 329.39, 273.77, 329.39, 268.78, 331.88, 261.3, 335.62, 256.32, 338.11, 249.46, 339.98, 247.59, 342.47, 246.35, 353.07, 251.33, 353.07, 256.32, 355.56, 256.94, 359.3, 260.06, 364.91, 258.19, 369.27, 266.29, 377.37, 262.55, 383.61, 266.29, 385.48, 266.91, 387.97, 266.91, 392.33, 264.42, 396.07]], "area": 4257.51855, "iscrowd": 0, "image_id": 10428, "bbox": [246.35, 329.39, 74.78, 93.48], "category_id": 64, "id": 291506}, {"segmentation": [[0.0, 276.54, 88.77, 286.56, 90.2, 633.05, 0.0, 631.61]], "area": 31385.451349999996, "iscrowd": 0, "image_id": 10114, "bbox": [0.0, 276.54, 90.2, 356.51], "category_id": 82, "id": 332730}, {"segmentation": [[565.68, 223.65, 579.27, 218.83, 592.01, 219.97, 600.78, 225.06, 607.86, 234.12, 608.99, 244.88, 604.75, 254.79, 595.12, 264.7, 582.1, 272.91, 571.62, 273.19, 560.02, 268.95, 554.92, 264.13, 551.81, 258.19, 550.96, 248.28, 550.96, 238.09, 553.79, 231.29, 557.75, 226.2]], "area": 2450.2187000000004, "iscrowd": 0, "image_id": 10192, "bbox": [550.96, 218.83, 58.03, 54.36], "category_id": 85, "id": 334198}, {"segmentation": [[262.66, 510.94, 260.07, 500.41, 266.09, 493.39, 275.12, 492.64, 285.4, 496.65, 301.45, 506.18, 310.47, 513.95, 314.74, 518.97, 320.5, 523.48, 330.78, 539.03, 338.31, 551.56, 341.06, 568.87, 339.31, 572.88, 324.26, 577.39, 309.72, 569.87, 287.91, 551.82, 276.12, 538.53, 266.09, 525.24, 262.58, 518.22]], "area": 3597.4312999999993, "iscrowd": 0, "image_id": 10039, "bbox": [260.07, 492.64, 80.99, 84.75], "category_id": 85, "id": 334903}, {"segmentation": [[198.34, 77.48, 190.3, 74.6, 182.26, 64.28, 178.93, 55.48, 179.08, 43.65, 181.96, 38.34, 184.39, 33.48, 187.27, 30.52, 189.27, 28.92, 195.58, 27.61, 199.58, 27.61, 202.58, 29.12, 206.59, 31.72, 209.29, 34.72, 211.59, 37.22, 214.3, 42.33, 215.7, 45.93, 216.1, 52.84, 215.8, 57.14, 213.89, 63.35, 212.19, 66.95, 210.69, 69.55, 208.49, 71.56, 205.39, 73.56, 203.99, 74.96]], "area": 1406.5342999999998, "iscrowd": 0, "image_id": 10192, "bbox": [178.93, 27.61, 37.17, 49.87], "category_id": 85, "id": 340757}, {"segmentation": [[461.26, 331.71, 524.92, 335.06, 534.97, 340.64, 538.32, 348.46, 538.32, 352.93, 529.39, 415.47, 526.04, 440.04, 491.42, 433.34, 494.77, 400.95, 497.0, 380.85, 494.77, 374.15, 474.66, 371.91, 463.49, 362.98, 464.61, 351.81, 460.14, 339.52]], "area": 5156.796500000002, "iscrowd": 0, "image_id": 10192, "bbox": [460.14, 331.71, 78.18, 108.33], "category_id": 62, "id": 381435}, {"segmentation": [[547.37, 443.83, 550.73, 424.8, 550.73, 408.01, 548.49, 397.94, 547.37, 383.38, 547.37, 378.91, 550.73, 373.31, 573.12, 366.59, 599.98, 367.71, 621.25, 369.95, 636.92, 371.07, 640.0, 378.91, 640.0, 391.22, 640.0, 412.49, 640.0, 422.56, 640.0, 428.16, 638.04, 432.64, 629.09, 434.88, 612.3, 438.23, 610.06, 446.07, 606.7, 452.78, 586.55, 451.67, 568.64, 449.43, 558.57, 444.95, 550.73, 441.59]], "area": 6870.079099999999, "iscrowd": 0, "image_id": 10192, "bbox": [547.37, 366.59, 92.63, 86.19], "category_id": 62, "id": 384254}, {"segmentation": [[300.65, 121.53, 320.66, 109.44, 328.73, 107.91, 339.98, 109.86, 345.13, 107.22, 351.38, 105.55, 371.39, 108.75, 386.68, 120.42, 400.3, 140.29, 404.75, 162.95, 404.19, 167.26, 402.94, 191.86, 402.11, 214.93, 401.0, 219.93, 428.65, 231.61, 443.11, 236.19, 451.45, 240.5, 454.5, 249.4, 457.01, 259.26, 456.17, 272.33, 456.45, 289.56, 459.37, 296.23, 460.34, 309.44, 463.26, 317.5, 461.73, 326.95, 463.82, 337.51, 464.09, 341.96, 460.2, 343.63, 461.18, 357.94, 473.27, 372.26, 473.27, 376.29, 471.6, 378.93, 481.61, 393.38, 490.5, 410.89, 495.37, 421.04, 495.23, 423.68, 492.31, 428.27, 491.89, 435.35, 424.35, 424.65, 416.98, 425.07, 402.8, 423.54, 360.0, 416.31, 356.94, 416.59, 355.55, 408.25, 355.97, 405.33, 352.07, 398.94, 332.34, 393.1, 286.89, 388.38, 264.38, 389.63, 254.93, 392.27, 248.95, 394.35, 246.73, 393.94, 244.64, 373.09, 242.42, 353.91, 244.64, 325.14, 247.84, 295.12, 247.42, 268.85, 245.75, 253.43, 240.19, 248.7, 231.99, 238.14, 229.35, 229.1, 228.52, 220.9, 228.94, 216.32, 230.05, 214.79, 228.52, 209.51, 229.08, 204.5, 232.55, 202.98, 237.83, 202.42, 238.25, 197.69, 241.45, 197.0, 251.73, 198.67, 256.04, 199.36, 254.65, 196.17, 252.15, 192.13, 252.15, 190.47, 254.09, 190.47, 259.79, 192.41, 261.88, 192.69, 262.15, 190.05, 263.82, 187.13, 265.91, 185.46, 267.02, 184.21, 268.96, 185.46, 271.05, 192.69, 274.11, 204.09, 274.52, 211.73, 276.75, 220.35, 276.75, 235.36, 274.66, 254.4, 274.66, 265.52, 272.72, 277.19, 272.99, 294.15, 274.11, 305.54, 275.36, 299.71, 273.97, 287.2, 274.38, 278.58, 277.72, 273.3, 279.8, 270.38, 279.67, 261.49, 282.17, 254.54, 285.5, 247.31, 295.79, 241.47, 306.49, 238.42, 313.3, 236.89, 308.3, 227.58, 302.32, 216.73, 295.93, 199.5, 294.4, 191.58, 288.28, 184.49, 283.83, 176.29, 280.22, 166.15, 278.97, 159.34, 282.03, 143.07, 292.87, 130.57]], "area": 53402.56380000003, "iscrowd": 0, "image_id": 10192, "bbox": [228.52, 105.55, 266.85, 329.8], "category_id": 1, "id": 446799}, {"segmentation": [[410.92, 83.19, 427.96, 75.17, 436.98, 75.17, 450.01, 85.19, 458.03, 101.23, 467.05, 134.3, 466.04, 143.32, 476.07, 150.34, 476.07, 166.37, 486.09, 171.38, 493.11, 190.43, 502.13, 229.51, 506.13, 259.58, 500.12, 276.62, 496.11, 278.62, 483.08, 280.63, 462.04, 308.69, 465.04, 331.74, 460.03, 342.77, 381.86, 336.76, 366.82, 322.72, 360.81, 302.68, 347.78, 289.65, 364.82, 263.59, 351.79, 249.56, 360.81, 172.39, 381.86, 156.35, 386.87, 144.32, 380.85, 134.3, 380.85, 122.27, 390.88, 115.26, 394.89, 98.22]], "area": 28784.099999999995, "iscrowd": 0, "image_id": 10463, "bbox": [347.78, 75.17, 158.35, 267.6], "category_id": 1, "id": 503497}, {"segmentation": [[181.82, 219.48, 174.78, 175.29, 168.76, 169.26, 210.95, 154.19, 355.59, 252.63, 360.62, 261.67, 354.59, 275.74, 350.57, 285.78, 355.59, 296.83, 358.61, 306.88, 367.65, 328.98, 379.7, 336.01, 408.83, 344.04, 431.94, 347.06, 447.0, 347.06, 462.07, 346.05, 466.09, 362.12, 470.11, 374.18, 482.16, 378.2, 496.23, 371.16, 512.3, 363.13, 516.32, 360.11, 545.45, 378.2, 539.42, 387.24, 530.38, 394.27, 525.36, 437.46, 518.32, 439.47, 515.31, 438.47, 514.31, 398.29, 471.11, 427.42, 466.09, 439.47, 447.0, 440.48, 446.0, 423.4, 262.18, 251.63, 268.2, 305.87, 259.16, 307.88, 254.14, 290.8, 252.13, 245.6, 180.81, 182.32, 186.84, 215.47]], "area": 21156.32775, "iscrowd": 0, "image_id": 10463, "bbox": [168.76, 154.19, 376.69, 286.29], "category_id": 15, "id": 574554}, {"segmentation": [[473.12, 147.66, 474.13, 165.74, 482.16, 165.74, 489.19, 176.79, 489.19, 186.84, 490.2, 187.84, 516.32, 202.91, 511.29, 250.12, 518.32, 253.14, 525.36, 248.11, 525.36, 211.95, 639.87, 279.25, 637.86, 224.0]], "area": 7383.804549999999, "iscrowd": 0, "image_id": 10463, "bbox": [473.12, 147.66, 166.75, 131.59], "category_id": 15, "id": 575438}, {"segmentation": [[164.32, 479.28, 172.97, 493.69, 184.5, 496.58, 201.8, 496.58, 213.33, 486.49, 214.77, 472.07, 201.8, 464.86, 197.48, 479.28, 177.3, 474.95, 177.3, 469.19, 167.21, 473.51, 167.21, 477.84]], "area": 982.9235000000003, "iscrowd": 0, "image_id": 10428, "bbox": [164.32, 464.86, 50.45, 31.72], "category_id": 51, "id": 712505}, {"segmentation": [[221.92, 426.81, 168.95, 436.83, 173.24, 474.05, 178.97, 519.87, 229.08, 522.73, 230.51, 488.37, 236.24, 448.28]], "area": 5191.05035, "iscrowd": 0, "image_id": 10115, "bbox": [168.95, 426.81, 67.29, 95.92], "category_id": 70, "id": 1093932}, {"segmentation": [[368.02, 601.42, 322.65, 600.39, 311.31, 575.64, 306.15, 556.05, 318.52, 547.8, 303.06, 532.33, 295.84, 503.46, 292.75, 500.37, 281.4, 482.84, 286.56, 464.27, 276.25, 399.31, 277.28, 397.25, 381.43, 395.19, 389.67, 414.78, 387.61, 432.31, 378.33, 465.31, 361.83, 481.8, 378.33, 491.09, 387.61, 516.86, 381.43, 535.42, 378.33, 542.64, 364.93, 546.77]], "area": 16832.950249999998, "iscrowd": 0, "image_id": 10290, "bbox": [276.25, 395.19, 113.42, 206.23], "category_id": 70, "id": 1094202}, {"segmentation": [[214.29, 572.4, 155.33, 632.81, 126.56, 632.81, 92.04, 632.81, 86.29, 430.02, 79.1, 376.81, 99.24, 368.18, 211.42, 395.51]], "area": 29809.95354999999, "iscrowd": 0, "image_id": 10114, "bbox": [79.1, 368.18, 135.19, 264.63], "category_id": 79, "id": 1127226}, {"segmentation": [[125.97, 542.33, 88.34, 584.21, 81.98, 592.16, 311.5, 628.73, 321.57, 524.84, 317.86, 520.07, 165.73, 507.35, 168.38, 521.13, 173.68, 526.96, 172.09, 539.15, 156.72, 558.76, 137.63, 565.66, 129.68, 554.52, 130.21, 542.86, 124.38, 540.21]], "area": 18555.994549999996, "iscrowd": 0, "image_id": 10428, "bbox": [81.98, 507.35, 239.59, 121.38], "category_id": 81, "id": 1134617}, {"segmentation": [[49.01, 629.19, 172.97, 630.63, 177.3, 518.2, 60.54, 516.76, 47.57, 627.75]], "area": 13632.745200000003, "iscrowd": 0, "image_id": 10290, "bbox": [47.57, 516.76, 129.73, 113.87], "category_id": 81, "id": 1134747}, {"segmentation": [[318.47, 349.74, 307.73, 358.0, 427.5, 368.74, 428.33, 358.83]], "area": 1100.4525500000007, "iscrowd": 0, "image_id": 10114, "bbox": [307.73, 349.74, 120.6, 19.0], "category_id": 81, "id": 1135189}, {"segmentation": [[548.94, 207.47, 544.32, 207.2, 534.0, 207.74, 525.85, 207.74, 522.59, 207.74, 514.99, 209.64, 514.45, 209.91, 515.26, 213.44, 516.08, 215.61, 514.72, 220.5, 513.36, 221.86, 512.27, 226.75, 510.37, 229.19, 510.1, 230.28, 509.01, 233.54, 507.39, 238.7, 506.84, 245.22, 507.93, 252.28, 516.89, 276.45, 547.31, 275.91, 552.47, 262.6, 548.94, 250.65, 548.94, 243.59, 550.02, 237.61, 553.55, 234.08, 555.45, 232.45, 553.28, 226.75, 547.85, 223.76, 547.04, 222.13, 546.76, 214.46]], "area": 2630.4818500000006, "iscrowd": 0, "image_id": 10192, "bbox": [506.84, 207.2, 48.61, 69.25], "category_id": 86, "id": 1154039}, {"segmentation": [[479.28, 211.12, 482.77, 210.07, 488.34, 210.77, 490.78, 211.12, 495.66, 211.12, 498.8, 207.28, 496.36, 215.65, 496.01, 232.38, 508.21, 239.0, 508.91, 260.61, 499.15, 274.9, 471.27, 276.3, 457.67, 258.17, 457.67, 245.63, 462.55, 237.96, 467.43, 234.12, 464.64, 221.23, 466.73, 212.86, 469.17, 209.38, 470.92, 208.33, 475.1, 207.28, 478.24, 210.42]], "area": 2592.1464499999997, "iscrowd": 0, "image_id": 10192, "bbox": [457.67, 207.28, 51.24, 69.02], "category_id": 86, "id": 1154210}, {"segmentation": [[365.78, 95.19, 416.77, 126.98, 428.76, 156.37, 504.35, 194.77, 504.95, 171.37, 512.75, 147.98, 457.56, 107.18, 438.36, 101.18, 386.17, 71.79, 356.78, 87.39, 359.18, 92.79]], "area": 6931.902250000001, "iscrowd": 0, "image_id": 10393, "bbox": [356.78, 71.79, 155.97, 122.98], "category_id": 27, "id": 1169587}, {"segmentation": [[474.06, 175.64, 485.96, 249.7, 502.49, 280.78, 521.66, 315.82, 522.99, 331.69, 513.07, 358.14, 505.13, 372.69, 487.94, 375.33, 470.75, 373.35, 463.48, 347.56, 465.46, 316.48, 458.85, 283.42, 457.52, 259.62, 460.83, 217.96, 461.49, 188.2, 462.15, 169.03, 467.44, 167.04, 473.39, 167.04]], "area": 7389.887850000001, "iscrowd": 0, "image_id": 10463, "bbox": [457.52, 167.04, 65.47, 208.29], "category_id": 31, "id": 1176483}, {"segmentation": [[0.0, 163.45, 0.0, 163.45, 11.94, 164.61, 12.46, 171.73, 14.53, 177.16, 13.88, 180.78, 11.04, 182.72, 0.0, 183.24]], "area": 245.53195000000005, "iscrowd": 0, "image_id": 10393, "bbox": [0.0, 163.45, 14.53, 19.79], "category_id": 3, "id": 1337570}, {"segmentation": [[25.95, 183.24, 101.62, 181.08, 135.14, 180.0, 135.14, 163.78, 127.57, 157.3, 120.0, 142.16, 25.95, 140.0]], "area": 4218.4301000000005, "iscrowd": 0, "image_id": 10393, "bbox": [25.95, 140.0, 109.19, 43.24], "category_id": 8, "id": 1373987}, {"segmentation": [[167.37, 177.86, 139.8, 177.24, 140.11, 166.09, 143.21, 158.65, 168.3, 156.8, 174.8, 157.42, 178.52, 162.37, 182.24, 162.37, 184.72, 166.71, 184.72, 170.43, 182.55, 175.07, 166.75, 177.24]], "area": 801.1055999999998, "iscrowd": 0, "image_id": 10393, "bbox": [139.8, 156.8, 44.92, 21.06], "category_id": 8, "id": 1374168}, {"segmentation": [[131.13, 322.95, 132.21, 317.89, 133.66, 315.36, 134.2, 311.03, 134.38, 309.04, 138.9, 307.6, 142.87, 309.04, 142.87, 312.47, 148.1, 322.4, 146.12, 329.99, 146.12, 335.77, 146.66, 338.84, 146.12, 340.82, 140.88, 340.64, 139.44, 340.64, 138.72, 339.2, 139.26, 331.61, 138.35, 327.46, 135.28, 325.83, 131.49, 325.65]], "area": 332.86639999999966, "iscrowd": 0, "image_id": 10114, "bbox": [131.13, 307.6, 16.97, 33.22], "category_id": 44, "id": 1490093}, {"segmentation": [[127.15, 364.68, 130.42, 366.72, 133.7, 365.08, 133.08, 362.02, 133.08, 358.13, 140.24, 357.11, 140.65, 345.04, 139.22, 339.92, 138.61, 332.97, 138.4, 328.47, 135.33, 325.19, 128.58, 326.22, 129.4, 334.81, 124.69, 340.13, 126.33, 355.47, 127.76, 364.68]], "area": 453.16710000000023, "iscrowd": 0, "image_id": 10114, "bbox": [124.69, 325.19, 15.96, 41.53], "category_id": 44, "id": 1491594}, {"segmentation": [[123.49, 325.61, 123.49, 312.53, 129.11, 311.68, 128.97, 326.88, 129.11, 333.07, 127.0, 337.85, 125.17, 334.62, 124.19, 327.44, 123.21, 326.04]], "area": 120.98685000000033, "iscrowd": 0, "image_id": 10114, "bbox": [123.21, 311.68, 5.9, 26.17], "category_id": 44, "id": 1492171}, {"segmentation": [[278.33, 296.46, 253.13, 267.67, 250.33, 265.27, 248.33, 266.47, 272.73, 297.26]], "area": 154.0279999999994, "iscrowd": 0, "image_id": 10149, "bbox": [248.33, 265.27, 30.0, 31.99], "category_id": 49, "id": 1522417}, {"segmentation": [[199.63, 483.58, 200.0, 448.54, 208.85, 435.26, 225.08, 431.57, 248.32, 428.99, 257.54, 429.36, 268.98, 432.31, 288.16, 441.16, 294.06, 450.75, 296.28, 468.09, 295.17, 484.0]], "area": 4719.046599999999, "iscrowd": 0, "image_id": 10149, "bbox": [199.63, 428.99, 96.65, 55.01], "category_id": 51, "id": 1536016}, {"segmentation": [[204.4, 347.84, 199.64, 347.98, 198.52, 345.74, 196.42, 344.9, 193.62, 345.6, 190.96, 347.98, 186.62, 347.42, 185.92, 341.68, 185.92, 340.0, 186.34, 339.02, 191.8, 337.34, 197.96, 337.34, 206.79, 337.34, 214.07, 338.6, 216.87, 339.58, 217.57, 340.0, 216.45, 345.32, 215.33, 348.96]], "area": 296.14900000000034, "iscrowd": 0, "image_id": 10114, "bbox": [185.92, 337.34, 31.65, 11.62], "category_id": 51, "id": 1539812}, {"segmentation": [[325.57, 405.95, 324.07, 423.75, 320.88, 423.57, 309.08, 413.07, 309.83, 409.89, 313.2, 407.64, 317.51, 405.95, 321.45, 405.02]], "area": 202.2828000000002, "iscrowd": 0, "image_id": 10115, "bbox": [309.08, 405.02, 16.49, 18.73], "category_id": 81, "id": 1646121}, {"segmentation": [[535.68, 159.5, 548.65, 154.63, 554.81, 146.85, 561.3, 142.95, 578.49, 141.01, 601.52, 139.71, 615.14, 146.2, 619.36, 150.09, 628.76, 151.06, 632.33, 155.28, 536.65, 159.17]], "area": 1084.1826000000005, "iscrowd": 0, "image_id": 10393, "bbox": [535.68, 139.71, 96.65, 19.79], "category_id": 3, "id": 1771663}, {"segmentation": [[425.26, 290.42, 422.3, 200.78, 430.45, 192.63, 437.11, 187.45, 438.6, 180.04, 437.86, 166.71, 461.08, 166.33, 460.7, 173.94, 459.94, 178.13, 458.42, 180.42, 459.56, 186.89, 466.03, 191.84, 473.27, 197.93, 475.55, 204.79, 472.13, 212.4, 474.03, 277.52, 475.17, 292.75, 425.29, 291.99]], "area": 5527.4650999999985, "iscrowd": 0, "image_id": 10149, "bbox": [422.3, 166.33, 53.25, 126.42], "category_id": 44, "id": 1865257}, {"segmentation": [[192.45, 236.99, 199.4, 241.71, 202.13, 247.67, 202.63, 251.64, 200.64, 262.07, 200.64, 268.52, 197.42, 269.52, 194.93, 262.56, 186.24, 260.08, 183.02, 256.6, 184.01, 252.13, 182.02, 246.67, 183.26, 238.97, 185.25, 236.74, 190.46, 236.0, 193.44, 236.99]], "area": 454.67104999999947, "iscrowd": 0, "image_id": 10149, "bbox": [182.02, 236.0, 20.61, 33.52], "category_id": 50, "id": 1895680}, {"segmentation": [[229.14, 134.23, 229.14, 164.75, 233.27, 179.69, 234.54, 188.9, 230.09, 195.26, 224.37, 199.39, 223.74, 206.7, 226.28, 213.06, 231.05, 217.51, 240.26, 217.19, 244.4, 214.01, 249.16, 205.75, 248.53, 198.12, 243.12, 190.49, 238.67, 185.73, 234.86, 129.78, 232.64, 119.61, 229.14, 118.02, 226.91, 119.3, 226.6, 124.06, 226.91, 130.74]], "area": 1010.7432500000004, "iscrowd": 0, "image_id": 10149, "bbox": [223.74, 118.02, 25.42, 99.49], "category_id": 50, "id": 1896038}, {"segmentation": [[261.44, 187.52, 264.09, 194.83, 258.45, 205.46, 254.13, 206.79, 248.81, 205.46, 243.83, 190.18, 246.15, 187.19, 253.46, 185.2, 255.79, 127.39, 254.79, 122.74, 256.12, 106.47, 261.77, 107.79, 260.11, 176.56]], "area": 792.6437999999996, "iscrowd": 0, "image_id": 10149, "bbox": [243.83, 106.47, 20.26, 100.32], "category_id": 50, "id": 1896410}, {"segmentation": [[213.15, 265.86, 216.88, 266.95, 219.07, 269.58, 218.63, 273.97, 217.1, 278.57, 214.91, 280.76, 211.84, 282.74, 206.8, 282.74, 205.7, 281.2, 204.82, 277.69, 205.26, 273.09, 206.14, 268.93, 207.67, 267.17, 209.65, 266.08, 213.59, 265.64]], "area": 191.3573500000002, "iscrowd": 0, "image_id": 10149, "bbox": [204.82, 265.64, 14.25, 17.1], "category_id": 50, "id": 1896507}, {"segmentation": [[216.13, 348.09, 216.96, 349.34, 223.82, 349.96, 231.09, 348.92, 236.49, 347.67, 238.57, 344.76, 238.78, 339.78, 230.88, 331.26, 224.23, 330.43, 220.7, 330.22, 218.83, 330.63, 216.13, 333.75, 212.81, 335.62, 212.81, 338.11, 217.58, 339.36, 217.38, 342.06, 216.55, 348.5]], "area": 373.27934999999997, "iscrowd": 0, "image_id": 10114, "bbox": [212.81, 330.22, 25.97, 19.74], "category_id": 51, "id": 1902891}, {"segmentation": [[374.75, 85.5, 383.09, 68.82, 373.82, 60.48, 372.9, 52.14, 360.85, 41.95, 357.61, 27.59, 359.92, 16.47, 360.85, 16.0, 362.24, 15.54, 369.65, 12.76, 384.94, 12.76, 396.06, 7.66, 404.87, 10.44, 407.65, 14.15, 412.74, 22.49, 412.74, 23.88, 431.28, 22.95, 440.08, 24.81, 442.4, 28.98, 444.71, 46.58, 439.62, 60.95, 433.13, 64.65, 421.08, 61.87, 418.77, 56.78, 412.74, 66.04, 412.74, 79.48, 413.67, 86.89, 409.04, 90.14, 399.31, 90.6, 394.21, 92.45]], "area": 4545.517799999999, "iscrowd": 0, "image_id": 10149, "bbox": [357.61, 7.66, 87.1, 84.79], "category_id": 64, "id": 1954200}, {"segmentation": [[640.0, 452.45, 486.23, 432.3, 342.73, 495.81, 640.0, 497.0]], "area": 12950.418099999999, "iscrowd": 0, "image_id": 10192, "bbox": [342.73, 432.3, 297.27, 64.7], "category_id": 67, "id": 1959512}, {"segmentation": [[476.35, 433.75, 366.62, 481.51, 357.58, 444.07, 365.33, 413.09, 416.96, 429.87, 458.27, 418.25]], "area": 4096.8555000000015, "iscrowd": 0, "image_id": 10192, "bbox": [357.58, 413.09, 118.77, 68.42], "category_id": 67, "id": 1959910}, {"segmentation": [[64.0, 423.19, 1.17, 434.92, 1.17, 454.19, 0.0, 497.0, 344.66, 495.66, 368.54, 483.09, 357.23, 445.39, 365.61, 418.17, 357.23, 416.07, 354.71, 401.41, 340.05, 395.97, 321.62, 391.78, 305.28, 388.43, 288.95, 387.17, 270.94, 390.1, 260.04, 392.61, 246.22, 393.87, 244.13, 393.03, 223.18, 395.97]], "area": 32284.978699999996, "iscrowd": 0, "image_id": 10192, "bbox": [0.0, 387.17, 368.54, 109.83], "category_id": 67, "id": 1962651}, {"segmentation": [[173.57, 461.6, 173.57, 448.46, 177.72, 441.54, 182.56, 439.46, 183.25, 429.09, 185.32, 427.01, 185.32, 416.64, 193.62, 418.71, 199.16, 420.1, 197.08, 423.56, 195.01, 423.56, 194.32, 425.63, 195.01, 431.16, 196.39, 440.16, 205.38, 449.15, 204.0, 470.59, 204.69, 478.2, 187.4, 466.44, 180.48, 461.6]], "area": 1072.58015, "iscrowd": 0, "image_id": 10428, "bbox": [173.57, 416.64, 31.81, 61.56], "category_id": 44, "id": 2094835}, {"segmentation": [[549.64, 321.54, 565.15, 324.8, 575.34, 328.88, 576.98, 340.71, 574.12, 388.44, 573.3, 401.5, 533.33, 400.27, 536.18, 379.06, 530.47, 369.68, 529.25, 328.07, 542.3, 322.77]], "area": 3339.3894999999998, "iscrowd": 0, "image_id": 10149, "bbox": [529.25, 321.54, 47.73, 79.96], "category_id": 47, "id": 2100171}, {"segmentation": [[473.3, 399.75, 510.85, 399.75, 513.38, 330.44, 503.63, 324.66, 488.11, 322.86, 474.39, 326.83, 467.17, 330.08, 470.42, 398.67]], "area": 3221.5601999999994, "iscrowd": 0, "image_id": 10149, "bbox": [467.17, 322.86, 46.21, 76.89], "category_id": 47, "id": 2100778}, {"segmentation": [[411.08, 319.82, 410.61, 354.22, 415.79, 397.09, 451.13, 398.04, 455.37, 324.54, 453.95, 317.47, 412.02, 317.94]], "area": 3292.3652499999985, "iscrowd": 0, "image_id": 10149, "bbox": [410.61, 317.47, 44.76, 80.57], "category_id": 47, "id": 2100798}, {"segmentation": [[259.65, 265.54, 275.7, 287.46, 283.52, 292.54, 288.61, 290.19, 280.0, 281.59, 263.96, 260.85, 261.22, 260.85, 259.26, 263.19]], "area": 251.60530000000043, "iscrowd": 0, "image_id": 10149, "bbox": [259.26, 260.85, 29.35, 31.69], "category_id": 49, "id": 2104794}, {"segmentation": [[270.53, 389.61, 263.96, 401.59, 265.5, 413.18, 267.43, 420.14, 296.41, 421.3, 297.19, 410.86, 292.55, 393.47, 289.07, 391.54]], "area": 876.2192, "iscrowd": 0, "image_id": 10428, "bbox": [263.96, 389.61, 33.23, 31.69], "category_id": 86, "id": 2145731}, {"segmentation": [[412.88, 56.62, 415.85, 88.74, 411.09, 90.52, 399.2, 90.52, 393.85, 90.52, 384.93, 70.3, 386.12, 53.65, 388.5, 50.08, 408.71, 40.57]], "area": 1172.7528499999996, "iscrowd": 0, "image_id": 10149, "bbox": [384.93, 40.57, 30.92, 49.95], "category_id": 86, "id": 2146666}, {"segmentation": [[166.87, 385.21, 194.22, 387.62, 217.76, 389.43, 227.01, 395.06, 230.43, 399.29, 213.33, 400.69, 174.91, 399.49, 156.41, 398.88, 166.87, 394.86, 167.07, 390.44], [95.86, 376.96, 101.49, 376.35, 109.54, 388.22, 103.7, 389.03, 98.67, 388.63, 95.86, 385.81, 95.25, 376.76]], "area": 861.2610499999998, "iscrowd": 0, "image_id": 10149, "bbox": [95.25, 376.35, 135.18, 24.34], "category_id": 49, "id": 2230908}, {"segmentation": [[165.63, 384.82, 168.1, 390.02, 166.62, 392.0, 156.96, 398.69, 165.87, 400.18, 222.09, 400.67, 230.51, 399.19, 226.05, 395.72, 218.38, 391.01, 209.46, 388.29, 166.37, 384.82], [151.26, 393.0, 151.51, 386.56, 153.24, 385.57, 154.73, 389.78, 151.51, 394.23], [101.98, 375.66, 96.78, 376.4, 95.54, 378.88, 95.29, 384.57, 97.52, 387.79, 103.46, 389.78, 106.19, 388.29, 112.38, 387.79, 107.68, 384.57, 102.72, 377.89]], "area": 939.0742000000004, "iscrowd": 0, "image_id": 10149, "bbox": [95.29, 375.66, 135.22, 25.01], "category_id": 49, "id": 2230919}, {"segmentation": [[261.6, 252.03, 268.9, 255.96, 272.83, 262.13, 294.15, 284.58, 289.38, 286.54, 285.45, 285.7, 262.16, 260.45, 259.08, 255.12]], "area": 301.3193999999992, "iscrowd": 0, "image_id": 10149, "bbox": [259.08, 252.03, 35.07, 34.51], "category_id": 49, "id": 2230933}, {"segmentation": [[180.34, 281.37, 174.19, 303.92, 171.12, 319.29, 176.24, 344.9, 215.18, 368.47, 243.87, 363.35, 269.49, 326.46, 283.83, 333.63, 284.86, 324.41, 313.55, 341.83, 402.69, 325.43, 422.16, 331.58, 432.41, 325.43, 446.75, 317.24, 453.93, 302.89, 461.1, 293.67, 478.52, 285.47, 451.88, 261.9, 441.63, 257.81, 418.06, 266.0, 387.32, 279.32, 374.0, 257.81, 350.43, 255.76, 334.04, 317.24, 306.37, 322.36, 299.2, 313.14, 318.67, 285.47, 325.84, 256.78, 313.55, 251.66, 301.25, 232.19, 292.03, 215.79, 293.05, 203.5, 269.49, 204.52, 256.17, 195.3, 248.99, 230.14, 291.0, 246.53, 301.25, 268.05, 301.25, 281.37, 228.5, 288.55]], "area": 19373.624399999997, "iscrowd": 0, "image_id": 10104, "bbox": [171.12, 195.3, 307.4, 173.17], "category_id": 4, "id": 150470}, {"segmentation": [[328.57, 280.82, 328.57, 318.07, 328.57, 331.44, 347.68, 344.81, 599.84, 334.3, 605.57, 309.47, 598.88, 298.96, 595.06, 280.82, 596.97, 271.26, 600.79, 265.53, 603.66, 257.89, 607.48, 219.69, 619.9, 211.09, 628.49, 176.7, 624.67, 170.02, 616.08, 170.02, 589.33, 49.67, 353.41, 46.8, 339.08, 50.62, 332.39, 51.58, 330.48, 75.46, 329.53, 79.28, 315.2, 62.09, 312.34, 59.22, 309.47, 85.01, 305.65, 89.78, 298.01, 107.93, 298.01, 133.72, 331.44, 140.41, 328.57, 159.51, 326.66, 170.02, 364.87, 158.56, 383.97, 150.91, 392.57, 139.45, 403.08, 139.45, 400.21, 148.05, 400.21, 148.05, 408.81, 157.6, 408.81, 166.2, 401.17, 174.79, 389.7, 174.79, 383.02, 184.35, 374.42, 199.63, 328.57, 234.01, 329.53, 309.47]], "area": 78748.37814999999, "iscrowd": 0, "image_id": 10014, "bbox": [298.01, 46.8, 330.48, 298.01], "category_id": 6, "id": 165509}, {"segmentation": [[144.73, 147.18, 132.25, 144.43, 129.5, 135.19, 117.76, 129.7, 110.52, 139.19, 103.53, 143.93, 101.53, 143.69, 91.29, 134.2, 82.8, 140.19, 76.56, 142.19, 66.32, 139.94, 62.83, 118.46, 60.58, 130.7, 55.08, 137.94, 50.84, 141.44, 41.85, 143.19, 40.6, 148.18, 34.11, 152.18, 26.87, 157.67, 19.87, 159.92, 22.12, 160.67, 12.13, 160.67, 0.0, 165.41, 0.4, 169.41, 115.77, 166.66, 134.25, 161.17, 145.48, 148.43], [131.81, 174.16, 129.7, 180.49, 28.34, 183.66, 24.12, 182.08, 31.51, 176.8, 128.64, 174.68]], "area": 3885.831749999999, "iscrowd": 0, "image_id": 10104, "bbox": [0.0, 118.46, 145.48, 65.2], "category_id": 9, "id": 180981}, {"segmentation": [[327.55, 153.42, 326.63, 167.23, 326.63, 176.43, 336.75, 171.83, 343.19, 166.31, 356.99, 158.94, 375.4, 158.02, 385.52, 147.9, 391.96, 139.62, 401.16, 135.94, 403.92, 140.54, 400.24, 144.22, 395.64, 147.9, 398.4, 151.58, 403.0, 152.5, 407.6, 162.63, 400.24, 168.15, 395.64, 174.59, 387.36, 174.59, 385.52, 174.59, 376.32, 181.03, 368.95, 193.91, 356.99, 208.63, 326.63, 232.55, 324.79, 235.31, 324.79, 286.84, 306.39, 308.92, 295.35, 345.72, 290.75, 388.97, 283.39, 404.61, 285.23, 420.25, 247.5, 420.25, 239.22, 352.16, 239.22, 319.96, 239.22, 287.76, 238.3, 258.31, 249.34, 241.75, 261.3, 203.11, 276.03, 172.75, 284.31, 160.79, 292.59, 146.98, 298.11, 137.78, 306.39, 130.42, 316.51, 130.42, 322.95, 131.34, 329.39, 140.54]], "area": 20437.850900000012, "iscrowd": 0, "image_id": 10014, "bbox": [238.3, 130.42, 169.3, 289.83], "category_id": 1, "id": 188926}, {"segmentation": [[124.97, 241.82, 115.85, 223.58, 105.82, 216.28, 112.2, 212.63, 113.11, 198.95, 124.97, 185.27, 140.48, 171.58, 152.34, 167.93, 160.55, 167.93, 170.58, 173.41, 176.97, 187.09, 180.62, 199.86, 181.53, 201.69, 190.65, 217.19, 189.74, 230.88, 185.18, 237.26, 207.98, 243.65, 218.02, 246.38, 235.35, 249.12, 240.82, 261.89, 237.17, 276.49, 237.17, 301.12, 237.17, 318.45, 239.91, 333.96, 234.44, 339.43, 240.82, 364.06, 242.65, 421.53, 133.18, 419.7, 99.43, 417.88, 104.9, 364.06, 90.31, 408.76, 81.19, 415.14, 70.24, 408.76, 63.85, 393.25, 63.85, 358.58, 64.77, 303.85, 83.01, 269.19, 105.82, 257.33]], "area": 33470.63339999999, "iscrowd": 0, "image_id": 10014, "bbox": [63.85, 167.93, 178.8, 253.6], "category_id": 1, "id": 189863}, {"segmentation": [[247.22, 157.92, 241.24, 159.12, 237.66, 161.51, 232.87, 162.71, 228.09, 168.69, 226.89, 169.88, 220.91, 169.28, 218.52, 169.28, 215.53, 171.08, 211.35, 172.87, 204.17, 172.87, 201.78, 172.87, 192.81, 194.4, 192.81, 202.77, 196.4, 209.35, 206.56, 218.32, 208.36, 225.49, 211.35, 232.07, 211.95, 237.45, 217.33, 242.23, 225.1, 244.03, 230.48, 245.82, 231.68, 251.8, 226.89, 262.56, 230.48, 265.55, 239.45, 267.35, 254.4, 270.34, 246.63, 273.92, 232.87, 273.92, 230.48, 273.92, 228.09, 273.33, 222.71, 272.13, 216.13, 275.72, 208.36, 282.29, 206.56, 284.09, 210.15, 294.25, 215.53, 299.64, 217.93, 305.02, 220.91, 311.0, 224.5, 316.38, 226.3, 317.57, 229.88, 318.77, 231.08, 319.96, 235.27, 317.57, 235.86, 312.19, 236.46, 309.8, 237.06, 306.81, 232.28, 300.23, 231.68, 296.65, 231.68, 290.67, 231.68, 289.47, 271.74, 287.08, 281.9, 286.48, 289.68, 283.49, 296.85, 279.9, 301.04, 273.33, 301.64, 268.54, 301.64, 261.96, 298.65, 257.18, 284.3, 247.02, 273.53, 241.04, 263.97, 237.45, 256.19, 230.27, 253.2, 227.28, 249.02, 224.89, 249.62, 214.73, 250.21, 211.74, 250.81, 207.55, 250.81, 204.56, 253.8, 194.4, 255.0, 192.01, 265.76, 199.78, 271.74, 203.96, 275.93, 205.16, 284.89, 203.37, 295.06, 199.78, 299.24, 199.18, 303.43, 195.59, 304.63, 194.4, 305.82, 193.2, 311.2, 192.01, 315.39, 190.81, 317.78, 187.82, 321.97, 184.83, 322.56, 180.65, 320.77, 178.85, 324.36, 178.25, 326.75, 176.46, 324.96, 174.67, 319.57, 174.07, 314.19, 174.07, 310.61, 174.07, 307.02, 176.46, 301.04, 177.66, 293.86, 178.25, 283.7, 178.25, 278.32, 178.25, 274.73, 178.25, 272.34, 174.07, 270.54, 172.27, 266.36, 169.28, 262.77, 166.29, 257.39, 161.51, 251.41, 157.33], [241.24, 129.82, 250.81, 131.61, 257.39, 133.41, 262.77, 134.01, 267.55, 135.2, 271.74, 138.79, 272.34, 135.8, 272.34, 133.41, 268.75, 129.22, 266.36, 125.63, 263.37, 125.04, 256.19, 123.24, 251.41, 122.65, 247.82, 123.84, 243.04, 128.62]], "area": 9512.658049999996, "iscrowd": 0, "image_id": 10104, "bbox": [192.81, 122.65, 133.94, 197.31], "category_id": 1, "id": 190109}, {"segmentation": [[260.44, 204.49, 254.4, 191.28, 247.61, 188.08, 244.78, 179.96, 241.95, 176.0, 240.25, 170.34, 236.1, 167.89, 229.69, 168.46, 226.67, 175.25, 226.1, 179.21, 229.12, 185.62, 224.78, 188.08, 218.18, 195.24, 208.18, 216.0, 208.37, 222.6, 212.71, 226.0, 221.95, 231.09, 221.01, 244.86, 228.74, 254.48, 240.44, 263.54, 239.5, 253.16, 248.93, 245.43, 252.89, 235.24, 253.83, 222.41, 255.91, 209.96, 258.17, 206.56]], "area": 2742.208, "iscrowd": 0, "image_id": 10014, "bbox": [208.18, 167.89, 52.26, 95.65], "category_id": 1, "id": 204203}, {"segmentation": [[271.61, 176.6, 249.89, 156.12, 226.3, 164.81, 225.06, 170.4, 201.48, 171.64, 191.54, 197.09, 205.2, 216.95, 205.82, 235.57, 207.68, 244.26, 197.13, 246.74, 184.72, 236.81, 171.68, 217.57, 154.92, 213.22, 147.48, 213.22, 149.34, 226.88, 138.17, 229.36, 125.13, 233.71, 112.1, 225.64, 109.62, 215.09, 104.65, 204.53, 105.27, 200.19, 109.62, 192.74, 111.48, 185.91, 121.41, 187.15, 126.99, 179.71, 134.44, 161.71, 139.41, 153.02, 160.51, 131.91, 193.41, 118.88, 202.72, 127.57, 213.89, 125.71, 256.72, 127.57, 279.68, 139.98, 289.61, 146.81, 298.3, 154.88, 301.41, 163.57, 279.68, 179.71]], "area": 11033.530300000002, "iscrowd": 0, "image_id": 10104, "bbox": [104.65, 118.88, 196.76, 127.86], "category_id": 1, "id": 225283}, {"segmentation": [[290.63, 176.32, 298.85, 157.84, 329.66, 142.43, 366.63, 123.95, 391.27, 117.79, 408.73, 117.79, 434.41, 131.14, 457.0, 144.49, 476.51, 158.87, 492.94, 170.16, 513.48, 180.43, 529.91, 187.62, 519.64, 198.92, 503.21, 195.84, 459.05, 182.49, 429.27, 182.49, 410.79, 185.57, 403.6, 189.67, 391.27, 168.11, 372.79, 158.87, 346.09, 160.92, 324.52, 170.16, 295.77, 175.3], [295.77, 159.89, 330.68, 141.41, 330.68, 132.16, 313.22, 141.41, 297.82, 150.65]], "area": 8452.299299999999, "iscrowd": 0, "image_id": 10104, "bbox": [290.63, 117.79, 239.28, 81.13], "category_id": 1, "id": 227693}, {"segmentation": [[329.37, 141.53, 329.37, 140.5, 330.4, 139.47, 329.37, 137.41, 329.37, 136.38, 329.37, 130.2, 329.37, 127.12, 329.37, 125.06, 330.4, 121.97, 337.6, 112.71, 338.63, 112.71, 344.81, 111.68, 348.93, 111.68, 355.1, 111.68, 360.25, 117.85, 364.36, 125.06, 364.36, 126.09, 363.34, 128.15, 353.04, 130.2, 344.81, 132.26, 334.52, 138.44, 331.43, 140.5], [383.92, 165.2, 392.16, 174.46, 392.16, 175.49, 393.18, 182.7, 396.27, 184.76, 397.3, 192.99, 397.3, 194.02, 397.3, 197.11, 397.3, 201.22, 395.24, 208.43, 397.3, 215.63, 395.24, 227.99, 395.24, 232.1, 398.33, 238.28, 393.18, 244.45, 390.1, 248.57, 376.72, 249.6, 366.42, 249.6, 357.16, 247.54, 355.1, 245.48, 348.93, 245.48, 345.84, 248.57, 346.87, 261.95, 345.84, 277.39, 334.52, 314.44, 325.25, 319.59, 309.81, 321.65, 304.67, 321.65, 289.23, 317.53, 288.2, 316.5, 294.37, 310.33, 303.64, 308.27, 317.02, 301.06, 323.19, 293.86, 327.31, 276.36, 327.31, 259.89, 327.31, 250.63, 327.31, 234.16, 327.31, 233.13, 313.93, 232.1, 306.73, 231.07, 298.49, 226.96, 314.96, 219.75, 317.02, 219.75, 317.02, 219.75, 313.93, 219.75, 311.87, 218.72, 303.64, 214.6, 301.58, 203.28, 307.75, 196.08, 317.02, 192.99, 320.11, 191.96, 322.16, 186.81, 322.16, 185.78, 329.37, 175.49, 330.4, 173.43, 332.46, 168.29, 333.49, 167.26, 341.72, 166.23, 349.95, 162.11, 365.39, 162.11]], "area": 8872.4605, "iscrowd": 0, "image_id": 10104, "bbox": [288.2, 111.68, 110.13, 209.97], "category_id": 1, "id": 237196}, {"segmentation": [[363.34, 258.86, 396.27, 250.63, 419.95, 242.4, 416.86, 238.28, 385.98, 237.25, 405.54, 221.81, 467.29, 217.69, 500.23, 222.84, 538.31, 258.86, 535.23, 270.19, 565.07, 300.03, 583.6, 323.71, 561.99, 323.71, 552.72, 313.42, 530.08, 302.09, 517.73, 290.77, 495.08, 278.42, 473.47, 269.16, 424.06, 260.92, 395.24, 275.33, 376.72, 287.68, 367.45, 276.36, 366.42, 267.1]], "area": 8580.723049999999, "iscrowd": 0, "image_id": 10104, "bbox": [363.34, 217.69, 220.26, 106.02], "category_id": 1, "id": 237443}, {"segmentation": [[153.17, 326.65, 162.88, 268.4, 163.96, 246.83, 140.22, 121.71, 163.96, 103.37, 166.11, 68.85, 193.08, 65.62, 193.08, 110.92, 199.55, 202.61, 186.61, 248.99, 181.21, 309.39, 179.06, 323.42, 202.79, 344.99, 187.69, 347.15, 186.61, 360.09, 172.58, 362.25]], "area": 10062.564550000003, "iscrowd": 0, "image_id": 10040, "bbox": [140.22, 65.62, 62.57, 296.63], "category_id": 1, "id": 443546}, {"segmentation": [[226.73, 628.69, 311.39, 630.12, 318.57, 564.11, 322.87, 562.68, 330.04, 630.12, 404.66, 632.99, 413.27, 625.82, 400.36, 552.63, 371.66, 489.49, 334.35, 424.92, 324.3, 368.96, 353.0, 370.39, 357.31, 354.61, 363.05, 333.08, 365.92, 305.82, 340.09, 275.68, 312.83, 229.76, 311.39, 209.67, 305.65, 191.02, 289.87, 170.93, 272.65, 160.88, 233.9, 160.88, 228.16, 162.32, 203.77, 173.8, 206.64, 162.32, 219.55, 117.84, 218.12, 104.92, 202.33, 92.01, 185.11, 89.14, 177.94, 80.53, 175.07, 80.53, 170.76, 86.27, 167.89, 92.01, 170.76, 107.79, 172.2, 122.14, 170.76, 149.41, 160.72, 162.32, 143.5, 182.41, 111.93, 244.11, 124.84, 298.64, 139.19, 335.95, 142.06, 401.96, 152.11, 499.54, 196.59, 532.54, 205.2, 533.98, 223.86, 548.33, 231.03, 561.24, 231.03, 577.03, 233.9, 597.12]], "area": 94542.05124999995, "iscrowd": 0, "image_id": 10249, "bbox": [111.93, 80.53, 301.34, 552.46], "category_id": 1, "id": 468383}, {"segmentation": [[208.92, 104.02, 218.76, 98.77, 216.14, 82.36, 219.42, 72.52, 225.33, 68.58, 237.8, 70.55, 246.99, 77.77, 245.67, 84.99, 248.96, 88.27, 246.33, 93.52, 245.02, 96.14, 243.05, 100.74, 239.11, 105.33, 237.14, 107.96, 231.89, 106.64, 231.89, 108.61, 242.39, 117.8, 247.64, 126.99, 246.33, 144.71, 243.05, 158.49, 244.36, 175.56, 249.61, 193.28, 247.64, 196.96, 251.58, 212.05, 251.58, 230.43, 250.27, 259.97, 248.3, 277.03, 247.64, 282.28, 249.61, 286.22, 245.02, 290.16, 246.33, 300.0, 252.24, 309.85, 263.39, 311.81, 267.33, 317.72, 267.33, 321.66, 250.92, 321.66, 240.42, 319.03, 232.55, 319.03, 228.61, 316.41, 230.58, 307.22, 232.55, 295.41, 226.64, 275.06, 225.33, 259.97, 221.39, 243.56, 219.42, 241.59, 214.83, 261.28, 213.51, 270.47, 215.48, 276.37, 212.86, 286.87, 211.55, 291.47, 216.8, 300.0, 216.8, 305.25, 218.11, 308.53, 225.98, 315.75, 227.95, 318.38, 225.33, 322.97, 212.2, 322.32, 200.39, 320.35, 200.39, 313.78, 200.39, 302.63, 200.39, 294.09, 195.14, 291.47, 198.42, 265.87, 200.39, 242.9, 204.98, 219.27, 207.61, 181.21, 209.58, 139.2, 208.26, 128.04, 207.61, 122.79, 201.7, 118.2, 200.39, 113.61, 206.95, 103.76]], "area": 9761.904000000002, "iscrowd": 0, "image_id": 10040, "bbox": [195.14, 68.58, 72.19, 254.39], "category_id": 1, "id": 557625}, {"segmentation": [[2.88, 345.17, 139.51, 316.4, 159.64, 385.44, 148.13, 457.35, 181.21, 517.75, 197.03, 519.19, 0.0, 582.47]], "area": 35454.96620000001, "iscrowd": 0, "image_id": 10249, "bbox": [0.0, 316.4, 197.03, 266.07], "category_id": 15, "id": 573228}, {"segmentation": [[613.45, 363.77, 595.16, 364.84, 582.24, 337.94, 563.95, 333.63, 559.64, 367.0, 538.12, 363.77, 533.81, 343.32, 521.97, 339.01, 515.52, 311.03, 499.37, 312.11, 496.14, 286.28, 526.28, 213.09, 611.3, 217.4, 611.3, 242.15, 618.83, 264.75, 607.0, 287.35, 611.3, 355.16]], "area": 13752.665599999998, "iscrowd": 0, "image_id": 10040, "bbox": [496.14, 213.09, 122.69, 153.91], "category_id": 15, "id": 574806}, {"segmentation": [[2.88, 119.13, 25.89, 145.02, 28.46, 158.84, 45.28, 172.05, 62.69, 190.66, 71.1, 206.28, 74.1, 220.69, 72.9, 236.9, 69.3, 249.51, 68.7, 263.93, 70.5, 297.55, 70.5, 324.58, 65.09, 353.4, 55.48, 369.62, 48.28, 376.82, 39.87, 387.03, 29.06, 390.03, 26.66, 379.82, 26.66, 364.21, 26.06, 349.2, 18.85, 369.62, 17.05, 364.81, 22.46, 349.2, 20.65, 335.99, 15.25, 324.58, 18.25, 310.16, 24.26, 292.15, 30.86, 274.73, 29.06, 270.53, 24.86, 269.93, 18.85, 274.13, 13.45, 278.94, 8.64, 281.34, 9.85, 286.74, 6.84, 292.15, 1.44, 300.56]], "area": 12683.455949999998, "iscrowd": 0, "image_id": 10249, "bbox": [1.44, 119.13, 72.66, 270.9], "category_id": 1, "id": 1210047}, {"segmentation": [[67.97, 403.98, 43.08, 414.51, 36.38, 407.81, 52.65, 391.54, 21.06, 334.1, 16.27, 317.82, 3.83, 281.45, 0.0, 192.42, 18.19, 183.8, 12.44, 149.34, 26.8, 141.68, 43.08, 142.64, 68.93, 158.91, 58.4, 180.93, 91.9, 204.86, 93.82, 220.18, 103.39, 240.28, 103.39, 258.47, 71.8, 286.23, 63.18, 359.95, 67.97, 402.07]], "area": 15610.024899999999, "iscrowd": 0, "image_id": 10014, "bbox": [0.0, 141.68, 103.39, 272.83], "category_id": 1, "id": 1211482}, {"segmentation": [[130.46, 181.94, 125.25, 173.12, 128.85, 170.72, 130.86, 167.12, 130.06, 163.11, 122.84, 159.5, 116.43, 157.1, 106.02, 157.1, 100.01, 161.51, 98.41, 167.12, 100.41, 174.33, 102.81, 177.53, 102.41, 183.54, 96.0, 190.75, 91.6, 195.96, 90.79, 196.76, 90.39, 201.57, 94.4, 219.2, 96.8, 233.22, 103.21, 245.64, 110.83, 251.65, 114.03, 251.65, 114.83, 251.65, 124.05, 247.24, 126.05, 244.84, 125.25, 240.43, 125.25, 240.43, 120.04, 218.39, 116.83, 215.99, 115.63, 210.78, 115.63, 205.17, 116.03, 199.16, 118.04, 195.56]], "area": 2362.5342499999997, "iscrowd": 0, "image_id": 10014, "bbox": [90.39, 157.1, 40.47, 94.55], "category_id": 1, "id": 1243346}, {"segmentation": [[257.51, 200.08, 253.69, 191.46, 244.11, 188.59, 244.11, 179.02, 243.16, 173.27, 237.41, 168.49, 238.37, 161.78, 245.07, 156.04, 250.81, 155.08, 255.6, 162.74, 255.6, 172.31, 257.51, 180.93, 262.3, 194.33]], "area": 549.3787999999997, "iscrowd": 0, "image_id": 10014, "bbox": [237.41, 155.08, 24.89, 45.0], "category_id": 1, "id": 1261907}, {"segmentation": [[193.57, 240.27, 189.49, 221.63, 191.82, 204.74, 186.0, 191.35, 184.83, 179.7, 195.32, 165.72, 199.98, 156.98, 212.21, 159.31, 215.71, 163.97, 213.38, 179.11, 216.29, 197.75, 206.39, 218.14, 222.7, 233.28, 220.95, 244.35, 196.48, 243.19]], "area": 2066.8635999999997, "iscrowd": 0, "image_id": 10014, "bbox": [184.83, 156.98, 37.87, 87.37], "category_id": 1, "id": 1296527}, {"segmentation": [[267.75, 178.82, 266.22, 173.9, 265.14, 172.21, 260.38, 170.37, 259.0, 168.68, 259.15, 166.07, 260.07, 163.61, 261.61, 162.38, 263.61, 162.69, 265.45, 164.69, 268.21, 169.6, 268.98, 171.29, 268.67, 180.66]], "area": 79.33435000000014, "iscrowd": 0, "image_id": 10014, "bbox": [259.0, 162.38, 9.98, 18.28], "category_id": 1, "id": 1304616}, {"segmentation": [[13.9, 150.18, 12.22, 149.15, 9.04, 148.59, 5.03, 149.06, 3.16, 150.56, 2.04, 153.45, 1.85, 155.04, 2.13, 156.82, 3.53, 159.15, 3.44, 160.37, 0.0, 163.64, 0.82, 165.32, 3.16, 166.91, 9.03, 168.91, 9.49, 172.3, 9.95, 175.07, 7.49, 176.14, 9.34, 176.14, 14.57, 179.99, 14.73, 184.3, 15.5, 185.38, 15.96, 185.23, 18.42, 182.61, 17.65, 171.99, 16.88, 165.68, 15.65, 160.29, 15.65, 158.14, 15.03, 154.13, 14.88, 149.98, 13.65, 148.75]], "area": 360.76669999999984, "iscrowd": 0, "image_id": 10014, "bbox": [0.0, 148.59, 18.42, 36.79], "category_id": 1, "id": 1311650}, {"segmentation": [[192.4, 75.91, 204.43, 80.54, 208.13, 94.42, 205.36, 112.94, 200.73, 114.79, 208.13, 121.27, 209.06, 138.86, 205.36, 157.37, 196.1, 116.64, 188.69, 108.31, 191.47, 96.27, 189.62, 82.39, 194.25, 81.46, 195.17, 77.76]], "area": 846.5882, "iscrowd": 0, "image_id": 10040, "bbox": [188.69, 75.91, 20.37, 81.46], "category_id": 1, "id": 1739783}, {"segmentation": [[191.33, 181.69, 184.4, 183.42, 185.37, 189.58, 188.83, 197.66, 192.29, 188.61]], "area": 76.22715, "iscrowd": 0, "image_id": 10014, "bbox": [184.4, 181.69, 7.89, 15.97], "category_id": 27, "id": 1826471}, {"segmentation": [[237.66, 162.32, 237.66, 162.32, 230.67, 159.14, 224.95, 162.64, 222.72, 167.4, 223.36, 172.8, 216.05, 177.25, 215.42, 189.33, 217.32, 195.36, 228.44, 185.83, 225.27, 176.62, 230.03, 167.72, 236.71, 167.4]], "area": 308.0061000000003, "iscrowd": 0, "image_id": 10014, "bbox": [215.42, 159.14, 22.24, 36.22], "category_id": 1, "id": 2007571}, {"segmentation": [[444.75, 174.98, 442.79, 168.27, 441.95, 160.16, 443.91, 151.21, 451.18, 139.46, 459.57, 132.75, 469.08, 129.39, 470.76, 129.39, 472.72, 134.42, 474.4, 140.86, 473.28, 145.61, 467.41, 148.69, 460.69, 151.77, 457.06, 157.08, 452.58, 167.99, 450.06, 173.86], [471.56, 128.24, 469.5, 124.53, 466.93, 122.46, 466.82, 118.44, 467.65, 116.07, 468.06, 112.98, 467.96, 108.65, 467.96, 104.63, 467.96, 102.57, 471.56, 100.4, 475.38, 100.3, 482.49, 100.61, 487.13, 100.71, 489.3, 101.74, 489.91, 105.04, 489.91, 106.79, 480.33, 107.62, 478.47, 108.75, 476.0, 111.12, 474.35, 112.16, 473.42, 114.73, 472.6, 117.93, 472.6, 123.19]], "area": 957.1310000000007, "iscrowd": 0, "image_id": 10040, "bbox": [441.95, 100.3, 47.96, 74.68], "category_id": 1, "id": 2026582}, {"segmentation": [[608.49, 234.45, 622.21, 235.43, 639.86, 236.17, 640.0, 205.29, 625.4, 199.41, 623.68, 198.68, 620.25, 205.78, 618.54, 210.2, 616.58, 211.67, 616.33, 217.06, 612.9, 220.49, 608.74, 222.2]], "area": 874.87125, "iscrowd": 0, "image_id": 10014, "bbox": [608.49, 198.68, 31.51, 37.49], "category_id": 3, "id": 2037311}, {"segmentation": [[472.26, 145.38, 457.27, 156.87, 451.28, 171.85, 446.29, 186.33, 439.3, 200.81, 437.8, 208.3, 449.28, 217.79, 456.78, 206.81, 464.27, 195.82, 469.76, 197.82, 464.76, 208.3, 464.76, 235.77, 464.76, 251.75, 465.26, 268.73, 465.76, 284.21, 468.76, 302.68, 465.76, 324.66, 465.76, 333.15, 456.28, 336.64, 456.28, 344.63, 459.77, 352.62, 461.77, 354.12, 470.76, 354.12, 478.25, 346.63, 480.74, 335.64, 481.74, 337.64, 483.24, 350.12, 474.75, 364.11, 488.73, 369.6, 497.72, 370.6, 503.72, 366.6, 502.72, 353.62, 502.72, 343.63, 505.71, 332.15, 505.71, 310.67, 499.22, 280.21, 507.21, 266.73, 512.7, 251.75, 515.2, 240.26, 516.7, 227.28, 519.2, 221.29, 527.19, 216.79, 534.68, 208.8, 535.68, 198.32, 527.19, 165.86, 515.7, 154.87, 504.22, 147.38, 499.22, 142.39, 500.72, 132.9, 500.72, 128.4, 498.72, 129.9, 499.22, 123.41, 499.22, 119.42, 499.22, 112.42, 494.23, 108.93, 478.25, 110.43, 473.75, 114.42, 471.26, 121.41, 471.26, 130.4, 472.75, 139.89, 466.76, 148.88]], "area": 12529.036600000007, "iscrowd": 0, "image_id": 10040, "bbox": [437.8, 108.93, 97.88, 261.67], "category_id": 1, "id": 2156056}, {"segmentation": [[98.98, 30.09, 107.17, 30.48, 124.34, 36.72, 132.92, 39.84, 139.16, 43.74, 135.26, 59.74, 144.23, 71.44, 131.75, 70.27, 134.87, 76.9, 128.24, 88.99, 129.8, 92.11, 118.88, 95.24, 119.66, 103.43, 129.02, 106.94, 140.33, 124.88, 150.08, 144.0, 153.21, 165.06, 149.69, 172.48, 151.64, 195.49, 160.62, 218.51, 161.4, 235.28, 164.52, 248.94, 160.23, 267.66, 148.13, 270.39, 146.57, 289.9, 137.99, 325.79, 129.8, 356.21, 120.05, 371.43, 113.8, 386.64, 116.54, 394.44, 116.54, 406.93, 114.19, 422.92, 132.92, 436.19, 150.47, 438.14, 152.03, 443.6, 143.84, 452.57, 132.92, 454.13, 117.32, 454.13, 109.51, 449.06, 105.61, 454.91, 83.77, 447.5, 79.48, 443.6, 80.65, 406.93, 70.5, 382.35, 75.57, 343.73, 81.82, 287.56, 77.53, 262.98, 68.55, 231.77, 67.38, 210.71, 65.43, 186.13, 61.92, 161.16, 59.58, 124.49, 67.77, 114.74, 77.53, 104.21, 92.74, 90.16, 93.52, 76.9, 88.84, 66.76, 81.04, 64.81, 81.04, 57.01, 90.4, 48.03, 93.52, 40.23, 93.91, 31.65]], "area": 27117.02940000002, "iscrowd": 0, "image_id": 10040, "bbox": [59.58, 30.09, 104.94, 424.82], "category_id": 1, "id": 2157581}, {"segmentation": [[579.23, 399.33, 577.62, 393.51, 579.23, 379.28, 588.29, 371.19, 596.7, 361.81, 609.0, 362.46, 611.58, 358.57, 624.2, 360.51, 623.88, 365.37, 634.23, 365.37, 639.08, 369.9, 640.0, 372.81, 640.0, 401.92, 631.64, 402.57, 628.08, 407.42, 626.14, 406.13, 624.85, 401.92, 587.0, 396.42, 585.38, 399.98]], "area": 2148.780000000001, "iscrowd": 0, "image_id": 10056, "bbox": [577.62, 358.57, 62.38, 48.85], "category_id": 3, "id": 136050}, {"segmentation": [[517.66, 417.16, 553.33, 405.27, 557.65, 301.52, 337.18, 235.6, 316.65, 230.19, 162.11, 220.47, 161.03, 262.61, 152.38, 338.26, 137.25, 379.33, 132.93, 408.51, 184.8, 422.56, 274.5, 443.09, 311.25, 451.74, 370.69, 444.17, 377.17, 408.51, 384.74, 389.06, 398.78, 386.9, 403.11, 420.4, 402.03, 444.17, 452.82, 434.45, 466.87, 432.29, 501.45, 423.64, 503.61, 398.78, 510.1, 382.57, 517.66, 413.91]], "area": 72983.1538, "iscrowd": 0, "image_id": 10056, "bbox": [132.93, 220.47, 424.72, 231.27], "category_id": 6, "id": 166623}, {"segmentation": [[147.31, 352.29, 89.9, 345.79, 74.74, 351.21, 66.07, 350.13, 57.41, 345.79, 46.58, 343.63, 34.66, 354.46, 20.58, 352.29, 14.08, 344.71, 0.0, 350.13, 1.08, 339.3, 2.17, 272.14, 0.0, 188.74, 161.39, 225.57, 160.31, 241.81, 160.31, 254.81, 157.06, 271.06, 155.97, 285.14, 155.97, 300.3, 153.81, 317.63, 150.56, 341.46]], "area": 22039.122900000002, "iscrowd": 0, "image_id": 10056, "bbox": [0.0, 188.74, 161.39, 165.72], "category_id": 6, "id": 168007}, {"segmentation": [[105.66, 236.51, 112.43, 238.33, 113.58, 239.81, 113.25, 241.13, 112.43, 242.12, 109.79, 243.6, 109.13, 243.77, 107.48, 244.43, 109.13, 243.77, 107.64, 244.92, 108.14, 248.06, 108.14, 248.72, 108.47, 249.71, 107.15, 249.71, 105.5, 249.21, 104.84, 249.05, 104.84, 246.74, 104.34, 248.39, 104.18, 248.39, 103.36, 248.55, 101.87, 248.06, 99.89, 247.4, 98.9, 247.07, 100.22, 243.11, 100.39, 240.14, 100.06, 238.16, 100.06, 235.52, 100.39, 232.06, 101.71, 231.73, 104.67, 232.39, 106.16, 233.05, 105.83, 236.18]], "area": 148.98265000000004, "iscrowd": 0, "image_id": 10056, "bbox": [98.9, 231.73, 14.68, 17.98], "category_id": 1, "id": 211642}, {"segmentation": [[120.15, 302.11, 121.26, 300.3, 121.61, 298.63, 121.26, 296.06, 120.78, 294.8, 119.59, 294.66, 117.37, 294.52, 115.77, 294.52, 115.77, 296.75, 115.49, 299.54, 115.56, 301.34, 115.21, 302.46, 114.23, 304.41, 114.23, 304.41, 114.23, 304.48, 114.23, 306.84, 114.58, 308.03, 114.86, 309.77, 115.0, 310.95, 116.46, 311.37, 118.69, 311.78, 121.89, 311.65, 122.59, 311.3, 122.59, 308.79, 122.45, 307.33, 122.31, 305.73, 121.75, 304.82, 121.06, 303.57, 120.22, 303.29, 119.94, 302.74]], "area": 110.90524999999995, "iscrowd": 0, "image_id": 10056, "bbox": [114.23, 294.52, 8.36, 17.26], "category_id": 1, "id": 216891}, {"segmentation": [[492.94, 324.93, 495.12, 320.58, 499.78, 319.33, 501.65, 321.2, 502.58, 324.93, 503.2, 326.8, 504.14, 329.29, 506.0, 331.78, 508.18, 333.95, 509.74, 338.93, 510.67, 343.28, 511.29, 345.15, 511.29, 347.33, 507.87, 347.95, 491.38, 347.33, 490.76, 341.42, 488.58, 336.13, 490.14, 330.84, 491.38, 327.42]], "area": 436.0946500000001, "iscrowd": 0, "image_id": 10056, "bbox": [488.58, 319.33, 22.71, 28.62], "category_id": 1, "id": 256879}, {"segmentation": [[76.77, 293.36, 75.77, 293.03, 75.59, 292.46, 76.09, 291.28, 76.91, 290.21, 77.81, 289.78, 78.13, 289.53, 77.99, 289.21, 78.17, 288.6, 78.27, 287.95, 78.99, 287.56, 79.6, 287.38, 80.06, 287.38, 80.53, 287.49, 80.85, 287.95, 80.85, 289.1, 80.39, 289.78, 81.06, 290.17, 81.71, 291.24, 81.6, 290.42, 82.28, 290.85, 82.53, 291.67, 82.5, 292.96, 82.28, 293.46, 81.64, 293.61, 81.46, 293.61, 81.42, 294.93, 81.03, 295.47, 80.49, 296.07, 79.63, 296.25, 78.42, 296.25, 76.99, 296.07, 76.63, 295.54, 76.63, 294.68, 76.56, 293.75]], "area": 39.79460000000004, "iscrowd": 0, "image_id": 10056, "bbox": [75.59, 287.38, 6.94, 8.87], "category_id": 1, "id": 257592}, {"segmentation": [[534.28, 216.12, 535.0, 211.78, 535.36, 204.56, 534.28, 199.33, 532.83, 195.9, 532.65, 188.14, 537.35, 182.0, 540.42, 181.64, 545.29, 181.64, 548.0, 185.07, 549.44, 188.68, 549.62, 194.82, 548.54, 200.23, 550.89, 200.59, 549.44, 202.94, 548.54, 205.29, 548.54, 206.19, 548.0, 208.72, 548.0, 212.87, 548.18, 216.3, 544.39, 216.3, 542.76, 219.19, 538.07, 219.01, 538.25, 214.67, 538.97, 212.33, 539.15, 208.17, 537.35, 204.92, 537.35, 209.98, 536.99, 214.13, 535.72, 215.94, 534.82, 216.48]], "area": 493.42755000000017, "iscrowd": 0, "image_id": 10211, "bbox": [532.65, 181.64, 18.24, 37.55], "category_id": 24, "id": 588133}, {"segmentation": [[196.65, 186.38, 195.08, 182.27, 193.32, 186.18, 189.6, 185.6, 188.82, 174.24, 195.28, 167.78, 199.0, 166.61, 204.28, 167.78, 207.02, 170.52, 207.81, 177.18, 207.61, 186.97, 200.96, 187.16, 197.43, 186.77]], "area": 321.0947500000001, "iscrowd": 0, "image_id": 10211, "bbox": [188.82, 166.61, 18.99, 20.55], "category_id": 24, "id": 588435}, {"segmentation": [[208.18, 180.96, 214.86, 170.46, 230.14, 168.55, 230.14, 177.14, 228.23, 189.56, 208.18, 181.92, 208.18, 181.92]], "area": 310.5062999999993, "iscrowd": 0, "image_id": 10211, "bbox": [208.18, 168.55, 21.96, 21.01], "category_id": 24, "id": 591194}, {"segmentation": [[182.73, 413.03, 202.08, 413.77, 205.06, 413.03, 196.13, 403.35, 202.08, 348.29, 205.8, 325.23, 213.99, 313.32, 219.94, 337.88, 222.91, 401.12, 227.38, 406.33, 225.89, 417.49, 245.24, 416.0, 234.82, 401.12, 233.33, 343.83, 237.8, 307.37, 246.72, 283.56, 269.05, 251.56, 272.02, 250.08, 280.21, 253.05, 283.93, 249.33, 297.32, 244.87, 302.53, 244.12, 304.76, 250.82, 301.04, 323.74, 304.02, 353.5, 299.55, 397.4, 302.53, 404.1, 299.55, 412.28, 319.64, 416.75, 315.18, 394.42, 315.92, 386.98, 312.2, 377.31, 313.69, 336.39, 318.9, 321.51, 318.9, 293.98, 322.62, 272.4, 323.36, 311.83, 325.6, 340.11, 327.08, 392.19, 329.32, 403.35, 333.78, 411.54, 328.57, 420.47, 350.89, 423.44, 340.48, 397.4, 338.99, 329.69, 341.22, 305.88, 341.22, 277.61, 348.66, 253.8, 353.13, 232.96, 362.8, 214.36, 362.8, 197.25, 358.33, 183.85, 361.31, 170.46, 391.82, 160.04, 432.74, 143.67, 461.76, 125.07, 466.97, 139.95, 472.18, 154.83, 477.39, 154.83, 480.36, 146.65, 480.36, 128.05, 491.52, 113.17, 493.75, 107.96, 504.92, 99.03, 493.75, 95.31, 493.75, 81.92, 490.03, 81.92, 483.34, 90.1, 477.39, 90.1, 478.87, 78.2, 475.9, 78.2, 466.97, 90.84, 459.53, 90.84, 450.6, 81.17, 451.34, 96.8, 427.53, 110.93, 395.54, 114.65, 346.43, 120.61, 329.32, 116.89, 320.39, 119.12, 302.53, 134.0, 266.07, 157.81, 235.56, 168.97, 210.27, 200.97, 207.29, 224.03, 203.57, 264.21, 190.18, 288.02, 181.25, 313.32, 181.25, 358.71, 187.2, 364.66, 183.48, 392.94, 185.71, 401.86, 185.71, 408.56]], "area": 33446.479349999994, "iscrowd": 0, "image_id": 10211, "bbox": [181.25, 78.2, 323.67, 345.24], "category_id": 25, "id": 598283}, {"segmentation": [[0.95, 401.56, 7.64, 403.47, 6.68, 411.11, 20.05, 411.11, 20.05, 406.33, 26.74, 406.33, 34.38, 408.24, 30.56, 375.77, 34.38, 353.81, 34.38, 335.67, 40.11, 323.25, 37.24, 310.84, 50.61, 260.23, 57.3, 238.26, 48.7, 207.7, 46.79, 184.78, 58.25, 163.77, 77.35, 128.44, 85.95, 101.7, 97.41, 91.2, 111.73, 95.97, 127.96, 103.61, 130.83, 107.43, 134.65, 116.98, 142.29, 108.39, 140.38, 97.88, 133.69, 90.24, 125.1, 74.96, 112.68, 56.82, 104.09, 51.09, 93.59, 55.86, 80.22, 53.95, 79.26, 65.41, 82.13, 71.14, 72.58, 84.51, 61.12, 99.79, 55.39, 109.34, 42.97, 123.67, 28.65, 136.08, 20.05, 145.63, 12.41, 159.0, 0.0, 182.87, 0.95, 272.64, 3.82, 279.32, 3.82, 290.78, 3.82, 312.75, 0.0, 339.49, 0.95, 348.08, 0.95, 371.95, 0.95, 387.23]], "area": 15042.883049999999, "iscrowd": 0, "image_id": 10211, "bbox": [0.0, 51.09, 142.29, 360.02], "category_id": 25, "id": 599408}, {"segmentation": [[506.58, 208.19, 505.99, 208.23, 503.43, 211.01, 501.08, 211.86, 499.59, 209.73, 497.88, 208.66, 496.6, 210.79, 495.96, 216.12, 492.13, 218.89, 489.14, 221.45, 488.29, 222.31, 484.88, 222.31, 483.17, 224.22, 483.17, 226.14, 481.47, 228.7, 482.32, 229.98, 484.67, 229.77, 485.73, 230.83, 487.22, 231.05, 489.57, 229.55, 493.62, 230.62, 501.08, 230.62, 502.57, 232.33, 509.61, 250.23, 518.14, 267.08, 526.24, 276.24, 529.01, 280.29, 529.44, 283.71, 526.45, 289.46, 526.03, 294.58, 527.09, 300.12, 531.36, 308.22, 531.78, 312.91, 530.93, 320.59, 531.36, 329.76, 530.08, 335.51, 528.37, 339.35, 527.94, 345.11, 529.22, 349.58, 529.22, 355.55, 527.94, 364.93, 527.94, 369.84, 526.67, 376.02, 525.39, 381.14, 527.09, 383.91, 531.78, 383.7, 532.42, 381.14, 532.0, 374.31, 531.78, 367.49, 533.49, 355.34, 533.91, 354.06, 535.41, 358.54, 535.62, 368.13, 535.41, 374.53, 533.7, 378.15, 534.34, 384.76, 539.46, 383.48, 541.59, 378.37, 540.52, 371.97, 540.1, 360.24, 539.67, 354.91, 541.16, 351.72, 542.44, 342.33, 542.44, 335.09, 543.08, 326.77, 543.08, 322.51, 544.79, 312.49, 552.04, 308.86, 558.01, 311.63, 566.53, 312.06, 569.09, 310.36, 570.37, 312.91, 573.78, 320.16, 578.47, 328.26, 582.52, 339.14, 585.08, 348.94, 585.72, 354.49, 586.36, 366.21, 585.51, 371.12, 584.65, 381.35, 584.23, 386.68, 582.52, 389.66, 589.56, 388.17, 592.12, 386.89, 594.46, 385.4, 594.68, 380.28, 592.97, 374.74, 592.54, 367.49, 592.76, 357.05, 593.82, 350.22, 596.59, 342.97, 597.02, 339.35, 593.4, 333.59, 590.62, 326.98, 590.62, 324.0, 591.26, 315.9, 593.4, 307.37, 595.74, 296.28, 600.01, 294.15, 604.48, 296.5, 606.4, 300.97, 608.32, 309.93, 607.68, 316.11, 608.53, 320.38, 611.3, 326.13, 611.52, 328.05, 611.3, 336.37, 612.16, 340.2, 613.86, 342.76, 615.36, 342.33, 617.7, 336.58, 616.63, 333.38, 618.34, 334.66, 618.34, 336.79, 618.98, 331.89, 617.06, 328.05, 615.14, 326.13, 610.66, 320.8, 610.24, 315.9, 610.66, 306.52, 609.81, 299.06, 605.97, 293.3, 600.86, 288.61, 593.82, 286.05, 589.98, 282.64, 584.02, 277.52, 568.24, 273.47, 562.06, 270.06, 555.66, 264.73, 548.2, 260.04, 544.57, 257.7, 540.31, 255.35, 534.34, 251.3, 529.86, 245.33, 526.45, 240.64, 519.42, 229.77, 515.15, 224.01, 514.51, 224.01, 517.5, 219.32, 519.63, 216.12, 518.14, 213.56, 515.15, 213.78, 512.81, 214.2, 510.46, 216.34, 508.76, 217.61, 507.69, 214.42, 511.53, 209.73, 510.89, 208.45, 508.97, 209.73, 507.69, 208.66, 506.84, 208.45]], "area": 6104.840349999997, "iscrowd": 0, "image_id": 10211, "bbox": [481.47, 208.19, 137.51, 181.47], "category_id": 25, "id": 600144}, {"segmentation": [[591.22, 367.67, 580.69, 378.73, 577.79, 380.31, 575.42, 378.21, 576.47, 369.25, 577.53, 364.25, 581.48, 360.3, 589.12, 350.55, 613.87, 352.13, 616.77, 358.19, 610.98, 359.51, 608.61, 362.93]], "area": 562.4163500000008, "iscrowd": 0, "image_id": 10056, "bbox": [575.42, 350.55, 41.35, 29.76], "category_id": 3, "id": 1350975}, {"segmentation": [[245.2, 306.16, 237.35, 300.98, 237.01, 292.29, 236.85, 285.78, 234.68, 283.1, 225.49, 281.26, 221.48, 288.78, 221.98, 294.13, 217.13, 304.65, 213.46, 313.34, 213.79, 318.02, 219.97, 327.54, 223.98, 334.06, 229.66, 328.04, 227.16, 324.2, 229.83, 318.85, 237.52, 316.01]], "area": 855.3172000000003, "iscrowd": 0, "image_id": 10056, "bbox": [213.46, 281.26, 31.74, 52.8], "category_id": 1, "id": 1688972}, {"segmentation": [[46.12, 292.07, 46.12, 289.09, 45.98, 286.92, 46.66, 284.62, 48.15, 283.0, 50.72, 282.32, 52.89, 283.0, 54.24, 284.22, 53.57, 286.38, 52.21, 287.46, 52.21, 289.22, 52.21, 290.04, 50.86, 290.71, 50.86, 292.34, 49.37, 292.47, 45.85, 292.2]], "area": 59.632950000000044, "iscrowd": 0, "image_id": 10056, "bbox": [45.85, 282.32, 8.39, 10.15], "category_id": 1, "id": 1726843}, {"segmentation": [[62.6, 293.72, 63.23, 292.12, 65.46, 291.4, 65.19, 290.69, 64.92, 288.81, 65.55, 286.85, 67.6, 284.97, 69.84, 284.88, 71.44, 286.31, 71.53, 289.52, 70.55, 289.97, 69.3, 289.97, 69.84, 291.58, 72.34, 292.56, 73.05, 293.99, 73.05, 295.06]], "area": 60.47485000000014, "iscrowd": 0, "image_id": 10056, "bbox": [62.6, 284.88, 10.45, 10.18], "category_id": 1, "id": 1733772}, {"segmentation": [[136.61, 255.14, 135.55, 249.87, 137.66, 249.16, 138.01, 246.63, 139.42, 244.94, 142.02, 244.87, 143.01, 246.42, 142.17, 250.78, 145.47, 254.3, 145.47, 256.41]], "area": 69.52549999999991, "iscrowd": 0, "image_id": 10056, "bbox": [135.55, 244.87, 9.92, 11.54], "category_id": 1, "id": 1746835}, {"segmentation": [[463.74, 314.78, 434.48, 319.21, 420.3, 307.68, 414.98, 281.97, 414.09, 252.71, 397.24, 242.96, 386.6, 219.9, 391.03, 197.73, 403.45, 189.75, 411.43, 182.66, 411.43, 160.49, 391.03, 147.19, 381.28, 137.44, 383.05, 125.02, 400.79, 112.61, 407.88, 108.18, 409.66, 89.56, 419.41, 55.86, 427.39, 47.88, 495.67, 51.43, 500.1, 89.56, 488.57, 135.67, 490.34, 161.38, 485.02, 193.3, 485.02, 215.47, 485.02, 242.96, 478.82, 289.06, 469.95, 315.67]], "area": 22016.922049999997, "iscrowd": 0, "image_id": 10256, "bbox": [381.28, 47.88, 118.82, 271.33], "category_id": 11, "id": 1808675}, {"segmentation": [[169.37, 195.23, 191.35, 183.6, 218.51, 182.3, 234.02, 183.6, 256.0, 191.35, 276.69, 200.4, 293.49, 202.99, 315.47, 206.87, 333.58, 219.8, 332.28, 232.73, 343.92, 239.19, 363.31, 245.66, 380.12, 257.29, 395.64, 277.98, 391.76, 293.49, 387.88, 299.96, 402.1, 307.72, 416.32, 315.47, 430.55, 329.7, 435.72, 352.97, 447.35, 373.66, 465.45, 407.27, 473.21, 430.55, 477.09, 483.56, 475.8, 515.88, 458.99, 535.27, 451.23, 543.03, 468.04, 616.73, 475.8, 632.24, 447.35, 632.24, 438.3, 630.95, 429.25, 629.66, 424.08, 575.35, 382.71, 576.65, 334.87, 580.53, 301.25, 583.11, 281.86, 599.92, 254.71, 618.02, 219.8, 628.36, 201.7, 632.24, 147.39, 632.24, 139.64, 627.07, 156.44, 611.56, 217.21, 601.21, 246.95, 583.11, 253.41, 576.65, 227.56, 572.77, 221.09, 568.89, 226.26, 554.67, 252.12, 532.69, 256.0, 524.93, 230.14, 541.74, 210.75, 537.86, 188.77, 533.98, 162.91, 530.1, 153.86, 533.98, 143.52, 533.98, 131.88, 527.52, 124.12, 522.34, 115.07, 513.29, 121.54, 501.66, 137.05, 504.24, 155.15, 508.12, 190.06, 513.29, 201.7, 506.83, 187.47, 502.95, 195.23, 492.61, 213.33, 484.85, 227.56, 464.16, 232.73, 439.6, 237.9, 415.03, 239.19, 381.41, 231.43, 359.43, 215.92, 351.68, 191.35, 349.09, 178.42, 337.45, 173.25, 333.58, 159.03, 318.06, 155.15, 311.6, 165.49, 303.84, 159.03, 297.37, 142.22, 292.2, 131.88, 275.39, 130.59, 270.22, 137.05, 245.66, 140.93, 227.56, 155.15, 214.63, 165.49, 197.82]], "area": 98498.61659999996, "iscrowd": 0, "image_id": 10107, "bbox": [115.07, 182.3, 362.02, 449.94], "category_id": 18, "id": 6268}, {"segmentation": [[146.42, 98.75, 199.76, 90.99, 233.7, 106.51, 251.15, 110.38, 289.94, 100.69, 348.12, 101.66, 353.94, 102.63, 352.97, 89.05, 367.52, 46.38, 396.61, 21.17, 436.36, 15.35, 453.82, 24.08, 460.61, 30.87, 421.82, 49.29, 405.33, 71.6, 399.52, 95.84, 388.85, 113.29, 381.09, 122.99, 396.61, 150.14, 423.76, 170.51, 451.88, 182.14, 457.7, 172.44, 510.06, 164.69, 529.45, 170.51, 504.24, 184.08, 473.21, 197.66, 433.45, 232.57, 360.73, 211.23, 288.97, 270.38, 298.67, 302.38, 370.42, 405.17, 346.18, 424.57, 327.76, 405.17, 305.45, 365.41, 256.97, 322.75, 219.15, 316.93, 164.85, 322.75, 145.45, 335.35, 140.61, 385.78, 118.3, 385.78, 107.64, 337.29, 120.24, 277.17, 106.67, 234.51, 109.58, 195.72, 89.21, 149.17]], "area": 69146.47120000001, "iscrowd": 0, "image_id": 10219, "bbox": [89.21, 15.35, 440.24, 409.22], "category_id": 18, "id": 12916}, {"segmentation": [[372.86, 372.54, 377.25, 358.27, 379.07, 352.78, 378.34, 343.27, 368.1, 332.3, 374.32, 323.52, 388.95, 326.08, 391.51, 328.64, 389.68, 337.78, 391.88, 346.93, 397.0, 355.71, 400.29, 369.61, 394.44, 387.54, 392.24, 404.73, 390.05, 406.56, 373.95, 374.37]], "area": 1365.0866500000009, "iscrowd": 0, "image_id": 10386, "bbox": [368.1, 323.52, 32.19, 83.04], "category_id": 32, "id": 295226}, {"segmentation": [[2.14, 163.33, 179.7, 140.87, 192.54, 102.36, 204.31, 75.62, 275.97, 78.83, 300.58, 78.83, 338.01, 68.13, 358.34, 114.13, 497.39, 88.46, 496.32, 466.05, 111.24, 468.19, 2.14, 463.91, 1.07, 164.4]], "area": 175404.22400000002, "iscrowd": 0, "image_id": 10395, "bbox": [1.07, 68.13, 496.32, 400.06], "category_id": 65, "id": 314491}, {"segmentation": [[250.25, 471.37, 244.85, 455.19, 251.33, 440.09, 258.88, 406.65, 261.03, 374.29, 270.74, 333.3, 334.38, 307.42, 344.09, 285.84, 332.22, 276.13, 318.2, 244.85, 310.65, 223.28, 322.52, 192.0, 364.58, 174.74, 416.36, 184.45, 424.99, 210.34, 419.6, 222.2, 426.07, 243.78, 419.6, 270.74, 405.57, 281.53, 402.34, 296.63, 423.91, 308.49, 456.27, 324.67, 473.53, 333.3, 475.69, 386.16, 488.63, 443.33, 492.94, 459.51, 487.55, 474.61, 251.33, 470.29]], "area": 46656.33625000001, "iscrowd": 0, "image_id": 10386, "bbox": [244.85, 174.74, 248.09, 299.87], "category_id": 1, "id": 499365}, {"segmentation": [[88.15, 322.04, 88.46, 315.84, 88.46, 306.52, 88.46, 299.38, 88.15, 293.79, 84.74, 293.79, 81.63, 290.38, 81.63, 285.41, 81.94, 277.96, 82.25, 274.86, 85.36, 265.23, 89.39, 260.57, 95.6, 257.47, 99.95, 256.85, 106.78, 257.47, 115.78, 258.71, 118.89, 259.33, 124.16, 260.88, 127.58, 267.09, 129.44, 273.92, 129.13, 280.75, 128.2, 287.58, 126.96, 296.28, 124.47, 306.52, 123.54, 309.94, 123.54, 314.9, 120.75, 317.39, 121.06, 321.42, 117.33, 322.67, 114.85, 322.67, 113.92, 318.63, 112.99, 313.66, 111.12, 310.56, 110.5, 315.84, 110.5, 321.11, 112.06, 323.6, 103.98, 323.91, 101.81, 323.91, 101.81, 319.87, 102.12, 309.01, 102.43, 304.35, 98.71, 299.69, 98.4, 313.04, 98.4, 322.04, 98.4, 324.53]], "area": 2501.76605, "iscrowd": 0, "image_id": 10449, "bbox": [81.63, 256.85, 47.81, 67.68], "category_id": 22, "id": 581256}, {"segmentation": [[184.81, 319.47, 184.09, 298.83, 174.84, 263.25, 178.4, 241.9, 196.19, 234.07, 204.73, 232.65, 212.56, 236.21, 218.25, 231.94, 228.93, 234.78, 237.47, 242.61, 245.3, 246.17, 246.23, 265.6, 248.06, 276.94, 256.48, 287.19, 247.7, 282.06, 242.94, 304.38, 246.23, 316.45, 234.89, 320.48, 229.77, 317.18, 228.31, 283.16, 226.48, 282.06, 224.28, 289.02, 218.43, 289.02, 212.21, 317.92, 214.04, 323.04]], "area": 5058.261750000001, "iscrowd": 0, "image_id": 10449, "bbox": [174.84, 231.94, 81.64, 91.1], "category_id": 22, "id": 583251}, {"segmentation": [[574.65, 274.75, 569.52, 275.32, 566.67, 273.61, 558.12, 273.32, 557.55, 271.04, 555.55, 269.62, 549.57, 269.62, 546.43, 269.05, 542.44, 267.91, 537.88, 269.33, 535.03, 270.19, 529.33, 266.2, 525.34, 261.92, 520.78, 259.07, 513.94, 259.35, 509.09, 260.49, 505.96, 265.34, 508.24, 268.19, 508.52, 269.62, 506.53, 272.47, 505.39, 273.89, 504.82, 267.05, 503.11, 256.22, 502.54, 254.79, 502.54, 251.37, 495.98, 244.82, 488.85, 239.4, 479.73, 233.42, 481.16, 229.14, 482.58, 222.01, 487.14, 212.04, 492.56, 207.48, 499.69, 206.62, 507.38, 207.19, 511.09, 210.33, 517.07, 211.75, 525.62, 208.05, 532.47, 207.19, 538.74, 207.48, 543.87, 209.47, 547.57, 210.9, 554.13, 209.19, 562.39, 207.19, 568.38, 206.34, 574.37, 210.04, 581.21, 214.32, 586.91, 220.3, 593.18, 228.57, 594.89, 243.68, 587.48, 253.65, 586.62, 256.79, 584.63, 260.49, 583.2, 263.35, 579.78, 266.48, 577.5, 270.47]], "area": 5717.9408, "iscrowd": 0, "image_id": 10449, "bbox": [479.73, 206.34, 115.16, 68.98], "category_id": 22, "id": 583543}, {"segmentation": [[336.2, 427.46, 317.26, 422.8, 294.29, 415.35, 275.35, 409.14, 256.41, 403.86, 240.27, 400.14, 229.4, 398.58, 225.05, 398.58, 221.95, 399.51, 222.26, 409.14, 227.85, 417.21, 232.2, 420.01, 246.48, 425.59, 252.06, 429.63, 255.17, 434.91, 275.35, 442.05, 298.32, 449.81, 336.51, 458.19, 368.18, 464.4, 387.11, 466.26, 390.53, 464.71, 399.84, 464.71, 411.95, 465.95, 416.61, 465.33, 421.58, 462.85, 423.75, 456.64, 425.3, 450.74, 424.99, 450.12, 420.33, 450.43, 407.92, 450.43, 393.01, 447.95, 367.25, 442.36, 353.9, 439.56, 341.48, 435.84, 324.71, 432.42, 322.23, 432.11, 326.58, 431.8, 334.65, 429.94]], "area": 4969.974099999998, "iscrowd": 0, "image_id": 10219, "bbox": [221.95, 398.58, 203.35, 67.68], "category_id": 34, "id": 603145}, {"segmentation": [[229.86, 79.61, 254.56, 71.85, 306.78, 76.79, 318.07, 67.62, 335.01, 66.2, 353.36, 81.73, 357.59, 97.96, 358.3, 110.66, 359.0, 141.01, 346.3, 188.29, 320.89, 229.93, 313.84, 236.99, 311.01, 245.46, 317.36, 256.04, 337.12, 266.63, 352.65, 275.1, 362.53, 275.8, 387.23, 268.04, 409.81, 267.33, 426.04, 272.98, 428.16, 292.03, 426.75, 318.14, 420.4, 332.26, 377.35, 351.31, 349.12, 352.02, 327.95, 359.08, 316.66, 381.66, 343.48, 378.13, 371.0, 385.19, 378.06, 393.66, 384.41, 413.42, 371.7, 426.12, 349.12, 431.76, 266.55, 445.88, 178.34, 445.17, 105.65, 438.12, 62.6, 436.7, 64.01, 423.3, 66.13, 414.12, 69.66, 404.95, 83.77, 395.07, 138.11, 392.24, 140.94, 361.19, 138.82, 325.2, 85.18, 306.15, 49.19, 275.8, 54.13, 235.58, 74.6, 217.23, 107.77, 228.52, 163.52, 255.34, 187.51, 244.75, 185.4, 236.99, 172.69, 186.88, 179.04, 126.9, 205.86, 90.9]], "area": 84587.43910000003, "iscrowd": 0, "image_id": 10395, "bbox": [49.19, 66.2, 378.97, 379.68], "category_id": 88, "id": 1161234}, {"segmentation": [[186.75, 309.01, 191.93, 305.55, 194.82, 302.95, 197.41, 300.36, 200.87, 295.75, 207.21, 292.58, 211.24, 289.99, 219.31, 288.26, 225.65, 288.84, 228.24, 290.28, 231.41, 291.43, 236.88, 291.43, 240.05, 292.29, 244.95, 292.87, 247.83, 294.02, 250.71, 295.75, 244.95, 300.94, 242.93, 301.51, 237.75, 303.24, 236.88, 306.12, 237.46, 309.29, 236.02, 312.46, 232.85, 317.94, 231.99, 321.97, 231.99, 323.41, 227.66, 327.45, 222.48, 328.31, 216.14, 329.18, 208.07, 328.6, 204.32, 328.02, 202.88, 322.26, 202.6, 320.53, 195.39, 319.38, 194.24, 319.09, 192.22, 317.36, 188.77, 314.77, 185.02, 313.04, 183.87, 312.18]], "area": 1582.0875000000005, "iscrowd": 0, "image_id": 10324, "bbox": [183.87, 288.26, 66.84, 40.92], "category_id": 18, "id": 5515}, {"segmentation": [[241.26, 106.39, 240.05, 88.39, 237.42, 85.96, 236.61, 79.69, 234.99, 77.67, 234.79, 75.24, 232.36, 75.04, 230.34, 75.64, 230.14, 77.67, 228.11, 81.91, 227.91, 85.96, 225.08, 87.78, 223.06, 90.21, 222.04, 103.76, 222.65, 105.58]], "area": 425.87115000000006, "iscrowd": 0, "image_id": 10324, "bbox": [222.04, 75.04, 19.22, 31.35], "category_id": 44, "id": 79728}, {"segmentation": [[356.69, 325.86, 356.69, 349.38, 351.59, 357.88, 352.44, 381.12, 367.75, 380.84, 365.2, 370.07, 370.3, 364.68, 372.28, 350.8, 376.82, 346.26, 374.83, 321.89, 359.25, 322.18], [352.44, 389.34, 350.74, 401.81, 374.83, 401.24, 374.26, 387.36]], "area": 1340.3254499999998, "iscrowd": 0, "image_id": 10324, "bbox": [350.74, 321.89, 26.08, 79.92], "category_id": 44, "id": 81503}, {"segmentation": [[318.06, 368.19, 323.56, 358.56, 326.32, 348.92, 327.69, 343.42, 329.07, 337.91, 327.69, 322.77, 329.07, 317.27, 337.33, 310.39, 340.08, 311.76, 341.46, 314.52, 345.59, 318.65, 346.96, 326.9, 344.21, 335.16, 344.21, 347.55, 344.21, 355.81, 344.21, 361.31, 342.83, 373.7, 340.08, 376.45, 337.33, 375.08, 333.2, 376.45, 329.07, 376.45, 326.32, 375.08, 315.31, 373.7]], "area": 1189.6992999999989, "iscrowd": 0, "image_id": 10324, "bbox": [315.31, 310.39, 31.65, 66.06], "category_id": 44, "id": 92315}, {"segmentation": [[170.41, 179.11, 195.19, 179.89, 195.71, 165.55, 188.67, 157.98, 189.45, 140.77, 187.88, 138.17, 185.28, 137.64, 180.58, 137.38, 177.71, 138.43, 176.93, 154.33, 171.46, 161.11, 171.2, 166.59]], "area": 739.8487499999998, "iscrowd": 0, "image_id": 10324, "bbox": [170.41, 137.38, 25.3, 42.51], "category_id": 44, "id": 92530}, {"segmentation": [[322.13, 101.64, 324.22, 110.0, 321.43, 118.7, 323.87, 130.19, 338.49, 118.0, 336.75, 109.65, 333.27, 97.46], [340.93, 123.92, 341.28, 131.93, 331.88, 139.59, 327.0, 134.71]], "area": 451.9323999999996, "iscrowd": 0, "image_id": 10324, "bbox": [321.43, 97.46, 19.85, 42.13], "category_id": 44, "id": 93741}, {"segmentation": [[292.72, 67.08, 292.41, 61.86, 294.25, 56.63, 294.87, 51.71, 297.02, 50.18, 297.64, 55.4, 300.4, 57.25]], "area": 57.0981499999997, "iscrowd": 0, "image_id": 10324, "bbox": [292.41, 50.18, 7.99, 16.9], "category_id": 44, "id": 97168}, {"segmentation": [[308.94, 41.46, 310.95, 41.2, 311.49, 45.75, 308.81, 48.3, 308.94, 41.73], [309.74, 53.98, 304.86, 58.66, 305.27, 66.58, 314.0, 56.42, 312.78, 51.14, 309.74, 54.39]], "area": 75.33564999999984, "iscrowd": 0, "image_id": 10324, "bbox": [304.86, 41.2, 9.14, 25.38], "category_id": 44, "id": 97550}, {"segmentation": [[115.06, 7.55, 112.18, 505.17, 133.75, 542.56, 296.27, 556.94, 414.2, 559.82, 396.94, 10.43, 348.04, 7.55, 302.02, 0.36]], "area": 159474.27025000003, "iscrowd": 0, "image_id": 10324, "bbox": [112.18, 0.36, 302.02, 559.46], "category_id": 82, "id": 330631}, {"segmentation": [[335.46, 382.74, 327.91, 398.92, 320.36, 400.0, 320.36, 412.94, 349.48, 424.81, 350.56, 407.55, 359.19, 400.0, 360.27, 366.56, 374.29, 342.83, 380.76, 357.93, 378.61, 382.74, 377.53, 404.31, 382.92, 421.57, 401.26, 422.65, 405.57, 397.84, 405.57, 355.78, 404.49, 325.57, 408.81, 296.45, 405.57, 267.33, 399.1, 216.63, 394.79, 211.24, 372.13, 195.06, 373.21, 168.09, 352.72, 173.48, 340.85, 187.51, 348.4, 212.31, 347.33, 241.44, 331.15, 242.52, 325.75, 269.48, 339.78, 273.8, 354.88, 275.96, 354.88, 287.82, 345.17, 314.79, 343.01, 335.28, 337.62, 362.25]], "area": 13476.947949999998, "iscrowd": 0, "image_id": 10142, "bbox": [320.36, 168.09, 88.45, 256.72], "category_id": 1, "id": 469874}, {"segmentation": [[501.97, 248.91, 490.14, 253.5, 479.63, 261.39, 474.38, 280.44, 468.46, 297.52, 468.46, 307.37, 472.41, 314.6, 478.32, 314.6, 481.6, 311.97, 482.92, 310.0, 490.14, 310.0, 495.4, 317.88, 498.03, 355.33, 508.54, 407.88, 517.08, 426.0, 522.84, 392.18, 524.15, 378.38, 528.75, 344.22, 531.38, 323.2, 535.32, 311.38, 537.29, 312.69, 535.32, 321.23, 535.32, 324.52, 535.98, 327.14, 543.2, 325.17, 548.46, 316.63, 543.2, 269.33, 535.32, 257.51, 528.09, 247.66, 525.47, 247.0, 524.81, 229.26, 516.27, 222.04, 504.44, 222.04, 505.76, 232.55]], "area": 7545.963900000004, "iscrowd": 0, "image_id": 10442, "bbox": [468.46, 222.04, 80.0, 203.96], "category_id": 1, "id": 470210}, {"segmentation": [[266.61, 247.9, 267.57, 239.47, 264.92, 236.82, 264.92, 229.83, 264.92, 227.91, 264.68, 225.98, 266.13, 223.57, 269.26, 222.13, 271.18, 222.61, 272.15, 224.78, 272.63, 226.7, 272.87, 230.08, 273.59, 233.69, 274.31, 240.91, 274.31, 245.25, 273.35, 249.1, 270.22, 250.79]], "area": 203.00394999999966, "iscrowd": 0, "image_id": 10142, "bbox": [264.68, 222.13, 9.63, 28.66], "category_id": 1, "id": 475005}, {"segmentation": [[465.34, 289.28, 464.38, 269.13, 457.66, 258.57, 455.74, 247.06, 453.82, 235.55, 460.54, 218.28, 469.18, 211.56, 472.05, 204.84, 475.89, 189.49, 478.77, 180.86, 494.12, 181.82, 496.04, 192.37, 497.0, 201.97, 502.76, 208.68, 508.51, 214.44, 505.64, 222.11, 503.72, 229.79, 503.72, 237.47, 503.72, 243.22, 496.04, 251.86, 483.57, 263.37, 474.93, 275.84, 473.01, 288.32, 469.18, 296.95], [467.26, 324.78, 468.22, 343.01, 471.09, 352.6, 473.01, 353.56, 477.81, 355.48, 484.53, 356.44, 494.12, 355.48, 496.04, 346.84, 496.04, 329.57, 493.16, 322.86, 487.41, 326.7, 482.61, 333.41, 477.81, 329.57, 475.89, 322.86]], "area": 4055.0317000000005, "iscrowd": 0, "image_id": 10442, "bbox": [453.82, 180.86, 54.69, 175.58], "category_id": 1, "id": 483257}, {"segmentation": [[293.89, 168.49, 320.7, 186.67, 336.97, 172.31, 347.5, 167.53, 354.2, 157.96, 365.69, 157.96, 362.82, 171.36, 363.78, 175.19, 380.05, 184.76, 379.09, 242.2, 378.13, 249.86, 370.48, 245.07, 362.82, 245.07, 368.56, 232.62, 368.56, 205.82, 335.06, 314.95, 321.65, 311.12, 328.36, 195.29, 317.82, 197.2, 299.64, 177.1, 291.98, 176.14, 291.98, 169.44]], "area": 5565.394749999999, "iscrowd": 0, "image_id": 10442, "bbox": [291.98, 157.96, 88.07, 156.99], "category_id": 1, "id": 561954}, {"segmentation": [[220.49, 261.91, 224.41, 207.66, 227.02, 187.39, 218.53, 169.09, 228.33, 140.33, 244.02, 134.45, 241.4, 120.07, 244.67, 114.84, 264.94, 123.33, 259.06, 140.98, 271.47, 152.75, 283.24, 210.28, 268.21, 226.62, 268.86, 203.08, 271.47, 195.89, 262.98, 178.9, 266.24, 224.66, 264.94, 273.03, 265.59, 281.53, 251.86, 276.3, 245.98, 218.12, 240.75, 234.46, 234.22, 274.99, 222.45, 272.37]], "area": 6333.2877499999995, "iscrowd": 0, "image_id": 10442, "bbox": [218.53, 114.84, 64.71, 166.69], "category_id": 1, "id": 570788}, {"segmentation": [[81.37, 242.2, 79.46, 214.44, 83.29, 195.29, 83.29, 186.67, 67.97, 182.84, 72.76, 168.49, 74.67, 134.98, 80.41, 121.58, 90.94, 116.79, 96.69, 97.64, 104.35, 92.86, 119.66, 97.64, 112.0, 117.75, 123.49, 130.19, 133.07, 168.49, 134.02, 194.33, 123.49, 189.55, 117.75, 238.37, 122.53, 250.81, 104.35, 248.9, 106.26, 195.29, 92.86, 223.05, 93.82, 243.16, 89.99, 248.9]], "area": 6188.757300000001, "iscrowd": 0, "image_id": 10442, "bbox": [67.97, 92.86, 66.05, 157.95], "category_id": 1, "id": 571062}, {"segmentation": [[363.49, 231.51, 363.49, 280.55, 365.42, 329.6, 347.15, 322.87, 351.95, 291.13, 351.95, 257.48, 351.95, 244.97], [384.65, 194.97, 384.65, 183.43, 390.42, 168.04, 397.15, 173.81, 397.15, 187.28, 388.5, 208.43], [311.57, 212.28, 300.99, 237.28, 292.33, 247.86, 300.99, 260.36, 311.57, 260.36, 321.18, 251.71, 321.18, 231.51, 327.91, 219.01, 331.76, 209.39, 331.76, 196.89, 318.3, 203.62]], "area": 2654.906800000003, "iscrowd": 0, "image_id": 10442, "bbox": [292.33, 168.04, 104.82, 161.56], "category_id": 1, "id": 571102}, {"segmentation": [[81.41, 19.12, 77.28, 15.0, 77.01, 0.0, 113.02, 1.25, 110.55, 8.68, 112.2, 11.7, 110.27, 16.1, 110.0, 19.95, 108.35, 30.67, 107.52, 40.02, 105.87, 47.72, 106.15, 57.61, 105.87, 60.36, 96.25, 59.26, 94.88, 59.26, 99.55, 55.96, 98.45, 51.01, 94.6, 27.37, 92.68, 44.69, 92.68, 54.04, 91.85, 58.44, 78.38, 58.44, 78.11, 57.89, 83.33, 53.21, 83.61, 46.62]], "area": 1506.72295, "iscrowd": 0, "image_id": 10442, "bbox": [77.01, 0.0, 36.01, 60.36], "category_id": 1, "id": 571191}, {"segmentation": [[243.87, 178.68, 250.85, 187.41, 254.34, 179.26, 248.52, 160.06, 218.26, 166.46, 211.86, 169.37, 176.35, 168.2, 161.22, 178.68, 164.13, 206.04, 163.55, 189.16, 165.88, 184.5, 170.53, 197.31, 169.37, 204.29, 171.7, 222.33, 179.26, 220.59, 176.93, 206.04, 184.5, 194.4, 210.69, 194.98, 214.18, 223.5, 220.59, 221.75, 224.08, 194.4, 239.21, 175.19]], "area": 2625.4631500000014, "iscrowd": 0, "image_id": 10077, "bbox": [161.22, 160.06, 93.12, 63.44], "category_id": 24, "id": 588352}, {"segmentation": [[292.24, 375.97, 296.29, 387.68, 367.45, 455.24, 374.21, 454.79, 368.35, 448.03, 342.68, 420.56, 324.21, 412.45, 321.96, 406.15, 321.96, 401.19, 293.59, 375.07], [389.52, 425.97, 395.82, 452.09, 402.13, 455.24, 402.58, 455.24, 398.98, 421.46]], "area": 934.7678000000005, "iscrowd": 0, "image_id": 10142, "bbox": [292.24, 375.07, 110.34, 80.17], "category_id": 35, "id": 606831}, {"segmentation": [[271.87, 204.8, 267.18, 209.49, 267.18, 217.2, 265.26, 220.78, 270.22, 227.4, 280.96, 216.93, 282.34, 213.89, 282.34, 211.14, 283.44, 204.53, 279.03, 203.98]], "area": 267.2549999999997, "iscrowd": 0, "image_id": 10442, "bbox": [265.26, 203.98, 18.18, 23.42], "category_id": 40, "id": 635697}, {"segmentation": [[363.18, 244.67, 368.86, 235.98, 373.72, 236.48, 378.9, 236.14, 380.91, 243.84, 382.08, 248.35, 380.57, 247.69, 379.07, 245.51, 377.73, 250.86, 374.55, 256.22, 370.2, 258.39, 363.18, 255.05]], "area": 297.1658000000003, "iscrowd": 0, "image_id": 10442, "bbox": [363.18, 235.98, 18.9, 22.41], "category_id": 40, "id": 635718}, {"segmentation": [[478.72, 330.71, 480.4, 329.8, 479.48, 326.43, 479.79, 324.6, 481.77, 323.53, 486.21, 323.83, 488.65, 325.36, 490.33, 325.21, 489.72, 323.53, 484.53, 315.88, 485.29, 313.44, 484.68, 311.45, 483.3, 310.23, 482.23, 309.16, 480.86, 306.71, 479.79, 306.56, 478.41, 306.25, 475.66, 306.71, 473.36, 306.56, 471.84, 306.25, 470.92, 306.71, 470.0, 307.93, 469.85, 309.77, 469.69, 311.3, 469.85, 313.13, 470.46, 316.19, 470.46, 318.48, 472.6, 321.85, 474.43, 325.06, 475.5, 327.2, 476.88, 329.19, 478.87, 331.33]], "area": 283.3042500000002, "iscrowd": 0, "image_id": 10442, "bbox": [469.69, 306.25, 20.64, 25.08], "category_id": 40, "id": 636393}, {"segmentation": [[132.98, 195.36, 123.32, 188.73, 121.38, 181.83, 123.59, 176.86, 130.22, 173.54, 135.19, 174.92, 135.74, 189.56, 136.3, 192.32]], "area": 227.1367500000002, "iscrowd": 0, "image_id": 10442, "bbox": [121.38, 173.54, 14.92, 21.82], "category_id": 40, "id": 636462}, {"segmentation": [[209.06, 185.12, 215.3, 185.12, 219.6, 182.32, 220.25, 175.43, 219.6, 170.05, 213.36, 170.27, 204.32, 171.56, 203.25, 177.58, 205.62, 184.04, 207.34, 185.12]], "area": 219.87634999999986, "iscrowd": 0, "image_id": 10442, "bbox": [203.25, 170.05, 17.0, 15.07], "category_id": 40, "id": 636675}, {"segmentation": [[524.88, 201.3, 529.76, 199.08, 535.98, 199.3, 540.87, 202.63, 548.64, 207.3, 551.3, 216.18, 540.87, 221.51, 534.2, 231.95, 531.32, 235.06, 528.87, 235.06, 527.99, 229.51, 525.99, 215.07, 523.99, 205.74, 523.99, 201.3]], "area": 579.4633499999993, "iscrowd": 0, "image_id": 10012, "bbox": [523.99, 199.08, 27.31, 35.98], "category_id": 40, "id": 637133}, {"segmentation": [[302.11, 240.93, 307.15, 237.75, 310.86, 236.16, 313.52, 237.22, 314.58, 238.28, 314.84, 242.26, 312.72, 245.71, 311.92, 248.89, 311.39, 253.14, 310.07, 254.99, 305.82, 257.12, 297.86, 260.04, 295.74, 258.18, 294.15, 256.85, 291.23, 253.67, 289.64, 251.55, 290.96, 248.36, 293.35, 246.5, 297.33, 244.38, 300.51, 243.32]], "area": 345.34390000000025, "iscrowd": 0, "image_id": 10442, "bbox": [289.64, 236.16, 25.2, 23.88], "category_id": 40, "id": 637715}, {"segmentation": [[13.11, 240.5, 0.0, 239.04, 0.44, 157.17, 0.44, 144.55, 97.82, 147.87, 90.67, 243.06]], "area": 8968.320249999999, "iscrowd": 0, "image_id": 10324, "bbox": [0.0, 144.55, 97.82, 98.51], "category_id": 79, "id": 1124122}, {"segmentation": [[299.0, 168.39, 298.65, 157.43, 286.98, 150.0, 287.33, 147.17, 284.5, 139.39, 284.5, 137.27, 285.57, 133.38, 301.48, 125.95, 308.9, 123.12, 312.09, 121.0, 319.16, 121.0, 324.82, 123.83, 326.23, 130.9, 327.65, 135.5, 327.29, 140.1, 325.52, 146.11, 325.52, 146.11, 340.73, 152.83, 343.21, 158.49, 346.04, 164.85, 344.27, 166.97, 339.67, 167.68, 336.13, 168.03, 334.72, 170.86, 334.37, 175.11, 325.88, 181.83, 322.34, 182.53, 318.81, 182.53, 313.5, 178.64, 308.55, 176.17, 304.66, 171.22, 303.95, 167.68, 301.83, 167.68, 300.42, 168.03], [301.83, 182.89, 303.25, 193.5, 299.71, 204.1, 299.36, 216.48, 299.36, 226.03, 300.06, 236.64, 299.71, 239.82, 299.71, 239.82, 299.71, 239.82, 301.96, 235.67, 303.4, 234.23, 306.53, 233.06, 307.18, 232.41, 313.82, 217.29, 312.91, 214.16, 317.73, 204.26, 322.69, 195.92, 309.87, 189.66, 303.06, 181.64], [296.15, 257.79, 294.81, 269.0, 294.81, 276.03, 295.31, 280.54, 290.12, 284.56, 289.62, 285.89, 291.8, 288.91, 296.48, 290.24, 301.67, 289.57, 303.34, 285.89, 304.34, 282.05, 307.19, 277.53, 308.19, 272.18, 310.53, 254.95, 306.18, 256.96, 302.5, 259.3, 299.99, 259.3], [318.17, 229.75, 321.2, 249.31, 319.27, 257.3, 319.0, 266.4, 319.55, 277.97, 318.72, 285.41, 319.82, 288.72, 322.3, 289.54, 325.06, 266.12, 323.96, 258.68, 326.44, 245.18, 326.99, 240.22, 326.99, 237.47, 326.44, 235.81, 325.33, 233.06, 325.33, 221.21]], "area": 3595.855900000001, "iscrowd": 0, "image_id": 10442, "bbox": [284.5, 121.0, 61.54, 169.24], "category_id": 1, "id": 1236284}, {"segmentation": [[528.66, 339.17, 535.38, 378.51, 531.54, 395.78, 549.77, 398.66, 552.65, 381.39, 552.65, 357.4, 544.01, 339.17, 544.01, 329.57, 535.38, 311.34, 529.62, 325.74], [497.0, 336.29, 497.96, 369.87, 488.36, 379.47, 501.8, 397.7], [543.02, 266.95, 541.99, 253.07, 537.88, 243.81, 530.68, 240.73, 523.48, 236.1, 519.88, 242.27, 529.14, 254.61, 537.36, 263.35, 540.96, 269.0], [524.51, 230.96, 525.02, 223.76, 525.02, 218.62, 522.45, 215.02, 514.23, 214.5, 505.49, 215.53, 500.86, 220.16, 503.94, 226.33]], "area": 2188.9351500000007, "iscrowd": 0, "image_id": 10442, "bbox": [488.36, 214.5, 64.29, 184.16], "category_id": 1, "id": 1240065}, {"segmentation": [[461.53, 76.48, 460.98, 72.08, 458.23, 70.71, 454.65, 70.71, 455.48, 65.21, 458.5, 64.93, 460.7, 62.18, 462.9, 57.79, 465.1, 53.66, 466.75, 50.09, 466.2, 44.86, 468.4, 39.09, 471.15, 34.97, 478.02, 35.79, 480.77, 42.12, 479.95, 47.34, 481.87, 51.19, 482.15, 55.59, 482.42, 61.08, 482.69, 66.03, 482.69, 69.33, 483.52, 74.56, 481.6, 75.38, 474.72, 75.66, 468.67, 75.38, 467.57, 75.11, 465.65, 75.11]], "area": 733.3720500000001, "iscrowd": 0, "image_id": 10442, "bbox": [454.65, 34.97, 28.87, 41.51], "category_id": 1, "id": 1267952}, {"segmentation": [[502.51, 250.4, 494.52, 253.36, 490.23, 249.51, 488.89, 245.51, 488.75, 242.7, 488.01, 239.3, 490.23, 235.75, 493.19, 233.68, 495.26, 234.12, 498.66, 238.12, 499.55, 240.63, 504.28, 240.78, 506.95, 242.56, 506.65, 246.7, 504.28, 250.1]], "area": 234.51474999999982, "iscrowd": 0, "image_id": 10442, "bbox": [488.01, 233.68, 18.94, 19.68], "category_id": 40, "id": 1470592}, {"segmentation": [[201.43, 72.98, 210.28, 72.98, 209.92, 77.13, 218.77, 92.12, 222.38, 101.33, 221.84, 105.84, 187.89, 104.04, 188.98, 93.93, 198.0, 82.19, 201.25, 76.77]], "area": 727.7048500000003, "iscrowd": 0, "image_id": 10324, "bbox": [187.89, 72.98, 34.49, 32.86], "category_id": 44, "id": 1485308}, {"segmentation": [[331.58, 381.34, 331.58, 365.51, 343.04, 350.68, 342.7, 329.79, 346.75, 326.08, 357.19, 327.09, 357.86, 348.66, 348.09, 363.35, 347.08, 381.89], [333.27, 389.3, 335.96, 400.08, 348.77, 399.41, 347.76, 388.63, 332.93, 388.96]], "area": 968.3620500000002, "iscrowd": 0, "image_id": 10324, "bbox": [331.58, 326.08, 26.28, 74.0], "category_id": 44, "id": 1488432}, {"segmentation": [[289.51, 157.38, 289.86, 151.49, 292.28, 148.2, 294.02, 146.81, 294.71, 145.25, 294.54, 126.55, 298.35, 125.51, 299.21, 126.55, 299.91, 130.53, 300.08, 142.31, 300.42, 143.52, 301.12, 148.02, 301.29, 150.1]], "area": 182.36385000000013, "iscrowd": 0, "image_id": 10324, "bbox": [289.51, 125.51, 11.78, 31.87], "category_id": 44, "id": 1489416}, {"segmentation": [[217.89, 171.33, 239.46, 164.85, 250.25, 183.19, 266.43, 190.74, 302.02, 241.44, 303.1, 256.54, 295.55, 264.09, 271.82, 272.72, 266.43, 274.88, 238.38, 271.64, 237.3, 258.7, 223.28, 240.36, 203.87, 223.1, 187.69, 209.08]], "area": 7022.1494999999995, "iscrowd": 0, "image_id": 10432, "bbox": [187.69, 164.85, 115.41, 110.03], "category_id": 52, "id": 1543037}, {"segmentation": [[252.49, 78.4, 244.82, 86.92, 243.33, 90.75, 239.5, 101.4, 238.86, 114.39, 245.46, 130.79, 262.29, 146.77, 260.58, 155.29, 252.92, 157.42, 234.39, 153.16, 224.16, 140.8, 225.87, 131.86, 223.1, 97.78, 223.1, 92.88, 225.44, 88.2, 231.83, 83.3, 247.59, 74.14, 251.0, 72.01]], "area": 1618.9473000000005, "iscrowd": 0, "image_id": 10432, "bbox": [223.1, 72.01, 39.19, 85.41], "category_id": 52, "id": 1543213}, {"segmentation": [[338.06, 239.44, 334.5, 243.71, 326.67, 246.56, 323.12, 245.85, 319.56, 250.83, 312.44, 257.23, 302.48, 256.52, 300.34, 244.42, 286.82, 225.21, 266.19, 193.9, 270.45, 182.51, 278.28, 171.12, 281.84, 162.58, 288.96, 155.47, 304.61, 146.93, 314.58, 146.93, 314.58, 165.43, 317.42, 181.8, 330.94, 202.43, 345.18, 222.36]], "area": 4723.9360000000015, "iscrowd": 0, "image_id": 10432, "bbox": [266.19, 146.93, 78.99, 110.3], "category_id": 52, "id": 1545333}, {"segmentation": [[424.3, 364.87, 426.46, 363.79, 441.59, 375.68, 463.22, 424.33, 463.22, 424.33, 487.0, 476.22, 490.24, 479.46, 409.16, 480.0, 395.11, 460.0, 394.03, 441.63, 391.86, 422.17, 391.86, 417.84, 391.86, 398.38, 408.08, 368.11, 418.89, 361.63]], "area": 7509.557899999997, "iscrowd": 0, "image_id": 10432, "bbox": [391.86, 361.63, 98.38, 118.37], "category_id": 52, "id": 1545539}, {"segmentation": [[356.65, 269.53, 344.12, 272.12, 332.02, 282.49, 321.22, 287.24, 313.87, 300.63, 313.44, 326.12, 327.27, 360.69, 345.41, 388.77, 361.4, 397.84, 369.17, 392.66, 370.04, 389.2, 376.09, 391.79, 379.54, 389.2, 381.27, 377.97, 388.18, 378.83, 391.64, 374.51, 386.89, 358.53, 378.25, 341.25, 367.88, 316.62, 360.97, 296.31, 360.1, 284.22]], "area": 5917.327400000001, "iscrowd": 0, "image_id": 10432, "bbox": [313.44, 269.53, 78.2, 128.31], "category_id": 52, "id": 1546568}, {"segmentation": [[406.87, 252.31, 364.09, 263.29, 357.74, 265.61, 361.78, 293.35, 390.11, 367.34, 398.2, 364.45, 401.67, 353.47, 415.54, 363.29, 419.01, 362.72, 430.57, 355.78, 429.99, 354.62, 439.24, 360.4, 447.91, 358.67, 455.42, 348.27, 455.42, 348.27, 456.58, 345.95, 456.0, 336.13, 455.42, 335.55, 469.87, 335.55, 469.3, 334.97, 438.08, 236.7, 438.08, 236.7, 436.35, 232.66, 425.94, 237.28, 423.63, 239.02, 413.8, 250.0]], "area": 9439.170650000002, "iscrowd": 0, "image_id": 10432, "bbox": [357.74, 232.66, 112.13, 134.68], "category_id": 52, "id": 1546710}, {"segmentation": [[449.83, 239.68, 452.69, 233.56, 455.14, 231.72, 459.21, 226.42, 464.31, 221.32, 467.57, 220.3, 470.63, 220.3, 472.47, 221.12, 475.53, 220.71, 476.55, 220.3, 479.2, 218.88, 482.87, 217.65, 484.29, 217.65, 486.74, 217.65, 487.97, 218.27, 489.6, 219.28, 490.82, 221.73, 490.82, 227.44, 487.76, 236.41, 492.45, 242.73, 496.12, 255.58, 501.42, 268.22, 504.28, 274.34, 513.25, 288.82, 520.39, 298.81, 524.46, 305.33, 525.48, 315.94, 522.02, 318.59, 516.31, 315.94, 514.68, 320.83, 510.19, 321.24, 508.76, 321.65, 498.77, 316.55, 489.6, 308.39, 487.56, 299.83, 480.83, 289.84, 471.65, 276.99, 467.98, 267.81, 460.03, 249.46, 453.3, 242.33, 450.24, 240.08]], "area": 3333.2997999999993, "iscrowd": 0, "image_id": 10432, "bbox": [449.83, 217.65, 75.65, 104.0], "category_id": 52, "id": 1547671}, {"segmentation": [[234.09, 316.88, 229.8, 326.55, 214.77, 331.92, 206.17, 350.17, 206.17, 368.43, 211.54, 387.75, 226.58, 426.41, 238.39, 444.67, 249.13, 446.82, 254.5, 443.59, 253.42, 423.19, 246.98, 403.86, 237.32, 373.8, 235.17, 348.02, 235.17, 335.14, 243.76, 320.1, 235.17, 320.1]], "area": 3270.470749999999, "iscrowd": 0, "image_id": 10432, "bbox": [206.17, 316.88, 48.33, 129.94], "category_id": 52, "id": 1547838}, {"segmentation": [[156.4, 293.39, 141.3, 284.76, 131.6, 284.76, 127.28, 284.76, 117.57, 255.64, 128.36, 198.47, 135.91, 189.84, 144.54, 189.84, 157.48, 168.27, 175.82, 169.35, 185.53, 186.61, 190.92, 188.76, 190.92, 203.87, 190.92, 212.49, 228.67, 244.85, 237.3, 259.96, 237.3, 271.82, 218.97, 271.82, 206.02, 278.29, 190.92, 277.21, 171.51, 288.0, 171.51, 288.0]], "area": 9079.806449999998, "iscrowd": 0, "image_id": 10432, "bbox": [117.57, 168.27, 119.73, 125.12], "category_id": 52, "id": 1547931}, {"segmentation": [[297.71, 288.01, 289.88, 298.26, 280.84, 295.85, 268.19, 315.13, 273.01, 344.05, 297.11, 398.89, 315.79, 403.71, 321.22, 391.66, 293.5, 328.39, 295.3, 304.28, 304.34, 291.03, 298.32, 287.41]], "area": 2715.3953000000006, "iscrowd": 0, "image_id": 10432, "bbox": [268.19, 287.41, 53.03, 116.3], "category_id": 52, "id": 1548110}, {"segmentation": [[444.36, 227.46, 438.06, 235.68, 428.19, 252.39, 425.45, 262.26, 421.89, 278.7, 428.47, 297.34, 444.36, 323.1, 457.79, 338.17, 467.65, 340.36, 470.4, 338.72, 474.51, 334.06, 483.82, 332.41, 489.03, 328.3, 484.65, 323.1, 484.37, 316.25, 489.58, 312.14, 489.85, 304.19, 484.92, 292.95, 483.0, 290.76, 469.57, 271.85, 469.57, 269.93, 461.08, 248.37, 450.66, 240.15, 447.1, 230.55, 447.38, 225.89]], "area": 4404.489949999999, "iscrowd": 0, "image_id": 10432, "bbox": [421.89, 225.89, 67.96, 114.47], "category_id": 52, "id": 1548192}, {"segmentation": [[498.34, 374.29, 482.16, 373.21, 481.08, 366.74, 484.31, 357.03, 484.31, 331.15, 477.84, 304.18, 472.45, 272.9, 470.29, 263.19, 450.88, 257.8, 454.11, 207.1, 457.35, 190.92, 454.11, 175.82, 453.03, 149.93, 462.74, 133.75, 483.24, 121.89, 486.47, 117.57, 477.84, 108.94, 470.29, 98.16, 472.45, 77.66, 488.63, 76.58, 500.49, 78.74, 505.89, 100.31, 510.2, 117.57, 544.72, 129.44, 549.03, 154.25, 551.19, 199.55, 549.03, 220.04, 544.72, 235.15, 526.38, 242.7, 541.48, 336.54, 549.03, 364.58, 544.72, 377.53, 528.54, 373.21, 524.22, 341.93, 498.34, 252.4, 511.28, 372.13]], "area": 19197.105450000003, "iscrowd": 0, "image_id": 10012, "bbox": [450.88, 76.58, 100.31, 300.95], "category_id": 1, "id": 1730659}, {"segmentation": [[494.27, 303.89, 485.72, 311.97, 485.72, 315.06, 487.62, 319.33, 492.37, 326.22, 492.61, 321.94, 494.03, 316.96, 494.75, 312.68, 494.98, 306.51, 497.12, 303.89, 496.88, 302.47, 493.8, 304.37]], "area": 121.09799999999966, "iscrowd": 0, "image_id": 10442, "bbox": [485.72, 302.47, 11.4, 23.75], "category_id": 40, "id": 1858847}, {"segmentation": [[234.91, 182.62, 215.34, 180.71, 217.25, 142.52, 221.07, 141.08, 221.07, 136.79, 225.37, 134.4, 230.62, 133.92, 233.48, 135.83, 235.87, 151.59, 235.39, 181.66]], "area": 855.6226999999998, "iscrowd": 0, "image_id": 10324, "bbox": [215.34, 133.92, 20.53, 48.7], "category_id": 44, "id": 1868706}, {"segmentation": [[156.49, 90.09, 158.43, 100.25, 160.23, 105.04, 163.07, 109.52, 168.45, 119.84, 170.24, 123.43, 175.03, 134.79, 178.76, 143.91, 183.7, 153.48, 186.09, 159.9, 186.09, 165.43, 183.4, 168.42, 180.41, 170.97, 172.63, 169.77, 162.21, 157.88, 162.91, 163.82, 162.91, 167.44, 158.72, 168.48, 157.09, 170.7, 155.46, 171.63, 150.56, 171.75, 146.72, 169.18, 142.53, 164.29, 141.25, 164.64, 139.73, 167.9, 135.19, 168.48, 127.85, 167.78, 120.86, 161.03, 117.02, 155.79, 113.52, 149.26, 113.06, 145.07, 108.89, 141.25, 102.29, 135.58, 97.14, 129.24, 93.58, 121.85, 91.2, 114.59, 90.28, 104.83, 91.89, 98.59, 95.28, 91.8, 100.53, 86.25, 104.74, 83.58, 110.4, 82.45, 114.3, 82.45, 118.42, 83.06, 127.26, 79.05, 132.61, 75.45, 142.68, 74.12, 146.79, 75.04, 150.09, 76.89, 153.27, 77.92, 155.95, 78.23, 157.28, 81.93, 156.67, 83.27, 156.67, 90.05]], "area": 6036.474, "iscrowd": 0, "image_id": 10432, "bbox": [90.28, 74.12, 95.81, 97.63], "category_id": 52, "id": 1904361}, {"segmentation": [[192.9, 63.17, 196.76, 44.39, 184.72, 32.35, 188.57, 25.61, 207.35, 30.9, 209.28, 21.27, 217.95, 24.64, 220.36, 33.31, 226.14, 38.61, 227.58, 55.95, 216.98, 63.17, 207.35, 63.65]], "area": 1175.3052500000001, "iscrowd": 0, "image_id": 10442, "bbox": [184.72, 21.27, 42.86, 42.38], "category_id": 1, "id": 2000401}, {"segmentation": [[364.5, 376.15, 373.06, 354.15, 381.61, 341.93, 396.28, 342.54, 406.06, 354.76, 404.22, 366.37, 393.22, 376.15, 391.39, 377.98, 375.5, 379.2], [374.89, 402.42, 376.11, 387.76, 381.61, 389.59, 383.45, 398.76]], "area": 1159.7842999999998, "iscrowd": 0, "image_id": 10324, "bbox": [364.5, 341.93, 41.56, 60.49], "category_id": 44, "id": 2093222}, {"segmentation": [[533.15, 205.61, 512.64, 215.45, 499.51, 231.04, 509.36, 259.76, 529.87, 279.45, 548.74, 279.45, 570.07, 285.19, 587.3, 272.06, 561.87, 246.63, 542.18, 220.38, 547.1, 203.97]], "area": 3787.6509499999984, "iscrowd": 0, "image_id": 10432, "bbox": [499.51, 203.97, 87.79, 81.22], "category_id": 52, "id": 2110149}, {"segmentation": [[248.27, 411.01, 248.27, 405.19, 244.74, 399.17, 237.88, 396.88, 229.78, 398.13, 226.24, 401.66, 226.03, 408.52, 232.06, 413.92, 248.68, 413.51]], "area": 315.93870000000004, "iscrowd": 0, "image_id": 10324, "bbox": [226.03, 396.88, 22.65, 17.04], "category_id": 53, "id": 2111233}, {"segmentation": [[179.25, 106.22, 179.25, 119.5, 179.25, 123.93, 171.51, 131.67, 164.87, 148.27, 163.76, 165.97, 163.76, 172.61, 169.29, 183.68, 171.51, 188.1, 172.61, 196.96, 174.83, 204.7, 174.83, 245.64, 174.83, 255.6, 175.93, 262.24, 184.78, 267.77, 188.1, 267.77, 189.21, 265.56, 188.1, 257.81, 187.0, 231.26, 189.21, 210.23, 191.42, 203.59, 193.64, 200.28, 198.06, 214.66, 196.96, 221.3, 193.64, 240.11, 194.74, 246.75, 194.74, 255.6, 199.17, 263.35, 204.7, 267.77, 205.81, 264.45, 206.91, 255.6, 206.91, 254.49, 209.13, 240.11, 210.23, 225.72, 212.45, 215.77, 209.13, 204.7, 206.91, 185.89, 204.7, 165.97, 204.7, 150.48, 209.13, 159.34, 213.55, 170.4, 217.98, 162.65, 206.91, 130.57, 201.38, 128.35, 198.06, 125.03, 196.96, 102.9, 190.32, 101.8, 183.68, 101.8]], "area": 5216.454249999997, "iscrowd": 0, "image_id": 10442, "bbox": [163.76, 101.8, 54.22, 165.97], "category_id": 1, "id": 2152847}, {"segmentation": [[150.48, 0.0, 146.06, 23.24, 156.02, 8.85, 156.02, 61.96, 152.7, 77.45, 159.34, 70.82, 165.97, 32.09, 167.08, 77.45, 173.72, 64.18, 180.36, 29.88, 190.32, 12.17, 191.42, 1.11, 154.91, 0.0]], "area": 1750.1656999999998, "iscrowd": 0, "image_id": 10442, "bbox": [146.06, 0.0, 45.36, 77.45], "category_id": 1, "id": 2154531}, {"segmentation": [[143.67, 119.45, 149.84, 205.95, 160.14, 205.26, 198.58, 187.41, 193.09, 109.16, 173.87, 107.79, 144.35, 119.45]], "area": 4334.445350000001, "iscrowd": 0, "image_id": 10008, "bbox": [143.67, 107.79, 54.91, 98.16], "category_id": 72, "id": 32211}, {"segmentation": [[234.6, 249.32, 253.33, 248.83, 257.95, 235.45, 260.14, 226.21, 254.06, 220.37, 265.49, 207.72, 270.35, 200.67, 277.24, 193.91, 296.53, 191.7, 333.73, 191.98, 353.85, 193.91, 354.95, 203.83, 359.08, 216.23, 362.94, 220.36, 361.01, 225.87, 364.04, 230.83, 363.49, 238.27, 376.18, 253.89, 385.55, 276.36, 386.17, 291.35, 390.54, 306.96, 391.48, 330.06, 388.36, 339.42, 385.16, 371.64, 377.9, 401.34, 338.97, 402.66, 250.53, 405.96, 179.26, 400.02, 154.18, 392.1, 156.16, 355.14, 177.94, 316.87]], "area": 37032.70650000001, "iscrowd": 0, "image_id": 10008, "bbox": [154.18, 191.7, 237.3, 214.26], "category_id": 65, "id": 315245}, {"segmentation": [[213.83, 187.33, 208.82, 178.97, 202.97, 171.04, 198.79, 166.44, 198.79, 164.35, 198.38, 162.27, 204.22, 162.27, 205.48, 158.92, 220.51, 151.41, 242.65, 139.29, 252.67, 132.61, 266.04, 127.6, 281.91, 111.73, 286.92, 107.13, 279.82, 97.53, 282.74, 84.16, 291.93, 72.05, 291.93, 64.53, 298.2, 54.92, 306.55, 44.9, 312.4, 49.08, 331.61, 71.21, 339.13, 86.67, 339.55, 90.01, 353.75, 92.1, 380.06, 105.46, 391.34, 121.33, 401.36, 129.27, 398.02, 140.55, 414.31, 176.47, 427.68, 211.55, 433.52, 221.16, 431.85, 224.08, 431.43, 225.75, 426.42, 225.75, 428.93, 229.93, 426.0, 232.85, 422.25, 227.42, 424.75, 239.53, 423.08, 241.62, 421.41, 236.61, 415.56, 220.74, 411.8, 203.61, 393.01, 163.1, 383.82, 151.82, 378.81, 146.39, 383.82, 164.35, 379.64, 173.13, 373.8, 174.8, 369.2, 189.41, 365.86, 202.78, 361.27, 206.54, 357.92, 203.2, 345.39, 204.03, 337.04, 206.54, 334.54, 209.46, 331.19, 209.46, 328.69, 222.41, 330.36, 233.69, 334.12, 244.55, 331.19, 258.33, 322.0, 268.35, 309.06, 270.86, 305.3, 262.92, 314.9, 239.95, 311.15, 225.75, 306.13, 207.37, 301.12, 196.93, 289.01, 199.86, 278.99, 229.51, 272.72, 251.23, 273.97, 264.18, 270.21, 271.28, 251.84, 267.52, 234.71, 265.01, 225.94, 256.24, 228.86, 252.9, 249.75, 245.8, 256.43, 242.46, 262.7, 241.62, 263.53, 191.5, 270.21, 172.71, 278.15, 163.94, 303.63, 155.58, 317.83, 150.15, 313.65, 141.38, 306.97, 131.78, 301.96, 131.78, 292.77, 133.45, 278.15, 135.95, 262.28, 145.14, 239.72, 156.84, 221.76, 162.27, 217.17, 166.02, 215.92, 173.54, 218.42, 181.06, 218.84, 184.4]], "area": 18230.852450000002, "iscrowd": 0, "image_id": 10023, "bbox": [198.38, 44.9, 235.14, 226.38], "category_id": 1, "id": 439238}, {"segmentation": [[242.77, 276.35, 321.45, 329.13, 323.37, 349.28, 312.81, 352.16, 231.25, 310.89, 221.66, 306.1, 220.7, 287.87, 224.53, 277.31, 231.25, 273.47, 243.73, 279.23]], "area": 3400.38795, "iscrowd": 0, "image_id": 10023, "bbox": [220.7, 273.47, 102.67, 78.69], "category_id": 41, "id": 642104}, {"segmentation": [[391.67, 233.54, 390.56, 422.25, 639.95, 418.13, 635.51, 227.36, 404.82, 229.58]], "area": 47243.47455, "iscrowd": 0, "image_id": 10008, "bbox": [390.56, 227.36, 249.39, 194.89], "category_id": 65, "id": 1957130}, {"segmentation": [[196.22, 59.17, 199.19, 74.28, 203.63, 87.33, 191.77, 82.58, 190.89, 80.81, 192.07, 74.58, 191.48, 59.76]], "area": 188.5965500000001, "iscrowd": 0, "image_id": 10138, "bbox": [190.89, 59.17, 12.74, 28.16], "category_id": 44, "id": 79208}, {"segmentation": [[206.29, 56.77, 207.05, 74.3, 202.85, 79.64, 202.47, 92.99, 202.47, 105.57, 221.92, 104.81, 220.77, 78.12, 214.67, 69.35, 213.15, 59.43, 212.77, 55.24, 210.48, 54.1, 207.05, 55.24]], "area": 709.77385, "iscrowd": 0, "image_id": 10138, "bbox": [202.47, 54.1, 19.45, 51.47], "category_id": 44, "id": 85615}, {"segmentation": [[495.13, 342.7, 519.35, 345.26, 545.03, 340.13, 545.4, 334.62, 555.67, 325.45, 565.95, 325.82, 567.42, 322.51, 576.22, 322.51, 580.26, 322.51, 578.42, 335.72, 586.5, 335.36, 583.56, 333.16, 577.92, 250.75, 583.57, 251.69, 583.57, 259.22, 616.53, 258.28, 614.65, 252.16, 604.76, 248.39, 586.39, 246.98, 587.81, 241.33, 581.68, 237.09, 573.68, 234.73, 567.08, 238.03, 572.26, 253.1, 572.26, 260.16, 565.67, 266.76, 559.08, 268.64, 549.66, 262.99, 545.42, 257.34, 529.88, 264.87, 525.64, 274.29, 520.93, 287.48, 511.04, 287.48, 492.67, 291.72, 495.03, 311.03, 495.97, 340.23], [487.49, 339.75, 461.12, 332.69, 463.48, 322.8, 477.13, 310.08, 478.55, 306.79, 483.73, 314.79, 488.44, 338.34], [459.24, 313.85, 443.7, 290.31, 446.99, 272.41, 455.47, 274.76, 462.06, 259.69, 466.3, 248.86, 466.3, 239.91, 466.3, 230.97, 471.48, 225.79, 479.02, 224.84, 500.21, 224.37, 488.44, 240.86, 475.72, 256.4, 463.01, 271.47, 461.59, 278.06, 448.88, 288.42, 454.53, 297.84, 463.95, 298.78, 468.66, 306.79], [395.66, 282.77, 410.26, 281.83, 412.14, 291.25, 417.32, 299.25, 426.74, 312.44, 429.57, 323.27, 431.45, 333.63, 422.98, 330.34, 411.2, 311.97, 401.31, 297.84]], "area": 8588.112249999995, "iscrowd": 0, "image_id": 10205, "bbox": [395.66, 224.37, 220.87, 120.89], "category_id": 63, "id": 115206}, {"segmentation": [[199.55, 237.3, 201.71, 207.1, 222.2, 166.11, 252.4, 149.93, 264.27, 142.38, 259.96, 116.49, 257.8, 90.61, 265.35, 62.56, 297.71, 57.17, 322.52, 63.64, 343.01, 77.66, 350.56, 94.92, 350.56, 121.89, 349.48, 140.22, 350.56, 145.62, 381.84, 155.33, 401.26, 171.51, 414.2, 196.31, 424.99, 245.93, 424.99, 257.8, 418.52, 272.9, 405.57, 283.69, 265.35, 268.58, 253.48, 252.4, 240.54, 242.7, 198.47, 245.93, 201.71, 232.99]], "area": 31544.90015, "iscrowd": 0, "image_id": 10138, "bbox": [198.47, 57.17, 226.52, 226.52], "category_id": 1, "id": 228945}, {"segmentation": [[319.53, 114.35, 321.17, 115.07, 321.56, 115.59, 321.95, 116.28, 322.09, 117.86, 322.09, 118.55, 321.99, 119.23, 321.86, 119.53, 321.53, 119.96, 321.04, 120.25, 320.41, 120.35, 319.56, 120.38, 319.13, 120.38, 318.31, 120.28, 317.72, 120.05, 317.1, 119.59, 316.48, 119.07, 316.02, 118.48, 315.72, 117.33, 315.76, 116.05, 316.28, 115.07, 317.13, 114.45, 317.63, 114.25, 318.35, 114.19, 319.46, 114.22, 319.69, 114.41]], "area": 32.30234999999993, "iscrowd": 0, "image_id": 10216, "bbox": [315.72, 114.19, 6.37, 6.19], "category_id": 37, "id": 304745}, {"segmentation": [[139.51, 348.4, 149.49, 344.27, 158.0, 342.56, 167.97, 350.35, 168.95, 363.24, 164.81, 370.54, 158.24, 377.35, 143.89, 380.75, 131.97, 373.46, 129.05, 361.05, 131.97, 354.0, 135.62, 348.16]], "area": 1119.6623500000003, "iscrowd": 0, "image_id": 10123, "bbox": [129.05, 342.56, 39.9, 38.19], "category_id": 37, "id": 306033}, {"segmentation": [[411.89, 2.7, 558.92, 4.86, 541.62, 152.97, 461.62, 150.81, 457.3, 263.24, 448.65, 272.97, 442.16, 281.62, 442.16, 288.11, 417.3, 283.78, 421.62, 269.73, 421.62, 252.43, 424.86, 236.22, 425.95, 227.57, 402.16, 174.59, 408.65, 1.62]], "area": 27047.282799999994, "iscrowd": 0, "image_id": 10138, "bbox": [402.16, 1.62, 156.76, 286.49], "category_id": 82, "id": 330862}, {"segmentation": [[201.12, 113.03, 197.08, 116.13, 194.91, 120.48, 193.04, 126.38, 193.04, 130.72, 194.6, 135.07, 196.46, 139.11, 199.56, 140.04, 203.91, 139.11, 206.7, 135.38, 209.81, 131.66, 209.81, 125.45, 209.5, 120.17, 207.32, 114.27, 205.15, 113.34]], "area": 353.15585, "iscrowd": 0, "image_id": 10216, "bbox": [193.04, 113.03, 16.77, 27.01], "category_id": 85, "id": 336279}, {"segmentation": [[324.86, 70.46, 329.57, 74.34, 337.94, 74.34, 343.67, 71.89, 345.1, 69.43, 346.12, 70.46, 348.37, 116.23, 346.32, 115.83, 343.46, 92.94, 334.67, 94.78, 335.29, 121.34, 332.63, 121.55, 331.2, 100.29, 312.19, 97.23, 310.76, 119.5, 308.72, 118.28, 308.31, 84.76, 307.08, 83.74, 308.72, 81.9, 319.55, 77.61, 320.78, 68.0, 322.82, 68.21, 322.82, 70.05]], "area": 1060.3012500000002, "iscrowd": 0, "image_id": 10216, "bbox": [307.08, 68.0, 41.29, 53.55], "category_id": 62, "id": 376131}, {"segmentation": [[278.92, 118.85, 280.12, 80.69, 284.09, 77.9, 286.88, 76.31, 291.65, 74.32, 303.97, 74.32, 312.72, 73.93, 305.96, 85.85, 303.57, 117.26, 279.32, 116.07]], "area": 1085.7662999999995, "iscrowd": 0, "image_id": 10216, "bbox": [278.92, 73.93, 33.8, 44.92], "category_id": 62, "id": 378965}, {"segmentation": [[326.98, 319.61, 334.7, 290.46, 332.6, 288.35, 332.6, 283.79, 322.06, 254.98, 323.11, 247.96, 325.22, 244.8, 334.0, 244.45, 339.62, 253.58, 346.65, 269.03, 348.75, 282.03, 349.11, 289.06, 348.4, 290.46, 347.0, 308.73, 344.89, 320.32, 343.13, 321.02, 344.19, 289.76, 341.03, 294.32, 334.0, 316.1, 332.6, 315.05, 340.32, 289.41, 336.46, 289.76, 329.44, 318.56]], "area": 987.1263999999981, "iscrowd": 0, "image_id": 10205, "bbox": [322.06, 244.45, 27.05, 76.57], "category_id": 62, "id": 385197}, {"segmentation": [[235.92, 238.84, 257.23, 238.84, 261.34, 239.81, 261.1, 247.8, 259.4, 248.29, 259.89, 263.78, 269.57, 265.96, 271.27, 270.08, 270.78, 287.99, 272.0, 319.47, 266.67, 318.74, 264.01, 306.64, 259.65, 306.4, 258.68, 317.53, 255.29, 315.35, 254.8, 303.49, 241.73, 303.01, 242.7, 320.44, 238.1, 320.2]], "area": 2167.9228999999987, "iscrowd": 0, "image_id": 10205, "bbox": [235.92, 238.84, 36.08, 81.6], "category_id": 62, "id": 385929}, {"segmentation": [[371.02, 332.17, 382.87, 308.46, 340.93, 240.09, 340.93, 225.5, 373.76, 202.71, 395.64, 189.94, 371.93, 127.94, 298.99, 140.71, 262.53, 142.53, 253.41, 136.15, 255.24, 120.65, 274.38, 126.12, 340.93, 111.54, 338.21, 95.13, 354.61, 80.54, 339.12, 64.13, 340.02, 35.86, 371.02, 30.39, 381.96, 36.77, 391.08, 51.36, 426.64, 51.36, 444.87, 90.56, 464.93, 148.92, 476.78, 201.8, 461.29, 251.94, 454.9, 273.82, 445.79, 285.67, 467.66, 346.75, 484.08, 377.75, 490.46, 380.49, 469.49, 416.04, 440.31, 419.69, 450.34, 387.78, 440.31, 341.29, 423.9, 302.09, 410.22, 294.79, 414.79, 252.85, 412.96, 241.91, 396.55, 247.38, 386.52, 247.38, 402.93, 303.91, 420.26, 335.82, 392.91, 344.03, 361.0, 351.32, 359.17, 341.29, 365.56, 324.88]], "area": 31105.181600000007, "iscrowd": 0, "image_id": 10205, "bbox": [253.41, 30.39, 237.05, 389.3], "category_id": 1, "id": 440791}, {"segmentation": [[452.41, 290.27, 469.63, 260.26, 497.19, 229.74, 500.14, 220.89, 511.46, 219.9, 525.73, 229.25, 529.67, 244.02, 542.96, 259.27, 531.15, 278.96, 512.94, 278.46, 511.95, 274.03, 509.0, 271.57, 510.97, 278.96, 517.37, 289.78, 508.51, 289.29, 502.6, 288.8, 500.14, 283.38, 501.13, 265.18, 496.21, 269.11, 492.76, 279.94, 492.76, 291.26, 494.24, 321.28, 497.19, 338.01, 494.73, 346.87, 491.29, 347.85, 485.38, 346.37, 483.41, 311.43, 479.47, 305.04, 476.52, 302.58, 476.52, 309.96, 474.55, 312.91, 462.74, 323.74, 457.82, 317.34, 465.7, 307.5, 467.17, 303.07]], "area": 4643.441100000001, "iscrowd": 0, "image_id": 10205, "bbox": [452.41, 219.9, 90.55, 127.95], "category_id": 1, "id": 442715}, {"segmentation": [[292.15, 193.15, 295.86, 194.74, 290.03, 200.58, 283.66, 211.71, 279.95, 219.13, 273.59, 227.09, 268.82, 228.68, 262.99, 223.38, 262.99, 219.13, 264.58, 211.71, 268.29, 208.53, 274.65, 206.94, 283.49, 200.47]], "area": 420.53524999999996, "iscrowd": 0, "image_id": 10216, "bbox": [262.99, 193.15, 32.87, 35.53], "category_id": 43, "id": 656517}, {"segmentation": [[198.63, 222.62, 206.3, 237.97, 182.31, 278.27, 171.76, 319.53, 170.8, 378.06, 158.33, 416.44, 127.62, 420.28, 102.67, 410.69, 84.44, 384.78, 79.64, 335.84, 106.51, 290.74, 137.22, 282.11, 163.12, 271.55, 184.23, 248.52]], "area": 11796.60735, "iscrowd": 0, "image_id": 10123, "bbox": [79.64, 222.62, 126.66, 197.66], "category_id": 43, "id": 659921}, {"segmentation": [[181.99, 283.03, 160.92, 274.71, 138.74, 281.92, 137.63, 294.12, 145.39, 302.43, 150.38, 324.06, 171.45, 323.5, 178.1, 317.96, 177.55, 304.1, 177.0, 291.9, 180.88, 286.35]], "area": 1566.9302500000006, "iscrowd": 0, "image_id": 10138, "bbox": [137.63, 274.71, 44.36, 49.35], "category_id": 47, "id": 669563}, {"segmentation": [[185.64, 91.93, 190.97, 115.47, 201.86, 115.25, 202.52, 89.93, 194.08, 89.71, 185.42, 90.6]], "area": 357.95600000000053, "iscrowd": 0, "image_id": 10138, "bbox": [185.42, 89.71, 17.1, 25.76], "category_id": 47, "id": 681104}, {"segmentation": [[227.75, 266.65, 231.75, 261.54, 238.86, 260.21, 239.97, 260.65, 235.31, 264.87, 232.42, 266.42]], "area": 36.615549999999985, "iscrowd": 0, "image_id": 10138, "bbox": [227.75, 260.21, 12.22, 6.44], "category_id": 50, "id": 707337}, {"segmentation": [[222.55, 244.69, 244.77, 247.07, 250.32, 251.44, 252.7, 254.21, 253.49, 266.11, 246.75, 282.38, 230.88, 290.31, 212.64, 289.91, 199.55, 283.17, 192.8, 266.11, 192.8, 258.97, 195.98, 251.44, 209.86, 246.68, 219.78, 245.49]], "area": 2246.305500000001, "iscrowd": 0, "image_id": 10138, "bbox": [192.8, 244.69, 60.69, 45.62], "category_id": 51, "id": 709546}, {"segmentation": [[354.29, 379.81, 378.74, 372.59, 396.53, 354.25, 393.75, 333.68, 391.53, 317.57, 355.96, 299.23, 329.28, 296.45, 296.5, 302.56, 273.71, 319.24, 268.15, 343.69, 267.04, 357.03, 289.27, 377.03, 332.62, 384.81]], "area": 8889.649099999999, "iscrowd": 0, "image_id": 10138, "bbox": [267.04, 296.45, 129.49, 88.36], "category_id": 61, "id": 1089029}, {"segmentation": [[249.75, 131.31, 246.29, 127.67, 242.11, 122.58, 237.2, 121.13, 238.3, 117.86, 240.3, 116.22, 245.2, 117.49, 267.02, 127.85, 263.56, 130.58, 259.38, 129.67, 249.57, 131.49]], "area": 202.9367499999999, "iscrowd": 0, "image_id": 10205, "bbox": [237.2, 116.22, 29.82, 15.27], "category_id": 75, "id": 1108240}, {"segmentation": [[5.73, 141.31, 44.82, 128.72, 103.57, 131.34, 67.63, 142.88, 6.0, 141.31]], "area": 806.2030999999996, "iscrowd": 0, "image_id": 10138, "bbox": [5.73, 128.72, 97.84, 14.16], "category_id": 81, "id": 1133095}, {"segmentation": [[544.07, 214.04, 555.73, 211.54, 562.4, 212.79, 566.57, 219.46, 570.32, 227.79, 569.9, 234.46, 565.73, 235.29, 564.9, 237.38, 574.07, 254.88, 567.4, 264.04, 559.07, 268.21, 549.48, 260.29, 547.4, 259.04, 542.4, 257.38, 534.07, 248.21, 529.9, 242.79, 529.07, 237.38, 540.73, 241.96, 544.48, 242.38, 545.32, 241.13, 541.57, 231.54, 540.32, 227.79, 540.73, 222.79, 544.07, 214.88]], "area": 1465.3540999999996, "iscrowd": 0, "image_id": 10205, "bbox": [529.07, 211.54, 45.0, 56.67], "category_id": 1, "id": 1217885}, {"segmentation": [[293.11, 322.28, 287.95, 321.35, 285.6, 318.06, 284.19, 310.08, 284.66, 288.95, 288.42, 279.56, 288.89, 260.78, 298.75, 244.35, 302.5, 235.89, 303.91, 222.75, 305.32, 220.87, 292.17, 224.63, 287.48, 225.1, 286.07, 219.46, 294.99, 218.05, 302.5, 214.77, 298.75, 203.97, 296.4, 200.21, 295.93, 196.46, 292.17, 195.99, 289.36, 192.23, 293.58, 187.07, 299.69, 190.82, 303.91, 199.27, 309.55, 206.78, 312.83, 214.3, 317.53, 202.09, 323.63, 199.27, 329.74, 206.78, 325.04, 217.11, 332.55, 226.5, 334.43, 240.12, 341.94, 259.37, 335.37, 261.25, 331.14, 252.8, 325.51, 236.83, 321.75, 239.65, 316.59, 259.84, 313.77, 280.03, 310.96, 282.85, 305.79, 309.14, 306.26, 326.04, 301.57, 325.1, 296.87, 314.77, 298.28, 308.2, 302.03, 289.89, 303.44, 266.88, 302.03, 265.94, 296.87, 278.15, 290.3, 292.7, 291.24, 307.26, 293.11, 314.77]], "area": 2969.8928999999994, "iscrowd": 0, "image_id": 10216, "bbox": [284.19, 187.07, 57.75, 138.97], "category_id": 1, "id": 1246165}, {"segmentation": [[482.16, 96.0, 505.89, 96.0, 514.52, 96.0, 518.83, 94.92, 511.28, 77.66, 506.97, 74.43, 503.73, 70.11, 496.18, 64.72, 487.55, 72.27, 478.92, 78.74, 480.0, 89.53]], "area": 844.1293, "iscrowd": 0, "image_id": 10216, "bbox": [478.92, 64.72, 39.91, 31.28], "category_id": 1, "id": 1264732}, {"segmentation": [[155.42, 107.45, 152.75, 93.41, 152.41, 76.03, 156.42, 65.0, 161.6, 60.65, 160.77, 58.98, 159.26, 56.14, 158.76, 52.63, 158.76, 50.79, 159.26, 50.79, 160.1, 47.79, 161.27, 46.45, 163.44, 45.45, 165.11, 45.61, 167.45, 46.78, 170.96, 50.13, 171.47, 54.97, 170.96, 59.15, 170.46, 60.65, 170.13, 62.66, 170.13, 63.5, 172.47, 63.83, 173.47, 69.85, 173.64, 73.69, 171.8, 81.88, 174.14, 95.92, 174.47, 103.27, 174.14, 107.12, 173.64, 113.47, 173.64, 116.14, 172.13, 125.17, 173.3, 143.72, 178.82, 147.9, 183.67, 150.07, 184.5, 151.91, 180.16, 153.41, 170.13, 153.41, 166.79, 152.07, 166.79, 149.4, 168.12, 146.39, 168.46, 143.38, 167.96, 137.53, 166.28, 129.51, 165.28, 125.84, 163.44, 123.83, 161.77, 127.17, 159.26, 130.35, 157.09, 148.4, 158.43, 149.74, 160.94, 150.24, 161.6, 153.58, 164.45, 157.92, 164.61, 159.6, 161.77, 160.43, 156.42, 159.26, 153.08, 156.92, 153.25, 148.73, 151.74, 139.37, 151.74, 132.69, 152.08, 129.01, 153.25, 126.0, 153.42, 120.65, 154.58, 113.47, 155.92, 107.62]], "area": 1856.6204499999994, "iscrowd": 0, "image_id": 10216, "bbox": [151.74, 45.45, 32.76, 114.98], "category_id": 1, "id": 1272700}, {"segmentation": [[510.6, 71.45, 514.82, 64.8, 519.47, 60.15, 524.79, 58.38, 527.67, 56.6, 525.45, 52.39, 527.22, 49.29, 529.0, 47.96, 534.09, 44.42, 540.52, 47.08, 542.96, 49.29, 542.96, 53.28, 541.18, 58.16, 539.63, 60.37, 538.53, 60.37, 538.75, 62.81, 541.85, 74.11, 540.96, 75.66]], "area": 570.1823499999995, "iscrowd": 0, "image_id": 10216, "bbox": [510.6, 44.42, 32.36, 31.24], "category_id": 1, "id": 1278515}, {"segmentation": [[557.59, 42.55, 569.7, 39.44, 577.46, 45.96, 574.67, 57.14, 576.22, 68.63, 569.39, 72.66, 559.46, 68.63, 553.25, 68.31, 550.76, 63.97, 549.21, 58.07, 546.73, 50.62, 553.25, 52.79, 554.8, 58.69, 560.08, 56.83, 562.56, 53.1, 562.56, 52.48, 559.15, 46.58]], "area": 595.4245000000001, "iscrowd": 0, "image_id": 10216, "bbox": [546.73, 39.44, 30.73, 33.22], "category_id": 1, "id": 1280415}, {"segmentation": [[525.3, 312.81, 538.25, 337.62, 539.33, 360.27, 572.76, 364.58, 587.87, 317.12, 588.94, 313.89, 578.16, 303.1, 564.13, 299.87, 547.96, 297.71, 526.38, 303.1, 524.22, 306.34]], "area": 2998.657399999999, "iscrowd": 0, "image_id": 10138, "bbox": [524.22, 297.71, 64.72, 66.87], "category_id": 47, "id": 1502676}, {"segmentation": [[640.0, 366.13, 630.14, 352.21, 630.91, 341.38, 634.0, 333.65, 640.0, 328.24]], "area": 245.79270000000042, "iscrowd": 0, "image_id": 10138, "bbox": [630.14, 328.24, 9.86, 37.89], "category_id": 51, "id": 1535236}, {"segmentation": [[464.78, 149.82, 618.68, 149.05, 620.22, 159.87, 607.08, 301.4, 501.9, 294.44, 502.67, 275.88, 487.2, 272.79, 479.47, 262.73, 459.36, 261.19, 463.23, 178.44]], "area": 21386.958700000003, "iscrowd": 0, "image_id": 10138, "bbox": [459.36, 149.05, 160.86, 152.35], "category_id": 62, "id": 1578778}, {"segmentation": [[357.78, 55.61, 359.06, 50.27, 362.69, 49.63, 371.23, 49.41, 377.21, 50.48, 378.71, 51.55, 379.13, 54.54, 379.13, 56.67, 378.92, 57.31, 378.49, 57.95]], "area": 143.20760000000007, "iscrowd": 0, "image_id": 10216, "bbox": [357.78, 49.41, 21.35, 8.54], "category_id": 62, "id": 1582582}, {"segmentation": [[636.14, 284.76, 637.62, 294.4, 631.68, 302.56, 607.95, 302.56, 608.69, 275.85, 612.4, 273.63, 623.52, 244.7, 617.59, 235.05, 619.07, 217.25, 625.01, 197.22, 622.78, 175.7, 616.11, 151.96, 593.11, 148.99, 563.43, 137.12, 568.63, 116.35, 603.49, 97.06, 610.17, 72.58, 627.23, 84.45, 639.1, 100.03, 639.1, 206.12]], "area": 6827.851650000001, "iscrowd": 0, "image_id": 10138, "bbox": [563.43, 72.58, 75.67, 229.98], "category_id": 64, "id": 1605547}, {"segmentation": [[639.64, 418.52, 640.0, 480.0, 76.58, 474.61, 0.0, 473.53, 1.08, 368.9, 57.17, 333.3, 73.35, 332.22, 125.12, 288.0, 159.64, 263.19, 192.46, 263.85, 193.13, 256.78, 200.54, 251.39, 219.05, 246.01, 238.91, 246.01, 251.03, 250.05, 254.4, 254.09, 253.39, 267.55, 259.78, 267.89, 262.81, 270.92, 441.9, 288.09, 439.21, 278.32, 446.28, 271.25, 460.41, 269.23, 462.77, 263.51, 469.84, 262.5, 480.27, 264.52, 483.98, 271.59, 494.41, 272.94, 502.49, 281.35, 498.45, 293.81, 537.16, 296.17, 605.16, 302.9, 632.77, 305.59, 640.0, 327.51, 640.0, 398.37]], "area": 120117.90779999997, "iscrowd": 0, "image_id": 10138, "bbox": [0.0, 246.01, 640.0, 233.99], "category_id": 67, "id": 1621290}, {"segmentation": [[230.5, 161.42, 231.52, 123.57, 231.01, 120.51, 233.57, 117.44, 248.4, 110.28, 256.58, 106.19, 259.65, 111.81, 261.69, 117.95, 262.72, 135.85, 265.78, 144.03, 264.76, 146.08, 238.17, 155.28, 237.66, 155.79, 236.12, 156.3], [343.51, 118.97, 361.92, 102.1, 343.51, 102.1, 344.03, 112.84]], "area": 1428.3696000000002, "iscrowd": 0, "image_id": 10138, "bbox": [230.5, 102.1, 131.42, 59.32], "category_id": 79, "id": 1642180}, {"segmentation": [[209.45, 108.01, 238.09, 99.32, 241.16, 122.84, 211.5, 133.58]], "area": 740.3571500000004, "iscrowd": 0, "image_id": 10216, "bbox": [209.45, 99.32, 31.71, 34.26], "category_id": 85, "id": 1664530}, {"segmentation": [[540.74, 35.34, 548.54, 36.67, 552.03, 40.82, 549.87, 46.8, 558.67, 48.62, 558.0, 52.11, 558.34, 58.25, 556.68, 59.58, 553.19, 52.44, 552.19, 51.45, 546.22, 51.61, 552.03, 68.05, 541.24, 68.54, 538.58, 60.58, 540.57, 52.77, 540.57, 52.77, 539.74, 47.96, 538.75, 44.64, 535.93, 40.82, 536.26, 35.18]], "area": 412.42964999999936, "iscrowd": 0, "image_id": 10216, "bbox": [535.93, 35.18, 22.74, 33.36], "category_id": 1, "id": 1676412}, {"segmentation": [[461.47, 34.69, 468.8, 24.92, 478.16, 24.92, 478.77, 20.86, 482.02, 19.23, 486.91, 20.04, 490.57, 25.74, 492.2, 28.59, 492.2, 32.05, 490.97, 37.54, 491.58, 45.47, 487.72, 55.24, 487.72, 59.72, 485.48, 64.39, 483.65, 68.06, 472.46, 67.85, 472.87, 62.16, 466.76, 58.49, 464.93, 58.09, 464.93, 49.54, 461.88, 48.93, 464.93, 64.39, 460.46, 67.04, 457.81, 64.6, 458.02, 60.73, 458.02, 51.58, 458.42, 48.12, 459.64, 43.44, 462.29, 37.34]], "area": 1205.2337500000003, "iscrowd": 0, "image_id": 10216, "bbox": [457.81, 19.23, 34.39, 48.83], "category_id": 1, "id": 1682278}, {"segmentation": [[439.66, 30.17, 435.57, 35.08, 434.55, 36.31, 459.28, 37.94, 460.92, 34.26, 463.37, 31.2, 439.25, 28.74], [462.35, 17.71, 463.98, 22.41, 462.75, 26.29, 462.75, 27.52, 441.71, 25.47, 440.68, 25.06, 441.3, 20.77, 442.73, 17.71, 444.97, 15.66, 447.22, 14.44, 446.81, 11.99, 446.2, 9.12, 445.59, 5.45, 445.59, 3.4, 447.22, 1.97, 450.29, 1.15, 455.19, 1.15, 456.42, 4.02, 457.65, 9.33, 457.65, 13.01, 457.65, 14.23, 460.1, 15.87, 461.32, 16.28, 463.37, 18.32, 463.98, 20.98, 464.19, 22.0]], "area": 562.8165999999999, "iscrowd": 0, "image_id": 10216, "bbox": [434.55, 1.15, 29.64, 36.79], "category_id": 1, "id": 1682466}, {"segmentation": [[438.59, 36.54, 425.2, 38.7, 423.04, 36.98, 413.54, 35.25, 416.56, 25.31, 439.89, 26.18], [441.19, 26.61, 416.56, 23.58, 415.7, 19.69, 419.58, 11.92, 423.9, 10.19, 424.34, 1.98, 428.66, 0.0, 430.82, 0.68, 433.41, 4.57, 433.84, 9.76, 440.75, 11.92, 442.48, 20.56]], "area": 714.7219500000001, "iscrowd": 0, "image_id": 10216, "bbox": [413.54, 0.0, 28.94, 38.7], "category_id": 1, "id": 1685931}, {"segmentation": [[403.23, 4.48, 400.76, 2.57, 397.75, 2.29, 393.09, 7.77, 393.91, 11.34, 391.99, 14.08, 393.09, 20.38, 395.55, 21.75, 402.95, 23.12, 414.46, 22.02, 413.91, 16.82, 410.08, 13.8, 408.43, 12.16, 408.43, 8.05, 405.97, 4.21], [415.01, 26.41, 395.83, 25.04, 395.83, 25.04, 394.46, 31.62, 403.5, 34.9, 413.37, 36.0, 414.46, 36.0]], "area": 497.57030000000015, "iscrowd": 0, "image_id": 10216, "bbox": [391.99, 2.29, 23.02, 33.71], "category_id": 1, "id": 1687015}, {"segmentation": [[393.8, 21.71, 391.33, 16.78, 394.07, 12.12, 394.07, 7.19, 391.33, 5.54, 386.95, 3.62, 385.85, 0.34, 372.97, 0.61, 373.52, 3.35, 366.67, 6.09, 360.64, 9.38, 359.27, 10.75, 358.45, 13.22, 359.82, 14.04, 365.3, 14.04, 367.76, 17.05, 368.86, 20.07, 372.42, 22.53, 394.35, 23.08], [395.99, 25.82, 394.9, 31.3, 389.41, 33.49, 387.22, 33.49, 386.67, 28.01, 384.48, 25.0, 374.89, 23.35, 370.23, 28.84, 368.59, 22.53, 378.73, 22.53, 397.09, 24.73]], "area": 680.9992999999996, "iscrowd": 0, "image_id": 10216, "bbox": [358.45, 0.34, 38.64, 33.15], "category_id": 1, "id": 1688117}, {"segmentation": [[221.38, 13.73, 216.29, 22.02, 214.6, 28.62, 214.6, 31.26, 220.06, 29.18, 225.34, 27.87, 230.24, 26.55, 232.5, 24.85, 235.71, 25.6, 250.97, 21.83, 251.54, 18.63, 251.16, 17.12, 250.79, 16.37, 249.47, 15.61, 248.52, 15.61, 246.64, 15.61, 244.57, 15.99, 242.12, 15.8, 237.4, 14.67, 236.08, 13.54, 236.84, 11.9, 236.27, 9.26, 236.27, 6.62, 236.27, 4.74, 235.9, 2.29, 233.82, 1.72, 231.94, 1.15, 230.05, 1.15, 228.92, 1.34, 227.41, 1.72, 224.96, 3.98, 224.4, 7.0, 224.4, 7.94, 225.53, 8.69, 225.53, 9.45, 224.4, 10.58, 223.27, 12.09, 222.7, 12.84]], "area": 527.3456, "iscrowd": 0, "image_id": 10216, "bbox": [214.6, 1.15, 36.94, 30.11], "category_id": 1, "id": 1694497}, {"segmentation": [[380.19, 58.24, 381.11, 53.9, 384.01, 51.93, 386.9, 51.27, 397.04, 51.53, 400.85, 52.71, 401.64, 54.16, 400.85, 60.61]], "area": 156.9059, "iscrowd": 0, "image_id": 10216, "bbox": [380.19, 51.27, 21.45, 9.34], "category_id": 62, "id": 1933821}, {"segmentation": [[42.25, 61.51, 38.87, 55.51, 37.37, 49.88, 36.25, 45.95, 37.93, 43.7, 41.87, 42.01, 46.37, 41.82, 50.87, 42.38, 53.5, 43.51, 55.93, 48.57, 58.18, 51.38, 60.25, 53.82, 61.0, 55.88]], "area": 321.49435000000005, "iscrowd": 0, "image_id": 10216, "bbox": [36.25, 41.82, 24.75, 19.69], "category_id": 62, "id": 1933979}, {"segmentation": [[345.76, 353.79, 350.08, 361.0, 362.57, 362.44, 385.14, 359.07, 390.91, 364.36, 397.15, 376.84, 400.51, 391.25, 404.35, 426.79, 388.99, 427.0, 384.66, 379.25, 370.26, 378.28, 363.05, 379.73, 358.73, 382.13, 357.77, 383.09, 355.37, 386.93, 354.89, 400.38, 353.93, 427.0, 341.44, 425.35, 346.24, 401.82, 342.88, 388.37, 342.4, 379.73, 340.96, 357.15, 345.28, 356.19], [279.48, 381.65, 284.77, 390.77, 298.7, 426.79, 291.97, 425.83, 286.69, 405.66, 283.81, 426.31, 268.44, 424.87, 276.6, 386.93, 257.39, 391.25, 254.99, 402.3, 254.51, 424.87, 240.58, 424.87, 251.63, 386.45]], "area": 3336.0703499999995, "iscrowd": 0, "image_id": 10123, "bbox": [240.58, 353.79, 163.77, 73.21], "category_id": 62, "id": 1934128}, {"segmentation": [[26.43, 64.93, 22.5, 59.93, 20.35, 59.57, 18.03, 54.21, 17.85, 51.36, 18.39, 49.93, 23.93, 47.78, 29.86, 46.79, 31.26, 46.49, 32.95, 47.09, 37.64, 52.98, 39.44, 58.27, 41.31, 61.24, 31.92, 62.28, 30.18, 65.06, 28.1, 65.06]], "area": 280.57000000000005, "iscrowd": 0, "image_id": 10216, "bbox": [17.85, 46.49, 23.46, 18.57], "category_id": 62, "id": 1938384}, {"segmentation": [[339.91, 253.4, 340.12, 248.79, 342.85, 246.06, 347.04, 244.81, 353.12, 257.17, 353.12, 257.17, 366.12, 280.86, 368.63, 290.72, 366.75, 291.35, 369.05, 294.28, 368.84, 303.3, 367.58, 301.41, 368.21, 319.86, 368.21, 326.15, 365.07, 326.15, 363.81, 291.56, 360.67, 291.56, 361.5, 314.2, 359.41, 314.2, 359.62, 317.76, 356.89, 317.76, 353.75, 299.73, 345.57, 323.21, 343.48, 321.74, 353.12, 291.76, 349.14, 290.3, 349.14, 288.2, 349.97, 286.94, 349.97, 284.43, 347.46, 269.12]], "area": 980.7689999999991, "iscrowd": 0, "image_id": 10205, "bbox": [339.91, 244.81, 29.14, 81.34], "category_id": 62, "id": 1938765}, {"segmentation": [[16.26, 33.97, 16.26, 26.61, 17.73, 22.52, 18.55, 21.71, 24.43, 20.73, 34.08, 23.34, 37.02, 28.08, 37.02, 29.23, 18.55, 36.75]], "area": 223.05610000000001, "iscrowd": 0, "image_id": 10216, "bbox": [16.26, 20.73, 20.76, 16.02], "category_id": 62, "id": 1944774}, {"segmentation": [[13.01, 25.35, 17.64, 35.6, 17.32, 37.0, 17.21, 38.08, 8.91, 42.93, 5.56, 43.58, 2.0, 41.74, 0.0, 37.86, 0.0, 33.87, 0.0, 26.32, 10.85, 24.38]], "area": 258.45559999999995, "iscrowd": 0, "image_id": 10216, "bbox": [0.0, 24.38, 17.64, 19.2], "category_id": 62, "id": 1945472}, {"segmentation": [[445.14, 50.82, 446.23, 40.22, 444.67, 38.67, 430.64, 37.89, 426.9, 39.6, 425.19, 46.77, 425.34, 48.48, 419.27, 49.89, 417.24, 53.0, 424.56, 55.19, 425.97, 57.84, 424.72, 62.67, 425.81, 62.2, 429.08, 57.21, 430.64, 56.43, 440.93, 55.97, 441.08, 53.63, 442.64, 52.07, 444.04, 51.29]], "area": 386.167, "iscrowd": 0, "image_id": 10216, "bbox": [417.24, 37.89, 28.99, 24.78], "category_id": 62, "id": 1945926}, {"segmentation": [[402.61, 60.42, 406.84, 54.33, 416.67, 53.82, 424.29, 55.17, 425.64, 56.53, 424.63, 61.95]], "area": 142.22320000000005, "iscrowd": 0, "image_id": 10216, "bbox": [402.61, 53.82, 23.03, 8.13], "category_id": 62, "id": 1945953}, {"segmentation": [[586.14, 70.43, 588.04, 67.1, 587.33, 67.1, 585.19, 68.53, 581.63, 69.95, 579.96, 70.9, 578.54, 72.33, 574.27, 71.38, 572.84, 70.43, 573.08, 68.53, 576.64, 66.63, 581.86, 62.83, 582.58, 59.03, 582.81, 53.33, 583.53, 50.24, 584.71, 49.06, 587.33, 48.11, 588.51, 48.34, 587.09, 47.16, 586.14, 45.26, 586.61, 42.88, 586.38, 40.03, 587.56, 38.13, 591.36, 36.95, 593.26, 36.95, 594.92, 38.61, 596.11, 39.08, 598.72, 40.74, 598.01, 42.41, 597.54, 43.59, 596.59, 43.59, 597.07, 46.04, 596.83, 46.65, 596.71, 47.01, 597.81, 47.01, 598.54, 47.62, 602.69, 47.87, 603.91, 48.11, 606.35, 49.82, 606.47, 52.38, 606.47, 53.97, 603.91, 55.31, 596.34, 59.22, 595.12, 60.32, 594.88, 62.15, 594.63, 63.12, 593.66, 63.73, 592.19, 65.08, 586.46, 69.96], [605.37, 58.12, 605.37, 72.52, 599.76, 72.89, 597.56, 75.21, 596.22, 77.28, 594.88, 79.85, 593.66, 79.72, 593.78, 72.77, 588.41, 72.52, 605.01, 57.14]], "area": 652.1805000000011, "iscrowd": 0, "image_id": 10216, "bbox": [572.84, 36.95, 33.63, 42.9], "category_id": 1, "id": 2021899}, {"segmentation": [[220.68, 99.48, 220.21, 83.66, 219.5, 75.39, 218.79, 71.85, 218.55, 68.07, 217.84, 64.76, 217.14, 62.16, 218.08, 59.56, 220.44, 58.85, 222.8, 62.4, 224.93, 67.12, 225.17, 70.19, 225.64, 80.11, 221.62, 101.14]], "area": 188.99809999999965, "iscrowd": 0, "image_id": 10138, "bbox": [217.14, 58.85, 8.5, 42.29], "category_id": 44, "id": 2094307}, {"segmentation": [[69.38, 121.92, 62.85, 86.09, 58.09, 81.73, 58.09, 78.76, 55.92, 76.98, 52.35, 78.17, 51.96, 79.36, 51.96, 81.73, 52.55, 82.52, 51.76, 84.9, 50.57, 87.27, 51.36, 93.21, 54.73, 120.33, 55.92, 124.89, 68.59, 122.12]], "area": 562.893, "iscrowd": 0, "image_id": 10138, "bbox": [50.57, 76.98, 18.81, 47.91], "category_id": 44, "id": 2096136}, {"segmentation": [[338.55, 251.75, 340.06, 249.94, 341.58, 248.12, 344.6, 245.7, 346.11, 245.1, 345.51, 244.79, 343.69, 244.19, 341.88, 244.19, 339.15, 245.1, 337.34, 246.01, 336.43, 246.61, 336.13, 247.22]], "area": 32.802750000000046, "iscrowd": 0, "image_id": 10205, "bbox": [336.13, 244.19, 9.98, 7.56], "category_id": 62, "id": 2124447}, {"segmentation": [[215.7, 95.28, 234.59, 92.14, 249.28, 98.96, 261.35, 110.5, 272.36, 122.56, 281.28, 123.09, 268.69, 140.4, 293.35, 182.37, 299.65, 189.19, 310.14, 195.49, 332.17, 216.47, 358.4, 233.79, 373.09, 239.03, 384.11, 241.13, 400.37, 242.18, 415.59, 242.7, 418.21, 251.1, 396.7, 252.67, 395.13, 254.25, 414.01, 274.71, 422.93, 285.72, 419.26, 289.4, 413.49, 291.5, 401.95, 282.05, 404.05, 294.64, 398.8, 287.82, 386.21, 268.94, 385.68, 284.68, 380.96, 283.63, 379.39, 271.03, 369.95, 258.97, 357.88, 255.82, 335.84, 247.43, 298.07, 228.01, 314.33, 264.74, 326.4, 282.05, 320.11, 287.82, 325.88, 301.46, 348.44, 348.16, 355.26, 357.07, 341.09, 357.6, 345.29, 391.18, 344.76, 402.72, 343.19, 427.0, 298.07, 425.8, 280.76, 383.31, 251.38, 388.03, 238.26, 427.0, 186.32, 426.85, 184.23, 395.9, 181.08, 387.5, 182.65, 367.57, 178.98, 338.19, 173.73, 315.1, 183.18, 275.76, 191.05, 262.12, 196.29, 249.0, 206.26, 237.98, 207.31, 221.19, 191.05, 222.77, 185.8, 239.03, 183.7, 241.66, 177.41, 226.97, 168.49, 217.52, 163.77, 211.59, 152.75, 209.49, 150.65, 204.24, 139.11, 177.48, 129.66, 157.55, 107.11, 169.62, 96.09, 166.47, 110.78, 161.22, 115.5, 148.63, 118.65, 139.71, 118.12, 97.22, 111.83, 86.72, 95.04, 56.29, 93.46, 37.41, 100.81, 21.37, 114.45, 10.36, 121.27, 5.64, 132.81, 3.01, 141.73, 4.59, 151.17, 10.36, 159.04, 15.6, 167.96, 23.47, 174.78, 34.49, 178.46, 44.98, 178.46, 54.43, 175.83, 60.72, 187.37, 88.0, 204.16, 92.2, 212.56, 94.82]], "area": 57424.77520000001, "iscrowd": 0, "image_id": 10123, "bbox": [93.46, 3.01, 329.47, 423.99], "category_id": 1, "id": 2152925}, {"segmentation": [[623.09, 315.0, 623.41, 338.2, 613.88, 338.52, 614.52, 317.55, 608.16, 317.23, 613.24, 339.15, 609.11, 342.33, 601.17, 341.06, 595.13, 314.69, 594.18, 311.19, 590.68, 310.24, 588.78, 312.46, 586.55, 313.73, 586.55, 336.61, 581.79, 334.7, 581.15, 329.3, 583.38, 319.45, 579.24, 263.53, 578.61, 252.09, 582.1, 249.86, 582.74, 251.45, 583.38, 260.03, 611.97, 258.12, 613.56, 250.18, 619.28, 251.45, 622.78, 304.2]], "area": 2978.710299999998, "iscrowd": 0, "image_id": 10205, "bbox": [578.61, 249.86, 44.8, 92.47], "category_id": 62, "id": 2191957}, {"segmentation": [[2.15, 452.08, 30.2, 435.06, 55.74, 445.15, 74.65, 463.75, 68.98, 470.68, 56.05, 480.0, 0.0, 480.0]], "area": 2421.199550000001, "iscrowd": 0, "image_id": 10138, "bbox": [0.0, 435.06, 74.65, 44.94], "category_id": 77, "id": 2195897}, {"segmentation": [[132.3, 76.26, 132.43, 59.68, 134.93, 60.21, 135.19, 62.44, 134.4, 75.6]], "area": 39.33569999999988, "iscrowd": 0, "image_id": 10138, "bbox": [132.3, 59.68, 2.89, 16.58], "category_id": 49, "id": 2230916}, {"segmentation": [[132.28, 59.68, 135.27, 60.55, 135.14, 67.28, 134.4, 73.56, 132.22, 73.69, 131.78, 72.82, 132.03, 61.3, 132.09, 59.74]], "area": 41.66949999999996, "iscrowd": 0, "image_id": 10138, "bbox": [131.78, 59.68, 3.49, 14.01], "category_id": 49, "id": 2230939}, {"segmentation": [[138.12, 59.24, 141.43, 59.09, 140.98, 71.74, 140.25, 73.28, 138.26, 72.99, 138.41, 67.84]], "area": 39.93589999999998, "iscrowd": 0, "image_id": 10138, "bbox": [138.12, 59.09, 3.31, 14.19], "category_id": 49, "id": 2230945}, {"segmentation": [[143.22, 72.48, 146.12, 72.87, 144.41, 86.03, 141.78, 85.64, 142.96, 72.87]], "area": 38.43164999999994, "iscrowd": 0, "image_id": 10138, "bbox": [141.78, 72.48, 4.34, 13.55], "category_id": 49, "id": 2230959}, {"segmentation": [[263.43, 216.57, 266.02, 207.74, 269.82, 203.02, 275.61, 198.76, 281.39, 197.24, 289.61, 197.09, 296.31, 200.59, 300.88, 206.37, 302.25, 211.55, 301.48, 218.1, 299.81, 224.34, 295.7, 227.53, 290.07, 232.25, 285.2, 233.32, 280.17, 234.38, 262.21, 217.03]], "area": 1050.1988000000001, "iscrowd": 0, "image_id": 10400, "bbox": [262.21, 197.09, 40.04, 37.29], "category_id": 85, "id": 334462}, {"segmentation": [[211.89, 281.62, 264.86, 391.89, 264.86, 391.89, 317.84, 401.62, 408.65, 315.14, 503.78, 201.62, 486.49, 194.05, 425.95, 201.62, 361.08, 185.41, 305.95, 172.43, 272.43, 170.27, 243.24, 170.27, 259.46, 181.08, 260.54, 184.32, 264.86, 207.03, 264.86, 223.24, 249.73, 241.62, 247.57, 243.78, 234.59, 260.0, 232.43, 263.24, 214.05, 278.38]], "area": 37887.92384999998, "iscrowd": 0, "image_id": 10217, "bbox": [211.89, 170.27, 291.89, 231.35], "category_id": 59, "id": 1570928}, {"segmentation": [[445.56, 84.97, 460.63, 53.76, 476.77, 20.39, 496.14, 17.17, 542.42, 23.62, 587.62, 35.46, 636.05, 86.04, 640.0, 110.8, 639.28, 187.21, 610.22, 200.13, 482.15, 168.91, 443.41, 126.94]], "area": 27252.161699999997, "iscrowd": 0, "image_id": 10217, "bbox": [443.41, 17.17, 196.59, 182.96], "category_id": 74, "id": 1629792}, {"segmentation": {"counts": [121, 12, 347, 2, 2, 8, 3, 1, 1, 1, 5, 2, 3, 1, 1, 1, 2, 2, 3, 5, 1, 7, 1, 5, 1, 4, 1, 3, 1, 4, 1, 5, 1, 12, 1, 2, 1, 1, 2, 1, 14, 30, 11, 11, 1, 7, 1, 6, 3, 2, 12, 8, 8, 38, 1, 1, 1, 4, 2, 2, 1, 1, 1, 2, 1, 85, 128, 2, 1, 10, 2, 42, 1, 41, 1, 1, 7, 38, 7, 11, 1, 25, 5, 9, 8, 140, 128, 14, 1, 87, 3, 42, 6, 37, 4, 10, 8, 140, 128, 14, 1, 133, 5, 38, 2, 11, 8, 140, 128, 14, 1, 133, 4, 53, 7, 140, 128, 149, 3, 54, 6, 140, 128, 206, 6, 140, 99, 22, 7, 206, 6, 140, 95, 29, 4, 206, 7, 139, 70, 57, 1, 206, 7, 139, 63, 65, 1, 72, 6, 127, 7, 138, 60, 69, 1, 73, 5, 127, 8, 137, 57, 146, 5, 127, 8, 136, 57, 147, 5, 126, 10, 135, 55, 149, 5, 125, 11, 134, 53, 152, 6, 124, 12, 133, 50, 155, 6, 123, 13, 132, 50, 156, 7, 121, 15, 131, 48, 157, 8, 119, 18, 129, 48, 157, 10, 114, 23, 127, 49, 155, 12, 113, 25, 125, 49, 158, 11, 112, 26, 123, 49, 160, 10, 112, 28, 120, 50, 161, 7, 114, 29, 118, 50, 283, 31, 115, 50, 283, 35, 111, 49, 285, 35, 109, 47, 288, 40, 12, 1, 91, 45, 291, 41, 7, 5, 89, 46, 291, 56, 65, 66, 293, 58, 59, 69, 294, 59, 56, 71, 293, 61, 53, 71, 295, 64, 44, 76, 295, 67, 40, 76, 191, 2, 103, 69, 37, 77, 188, 6, 102, 179, 190, 8, 102, 177, 191, 10, 102, 176, 190, 12, 102, 174, 191, 12, 104, 172, 191, 12, 105, 172, 190, 13, 105, 171, 189, 14, 106, 170, 188, 16, 106, 170, 189, 14, 107, 169, 193, 10, 108, 169, 194, 9, 108, 169, 195, 7, 109, 169, 196, 6, 109, 169, 196, 6, 109, 169, 196, 5, 110, 169, 196, 4, 111, 169, 196, 4, 111, 169, 196, 3, 112, 169, 196, 3, 112, 169, 196, 2, 112, 171, 196, 1, 112, 171, 309, 172, 308, 173, 307, 174, 306, 175, 304, 177, 303, 179, 14, 3, 283, 183, 8, 7, 282, 199, 280, 202, 17, 2, 259, 205, 7, 13, 254, 227, 253, 228, 251, 230, 249, 232, 247, 235, 13, 2, 229, 239, 7, 8, 225, 261, 53, 1, 163, 263, 53, 4, 159, 265, 52, 6, 156, 267, 51, 11, 151, 268, 38, 1, 10, 1, 162, 269, 211, 270, 210, 272, 208, 275, 205, 279, 201, 279, 201, 279, 201, 279, 201, 279, 201, 279, 111, 5, 85, 279, 106, 11, 13, 10, 61, 279, 105, 14, 7, 19, 55, 280, 100, 20, 4, 24, 52, 281, 96, 53, 50, 281, 94, 57, 48, 282, 93, 59, 45, 284, 92, 61, 43, 285, 92, 62, 40, 287, 92, 62, 39, 288, 92, 62, 37, 290, 93, 61, 36, 291, 93, 62, 33, 293, 93, 62, 32, 294, 93, 62, 30, 297, 91, 62, 29, 301, 12, 1, 75, 63, 27, 315, 75, 64, 25, 316, 75, 65, 23, 317, 75, 66, 20, 319, 75, 67, 18, 320, 75, 68, 15, 322, 75, 69, 11, 325, 74, 71, 6, 329, 73, 407, 71, 409, 68, 412, 67, 414, 66, 271, 8, 135, 65, 269, 14, 131, 66, 268, 16, 130, 66, 266, 20, 128, 66, 265, 22, 127, 66, 265, 22, 127, 67, 263, 24, 126, 67, 262, 26, 125, 68, 261, 26, 124, 69, 260, 28, 123, 69, 260, 28, 123, 69, 260, 28, 123, 69, 260, 28, 124, 68, 260, 28, 124, 68, 260, 28, 125, 67, 260, 28, 124, 68, 260, 28, 123, 70, 259, 28, 123, 70, 259, 28, 123, 71, 258, 28, 123, 72, 257, 28, 123, 73, 256, 28, 123, 73, 256, 28, 123, 12, 2, 60, 255, 28, 123, 12, 3, 60, 254, 28, 123, 11, 5, 59, 254, 28, 124, 9, 3, 62, 254, 28, 126, 5, 3, 64, 254, 28, 133, 65, 254, 28, 129, 70, 253, 28, 125, 74, 253, 28, 124, 75, 253, 28, 123, 76, 252, 29, 123, 76, 252, 29, 123, 75, 252, 30, 123, 74, 253, 30, 123, 72, 255, 30, 123, 68, 259, 30, 124, 68, 258, 30, 124, 69, 257, 30, 124, 70, 13, 14, 228, 30, 125, 71, 9, 21, 224, 30, 125, 71, 7, 26, 221, 29, 126, 71, 5, 30, 219, 29, 127, 70, 3, 33, 218, 29, 126, 71, 2, 36, 216, 28, 127, 71, 1, 39, 213, 29, 127, 113, 211, 29, 127, 115, 209, 31, 125, 117, 207, 32, 4, 8, 112, 118, 205, 48, 110, 119, 202, 50, 108, 122, 200, 52, 106, 125, 196, 54, 105, 127, 193, 55, 104, 130, 191, 57, 102, 133, 187, 59, 101, 135, 185, 61, 99, 138, 181, 63, 98, 140, 179, 63, 98, 143, 176, 66, 95, 145, 172, 69, 94, 147, 169, 72, 92, 149, 165, 75, 91, 151, 162, 77, 90, 153, 159, 79, 89, 155, 155, 82, 88, 157, 152, 84, 87, 157, 151, 86, 87, 157, 149, 88, 87, 157, 148, 90, 84, 159, 146, 92, 83, 159, 145, 95, 81, 160, 144, 96, 80, 161, 142, 99, 78, 162, 141, 103, 74, 162, 141, 106, 71, 163, 139, 108, 69, 165, 138, 110, 67, 166, 137, 111, 66, 167, 136, 111, 66, 168, 135, 112, 65, 169, 134, 113, 64, 170, 133, 113, 64, 170, 133, 114, 63, 171, 132, 114, 63, 172, 131, 114, 63, 172, 131, 114, 63, 173, 130, 114, 63, 173, 130, 46, 23, 45, 63, 173, 130, 44, 29, 41, 63, 174, 129, 42, 34, 38, 63, 174, 129, 40, 40, 34, 63, 175, 128, 37, 46, 31, 63, 175, 128, 35, 51, 28, 64, 177, 124, 34, 56, 24, 65, 176, 125, 32, 61, 21, 65, 174, 126, 31, 65, 18, 66, 173, 127, 31, 68, 14, 67, 172, 127, 32, 70, 11, 68, 171, 128, 31, 74, 7, 69, 170, 128, 32, 76, 6, 67, 171, 128, 32, 79, 3, 67, 71, 1, 99, 127, 32, 83, 1, 66, 71, 4, 96, 127, 32, 150, 71, 8, 91, 127, 32, 151, 71, 12, 9, 17, 61, 127, 32, 151, 71, 15, 4, 32, 15, 5, 28, 127, 32, 151, 71, 73, 25, 128, 31, 152, 70, 75, 24, 127, 32, 152, 70, 76, 23, 127, 32, 152, 71, 76, 21, 128, 31, 153, 72, 76, 20, 128, 31, 153, 73, 77, 18, 128, 28, 156, 73, 78, 17, 128, 26, 158, 73, 79, 15, 129, 24, 160, 73, 80, 14, 129, 22, 162, 73, 81, 13, 129, 24, 160, 73, 81, 12, 130, 25, 13, 24, 122, 73, 81, 12, 130, 25, 11, 38, 110, 73, 81, 12, 130, 25, 10, 45, 104, 73, 39, 3, 40, 10, 131, 25, 8, 51, 100, 73, 28, 17, 37, 11, 130, 25, 6, 56, 97, 73, 25, 22, 35, 13, 128, 25, 4, 61, 94, 72, 23, 28, 32, 15, 126, 25, 3, 65, 91, 71, 21, 33, 31, 15, 125, 25, 1, 70, 88, 69, 21, 38, 28, 17, 123, 99, 85, 63, 24, 43, 26, 19, 121, 102, 82, 65, 10, 1, 10, 46, 24, 20, 120, 105, 79, 67, 7, 1, 10, 48, 24, 21, 118, 108, 76, 69, 4, 1, 10, 50, 23, 23, 116, 111, 73, 70, 2, 2, 9, 52, 22, 25, 113, 115, 70, 71, 1, 1, 9, 54, 21, 26, 110, 120, 67, 73, 8, 56, 20, 27, 108, 124, 64, 77, 2, 58, 21, 27, 105, 129, 61, 138, 20, 27, 104, 133, 23, 2, 33, 139, 19, 27, 103, 147, 9, 5, 31, 140, 17, 29, 101, 165, 28, 141, 16, 29, 100, 167, 27, 142, 15, 30, 98, 170, 25, 143, 14, 30, 97, 172, 24, 144, 12, 32, 95, 174, 23, 145, 11, 32, 94, 175, 23, 146, 8, 35, 92, 177, 22, 147, 2, 1, 1, 38, 92, 178, 21, 190, 89, 180, 21, 190, 88, 182, 21, 190, 86, 183, 21, 190, 86, 183, 21, 191, 84, 184, 21, 189, 85, 185, 20, 187, 88, 39, 6, 140, 20, 184, 90, 39, 13, 134, 20, 182, 92, 37, 21, 128, 20, 181, 92, 37, 28, 122, 20, 179, 94, 35, 36, 116, 20, 178, 95, 34, 40, 113, 20, 176, 96, 33, 44, 110, 21, 175, 97, 32, 47, 42, 1, 65, 21, 173, 99, 30, 52, 39, 11, 54, 22, 172, 99, 30, 55, 37, 11, 53, 23, 170, 101, 28, 59, 35, 11, 52, 25, 166, 103, 28, 62, 33, 11, 51, 27, 155, 1, 7, 105, 26, 67, 30, 11, 50, 29, 154, 2, 4, 107, 27, 68, 27, 12, 48, 32, 153, 3, 2, 108, 27, 70, 25, 12, 32, 6, 7, 37, 151, 113, 27, 73, 21, 14, 31, 54, 147, 113, 27, 75, 18, 15, 31, 55, 146, 113, 28, 76, 15, 17, 30, 55, 146, 113, 28, 78, 12, 19, 29, 55, 146, 113, 28, 81, 8, 21, 27, 57, 144, 114, 29, 82, 4, 24, 26, 58, 142, 115, 29, 111, 24, 61, 140, 115, 27, 114, 22, 60, 141, 117, 25, 116, 20, 60, 142, 117, 24, 118, 18, 60, 142, 119, 21, 29, 8, 84, 16, 60, 143, 120, 19, 17, 23, 84, 12, 61, 143, 122, 17, 13, 31, 84, 6, 63, 144, 123, 14, 13, 35, 150, 144, 125, 12, 13, 38, 148, 143, 127, 11, 11, 42, 145, 144, 127, 12, 9, 46, 141, 144, 128, 13, 6, 50, 139, 144, 128, 13, 5, 53, 136, 144, 127, 16, 2, 58, 133, 144, 124, 19, 1, 61, 131, 143, 124, 84, 128, 144, 122, 88, 126, 144, 121, 92, 123, 144, 119, 96, 121, 144, 118, 99, 119, 144, 117, 103, 36, 7, 73, 144, 116, 106, 34, 38, 42, 144, 116, 108, 32, 41, 39, 144, 115, 111, 30, 42, 38, 144, 114, 40, 27, 48, 28, 43, 36, 153, 4, 8, 93, 38, 32, 47, 26, 44, 35, 153, 2, 16, 86, 37, 36, 47, 24, 44, 35, 177, 80, 35, 41, 47, 19, 47, 34, 180, 77, 34, 44, 47, 14, 51, 33, 182, 75, 32, 49, 46, 10, 53, 32, 184, 73, 31, 53, 46, 6, 56, 30, 187, 71, 29, 58, 46, 1, 58, 30, 188, 70, 28, 61, 103, 29, 191, 67, 29, 64, 100, 29, 192, 66, 29, 66, 98, 29, 194, 63, 29, 70, 95, 29, 195, 61, 30, 72, 93, 29, 197, 59, 29, 76, 90, 29, 198, 57, 30, 77, 89, 29, 200, 55, 29, 80, 87, 29, 201, 53, 30, 81, 86, 29, 203, 51, 29, 84, 83, 30, 204, 49, 30, 86, 81, 30, 206, 47, 29, 88, 79, 31, 207, 46, 28, 91, 76, 32, 209, 44, 27, 93, 74, 33, 210, 43, 27, 95, 71, 34, 211, 42, 26, 97, 69, 35, 213, 39, 26, 101, 10, 2, 6, 2, 44, 37, 214, 24, 2, 12, 25, 133, 30, 40, 216, 19, 6, 11, 24, 204, 217, 16, 9, 10, 23, 205, 218, 12, 13, 9, 22, 206, 220, 8, 15, 9, 22, 206, 221, 5, 18, 8, 21, 207, 245, 7, 20, 208, 245, 7, 20, 208, 246, 6, 20, 208, 246, 6, 20, 208, 246, 6, 20, 208, 247, 5, 19, 209, 247, 5, 19, 209, 247, 5, 19, 209, 247, 5, 19, 209, 247, 6, 18, 209, 247, 6, 17, 210, 247, 7, 16, 210, 247, 8, 17, 208, 247, 9, 10, 2, 8, 204, 247, 10, 9, 9, 5, 200, 247, 11, 7, 17, 2, 196, 247, 13, 5, 23, 1, 191, 247, 16, 2, 215, 247, 233, 247, 233, 246, 234, 147, 1, 98, 234, 148, 2, 95, 235, 148, 3, 94, 235, 148, 5, 91, 236, 148, 8, 88, 236, 148, 8, 88, 236, 148, 7, 89, 236, 148, 7, 89, 236, 148, 7, 89, 236, 148, 6, 90, 236, 148, 6, 90, 236, 148, 6, 90, 236, 148, 6, 90, 236, 148, 6, 90, 236, 148, 6, 90, 236, 148, 6, 90, 236, 148, 6, 90, 236, 148, 6, 89, 237, 148, 6, 89, 237, 148, 6, 88, 238, 148, 6, 88, 238, 148, 6, 87, 239, 148, 6, 87, 239, 148, 6, 86, 240, 148, 7, 85, 240, 148, 7, 84, 241, 148, 8, 82, 242, 147, 9, 81, 243, 147, 10, 79, 244, 147, 10, 79, 244, 146, 12, 77, 245, 146, 12, 76, 246, 145, 14, 75, 246, 145, 15, 74, 246, 144, 17, 73, 246, 144, 18, 72, 246, 143, 20, 71, 246, 143, 21, 70, 246, 142, 22, 69, 247, 141, 24, 68, 248, 139, 25, 68, 249, 137, 27, 66, 251, 135, 29, 65, 252, 135, 29, 63, 255, 133, 30, 62, 256, 133, 30, 60, 259, 131, 32, 58, 261, 129, 33, 56, 263, 129, 33, 55, 265, 127, 33, 54, 267, 126, 33, 54, 269, 124, 34, 53, 271, 122, 34, 53, 274, 119, 35, 52, 276, 117, 35, 52, 277, 116, 36, 51, 278, 115, 36, 51, 279, 114, 36, 51, 280, 113, 37, 50, 281, 112, 37, 49, 284, 110, 38, 48, 285, 109, 38, 47, 288, 107, 39, 46, 290, 105, 39, 45, 294, 21, 9, 72, 40, 44, 298, 13, 13, 72, 40, 43, 325, 73, 40, 42, 325, 73, 41, 40, 325, 74, 42, 38, 325, 75, 43, 36, 326, 75, 44, 34, 326, 76, 45, 32, 141, 11, 174, 77, 47, 28, 143, 13, 172, 77, 48, 26, 145, 13, 170, 78, 50, 22, 147, 14, 169, 78, 53, 16, 150, 15, 168, 78, 57, 8, 153, 17, 166, 79, 218, 19, 164, 79, 218, 22, 161, 79, 218, 24, 159, 79, 9, 12, 197, 26, 156, 80, 6, 18, 193, 29, 154, 80, 4, 22, 191, 32, 150, 81, 2, 26, 188, 35, 148, 119, 176, 39, 145, 123, 172, 42, 143, 125, 169, 46, 140, 127, 165, 50, 137, 130, 162, 53, 135, 131, 159, 57, 133, 132, 157, 61, 130, 133, 146, 73, 128, 134, 146, 74, 126, 135, 145, 76, 124, 136, 144, 79, 121, 137, 143, 81, 119, 138, 143, 82, 117, 139, 142, 84, 115, 139, 142, 87, 112, 140, 141, 89, 110, 141, 140, 91, 108, 141, 141, 92, 106, 142, 140, 94, 104, 142, 139, 97, 102, 142, 138, 101, 99, 143, 137, 103, 97, 143, 135, 107, 95, 143, 134, 110, 93, 143, 133, 113, 91, 143, 132, 117, 88, 143, 132, 119, 86, 143, 132, 121, 84, 143, 132, 123, 82, 143, 132, 125, 80, 143, 132, 127, 79, 142, 131, 131, 76, 142, 131, 133, 74, 142, 131, 135, 73, 141, 131, 137, 71, 141, 130, 140, 69, 141, 129, 144, 66, 141, 129, 146, 64, 141, 128, 148, 63, 143, 126, 149, 62, 145, 124, 150, 61, 146, 122, 151, 61, 147, 121, 151, 61, 148, 120, 151, 62, 148, 119, 151, 62, 149, 118, 151, 63, 149, 116, 152, 63, 149, 116, 152, 64, 149, 115, 152, 64, 150, 113, 153, 65, 149, 113, 153, 65, 150, 112, 153, 66, 149, 112, 153, 67, 148, 112, 153, 68, 148, 111, 153, 69, 147, 111, 153, 70, 146, 111, 153, 71, 145, 110, 154, 72, 144, 109, 155, 73, 143, 109, 155, 73, 143, 108, 156, 74, 142, 108, 156, 74, 142, 107, 157, 75, 141, 107, 157, 76, 139, 108, 157, 77, 138, 107, 158, 77, 137, 108, 158, 78, 136, 108, 158, 78, 135, 109, 158, 79, 134, 108, 159, 79, 133, 108, 160, 80, 132, 108, 160, 80, 131, 108, 161, 80, 131, 107, 162, 81, 129, 108, 162, 81, 129, 107, 163, 82, 128, 106, 164, 82, 127, 106, 165, 83, 126, 106, 165, 83, 125, 106, 166, 83, 125, 106, 166, 83, 124, 107, 166, 83, 124, 106, 167, 83, 123, 106, 168, 83, 123, 106, 168, 83, 122, 106, 169, 83, 120, 108, 169, 83, 120, 106, 171, 83, 119, 106, 172, 83, 119, 105, 173, 83, 118, 105, 174, 83, 50, 1, 67, 104, 175, 83, 50, 2, 66, 103, 176, 83, 50, 2, 66, 102, 177, 84, 48, 3, 66, 101, 178, 84, 48, 4, 65, 100, 179, 85, 46, 5, 65, 99, 180, 85, 46, 6, 64, 98, 181, 86, 44, 7, 64, 97, 182, 86, 44, 8, 63, 96, 183, 87, 42, 9, 63, 95, 184, 87, 42, 10, 62, 95, 184, 88, 40, 11, 62, 94, 185, 89, 38, 13, 61, 93, 186, 90, 36, 15, 60, 93, 186, 91, 34, 16, 60, 92, 187, 92, 32, 18, 59, 92, 187, 94, 28, 20, 59, 91, 188, 95, 26, 21, 59, 91, 188, 97, 22, 24, 58, 90, 189, 100, 16, 27, 58, 90, 189, 104, 8, 32, 57, 8, 12, 69, 143, 1, 46, 144, 56, 6, 21, 63, 143, 3, 44, 144, 56, 4, 26, 59, 144, 6, 41, 145, 55, 2, 31, 55, 145, 9, 38, 145, 92, 51, 145, 12, 33, 148, 94, 47, 146, 13, 31, 149, 97, 44, 146, 15, 27, 152, 99, 40, 147, 18, 21, 155, 101, 37, 147, 23, 13, 159, 103, 36, 146, 195, 105, 33, 146, 196, 107, 30, 147, 196, 108, 29, 147, 196, 109, 27, 147, 197, 110, 26, 147, 197, 111, 24, 148, 198, 111, 22, 148, 199, 112, 21, 147, 201, 112, 19, 147, 202, 113, 17, 148, 203, 113, 16, 147, 204, 113, 15, 146, 207, 113, 13, 146, 208, 114, 12, 144, 211, 113, 11, 142, 215, 113, 10, 141, 217, 112, 9, 142, 218, 112, 6, 143, 220, 111, 5, 143, 222, 111, 3, 143, 225, 109, 2, 143, 227, 108, 1, 145, 228, 252, 231, 249, 235, 245, 242, 238, 242, 238, 242, 238, 242, 238, 242, 238, 242, 238, 242, 238, 242, 238, 242, 237, 243, 237, 243, 237, 243, 236, 244, 235, 245, 234, 247, 233, 247, 232, 249, 229, 251, 228, 253, 225, 255, 222, 259, 219, 261, 217, 264, 213, 268, 208, 273, 199, 282, 198, 283, 197, 285, 195, 286, 26, 2, 166, 288, 22, 5, 165, 291, 16, 9, 164, 295, 8, 15, 162, 319, 161, 321, 159, 322, 158, 322, 158, 323, 157, 323, 157, 324, 156, 324, 156, 325, 154, 327, 153, 328, 151, 329, 151, 100], "size": [480, 640]}, "area": 161254, "iscrowd": 1, "image_id": 10432, "bbox": [0, 0, 639, 479], "category_id": 52, "id": 905200010432}, {"segmentation": {"counts": [6, 8, 54, 4, 16, 4, 393, 10, 46, 3, 1, 9, 8, 11, 391, 11, 46, 33, 388, 13, 46, 33, 387, 14, 46, 33, 386, 15, 46, 33, 386, 16, 46, 32, 386, 17, 45, 32, 386, 18, 44, 32, 386, 19, 42, 33, 387, 19, 40, 34, 387, 19, 39, 34, 388, 19, 38, 34, 390, 18, 37, 36, 390, 19, 35, 36, 391, 19, 34, 36, 391, 19, 34, 36, 391, 19, 34, 36, 392, 19, 33, 35, 390, 4, 1, 17, 33, 34, 390, 23, 33, 34, 389, 24, 33, 33, 390, 24, 32, 34, 390, 23, 33, 33, 391, 19, 37, 33, 391, 19, 37, 32, 392, 21, 35, 31, 393, 22, 35, 30, 393, 23, 35, 29, 393, 24, 36, 11, 1, 14, 394, 24, 39, 8, 4, 10, 396, 23, 40, 6, 6, 9, 396, 23, 41, 4, 7, 9, 396, 28, 47, 9, 396, 29, 46, 9, 396, 30, 46, 7, 397, 31, 46, 5, 398, 31, 449, 31, 449, 31, 449, 31, 449, 31, 449, 32, 448, 32, 448, 36, 444, 37, 443, 39, 441, 40, 440, 41, 439, 41, 439, 41, 439, 41, 439, 41, 439, 41, 439, 41, 439, 41, 440, 40, 440, 40, 439, 42, 21, 7, 410, 42, 18, 12, 409, 41, 13, 18, 407, 42, 8, 23, 407, 42, 4, 28, 406, 43, 1, 30, 406, 74, 405, 75, 405, 75, 406, 74, 99, 5, 1, 6, 296, 73, 92, 20, 295, 73, 81, 32, 294, 73, 79, 36, 292, 72, 74, 43, 291, 72, 73, 45, 290, 72, 66, 53, 289, 71, 62, 59, 288, 70, 61, 62, 287, 16, 2, 52, 60, 64, 286, 16, 1, 32, 1, 19, 60, 65, 286, 47, 3, 18, 58, 68, 287, 45, 4, 8, 1, 8, 50, 6, 2, 70, 285, 46, 4, 8, 3, 4, 51, 79, 285, 46, 4, 8, 56, 81, 286, 29, 1, 15, 4, 8, 54, 84, 285, 29, 1, 15, 4, 8, 53, 86, 284, 46, 3, 9, 51, 87, 284, 47, 3, 9, 49, 88, 284, 47, 2, 11, 47, 89, 284, 47, 2, 11, 47, 89, 284, 47, 2, 11, 47, 89, 284, 60, 47, 74, 2, 13, 284, 61, 46, 72, 4, 13, 284, 61, 46, 62, 14, 13, 284, 62, 45, 60, 17, 11, 285, 15, 1, 46, 44, 55, 24, 9, 286, 62, 44, 53, 28, 5, 288, 62, 44, 67, 307, 62, 43, 73, 302, 62, 43, 75, 300, 62, 43, 76, 299, 29, 1, 32, 43, 77, 298, 27, 4, 31, 43, 78, 298, 26, 4, 31, 38, 84, 296, 27, 5, 30, 37, 85, 296, 27, 5, 30, 36, 86, 297, 26, 5, 30, 35, 87, 297, 26, 6, 29, 34, 89, 295, 26, 7, 29, 33, 90, 296, 25, 7, 28, 34, 90, 296, 26, 7, 27, 34, 90, 296, 25, 10, 24, 35, 91, 295, 25, 11, 23, 35, 45, 2, 4, 1, 39, 295, 25, 10, 24, 35, 43, 14, 34, 295, 25, 10, 23, 36, 39, 18, 34, 295, 25, 11, 22, 36, 37, 20, 34, 295, 25, 11, 22, 36, 31, 26, 34, 293, 27, 12, 20, 38, 29, 28, 33, 292, 27, 12, 20, 40, 26, 31, 31, 292, 28, 12, 13, 49, 23, 34, 14, 1, 14, 292, 28, 13, 12, 50, 21, 37, 6, 1, 2, 3, 15, 292, 28, 13, 12, 50, 20, 50, 14, 293, 28, 13, 13, 50, 17, 52, 14, 293, 28, 13, 13, 50, 15, 54, 13, 294, 27, 14, 13, 51, 10, 58, 12, 295, 28, 13, 13, 52, 8, 59, 12, 295, 28, 14, 12, 54, 4, 61, 12, 295, 28, 14, 13, 118, 12, 295, 28, 15, 12, 118, 12, 295, 27, 15, 13, 118, 12, 295, 27, 15, 13, 118, 12, 295, 27, 15, 13, 118, 12, 295, 27, 16, 12, 119, 10, 296, 27, 16, 13, 119, 8, 297, 27, 16, 13, 121, 4, 299, 26, 17, 13, 424, 26, 17, 13, 425, 25, 17, 13, 427, 23, 18, 13, 426, 23, 18, 13, 426, 23, 18, 13, 427, 22, 18, 13, 427, 22, 18, 13, 427, 22, 19, 12, 427, 22, 19, 13, 427, 21, 19, 13, 426, 21, 20, 13, 426, 21, 7, 6, 7, 13, 426, 21, 5, 28, 77, 4, 1, 6, 338, 21, 4, 30, 60, 3, 1, 24, 336, 22, 2, 32, 44, 1, 3, 44, 331, 57, 32, 62, 328, 58, 16, 3, 1, 78, 323, 60, 3, 4, 1, 90, 322, 130, 11, 21, 318, 75, 20, 32, 21, 15, 317, 72, 28, 18, 40, 9, 313, 69, 37, 6, 47, 11, 310, 67, 92, 14, 307, 65, 95, 15, 306, 63, 77, 9, 10, 18, 304, 45, 1, 3, 4, 8, 81, 6, 10, 21, 302, 43, 2, 1, 9, 4, 84, 5, 10, 22, 300, 43, 14, 2, 88, 1, 10, 26, 296, 43, 106, 3, 6, 28, 294, 43, 109, 1, 5, 31, 291, 43, 111, 1, 2, 34, 289, 42, 115, 37, 287, 40, 119, 36, 285, 39, 123, 37, 280, 33, 1, 4, 129, 34, 280, 32, 135, 37, 276, 32, 3, 5, 131, 35, 274, 18, 3, 11, 2, 8, 130, 38, 269, 19, 4, 10, 1, 10, 133, 35, 266, 21, 4, 22, 134, 37, 261, 22, 4, 22, 138, 34, 260, 22, 5, 21, 139, 37, 256, 22, 7, 4, 2, 13, 143, 35, 254, 22, 13, 13, 144, 38, 250, 22, 14, 12, 148, 35, 249, 22, 13, 13, 150, 37, 245, 22, 13, 13, 153, 35, 244, 23, 12, 13, 155, 37, 240, 23, 12, 13, 159, 36, 237, 23, 12, 13, 161, 37, 234, 24, 11, 13, 164, 37, 231, 24, 11, 12, 13, 6, 148, 37, 229, 24, 11, 12, 12, 8, 150, 37, 226, 24, 11, 13, 10, 10, 151, 37, 224, 24, 11, 12, 10, 12, 154, 37, 220, 24, 11, 12, 10, 12, 156, 37, 218, 31, 4, 12, 9, 14, 158, 37, 215, 47, 9, 15, 160, 36, 214, 46, 9, 16, 161, 37, 213, 44, 10, 15, 165, 35, 211, 44, 10, 16, 166, 37, 207, 44, 11, 16, 169, 34, 206, 43, 13, 16, 169, 37, 202, 44, 13, 15, 173, 35, 200, 44, 13, 16, 173, 38, 196, 44, 14, 15, 177, 35, 195, 43, 16, 16, 177, 37, 191, 43, 17, 15, 181, 34, 190, 43, 17, 16, 181, 37, 186, 43, 18, 15, 185, 35, 184, 43, 18, 16, 185, 38, 180, 43, 19, 16, 188, 35, 179, 43, 20, 16, 189, 34, 177, 43, 22, 15, 192, 32, 177, 43, 21, 16, 193, 30, 177, 43, 22, 16, 196, 26, 177, 43, 23, 16, 197, 24, 176, 44, 24, 15, 200, 21, 176, 43, 25, 16, 201, 19, 176, 43, 26, 16, 203, 16, 177, 15, 3, 24, 27, 16, 205, 13, 177, 15, 8, 2, 4, 13, 28, 15, 205, 13, 176, 15, 14, 14, 28, 16, 204, 13, 176, 15, 16, 12, 29, 15, 204, 13, 176, 15, 15, 13, 30, 16, 202, 12, 177, 15, 15, 13, 31, 15, 202, 12, 177, 14, 16, 13, 31, 16, 200, 13, 178, 12, 17, 13, 32, 15, 200, 13, 177, 12, 18, 13, 32, 16, 199, 13, 177, 11, 19, 12, 34, 16, 199, 12, 177, 10, 20, 12, 35, 16, 197, 12, 178, 2, 5, 1, 22, 12, 36, 15, 197, 12, 179, 1, 27, 13, 36, 16, 196, 13, 177, 1, 28, 13, 37, 16, 195, 13, 206, 13, 38, 16, 194, 12, 207, 13, 39, 15, 194, 12, 207, 13, 39, 16, 192, 13, 207, 12, 41, 16, 191, 13, 206, 13, 42, 16, 190, 13, 206, 13, 43, 15, 190, 13, 206, 13, 43, 16, 189, 13, 178, 1, 27, 13, 44, 15, 189, 12, 179, 1, 27, 13, 45, 16, 186, 13, 179, 13, 14, 13, 47, 15, 186, 13, 179, 13, 14, 13, 47, 16, 185, 13, 179, 14, 13, 13, 48, 15, 186, 12, 178, 15, 14, 12, 48, 16, 184, 13, 177, 16, 13, 13, 50, 15, 183, 12, 178, 16, 13, 12, 51, 16, 182, 13, 177, 16, 12, 13, 52, 15, 182, 13, 177, 16, 12, 13, 52, 16, 181, 13, 177, 16, 12, 13, 53, 16, 180, 12, 178, 16, 12, 13, 54, 16, 179, 12, 178, 16, 12, 13, 55, 15, 178, 13, 178, 16, 12, 12, 56, 16, 177, 13, 178, 16, 11, 13, 57, 16, 176, 13, 178, 16, 11, 13, 58, 16, 175, 13, 178, 17, 11, 12, 59, 15, 175, 13, 178, 21, 6, 13, 59, 16, 174, 12, 179, 21, 6, 12, 61, 15, 174, 12, 179, 21, 6, 12, 62, 16, 171, 13, 180, 20, 5, 13, 63, 15, 172, 12, 181, 19, 5, 13, 63, 16, 171, 12, 183, 4, 2, 10, 6, 13, 64, 15, 170, 13, 188, 11, 6, 13, 64, 16, 169, 13, 183, 15, 7, 13, 66, 15, 168, 13, 182, 16, 7, 12, 67, 16, 167, 13, 181, 17, 7, 12, 68, 16, 166, 13, 180, 18, 7, 12, 68, 17, 165, 12, 181, 18, 7, 12, 69, 17, 164, 12, 181, 18, 7, 12, 71, 16, 162, 13, 181, 19, 6, 12, 71, 17, 161, 13, 181, 20, 6, 10, 72, 19, 159, 13, 180, 21, 7, 8, 74, 18, 159, 13, 180, 21, 9, 4, 77, 18, 158, 12, 181, 21, 92, 17, 157, 12, 181, 21, 92, 19, 155, 13, 180, 21, 93, 18, 155, 13, 180, 21, 94, 18, 154, 12, 181, 20, 97, 18, 152, 12, 181, 19, 98, 19, 150, 13, 181, 17, 101, 18, 150, 13, 181, 14, 105, 18, 149, 13, 181, 14, 107, 18, 147, 13, 181, 14, 107, 19, 146, 13, 182, 13, 108, 18, 146, 12, 184, 11, 110, 18, 144, 13, 183, 11, 113, 18, 142, 13, 182, 10, 115, 19, 141, 13, 182, 10, 116, 19, 140, 13, 182, 11, 117, 17, 140, 13, 182, 11, 118, 18, 138, 4, 191, 11, 119, 18, 137, 1, 194, 11, 119, 19, 331, 11, 121, 18, 330, 11, 122, 18, 329, 11, 123, 18, 328, 10, 125, 18, 139, 5, 183, 10, 126, 18, 135, 8, 183, 10, 127, 18, 132, 10, 183, 10, 128, 18, 129, 12, 183, 10, 129, 18, 127, 13, 183, 11, 129, 18, 126, 12, 184, 11, 130, 18, 125, 12, 184, 11, 131, 18, 123, 13, 184, 11, 132, 18, 122, 13, 184, 11, 134, 17, 122, 12, 184, 11, 134, 18, 120, 12, 185, 10, 136, 18, 119, 8, 189, 10, 137, 18, 315, 10, 139, 17, 314, 10, 139, 18, 313, 10, 140, 18, 312, 9, 142, 18, 311, 9, 144, 17, 310, 9, 144, 18, 122, 2, 185, 9, 145, 18, 116, 7, 185, 9, 38, 7, 101, 18, 110, 12, 185, 9, 37, 9, 102, 18, 107, 13, 185, 9, 36, 11, 101, 19, 106, 12, 186, 9, 23, 10, 2, 13, 101, 18, 106, 12, 186, 9, 17, 17, 1, 13, 102, 18, 105, 13, 185, 9, 15, 33, 104, 18, 103, 12, 186, 9, 14, 34, 104, 19, 102, 12, 186, 9, 13, 35, 105, 18, 101, 13, 186, 9, 12, 36, 106, 18, 100, 13, 186, 9, 12, 36, 108, 18, 98, 13, 186, 9, 12, 37, 107, 19, 97, 13, 186, 9, 12, 38, 107, 18, 97, 13, 186, 9, 12, 38, 109, 17, 96, 12, 187, 9, 12, 38, 110, 18, 93, 13, 187, 9, 12, 38, 110, 19, 92, 13, 187, 9, 12, 39, 110, 18, 92, 13, 187, 9, 12, 39, 112, 18, 90, 13, 187, 9, 12, 39, 113, 18, 89, 13, 187, 9, 13, 38, 113, 19, 88, 12, 188, 9, 14, 37, 114, 18, 88, 13, 187, 9, 16, 35, 116, 18, 86, 13, 187, 9, 19, 32, 117, 18, 85, 13, 187, 9, 20, 31, 117, 19, 84, 12, 188, 9, 22, 29, 119, 17, 84, 12, 188, 9, 25, 26, 120, 18, 81, 13, 188, 9, 26, 25, 121, 18, 80, 13, 188, 9, 29, 22, 122, 18, 79, 13, 188, 9, 31, 21, 122, 17, 79, 13, 188, 9, 33, 19, 123, 18, 77, 13, 188, 9, 33, 19, 124, 18, 76, 12, 189, 9, 33, 19, 125, 18, 74, 13, 189, 9, 33, 19, 126, 17, 74, 13, 189, 9, 33, 19, 127, 18, 72, 13, 189, 9, 33, 19, 128, 18, 72, 12, 189, 9, 33, 18, 130, 18, 70, 13, 189, 9, 33, 17, 132, 18, 69, 12, 190, 9, 33, 16, 134, 18, 68, 13, 189, 9, 32, 16, 136, 18, 67, 13, 189, 9, 26, 20, 139, 18, 66, 13, 189, 9, 25, 20, 141, 18, 65, 12, 190, 9, 21, 23, 143, 18, 64, 12, 190, 9, 20, 23, 145, 18, 62, 13, 190, 9, 19, 23, 147, 18, 61, 13, 190, 9, 16, 27, 147, 18, 60, 13, 190, 9, 15, 29, 147, 19, 58, 13, 190, 9, 10, 34, 148, 18, 58, 13, 190, 9, 6, 38, 149, 18, 57, 12, 191, 9, 5, 39, 150, 18, 56, 12, 191, 9, 5, 39, 151, 19, 53, 13, 191, 9, 6, 38, 152, 19, 53, 12, 191, 9, 6, 38, 153, 18, 53, 12, 191, 9, 6, 37, 156, 17, 51, 13, 191, 9, 6, 36, 158, 18, 49, 13, 191, 8, 7, 36, 158, 19, 48, 13, 191, 8, 7, 36, 159, 18, 48, 13, 191, 7, 8, 36, 161, 18, 46, 13, 191, 6, 11, 34, 162, 18, 45, 12, 192, 6, 12, 33, 162, 19, 43, 13, 192, 6, 15, 2, 2, 26, 163, 18, 43, 13, 192, 5, 16, 2, 5, 23, 165, 18, 41, 13, 192, 5, 23, 23, 166, 18, 40, 13, 192, 4, 23, 24, 166, 19, 40, 12, 192, 4, 25, 21, 168, 18, 39, 12, 193, 1, 28, 20, 171, 18, 37, 12, 193, 1, 28, 19, 173, 18, 36, 13, 192, 1, 29, 16, 175, 19, 35, 13, 192, 1, 31, 14, 177, 17, 35, 12, 193, 1, 32, 13, 178, 18, 33, 12, 193, 1, 33, 11, 180, 18, 31, 13, 193, 1, 35, 7, 183, 18, 30, 13, 193, 1, 226, 17, 30, 13, 193, 1, 227, 18, 28, 13, 193, 1, 228, 18, 27, 13, 193, 1, 229, 18, 26, 12, 194, 1, 230, 18, 24, 13, 194, 1, 231, 18, 23, 13, 194, 4, 229, 18, 22, 13, 194, 5, 229, 18, 21, 13, 194, 5, 230, 18, 20, 13, 194, 5, 231, 18, 19, 12, 195, 6, 231, 18, 18, 13, 194, 6, 232, 18, 17, 13, 194, 7, 232, 17, 17, 13, 194, 7, 233, 16, 17, 12, 195, 6, 235, 15, 17, 12, 195, 5, 237, 15, 15, 13, 195, 4, 240, 13, 15, 13, 195, 3, 241, 13, 15, 13, 195, 3, 241, 13, 15, 13, 195, 3, 241, 13, 15, 13, 195, 3, 242, 12, 15, 12, 196, 4, 241, 13, 13, 13, 196, 5, 240, 13, 13, 13, 196, 5, 240, 13, 13, 13, 196, 5, 240, 13, 14, 12, 196, 5, 240, 13, 13, 13, 197, 5, 240, 13, 12, 13, 196, 8, 238, 13, 12, 13, 196, 13, 233, 13, 12, 13, 196, 14, 232, 13, 12, 13, 196, 15, 231, 13, 12, 12, 197, 16, 230, 13, 11, 13, 197, 17, 230, 13, 10, 13, 197, 17, 230, 13, 10, 13, 197, 17, 230, 13, 10, 13, 197, 17, 230, 13, 10, 13, 197, 17, 230, 13, 10, 12, 198, 16, 232, 12, 10, 12, 198, 14, 234, 13, 9, 13, 197, 12, 236, 13, 9, 13, 197, 12, 236, 13, 9, 12, 199, 10, 237, 13, 9, 12, 200, 8, 238, 13, 8, 13, 202, 4, 241, 13, 7, 13, 447, 13, 7, 13, 447, 13, 7, 13, 447, 13, 7, 13, 447, 13, 7, 12, 449, 12, 6, 13, 449, 13, 5, 13, 449, 13, 5, 13, 449, 13, 5, 13, 449, 13, 5, 13, 201, 8, 240, 13, 5, 12, 201, 10, 240, 13, 4, 13, 200, 10, 240, 13, 4, 13, 199, 11, 240, 13, 4, 13, 199, 12, 239, 13, 4, 12, 200, 12, 239, 13, 4, 12, 200, 12, 240, 12, 3, 13, 200, 14, 238, 13, 2, 13, 200, 18, 234, 13, 2, 13, 200, 18, 234, 13, 2, 13, 201, 16, 235, 13, 2, 13, 202, 14, 236, 13, 2, 12, 204, 1, 4, 8, 237, 12, 1, 13, 454, 26, 454, 26, 454, 13, 1, 12, 454, 26, 454, 26, 455, 25, 455, 25, 455, 25, 455, 24, 205, 1, 250, 24, 205, 4, 248, 23, 205, 12, 240, 23, 205, 13, 239, 23, 206, 12, 239, 23, 207, 10, 240, 23, 208, 8, 241, 22, 211, 4, 14, 1, 229, 21, 217, 14, 228, 21, 216, 15, 228, 21, 215, 16, 228, 21, 209, 22, 228, 21, 208, 21, 231, 20, 207, 21, 232, 20, 207, 21, 232, 20, 207, 21, 232, 20, 207, 21, 232, 19, 208, 21, 232, 19, 208, 21, 233, 18, 208, 21, 233, 18, 209, 20, 233, 18, 211, 18, 233, 18, 213, 16, 233, 17, 214, 12, 238, 16, 214, 12, 238, 17, 213, 11, 239, 17, 214, 10, 239, 16, 217, 8, 239, 16, 214, 11, 239, 16, 211, 14, 240, 15, 208, 17, 240, 15, 207, 19, 239, 15, 206, 21, 239, 14, 206, 23, 237, 13, 207, 24, 237, 12, 207, 26, 235, 12, 207, 28, 233, 12, 208, 29, 231, 12, 208, 29, 232, 10, 209, 29, 233, 8, 210, 29, 235, 4, 212, 29, 451, 29, 451, 29, 451, 29, 451, 36, 443, 38, 4, 6, 432, 39, 2, 10, 14, 4, 411, 39, 1, 12, 1, 17, 410, 71, 409, 73, 406, 74, 406, 74, 406, 74, 406, 22, 2, 50, 406, 22, 3, 46, 1, 2, 406, 22, 4, 44, 2, 1, 407, 22, 6, 4, 1, 35, 413, 21, 13, 30, 417, 20, 7, 28, 424, 21, 6, 29, 423, 22, 5, 30, 423, 22, 5, 30, 423, 23, 3, 31, 423, 24, 1, 32, 423, 24, 1, 32, 423, 56, 424, 46, 4, 4, 427, 35, 1, 4, 439, 35, 445, 35, 445, 34, 446, 32, 448, 29, 451, 29, 451, 28, 453, 20, 1, 4, 456, 19, 461, 19, 462, 18, 464, 15, 466, 14, 468, 11, 474, 4, 1931, 6, 473, 8, 471, 10, 468, 12, 462, 18, 446, 6, 9, 19, 445, 8, 7, 21, 443, 10, 6, 22, 442, 10, 6, 22, 442, 10, 5, 23, 442, 10, 5, 23, 442, 10, 5, 23, 442, 10, 5, 23, 442, 10, 5, 23, 443, 8, 6, 23, 445, 4, 8, 23, 458, 22, 460, 20, 462, 19, 462, 19, 463, 18, 462, 18, 462, 18, 462, 18, 462, 18, 463, 16, 466, 14, 467, 13, 467, 13, 467, 11, 469, 11, 467, 13, 466, 14, 465, 15, 465, 15, 455, 6, 4, 15, 454, 26, 453, 27, 453, 26, 454, 26, 454, 26, 454, 26, 454, 27, 453, 27, 453, 27, 454, 26, 456, 24, 458, 22, 460, 20, 464, 15, 465, 15, 465, 16, 465, 16, 465, 16, 440, 6, 18, 16, 440, 8, 16, 17, 2, 1, 436, 9, 15, 20, 436, 10, 14, 8, 2, 10, 436, 11, 14, 7, 2, 10, 436, 11, 14, 19, 436, 11, 14, 18, 437, 11, 14, 16, 439, 11, 14, 16, 439, 11, 14, 16, 439, 11, 13, 16, 440, 11, 13, 16, 440, 10, 14, 8, 1, 6, 441, 10, 14, 8, 2, 4, 442, 10, 14, 8, 448, 10, 15, 6, 45, 4, 400, 11, 15, 4, 43, 8, 399, 11, 61, 9, 399, 11, 60, 10, 399, 11, 59, 11, 399, 11, 57, 13, 399, 11, 54, 16, 399, 11, 53, 17, 399, 11, 53, 17, 399, 11, 53, 18, 398, 11, 53, 18, 398, 12, 45, 4, 3, 18, 73, 5, 320, 12, 44, 6, 2, 18, 72, 7, 319, 12, 43, 8, 1, 22, 58, 4, 4, 10, 318, 12, 37, 4, 2, 8, 1, 23, 56, 6, 2, 11, 318, 12, 23, 6, 7, 6, 1, 8, 2, 22, 49, 26, 318, 12, 21, 11, 3, 16, 5, 19, 48, 27, 318, 12, 20, 13, 2, 16, 8, 16, 36, 4, 1, 34, 318, 12, 16, 18, 1, 16, 8, 16, 28, 46, 319, 11, 4, 8, 3, 37, 9, 14, 28, 46, 320, 11, 2, 11, 1, 38, 10, 11, 25, 40, 2, 6, 323, 11, 1, 51, 10, 11, 24, 40, 4, 4, 324, 54, 1, 8, 10, 11, 23, 38, 335, 54, 1, 8, 11, 10, 22, 38, 336, 53, 3, 6, 13, 8, 22, 32, 343, 52, 5, 4, 14, 8, 21, 23, 1, 8, 344, 50, 25, 8, 21, 19, 357, 50, 25, 7, 22, 10, 366], "size": [480, 640]}, "area": 37028, "iscrowd": 1, "image_id": 10216, "bbox": [0, 0, 639, 305], "category_id": 1, "id": 900100010216}, {"segmentation": {"counts": [3024, 9, 415, 13, 411, 17, 407, 20, 374, 7, 25, 21, 371, 10, 8, 6, 9, 25, 368, 11, 5, 9, 8, 26, 366, 13, 4, 10, 6, 29, 364, 13, 3, 14, 3, 29, 363, 14, 3, 16, 1, 33, 359, 14, 2, 52, 358, 14, 2, 55, 356, 13, 2, 56, 355, 13, 2, 57, 354, 73, 353, 74, 352, 75, 351, 75, 351, 75, 351, 75, 352, 74, 352, 74, 351, 75, 351, 74, 352, 73, 353, 71, 355, 72, 354, 73, 353, 73, 352, 75, 351, 76, 350, 76, 351, 75, 351, 75, 350, 12, 1, 63, 350, 13, 1, 62, 350, 13, 2, 61, 351, 13, 2, 60, 351, 13, 1, 60, 352, 12, 2, 59, 353, 12, 2, 57, 355, 12, 3, 39, 4, 11, 357, 12, 1, 42, 372, 55, 371, 55, 370, 24, 1, 31, 370, 25, 2, 29, 370, 25, 5, 26, 370, 24, 9, 23, 371, 23, 12, 20, 371, 23, 14, 17, 371, 23, 17, 14, 372, 22, 25, 5, 374, 19, 407, 19, 408, 17, 409, 17, 408, 19, 407, 19, 407, 19, 407, 19, 407, 19, 408, 18, 407, 19, 408, 18, 407, 19, 407, 19, 407, 19, 407, 19, 407, 19, 407, 19, 422, 4, 423, 3, 424, 2, 425, 1, 58405, 3, 422, 5, 421, 6, 419, 8, 417, 9, 417, 9, 416, 10, 415, 11, 415, 11, 388, 12, 14, 12, 386, 40, 386, 40, 385, 41, 383, 43, 383, 42, 383, 42, 384, 42, 382, 43, 381, 45, 381, 44, 381, 45, 381, 44, 381, 45, 381, 45, 381, 45, 382, 44, 382, 49, 378, 49, 378, 49, 375, 52, 372, 54, 371, 55, 371, 55, 370, 56, 370, 56, 370, 56, 370, 56, 370, 55, 372, 53, 374, 52, 375, 51, 376, 6, 1, 5, 2, 4, 1, 13, 3, 14, 397, 11, 5, 12, 400, 8, 8, 8, 404, 4, 31518, 6, 418, 9, 417, 16, 409, 20, 406, 26, 399, 42, 384, 43, 383, 44, 383, 44, 382, 44, 383, 43, 384, 42, 371, 6, 9, 40, 369, 10, 8, 39, 369, 11, 7, 39, 368, 13, 6, 38, 369, 14, 5, 37, 369, 16, 3, 36, 371, 49, 377, 55, 371, 56, 370, 57, 369, 58, 368, 59, 367, 59, 368, 58, 368, 58, 369, 57, 369, 57, 370, 56, 370, 55, 372, 53, 374, 52, 375, 50, 378, 48, 379, 47, 381, 44, 385, 40, 387, 37, 390, 34, 394, 32, 394, 30, 397, 27, 400, 25, 401, 24, 403, 22, 405, 20, 408, 10, 2, 4, 46431, 6, 10, 6, 402, 13, 3, 9, 401, 26, 399, 28, 398, 28, 397, 29, 396, 30, 394, 32, 394, 32, 393, 33, 393, 32, 393, 32, 394, 32, 393, 33, 393, 33, 380, 7, 6, 33, 378, 48, 378, 48, 377, 49, 377, 49, 376, 50, 376, 50, 376, 50, 377, 49, 377, 49, 378, 47, 380, 46, 381, 45, 381, 45, 381, 45, 381, 45, 381, 45, 382, 44, 382, 44, 383, 42, 383, 42, 384, 41, 385, 39, 388, 35, 391, 33, 390, 36, 388, 40, 386, 41, 384, 43, 1, 7, 375, 52, 373, 54, 372, 55, 371, 55, 371, 55, 370, 56, 370, 56, 370, 56, 370, 56, 371, 55, 371, 55, 372, 53, 374, 51, 377, 4, 6, 37, 387, 38, 386, 38, 388, 37, 388, 38, 388, 37, 388, 37, 389, 36, 390, 35, 392, 22, 1, 9, 394, 21, 4, 4, 398, 19, 408, 13, 415, 4, 1, 4, 33173], "size": [426, 640]}, "area": 10376, "iscrowd": 1, "image_id": 10442, "bbox": [7, 0, 555, 87], "category_id": 1, "id": 900100010442}, {"segmentation": [[107.35, 420.13, 91.87, 393.29, 97.03, 322.06, 107.35, 279.74, 140.39, 225.03, 167.23, 207.48, 210.58, 194.06, 238.45, 187.87, 270.45, 198.19, 293.16, 225.03, 298.32, 268.39, 293.16, 333.42, 264.26, 408.77, 239.48, 455.23, 203.35, 466.58, 131.1, 465.55, 109.42, 422.19, 101.16, 407.74]], "area": 44717.0985, "iscrowd": 0, "image_id": 10046, "bbox": [91.87, 187.87, 206.45, 278.71], "category_id": 58, "id": 765}, {"segmentation": [[533.2, 274.79, 525.52, 250.05, 501.63, 232.98, 494.81, 204.83, 501.63, 169.85, 526.37, 147.67, 555.38, 142.55, 591.21, 163.88, 621.07, 189.47, 630.45, 192.03, 631.31, 204.83, 625.34, 215.92, 615.95, 226.16, 623.63, 234.69, 629.6, 244.07, 619.36, 247.49, 612.54, 247.49, 618.51, 252.61, 615.95, 263.7, 598.89, 264.55, 588.65, 272.23, 580.12, 264.55, 574.15, 267.11, 571.59, 270.52, 582.68, 287.58, 601.45, 295.26, 614.25, 306.35, 623.63, 309.76, 625.34, 322.56, 610.83, 321.71, 601.45, 321.71, 592.92, 313.18, 585.24, 304.65, 563.06, 295.26, 542.58, 285.02, 534.91, 280.76, 532.35, 272.23]], "area": 14629.467750000005, "iscrowd": 0, "image_id": 10369, "bbox": [494.81, 142.55, 136.5, 180.01], "category_id": 18, "id": 4791}, {"segmentation": [[185.46, 0.92, 244.12, 0.92, 239.81, 19.04, 249.3, 24.21, 270.86, 23.35, 281.22, 19.04, 288.98, 25.07, 312.27, 2.65, 384.73, 1.78, 383.87, 22.49, 416.65, 48.36, 411.47, 50.95, 376.11, 44.05, 381.28, 56.13, 373.52, 75.97, 364.89, 87.18, 384.73, 119.96, 389.04, 138.08, 389.04, 217.44, 408.88, 255.39, 405.43, 270.92, 389.91, 288.17, 365.75, 309.74, 335.56, 314.05, 334.7, 334.76, 319.17, 358.91, 282.08, 378.75, 271.73, 383.93, 258.79, 399.45, 270.86, 422.74, 208.76, 422.74, 202.72, 420.16, 207.89, 408.94, 206.17, 386.51, 144.92, 372.71, 143.2, 383.06, 156.14, 389.1, 164.76, 395.14, 163.9, 412.39, 161.31, 419.29, 155.27, 421.88, 105.24, 421.88, 95.75, 406.35, 100.06, 386.51, 79.36, 299.39, 76.77, 267.47, 78.5, 256.26, 84.54, 251.08, 73.32, 242.46, 56.93, 265.75, 47.44, 270.92, 31.05, 270.06, 27.6, 255.39, 25.02, 235.55, 35.37, 207.95, 46.58, 201.05, 55.21, 165.68, 51.76, 151.88, 64.7, 144.12, 70.74, 124.28, 79.36, 118.24, 76.77, 99.26, 81.09, 92.36, 111.28, 81.14, 125.08, 56.13, 124.22, 49.23, 156.14, 19.9, 166.49, 17.31, 181.15, 17.31, 186.33, 2.65]], "area": 114934.57880000002, "iscrowd": 0, "image_id": 10248, "bbox": [25.02, 0.92, 391.63, 421.82], "category_id": 18, "id": 9359}, {"segmentation": [[384.58, 192.9, 379.72, 205.07, 365.11, 198.58, 361.87, 212.37, 359.43, 222.92, 355.38, 236.71, 352.13, 211.56, 337.53, 213.18, 331.85, 227.79, 329.41, 239.96, 323.73, 236.71, 327.79, 213.18, 319.68, 239.15, 317.24, 229.41, 318.86, 216.43, 317.24, 204.26, 314.81, 196.15, 324.54, 190.47, 329.41, 196.15, 339.96, 186.41, 347.26, 186.41, 355.38, 187.22, 368.36, 191.28, 376.47, 198.58, 381.34, 188.84]], "area": 1690.5639500000004, "iscrowd": 0, "image_id": 10005, "bbox": [314.81, 186.41, 69.77, 53.55], "category_id": 18, "id": 13017}, {"segmentation": [[537.02, 309.82, 533.58, 302.07, 530.13, 295.19, 528.41, 291.75, 526.69, 285.72, 533.58, 279.7, 537.88, 277.12, 550.79, 277.12, 557.67, 277.98, 568.86, 279.7, 580.05, 273.67, 586.93, 271.09, 597.26, 267.65, 609.31, 280.56, 611.03, 286.58, 614.47, 294.33, 614.47, 295.19, 617.92, 307.24, 617.05, 323.59, 613.61, 329.61, 616.19, 344.24, 612.75, 347.68, 605.01, 336.5, 604.15, 332.19, 604.15, 327.89, 600.7, 322.73, 598.98, 329.61, 583.49, 345.96, 577.47, 348.55, 578.33, 355.43, 577.47, 364.9, 562.84, 364.9, 562.84, 359.73, 555.95, 356.29, 553.37, 350.27, 553.37, 343.38, 557.67, 335.64, 558.53, 328.75, 549.93, 327.89, 545.62, 327.03, 532.72, 318.42, 531.85, 305.52]], "area": 5467.03105, "iscrowd": 0, "image_id": 10276, "bbox": [526.69, 267.65, 91.23, 97.25], "category_id": 18, "id": 15870}, {"segmentation": [[288.54, 208.77, 297.45, 206.65, 300.0, 204.95, 300.85, 212.17, 301.27, 219.38, 304.24, 223.62, 304.24, 228.71, 304.24, 229.98, 306.79, 228.71, 310.6, 232.53, 311.88, 227.44, 310.6, 223.2, 310.18, 218.95, 312.73, 213.86, 313.57, 212.17, 314.42, 216.83, 317.39, 217.26, 319.09, 214.29, 319.09, 207.07, 317.39, 203.26, 316.97, 195.62, 311.45, 190.53, 299.15, 186.71, 283.88, 186.71, 276.66, 183.74, 271.15, 186.29, 268.18, 186.71, 269.88, 196.47, 272.42, 207.07, 271.57, 213.86, 269.45, 217.26, 277.51, 217.68, 278.79, 210.47, 283.45, 209.2, 281.33, 213.86, 277.51, 219.38, 282.18, 219.8, 286.42, 213.01, 288.54, 209.62]], "area": 1344.3865499999997, "iscrowd": 0, "image_id": 10005, "bbox": [268.18, 183.74, 50.91, 48.79], "category_id": 18, "id": 17044}, {"segmentation": [[365.95, 188.29, 374.81, 188.78, 380.71, 187.3, 390.06, 181.89, 396.45, 180.42, 391.04, 197.64, 389.07, 204.03, 389.07, 216.82, 384.65, 224.7, 374.81, 237.49, 372.35, 251.76, 365.95, 265.53, 362.01, 286.2, 363.0, 307.84, 363.49, 313.75, 360.54, 314.73, 358.08, 315.22, 354.14, 309.32, 352.67, 302.92, 353.16, 284.23, 353.16, 271.93, 352.67, 269.96, 349.22, 265.04, 342.83, 274.88, 347.75, 304.89, 347.75, 314.24, 344.3, 316.7, 342.83, 311.29, 340.86, 282.75, 339.38, 275.86, 334.46, 273.9, 331.02, 273.9, 327.57, 284.23, 327.08, 291.12, 324.62, 293.08, 329.05, 298.5, 337.91, 302.92, 333.48, 310.8, 331.51, 310.3, 329.05, 307.35, 322.16, 301.45, 317.24, 297.02, 313.8, 288.16, 314.29, 280.78, 312.81, 275.86, 311.34, 273.4, 309.86, 275.86, 308.88, 287.18, 308.39, 296.04, 306.91, 301.94, 305.93, 311.29, 304.94, 313.75, 303.47, 312.27, 302.48, 299.48, 302.48, 282.75, 302.48, 270.94, 297.07, 268.98, 294.12, 266.02, 291.66, 262.58, 286.74, 252.74, 283.79, 241.42, 284.77, 233.06, 291.17, 230.6, 299.53, 227.16, 315.27, 221.25, 328.07, 214.86, 341.35, 215.84, 347.25, 209.94, 350.7, 204.03, 355.62, 201.08, 356.11, 198.62, 354.14, 195.67, 354.14, 190.26, 354.14, 187.3, 356.6, 182.88, 359.55, 181.89, 363.49, 181.89, 368.41, 184.84]], "area": 7066.845449999999, "iscrowd": 0, "image_id": 10276, "bbox": [283.79, 180.42, 112.66, 136.28], "category_id": 18, "id": 17744}, {"segmentation": [[280.97, 266.21, 287.24, 263.26, 285.39, 245.2, 282.45, 244.09, 280.6, 226.77, 287.24, 220.87, 293.13, 223.82, 300.87, 219.4, 303.45, 210.92, 306.77, 203.18, 309.35, 199.86, 304.56, 194.7, 300.51, 193.23, 299.4, 185.12, 277.65, 173.33, 274.34, 175.17, 273.6, 181.07, 263.28, 182.91, 262.91, 187.33, 264.02, 190.65, 261.44, 195.07, 257.38, 198.02, 249.27, 204.29]], "area": 2554.6601999999975, "iscrowd": 0, "image_id": 10145, "bbox": [249.27, 173.33, 60.08, 92.88], "category_id": 64, "id": 21815}, {"segmentation": [[122.86, 128.4, 194.37, 135.45, 193.36, 219.04, 119.84, 241.19, 120.85, 154.59, 121.86, 128.4]], "area": 7191.936650000001, "iscrowd": 0, "image_id": 10145, "bbox": [119.84, 128.4, 74.53, 112.79], "category_id": 72, "id": 32610}, {"segmentation": [[220.24, 242.96, 223.23, 205.26, 225.02, 192.7, 222.63, 102.94, 222.03, 98.16, 220.24, 95.76, 79.02, 96.36, 73.04, 102.94, 79.02, 221.42, 79.02, 277.67, 92.19, 277.67, 98.77, 282.45, 121.51, 278.86, 181.94, 265.1, 205.28, 256.13, 210.66, 252.54, 211.86, 248.35, 220.24, 243.56]], "area": 25377.6892, "iscrowd": 0, "image_id": 10346, "bbox": [73.04, 95.76, 151.98, 186.69], "category_id": 72, "id": 33123}, {"segmentation": [[118.1, 64.31, 368.72, 5.71, 378.75, 9.56, 371.03, 169.46, 156.66, 252.74, 147.41, 245.03]], "area": 43929.302899999995, "iscrowd": 0, "image_id": 10083, "bbox": [118.1, 5.71, 260.65, 247.03], "category_id": 72, "id": 33563}, {"segmentation": [[2.42, 266.37, 22.52, 255.91, 32.98, 243.05, 47.46, 252.7, 53.89, 263.96, 44.24, 272.0, 35.39, 269.59, 32.17, 272.8, 31.37, 284.07, 31.37, 287.28, 35.39, 291.3, 35.39, 293.72, 21.72, 293.72, 10.46, 295.33, 12.07, 299.35, 1.61, 298.54]], "area": 1557.7888000000003, "iscrowd": 0, "image_id": 10346, "bbox": [1.61, 243.05, 52.28, 56.3], "category_id": 17, "id": 50970}, {"segmentation": [[111.05, 612.0, 111.05, 605.86, 111.05, 598.19, 112.58, 594.36, 112.58, 589.75, 110.28, 582.08, 107.98, 575.18, 110.28, 565.97, 111.05, 561.36, 109.52, 549.86, 107.21, 535.28, 106.45, 529.14, 101.84, 530.68, 100.31, 532.21, 96.47, 534.51, 93.4, 532.98, 90.33, 522.24, 91.87, 506.89, 92.64, 485.41, 92.64, 478.5, 98.01, 459.32, 95.71, 443.98, 91.1, 410.99, 95.71, 387.2, 104.14, 368.79, 121.79, 357.28, 127.16, 354.21, 141.74, 351.14, 154.02, 348.84, 163.22, 349.61, 169.36, 353.44, 172.43, 364.19, 172.43, 368.79, 172.43, 381.83, 173.2, 390.27, 167.06, 403.31, 162.45, 414.06, 157.08, 435.54, 157.08, 438.61, 156.32, 452.42, 157.85, 464.69, 157.85, 470.83, 160.15, 477.74, 160.92, 480.81, 161.69, 487.71, 161.69, 487.71, 164.76, 490.78, 160.92, 490.01, 157.08, 494.62, 154.02, 501.52, 151.71, 509.96, 150.95, 509.19, 147.11, 523.0, 144.81, 532.98, 144.81, 536.81, 143.27, 549.86, 143.27, 552.16, 141.74, 562.13, 146.34, 585.92, 154.02, 605.86, 154.02, 609.7, 142.51, 612.77, 135.6, 609.7, 131.77, 619.67, 120.26, 618.91, 112.58, 615.07], [180.1, 486.18, 173.2, 490.01, 168.59, 490.78, 171.66, 496.15, 174.73, 496.92, 181.64, 498.45, 193.14, 499.22, 195.45, 499.22, 200.05, 501.52, 206.19, 504.59, 206.95, 505.36, 215.39, 510.73, 216.93, 526.07, 218.46, 541.42, 213.86, 564.43, 213.09, 578.24, 214.63, 584.38, 215.39, 588.22, 213.86, 602.8, 209.26, 611.24, 204.65, 622.74, 206.19, 630.42, 206.19, 632.72, 209.26, 638.7, 215.39, 639.47, 221.53, 639.47, 224.6, 639.47, 224.6, 633.33, 224.6, 629.5, 224.6, 621.06, 227.67, 595.74, 233.81, 585.0, 237.64, 568.12, 233.81, 558.14, 238.41, 538.2, 243.01, 520.55, 243.78, 517.48, 252.99, 513.64, 260.66, 510.57, 261.43, 527.45, 258.36, 540.5, 257.59, 549.7, 256.82, 562.75, 255.29, 569.65, 253.76, 594.2, 252.99, 598.81, 249.15, 608.01, 249.15, 612.62, 252.22, 621.06, 252.99, 627.19, 252.22, 636.4, 249.92, 640.0, 268.33, 640.0, 271.4, 639.47, 273.7, 637.94, 273.7, 633.33, 270.63, 621.06, 269.1, 611.85, 269.1, 608.01, 269.87, 596.5, 276.01, 578.09, 278.31, 561.98, 278.31, 550.47, 278.31, 546.63, 285.98, 526.69, 289.05, 519.78, 294.42, 507.51, 296.72, 502.9, 298.26, 498.3, 305.93, 481.42, 308.23, 475.28, 313.6, 464.54, 316.67, 456.1, 316.67, 451.5, 329.71, 442.29, 341.22, 436.92, 351.96, 433.08, 356.57, 431.55, 365.77, 436.92, 369.61, 449.2, 378.82, 457.64, 384.19, 459.94, 388.02, 461.47, 394.16, 466.84, 395.69, 469.14, 399.53, 481.42, 404.13, 487.56, 408.74, 496.0, 411.04, 501.37, 432.52, 503.67, 437.13, 500.6, 443.26, 496.0, 445.56, 490.63, 448.63, 483.72, 450.17, 475.28, 449.4, 472.21, 445.56, 459.94, 443.26, 446.13, 440.19, 437.69, 437.89, 430.78, 434.82, 420.81, 433.29, 416.97, 438.66, 406.23, 433.29, 395.49, 430.22, 392.42, 427.15, 384.75, 430.99, 377.08, 421.78, 364.8, 415.64, 361.73, 412.57, 355.59, 412.57, 348.69, 410.27, 342.55, 407.2, 341.78, 403.37, 347.92, 398.76, 357.13, 398.0, 357.13, 391.09, 357.13, 383.42, 357.13, 377.28, 354.06, 368.07, 348.69, 362.7, 348.69, 311.3, 347.15, 270.63, 349.46, 244.55, 347.92, 227.67, 345.62, 230.74, 351.76, 228.44, 364.8, 227.67, 371.7, 223.07, 380.91, 220.0, 387.82, 206.19, 390.89, 200.05, 397.02, 194.68, 406.23, 193.91, 412.37, 187.77, 425.41, 187.01, 430.01, 187.01, 434.62, 181.64, 447.66, 178.57, 459.17, 178.57, 461.47, 179.33, 466.84, 181.64, 479.12, 184.7, 486.02, 179.33, 489.09]], "area": 52294.53945, "iscrowd": 0, "image_id": 10321, "bbox": [90.33, 341.78, 359.84, 298.22], "category_id": 19, "id": 60142}, {"segmentation": [[608.51, 12.7, 613.44, 12.7, 613.76, 17.16, 616.15, 20.98, 616.31, 26.07, 618.86, 36.58, 619.09, 46.04, 619.07, 54.85, 615.4, 60.36, 615.4, 63.51, 602.81, 64.82, 604.64, 60.1, 605.43, 46.72, 604.38, 34.66, 605.69, 20.75, 608.58, 16.82]], "area": 610.8264500000004, "iscrowd": 0, "image_id": 10175, "bbox": [602.81, 12.7, 16.28, 52.12], "category_id": 44, "id": 81031}, {"segmentation": [[306.45, 271.49, 345.77, 269.61, 370.72, 283.97, 376.96, 272.73, 411.91, 271.49, 463.08, 283.34, 451.22, 320.16, 453.72, 351.36, 454.34, 384.43, 448.72, 431.75, 433.12, 442.98, 436.24, 461.7, 434.37, 473.56, 365.73, 442.98, 404.42, 416.18, 411.28, 398.71, 410.04, 386.89, 401.92, 385.64, 397.56, 377.53, 396.31, 358.81, 377.59, 363.84, 348.88, 363.84, 333.91, 363.84, 325.8, 365.09, 323.3, 351.36, 318.93, 343.87, 305.83, 346.37, 297.09, 366.33, 298.97, 322.03, 314.57, 296.45, 308.33, 275.85, 305.21, 270.86], [513.62, 347.61, 526.72, 390.67, 539.83, 449.33, 518.61, 480.0, 470.56, 478.65, 482.42, 436.85, 482.42, 405.65, 508.63, 347.61], [564.16, 293.95, 640.0, 305.81, 640.0, 420.0, 596.61, 420.0, 568.53, 421.25]], "area": 32755.140199999994, "iscrowd": 0, "image_id": 10176, "bbox": [297.09, 269.61, 342.91, 210.39], "category_id": 63, "id": 98179}, {"segmentation": [[1.02, 336.31, 39.32, 342.3, 51.28, 330.32, 40.51, 315.97, 41.7, 299.22, 59.66, 296.82, 70.43, 298.02, 69.23, 325.55, 77.61, 331.52, 135.06, 605.59, 239.18, 509.85, 275.09, 513.45, 287.06, 525.41, 266.71, 542.17, 271.5, 631.92, 1.02, 627.14, 1.02, 338.7]], "area": 43908.68619999999, "iscrowd": 0, "image_id": 10342, "bbox": [1.02, 296.82, 286.04, 335.1], "category_id": 62, "id": 104895}, {"segmentation": [[476.39, 480.71, 443.38, 460.57, 432.67, 464.0, 427.52, 470.0, 425.81, 477.71, 426.67, 486.29, 428.38, 498.29, 427.52, 516.29, 425.38, 524.0, 427.1, 541.15, 432.67, 562.58, 442.1, 553.15, 445.1, 553.58, 446.81, 554.86, 440.38, 593.87, 432.24, 596.01, 429.24, 598.15, 427.52, 604.58, 427.1, 610.15, 420.67, 621.73, 427.52, 624.73, 426.24, 638.44, 476.39, 639.73, 477.24, 517.15, 477.24, 479.86]], "area": 7880.197950000003, "iscrowd": 0, "image_id": 10342, "bbox": [420.67, 460.57, 56.57, 179.16], "category_id": 62, "id": 106535}, {"segmentation": [[468.15, 309.14, 469.97, 287.19, 467.23, 280.79, 471.8, 267.99, 532.15, 269.82, 549.52, 227.76, 564.15, 227.76, 592.5, 249.71, 640.0, 267.99, 639.13, 315.54, 592.5, 313.71, 582.44, 302.74, 568.72, 304.57, 514.78, 335.65, 491.92, 321.94, 470.89, 312.79, 469.97, 308.22]], "area": 10532.29455, "iscrowd": 0, "image_id": 10145, "bbox": [467.23, 227.76, 172.77, 107.89], "category_id": 63, "id": 117617}, {"segmentation": [[558.45, 392.26, 448.0, 364.39, 478.97, 326.19, 374.71, 299.35, 361.29, 299.35, 344.77, 308.65, 347.87, 261.16, 352.0, 243.61, 362.32, 222.97, 401.55, 219.87, 406.71, 176.52, 545.03, 182.71, 638.97, 194.06, 637.94, 261.16, 635.87, 333.42, 604.9, 321.03]], "area": 43707.9344, "iscrowd": 0, "image_id": 10346, "bbox": [344.77, 176.52, 294.2, 215.74], "category_id": 63, "id": 117898}, {"segmentation": [[58.86, 70.35, 35.28, 83.95, 30.75, 99.38, 86.07, 130.21, 143.21, 109.35, 145.02, 139.28, 236.62, 135.65, 233.9, 112.98, 264.74, 122.05, 279.25, 143.81, 349.99, 117.51, 346.36, 96.65, 330.04, 83.05, 396.25, 80.33, 408.04, 60.38, 412.58, 22.29, 421.65, 64.91, 400.78, 103.9, 405.31, 224.53, 392.62, 230.89, 389.9, 230.89, 381.74, 220.0, 384.45, 114.79, 270.18, 155.6, 267.46, 183.72, 262.93, 199.14, 379.92, 219.09, 381.74, 229.07, 328.23, 228.16, 272.0, 228.16, 249.32, 243.58, 239.35, 299.81, 236.62, 174.65, 236.62, 310.7, 217.58, 305.25, 211.23, 171.03, 193.09, 160.14, 110.56, 148.35, 112.37, 186.44, 90.61, 174.65, 87.88, 142.91, 25.3, 103.01, 21.68, 82.15, 46.16, 75.79]], "area": 20731.587799999983, "iscrowd": 0, "image_id": 10369, "bbox": [21.68, 22.29, 399.97, 288.41], "category_id": 67, "id": 118496}, {"segmentation": [[567.99, 189.85, 584.77, 187.01, 593.28, 192.95, 594.83, 198.11, 592.25, 201.72, 581.41, 205.34, 563.34, 204.56, 564.89, 196.56, 567.47, 189.85]], "area": 435.77680000000004, "iscrowd": 0, "image_id": 10318, "bbox": [563.34, 187.01, 31.49, 18.33], "category_id": 3, "id": 143548}, {"segmentation": [[601.16, 194.21, 603.57, 186.98, 619.95, 185.05, 624.76, 187.46, 627.65, 188.91, 627.65, 190.83, 629.58, 194.21, 629.1, 199.99, 625.24, 199.99, 623.32, 199.5, 621.87, 201.91, 618.5, 202.88, 617.06, 202.88, 612.72, 199.5, 604.53, 200.47, 604.05, 202.88, 603.09, 202.88, 600.68, 200.47, 600.68, 194.21]], "area": 393.1824500000003, "iscrowd": 0, "image_id": 10318, "bbox": [600.68, 185.05, 28.9, 17.83], "category_id": 3, "id": 143652}, {"segmentation": [[537.3, 205.05, 537.1, 201.63, 536.9, 199.42, 537.1, 196.2, 540.32, 194.39, 542.13, 192.38, 543.14, 190.97, 546.76, 188.76, 552.39, 188.76, 559.43, 189.57, 566.47, 194.19, 564.86, 197.21, 564.26, 202.84, 561.24, 205.25, 551.99, 208.87, 543.74, 206.86]], "area": 444.0049500000004, "iscrowd": 0, "image_id": 10318, "bbox": [536.9, 188.76, 29.57, 20.11], "category_id": 3, "id": 146668}, {"segmentation": [[395.94, 210.41, 395.94, 200.25, 401.02, 196.19, 413.2, 193.15, 423.35, 195.18, 428.43, 200.25, 427.41, 211.42, 416.24, 211.42, 402.03, 213.45, 396.95, 211.42, 396.95, 208.38], [473.1, 189.09, 481.22, 189.09, 488.32, 190.1, 492.39, 193.15, 491.37, 205.33, 482.23, 206.35, 471.07, 193.15, 472.08, 190.1, 476.14, 191.12], [460.91, 209.39, 459.9, 201.27, 463.96, 192.13, 474.11, 211.42, 461.93, 209.39]], "area": 927.6084999999998, "iscrowd": 0, "image_id": 10318, "bbox": [395.94, 189.09, 96.45, 24.36], "category_id": 3, "id": 147502}, {"segmentation": [[640.0, 200.25, 635.59, 200.39, 635.24, 201.58, 634.33, 201.72, 633.07, 201.37, 632.65, 200.25, 632.3, 195.06, 632.86, 191.77, 635.66, 186.16, 639.72, 184.13, 639.65, 200.18]], "area": 98.9961000000003, "iscrowd": 0, "image_id": 10318, "bbox": [632.3, 184.13, 7.7, 17.59], "category_id": 3, "id": 147599}, {"segmentation": [[378.51, 87.91, 387.73, 87.91, 370.61, 156.42, 386.42, 160.37, 393.0, 153.78, 395.64, 153.78, 394.32, 164.32, 252.03, 163.0, 330.29, 149.48], [155.6, 172.38, 220.79, 174.99, 386.81, 178.46, 381.6, 186.29, 373.77, 189.76, 332.92, 192.37, 287.72, 205.41, 244.26, 208.89, 239.91, 212.36, 247.74, 216.71, 247.74, 222.79, 242.52, 226.27, 233.83, 226.27, 231.22, 221.06, 232.96, 216.71, 237.31, 212.36, 237.31, 209.76, 228.61, 211.5, 222.53, 218.45, 175.59, 223.66, 175.59, 217.58, 174.72, 210.63, 158.21, 213.23, 156.47, 212.36], [64.72, 205.68, 72.62, 209.63, 72.62, 218.85, 79.21, 220.17, 79.21, 212.27, 85.8, 214.9, 89.75, 218.85, 96.34, 218.85, 95.02, 212.27, 124.01, 209.63, 124.01, 199.09, 102.93, 200.41, 101.61, 208.31, 79.21, 210.95, 77.89, 197.77]], "area": 10345.872749999999, "iscrowd": 0, "image_id": 10342, "bbox": [64.72, 87.91, 330.92, 138.36], "category_id": 5, "id": 158410}, {"segmentation": [[416.52, 308.04, 416.78, 308.04, 456.79, 308.04, 456.79, 238.6, 401.04, 222.86, 399.49, 216.4, 394.07, 217.18, 381.16, 218.21, 357.15, 217.44, 355.35, 218.47, 357.67, 223.37, 356.12, 277.32, 367.99, 283.78, 370.06, 288.94, 373.16, 290.75, 377.8, 288.42, 398.45, 297.97, 400.26, 304.68, 404.65, 304.68, 405.68, 303.91]], "area": 7450.6056, "iscrowd": 0, "image_id": 10318, "bbox": [355.35, 216.4, 101.44, 91.64], "category_id": 6, "id": 167481}, {"segmentation": [[76.76, 173.39, 207.26, 181.06, 437.56, 206.97, 527.75, 217.52, 552.7, 222.32, 564.22, 223.28, 569.01, 234.8, 573.81, 252.07, 569.01, 267.42, 502.8, 259.74, 379.02, 229.04, 117.07, 200.25, 69.09, 198.33, 71.97, 173.39]], "area": 16100.235900000003, "iscrowd": 0, "image_id": 10343, "bbox": [69.09, 173.39, 504.72, 94.03], "category_id": 7, "id": 173062}, {"segmentation": [[251.86, 240.09, 251.86, 208.56, 252.76, 195.95, 288.34, 193.25, 295.1, 190.1, 304.56, 190.1, 306.36, 234.68, 285.64, 236.94], [312.67, 193.7, 328.43, 196.85, 325.73, 233.33, 314.02, 234.68], [338.34, 200.46, 344.19, 200.0, 345.09, 232.43, 336.99, 232.43], [371.22, 205.41, 379.77, 203.16, 387.43, 202.71, 392.83, 206.31, 396.44, 245.94, 395.09, 249.55, 369.41, 251.35, 368.96, 204.96]], "area": 4301.0380000000005, "iscrowd": 0, "image_id": 10430, "bbox": [251.86, 190.1, 144.58, 61.25], "category_id": 7, "id": 174583}, {"segmentation": [[600.76, 338.86, 595.02, 350.34, 591.2, 350.34, 585.46, 370.61, 575.51, 375.97, 573.98, 377.5, 455.38, 390.51, 414.06, 325.85, 412.53, 317.43, 406.03, 307.49, 398.0, 290.65, 401.82, 285.3, 419.04, 279.94, 464.56, 283.77, 501.67, 294.86, 541.08, 310.55, 602.67, 338.86]], "area": 14129.428699999999, "iscrowd": 0, "image_id": 10388, "bbox": [398.0, 279.94, 204.67, 110.57], "category_id": 9, "id": 176584}, {"segmentation": [[275.87, 405.16, 271.8, 385.81, 313.54, 371.56, 356.29, 369.53, 364.44, 398.03, 303.36, 414.32]], "area": 2907.6278999999995, "iscrowd": 0, "image_id": 10405, "bbox": [271.8, 369.53, 92.64, 44.79], "category_id": 9, "id": 176652}, {"segmentation": [[107.73, 404.29, 115.34, 386.22, 118.19, 368.15, 132.46, 356.74, 146.72, 352.93, 158.14, 354.83, 161.94, 357.69, 163.84, 358.64, 171.45, 364.34, 173.35, 365.29, 175.25, 367.2, 176.2, 369.1, 177.16, 371.0, 178.11, 372.9, 179.06, 374.8, 180.01, 377.66, 180.01, 379.56, 180.01, 382.41, 180.01, 385.27, 180.01, 390.97, 180.01, 393.82, 179.06, 397.63, 179.06, 399.53, 178.11, 406.19, 179.06, 409.04, 180.96, 409.99, 182.86, 411.89, 183.81, 414.75, 183.81, 416.65, 183.81, 418.55, 183.81, 423.31, 180.96, 425.21, 179.06, 428.06, 178.11, 429.01, 177.16, 431.86, 187.62, 433.77, 198.08, 446.13, 211.39, 469.9, 209.49, 471.81, 220.9, 488.92, 265.6, 488.92, 278.91, 492.73, 291.2, 495.22, 300.31, 498.12, 302.79, 499.36, 298.24, 502.67, 301.55, 511.78, 290.37, 522.96, 284.16, 515.5, 268.85, 505.16, 215.86, 510.95, 208.82, 508.47, 220.0, 526.68, 207.58, 539.51, 165.77, 575.11, 162.05, 579.25, 145.9, 579.67, 127.28, 568.08, 113.62, 505.57, 117.76, 487.77, 108.65, 480.73, 101.61, 446.38, 99.13, 434.78, 103.68, 428.99, 111.96, 424.85, 115.69, 424.85, 111.55, 419.47, 114.03, 413.67, 108.65, 412.43, 109.06, 404.57], [63.11, 428.16, 70.57, 462.11, 55.66, 436.44, 58.98, 430.65]], "area": 19614.002749999992, "iscrowd": 0, "image_id": 10342, "bbox": [55.66, 352.93, 247.13, 226.74], "category_id": 1, "id": 186490}, {"segmentation": [[100.23, 216.54, 106.03, 192.05, 113.12, 179.17, 124.08, 169.5, 120.86, 160.48, 115.7, 147.59, 112.48, 142.43, 109.9, 130.83, 104.75, 120.52, 98.95, 106.34, 104.75, 101.83, 113.12, 95.38, 129.24, 86.36, 145.99, 85.07, 149.21, 83.14, 167.9, 97.96, 175.64, 106.34, 177.57, 108.92, 179.5, 119.87, 180.15, 134.7, 174.99, 149.52, 176.93, 161.76, 195.62, 164.34, 214.95, 176.59, 225.26, 195.28, 230.42, 206.88, 233.64, 215.9, 229.77, 230.08, 227.84, 238.46, 231.71, 281.64, 222.04, 309.35, 211.08, 324.82, 196.26, 342.86, 188.53, 357.04, 182.73, 365.42, 175.64, 366.71, 161.46, 375.09, 158.24, 369.93, 164.68, 357.68, 151.15, 355.11, 155.01, 353.17, 171.13, 343.51, 185.3, 331.26, 191.75, 323.53, 191.1, 316.44, 189.82, 307.42, 194.97, 293.24, 196.26, 269.39, 195.62, 250.7, 190.46, 233.3, 192.39, 219.77, 191.1, 210.74, 179.5, 208.81, 164.68, 208.81, 149.86, 209.46, 133.1, 210.74, 115.06, 215.26, 104.1, 216.54], [200.13, 359.62, 196.91, 374.44, 196.26, 389.91, 196.91, 398.93, 197.55, 400.0, 171.13, 400.0, 147.93, 399.58, 107.97, 400.0, 95.08, 398.93, 95.72, 393.13, 97.66, 383.46, 98.3, 375.09, 99.59, 368.0, 112.48, 367.35, 128.59, 366.06, 144.06, 363.48, 162.1, 362.84, 153.08, 377.66, 157.59, 380.24, 165.33, 374.44, 176.93, 370.57, 191.1, 368.0]], "area": 18281.4437, "iscrowd": 0, "image_id": 10005, "bbox": [95.08, 83.14, 138.56, 316.86], "category_id": 1, "id": 205677}, {"segmentation": [[405.22, 226.13, 406.06, 220.06, 405.75, 218.6, 399.26, 218.7, 399.26, 217.76, 401.56, 216.82, 403.44, 217.23, 404.81, 215.14, 404.18, 213.88, 404.6, 212.42, 404.7, 212.0, 406.69, 211.9, 407.84, 211.9, 407.95, 212.73, 409.2, 214.3, 411.3, 217.65, 410.67, 224.25, 408.37, 227.91, 408.26, 228.96, 407.95, 229.9, 406.69, 230.11]], "area": 91.3957999999999, "iscrowd": 0, "image_id": 10342, "bbox": [399.26, 211.9, 12.04, 18.21], "category_id": 1, "id": 210086}, {"segmentation": [[325.28, 226.55, 326.08, 228.36, 325.68, 233.19, 324.27, 239.62, 325.28, 242.64, 326.08, 245.45, 325.88, 247.67, 323.87, 243.24, 323.87, 245.25, 322.26, 246.86, 320.65, 245.66, 321.86, 242.84, 319.04, 239.02, 319.44, 237.21, 319.64, 226.95, 320.05, 226.35, 319.04, 224.13, 321.25, 221.92, 322.86, 222.12, 324.67, 225.34, 325.88, 226.15]], "area": 124.35724999999984, "iscrowd": 0, "image_id": 10318, "bbox": [319.04, 221.92, 7.04, 25.75], "category_id": 1, "id": 215428}, {"segmentation": [[310.02, 249.25, 309.01, 244.02, 309.82, 237.38, 310.02, 234.16, 310.02, 231.55, 309.21, 229.33, 308.01, 227.52, 306.2, 227.12, 305.99, 230.94, 305.99, 233.96, 305.79, 235.77, 305.39, 237.98, 305.79, 239.99, 305.79, 242.0, 306.4, 244.82, 307.0, 246.63, 306.6, 247.44, 304.99, 248.04, 305.19, 248.64, 308.01, 249.65, 309.01, 249.65, 309.62, 249.45]], "area": 78.69084999999956, "iscrowd": 0, "image_id": 10318, "bbox": [304.99, 227.12, 5.03, 22.53], "category_id": 1, "id": 215669}, {"segmentation": [[230.9, 166.7, 236.83, 180.34, 240.39, 190.42, 238.61, 195.76, 238.02, 199.31, 257.59, 202.28, 254.03, 191.01, 266.48, 192.79, 271.82, 188.64, 273.01, 185.67, 280.12, 185.08, 288.43, 185.67, 290.8, 186.86, 290.8, 163.14, 284.28, 145.94], [242.17, 157.8, 247.51, 144.16, 264.71, 118.66, 268.86, 111.54, 274.79, 113.32, 273.6, 100.28, 285.46, 94.94, 289.02, 96.72, 292.58, 106.8, 290.21, 117.47, 271.23, 123.41, 267.67, 129.93, 252.25, 147.72, 253.44, 150.68, 247.51, 160.17]], "area": 2828.0351000000005, "iscrowd": 0, "image_id": 10005, "bbox": [230.9, 94.94, 61.68, 107.34], "category_id": 1, "id": 215759}, {"segmentation": [[317.81, 198.31, 317.58, 191.34, 314.56, 184.61, 309.68, 183.68, 307.36, 184.14, 304.57, 188.79, 302.95, 199.47, 296.67, 204.12, 294.12, 216.2, 294.12, 227.34, 295.74, 236.17, 299.23, 249.41, 299.69, 261.25, 301.55, 282.85, 302.71, 292.61, 303.87, 297.95, 308.75, 298.88, 314.56, 296.32, 312.0, 270.31, 313.16, 250.8, 318.97, 263.58, 323.38, 280.53, 330.58, 294.47, 331.05, 296.56, 332.91, 297.72, 344.52, 297.02, 344.29, 295.86, 336.16, 287.5, 329.19, 263.34, 326.4, 246.62, 331.98, 245.92, 328.26, 214.57, 327.1, 208.3, 324.78, 200.63, 321.99, 198.31]], "area": 2959.1717, "iscrowd": 0, "image_id": 10388, "bbox": [294.12, 183.68, 50.4, 115.2], "category_id": 1, "id": 219814}, {"segmentation": [[299.94, 251.61, 299.94, 238.64, 298.84, 237.66, 297.62, 236.44, 297.74, 235.34, 298.47, 234.11, 299.33, 232.28, 299.45, 231.18, 299.45, 230.32, 299.45, 228.97, 301.29, 227.38, 302.15, 227.38, 302.76, 228.36, 302.76, 229.83, 303.0, 230.57, 303.13, 230.93, 304.35, 231.67, 304.96, 231.79, 305.08, 233.14, 305.21, 233.87, 305.08, 236.93, 303.61, 245.5, 302.64, 248.56, 302.76, 250.15, 304.23, 250.88, 302.88, 251.86]], "area": 107.80479999999993, "iscrowd": 0, "image_id": 10318, "bbox": [297.62, 227.38, 7.59, 24.48], "category_id": 1, "id": 224274}, {"segmentation": [[327.36, 224.66, 328.8, 224.25, 330.34, 226.3, 330.45, 226.82, 330.45, 227.95, 331.37, 229.19, 332.3, 230.11, 331.37, 229.91, 331.17, 232.58, 331.17, 234.64, 331.17, 235.16, 330.65, 235.88, 330.96, 238.35, 330.45, 239.99, 329.11, 240.72, 329.11, 241.44, 328.7, 240.51, 327.67, 239.27, 326.95, 238.24, 327.77, 234.85, 326.54, 233.0, 326.12, 231.45, 326.12, 230.32, 326.64, 228.88, 327.05, 227.44, 327.57, 226.72, 326.84, 225.48, 327.26, 224.86]], "area": 60.32805000000001, "iscrowd": 0, "image_id": 10318, "bbox": [326.12, 224.25, 6.18, 17.19], "category_id": 1, "id": 224825}, {"segmentation": [[525.78, 153.49, 531.97, 141.12, 538.93, 139.57, 555.94, 139.57, 574.5, 139.57, 591.52, 138.8, 637.14, 137.25, 638.69, 140.34, 639.46, 301.2, 639.46, 306.62, 613.17, 312.8, 576.82, 307.39, 565.99, 304.3, 565.99, 327.5, 551.3, 325.18, 550.53, 310.48, 551.3, 277.23, 551.3, 267.18, 548.98, 255.57, 547.43, 239.33, 542.02, 230.05, 537.38, 220.77, 531.19, 202.21, 525.78, 192.16, 548.98, 189.84, 555.94, 184.42, 560.58, 181.33, 562.9, 172.82, 562.9, 165.09, 559.03, 159.68, 552.85, 154.26, 543.57, 153.49, 529.65, 155.04]], "area": 16094.31430000001, "iscrowd": 0, "image_id": 10229, "bbox": [525.78, 137.25, 113.68, 190.25], "category_id": 3, "id": 242854}, {"segmentation": [[77.66, 403.42, 70.11, 368.9, 66.88, 332.22, 63.64, 310.65, 55.01, 279.37, 56.09, 242.7, 62.56, 212.49, 81.98, 188.76, 96.0, 173.66, 127.28, 156.4, 147.78, 148.85, 155.33, 141.3, 163.96, 116.49, 176.9, 97.08, 187.69, 83.06, 214.65, 75.51, 279.37, 75.51, 333.3, 73.35, 388.31, 73.35, 431.46, 75.51, 470.29, 87.37, 491.87, 115.42, 503.73, 152.09, 512.36, 169.35, 516.67, 165.03, 528.54, 156.4, 555.51, 155.33, 559.82, 172.58, 550.11, 184.45, 541.48, 189.84, 530.7, 198.47, 550.11, 244.85, 550.11, 273.98, 554.43, 328.99, 547.96, 376.45, 528.54, 391.55, 505.89, 378.61, 501.57, 367.82, 492.94, 352.72, 478.92, 341.93, 471.37, 373.21, 459.51, 404.49, 418.52, 412.04, 402.34, 361.35, 381.84, 352.72, 299.87, 361.35, 261.03, 375.37, 226.52, 382.92, 210.34, 373.21, 202.79, 362.43, 181.21, 359.19, 166.11, 357.03, 144.54, 357.03, 136.99, 395.87, 131.6, 404.49, 98.16, 409.89]], "area": 131353.89925000005, "iscrowd": 0, "image_id": 10229, "bbox": [55.01, 73.35, 504.81, 338.69], "category_id": 3, "id": 243118}, {"segmentation": [[167.88, 155.17, 175.8, 157.16, 186.21, 158.15, 193.14, 155.92, 213.46, 147.99, 229.81, 128.67, 243.43, 111.82, 252.1, 112.32, 242.44, 157.41, 240.21, 159.14, 164.16, 158.64, 164.9, 155.42, 168.12, 155.42]], "area": 1234.877049999999, "iscrowd": 0, "image_id": 10342, "bbox": [164.16, 111.82, 87.94, 47.32], "category_id": 5, "id": 247024}, {"segmentation": [[156.71, 147.72, 170.02, 147.28, 197.07, 148.61, 214.8, 146.4, 195.29, 156.59, 177.55, 156.15, 158.49, 156.15, 153.61, 153.04, 153.17, 149.05, 158.93, 148.61], [245.84, 148.17, 267.57, 147.28, 262.25, 156.15, 243.18, 156.59, 243.18, 149.5], [281.76, 148.17, 297.72, 143.29, 319.45, 120.68, 326.1, 120.68, 318.56, 147.72, 309.25, 150.83, 296.84, 153.93, 276.88, 156.15, 278.21, 147.72, 287.08, 146.4]], "area": 1269.0786500000004, "iscrowd": 0, "image_id": 10342, "bbox": [153.17, 120.68, 172.93, 35.91], "category_id": 5, "id": 247182}, {"segmentation": [[76.33, 240.14, 78.38, 261.21, 78.38, 275.34, 96.12, 275.34, 111.02, 275.34, 134.92, 275.08, 156.51, 274.06, 154.19, 264.55, 147.51, 256.84, 138.0, 238.59, 133.38, 237.31, 118.73, 237.31, 93.03, 238.59, 77.36, 239.11], [162.93, 256.33, 175.27, 247.33, 176.29, 264.81, 170.64, 267.12, 163.96, 273.54, 162.93, 265.83], [160.1, 235.25, 176.81, 235.77, 175.27, 239.11, 162.42, 247.07], [147.0, 237.05, 152.91, 235.77, 157.02, 247.07, 155.99, 252.21, 152.39, 245.53]], "area": 2998.824849999999, "iscrowd": 0, "image_id": 10318, "bbox": [76.33, 235.25, 100.48, 40.09], "category_id": 6, "id": 248358}, {"segmentation": [[534.02, 105.72, 541.51, 105.72, 542.24, 102.66, 542.24, 102.09, 540.06, 101.93, 538.37, 101.13, 538.05, 98.71, 537.89, 95.41, 537.41, 92.91, 537.41, 92.18, 536.44, 91.94, 535.31, 93.15, 535.15, 95.0, 535.31, 97.66, 535.63, 99.19, 535.47, 100.97, 535.8, 101.77, 535.39, 102.42, 532.01, 102.74, 532.25, 104.19, 533.86, 105.48]], "area": 58.58784999999995, "iscrowd": 0, "image_id": 10318, "bbox": [532.01, 91.94, 10.23, 13.78], "category_id": 9, "id": 249962}, {"segmentation": [[81.57, 135.4, 75.52, 129.73, 72.11, 124.81, 76.28, 97.57, 85.36, 87.35, 96.71, 79.41, 95.19, 70.71, 100.49, 73.35, 101.25, 75.25, 118.65, 71.46, 139.84, 84.33, 151.95, 101.35, 142.87, 107.03, 135.68, 105.14, 130.76, 102.49, 102.0, 114.22, 100.49, 129.35, 97.09, 131.62]], "area": 2646.522100000001, "iscrowd": 0, "image_id": 10244, "bbox": [72.11, 70.71, 79.84, 64.69], "category_id": 28, "id": 280395}, {"segmentation": [[300.39, 120.27, 323.44, 126.7, 350.24, 148.68, 352.39, 150.29, 334.16, 157.79, 319.69, 162.08, 310.04, 170.12, 302.0, 184.6, 305.75, 188.88, 319.69, 198.53, 297.71, 204.97, 299.85, 120.27], [272.52, 121.34, 246.25, 116.52, 194.79, 138.5, 180.85, 144.93, 177.1, 156.72, 161.55, 187.81, 170.67, 187.28, 181.39, 195.85, 183.53, 196.92, 193.72, 185.67, 206.05, 180.31, 213.01, 181.38, 224.27, 186.2, 226.95, 196.39, 226.42, 204.43, 225.88, 207.65, 227.49, 210.33, 237.14, 212.47, 272.52, 214.61, 273.59, 121.34]], "area": 9003.237149999999, "iscrowd": 0, "image_id": 10275, "bbox": [161.55, 116.52, 190.84, 98.09], "category_id": 28, "id": 285274}, {"segmentation": [[354.07, 152.63, 387.66, 139.2, 446.19, 139.2, 466.34, 161.27, 471.14, 191.01, 418.36, 218.84, 378.06, 235.15, 337.76, 213.08, 318.57, 210.21, 320.49, 197.73, 308.98, 182.38, 303.22, 175.66, 308.02, 158.39]], "area": 10999.8843, "iscrowd": 0, "image_id": 10275, "bbox": [303.22, 139.2, 167.92, 95.95], "category_id": 28, "id": 286967}, {"segmentation": [[222.37, 91.74, 235.19, 88.49, 240.88, 92.15, 242.31, 96.22, 250.85, 98.86, 253.7, 107.82, 254.51, 113.72, 252.68, 122.06, 248.0, 126.53, 241.29, 130.4, 230.3, 131.42, 219.52, 128.16, 216.06, 121.65, 213.21, 116.77, 212.4, 109.65, 215.86, 103.75, 220.74, 95.41]], "area": 1332.1228499999997, "iscrowd": 0, "image_id": 10230, "bbox": [212.4, 88.49, 42.11, 42.93], "category_id": 37, "id": 302549}, {"segmentation": [[243.84, 137.08, 247.68, 134.2, 248.76, 134.68, 251.4, 136.72, 248.28, 142.36, 243.96, 146.19, 241.68, 145.95, 239.76, 143.91, 240.12, 141.16, 241.08, 139.0, 243.96, 136.84]], "area": 79.0734, "iscrowd": 0, "image_id": 10265, "bbox": [239.76, 134.2, 11.64, 11.99], "category_id": 37, "id": 305510}, {"segmentation": [[301.35, 60.91, 235.7, 92.13, 220.63, 126.57, 232.47, 212.66, 278.74, 263.25, 384.22, 308.45, 493.99, 334.28, 619.91, 350.42, 640.0, 319.21, 639.28, 31.86, 638.21, 11.41, 640.0, 6.03, 561.79, 1.72, 430.49, 20.02, 372.38, 20.02]], "area": 115708.0046, "iscrowd": 0, "image_id": 10421, "bbox": [220.63, 1.72, 419.37, 348.7], "category_id": 54, "id": 309442}, {"segmentation": [[6.46, 306.73, 21.52, 312.11, 55.96, 330.19, 117.31, 297.9, 137.76, 276.38, 157.13, 280.68, 233.54, 235.48, 236.77, 227.95, 232.47, 209.65, 223.86, 170.91, 219.55, 130.01, 227.09, 98.8, 263.68, 78.35, 301.35, 58.98, 299.19, 53.6, 291.66, 41.76, 240.0, 21.31, 195.87, 4.09, 149.6, 0.0, 31.21, 0.86, 3.23, 10.55, 0.0, 10.55]], "area": 68200.36965000002, "iscrowd": 0, "image_id": 10421, "bbox": [0.0, 0.0, 301.35, 330.19], "category_id": 54, "id": 312027}, {"segmentation": [[270.92, 142.18, 272.71, 126.08, 279.86, 114.16, 294.76, 105.22, 314.44, 107.6, 330.53, 123.7, 335.3, 136.81, 336.49, 155.89, 331.13, 172.58, 322.78, 184.51, 309.07, 191.66, 288.21, 188.08, 275.09, 173.78, 270.92, 158.87, 269.72, 139.2]], "area": 4504.112900000001, "iscrowd": 0, "image_id": 10125, "bbox": [269.72, 105.22, 66.77, 86.44], "category_id": 85, "id": 337009}, {"segmentation": [[385.79, 295.65, 384.84, 265.01, 381.01, 242.04, 383.88, 218.11, 386.75, 199.92, 403.02, 191.3, 414.51, 174.07, 434.62, 159.71, 449.93, 156.84, 493.97, 153.97, 541.83, 157.8, 558.11, 158.75, 586.83, 187.47, 600.23, 205.66, 610.76, 202.79, 617.46, 209.49, 615.55, 215.23, 608.84, 219.06, 620.33, 230.55, 628.95, 243.0, 630.86, 274.59, 627.03, 296.6, 625.12, 310.96, 608.84, 318.62, 600.23, 312.88, 593.53, 300.43, 493.97, 300.43, 472.91, 302.35, 452.8, 293.73, 445.15, 311.92, 439.4, 315.75, 435.57, 307.13, 428.87, 291.82, 433.66, 285.12, 408.77, 281.29, 409.73, 294.69, 403.02, 303.31, 392.49, 302.35, 382.92, 293.73, 379.09, 286.07]], "area": 31385.54095000001, "iscrowd": 0, "image_id": 10434, "bbox": [379.09, 153.97, 251.77, 164.65], "category_id": 3, "id": 347590}, {"segmentation": [[369.91, 142.75, 368.55, 125.99, 375.8, 106.07, 407.05, 103.8, 416.1, 122.82, 416.56, 132.33, 417.01, 143.2, 407.95, 142.29, 399.8, 135.05, 388.48, 138.67, 388.03, 145.01, 377.16, 149.09, 368.1, 146.37]], "area": 1627.8997999999997, "iscrowd": 0, "image_id": 10434, "bbox": [368.1, 103.8, 48.91, 45.29], "category_id": 3, "id": 349558}, {"segmentation": [[524.96, 136.64, 524.41, 120.15, 520.29, 119.32, 514.79, 123.44, 501.04, 123.44, 498.29, 128.12, 498.02, 134.17, 493.62, 135.82, 492.25, 138.56, 494.72, 141.04, 505.72, 142.14, 513.14, 142.96, 516.71, 145.71, 520.56, 152.31, 526.34, 151.49, 526.06, 137.19], [538.16, 116.3, 559.6, 113.0, 570.05, 112.72, 568.4, 126.19, 568.95, 131.97, 564.55, 128.12, 552.18, 127.84, 543.11, 131.97, 536.23, 138.29]], "area": 1150.5815999999998, "iscrowd": 0, "image_id": 10434, "bbox": [492.25, 112.72, 77.8, 39.59], "category_id": 3, "id": 355721}, {"segmentation": [[2.13, 120.52, 51.99, 119.68, 81.56, 118.83, 66.35, 135.73, 55.37, 152.63, 48.61, 163.62, 47.76, 172.91, 42.69, 180.52, 36.78, 181.36, 29.17, 177.14, 29.17, 171.22, 16.5, 172.07, 12.27, 177.14, 8.04, 180.52, 3.82, 181.36, 1.28, 174.6, 2.13, 119.68], [69.73, 162.77, 81.56, 154.32, 90.01, 150.94, 94.24, 153.48, 97.62, 161.08, 96.77, 165.31, 95.08, 167.84, 91.7, 172.07, 90.01, 177.98, 86.63, 180.52, 81.56, 180.52, 75.65, 177.98, 70.58, 172.91, 70.58, 172.91, 66.35, 170.38]], "area": 3888.86325, "iscrowd": 0, "image_id": 10434, "bbox": [1.28, 118.83, 96.34, 62.53], "category_id": 3, "id": 361274}, {"segmentation": [[317.84, 39.19, 471.73, 4.67, 475.0, 211.78, 362.43, 175.82, 345.17, 183.01, 323.6, 165.75, 320.72, 154.25, 296.27, 145.62]], "area": 27078.976950000007, "iscrowd": 0, "image_id": 10244, "bbox": [296.27, 4.67, 178.73, 207.11], "category_id": 6, "id": 365876}, {"segmentation": [[382.53, 14.67, 323.76, 52.71, 184.6, 153.87, 158.45, 174.79, 155.83, 227.75, 156.56, 258.47, 155.84, 259.67, 155.84, 267.62, 169.26, 275.64, 169.88, 293.58, 180.09, 296.05, 181.01, 294.51, 197.71, 299.45, 210.7, 301.31, 215.65, 298.84, 229.57, 300.69, 229.57, 303.78, 232.97, 303.78, 235.76, 298.53, 242.87, 299.15, 254.31, 301.0, 262.05, 296.05, 270.71, 296.05, 280.91, 289.87, 281.84, 284.3, 284.01, 283.68, 290.5, 277.5, 291.74, 280.28, 303.18, 270.38, 302.87, 265.74, 307.51, 258.94, 313.7, 249.97, 313.7, 243.78, 320.81, 236.67, 353.6, 203.58, 402.77, 152.23, 442.98, 113.57, 464.01, 91.3, 466.18, 94.71, 468.03, 96.56, 478.86, 91.92, 494.63, 82.95, 499.27, 72.75, 503.91, 68.73, 512.88, 62.54, 527.11, 55.74, 570.72, 21.41, 578.14, 20.79, 581.23, 16.15, 594.53, 9.65, 594.84, 5.01, 601.78, 0.63, 402.13, 1.58]], "area": 56417.027949999974, "iscrowd": 0, "image_id": 10084, "bbox": [155.83, 0.63, 445.95, 303.15], "category_id": 7, "id": 366905}, {"segmentation": [[148.32, 370.12, 152.18, 366.55, 160.79, 383.78, 179.2, 500.0, 134.67, 500.0, 131.4, 496.6, 118.93, 492.15, 108.54, 481.76, 104.08, 470.77, 103.19, 463.35, 110.91, 444.94, 123.68, 428.91, 144.46, 408.72, 147.43, 396.54, 147.14, 381.99], [79.36, 491.28, 76.09, 499.0, 23.54, 500.0, 37.49, 493.35, 65.4, 489.2]], "area": 5940.250749999997, "iscrowd": 0, "image_id": 10243, "bbox": [23.54, 366.55, 155.66, 133.45], "category_id": 62, "id": 382355}, {"segmentation": [[379.17, 102.38, 359.24, 84.67, 359.24, 3.47, 558.54, 4.95, 637.51, 19.72, 639.72, 427.0, 2.73, 427.0, 2.0, 0.53, 53.66, 3.47, 89.83, 33.0, 83.92, 59.57, 85.4, 66.22, 72.85, 83.93, 82.44, 134.13, 89.09, 165.12, 105.33, 168.81, 64.73, 207.2, 59.57, 256.65, 67.69, 289.86, 89.09, 320.86, 149.61, 358.51, 271.41, 395.41, 361.45, 396.15, 426.41, 368.84, 517.2, 334.15, 562.22, 287.65, 619.79, 364.42, 632.34, 346.7, 637.51, 343.01, 579.93, 255.91, 579.2, 201.29, 545.25, 158.48, 518.68, 142.24, 534.91, 126.01, 526.05, 112.72, 549.68, 78.03, 534.17, 68.44, 512.76, 68.44, 469.96, 92.05, 453.72, 80.98, 441.17, 89.09, 447.81, 100.91, 382.86, 103.86], [71.37, 0.08, 94.26, 35.51, 103.11, 26.66, 120.83, 27.4, 124.52, 22.22, 140.02, 19.27, 151.83, 25.92, 157.0, 28.13, 171.02, 14.84, 180.62, 1.55, 73.59, 2.29]], "area": 110712.74180000006, "iscrowd": 0, "image_id": 10161, "bbox": [2.0, 0.08, 637.72, 426.92], "category_id": 67, "id": 392660}, {"segmentation": [[161.8, 433.62, 197.39, 453.03, 278.29, 458.43, 340.85, 453.03, 366.74, 435.78, 400.18, 421.75, 412.04, 406.65, 409.89, 388.31, 399.1, 363.51, 385.08, 357.03, 335.46, 345.17, 262.11, 348.4, 184.45, 364.58, 158.56, 384.0, 142.38, 413.12, 148.85, 422.83]], "area": 23518.753249999998, "iscrowd": 0, "image_id": 10176, "bbox": [142.38, 345.17, 269.66, 113.26], "category_id": 67, "id": 393164}, {"segmentation": [[474.21, 351.74, 512.42, 315.49, 638.81, 328.22, 637.83, 431.1, 549.65, 429.14, 494.79, 426.2, 471.27, 419.34, 470.29, 389.95, 474.21, 350.76, 478.13, 345.86]], "area": 17225.573699999997, "iscrowd": 0, "image_id": 10125, "bbox": [470.29, 315.49, 168.52, 115.61], "category_id": 8, "id": 397146}, {"segmentation": [[142.38, 358.11, 132.67, 398.02, 125.12, 408.81, 75.51, 409.89, 63.64, 366.74, 66.88, 316.04, 59.33, 268.58, 58.25, 197.39, 87.37, 183.37, 99.24, 159.64, 110.02, 153.17, 143.46, 146.7, 165.03, 101.39, 184.45, 79.82, 293.39, 73.35, 435.78, 77.66, 474.61, 90.61, 492.94, 107.87, 492.94, 122.97, 510.2, 168.27, 526.38, 153.17, 560.9, 153.17, 565.21, 175.82, 528.54, 189.84, 538.25, 216.81, 550.11, 241.62, 558.74, 299.87, 550.11, 364.58, 542.56, 389.39, 497.26, 387.24, 495.1, 344.09, 480.0, 344.09, 469.21, 414.2, 412.04, 414.2, 405.57, 360.27, 364.58, 359.19, 361.35, 368.9, 344.09, 368.9, 344.09, 360.27, 294.47, 355.96, 293.39, 364.58, 284.76, 366.74, 263.19, 369.98, 261.03, 381.84, 220.04, 386.16, 208.18, 357.03, 193.08, 352.72, 202.79, 369.98, 176.9, 360.27, 179.06, 354.88, 147.78, 352.72]], "area": 134246.28490000003, "iscrowd": 0, "image_id": 10229, "bbox": [58.25, 73.35, 506.96, 340.85], "category_id": 8, "id": 397350}, {"segmentation": [[531.66, 144.16, 640.0, 140.93, 638.21, 307.75, 596.23, 307.75, 569.33, 300.22, 560.72, 324.97, 557.49, 286.22, 543.5, 218.42, 531.66, 193.67, 561.79, 176.45, 563.95, 154.92, 553.18, 150.62, 523.05, 152.77]], "area": 14706.711400000002, "iscrowd": 0, "image_id": 10229, "bbox": [523.05, 140.93, 116.95, 184.04], "category_id": 8, "id": 399754}, {"segmentation": [[266.85, 354.62, 276.38, 164.96, 284.0, 149.72, 301.15, 137.33, 312.59, 125.89, 505.1, 118.27, 537.5, 136.37, 578.48, 178.31, 599.45, 174.49, 615.65, 218.33, 619.46, 247.88, 620.42, 298.39, 624.23, 285.05, 621.37, 370.82, 599.45, 370.82, 579.44, 374.63, 569.91, 390.83, 553.7, 389.88, 530.83, 362.24, 410.75, 367.0, 407.89, 403.22, 371.68, 405.13, 334.51, 394.64, 330.7, 379.39, 328.79, 355.57]], "area": 82795.81754999999, "iscrowd": 0, "image_id": 10058, "bbox": [266.85, 118.27, 357.38, 286.86], "category_id": 8, "id": 400533}, {"segmentation": [[203.82, 27.16, 208.78, 274.68, 282.86, 273.18, 288.85, 122.03, 270.89, 102.57, 276.13, 72.64, 263.41, 61.41, 268.64, 30.73, 257.42, 22.5, 246.94, 21.75, 227.49, 28.49]], "area": 18377.789800000006, "iscrowd": 0, "image_id": 10222, "bbox": [203.82, 21.75, 85.03, 252.93], "category_id": 10, "id": 403063}, {"segmentation": [[555.53, 275.17, 551.31, 57.35, 461.82, 39.63, 440.72, 105.48, 359.67, 131.65, 379.23, 336.16, 555.85, 328.58]], "area": 47000.18014999998, "iscrowd": 0, "image_id": 10241, "bbox": [359.67, 39.63, 196.18, 296.53], "category_id": 10, "id": 406094}, {"segmentation": [[181.62, 132.68, 200.45, 132.68, 202.43, 132.68, 215.32, 136.65, 238.12, 137.64, 250.02, 113.85, 259.93, 102.94, 265.88, 102.94, 283.73, 111.86, 284.72, 126.73, 273.81, 145.57, 263.9, 151.52, 261.92, 156.48, 269.85, 162.42, 273.81, 202.08, 263.9, 212.98, 258.94, 220.92, 266.87, 277.42, 264.89, 298.24, 264.89, 328.98, 254.98, 340.87, 244.07, 346.82, 239.12, 346.82, 238.12, 344.84, 239.12, 335.92, 243.08, 321.04, 244.07, 311.13, 244.07, 296.26, 243.08, 293.29, 242.09, 293.29, 236.14, 296.26, 232.18, 301.22, 231.18, 315.1, 231.18, 328.98, 232.18, 335.92, 218.3, 336.91, 205.41, 336.91, 208.38, 327.98, 219.29, 316.09, 220.28, 279.41, 220.28, 222.9, 215.32, 168.37, 213.34, 154.49, 185.58, 142.6, 171.7, 143.59]], "area": 11080.774350000007, "iscrowd": 0, "image_id": 10358, "bbox": [171.7, 102.94, 113.02, 243.88], "category_id": 1, "id": 429293}, {"segmentation": [[170.05, 423.99, 176.8, 408.22, 176.8, 371.06, 181.31, 317.0, 165.54, 301.24, 162.16, 292.23, 155.41, 291.1, 152.03, 289.98, 150.9, 298.99, 146.4, 304.62, 144.14, 313.63, 121.62, 319.26, 114.86, 310.25, 108.11, 289.98, 106.98, 271.96, 106.98, 271.96, 56.31, 262.95, 55.18, 268.58, 43.92, 282.09, 38.29, 292.23, 33.78, 298.99, 23.65, 291.1, 23.65, 278.72, 27.03, 266.33, 24.77, 257.32, 25.9, 243.81, 30.41, 238.18, 50.68, 241.55, 78.83, 249.44, 97.97, 246.06, 128.38, 244.93, 139.64, 203.27, 156.53, 189.75, 182.43, 163.85, 195.95, 157.09, 213.96, 153.72, 220.72, 153.72, 220.72, 137.95, 227.48, 126.69, 238.74, 119.93, 253.38, 118.81, 263.51, 124.44, 277.03, 131.19, 279.28, 143.58, 271.4, 145.83, 271.4, 145.83, 269.14, 164.98, 269.14, 175.11, 269.14, 181.87, 270.27, 196.51, 266.89, 216.78, 266.89, 228.04, 252.25, 230.29, 248.87, 230.29, 242.12, 232.55, 237.61, 238.18, 224.1, 246.06, 209.46, 256.19, 199.32, 262.95, 216.22, 301.24, 216.22, 323.76, 208.33, 358.67, 198.2, 395.83, 198.2, 409.35, 216.22, 419.48, 224.1, 425.11, 226.35, 434.12, 218.47, 437.5, 189.19, 437.5, 172.3, 436.37]], "area": 24826.732949999994, "iscrowd": 0, "image_id": 10309, "bbox": [23.65, 118.81, 255.63, 318.69], "category_id": 1, "id": 438428}, {"segmentation": [[189.03, 494.57, 171.84, 432.26, 182.59, 364.58, 191.19, 343.09, 143.91, 319.45, 117.05, 281.84, 126.72, 259.28, 175.07, 203.42, 225.56, 178.7, 211.6, 143.26, 211.6, 114.24, 226.63, 92.75, 252.42, 98.13, 276.05, 114.24, 273.91, 167.96, 325.48, 193.75, 335.16, 212.01, 308.3, 313.0, 319.04, 323.75, 310.44, 352.75, 327.63, 429.04, 262.09, 460.19, 270.69, 478.46, 334.07, 455.89, 342.67, 493.49, 193.33, 491.35]], "area": 52552.47525000001, "iscrowd": 0, "image_id": 10179, "bbox": [117.05, 92.75, 225.62, 401.82], "category_id": 1, "id": 440556}, {"segmentation": [[76.4, 299.14, 59.25, 299.14, 57.01, 281.98, 51.79, 279.74, 62.97, 251.4, 60.74, 247.67, 83.11, 214.1, 96.54, 179.79, 95.79, 154.43, 92.06, 150.7, 77.89, 161.15, 71.93, 162.64, 69.69, 166.37, 59.25, 214.1, 47.31, 218.58, 39.11, 209.63, 36.87, 199.93, 51.79, 152.2, 74.91, 122.36, 95.79, 107.44, 104.74, 102.22, 114.44, 82.83, 134.58, 90.29, 141.29, 97.74, 181.57, 105.2, 203.95, 117.14, 211.41, 130.56, 227.07, 136.53, 211.41, 151.45, 201.71, 137.28, 191.27, 136.53, 174.86, 135.04, 165.16, 132.06, 167.4, 163.38, 175.61, 182.78, 196.49, 220.82, 184.56, 261.1, 205.44, 299.88, 162.92, 293.92, 165.16, 279.0, 165.91, 274.52, 149.5, 261.1, 164.42, 229.02, 161.43, 219.33, 132.34, 206.65, 108.47, 223.06, 104.74, 227.53, 95.79, 235.74, 82.37, 261.84, 86.1, 272.28, 80.88, 278.25, 82.37, 287.95]], "area": 18237.7949, "iscrowd": 0, "image_id": 10434, "bbox": [36.87, 82.83, 190.2, 217.05], "category_id": 1, "id": 451116}, {"segmentation": [[541.32, 157.23, 547.81, 150.12, 558.62, 146.72, 554.61, 138.38, 557.08, 135.6, 556.15, 122.92, 555.53, 117.05, 553.68, 113.03, 556.77, 112.42, 558.62, 109.02, 561.71, 99.44, 567.9, 93.56, 573.15, 90.16, 585.2, 91.4, 591.38, 93.87, 594.78, 100.98, 596.33, 107.78, 593.55, 117.98, 591.69, 122.0, 587.68, 127.87, 588.6, 130.03, 588.6, 137.14, 597.26, 143.63, 606.84, 149.5, 614.56, 156.61, 619.82, 164.34, 622.6, 168.67, 620.45, 186.63, 619.83, 192.81, 621.06, 197.75, 619.21, 200.84, 618.59, 205.17, 617.05, 212.59, 615.5, 228.35, 613.65, 234.53, 612.41, 244.42, 610.56, 255.24, 609.32, 273.17, 610.56, 280.27, 608.39, 289.86, 604.37, 295.11, 599.74, 296.96, 596.65, 302.22, 594.17, 300.98, 597.57, 290.47, 591.7, 301.29, 589.54, 299.75, 567.59, 295.73, 567.59, 285.84, 568.83, 281.51, 566.36, 270.38, 577.79, 267.91, 583.67, 264.2, 585.52, 257.09, 583.36, 238.86, 577.18, 220.32, 571.61, 202.08, 565.43, 187.25, 564.2, 177.36, 559.87, 172.1, 550.29, 162.83, 546.27, 160.36]], "area": 8640.924449999995, "iscrowd": 0, "image_id": 10176, "bbox": [541.32, 90.16, 81.28, 212.06], "category_id": 1, "id": 451458}, {"segmentation": [[5.62, 185.05, 30.34, 160.33, 8.99, 149.09, 5.62, 137.86, 3.37, 114.26, 4.49, 86.17, 16.85, 51.34, 29.21, 42.35, 79.78, 62.58, 80.9, 64.83, 86.52, 87.3, 92.13, 106.4, 97.75, 128.87, 98.88, 141.23, 102.25, 154.71, 103.37, 158.08, 141.57, 172.69, 151.69, 173.81, 203.37, 177.18, 241.57, 191.79, 255.06, 198.53, 248.31, 215.39, 183.15, 217.63, 176.4, 217.63, 135.96, 222.13, 131.46, 222.13, 140.45, 261.45, 141.57, 279.43, 146.07, 328.87, 139.33, 352.47, 142.7, 400.78, 130.34, 431.12, 104.49, 467.07, 102.25, 487.3, 89.89, 488.42, 75.28, 433.36, 75.28, 425.5, 50.56, 350.22, 40.45, 299.66, 39.33, 286.17, 22.47, 249.09, 11.24, 261.45, 7.87, 278.31]], "area": 42897.21920000001, "iscrowd": 0, "image_id": 10243, "bbox": [3.37, 42.35, 251.69, 446.07], "category_id": 1, "id": 456997}, {"segmentation": [[445.48, 426.97, 441.17, 435.6, 434.7, 462.56, 434.7, 471.19, 477.84, 473.35, 483.24, 436.67, 484.31, 404.31, 509.12, 346.07, 518.83, 360.09, 530.7, 405.39, 537.17, 447.46, 571.69, 423.73, 572.76, 404.31, 571.69, 378.43, 567.37, 300.76, 567.37, 272.72, 585.71, 264.09, 578.16, 218.79, 564.13, 177.8, 552.27, 162.7, 518.83, 142.2, 509.12, 135.73, 512.36, 109.84, 504.81, 90.43, 488.63, 77.48, 468.13, 79.64, 453.03, 83.96, 447.64, 94.74, 448.72, 115.24, 449.8, 130.34, 449.8, 141.12, 458.43, 158.38, 463.82, 159.46, 459.51, 170.25, 458.43, 184.27, 465.98, 226.34, 465.98, 251.15, 473.53, 272.72, 464.9, 278.11, 463.82, 284.58, 455.19, 314.79, 453.03, 329.89, 453.03, 356.85]], "area": 35054.99769999999, "iscrowd": 0, "image_id": 10176, "bbox": [434.7, 77.48, 151.01, 395.87], "category_id": 1, "id": 459617}, {"segmentation": [[618.91, 419.32, 588.2, 373.27, 596.84, 361.75, 577.65, 349.28, 565.18, 334.88, 547.9, 299.38, 532.55, 284.99, 508.56, 285.95, 494.17, 293.62, 488.41, 310.89, 488.41, 325.29, 487.45, 332.0, 488.41, 343.52, 479.78, 350.24, 471.14, 359.83, 487.45, 386.7, 479.78, 391.5, 491.29, 421.24, 612.19, 416.44]], "area": 12366.98715, "iscrowd": 0, "image_id": 10130, "bbox": [471.14, 284.99, 147.77, 136.25], "category_id": 1, "id": 465262}, {"segmentation": [[345.47, 194.54, 375.66, 174.41, 361.13, 169.94, 355.54, 149.82, 352.18, 130.81, 348.83, 114.04, 333.18, 112.92, 336.53, 100.62, 351.06, 93.92, 355.54, 89.44, 365.6, 76.03, 377.9, 73.79, 394.67, 79.38, 414.79, 91.68, 419.27, 119.63, 413.67, 130.81, 417.03, 145.35, 424.86, 155.41, 443.86, 161.0, 461.75, 163.23, 480.76, 167.71, 490.82, 172.18, 508.71, 192.3, 518.77, 209.07, 528.83, 223.61, 540.01, 235.91, 548.96, 248.2, 557.9, 261.62, 550.08, 269.45, 551.19, 294.04, 550.08, 313.05, 555.67, 333.18, 560.14, 339.88, 562.37, 348.83, 566.85, 360.01, 557.9, 368.95, 541.13, 377.9, 527.71, 375.66, 521.01, 368.95, 510.94, 355.54, 517.65, 333.18, 522.12, 317.52, 522.12, 304.11, 518.77, 294.04, 510.94, 294.04, 502.0, 296.28, 494.17, 302.99, 497.53, 322.0, 506.47, 343.24, 518.77, 384.61, 518.77, 417.03, 516.53, 429.33, 513.18, 436.04, 513.18, 442.74, 510.94, 480.76, 510.94, 487.47, 504.24, 493.06, 386.84, 496.41, 385.72, 456.16, 383.49, 444.98, 382.37, 436.04, 382.37, 427.09, 373.43, 449.45, 354.42, 456.16, 337.65, 450.57, 334.29, 433.8, 337.65, 423.74, 338.77, 396.9, 344.36, 382.37, 338.77, 356.65, 334.29, 332.06, 334.29, 324.23, 319.76, 319.76, 310.82, 315.29, 307.46, 306.34, 334.29, 210.19, 345.47, 193.42]], "area": 67431.156, "iscrowd": 0, "image_id": 10179, "bbox": [307.46, 73.79, 259.39, 422.62], "category_id": 1, "id": 469960}, {"segmentation": [[288.82, 125.7, 258.12, 140.09, 257.16, 149.69, 298.42, 170.8, 298.42, 170.8, 299.38, 155.45, 300.34, 132.42, 302.26, 127.62]], "area": 1234.843399999999, "iscrowd": 0, "image_id": 10245, "bbox": [257.16, 125.7, 45.1, 45.1], "category_id": 1, "id": 473149}, {"segmentation": [[244.85, 480.0, 244.85, 480.0, 245.93, 480.0, 245.93, 477.84, 395.87, 480.0, 393.71, 448.72, 409.89, 410.97, 423.91, 413.12, 405.57, 381.84, 394.79, 358.11, 386.16, 293.39, 382.92, 257.8, 389.39, 230.83, 360.27, 186.61, 336.54, 174.74, 335.46, 166.11, 343.01, 134.83, 343.01, 115.42, 336.54, 83.06, 306.34, 74.43, 279.37, 88.45, 278.29, 120.81, 276.13, 128.36, 280.45, 141.3, 279.37, 161.8, 261.03, 159.64, 257.8, 153.17, 258.88, 129.44, 255.64, 111.1, 247.01, 126.2, 231.91, 133.75, 214.65, 119.73, 210.34, 115.42, 206.02, 130.52, 208.18, 149.93, 216.81, 157.48, 216.81, 185.53, 215.73, 211.42, 230.83, 239.46, 242.7, 298.79, 235.15, 419.6], [213.57, 104.63, 220.04, 98.16, 224.36, 90.61, 217.89, 86.29, 209.26, 88.45, 208.18, 94.92, 209.26, 103.55], [247.01, 96.0, 254.56, 102.47, 254.56, 87.37, 249.17, 85.21, 242.7, 88.45, 243.78, 94.92]], "area": 56148.40265000001, "iscrowd": 0, "image_id": 10230, "bbox": [206.02, 74.43, 217.89, 405.57], "category_id": 1, "id": 473553}, {"segmentation": [[403.23, 330.52, 364.48, 280.3, 320.0, 224.33, 318.57, 194.2, 320.0, 146.85, 294.17, 115.28, 269.78, 89.45, 249.69, 29.18, 198.03, 6.22, 162.15, 30.61, 144.93, 70.79, 143.5, 138.24, 117.67, 154.02, 113.36, 230.07, 134.89, 304.69, 165.02, 364.96, 139.19, 395.1, 136.32, 425.23, 113.36, 498.42, 101.88, 616.08, 93.27, 637.61, 93.27, 640.0, 139.19, 640.0, 140.63, 621.82, 140.63, 597.43, 177.94, 517.07, 196.59, 438.15, 212.38, 442.45, 228.16, 442.45, 232.47, 445.32, 337.22, 537.16, 358.74, 560.12, 351.57, 603.17, 330.04, 626.13, 334.35, 636.17, 363.05, 636.17, 388.88, 626.13, 416.14, 598.86, 408.97, 558.68, 406.1, 545.77, 386.01, 535.72, 341.52, 479.76, 305.65, 428.1, 279.82, 413.75, 297.04, 402.27, 308.52, 408.01, 374.53, 380.75, 384.57, 360.66, 396.05, 352.05, 403.23, 333.39]], "area": 102389.06404999999, "iscrowd": 0, "image_id": 10069, "bbox": [93.27, 6.22, 322.87, 633.78], "category_id": 1, "id": 473954}, {"segmentation": [[404.46, 229.87, 399.84, 257.06, 399.33, 265.78, 400.87, 272.97, 400.87, 281.69, 401.9, 284.25, 403.44, 284.77, 407.54, 288.87, 419.34, 286.31, 424.47, 283.74, 425.5, 279.64, 425.5, 267.32, 426.01, 260.14, 428.06, 255.01, 428.58, 247.31, 432.68, 233.97, 432.68, 222.69, 423.96, 189.34, 418.83, 188.31, 413.7, 189.85, 411.13, 192.42, 410.11, 200.11, 410.11, 203.7, 407.03, 209.35, 399.33, 214.99, 400.87, 225.76]], "area": 2448.8273500000005, "iscrowd": 0, "image_id": 10281, "bbox": [399.33, 188.31, 33.35, 100.56], "category_id": 1, "id": 474848}, {"segmentation": [[125.02, 5.29, 120.21, 50.49, 102.9, 134.16, 100.98, 187.05, 100.98, 217.83, 117.33, 218.79, 120.21, 219.75, 127.91, 299.57, 137.52, 337.08, 140.41, 371.7, 161.57, 414.98, 169.26, 418.83, 236.58, 421.71, 230.81, 389.97, 226.0, 334.19, 222.16, 289.96, 214.46, 282.26, 209.65, 259.18, 204.84, 246.68, 200.04, 231.29, 226.0, 228.41, 253.89, 219.75, 266.39, 235.14, 272.16, 244.76, 271.2, 245.72, 254.85, 249.56, 251.97, 267.84, 254.85, 281.3, 252.93, 297.65, 252.93, 349.58, 253.89, 377.47, 265.43, 418.83, 280.82, 418.83, 440.46, 412.09, 436.62, 328.42, 428.92, 263.03, 419.31, 237.06, 404.88, 235.14, 401.03, 234.18, 399.11, 217.83, 392.38, 205.33, 398.15, 202.44, 426.04, 200.52, 457.77, 199.56, 460.66, 199.56, 460.66, 208.21, 476.05, 174.55, 467.39, 134.16, 451.04, 97.61, 433.73, 69.72, 424.11, 41.83, 425.08, 5.29, 425.08, 2.4]], "area": 124324.93295, "iscrowd": 0, "image_id": 10232, "bbox": [100.98, 2.4, 375.07, 419.31], "category_id": 1, "id": 475960}, {"segmentation": [[139.33, 80.56, 146.07, 119.88, 157.3, 131.12, 188.76, 132.24, 211.24, 122.13, 228.09, 115.39, 252.81, 114.26, 273.03, 113.14, 289.89, 108.65, 296.63, 90.67, 292.13, 71.57, 292.13, 56.96, 310.11, 42.35, 298.88, 36.74, 339.33, 26.62, 360.67, 28.87, 371.91, 45.72, 382.02, 58.08, 396.63, 62.58, 401.12, 68.2, 395.51, 79.43, 383.15, 85.05, 376.4, 88.42, 379.78, 101.9, 379.78, 116.51, 377.53, 126.62, 428.09, 161.45, 478.65, 241.23, 483.15, 253.59, 430.34, 307.52, 408.99, 317.63, 388.76, 318.76, 383.15, 305.27, 383.15, 288.42, 387.64, 285.05, 376.4, 273.81, 422.47, 267.07, 434.83, 256.96, 438.2, 251.34, 433.71, 244.6, 429.21, 243.48, 413.48, 231.12, 396.63, 212.02, 382.02, 214.26, 389.89, 228.87, 385.39, 247.97, 379.78, 247.97, 388.76, 260.33, 383.15, 270.44, 375.28, 270.44, 375.28, 277.18, 378.65, 288.42, 378.65, 296.29, 382.02, 310.89, 386.52, 337.86, 378.65, 389.54, 356.18, 461.45, 344.94, 489.54, 339.33, 491.79, 267.42, 492.92, 264.04, 473.81, 253.93, 436.74, 250.56, 414.26, 250.56, 391.79, 247.19, 376.06, 244.94, 358.08, 244.94, 332.24, 251.69, 309.77, 251.69, 294.04, 248.31, 278.31, 242.7, 234.49, 232.58, 210.89, 215.73, 195.16, 196.63, 189.54, 174.16, 188.42, 155.06, 187.3, 138.2, 180.56, 120.22, 163.7, 119.1, 141.23, 116.85, 126.62, 115.73, 109.77, 117.98, 92.92], [114.61, 69.32, 114.61, 74.94, 113.48, 83.93, 113.48, 91.79, 106.74, 98.53, 97.75, 99.66, 101.12, 86.17, 105.62, 73.81, 113.48, 62.58, 120.22, 58.08, 119.1, 64.83]], "area": 75171.61760000003, "iscrowd": 0, "image_id": 10094, "bbox": [97.75, 26.62, 385.4, 466.3], "category_id": 1, "id": 477016}, {"segmentation": [[49.66, 417.36, 47.75, 365.79, 61.12, 344.78, 53.48, 316.12, 51.57, 247.36, 41.07, 202.47, 23.88, 181.46, 8.6, 170.96, 14.33, 148.03, 17.19, 133.71, 0.96, 122.25, 2.87, 417.36]], "area": 11868.79725, "iscrowd": 0, "image_id": 10082, "bbox": [0.96, 122.25, 60.16, 295.11], "category_id": 1, "id": 478535}, {"segmentation": [[270.59, 208.22, 271.55, 178.48, 260.04, 166.0, 268.67, 143.93, 256.2, 138.18, 246.6, 123.78, 251.4, 88.28, 265.8, 75.8, 293.62, 71.01, 309.93, 87.32, 330.09, 133.38, 345.44, 176.56, 359.83, 210.14]], "area": 9733.725249999998, "iscrowd": 0, "image_id": 10130, "bbox": [246.6, 71.01, 113.23, 139.13], "category_id": 1, "id": 479245}, {"segmentation": [[512.92, 196.57, 512.92, 201.06, 515.27, 204.05, 520.83, 205.55, 525.11, 204.48, 532.8, 203.62, 537.07, 201.7, 541.99, 199.78, 544.98, 199.14, 547.55, 197.21, 547.55, 194.01, 546.91, 189.73, 546.69, 186.31, 545.62, 181.61, 540.92, 175.2, 531.73, 174.56, 529.38, 174.77, 522.75, 177.98, 519.55, 179.9, 516.13, 186.95, 514.42, 190.8, 514.42, 191.01]], "area": 819.9342500000007, "iscrowd": 0, "image_id": 10434, "bbox": [512.92, 174.56, 34.63, 30.99], "category_id": 1, "id": 480341}, {"segmentation": [[164.12, 311.88, 165.5, 284.36, 167.56, 272.66, 173.07, 257.53, 174.44, 245.15, 173.75, 228.63, 177.88, 210.75, 187.51, 199.05, 199.21, 183.92, 211.59, 184.6, 217.78, 185.98, 223.98, 190.8, 230.17, 214.87, 228.79, 225.88, 232.92, 227.26, 241.86, 251.34, 246.68, 253.4, 254.25, 234.83, 270.07, 219.69, 270.76, 268.54, 267.32, 282.3, 255.62, 280.23, 245.99, 279.54, 245.99, 282.3, 254.94, 300.87, 257.0, 310.5]], "area": 9399.22, "iscrowd": 0, "image_id": 10275, "bbox": [164.12, 183.92, 106.64, 127.96], "category_id": 1, "id": 480882}, {"segmentation": [[464.54, 171.15, 469.56, 172.27, 466.21, 178.96, 474.57, 188.44, 469.0, 203.49, 461.75, 207.4, 451.15, 214.09, 429.4, 219.67, 426.06, 220.78, 424.94, 230.26, 454.5, 223.57, 468.44, 223.01, 466.77, 230.26, 475.69, 245.32, 482.38, 272.64, 487.4, 282.12, 494.65, 286.03, 499.67, 313.35, 506.36, 316.14, 505.24, 284.35, 501.9, 253.68, 508.59, 203.49, 506.36, 180.07, 496.32, 175.61, 496.88, 163.9, 487.96, 153.31, 476.8, 153.31, 463.98, 162.23], [471.82, 326.22, 470.95, 336.65, 470.95, 339.25, 464.87, 344.47, 457.48, 347.51, 457.48, 350.98, 468.34, 351.85, 473.99, 351.85, 475.73, 351.85, 478.33, 355.33, 486.16, 356.2, 493.11, 356.2, 500.06, 355.33, 502.67, 353.16, 507.01, 351.85, 507.45, 342.73, 508.32, 332.74, 508.75, 324.91]], "area": 5933.446499999998, "iscrowd": 0, "image_id": 10239, "bbox": [424.94, 153.31, 83.81, 202.89], "category_id": 1, "id": 484235}, {"segmentation": [[189.84, 316.04, 199.55, 338.7, 212.49, 354.88, 231.91, 369.98, 248.09, 363.51, 303.1, 351.64, 346.25, 349.48, 422.83, 368.9, 421.75, 395.87, 484.31, 430.38, 565.21, 472.45, 595.42, 473.53, 600.81, 432.54, 610.52, 390.47, 605.12, 377.53, 631.01, 365.66, 640.0, 256.72, 637.48, 237.3, 609.44, 201.71, 594.34, 157.48, 578.16, 118.65, 564.13, 81.98, 531.78, 35.6, 498.34, 15.1, 467.06, 2.16, 361.35, 1.08, 323.6, 1.08, 302.02, 6.47, 166.11, 7.55, 175.82, 35.6, 188.76, 71.19, 221.12, 93.84, 230.83, 108.94, 238.38, 131.6, 239.46, 142.38, 239.46, 159.64, 237.3, 184.45, 239.46, 199.55, 253.48, 187.69, 254.56, 173.66, 266.43, 184.45, 276.13, 184.45, 289.08, 170.43, 292.31, 159.64, 314.97, 175.82, 339.78, 170.43, 344.09, 190.92, 371.06, 207.1, 379.69, 223.28, 387.24, 241.62, 423.91, 302.02, 367.82, 299.87, 264.27, 288.0, 226.52, 289.08, 204.94, 299.87, 188.76, 314.97]], "area": 132502.2999, "iscrowd": 0, "image_id": 10175, "bbox": [166.11, 1.08, 473.89, 472.45], "category_id": 1, "id": 489633}, {"segmentation": [[101.56, 306.97, 123.73, 247.39, 133.43, 203.05, 141.74, 183.65, 133.43, 179.49, 127.89, 168.4, 5.94, 164.25, 0.0, 125.45, 14.26, 135.15, 29.5, 142.08, 100.17, 129.6, 141.74, 135.15, 181.93, 130.99, 211.03, 137.92, 230.43, 136.53, 230.43, 115.75, 242.9, 99.12, 276.16, 92.19, 295.55, 114.36, 299.71, 132.38, 305.25, 137.92, 359.3, 104.66, 380.08, 101.89, 405.02, 119.9, 380.08, 136.53, 348.21, 136.53, 290.01, 176.72, 262.3, 185.03, 251.21, 198.89, 242.9, 204.43, 209.64, 276.49, 285.85, 300.04, 294.17, 305.59, 294.17, 326.37, 278.93, 373.49, 266.46, 433.07, 269.23, 445.54, 299.71, 460.79, 308.03, 473.26, 292.78, 487.11, 198.56, 489.88, 193.01, 503.74, 156.99, 507.9, 132.04, 494.04, 134.81, 478.8, 144.51, 469.1, 144.51, 458.01, 169.46, 416.44, 181.93, 395.66, 118.19, 395.66, 94.63, 381.8, 94.63, 334.69]], "area": 60930.67275, "iscrowd": 0, "image_id": 10313, "bbox": [0.0, 92.19, 405.02, 415.71], "category_id": 1, "id": 489888}, {"segmentation": [[233.9, 463.5, 236.77, 430.49, 236.77, 384.57, 232.47, 347.26, 219.55, 314.26, 193.72, 335.78, 208.07, 279.82, 218.12, 261.17, 235.34, 239.64, 241.08, 208.07, 268.34, 223.86, 281.26, 246.82, 304.22, 274.08, 324.3, 314.26, 302.78, 324.3, 281.26, 324.3, 282.69, 341.52, 275.52, 390.31, 275.52, 433.36, 278.39, 466.37, 265.47, 492.2, 256.86, 485.02, 229.6, 479.28]], "area": 15634.278399999997, "iscrowd": 0, "image_id": 10024, "bbox": [193.72, 208.07, 130.58, 284.13], "category_id": 1, "id": 490664}, {"segmentation": [[337.31, 311.29, 333.24, 315.15, 324.88, 314.93, 308.17, 314.72, 307.1, 311.29, 308.39, 309.79, 321.45, 302.29, 322.95, 286.87, 322.95, 268.87, 323.6, 261.59, 333.24, 249.81, 344.38, 241.45, 331.95, 237.38, 328.74, 236.74, 329.59, 246.81, 324.02, 259.02, 317.81, 271.87, 315.67, 275.73, 315.24, 273.16, 313.96, 273.59, 312.46, 275.09, 311.81, 278.73, 309.46, 280.23, 308.6, 272.09, 316.1, 255.59, 319.74, 243.81, 316.74, 227.31, 309.03, 226.24, 305.17, 223.24, 304.1, 219.6, 301.32, 215.53, 299.82, 210.82, 305.6, 201.39, 315.24, 201.39, 322.95, 207.6, 337.52, 206.75, 357.87, 212.32, 362.8, 217.03, 368.37, 224.53, 379.94, 235.03, 379.29, 239.74, 392.36, 249.16, 392.58, 255.38, 397.07, 261.16, 409.5, 257.3, 424.5, 260.52, 436.71, 256.66, 442.92, 256.45, 445.49, 263.95, 450.84, 265.87, 451.49, 274.23, 453.2, 280.01, 449.56, 278.73, 439.49, 272.51, 420.21, 267.8, 392.79, 273.8, 373.94, 262.45, 364.94, 257.73, 352.3, 265.87, 344.38, 263.73, 333.24, 267.37, 335.81, 279.58, 332.81, 291.37, 333.02, 302.72]], "area": 5189.584999999999, "iscrowd": 0, "image_id": 10265, "bbox": [299.82, 201.39, 153.38, 113.76], "category_id": 1, "id": 493301}, {"segmentation": [[111.08, 314.14, 117.38, 292.08, 106.35, 260.57, 103.2, 219.6, 111.08, 201.48, 103.2, 175.48, 94.54, 146.34, 97.69, 132.16, 101.63, 118.76, 118.17, 114.82, 120.53, 108.52, 118.96, 88.04, 125.26, 75.43, 136.29, 69.13, 148.11, 72.28, 149.68, 83.31, 149.68, 101.43, 149.68, 110.88, 148.11, 120.34, 159.93, 136.09, 176.47, 178.64, 197.74, 210.94, 219.8, 232.99, 211.92, 250.33, 205.62, 250.33, 184.35, 221.97, 154.41, 198.33, 158.35, 225.9, 175.68, 261.36, 167.8, 297.6, 159.93, 313.35, 118.17, 340.14, 102.42, 335.41, 106.35, 325.96]], "area": 15389.807000000003, "iscrowd": 0, "image_id": 10445, "bbox": [94.54, 69.13, 125.26, 271.01], "category_id": 1, "id": 494678}, {"segmentation": [[152.71, 120.68, 146.37, 138.78, 141.39, 152.81, 127.82, 155.53, 123.75, 147.83, 128.72, 127.92, 132.8, 104.39, 139.13, 79.5, 139.58, 65.48, 146.82, 54.62, 155.87, 43.3, 167.64, 46.02, 171.71, 57.78, 178.5, 65.48, 179.86, 79.5, 185.74, 95.79, 190.27, 109.82, 197.05, 125.12, 199.77, 141.41, 203.84, 151.36, 193.43, 155.89, 186.65, 150.01, 184.38, 142.31, 182.12, 129.64, 173.07, 110.64, 171.71, 121.5, 167.64, 126.93, 159.04, 126.47, 153.61, 122.4]], "area": 4517.318650000001, "iscrowd": 0, "image_id": 10265, "bbox": [123.75, 43.3, 80.09, 112.59], "category_id": 1, "id": 495760}, {"segmentation": [[318.66, 256.63, 318.66, 235.59, 312.85, 231.99, 319.77, 209.3, 321.7, 206.81, 320.04, 195.73, 327.24, 197.12, 330.84, 210.13, 333.88, 222.58, 333.05, 233.66, 330.28, 256.63, 327.52, 255.25, 327.24, 253.86, 326.96, 248.33, 323.36, 238.64, 322.81, 242.51, 320.32, 249.43]], "area": 716.7143499999991, "iscrowd": 0, "image_id": 10281, "bbox": [312.85, 195.73, 21.03, 60.9], "category_id": 1, "id": 496819}, {"segmentation": [[116.78, 419.26, 115.82, 362.78, 100.51, 340.77, 98.59, 299.61, 96.68, 244.09, 93.81, 206.76, 89.02, 199.1, 88.06, 157.94, 114.86, 144.54, 124.44, 130.18, 117.74, 121.57, 111.04, 110.08, 110.08, 83.28, 127.31, 71.79, 155.07, 74.66, 158.9, 93.81, 154.11, 121.57, 161.77, 134.01, 194.31, 143.58, 206.76, 156.98, 214.41, 192.4, 213.46, 213.46, 226.86, 279.5, 217.29, 299.61, 211.54, 317.79, 218.24, 331.19, 224.94, 334.07, 236.43, 420.21]], "area": 36071.7022, "iscrowd": 0, "image_id": 10082, "bbox": [88.06, 71.79, 148.37, 348.42], "category_id": 1, "id": 510678}, {"segmentation": [[108.11, 470.72, 79.95, 470.72, 67.57, 459.46, 60.81, 441.44, 60.81, 423.42, 63.06, 405.41, 55.18, 364.86, 54.05, 319.82, 59.68, 299.55, 68.69, 293.92, 83.33, 286.04, 94.59, 282.66, 99.1, 275.9, 101.35, 268.02, 90.09, 264.64, 88.96, 252.25, 92.34, 233.11, 100.23, 227.48, 111.49, 226.35, 125.0, 225.23, 132.88, 228.6, 137.39, 233.11, 144.14, 233.11, 154.28, 239.86, 146.4, 250.0, 145.27, 253.38, 145.27, 256.76, 145.27, 264.64, 144.14, 275.9, 137.39, 284.91, 134.01, 287.16, 137.39, 297.3, 143.02, 305.18, 144.14, 314.19, 145.27, 325.45, 147.52, 334.46, 148.65, 343.47, 147.52, 356.98, 147.52, 367.12, 153.15, 372.75, 153.15, 389.64, 152.03, 420.05, 152.03, 426.8, 147.52, 429.05, 128.38, 432.43, 120.5, 433.56, 114.86, 440.32, 112.61, 454.95, 111.49, 461.71]], "area": 17834.80885, "iscrowd": 0, "image_id": 10094, "bbox": [54.05, 225.23, 100.23, 245.49], "category_id": 1, "id": 512541}, {"segmentation": [[460.49, 259.51, 464.64, 233.1, 467.65, 216.69, 470.86, 204.05, 475.39, 191.6, 495.2, 157.08, 499.35, 153.12, 513.68, 117.28, 527.64, 101.81, 520.66, 95.96, 509.72, 80.68, 508.02, 57.86, 520.47, 45.79, 536.32, 40.88, 555.56, 24.85, 573.86, 23.72, 605.36, 28.43, 634.41, 42.39, 625.92, 69.93, 620.07, 82.57, 616.11, 92.95, 636.29, 105.96, 638.75, 117.09, 640.0, 116.15, 639.31, 119.17, 639.5, 121.05, 639.5, 151.42, 639.88, 156.14, 639.31, 159.53, 639.31, 196.69, 639.12, 234.04, 638.37, 271.77, 637.8, 308.74, 637.99, 346.85, 637.99, 384.2, 637.8, 420.04, 638.18, 420.41, 638.75, 422.3, 565.74, 424.75, 535.19, 340.81, 533.68, 334.96, 529.53, 323.46, 526.89, 310.44, 526.51, 307.61, 526.7, 214.24, 520.28, 173.68, 504.25, 196.13, 489.73, 224.05, 480.48, 235.17, 477.09, 241.4, 485.95, 266.3, 489.73, 272.52, 480.86, 285.54, 476.33, 287.62, 470.86, 282.71, 466.71, 279.13, 464.45, 274.98, 460.68, 262.72, 459.92, 258.19]], "area": 46133.73725, "iscrowd": 0, "image_id": 10082, "bbox": [459.92, 23.72, 180.08, 401.03], "category_id": 1, "id": 513597}, {"segmentation": [[248.13, 191.51, 198.28, 180.68, 193.95, 163.34, 182.03, 135.17, 178.78, 114.58, 192.87, 116.75, 195.03, 130.84, 203.7, 149.26, 204.79, 163.34, 222.12, 163.34, 264.38, 162.26, 277.38, 154.67, 269.8, 133.0, 270.88, 108.08, 291.47, 99.41, 301.22, 100.5, 312.05, 114.58, 322.89, 127.58, 322.89, 135.17, 315.3, 140.59, 304.47, 153.59, 317.47, 162.26, 318.56, 173.09, 318.56, 241.35, 312.05, 271.69, 326.14, 298.78, 317.47, 337.79, 295.8, 347.54, 280.63, 357.29, 248.13, 364.88, 248.13, 306.37, 244.88, 252.19, 216.7, 251.11, 214.54, 235.94, 222.12, 230.52, 236.21, 232.69, 241.63, 232.69]], "area": 18701.789650000006, "iscrowd": 0, "image_id": 10176, "bbox": [178.78, 99.41, 147.36, 265.47], "category_id": 1, "id": 517372}, {"segmentation": [[388.71, 286.0, 387.65, 283.33, 387.65, 279.6, 391.38, 275.87, 392.44, 274.27, 390.85, 264.67, 388.18, 262.54, 381.25, 260.94, 379.12, 260.41, 370.59, 268.94, 370.05, 273.2, 370.59, 278.0, 372.19, 285.46, 380.72, 289.19, 386.58, 289.19]], "area": 478.05169999999976, "iscrowd": 0, "image_id": 10041, "bbox": [370.05, 260.41, 22.39, 28.78], "category_id": 1, "id": 517982}, {"segmentation": [[269.81, 264.37, 267.83, 266.72, 264.04, 268.34, 262.6, 266.17, 265.85, 264.37, 264.4, 254.63, 268.73, 250.48, 268.01, 249.94, 263.68, 251.57, 262.6, 250.48, 262.6, 247.78, 264.4, 247.06, 266.93, 246.7, 268.37, 240.21, 268.73, 238.4, 268.19, 234.8, 269.27, 231.91, 272.88, 232.09, 275.22, 235.34, 276.49, 241.65, 277.75, 247.42, 277.03, 253.37, 276.31, 253.91, 279.91, 265.63, 280.63, 267.98, 278.47, 269.96, 273.6, 268.88, 274.32, 265.45, 271.26, 255.35, 269.09, 257.52]], "area": 357.5469999999998, "iscrowd": 0, "image_id": 10041, "bbox": [262.6, 231.91, 18.03, 38.05], "category_id": 1, "id": 524873}, {"segmentation": [[517.75, 287.08, 512.36, 295.71, 511.28, 300.03, 520.99, 305.42, 520.99, 302.18, 519.91, 295.71, 520.99, 290.32]], "area": 105.34870000000001, "iscrowd": 0, "image_id": 10041, "bbox": [511.28, 287.08, 9.71, 18.34], "category_id": 1, "id": 539146}, {"segmentation": [[339.28, 107.36, 338.39, 101.58, 337.51, 94.93, 336.62, 90.49, 334.84, 86.93, 332.62, 85.16, 331.29, 79.39, 331.29, 71.4, 333.07, 66.07, 334.84, 59.86, 337.95, 56.75, 339.73, 54.97, 344.17, 53.2, 349.05, 55.42, 350.82, 57.19, 360.59, 61.19, 361.92, 67.4, 363.25, 72.73, 365.03, 79.39, 364.59, 82.5, 360.59, 88.71, 360.15, 97.15, 360.15, 104.25, 360.59, 111.35, 356.6, 110.91, 356.15, 114.9, 356.15, 116.23, 354.38, 118.9, 351.27, 119.79, 345.94, 120.23, 341.5, 120.23, 337.95, 118.01, 341.5, 115.79, 342.83, 112.24, 339.73, 110.02, 338.39, 103.8]], "area": 1577.0200999999993, "iscrowd": 0, "image_id": 10015, "bbox": [331.29, 53.2, 33.74, 67.03], "category_id": 1, "id": 543665}, {"segmentation": [[433.66, 119.73, 439.43, 109.97, 444.76, 92.65, 449.64, 82.0, 452.75, 77.12, 458.96, 67.35, 466.95, 69.57, 467.84, 75.34, 475.39, 81.11, 475.39, 94.43, 476.72, 103.75, 470.95, 111.74, 469.17, 130.83, 462.07, 131.27, 464.73, 110.41, 456.3, 131.27, 450.97, 136.6, 439.87, 128.61]], "area": 1763.46995, "iscrowd": 0, "image_id": 10015, "bbox": [433.66, 67.35, 43.06, 69.25], "category_id": 1, "id": 547297}, {"segmentation": [[278.99, 156.32, 279.22, 148.22, 279.22, 142.9, 279.91, 136.89, 283.84, 135.5, 290.09, 135.73, 293.56, 139.66, 294.48, 145.45, 293.33, 148.68, 292.17, 154.47, 289.16, 157.47, 285.23, 159.79, 282.69, 185.23, 288.47, 209.51, 286.85, 215.99, 283.15, 233.8, 285.23, 237.26, 288.01, 240.73, 288.24, 244.67, 283.84, 243.74, 280.84, 240.5, 277.14, 236.34, 280.84, 221.07, 282.22, 211.13, 280.61, 209.05, 277.83, 209.74, 271.59, 218.53, 265.57, 228.94, 264.88, 232.41, 266.73, 236.57, 271.35, 240.97, 269.04, 243.51, 264.65, 243.51, 263.49, 239.11, 257.94, 234.72, 262.33, 223.85, 271.82, 205.58, 268.35, 186.15, 268.35, 174.59, 272.74, 161.87]], "area": 1468.7433500000006, "iscrowd": 0, "image_id": 10097, "bbox": [257.94, 135.5, 36.54, 109.17], "category_id": 1, "id": 553770}, {"segmentation": [[323.37, 245.64, 349.28, 300.34, 355.99, 319.53, 362.71, 365.59, 361.75, 389.58, 333.92, 384.78, 311.85, 408.77, 307.06, 412.61, 301.3, 420.28, 396.29, 417.4, 408.77, 389.58, 421.24, 357.91, 430.84, 345.44, 443.31, 338.72, 451.95, 330.09, 454.83, 327.21, 473.06, 316.65, 508.56, 282.11, 526.79, 274.43, 540.23, 282.11, 535.43, 291.7, 518.16, 304.18, 512.4, 312.81, 498.97, 326.25, 473.06, 335.84, 465.38, 344.48, 460.58, 353.11, 458.67, 362.71, 466.34, 357.91, 490.33, 394.38, 496.09, 410.69, 496.09, 414.53, 498.01, 421.24, 553.66, 419.32, 526.79, 360.79, 522.96, 331.04, 519.12, 317.61, 542.15, 294.58, 545.98, 269.63, 525.83, 261.96, 506.64, 279.23, 497.05, 288.82, 481.69, 288.82, 479.78, 280.19, 479.78, 267.71, 464.42, 217.82, 458.67, 195.75, 452.91, 188.07, 432.76, 174.64, 399.17, 164.08, 383.82, 171.76, 374.22, 168.88, 372.31, 139.13, 354.07, 125.7, 333.92, 122.82, 322.41, 122.82, 294.58, 127.62, 279.23, 131.46, 271.55, 157.37, 276.35, 166.96, 257.16, 192.87, 291.7, 204.38, 300.34, 206.3, 306.1, 204.38, 323.37, 219.74, 330.09, 223.58]], "area": 40378.679449999996, "iscrowd": 0, "image_id": 10319, "bbox": [257.16, 122.82, 296.5, 298.42], "category_id": 1, "id": 555865}, {"segmentation": [[596.59, 184.11, 599.22, 184.11, 605.15, 183.13, 605.81, 179.17, 605.81, 173.91, 603.5, 168.64, 603.17, 167.65, 601.53, 167.32, 600.21, 169.63, 597.57, 170.61, 595.93, 173.91, 595.27, 178.19, 595.27, 182.14, 595.27, 182.8, 596.26, 183.78]], "area": 138.78214999999966, "iscrowd": 0, "image_id": 10230, "bbox": [595.27, 167.32, 10.54, 16.79], "category_id": 1, "id": 557247}, {"segmentation": [[488.48, 426.12, 640.0, 426.78, 638.58, 136.08, 571.26, 146.66, 569.33, 163.97, 563.56, 182.24, 557.79, 197.63, 552.02, 208.21, 559.72, 214.94, 560.68, 232.25, 563.56, 238.02, 551.06, 254.37, 527.02, 300.53, 500.09, 330.35, 474.12, 351.51, 471.24, 378.43]], "area": 32442.68595000003, "iscrowd": 0, "image_id": 10275, "bbox": [471.24, 136.08, 168.76, 290.7], "category_id": 1, "id": 558741}, {"segmentation": [[575.76, 170.1, 577.24, 169.69, 578.59, 171.18, 577.78, 173.21, 578.59, 174.56, 580.62, 175.91, 580.62, 178.34, 579.68, 180.64, 579.54, 182.13, 579.68, 184.15, 580.49, 185.64, 579.95, 186.18, 574.14, 185.64, 573.32, 185.37, 573.73, 182.67, 574.0, 180.64, 574.0, 179.69, 572.92, 178.21, 571.97, 176.18, 572.38, 175.1, 574.0, 176.18, 574.95, 176.32, 575.62, 175.37, 575.76, 174.02, 574.68, 173.07, 574.68, 171.86, 574.95, 171.59, 575.08, 170.5, 575.89, 170.23]], "area": 86.52359999999979, "iscrowd": 0, "image_id": 10230, "bbox": [571.97, 169.69, 8.65, 16.49], "category_id": 1, "id": 562518}, {"segmentation": [[299.79, 199.37, 303.09, 201.39, 302.84, 204.94, 303.6, 207.23, 306.13, 208.49, 307.91, 213.82, 309.68, 219.14, 310.44, 223.2, 309.43, 227.0, 308.16, 223.2, 306.64, 220.16, 304.86, 225.99, 299.79, 233.09, 301.82, 240.19, 302.58, 242.47, 301.31, 240.7, 298.52, 237.4, 298.52, 239.94, 298.27, 244.25, 296.75, 241.46, 297.26, 235.37, 297.0, 229.79, 295.74, 226.5, 293.2, 221.68, 292.69, 214.07, 295.23, 209.76, 297.0, 206.97, 295.99, 204.94, 296.24, 200.89, 298.02, 199.11]], "area": 378.77840000000015, "iscrowd": 0, "image_id": 10281, "bbox": [292.69, 199.11, 17.75, 45.14], "category_id": 1, "id": 562916}, {"segmentation": [[385.89, 71.24, 376.18, 78.53, 379.42, 87.42, 410.97, 93.9, 411.78, 100.37, 404.49, 106.84, 410.16, 116.55, 455.46, 77.72, 447.37, 66.39, 446.56, 53.45, 440.09, 33.22, 418.25, 37.27, 412.58, 19.47, 462.74, 7.33, 334.92, 1.67, 354.34, 28.37, 349.48, 43.74, 383.46, 65.58, 383.46, 65.58]], "area": 7153.5055999999995, "iscrowd": 0, "image_id": 10097, "bbox": [334.92, 1.67, 127.82, 114.88], "category_id": 1, "id": 568316}, {"segmentation": [[102.17, 202.27, 100.08, 201.02, 99.66, 200.18, 98.82, 196.41, 98.82, 194.32, 102.59, 189.71, 104.26, 188.88, 108.45, 190.55, 110.12, 191.81, 112.63, 198.09, 114.31, 203.95, 116.82, 209.81, 118.08, 214.83, 119.75, 218.18, 120.17, 224.88, 119.75, 227.39, 117.66, 229.06, 113.05, 233.25, 111.38, 235.76, 108.45, 238.27, 107.19, 237.85, 105.94, 236.18, 105.52, 232.41, 106.36, 224.04, 107.61, 218.6, 107.19, 213.57, 104.26, 208.55, 104.26, 206.88, 102.59, 203.11, 102.59, 203.11], [87.94, 240.36, 87.52, 244.97, 88.36, 251.25, 88.36, 257.53, 88.36, 264.64, 87.94, 269.67, 86.68, 275.53, 87.1, 281.81, 87.52, 286.83, 87.52, 289.34, 89.61, 290.18, 91.7, 289.76, 91.7, 283.48, 90.87, 276.78, 90.87, 272.18, 92.12, 265.9, 92.54, 259.2, 94.63, 255.43, 95.47, 254.18, 100.49, 254.18, 102.17, 259.2, 102.59, 265.06, 102.59, 270.5, 102.59, 275.11, 102.59, 280.13, 103.84, 285.16, 103.84, 285.57, 105.52, 288.09, 106.36, 288.09, 106.77, 281.81, 106.36, 273.85, 105.94, 268.41, 106.36, 262.97, 108.45, 259.2, 105.94, 256.69, 102.59, 253.76, 98.82, 250.41, 94.22, 246.23, 92.12, 242.88, 90.45, 241.62, 89.19, 240.78, 88.77, 240.36]], "area": 924.13265, "iscrowd": 0, "image_id": 10281, "bbox": [86.68, 188.88, 33.49, 101.3], "category_id": 1, "id": 568876}, {"segmentation": [[4.31, 262.95, 117.93, 218.37, 165.39, 363.63, 133.75, 435.54, 4.31, 493.06], [346.61, 152.21, 381.12, 145.02, 427.0, 293.15, 422.83, 366.5, 375.37, 372.25, 399.82, 343.49, 404.13, 324.79, 343.73, 255.76, 312.09, 212.61, 333.66, 152.21]], "area": 44159.2518, "iscrowd": 0, "image_id": 10069, "bbox": [4.31, 145.02, 422.69, 348.04], "category_id": 15, "id": 575240}, {"segmentation": [[100.14, 313.5, 112.24, 281.48, 118.64, 260.84, 125.05, 240.2, 130.03, 218.14, 137.15, 203.2, 144.26, 191.81, 155.65, 185.41, 173.44, 183.98, 181.27, 183.98, 195.5, 188.25, 204.04, 193.24, 211.16, 195.37, 218.27, 186.83, 222.54, 186.83, 228.24, 186.83, 230.37, 180.43, 227.53, 173.31, 228.24, 167.62, 232.51, 160.5, 236.78, 155.52, 223.26, 124.92, 246.74, 142.71, 255.99, 122.07, 268.8, 146.27, 294.42, 125.63, 295.84, 137.73, 284.46, 155.52, 282.32, 169.04, 286.59, 181.14, 288.02, 191.1, 285.17, 204.62, 284.46, 218.86, 280.19, 228.82, 273.07, 232.38, 275.92, 240.92, 274.49, 251.59, 273.07, 262.27, 272.36, 275.08, 269.51, 290.02, 265.24, 293.58, 263.82, 307.81, 258.13, 316.35, 250.3, 327.74, 249.59, 342.68, 247.45, 353.36, 246.03, 362.61, 242.47, 370.44, 242.47, 384.67, 248.87, 403.17, 248.16, 411.0, 240.34, 411.71, 233.93, 415.27, 233.93, 413.13, 231.8, 413.13, 233.22, 407.44, 233.22, 401.04, 231.8, 401.75, 227.53, 397.48, 229.66, 387.51, 231.08, 378.26, 231.08, 365.45, 231.8, 349.09, 232.51, 332.72, 232.51, 321.33, 233.22, 310.66, 233.22, 306.39, 229.66, 305.68, 222.54, 305.68, 217.56, 305.68, 209.73, 312.79, 216.85, 317.06, 216.85, 331.29, 220.41, 339.83, 220.41, 356.91, 217.56, 365.45, 210.45, 369.72, 209.02, 381.11, 209.02, 390.36, 209.02, 399.61, 209.02, 409.58, 208.31, 414.56, 199.06, 415.27, 194.79, 414.56, 194.79, 410.29, 197.64, 402.46, 197.64, 396.05, 200.48, 381.82, 201.91, 372.57, 202.62, 364.03, 202.62, 351.93, 201.19, 344.1, 200.48, 329.87, 199.06, 319.91, 195.5, 315.64, 188.39, 320.62, 184.83, 327.03, 181.27, 336.99, 175.58, 351.22, 174.15, 369.01, 174.15, 373.99, 175.58, 383.25, 178.42, 393.92, 177.71, 400.32, 167.75, 400.32, 163.48, 398.9, 160.63, 389.65, 164.19, 381.11, 164.19, 369.01, 164.19, 359.76, 161.34, 350.51, 159.21, 345.53, 156.36, 348.37, 154.94, 354.78, 154.94, 370.44, 154.94, 376.84, 154.94, 388.23, 153.51, 398.19, 147.11, 398.19, 141.42, 396.77, 139.28, 388.94, 144.97, 369.72, 144.97, 359.76, 145.69, 346.95, 144.26, 324.89, 142.13, 317.06, 135.72, 306.39, 134.3, 290.73, 132.88, 286.46, 127.9, 292.87, 125.05, 300.69, 117.93, 308.52, 110.1, 319.2, 104.41, 326.31, 99.43, 329.16, 97.29, 329.16, 95.87, 326.31, 95.87, 322.04, 98.72, 314.93]], "area": 27745.74895, "iscrowd": 0, "image_id": 10327, "bbox": [95.87, 122.07, 199.97, 293.2], "category_id": 24, "id": 589704}, {"segmentation": [[524.66, 369.13, 362.62, 437.13, 271.96, 476.79, 261.77, 466.59, 261.77, 456.39, 265.16, 454.12, 522.4, 358.94]], "area": 4615.889149999999, "iscrowd": 0, "image_id": 10179, "bbox": [261.77, 358.94, 262.89, 117.85], "category_id": 39, "id": 629190}, {"segmentation": [[531.1, 287.0, 471.34, 338.08, 391.34, 421.94, 391.34, 416.16, 410.61, 386.28, 417.36, 359.29, 432.78, 343.87, 443.39, 334.23, 472.3, 317.84, 521.46, 271.57]], "area": 3206.021099999997, "iscrowd": 0, "image_id": 10319, "bbox": [391.34, 271.57, 139.76, 150.37], "category_id": 39, "id": 629220}, {"segmentation": [[14.74, 285.71, 29.48, 292.52, 32.88, 270.98, 150.79, 52.15, 165.53, 29.48, 159.86, 15.87, 154.2, 15.87, 145.12, 15.87, 79.37, 142.86, 24.94, 272.11, 13.61, 276.64, 23.81, 285.71]], "area": 5165.0255499999985, "iscrowd": 0, "image_id": 10094, "bbox": [13.61, 15.87, 151.92, 276.65], "category_id": 39, "id": 630078}, {"segmentation": [[404.4, 377.88, 412.73, 392.19, 418.71, 399.66, 420.42, 406.07, 420.42, 410.34, 426.82, 415.68, 428.96, 423.36, 429.6, 430.84, 427.68, 459.24, 425.12, 467.14, 420.63, 474.4, 415.72, 480.0, 402.05, 478.03, 396.29, 476.96, 395.22, 471.62, 391.17, 439.81, 388.82, 427.63, 383.48, 408.63, 382.84, 400.3, 378.99, 393.04, 374.94, 389.84, 376.22, 387.28, 379.42, 383.22, 384.12, 383.86, 387.11, 379.59, 391.59, 380.02, 394.8, 379.59, 401.41, 378.74]], "area": 3461.586549999999, "iscrowd": 0, "image_id": 10230, "bbox": [374.94, 377.88, 54.66, 102.12], "category_id": 40, "id": 632755}, {"segmentation": [[119.33, 259.57, 134.81, 267.07, 138.56, 280.21, 150.29, 291.0, 150.76, 297.57, 143.25, 302.73, 142.31, 307.89, 130.59, 317.74, 122.14, 319.15, 110.41, 300.85, 107.13, 271.77]], "area": 1641.5885500000006, "iscrowd": 0, "image_id": 10309, "bbox": [107.13, 259.57, 43.63, 59.58], "category_id": 40, "id": 633523}, {"segmentation": [[188.05, 371.31, 147.76, 317.58, 131.45, 294.55, 127.61, 269.61, 135.28, 262.89, 148.72, 265.77, 156.39, 276.32, 159.27, 285.92, 166.95, 295.51, 175.58, 302.23, 192.85, 319.5, 211.08, 345.41, 214.92, 360.76, 203.41, 374.19, 192.85, 373.23]], "area": 3835.3549000000003, "iscrowd": 0, "image_id": 10434, "bbox": [127.61, 262.89, 87.31, 111.3], "category_id": 41, "id": 640137}, {"segmentation": [[447.15, 247.16, 427.28, 234.83, 415.64, 216.34, 376.59, 169.07, 349.19, 135.51, 329.33, 103.31, 319.74, 99.89, 323.16, 114.27, 338.23, 138.25, 332.75, 147.84, 327.27, 147.84, 327.27, 154.69, 343.03, 157.43, 347.82, 153.32, 403.31, 215.65, 395.77, 223.87, 392.35, 232.78, 406.05, 236.89, 414.27, 231.41, 422.49, 233.46, 441.67, 247.85]], "area": 2244.4401999999986, "iscrowd": 0, "image_id": 10097, "bbox": [319.74, 99.89, 127.41, 147.96], "category_id": 41, "id": 640727}, {"segmentation": [[206.1, 489.98, 214.1, 491.07, 226.47, 491.8, 249.75, 495.8, 277.03, 500.16, 289.76, 500.89, 300.67, 504.53, 309.77, 504.53, 314.5, 505.26, 314.5, 507.8, 301.04, 510.71, 280.67, 515.08, 276.66, 519.08, 275.94, 521.62, 283.94, 524.17, 287.21, 520.9, 295.22, 520.17, 297.76, 524.53, 297.76, 530.35, 295.58, 535.08, 287.21, 536.9, 282.48, 531.45, 261.75, 533.63, 258.84, 533.63, 257.75, 539.45, 247.93, 540.18, 245.75, 537.99, 245.38, 531.08, 251.93, 528.54, 253.38, 525.99, 253.75, 523.08, 252.66, 520.17, 221.74, 511.8, 216.65, 512.17, 217.01, 514.71, 214.1, 517.62, 207.55, 519.81, 203.55, 516.17, 190.82, 517.62, 182.45, 520.17, 178.82, 520.17, 178.45, 523.81, 171.18, 526.72, 167.54, 524.9, 164.63, 521.62, 163.54, 517.62, 163.9, 514.35, 168.27, 511.8, 174.81, 510.71, 179.18, 513.26, 186.45, 507.07, 184.64, 505.26, 170.09, 503.8, 159.9, 503.07, 159.54, 501.62, 166.08, 499.8, 174.45, 499.8, 189.36, 501.62, 199.55, 499.07, 203.19, 495.8, 204.28, 492.89]], "area": 3365.407199999999, "iscrowd": 0, "image_id": 10313, "bbox": [159.54, 489.98, 154.96, 50.2], "category_id": 41, "id": 642768}, {"segmentation": [[196.85, 175.44, 218.03, 154.26, 243.91, 142.5, 268.22, 132.3, 304.3, 119.75, 346.65, 107.99, 349.0, 121.32, 354.49, 138.58, 366.25, 170.73, 374.88, 185.63, 370.96, 195.04, 369.39, 210.73, 330.96, 215.43, 272.93, 220.14, 254.89, 217.79, 223.52, 214.65, 215.67, 213.87, 213.32, 215.43, 210.18, 209.94, 202.34, 204.45], [366.25, 105.64, 421.15, 94.66, 456.44, 91.52, 473.7, 91.52, 499.58, 91.52, 499.58, 173.87, 491.74, 179.36, 416.45, 201.32, 389.0, 206.02, 392.13, 197.4, 385.08, 185.63, 380.37, 154.26, 371.74, 133.87, 364.69, 119.75]], "area": 25820.562449999998, "iscrowd": 0, "image_id": 10445, "bbox": [196.85, 91.52, 302.73, 128.62], "category_id": 42, "id": 648995}, {"segmentation": [[167.62, 136.07, 249.3, 140.71, 220.08, 154.66, 203.48, 169.27, 200.82, 179.23, 200.82, 217.08, 175.59, 186.54, 160.98, 143.37], [11.56, 185.87, 99.22, 157.32, 109.84, 192.51, 103.87, 206.46, 103.87, 219.74, 103.87, 237.67, 103.87, 247.63, 1.6, 265.56, 1.6, 199.82]], "area": 11350.24745, "iscrowd": 0, "image_id": 10445, "bbox": [1.6, 136.07, 247.7, 129.49], "category_id": 42, "id": 650370}, {"segmentation": [[232.66, 213.26, 303.87, 228.91, 328.91, 228.91, 310.91, 232.82, 328.13, 242.99, 333.6, 247.69, 337.91, 252.38, 337.91, 258.25, 337.91, 259.82, 338.69, 267.25, 357.47, 265.69, 353.56, 269.21, 339.08, 270.38, 337.13, 282.51, 325.0, 297.38, 310.13, 309.51, 330.47, 311.46, 320.69, 313.81, 302.69, 316.16, 192.36, 356.85, 189.23, 350.59, 204.88, 324.77, 224.44, 301.29, 229.14, 264.91], [145.02, 212.48, 189.23, 211.69, 188.45, 240.26, 191.97, 269.6, 191.97, 289.95, 191.97, 296.21, 189.23, 302.07, 182.97, 307.16, 190.79, 319.68, 187.66, 327.51, 182.58, 331.03, 170.06, 337.29, 150.89, 351.37, 153.63, 354.89, 167.71, 352.16, 165.75, 361.94, 82.81, 366.24, 2.6, 363.89, 0.64, 271.17, 0.25, 232.43, 48.38, 221.87, 126.63, 211.69]], "area": 38347.61120000001, "iscrowd": 0, "image_id": 10005, "bbox": [0.25, 211.69, 357.22, 154.55], "category_id": 42, "id": 651079}, {"segmentation": [[267.86, 124.68, 293.26, 117.86, 295.74, 111.67, 296.98, 119.72, 308.13, 117.24, 314.95, 121.58, 300.69, 135.21, 277.15, 150.08, 260.42, 151.94, 254.22, 156.28, 239.97, 163.09, 213.95, 168.67, 210.85, 170.53, 227.58, 146.98, 249.89, 132.73, 256.7, 129.02, 245.55, 147.6, 246.79, 152.56, 246.17, 154.42, 246.79, 157.52, 249.89, 154.42, 252.36, 147.6, 264.14, 130.26]], "area": 1864.1982000000003, "iscrowd": 0, "image_id": 10005, "bbox": [210.85, 111.67, 104.1, 58.86], "category_id": 42, "id": 653611}, {"segmentation": [[313.53, 277.59, 316.54, 275.92, 316.54, 272.57, 313.03, 271.9, 312.36, 274.25, 311.86, 276.25], [308.34, 274.75, 296.63, 279.43, 288.77, 281.94, 287.77, 282.94, 282.41, 284.78, 277.73, 286.12, 273.21, 287.8, 268.7, 289.3, 263.68, 291.98, 261.0, 293.99, 260.83, 297.5, 263.85, 299.0, 271.21, 296.5, 276.89, 294.66, 285.93, 289.97, 289.44, 288.3, 303.33, 281.27, 308.34, 278.93, 310.02, 278.26, 308.85, 275.42, 308.51, 274.75]], "area": 327.01220000000023, "iscrowd": 0, "image_id": 10265, "bbox": [260.83, 271.9, 55.71, 27.1], "category_id": 43, "id": 657811}, {"segmentation": [[302.59, 348.59, 307.53, 345.98, 315.17, 345.61, 320.56, 346.28, 323.26, 348.04, 322.32, 368.96, 319.54, 375.46, 317.87, 373.52, 313.17, 376.68, 308.88, 375.6, 305.87, 371.5, 304.79, 368.53, 303.71, 368.26, 303.27, 365.77, 304.81, 366.12, 304.0, 363.68, 303.05, 355.78, 301.28, 356.8, 300.07, 359.5, 300.6, 362.21, 298.05, 361.25, 297.37, 357.2, 299.39, 353.43, 302.8, 353.04]], "area": 562.2471999999997, "iscrowd": 0, "image_id": 10176, "bbox": [297.37, 345.61, 25.89, 31.07], "category_id": 47, "id": 672620}, {"segmentation": [[267.86, 401.94, 267.86, 365.35, 272.16, 362.77, 284.21, 359.76, 297.12, 360.19, 304.01, 364.49, 304.01, 380.85, 303.15, 403.66, 288.09, 405.81, 276.46, 404.52]], "area": 1549.9942499999993, "iscrowd": 0, "image_id": 10176, "bbox": [267.86, 359.76, 36.15, 46.05], "category_id": 47, "id": 673100}, {"segmentation": [[95.96, 170.8, 76.76, 89.24, 75.8, 82.52, 90.2, 65.25, 125.7, 59.49, 161.2, 54.69, 181.36, 55.65, 192.87, 65.25, 193.83, 122.82, 153.53, 136.26, 111.31, 165.04]], "area": 9534.2515, "iscrowd": 0, "image_id": 10161, "bbox": [75.8, 54.69, 118.03, 116.11], "category_id": 47, "id": 682193}, {"segmentation": [[630.25, 460.57, 608.12, 441.6, 577.56, 440.54, 502.73, 415.25, 491.13, 422.63, 467.95, 418.41, 448.98, 407.87, 431.06, 399.44, 422.63, 402.6, 411.03, 412.09, 392.06, 416.3, 377.31, 415.25, 418.41, 442.65, 442.65, 447.92, 462.68, 442.65, 464.78, 452.14, 501.67, 446.87, 522.75, 448.98, 525.91, 462.68, 556.48, 462.68, 613.39, 461.62]], "area": 6711.333399999998, "iscrowd": 0, "image_id": 10073, "bbox": [377.31, 399.44, 252.94, 63.24], "category_id": 48, "id": 687353}, {"segmentation": [[0.0, 401.63, 29.43, 371.62, 65.26, 346.62, 87.76, 332.46, 97.35, 321.62, 119.85, 287.45, 98.6, 328.29, 126.93, 285.79, 104.43, 328.71, 134.43, 282.45, 108.18, 328.29, 138.18, 286.2, 113.6, 336.62, 100.68, 344.54, 86.93, 345.79, 61.51, 354.96, 44.43, 366.62, 0.68, 413.71]], "area": 1731.0175499999993, "iscrowd": 0, "image_id": 10037, "bbox": [0.0, 282.45, 138.18, 131.26], "category_id": 48, "id": 688032}, {"segmentation": [[172.89, 304.0, 194.36, 257.82, 244.83, 195.54, 258.79, 172.99, 259.87, 188.02, 265.23, 190.17, 259.87, 203.06, 213.69, 280.37, 181.48, 310.44, 173.96, 311.51]], "area": 3146.568699999999, "iscrowd": 0, "image_id": 10175, "bbox": [172.89, 172.99, 92.34, 138.52], "category_id": 49, "id": 695357}, {"segmentation": [[224.66, 206.06, 237.05, 201.93, 242.84, 208.13, 247.79, 204.0, 252.34, 192.02, 258.95, 178.79, 260.19, 170.53, 253.99, 170.12, 248.62, 173.42, 244.49, 177.14, 238.29, 184.99, 237.05, 189.54, 233.75, 194.08, 223.83, 197.39]], "area": 613.3241, "iscrowd": 0, "image_id": 10243, "bbox": [223.83, 170.12, 36.36, 38.01], "category_id": 50, "id": 705953}, {"segmentation": [[464.64, 93.46, 507.59, 69.87, 539.28, 66.7, 550.9, 79.02, 546.67, 91.34, 529.42, 105.43, 505.48, 118.45, 485.76, 123.38]], "area": 2893.47385, "iscrowd": 0, "image_id": 10161, "bbox": [464.64, 66.7, 86.26, 56.68], "category_id": 50, "id": 706795}, {"segmentation": [[273.09, 319.8, 275.92, 283.08, 290.04, 253.88, 317.35, 226.57, 350.31, 212.45, 384.22, 212.45, 408.7, 217.16, 434.13, 230.34, 457.67, 246.35, 484.04, 295.32, 484.04, 334.87, 468.97, 378.19, 448.25, 399.85, 421.88, 414.91, 409.64, 419.62, 361.61, 419.62, 341.84, 417.74, 308.88, 400.79, 288.16, 368.77, 277.8, 349.0]], "area": 35125.34070000001, "iscrowd": 0, "image_id": 10414, "bbox": [273.09, 212.45, 210.95, 207.17], "category_id": 51, "id": 711288}, {"segmentation": [[4.23, 401.92, 83.45, 377.63, 114.08, 349.11, 172.18, 306.86, 188.02, 273.06, 195.42, 235.03, 204.92, 224.47, 201.75, 191.72, 193.3, 175.88, 183.8, 156.86, 151.05, 142.07, 111.97, 128.34, 83.45, 123.06, 52.82, 120.95, 26.41, 122.0, 8.45, 124.12, 1.06, 124.12, 5.28, 399.81]], "area": 42774.42295, "iscrowd": 0, "image_id": 10073, "bbox": [1.06, 120.95, 203.86, 280.97], "category_id": 51, "id": 711574}, {"segmentation": [[243.51, 216.13, 260.49, 250.11, 269.93, 294.47, 264.27, 340.72, 239.73, 381.3, 187.82, 412.45, 119.87, 414.34, 50.02, 365.26, 36.81, 315.24, 49.08, 246.34, 74.56, 213.3, 126.47, 186.88, 184.04, 182.16, 229.35, 206.7]], "area": 42428.327000000005, "iscrowd": 0, "image_id": 10414, "bbox": [36.81, 182.16, 233.12, 232.18], "category_id": 51, "id": 712204}, {"segmentation": [[568.64, 420.26, 532.26, 389.62, 509.29, 358.99, 494.93, 316.87, 488.22, 283.36, 488.22, 262.3, 494.93, 242.2, 511.2, 218.27, 538.0, 201.03, 577.25, 188.59, 640.0, 189.55, 640.0, 393.45, 640.0, 418.34]], "area": 29549.62155, "iscrowd": 0, "image_id": 10037, "bbox": [488.22, 188.59, 151.78, 231.67], "category_id": 51, "id": 713175}, {"segmentation": [[0.0, 361.56, 24.12, 354.98, 49.53, 349.8, 72.59, 346.98, 92.82, 348.86, 102.23, 353.09, 106.47, 361.56, 103.17, 371.92, 99.88, 373.33, 97.53, 400.62, 91.41, 421.33, 84.35, 437.33, 63.18, 457.56, 36.35, 470.26, 16.12, 476.38, 0.59, 477.32]], "area": 10553.405899999998, "iscrowd": 0, "image_id": 10175, "bbox": [0.0, 346.98, 106.47, 130.34], "category_id": 51, "id": 714821}, {"segmentation": [[90.2, 178.18, 146.81, 141.72, 223.58, 111.97, 309.93, 101.42, 387.66, 101.42, 455.79, 115.81, 505.68, 133.08, 560.38, 171.47, 582.45, 224.24, 571.89, 264.54, 535.43, 319.24, 413.57, 375.85, 386.7, 392.16, 326.25, 400.8, 294.58, 400.8, 243.73, 388.32, 189.99, 369.13, 116.11, 340.35, 71.01, 298.13, 55.65, 251.11, 71.01, 197.37]], "area": 118552.32175000003, "iscrowd": 0, "image_id": 10161, "bbox": [55.65, 101.42, 526.8, 299.38], "category_id": 51, "id": 715642}, {"segmentation": [[337.93, 362.82, 341.76, 332.18, 323.57, 332.18, 278.58, 342.71, 214.44, 394.41, 205.82, 426.0, 278.58, 424.09, 289.11, 381.01, 296.76, 363.78, 329.31, 361.86], [422.17, 358.03, 413.56, 376.22, 427.91, 382.92, 446.1, 397.28, 457.59, 425.04, 479.61, 426.0, 456.63, 382.92, 432.7, 363.78]], "area": 7325.5190999999995, "iscrowd": 0, "image_id": 10037, "bbox": [205.82, 332.18, 273.79, 93.82], "category_id": 51, "id": 716143}, {"segmentation": [[215.9, 83.79, 222.14, 63.74, 240.85, 38.8, 260.0, 25.43, 283.16, 16.08, 301.87, 9.84, 329.94, 7.61, 355.77, 12.51, 381.61, 20.98, 401.66, 32.56, 421.26, 49.04, 437.29, 72.21, 444.42, 88.69, 446.65, 106.51, 441.3, 134.12, 434.17, 149.27, 425.71, 160.4, 415.46, 182.68, 408.34, 198.71, 395.86, 214.75, 388.74, 212.97, 369.14, 212.97, 353.99, 212.97, 339.29, 216.53, 325.04, 223.21, 317.91, 228.11, 307.22, 236.13, 305.88, 237.91, 289.85, 233.01, 266.68, 222.77, 241.29, 203.17, 227.48, 182.68, 222.14, 167.09, 219.47, 152.83, 218.13, 136.8, 217.68, 121.65, 214.57, 99.38, 216.35, 83.79]], "area": 40444.323, "iscrowd": 0, "image_id": 10414, "bbox": [214.57, 7.61, 232.08, 230.3], "category_id": 51, "id": 717212}, {"segmentation": [[80.04, 183.63, 108.3, 184.57, 128.07, 182.69, 147.85, 182.69, 166.68, 177.04, 183.63, 168.57, 199.64, 152.56, 217.53, 126.19, 219.42, 109.24, 223.18, 75.34, 221.3, 39.55, 158.21, 10.36, 112.06, 6.59, 91.35, 9.42, 75.34, 15.07, 52.74, 28.25, 36.73, 44.26, 16.01, 80.04, 14.13, 103.59, 17.89, 118.65, 19.78, 133.72, 23.54, 145.02, 38.61, 166.68, 48.97, 173.27, 61.21, 178.92, 71.57, 183.63, 82.87, 186.46]], "area": 30321.100100000003, "iscrowd": 0, "image_id": 10414, "bbox": [14.13, 6.59, 209.05, 179.87], "category_id": 51, "id": 717404}, {"segmentation": [[112.56, 113.54, 37.2, 103.76, 11.75, 98.86, 1.96, 126.27, 0.98, 176.19, 76.35, 180.1, 103.76, 185.0, 134.1, 174.23, 121.37, 144.87, 124.31, 141.93]], "area": 8753.221249999997, "iscrowd": 0, "image_id": 10403, "bbox": [0.98, 98.86, 133.12, 86.14], "category_id": 52, "id": 1044227}, {"segmentation": [[24.17, 223.98, 54.33, 205.64, 131.22, 172.52, 156.07, 193.22, 183.86, 200.32, 153.11, 209.78, 72.67, 242.9, 43.1, 257.69, 22.4, 257.69, 16.48, 254.73, 14.12, 250.59, 12.93, 244.68, 17.66, 233.44]], "area": 6005.9652000000015, "iscrowd": 0, "image_id": 10403, "bbox": [12.93, 172.52, 170.93, 85.17], "category_id": 52, "id": 1044732}, {"segmentation": [[179.49, 307.23, 189.4, 329.25, 201.52, 342.47, 254.37, 356.78, 352.38, 367.79, 437.17, 334.76, 475.71, 300.62, 514.25, 289.61, 546.18, 276.4, 549.49, 312.73, 527.46, 357.88, 480.11, 398.63, 414.04, 432.76, 322.64, 456.99, 236.75, 444.88, 188.3, 428.36, 155.27, 394.22, 147.56, 372.2, 150.86, 335.86, 155.27, 314.94, 145.36, 308.33, 137.65, 292.91, 177.29, 295.12, 186.1, 311.63]], "area": 35745.71755, "iscrowd": 0, "image_id": 10303, "bbox": [137.65, 276.4, 411.84, 180.59], "category_id": 52, "id": 1045120}, {"segmentation": [[106.69, 112.56, 99.84, 112.56, 70.48, 107.67, 51.88, 103.76, 39.15, 102.78, 33.28, 102.78, 26.43, 98.86, 22.51, 97.88, 25.45, 91.03, 26.43, 90.05, 37.2, 69.5, 46.98, 64.6, 55.79, 61.67, 66.56, 61.67, 76.35, 60.69, 85.16, 60.69, 92.99, 60.69, 108.65, 62.64, 117.46, 65.58, 133.12, 70.48, 142.91, 75.37, 157.59, 82.22, 174.23, 90.05, 177.17, 91.03, 193.81, 99.84, 209.47, 109.63, 219.26, 114.52, 207.51, 112.56, 191.85, 105.71, 181.08, 102.78, 166.4, 93.97, 151.72, 91.03, 138.01, 91.03, 125.29, 93.97, 115.5, 98.86, 113.54, 105.71, 112.56, 112.56, 109.63, 114.52]], "area": 5072.884500000001, "iscrowd": 0, "image_id": 10403, "bbox": [22.51, 60.69, 196.75, 53.83], "category_id": 52, "id": 1045315}, {"segmentation": [[254.49, 171.97, 248.62, 170.02, 244.71, 160.23, 238.83, 138.69, 231.0, 122.05, 220.24, 115.2, 201.64, 109.33, 186.96, 108.35, 173.25, 103.46, 161.51, 99.54, 148.78, 92.69, 133.12, 92.69, 121.37, 96.6, 111.59, 110.31, 115.5, 121.08, 129.2, 135.76, 129.2, 148.48, 123.33, 163.16, 139.97, 177.85, 151.72, 184.7, 158.57, 191.55, 166.4, 197.42, 185.98, 200.36, 202.62, 201.34, 216.32, 203.3, 222.19, 206.23, 223.17, 211.13, 220.24, 216.02, 156.61, 261.05, 156.61, 261.05, 154.65, 265.94, 154.65, 271.81, 157.59, 278.67, 160.53, 286.5, 162.48, 290.41, 170.32, 294.33, 181.08, 294.33, 190.87, 294.33, 203.6, 294.33, 216.32, 290.41, 230.02, 280.62, 241.77, 268.88, 245.68, 268.88, 235.9, 282.58, 228.07, 292.37, 220.24, 301.18, 217.3, 311.95, 220.24, 319.78, 227.09, 326.63, 240.79, 330.54, 256.45, 330.54, 268.2, 323.69, 275.05, 309.99, 278.96, 294.33, 278.96, 279.64, 284.84, 265.94, 290.71, 247.34, 301.48, 227.77, 290.71, 211.13]], "area": 22627.262500000008, "iscrowd": 0, "image_id": 10403, "bbox": [111.59, 92.69, 189.89, 237.85], "category_id": 52, "id": 1046246}, {"segmentation": [[1.69, 198.64, 17.98, 187.25, 50.54, 187.25, 78.22, 191.32, 104.27, 207.6, 121.36, 236.9, 127.06, 267.84, 123.81, 299.59, 108.34, 328.9, 155.56, 336.22, 183.23, 352.5, 200.33, 379.37, 209.28, 399.72, 207.66, 423.33, 203.59, 443.0, 34.26, 443.0, 34.26, 414.37, 44.84, 378.55, 50.54, 368.79, 29.37, 359.83, 3.32, 349.25]], "area": 34408.68220000001, "iscrowd": 0, "image_id": 10196, "bbox": [1.69, 187.25, 207.59, 255.75], "category_id": 53, "id": 1048678}, {"segmentation": [[348.0, 377.1, 334.0, 363.1, 339.0, 340.1, 345.0, 320.1, 361.0, 305.1, 374.0, 293.1, 405.0, 303.1, 429.0, 329.1, 427.0, 359.1, 412.0, 380.1, 376.0, 382.1, 361.0, 382.1]], "area": 6343.5, "iscrowd": 0, "image_id": 10037, "bbox": [334.0, 293.1, 95.0, 89.0], "category_id": 55, "id": 1050734}, {"segmentation": [[409.8, 177.51, 439.89, 162.98, 456.49, 156.76, 471.01, 153.65, 503.17, 167.13, 524.96, 183.73, 528.07, 210.71, 528.07, 237.68, 516.66, 259.47, 504.21, 266.73, 478.27, 278.14, 455.45, 287.48, 429.51, 291.63, 409.8, 283.33, 389.05, 263.62, 380.75, 242.87, 383.86, 216.93, 394.24, 194.11]], "area": 15222.65395, "iscrowd": 0, "image_id": 10196, "bbox": [380.75, 153.65, 147.32, 137.98], "category_id": 55, "id": 1052035}, {"segmentation": [[638.5, 340.8, 621.46, 347.82, 598.4, 322.76, 592.39, 291.68, 599.41, 268.63, 615.44, 253.6, 636.49, 244.57]], "area": 3461.3243500000012, "iscrowd": 0, "image_id": 10037, "bbox": [592.39, 244.57, 46.11, 103.25], "category_id": 55, "id": 1052832}, {"segmentation": [[524.3, 196.03, 527.43, 150.17, 551.4, 128.28, 586.84, 126.19, 625.41, 140.79, 640.0, 160.59, 636.88, 255.45, 617.07, 264.83, 588.93, 254.4, 553.49, 248.15, 535.77, 228.34, 525.35, 191.86]], "area": 12892.222500000005, "iscrowd": 0, "image_id": 10196, "bbox": [524.3, 126.19, 115.7, 138.64], "category_id": 55, "id": 1052869}, {"segmentation": [[528.67, 28.73, 529.72, 56.94, 537.03, 97.69, 547.48, 112.32, 574.65, 133.21, 619.57, 132.17, 639.42, 124.85, 640.0, 4.7, 568.38, 1.57, 540.17, 16.19]], "area": 12858.581, "iscrowd": 0, "image_id": 10196, "bbox": [528.67, 1.57, 111.33, 131.64], "category_id": 55, "id": 1053238}, {"segmentation": [[384.28, 382.77, 370.07, 392.92, 362.97, 406.79, 359.58, 414.91, 356.54, 423.37, 356.88, 425.06, 462.44, 426.0, 458.04, 414.91, 449.59, 397.99, 435.37, 385.14, 418.46, 374.99, 417.44, 374.99, 416.43, 374.65, 412.7, 380.06, 412.7, 381.08, 384.62, 382.09]], "area": 3752.981750000001, "iscrowd": 0, "image_id": 10037, "bbox": [356.54, 374.65, 105.9, 51.35], "category_id": 55, "id": 1053346}, {"segmentation": [[333.32, 360.23, 305.88, 362.6, 285.07, 382.94, 278.92, 399.97, 278.92, 413.68, 280.81, 426.0, 354.6, 424.56, 362.17, 406.12, 369.74, 388.61, 359.81, 381.52, 345.62, 377.26, 331.9, 362.6]], "area": 4475.59625, "iscrowd": 0, "image_id": 10037, "bbox": [278.92, 360.23, 90.82, 65.77], "category_id": 55, "id": 1053417}, {"segmentation": [[533.68, 373.23, 519.09, 366.98, 500.33, 356.55, 486.78, 338.83, 480.52, 304.44, 480.52, 284.63, 485.74, 270.04, 506.58, 258.57, 538.9, 248.15, 581.63, 255.45, 606.65, 258.57, 611.86, 265.87, 629.58, 281.5, 634.79, 310.69, 627.5, 349.26, 594.14, 371.15, 574.34, 379.49, 544.11, 376.36, 533.68, 369.06]], "area": 15983.7849, "iscrowd": 0, "image_id": 10196, "bbox": [480.52, 248.15, 154.27, 131.34], "category_id": 55, "id": 1053752}, {"segmentation": [[561.32, 360.85, 574.35, 360.85, 600.41, 342.8, 597.4, 310.73, 586.38, 290.68, 564.32, 277.65, 531.25, 283.67, 505.19, 303.71, 505.19, 308.72, 526.24, 335.79, 552.3, 358.84, 563.32, 363.85]], "area": 5461.2543000000005, "iscrowd": 0, "image_id": 10037, "bbox": [505.19, 277.65, 95.22, 86.2], "category_id": 55, "id": 1054003}, {"segmentation": [[46.31, 63.25, 60.99, 75.67, 74.54, 65.51, 76.8, 63.25, 89.22, 58.73, 98.26, 70.02, 103.91, 75.67, 123.11, 98.26, 136.66, 79.06, 138.92, 77.93, 141.18, 77.93, 153.6, 85.84, 161.51, 92.61, 181.84, 89.22, 185.22, 88.09, 185.22, 106.16, 186.35, 115.2, 208.94, 115.2, 219.11, 120.85, 230.4, 128.75, 233.79, 136.66, 246.21, 146.82, 243.95, 166.02, 257.51, 154.73, 266.54, 136.66, 275.58, 136.66, 282.35, 143.44, 283.48, 153.6, 283.48, 163.76, 295.91, 173.93, 303.81, 180.71, 303.81, 198.78, 303.81, 228.14, 304.94, 242.82, 306.07, 257.51, 311.72, 273.32, 304.94, 302.68, 301.55, 328.66, 297.04, 365.93, 289.13, 376.09, 288.0, 398.68, 290.26, 412.24, 300.42, 422.4, 307.2, 425.79, 313.98, 426.92, 336.56, 457.41, 334.31, 470.96, 326.4, 477.74, 326.4, 477.74, 325.27, 480.0, 4.52, 478.87, 11.29, 111.81, 15.81, 105.04, 23.72, 105.04, 30.49, 97.13, 33.88, 96.0, 35.01, 56.47, 42.92, 49.69]], "area": 111590.77340000002, "iscrowd": 0, "image_id": 10407, "bbox": [4.52, 49.69, 332.04, 430.31], "category_id": 56, "id": 1056237}, {"segmentation": [[294.06, 100.6, 304.27, 93.02, 312.83, 86.44, 321.06, 84.46, 330.94, 89.4, 335.22, 101.58, 341.14, 114.09, 350.36, 127.92, 356.95, 137.14, 363.2, 145.37, 350.36, 145.37, 339.82, 138.13, 325.34, 126.93, 309.53, 126.28, 295.38, 114.42]], "area": 1888.5172000000011, "iscrowd": 0, "image_id": 10166, "bbox": [294.06, 84.46, 69.14, 60.91], "category_id": 56, "id": 1059204}, {"segmentation": [[387.34, 122.23, 361.74, 107.36, 355.96, 89.2, 366.69, 76.81, 382.38, 73.5, 398.08, 67.72, 421.2, 89.2, 432.76, 106.54, 422.03, 121.4, 405.51, 122.23]], "area": 2839.2364, "iscrowd": 0, "image_id": 10166, "bbox": [355.96, 67.72, 76.8, 54.51], "category_id": 56, "id": 1059232}, {"segmentation": [[159.67, 171.69, 185.74, 177.71, 209.31, 168.69, 209.81, 160.66, 197.78, 136.6, 184.24, 133.59, 167.69, 136.09, 156.66, 132.59, 142.12, 130.58, 140.62, 148.13, 149.14, 162.67, 162.18, 174.2]], "area": 2352.54315, "iscrowd": 0, "image_id": 10166, "bbox": [140.62, 130.58, 69.19, 47.13], "category_id": 56, "id": 1059625}, {"segmentation": [[168.89, 72.71, 179.77, 68.43, 188.72, 73.1, 193.0, 81.27, 197.66, 85.15, 201.55, 78.54, 206.6, 69.99, 215.94, 69.99, 225.27, 69.99, 231.49, 74.65, 224.1, 98.37, 210.1, 111.59, 203.11, 116.65, 179.77, 112.76, 177.05, 104.98, 177.05, 94.87, 165.78, 94.1, 161.89, 82.04]], "area": 2176.6643000000004, "iscrowd": 0, "image_id": 10166, "bbox": [161.89, 68.43, 69.6, 48.22], "category_id": 56, "id": 1060098}, {"segmentation": [[200.69, 217.21, 180.04, 213.08, 175.09, 198.21, 175.09, 187.48, 168.48, 178.39, 160.22, 178.39, 147.01, 185.82, 131.32, 197.39, 128.01, 211.43, 131.32, 225.47, 142.05, 226.29, 151.96, 220.51, 165.18, 221.34, 184.17, 227.94, 198.21, 225.47, 199.86, 219.68]], "area": 2046.8189500000005, "iscrowd": 0, "image_id": 10166, "bbox": [128.01, 178.39, 72.68, 49.55], "category_id": 56, "id": 1060138}, {"segmentation": [[106.02, 99.95, 98.51, 97.27, 91.0, 98.34, 82.43, 99.95, 82.69, 85.2, 89.4, 70.46, 95.02, 58.4, 105.75, 53.84, 116.74, 48.75, 123.98, 56.79, 133.36, 54.11, 141.67, 63.22, 148.37, 68.58, 150.51, 75.55, 140.06, 76.63, 140.33, 87.35, 131.75, 92.71, 120.22, 93.51, 108.43, 98.34]], "area": 2253.9273000000003, "iscrowd": 0, "image_id": 10166, "bbox": [82.43, 48.75, 68.08, 51.2], "category_id": 56, "id": 1060510}, {"segmentation": [[306.54, 427.71, 366.97, 444.08, 426.77, 459.18, 429.29, 451.63, 427.4, 403.79, 409.15, 377.36, 402.85, 354.69, 401.59, 321.96, 394.67, 306.86, 382.08, 280.42, 379.56, 272.87, 361.31, 266.57, 344.31, 259.65, 316.62, 249.58, 304.03, 247.06, 305.92, 253.35, 309.69, 261.54, 312.21, 266.57, 304.66, 285.45, 300.88, 298.04, 298.99, 313.78, 293.96, 327.63, 287.66, 345.25, 285.14, 361.62, 291.44, 391.2, 294.59, 407.57, 298.99, 417.01, 301.51, 425.82, 302.77, 426.45]], "area": 20059.09555, "iscrowd": 0, "image_id": 10407, "bbox": [285.14, 247.06, 144.15, 212.12], "category_id": 57, "id": 1061762}, {"segmentation": [[521.79, 300.42, 635.86, 369.32, 640.0, 472.09, 522.92, 472.09, 465.32, 370.45, 477.74, 307.2]], "area": 22006.0726, "iscrowd": 0, "image_id": 10407, "bbox": [465.32, 300.42, 174.68, 171.67], "category_id": 57, "id": 1064657}, {"segmentation": [[459.24, 427.38, 441.2, 394.3, 431.64, 364.24, 431.09, 345.37, 443.94, 337.99, 468.81, 345.65, 464.71, 369.98, 479.47, 396.76, 483.3, 401.41, 501.07, 444.33, 505.17, 455.53, 510.09, 475.49, 457.06, 476.58, 469.63, 443.78]], "area": 4956.79845, "iscrowd": 0, "image_id": 10407, "bbox": [431.09, 337.99, 79.0, 138.59], "category_id": 57, "id": 1065139}, {"segmentation": [[11.83, 344.69, 2.37, 332.07, 0.79, 126.2, 14.2, 116.74, 29.97, 104.12, 41.02, 86.76, 71.78, 64.68, 126.99, 29.18, 143.56, 22.87, 151.44, 12.62, 169.58, 0.0, 456.69, 1.58, 467.74, 8.68, 470.0, 32.34, 470.0, 109.64, 437.76, 155.39, 399.9, 178.26, 373.09, 188.51, 354.16, 194.82, 341.53, 203.5, 317.87, 222.43, 308.41, 240.57, 309.98, 258.71, 287.11, 280.01, 246.09, 312.35, 202.71, 324.97, 184.57, 333.65, 138.82, 343.9, 134.88, 344.69, 55.21, 347.06]], "area": 119209.93014999999, "iscrowd": 0, "image_id": 10166, "bbox": [0.79, 0.0, 469.21, 347.06], "category_id": 59, "id": 1074907}, {"segmentation": [[539.61, 60.07, 516.43, 70.61, 508.0, 83.26, 506.94, 94.85, 510.1, 110.66, 513.27, 128.58, 514.32, 147.55, 514.32, 177.06, 516.43, 200.25, 509.05, 225.54, 497.46, 246.62, 484.81, 276.13, 480.59, 292.99, 473.22, 311.96, 465.84, 327.77, 450.03, 344.64, 418.41, 354.12, 412.09, 358.34, 377.31, 358.34, 366.77, 346.74, 354.12, 334.1, 286.67, 345.69, 264.54, 353.07, 242.4, 341.47, 221.33, 327.77, 185.49, 311.96, 173.9, 299.32, 173.9, 292.99, 187.6, 263.48, 203.41, 240.3, 207.62, 216.06, 207.62, 202.36, 186.55, 169.68, 169.68, 158.09, 138.07, 143.33, 107.5, 134.9, 87.48, 129.63, 55.86, 127.53, 31.62, 123.31, 26.35, 120.15, 63.24, 86.42, 79.04, 69.56, 96.96, 61.13, 100.12, 60.07, 119.09, 32.67, 129.63, 36.89, 130.69, 43.21, 167.58, 31.62, 193.92, 26.35, 225.54, 21.08, 260.32, 18.97, 292.99, 17.92, 336.2, 16.86, 367.82, 16.86, 426.84, 21.08, 455.3, 23.19, 481.65, 25.29, 509.05, 34.78, 532.24, 48.48]], "area": 113511.33254999998, "iscrowd": 0, "image_id": 10073, "bbox": [26.35, 16.86, 513.26, 341.48], "category_id": 59, "id": 1077450}, {"segmentation": [[448.02, 137.85, 466.21, 180.93, 470.04, 207.73, 453.76, 246.03, 426.0, 274.75, 358.99, 290.06, 293.89, 284.32, 255.6, 269.96, 232.62, 242.2, 224.01, 207.73, 224.97, 179.02, 242.2, 154.13, 269.96, 131.15, 300.59, 116.79, 316.87, 110.09, 346.54, 105.3, 367.6, 103.39, 383.88, 105.3, 409.73, 114.88, 432.7, 125.41, 437.49, 128.28]], "area": 35966.54044999999, "iscrowd": 0, "image_id": 10037, "bbox": [224.01, 103.39, 246.03, 186.67], "category_id": 60, "id": 1078956}, {"segmentation": [[0.0, 435.65, 38.2, 467.42, 74.16, 485.39, 146.07, 487.64, 214.61, 470.79, 246.07, 446.07, 271.91, 412.36, 288.76, 364.04, 288.76, 329.21, 271.91, 296.63, 226.97, 261.8, 185.39, 241.57, 144.94, 233.71, 69.66, 250.56, 5.62, 293.26, 0.0, 303.37]], "area": 59049.35005000001, "iscrowd": 0, "image_id": 10444, "bbox": [0.0, 233.71, 288.76, 253.93], "category_id": 60, "id": 1079276}, {"segmentation": [[0.96, 150.16, 73.88, 0.48, 635.16, 2.4, 638.04, 419.76, 1.92, 420.72]], "area": 260688.60319999998, "iscrowd": 0, "image_id": 10037, "bbox": [0.96, 0.48, 637.08, 420.24], "category_id": 67, "id": 1091124}, {"segmentation": [[118.28, 534.5, 95.86, 544.01, 84.08, 545.53, 74.58, 545.53, 69.64, 541.72, 71.54, 513.6, 67.36, 509.04, 59.76, 504.86, 47.59, 493.46, 44.17, 486.62, 41.13, 483.2, 43.41, 474.08, 49.87, 466.09, 66.22, 458.11, 102.7, 450.89, 118.66, 455.83, 122.46, 459.25, 131.97, 460.01, 132.73, 468.37, 125.5, 470.28, 115.24, 482.82, 111.82, 486.62, 115.62, 485.86, 121.32, 482.82, 127.4, 485.48, 133.49, 496.5, 136.15, 509.04, 131.21, 513.98, 124.74, 515.88, 121.32, 512.46, 119.04, 510.56, 116.76, 521.96, 115.62, 526.52]], "area": 5833.763949999999, "iscrowd": 0, "image_id": 10337, "bbox": [41.13, 450.89, 95.02, 94.64], "category_id": 70, "id": 1095547}, {"segmentation": [[485.13, 240.44, 475.27, 236.68, 468.23, 223.53, 466.35, 216.49, 465.88, 210.86, 469.64, 205.69, 475.27, 202.4, 479.5, 203.34, 482.32, 201.94, 488.42, 202.87, 491.71, 206.63, 501.1, 208.04, 507.2, 213.67, 513.3, 221.19, 518.47, 228.7, 520.35, 235.74, 520.81, 241.84, 520.81, 246.07, 516.12, 247.48, 507.2, 248.89, 495.93, 247.01, 489.36, 243.72]], "area": 1749.2476999999997, "iscrowd": 0, "image_id": 10083, "bbox": [465.88, 201.94, 54.93, 46.95], "category_id": 74, "id": 1107099}, {"segmentation": [[185.48, 121.6, 187.17, 121.99, 188.2, 127.68, 180.44, 130.52, 180.18, 124.06, 183.29, 123.8, 185.23, 123.54, 185.23, 121.99]], "area": 44.70694999999999, "iscrowd": 0, "image_id": 10176, "bbox": [180.18, 121.6, 8.02, 8.92], "category_id": 75, "id": 1113756}, {"segmentation": [[471.97, 274.82, 459.02, 275.44, 458.71, 270.2, 469.5, 268.04, 476.28, 270.81, 471.35, 274.82]], "area": 91.59094999999988, "iscrowd": 0, "image_id": 10176, "bbox": [458.71, 268.04, 17.57, 7.4], "category_id": 75, "id": 1114099}, {"segmentation": [[203.87, 379.69, 143.46, 303.1, 148.85, 294.47, 222.2, 257.8, 327.91, 207.1, 363.51, 204.94, 387.24, 192.0, 468.13, 240.54, 468.13, 244.85, 419.6, 270.74, 410.97, 280.45, 374.29, 300.94, 295.55, 344.09, 248.09, 369.98, 224.36, 377.53]], "area": 29166.849700000002, "iscrowd": 0, "image_id": 10083, "bbox": [143.46, 192.0, 324.67, 187.69], "category_id": 76, "id": 1115246}, {"segmentation": [[252.91, 380.99, 461.7, 262.6, 514.44, 303.5, 301.35, 439.1, 259.37, 389.6]], "area": 16888.100650000008, "iscrowd": 0, "image_id": 10083, "bbox": [252.91, 262.6, 261.53, 176.5], "category_id": 76, "id": 1116701}, {"segmentation": [[243.19, 227.5, 263.49, 186.9, 322.43, 179.7, 323.08, 191.49, 368.27, 192.8, 368.92, 203.93, 381.36, 232.74, 385.95, 236.02, 423.93, 304.77, 334.21, 299.54, 246.46, 283.82]], "area": 15536.312549999999, "iscrowd": 0, "image_id": 10175, "bbox": [243.19, 179.7, 180.74, 125.07], "category_id": 79, "id": 1123456}, {"segmentation": [[14.02, 268.58, 126.2, 249.17, 182.29, 294.47, 3.24, 334.38]], "area": 8760.860550000003, "iscrowd": 0, "image_id": 10175, "bbox": [3.24, 249.17, 179.05, 85.21], "category_id": 81, "id": 1129473}, {"segmentation": [[445.69, 69.11, 449.06, 68.97, 448.92, 92.12, 447.01, 92.41, 444.96, 91.82]], "area": 84.93395000000046, "iscrowd": 0, "image_id": 10346, "bbox": [444.96, 68.97, 4.1, 23.44], "category_id": 84, "id": 1138841}, {"segmentation": [[193.27, 383.83, 214.96, 388.06, 208.61, 475.33, 188.51, 473.22, 192.22, 430.9, 191.16, 430.9]], "area": 1823.1149500000013, "iscrowd": 0, "image_id": 10136, "bbox": [188.51, 383.83, 26.45, 91.5], "category_id": 84, "id": 1142593}, {"segmentation": [[38.52, 366.63, 277.52, 375.87, 276.2, 279.48, 37.2, 263.63]], "area": 23810.545599999998, "iscrowd": 0, "image_id": 10136, "bbox": [37.2, 263.63, 240.32, 112.24], "category_id": 84, "id": 1142653}, {"segmentation": [[449.97, 69.99, 453.36, 69.82, 451.67, 91.87, 449.29, 91.7, 449.29, 69.31]], "area": 70.7363999999999, "iscrowd": 0, "image_id": 10346, "bbox": [449.29, 69.31, 4.07, 22.56], "category_id": 84, "id": 1144073}, {"segmentation": [[246.23, 392.92, 239.0, 475.67, 265.51, 479.69, 274.35, 387.29, 247.84, 386.49]], "area": 2471.516600000001, "iscrowd": 0, "image_id": 10136, "bbox": [239.0, 386.49, 35.35, 93.2], "category_id": 84, "id": 1144196}, {"segmentation": [[458.63, 70.08, 453.8, 70.56, 452.59, 91.8, 457.42, 91.32]], "area": 102.00840000000022, "iscrowd": 0, "image_id": 10346, "bbox": [452.59, 70.08, 6.04, 21.72], "category_id": 84, "id": 1145687}, {"segmentation": [[435.51, 421.02, 306.57, 416.25, 287.47, 389.5, 281.74, 251.02, 270.28, 282.54, 276.01, 312.14, 259.78, 306.41, 247.36, 334.11, 227.3, 331.25, 214.89, 321.69, 217.75, 289.22, 238.76, 231.92, 248.31, 205.18, 255.96, 165.07, 274.1, 127.82, 252.13, 102.99, 252.13, 71.47, 237.81, 47.59, 244.49, 25.63, 258.82, 10.35, 283.65, 0.0, 293.2, 3.66, 317.08, 0.0, 384.89, 0.8, 387.75, 6.53, 406.85, 0.0, 441.24, 3.66, 452.7, 37.09, 429.78, 59.05, 428.82, 98.21, 411.63, 123.04, 407.81, 124.0, 418.31, 157.43, 425.96, 191.81, 437.42, 218.55, 452.7, 252.93, 453.65, 265.35, 456.52, 293.04, 454.61, 315.01, 439.33, 323.6, 449.83, 380.91, 444.1, 395.23, 441.24, 417.2]], "area": 75660.35605, "iscrowd": 0, "image_id": 10082, "bbox": [214.89, 0.0, 241.63, 421.02], "category_id": 88, "id": 1159433}, {"segmentation": [[117.57, 422.83, 78.74, 421.75, 46.38, 428.22, 23.73, 462.74, 11.87, 469.21, 145.62, 473.53, 149.93, 441.17, 139.15, 428.22, 131.6, 424.99]], "area": 5395.958049999997, "iscrowd": 0, "image_id": 10176, "bbox": [11.87, 421.75, 138.06, 51.78], "category_id": 27, "id": 1166330}, {"segmentation": [[299.58, 296.25, 346.67, 306.25, 377.51, 301.67, 382.92, 267.91, 380.42, 257.91, 373.34, 246.66, 380.42, 239.58, 357.09, 236.24, 339.58, 234.16, 330.0, 232.91, 331.67, 224.99, 331.67, 216.24, 327.08, 209.15, 325.83, 214.57, 322.5, 223.32, 319.58, 229.57, 312.91, 234.58, 305.83, 239.16, 300.83, 248.33, 296.66, 252.91, 296.24, 253.33, 296.24, 293.33]], "area": 5612.925149999999, "iscrowd": 0, "image_id": 10275, "bbox": [296.24, 209.15, 86.68, 97.1], "category_id": 31, "id": 1173081}, {"segmentation": [[142.12, 145.51, 143.55, 155.48, 143.55, 159.18, 143.55, 159.18, 143.83, 171.42, 140.98, 170.85, 143.83, 175.69, 156.07, 173.13, 156.93, 172.28, 154.93, 157.19, 154.93, 157.19, 153.23, 154.91, 151.8, 154.34, 152.66, 148.65, 148.67, 145.23, 146.11, 141.53]], "area": 339.3100499999999, "iscrowd": 0, "image_id": 10244, "bbox": [140.98, 141.53, 15.95, 34.16], "category_id": 31, "id": 1173590}, {"segmentation": [[469.03, 170.13, 456.61, 204.52, 457.57, 217.89, 456.61, 222.67, 453.75, 226.49, 454.7, 267.56, 469.99, 422.32, 561.69, 420.41, 546.41, 381.24, 553.09, 376.46, 553.09, 354.49, 540.68, 334.43, 526.35, 311.51, 520.62, 293.36, 508.2, 279.98, 514.88, 266.61, 515.84, 255.15, 508.2, 238.91, 510.11, 236.04, 504.38, 224.58, 496.73, 215.98, 482.4, 194.01]], "area": 15645.8498, "iscrowd": 0, "image_id": 10232, "bbox": [453.75, 170.13, 107.94, 252.19], "category_id": 31, "id": 1176820}, {"segmentation": [[168.43, 179.01, 170.97, 184.08, 170.97, 188.36, 171.44, 192.01, 171.44, 193.75, 165.9, 192.96, 164.15, 185.82, 163.68, 182.81, 163.36, 179.64, 163.52, 176.95, 163.52, 175.2, 165.1, 174.41, 166.05, 174.57, 167.8, 177.58, 168.59, 179.17]], "area": 105.8502999999999, "iscrowd": 0, "image_id": 10230, "bbox": [163.36, 174.41, 8.08, 19.34], "category_id": 1, "id": 1189565}, {"segmentation": [[216.46, 230.98, 216.24, 226.47, 220.32, 222.39, 220.75, 220.25, 220.32, 216.81, 220.32, 215.52, 217.96, 209.51, 214.74, 205.65, 211.73, 204.57, 212.38, 197.06, 209.37, 193.19, 204.0, 195.98, 202.29, 199.21, 201.64, 203.71, 201.0, 207.15, 196.7, 225.4, 196.92, 227.98, 200.78, 236.56, 204.86, 240.0, 206.36, 240.64, 206.79, 238.5, 205.72, 234.42, 207.22, 233.34, 210.44, 233.56, 212.59, 233.34, 215.17, 233.13]], "area": 681.8614500000002, "iscrowd": 0, "image_id": 10281, "bbox": [196.7, 193.19, 24.05, 47.45], "category_id": 1, "id": 1189576}, {"segmentation": [[530.03, 208.26, 530.03, 199.99, 529.51, 198.54, 529.2, 197.09, 529.2, 196.06, 529.2, 194.92, 529.4, 193.48, 529.82, 192.86, 530.54, 192.75, 531.06, 192.13, 531.58, 190.68, 532.3, 190.58, 533.13, 190.58, 534.06, 191.72, 534.06, 192.65, 534.68, 192.75, 535.19, 193.06, 535.3, 194.2, 535.5, 200.61, 534.16, 203.09, 534.16, 204.02, 534.26, 205.57, 534.37, 206.61, 534.78, 207.43, 535.3, 207.95, 535.3, 208.88, 534.47, 209.4, 533.44, 209.61, 533.23, 209.09, 533.23, 207.85, 533.13, 203.3, 532.92, 202.57, 532.2, 202.78, 531.89, 203.82, 532.09, 206.09, 532.09, 207.54, 532.09, 208.47, 532.09, 209.09, 531.47, 209.29, 531.06, 209.4, 530.65, 209.4, 530.03, 208.98]], "area": 84.71504999999986, "iscrowd": 0, "image_id": 10318, "bbox": [529.2, 190.58, 6.3, 19.03], "category_id": 1, "id": 1207029}, {"segmentation": [[404.75, 233.95, 404.75, 235.6, 402.27, 232.84, 402.27, 231.47, 400.35, 230.36, 396.76, 228.44, 393.18, 226.51, 392.63, 224.58, 394.28, 222.1, 395.39, 220.44, 399.24, 220.72, 401.45, 222.37, 401.17, 222.1, 400.35, 220.17, 399.79, 216.31, 401.72, 213.0, 401.72, 211.9, 399.79, 211.08, 398.14, 210.8, 396.49, 209.42, 397.04, 204.46, 399.24, 201.43, 406.41, 201.43, 409.71, 205.29, 409.71, 206.12]], "area": 303.3419499999994, "iscrowd": 0, "image_id": 10281, "bbox": [392.63, 201.43, 17.08, 34.17], "category_id": 1, "id": 1212442}, {"segmentation": [[150.78, 176.96, 151.76, 174.74, 153.81, 175.62, 155.32, 177.32, 154.16, 184.52, 154.52, 188.35, 153.01, 190.93, 153.19, 193.24, 149.63, 192.79, 150.43, 189.5, 152.65, 186.57, 152.03, 182.21, 150.16, 182.12, 149.81, 177.14]], "area": 59.492049999999935, "iscrowd": 0, "image_id": 10230, "bbox": [149.63, 174.74, 5.69, 18.5], "category_id": 1, "id": 1214085}, {"segmentation": [[608.36, 186.07, 600.27, 148.85, 606.74, 135.91, 622.11, 126.2, 629.39, 133.48, 620.49, 148.04, 624.54, 152.9, 635.87, 154.52, 640.0, 160.18, 629.39, 164.22, 615.64, 163.42, 625.35, 179.6]], "area": 1140.4444999999998, "iscrowd": 0, "image_id": 10097, "bbox": [600.27, 126.2, 39.73, 59.87], "category_id": 1, "id": 1216711}, {"segmentation": [[108.76, 326.1, 113.66, 319.16, 114.48, 312.21, 114.89, 309.35, 121.02, 304.86, 125.1, 302.82, 124.69, 294.24, 126.33, 279.12, 132.86, 266.46, 138.58, 260.74, 143.07, 258.29, 148.38, 259.11, 155.33, 265.64, 162.27, 270.54, 169.22, 288.52, 167.58, 293.83, 163.91, 314.66, 162.68, 319.97, 154.51, 324.06, 152.06, 331.0, 146.75, 331.0, 146.34, 324.06, 148.38, 316.7, 148.79, 312.62, 150.43, 302.82, 136.54, 308.53, 129.19, 321.2, 124.69, 325.28, 115.3, 331.41, 109.17, 331.82]], "area": 2395.900299999999, "iscrowd": 0, "image_id": 10015, "bbox": [108.76, 258.29, 60.46, 73.53], "category_id": 1, "id": 1224547}, {"segmentation": [[32.62, 127.44, 39.71, 126.35, 44.61, 133.7, 44.34, 139.43, 50.06, 144.88, 52.79, 163.68, 61.51, 185.75, 62.6, 201.55, 54.97, 184.11, 49.79, 175.39, 55.51, 197.47, 57.15, 202.1, 51.15, 202.1, 43.79, 179.75, 34.53, 178.66, 28.81, 170.22, 27.99, 155.78, 29.9, 142.7, 32.08, 139.15, 32.08, 127.71]], "area": 1287.0788000000005, "iscrowd": 0, "image_id": 10069, "bbox": [27.99, 126.35, 34.61, 75.75], "category_id": 1, "id": 1240549}, {"segmentation": [[109.85, 190.22, 109.85, 186.75, 110.48, 183.37, 111.1, 181.41, 110.66, 178.21, 112.7, 177.76, 113.77, 177.5, 113.59, 180.79, 115.19, 181.77, 114.04, 184.26, 114.21, 190.75, 112.88, 191.11, 112.52, 186.57, 111.81, 187.9, 110.92, 191.2]], "area": 44.698150000000076, "iscrowd": 0, "image_id": 10230, "bbox": [109.85, 177.5, 5.34, 13.7], "category_id": 1, "id": 1241479}, {"segmentation": [[318.55, 262.91, 318.16, 231.53, 326.2, 224.26, 329.64, 217.75, 334.62, 207.04, 344.19, 208.57, 346.1, 217.37, 356.81, 224.64, 359.11, 240.71, 362.31, 258.81, 361.38, 269.03, 356.04, 269.03, 354.18, 266.94, 351.85, 280.18, 347.53, 296.19, 347.03, 302.08, 349.0, 310.92, 349.0, 320.75, 344.58, 318.78, 339.67, 322.71, 327.39, 316.32, 331.32, 310.43, 330.83, 295.7, 326.9, 270.16, 323.46, 289.8, 318.55, 285.87, 317.08, 262.79]], "area": 3291.9686000000006, "iscrowd": 0, "image_id": 10239, "bbox": [317.08, 207.04, 45.23, 115.67], "category_id": 1, "id": 1242558}, {"segmentation": [[149.28, 471.27, 160.4, 412.51, 168.34, 395.04, 168.34, 364.86, 179.45, 331.51, 163.57, 337.87, 155.63, 307.69, 155.63, 280.69, 165.16, 267.99, 184.22, 258.46, 196.92, 256.87, 195.33, 240.99, 206.45, 217.17, 220.74, 214.0, 239.8, 221.94, 228.68, 267.99, 244.57, 282.28, 255.68, 325.16, 266.8, 337.87, 254.09, 360.1, 239.8, 353.75, 230.27, 348.98, 206.45, 352.16, 195.33, 388.68, 176.28, 423.62, 163.57, 455.38, 182.63, 483.97, 184.22, 496.67, 168.34, 498.26, 144.52, 471.27]], "area": 13039.704799999998, "iscrowd": 0, "image_id": 10321, "bbox": [144.52, 214.0, 122.28, 284.26], "category_id": 1, "id": 1256012}, {"segmentation": [[337.15, 218.06, 339.62, 216.6, 341.64, 216.71, 341.64, 217.72, 341.3, 220.3, 337.94, 220.98, 336.59, 220.53, 336.03, 218.62, 336.14, 218.06]], "area": 18.08885000000007, "iscrowd": 0, "image_id": 10281, "bbox": [336.03, 216.6, 5.61, 4.38], "category_id": 1, "id": 1260936}, {"segmentation": [[430.81, 253.88, 430.95, 249.55, 432.54, 248.11, 432.54, 246.24, 434.7, 243.64, 437.3, 243.5, 439.03, 247.25, 440.9, 250.27, 441.63, 251.57, 441.63, 252.15, 437.44, 252.44], [430.95, 258.35, 431.53, 254.89, 435.57, 253.59, 440.76, 254.46, 440.76, 257.05, 440.47, 257.48]], "area": 105.08180000000007, "iscrowd": 0, "image_id": 10318, "bbox": [430.81, 243.5, 10.82, 14.85], "category_id": 1, "id": 1265505}, {"segmentation": [[0.0, 260.35, 12.3, 259.2, 20.73, 260.35, 33.77, 270.7, 38.76, 275.69, 47.19, 283.36, 48.34, 288.34, 44.51, 294.09, 44.51, 309.05, 44.51, 324.0, 45.28, 330.14, 41.44, 337.04, 36.07, 335.12, 38.76, 324.39, 36.07, 310.2, 33.77, 303.3, 31.47, 298.7, 27.25, 297.93, 25.34, 300.61, 28.4, 310.97, 27.25, 319.79, 26.87, 325.15, 24.57, 329.37, 16.13, 332.06, 11.53, 333.59, 11.53, 324.0, 11.92, 317.1, 12.68, 315.18, 7.31, 313.65, 4.25, 307.51, 3.1, 304.45, 0.41, 305.98, 4.63, 326.69, 10.38, 333.97, 7.7, 336.66, 0.41, 341.64]], "area": 2579.0673500000003, "iscrowd": 0, "image_id": 10281, "bbox": [0.0, 259.2, 48.34, 82.44], "category_id": 1, "id": 1280124}, {"segmentation": [[130.09, 228.72, 131.97, 227.15, 135.74, 227.78, 136.36, 230.6, 135.11, 232.79, 135.74, 236.56, 138.25, 238.75, 138.56, 240.32, 138.56, 241.26, 136.99, 241.26, 135.42, 241.26, 132.6, 242.2, 130.41, 241.89, 128.84, 241.57, 126.96, 241.26, 126.02, 240.32, 124.13, 238.75, 126.02, 235.3, 129.15, 234.36, 130.09, 230.91, 131.03, 229.03]], "area": 121.89719999999991, "iscrowd": 0, "image_id": 10281, "bbox": [124.13, 227.15, 14.43, 15.05], "category_id": 1, "id": 1283845}, {"segmentation": [[332.91, 349.37, 334.91, 331.57, 345.19, 324.3, 347.7, 311.26, 356.98, 311.51, 358.23, 316.53, 354.72, 324.3, 361.49, 331.07, 363.25, 345.11, 361.24, 355.89, 332.91, 350.13]], "area": 884.5516999999998, "iscrowd": 0, "image_id": 10321, "bbox": [332.91, 311.26, 30.34, 44.63], "category_id": 1, "id": 1287800}, {"segmentation": [[113.6, 272.32, 114.11, 259.95, 113.6, 256.67, 112.34, 251.62, 111.84, 247.83, 111.58, 244.55, 111.08, 236.98, 110.57, 233.44, 109.56, 227.63, 109.82, 224.1, 111.84, 220.56, 113.35, 216.27, 116.63, 211.98, 122.19, 216.27, 122.19, 220.56, 123.95, 220.31, 126.98, 219.3, 127.74, 221.83, 123.2, 227.89, 123.95, 233.95, 122.19, 248.34, 120.42, 255.91, 120.42, 260.71, 119.92, 266.77, 120.67, 270.3, 122.94, 272.57, 119.66, 272.83]], "area": 605.09915, "iscrowd": 0, "image_id": 10239, "bbox": [109.56, 211.98, 18.18, 60.85], "category_id": 1, "id": 1294191}, {"segmentation": [[327.78, 308.82, 327.78, 306.08, 329.73, 303.93, 333.25, 304.71, 333.05, 308.43, 331.68, 310.97, 328.75, 313.7, 327.19, 315.85, 324.84, 324.06, 323.67, 331.09, 321.72, 333.82, 320.35, 322.1, 321.13, 316.24, 323.28, 312.33, 325.24, 310.38]], "area": 137.2716999999999, "iscrowd": 0, "image_id": 10321, "bbox": [320.35, 303.93, 12.9, 29.89], "category_id": 1, "id": 1294505}, {"segmentation": [[597.29, 224.81, 596.55, 223.02, 596.18, 220.06, 596.18, 217.71, 596.67, 216.41, 597.29, 215.98, 597.35, 214.68, 598.16, 213.75, 599.15, 214.19, 599.39, 214.68, 599.39, 214.8, 599.46, 216.6, 599.58, 216.72, 600.32, 217.34, 600.57, 217.89, 600.57, 218.7, 600.75, 220.98, 600.75, 222.84, 599.95, 224.88, 599.64, 225.68, 599.46, 225.8, 599.21, 225.87]], "area": 40.53215000000066, "iscrowd": 0, "image_id": 10281, "bbox": [596.18, 213.75, 4.57, 12.12], "category_id": 1, "id": 1298951}, {"segmentation": [[368.26, 307.51, 369.71, 307.47, 371.11, 307.07, 371.2, 304.93, 369.45, 303.57, 367.48, 304.22, 367.39, 305.54, 367.87, 306.33]], "area": 11.576249999999987, "iscrowd": 0, "image_id": 10321, "bbox": [367.39, 303.57, 3.81, 3.94], "category_id": 1, "id": 1306570}, {"segmentation": [[363.53, 345.1, 362.95, 339.24, 363.92, 336.31, 361.97, 335.92, 360.99, 331.23, 361.19, 329.47, 362.56, 330.06, 363.92, 330.65, 364.9, 328.3, 367.64, 325.17, 366.46, 323.42, 365.88, 322.05, 367.24, 318.92, 369.98, 318.34, 373.11, 321.07, 374.47, 324.78, 373.11, 325.96, 376.43, 329.86, 378.38, 335.92, 379.16, 344.32, 377.01, 346.08, 376.82, 353.11, 372.13, 350.38, 367.05, 346.08, 363.53, 346.08]], "area": 373.8783000000003, "iscrowd": 0, "image_id": 10321, "bbox": [360.99, 318.34, 18.17, 34.77], "category_id": 1, "id": 1319412}, {"segmentation": [[292.51, 331.14, 291.66, 322.6, 292.23, 313.2, 299.06, 313.2, 300.77, 306.94, 305.89, 306.37, 307.03, 311.49, 306.46, 315.76, 307.32, 320.6, 307.32, 323.17, 306.75, 328.29, 305.04, 336.26, 305.89, 345.94, 305.89, 348.79, 298.78, 349.93, 297.35, 349.64, 295.08, 343.09, 293.94, 335.69]], "area": 508.1385499999998, "iscrowd": 0, "image_id": 10321, "bbox": [291.66, 306.37, 15.66, 43.56], "category_id": 1, "id": 1325000}, {"segmentation": [[269.98, 346.19, 270.42, 339.11, 267.32, 335.57, 266.88, 326.72, 268.87, 323.62, 263.78, 322.29, 262.45, 320.3, 263.56, 319.41, 269.09, 319.19, 269.31, 318.09, 270.86, 315.87, 271.53, 312.33, 274.4, 310.56, 277.5, 312.11, 277.94, 314.54, 280.82, 316.98, 279.94, 320.74, 277.28, 321.85, 277.28, 324.95, 275.29, 330.04, 278.17, 340.66, 279.49, 345.31, 279.94, 348.19, 277.06, 348.63, 274.85, 339.55, 274.18, 344.2, 273.3, 349.07, 270.64, 351.06, 269.75, 348.41]], "area": 338.7781500000001, "iscrowd": 0, "image_id": 10321, "bbox": [262.45, 310.56, 18.37, 40.5], "category_id": 1, "id": 1325448}, {"segmentation": [[454.38, 341.75, 455.02, 324.37, 457.28, 323.41, 457.28, 316.65, 459.53, 313.43, 465.32, 318.58, 465.64, 324.37, 467.9, 326.63, 470.47, 335.32, 467.25, 335.64, 468.22, 365.57, 470.79, 368.14, 468.22, 370.07, 464.36, 368.46, 463.39, 347.22, 461.78, 345.94, 462.1, 366.85, 456.95, 369.11, 457.28, 351.41, 454.7, 342.72]], "area": 570.7439500000014, "iscrowd": 0, "image_id": 10321, "bbox": [454.38, 313.43, 16.41, 56.64], "category_id": 1, "id": 1325905}, {"segmentation": [[61.25, 364.69, 54.64, 365.93, 55.47, 358.5, 55.88, 341.15, 54.64, 332.06, 56.29, 328.35, 55.47, 323.8, 53.4, 321.74, 54.64, 309.76, 59.6, 307.28, 59.6, 300.26, 65.38, 297.78, 67.86, 301.91, 67.86, 304.8, 71.16, 308.93, 65.38, 314.3, 64.55, 318.85, 71.99, 322.98, 72.81, 331.24, 71.99, 346.1, 72.81, 356.02, 76.53, 356.02, 76.53, 358.08, 75.29, 360.56, 68.68, 364.28, 67.86, 360.97, 65.38, 343.63, 62.9, 344.87, 61.66, 363.04]], "area": 899.84315, "iscrowd": 0, "image_id": 10321, "bbox": [53.4, 297.78, 23.13, 68.15], "category_id": 1, "id": 1327430}, {"segmentation": [[252.72, 314.6, 254.71, 312.79, 254.54, 310.14, 255.7, 306.0, 260.66, 304.02, 263.14, 307.33, 263.14, 311.13, 261.99, 313.78, 261.99, 315.93, 263.14, 318.91, 262.15, 320.56, 261.49, 321.88, 262.15, 328.83, 261.82, 331.31, 257.35, 327.01, 255.7, 325.36]], "area": 180.52394999999996, "iscrowd": 0, "image_id": 10321, "bbox": [252.72, 304.02, 10.42, 27.29], "category_id": 1, "id": 1329455}, {"segmentation": [[278.77, 322.04, 280.48, 320.64, 280.98, 318.23, 280.08, 316.52, 280.28, 314.71, 281.68, 313.21, 285.3, 313.31, 288.11, 314.41, 288.31, 316.42, 287.51, 320.24, 288.11, 322.45, 288.92, 324.15, 289.92, 326.16, 289.32, 330.78, 288.41, 339.72, 286.51, 336.1, 283.79, 331.18, 282.29, 326.36, 279.88, 324.45, 279.17, 323.35, 278.37, 322.65]], "area": 158.06115000000014, "iscrowd": 0, "image_id": 10321, "bbox": [278.37, 313.21, 11.55, 26.51], "category_id": 1, "id": 1329877}, {"segmentation": [[592.79, 206.34, 594.2, 214.79, 600.18, 219.37, 606.17, 220.42, 610.4, 219.01, 618.85, 211.62, 622.72, 204.58, 621.31, 198.59, 597.01, 205.28], [635.87, 159.37, 640.0, 159.37, 640.0, 175.55, 638.29, 175.55, 635.06, 161.8]], "area": 463.3245500000009, "iscrowd": 0, "image_id": 10097, "bbox": [592.79, 159.37, 47.21, 61.05], "category_id": 2, "id": 1334389}, {"segmentation": [[82.25, 118.89, 71.43, 118.05, 70.78, 116.46, 73.3, 112.45, 75.54, 109.28, 86.35, 110.03, 86.35, 113.57, 82.34, 119.07]], "area": 113.0777999999999, "iscrowd": 0, "image_id": 10434, "bbox": [70.78, 109.28, 15.57, 9.79], "category_id": 3, "id": 1339072}, {"segmentation": [[460.53, 199.96, 460.31, 206.54, 447.72, 209.6, 441.26, 211.53, 434.57, 211.41, 427.88, 209.94, 427.88, 205.52, 427.88, 201.55, 427.88, 199.17, 434.23, 194.07, 451.92, 193.61, 458.95, 197.92, 460.42, 198.15]], "area": 481.9141999999998, "iscrowd": 0, "image_id": 10318, "bbox": [427.88, 193.61, 32.65, 17.92], "category_id": 3, "id": 1344065}, {"segmentation": [[639.98, 208.91, 632.2, 207.46, 618.79, 207.75, 616.05, 209.2, 611.43, 210.93, 606.24, 211.94, 604.8, 213.38, 604.65, 217.85, 608.11, 218.71, 609.56, 219.29, 610.42, 223.04, 610.85, 226.21, 611.43, 227.22, 611.72, 227.22, 613.16, 226.21, 613.45, 224.91, 627.87, 225.92, 630.32, 226.21, 633.35, 226.36, 636.38, 227.08, 638.83, 228.09, 639.98, 229.38, 640.0, 227.94]], "area": 565.3374000000007, "iscrowd": 0, "image_id": 10318, "bbox": [604.65, 207.46, 35.35, 21.92], "category_id": 3, "id": 1346177}, {"segmentation": [[405.91, 202.93, 408.08, 163.47, 467.48, 161.31, 476.15, 150.9, 495.65, 158.71, 496.09, 161.31, 543.34, 173.88, 544.64, 275.32, 542.91, 310.87, 513.43, 315.21, 498.69, 265.79, 512.56, 204.23], [561.4, 205.1, 566.37, 213.9, 573.26, 221.93, 564.84, 251.02, 564.08, 250.63, 561.02, 210.07]], "area": 10037.861700000001, "iscrowd": 0, "image_id": 10239, "bbox": [405.91, 150.9, 167.35, 164.31], "category_id": 6, "id": 1366308}, {"segmentation": [[302.25, 220.17, 301.97, 222.9, 299.79, 223.72, 297.07, 224.53, 293.26, 223.99, 292.98, 222.9, 292.98, 221.81, 293.26, 220.99, 290.8, 220.17, 291.35, 219.36, 291.89, 218.54, 291.35, 218.27, 289.44, 219.36, 288.35, 219.08, 286.72, 218.54, 286.72, 217.72, 288.08, 216.36, 289.17, 216.09, 289.71, 213.63, 289.71, 211.45, 289.17, 207.37, 288.9, 206.28, 288.9, 206.0, 291.62, 205.73, 292.98, 205.46, 295.16, 204.91, 298.98, 204.37, 303.06, 204.1, 305.79, 204.1, 309.6, 204.1, 311.24, 205.73, 313.69, 207.09, 313.69, 204.1, 316.96, 201.92, 319.14, 200.28, 321.32, 199.46, 325.95, 199.46, 329.77, 199.46, 332.77, 199.74, 335.22, 201.1, 337.94, 205.19, 339.85, 210.09, 338.22, 215.27, 337.94, 216.9, 337.94, 218.81, 337.4, 219.08, 318.05, 220.72, 316.42, 222.35, 316.69, 223.72, 316.69, 226.17, 316.42, 227.53, 312.6, 228.89, 310.42, 225.35, 310.15, 224.26, 309.6, 223.17, 303.34, 220.99]], "area": 953.5763000000004, "iscrowd": 0, "image_id": 10342, "bbox": [286.72, 199.46, 53.13, 29.43], "category_id": 8, "id": 1370191}, {"segmentation": [[407.91, 207.89, 408.72, 165.11, 466.84, 160.26, 462.8, 166.72, 469.26, 169.95, 469.26, 174.79, 473.3, 186.09, 472.49, 200.62, 466.84, 207.08, 447.47, 215.15, 436.97, 210.31, 424.06, 210.31, 420.83, 200.62, 412.76, 203.85], [493.48, 161.88, 541.91, 174.79, 542.71, 270.04, 540.29, 313.63, 534.64, 304.75, 529.8, 304.75, 527.38, 314.43, 509.62, 315.24, 505.58, 275.69, 505.58, 274.88, 502.35, 239.37, 499.13, 180.44, 491.05, 178.02], [561.28, 207.08, 569.35, 213.54, 570.16, 245.82, 566.12, 249.86, 560.47, 243.4]], "area": 8881.1214, "iscrowd": 0, "image_id": 10239, "bbox": [407.91, 160.26, 162.25, 154.98], "category_id": 8, "id": 1370910}, {"segmentation": [[153.58, 210.98, 148.73, 210.8, 149.57, 208.56, 154.7, 208.84, 154.14, 210.52]], "area": 11.495099999999981, "iscrowd": 0, "image_id": 10058, "bbox": [148.73, 208.56, 5.97, 2.42], "category_id": 9, "id": 1375447}, {"segmentation": [[81.62, 76.51, 70.1, 76.01, 70.93, 57.48, 80.61, 57.82]], "area": 197.22820000000007, "iscrowd": 0, "image_id": 10434, "bbox": [70.1, 57.48, 11.52, 19.03], "category_id": 10, "id": 1384480}, {"segmentation": [[119.09, 51.98, 119.63, 50.18, 126.55, 50.54, 125.56, 68.78, 125.02, 69.05, 119.27, 69.41, 119.18, 67.25]], "area": 129.79064999999989, "iscrowd": 0, "image_id": 10434, "bbox": [119.09, 50.18, 7.46, 19.23], "category_id": 10, "id": 1384691}, {"segmentation": [[170.75, 97.16, 176.99, 96.9, 176.86, 105.48, 171.01, 105.74, 170.75, 97.42]], "area": 51.91680000000012, "iscrowd": 0, "image_id": 10434, "bbox": [170.75, 96.9, 6.24, 8.84], "category_id": 10, "id": 1386730}, {"segmentation": [[166.63, 96.18, 159.56, 96.75, 159.7, 100.14, 165.64, 103.25, 166.91, 101.97]], "area": 38.41675, "iscrowd": 0, "image_id": 10434, "bbox": [159.56, 96.18, 7.35, 7.07], "category_id": 10, "id": 1386805}, {"segmentation": [[391.39, 27.47, 393.94, 25.44, 400.56, 24.42, 405.65, 16.53, 407.68, 11.43, 412.52, 7.99, 421.69, 0.0, 423.98, 1.12, 421.94, 11.56, 419.14, 15.63, 417.36, 18.43, 416.85, 23.52, 411.76, 26.82, 412.01, 30.89, 414.81, 33.69, 417.87, 35.22, 417.61, 38.78, 412.78, 39.04, 411.5, 38.02, 409.72, 34.45, 405.39, 36.49, 402.08, 35.47, 398.01, 32.42, 394.96, 29.62, 391.9, 28.34, 391.14, 27.84]], "area": 486.99205000000063, "iscrowd": 0, "image_id": 10445, "bbox": [391.14, 0.0, 32.84, 39.04], "category_id": 16, "id": 1399705}, {"segmentation": [[352.95, 268.68, 355.74, 285.87, 355.28, 292.38, 356.21, 297.72, 359.69, 299.35, 371.31, 290.06, 365.73, 275.19, 363.41, 271.24, 361.32, 269.84, 357.6, 268.45, 354.35, 267.98]], "area": 353.45510000000087, "iscrowd": 0, "image_id": 10239, "bbox": [352.95, 267.98, 18.36, 31.37], "category_id": 31, "id": 1432731}, {"segmentation": [[379.46, 135.05, 370.0, 144.5, 385.76, 178.52, 382.61, 222.63, 351.73, 221.37, 345.43, 203.73, 351.73, 152.69, 315.81, 140.72, 324.64, 136.94, 370.63, 137.57]], "area": 3008.1870999999983, "iscrowd": 0, "image_id": 10082, "bbox": [315.81, 135.05, 69.95, 87.58], "category_id": 32, "id": 1442505}, {"segmentation": [[345.72, 120.74, 340.22, 122.28, 335.82, 121.62, 331.87, 119.86, 328.13, 118.76, 325.27, 120.3, 326.81, 122.72, 331.87, 124.92, 340.66, 124.7, 345.06, 123.16], [366.83, 117.66, 355.39, 117.66, 356.49, 120.3, 367.05, 120.08, 367.71, 118.54]], "area": 95.50090000000006, "iscrowd": 0, "image_id": 10015, "bbox": [325.27, 117.66, 42.44, 7.26], "category_id": 35, "id": 1450756}, {"segmentation": [[454.53, 140.67, 450.41, 140.5, 429.34, 120.28, 432.26, 118.4, 450.93, 137.76], [455.21, 132.96, 462.92, 136.9, 463.26, 135.19, 456.07, 131.42]], "area": 100.04635000000016, "iscrowd": 0, "image_id": 10015, "bbox": [429.34, 118.4, 33.92, 22.27], "category_id": 35, "id": 1453020}, {"segmentation": [[152.86, 329.05, 147.53, 337.85, 142.45, 347.84, 140.08, 353.85, 138.22, 355.2, 134.92, 354.86, 131.37, 351.9, 137.46, 344.71, 145.67, 331.08, 146.6, 330.41, 149.31, 330.41], [111.65, 334.05, 107.67, 339.88, 100.56, 350.55, 98.7, 353.93, 95.4, 353.85, 91.68, 350.63, 93.46, 346.82, 105.39, 333.45, 106.57, 331.68, 107.42, 331.68]], "area": 335.13825000000054, "iscrowd": 0, "image_id": 10015, "bbox": [91.68, 329.05, 61.18, 26.15], "category_id": 35, "id": 1454651}, {"segmentation": [[329.15, 124.21, 322.91, 124.5, 321.48, 123.92, 318.6, 124.78, 318.89, 126.7, 319.17, 126.99, 319.46, 127.28, 330.4, 126.32, 333.95, 124.11], [356.2, 116.68, 362.04, 114.74, 362.89, 114.31, 365.43, 114.99, 365.51, 115.5, 365.34, 116.01, 357.05, 118.38]], "area": 50.46624999999989, "iscrowd": 0, "image_id": 10015, "bbox": [318.6, 114.31, 46.91, 12.97], "category_id": 35, "id": 1454974}, {"segmentation": [[611.84, 160.72, 630.14, 144.86, 631.36, 127.78, 622.82, 116.19, 616.11, 109.48, 610.01, 108.26, 603.3, 105.82, 597.81, 105.82, 590.49, 111.92, 591.71, 111.92, 604.52, 112.53, 619.16, 118.02, 624.04, 127.17, 624.04, 144.86, 611.84, 157.06]], "area": 421.58930000000197, "iscrowd": 0, "image_id": 10281, "bbox": [590.49, 105.82, 40.87, 54.9], "category_id": 38, "id": 1466660}, {"segmentation": [[570.9, 147.72, 573.42, 147.22, 574.92, 147.47, 576.93, 149.23, 577.31, 152.24, 577.06, 155.26, 576.81, 157.64, 579.07, 159.65, 580.2, 157.77, 581.7, 155.38, 581.96, 150.74, 580.7, 146.97, 578.31, 143.83, 572.91, 142.32, 570.78, 143.08, 569.27, 144.08, 568.02, 145.21, 567.51, 147.72, 569.4, 148.98]], "area": 102.07080000000099, "iscrowd": 0, "image_id": 10281, "bbox": [567.51, 142.32, 14.45, 17.33], "category_id": 38, "id": 1468369}, {"segmentation": [[142.31, 23.02, 152.54, 24.86, 152.54, 27.74, 152.54, 38.63, 151.89, 40.2, 149.53, 42.04, 144.8, 42.04, 141.4, 40.59, 140.35, 33.77, 139.95, 26.04]], "area": 210.18714999999995, "iscrowd": 0, "image_id": 10281, "bbox": [139.95, 23.02, 12.59, 19.02], "category_id": 38, "id": 1468450}, {"segmentation": [[68.31, 105.33, 50.73, 117.21, 47.4, 124.81, 41.7, 145.25, 41.7, 180.89, 70.69, 220.34, 87.8, 238.4, 95.88, 249.8, 101.1, 257.41, 103.48, 259.78, 112.03, 256.93, 118.69, 251.23, 121.54, 249.8, 132.47, 257.88, 138.17, 258.36, 148.63, 261.21, 160.04, 262.63, 162.89, 263.11, 176.67, 276.89, 183.8, 278.32, 204.23, 268.34, 211.36, 265.01, 217.07, 262.63, 227.05, 258.36, 211.36, 254.56, 193.78, 255.98, 176.19, 255.98, 168.59, 252.18, 164.79, 243.15, 151.48, 238.4, 144.83, 238.4, 139.12, 238.87, 132.47, 238.87, 129.62, 238.87, 120.11, 236.5, 115.36, 234.59, 108.23, 239.82, 104.43, 233.64, 107.76, 232.22, 107.76, 220.34, 106.33, 213.21, 99.68, 202.75, 96.35, 198.48, 91.6, 193.72, 83.04, 189.45, 64.98, 188.02, 67.84, 174.71, 69.26, 168.53, 68.79, 160.46, 60.23, 148.1, 64.98, 128.14, 69.74, 119.58, 74.97, 114.36, 77.82, 111.5, 72.59, 106.75]], "area": 5806.002300000002, "iscrowd": 0, "image_id": 10281, "bbox": [41.7, 105.33, 185.35, 172.99], "category_id": 38, "id": 1469313}, {"segmentation": [[521.87, 353.58, 496.69, 340.62, 479.29, 344.7, 441.51, 338.03, 390.04, 336.18, 378.56, 345.07, 371.53, 343.95, 359.68, 337.29, 341.53, 336.18, 315.24, 348.4, 308.95, 348.77, 294.5, 336.55, 236.0, 336.18, 188.23, 341.73, 172.31, 348.03, 168.23, 338.03, 183.41, 329.51, 206.0, 309.89, 232.66, 293.96, 251.55, 312.85, 285.99, 298.41, 303.02, 325.07, 354.49, 319.89, 392.63, 325.07, 426.33, 275.82, 448.55, 302.85, 475.21, 290.63, 500.76, 315.44, 509.65, 329.88, 522.98, 332.48, 528.17, 346.55, 526.68, 350.62]], "area": 10490.944599999999, "iscrowd": 0, "image_id": 10281, "bbox": [168.23, 275.82, 359.94, 77.76], "category_id": 38, "id": 1469830}, {"segmentation": [[583.33, 278.29, 599.83, 283.92, 612.3, 302.03, 625.58, 323.76, 617.94, 328.59, 580.51, 322.96, 556.77, 331.0, 540.27, 330.2, 540.27, 324.57, 507.27, 326.17, 555.16, 316.52, 570.05, 305.65, 576.89, 296.8, 580.92, 280.3]], "area": 2275.8699500000002, "iscrowd": 0, "image_id": 10281, "bbox": [507.27, 278.29, 118.31, 52.71], "category_id": 38, "id": 1469921}, {"segmentation": [[436.54, 270.08, 451.21, 262.91, 454.15, 269.76, 460.67, 294.87, 472.41, 289.98, 482.19, 294.54, 492.96, 281.82, 501.11, 290.96, 507.3, 306.93, 519.7, 308.24, 517.41, 288.02, 514.8, 278.24, 482.85, 276.28, 471.11, 281.82, 462.63, 264.54, 451.21, 248.89, 446.65, 252.15]], "area": 1340.1867500000008, "iscrowd": 0, "image_id": 10281, "bbox": [436.54, 248.89, 83.16, 59.35], "category_id": 38, "id": 1469970}, {"segmentation": [[365.52, 305.25, 342.86, 304.26, 331.13, 303.86, 320.79, 300.48, 317.21, 299.89, 302.31, 304.86, 290.38, 308.63, 283.42, 304.86, 279.65, 299.69, 289.19, 284.38, 308.67, 268.28, 341.47, 249.6, 351.4, 243.83, 352.2, 242.44, 360.15, 266.29, 367.7, 280.41, 372.87, 275.44, 392.35, 262.12, 397.32, 261.52, 399.31, 265.1, 403.09, 280.61, 407.26, 291.34, 396.33, 300.09, 386.98, 302.27]], "area": 4563.353949999999, "iscrowd": 0, "image_id": 10281, "bbox": [279.65, 242.44, 127.61, 66.19], "category_id": 38, "id": 1470035}, {"segmentation": [[226.51, 119.49, 228.51, 127.48, 226.7, 128.02, 226.7, 130.2, 226.7, 130.74, 227.06, 134.73, 227.6, 136.91, 228.51, 141.63, 228.69, 142.18, 229.96, 149.8, 229.96, 153.43, 228.69, 157.96, 226.88, 160.14, 225.79, 162.14, 225.06, 164.68, 224.52, 167.04, 225.61, 180.83, 225.79, 184.46, 237.22, 189.18, 237.4, 157.96, 238.13, 153.43, 238.31, 149.25, 238.31, 147.44, 240.13, 144.35, 235.77, 125.66, 235.04, 125.3, 233.41, 117.31, 232.5, 117.31, 229.78, 116.04, 226.88, 117.86, 226.15, 120.22], [231.41, 211.96, 235.73, 230.47, 241.28, 229.03, 241.08, 223.68, 240.05, 218.13, 239.64, 212.99, 237.79, 209.91, 234.91, 210.94, 231.41, 211.76]], "area": 847.6174500000003, "iscrowd": 0, "image_id": 10243, "bbox": [224.52, 116.04, 16.76, 114.43], "category_id": 44, "id": 1483932}, {"segmentation": [[4.62, 220.98, 33.77, 261.47, 41.06, 265.52, 59.68, 293.86, 15.96, 361.88, 0.57, 342.45, 0.0, 218.55]], "area": 4738.451349999999, "iscrowd": 0, "image_id": 10046, "bbox": [0.0, 218.55, 59.68, 143.33], "category_id": 44, "id": 1487988}, {"segmentation": [[261.06, 113.81, 261.34, 105.59, 275.86, 55.44, 279.42, 57.08, 280.52, 59.82, 272.02, 96.27, 272.02, 96.54, 271.75, 97.37, 267.64, 109.97]], "area": 387.5058499999995, "iscrowd": 0, "image_id": 10046, "bbox": [261.06, 55.44, 19.46, 58.37], "category_id": 50, "id": 1530578}, {"segmentation": [[267.77, 155.72, 251.32, 138.22, 237.48, 123.6, 222.86, 105.46, 217.64, 90.05, 218.94, 89.27, 227.82, 98.93, 246.1, 119.82, 255.76, 136.01, 261.76, 142.79, 272.21, 150.76]], "area": 537.1475499999998, "iscrowd": 0, "image_id": 10046, "bbox": [217.64, 89.27, 54.57, 66.45], "category_id": 50, "id": 1531235}, {"segmentation": [[250.79, 124.79, 277.17, 113.53, 303.2, 106.85, 328.87, 105.44, 332.39, 114.94, 339.42, 159.96, 314.8, 209.9, 301.79, 214.12, 273.65, 193.72, 231.8, 171.92, 230.04, 134.99, 243.05, 129.36, 269.78, 157.14, 273.65, 155.03]], "area": 7925.686750000002, "iscrowd": 0, "image_id": 10046, "bbox": [230.04, 105.44, 109.38, 108.68], "category_id": 51, "id": 1540184}, {"segmentation": [[369.56, 110.78, 364.18, 99.0, 363.17, 95.63, 365.52, 86.88, 373.27, 78.8, 391.78, 67.35, 395.48, 65.33, 406.59, 82.5, 414.67, 76.11, 410.3, 61.63, 419.39, 56.58, 441.94, 50.52, 467.86, 44.13, 488.39, 43.45, 498.49, 45.81, 500.18, 53.55, 498.16, 71.06, 499.17, 82.17, 476.28, 74.42, 462.47, 71.73, 439.58, 74.76, 422.08, 79.14, 403.9, 84.86, 384.04, 89.24, 377.64, 99.67]], "area": 3189.1501500000004, "iscrowd": 0, "image_id": 10046, "bbox": [363.17, 43.45, 137.01, 67.33], "category_id": 51, "id": 1540335}, {"segmentation": [[306.14, 94.62, 316.12, 102.94, 336.08, 110.15, 341.07, 127.34, 353.82, 135.1, 368.8, 112.37, 363.25, 92.96, 377.11, 76.32, 396.52, 61.35, 387.65, 51.93, 363.81, 54.14, 341.07, 58.58, 320.56, 73.0, 341.07, 84.64, 312.79, 81.87, 303.92, 89.63]], "area": 3479.3437500000005, "iscrowd": 0, "image_id": 10046, "bbox": [303.92, 51.93, 92.6, 83.17], "category_id": 51, "id": 1540502}, {"segmentation": [[86.29, 254.56, 76.58, 241.62, 61.48, 234.07, 55.01, 222.2, 78.74, 200.63, 96.0, 190.92, 104.63, 186.61, 120.81, 175.82, 159.64, 171.51, 180.13, 166.11, 177.98, 177.98, 177.98, 189.84, 144.54, 215.73, 111.1, 240.54]], "area": 5238.639949999999, "iscrowd": 0, "image_id": 10046, "bbox": [55.01, 166.11, 125.12, 88.45], "category_id": 51, "id": 1540993}, {"segmentation": [[250.51, 123.62, 289.24, 107.87, 308.27, 103.93, 301.05, 79.65, 282.67, 79.65, 248.55, 92.77, 248.55, 92.77, 224.92, 103.93, 219.67, 115.09, 203.92, 126.25, 224.92, 132.81, 247.89, 121.65]], "area": 2594.32115, "iscrowd": 0, "image_id": 10046, "bbox": [203.92, 79.65, 104.35, 53.16], "category_id": 51, "id": 1541105}, {"segmentation": [[291.62, 56.01, 317.94, 51.45, 324.96, 58.12, 322.15, 69.35, 317.24, 70.75, 306.71, 65.13, 292.32, 58.12], [279.34, 64.78, 284.95, 62.68, 305.66, 74.96, 312.33, 80.57, 307.06, 84.44, 300.04, 81.98, 296.53, 78.47, 284.95, 78.82, 274.07, 79.52], [264.6, 71.8, 247.76, 78.47, 244.95, 86.19, 244.6, 90.4, 259.34, 89.0, 264.6, 84.79, 272.32, 65.13]], "area": 1059.1706, "iscrowd": 0, "image_id": 10046, "bbox": [244.6, 51.45, 80.36, 38.95], "category_id": 51, "id": 1541218}, {"segmentation": [[378.82, 203.13, 364.17, 158.73, 378.36, 145.45, 381.57, 135.84, 380.65, 106.09, 414.53, 93.73, 426.89, 99.68, 438.79, 114.33, 444.28, 116.16, 439.71, 95.56, 453.44, 83.65, 476.33, 72.67, 496.93, 85.03, 494.64, 115.7, 512.03, 121.65, 516.15, 99.22, 543.16, 95.1, 568.34, 116.16, 564.22, 138.59, 574.75, 151.41, 586.65, 163.77, 590.77, 177.04, 588.94, 190.77, 568.8, 202.22, 580.24, 230.14, 545.45, 256.69, 535.38, 266.76, 490.52, 275.46, 453.9, 270.88, 424.6, 256.69, 420.02, 242.96, 408.58, 239.76, 379.74, 216.41, 376.99, 200.84]], "area": 31860.3224, "iscrowd": 0, "image_id": 10303, "bbox": [364.17, 72.67, 226.6, 202.79], "category_id": 52, "id": 1543566}, {"segmentation": [[416.93, 409.46, 416.93, 409.46, 424.41, 390.76, 439.37, 375.8, 457.13, 367.39, 490.79, 365.52, 514.16, 376.74, 524.44, 392.63, 535.66, 410.39, 535.66, 410.39]], "area": 3876.4890499999988, "iscrowd": 0, "image_id": 10403, "bbox": [416.93, 365.52, 118.73, 44.87], "category_id": 55, "id": 1556639}, {"segmentation": [[581.26, 406.75, 583.47, 391.71, 584.8, 375.35, 592.31, 354.57, 599.83, 340.86, 605.58, 330.25, 615.75, 322.29, 630.34, 309.46, 639.19, 305.93, 640.0, 416.0, 625.04, 405.87, 596.29, 404.54, 582.59, 405.87]], "area": 4269.166750000004, "iscrowd": 0, "image_id": 10403, "bbox": [581.26, 305.93, 58.74, 110.07], "category_id": 55, "id": 1558516}, {"segmentation": [[282.32, 187.9, 259.88, 175.75, 253.34, 164.53, 247.73, 144.9, 247.73, 123.4, 255.21, 97.22, 271.1, 73.85, 292.6, 65.44, 314.1, 58.89, 329.06, 55.16, 340.28, 57.02, 352.43, 61.7, 379.54, 80.4, 385.15, 99.09, 387.02, 129.01, 383.28, 130.88, 367.39, 123.4, 331.87, 124.33, 305.69, 136.49, 287.93, 147.7, 287.93, 175.75]], "area": 10059.791499999998, "iscrowd": 0, "image_id": 10403, "bbox": [247.73, 55.16, 139.29, 132.74], "category_id": 55, "id": 1558638}, {"segmentation": [[361.78, 230.9, 318.78, 229.03, 300.08, 233.71, 287.93, 247.73, 279.51, 262.69, 279.51, 294.47, 291.67, 315.04, 334.67, 261.75]], "area": 3495.946350000002, "iscrowd": 0, "image_id": 10403, "bbox": [279.51, 229.03, 82.27, 86.01], "category_id": 55, "id": 1558700}, {"segmentation": [[92.11, 343.17, 106.58, 338.35, 122.08, 337.31, 143.1, 336.97, 163.08, 354.2, 167.91, 359.37, 175.83, 378.66, 175.14, 402.09, 171.01, 413.12, 167.91, 415.18, 66.27, 416.0, 60.75, 400.37, 64.2, 378.66, 70.4, 363.16, 73.16, 359.37, 83.49, 347.65, 90.38, 343.86]], "area": 7657.026199999999, "iscrowd": 0, "image_id": 10403, "bbox": [60.75, 336.97, 115.08, 79.03], "category_id": 55, "id": 1558874}, {"segmentation": [[41.5, 212.52, 49.46, 192.62, 59.19, 179.35, 79.09, 176.7, 109.16, 182.89, 109.16, 182.89]], "area": 1005.4959000000003, "iscrowd": 0, "image_id": 10403, "bbox": [41.5, 176.7, 67.66, 35.82], "category_id": 55, "id": 1558908}, {"segmentation": [[263.21, 368.75, 261.83, 356.69, 265.27, 344.98, 274.58, 336.36, 283.19, 331.88, 290.08, 329.47, 293.53, 323.96, 293.18, 317.76, 290.43, 313.28, 288.01, 308.45, 273.2, 312.93, 262.17, 322.92, 253.21, 333.26, 249.77, 339.12, 247.7, 347.04, 247.01, 359.45]], "area": 1168.2665999999992, "iscrowd": 0, "image_id": 10403, "bbox": [247.01, 308.45, 46.52, 60.3], "category_id": 55, "id": 1559164}, {"segmentation": [[319.32, 55.71, 316.79, 51.49, 312.14, 52.76, 310.87, 54.66, 310.24, 57.61, 313.41, 62.26, 314.46, 63.32, 310.66, 67.75, 308.76, 65.43, 304.12, 65.01, 301.37, 65.85, 297.99, 63.74, 293.98, 60.78, 296.3, 57.4, 298.84, 53.81, 298.84, 51.7, 295.88, 51.7, 292.71, 53.18, 288.7, 53.39, 289.12, 44.52, 294.61, 34.38, 301.37, 29.53, 305.17, 28.68, 305.81, 28.68, 306.86, 25.51, 309.82, 24.46, 311.93, 26.36, 313.83, 26.36, 315.73, 27.63, 318.27, 34.6, 318.48, 36.28, 316.79, 39.66, 318.9, 43.68, 320.17, 44.94, 326.08, 45.58]], "area": 875.8981499999999, "iscrowd": 0, "image_id": 10414, "bbox": [288.7, 24.46, 37.38, 43.29], "category_id": 56, "id": 1560923}, {"segmentation": [[327.14, 187.65, 319.74, 170.8, 323.03, 160.94, 326.72, 151.09, 337.41, 146.57, 345.21, 137.53, 353.43, 131.37, 365.34, 134.65, 365.34, 143.28, 359.59, 153.14, 353.43, 157.66, 358.77, 173.27, 360.41, 188.06, 356.3, 189.29, 344.39, 189.29]], "area": 1727.1499999999992, "iscrowd": 0, "image_id": 10414, "bbox": [319.74, 131.37, 45.6, 57.92], "category_id": 56, "id": 1561570}, {"segmentation": [[303.68, 183.91, 304.6, 182.99, 306.89, 179.09, 309.19, 177.26, 311.02, 177.03, 313.55, 175.19, 313.32, 173.58, 312.17, 171.06, 309.88, 168.31, 307.81, 167.85, 307.58, 168.08, 305.29, 167.39, 302.53, 166.01, 300.7, 166.01, 296.57, 166.24, 291.75, 168.31, 290.14, 170.83, 288.3, 172.9, 287.84, 174.04, 288.53, 180.93, 295.42, 183.91, 300.01, 185.52, 302.76, 185.29, 303.68, 185.06]], "area": 347.4833500000003, "iscrowd": 0, "image_id": 10414, "bbox": [287.84, 166.01, 25.71, 19.51], "category_id": 56, "id": 1562132}, {"segmentation": [[401.92, 111.38, 407.8, 107.6, 413.27, 106.55, 415.79, 106.97, 417.68, 112.22, 423.57, 109.91, 426.51, 108.86, 431.98, 109.49, 433.87, 112.43, 433.87, 117.69, 432.19, 125.68, 431.77, 127.36, 428.83, 129.88, 419.37, 134.3, 416.21, 133.88, 420.63, 129.88, 420.63, 129.88, 420.42, 128.41, 415.58, 127.57, 412.64, 127.15, 410.11, 129.25, 409.06, 128.41, 406.54, 125.05, 401.49, 123.58, 398.76, 120.42, 398.34, 119.16, 400.44, 113.9]], "area": 637.5105, "iscrowd": 0, "image_id": 10414, "bbox": [398.34, 106.55, 35.53, 27.75], "category_id": 57, "id": 1564863}, {"segmentation": [[252.13, 336.27, 257.54, 325.64, 265.65, 319.33, 272.32, 317.35, 284.39, 316.99, 292.51, 317.53, 297.73, 319.33, 303.14, 320.77, 308.55, 324.74, 310.71, 328.7, 309.81, 331.41, 306.57, 335.55, 305.84, 340.42, 304.4, 344.56, 300.26, 346.37, 294.13, 348.89, 287.64, 351.95, 285.11, 352.5, 280.25, 349.25, 274.84, 348.71, 270.69, 348.89, 266.19, 349.25, 263.48, 349.61, 262.22, 349.97, 261.32, 350.33, 259.88, 349.97, 258.62, 349.61, 257.36, 347.09, 256.63, 343.48, 255.91, 340.78, 254.65, 338.62, 253.75, 337.35, 253.39, 336.99]], "area": 1539.3582999999996, "iscrowd": 0, "image_id": 10243, "bbox": [252.13, 316.99, 58.58, 35.51], "category_id": 60, "id": 1573412}, {"segmentation": [[245.74, 345.6, 251.26, 341.02, 251.4, 335.23, 249.64, 333.08, 249.64, 330.78, 247.09, 327.15, 243.18, 326.2, 234.15, 325.93, 229.71, 329.3, 226.47, 332.13, 224.18, 335.5, 224.18, 338.87, 223.78, 342.64, 226.2, 346.14, 227.82, 347.49, 231.59, 347.76, 239.0, 346.28, 245.6, 345.74]], "area": 476.1917499999997, "iscrowd": 0, "image_id": 10243, "bbox": [223.78, 325.93, 27.62, 21.83], "category_id": 60, "id": 1573790}, {"segmentation": [[288.64, 315.69, 288.64, 311.88, 292.34, 307.35, 298.54, 305.92, 303.19, 305.68, 306.64, 306.03, 309.03, 306.39, 312.96, 309.13, 314.27, 312.47, 314.75, 317.72, 314.75, 318.91, 313.91, 322.13, 310.93, 323.68, 303.42, 322.36, 298.66, 319.38, 291.98, 317.12]], "area": 343.8032499999999, "iscrowd": 0, "image_id": 10243, "bbox": [288.64, 305.68, 26.11, 18.0], "category_id": 60, "id": 1574716}, {"segmentation": [[359.94, 298.09, 366.91, 304.07, 369.3, 313.43, 363.52, 322.79, 348.39, 325.18, 338.63, 331.35, 327.07, 330.56, 319.11, 327.97, 314.33, 321.39, 314.33, 312.03, 324.88, 302.47, 334.84, 298.29, 342.01, 297.89]], "area": 1393.2164500000013, "iscrowd": 0, "image_id": 10243, "bbox": [314.33, 297.89, 54.97, 33.46], "category_id": 60, "id": 1574880}, {"segmentation": [[334.14, 393.17, 347.74, 387.48, 356.89, 377.59, 356.89, 363.99, 350.7, 356.33, 330.92, 349.41, 317.57, 346.69, 306.69, 347.67, 293.83, 356.82, 284.19, 366.47, 282.95, 379.82, 290.12, 387.98, 304.47, 392.92, 305.21, 397.13, 308.92, 397.87, 314.36, 394.16, 321.53, 394.9, 326.22, 397.37, 330.92, 397.37, 333.64, 395.89]], "area": 2804.1184999999996, "iscrowd": 0, "image_id": 10243, "bbox": [282.95, 346.69, 73.94, 51.18], "category_id": 60, "id": 1575260}, {"segmentation": [[205.05, 294.87, 191.69, 288.63, 188.12, 279.13, 188.12, 276.46, 194.66, 271.71, 196.73, 272.0, 203.56, 269.93, 210.1, 269.03, 216.33, 269.33, 221.67, 271.41, 226.72, 272.6, 229.99, 274.68, 232.07, 279.72, 232.07, 282.69, 219.0, 284.18, 213.96, 287.15, 209.2, 290.41]], "area": 710.4103000000001, "iscrowd": 0, "image_id": 10243, "bbox": [188.12, 269.03, 43.95, 25.84], "category_id": 60, "id": 1575314}, {"segmentation": [[253.7, 266.2, 250.09, 264.93, 248.81, 262.38, 248.81, 261.11, 249.45, 261.11, 250.09, 253.88, 256.67, 248.15, 268.14, 244.54, 278.76, 244.54, 285.99, 246.24, 289.17, 250.49, 289.6, 253.88, 288.32, 256.86, 287.9, 258.13, 284.71, 257.71, 282.8, 259.41, 281.31, 262.59, 277.49, 264.93, 268.57, 267.48, 261.56, 268.75, 255.4, 267.48]], "area": 724.9205000000005, "iscrowd": 0, "image_id": 10243, "bbox": [248.81, 244.54, 40.79, 24.21], "category_id": 60, "id": 1575399}, {"segmentation": [[328.16, 295.98, 312.58, 295.98, 304.53, 292.46, 303.02, 289.19, 302.27, 286.18, 301.26, 281.15, 310.06, 271.34, 318.86, 268.58, 326.4, 266.06, 335.2, 268.58, 344.51, 269.83, 348.78, 273.61, 351.55, 278.13, 351.55, 284.67, 349.28, 287.69, 346.27, 289.95, 340.48, 292.71]], "area": 1148.042800000001, "iscrowd": 0, "image_id": 10243, "bbox": [301.26, 266.06, 50.29, 29.92], "category_id": 60, "id": 1575922}, {"segmentation": [[285.34, 308.1, 291.75, 306.27, 296.48, 303.07, 298.77, 297.88, 298.92, 289.64, 298.31, 285.21, 292.66, 282.0, 285.34, 281.24, 271.75, 281.7, 261.53, 283.38, 256.8, 285.06, 249.93, 289.02, 246.26, 294.21, 246.72, 298.95, 248.55, 303.83, 249.47, 305.51, 246.42, 307.19, 248.71, 308.87, 255.42, 310.39, 266.26, 311.0, 264.58, 312.68, 264.88, 313.29, 271.45, 313.9, 276.64, 313.29, 279.38, 312.07, 281.22, 311.46, 284.57, 310.85]], "area": 1357.62875, "iscrowd": 0, "image_id": 10243, "bbox": [246.26, 281.24, 52.66, 32.66], "category_id": 60, "id": 1576115}, {"segmentation": [[375.0, 280.56, 367.67, 281.65, 357.21, 281.83, 351.08, 281.65, 349.82, 281.65, 350.18, 276.78, 347.3, 273.53, 344.05, 269.93, 339.37, 269.39, 340.09, 265.6, 342.97, 260.38, 351.44, 257.49, 358.83, 256.59, 370.37, 257.13, 375.0, 258.39]], "area": 726.1996999999997, "iscrowd": 0, "image_id": 10243, "bbox": [339.37, 256.59, 35.63, 25.24], "category_id": 60, "id": 1576143}, {"segmentation": [[307.49, 261.58, 307.17, 257.39, 308.14, 254.81, 312.98, 251.58, 316.53, 249.97, 320.72, 248.35, 322.01, 248.35, 327.17, 248.03, 333.63, 247.71, 338.79, 248.03, 343.95, 249.32, 349.76, 253.52, 350.41, 255.77, 351.05, 257.06, 349.44, 258.36, 345.89, 259.32, 340.08, 262.23, 338.47, 267.71, 337.18, 268.36, 328.14, 268.36, 322.66, 266.74, 318.78, 265.13, 313.94, 270.29, 312.98, 269.65, 309.75, 262.23]], "area": 671.1234000000001, "iscrowd": 0, "image_id": 10243, "bbox": [307.17, 247.71, 43.88, 22.58], "category_id": 60, "id": 1576198}, {"segmentation": [[246.44, 273.29, 243.53, 278.45, 245.15, 280.71, 253.54, 286.52, 258.05, 284.9, 263.54, 278.77, 265.15, 275.87, 260.96, 273.61, 249.67, 272.97]], "area": 193.16459999999927, "iscrowd": 0, "image_id": 10243, "bbox": [243.53, 272.97, 21.62, 13.55], "category_id": 60, "id": 1576218}, {"segmentation": [[355.85, 0.0, 526.32, 0.0, 627.25, 0.0, 616.65, 34.81, 592.9, 103.09, 574.67, 125.56, 560.67, 124.71, 556.43, 110.29, 556.43, 92.91, 553.46, 67.04, 542.86, 57.71, 547.53, 95.45, 536.08, 93.76, 513.6, 97.57, 505.12, 116.23, 497.06, 121.74, 479.25, 127.68, 391.05, 98.42, 369.0, 66.19, 351.18, 61.53, 312.17, 58.14, 323.62, 0.0]], "area": 28942.88735, "iscrowd": 0, "image_id": 10403, "bbox": [312.17, 0.0, 315.08, 127.68], "category_id": 62, "id": 1583560}, {"segmentation": [[154.51, 75.8, 148.39, 49.79, 154.89, 47.11, 163.69, 47.87, 167.13, 53.61, 168.66, 64.71, 184.73, 67.77, 184.73, 69.68, 171.72, 69.68, 172.1, 75.42]], "area": 530.8789000000004, "iscrowd": 0, "image_id": 10082, "bbox": [148.39, 47.11, 36.34, 28.69], "category_id": 62, "id": 1594617}, {"segmentation": [[190.7, 70.94, 191.29, 65.43, 188.73, 57.37, 187.35, 49.7, 187.35, 45.96, 190.11, 44.19, 193.45, 43.41, 196.6, 43.21, 198.56, 43.41, 201.51, 44.0, 203.28, 44.19, 204.66, 49.5, 206.23, 57.17, 205.64, 67.59, 205.25, 69.36]], "area": 427.65205, "iscrowd": 0, "image_id": 10082, "bbox": [187.35, 43.21, 18.88, 27.73], "category_id": 62, "id": 1594766}, {"segmentation": [[208.76, 40.08, 211.48, 39.0, 214.01, 38.46, 217.99, 38.27, 222.33, 38.27, 223.24, 38.64, 224.32, 57.09, 224.32, 57.82, 225.05, 58.18, 227.22, 58.18, 230.84, 58.9, 232.83, 60.17, 232.83, 61.07, 232.28, 61.62, 233.91, 64.87, 234.09, 67.95, 232.28, 68.85, 230.29, 65.42, 228.67, 64.33, 228.67, 66.32, 228.48, 68.31, 227.4, 68.67, 225.05, 64.69, 224.5, 65.05, 224.5, 67.41, 223.78, 68.49, 222.51, 66.68, 219.8, 64.33, 214.37, 64.69, 212.02, 64.51, 210.03, 62.34, 208.4, 58.18, 208.22, 54.92, 208.22, 49.13, 208.22, 43.52, 207.49, 41.35, 208.04, 40.63]], "area": 478.71460000000013, "iscrowd": 0, "image_id": 10082, "bbox": [207.49, 38.27, 26.6, 30.58], "category_id": 62, "id": 1596540}, {"segmentation": [[152.12, 73.24, 149.52, 56.07, 134.95, 57.37, 136.24, 70.32]], "area": 227.71305000000004, "iscrowd": 0, "image_id": 10082, "bbox": [134.95, 56.07, 17.17, 17.17], "category_id": 62, "id": 1597397}, {"segmentation": [[319.53, 370.39, 329.13, 375.18, 327.21, 418.36, 323.37, 419.32, 591.08, 414.53, 609.31, 360.79, 607.4, 335.84, 597.8, 316.65, 582.45, 304.18, 571.89, 301.3, 537.35, 324.33, 519.12, 333.92, 438.51, 301.3, 428.92, 303.22, 417.4, 319.53, 418.36, 332.96, 418.36, 337.76, 382.86, 350.24, 379.02, 353.11, 355.03, 337.76, 342.56, 335.84, 328.17, 339.68, 318.57, 350.24, 318.57, 362.71]], "area": 25682.540049999996, "iscrowd": 0, "image_id": 10145, "bbox": [318.57, 301.3, 290.74, 118.02], "category_id": 62, "id": 1598926}, {"segmentation": [[318.14, 382.86, 324.41, 382.01, 325.55, 379.15, 329.54, 380.58, 339.51, 372.31, 337.23, 368.89, 334.67, 366.9, 330.39, 366.61, 315.85, 378.01, 316.71, 383.15]], "area": 205.66459999999992, "iscrowd": 0, "image_id": 10176, "bbox": [315.85, 366.61, 23.66, 16.54], "category_id": 75, "id": 1632982}, {"segmentation": [[226.59, 431.05, 298.65, 436.0, 297.3, 426.55, 296.4, 424.74, 231.09, 417.99, 224.34, 425.64, 225.69, 431.05]], "area": 874.1210999999997, "iscrowd": 0, "image_id": 10176, "bbox": [224.34, 417.99, 74.31, 18.01], "category_id": 75, "id": 1633143}, {"segmentation": [[374.14, 279.06, 397.42, 278.7, 397.9, 275.95, 397.3, 275.0, 373.06, 275.59, 373.06, 277.98]], "area": 87.80820000000018, "iscrowd": 0, "image_id": 10145, "bbox": [373.06, 275.0, 24.84, 4.06], "category_id": 75, "id": 1633279}, {"segmentation": [[267.9, 375.63, 259.19, 376.17, 245.49, 378.48, 244.6, 377.68, 241.39, 374.83, 243.53, 371.01, 267.37, 368.78]], "area": 174.09700000000072, "iscrowd": 0, "image_id": 10176, "bbox": [241.39, 368.78, 26.51, 9.7], "category_id": 75, "id": 1633877}, {"segmentation": [[413.41, 263.24, 430.81, 265.08, 433.32, 266.76, 433.82, 277.63, 431.98, 279.81, 410.74, 277.97, 407.23, 276.13, 405.22, 271.61, 410.57, 265.59, 411.07, 264.58]], "area": 372.3500000000003, "iscrowd": 0, "image_id": 10145, "bbox": [405.22, 263.24, 28.6, 16.57], "category_id": 76, "id": 1634235}, {"segmentation": [[190.87, 159.95, 213.36, 170.45, 214.4, 163.41, 194.56, 155.11, 192.37, 155.22, 190.76, 154.65, 190.29, 154.42, 189.49, 153.72, 189.37, 153.72, 188.45, 153.61, 185.45, 153.96, 184.76, 153.96, 180.49, 154.19, 179.22, 154.88, 179.34, 155.69, 186.95, 155.69, 189.72, 155.69, 191.22, 155.92, 192.6, 156.72, 192.6, 156.95, 192.6, 157.88, 191.45, 159.03]], "area": 171.92539999999957, "iscrowd": 0, "image_id": 10130, "bbox": [179.22, 153.61, 35.18, 16.84], "category_id": 77, "id": 1636873}, {"segmentation": [[423.52, 115.37, 575.22, 41.4, 582.73, 44.08, 584.34, 45.69, 620.25, 113.23, 622.4, 123.95, 619.72, 128.77, 614.89, 133.6, 608.46, 135.2, 465.87, 202.21, 457.83, 197.92, 452.47, 192.56, 434.24, 145.93, 428.35, 131.99, 419.23, 123.95]], "area": 17712.0472, "iscrowd": 0, "image_id": 10130, "bbox": [419.23, 41.4, 203.17, 160.81], "category_id": 77, "id": 1637273}, {"segmentation": [[21.5, 219.0, 100.5, 218.5, 106.5, 225.0, 104.5, 392.5, 82.5, 398.5, 16.0, 399.5, 8.0, 388.5, 10.0, 224.0]], "area": 17232.5, "iscrowd": 0, "image_id": 10130, "bbox": [8.0, 218.5, 98.5, 181.0], "category_id": 77, "id": 1639664}, {"segmentation": [[298.97, 74.62, 298.28, 61.39, 304.72, 60.58, 308.63, 61.62, 308.98, 78.99, 305.07, 79.34]], "area": 169.7854500000001, "iscrowd": 0, "image_id": 10130, "bbox": [298.28, 60.58, 10.7, 18.76], "category_id": 77, "id": 1639926}, {"segmentation": [[309.53, 78.96, 309.53, 62.63, 311.72, 59.98, 315.29, 59.86, 320.81, 59.75, 321.38, 61.25, 321.38, 78.62, 320.35, 79.31]], "area": 224.79370000000037, "iscrowd": 0, "image_id": 10130, "bbox": [309.53, 59.75, 11.85, 19.56], "category_id": 77, "id": 1640051}, {"segmentation": [[536.7, 267.45, 545.46, 267.21, 546.9, 268.77, 546.9, 285.33, 536.58, 285.93, 535.62, 284.49, 535.5, 269.01, 536.46, 266.85]], "area": 205.6679999999997, "iscrowd": 0, "image_id": 10130, "bbox": [535.5, 266.85, 11.4, 19.08], "category_id": 77, "id": 1640094}, {"segmentation": [[558.81, 284.91, 559.61, 267.31, 562.95, 265.58, 568.47, 265.58, 570.31, 267.65, 570.43, 284.91, 564.79, 284.1]], "area": 205.40699999999978, "iscrowd": 0, "image_id": 10130, "bbox": [558.81, 265.58, 11.62, 19.33], "category_id": 77, "id": 1640113}, {"segmentation": [[136.26, 219.98, 231.25, 221.9, 228.37, 396.53, 221.66, 399.41, 135.3, 397.49, 136.26, 361.03]], "area": 16619.879700000005, "iscrowd": 0, "image_id": 10130, "bbox": [135.3, 219.98, 95.95, 179.43], "category_id": 77, "id": 1640127}, {"segmentation": [[288.31, 71.32, 288.12, 62.78, 290.85, 61.5, 294.12, 61.5, 296.67, 61.5, 297.03, 73.68, 288.67, 71.5]], "area": 93.39489999999992, "iscrowd": 0, "image_id": 10130, "bbox": [288.12, 61.5, 8.91, 12.18], "category_id": 77, "id": 1640138}, {"segmentation": [[0.0, 53.22, 65.71, 41.92, 65.71, 34.5, 57.96, 0.0, 0.85, 0.0]], "area": 2969.5187, "iscrowd": 0, "image_id": 10243, "bbox": [0.0, 0.0, 65.71, 53.22], "category_id": 78, "id": 1640488}, {"segmentation": [[436.27, 89.33, 436.68, 68.69, 444.04, 68.49, 445.26, 70.33, 443.42, 91.79, 435.45, 91.79]], "area": 184.5608000000003, "iscrowd": 0, "image_id": 10346, "bbox": [435.45, 68.49, 9.81, 23.3], "category_id": 84, "id": 1653596}, {"segmentation": [[51.76, 182.56, 71.57, 139.46, 77.98, 116.74, 78.56, 110.33, 80.89, 99.26, 82.64, 87.61, 92.54, 75.96, 92.54, 71.3, 104.19, 53.24, 114.09, 42.17, 122.25, 32.27, 129.82, 33.43, 133.32, 38.09, 142.05, 35.76, 153.71, 35.18, 163.61, 38.09, 174.09, 46.25, 174.68, 66.06, 174.09, 72.46, 177.59, 78.87, 171.18, 85.28, 164.19, 95.18, 158.37, 105.67, 158.95, 112.08, 163.61, 130.72, 164.19, 138.29, 168.27, 143.53, 177.59, 144.12, 184.0, 141.2, 185.75, 137.13, 189.82, 138.29, 193.9, 141.2, 201.47, 141.79, 210.79, 141.79, 216.04, 149.94, 209.05, 152.27, 198.56, 154.6, 188.66, 161.59, 180.5, 164.5, 168.85, 170.33, 165.94, 165.67, 142.64, 163.92, 128.07, 163.92, 110.6, 169.75, 105.94, 177.9, 89.04, 179.07, 76.23, 181.4, 59.33, 182.56]], "area": 12441.07505, "iscrowd": 0, "image_id": 10130, "bbox": [51.76, 32.27, 164.28, 150.29], "category_id": 1, "id": 1685208}, {"segmentation": [[416.1, 236.96, 413.93, 236.96, 411.77, 236.96, 411.91, 235.52, 412.49, 234.22, 412.06, 230.61, 411.91, 229.6, 412.78, 228.16, 415.23, 228.45, 416.67, 231.33, 418.26, 234.22, 417.54, 236.52]], "area": 41.93810000000009, "iscrowd": 0, "image_id": 10318, "bbox": [411.77, 228.16, 6.49, 8.8], "category_id": 1, "id": 1695063}, {"segmentation": [[387.12, 237.26, 385.92, 235.53, 386.32, 233.8, 387.52, 232.47, 388.98, 232.47, 389.51, 235.39, 389.38, 236.33, 389.38, 237.12]], "area": 13.368099999999982, "iscrowd": 0, "image_id": 10318, "bbox": [385.92, 232.47, 3.59, 4.79], "category_id": 1, "id": 1695507}, {"segmentation": [[393.77, 240.18, 393.77, 238.67, 395.45, 238.25, 396.21, 238.25, 396.21, 239.42, 396.04, 240.01], [394.11, 241.94, 396.96, 241.86, 395.62, 243.62, 395.7, 244.38, 395.7, 245.39, 394.69, 245.64, 393.94, 244.97]], "area": 10.982549999999947, "iscrowd": 0, "image_id": 10318, "bbox": [393.77, 238.25, 3.19, 7.39], "category_id": 1, "id": 1697617}, {"segmentation": [[514.95, 190.69, 517.11, 184.21, 517.98, 181.62, 521.43, 181.18, 524.02, 187.23, 525.32, 189.83]], "area": 60.95819999999968, "iscrowd": 0, "image_id": 10230, "bbox": [514.95, 181.18, 10.37, 9.51], "category_id": 1, "id": 1700352}, {"segmentation": [[551.97, 184.46, 551.03, 182.57, 550.71, 180.78, 550.39, 178.79, 549.97, 177.84, 549.87, 176.06, 550.08, 174.48, 550.18, 172.8, 550.81, 171.33, 552.81, 170.28, 554.07, 170.28, 553.97, 169.44, 553.76, 168.07, 554.6, 167.23, 555.96, 166.81, 557.54, 166.92, 558.17, 167.65, 557.85, 168.91, 557.33, 170.28, 557.43, 171.22, 557.64, 173.43, 558.38, 175.53, 558.48, 177.32, 558.48, 178.68, 558.9, 180.47, 558.9, 182.36, 558.8, 184.88]], "area": 123.69389999999981, "iscrowd": 0, "image_id": 10230, "bbox": [549.87, 166.81, 9.03, 18.07], "category_id": 1, "id": 1703245}, {"segmentation": [[399.57, 247.34, 399.17, 238.67, 399.17, 235.45, 401.79, 235.25, 404.81, 239.48, 404.81, 243.51, 405.22, 247.54, 403.61, 250.36, 400.58, 248.15]], "area": 69.35205000000016, "iscrowd": 0, "image_id": 10318, "bbox": [399.17, 235.25, 6.05, 15.11], "category_id": 1, "id": 1703852}, {"segmentation": [[582.18, 182.99, 581.89, 176.9, 581.4, 175.45, 579.47, 173.81, 578.89, 172.45, 579.37, 171.2, 580.24, 170.52, 581.02, 170.13, 580.92, 168.68, 580.92, 167.52, 581.6, 167.14, 582.95, 167.04, 583.72, 167.43, 584.21, 168.68, 585.08, 170.04, 588.36, 172.55, 588.85, 173.61, 587.49, 174.68, 586.24, 175.26, 585.56, 178.25, 585.56, 180.38, 585.46, 181.93, 584.98, 183.09]], "area": 78.42550000000037, "iscrowd": 0, "image_id": 10230, "bbox": [578.89, 167.04, 9.96, 16.05], "category_id": 1, "id": 1704484}, {"segmentation": [[196.43, 226.83, 199.11, 216.45, 201.28, 207.59, 199.78, 204.58, 196.1, 202.9, 196.27, 198.39, 196.27, 195.88, 195.1, 193.03, 191.08, 191.86, 188.4, 193.54, 187.57, 196.88, 188.91, 202.74, 186.9, 207.76, 186.73, 212.1, 185.89, 214.11, 183.89, 220.97, 183.89, 222.14, 186.23, 224.15, 187.9, 224.15, 189.24, 218.63, 191.08, 210.43, 191.75, 208.42, 193.09, 208.93, 193.76, 213.61, 192.75, 219.63, 194.93, 221.64, 194.93, 226.32, 196.77, 229.34]], "area": 308.34675000000044, "iscrowd": 0, "image_id": 10281, "bbox": [183.89, 191.86, 17.39, 37.48], "category_id": 1, "id": 1711506}, {"segmentation": [[307.21, 349.9, 328.1, 296.73, 347.1, 281.53, 357.23, 280.27, 352.01, 273.31, 387.61, 232.79, 397.11, 239.75, 397.11, 239.75, 411.04, 237.85, 425.6, 245.45, 430.66, 262.54, 424.33, 280.27, 424.33, 280.27, 419.59, 287.44, 418.63, 289.76, 404.71, 304.96, 404.71, 304.96, 407.87, 343.57, 413.57, 349.27, 413.57, 349.27, 414.2, 341.04, 424.96, 344.84, 424.33, 365.1, 399.64, 370.16, 385.71, 370.16, 377.48, 371.43, 378.75, 377.13, 306.58, 394.85, 318.61, 368.26, 314.18, 361.3, 304.68, 360.03, 306.58, 351.8]], "area": 11986.421250000005, "iscrowd": 0, "image_id": 10130, "bbox": [304.68, 232.79, 125.98, 162.06], "category_id": 1, "id": 1713472}, {"segmentation": [[78.71, 200.97, 26.05, 124.71, 32.86, 98.84, 59.19, 78.87, 107.75, 51.18, 125.91, 35.3, 111.84, 104.29, 105.49, 135.61, 100.04, 208.23]], "area": 8576.342250000002, "iscrowd": 0, "image_id": 10232, "bbox": [26.05, 35.3, 99.86, 172.93], "category_id": 1, "id": 1717125}, {"segmentation": [[41.9, 172.14, 43.63, 172.67, 43.71, 174.78, 45.29, 175.15, 46.65, 176.81, 44.99, 177.94, 45.22, 180.28, 45.37, 184.72, 44.84, 188.56, 45.22, 189.99, 43.71, 189.99, 41.37, 189.46, 40.85, 185.55, 40.7, 181.18, 40.7, 178.77, 38.81, 178.47, 39.42, 175.68, 40.25, 174.85, 40.92, 174.32, 40.92, 172.37, 41.83, 172.22]], "area": 79.07260000000004, "iscrowd": 0, "image_id": 10230, "bbox": [38.81, 172.14, 7.84, 17.85], "category_id": 1, "id": 1722632}, {"segmentation": [[127.57, 6.33, 123.36, 40.06, 59.04, 70.64, 32.68, 90.67, 21.09, 94.89, 1.05, 87.51, 1.05, 48.5, 2.11, 2.11, 124.41, 2.11], [87.51, 216.14, 81.18, 241.44, 80.13, 265.69, 79.07, 281.5, 73.8, 293.1, 68.53, 309.97, 70.64, 319.46, 76.97, 327.89, 85.4, 338.44, 97.0, 342.65, 107.54, 352.14, 117.03, 415.4, 117.03, 421.73, 160.26, 417.51, 141.28, 372.18, 140.22, 330.0, 117.03, 218.24, 95.94, 206.65]], "area": 17710.756699999998, "iscrowd": 0, "image_id": 10232, "bbox": [1.05, 2.11, 159.21, 419.62], "category_id": 1, "id": 1741584}, {"segmentation": [[142.74, 314.45, 157.25, 280.6, 188.42, 272.54, 205.08, 237.07, 240.54, 266.62, 227.11, 285.43, 246.99, 307.47, 235.17, 340.25, 245.38, 381.09, 224.96, 391.27, 206.69, 435.87, 193.25, 451.99, 181.43, 433.18, 155.64, 429.42, 147.58, 412.76, 156.71, 384.28, 149.73, 354.24, 156.71, 331.68]], "area": 14060.934849999998, "iscrowd": 0, "image_id": 10094, "bbox": [142.74, 237.07, 104.25, 214.92], "category_id": 1, "id": 1741894}, {"segmentation": [[517.1, 227.51, 517.51, 231.41, 517.2, 233.88, 514.43, 234.08, 514.74, 230.59, 514.23, 228.23, 514.84, 226.9, 514.84, 225.15, 515.56, 224.84, 516.18, 225.25, 516.9, 226.59]], "area": 22.72984999999996, "iscrowd": 0, "image_id": 10281, "bbox": [514.23, 224.84, 3.28, 9.24], "category_id": 1, "id": 1744146}, {"segmentation": [[258.33, 135.42, 269.64, 122.41, 282.66, 92.42, 293.41, 74.89, 312.64, 62.44, 322.26, 60.74, 320.56, 58.48, 316.03, 48.86, 320.56, 38.11, 329.05, 27.93, 336.97, 22.84, 354.5, 23.87, 364.12, 38.02, 366.38, 47.63, 368.08, 54.42, 369.21, 56.12, 362.42, 61.78, 355.64, 66.3, 355.64, 70.26, 362.42, 75.35, 364.69, 84.97, 363.56, 101.38, 365.82, 113.82, 379.96, 159.97, 383.92, 180.34, 387.88, 193.92, 390.15, 198.44, 391.28, 200.71, 382.79, 212.02, 377.7, 212.02, 370.91, 212.02, 366.95, 212.02, 369.21, 204.67, 374.87, 184.86, 353.94, 135.08, 348.85, 108.49, 300.76, 122.07, 300.19, 122.07, 295.1, 107.92, 287.18, 124.9, 286.05, 126.59, 258.9, 135.65], [348.59, 215.94, 343.72, 243.52, 348.59, 261.37, 338.04, 270.29, 335.61, 291.38, 319.79, 294.22, 319.79, 288.14, 315.32, 294.22, 296.26, 301.93, 295.04, 298.28, 290.58, 297.87, 286.12, 298.28, 307.21, 266.64, 300.72, 266.24, 309.65, 233.79, 300.72, 219.99, 349.4, 212.69, 348.99, 217.56]], "area": 10674.347200000002, "iscrowd": 0, "image_id": 10445, "bbox": [258.33, 22.84, 132.95, 279.09], "category_id": 1, "id": 1750386}, {"segmentation": [[389.16, 87.15, 382.5, 120.44, 375.85, 131.93, 376.45, 143.43, 376.45, 152.51, 390.37, 167.04, 382.5, 164.62, 369.79, 152.51, 371.61, 142.22, 363.14, 142.22, 352.24, 144.04, 351.03, 156.14, 371.0, 165.22, 181.56, 161.59, 172.49, 160.99, 180.35, 157.96, 158.57, 147.67, 154.33, 114.99, 165.22, 106.51, 170.07, 124.67, 177.33, 113.17, 180.96, 116.2, 183.38, 125.88, 175.51, 138.59, 173.09, 145.86, 175.51, 151.3, 186.41, 153.12, 185.8, 131.93, 199.12, 129.51, 196.7, 151.91, 212.43, 149.49, 233.01, 137.38, 237.85, 117.41, 246.93, 118.01, 249.96, 134.96, 259.64, 130.72, 301.4, 133.75, 320.77, 130.72, 333.48, 130.72, 336.51, 108.33, 346.79, 102.88, 350.43, 108.94, 349.82, 133.75, 371.0, 131.93, 372.21, 120.44, 371.0, 107.73, 371.0, 101.07, 366.77, 92.59, 372.21, 92.59, 374.03, 101.07, 376.45, 111.96, 383.11, 99.25, 383.11, 86.54, 387.95, 85.94]], "area": 7013.835699999999, "iscrowd": 0, "image_id": 10229, "bbox": [154.33, 85.94, 236.04, 81.1], "category_id": 2, "id": 1764862}, {"segmentation": [[125.49, 142.56, 166.35, 56.68, 290.33, 59.45, 283.4, 249.91, 284.09, 297.7, 179.51, 307.4, 181.59, 309.47, 162.2, 298.39, 161.51, 295.62, 151.12, 294.93, 152.6, 274.83, 148.32, 271.02, 141.17, 269.11, 136.41, 274.35, 131.17, 275.78, 125.93, 275.78, 125.45, 190.52, 124.02, 141.45]], "area": 36776.659799999994, "iscrowd": 0, "image_id": 10239, "bbox": [124.02, 56.68, 166.31, 252.79], "category_id": 6, "id": 1794665}, {"segmentation": [[118.43, 99.17, 123.51, 93.64, 177.0, 94.97, 167.93, 100.49]], "area": 293.88424999999984, "iscrowd": 0, "image_id": 10318, "bbox": [118.43, 93.64, 58.57, 6.85], "category_id": 9, "id": 1802355}, {"segmentation": [[32.16, 102.5, 36.19, 94.19, 43.09, 94.71, 45.5, 99.73, 49.47, 99.83, 49.78, 102.03, 34.21, 102.65]], "area": 93.96210000000013, "iscrowd": 0, "image_id": 10318, "bbox": [32.16, 94.19, 17.62, 8.46], "category_id": 9, "id": 1802682}, {"segmentation": [[52.03, 99.13, 53.08, 93.69, 56.22, 92.86, 59.46, 92.65, 62.38, 93.27, 63.43, 95.57, 63.32, 97.77, 63.53, 98.92, 65.0, 99.23, 65.41, 99.65, 65.41, 101.11, 64.89, 103.31, 55.17, 104.36, 53.18, 104.25, 52.66, 102.68]], "area": 125.71050000000001, "iscrowd": 0, "image_id": 10318, "bbox": [52.03, 92.65, 13.38, 11.71], "category_id": 9, "id": 1803143}, {"segmentation": [[79.77, 92.59, 90.55, 94.2, 93.32, 94.78, 93.32, 96.68, 83.12, 99.3, 76.56, 93.76]], "area": 65.10764999999994, "iscrowd": 0, "image_id": 10318, "bbox": [76.56, 92.59, 16.76, 6.71], "category_id": 9, "id": 1803353}, {"segmentation": [[13.37, 100.1, 19.53, 98.63, 23.59, 97.89, 32.33, 98.26, 30.98, 102.81, 11.4, 102.44, 12.14, 100.35, 14.23, 99.61]], "area": 78.80505000000002, "iscrowd": 0, "image_id": 10318, "bbox": [11.4, 97.89, 20.93, 4.92], "category_id": 9, "id": 1803380}, {"segmentation": [[287.91, 144.0, 285.82, 165.48, 290.89, 167.27, 293.57, 179.21, 297.75, 168.76, 302.53, 157.43, 307.6, 154.14, 303.12, 147.88, 304.02, 143.7, 308.79, 141.02, 305.51, 138.93, 304.02, 133.26]], "area": 519.5937499999998, "iscrowd": 0, "image_id": 10005, "bbox": [285.82, 133.26, 22.97, 45.95], "category_id": 27, "id": 1825629}, {"segmentation": [[471.36, 409.25, 456.95, 258.42, 455.84, 237.35, 456.67, 226.91, 463.33, 213.6, 431.16, 201.4, 397.89, 202.51, 400.11, 229.13, 418.96, 230.24, 428.95, 261.29, 446.69, 427.0, 473.31, 425.44], [254.82, 220.26, 271.45, 245.77, 251.49, 252.42, 251.49, 276.82, 241.51, 280.15, 261.47, 427.0, 238.18, 426.55, 219.33, 281.26, 212.67, 251.31, 201.58, 238.0, 201.58, 232.46, 208.24, 229.13, 257.04, 218.04]], "area": 13035.366000000002, "iscrowd": 0, "image_id": 10232, "bbox": [201.58, 201.4, 271.73, 225.6], "category_id": 33, "id": 1843412}, {"segmentation": [[141.43, 122.0, 155.01, 122.29, 164.27, 123.44, 171.78, 126.33, 177.27, 129.51, 179.87, 134.43, 179.87, 139.34, 175.83, 141.94, 174.96, 143.1, 171.49, 145.12, 162.24, 146.57, 152.41, 145.7, 144.03, 143.1, 137.96, 140.21, 133.62, 137.03, 131.02, 135.0, 129.58, 128.93, 133.05, 124.31, 137.67, 122.58]], "area": 943.7643999999996, "iscrowd": 0, "image_id": 10358, "bbox": [129.58, 122.0, 50.29, 24.57], "category_id": 34, "id": 1844853}, {"segmentation": [[205.46, 236.54, 208.32, 234.63, 214.06, 233.68, 215.33, 230.49, 220.75, 225.08, 222.66, 219.35, 227.12, 215.2, 234.44, 211.38, 240.17, 208.2, 249.41, 207.56, 255.14, 202.78, 260.88, 193.55, 265.97, 188.13, 265.97, 180.81, 266.29, 176.03, 270.43, 170.3, 274.25, 169.34, 276.48, 173.16, 273.62, 183.99, 272.03, 193.23, 271.39, 200.87, 270.11, 206.29, 265.97, 210.43, 263.11, 216.16, 260.56, 218.07, 256.74, 219.03, 251.64, 216.8, 249.41, 214.89, 241.77, 218.07, 236.35, 221.26, 230.62, 223.8, 226.16, 227.31, 228.71, 230.81, 225.52, 237.18, 222.02, 241.0, 222.02, 244.51, 214.38, 250.88, 211.51, 252.79, 207.05, 243.87, 207.37, 239.09]], "area": 1161.6313499999992, "iscrowd": 0, "image_id": 10281, "bbox": [205.46, 169.34, 71.02, 83.45], "category_id": 38, "id": 1855596}, {"segmentation": [[437.29, 144.28, 439.63, 143.53, 442.29, 143.53, 443.43, 143.97, 446.4, 145.55, 449.06, 151.25, 448.55, 154.41, 447.04, 156.44, 445.45, 158.91, 443.74, 159.6, 443.43, 158.53, 445.9, 155.3, 446.53, 153.02, 446.91, 151.0, 446.91, 150.68, 445.64, 147.96, 443.74, 146.44, 438.81, 145.99, 436.53, 147.01, 433.11, 148.78, 432.98, 147.39, 433.68, 146.06]], "area": 57.8832499999999, "iscrowd": 0, "image_id": 10281, "bbox": [432.98, 143.53, 16.08, 16.07], "category_id": 38, "id": 1855911}, {"segmentation": [[285.51, 177.71, 284.0, 173.79, 284.0, 171.83, 284.61, 170.33, 286.26, 169.72, 288.67, 170.48, 290.33, 171.68, 289.13, 172.13, 286.41, 171.53, 285.51, 172.13, 285.66, 174.24, 285.66, 175.3]], "area": 15.357250000000063, "iscrowd": 0, "image_id": 10281, "bbox": [284.0, 169.72, 6.33, 7.99], "category_id": 38, "id": 1856943}, {"segmentation": [[245.95, 174.82, 247.86, 173.8, 249.52, 174.05, 251.69, 175.58, 251.56, 177.62, 250.8, 180.43, 249.65, 181.07, 249.01, 179.41, 249.65, 178.13, 249.78, 176.99, 249.52, 176.22, 248.63, 175.97, 246.84, 175.97]], "area": 17.47104999999998, "iscrowd": 0, "image_id": 10281, "bbox": [245.95, 173.8, 5.74, 7.27], "category_id": 38, "id": 1856966}, {"segmentation": [[271.73, 6.65, 280.6, 106.47, 280.6, 106.47, 359.35, 99.82, 359.35, 1.11, 272.84, 2.22, 272.84, 2.22]], "area": 8475.393949999998, "iscrowd": 0, "image_id": 10161, "bbox": [271.73, 1.11, 87.62, 105.36], "category_id": 47, "id": 1884682}, {"segmentation": [[291.84, 58.58, 338.38, 83.7, 324.59, 85.67, 295.29, 69.91, 278.05, 55.63, 281.0, 53.41, 292.82, 58.34]], "area": 454.36664999999937, "iscrowd": 0, "image_id": 10046, "bbox": [278.05, 53.41, 60.33, 32.26], "category_id": 50, "id": 1895370}, {"segmentation": [[76.96, 153.13, 112.42, 199.31, 123.14, 211.68, 133.04, 211.68, 136.34, 203.43, 127.27, 195.18, 82.73, 141.58, 76.14, 144.88, 80.26, 153.13]], "area": 1089.5754499999996, "iscrowd": 0, "image_id": 10046, "bbox": [76.14, 141.58, 60.2, 70.1], "category_id": 50, "id": 1896193}, {"segmentation": [[88.41, 135.7, 90.93, 133.18, 94.71, 132.23, 96.6, 135.7, 96.29, 140.11, 103.22, 146.73, 109.53, 149.57, 112.68, 150.51, 127.81, 161.55, 131.59, 163.12, 128.76, 165.01, 125.92, 167.85, 125.6, 171.63, 99.76, 154.3, 89.35, 149.57, 86.2, 145.15, 85.89, 140.74, 86.52, 136.33]], "area": 521.52215, "iscrowd": 0, "image_id": 10046, "bbox": [85.89, 132.23, 45.7, 39.4], "category_id": 50, "id": 1896393}, {"segmentation": [[80.62, 151.73, 97.25, 149.15, 102.11, 126.05, 121.56, 116.32, 136.15, 110.25, 150.73, 83.5, 178.69, 79.86, 194.49, 99.31, 199.36, 116.32, 220.02, 112.68, 239.47, 113.89, 256.49, 118.76, 261.35, 110.25, 286.88, 122.4, 301.46, 166.16, 295.74, 183.5, 288.09, 217.22, 275.94, 226.94, 265.0, 236.67, 257.7, 251.25, 234.61, 264.63, 207.86, 276.78, 189.63, 276.78, 137.36, 282.86, 128.85, 268.27, 94.82, 252.47, 88.74, 234.24, 77.8, 224.51, 81.44, 216.0, 76.58, 201.42, 73.64, 185.14, 71.32, 167.58]], "area": 32320.78125000001, "iscrowd": 0, "image_id": 10303, "bbox": [71.32, 79.86, 230.14, 203.0], "category_id": 52, "id": 1904301}, {"segmentation": [[595.24, 286.73, 599.7, 278.77, 593.97, 273.67, 583.46, 269.53, 562.75, 268.89, 554.47, 270.48, 542.36, 276.86, 539.49, 281.0, 548.41, 281.95, 572.31, 280.04, 583.78, 284.5, 589.19, 289.6]], "area": 661.317850000001, "iscrowd": 0, "image_id": 10037, "bbox": [539.49, 268.89, 60.21, 20.71], "category_id": 53, "id": 1906457}, {"segmentation": [[369.33, 140.1, 391.71, 120.21, 411.61, 109.02, 420.31, 86.63, 480.0, 80.41, 548.39, 96.58, 594.4, 123.94, 629.22, 169.95, 637.93, 189.84, 639.17, 311.71, 605.6, 327.88, 537.2, 334.09, 509.84, 334.09, 478.76, 353.99, 445.18, 342.8, 379.27, 298.03, 346.94, 227.15, 345.7, 181.14, 358.13, 152.54, 360.62, 146.32]], "area": 61925.627299999986, "iscrowd": 0, "image_id": 10046, "bbox": [345.7, 80.41, 293.47, 273.58], "category_id": 54, "id": 1909962}, {"segmentation": [[606.66, 391.6, 618.12, 362.06, 633.11, 349.27, 640.0, 350.59, 638.4, 390.72, 628.26, 386.31, 622.53, 386.31, 607.54, 392.48]], "area": 867.2648000000003, "iscrowd": 0, "image_id": 10037, "bbox": [606.66, 349.27, 33.34, 43.21], "category_id": 55, "id": 1912484}, {"segmentation": [[380.03, 137.5, 372.82, 144.7, 367.63, 148.16, 365.61, 150.47, 361.58, 153.93, 358.41, 156.52, 360.43, 159.7, 355.52, 160.85, 355.81, 163.73, 361.0, 170.36, 361.58, 175.26, 361.29, 179.59, 363.88, 185.06, 370.51, 184.78, 379.45, 183.33, 393.0, 176.7, 397.61, 171.8, 397.9, 166.33, 400.5, 162.87, 401.36, 162.0, 404.24, 159.7, 405.11, 157.97, 405.11, 155.08, 403.09, 154.51, 400.5, 149.32, 394.44, 153.06, 394.44, 153.35, 392.42, 153.93, 391.56, 151.34, 390.69, 147.88, 386.95, 144.42, 392.14, 132.02]], "area": 1459.87455, "iscrowd": 0, "image_id": 10414, "bbox": [355.52, 132.02, 49.59, 53.04], "category_id": 56, "id": 1914782}, {"segmentation": [[256.05, 51.08, 242.62, 51.78, 229.9, 46.13, 217.88, 44.72, 212.94, 41.89, 213.16, 31.9, 202.9, 31.9, 217.36, 20.71, 236.94, 15.11, 263.98, 22.57, 273.77, 30.03, 277.97, 35.16, 268.64, 37.96, 258.85, 38.89, 256.06, 42.16]], "area": 1588.4836, "iscrowd": 0, "image_id": 10166, "bbox": [202.9, 15.11, 75.07, 36.67], "category_id": 56, "id": 1914998}, {"segmentation": [[53.82, 118.84, 50.27, 124.52, 34.64, 128.78, 16.89, 131.62, 16.17, 125.23, 34.64, 121.68, 46.01, 111.02, 54.53, 101.08, 68.03, 105.34, 78.69, 117.41, 70.16, 121.68]], "area": 712.5349000000001, "iscrowd": 0, "image_id": 10166, "bbox": [16.17, 101.08, 62.52, 30.54], "category_id": 56, "id": 1915729}, {"segmentation": [[362.64, 63.76, 355.0, 68.12, 348.45, 67.03, 344.09, 59.39, 341.91, 50.67, 344.09, 44.12, 353.91, 45.21, 365.91, 47.39, 370.27, 58.3, 361.55, 63.76]], "area": 476.70645000000025, "iscrowd": 0, "image_id": 10414, "bbox": [341.91, 44.12, 28.36, 24.0], "category_id": 56, "id": 1915786}, {"segmentation": [[263.56, 66.18, 258.81, 63.66, 247.55, 68.4, 240.88, 77.3, 237.33, 83.67, 238.36, 88.56, 243.25, 89.15, 246.81, 82.33, 252.29, 76.55, 260.89, 69.29, 263.7, 67.07]], "area": 249.63624999999965, "iscrowd": 0, "image_id": 10414, "bbox": [237.33, 63.66, 26.37, 25.49], "category_id": 56, "id": 1915961}, {"segmentation": [[251.52, 155.22, 246.88, 148.0, 244.81, 143.35, 247.39, 140.26, 245.84, 134.58, 247.39, 130.45, 250.49, 131.48, 257.71, 127.87, 261.84, 130.45, 263.39, 133.55, 264.42, 136.64, 266.49, 138.19, 271.65, 137.16, 275.26, 137.16, 276.29, 139.74, 278.87, 141.8, 281.45, 157.29, 287.13, 176.38, 282.48, 179.47, 268.55, 172.77, 263.39, 170.19]], "area": 1194.9491999999998, "iscrowd": 0, "image_id": 10414, "bbox": [244.81, 127.87, 42.32, 51.6], "category_id": 56, "id": 1916052}, {"segmentation": [[230.18, 114.45, 235.18, 108.2, 239.24, 101.32, 249.24, 98.82, 255.8, 99.45, 262.99, 103.2, 258.93, 106.32, 256.43, 105.39, 249.24, 104.76, 238.62, 111.95, 238.62, 119.76, 237.68, 123.82]], "area": 242.67460000000005, "iscrowd": 0, "image_id": 10414, "bbox": [230.18, 98.82, 32.81, 25.0], "category_id": 56, "id": 1916243}, {"segmentation": [[380.24, 132.52, 376.62, 118.82, 388.41, 110.65, 390.89, 129.66]], "area": 200.32384999999994, "iscrowd": 0, "image_id": 10414, "bbox": [376.62, 110.65, 14.27, 21.87], "category_id": 57, "id": 1917223}, {"segmentation": [[289.4, 68.22, 268.31, 70.81, 264.98, 65.26, 265.35, 54.9, 290.88, 53.79]], "area": 373.2578499999995, "iscrowd": 0, "image_id": 10414, "bbox": [264.98, 53.79, 25.9, 17.02], "category_id": 57, "id": 1917941}, {"segmentation": [[219.74, 309.4, 207.84, 307.17, 205.23, 299.73, 207.09, 294.52, 216.39, 285.96, 231.27, 282.24, 238.34, 281.87, 243.55, 282.24, 246.52, 283.73, 248.01, 288.57, 248.38, 292.29, 238.34, 303.82, 231.64, 309.03, 223.09, 309.03]], "area": 866.9764999999998, "iscrowd": 0, "image_id": 10243, "bbox": [205.23, 281.87, 43.15, 27.53], "category_id": 61, "id": 1927386}, {"segmentation": [[173.88, 269.9, 173.88, 239.82, 210.64, 236.0, 206.83, 249.37, 191.07, 268.47, 177.23, 269.42]], "area": 885.197250000001, "iscrowd": 0, "image_id": 10094, "bbox": [173.88, 236.0, 36.76, 33.9], "category_id": 62, "id": 1931233}, {"segmentation": [[597.19, 331.64, 498.7, 462.55, 499.95, 473.77, 639.58, 473.77, 637.09, 330.39]], "area": 13419.140850000002, "iscrowd": 0, "image_id": 10346, "bbox": [498.7, 330.39, 140.88, 143.38], "category_id": 63, "id": 1951790}, {"segmentation": [[638.18, 460.71, 639.4, 1.22, 0.0, 2.43, 1.22, 461.92]], "area": 293237.3282, "iscrowd": 0, "image_id": 10303, "bbox": [0.0, 1.22, 639.4, 460.7], "category_id": 67, "id": 1964868}, {"segmentation": [[375.0, 150.65, 359.74, 150.65, 364.94, 115.58, 372.73, 94.81, 375.0, 76.62, 355.84, 72.73, 324.68, 58.44, 310.39, 48.05, 319.48, 36.36, 312.99, 22.08, 274.03, 20.78, 258.44, 29.87, 263.64, 46.75, 248.05, 55.84, 216.88, 67.53, 164.94, 67.53, 149.35, 88.31, 146.75, 96.1, 170.13, 111.69, 181.82, 138.96, 181.82, 144.16, 0.0, 136.36, 0.0, 493.51, 372.73, 490.91]], "area": 149232.75710000002, "iscrowd": 0, "image_id": 10444, "bbox": [0.0, 20.78, 375.0, 472.73], "category_id": 67, "id": 1965041}, {"segmentation": [[393.09, 344.53, 400.66, 355.25, 409.9, 356.72, 412.21, 359.03, 416.21, 357.98, 406.54, 342.85, 396.45, 341.38, 393.3, 344.11]], "area": 206.27259999999976, "iscrowd": 0, "image_id": 10130, "bbox": [393.09, 341.38, 23.12, 17.65], "category_id": 77, "id": 1976101}, {"segmentation": [[2.49, 166.69, 2.49, 191.63, 61.09, 246.48, 132.16, 226.54, 113.45, 157.96]], "area": 8036.809199999998, "iscrowd": 0, "image_id": 10175, "bbox": [2.49, 157.96, 129.67, 88.52], "category_id": 78, "id": 1979000}, {"segmentation": [[367.43, 426.17, 360.11, 429.5, 364.77, 433.5, 368.1, 438.16, 369.43, 438.16, 370.09, 432.83, 367.43, 427.51], [318.83, 441.49, 324.82, 445.48, 324.82, 438.82, 322.16, 439.49], [358.11, 458.8, 350.79, 462.13, 360.77, 465.46, 360.11, 460.13], [459.31, 474.78, 458.65, 468.12, 444.0, 465.46, 445.33, 456.8, 430.02, 449.48, 408.71, 442.15, 393.4, 439.49, 385.41, 439.49, 386.74, 432.83, 437.34, 437.49, 465.97, 448.15, 478.62, 457.47, 466.64, 468.79], [445.33, 422.18, 445.33, 424.18, 439.34, 427.51, 446.66, 434.16, 448.66, 438.16, 451.99, 436.16, 464.64, 433.5, 466.64, 430.17, 467.97, 422.84, 479.96, 422.84, 475.96, 418.85, 423.36, 412.19, 421.36, 414.85, 424.03, 421.51, 425.36, 421.51, 428.02, 416.19]], "area": 1960.4197000000004, "iscrowd": 0, "image_id": 10337, "bbox": [318.83, 412.19, 161.13, 62.59], "category_id": 81, "id": 1982802}, {"segmentation": [[446.55, 457.01, 425.48, 466.71, 422.95, 477.66, 412.84, 479.77, 357.64, 465.44, 359.74, 448.17, 386.29, 441.0, 396.4, 440.16, 443.18, 456.59]], "area": 2121.9383499999994, "iscrowd": 0, "image_id": 10337, "bbox": [357.64, 440.16, 88.91, 39.61], "category_id": 81, "id": 1982960}, {"segmentation": [[123.9, 476.02, 120.62, 474.71, 117.99, 464.2, 120.62, 430.38, 122.26, 411.34, 121.61, 388.03, 125.55, 387.7, 126.53, 387.7, 127.19, 387.7, 127.51, 390.0, 124.56, 449.76, 125.22, 466.83]], "area": 457.08020000000005, "iscrowd": 0, "image_id": 10136, "bbox": [117.99, 387.7, 9.52, 88.32], "category_id": 84, "id": 1984879}, {"segmentation": [[53.31, 112.74, 69.91, 112.74, 61.09, 169.8, 46.56, 170.32, 51.23, 114.81]], "area": 943.0586500000002, "iscrowd": 0, "image_id": 10136, "bbox": [46.56, 112.74, 23.35, 57.58], "category_id": 84, "id": 1986276}, {"segmentation": [[71.67, 116.91, 78.03, 117.78, 73.12, 167.79, 65.02, 169.81, 64.16, 169.52]], "area": 392.40740000000017, "iscrowd": 0, "image_id": 10136, "bbox": [64.16, 116.91, 13.87, 52.9], "category_id": 84, "id": 1987460}, {"segmentation": [[511.67, 47.76, 528.29, 50.41, 530.94, 52.13, 532.23, 54.35, 532.3, 56.71, 532.45, 58.79, 528.29, 59.58, 519.7, 59.87, 514.32, 57.07, 511.17, 53.56, 510.38, 51.34, 510.38, 48.26]], "area": 194.67339999999982, "iscrowd": 0, "image_id": 10245, "bbox": [510.38, 47.76, 22.07, 12.11], "category_id": 84, "id": 1988360}, {"segmentation": [[127.97, 170.58, 133.19, 116.67, 140.72, 117.83, 133.19, 172.61]], "area": 356.61750000000006, "iscrowd": 0, "image_id": 10136, "bbox": [127.97, 116.67, 12.75, 55.94], "category_id": 84, "id": 1988473}, {"segmentation": [[206.52, 474.58, 214.87, 386.89, 243.41, 386.89, 237.14, 476.67]], "area": 2632.420249999999, "iscrowd": 0, "image_id": 10136, "bbox": [206.52, 386.89, 36.89, 89.78], "category_id": 84, "id": 1989007}, {"segmentation": [[503.12, 16.09, 504.92, 53.8, 511.02, 54.77, 507.83, 15.81, 503.26, 15.81]], "area": 206.97969999999893, "iscrowd": 0, "image_id": 10245, "bbox": [503.12, 15.81, 7.9, 38.96], "category_id": 84, "id": 1989107}, {"segmentation": [[120.63, 125.15, 114.73, 165.32, 113.37, 172.82, 120.18, 172.36, 126.08, 132.64, 126.31, 125.15]], "area": 307.0600500000001, "iscrowd": 0, "image_id": 10136, "bbox": [113.37, 125.15, 12.94, 47.67], "category_id": 84, "id": 1989129}, {"segmentation": [[146.8, 173.52, 142.71, 174.46, 139.56, 174.15, 137.99, 171.0, 137.67, 158.4, 141.13, 117.14, 141.13, 115.29, 148.06, 114.34, 148.38, 124.42, 148.69, 137.65, 149.32, 154.03, 148.38, 165.68]], "area": 559.5045000000002, "iscrowd": 0, "image_id": 10136, "bbox": [137.67, 114.34, 11.65, 60.12], "category_id": 84, "id": 1989387}, {"segmentation": [[510.0, 19.19, 510.0, 44.17, 529.99, 48.67, 525.99, 25.19]], "area": 425.3977000000002, "iscrowd": 0, "image_id": 10245, "bbox": [510.0, 19.19, 19.99, 29.48], "category_id": 84, "id": 1989542}, {"segmentation": [[52.3, 384.71, 55.57, 471.81, 65.36, 471.81, 66.45, 384.71, 56.65, 384.71]], "area": 1042.5870000000004, "iscrowd": 0, "image_id": 10136, "bbox": [52.3, 384.71, 14.15, 87.1], "category_id": 84, "id": 1989709}, {"segmentation": [[117.25, 189.61, 108.11, 259.22, 114.73, 259.53, 123.86, 192.76, 117.87, 191.5]], "area": 461.6104499999998, "iscrowd": 0, "image_id": 10136, "bbox": [108.11, 189.61, 15.75, 69.92], "category_id": 84, "id": 1989894}, {"segmentation": [[253.08, 202.59, 260.41, 202.59, 267.14, 223.37, 263.47, 226.42, 250.02, 227.03, 245.75, 215.42, 246.36, 209.31]], "area": 387.5798999999998, "iscrowd": 0, "image_id": 10136, "bbox": [245.75, 202.59, 21.39, 24.44], "category_id": 85, "id": 1991743}, {"segmentation": [[29.59, 190.04, 29.59, 182.63, 28.79, 179.59, 28.92, 174.96, 27.34, 172.18, 24.69, 174.56, 24.56, 177.73, 25.62, 182.36, 23.23, 186.73, 23.63, 190.57, 26.28, 190.3, 26.81, 186.33, 28.53, 191.1]], "area": 77.88664999999999, "iscrowd": 0, "image_id": 10230, "bbox": [23.23, 172.18, 6.36, 18.92], "category_id": 1, "id": 2021204}, {"segmentation": [[306.3, 307.73, 309.83, 304.2, 311.08, 302.75, 314.19, 302.75, 314.19, 304.2, 314.4, 306.69, 313.16, 308.56, 312.32, 310.02, 312.53, 312.1, 320.22, 322.9, 320.01, 323.73, 307.55, 324.15]], "area": 168.37839999999974, "iscrowd": 0, "image_id": 10321, "bbox": [306.3, 302.75, 13.92, 21.4], "category_id": 1, "id": 2023865}, {"segmentation": [[377.22, 239.15, 378.22, 234.63, 378.66, 231.66, 378.22, 230.0, 375.57, 230.22, 374.58, 232.98, 372.92, 236.29, 372.26, 237.94]], "area": 36.02630000000029, "iscrowd": 0, "image_id": 10318, "bbox": [372.26, 230.0, 6.4, 9.15], "category_id": 1, "id": 2024156}, {"segmentation": [[573.02, 93.98, 572.83, 92.38, 573.02, 91.45, 573.36, 89.73, 573.84, 89.88, 574.29, 90.89, 574.62, 92.19, 575.22, 93.35, 575.52, 93.95]], "area": 6.607399999999988, "iscrowd": 0, "image_id": 10318, "bbox": [572.83, 89.73, 2.69, 4.25], "category_id": 1, "id": 2033641}, {"segmentation": [[5.55, 2.22, 640.0, 2.22, 638.84, 421.45, 0.0, 419.24, 1.11, 0.0]], "area": 267132.84280000004, "iscrowd": 0, "image_id": 10275, "bbox": [0.0, 0.0, 640.0, 421.45], "category_id": 7, "id": 2050978}, {"segmentation": [[381.25, 220.08, 381.25, 233.29, 379.73, 236.59, 375.66, 236.08, 374.65, 245.98, 381.76, 249.54, 392.43, 251.82, 400.3, 250.81, 405.89, 249.03, 408.43, 249.03, 410.71, 250.81, 415.03, 250.81, 418.08, 246.24, 419.86, 233.54, 408.17, 232.78, 404.11, 219.32, 382.78, 218.05, 381.76, 219.06]], "area": 1076.7957000000001, "iscrowd": 0, "image_id": 10342, "bbox": [374.65, 218.05, 45.21, 33.77], "category_id": 8, "id": 2051669}, {"segmentation": [[0.0, 208.43, 15.06, 212.88, 23.96, 242.32, 37.99, 244.37, 40.05, 267.3, 27.73, 268.67, 22.59, 265.59, 16.09, 272.1, 9.93, 276.54, 7.53, 276.89, 4.79, 272.44, 0.0, 270.73]], "area": 1690.2626000000002, "iscrowd": 0, "image_id": 10342, "bbox": [0.0, 208.43, 40.05, 68.46], "category_id": 8, "id": 2053653}, {"segmentation": [[216.49, 212.08, 215.48, 213.35, 228.71, 213.6, 231.13, 211.57, 229.35, 211.82, 216.49, 212.08]], "area": 21.39369999999989, "iscrowd": 0, "image_id": 10058, "bbox": [215.48, 211.57, 15.65, 2.03], "category_id": 9, "id": 2054682}, {"segmentation": [[230.51, 95.69, 222.31, 96.22, 224.82, 99.92, 222.7, 102.57, 225.88, 106.14, 231.97, 106.8, 230.91, 95.82]], "area": 79.24590000000006, "iscrowd": 0, "image_id": 10434, "bbox": [222.31, 95.69, 9.66, 11.11], "category_id": 10, "id": 2057256}, {"segmentation": [[431.45, 339.29, 432.49, 341.98, 432.19, 345.4, 420.42, 345.4, 420.42, 341.68, 420.72, 338.4, 424.3, 337.95, 428.47, 339.0, 430.85, 339.44]], "area": 79.12274999999968, "iscrowd": 0, "image_id": 10321, "bbox": [420.42, 337.95, 12.07, 7.45], "category_id": 31, "id": 2077559}, {"segmentation": [[107.26, 367.41, 115.26, 367.41, 123.98, 368.28, 125.73, 369.59, 131.98, 370.6, 136.49, 374.82, 153.51, 375.55, 159.33, 378.17, 160.78, 374.97, 163.11, 374.24, 165.29, 374.24, 168.49, 375.26, 175.61, 381.22, 178.38, 386.89, 175.47, 395.91, 171.25, 400.42, 160.93, 401.15, 169.51, 413.65, 178.09, 422.67, 179.4, 427.0, 115.99, 427.0, 81.66, 427.0, 45.01, 427.0, 22.76, 427.0, 26.54, 423.54, 30.47, 419.18, 41.67, 396.49, 44.72, 392.27, 41.96, 392.27, 37.45, 391.69, 34.4, 389.22, 34.25, 385.44, 22.76, 379.62, 15.93, 377.15, 9.67, 374.24, 0.0, 372.64, 0.0, 350.39, 0.0, 333.23, 5.02, 335.85, 12.87, 332.21, 20.87, 328.28, 38.18, 332.5, 40.07, 335.12, 54.16, 333.87, 65.18, 331.01, 71.58, 328.8, 78.63, 324.39, 86.57, 321.97, 89.65, 321.53, 94.94, 329.46, 94.5, 333.65, 102.26, 337.54, 104.01, 345.97, 110.26, 352.37, 111.86, 358.19, 112.3, 361.24, 107.94, 364.3]], "area": 12154.781850000001, "iscrowd": 0, "image_id": 10281, "bbox": [0.0, 321.53, 179.4, 105.47], "category_id": 38, "id": 2090089}, {"segmentation": [[366.2, 438.5, 373.42, 418.86, 383.59, 420.44, 385.84, 441.21, 371.62, 444.37, 370.49, 440.76]], "area": 350.3185999999991, "iscrowd": 0, "image_id": 10337, "bbox": [366.2, 418.86, 19.64, 25.51], "category_id": 44, "id": 2095989}, {"segmentation": [[301.18, 111.16, 321.3, 116.46, 347.77, 132.34, 357.3, 141.87, 374.24, 134.46, 390.12, 119.64, 401.77, 101.64, 409.18, 89.99, 411.3, 75.16, 412.35, 56.11, 406.0, 38.11, 398.59, 20.11, 385.88, 12.69, 364.71, 3.17, 356.24, 1.05, 292.71, 1.05, 274.71, 20.11, 263.06, 35.99, 253.53, 47.64, 250.36, 57.17, 256.71, 77.28, 269.41, 91.05, 275.77, 89.99, 277.88, 89.99, 285.3, 86.81, 292.71, 87.87, 296.94, 89.99, 301.18, 93.16, 299.06, 100.58, 300.12, 109.05]], "area": 15784.109099999998, "iscrowd": 0, "image_id": 10196, "bbox": [250.36, 1.05, 161.99, 140.82], "category_id": 53, "id": 2112002}, {"segmentation": [[240.23, 364.1, 231.64, 363.96, 229.32, 363.14, 227.55, 361.5, 227.14, 359.46, 226.46, 356.32, 226.32, 354.68, 226.86, 351.41, 227.96, 349.77, 230.0, 348.96, 233.41, 347.59, 242.28, 346.5, 245.96, 346.91, 251.69, 348.0, 254.14, 350.18, 255.1, 352.09, 255.1, 354.55, 255.1, 356.32, 255.1, 358.37, 249.78, 360.0, 248.55, 361.5, 245.28, 363.55, 240.64, 363.96]], "area": 415.7546, "iscrowd": 0, "image_id": 10243, "bbox": [226.32, 346.5, 28.78, 17.6], "category_id": 60, "id": 2118252}, {"segmentation": [[172.58, 84.23, 172.79, 72.72, 185.55, 72.31, 185.97, 83.18]], "area": 146.3859000000001, "iscrowd": 0, "image_id": 10082, "bbox": [172.58, 72.31, 13.39, 11.92], "category_id": 62, "id": 2121088}, {"segmentation": [[433.54, 236.39, 431.74, 230.62, 432.1, 223.04, 434.26, 223.04, 463.13, 221.6, 462.77, 229.89, 461.33, 232.42, 461.69, 233.14, 486.58, 224.84, 489.47, 223.76, 493.08, 208.24, 500.66, 207.16, 516.53, 223.4, 514.01, 224.84, 517.98, 223.76, 523.75, 226.29, 524.47, 228.45, 520.5, 268.14, 465.3, 268.14, 466.74, 268.14, 469.26, 293.04, 444.73, 295.57, 437.51, 284.02, 434.26, 273.19, 434.99, 265.62, 420.91, 262.73, 409.01, 263.09, 408.65, 264.89, 406.48, 265.98, 379.78, 264.89, 384.83, 245.41, 381.94, 236.03, 436.07, 237.11]], "area": 6383.886499999998, "iscrowd": 0, "image_id": 10145, "bbox": [379.78, 207.16, 144.69, 88.41], "category_id": 62, "id": 2121741}, {"segmentation": [[551.43, 285.13, 558.7, 285.52, 559.27, 266.76, 549.13, 267.34, 548.37, 281.5, 548.56, 284.56, 550.66, 285.52]], "area": 187.32630000000046, "iscrowd": 0, "image_id": 10130, "bbox": [548.37, 266.76, 10.9, 18.76], "category_id": 77, "id": 2137248}, {"segmentation": [[534.07, 264.55, 523.25, 263.77, 522.47, 243.28, 533.69, 243.47]], "area": 228.7694000000008, "iscrowd": 0, "image_id": 10130, "bbox": [522.47, 243.28, 11.6, 21.27], "category_id": 77, "id": 2137411}, {"segmentation": [[310.67, 395.39, 308.11, 391.78, 305.7, 391.02, 305.7, 389.97, 309.01, 390.12, 315.19, 386.96, 320.16, 386.96, 323.93, 391.63]], "area": 85.7347, "iscrowd": 0, "image_id": 10130, "bbox": [305.7, 386.96, 18.23, 8.43], "category_id": 77, "id": 2138309}, {"segmentation": [[126.92, 188.47, 120.25, 247.99, 124.54, 247.99, 131.68, 188.0, 128.35, 187.04]], "area": 271.8360500000004, "iscrowd": 0, "image_id": 10136, "bbox": [120.25, 187.04, 11.43, 60.95], "category_id": 84, "id": 2141654}, {"segmentation": [[450.92, 24.84, 449.83, 44.79, 449.52, 51.8, 449.52, 55.39, 449.05, 56.16, 457.1, 57.25, 459.27, 23.99, 451.01, 23.13, 451.01, 25.52]], "area": 268.6148000000003, "iscrowd": 0, "image_id": 10346, "bbox": [449.05, 23.13, 10.22, 34.12], "category_id": 84, "id": 2144340}, {"segmentation": [[492.19, 176.43, 497.4, 94.4, 476.56, 81.38, 467.45, 59.24, 446.61, 54.04, 438.8, 83.98, 449.22, 115.23, 440.1, 142.58, 463.54, 166.02]], "area": 4898.673499999997, "iscrowd": 0, "image_id": 10094, "bbox": [438.8, 54.04, 58.6, 122.39], "category_id": 1, "id": 2156668}, {"segmentation": [[379.79, 312.6, 382.71, 308.23, 383.54, 304.48, 387.29, 303.85, 387.5, 306.56, 387.29, 309.48, 389.38, 310.94, 390.63, 311.56, 390.83, 313.85, 390.63, 317.81, 391.04, 320.94, 390.21, 324.48, 389.79, 325.73, 387.71, 348.85, 383.33, 349.27, 382.92, 333.44, 385.42, 326.77, 382.71, 324.69, 380.63, 320.1, 379.17, 316.77, 380.21, 312.19]], "area": 303.46995, "iscrowd": 0, "image_id": 10321, "bbox": [379.17, 303.85, 11.87, 45.42], "category_id": 1, "id": 2157700}, {"segmentation": [[125.61, 227.26, 131.8, 233.65, 138.58, 232.17, 136.91, 228.04, 133.77, 224.6, 132.98, 221.16, 133.18, 218.9, 138.39, 218.21, 138.39, 214.48, 138.39, 199.73, 138.19, 194.82, 138.88, 180.08, 140.55, 174.67, 141.14, 172.21, 143.01, 170.05, 143.79, 157.27, 143.79, 155.01, 142.61, 144.49, 146.45, 141.05, 147.92, 137.61, 148.22, 135.16, 146.74, 122.58, 144.09, 117.46, 143.79, 115.99, 141.34, 110.29, 135.44, 106.85, 132.98, 105.18, 132.0, 104.88, 112.63, 110.58, 101.23, 115.7, 100.5, 130.4, 100.5, 132.69, 100.31, 142.06, 105.28, 148.37, 106.23, 150.86, 105.28, 175.53, 109.1, 177.44, 109.1, 186.62, 107.19, 194.26, 104.7, 201.91, 107.57, 205.74, 108.15, 206.12, 109.1, 210.52, 109.1, 215.3, 110.06, 217.59, 111.4, 220.08, 112.35, 220.46, 114.26, 220.08, 114.84, 216.25, 116.18, 209.94, 115.41, 205.74, 119.04, 206.12, 119.62, 203.82, 119.62, 200.96, 119.62, 199.04, 121.53, 194.84, 122.87, 192.93, 124.78, 175.14, 125.35, 193.31, 126.31, 216.25, 126.69, 218.55], [110.53, 107.0, 113.03, 103.0, 115.11, 102.17, 115.94, 99.93, 112.19, 97.84, 112.65, 93.34, 112.65, 88.13, 115.25, 84.01, 116.35, 81.27, 120.74, 79.9, 124.85, 79.63, 129.65, 82.64, 132.12, 84.01, 132.8, 89.5, 131.84, 93.88, 129.79, 98.0, 129.1, 99.37, 129.65, 100.05]], "area": 4355.59415, "iscrowd": 0, "image_id": 10244, "bbox": [100.31, 79.63, 47.91, 154.02], "category_id": 1, "id": 2159840}, {"segmentation": [[383.91, 177.87, 382.89, 178.21, 382.89, 179.05, 383.4, 180.41, 382.38, 180.75, 382.04, 182.1, 381.2, 182.78, 381.37, 183.29, 381.87, 184.3, 381.87, 187.01, 381.87, 187.69, 382.21, 189.72, 381.87, 193.96, 381.37, 194.3, 381.37, 196.16, 383.06, 195.82, 384.41, 193.62, 384.58, 192.09, 384.92, 194.13, 385.09, 195.82, 386.95, 195.99, 387.29, 194.8, 386.28, 192.26, 386.11, 190.74, 386.62, 189.38, 386.79, 188.37, 387.12, 186.0, 386.28, 185.66, 386.62, 184.64, 386.95, 182.95, 385.94, 181.42, 385.6, 181.25, 385.6, 180.07, 385.6, 179.22, 385.6, 177.53, 384.24, 178.04]], "area": 76.4423000000002, "iscrowd": 0, "image_id": 10230, "bbox": [381.2, 177.53, 6.09, 18.63], "category_id": 1, "id": 2160088}, {"segmentation": [[345.88, 141.75, 351.41, 135.43, 354.57, 135.43, 354.83, 135.17, 354.83, 132.01, 355.89, 130.16, 357.2, 130.16, 360.63, 131.48, 360.63, 134.91, 362.21, 135.96, 360.89, 138.86, 361.94, 141.49, 360.36, 144.39, 359.31, 146.23, 358.26, 150.18, 360.1, 155.71, 358.26, 156.76, 355.89, 156.24, 355.1, 154.13, 354.57, 153.08, 351.41, 153.08, 351.67, 154.92, 350.62, 161.77, 348.51, 164.14, 347.99, 160.19, 346.67, 151.5, 348.51, 146.49, 345.09, 142.54]], "area": 299.12694999999997, "iscrowd": 0, "image_id": 10005, "bbox": [345.09, 130.16, 17.12, 33.98], "category_id": 1, "id": 2160616}, {"segmentation": [[158.96, 422.04, 131.41, 410.23, 101.88, 352.17, 149.12, 326.58, 150.1, 307.88, 128.45, 250.8, 95.98, 245.88, 82.2, 229.15, 57.6, 229.15, 45.79, 216.36, 46.77, 204.55, 23.15, 175.03, 0.0, 165.19, 0.52, 427.0, 163.88, 427.0]], "area": 27574.92169999999, "iscrowd": 0, "image_id": 10275, "bbox": [0.0, 165.19, 163.88, 261.81], "category_id": 1, "id": 2165549}, {"segmentation": [[149.48, 86.04, 141.56, 82.27, 135.19, 81.75, 133.25, 81.75, 131.95, 50.32, 131.43, 46.56, 130.78, 49.94, 131.04, 73.44, 131.82, 81.49, 129.22, 82.14, 126.49, 83.31, 123.9, 83.83, 123.51, 85.13, 127.27, 85.91, 128.57, 84.22, 129.35, 82.92, 129.87, 82.79, 129.74, 83.96, 130.13, 86.69, 140.0, 86.3, 139.74, 84.22, 140.65, 83.44, 141.43, 83.44, 142.34, 84.35, 143.12, 86.04, 149.35, 86.43]], "area": 125.61184999999983, "iscrowd": 0, "image_id": 10318, "bbox": [123.51, 46.56, 25.97, 40.13], "category_id": 9, "id": 2172388}, {"segmentation": [[42.97, 94.38, 50.18, 93.74, 51.63, 93.74, 52.59, 95.34, 52.27, 98.87, 51.47, 102.39, 49.7, 101.11, 45.53, 99.67]], "area": 53.831400000000066, "iscrowd": 0, "image_id": 10318, "bbox": [42.97, 93.74, 9.62, 8.65], "category_id": 9, "id": 2172466}, {"segmentation": [[86.77, 76.98, 96.31, 76.79, 96.31, 75.72, 93.88, 74.26, 92.81, 70.17, 92.32, 61.51, 89.4, 61.99, 89.98, 72.6, 86.77, 75.42]], "area": 62.87454999999996, "iscrowd": 0, "image_id": 10318, "bbox": [86.77, 61.51, 9.54, 15.47], "category_id": 9, "id": 2172507}, {"segmentation": [[240.46, 480.65, 254.15, 507.35, 259.97, 521.04, 267.5, 518.3, 255.18, 489.89, 250.04, 477.23, 239.77, 479.62], [234.91, 470.48, 225.93, 456.57, 225.93, 438.6, 230.28, 446.43, 231.44, 455.12, 232.3, 459.47, 234.62, 460.92, 235.49, 469.61], [264.76, 467.0, 266.21, 486.71, 268.24, 487.87, 274.33, 487.87, 272.59, 467.58, 265.92, 467.0]], "area": 674.0252499999993, "iscrowd": 0, "image_id": 10024, "bbox": [225.93, 438.6, 48.4, 82.44], "category_id": 35, "id": 2179292}, {"segmentation": [[250.46, 359.06, 240.73, 368.38, 237.9, 373.25, 237.9, 376.49, 246.41, 385.0, 260.59, 386.62, 269.51, 382.57, 276.0, 375.27, 278.43, 363.92, 273.56, 360.28, 268.7, 356.63, 256.54, 357.84, 254.11, 357.84]], "area": 883.0281500000003, "iscrowd": 0, "image_id": 10243, "bbox": [237.9, 356.63, 40.53, 29.99], "category_id": 61, "id": 2189469}, {"segmentation": [[56.28, 91.79, 44.24, 99.12, 29.59, 102.26, 34.3, 89.18, 33.25, 68.77, 36.91, 62.48, 36.91, 49.92, 43.19, 57.77, 54.71, 57.77, 56.8, 52.02, 60.47, 60.91, 64.13, 60.91, 62.04, 92.32, 55.23, 89.7], [73.55, 63.53, 99.2, 68.24, 109.67, 59.34, 125.89, 68.77, 135.84, 59.87, 153.63, 65.62, 172.48, 76.62, 193.93, 84.99, 196.03, 120.06, 196.55, 186.53, 180.33, 199.09, 177.71, 193.86, 183.47, 176.59, 183.47, 163.5, 171.95, 178.68, 173.0, 188.62, 167.24, 193.34, 164.1, 177.63, 176.14, 157.74, 160.44, 127.91, 148.4, 127.39, 109.67, 127.39, 112.28, 159.84, 114.38, 188.1, 104.43, 181.82, 106.53, 160.36, 96.58, 133.14, 98.68, 168.74, 100.77, 180.77, 91.35, 179.73, 82.97, 136.28, 72.51, 112.21]], "area": 11109.5226, "iscrowd": 0, "image_id": 10276, "bbox": [29.59, 49.92, 166.96, 149.17], "category_id": 19, "id": 2191492}, {"segmentation": [[103.98, 1.24, 362.84, 54.33, 393.81, 41.06, 428.11, 47.7, 461.29, 47.7, 481.2, 46.59, 486.74, 67.61, 512.18, 63.18, 537.62, 54.33, 561.96, 34.42, 602.89, 30.0, 619.48, 32.21, 640.0, 56.55, 640.0, 418.28, 0.0, 422.7, 0.0, 2.34]], "area": 248914.49725, "iscrowd": 0, "image_id": 10245, "bbox": [0.0, 1.24, 640.0, 421.46], "category_id": 65, "id": 2194040}, {"segmentation": [[249.8, 263.06, 252.67, 264.85, 267.38, 266.65, 267.03, 262.34, 251.23, 263.06], [380.46, 286.39, 390.87, 287.83, 391.23, 285.31, 380.1, 284.95]], "area": 68.64890000000011, "iscrowd": 0, "image_id": 10041, "bbox": [249.8, 262.34, 141.43, 25.49], "category_id": 35, "id": 2201817}, {"segmentation": [[409.47, 94.88, 409.6, 92.95, 408.98, 91.64, 410.09, 90.75, 409.74, 89.85, 411.05, 89.71, 411.33, 90.4, 411.33, 90.75, 412.36, 91.44, 411.81, 93.44, 411.53, 95.02]], "area": 11.56084999999992, "iscrowd": 0, "image_id": 10318, "bbox": [408.98, 89.71, 3.38, 5.31], "category_id": 1, "id": 2206997}, {"segmentation": [[356.44, 159.21, 343.37, 201.98, 351.68, 251.88, 415.84, 332.67, 468.12, 352.87, 478.81, 349.31, 489.5, 339.8, 513.27, 327.92, 583.37, 340.99, 626.14, 324.36, 640.0, 299.41, 640.0, 180.59, 591.68, 130.69, 561.98, 105.74, 515.64, 86.73, 471.68, 80.79, 458.61, 85.54, 449.11, 91.49, 425.35, 91.49, 417.03, 93.86, 422.97, 109.31, 402.77, 120.0, 381.39, 128.32, 368.32, 134.26, 357.62, 165.15]], "area": 61644.439500000015, "iscrowd": 0, "image_id": 10046, "bbox": [343.37, 80.79, 296.63, 272.08], "category_id": 58, "id": 2219898}, {"segmentation": [[285.4, 391.53, 274.13, 396.36, 270.5, 408.44, 280.57, 420.12, 301.51, 421.32, 309.56, 409.65, 308.75, 400.39, 300.7, 393.94]], "area": 891.7685500000002, "iscrowd": 0, "image_id": 10243, "bbox": [270.5, 391.53, 39.06, 29.79], "category_id": 61, "id": 2222255}, {"segmentation": [[527.84, 286.31, 503.7, 268.47, 498.46, 251.68, 505.8, 233.84, 491.11, 224.39, 491.11, 218.1, 520.49, 175.07, 521.54, 228.59, 525.74, 244.33, 519.44, 264.27]], "area": 1951.76175, "iscrowd": 0, "image_id": 10082, "bbox": [491.11, 175.07, 36.73, 111.24], "category_id": 64, "id": 2225436}, {"segmentation": [[285.46, 245.31, 286.87, 239.85, 296.24, 236.72, 300.45, 235.01, 304.35, 235.63, 305.6, 236.1, 307.63, 235.32, 308.72, 235.01, 309.66, 234.85, 313.41, 234.38, 318.09, 235.48, 325.43, 239.85, 325.27, 243.44, 324.49, 245.31, 322.93, 247.5, 319.96, 248.9, 315.13, 249.84, 312.0, 250.31, 309.19, 250.31, 304.35, 249.21, 301.08, 248.59, 298.11, 248.28, 294.99, 249.21, 292.96, 249.84, 289.05, 249.84, 287.81, 249.53, 286.56, 247.65]], "area": 493.21300000000036, "iscrowd": 0, "image_id": 10243, "bbox": [285.46, 234.38, 39.97, 15.93], "category_id": 61, "id": 2231215}, {"segmentation": [[305.67, 394.69, 289.54, 387.78, 281.64, 377.9, 286.57, 361.44, 298.76, 351.89, 310.61, 347.28, 328.05, 348.27, 345.83, 354.85, 353.73, 360.12, 357.35, 370.0, 356.37, 379.22, 346.49, 390.41, 332.66, 395.68, 325.75, 397.32, 323.77, 395.02, 314.56, 394.03, 309.95, 396.66, 304.02, 396.34]], "area": 2844.5682500000016, "iscrowd": 0, "image_id": 10243, "bbox": [281.64, 347.28, 75.71, 50.04], "category_id": 61, "id": 2231255}, {"segmentation": {"counts": [18304, 52, 28, 12, 547, 68, 5, 21, 545, 96, 543, 98, 541, 99, 541, 99, 541, 99, 541, 99, 406, 9, 126, 99, 392, 6, 6, 12, 125, 99, 391, 26, 124, 99, 386, 32, 123, 99, 371, 47, 123, 98, 362, 57, 122, 98, 357, 63, 121, 98, 350, 71, 120, 98, 350, 73, 119, 98, 348, 75, 119, 98, 347, 76, 118, 99, 346, 77, 117, 100, 345, 79, 116, 100, 345, 79, 116, 100, 345, 79, 116, 100, 345, 79, 116, 100, 345, 79, 116, 99, 346, 79, 116, 10, 19, 69, 347, 79, 117, 9, 45, 11, 1, 17, 8, 4, 349, 79, 118, 8, 435, 79, 120, 6, 435, 79, 122, 4, 436, 78, 563, 77, 564, 76, 564, 76, 564, 76, 213, 1, 349, 77, 213, 2, 348, 77, 213, 3, 347, 77, 213, 4, 346, 77, 125, 1, 36, 55, 346, 77, 124, 93, 346, 77, 123, 95, 345, 77, 123, 96, 345, 76, 122, 97, 345, 76, 121, 98, 345, 76, 120, 99, 330, 2, 13, 77, 119, 100, 320, 12, 12, 77, 119, 101, 309, 23, 11, 77, 119, 102, 298, 34, 10, 77, 119, 102, 288, 44, 11, 76, 119, 103, 275, 1, 1, 54, 12, 75, 119, 104, 273, 57, 12, 75, 119, 104, 272, 58, 11, 77, 118, 104, 271, 59, 11, 78, 117, 104, 271, 59, 11, 79, 116, 104, 271, 59, 11, 80, 115, 104, 271, 59, 11, 80, 116, 103, 271, 59, 11, 80, 116, 102, 272, 59, 11, 80, 117, 100, 273, 59, 11, 80, 117, 99, 275, 58, 12, 79, 118, 95, 277, 60, 12, 78, 119, 93, 278, 60, 12, 77, 121, 92, 278, 60, 13, 75, 123, 92, 276, 61, 11, 77, 122, 94, 275, 61, 10, 78, 122, 94, 274, 62, 9, 79, 122, 94, 274, 62, 8, 80, 122, 94, 274, 63, 7, 81, 121, 94, 274, 64, 6, 81, 121, 94, 274, 64, 6, 81, 121, 94, 274, 64, 6, 81, 122, 93, 274, 64, 6, 81, 123, 92, 274, 64, 6, 81, 123, 92, 274, 64, 7, 80, 120, 95, 273, 65, 7, 80, 119, 96, 273, 65, 7, 80, 118, 97, 273, 65, 7, 79, 118, 98, 273, 65, 8, 77, 119, 99, 272, 65, 9, 76, 119, 99, 272, 65, 11, 73, 120, 99, 271, 66, 13, 64, 127, 99, 270, 72, 8, 56, 135, 99, 270, 73, 7, 46, 1, 2, 142, 99, 270, 74, 7, 40, 151, 99, 269, 75, 6, 23, 168, 99, 269, 61, 3, 11, 6, 19, 172, 99, 269, 55, 9, 11, 7, 16, 174, 99, 269, 48, 16, 11, 8, 8, 51, 1, 129, 99, 270, 40, 23, 11, 59, 9, 129, 99, 271, 33, 29, 11, 52, 16, 129, 99, 273, 24, 36, 11, 45, 23, 130, 70, 17, 10, 274, 17, 43, 10, 8, 1, 29, 31, 131, 56, 34, 5, 276, 12, 41, 15, 8, 3, 21, 28, 6, 4, 133, 41, 329, 11, 35, 18, 11, 3, 14, 26, 15, 4, 134, 2, 15, 12, 342, 9, 28, 23, 13, 3, 7, 24, 24, 5, 134, 1, 399, 31, 12, 25, 33, 6, 222, 1, 281, 6, 16, 38, 12, 16, 39, 10, 186, 21, 7, 9, 279, 8, 9, 44, 12, 7, 39, 20, 166, 57, 277, 62, 50, 28, 145, 78, 276, 63, 41, 37, 132, 91, 276, 45, 11, 7, 33, 45, 131, 92, 276, 35, 22, 7, 8, 1, 15, 53, 130, 93, 276, 25, 32, 8, 7, 1, 6, 62, 127, 96, 276, 14, 44, 8, 6, 69, 126, 97, 276, 4, 54, 9, 5, 68, 126, 98, 276, 2, 50, 15, 5, 67, 126, 100, 275, 2, 43, 22, 5, 65, 127, 101, 275, 3, 35, 29, 5, 57, 134, 102, 275, 3, 27, 37, 5, 53, 138, 102, 276, 2, 20, 17, 17, 10, 5, 45, 146, 102, 277, 1, 13, 12, 31, 8, 5, 37, 154, 102, 284, 7, 44, 7, 6, 34, 156, 102, 335, 6, 8, 31, 158, 102, 335, 6, 10, 3, 3, 15, 166, 101, 336, 6, 16, 13, 169, 99, 337, 6, 16, 13, 169, 100, 335, 7, 16, 13, 169, 100, 335, 7, 16, 12, 170, 100, 334, 7, 17, 12, 170, 100, 329, 11, 18, 13, 169, 100, 328, 12, 18, 13, 169, 100, 329, 10, 19, 13, 170, 99, 330, 8, 20, 13, 170, 99, 332, 3, 23, 12, 171, 99, 358, 12, 171, 99, 282, 6, 70, 13, 170, 98, 282, 8, 69, 13, 170, 98, 281, 10, 68, 13, 170, 98, 280, 12, 67, 13, 170, 98, 280, 12, 67, 12, 171, 98, 280, 12, 68, 11, 171, 97, 281, 12, 67, 13, 171, 74, 1, 20, 282, 12, 67, 13, 171, 69, 13, 3, 1, 6, 285, 12, 67, 13, 171, 62, 315, 12, 67, 13, 172, 52, 325, 10, 68, 13, 172, 48, 330, 8, 70, 11, 173, 48, 332, 4, 71, 13, 173, 47, 407, 13, 174, 46, 407, 13, 175, 45, 407, 13, 177, 44, 406, 13, 177, 44, 407, 11, 178, 44, 406, 13, 177, 44, 406, 13, 177, 44, 406, 13, 177, 44, 406, 13, 177, 44, 406, 13, 178, 42, 408, 11, 179, 42, 408, 11, 179, 42, 407, 13, 178, 42, 407, 13, 179, 41, 407, 13, 180, 40, 407, 13, 182, 38, 407, 13, 185, 35, 408, 11, 186, 35, 407, 13, 185, 35, 407, 13, 185, 35, 407, 13, 185, 35, 407, 13, 185, 35, 407, 13, 185, 34, 409, 11, 187, 32, 409, 13, 187, 29, 411, 13, 189, 14, 424, 13, 627, 13, 627, 13, 628, 11, 628, 13, 627, 13, 627, 13, 627, 13, 627, 13, 628, 12, 628, 12, 627, 13, 627, 13, 627, 13, 627, 13, 628, 12, 628, 12, 627, 13, 627, 13, 627, 13, 627, 13, 627, 13, 628, 11, 629, 12, 627, 13, 627, 13, 627, 13, 627, 13, 628, 12, 628, 12, 627, 13, 627, 13, 627, 13, 627, 13, 628, 12, 628, 12, 627, 13, 627, 13, 627, 13, 627, 13, 628, 12, 628, 12, 628, 12, 627, 13, 627, 13, 627, 13, 628, 12, 628, 12, 628, 12, 627, 13, 627, 13, 627, 13, 628, 12, 628, 12, 628, 12, 627, 13, 627, 13, 627, 13, 628, 12, 628, 12, 628, 12, 628, 12, 627, 13, 627, 13, 628, 12, 628, 12, 628, 12, 628, 12, 627, 13, 627, 13, 628, 12, 628, 12, 628, 12, 628, 12, 628, 12, 627, 13, 627, 13, 628, 12, 628, 12, 628, 12, 628, 12, 627, 13, 627, 13, 628, 12, 628, 12, 628, 12, 628, 12, 46, 6, 576, 12, 45, 8, 575, 12, 44, 10, 574, 12, 43, 12, 573, 12, 43, 12, 573, 12, 43, 12, 544, 40, 44, 12, 3, 6, 521, 6, 5, 42, 12, 19, 14, 22, 519, 54, 11, 57, 517, 56, 9, 59, 515, 58, 7, 60, 514, 59, 7, 60, 513, 61, 6, 60, 513, 62, 5, 60, 513, 62, 5, 60, 513, 62, 5, 61, 512, 62, 5, 62, 511, 62, 5, 62, 511, 62, 5, 62, 511, 62, 5, 62, 511, 62, 5, 62, 511, 62, 5, 62, 511, 62, 5, 62, 511, 62, 6, 61, 511, 62, 6, 60, 512, 62, 7, 59, 513, 61, 7, 59, 513, 60, 1, 3, 4, 59, 513, 127, 513, 126, 514, 125, 515, 125, 515, 125, 515, 125, 515, 125, 516, 124, 516, 19, 1, 103, 365], "size": [640, 316]}, "area": 30530, "iscrowd": 1, "image_id": 10136, "bbox": [28, 109, 287, 373], "category_id": 84, "id": 908400010136}, {"segmentation": {"counts": [175851, 7, 471, 15, 464, 31, 448, 33, 447, 34, 445, 36, 444, 37, 443, 37, 443, 37, 443, 38, 442, 38, 442, 38, 443, 36, 445, 35, 446, 34, 447, 32, 451, 10, 6, 4, 4, 4, 454, 4, 1, 1, 15, 4, 454, 4, 17, 4, 453, 6, 17, 5, 451, 11, 14, 5, 449, 16, 1, 8, 1, 6, 448, 33, 446, 35, 445, 35, 445, 35, 445, 36, 444, 36, 444, 36, 444, 35, 446, 34, 447, 33, 447, 32, 448, 31, 449, 30, 450, 20, 1, 6, 453, 16, 464, 17, 463, 17, 463, 17, 463, 16, 464, 16, 464, 16, 464, 17, 463, 17, 463, 17, 463, 16, 464, 16, 463, 17, 463, 17, 463, 17, 463, 17, 463, 18, 462, 18, 462, 17, 463, 17, 464, 16, 464, 16, 464, 16, 464, 16, 463, 18, 462, 18, 463, 17, 463, 17, 463, 17, 463, 16, 464, 16, 464, 17, 463, 17, 463, 17, 463, 17, 463, 17, 463, 17, 463, 17, 463, 17, 463, 17, 464, 16, 463, 17, 463, 18, 462, 18, 462, 18, 462, 17, 463, 17, 463, 17, 464, 16, 464, 16, 463, 18, 462, 19, 461, 19, 461, 19, 461, 20, 460, 20, 461, 19, 461, 19, 460, 20, 460, 19, 461, 19, 461, 20, 460, 20, 460, 20, 460, 21, 459, 21, 459, 21, 459, 20, 460, 20, 460, 20, 460, 19, 461, 19, 462, 19, 460, 20, 460, 20, 460, 21, 459, 21, 459, 20, 460, 20, 460, 20, 461, 19, 461, 19, 462, 18, 462, 19, 461, 19, 460, 31, 449, 32, 448, 33, 447, 34, 446, 35, 445, 35, 445, 35, 445, 36, 444, 36, 444, 36, 444, 35, 445, 35, 445, 35, 445, 34, 446, 33, 448, 31, 448, 20, 2, 3, 1, 3, 451, 16, 464, 17, 463, 17, 463, 17, 463, 16, 464, 16, 465, 15, 464, 16, 464, 16, 463, 18, 462, 18, 462, 18, 462, 17, 463, 14, 466, 11, 469, 11, 470, 10, 471, 9, 472, 9, 472, 9, 474, 3, 1915, 21, 457, 24, 455, 26, 453, 28, 452, 29, 450, 30, 450, 30, 450, 31, 449, 31, 449, 31, 449, 30, 450, 30, 451, 29, 452, 27, 454, 25, 456, 23, 460, 6, 4, 3, 1, 3, 45885], "size": [480, 640]}, "area": 4029, "iscrowd": 1, "image_id": 10230, "bbox": [366, 166, 178, 41], "category_id": 1, "id": 900100010230}, {"segmentation": {"counts": [110406, 6, 420, 8, 418, 10, 416, 12, 415, 12, 415, 12, 415, 12, 415, 13, 414, 14, 413, 14, 414, 13, 415, 12, 415, 12, 415, 12, 415, 12, 416, 10, 418, 8, 421, 4, 89637, 6, 420, 8, 418, 10, 416, 12, 415, 12, 415, 12, 415, 12, 415, 12, 415, 12, 415, 12, 416, 10, 418, 8, 421, 4, 31166, 6, 420, 8, 418, 10, 416, 12, 415, 12, 415, 12, 415, 12, 415, 12, 415, 12, 415, 12, 416, 10, 418, 8, 421, 4, 14940, 11, 415, 13, 413, 15, 411, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 411, 15, 413, 13, 416, 4, 1, 4, 4473], "size": [427, 640]}, "area": 650, "iscrowd": 1, "image_id": 10281, "bbox": [258, 211, 371, 39], "category_id": 1, "id": 900100010281}, {"segmentation": {"counts": [28882, 4, 395, 6, 393, 8, 392, 8, 392, 9, 391, 9, 391, 8, 392, 8, 393, 6, 395, 4, 16397, 6, 393, 8, 391, 10, 389, 12, 388, 12, 388, 12, 388, 12, 387, 13, 387, 13, 387, 13, 387, 12, 388, 12, 388, 12, 388, 12, 389, 10, 391, 10, 389, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 389, 10, 391, 8, 394, 4, 32801, 4, 395, 6, 393, 8, 392, 8, 392, 8, 392, 8, 392, 8, 393, 6, 395, 4, 4793, 6, 393, 8, 391, 10, 389, 12, 388, 12, 388, 12, 388, 12, 388, 12, 144, 8, 236, 12, 139, 14, 235, 12, 138, 16, 235, 10, 138, 18, 235, 8, 138, 19, 237, 6, 138, 19, 236, 8, 137, 19, 235, 10, 136, 19, 234, 12, 135, 19, 234, 12, 135, 19, 234, 12, 135, 18, 235, 12, 136, 16, 236, 12, 137, 13, 238, 12, 139, 9, 240, 12, 388, 11, 389, 10, 390, 8, 393, 6, 395, 4, 396, 4, 395, 6, 393, 8, 392, 8, 392, 8, 392, 8, 392, 8, 393, 6, 395, 4, 18799, 6, 393, 8, 391, 10, 389, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 389, 10, 391, 10, 389, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 389, 10, 391, 8, 394, 4, 1594, 6, 393, 8, 391, 10, 129, 6, 254, 12, 127, 8, 253, 12, 126, 10, 252, 12, 125, 12, 251, 12, 125, 12, 251, 12, 125, 12, 251, 12, 125, 12, 251, 12, 125, 12, 252, 10, 126, 12, 253, 8, 127, 12, 255, 4, 130, 10, 391, 8, 394, 4, 1608, 3, 397, 4, 245, 6, 145, 5, 243, 8, 145, 5, 241, 10, 140, 9, 240, 12, 136, 12, 240, 12, 136, 12, 240, 12, 136, 12, 240, 12, 136, 13, 239, 12, 136, 14, 238, 13, 126, 6, 4, 13, 238, 14, 124, 8, 4, 12, 239, 14, 122, 10, 3, 12, 240, 13, 121, 12, 5, 9, 241, 12, 121, 12, 5, 9, 241, 12, 121, 12, 5, 9, 241, 12, 121, 12, 2, 12, 241, 12, 121, 12, 2, 12, 241, 12, 121, 12, 2, 12, 242, 10, 122, 12, 2, 12, 243, 8, 124, 10, 3, 4, 2, 3, 2, 1, 245, 4, 127, 8, 4, 4, 2, 1, 4, 1, 378, 4, 6, 4, 2, 1, 2, 3, 389, 10, 391, 8, 394, 4, 645, 6, 393, 8, 391, 10, 389, 12, 153, 1, 234, 12, 143, 6, 2, 4, 233, 12, 143, 12, 233, 12, 143, 12, 233, 12, 143, 12, 233, 12, 143, 12, 233, 5, 5, 2, 143, 12, 233, 5, 5, 2, 143, 13, 232, 7, 1, 4, 143, 14, 231, 12, 143, 14, 231, 12, 144, 13, 231, 12, 145, 12, 231, 12, 145, 12, 231, 12, 145, 12, 232, 10, 145, 13, 232, 10, 145, 13, 231, 12, 144, 13, 231, 12, 144, 13, 231, 12, 144, 13, 231, 12, 143, 14, 231, 12, 142, 15, 231, 12, 142, 15, 231, 12, 142, 15, 232, 10, 143, 15, 232, 10, 143, 15, 231, 12, 142, 15, 231, 12, 142, 15, 230, 13, 143, 10, 233, 14, 144, 8, 233, 15, 146, 3, 235, 16, 384, 16, 384, 15, 385, 14, 186, 6, 194, 12, 187, 8, 193, 12, 186, 10, 192, 12, 185, 12, 192, 10, 186, 12, 193, 8, 154, 6, 27, 12, 195, 4, 155, 8, 26, 12, 199, 6, 148, 10, 25, 12, 198, 8, 146, 12, 24, 12, 197, 10, 145, 12, 24, 12, 196, 12, 144, 12, 25, 10, 197, 12, 144, 12, 26, 8, 198, 12, 144, 12, 28, 4, 200, 12, 144, 12, 232, 12, 144, 12, 232, 12, 145, 10, 233, 12, 146, 8, 235, 10, 149, 4, 236, 10, 389, 9, 390, 10, 389, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 389, 10, 391, 8, 394, 4, 795, 4, 395, 6, 393, 8, 391, 10, 389, 12, 388, 12, 388, 12, 388, 12, 388, 12, 387, 13, 387, 13, 387, 12, 388, 11, 389, 9, 392, 6, 395, 4, 2, 4, 394, 7, 392, 9, 390, 10, 389, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 389, 11, 388, 13, 387, 13, 387, 13, 387, 13, 387, 13, 387, 12, 388, 12, 389, 10, 391, 8, 394, 4, 388, 6, 393, 8, 391, 10, 389, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 388, 12, 389, 10, 391, 8, 394, 6, 393, 8, 391, 10, 389, 12, 388, 12, 388, 12, 388, 12, 388, 16, 384, 17, 383, 18, 383, 18, 383, 17, 385, 15, 388, 12, 385, 15, 384, 16, 383, 17, 382, 19, 381, 19, 381, 19, 381, 19, 381, 19, 381, 19, 381, 19, 380, 19, 380, 19, 380, 19, 380, 20, 380, 20, 380, 20, 380, 12, 1, 6, 381, 12, 2, 4, 380, 14, 385, 15, 384, 15, 385, 14, 386, 12, 388, 8, 392, 8, 393, 6, 395, 4, 1605, 6, 393, 8, 391, 10, 389, 12, 388, 12, 388, 18, 382, 19, 381, 20, 380, 21, 379, 21, 380, 20, 381, 11, 2, 6, 383, 4, 1, 3, 3, 6, 388, 5, 1, 6, 377, 4, 7, 13, 375, 6, 7, 12, 374, 8, 5, 13, 374, 8, 5, 13, 374, 8, 5, 13, 374, 8, 5, 13, 374, 8, 5, 13, 375, 6, 6, 12, 377, 4, 8, 10, 391, 7, 392, 6, 393, 8, 391, 10, 389, 12, 388, 12, 372, 6, 10, 12, 371, 8, 9, 12, 370, 10, 8, 12, 369, 12, 7, 12, 369, 12, 7, 12, 369, 12, 8, 10, 370, 12, 9, 8, 371, 12, 11, 4, 373, 12, 388, 12, 389, 10, 391, 8, 394, 4, 3611, 7, 392, 9, 390, 11, 388, 13, 387, 13, 387, 13, 387, 13, 387, 13, 387, 13, 387, 13, 388, 11, 390, 9, 393, 6, 6307], "size": [400, 640]}, "area": 5451, "iscrowd": 1, "image_id": 10318, "bbox": [72, 67, 552, 222], "category_id": 1, "id": 900100010318}, {"segmentation": {"counts": [927, 67, 573, 67, 573, 70, 569, 72, 567, 74, 566, 75, 564, 77, 563, 77, 563, 78, 561, 80, 560, 80, 560, 81, 559, 81, 559, 82, 558, 82, 558, 82, 558, 83, 557, 83, 557, 83, 557, 83, 557, 83, 557, 83, 557, 83, 557, 83, 557, 83, 557, 83, 558, 82, 558, 82, 558, 82, 558, 82, 558, 82, 558, 81, 559, 81, 559, 82, 558, 83, 557, 83, 557, 83, 558, 82, 558, 82, 559, 81, 559, 81, 560, 79, 561, 78, 563, 76, 564, 76, 565, 75, 566, 74, 567, 73, 568, 72, 569, 71, 569, 70, 569, 70, 570, 68, 571, 25, 7, 16, 591, 20, 619, 17, 622, 16, 624, 16, 624, 15, 625, 13, 627, 12, 628, 12, 628, 11, 630, 10, 631, 8, 19, 3, 612, 7, 15, 6, 614, 7, 12, 8, 612, 11, 8, 9, 611, 13, 6, 11, 610, 16, 3, 11, 610, 17, 1, 13, 609, 32, 608, 37, 603, 38, 602, 39, 602, 41, 600, 42, 13, 9, 576, 47, 7, 11, 574, 49, 5, 13, 573, 50, 3, 15, 571, 52, 2, 15, 570, 70, 570, 70, 569, 71, 569, 71, 569, 71, 568, 71, 569, 71, 569, 70, 570, 69, 571, 68, 572, 68, 572, 67, 573, 67, 573, 68, 572, 68, 572, 68, 572, 68, 572, 68, 572, 68, 572, 70, 571, 70, 570, 71, 570, 71, 569, 71, 570, 70, 570, 70, 570, 70, 570, 70, 570, 70, 570, 70, 570, 70, 570, 70, 570, 69, 572, 68, 573, 67, 573, 66, 574, 66, 574, 65, 575, 64, 576, 63, 577, 63, 577, 63, 577, 63, 577, 63, 577, 63, 577, 62, 578, 62, 578, 62, 578, 62, 579, 61, 579, 61, 579, 61, 578, 62, 578, 62, 578, 62, 578, 62, 578, 61, 579, 61, 579, 61, 579, 61, 579, 60, 580, 60, 580, 59, 581, 59, 581, 59, 581, 58, 582, 58, 582, 58, 582, 58, 583, 57, 583, 57, 583, 56, 584, 55, 585, 54, 601, 41, 602, 39, 605, 36, 608, 33, 611, 29, 615, 25, 618, 22, 622, 18, 624, 16, 624, 1, 2, 13, 628, 11, 630, 9, 633, 5, 52432, 2, 637, 7, 632, 11, 628, 16, 623, 16, 624, 11, 628, 9, 630, 10, 630, 10, 629, 10, 630, 10, 25, 1, 604, 10, 26, 1, 602, 12, 8, 2, 5, 7, 2, 3, 601, 14, 4, 7, 3, 12, 600, 26, 3, 12, 8, 1, 590, 26, 3, 13, 6, 2, 590, 26, 3, 14, 3, 4, 590, 26, 4, 3, 3, 14, 590, 26, 4, 1, 12, 7, 590, 26, 18, 6, 590, 24, 21, 5, 590, 22, 618, 19, 621, 18, 622, 17, 623, 17, 30, 3, 590, 18, 17, 4, 601, 18, 14, 11, 598, 20, 7, 19, 594, 21, 8, 19, 593, 21, 4, 1, 3, 17, 594, 18, 12, 16, 595, 17, 13, 16, 594, 17, 15, 15, 594, 16, 18, 12, 593, 17, 20, 10, 593, 17, 22, 9, 591, 18, 24, 7, 591, 19, 3, 5, 16, 6, 591, 29, 9, 12, 590, 50, 590, 50, 589, 22, 10, 19, 589, 19, 19, 13, 589, 19, 23, 9, 589, 19, 29, 3, 589, 19, 621, 19, 622, 18, 622, 18, 622, 14, 626, 11, 629, 11, 630, 10, 630, 10, 630, 10, 631, 9, 25, 12, 594, 10, 9, 2, 8, 16, 596, 8, 18, 18, 597, 6, 19, 17, 598, 5, 20, 16, 600, 2, 22, 16, 601, 1, 21, 17, 601, 1, 6, 4, 11, 18, 599, 2, 5, 7, 9, 19, 598, 15, 8, 19, 597, 17, 7, 20, 595, 20, 5, 21, 594, 21, 4, 21, 593, 24, 2, 22, 591, 26, 1, 22, 590, 22, 10, 18, 589, 20, 19, 13, 588, 18, 20, 14, 588, 17, 18, 18, 587, 16, 13, 25, 586, 15, 11, 28, 586, 15, 7, 32, 586, 11, 9, 34, 587, 9, 9, 35, 588, 7, 9, 36, 588, 8, 7, 37, 588, 8, 6, 37, 589, 8, 4, 38, 590, 43, 597, 35, 605, 34, 607, 33, 606, 33, 607, 32, 608, 31, 609, 31, 609, 30, 610, 29, 611, 29, 611, 28, 612, 24, 616, 18, 622, 15, 625, 15, 625, 15, 625, 15, 625, 15, 626, 14, 626, 14, 626, 14, 12, 1, 613, 14, 10, 4, 612, 14, 8, 7, 611, 18, 2, 10, 610, 31, 609, 32, 607, 34, 606, 33, 607, 34, 6, 7, 3, 2, 588, 34, 16, 4, 586, 32, 18, 5, 585, 25, 1, 5, 19, 6, 584, 23, 5, 1, 21, 7, 583, 8, 2, 12, 28, 8, 582, 7, 4, 11, 29, 8, 581, 7, 4, 11, 30, 8, 580, 8, 3, 12, 30, 7, 580, 24, 30, 7, 579, 24, 30, 8, 578, 27, 2, 2, 24, 7, 578, 32, 24, 7, 578, 32, 23, 7, 578, 34, 15, 13, 578, 37, 11, 15, 576, 46, 2, 16, 576, 17, 5, 42, 576, 14, 10, 40, 575, 14, 14, 37, 574, 12, 18, 9, 3, 24, 573, 11, 21, 5, 19, 11, 573, 11, 22, 1, 22, 11, 573, 11, 45, 11, 573, 10, 45, 12, 573, 16, 36, 15, 573, 17, 24, 26, 573, 18, 14, 35, 574, 26, 1, 39, 575, 65, 575, 64, 576, 64, 577, 62, 578, 62, 579, 60, 580, 61, 578, 62, 578, 63, 576, 64, 576, 64, 576, 65, 574, 66, 574, 66, 574, 66, 574, 66, 574, 66, 574, 66, 574, 67, 573, 66, 574, 66, 574, 66, 574, 66, 574, 66, 574, 66, 574, 66, 574, 65, 576, 71, 569, 72, 569, 72, 568, 73, 567, 73, 566, 74, 566, 74, 566, 74, 565, 75, 565, 75, 565, 75, 564, 75, 565, 77, 563, 78, 562, 79, 561, 80, 560, 81, 559, 82, 558, 83, 557, 83, 557, 84, 556, 85, 555, 85, 555, 86, 555, 85, 555, 85, 555, 86, 554, 86, 554, 86, 553, 88, 552, 88, 552, 88, 551, 89, 551, 89, 551, 89, 551, 89, 551, 32, 19, 39, 550, 31, 24, 35, 550, 31, 27, 16, 3, 13, 550, 23, 53, 15, 549, 22, 54, 15, 549, 21, 54, 16, 549, 22, 53, 16, 549, 23, 31, 14, 6, 17, 549, 24, 30, 37, 549, 25, 43, 23, 549, 26, 50, 15, 549, 32, 45, 14, 549, 33, 44, 14, 549, 34, 9, 23, 11, 14, 549, 38, 5, 31, 3, 14, 549, 41, 2, 32, 1, 15, 549, 91, 549, 91, 549, 91, 549, 91, 550, 90, 550, 90, 551, 88, 552, 88, 553, 86, 258], "size": [640, 480]}, "area": 24824, "iscrowd": 1, "image_id": 10321, "bbox": [1, 283, 478, 100], "category_id": 1, "id": 900100010321}, {"segmentation": {"counts": [45100, 3, 421, 9, 417, 11, 415, 13, 413, 15, 412, 16, 411, 16, 410, 17, 410, 17, 410, 17, 410, 17, 410, 18, 408, 19, 408, 20, 406, 21, 406, 21, 406, 21, 406, 21, 406, 21, 406, 21, 407, 20, 407, 20, 407, 20, 406, 21, 406, 20, 408, 18, 409, 18, 410, 15, 412, 15, 413, 14, 413, 13, 414, 12, 415, 12, 368, 7, 41, 9, 369, 10, 41, 5, 369, 13, 414, 14, 412, 15, 412, 16, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 18, 409, 18, 409, 19, 408, 19, 408, 19, 408, 19, 408, 19, 409, 18, 409, 18, 410, 16, 412, 14, 414, 13, 415, 10, 419, 6, 24404, 7, 419, 10, 415, 13, 414, 14, 412, 14, 413, 14, 412, 15, 412, 16, 411, 17, 410, 17, 410, 17, 409, 18, 409, 19, 407, 20, 407, 20, 407, 20, 407, 20, 407, 20, 406, 21, 406, 22, 404, 23, 404, 23, 404, 23, 404, 23, 376, 7, 21, 23, 375, 10, 18, 24, 373, 13, 17, 25, 372, 14, 15, 26, 371, 17, 13, 26, 371, 18, 12, 26, 370, 20, 11, 26, 370, 20, 11, 26, 370, 21, 10, 26, 370, 21, 9, 27, 370, 21, 8, 29, 369, 21, 8, 29, 369, 21, 8, 29, 369, 21, 7, 31, 368, 21, 7, 31, 367, 21, 8, 30, 368, 20, 9, 30, 368, 20, 9, 31, 367, 19, 10, 31, 367, 19, 10, 32, 366, 18, 10, 33, 366, 18, 10, 33, 365, 19, 10, 33, 365, 20, 9, 33, 365, 20, 9, 33, 364, 21, 9, 16, 1, 16, 362, 23, 9, 16, 1, 16, 362, 22, 9, 17, 1, 15, 362, 24, 8, 16, 2, 15, 362, 24, 8, 17, 1, 13, 363, 25, 8, 17, 1, 11, 365, 25, 8, 17, 1, 9, 367, 25, 8, 16, 3, 7, 368, 25, 8, 16, 3, 5, 370, 25, 7, 17, 3, 4, 371, 24, 8, 16, 4, 2, 372, 24, 8, 17, 378, 24, 8, 20, 375, 23, 9, 18, 377, 49, 378, 48, 379, 48, 365, 5, 1, 55, 357, 69, 357, 69, 356, 70, 357, 69, 357, 70, 357, 69, 357, 69, 358, 68, 359, 67, 360, 66, 361, 66, 362, 64, 363, 56, 1, 6, 364, 55, 2, 5, 365, 61, 366, 19, 3, 2, 1, 36, 366, 17, 9, 34, 367, 17, 9, 33, 368, 17, 10, 32, 368, 16, 12, 30, 370, 16, 12, 29, 370, 16, 14, 26, 371, 16, 15, 25, 370, 17, 17, 22, 371, 17, 21, 17, 372, 17, 22, 16, 373, 16, 23, 13, 375, 16, 25, 9, 377, 16, 411, 17, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 411, 16, 411, 16, 411, 16, 411, 16, 411, 17, 410, 17, 410, 16, 411, 16, 411, 16, 412, 16, 410, 17, 410, 17, 410, 17, 410, 17, 410, 17, 411, 16, 411, 16, 411, 16, 411, 17, 410, 17, 410, 17, 410, 17, 410, 16, 17, 1, 393, 16, 412, 16, 13, 4, 394, 16, 13, 7, 390, 17, 12, 11, 387, 17, 10, 16, 384, 17, 10, 19, 382, 16, 9, 23, 379, 16, 9, 26, 376, 16, 8, 30, 373, 16, 8, 32, 371, 17, 7, 34, 369, 17, 7, 35, 368, 17, 7, 35, 368, 17, 8, 34, 368, 17, 8, 34, 368, 16, 10, 33, 369, 16, 10, 32, 369, 16, 10, 31, 370, 16, 10, 31, 369, 17, 10, 31, 370, 16, 10, 31, 370, 16, 10, 31, 370, 16, 5, 36, 370, 16, 4, 37, 371, 15, 2, 38, 371, 17, 1, 37, 372, 56, 371, 56, 371, 56, 371, 56, 372, 54, 373, 54, 373, 54, 373, 53, 374, 53, 374, 52, 375, 17, 1, 34, 375, 16, 3, 32, 376, 16, 5, 29, 378, 16, 7, 26, 378, 16, 8, 24, 378, 17, 9, 23, 378, 17, 10, 21, 379, 17, 12, 5, 1, 13, 379, 17, 18, 13, 380, 16, 18, 13, 380, 16, 18, 14, 379, 16, 17, 17, 377, 17, 16, 17, 377, 17, 16, 17, 377, 17, 16, 17, 377, 17, 16, 17, 377, 17, 16, 17, 377, 16, 17, 16, 379, 16, 15, 16, 380, 16, 15, 17, 379, 16, 15, 17, 378, 17, 15, 17, 378, 17, 15, 17, 378, 17, 15, 16, 380, 16, 14, 17, 380, 16, 14, 16, 381, 16, 14, 16, 381, 17, 13, 16, 381, 17, 12, 17, 381, 17, 13, 16, 381, 17, 13, 16, 381, 17, 12, 17, 381, 17, 12, 17, 382, 16, 12, 16, 383, 16, 11, 17, 383, 16, 11, 17, 383, 17, 8, 19, 383, 22, 3, 19, 383, 44, 383, 43, 384, 43, 384, 43, 385, 42, 1, 7, 376, 53, 374, 54, 373, 55, 372, 55, 372, 56, 372, 55, 372, 55, 373, 49, 2, 3, 374, 46, 3, 4, 375, 43, 5, 4, 376, 41, 5, 5, 378, 37, 7, 4, 379, 33, 1, 1, 8, 4, 381, 32, 10, 4, 382, 30, 10, 3, 385, 27, 12, 1, 389, 23, 405, 22, 405, 21, 407, 19, 409, 18, 411, 16, 412, 17, 410, 18, 404, 25, 401, 27, 398, 30, 397, 32, 394, 34, 393, 35, 391, 38, 389, 39, 388, 41, 386, 43, 384, 45, 383, 46, 381, 46, 382, 46, 382, 46, 382, 47, 382, 46, 387, 40, 387, 41, 387, 17, 2, 22, 387, 41, 386, 41, 386, 41, 386, 40, 387, 22, 1, 17, 388, 38, 17, 1, 371, 22, 1, 15, 16, 3, 371, 21, 2, 13, 18, 3, 370, 21, 3, 12, 17, 5, 369, 21, 4, 11, 16, 7, 368, 21, 6, 9, 15, 9, 367, 21, 6, 9, 14, 11, 367, 20, 4, 11, 12, 14, 366, 21, 2, 12, 11, 16, 366, 34, 10, 16, 354, 47, 10, 16, 353, 48, 9, 16, 352, 50, 6, 18, 353, 50, 5, 18, 353, 51, 6, 17, 353, 52, 7, 16, 351, 53, 8, 15, 351, 53, 9, 14, 351, 53, 10, 13, 351, 53, 11, 12, 351, 53, 12, 11, 352, 52, 13, 10, 352, 52, 16, 6, 354, 51, 18, 4, 355, 50, 378, 49, 380, 47, 381, 46, 380, 47, 380, 47, 380, 47, 380, 48, 379, 48, 380, 47, 380, 47, 381, 46, 382, 49, 379, 52, 376, 58, 370, 57, 371, 56, 372, 55, 373, 53, 373, 54, 373, 54, 372, 54, 372, 54, 372, 55, 371, 56, 368, 59, 367, 60, 366, 60, 3, 12, 351, 77, 349, 79, 345, 83, 343, 84, 342, 85, 342, 85, 339, 88, 338, 89, 336, 92, 335, 27, 1, 64, 334, 27, 1, 65, 334, 94, 332, 95, 332, 95, 332, 81, 1, 13, 332, 81, 1, 13, 332, 81, 1, 13, 333, 79, 1, 13, 334, 93, 335, 92, 336, 91, 337, 90, 339, 87, 346, 81, 348, 78, 352, 75, 351, 76, 351, 76, 349, 78, 348, 79, 348, 78, 348, 79, 348, 79, 348, 79, 348, 78, 350, 13, 1, 63, 350, 12, 2, 62, 352, 10, 2, 63, 353, 8, 3, 64, 354, 4, 4, 65, 362, 64, 363, 62, 365, 61, 365, 61, 365, 60, 367, 59, 366, 57, 369, 54, 371, 52, 375, 48, 378, 48, 379, 47, 379, 48, 379, 41, 2, 5, 379, 40, 4, 5, 378, 40, 5, 4, 378, 40, 5, 4, 378, 39, 6, 5, 377, 39, 6, 5, 377, 38, 7, 5, 378, 37, 7, 6, 377, 37, 8, 5, 377, 37, 8, 5, 377, 43, 3, 5, 376, 45, 2, 4, 376, 46, 1, 4, 376, 52, 374, 53, 374, 54, 372, 56, 371, 58, 369, 59, 368, 60, 368, 61, 365, 63, 364, 65, 361, 67, 360, 68, 359, 68, 359, 68, 357, 70, 357, 71, 355, 73, 354, 73, 353, 75, 352, 75, 352, 75, 352, 75, 352, 75, 353, 74, 353, 74, 354, 74, 354, 75, 353, 75, 354, 74, 353, 76, 351, 77, 350, 78, 350, 77, 350, 78, 350, 17, 1, 59, 351, 16, 1, 59, 352, 13, 3, 59, 354, 9, 5, 59, 369, 58, 369, 58, 370, 20, 2, 34, 372, 17, 10, 1, 2, 24, 119], "size": [427, 640]}, "area": 23862, "iscrowd": 1, "image_id": 10281, "bbox": [105, 207, 534, 102], "category_id": 38, "id": 903800010281}, {"segmentation": {"counts": [29637, 12, 412, 18, 407, 22, 403, 26, 399, 30, 396, 32, 394, 34, 392, 36, 390, 38, 388, 40, 386, 42, 385, 42, 384, 44, 382, 46, 381, 46, 380, 48, 379, 48, 379, 48, 378, 50, 377, 50, 377, 50, 377, 50, 377, 50, 377, 50, 377, 50, 377, 51, 376, 51, 376, 52, 375, 52, 375, 52, 375, 53, 374, 53, 374, 53, 374, 53, 374, 53, 374, 53, 375, 52, 375, 52, 375, 52, 375, 52, 375, 52, 375, 52, 376, 51, 376, 51, 377, 50, 377, 50, 378, 48, 379, 48, 380, 46, 381, 46, 382, 44, 383, 44, 384, 42, 385, 42, 386, 40, 388, 38, 390, 36, 392, 34, 394, 32, 397, 28, 400, 26, 403, 22, 408, 16, 415, 8, 32784, 10, 414, 16, 409, 20, 405, 24, 402, 26, 400, 28, 398, 31, 395, 34, 392, 37, 390, 38, 20, 10, 358, 40, 16, 16, 354, 42, 13, 20, 352, 43, 10, 24, 350, 44, 8, 26, 348, 45, 7, 28, 347, 46, 5, 30, 346, 47, 3, 32, 345, 47, 2, 34, 344, 47, 2, 34, 344, 84, 343, 85, 342, 85, 342, 85, 342, 86, 341, 86, 341, 86, 341, 86, 341, 86, 342, 85, 342, 85, 343, 84, 343, 84, 344, 83, 345, 82, 345, 82, 346, 81, 347, 39, 2, 38, 349, 38, 2, 38, 351, 35, 4, 36, 353, 33, 5, 36, 356, 29, 7, 34, 359, 26, 9, 33, 361, 22, 11, 32, 363, 20, 13, 30, 319, 12, 36, 14, 17, 28, 317, 18, 36, 8, 21, 26, 316, 22, 65, 22, 316, 26, 64, 20, 316, 28, 66, 14, 318, 30, 68, 8, 320, 32, 394, 34, 392, 36, 391, 36, 390, 38, 388, 40, 387, 40, 387, 40, 386, 42, 385, 42, 385, 42, 385, 42, 385, 42, 385, 42, 385, 42, 385, 42, 385, 42, 385, 42, 385, 42, 385, 42, 385, 42, 386, 41, 386, 41, 387, 40, 387, 40, 387, 41, 386, 41, 386, 41, 387, 40, 387, 40, 387, 25, 9, 6, 387, 24, 10, 6, 387, 24, 11, 5, 387, 24, 11, 5, 387, 24, 11, 5, 387, 24, 11, 5, 387, 24, 12, 4, 387, 24, 12, 4, 387, 35, 1, 4, 387, 40, 387, 24, 13, 3, 387, 24, 14, 2, 387, 24, 15, 1, 387, 23, 16, 1, 387, 23, 404, 23, 404, 23, 404, 23, 404, 24, 403, 24, 403, 40, 12, 10, 365, 25, 24, 16, 362, 23, 24, 20, 360, 22, 23, 24, 358, 22, 22, 27, 356, 22, 21, 29, 355, 22, 20, 31, 354, 22, 20, 32, 353, 22, 20, 33, 352, 22, 20, 34, 351, 22, 20, 34, 351, 22, 20, 35, 350, 23, 18, 37, 349, 78, 349, 78, 349, 79, 348, 79, 349, 78, 349, 78, 348, 79, 348, 79, 347, 80, 346, 82, 345, 82, 327, 10, 8, 82, 324, 16, 4, 83, 322, 20, 2, 83, 320, 64, 1, 42, 319, 65, 1, 42, 318, 66, 2, 41, 317, 67, 2, 41, 316, 68, 3, 40, 315, 69, 3, 40, 315, 69, 3, 40, 314, 70, 3, 40, 313, 71, 3, 40, 313, 71, 3, 41, 253, 15, 44, 71, 3, 41, 250, 21, 40, 72, 3, 41, 248, 25, 38, 71, 4, 42, 245, 29, 36, 71, 4, 42, 243, 33, 34, 70, 5, 42, 242, 35, 33, 70, 5, 43, 240, 38, 31, 69, 6, 43, 239, 40, 30, 69, 6, 43, 238, 42, 29, 68, 7, 44, 236, 44, 28, 68, 7, 44, 235, 46, 27, 67, 9, 43, 235, 47, 26, 67, 9, 44, 233, 49, 25, 66, 11, 43, 232, 51, 24, 66, 11, 43, 232, 51, 24, 65, 12, 43, 231, 53, 23, 65, 12, 44, 230, 54, 22, 65, 12, 44, 230, 54, 22, 66, 12, 43, 229, 56, 21, 66, 12, 43, 229, 56, 21, 66, 13, 42, 229, 56, 21, 66, 13, 42, 229, 57, 20, 66, 14, 41, 229, 57, 20, 66, 13, 42, 229, 57, 20, 66, 13, 42, 229, 57, 20, 66, 13, 42, 229, 57, 20, 66, 13, 42, 229, 57, 20, 66, 13, 42, 229, 57, 20, 66, 13, 42, 229, 57, 20, 66, 13, 42, 229, 57, 20, 66, 13, 42, 229, 57, 20, 66, 13, 42, 229, 57, 20, 66, 13, 42, 229, 57, 21, 65, 13, 42, 230, 56, 21, 65, 13, 42, 230, 56, 22, 64, 13, 41, 232, 55, 22, 64, 14, 40, 232, 54, 24, 63, 14, 39, 234, 53, 25, 62, 15, 38, 234, 52, 26, 62, 15, 37, 236, 51, 27, 60, 17, 36, 236, 50, 29, 59, 18, 34, 238, 49, 30, 57, 19, 33, 240, 47, 32, 56, 20, 31, 242, 46, 33, 54, 22, 29, 244, 44, 34, 54, 23, 26, 247, 42, 36, 52, 26, 23, 250, 39, 38, 51, 27, 20, 253, 37, 40, 49, 31, 14, 258, 34, 43, 46, 35, 8, 264, 29, 46, 44, 310, 26, 50, 40, 313, 22, 55, 36, 317, 16, 62, 30, 323, 8, 67, 28, 402, 22, 408, 16, 7310, 6, 420, 8, 418, 12, 414, 15, 412, 17, 410, 18, 408, 18, 29, 4, 376, 17, 22, 19, 370, 16, 21, 21, 369, 15, 21, 26, 366, 14, 20, 29, 365, 12, 21, 33, 362, 11, 23, 32, 363, 8, 27, 30, 363, 7, 29, 31, 361, 5, 32, 30, 362, 3, 35, 31, 398, 30, 400, 28, 401, 27, 403, 25, 405, 22, 407, 20, 410, 17, 412, 15, 415, 12, 417, 10, 420, 7, 423, 4, 425, 2, 1202, 1, 701, 10, 141, 1, 272, 16, 137, 1, 271, 20, 135, 1, 269, 24, 133, 1, 268, 26, 131, 1, 268, 28, 130, 1, 267, 30, 396, 32, 228, 1, 165, 34, 228, 6, 159, 34, 228, 7, 157, 36, 228, 7, 155, 38, 227, 8, 154, 38, 228, 8, 153, 38, 228, 8, 152, 40, 228, 7, 152, 40, 227, 8, 152, 40, 227, 8, 152, 40, 226, 9, 152, 40, 226, 9, 152, 40, 225, 9, 153, 40, 225, 8, 154, 40, 225, 6, 156, 40, 387, 40, 387, 40, 387, 40, 387, 40, 388, 38, 389, 38, 390, 36, 391, 36, 392, 34, 394, 33, 394, 32, 396, 30, 398, 28, 400, 26, 403, 22, 406, 20, 410, 14, 416, 8, 972, 5, 420, 6, 420, 7, 419, 7, 419, 8, 418, 8, 418, 9, 418, 8, 419, 8, 419, 7, 420, 7, 420, 6, 421, 6, 421, 5, 422, 5, 422, 4, 181, 10, 232, 4, 178, 16, 229, 3, 177, 20, 227, 3, 175, 24, 225, 2, 175, 26, 225, 1, 174, 28, 398, 30, 396, 32, 394, 37, 390, 40, 386, 43, 204, 7, 172, 46, 201, 7, 173, 47, 199, 8, 173, 48, 197, 8, 173, 4, 14, 32, 196, 8, 173, 4, 20, 27, 195, 7, 174, 4, 20, 28, 194, 7, 174, 4, 20, 28, 194, 6, 175, 4, 21, 28, 193, 6, 175, 4, 21, 29, 192, 5, 176, 4, 21, 29, 192, 5, 176, 4, 21, 29, 192, 4, 177, 4, 21, 30, 191, 4, 177, 4, 21, 30, 191, 3, 178, 4, 21, 30, 191, 3, 178, 21, 4, 30, 191, 3, 178, 55, 191, 2, 179, 28, 18, 9, 192, 1, 179, 28, 18, 9, 372, 28, 18, 9, 372, 28, 18, 9, 372, 28, 18, 9, 371, 29, 18, 9, 371, 29, 18, 9, 371, 29, 18, 9, 371, 29, 18, 9, 371, 29, 18, 9, 157, 7, 207, 29, 18, 9, 156, 9, 206, 56, 155, 11, 205, 56, 154, 14, 203, 31, 15, 21, 143, 15, 202, 29, 18, 23, 140, 16, 201, 29, 18, 25, 138, 19, 197, 30, 18, 27, 136, 22, 194, 30, 18, 29, 134, 23, 193, 30, 18, 30, 133, 28, 188, 30, 18, 31, 133, 28, 187, 29, 19, 32, 133, 27, 187, 29, 19, 33, 132, 26, 188, 29, 19, 34, 132, 25, 188, 29, 9, 5, 4, 36, 132, 23, 189, 30, 17, 36, 133, 22, 189, 29, 18, 37, 132, 21, 189, 30, 18, 38, 132, 20, 189, 29, 19, 38, 133, 18, 189, 30, 19, 38, 134, 17, 188, 31, 19, 39, 134, 15, 189, 31, 19, 40, 133, 15, 189, 31, 19, 41, 132, 14, 189, 32, 19, 41, 133, 13, 189, 33, 18, 42, 133, 11, 190, 34, 17, 43, 133, 10, 190, 94, 133, 9, 190, 95, 134, 8, 190, 96, 134, 6, 191, 96, 135, 5, 109, 1, 81, 96, 135, 5, 191, 96, 136, 5, 107, 1, 82, 96, 136, 5, 107, 1, 82, 97, 136, 4, 107, 1, 82, 98, 136, 4, 105, 2, 82, 98, 136, 4, 105, 2, 82, 98, 137, 3, 104, 2, 83, 99, 136, 4, 103, 1, 84, 99, 137, 4, 101, 2, 84, 99, 139, 3, 100, 1, 85, 99, 139, 5, 97, 1, 86, 99, 139, 7, 182, 99, 140, 8, 180, 99, 140, 10, 178, 99, 141, 11, 177, 98, 142, 12, 175, 98, 143, 13, 174, 97, 143, 14, 173, 97, 144, 15, 172, 96, 144, 16, 172, 95, 145, 15, 172, 95, 147, 15, 171, 94, 147, 16, 171, 92, 148, 17, 171, 91, 149, 17, 172, 89, 150, 16, 172, 89, 151, 16, 170, 89, 155, 14, 168, 90, 155, 14, 167, 90, 156, 15, 165, 91, 156, 15, 165, 90, 158, 14, 164, 91, 159, 13, 163, 91, 160, 13, 163, 91, 161, 12, 163, 91, 161, 12, 162, 93, 160, 12, 162, 94, 160, 10, 163, 94, 161, 8, 164, 94, 163, 4, 166, 95, 332, 95, 332, 95, 332, 95, 332, 95, 332, 95, 213, 1, 10, 2, 106, 95, 213, 6, 3, 4, 106, 95, 213, 13, 106, 95, 213, 13, 107, 94, 213, 12, 108, 40, 2, 52, 214, 10, 110, 38, 3, 52, 215, 8, 111, 37, 5, 51, 217, 4, 114, 35, 6, 51, 336, 33, 8, 50, 336, 32, 10, 48, 338, 30, 11, 48, 339, 28, 13, 46, 341, 26, 15, 45, 343, 22, 18, 43, 345, 20, 21, 41, 348, 14, 25, 39, 352, 8, 31, 35, 394, 32, 396, 30, 104], "size": [427, 640]}, "area": 37201, "iscrowd": 1, "image_id": 10130, "bbox": [69, 3, 570, 406], "category_id": 77, "id": 907700010130}], "categories": [{"supercategory": "person", "id": 1, "name": "person"}, {"supercategory": "vehicle", "id": 2, "name": "bicycle"}, {"supercategory": "vehicle", "id": 3, "name": "car"}, {"supercategory": "vehicle", "id": 4, "name": "motorcycle"}, {"supercategory": "vehicle", "id": 5, "name": "airplane"}, {"supercategory": "vehicle", "id": 6, "name": "bus"}, {"supercategory": "vehicle", "id": 7, "name": "train"}, {"supercategory": "vehicle", "id": 8, "name": "truck"}, {"supercategory": "vehicle", "id": 9, "name": "boat"}, {"supercategory": "outdoor", "id": 10, "name": "traffic light"}, {"supercategory": "outdoor", "id": 11, "name": "fire hydrant"}, {"supercategory": "outdoor", "id": 13, "name": "stop sign"}, {"supercategory": "outdoor", "id": 14, "name": "parking meter"}, {"supercategory": "outdoor", "id": 15, "name": "bench"}, {"supercategory": "animal", "id": 16, "name": "bird"}, {"supercategory": "animal", "id": 17, "name": "cat"}, {"supercategory": "animal", "id": 18, "name": "dog"}, {"supercategory": "animal", "id": 19, "name": "horse"}, {"supercategory": "animal", "id": 20, "name": "sheep"}, {"supercategory": "animal", "id": 21, "name": "cow"}, {"supercategory": "animal", "id": 22, "name": "elephant"}, {"supercategory": "animal", "id": 23, "name": "bear"}, {"supercategory": "animal", "id": 24, "name": "zebra"}, {"supercategory": "animal", "id": 25, "name": "giraffe"}, {"supercategory": "accessory", "id": 27, "name": "backpack"}, {"supercategory": "accessory", "id": 28, "name": "umbrella"}, {"supercategory": "accessory", "id": 31, "name": "handbag"}, {"supercategory": "accessory", "id": 32, "name": "tie"}, {"supercategory": "accessory", "id": 33, "name": "suitcase"}, {"supercategory": "sports", "id": 34, "name": "frisbee"}, {"supercategory": "sports", "id": 35, "name": "skis"}, {"supercategory": "sports", "id": 36, "name": "snowboard"}, {"supercategory": "sports", "id": 37, "name": "sports ball"}, {"supercategory": "sports", "id": 38, "name": "kite"}, {"supercategory": "sports", "id": 39, "name": "baseball bat"}, {"supercategory": "sports", "id": 40, "name": "baseball glove"}, {"supercategory": "sports", "id": 41, "name": "skateboard"}, {"supercategory": "sports", "id": 42, "name": "surfboard"}, {"supercategory": "sports", "id": 43, "name": "tennis racket"}, {"supercategory": "kitchen", "id": 44, "name": "bottle"}, {"supercategory": "kitchen", "id": 46, "name": "wine glass"}, {"supercategory": "kitchen", "id": 47, "name": "cup"}, {"supercategory": "kitchen", "id": 48, "name": "fork"}, {"supercategory": "kitchen", "id": 49, "name": "knife"}, {"supercategory": "kitchen", "id": 50, "name": "spoon"}, {"supercategory": "kitchen", "id": 51, "name": "bowl"}, {"supercategory": "food", "id": 52, "name": "banana"}, {"supercategory": "food", "id": 53, "name": "apple"}, {"supercategory": "food", "id": 54, "name": "sandwich"}, {"supercategory": "food", "id": 55, "name": "orange"}, {"supercategory": "food", "id": 56, "name": "broccoli"}, {"supercategory": "food", "id": 57, "name": "carrot"}, {"supercategory": "food", "id": 58, "name": "hot dog"}, {"supercategory": "food", "id": 59, "name": "pizza"}, {"supercategory": "food", "id": 60, "name": "donut"}, {"supercategory": "food", "id": 61, "name": "cake"}, {"supercategory": "furniture", "id": 62, "name": "chair"}, {"supercategory": "furniture", "id": 63, "name": "couch"}, {"supercategory": "furniture", "id": 64, "name": "potted plant"}, {"supercategory": "furniture", "id": 65, "name": "bed"}, {"supercategory": "furniture", "id": 67, "name": "dining table"}, {"supercategory": "furniture", "id": 70, "name": "toilet"}, {"supercategory": "electronic", "id": 72, "name": "tv"}, {"supercategory": "electronic", "id": 73, "name": "laptop"}, {"supercategory": "electronic", "id": 74, "name": "mouse"}, {"supercategory": "electronic", "id": 75, "name": "remote"}, {"supercategory": "electronic", "id": 76, "name": "keyboard"}, {"supercategory": "electronic", "id": 77, "name": "cell phone"}, {"supercategory": "appliance", "id": 78, "name": "microwave"}, {"supercategory": "appliance", "id": 79, "name": "oven"}, {"supercategory": "appliance", "id": 80, "name": "toaster"}, {"supercategory": "appliance", "id": 81, "name": "sink"}, {"supercategory": "appliance", "id": 82, "name": "refrigerator"}, {"supercategory": "indoor", "id": 84, "name": "book"}, {"supercategory": "indoor", "id": 85, "name": "clock"}, {"supercategory": "indoor", "id": 86, "name": "vase"}, {"supercategory": "indoor", "id": 87, "name": "scissors"}, {"supercategory": "indoor", "id": 88, "name": "teddy bear"}, {"supercategory": "indoor", "id": 89, "name": "hair drier"}, {"supercategory": "indoor", "id": 90, "name": "toothbrush"}]} \ No newline at end of file diff --git a/src/taming-transformers/data/coco_annotations_100/annotations/instances_val2017.json b/src/taming-transformers/data/coco_annotations_100/annotations/instances_val2017.json new file mode 100644 index 0000000000000000000000000000000000000000..edfed4d9628c23f03468f85c84b0af3272dee176 --- /dev/null +++ b/src/taming-transformers/data/coco_annotations_100/annotations/instances_val2017.json @@ -0,0 +1 @@ +{"info": {"description": "COCO 2017 Dataset", "url": "http://cocodataset.org", "version": "1.0", "year": 2017, "contributor": "COCO Consortium", "date_created": "2017/09/01"}, "licenses": [{"url": "http://creativecommons.org/licenses/by-nc-sa/2.0/", "id": 1, "name": "Attribution-NonCommercial-ShareAlike License"}, {"url": "http://creativecommons.org/licenses/by-nc/2.0/", "id": 2, "name": "Attribution-NonCommercial License"}, {"url": "http://creativecommons.org/licenses/by-nc-nd/2.0/", "id": 3, "name": "Attribution-NonCommercial-NoDerivs License"}, {"url": "http://creativecommons.org/licenses/by/2.0/", "id": 4, "name": "Attribution License"}, {"url": "http://creativecommons.org/licenses/by-sa/2.0/", "id": 5, "name": "Attribution-ShareAlike License"}, {"url": "http://creativecommons.org/licenses/by-nd/2.0/", "id": 6, "name": "Attribution-NoDerivs License"}, {"url": "http://flickr.com/commons/usage/", "id": 7, "name": "No known copyright restrictions"}, {"url": "http://www.usa.gov/copyright.shtml", "id": 8, "name": "United States Government Work"}], "images": [{"license": 1, "file_name": "000000017627.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017627.jpg", "height": 480, "width": 640, "date_captured": "2013-11-16 15:13:53", "flickr_url": "http://farm5.staticflickr.com/4145/4977243989_c2efb1b911_z.jpg", "id": 17627}, {"license": 3, "file_name": "000000016228.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016228.jpg", "height": 440, "width": 640, "date_captured": "2013-11-19 00:09:53", "flickr_url": "http://farm4.staticflickr.com/3737/10031812195_372ae7538f_z.jpg", "id": 16228}, {"license": 2, "file_name": "000000011813.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011813.jpg", "height": 500, "width": 333, "date_captured": "2013-11-24 04:49:37", "flickr_url": "http://farm4.staticflickr.com/3545/3411897599_c3ae826bbb_z.jpg", "id": 11813}, {"license": 3, "file_name": "000000015079.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015079.jpg", "height": 424, "width": 640, "date_captured": "2013-11-20 14:57:40", "flickr_url": "http://farm8.staticflickr.com/7064/6970424809_69d949181f_z.jpg", "id": 15079}, {"license": 3, "file_name": "000000011197.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011197.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 03:59:36", "flickr_url": "http://farm8.staticflickr.com/7002/6732385791_cd9fcb9572_z.jpg", "id": 11197}, {"license": 3, "file_name": "000000016010.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016010.jpg", "height": 471, "width": 640, "date_captured": "2013-11-18 21:20:54", "flickr_url": "http://farm2.staticflickr.com/1134/950664990_8070cd6e3a_z.jpg", "id": 16010}, {"license": 3, "file_name": "000000018150.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018150.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 03:12:35", "flickr_url": "http://farm8.staticflickr.com/7155/6476497205_c725257677_z.jpg", "id": 18150}, {"license": 3, "file_name": "000000011760.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011760.jpg", "height": 425, "width": 640, "date_captured": "2013-11-18 18:15:02", "flickr_url": "http://farm3.staticflickr.com/2477/5856512283_9abe8e859f_z.jpg", "id": 11760}, {"license": 3, "file_name": "000000015278.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015278.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 23:14:33", "flickr_url": "http://farm4.staticflickr.com/3633/3291104715_bdec9818d3_z.jpg", "id": 15278}, {"license": 6, "file_name": "000000011051.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011051.jpg", "height": 536, "width": 640, "date_captured": "2013-11-18 05:42:28", "flickr_url": "http://farm4.staticflickr.com/3155/3281278459_15063a4662_z.jpg", "id": 11051}, {"license": 3, "file_name": "000000016958.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016958.jpg", "height": 428, "width": 640, "date_captured": "2013-11-21 20:49:33", "flickr_url": "http://farm8.staticflickr.com/7108/7435713066_78b44aae33_z.jpg", "id": 16958}, {"license": 2, "file_name": "000000010977.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010977.jpg", "height": 375, "width": 500, "date_captured": "2013-11-15 02:16:38", "flickr_url": "http://farm9.staticflickr.com/8060/8241415983_02d80c2fca_z.jpg", "id": 10977}, {"license": 1, "file_name": "000000017436.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017436.jpg", "height": 640, "width": 481, "date_captured": "2013-11-15 14:11:51", "flickr_url": "http://farm4.staticflickr.com/3265/2922590857_cc7c32cfaa_z.jpg", "id": 17436}, {"license": 4, "file_name": "000000013659.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013659.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 06:35:46", "flickr_url": "http://farm7.staticflickr.com/6144/5987177856_785814a990_z.jpg", "id": 13659}, {"license": 1, "file_name": "000000020059.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000020059.jpg", "height": 427, "width": 640, "date_captured": "2013-11-18 21:44:47", "flickr_url": "http://farm1.staticflickr.com/177/393601030_4451879068_z.jpg", "id": 20059}, {"license": 3, "file_name": "000000012576.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012576.jpg", "height": 640, "width": 480, "date_captured": "2013-11-21 01:24:50", "flickr_url": "http://farm3.staticflickr.com/2813/9012011605_cbb7999e2b_z.jpg", "id": 12576}, {"license": 4, "file_name": "000000014439.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014439.jpg", "height": 404, "width": 640, "date_captured": "2013-11-22 17:25:30", "flickr_url": "http://farm4.staticflickr.com/3544/3506151605_2a3530b2f9_z.jpg", "id": 14439}, {"license": 3, "file_name": "000000018575.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018575.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 01:42:34", "flickr_url": "http://farm4.staticflickr.com/3252/2464830020_ecf3bcf1c3_z.jpg", "id": 18575}, {"license": 2, "file_name": "000000013546.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013546.jpg", "height": 425, "width": 640, "date_captured": "2013-11-20 06:39:19", "flickr_url": "http://farm3.staticflickr.com/2689/4091707765_2f3bf944a7_z.jpg", "id": 13546}, {"license": 3, "file_name": "000000013923.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013923.jpg", "height": 427, "width": 640, "date_captured": "2013-11-21 21:17:47", "flickr_url": "http://farm9.staticflickr.com/8550/8973469217_ddac383dc5_z.jpg", "id": 13923}, {"license": 1, "file_name": "000000017379.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017379.jpg", "height": 640, "width": 478, "date_captured": "2013-11-15 01:16:56", "flickr_url": "http://farm6.staticflickr.com/5123/5316824279_9f0a0584c7_z.jpg", "id": 17379}, {"license": 1, "file_name": "000000010363.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010363.jpg", "height": 361, "width": 640, "date_captured": "2013-11-15 07:08:52", "flickr_url": "http://farm4.staticflickr.com/3027/2477308902_443e5baf08_z.jpg", "id": 10363}, {"license": 2, "file_name": "000000017178.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017178.jpg", "height": 427, "width": 640, "date_captured": "2013-11-15 08:30:55", "flickr_url": "http://farm4.staticflickr.com/3354/3626704406_be9d80e909_z.jpg", "id": 17178}, {"license": 1, "file_name": "000000015338.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015338.jpg", "height": 424, "width": 640, "date_captured": "2013-11-16 17:43:06", "flickr_url": "http://farm9.staticflickr.com/8526/8519097250_f635a04651_z.jpg", "id": 15338}, {"license": 3, "file_name": "000000011122.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011122.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 09:24:02", "flickr_url": "http://farm4.staticflickr.com/3278/3105013044_2f108fed95_z.jpg", "id": 11122}, {"license": 5, "file_name": "000000010707.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010707.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 23:35:53", "flickr_url": "http://farm1.staticflickr.com/147/434840964_a9c5bc3b58_z.jpg", "id": 10707}, {"license": 4, "file_name": "000000012120.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012120.jpg", "height": 428, "width": 640, "date_captured": "2013-11-23 03:42:48", "flickr_url": "http://farm4.staticflickr.com/3492/3179857331_fdd8bbd30f_z.jpg", "id": 12120}, {"license": 1, "file_name": "000000018193.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018193.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 13:24:37", "flickr_url": "http://farm1.staticflickr.com/242/516677812_f03351fffd_z.jpg", "id": 18193}, {"license": 3, "file_name": "000000019109.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019109.jpg", "height": 428, "width": 640, "date_captured": "2013-11-17 02:08:36", "flickr_url": "http://farm8.staticflickr.com/7223/7017616831_24cd0b6131_z.jpg", "id": 19109}, {"license": 4, "file_name": "000000013291.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013291.jpg", "height": 335, "width": 500, "date_captured": "2013-11-18 16:17:44", "flickr_url": "http://farm4.staticflickr.com/3394/3491087208_8efdfeb6d4_z.jpg", "id": 13291}, {"license": 1, "file_name": "000000017714.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017714.jpg", "height": 480, "width": 640, "date_captured": "2013-11-24 14:14:00", "flickr_url": "http://farm7.staticflickr.com/6133/5943387737_ffd52a7f27_z.jpg", "id": 17714}, {"license": 4, "file_name": "000000012062.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012062.jpg", "height": 427, "width": 640, "date_captured": "2013-11-16 20:16:30", "flickr_url": "http://farm4.staticflickr.com/3775/9086068242_2064357878_z.jpg", "id": 12062}, {"license": 4, "file_name": "000000015517.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015517.jpg", "height": 480, "width": 640, "date_captured": "2013-11-16 23:41:40", "flickr_url": "http://farm9.staticflickr.com/8184/8407007011_9456edeb6d_z.jpg", "id": 15517}, {"license": 1, "file_name": "000000010764.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010764.jpg", "height": 424, "width": 640, "date_captured": "2013-11-19 19:23:45", "flickr_url": "http://farm3.staticflickr.com/2714/5810596234_b5090d75f6_z.jpg", "id": 10764}, {"license": 4, "file_name": "000000015272.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015272.jpg", "height": 640, "width": 424, "date_captured": "2013-11-16 12:18:43", "flickr_url": "http://farm9.staticflickr.com/8386/8584364941_15ab4eb0e4_z.jpg", "id": 15272}, {"license": 3, "file_name": "000000010583.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010583.jpg", "height": 612, "width": 612, "date_captured": "2013-11-20 14:18:50", "flickr_url": "http://farm9.staticflickr.com/8497/8288720209_c13ea818f8_z.jpg", "id": 10583}, {"license": 4, "file_name": "000000017029.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017029.jpg", "height": 640, "width": 640, "date_captured": "2013-11-18 14:33:10", "flickr_url": "http://farm8.staticflickr.com/7304/8746020648_f1e2075b86_z.jpg", "id": 17029}, {"license": 2, "file_name": "000000012748.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012748.jpg", "height": 640, "width": 480, "date_captured": "2013-11-19 01:51:12", "flickr_url": "http://farm8.staticflickr.com/7295/9090127695_6dc690f776_z.jpg", "id": 12748}, {"license": 1, "file_name": "000000015597.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015597.jpg", "height": 640, "width": 433, "date_captured": "2013-11-20 01:36:59", "flickr_url": "http://farm7.staticflickr.com/6128/5960989557_660cd5f173_z.jpg", "id": 15597}, {"license": 4, "file_name": "000000013348.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013348.jpg", "height": 427, "width": 640, "date_captured": "2013-11-16 14:52:33", "flickr_url": "http://farm9.staticflickr.com/8286/7733450942_0da3e941b4_z.jpg", "id": 13348}, {"license": 3, "file_name": "000000011699.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011699.jpg", "height": 640, "width": 480, "date_captured": "2013-11-18 10:35:30", "flickr_url": "http://farm7.staticflickr.com/6010/5946492599_6248b4620e_z.jpg", "id": 11699}, {"license": 1, "file_name": "000000010995.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010995.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 21:22:47", "flickr_url": "http://farm4.staticflickr.com/3438/3815505319_1c077a82b6_z.jpg", "id": 10995}, {"license": 1, "file_name": "000000015497.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015497.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 00:19:02", "flickr_url": "http://farm3.staticflickr.com/2197/2269556612_b210991e62_z.jpg", "id": 15497}, {"license": 2, "file_name": "000000017115.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017115.jpg", "height": 640, "width": 443, "date_captured": "2013-11-18 18:09:41", "flickr_url": "http://farm6.staticflickr.com/5189/5672755536_fd276c33d6_z.jpg", "id": 17115}, {"license": 6, "file_name": "000000019742.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019742.jpg", "height": 374, "width": 500, "date_captured": "2013-11-24 03:31:54", "flickr_url": "http://farm1.staticflickr.com/70/194348221_493851f79b_z.jpg", "id": 19742}, {"license": 4, "file_name": "000000011149.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011149.jpg", "height": 375, "width": 500, "date_captured": "2013-11-15 04:15:40", "flickr_url": "http://farm4.staticflickr.com/3625/3323418866_ea5017538d_z.jpg", "id": 11149}, {"license": 2, "file_name": "000000017207.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017207.jpg", "height": 480, "width": 640, "date_captured": "2013-11-15 10:53:00", "flickr_url": "http://farm6.staticflickr.com/5131/5537426848_a4508fe44f_z.jpg", "id": 17207}, {"license": 6, "file_name": "000000018737.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018737.jpg", "height": 427, "width": 640, "date_captured": "2013-11-15 18:31:53", "flickr_url": "http://farm5.staticflickr.com/4026/4511471485_c1791c0767_z.jpg", "id": 18737}, {"license": 1, "file_name": "000000015751.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015751.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 05:52:45", "flickr_url": "http://farm8.staticflickr.com/7351/9419515091_a211b75ce5_z.jpg", "id": 15751}, {"license": 1, "file_name": "000000014888.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014888.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 18:50:25", "flickr_url": "http://farm9.staticflickr.com/8380/8634330041_a47c2cdaeb_z.jpg", "id": 14888}, {"license": 3, "file_name": "000000020333.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000020333.jpg", "height": 640, "width": 427, "date_captured": "2013-11-18 04:03:40", "flickr_url": "http://farm5.staticflickr.com/4027/4697218785_7f0414cdf8_z.jpg", "id": 20333}, {"license": 4, "file_name": "000000012280.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012280.jpg", "height": 640, "width": 480, "date_captured": "2013-11-18 07:29:51", "flickr_url": "http://farm9.staticflickr.com/8516/8544258219_95e49e415e_z.jpg", "id": 12280}, {"license": 5, "file_name": "000000010092.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010092.jpg", "height": 426, "width": 640, "date_captured": "2013-11-21 00:20:22", "flickr_url": "http://farm9.staticflickr.com/8276/8710590452_08a7a8f59c_z.jpg", "id": 10092}, {"license": 1, "file_name": "000000019221.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019221.jpg", "height": 478, "width": 640, "date_captured": "2013-11-19 22:51:01", "flickr_url": "http://farm7.staticflickr.com/6156/6237638989_9d2c007615_z.jpg", "id": 19221}, {"license": 1, "file_name": "000000018770.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018770.jpg", "height": 428, "width": 640, "date_captured": "2013-11-18 02:44:01", "flickr_url": "http://farm9.staticflickr.com/8020/7499130232_34bd20c007_z.jpg", "id": 18770}, {"license": 3, "file_name": "000000012639.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012639.jpg", "height": 640, "width": 480, "date_captured": "2013-11-22 21:09:08", "flickr_url": "http://farm5.staticflickr.com/4102/4795012771_81c0b6b502_z.jpg", "id": 12639}, {"license": 3, "file_name": "000000012670.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012670.jpg", "height": 428, "width": 640, "date_captured": "2013-11-24 01:39:03", "flickr_url": "http://farm5.staticflickr.com/4144/5072551441_fd302a2c44_z.jpg", "id": 12670}, {"license": 3, "file_name": "000000014038.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014038.jpg", "height": 427, "width": 640, "date_captured": "2013-11-24 11:18:00", "flickr_url": "http://farm9.staticflickr.com/8507/8561635383_4bc0c679dd_z.jpg", "id": 14038}, {"license": 4, "file_name": "000000020247.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000020247.jpg", "height": 457, "width": 640, "date_captured": "2013-11-18 14:33:42", "flickr_url": "http://farm8.staticflickr.com/7027/6473127891_50c1ca2c03_z.jpg", "id": 20247}, {"license": 3, "file_name": "000000015956.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015956.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 23:12:04", "flickr_url": "http://farm5.staticflickr.com/4057/5078510649_c131c12862_z.jpg", "id": 15956}, {"license": 3, "file_name": "000000011615.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011615.jpg", "height": 640, "width": 480, "date_captured": "2013-11-17 07:15:52", "flickr_url": "http://farm1.staticflickr.com/47/151953288_f6b6a50f78_z.jpg", "id": 11615}, {"license": 3, "file_name": "000000014380.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014380.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 09:54:28", "flickr_url": "http://farm6.staticflickr.com/5463/8750190611_325720f243_z.jpg", "id": 14380}, {"license": 1, "file_name": "000000018519.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018519.jpg", "height": 640, "width": 515, "date_captured": "2013-11-20 01:22:59", "flickr_url": "http://farm8.staticflickr.com/7199/6892325386_145a03efa0_z.jpg", "id": 18519}, {"license": 4, "file_name": "000000019924.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019924.jpg", "height": 500, "width": 458, "date_captured": "2013-11-18 01:01:49", "flickr_url": "http://farm4.staticflickr.com/3407/3642510664_1c89fbc90a_z.jpg", "id": 19924}, {"license": 3, "file_name": "000000016598.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016598.jpg", "height": 640, "width": 478, "date_captured": "2013-11-18 03:39:49", "flickr_url": "http://farm6.staticflickr.com/5091/5391571396_41823477da_z.jpg", "id": 16598}, {"license": 5, "file_name": "000000013774.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013774.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 18:22:53", "flickr_url": "http://farm8.staticflickr.com/7167/6837122127_de8b1f8d77_z.jpg", "id": 13774}, {"license": 5, "file_name": "000000018491.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018491.jpg", "height": 427, "width": 640, "date_captured": "2013-11-19 17:54:54", "flickr_url": "http://farm3.staticflickr.com/2134/5814907667_496ae24446_z.jpg", "id": 18491}, {"license": 4, "file_name": "000000012667.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012667.jpg", "height": 480, "width": 640, "date_captured": "2013-11-15 15:06:56", "flickr_url": "http://farm1.staticflickr.com/197/499050773_995cd1e9bb_z.jpg", "id": 12667}, {"license": 3, "file_name": "000000013201.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013201.jpg", "height": 640, "width": 427, "date_captured": "2013-11-19 21:57:52", "flickr_url": "http://farm9.staticflickr.com/8391/8577059857_69c575151f_z.jpg", "id": 13201}, {"license": 1, "file_name": "000000017959.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017959.jpg", "height": 427, "width": 640, "date_captured": "2013-11-22 18:46:36", "flickr_url": "http://farm4.staticflickr.com/3031/2389030002_e3a04076c3_z.jpg", "id": 17959}, {"license": 1, "file_name": "000000017899.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017899.jpg", "height": 640, "width": 480, "date_captured": "2013-11-14 15:45:58", "flickr_url": "http://farm8.staticflickr.com/7031/6746562893_cbf91d331c_z.jpg", "id": 17899}, {"license": 4, "file_name": "000000015746.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015746.jpg", "height": 640, "width": 427, "date_captured": "2013-11-16 21:36:18", "flickr_url": "http://farm4.staticflickr.com/3643/3517907686_509f46055f_z.jpg", "id": 15746}, {"license": 4, "file_name": "000000014473.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014473.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 11:06:09", "flickr_url": "http://farm9.staticflickr.com/8401/8607706408_e00725a54d_z.jpg", "id": 14473}, {"license": 1, "file_name": "000000014831.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014831.jpg", "height": 640, "width": 480, "date_captured": "2013-11-17 19:58:56", "flickr_url": "http://farm9.staticflickr.com/8113/8656986875_366dec25c9_z.jpg", "id": 14831}, {"license": 1, "file_name": "000000016502.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016502.jpg", "height": 500, "width": 375, "date_captured": "2013-11-16 18:53:28", "flickr_url": "http://farm1.staticflickr.com/153/388880244_55dd5edd8e_z.jpg", "id": 16502}, {"license": 3, "file_name": "000000015254.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015254.jpg", "height": 427, "width": 640, "date_captured": "2013-11-20 01:29:32", "flickr_url": "http://farm1.staticflickr.com/140/385285808_120242fcc0_z.jpg", "id": 15254}, {"license": 1, "file_name": "000000015660.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015660.jpg", "height": 348, "width": 640, "date_captured": "2013-11-22 08:41:16", "flickr_url": "http://farm4.staticflickr.com/3356/3414127711_6772851b0d_z.jpg", "id": 15660}, {"license": 5, "file_name": "000000011511.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011511.jpg", "height": 464, "width": 640, "date_captured": "2013-11-16 13:42:03", "flickr_url": "http://farm8.staticflickr.com/7124/7556029168_519acfdf09_z.jpg", "id": 11511}, {"license": 3, "file_name": "000000017905.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017905.jpg", "height": 640, "width": 480, "date_captured": "2013-11-16 18:01:33", "flickr_url": "http://farm1.staticflickr.com/44/173771776_53b9c22bb6_z.jpg", "id": 17905}, {"license": 1, "file_name": "000000013597.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013597.jpg", "height": 425, "width": 640, "date_captured": "2013-11-19 20:18:39", "flickr_url": "http://farm5.staticflickr.com/4040/4474734743_bc5e8973c7_z.jpg", "id": 13597}, {"license": 3, "file_name": "000000020107.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000020107.jpg", "height": 500, "width": 333, "date_captured": "2013-11-16 23:28:30", "flickr_url": "http://farm2.staticflickr.com/1311/968078473_4a7d696ec6_z.jpg", "id": 20107}, {"license": 1, "file_name": "000000018833.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018833.jpg", "height": 426, "width": 640, "date_captured": "2013-11-17 16:35:54", "flickr_url": "http://farm1.staticflickr.com/92/217798870_1d648607b4_z.jpg", "id": 18833}, {"license": 1, "file_name": "000000016439.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016439.jpg", "height": 480, "width": 640, "date_captured": "2013-11-22 19:14:13", "flickr_url": "http://farm1.staticflickr.com/52/171945415_f37fb5d1b2_z.jpg", "id": 16439}, {"license": 3, "file_name": "000000016451.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016451.jpg", "height": 612, "width": 612, "date_captured": "2013-11-20 20:12:37", "flickr_url": "http://farm8.staticflickr.com/7460/9050893513_1fb9508000_z.jpg", "id": 16451}, {"license": 5, "file_name": "000000019432.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019432.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 04:39:45", "flickr_url": "http://farm6.staticflickr.com/5131/5533564723_6f1633b85e_z.jpg", "id": 19432}, {"license": 3, "file_name": "000000019786.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019786.jpg", "height": 375, "width": 500, "date_captured": "2013-11-22 00:20:10", "flickr_url": "http://farm1.staticflickr.com/115/317277248_05f5ac031e_z.jpg", "id": 19786}, {"license": 1, "file_name": "000000017031.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017031.jpg", "height": 334, "width": 500, "date_captured": "2013-11-16 22:09:32", "flickr_url": "http://farm4.staticflickr.com/3431/3811840964_b913f6f140_z.jpg", "id": 17031}, {"license": 5, "file_name": "000000018837.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018837.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 18:58:56", "flickr_url": "http://farm9.staticflickr.com/8219/8372455764_124e052754_z.jpg", "id": 18837}, {"license": 3, "file_name": "000000014007.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014007.jpg", "height": 426, "width": 640, "date_captured": "2013-11-24 11:03:51", "flickr_url": "http://farm8.staticflickr.com/7161/6701691801_dc2cee1aa9_z.jpg", "id": 14007}, {"license": 1, "file_name": "000000018380.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018380.jpg", "height": 426, "width": 640, "date_captured": "2013-11-25 14:13:45", "flickr_url": "http://farm6.staticflickr.com/5474/9701242334_0797348359_z.jpg", "id": 18380}, {"license": 3, "file_name": "000000016249.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016249.jpg", "height": 365, "width": 500, "date_captured": "2013-11-14 12:26:50", "flickr_url": "http://farm4.staticflickr.com/3168/2931904036_1c5828e037_z.jpg", "id": 16249}, {"license": 4, "file_name": "000000013004.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013004.jpg", "height": 500, "width": 375, "date_captured": "2013-11-19 21:30:33", "flickr_url": "http://farm5.staticflickr.com/4049/4208826429_3432119060_z.jpg", "id": 13004}, {"license": 4, "file_name": "000000019402.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019402.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 04:31:37", "flickr_url": "http://farm5.staticflickr.com/4135/5435897535_a9b3e0a053_z.jpg", "id": 19402}, {"license": 3, "file_name": "000000013177.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013177.jpg", "height": 427, "width": 640, "date_captured": "2013-11-15 20:03:10", "flickr_url": "http://farm8.staticflickr.com/7127/7607618094_78c23b097e_z.jpg", "id": 13177}, {"license": 3, "file_name": "000000014226.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014226.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 04:22:03", "flickr_url": "http://farm1.staticflickr.com/6/6710769_d74169f5b7_z.jpg", "id": 14226}, {"license": 2, "file_name": "000000015440.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015440.jpg", "height": 640, "width": 404, "date_captured": "2013-11-17 09:50:00", "flickr_url": "http://farm4.staticflickr.com/3261/2870016347_39ffc0ca45_z.jpg", "id": 15440}, {"license": 4, "file_name": "000000017182.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017182.jpg", "height": 428, "width": 640, "date_captured": "2013-11-19 22:30:23", "flickr_url": "http://farm4.staticflickr.com/3020/2906486794_80400b009e_z.jpg", "id": 17182}, {"license": 6, "file_name": "000000019042.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019042.jpg", "height": 371, "width": 640, "date_captured": "2013-11-17 01:03:41", "flickr_url": "http://farm8.staticflickr.com/7289/9652593344_4469e9a6f1_z.jpg", "id": 19042}, {"license": 2, "file_name": "000000013729.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013729.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 20:10:40", "flickr_url": "http://farm2.staticflickr.com/1009/559099100_98414a0e66_z.jpg", "id": 13729}, {"license": 2, "file_name": "000000015335.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015335.jpg", "height": 480, "width": 640, "date_captured": "2013-11-25 14:00:10", "flickr_url": "http://farm6.staticflickr.com/5533/10257288534_c916fafd78_z.jpg", "id": 15335}], "annotations": [{"segmentation": [[284.76, 320.72, 267.51, 322.16, 247.37, 322.16, 211.42, 322.16, 149.57, 320.72, 145.26, 287.64, 152.45, 214.29, 310.65, 220.04, 307.78, 271.82, 309.21, 304.9, 284.76, 322.16]], "area": 16606.205650000004, "iscrowd": 0, "image_id": 17379, "bbox": [145.26, 214.29, 165.39, 107.87], "category_id": 72, "id": 30246}, {"segmentation": [[213.53, 622.48, 211.99, 617.19, 209.57, 613.44, 210.45, 607.5, 211.33, 603.09, 209.35, 601.33, 209.79, 597.14, 205.82, 593.84, 204.72, 591.85, 204.94, 587.23, 206.04, 584.8, 206.92, 584.58, 208.47, 588.11, 208.69, 589.87, 210.01, 590.75, 213.09, 592.73, 214.41, 591.63, 219.26, 593.39, 217.72, 595.38, 217.72, 596.92, 218.16, 598.9, 217.94, 602.43, 216.4, 603.97, 215.74, 606.61, 214.19, 610.14, 213.53, 612.78, 213.53, 614.99, 213.75, 617.63, 214.64, 620.5, 214.64, 622.48, 214.19, 624.02]], "area": 198.93215000000026, "iscrowd": 0, "image_id": 17899, "bbox": [204.72, 584.58, 14.54, 39.44], "category_id": 16, "id": 36197}, {"segmentation": [[422.38, 178.56, 403.0, 207.63, 390.88, 225.4, 373.11, 224.59, 379.57, 209.25, 368.27, 211.67, 367.46, 197.94, 388.46, 188.25, 350.5, 189.87, 340.81, 239.94, 323.85, 239.94, 327.08, 206.83, 314.97, 243.98, 296.39, 241.55, 294.78, 234.28, 307.7, 222.17, 297.2, 191.48, 282.66, 174.52, 258.43, 172.91, 245.51, 164.83, 247.94, 133.33, 250.36, 108.3, 258.43, 110.72, 267.32, 126.87, 276.2, 127.68, 285.09, 113.95, 294.78, 121.22, 344.04, 116.37, 385.23, 108.3, 419.96, 114.76, 440.15, 142.22, 442.57, 164.02, 456.3, 172.1, 464.37, 162.41, 471.64, 173.71, 453.07, 191.48]], "area": 16892.101950000004, "iscrowd": 0, "image_id": 10363, "bbox": [245.51, 108.3, 226.13, 135.68], "category_id": 17, "id": 47902}, {"segmentation": [[407.74, 174.13, 396.15, 178.93, 391.48, 180.67, 388.16, 177.73, 381.76, 180.52, 377.77, 180.52, 378.17, 189.72, 374.97, 194.11, 375.77, 200.11, 374.97, 206.9, 376.57, 216.9, 378.97, 224.09, 379.76, 233.69, 380.96, 240.08, 380.96, 246.88, 380.56, 252.87, 377.37, 255.27, 378.97, 258.87, 384.16, 260.07, 386.56, 259.27, 384.16, 254.87, 385.36, 247.67, 384.16, 234.08, 383.36, 220.89, 387.76, 218.5, 392.16, 220.89, 392.16, 235.28, 394.95, 240.88, 394.95, 247.67, 395.35, 251.67, 394.55, 254.87, 393.35, 258.47, 400.55, 259.27, 399.75, 252.87, 398.95, 248.87, 397.35, 240.88, 397.75, 236.88, 398.55, 234.48, 398.55, 232.89, 396.95, 231.69, 396.95, 226.09, 397.75, 222.49, 404.15, 220.49, 407.23, 231.41, 410.14, 238.88, 410.54, 244.48, 407.74, 254.07, 404.15, 260.47, 410.54, 263.66, 413.74, 263.66, 412.94, 258.07, 414.14, 256.87, 414.54, 251.67, 416.14, 230.49, 414.26, 218.73, 414.56, 220.27, 420.4, 231.38, 420.53, 245.28, 420.53, 252.87, 421.33, 262.06, 420.53, 267.26, 427.33, 263.26, 426.13, 255.67, 424.53, 249.67, 426.13, 247.28, 432.53, 247.28, 433.33, 246.08, 432.93, 240.08, 428.93, 221.69, 428.13, 207.7, 430.37, 188.95, 423.73, 179.33, 407.89, 173.6]], "area": 3310.1459500000014, "iscrowd": 0, "image_id": 17178, "bbox": [374.97, 173.6, 58.36, 93.66], "category_id": 19, "id": 54220}, {"segmentation": [[331.7, 188.39, 339.95, 180.15, 351.86, 181.06, 360.11, 160.9, 364.69, 166.4, 369.27, 168.23, 375.69, 162.74, 375.69, 177.4, 377.52, 195.72, 375.69, 210.38, 368.36, 208.55, 364.69, 222.3, 364.69, 246.12, 370.19, 260.78, 363.77, 260.78, 363.77, 250.7, 360.11, 226.88, 357.36, 218.63, 349.11, 220.46, 350.03, 238.79, 350.03, 254.37, 350.03, 256.2, 345.45, 239.71, 339.95, 242.46, 339.95, 254.37, 338.12, 255.28, 335.37, 241.54, 334.45, 221.38, 328.04, 206.72, 328.95, 192.06]], "area": 2554.3836499999984, "iscrowd": 0, "image_id": 17178, "bbox": [328.04, 160.9, 49.48, 99.88], "category_id": 19, "id": 57131}, {"segmentation": [[273.94, 201.32, 269.43, 201.49, 263.89, 202.01, 262.16, 202.01, 260.77, 202.19, 259.21, 202.71, 257.31, 206.17, 256.79, 210.33, 256.62, 211.89, 256.27, 215.35, 256.96, 216.39, 259.21, 217.08, 260.25, 217.26, 260.77, 214.66, 261.12, 213.97, 263.54, 211.71, 264.76, 210.67, 265.28, 209.29, 265.8, 208.42, 268.92, 208.94, 270.82, 209.98, 273.42, 212.41, 277.06, 214.83, 278.1, 216.04, 279.66, 219.68, 281.39, 222.28, 282.25, 224.36, 282.25, 227.82, 283.47, 233.37, 283.64, 233.37, 284.85, 229.56, 284.85, 224.53, 284.85, 219.51, 285.03, 217.43, 288.32, 217.26, 289.88, 217.08, 292.13, 217.43, 294.03, 220.72, 293.86, 224.36, 293.69, 227.13, 293.69, 230.94, 294.9, 233.54, 295.25, 234.41, 297.15, 233.89, 297.5, 230.42, 297.33, 227.65, 296.81, 224.36, 297.15, 221.41, 297.33, 220.55, 298.89, 218.82, 300.27, 218.64, 302.18, 220.9, 302.52, 224.19, 302.35, 227.82, 301.31, 230.6, 300.96, 232.68, 300.96, 234.06, 303.22, 233.37, 304.95, 230.6, 305.64, 229.21, 306.16, 227.82, 306.85, 224.36, 307.2, 221.93, 306.85, 218.82, 307.89, 216.22, 309.11, 217.78, 308.41, 224.88, 307.55, 228.69, 311.18, 227.65, 313.26, 224.36, 313.61, 222.63, 313.96, 216.04, 312.74, 211.54, 312.05, 209.81, 310.49, 206.34, 309.28, 204.61, 309.11, 204.26, 305.29, 203.92, 302.0, 204.09, 295.25, 204.96, 294.03, 204.78, 291.78, 204.26, 287.8, 203.4, 286.76, 202.88, 283.12, 201.84, 279.83, 201.32, 276.36, 201.67, 273.94, 201.49]], "area": 921.3810500000001, "iscrowd": 0, "image_id": 17178, "bbox": [256.27, 201.32, 57.69, 33.09], "category_id": 19, "id": 58138}, {"segmentation": [[458.11, 190.94, 459.91, 179.86, 465.9, 177.17, 472.18, 175.37, 472.48, 179.26, 484.46, 178.96, 511.7, 183.15, 503.62, 194.83, 499.08, 198.86, 495.17, 204.63, 480.14, 198.86, 477.26, 196.18, 474.58, 196.8, 472.93, 198.45, 476.84, 201.54, 476.64, 211.42, 473.14, 208.95, 471.49, 198.24, 465.93, 192.48, 458.72, 192.27]], "area": 943.4261, "iscrowd": 0, "image_id": 17178, "bbox": [458.11, 175.37, 53.59, 36.05], "category_id": 19, "id": 58916}, {"segmentation": [[150.7, 28.8, 154.92, 28.8, 154.92, 31.96, 157.38, 33.72, 159.84, 44.62, 159.84, 65.71, 148.24, 66.41, 147.18, 46.37, 147.89, 36.18, 149.29, 32.66, 151.05, 31.26]], "area": 404.1564499999999, "iscrowd": 0, "image_id": 10363, "bbox": [147.18, 28.8, 12.66, 37.61], "category_id": 44, "id": 80785}, {"segmentation": [[4.12, 374.39, 59.06, 353.79, 103.0, 393.61, 23.35, 440.31, 8.24, 418.33], [86.52, 338.68, 113.99, 318.08, 119.48, 320.82, 131.85, 375.76]], "area": 6017.466, "iscrowd": 0, "image_id": 17899, "bbox": [4.12, 318.08, 127.73, 122.23], "category_id": 62, "id": 106130}, {"segmentation": [[125.46, 310.93, 140.08, 363.5, 144.43, 359.54, 161.43, 354.41, 170.91, 352.83, 167.75, 327.53, 169.73, 321.21, 145.62, 291.96, 125.06, 307.37], [179.21, 261.92, 182.77, 256.38, 193.84, 299.47, 178.03, 264.29]], "area": 2208.5101000000013, "iscrowd": 0, "image_id": 17899, "bbox": [125.06, 256.38, 68.78, 107.12], "category_id": 62, "id": 108544}, {"segmentation": [[83.22, 632.06, 1.51, 627.52, 1.51, 509.5, 0.0, 453.52, 102.88, 389.98, 140.71, 370.31, 164.92, 344.59, 178.53, 344.59, 190.64, 379.39, 204.26, 373.33, 208.79, 365.77, 223.92, 373.33, 240.57, 365.77, 211.82, 324.92, 217.87, 303.74, 264.78, 279.53, 338.91, 294.66, 369.17, 294.66, 437.26, 305.25, 447.85, 317.35, 447.85, 337.02, 480.0, 352.15, 478.11, 632.06, 266.29, 629.03, 51.44, 627.52]], "area": 136955.75629999995, "iscrowd": 0, "image_id": 17899, "bbox": [0.0, 279.53, 480.0, 352.53], "category_id": 67, "id": 119334}, {"segmentation": [[222.16, 121.37, 204.15, 131.43, 198.32, 148.39, 198.32, 171.17, 205.21, 201.89, 210.51, 210.37, 211.03, 222.56, 214.74, 222.56, 220.57, 211.96, 246.53, 222.03, 267.19, 205.6, 276.73, 216.2, 294.21, 211.96, 298.45, 193.42, 345.6, 158.98, 345.6, 166.93, 340.3, 174.35, 330.24, 198.72, 324.41, 224.68, 332.35, 227.32, 350.9, 262.29, 372.62, 271.83, 403.35, 272.36, 422.95, 242.16, 416.59, 203.48, 404.93, 176.47, 389.57, 161.63, 395.93, 156.33, 402.82, 113.42, 371.56, 116.6, 342.42, 112.36, 357.78, 106.0, 345.6, 103.36, 320.17, 103.36, 296.86, 98.06, 294.21, 99.65, 293.15, 107.06, 320.17, 107.06, 333.94, 110.24, 338.71, 112.36, 339.77, 136.73, 275.14, 119.25, 268.25, 108.65, 282.56, 107.59, 286.26, 100.18, 283.09, 99.12, 275.14, 98.06, 272.49, 98.06, 268.78, 94.88, 266.13, 92.76, 258.19, 91.17, 252.36, 95.41, 256.6, 102.83, 261.36, 104.94, 263.48, 106.53, 266.66, 108.12, 266.66, 113.42, 264.01, 118.19, 260.83, 118.72, 252.89, 113.95, 249.18, 111.3, 241.76, 109.71, 238.05, 108.65, 228.52, 108.12, 224.81, 108.12, 216.33, 110.24, 216.33, 120.31]], "area": 23082.81575, "iscrowd": 0, "image_id": 11149, "bbox": [198.32, 91.17, 224.63, 181.19], "category_id": 2, "id": 126643}, {"segmentation": [[492.36, 117.42, 637.6, 82.4, 638.63, 267.81, 638.63, 283.26, 623.18, 279.14, 584.03, 290.47, 572.7, 313.13, 543.86, 318.28, 523.26, 271.93, 482.06, 268.84, 489.27, 118.45]], "area": 28786.120799999997, "iscrowd": 0, "image_id": 17207, "bbox": [482.06, 82.4, 156.57, 235.88], "category_id": 3, "id": 135232}, {"segmentation": [[246.1, 135.08, 246.1, 169.24, 254.64, 170.8, 265.51, 173.12, 281.81, 176.23, 281.81, 194.09, 281.81, 194.09, 301.22, 196.42, 304.33, 211.17, 305.1, 219.71, 305.1, 226.69, 295.79, 232.13, 295.79, 232.13, 295.79, 241.44, 308.21, 245.32, 319.08, 243.0, 341.59, 242.22, 350.91, 197.97, 352.46, 190.98, 384.29, 187.1, 375.75, 197.19, 367.99, 199.52, 366.43, 208.84, 366.43, 208.84, 374.97, 211.17, 374.97, 225.14, 379.63, 228.25, 395.94, 223.59, 421.55, 180.11, 437.08, 187.1, 437.08, 187.1, 457.27, 187.1, 467.36, 175.45, 467.36, 175.45, 465.81, 164.58, 453.38, 155.27, 439.41, 155.27, 435.53, 138.19, 426.99, 122.66, 408.36, 112.57, 397.49, 110.24, 475.12, 66.77, 541.11, 32.61, 640.0, 27.17, 639.71, 359.45, 410.69, 361.0, 93.94, 361.0, 90.83, 311.31, 107.14, 251.54, 111.79, 249.21, 137.41, 190.98, 173.12, 164.58, 205.73, 144.4, 244.55, 135.08]], "area": 121140.34724999999, "iscrowd": 0, "image_id": 10363, "bbox": [90.83, 27.17, 549.17, 333.83], "category_id": 3, "id": 138210}, {"segmentation": [[11.73, 207.04, 27.22, 203.95, 45.19, 205.8, 45.5, 210.45, 45.5, 216.65, 44.26, 224.08, 44.26, 232.75, 45.8, 238.64, 46.73, 241.74, 44.88, 242.67, 41.78, 238.64, 35.27, 238.33, 21.64, 241.74, 15.14, 239.88, 14.52, 235.54, 20.09, 233.99, 25.98, 233.37, 24.74, 228.73, 19.17, 221.29, 10.8, 212.31, 9.56, 208.28]], "area": 969.1859499999997, "iscrowd": 0, "image_id": 17207, "bbox": [9.56, 203.95, 37.17, 38.72], "category_id": 3, "id": 139920}, {"segmentation": [[443.35, 337.08, 479.89, 338.04, 523.17, 406.32, 526.06, 427.0, 640.0, 427.0, 640.0, 108.19, 627.04, 112.04, 608.76, 122.62, 595.3, 135.12, 586.64, 144.74, 552.98, 151.47, 528.94, 163.97, 507.78, 184.17, 499.13, 201.48, 492.4, 204.36, 474.12, 201.48, 469.32, 193.78, 450.08, 189.94, 441.43, 204.36, 443.35, 211.1, 468.35, 215.9, 476.05, 214.94, 458.74, 223.6, 445.27, 228.41, 437.58, 249.56, 437.58, 255.33, 433.73, 292.84, 435.66, 332.27]], "area": 47071.29030000001, "iscrowd": 0, "image_id": 17178, "bbox": [433.73, 108.19, 206.27, 318.81], "category_id": 3, "id": 140522}, {"segmentation": [[0.0, 133.87, 0.0, 265.63, 14.36, 280.83, 21.96, 279.14, 26.18, 269.85, 30.41, 261.4, 38.85, 263.09, 50.68, 263.09, 54.05, 271.54, 55.74, 286.74, 61.66, 308.7, 68.41, 323.06, 72.64, 333.19, 83.61, 345.86, 96.28, 350.93, 120.78, 349.24, 130.91, 339.95, 135.14, 324.75, 136.82, 310.39, 136.82, 295.19, 135.98, 280.83, 132.6, 259.71, 126.69, 247.89, 119.93, 235.22, 113.18, 223.4, 108.95, 212.42, 103.89, 208.19, 99.66, 202.28, 95.44, 192.99, 92.91, 182.01, 90.37, 171.88, 89.53, 163.43, 89.53, 154.98, 90.37, 151.6, 108.11, 138.94, 103.04, 130.49, 95.44, 130.49, 90.37, 132.18, 88.68, 133.02, 81.93, 133.02, 77.7, 132.18, 79.39, 126.27, 81.08, 122.04, 85.3, 119.51, 88.68, 111.91, 88.68, 103.46, 92.91, 93.33, 97.13, 89.95, 103.04, 84.88, 111.49, 76.44, 111.49, 69.68, 106.42, 68.83, 90.37, 68.83, 86.15, 68.83, 85.3, 75.59, 86.15, 77.28, 84.46, 102.62, 75.17, 105.15, 71.79, 106.84, 67.57, 110.22, 61.66, 106.84, 53.21, 97.55, 47.3, 97.55, 39.7, 103.46, 36.32, 106.0, 36.32, 110.22, 33.78, 115.29, 29.56, 118.67, 27.03, 121.2, 21.11, 121.2, 16.05, 115.29, 8.45, 109.38, 0.84, 104.31]], "area": 22842.389549999996, "iscrowd": 0, "image_id": 11149, "bbox": [0.0, 68.83, 136.82, 282.1], "category_id": 4, "id": 151281}, {"segmentation": [[56.09, 107.87, 60.4, 117.57, 40.99, 234.07, 58.25, 296.63, 50.7, 302.02, 49.62, 325.75, 46.38, 348.4, 52.85, 364.58, 62.56, 372.13, 101.39, 372.13, 121.89, 372.13, 124.04, 345.17, 460.58, 373.21, 480.0, 271.82, 489.71, 163.96, 487.55, 28.04, 482.16, 3.24, 485.39, 1.08, 88.45, 1.08, 65.8, 87.37, 48.54, 80.9, 56.09, 107.87]], "area": 153500.98140000002, "iscrowd": 0, "image_id": 17207, "bbox": [40.99, 1.08, 448.72, 372.13], "category_id": 6, "id": 162985}, {"segmentation": [[21.11, 120.35, 30.41, 103.46, 34.63, 95.02, 39.7, 99.24, 58.28, 99.24, 67.57, 103.46, 75.17, 103.46, 73.48, 97.55, 51.52, 76.44, 13.51, 51.94, 22.8, 40.12, 22.8, 23.23, 19.43, 13.09, 17.74, 7.18, 10.14, 5.49, 3.38, 3.8, 0.0, 46.03, 1.69, 108.53, 1.69, 108.53, 19.43, 121.2]], "area": 3560.2923000000005, "iscrowd": 0, "image_id": 11149, "bbox": [0.0, 3.8, 75.17, 117.4], "category_id": 1, "id": 197935}, {"segmentation": [[417.13, 288.9, 436.52, 268.68, 439.04, 228.23, 434.83, 143.12, 445.79, 111.1, 445.79, 98.46, 458.43, 79.92, 450.0, 57.16, 453.37, 34.41, 471.07, 1.54, 498.88, 1.54, 500.0, 245.08, 488.76, 260.25, 486.24, 281.32, 485.39, 310.81, 474.44, 315.03, 467.7, 315.87, 460.96, 313.34, 471.91, 233.29, 470.22, 222.33, 469.38, 222.33, 460.11, 259.41, 453.37, 293.12, 423.88, 297.33]], "area": 15959.356599999996, "iscrowd": 0, "image_id": 11149, "bbox": [417.13, 1.54, 82.87, 314.33], "category_id": 1, "id": 199247}, {"segmentation": [[87.73, 384.0, 44.58, 356.67, 1.44, 335.1, 1.44, 135.19, 40.27, 116.49, 40.27, 56.09, 96.36, 14.38, 132.31, 11.51, 172.58, 34.52, 181.21, 58.97, 202.79, 87.73, 171.15, 129.44, 152.45, 159.64, 195.6, 300.58, 222.92, 336.54, 244.49, 365.3, 217.17, 372.49, 201.35, 376.81, 172.58, 362.43, 166.83, 327.91, 146.7, 286.2, 135.19, 267.51, 125.12, 280.45, 113.62, 302.02, 102.11, 317.84, 92.04, 322.16, 84.85, 326.47, 110.74, 346.61, 123.69, 358.11, 123.69, 373.93, 122.25, 386.88, 100.67, 391.19, 96.36, 391.19]], "area": 54516.36135000001, "iscrowd": 0, "image_id": 17899, "bbox": [1.44, 11.51, 243.05, 379.68], "category_id": 1, "id": 209675}, {"segmentation": [[94.17, 98.47, 95.01, 90.91, 98.37, 89.22, 109.3, 89.22, 113.51, 94.27, 114.35, 97.63, 114.35, 106.88, 116.03, 117.81, 118.55, 140.51, 131.17, 112.77, 131.17, 91.75, 125.28, 82.5, 119.39, 76.61, 108.46, 71.57, 108.46, 69.89, 110.99, 63.16, 116.03, 60.64, 125.28, 58.95, 143.78, 72.41, 153.87, 82.5, 146.3, 97.63, 148.82, 124.54, 176.57, 131.26, 193.39, 153.97, 199.27, 212.82, 161.43, 230.48, 134.53, 228.8, 110.99, 206.1, 103.42, 178.35, 97.53, 175.83, 88.28, 171.62, 91.65, 148.08, 105.1, 146.4, 110.99, 133.79, 108.46, 127.06, 111.83, 107.72, 98.37, 97.63]], "area": 10372.88825, "iscrowd": 0, "image_id": 11149, "bbox": [88.28, 58.95, 110.99, 171.53], "category_id": 2, "id": 240899}, {"segmentation": [[469.47, 192.7, 414.74, 224.96, 393.43, 205.37, 391.12, 169.66, 362.32, 158.14, 358.29, 123.0, 358.29, 117.24, 356.56, 106.29, 366.93, 101.11, 381.33, 101.11, 400.34, 95.93, 409.56, 91.89, 413.59, 91.89, 415.89, 103.99, 411.86, 120.12, 415.32, 134.52, 438.94, 139.13, 469.47, 144.31, 478.11, 144.31, 478.11, 160.44, 471.19, 195.01]], "area": 8831.1007, "iscrowd": 0, "image_id": 17899, "bbox": [356.56, 91.89, 121.55, 133.07], "category_id": 63, "id": 389786}, {"segmentation": [[76.55, 146.73, 52.9, 164.62, 42.67, 197.22, 50.34, 225.98, 63.76, 232.37, 119.36, 233.65, 138.54, 248.98, 137.9, 266.24, 137.26, 275.83, 133.42, 284.13, 123.2, 296.28, 119.36, 310.98, 125.12, 342.29, 157.71, 349.96, 160.91, 345.49, 151.96, 330.79, 158.99, 316.73, 190.3, 280.94, 189.03, 268.8, 183.91, 256.65, 171.13, 253.46, 162.18, 259.21, 148.12, 250.9, 129.59, 237.48, 130.23, 232.37, 159.63, 216.39, 173.69, 198.5, 179.44, 184.44, 174.97, 180.6, 163.46, 183.16, 156.43, 189.55, 121.92, 197.22, 112.97, 195.94, 102.11, 171.65, 103.39, 171.01, 109.14, 165.26, 119.36, 143.53, 114.25, 121.8, 94.44, 116.69, 80.38, 126.28, 75.91, 143.53], [65.04, 239.4, 89.33, 236.85, 116.81, 241.32, 124.48, 249.63, 123.84, 259.22, 103.39, 262.41, 93.8, 267.52, 84.21, 267.52, 74.63, 263.05, 66.32, 256.02, 62.49, 242.6]], "area": 13752.52955, "iscrowd": 0, "image_id": 16249, "bbox": [42.67, 116.69, 147.63, 233.27], "category_id": 1, "id": 447686}, {"segmentation": [[286.26, 161.78, 287.15, 138.83, 279.2, 134.41, 280.08, 126.91, 275.23, 117.64, 278.32, 105.72, 276.99, 100.86, 280.97, 92.03, 288.47, 74.38, 293.33, 69.52, 303.92, 66.87, 311.87, 62.9, 311.43, 54.51, 314.52, 43.03, 322.46, 38.18, 333.94, 39.94, 338.8, 47.89, 337.47, 56.28, 331.29, 68.2, 329.97, 72.17, 342.77, 78.79, 346.75, 100.41, 346.29, 112.93, 343.21, 117.2, 333.52, 112.95, 330.97, 123.66, 330.09, 131.05, 332.77, 134.1, 332.62, 138.39, 329.53, 143.24, 326.88, 148.1, 322.46, 153.84, 314.96, 160.02, 312.31, 164.43]], "area": 5683.427350000001, "iscrowd": 0, "image_id": 16249, "bbox": [275.23, 38.18, 71.52, 126.25], "category_id": 1, "id": 452702}, {"segmentation": [[129.57, 490.94, 126.37, 495.73, 126.37, 502.12, 125.84, 504.25, 123.18, 505.31, 118.39, 509.04, 113.59, 510.1, 112.0, 512.77, 110.93, 522.88, 113.06, 538.86, 113.06, 563.35, 115.19, 573.47, 117.85, 575.6, 126.91, 573.47, 130.63, 572.94, 139.69, 624.05, 145.54, 629.91, 147.14, 635.23, 155.66, 635.23, 158.85, 627.25, 152.46, 619.26, 158.32, 619.26, 165.78, 619.79, 177.49, 616.07, 166.84, 608.61, 166.31, 604.88, 166.31, 596.9, 156.19, 568.14, 150.87, 550.57, 157.79, 552.17, 166.31, 552.7, 165.78, 541.52, 160.98, 531.4, 160.45, 525.01, 151.12, 513.71, 144.98, 512.83, 144.98, 504.94, 144.1, 494.41, 139.72, 490.9, 132.7, 490.03]], "area": 4899.2145, "iscrowd": 0, "image_id": 17436, "bbox": [110.93, 490.03, 66.56, 145.2], "category_id": 1, "id": 469589}, {"segmentation": [[316.07, 158.03, 328.9, 142.79, 334.52, 130.76, 337.73, 121.93, 350.56, 113.91, 360.19, 99.47, 367.41, 98.67, 377.84, 111.51, 374.63, 126.75, 374.63, 131.56, 374.63, 144.4, 378.64, 150.01, 382.65, 160.44, 385.05, 162.85, 389.07, 179.69, 390.67, 182.9, 394.68, 192.53, 405.91, 202.96, 414.74, 198.95, 417.95, 198.14, 433.19, 204.56, 441.21, 217.4, 442.01, 223.81, 443.62, 234.24, 442.81, 239.86, 442.01, 247.88, 447.63, 267.13, 447.63, 267.13, 448.43, 264.73, 454.04, 275.96, 437.2, 281.57, 427.57, 279.16, 414.74, 275.96, 389.87, 277.56, 378.64, 274.35, 369.01, 266.33, 365.8, 259.91, 371.42, 254.3, 376.23, 243.07, 379.44, 242.26, 383.45, 240.66, 385.86, 237.45, 385.86, 237.45, 387.46, 231.03, 389.87, 223.01, 383.45, 219.8, 377.03, 219.0, 374.63, 219.0, 360.19, 216.59, 347.35, 210.98, 338.53, 202.15, 336.12, 191.73, 332.91, 184.51, 316.07, 177.29, 314.46, 171.67, 314.46, 162.85, 314.46, 161.24, 315.26, 168.46, 320.88, 156.43, 322.48, 152.42]], "area": 10542.287450000005, "iscrowd": 0, "image_id": 16249, "bbox": [314.46, 98.67, 139.58, 182.9], "category_id": 1, "id": 558256}, {"segmentation": [[463.13, 245.42, 486.43, 221.25, 491.26, 215.97, 476.76, 206.74, 467.53, 203.23, 437.2, 198.39, 431.05, 192.24, 422.25, 171.14, 424.45, 152.68, 430.17, 141.25, 433.68, 131.14, 446.87, 120.15, 466.21, 101.25, 474.56, 103.45, 481.15, 109.16, 478.96, 117.96, 471.92, 139.93, 456.98, 139.93, 463.13, 142.57, 469.73, 164.55, 488.19, 181.25, 495.22, 184.77, 500.0, 184.77, 499.62, 225.64, 489.95, 237.07, 482.47, 243.67, 492.58, 253.34, 463.13, 259.05, 483.93, 248.58]], "area": 5333.7381, "iscrowd": 0, "image_id": 16249, "bbox": [422.25, 101.25, 77.75, 157.8], "category_id": 1, "id": 561321}, {"segmentation": [[230.06, 199.99, 222.9, 283.28, 225.43, 283.28, 230.06, 288.75, 230.9, 298.43, 230.9, 300.53, 225.85, 304.32, 225.85, 306.84, 232.58, 310.21, 241.83, 312.73, 244.78, 311.89, 247.72, 308.95, 251.09, 306.84, 254.46, 305.58, 257.82, 303.48, 264.13, 300.95, 271.28, 299.69, 274.65, 298.43, 276.33, 297.17, 276.75, 294.64, 267.5, 263.09, 260.77, 259.72, 273.39, 251.31, 277.17, 247.94, 282.64, 241.21, 286.01, 236.16, 281.38, 218.08, 275.91, 210.08, 267.92, 205.45, 259.08, 202.93, 246.04, 201.67, 231.74, 202.09]], "area": 5022.396499999998, "iscrowd": 0, "image_id": 16249, "bbox": [222.9, 199.99, 63.11, 112.74], "category_id": 15, "id": 573041}, {"segmentation": [[22.31, 538.8, 113.25, 534.17, 115.57, 558.84, 111.71, 568.85, 124.04, 575.79, 129.44, 585.81, 60.85, 587.35, 60.08, 630.51, 50.06, 628.2, 45.43, 591.21, 23.85, 588.12, 22.31, 583.5, 24.62, 565.0, 25.39, 539.57], [164.12, 537.26, 171.06, 536.48, 172.6, 570.4, 177.99, 580.42, 177.22, 585.81, 176.45, 589.66, 163.35, 589.66, 154.1, 567.31, 157.18, 558.06, 155.64, 551.9, 164.12, 551.13, 164.89, 541.11, 164.12, 538.03]], "area": 6032.239250000002, "iscrowd": 0, "image_id": 17436, "bbox": [22.31, 534.17, 155.68, 96.34], "category_id": 15, "id": 574923}, {"segmentation": [[442.18, 489.59, 458.73, 492.2, 468.31, 493.95, 480.0, 504.4, 479.64, 529.66, 458.73, 593.26, 454.38, 603.71, 444.79, 607.2, 429.11, 606.33, 413.43, 593.26, 415.17, 513.11, 416.91, 498.3, 426.5, 492.2, 443.05, 490.46]], "area": 6274.411050000001, "iscrowd": 0, "image_id": 17899, "bbox": [413.43, 489.59, 66.57, 117.61], "category_id": 47, "id": 672382}, {"segmentation": [[442.25, 99.11, 428.22, 101.27, 410.97, 101.27, 398.02, 96.95, 390.47, 105.58, 357.03, 170.3, 339.78, 256.59, 322.52, 290.03, 308.49, 286.8, 298.79, 280.32, 295.55, 277.09, 283.84, 228.69, 300.03, 145.86, 332.4, 84.92, 354.3, 61.12, 383.82, 48.74, 411.43, 69.69, 414.28, 78.26, 447.61, 91.59]], "area": 14720.852149999997, "iscrowd": 0, "image_id": 12667, "bbox": [283.84, 48.74, 163.77, 241.29], "category_id": 52, "id": 1043443}, {"segmentation": [[295.98, 255.75, 272.55, 255.75, 254.07, 259.36, 244.16, 264.76, 240.55, 278.73, 245.96, 295.4, 253.62, 304.41, 257.23, 304.41, 254.52, 327.84, 261.73, 336.41, 271.19, 339.56, 300.48, 333.25, 296.43, 257.1]], "area": 3897.0741500000004, "iscrowd": 0, "image_id": 10977, "bbox": [240.55, 255.75, 59.93, 83.81], "category_id": 70, "id": 1095365}, {"segmentation": [[415.69, 216.04, 343.54, 224.72, 416.23, 253.47, 418.4, 213.86]], "area": 1403.9370999999996, "iscrowd": 0, "image_id": 10977, "bbox": [343.54, 213.86, 74.86, 39.61], "category_id": 81, "id": 1132016}, {"segmentation": [[411.33, 570.97, 394.07, 562.34, 379.69, 549.39, 379.69, 533.57, 392.63, 526.38, 398.38, 523.51, 409.89, 523.51, 424.27, 523.51, 437.21, 523.51, 440.09, 523.51, 455.91, 522.07, 465.98, 523.51, 474.61, 526.38, 476.04, 529.26, 477.48, 530.7, 478.0, 540.76, 478.0, 549.39, 477.48, 559.46, 477.48, 569.53, 473.17, 569.53, 467.42, 570.97, 453.03, 572.4, 441.53, 573.84, 432.9, 575.28, 428.58, 575.28, 419.96, 572.4, 407.01, 568.09]], "area": 4353.856100000001, "iscrowd": 0, "image_id": 17379, "bbox": [379.69, 522.07, 98.31, 53.21], "category_id": 81, "id": 1134446}, {"segmentation": [[476.94, 103.73, 483.62, 99.0, 495.86, 102.89, 500.0, 105.67, 500.0, 111.52, 500.0, 127.09, 499.19, 144.9, 470.82, 143.23, 468.87, 140.45, 474.71, 137.11, 476.38, 126.81, 479.16, 117.91, 480.28, 110.96, 479.44, 108.46]], "area": 987.6813, "iscrowd": 0, "image_id": 16249, "bbox": [468.87, 99.0, 31.13, 45.9], "category_id": 1, "id": 1269423}, {"segmentation": [[229.7, 483.09, 242.07, 480.88, 245.38, 490.16, 250.24, 491.7, 258.63, 494.35, 255.54, 500.76, 252.67, 504.95, 244.94, 506.72, 240.3, 497.66, 235.89, 493.69, 229.7, 491.48]], "area": 364.3076500000003, "iscrowd": 0, "image_id": 17436, "bbox": [229.7, 480.88, 28.93, 25.84], "category_id": 15, "id": 1392353}, {"segmentation": [[48.86, 205.26, 42.89, 205.26, 34.92, 200.78, 29.44, 203.77, 29.44, 210.24, 37.91, 216.22, 49.36, 256.05, 54.84, 279.46, 62.8, 300.37, 48.86, 308.84, 43.38, 332.24, 49.36, 337.72, 50.85, 336.72, 56.33, 334.23, 55.83, 326.76, 55.83, 319.3, 64.3, 310.83, 70.27, 308.84, 75.25, 308.84, 67.78, 331.25, 71.77, 335.73, 76.25, 334.73, 81.73, 310.33, 90.19, 310.33, 92.68, 310.83, 93.18, 324.77, 98.16, 329.75, 100.15, 328.76, 100.15, 323.78, 100.15, 312.82, 113.1, 318.8, 118.08, 332.24, 118.57, 343.2, 120.57, 349.67, 126.54, 347.68, 125.55, 339.71, 124.05, 331.25, 120.57, 318.8, 116.58, 310.33, 110.11, 304.85, 117.58, 296.89, 129.03, 286.93, 134.01, 279.46, 134.51, 272.99, 133.51, 268.5, 130.53, 267.01, 131.52, 257.05, 130.53, 248.59, 123.55, 241.12, 118.08, 236.14, 106.13, 231.65, 93.68, 232.15, 75.25, 233.65, 65.79, 234.14, 57.82, 231.65, 57.82, 227.67, 54.34, 212.73, 54.34, 210.74, 49.36, 205.76], [141.8, 232.37, 149.66, 242.35, 150.57, 246.28, 149.36, 249.3, 147.85, 249.3, 145.13, 244.16, 143.01, 239.63, 139.38, 236.0], [165.2, 306.09, 168.53, 318.63, 169.04, 322.73, 169.3, 326.57, 169.3, 328.62, 169.3, 330.41, 172.88, 332.2, 172.37, 334.5, 168.02, 335.53, 163.92, 336.04, 154.71, 334.25, 154.71, 331.94, 158.55, 330.66, 159.83, 330.66, 160.08, 327.85, 160.08, 323.24, 159.31, 317.61, 158.8, 313.26, 160.34, 309.67, 163.15, 306.6]], "area": 7504.523850000002, "iscrowd": 0, "image_id": 16249, "bbox": [29.44, 200.78, 143.44, 148.89], "category_id": 15, "id": 1394910}, {"segmentation": [[433.52, 240.66, 438.11, 261.28, 445.9, 261.74, 443.15, 247.08, 436.73, 235.16, 440.4, 234.7, 446.81, 247.08, 448.65, 259.45, 455.06, 258.99, 454.14, 246.62, 450.02, 232.41, 460.56, 228.75, 470.64, 213.63, 470.18, 201.71, 464.68, 187.05, 453.69, 181.09, 428.94, 179.72, 425.28, 157.72, 376.25, 153.6, 379.0, 164.6, 391.83, 180.63, 394.12, 195.76, 430.32, 201.25, 434.9, 216.37]], "area": 3923.8549499999995, "iscrowd": 0, "image_id": 16249, "bbox": [376.25, 153.6, 94.39, 108.14], "category_id": 15, "id": 1396783}, {"segmentation": [[328.91, 197.88, 339.57, 240.53, 342.85, 243.81, 332.19, 252.83, 324.81, 267.6, 334.65, 277.44, 337.11, 278.26, 347.78, 279.08, 355.98, 276.62, 369.92, 272.52, 379.76, 273.34, 374.84, 279.08, 383.04, 281.54, 387.97, 279.08, 387.97, 265.96, 383.87, 253.65, 387.97, 237.25, 399.45, 232.33, 399.45, 221.67, 392.89, 219.21, 387.97, 204.44, 383.87, 197.88, 378.12, 194.6, 363.36, 192.96, 347.78, 194.6, 339.57, 193.78, 331.37, 182.29, 328.91, 187.22, 332.19, 199.52]], "area": 4722.786300000001, "iscrowd": 0, "image_id": 16249, "bbox": [324.81, 182.29, 74.64, 99.25], "category_id": 15, "id": 1397318}, {"segmentation": [[275.44, 106.14, 275.79, 106.14, 295.07, 114.35, 295.07, 131.85, 285.79, 135.77, 279.72, 132.92, 275.08, 118.28], [298.64, 67.23, 304.0, 68.65, 300.43, 84.01, 295.43, 89.36, 298.28, 69.73]], "area": 527.3554000000003, "iscrowd": 0, "image_id": 16249, "bbox": [275.08, 67.23, 28.92, 68.54], "category_id": 27, "id": 1416870}, {"segmentation": [[122.71, 372.37, 146.02, 368.45, 148.95, 370.21, 150.13, 369.23, 169.32, 366.69, 173.43, 369.82, 172.84, 370.02, 149.15, 374.33, 142.88, 377.07, 125.46, 379.61, 124.87, 373.54]], "area": 281.81834999999967, "iscrowd": 0, "image_id": 17899, "bbox": [122.71, 366.69, 50.72, 12.92], "category_id": 50, "id": 1526874}, {"segmentation": [[349.66, 379.22, 343.89, 380.87, 327.4, 371.81, 326.99, 365.21, 329.87, 360.27, 350.48, 355.32, 353.36, 358.21, 354.19, 359.86, 352.13, 364.8, 351.3, 370.16, 350.07, 377.58]], "area": 471.87925000000064, "iscrowd": 0, "image_id": 17899, "bbox": [326.99, 355.32, 27.2, 25.55], "category_id": 61, "id": 1576783}, {"segmentation": [[428.52, 183.18, 427.01, 176.56, 430.92, 172.04, 434.84, 180.17, 440.56, 181.07, 448.38, 181.37, 456.2, 183.18, 461.92, 185.29, 467.04, 191.61, 469.45, 200.63, 471.55, 206.65, 474.26, 207.56, 472.76, 209.06, 467.34, 212.37, 464.93, 217.49, 464.03, 220.8, 460.72, 226.22, 459.21, 228.62, 463.73, 235.85, 468.54, 241.56, 467.34, 247.88, 468.84, 251.5, 471.25, 252.7, 471.25, 255.41, 464.93, 255.71, 459.21, 254.81, 458.01, 247.88, 456.51, 242.77, 451.99, 233.74, 450.19, 229.83, 447.78, 229.83, 445.97, 228.32, 451.39, 215.38, 449.28, 203.64, 444.47, 192.81, 441.16, 189.5, 433.03, 185.59, 427.92, 184.08]], "area": 1302.8786500000008, "iscrowd": 0, "image_id": 16249, "bbox": [427.01, 172.04, 47.25, 83.67], "category_id": 62, "id": 1601358}, {"segmentation": [[31.6, 277.34, 26.69, 271.93, 30.13, 271.44, 31.6, 250.79, 31.6, 245.39, 24.72, 242.93, 13.91, 237.52, 11.94, 233.1, 17.84, 232.6, 21.28, 232.6, 24.72, 232.6, 22.26, 224.74, 14.4, 219.82, 9.97, 213.43, 4.57, 209.99, 11.45, 210.48, 10.96, 202.12, 5.55, 191.8, 0.63, 192.29, 2.11, 207.53, 3.58, 238.5, 0.0, 279.31, 3.09, 302.41, 13.41, 301.43, 15.38, 297.0, 19.31, 290.61, 24.72, 280.29]], "area": 2044.2795500000004, "iscrowd": 0, "image_id": 17207, "bbox": [0.0, 191.8, 31.6, 110.61], "category_id": 1, "id": 1735330}, {"segmentation": [[6.41, 249.03, 14.47, 250.27, 17.57, 252.75, 23.62, 275.38, 24.55, 284.38, 19.12, 289.65, 17.88, 291.35, 18.35, 294.3, 14.47, 295.85, 6.56, 294.76, 6.87, 300.19, 4.39, 302.36, 0.0, 302.67, 0.0, 299.88, 0.0, 265.93, 0.0, 249.34, 0.0, 243.29, 0.0, 239.88, 0.0, 236.31, 0.0, 234.61, 4.55, 238.79, 7.18, 247.17]], "area": 1070.0957999999998, "iscrowd": 0, "image_id": 17207, "bbox": [0.0, 234.61, 24.55, 68.06], "category_id": 4, "id": 1789894}, {"segmentation": [[184.21, 639.92, 190.43, 626.95, 183.69, 607.23, 157.23, 594.78, 128.18, 590.63, 96.01, 593.74, 66.44, 602.05, 20.27, 619.68, 4.71, 637.84, 4.19, 640.0]], "area": 6815.9781, "iscrowd": 0, "image_id": 17379, "bbox": [4.19, 590.63, 186.24, 49.37], "category_id": 81, "id": 1982096}, {"segmentation": [[263.13, 271.81, 260.95, 291.43, 260.29, 312.14, 253.32, 313.23, 228.69, 313.23, 225.63, 299.06, 225.63, 291.87, 224.76, 284.68, 224.54, 267.67, 225.63, 264.84, 226.51, 263.1, 219.97, 260.92, 216.04, 254.38, 218.0, 250.45, 220.4, 248.27, 224.76, 240.42, 228.9, 235.19, 233.26, 233.23, 242.42, 233.23, 248.52, 234.54, 253.1, 243.04, 249.61, 256.99, 248.52, 259.61, 263.13, 267.02]], "area": 2645.4526500000015, "iscrowd": 0, "image_id": 17379, "bbox": [216.04, 233.23, 47.09, 80.0], "category_id": 1, "id": 2008412}, {"segmentation": [[167.2, 279.69, 164.05, 289.13, 164.05, 304.85, 164.84, 314.29, 197.08, 314.29, 197.86, 284.41, 190.79, 274.97, 189.21, 265.54, 191.57, 255.32, 190.79, 248.24, 178.21, 242.73, 171.92, 243.52, 164.84, 249.02, 159.33, 254.53, 157.76, 265.54]], "area": 2145.587850000001, "iscrowd": 0, "image_id": 17379, "bbox": [157.76, 242.73, 40.1, 71.56], "category_id": 1, "id": 2012579}, {"segmentation": [[497.95, 0.0, 492.55, 18.88, 494.71, 34.54, 507.39, 52.9, 544.65, 34.0, 567.87, 33.19, 574.08, 25.36, 574.08, 25.36, 571.65, 17.53, 585.15, 1.87, 593.79, 1.6, 581.64, 29.68, 635.36, 28.87, 635.9, 1.06, 559.23, 1.87, 558.96, 0.52, 538.17, 0.52]], "area": 4492.532800000001, "iscrowd": 0, "image_id": 10363, "bbox": [492.55, 0.0, 143.35, 52.9], "category_id": 2, "id": 2168366}, {"segmentation": [[419.27, 499.13, 429.09, 491.27, 444.3, 489.31, 456.57, 491.76, 467.13, 494.71, 480.0, 457.41, 480.0, 450.78, 474.0, 437.28, 458.54, 432.38, 440.87, 427.96, 417.55, 437.04, 419.27, 463.54, 419.76, 473.85]], "area": 3366.6167, "iscrowd": 0, "image_id": 17899, "bbox": [417.55, 427.96, 62.45, 71.17], "category_id": 47, "id": 2183804}, {"segmentation": [[249.4, 429.37, 257.79, 399.78, 281.46, 385.97, 294.78, 380.54, 303.65, 388.93, 302.67, 405.2, 283.93, 430.35, 273.57, 445.64, 261.24, 443.67]], "area": 2111.6567999999997, "iscrowd": 0, "image_id": 17899, "bbox": [249.4, 380.54, 54.25, 65.1], "category_id": 58, "id": 2220573}, {"segmentation": [[178.53, 169.79, 193.25, 132.06, 242.95, 87.88, 277.92, 74.08, 346.02, 70.4, 412.28, 70.4, 475.77, 75.0, 508.9, 80.52, 549.39, 109.97, 565.96, 132.06, 565.96, 173.47, 554.92, 228.68, 551.23, 238.81, 559.52, 257.21, 540.19, 257.21, 486.82, 244.33, 469.33, 238.81, 458.29, 235.13, 387.43, 242.49, 338.66, 231.45, 333.13, 243.41, 297.24, 248.01, 280.68, 259.05, 269.64, 242.49, 248.47, 228.68, 233.75, 238.81, 233.75, 261.81, 228.22, 276.54, 205.22, 279.3, 197.86, 261.81, 194.17, 248.01, 184.97, 236.97, 176.69, 216.72, 175.77, 202.92, 168.41, 206.6, 160.13, 199.24, 130.68, 208.44, 131.6, 203.84, 138.96, 193.71, 161.97, 179.91, 179.45, 166.11]], "area": 62556.14115000001, "iscrowd": 0, "image_id": 12062, "bbox": [130.68, 70.4, 435.28, 208.9], "category_id": 20, "id": 64311}, {"segmentation": [[0.0, 257.18, 44.08, 230.55, 59.69, 218.61, 74.38, 198.41, 92.75, 184.64, 123.05, 174.53, 140.5, 183.72, 140.5, 196.57, 130.4, 209.43, 130.4, 213.1, 156.11, 202.08, 163.45, 211.27, 171.72, 208.51, 183.66, 230.55, 191.0, 243.41, 197.43, 254.42, 200.18, 274.63, 203.86, 281.05, 225.9, 278.3, 231.41, 263.61, 231.41, 248.91, 236.92, 236.98, 247.02, 232.39, 261.71, 236.98, 270.89, 249.83, 270.89, 260.85, 250.69, 264.53, 238.75, 278.3, 236.92, 287.48, 213.04, 290.24, 200.18, 281.05, 183.66, 279.22, 164.37, 277.38, 143.25, 280.14, 137.74, 280.14, 134.07, 270.04, 124.89, 269.12, 125.8, 281.05, 104.68, 292.99, 92.75, 304.01, 92.75, 320.54, 95.5, 342.58, 95.5, 357.27, 83.56, 366.45, 78.05, 381.15, 70.71, 400.43, 67.95, 421.55, 0.92, 422.47]], "area": 27289.100100000007, "iscrowd": 0, "image_id": 12062, "bbox": [0.0, 174.53, 270.89, 247.94], "category_id": 20, "id": 64787}, {"segmentation": [[330.58, 5.74, 322.32, 25.02, 292.93, 51.65, 273.65, 85.63, 286.5, 90.22, 272.73, 136.13, 269.97, 166.44, 288.34, 194.9, 300.28, 198.58, 318.64, 186.64, 338.85, 164.6, 358.13, 138.89, 359.05, 126.03, 361.8, 99.4, 373.74, 79.2, 381.09, 67.26, 378.33, 51.65, 376.49, 47.98, 374.66, 34.21, 379.25, 20.43, 357.21, 14.92, 366.39, 2.98, 366.39, 2.98]], "area": 13623.237050000003, "iscrowd": 0, "image_id": 13177, "bbox": [269.97, 2.98, 111.12, 195.6], "category_id": 2, "id": 128386}, {"segmentation": [[142.49, 220.17, 171.89, 221.63, 177.3, 222.21, 179.2, 218.7, 175.99, 216.95, 173.94, 212.41, 179.2, 211.97, 179.2, 209.78, 150.83, 208.61, 142.34, 212.85, 140.15, 215.34, 140.59, 220.02], [180.67, 222.21, 189.74, 222.21, 190.32, 219.0, 189.3, 217.97, 184.62, 213.14, 181.25, 210.07, 179.64, 209.78]], "area": 494.9808999999998, "iscrowd": 0, "image_id": 15338, "bbox": [140.15, 208.61, 50.17, 13.6], "category_id": 3, "id": 133117}, {"segmentation": [[273.25, 300.22, 270.58, 293.11, 266.72, 291.03, 264.65, 283.32, 265.54, 278.58, 266.13, 266.13, 277.4, 239.75, 279.47, 235.89, 280.36, 235.3, 348.24, 235.6, 365.73, 255.46, 372.55, 263.46, 373.74, 264.35, 375.22, 271.17, 375.22, 278.28, 373.15, 290.44, 367.22, 292.51, 366.33, 285.7, 350.62, 290.74, 350.02, 296.07, 346.47, 299.92, 343.21, 300.52, 340.54, 296.37, 285.4, 295.18, 284.51, 300.81, 276.51, 302.59]], "area": 5876.319200000001, "iscrowd": 0, "image_id": 17627, "bbox": [264.65, 235.3, 110.57, 67.29], "category_id": 3, "id": 135748}, {"segmentation": [[30.14, 233.78, 37.55, 317.35, 70.08, 314.88, 77.9, 314.06, 79.96, 320.65, 84.9, 326.0, 89.43, 326.0, 89.84, 327.65, 102.19, 324.76, 109.6, 323.53, 113.3, 313.65, 119.89, 308.3, 141.71, 305.0, 139.65, 299.24, 147.47, 295.95, 145.83, 287.3, 143.36, 284.42, 131.01, 284.42, 123.6, 284.01, 118.24, 270.83, 98.89, 264.25, 79.96, 263.84, 72.55, 259.72, 71.31, 254.78, 66.78, 253.13, 65.55, 254.37, 56.49, 244.9, 44.96, 236.66, 40.02, 233.37, 31.38, 233.37]], "area": 6009.330949999997, "iscrowd": 0, "image_id": 17627, "bbox": [30.14, 233.37, 117.33, 94.28], "category_id": 3, "id": 136849}, {"segmentation": [[29.45, 218.02, 33.1, 233.54, 52.27, 247.24, 60.49, 256.37, 66.88, 257.28, 73.28, 260.02, 79.67, 264.59, 93.37, 264.59, 100.67, 266.41, 103.41, 265.5, 105.24, 264.59, 91.05, 220.78, 81.63, 215.79, 47.26, 214.68, 27.3, 214.68]], "area": 2534.161049999999, "iscrowd": 0, "image_id": 17627, "bbox": [27.3, 214.68, 77.94, 51.73], "category_id": 3, "id": 136903}, {"segmentation": [[269.19, 247.35, 252.6, 239.45, 207.19, 237.08, 171.65, 257.61, 168.49, 271.83, 178.76, 286.44, 183.5, 292.36, 193.37, 293.15, 196.92, 286.44, 231.28, 292.36, 242.73, 297.89, 251.42, 293.15, 257.34, 286.44, 264.45, 284.86, 266.42, 259.98, 270.37, 246.16]], "area": 4554.6753499999995, "iscrowd": 0, "image_id": 17627, "bbox": [168.49, 237.08, 101.88, 60.81], "category_id": 3, "id": 141360}, {"segmentation": [[421.18, 237.15, 413.84, 249.25, 412.11, 276.9, 413.84, 284.24, 422.91, 283.81, 424.21, 278.2, 434.58, 276.47, 436.3, 281.65, 443.22, 281.65, 446.67, 276.47, 458.34, 276.9, 459.2, 284.68, 466.98, 285.54, 469.57, 277.33, 483.83, 276.04, 481.67, 261.35, 480.37, 254.87, 468.71, 235.86, 421.18, 234.99, 419.89, 237.58]], "area": 2852.0705000000003, "iscrowd": 0, "image_id": 17627, "bbox": [412.11, 234.99, 71.72, 50.55], "category_id": 3, "id": 141859}, {"segmentation": [[0.0, 187.2, 28.0, 190.21, 30.46, 194.59, 32.65, 202.53, 32.37, 214.57, 1.18, 214.29]], "area": 791.4543999999997, "iscrowd": 0, "image_id": 15338, "bbox": [0.0, 187.2, 32.65, 27.37], "category_id": 3, "id": 142585}, {"segmentation": [[544.74, 284.16, 486.75, 285.23, 480.31, 274.49, 479.23, 265.9, 481.38, 250.87, 485.68, 246.57, 495.34, 237.98, 541.52, 234.76, 545.81, 235.84, 562.99, 253.02, 569.44, 260.53, 569.44, 282.01, 543.66, 284.16]], "area": 3848.700550000003, "iscrowd": 0, "image_id": 17627, "bbox": [479.23, 234.76, 90.21, 50.47], "category_id": 3, "id": 143876}, {"segmentation": [[0.0, 28.79, 149.69, 14.39, 179.44, 19.19, 205.34, 42.22, 205.34, 74.84, 173.68, 107.47, 194.79, 150.65, 240.85, 214.94, 237.97, 254.28, 189.03, 327.21, 169.84, 368.47, 129.54, 403.01, 82.52, 419.32, 59.49, 422.2, 35.5, 421.24, 5.76, 415.49, 0.0, 403.01, 1.92, 29.75]], "area": 77920.8604, "iscrowd": 0, "image_id": 13177, "bbox": [0.0, 14.39, 240.85, 407.81], "category_id": 4, "id": 150329}, {"segmentation": [[308.02, 206.3, 361.75, 213.02, 376.14, 235.09, 368.47, 244.69, 355.99, 252.36, 357.91, 272.51, 396.29, 257.16, 412.61, 271.55, 432.76, 277.31, 456.75, 253.32, 437.56, 251.4, 439.47, 243.73, 446.19, 236.05, 435.64, 236.05, 434.68, 230.29, 447.15, 224.53, 451.95, 233.17, 463.46, 211.1, 454.83, 184.23, 470.18, 168.88, 492.25, 159.29, 522.0, 177.52, 535.43, 188.07, 537.35, 178.48, 553.66, 172.72, 552.7, 181.36, 564.22, 187.11, 568.05, 199.59, 556.54, 218.78, 555.58, 245.64, 567.09, 260.04, 557.5, 267.71, 573.81, 297.46, 592.04, 332.0, 591.08, 362.71, 581.49, 375.18, 552.7, 355.99, 542.15, 338.72, 500.89, 363.67, 430.84, 370.39, 430.84, 370.39, 417.4, 377.1, 393.42, 394.38, 377.1, 407.81, 346.4, 405.89, 318.57, 384.78, 284.03, 379.02, 278.27, 376.14, 277.31, 367.51, 291.7, 364.63, 289.78, 334.88, 277.31, 332.96, 282.11, 316.65, 297.46, 320.49, 298.42, 308.02, 310.89, 304.18, 302.26, 284.99, 264.84, 286.91, 255.24, 249.48, 254.28, 225.49, 277.31, 222.62, 284.99, 230.29, 317.61, 219.74, 313.77, 210.14]], "area": 47586.101599999995, "iscrowd": 0, "image_id": 18737, "bbox": [254.28, 159.29, 337.76, 248.52], "category_id": 4, "id": 151923}, {"segmentation": [[0.0, 211.1, 89.24, 213.02, 74.84, 142.01, 86.36, 142.01, 135.3, 205.34, 272.51, 203.42, 268.67, 192.87, 274.43, 192.87, 285.95, 202.47, 486.49, 201.51, 547.9, 216.86, 559.42, 228.37, 566.13, 237.01, 549.82, 251.4, 523.91, 261.0, 458.67, 262.92, 446.19, 265.8, 425.08, 261.96, 403.01, 263.88, 379.98, 261.96, 377.1, 268.67, 351.2, 268.67, 341.6, 264.84, 331.04, 284.99, 288.82, 285.95, 280.19, 272.51, 268.67, 269.63, 260.04, 261.96, 240.85, 270.59, 236.05, 263.88, 237.97, 259.08, 189.03, 256.2, 181.36, 263.88, 172.72, 268.67, 164.08, 257.16, 144.89, 258.12, 135.3, 263.88, 129.54, 262.92, 136.26, 253.32, 142.97, 251.4, 96.91, 234.13, 68.13, 228.37, 64.29, 224.53, 2.88, 215.9]], "area": 30298.91215, "iscrowd": 0, "image_id": 13348, "bbox": [0.0, 142.01, 566.13, 143.94], "category_id": 5, "id": 161024}, {"segmentation": [[2.16, 473.53, 60.4, 472.45, 59.33, 454.11, 48.54, 441.17, 20.49, 69.03, 127.28, 88.45, 144.54, 94.92, 142.38, 122.97, 127.28, 119.73, 118.65, 127.28, 126.2, 153.17, 126.2, 179.06, 129.44, 203.87, 139.15, 218.97, 147.78, 194.16, 148.85, 167.19, 146.7, 160.72, 156.4, 167.19, 154.25, 149.93, 151.01, 144.54, 152.09, 115.42, 142.38, 51.78, 15.1, 22.65, 12.94, 2.16, 1.08, 1.08, 2.16, 470.29]], "area": 22851.46634999999, "iscrowd": 0, "image_id": 17627, "bbox": [1.08, 1.08, 155.32, 472.45], "category_id": 6, "id": 165041}, {"segmentation": [[452.62, 171.72, 517.52, 172.62, 536.0, 196.05, 530.59, 267.27, 520.22, 271.77, 444.95, 271.32]], "area": 8207.99295, "iscrowd": 0, "image_id": 15338, "bbox": [444.95, 171.72, 91.05, 100.05], "category_id": 6, "id": 165112}, {"segmentation": [[271.39, 203.14, 295.84, 202.54, 296.39, 201.17, 322.99, 201.17, 333.69, 204.46, 342.46, 210.22, 348.77, 218.72, 348.22, 221.19, 344.66, 221.19, 345.48, 235.72, 347.12, 236.82, 347.67, 246.69, 285.15, 246.97, 264.58, 247.51, 267.87, 205.83], [327.1, 251.9, 327.1, 248.61, 346.58, 248.34, 347.95, 252.45, 326.56, 252.18], [323.81, 251.35, 324.09, 248.34, 285.97, 248.61, 284.87, 255.47, 290.9, 253.27, 296.39, 253.82, 299.68, 251.63, 318.05, 251.9], [282.13, 249.71, 281.85, 260.4, 265.95, 259.31, 265.67, 249.98]], "area": 3881.2101000000002, "iscrowd": 0, "image_id": 15338, "bbox": [264.58, 201.17, 84.19, 59.23], "category_id": 6, "id": 168151}, {"segmentation": [[303.77, 303.77, 363.95, 280.85, 382.1, 254.1, 384.97, 196.78, 419.36, 186.28, 353.45, 127.05, 379.24, 61.14, 433.69, 62.09, 466.17, 103.17, 542.59, 150.93, 594.17, 213.98, 616.14, 302.82, 576.98, 362.04, 550.23, 365.86, 530.17, 404.07, 504.38, 412.67, 426.04, 371.6, 347.71, 353.45, 308.55, 332.43, 301.86, 313.32]], "area": 62508.03035000002, "iscrowd": 0, "image_id": 13177, "bbox": [301.86, 61.14, 314.28, 351.53], "category_id": 1, "id": 183777}, {"segmentation": [[350.29, 290.33, 349.82, 281.93, 349.82, 272.83, 351.22, 273.3, 351.46, 270.26, 353.79, 272.36, 356.12, 273.53, 355.66, 278.66, 355.19, 287.06, 355.66, 290.33, 352.39, 291.03, 351.92, 283.33, 351.46, 290.8, 350.29, 290.8]], "area": 100.89410000000015, "iscrowd": 0, "image_id": 13348, "bbox": [349.82, 270.26, 6.3, 20.77], "category_id": 1, "id": 191150}, {"segmentation": [[158.68, 293.56, 154.79, 280.6, 152.63, 276.71, 152.2, 269.36, 150.9, 262.02, 150.04, 252.52, 151.33, 244.74, 150.9, 238.69, 150.9, 235.67, 157.38, 233.94, 153.93, 225.3, 157.81, 224.0, 167.32, 232.64, 166.89, 238.26, 164.73, 243.01, 166.46, 252.52, 169.05, 265.04, 167.32, 272.82, 164.73, 283.19, 166.02, 295.72, 158.25, 293.56]], "area": 910.7307500000002, "iscrowd": 0, "image_id": 17627, "bbox": [150.04, 224.0, 19.01, 71.72], "category_id": 1, "id": 196731}, {"segmentation": [[271.28, 248.13, 263.22, 243.43, 259.18, 240.74, 259.85, 237.6, 262.32, 234.46, 263.22, 232.67, 263.22, 232.67, 263.22, 232.22, 263.22, 230.43, 264.56, 228.19, 267.25, 228.19, 268.15, 229.31, 268.82, 233.12, 267.92, 234.46, 266.8, 235.58, 265.91, 240.29, 273.3, 245.67, 272.4, 249.25]], "area": 114.68830000000003, "iscrowd": 0, "image_id": 17627, "bbox": [259.18, 228.19, 14.12, 21.06], "category_id": 1, "id": 209837}, {"segmentation": [[345.61, 235.81, 345.61, 234.18, 351.34, 233.36, 351.34, 231.11, 345.21, 229.68, 344.39, 227.64, 357.06, 227.84, 361.96, 228.45, 366.46, 233.56, 370.34, 242.35, 371.57, 242.96, 373.2, 244.39, 371.98, 246.85, 371.16, 252.36, 366.25, 254.2, 355.42, 243.58, 350.11, 237.04, 346.64, 235.61]], "area": 380.7914999999999, "iscrowd": 0, "image_id": 17627, "bbox": [344.39, 227.64, 28.81, 26.56], "category_id": 3, "id": 244760}, {"segmentation": [[25.73, 289.09, 26.23, 287.47, 26.23, 286.15, 24.92, 285.34, 23.19, 284.33, 22.99, 282.91, 23.09, 282.0, 22.69, 280.99, 21.77, 280.38, 20.56, 280.78, 20.36, 282.81, 20.25, 284.23, 18.33, 284.84, 17.62, 286.46, 17.11, 288.49, 17.72, 291.02, 18.53, 293.35, 20.36, 292.44, 20.96, 290.92, 23.9, 290.01, 25.02, 289.3]], "area": 63.09925000000013, "iscrowd": 0, "image_id": 13348, "bbox": [17.11, 280.38, 9.12, 12.97], "category_id": 1, "id": 257469}, {"segmentation": [[125.39, 272.39, 125.24, 271.68, 125.63, 271.12, 126.19, 270.57, 127.45, 270.81, 128.32, 271.52, 127.77, 272.79, 129.11, 274.13, 129.03, 275.08, 128.24, 276.58, 127.85, 278.8, 127.69, 281.49, 127.93, 285.53, 127.61, 286.95, 127.53, 288.22, 128.32, 288.85, 127.69, 289.8, 125.87, 289.8, 125.0, 289.17, 125.08, 287.19, 125.08, 285.13, 124.68, 282.84, 123.73, 281.89, 123.34, 280.7, 123.89, 278.8, 124.05, 276.5, 123.57, 276.74, 122.7, 277.14, 121.36, 277.61, 119.78, 278.64, 119.14, 278.96, 117.8, 278.96, 117.4, 277.77, 117.32, 277.14, 118.43, 276.35, 119.7, 276.35, 120.88, 275.55, 122.62, 273.97, 124.21, 273.42]], "area": 84.49289999999978, "iscrowd": 0, "image_id": 13348, "bbox": [117.32, 270.57, 11.79, 19.23], "category_id": 1, "id": 261461}, {"segmentation": [[41.95, 119.97, 42.47, 52.44, 49.08, 52.44, 49.87, 43.67, 73.68, 41.63, 87.29, 38.91, 109.74, 44.35, 124.03, 46.39, 153.28, 47.75, 168.25, 43.67, 188.66, 49.79, 228.79, 52.52, 247.84, 47.75, 262.81, 54.56, 270.29, 55.24, 273.69, 63.4, 276.42, 87.89, 275.06, 129.39, 275.06, 134.45, 274.08, 132.5, 271.58, 136.78, 49.37, 124.39, 49.37, 121.09]], "area": 19343.462300000003, "iscrowd": 0, "image_id": 15272, "bbox": [41.95, 38.91, 234.47, 97.87], "category_id": 10, "id": 407642}, {"segmentation": [[233.87, 279.96, 233.42, 225.2, 232.52, 136.33, 233.42, 133.19, 278.3, 134.98, 277.85, 139.02, 288.18, 144.41, 292.67, 160.12, 289.08, 173.58, 281.89, 183.45, 285.49, 191.09, 292.22, 205.0, 291.32, 215.32, 282.79, 229.24, 279.65, 231.93, 283.24, 235.97, 292.22, 247.19, 292.67, 268.29, 280.55, 280.4, 262.59, 279.96, 236.11, 280.85]], "area": 8021.1976, "iscrowd": 0, "image_id": 17905, "bbox": [232.52, 133.19, 60.15, 147.66], "category_id": 10, "id": 408512}, {"segmentation": [[168.1, 528.63, 163.74, 428.29, 158.75, 426.42, 150.03, 426.42, 143.79, 419.57, 150.65, 411.47, 159.38, 414.58, 164.36, 408.35, 161.24, 390.28, 152.52, 385.29, 135.69, 385.91, 132.58, 378.44, 126.35, 389.03, 120.74, 381.55, 108.27, 382.8, 98.92, 370.33, 92.07, 374.7, 88.95, 364.72, 71.5, 364.1, 72.13, 349.77, 87.71, 347.27, 90.2, 339.8, 99.55, 339.8, 100.17, 334.19, 105.16, 327.33, 120.11, 326.09, 121.36, 323.59, 127.59, 326.71, 130.08, 321.1, 137.56, 319.85, 151.9, 317.98, 148.78, 295.55, 136.94, 283.71, 130.08, 270.0, 124.48, 263.76, 123.85, 254.42, 126.97, 250.05, 130.71, 235.72, 144.42, 219.52, 151.9, 214.53, 152.52, 209.54, 164.98, 205.18, 178.07, 204.56, 181.81, 205.81, 194.28, 199.57, 204.25, 197.7, 209.86, 201.44, 221.07, 202.07, 235.41, 199.57, 247.87, 202.07, 247.87, 207.68, 264.7, 220.76, 274.67, 236.34, 277.79, 235.72, 285.89, 245.69, 279.66, 254.42, 275.92, 271.87, 268.44, 280.59, 265.94, 288.07, 267.81, 298.66, 267.19, 307.39, 284.64, 308.64, 284.02, 315.49, 287.76, 316.74, 293.37, 308.01, 298.98, 308.01, 313.93, 313.0, 318.29, 319.23, 320.79, 327.33, 325.77, 321.72, 331.38, 324.22, 333.25, 327.96, 333.25, 328.58, 350.08, 329.82, 349.46, 342.91, 336.99, 345.41, 335.12, 349.14, 330.76, 356.0, 324.53, 355.38, 322.03, 349.77, 320.16, 356.0, 317.05, 368.46, 308.95, 368.46, 306.45, 370.33, 298.98, 373.45, 292.12, 367.84, 291.5, 364.1, 289.63, 370.33, 288.38, 373.45, 273.42, 382.17, 263.45, 386.54, 271.55, 446.99, 269.06, 470.67, 272.8, 537.35, 267.19, 569.14, 257.22, 574.75, 257.84, 570.39, 261.58, 550.44, 260.96, 551.69, 254.73, 566.02, 246.63, 570.39, 237.9, 571.01, 231.67, 575.37, 233.54, 563.53, 237.9, 554.18, 226.68, 556.67, 222.32, 539.22, 223.57, 519.9, 215.46, 529.25, 215.46, 531.75, 219.83, 538.6, 212.35, 551.69, 212.35, 552.31, 211.1, 549.82, 203.62, 550.44, 201.75, 555.43, 199.26, 556.67, 197.39, 528.63, 188.67, 537.35, 184.3, 551.07, 181.19, 556.05]], "area": 48257.932500000046, "iscrowd": 0, "image_id": 15746, "bbox": [71.5, 197.7, 278.58, 377.67], "category_id": 11, "id": 417096}, {"segmentation": [[122.64, 55.18, 123.08, 68.71, 123.51, 80.93, 123.51, 87.47, 123.95, 95.33, 125.69, 100.57, 126.13, 107.11, 123.08, 114.09, 121.77, 122.82, 121.77, 132.42, 121.77, 141.15, 126.57, 151.62, 130.06, 183.91, 124.39, 187.84, 113.48, 190.02, 108.24, 187.4, 106.93, 185.22, 99.08, 185.22, 96.02, 182.16, 97.33, 179.11, 99.51, 177.8, 103.88, 173.87, 105.19, 162.96, 103.44, 145.95, 101.26, 131.11, 99.51, 123.69, 97.33, 112.35, 96.9, 104.49, 96.9, 101.0, 91.22, 92.71, 90.35, 84.42, 90.35, 75.69, 96.02, 68.71, 99.51, 65.66, 95.59, 60.42, 92.1, 53.0, 93.4, 42.97, 96.46, 38.6, 106.06, 38.6, 113.04, 41.22, 114.79, 44.28, 115.66, 47.77, 118.28, 49.95, 121.77, 53.44]], "area": 3858.6890499999995, "iscrowd": 0, "image_id": 11511, "bbox": [90.35, 38.6, 39.71, 151.42], "category_id": 1, "id": 463291}, {"segmentation": [[162.68, 88.5, 161.77, 76.69, 163.13, 68.98, 164.04, 62.17, 163.13, 57.63, 161.31, 53.09, 160.41, 49.46, 157.23, 41.29, 163.13, 33.58, 169.03, 32.22, 174.48, 35.39, 184.01, 45.83, 189.91, 54.46, 189.91, 65.8, 188.55, 90.31, 187.64, 100.3, 185.37, 102.56, 181.74, 119.36, 186.28, 142.96, 187.18, 166.56, 183.55, 170.64, 175.38, 171.55, 173.57, 168.37, 173.11, 163.84, 174.02, 161.11, 174.93, 149.77, 173.11, 137.51, 171.75, 130.25, 170.85, 122.53, 168.12, 109.37, 164.94, 94.4, 164.04, 88.5], [152.24, 158.84, 149.97, 162.47, 141.34, 166.56, 139.53, 169.28, 141.8, 172.46, 147.24, 172.46, 154.05, 172.46, 154.51, 172.01, 152.24, 159.3]], "area": 2691.584550000001, "iscrowd": 0, "image_id": 11511, "bbox": [139.53, 32.22, 50.38, 140.24], "category_id": 1, "id": 470792}, {"segmentation": [[83.54, 181.4, 78.04, 148.38, 80.79, 124.3, 78.73, 110.55, 75.29, 97.47, 77.35, 90.6, 71.16, 71.33, 64.97, 63.08, 60.15, 50.01, 43.64, 44.5, 35.39, 54.82, 42.27, 75.46, 36.08, 86.47, 38.83, 100.91, 44.33, 121.55, 49.83, 137.37, 58.78, 156.64, 64.28, 169.02, 63.59, 184.15, 71.16, 190.34, 78.73, 190.34, 85.61, 189.66]], "area": 4081.7877500000004, "iscrowd": 0, "image_id": 11511, "bbox": [35.39, 44.5, 50.22, 145.84], "category_id": 1, "id": 494713}, {"segmentation": [[214.72, 227.02, 56.56, 269.97, 37.71, 289.87, 56.56, 342.24, 89.03, 359.0, 147.68, 366.33, 189.58, 415.56, 226.24, 411.37, 244.05, 393.56, 256.61, 376.8, 259.76, 347.48, 261.85, 321.29, 296.42, 305.58, 315.27, 285.68, 283.85, 269.97, 246.14, 258.45, 225.19, 232.26]], "area": 29588.63449999999, "iscrowd": 0, "image_id": 11511, "bbox": [37.71, 227.02, 277.56, 188.54], "category_id": 15, "id": 572604}, {"segmentation": [[290.91, 348.26, 287.78, 373.29, 291.96, 401.44, 286.74, 429.59, 398.31, 433.76, 393.1, 350.35]], "area": 8744.866899999999, "iscrowd": 0, "image_id": 11511, "bbox": [286.74, 348.26, 111.57, 85.5], "category_id": 31, "id": 1181355}, {"segmentation": [[513.92, 337.99, 516.39, 328.61, 510.96, 312.34, 508.5, 293.1, 513.43, 283.73, 513.92, 275.84, 504.55, 265.48, 491.23, 260.55, 475.94, 264.99, 467.56, 271.89, 456.71, 275.35, 454.24, 280.77, 448.82, 301.49, 465.09, 343.41, 464.11, 346.86, 453.75, 350.81, 454.74, 356.24, 485.81, 364.13, 509.48, 350.32]], "area": 5175.7271, "iscrowd": 0, "image_id": 11511, "bbox": [448.82, 260.55, 67.57, 103.58], "category_id": 31, "id": 1181635}, {"segmentation": [[73.3, 282.35, 74.74, 283.52, 75.78, 283.52, 76.95, 281.31, 76.56, 277.01, 77.48, 272.97, 76.69, 269.84, 75.0, 270.1, 72.39, 273.36, 67.83, 272.84, 67.7, 271.92, 67.05, 270.36, 66.27, 270.23, 65.35, 271.79, 59.36, 271.79, 57.79, 273.36, 54.93, 274.14, 53.23, 275.31, 54.14, 277.27, 54.4, 278.31, 53.23, 278.44, 52.32, 278.96, 53.75, 282.09, 55.84, 282.48, 55.97, 283.78, 57.92, 284.18, 57.27, 283.92, 61.18, 284.57, 62.35, 282.22]], "area": 249.27475000000007, "iscrowd": 0, "image_id": 13348, "bbox": [52.32, 269.84, 25.16, 14.73], "category_id": 8, "id": 1198098}, {"segmentation": [[89.49, 256.9, 114.18, 255.4, 115.04, 263.13, 89.49, 263.13, 86.69, 264.2, 86.69, 273.22, 81.97, 271.07, 81.33, 267.85, 86.48, 262.49, 88.41, 260.98, 87.77, 255.61]], "area": 224.67705000000007, "iscrowd": 0, "image_id": 13348, "bbox": [81.33, 255.4, 33.71, 17.82], "category_id": 8, "id": 1198133}, {"segmentation": [[129.54, 241.54, 110.05, 242.18, 100.09, 249.17, 102.63, 258.92, 103.48, 266.12, 111.11, 268.03, 110.9, 258.7, 107.08, 258.28, 108.14, 252.98, 114.5, 252.56, 115.35, 255.53, 115.35, 258.49, 114.71, 259.34, 114.5, 268.45, 118.31, 270.78, 120.85, 273.11, 121.49, 276.71, 129.12, 276.71]], "area": 690.1310499999998, "iscrowd": 0, "image_id": 17627, "bbox": [100.09, 241.54, 29.45, 35.17], "category_id": 3, "id": 1345556}, {"segmentation": [[500.27, 100.53, 511.66, 100.53, 514.83, 94.2, 521.16, 94.84, 525.59, 99.27, 529.39, 96.74, 529.39, 70.15, 524.32, 60.65, 525.59, 55.59, 530.65, 53.06, 528.75, 50.53, 515.46, 51.79, 509.13, 56.86, 500.9, 61.92, 499.63, 64.45, 499.63, 79.01, 500.27, 100.53], [488.87, 79.64, 492.04, 87.87, 489.51, 89.77, 486.34, 86.61, 483.81, 84.71, 488.24, 84.08]], "area": 1267.7626000000005, "iscrowd": 0, "image_id": 11511, "bbox": [483.81, 50.53, 46.84, 50.0], "category_id": 4, "id": 1360514}, {"segmentation": [[0.96, 246.84, 7.68, 243.97, 13.43, 246.84, 23.99, 243.01, 29.75, 242.05, 37.42, 242.05, 47.98, 242.05, 53.73, 242.05, 54.69, 237.25, 54.69, 233.41, 53.73, 231.49, 45.1, 231.49, 31.67, 229.57, 20.15, 228.61, 4.8, 230.53, 0.0, 230.53]], "area": 720.6528500000001, "iscrowd": 0, "image_id": 13348, "bbox": [0.0, 228.61, 54.69, 18.23], "category_id": 5, "id": 1364096}, {"segmentation": [[92.46, 190.41, 90.14, 221.65, 145.67, 216.44, 140.47, 186.94, 97.66, 185.79], [76.84, 193.31, 86.09, 190.41, 88.99, 216.44, 68.74, 217.02, 67.58, 213.55]], "area": 2070.4994, "iscrowd": 0, "image_id": 15338, "bbox": [67.58, 185.79, 78.09, 35.86], "category_id": 8, "id": 1371612}, {"segmentation": [[16.05, 303.61, 16.23, 299.08, 17.86, 296.91, 18.76, 292.93, 23.47, 289.31, 39.4, 291.66, 40.48, 301.8, 40.3, 305.24, 29.26, 305.96, 22.74, 306.5, 22.56, 308.31, 19.67, 308.13, 18.04, 304.51, 16.59, 304.51]], "area": 351.72779999999943, "iscrowd": 0, "image_id": 13348, "bbox": [16.05, 289.31, 24.43, 19.0], "category_id": 8, "id": 1372048}, {"segmentation": [[76.39, 273.08, 75.78, 281.2, 79.03, 281.41, 79.54, 283.03, 79.94, 284.25, 82.18, 284.86, 84.61, 284.86, 86.14, 284.86, 86.95, 282.83, 90.2, 281.81, 90.71, 283.03, 91.52, 284.35, 93.86, 284.86, 96.7, 285.27, 97.41, 283.64, 100.86, 283.64, 102.79, 283.44, 103.5, 282.22, 103.2, 280.09, 102.79, 278.97, 99.85, 279.17, 98.22, 277.65, 97.21, 276.84, 96.19, 274.1, 95.38, 272.47, 92.84, 272.27, 90.1, 272.37, 88.68, 271.86, 87.86, 273.08, 87.86, 273.28]], "area": 256.6577500000002, "iscrowd": 0, "image_id": 13348, "bbox": [75.78, 271.86, 27.72, 13.41], "category_id": 8, "id": 1373235}, {"segmentation": [[640.0, 314.73, 632.34, 302.26, 579.57, 303.22, 520.08, 292.66, 454.83, 316.65, 399.17, 350.24, 357.91, 394.38, 344.48, 418.36, 634.26, 417.4, 640.0, 350.24]], "area": 27975.93394999999, "iscrowd": 0, "image_id": 12062, "bbox": [344.48, 292.66, 295.52, 125.7], "category_id": 20, "id": 1405357}, {"segmentation": [[41.14, 108.7, 45.89, 125.46, 48.89, 136.08, 46.51, 144.34, 40.76, 149.09, 30.76, 146.96, 25.38, 137.46, 24.01, 121.83, 27.38, 109.58, 27.76, 106.08, 28.13, 103.95, 29.63, 95.45]], "area": 857.6344500000001, "iscrowd": 0, "image_id": 11511, "bbox": [24.01, 95.45, 24.88, 53.64], "category_id": 31, "id": 1434557}, {"segmentation": [[173.15, 240.08, 174.26, 246.37, 175.03, 248.91, 174.04, 250.67, 175.91, 250.78, 176.13, 248.91, 176.69, 248.91, 177.79, 251.56, 178.23, 251.56, 178.67, 247.14, 179.56, 245.04, 180.11, 243.28, 180.0, 242.18, 178.34, 241.07, 177.9, 240.3, 174.04, 240.3, 173.15, 240.08]], "area": 50.52239999999993, "iscrowd": 0, "image_id": 13348, "bbox": [173.15, 240.08, 6.96, 11.48], "category_id": 1, "id": 1681190}, {"segmentation": [[638.98, 242.95, 619.58, 242.61, 609.71, 243.29, 603.58, 252.14, 598.47, 255.54, 598.81, 270.86, 600.18, 273.92, 605.62, 274.26, 607.32, 275.62, 612.09, 276.3, 618.21, 273.92, 636.93, 271.88, 636.93, 269.84, 639.32, 268.48, 640.0, 244.31]], "area": 1175.4748500000003, "iscrowd": 0, "image_id": 17627, "bbox": [598.47, 242.61, 41.53, 33.69], "category_id": 3, "id": 1786777}, {"segmentation": [[568.69, 276.96, 574.52, 277.76, 575.05, 272.19, 577.7, 272.45, 579.03, 277.49, 582.74, 278.55, 586.72, 276.17, 586.99, 270.86, 585.92, 266.35, 584.6, 263.97, 583.8, 260.52, 582.74, 257.07, 580.89, 254.69, 581.95, 254.69, 582.48, 250.44, 576.38, 250.71, 568.42, 241.96, 551.98, 241.96, 569.48, 259.19]], "area": 574.3420499999985, "iscrowd": 0, "image_id": 17627, "bbox": [551.98, 241.96, 35.01, 36.59], "category_id": 3, "id": 1786928}, {"segmentation": [[460.41, 235.66, 463.52, 231.81, 493.44, 231.36, 527.22, 233.59, 528.7, 235.81, 495.96, 238.18, 481.74, 250.48, 480.7, 255.81, 469.0, 235.66, 460.7, 235.36]], "area": 538.6895499999997, "iscrowd": 0, "image_id": 17627, "bbox": [460.41, 231.36, 68.29, 24.45], "category_id": 3, "id": 1787363}, {"segmentation": [[431.63, 640.0, 432.6, 582.29, 446.23, 576.13, 460.84, 578.4, 469.6, 583.27, 468.63, 639.74, 432.28, 640.0]], "area": 2259.0351500000006, "iscrowd": 0, "image_id": 17905, "bbox": [431.63, 576.13, 37.97, 63.87], "category_id": 11, "id": 1808732}, {"segmentation": [[78.71, 252.96, 80.29, 250.49, 81.41, 248.13, 86.69, 241.17, 88.71, 240.04, 92.42, 237.91, 95.23, 240.49, 97.25, 242.18, 100.96, 241.39, 112.2, 244.2, 115.23, 243.53, 127.7, 245.44, 148.6, 252.4, 156.35, 252.4, 163.32, 254.31, 163.88, 252.85, 164.78, 251.05, 167.47, 251.17, 173.54, 253.75, 181.86, 263.19, 183.65, 272.4, 181.29, 281.28, 180.4, 286.56, 179.16, 295.77, 177.25, 300.04, 176.69, 301.61, 172.53, 312.06, 171.52, 314.09, 170.73, 314.87, 168.04, 314.65, 167.7, 313.52, 169.5, 310.15, 170.4, 306.11, 169.72, 302.06, 169.27, 300.94, 166.69, 300.6, 166.01, 302.4, 167.7, 305.55, 166.8, 311.05, 163.88, 312.96, 161.63, 311.61, 159.83, 307.23, 159.05, 305.66, 155.9, 301.5, 150.06, 299.03, 132.98, 297.01, 129.05, 294.2, 128.6, 300.83, 128.6, 305.55, 128.6, 308.36, 127.14, 310.72, 124.67, 311.28, 120.62, 309.82, 120.96, 307.34, 121.52, 303.3, 121.52, 301.17, 120.17, 297.35, 119.05, 289.03, 116.24, 288.24, 108.71, 285.55, 106.13, 284.31, 98.49, 283.08, 94.33, 281.28, 93.54, 278.24, 94.56, 274.87, 95.68, 268.81, 95.79, 265.89, 95.68, 261.62, 94.11, 260.94, 92.76, 260.27, 88.38, 261.84, 83.77, 266.33, 82.31, 267.23, 81.3, 267.23, 76.47, 264.2, 75.23, 261.73, 76.13, 258.36, 76.69, 257.12]], "area": 4621.808499999997, "iscrowd": 0, "image_id": 16502, "bbox": [75.23, 237.91, 108.42, 76.96], "category_id": 20, "id": 1817553}, {"segmentation": [[90.05, 84.23, 90.3, 89.08, 90.17, 92.53, 91.32, 97.12, 94.13, 102.48, 95.66, 104.26, 98.34, 102.09, 101.53, 96.61, 99.87, 90.61, 98.59, 85.0, 95.4, 78.75, 91.83, 82.32, 91.32, 82.7]], "area": 186.3826000000002, "iscrowd": 0, "image_id": 11511, "bbox": [90.05, 78.75, 11.48, 25.51], "category_id": 31, "id": 1834488}, {"segmentation": [[173.1, 252.88, 173.75, 244.84, 174.84, 242.01, 174.84, 237.01, 177.67, 236.14, 181.8, 235.27, 182.88, 238.97, 182.67, 242.23, 180.93, 244.62, 180.27, 245.71, 180.06, 248.1, 179.19, 251.36, 178.75, 253.75, 177.67, 256.57, 175.93, 258.75, 174.62, 262.66, 174.41, 264.62, 174.19, 265.27, 173.1, 262.88, 172.88, 260.27, 173.32, 257.01, 173.32, 252.88]], "area": 156.28030000000012, "iscrowd": 0, "image_id": 17627, "bbox": [172.88, 235.27, 10.0, 30.0], "category_id": 1, "id": 2006197}, {"segmentation": [[191.58, 248.77, 190.28, 245.52, 187.25, 244.44, 187.03, 241.63, 190.49, 236.66, 193.09, 231.47, 195.47, 228.22, 198.5, 226.28, 201.31, 227.79, 201.09, 232.76, 200.23, 236.66, 203.04, 239.9]], "area": 190.49135000000007, "iscrowd": 0, "image_id": 17627, "bbox": [187.03, 226.28, 16.01, 22.49], "category_id": 1, "id": 2011679}, {"segmentation": [[126.95, 251.27, 128.48, 250.69, 129.07, 252.45, 128.83, 253.62, 128.36, 254.91, 127.89, 255.62, 127.07, 256.32, 126.95, 255.03, 126.95, 253.97, 126.6, 253.62, 125.43, 253.27, 124.96, 252.8, 125.66, 252.21, 126.48, 252.21, 126.95, 252.21, 127.42, 251.74, 127.42, 251.51]], "area": 10.264200000000002, "iscrowd": 0, "image_id": 13348, "bbox": [124.96, 250.69, 4.11, 5.63], "category_id": 1, "id": 2015225}, {"segmentation": [[151.15, 246.42, 152.3, 245.07, 153.64, 244.69, 156.52, 245.55, 160.07, 251.02, 158.63, 251.79, 153.07, 252.08, 149.13, 255.24, 148.94, 254.67, 150.48, 252.65, 150.96, 250.54, 150.96, 246.51]], "area": 54.30999999999999, "iscrowd": 0, "image_id": 13348, "bbox": [148.94, 244.69, 11.13, 10.55], "category_id": 1, "id": 2017079}, {"segmentation": [[637.25, 58.61, 625.79, 62.75, 636.94, 62.11, 636.94, 60.52], [620.06, 65.62, 611.46, 69.44, 610.5, 102.88, 621.01, 101.29, 623.24, 66.89, 620.37, 65.62], [609.86, 71.67, 605.4, 78.67, 603.81, 82.18, 603.17, 85.36, 601.58, 90.78, 601.58, 94.28, 601.58, 97.47, 606.36, 101.29, 608.91, 98.74, 610.5, 73.9], [625.79, 65.62, 636.62, 65.62, 633.75, 102.24, 623.24, 101.29], [639.48, 67.53, 636.3, 103.52, 639.8, 103.2, 638.85, 74.85], [620.06, 104.47, 611.14, 103.84, 608.91, 114.67, 610.18, 116.89, 611.77, 121.04, 614.96, 124.54, 618.46, 125.18, 619.74, 127.72, 621.01, 106.07], [622.92, 105.43, 633.75, 106.07, 633.75, 131.23, 622.92, 129.95, 623.56, 106.38], [640.0, 106.07, 636.94, 106.07, 635.66, 131.86, 639.17, 131.86, 638.21, 107.34], [604.45, 103.2, 607.32, 110.21, 608.59, 103.2, 604.13, 103.2]], "area": 1546.975700000001, "iscrowd": 0, "image_id": 12062, "bbox": [601.58, 58.61, 38.42, 73.25], "category_id": 37, "id": 2088406}, {"segmentation": [[190.53, 455.67, 185.46, 432.52, 186.91, 433.96, 186.18, 427.45, 186.18, 419.49, 186.18, 415.87, 189.08, 421.66, 189.08, 425.28, 189.08, 429.62, 186.91, 432.52, 189.08, 433.96, 193.42, 430.35, 197.76, 423.11, 195.59, 414.43, 192.7, 410.81, 191.25, 408.64, 189.8, 407.19, 189.08, 402.13, 189.08, 395.61, 188.35, 386.21, 188.35, 383.31, 186.91, 363.78, 184.74, 339.9, 192.7, 334.11, 184.01, 297.21, 178.22, 291.42, 153.62, 281.29, 145.66, 279.84, 144.22, 267.54, 150.01, 258.13, 150.01, 250.18, 150.01, 242.22, 147.83, 234.98, 144.22, 229.91, 140.6, 229.19, 134.81, 229.19, 126.85, 229.19, 122.51, 231.36, 120.34, 234.26, 116.0, 240.05, 115.27, 248.0, 113.83, 254.52, 115.27, 261.03, 117.44, 265.37, 120.34, 268.99, 121.06, 282.01, 94.29, 295.04, 89.95, 303.72, 85.61, 322.53, 81.27, 337.73, 90.67, 342.79, 88.5, 363.78, 88.5, 382.59, 88.5, 405.74, 89.95, 420.22, 88.5, 431.79, 92.84, 443.37, 102.97, 447.71, 101.53, 441.2, 105.14, 437.58, 105.87, 430.35, 102.25, 417.32, 99.36, 413.7, 105.87, 374.63, 110.21, 382.59, 108.76, 393.44, 107.31, 405.02, 107.31, 417.32, 108.04, 433.96, 109.49, 449.16, 113.1, 463.63, 111.66, 478.1, 113.83, 481.0, 114.55, 491.85, 114.55, 520.07, 114.55, 533.09, 119.62, 563.48, 118.89, 570.72, 115.27, 577.23, 108.04, 586.64, 111.66, 593.87, 126.13, 591.7, 133.36, 585.91, 136.26, 576.51, 134.81, 571.44, 132.64, 556.25, 136.26, 531.65, 136.26, 512.11, 134.81, 490.4, 141.32, 481.0, 139.88, 468.69, 145.66, 433.24, 152.18, 474.48, 155.79, 473.04, 157.24, 488.23, 160.86, 496.19, 163.75, 512.83, 166.65, 534.54, 172.44, 552.63, 172.44, 564.93, 169.54, 576.51, 189.08, 591.7, 200.66, 588.81, 199.21, 583.74, 191.25, 574.34, 187.63, 571.44, 186.18, 534.54, 184.74, 507.04, 181.12, 488.95, 178.95, 475.21, 178.95, 475.21, 177.5, 473.04, 191.97, 467.25, 191.97, 467.25, 189.8, 453.5]], "area": 23736.03525000002, "iscrowd": 0, "image_id": 17905, "bbox": [81.27, 229.19, 119.39, 364.68], "category_id": 1, "id": 2157397}, {"segmentation": [[21.65, 212.33, 46.49, 214.29, 62.82, 211.02, 54.33, 203.18, 43.64, 184.58, 38.53, 170.35, 45.83, 147.35, 51.67, 140.41, 33.42, 86.38, 5.08, 51.73, 1.27, 133.09, 25.42, 180.13, 27.97, 204.28]], "area": 4610.6455, "iscrowd": 0, "image_id": 11511, "bbox": [1.27, 51.73, 61.55, 162.56], "category_id": 1, "id": 2165380}, {"segmentation": [[164.58, 280.64, 210.99, 268.51, 237.4, 254.23, 239.55, 253.51, 255.25, 273.5, 262.39, 276.36, 277.39, 311.34, 280.24, 304.2, 285.95, 312.77, 284.53, 381.31, 295.95, 399.16, 295.95, 319.2, 298.8, 302.78, 298.09, 277.07, 295.23, 264.94, 293.09, 249.23, 265.96, 241.37, 238.83, 241.37, 209.56, 231.38, 220.98, 239.95, 163.87, 249.23, 167.44, 256.37, 152.44, 262.79, 155.3, 281.36]], "area": 5652.242499999999, "iscrowd": 0, "image_id": 15751, "bbox": [152.44, 231.38, 146.36, 167.78], "category_id": 16, "id": 36909}, {"segmentation": [[107.01, 368.05, 107.5, 356.26, 112.9, 348.9, 117.32, 344.97, 120.76, 333.18, 126.65, 326.31, 136.47, 323.36, 143.84, 325.33, 147.28, 322.87, 143.84, 331.22, 142.37, 345.95, 145.31, 358.23, 152.19, 368.54, 153.17, 370.5, 135.98, 370.5, 121.74, 371.48]], "area": 1405.1597500000003, "iscrowd": 0, "image_id": 15751, "bbox": [107.01, 322.87, 46.16, 48.61], "category_id": 16, "id": 38274}, {"segmentation": [[321.53, 205.29, 325.74, 190.93, 323.98, 179.02, 329.24, 171.31, 322.93, 167.46, 321.18, 165.01, 319.78, 168.51, 319.78, 171.66, 320.83, 173.41, 321.18, 174.12, 318.73, 174.12, 315.23, 173.06, 313.82, 173.06, 311.72, 174.47, 309.97, 176.22, 308.92, 176.92, 308.57, 178.32, 308.22, 181.12, 308.22, 186.03, 308.57, 189.53, 311.37, 193.73, 314.18, 197.23, 316.98, 198.64, 318.03, 203.54, 319.78, 204.24, 320.83, 204.94]], "area": 450.39435, "iscrowd": 0, "image_id": 19042, "bbox": [308.22, 165.01, 21.02, 40.28], "category_id": 16, "id": 40014}, {"segmentation": [[69.77, 355.19, 76.33, 359.39, 97.87, 367.0, 119.66, 372.25, 159.83, 369.1, 170.86, 368.58, 168.76, 375.4, 166.66, 376.98, 146.44, 383.02, 117.03, 394.05, 105.48, 397.2, 86.31, 395.89, 72.92, 389.58, 61.89, 385.38, 51.13, 380.39, 44.04, 374.09, 43.51, 368.05, 44.83, 358.07, 49.29, 350.98, 56.38, 347.05, 66.88, 348.1]], "area": 2996.3760999999986, "iscrowd": 0, "image_id": 15751, "bbox": [43.51, 347.05, 127.35, 50.15], "category_id": 16, "id": 40780}, {"segmentation": [[191.46, 178.06, 220.18, 178.06, 270.92, 132.11, 285.28, 111.05, 291.98, 46.91, 304.42, 49.78, 336.97, 107.22, 346.54, 118.71, 369.52, 127.32, 381.01, 145.51, 389.62, 149.34, 408.77, 142.64, 436.53, 112.96, 469.08, 106.26, 507.37, 92.86, 466.21, 225.92, 447.06, 269.0, 446.1, 268.04, 431.74, 298.68, 422.17, 313.04, 409.73, 302.51, 399.2, 266.13, 379.09, 287.19, 356.12, 289.11, 377.18, 316.87, 336.01, 283.36, 354.2, 340.8, 319.74, 293.89, 308.25, 370.48, 307.29, 275.7, 244.11, 326.44, 302.51, 268.04, 274.75, 256.56, 263.26, 259.43, 234.54, 229.75, 210.61, 226.88, 186.67, 177.1]], "area": 42418.22265, "iscrowd": 0, "image_id": 18833, "bbox": [186.67, 46.91, 320.7, 323.57], "category_id": 17, "id": 51982}, {"segmentation": [[592.45, 416.49, 620.56, 335.27, 621.61, 270.72, 621.61, 237.4, 624.73, 194.71, 613.28, 148.89, 624.73, 77.05, 635.14, 57.27, 639.31, 4.16, 0.0, 3.12, 1.04, 244.69, 63.51, 226.98, 91.63, 218.66, 142.65, 222.82, 217.61, 193.67, 239.48, 183.25, 263.43, 186.38, 266.55, 194.71, 301.95, 198.87, 320.69, 195.75, 322.78, 203.04, 356.1, 210.33, 387.33, 202.0, 396.7, 222.82, 434.19, 220.74, 470.63, 220.74, 501.87, 187.42, 520.61, 170.76, 516.44, 216.57, 518.52, 264.47, 535.18, 316.53, 554.97, 385.25, 554.97, 424.82, 562.26, 441.48, 591.41, 437.31]], "area": 146899.25910000002, "iscrowd": 0, "image_id": 14888, "bbox": [0.0, 3.12, 639.31, 438.36], "category_id": 21, "id": 70360}, {"segmentation": [[364.64, 383.79, 395.54, 380.7, 417.17, 385.85, 425.41, 374.52, 416.14, 348.77, 422.32, 318.9, 440.86, 290.06, 449.1, 291.09, 463.52, 299.33, 476.91, 325.08, 480.0, 330.23, 488.24, 333.32, 476.91, 374.52, 468.67, 399.24, 467.64, 431.18, 448.07, 449.72, 409.96, 456.93, 423.35, 428.09, 417.17, 417.79, 401.72, 421.91, 388.33, 436.33, 378.03, 442.51]], "area": 10332.542850000002, "iscrowd": 0, "image_id": 13659, "bbox": [364.64, 290.06, 123.6, 166.87], "category_id": 62, "id": 103597}, {"segmentation": [[305.75, 157.23, 314.04, 183.86, 317.1, 205.26, 313.17, 209.62, 324.08, 208.75, 372.99, 212.68, 381.28, 219.23, 381.72, 256.35, 374.3, 263.77, 316.22, 262.89, 317.1, 268.57, 377.79, 269.01, 384.78, 258.97, 384.34, 215.74, 377.79, 210.93, 390.45, 207.0, 388.27, 247.61, 385.65, 248.49, 387.4, 252.85, 398.75, 204.38, 378.66, 200.02, 371.24, 211.81, 358.14, 210.06, 360.33, 202.2, 361.64, 197.4, 334.13, 195.22, 333.69, 176.88, 328.45, 146.75, 316.22, 145.44, 306.18, 158.1]], "area": 2528.2628999999984, "iscrowd": 0, "image_id": 13659, "bbox": [305.75, 145.44, 93.0, 123.57], "category_id": 62, "id": 105100}, {"segmentation": [[482.27, 192.3, 486.07, 221.75, 486.07, 283.49, 484.17, 318.64, 514.56, 321.48, 563.96, 322.43, 560.16, 296.79, 569.66, 186.6, 563.96, 173.3, 490.82, 175.2, 484.17, 200.85]], "area": 11571.237649999995, "iscrowd": 0, "image_id": 13659, "bbox": [482.27, 173.3, 87.39, 149.13], "category_id": 62, "id": 105395}, {"segmentation": [[190.35, 133.67, 194.95, 155.54, 196.68, 156.69, 209.91, 157.84, 208.19, 167.04, 209.34, 172.8, 213.36, 194.67, 219.69, 191.21, 218.54, 182.01, 236.38, 181.43, 247.89, 181.43, 257.1, 176.83, 258.25, 182.01, 266.3, 183.16, 264.0, 176.25, 277.81, 168.77, 275.51, 153.23, 266.88, 144.03, 254.79, 142.88, 249.04, 149.78, 250.77, 175.68, 247.31, 176.25, 243.29, 172.8, 243.86, 150.93, 238.68, 132.52, 223.15, 125.61, 213.94, 124.46, 188.62, 130.22]], "area": 3250.8677000000002, "iscrowd": 0, "image_id": 13659, "bbox": [188.62, 124.46, 89.19, 70.21], "category_id": 62, "id": 107179}, {"segmentation": [[380.9, 439.74, 405.68, 416.0, 418.06, 420.13, 422.19, 428.39, 412.9, 445.94, 402.58, 473.81, 378.84, 473.81, 388.13, 458.32, 381.94, 456.26, 377.81, 442.84]], "area": 1518.9017999999994, "iscrowd": 0, "image_id": 13659, "bbox": [377.81, 416.0, 44.38, 57.81], "category_id": 62, "id": 110683}, {"segmentation": [[384.06, 252.16, 384.06, 252.16, 384.06, 251.69, 400.09, 181.42, 397.26, 173.87, 397.26, 172.93, 400.09, 165.39, 406.7, 159.73, 407.64, 159.26, 425.56, 154.07, 440.18, 156.43, 450.55, 159.26, 465.17, 153.6, 471.77, 147.94, 477.43, 144.64, 480.73, 150.3, 480.73, 150.77, 482.15, 155.01, 482.62, 155.95, 490.64, 155.01, 494.41, 155.01, 498.18, 155.01, 512.33, 155.01, 528.36, 157.37, 543.92, 158.78, 557.13, 161.14, 568.45, 169.63, 569.86, 171.52, 573.63, 176.23, 565.15, 183.78, 532.14, 187.08, 516.1, 185.66, 490.64, 185.66, 479.32, 188.49, 475.07, 206.41, 479.79, 235.18, 480.73, 257.34, 481.2, 270.08, 475.55, 278.09, 473.19, 278.09, 471.77, 278.57, 458.57, 282.34, 446.37, 282.36, 447.78, 269.15, 443.54, 262.08, 442.59, 261.14, 414.77, 258.78, 396.85, 259.72, 391.19, 257.36]], "area": 12086.843950000002, "iscrowd": 0, "image_id": 13659, "bbox": [384.06, 144.64, 189.57, 137.72], "category_id": 67, "id": 119383}, {"segmentation": [[621.18, 218.92, 605.36, 352.19, 617.79, 347.67, 624.56, 282.16, 626.82, 229.08, 640.0, 238.12, 639.25, 216.66, 622.31, 217.79]], "area": 1523.5983999999999, "iscrowd": 0, "image_id": 13659, "bbox": [605.36, 216.66, 34.64, 135.53], "category_id": 67, "id": 123229}, {"segmentation": [[570.34, 167.58, 571.44, 168.5, 576.77, 165.66, 577.69, 166.57, 575.21, 169.7, 580.17, 170.16, 581.73, 170.8, 580.91, 172.91, 580.81, 176.86, 579.07, 183.75, 578.7, 185.86, 573.65, 179.62, 572.0, 176.58, 568.23, 173.74, 565.66, 175.3, 565.57, 170.34, 566.21, 165.38, 565.93, 162.44, 568.96, 163.73, 569.88, 165.1, 569.15, 167.22], [561.89, 173.46, 558.68, 175.39, 553.99, 180.44, 554.82, 185.31, 557.85, 190.09, 562.26, 174.56], [588.9, 169.33, 592.02, 169.33, 591.19, 167.49, 589.63, 167.31, 586.6, 171.17, 585.31, 180.9, 584.49, 185.22, 585.22, 188.25, 590.37, 191.19, 595.88, 191.19, 599.46, 188.62, 601.94, 182.56, 600.38, 178.06, 597.81, 175.3, 593.58, 174.01, 588.99, 174.38, 586.88, 176.58, 588.99, 169.42]], "area": 492.7924500000005, "iscrowd": 0, "image_id": 11197, "bbox": [553.99, 162.44, 47.95, 28.75], "category_id": 2, "id": 127482}, {"segmentation": [[410.97, 185.58, 430.48, 186.9, 433.64, 190.85, 439.45, 191.38, 446.83, 191.12, 448.15, 188.48, 471.62, 189.27, 473.2, 194.02, 480.85, 193.75, 484.01, 190.06, 484.54, 184.0, 486.12, 178.46, 484.01, 172.92, 482.43, 170.02, 474.78, 166.07, 466.87, 156.84, 433.38, 153.67, 423.89, 161.58, 419.14, 164.22, 416.24, 167.38, 410.44, 166.86, 404.9, 169.23, 400.15, 173.71, 401.21, 180.83, 400.42, 185.84, 407.54, 186.63, 409.91, 184.53]], "area": 2349.6031000000003, "iscrowd": 0, "image_id": 11197, "bbox": [400.15, 153.67, 85.97, 40.35], "category_id": 3, "id": 132902}, {"segmentation": [[76.64, 237.53, 87.92, 237.53, 88.33, 232.82, 86.07, 228.72, 78.08, 228.1, 76.03, 231.59, 75.41, 237.33]], "area": 104.71550000000003, "iscrowd": 0, "image_id": 14380, "bbox": [75.41, 228.1, 12.92, 9.43], "category_id": 3, "id": 134914}, {"segmentation": [[173.07, 165.77, 173.07, 161.39, 173.07, 159.0, 172.67, 154.63, 175.86, 151.44, 172.27, 150.65, 172.67, 149.45, 174.26, 149.05, 176.25, 149.05, 178.64, 146.67, 179.84, 145.07, 185.41, 143.48, 196.95, 143.88, 197.75, 143.88, 197.75, 164.58, 182.62, 164.58, 181.43, 167.76, 176.65, 166.96, 173.47, 166.57], [206.9, 150.65, 208.09, 159.4, 208.89, 165.37, 212.47, 158.21, 210.88, 155.02, 208.09, 149.05]], "area": 544.3247000000002, "iscrowd": 0, "image_id": 11197, "bbox": [172.27, 143.48, 40.2, 24.28], "category_id": 3, "id": 135824}, {"segmentation": [[344.99, 10.63, 353.27, 1.95, 369.05, 1.17, 388.76, 1.17, 391.53, 7.87, 363.92, 11.02, 346.57, 11.81]], "area": 364.2751999999999, "iscrowd": 0, "image_id": 19042, "bbox": [344.99, 1.17, 46.54, 10.64], "category_id": 3, "id": 143831}, {"segmentation": [[95.43, 367.75, 95.43, 372.57, 93.5, 378.36, 90.61, 382.21, 83.86, 386.07, 76.15, 388.96, 72.3, 395.71, 56.87, 386.07, 51.09, 377.39, 52.05, 372.57, 43.38, 376.43, 40.49, 378.36, 41.45, 388.0, 38.56, 388.96, 33.74, 383.18, 27.95, 383.18, 21.21, 382.21, 17.35, 371.61, 16.39, 366.79, 25.06, 363.9, 26.99, 358.11, 25.06, 351.36, 24.1, 346.55, 27.95, 338.83, 27.95, 328.23, 26.03, 317.63, 20.24, 311.84, 23.14, 306.06, 29.88, 307.02, 35.67, 309.91, 43.38, 311.84, 44.34, 302.2, 49.16, 298.35, 40.49, 293.53, 29.88, 296.42, 26.99, 294.49, 28.92, 286.78, 36.63, 284.85, 44.34, 284.85, 47.23, 281.96, 45.31, 275.21, 39.52, 270.39, 37.59, 267.5, 33.74, 259.79, 38.56, 255.93, 43.38, 255.93, 45.31, 263.64, 47.23, 265.57, 51.09, 272.32, 52.05, 280.03, 56.87, 281.0, 61.69, 279.07, 63.62, 278.1, 65.55, 276.18, 67.48, 281.96, 71.33, 281.96, 73.26, 287.74, 73.26, 289.67, 74.23, 296.42, 71.33, 300.27, 74.23, 306.06, 74.23, 310.88, 81.94, 326.3, 84.83, 327.27, 81.94, 338.83, 81.94, 341.73, 90.61, 349.44, 92.54, 352.33, 95.43, 355.22, 91.58, 358.11, 93.5, 362.93]], "area": 5968.806500000001, "iscrowd": 0, "image_id": 19109, "bbox": [16.39, 255.93, 79.04, 139.78], "category_id": 4, "id": 148051}, {"segmentation": [[93.16, 259.28, 107.76, 254.02, 121.77, 253.44, 129.36, 263.36, 132.28, 270.95, 145.71, 277.96, 147.46, 282.63, 142.21, 296.65, 143.37, 301.9, 153.88, 317.08, 146.29, 326.43, 146.29, 335.77, 155.64, 346.28, 155.64, 359.71, 150.38, 374.31, 136.37, 384.23, 128.78, 385.4, 121.77, 384.82, 114.76, 381.9, 113.01, 377.23, 110.09, 372.55, 108.34, 365.55, 102.5, 352.7, 92.57, 351.53, 82.65, 339.27, 84.4, 330.51, 78.56, 318.25, 74.47, 307.74, 72.14, 301.9, 72.48, 299.88, 91.13, 303.06, 93.86, 298.97, 91.59, 292.14, 92.04, 286.23, 75.66, 287.14, 73.39, 285.32, 71.11, 283.95, 71.57, 279.86, 74.3, 278.04, 77.03, 277.13, 87.04, 277.58, 92.04, 277.58, 93.86, 276.22, 94.32, 273.95, 90.22, 271.22, 82.94, 269.4, 82.03, 263.48, 86.13, 259.39, 92.5, 260.3, 94.32, 263.03]], "area": 7202.677, "iscrowd": 0, "image_id": 19109, "bbox": [71.11, 253.44, 84.53, 131.96], "category_id": 4, "id": 152529}, {"segmentation": [[155.83, 317.49, 151.76, 310.18, 142.83, 300.43, 142.83, 291.49, 146.08, 289.87, 146.89, 283.37, 150.95, 281.74, 149.33, 271.99, 149.33, 267.93, 171.27, 267.93, 172.08, 265.49, 178.58, 257.36, 181.83, 258.18, 185.08, 258.18, 188.33, 258.18, 187.52, 263.05, 183.46, 266.3, 173.7, 267.93, 183.46, 297.18, 187.52, 300.43, 187.52, 306.12, 191.58, 318.31, 191.58, 323.18, 188.33, 328.87, 183.46, 332.93, 188.33, 346.75, 189.96, 352.43, 188.33, 357.31, 185.89, 358.94, 186.71, 371.94, 179.39, 376.0, 175.33, 371.94, 170.45, 365.44, 167.2, 358.94, 164.77, 350.81, 161.52, 339.43, 156.64, 340.25, 146.89, 333.75]], "area": 3320.82665, "iscrowd": 0, "image_id": 19109, "bbox": [142.83, 257.36, 48.75, 118.64], "category_id": 4, "id": 154233}, {"segmentation": [[186.17, 339.33, 196.73, 358.52, 211.12, 351.8, 216.88, 347.01, 231.27, 347.97, 231.27, 365.24, 246.63, 363.32, 243.75, 356.6, 264.86, 345.09, 277.34, 331.65, 282.13, 353.72, 294.61, 366.2, 317.64, 355.64, 320.52, 343.17, 312.84, 327.81, 320.52, 324.93, 296.53, 288.47, 284.05, 271.19, 244.71, 275.99, 259.1, 278.87, 262.94, 283.67, 255.26, 297.1, 269.66, 319.18, 265.82, 331.65, 261.02, 328.77, 245.67, 312.46, 231.27, 295.19, 216.88, 295.19, 206.32, 279.83, 193.85, 281.75, 188.09, 299.02, 189.05, 308.62, 191.93, 320.14]], "area": 7753.239449999999, "iscrowd": 0, "image_id": 19109, "bbox": [186.17, 271.19, 134.35, 95.01], "category_id": 4, "id": 155152}, {"segmentation": [[326.49, 275.69, 324.4, 281.55, 319.8, 285.32, 316.87, 285.32, 312.68, 289.51, 320.21, 297.04, 329.01, 310.44, 338.22, 321.32, 342.82, 330.95, 342.4, 341.0, 338.64, 342.72, 353.29, 354.44, 372.55, 342.3, 372.13, 325.14, 371.71, 322.2, 363.75, 313.43, 360.82, 312.18, 364.59, 282.06, 357.47, 281.22, 337.8, 251.54, 335.29, 251.54, 329.42, 251.54, 320.63, 257.82, 322.73, 262.43, 322.73, 268.71, 318.96, 268.71, 313.1, 269.54, 333.19, 276.24]], "area": 3149.922050000001, "iscrowd": 0, "image_id": 19109, "bbox": [312.68, 251.54, 59.87, 102.9], "category_id": 4, "id": 155355}, {"segmentation": [[362.1, 282.31, 361.39, 269.9, 366.71, 267.42, 364.23, 263.52, 363.52, 258.56, 365.29, 256.78, 369.19, 260.33, 370.61, 265.65, 375.93, 272.74, 376.99, 278.05, 378.76, 281.95, 386.56, 294.0, 392.59, 306.06, 395.42, 311.73, 394.36, 313.86, 392.23, 314.21, 399.32, 318.46, 404.64, 326.97, 404.29, 339.73, 398.61, 345.41, 390.11, 348.6, 385.85, 343.63, 386.21, 335.13, 384.79, 330.52, 381.6, 325.91, 378.05, 317.4, 374.51, 314.21, 369.9, 300.39, 366.36, 296.13, 363.17, 286.92, 364.58, 281.24]], "area": 1508.619950000001, "iscrowd": 0, "image_id": 19109, "bbox": [361.39, 256.78, 43.25, 91.82], "category_id": 4, "id": 155874}, {"segmentation": [[189.14, 180.64, 520.62, 218.85, 556.91, 224.58, 560.74, 228.4, 593.21, 266.61, 591.3, 279.98, 576.98, 282.85, 573.15, 289.54, 573.15, 295.27, 563.6, 301.95, 545.45, 301.95, 528.26, 308.64, 338.16, 275.21, 321.92, 269.47, 302.82, 271.39, 183.41, 251.32], [0.96, 154.84, 175.77, 179.68, 172.9, 239.86, 171.95, 246.55, 42.99, 232.22, 38.21, 226.49, 28.66, 223.62, 25.79, 229.35, 20.06, 232.22, 5.73, 226.49, 0.96, 224.58, 0.0, 155.8]], "area": 43199.8505, "iscrowd": 0, "image_id": 14473, "bbox": [0.0, 154.84, 593.21, 153.8], "category_id": 7, "id": 169920}, {"segmentation": [[565.18, 312.88, 202.47, 260.1, 193.83, 259.14, 186.15, 262.02, 186.15, 282.17, 206.3, 286.01, 419.32, 344.54, 506.64, 360.85, 567.09, 362.77, 566.13, 311.92], [633.3, 323.43, 640.0, 339.74, 639.06, 383.88, 601.64, 383.88, 577.65, 378.13, 578.61, 315.76]], "area": 20587.109299999996, "iscrowd": 0, "image_id": 14380, "bbox": [186.15, 259.14, 453.85, 124.74], "category_id": 7, "id": 173493}, {"segmentation": [[202.47, 218.9, 167.13, 244.97, 171.76, 276.83, 185.09, 309.85, 183.93, 316.22, 189.72, 320.28, 209.42, 331.29, 227.38, 339.4, 236.07, 332.45, 241.28, 332.45, 251.71, 336.5, 226.22, 374.74, 220.43, 396.17, 235.49, 404.28, 229.7, 415.29, 216.95, 417.61, 207.1, 415.29, 200.73, 402.55, 183.93, 412.97, 176.98, 410.08, 161.91, 412.97, 154.38, 422.24, 152.06, 433.83, 161.91, 444.26, 181.03, 474.38, 191.46, 479.02, 379.74, 479.02, 375.11, 429.77, 360.63, 361.99, 342.67, 328.97, 325.87, 316.8, 300.38, 306.95, 294.58, 300.0, 292.84, 295.37, 284.15, 296.53, 269.09, 282.04, 275.46, 273.35, 277.2, 266.98, 271.41, 259.45, 267.93, 237.43, 256.92, 223.53, 215.79, 220.63, 212.32, 217.16]], "area": 36192.03204999999, "iscrowd": 0, "image_id": 13659, "bbox": [152.06, 217.16, 227.68, 261.86], "category_id": 1, "id": 199407}, {"segmentation": [[421.75, 133.75, 424.99, 106.79, 408.81, 103.55, 406.65, 80.9, 413.12, 72.27, 420.67, 59.33, 428.22, 46.38, 431.46, 38.83, 439.01, 33.44, 442.25, 25.89, 450.88, 18.34, 450.88, 10.79, 457.35, 9.71, 460.58, 19.42, 467.06, 33.44, 472.45, 51.78, 488.63, 75.51, 491.87, 85.21, 484.31, 99.24, 475.69, 126.2, 475.69, 142.38, 474.61, 147.78, 468.13, 151.01, 440.09, 146.7, 427.15, 135.91]], "area": 7141.66215, "iscrowd": 0, "image_id": 13659, "bbox": [406.65, 9.71, 85.22, 141.3], "category_id": 1, "id": 201643}, {"segmentation": [[413.83, 129.27, 432.28, 139.65, 440.94, 146.58, 453.62, 147.73, 459.39, 151.19, 461.7, 154.65, 461.7, 158.69, 454.2, 159.84, 436.9, 155.8, 399.41, 137.92, 393.64, 150.61, 391.34, 157.53, 383.26, 169.64, 397.68, 179.45, 407.48, 183.49, 417.29, 185.79, 419.02, 188.1, 421.9, 192.71, 416.14, 261.35, 397.68, 263.65, 387.88, 265.38, 386.15, 259.62, 387.88, 248.08, 397.1, 209.44, 376.92, 198.48, 374.61, 207.71, 372.88, 214.05, 363.08, 214.05, 360.19, 211.17, 359.62, 206.56, 360.77, 197.33, 343.47, 198.48, 336.55, 195.6, 333.66, 193.29, 331.36, 189.25, 332.51, 180.03, 333.66, 169.64, 349.81, 133.89, 350.39, 125.24, 353.85, 116.01, 361.92, 112.55, 367.69, 111.97, 374.61, 111.97, 380.38, 114.28, 375.76, 110.82, 374.61, 106.2, 377.49, 101.59, 382.11, 98.13, 387.88, 96.4, 393.64, 95.82, 398.26, 94.09, 403.45, 94.09, 406.91, 95.82, 408.64, 98.71, 413.25, 108.51, 414.98, 115.43, 410.37, 126.39, 416.14, 130.43]], "area": 8584.56095, "iscrowd": 0, "image_id": 13659, "bbox": [331.36, 94.09, 130.34, 171.29], "category_id": 1, "id": 212964}, {"segmentation": [[547.08, 86.75, 557.13, 75.64, 568.77, 75.64, 583.05, 82.52, 601.03, 86.75, 628.54, 88.87, 638.06, 95.74, 638.59, 195.18, 626.95, 213.7, 617.96, 218.99, 626.95, 228.51, 625.37, 239.62, 594.16, 238.56, 605.8, 164.51, 596.8, 164.51, 585.17, 176.67, 576.17, 177.2, 567.71, 180.37, 565.07, 173.5, 568.77, 162.92, 577.23, 145.46, 577.76, 140.17, 549.73, 156.04, 520.64, 156.57, 519.05, 151.81, 520.11, 146.52, 530.16, 146.52, 546.02, 144.41, 570.36, 128.54, 572.47, 122.19, 570.36, 115.84, 561.36, 112.67, 553.96, 108.97, 551.31, 103.15, 548.67, 93.1]], "area": 9316.189800000004, "iscrowd": 0, "image_id": 13659, "bbox": [519.05, 75.64, 119.54, 163.98], "category_id": 1, "id": 213292}, {"segmentation": [[324.03, 289.23, 323.69, 275.87, 323.19, 275.54, 322.36, 274.37, 322.19, 274.21, 322.19, 274.04, 322.69, 273.54, 326.03, 271.53, 327.37, 271.2, 330.37, 274.04, 331.21, 277.54, 331.21, 279.38, 333.04, 285.39, 333.38, 286.39, 333.38, 288.23, 333.38, 298.58, 333.71, 300.41, 335.55, 308.26, 334.54, 313.6, 331.71, 313.1, 330.87, 312.1, 330.7, 309.09, 330.2, 307.92, 328.7, 304.58, 328.53, 300.75, 328.37, 298.24, 328.87, 296.57, 327.2, 298.07, 327.2, 298.58, 327.53, 304.08, 326.53, 304.58, 326.87, 306.75, 325.86, 312.1, 321.36, 311.26, 320.69, 311.09, 320.19, 309.59, 322.53, 304.42, 322.53, 303.58, 322.19, 300.91, 322.02, 298.41, 323.36, 293.07, 322.36, 289.06, 323.19, 288.56, 323.53, 288.06]], "area": 380.4250500000004, "iscrowd": 0, "image_id": 14473, "bbox": [320.19, 271.2, 15.36, 42.4], "category_id": 1, "id": 233526}, {"segmentation": [[277.52, 289.44, 280.82, 282.08, 283.1, 278.02, 283.61, 271.69, 288.93, 269.4, 292.73, 271.43, 292.73, 274.73, 294.0, 278.28, 296.03, 279.55, 297.55, 286.39, 295.52, 296.03, 293.75, 297.04, 292.48, 307.69, 284.87, 305.16, 285.13, 297.55, 283.61, 293.75, 282.84, 289.94, 280.82, 293.49, 277.01, 291.46, 277.27, 287.66]], "area": 447.80070000000023, "iscrowd": 0, "image_id": 14473, "bbox": [277.01, 269.4, 20.54, 38.29], "category_id": 1, "id": 235867}, {"segmentation": [[201.34, 266.15, 203.08, 258.58, 209.49, 260.91, 212.4, 266.15, 218.23, 277.8, 220.56, 289.45, 217.07, 295.28, 212.99, 294.69, 207.16, 292.95, 204.25, 285.37, 204.83, 277.8, 204.83, 277.22, 203.67, 276.64, 203.08, 274.89, 203.67, 273.14, 202.5, 269.06, 202.5, 266.73]], "area": 428.71489999999983, "iscrowd": 0, "image_id": 14473, "bbox": [201.34, 258.58, 19.22, 36.7], "category_id": 1, "id": 236039}, {"segmentation": [[157.01, 281.56, 159.33, 274.6, 159.33, 271.7, 162.81, 263.58, 166.87, 258.36, 169.19, 253.72, 172.67, 254.3, 172.67, 262.42, 169.19, 275.76, 169.19, 282.14, 165.13, 287.36, 164.55, 281.56, 165.13, 276.34, 162.81, 274.02, 161.07, 280.4, 159.33, 285.62, 155.85, 279.82]], "area": 253.14099999999945, "iscrowd": 0, "image_id": 14473, "bbox": [155.85, 253.72, 16.82, 33.64], "category_id": 1, "id": 237050}, {"segmentation": [[125.65, 276.81, 125.33, 267.05, 122.4, 262.49, 121.1, 258.91, 119.8, 255.98, 120.77, 252.4, 121.1, 249.15, 121.1, 246.87, 123.38, 245.57, 129.23, 246.22, 128.58, 246.55, 131.84, 249.47, 133.79, 252.4, 134.44, 257.28, 135.42, 261.52, 136.07, 266.4, 136.39, 274.21, 137.37, 278.11, 137.37, 280.72, 134.12, 280.06, 133.14, 278.11, 131.19, 267.05, 130.54, 276.81, 129.89, 278.76, 129.56, 279.09, 125.65, 278.44]], "area": 376.57574999999997, "iscrowd": 0, "image_id": 14473, "bbox": [119.8, 245.57, 17.57, 35.15], "category_id": 1, "id": 238488}, {"segmentation": [[78.11, 270.1, 80.19, 264.58, 80.19, 263.5, 77.84, 259.88, 80.92, 252.82, 84.9, 246.85, 86.71, 247.03, 89.06, 245.76, 92.14, 245.94, 93.41, 247.57, 93.59, 250.28, 94.13, 252.27, 94.49, 255.17, 91.96, 260.42, 93.04, 268.38, 91.41, 271.82, 89.79, 273.09, 89.42, 273.09, 88.16, 271.28, 88.16, 268.02, 87.25, 264.4, 85.8, 263.5, 83.45, 267.3, 82.0, 271.64]], "area": 291.97255, "iscrowd": 0, "image_id": 14473, "bbox": [77.84, 245.76, 16.65, 27.33], "category_id": 1, "id": 239121}, {"segmentation": [[29.69, 259.48, 29.69, 247.09, 27.33, 245.52, 25.96, 240.21, 26.35, 233.91, 26.94, 232.14, 28.91, 230.96, 29.1, 230.17, 29.89, 225.85, 31.27, 225.26, 34.22, 225.85, 34.81, 228.8, 34.81, 230.37, 37.56, 231.75, 39.14, 236.27, 39.14, 240.8, 38.35, 243.55, 36.77, 245.32, 37.76, 258.3, 39.14, 261.05, 35.2, 260.66, 34.02, 259.48, 33.43, 248.86, 33.04, 249.45, 32.84, 259.48]], "area": 307.9714500000003, "iscrowd": 0, "image_id": 14473, "bbox": [25.96, 225.26, 13.18, 35.79], "category_id": 1, "id": 239422}, {"segmentation": [[230.54, 9.22, 233.74, 8.21, 236.55, 8.76, 239.36, 8.99, 241.08, 9.22, 242.56, 9.61, 242.87, 9.93, 243.5, 11.18, 243.65, 11.57, 238.97, 11.96, 231.55, 12.19, 228.82, 12.03, 228.98, 10.55], [221.09, 11.88, 222.34, 10.79, 223.2, 10.94, 223.2, 12.35, 223.2, 12.89, 222.03, 13.05, 221.09, 12.74], [225.39, 11.18, 226.01, 9.54, 227.03, 8.68, 227.65, 8.52, 227.88, 9.69, 227.26, 12.43, 227.18, 12.89, 226.4, 13.05, 225.0, 12.5], [243.58, 9.38, 244.82, 9.15, 246.46, 9.54, 246.54, 11.1, 246.54, 11.88, 245.84, 11.49, 244.2, 9.38]], "area": 58.205500000000036, "iscrowd": 0, "image_id": 19042, "bbox": [221.09, 8.21, 25.45, 4.84], "category_id": 3, "id": 243269}, {"segmentation": [[465.7, 334.68, 471.76, 338.42, 481.56, 337.25, 487.4, 333.28, 490.67, 321.61, 487.86, 315.78, 484.36, 312.28, 480.86, 310.41, 480.86, 307.85, 472.93, 300.61, 473.16, 295.25, 471.53, 287.08, 465.7, 282.65, 455.9, 267.01, 451.7, 254.12, 447.03, 253.65, 450.76, 262.75, 445.63, 266.72, 437.23, 262.29, 433.73, 252.95, 430.93, 255.29, 436.29, 266.02, 444.23, 271.15, 441.19, 276.52, 454.5, 301.49, 460.1, 311.06, 460.8, 315.02, 462.2, 320.16, 463.6, 324.82, 465.7, 328.56, 466.16, 329.02]], "area": 1670.7341499999998, "iscrowd": 0, "image_id": 19109, "bbox": [430.93, 252.95, 59.74, 85.47], "category_id": 4, "id": 245859}, {"segmentation": [[423.46, 249.1, 435.08, 263.12, 437.89, 271.54, 440.69, 275.15, 456.32, 308.0, 461.53, 322.43, 461.53, 330.44, 455.92, 344.06, 449.51, 344.06, 440.69, 343.26, 433.08, 344.46, 427.07, 342.46, 421.86, 339.66, 417.05, 336.85, 408.24, 335.65, 406.23, 335.65, 405.03, 333.25, 405.03, 328.44, 405.03, 323.23, 399.42, 318.42, 395.42, 317.22, 395.02, 316.02, 395.42, 314.81, 395.82, 312.01, 395.82, 310.01, 392.21, 300.39, 382.99, 287.17, 378.59, 281.96, 391.41, 285.56, 394.21, 285.56, 401.83, 282.76, 402.23, 282.36, 405.83, 279.95, 408.64, 278.75, 412.25, 275.15, 411.04, 273.94, 407.44, 272.74, 406.64, 272.74, 405.83, 271.54, 406.23, 270.34, 411.04, 269.13, 413.45, 265.13, 407.04, 259.52, 406.23, 256.71, 407.04, 255.11, 411.84, 254.31, 412.65, 253.91, 415.05, 251.9, 417.45, 249.9, 419.46, 249.1]], "area": 4308.7966000000015, "iscrowd": 0, "image_id": 19109, "bbox": [378.59, 249.1, 82.94, 95.36], "category_id": 4, "id": 246641}, {"segmentation": [[312.92, 249.41, 309.74, 243.04, 314.74, 239.4, 317.47, 212.56, 318.38, 208.01, 319.29, 199.37, 319.75, 172.07, 323.84, 137.95, 328.85, 129.77, 337.94, 125.67, 339.31, 123.85, 340.22, 116.57, 348.41, 112.02, 356.14, 115.21, 362.96, 118.39, 358.87, 122.94, 355.23, 132.95, 349.32, 132.95, 348.86, 137.04, 353.41, 150.69, 353.41, 155.24, 357.96, 180.26, 358.87, 189.81, 351.59, 193.91, 351.59, 187.54, 345.68, 179.35, 342.95, 204.37, 340.22, 227.12, 338.4, 242.58, 348.86, 251.23, 342.95, 253.05, 337.03, 252.14, 328.39, 249.41, 322.02, 247.59]], "area": 3796.8146999999994, "iscrowd": 0, "image_id": 11197, "bbox": [309.74, 112.02, 53.22, 141.03], "category_id": 1, "id": 252476}, {"segmentation": [[18.44, 184.05, 21.57, 170.78, 20.79, 155.41, 17.4, 141.09, 21.57, 128.33, 24.43, 119.21, 29.64, 112.97, 36.41, 113.75, 39.01, 116.09, 40.58, 120.52, 39.8, 126.77, 35.63, 128.33, 38.75, 134.84, 41.36, 141.35, 42.14, 155.15, 41.1, 161.92, 44.48, 173.38, 42.14, 176.24, 43.18, 186.4, 19.22, 184.84]], "area": 1453.6855499999997, "iscrowd": 0, "image_id": 11197, "bbox": [17.4, 112.97, 27.08, 73.43], "category_id": 1, "id": 255782}, {"segmentation": [[584.1, 184.99, 583.02, 188.23, 583.5, 190.27, 583.02, 191.58, 576.9, 191.7, 574.86, 190.63, 578.34, 188.35, 579.06, 184.75, 579.78, 178.39, 577.86, 175.99, 575.82, 172.75, 581.82, 173.11, 581.82, 171.91, 574.5, 170.59, 574.62, 168.56, 575.7, 167.36, 577.38, 167.0, 577.62, 163.52, 571.14, 169.64, 568.87, 168.8, 567.91, 167.24, 570.79, 164.6, 571.14, 162.92, 569.35, 162.2, 569.11, 159.44, 574.02, 156.44, 575.34, 153.2, 573.42, 151.76, 573.18, 149.0, 573.66, 147.21, 575.34, 146.97, 576.66, 146.97, 578.22, 148.53, 579.42, 149.96, 580.74, 151.16, 581.22, 151.4, 582.3, 152.72, 584.58, 155.0, 584.94, 157.28, 588.42, 164.48, 590.7, 166.28, 590.7, 166.76, 588.54, 170.59, 586.98, 172.63]], "area": 444.30720000000065, "iscrowd": 0, "image_id": 11197, "bbox": [567.91, 146.97, 22.79, 44.73], "category_id": 1, "id": 256875}, {"segmentation": [[194.58, 115.77, 229.32, 156.11, 223.72, 185.25, 190.1, 223.35, 147.52, 217.75, 118.38, 183.01, 116.14, 147.15, 150.88, 115.77]], "area": 9075.6204, "iscrowd": 0, "image_id": 15440, "bbox": [116.14, 115.77, 113.18, 107.58], "category_id": 13, "id": 269186}, {"segmentation": [[252.18, 219.95, 252.18, 219.95, 276.71, 244.48, 276.71, 244.48, 306.62, 242.69, 329.95, 219.95, 329.95, 185.86, 329.95, 185.86, 308.41, 164.32, 308.41, 164.32, 308.41, 164.32, 272.52, 162.53, 250.39, 191.24, 253.38, 220.55]], "area": 5178.6560500000005, "iscrowd": 0, "image_id": 11122, "bbox": [250.39, 162.53, 79.56, 81.95], "category_id": 13, "id": 270172}, {"segmentation": [[1.44, 261.75, 296.27, 232.99, 480.0, 270.38, 480.0, 638.56, 4.31, 638.56]], "area": 185874.36909999998, "iscrowd": 0, "image_id": 14831, "bbox": [1.44, 232.99, 478.56, 405.57], "category_id": 17, "id": 273446}, {"segmentation": [[1.43, 0.2, 480.0, 0.2, 480.0, 269.38, 339.33, 239.31, 274.9, 235.01, 184.7, 246.47, 1.43, 259.35, 0.0, 260.79]], "area": 119214.07190000001, "iscrowd": 0, "image_id": 14831, "bbox": [0.0, 0.2, 480.0, 269.18], "category_id": 65, "id": 316818}, {"segmentation": [[59.33, 437.6, 90.61, 410.64, 114.34, 399.85, 135.91, 414.95, 167.19, 461.33, 173.66, 459.18, 188.76, 458.1, 222.2, 467.81, 226.52, 472.12, 210.34, 472.12, 87.37, 469.96, 64.72, 439.76]], "area": 5439.402099999999, "iscrowd": 0, "image_id": 14226, "bbox": [59.33, 399.85, 167.19, 72.27], "category_id": 62, "id": 377650}, {"segmentation": [[394.79, 30.95, 433.62, 16.93, 568.45, 22.32, 593.26, 50.37, 545.8, 271.49, 535.01, 216.48, 523.15, 176.57, 532.85, 145.29, 496.18, 119.4, 442.25, 95.67, 433.62, 79.49, 428.22, 66.55, 395.87, 35.27]], "area": 20048.027450000005, "iscrowd": 0, "image_id": 14226, "bbox": [394.79, 16.93, 198.47, 254.56], "category_id": 62, "id": 380478}, {"segmentation": [[66.88, 135.91, 49.62, 204.94, 35.6, 339.78, 24.81, 395.87, 58.25, 458.43, 307.42, 449.8, 331.15, 473.53, 365.66, 470.29, 393.71, 459.51, 379.69, 419.6, 377.53, 392.63, 405.57, 345.17, 443.33, 323.6, 441.17, 269.66, 462.74, 288.0, 461.66, 344.09, 450.88, 378.61, 475.69, 381.84, 482.16, 431.46, 519.91, 437.93, 560.9, 428.22, 584.63, 384.0, 584.63, 339.78, 581.39, 312.81, 588.94, 279.37, 606.2, 255.64, 601.89, 163.96, 455.19, 158.56, 405.57, 100.31, 339.78, 112.18, 305.26, 102.47, 273.98, 74.43, 119.73, 92.76, 92.76, 124.04]], "area": 172087.161, "iscrowd": 0, "image_id": 18837, "bbox": [24.81, 74.43, 581.39, 399.1], "category_id": 8, "id": 396804}, {"segmentation": [[179.85, 68.75, 187.37, 70.04, 187.8, 87.43, 179.64, 87.21]], "area": 140.4489500000003, "iscrowd": 0, "image_id": 11197, "bbox": [179.64, 68.75, 8.16, 18.68], "category_id": 10, "id": 404283}, {"segmentation": [[253.34, 24.64, 258.03, 24.64, 263.01, 24.64, 263.28, 21.88, 267.15, 19.67, 267.15, 46.46, 269.36, 50.6, 284.82, 50.6, 284.82, 57.51, 260.24, 58.33, 250.85, 56.95, 248.37, 52.81, 249.2, 29.06, 251.41, 27.13]], "area": 740.5159999999994, "iscrowd": 0, "image_id": 11197, "bbox": [248.37, 19.67, 36.45, 38.66], "category_id": 10, "id": 406334}, {"segmentation": [[220.58, 75.43, 220.89, 90.48, 229.99, 89.86, 227.17, 73.24, 219.95, 73.86]], "area": 132.28740000000005, "iscrowd": 0, "image_id": 11197, "bbox": [219.95, 73.24, 10.04, 17.24], "category_id": 10, "id": 407305}, {"segmentation": [[261.21, 490.66, 270.18, 476.08, 292.6, 457.03, 317.26, 247.38, 328.48, 228.33, 333.0, 215.99, 333.0, 158.82, 310.54, 152.09, 287.0, 113.98, 283.63, 97.16, 243.27, 87.07, 191.7, 103.89, 177.13, 122.94, 160.31, 149.85, 142.38, 162.18, 135.65, 190.21, 141.26, 227.2, 126.68, 249.63, 121.08, 281.02, 125.56, 305.68, 145.74, 322.5, 153.59, 340.43, 149.1, 470.48, 171.52, 483.93, 207.4, 492.9, 258.97, 494.02]], "area": 63020.718700000005, "iscrowd": 0, "image_id": 20107, "bbox": [121.08, 87.07, 211.92, 406.95], "category_id": 11, "id": 417811}, {"segmentation": [[372.97, 30.81, 410.81, 36.22, 434.59, 65.41, 436.76, 78.38, 438.92, 83.78, 441.08, 95.68, 440.0, 104.32, 500.54, 119.46, 535.14, 155.14, 531.89, 181.08, 530.81, 180.0, 541.62, 289.19, 541.62, 315.14, 448.65, 370.27, 441.08, 370.27, 434.59, 363.78, 430.27, 355.14, 428.11, 340.0, 422.7, 331.35, 407.57, 327.03, 387.03, 328.11, 380.54, 323.78, 385.95, 310.81, 404.32, 315.14, 418.38, 308.65, 411.89, 304.32, 379.46, 311.89, 378.38, 300.0, 382.7, 295.68, 404.32, 294.59, 415.14, 294.59, 417.3, 291.35, 417.3, 288.11, 409.73, 282.7, 397.84, 287.03, 393.51, 284.86, 380.54, 289.19, 383.78, 278.38, 391.35, 272.97, 397.84, 271.89, 401.08, 249.19, 354.59, 252.43, 287.57, 245.95, 251.89, 241.62, 235.68, 237.3, 228.11, 238.38, 252.97, 253.51, 251.89, 265.41, 249.73, 275.14, 246.49, 278.38, 247.57, 284.86, 245.41, 294.59, 230.27, 295.68, 220.54, 291.35, 214.05, 276.22, 208.65, 248.11, 208.65, 238.38, 244.32, 228.65, 263.78, 232.97, 274.59, 229.73, 286.49, 214.59, 292.97, 202.7, 314.59, 190.81, 315.68, 165.95, 320.0, 130.27, 321.08, 124.86, 325.41, 111.89, 318.92, 83.78, 332.97, 51.35, 347.03, 38.38, 369.73, 31.89]], "area": 55030.58024999999, "iscrowd": 0, "image_id": 14226, "bbox": [208.65, 30.81, 332.97, 339.46], "category_id": 1, "id": 476415}, {"segmentation": [[340.54, 50.27, 352.43, 36.22, 360.0, 22.16, 365.41, 14.59, 378.38, 15.68, 379.46, 29.73, 378.38, 43.78, 383.78, 48.11, 391.35, 53.51, 394.59, 65.41, 394.59, 76.22, 398.92, 79.46, 398.92, 85.95, 401.08, 89.19, 429.19, 117.3, 438.92, 124.86, 451.89, 122.7, 455.14, 129.19, 455.14, 144.32, 467.03, 158.38, 447.57, 158.38, 433.51, 138.92, 422.7, 132.43, 411.89, 121.62, 403.24, 105.41, 384.86, 100.0, 362.16, 102.16, 357.84, 114.05, 345.95, 109.73, 336.22, 93.51, 327.57, 76.22]], "area": 5614.067099999995, "iscrowd": 0, "image_id": 18837, "bbox": [327.57, 14.59, 139.46, 143.79], "category_id": 1, "id": 498085}, {"segmentation": [[337.74, 51.73, 336.45, 47.43, 342.04, 45.71, 337.31, 40.55, 331.72, 35.82, 329.57, 33.24, 329.57, 27.22, 325.27, 25.06, 313.66, 21.62, 308.93, 23.77, 309.36, 29.8, 299.89, 28.94, 296.88, 32.38, 299.89, 42.27, 304.19, 46.57, 306.78, 47.86, 309.36, 53.45, 312.37, 58.18, 316.67, 55.17, 316.67, 57.75, 309.79, 64.2, 305.05, 74.96, 300.75, 83.13, 297.74, 87.43, 295.59, 91.73, 294.73, 95.17, 294.3, 99.04, 299.89, 101.19, 305.48, 106.78, 307.64, 112.38, 309.79, 118.4, 326.13, 120.55, 339.46, 123.13, 341.61, 113.24, 342.04, 105.49, 342.47, 104.63, 341.61, 102.05, 336.45, 93.88, 331.72, 86.14, 328.28, 74.96, 330.43, 65.49, 334.73, 56.89, 336.45, 51.73]], "area": 2987.8379, "iscrowd": 0, "image_id": 18837, "bbox": [294.3, 21.62, 48.17, 101.51], "category_id": 1, "id": 500347}, {"segmentation": [[437.15, 332.59, 404.81, 336.94, 395.4, 366.63, 391.29, 378.69, 383.33, 395.35, 371.98, 407.9, 375.85, 424.79, 392.02, 453.03, 392.26, 462.68, 380.91, 476.68, 412.05, 469.44, 416.88, 466.79, 419.53, 480.0, 435.94, 479.82, 430.88, 444.34, 429.19, 432.03, 427.74, 411.28, 427.74, 405.72, 438.36, 401.38, 448.25, 360.35, 444.87, 327.04, 445.36, 331.39, 449.46, 310.87, 454.53, 306.53, 452.11, 299.53, 449.46, 286.74, 443.18, 286.74, 443.18, 319.32, 442.94, 330.42]], "area": 7237.5148500000005, "iscrowd": 0, "image_id": 18837, "bbox": [371.98, 286.74, 82.55, 193.26], "category_id": 1, "id": 518437}, {"segmentation": [[17.48, 262.56, 30.8, 262.77, 32.84, 262.15, 34.69, 254.16, 32.02, 249.66, 24.65, 245.77, 26.9, 243.1, 27.52, 239.62, 26.9, 235.32, 17.07, 235.11]], "area": 355.6931499999998, "iscrowd": 0, "image_id": 18837, "bbox": [17.07, 235.11, 17.62, 27.66], "category_id": 1, "id": 555506}, {"segmentation": [[224.7, 236.56, 397.64, 262.23, 396.74, 266.29, 400.8, 272.14, 387.29, 277.1, 383.23, 282.95, 385.93, 288.81, 405.75, 287.45, 413.41, 287.9, 416.11, 294.21, 382.78, 296.91, 376.93, 297.81, 376.93, 304.57, 379.18, 307.27, 391.34, 307.72, 411.16, 307.72, 414.76, 311.32, 408.45, 312.68, 390.89, 313.58, 382.78, 313.13, 380.53, 317.18, 381.88, 323.03, 396.29, 326.64, 418.81, 325.74, 420.16, 333.84, 424.22, 337.9, 429.17, 340.6, 432.32, 348.26, 433.68, 351.86, 434.58, 359.07, 426.02, 369.87, 257.58, 335.19, 255.77, 327.99, 238.21, 288.35, 247.67, 283.85, 249.02, 279.35, 249.02, 277.1, 253.52, 268.09, 252.62, 264.48, 250.37, 259.98, 250.37, 254.13, 247.67, 252.77, 235.96, 251.87, 235.51, 246.92, 231.9, 243.77, 224.7, 242.42, 221.54, 239.71, 223.35, 237.46]], "area": 15654.174449999991, "iscrowd": 0, "image_id": 14226, "bbox": [221.54, 236.56, 213.04, 133.31], "category_id": 73, "id": 1099277}, {"segmentation": [[56.09, 385.08, 86.29, 348.4, 130.52, 402.34, 199.55, 412.04, 181.21, 417.44, 171.51, 408.81, 158.56, 424.99, 161.8, 440.09, 172.58, 460.58, 114.34, 458.43, 88.45, 444.4, 89.53, 437.93, 53.93, 382.92]], "area": 6723.906750000004, "iscrowd": 0, "image_id": 13659, "bbox": [53.93, 348.4, 145.62, 112.18], "category_id": 73, "id": 1100204}, {"segmentation": [[189.84, 336.36, 127.28, 325.57, 97.08, 274.88, 119.73, 253.3, 155.33, 291.06, 199.55, 313.71]], "area": 3885.3440500000006, "iscrowd": 0, "image_id": 13659, "bbox": [97.08, 253.3, 102.47, 83.06], "category_id": 73, "id": 1103792}, {"segmentation": [[303.05, 129.01, 302.78, 125.03, 302.78, 121.53, 302.78, 119.63, 308.78, 119.19, 312.1, 119.35, 312.43, 119.84, 312.43, 120.55, 312.81, 121.1, 313.2, 121.81, 313.63, 122.3, 313.74, 122.3, 313.74, 122.35, 314.29, 122.95, 314.18, 123.88, 312.87, 123.94, 312.81, 124.15, 312.87, 125.41, 312.87, 125.95, 313.2, 126.5, 313.2, 127.64, 312.98, 128.19, 312.92, 128.63, 311.72, 128.63, 310.47, 128.68, 311.29, 129.17, 312.38, 129.61, 310.0, 131.03]], "area": 107.98460000000024, "iscrowd": 0, "image_id": 11197, "bbox": [302.78, 119.19, 11.51, 11.84], "category_id": 1, "id": 1237643}, {"segmentation": [[7.14, 238.42, 17.65, 233.16, 15.4, 228.66, 16.15, 223.4, 19.15, 219.64, 26.67, 219.64, 27.42, 223.4, 28.17, 228.66, 25.16, 235.42, 25.91, 239.17, 24.77, 247.77, 25.48, 261.62, 10.91, 260.91, 11.27, 254.16, 10.2, 245.28, 4.52, 243.15, 4.16, 241.02]], "area": 578.1933500000005, "iscrowd": 0, "image_id": 19109, "bbox": [4.16, 219.64, 24.01, 41.98], "category_id": 1, "id": 1252919}, {"segmentation": [[71.7, 282.24, 52.44, 279.73, 44.49, 283.08, 45.75, 260.47, 47.42, 255.45, 46.58, 248.33, 52.44, 240.38, 50.35, 228.24, 54.96, 224.05, 64.59, 225.31, 68.35, 228.65, 71.7, 239.12, 71.7, 242.05, 76.31, 252.1, 77.15, 272.19, 72.54, 280.57]], "area": 1453.2044000000003, "iscrowd": 0, "image_id": 19109, "bbox": [44.49, 224.05, 32.66, 59.03], "category_id": 1, "id": 1292605}, {"segmentation": [[348.93, 254.19, 350.1, 248.34, 351.27, 246.0, 353.37, 243.43, 355.01, 239.46, 355.01, 237.35, 355.94, 234.31, 356.88, 231.5, 357.81, 230.33, 361.09, 229.4, 363.66, 229.63, 367.87, 234.08, 368.34, 236.41, 368.81, 238.52, 368.1, 242.26, 368.57, 245.3, 370.68, 248.81, 369.74, 258.63, 369.97, 268.92, 367.87, 266.58, 367.4, 261.91, 367.4, 257.7, 366.23, 256.06, 363.19, 258.87, 360.85, 257.93, 356.64, 256.53, 351.73, 256.53, 347.29, 256.76]], "area": 461.8997500000001, "iscrowd": 0, "image_id": 19109, "bbox": [347.29, 229.4, 23.39, 39.52], "category_id": 1, "id": 1316008}, {"segmentation": [[168.93, 329.47, 193.52, 322.33, 232.0, 327.09, 235.17, 325.5, 243.9, 326.3, 244.69, 328.28, 284.75, 333.04, 289.51, 329.07, 314.5, 332.25, 318.07, 335.82, 319.66, 337.01, 329.18, 338.59, 345.05, 341.77, 344.65, 352.48, 346.63, 368.34, 347.82, 376.67, 348.22, 390.16, 346.24, 393.73, 335.53, 400.87, 331.56, 403.25, 315.3, 405.23, 311.73, 406.82, 309.74, 406.82, 304.19, 401.27, 247.07, 390.16, 222.87, 385.8, 216.92, 386.59, 213.35, 390.56, 202.25, 386.19, 201.06, 381.43, 191.54, 379.45, 173.69, 374.69, 162.58, 370.33, 165.75, 363.98, 166.15, 343.75, 168.53, 329.87]], "area": 11153.758949999998, "iscrowd": 0, "image_id": 15517, "bbox": [162.58, 322.33, 185.64, 84.49], "category_id": 6, "id": 1364776}, {"segmentation": [[0.67, 311.49, 0.27, 309.9, 20.15, 306.32, 84.15, 311.09, 88.53, 309.5, 98.07, 310.3, 103.63, 310.69, 104.43, 312.28, 106.81, 313.88, 125.7, 316.61, 127.87, 352.09, 115.08, 357.39, 102.29, 358.84, 93.36, 360.29, 83.7, 360.29, 75.98, 362.95, 68.98, 358.36, 65.84, 357.39, 27.95, 348.95, 27.95, 344.84, 27.23, 341.95, 22.4, 338.09, 21.19, 336.88, 21.67, 332.05, 18.54, 329.64, 14.43, 329.16, 7.19, 322.64, 2.37, 320.47, 0.0, 318.54]], "area": 5137.878850000002, "iscrowd": 0, "image_id": 15517, "bbox": [0.0, 306.32, 127.87, 56.63], "category_id": 6, "id": 1365665}, {"segmentation": [[260.49, 276.27, 298.15, 276.27, 315.71, 275.71, 317.68, 289.06, 319.23, 297.49, 319.09, 301.14, 314.87, 302.55, 282.97, 300.3, 242.22, 298.33, 230.7, 296.64, 230.56, 295.24, 231.4, 279.36, 235.06, 278.52]], "area": 2018.6980000000017, "iscrowd": 0, "image_id": 15517, "bbox": [230.56, 275.71, 88.67, 26.84], "category_id": 6, "id": 1365903}, {"segmentation": [[378.75, 308.16, 489.02, 314.05, 489.33, 314.05, 483.76, 293.3, 378.13, 292.37, 374.72, 308.16, 379.68, 308.78]], "area": 1998.5035000000007, "iscrowd": 0, "image_id": 15517, "bbox": [374.72, 292.37, 114.61, 21.68], "category_id": 6, "id": 1365946}, {"segmentation": [[362.48, 276.85, 416.21, 277.05, 414.9, 276.3, 430.1, 275.55, 429.54, 277.42, 445.67, 277.8, 447.92, 279.67, 447.17, 284.55, 432.91, 284.55, 432.54, 287.93, 411.9, 286.62, 408.9, 285.68, 406.46, 286.05, 404.39, 286.8, 393.13, 286.99, 390.32, 284.55, 376.62, 284.55, 376.62, 286.05, 375.12, 286.05, 374.56, 287.18, 367.62, 288.12, 363.3, 288.3, 361.24, 285.49]], "area": 796.1568499999997, "iscrowd": 0, "image_id": 15517, "bbox": [361.24, 275.55, 86.68, 12.75], "category_id": 6, "id": 1366003}, {"segmentation": [[435.5, 283.85, 481.68, 285.56, 481.96, 283.28, 492.79, 283.85, 494.79, 285.56, 500.77, 285.84, 507.61, 285.84, 511.89, 285.84, 515.88, 288.12, 515.88, 310.64, 511.89, 310.93, 506.76, 310.93, 504.48, 311.78, 501.91, 312.35, 498.21, 312.64, 495.64, 310.93, 491.94, 310.36, 488.8, 308.65, 487.09, 295.53, 482.53, 293.54, 466.0, 292.97, 459.73, 292.97, 456.88, 288.69, 452.89, 287.55, 449.18, 287.55, 446.62, 288.41, 441.77, 288.69, 433.5, 287.84, 433.22, 284.13]], "area": 1068.522, "iscrowd": 0, "image_id": 15517, "bbox": [433.22, 283.28, 82.66, 29.36], "category_id": 6, "id": 1366086}, {"segmentation": [[418.97, 289.04, 392.19, 287.74, 389.6, 285.15, 378.79, 285.15, 375.77, 288.61, 367.56, 289.04, 363.67, 288.61, 361.08, 285.58, 344.23, 285.15, 340.78, 287.74, 333.0, 289.04, 326.52, 289.04, 322.2, 297.68, 322.2, 300.27, 334.73, 304.59, 373.18, 306.32, 373.18, 298.54, 373.18, 292.5, 381.39, 292.06, 395.64, 291.63, 411.63, 289.9]], "area": 1033.8563499999989, "iscrowd": 0, "image_id": 15517, "bbox": [322.2, 285.15, 96.77, 21.17], "category_id": 6, "id": 1366254}, {"segmentation": [[89.0, 105.26, 89.28, 96.6, 89.28, 95.39, 94.86, 95.67, 95.05, 105.16, 89.38, 105.53]], "area": 56.959599999999966, "iscrowd": 0, "image_id": 11197, "bbox": [89.0, 95.39, 6.05, 10.14], "category_id": 10, "id": 1381133}, {"segmentation": [[49.94, 109.27, 46.12, 109.56, 43.99, 108.99, 43.43, 107.43, 44.13, 105.16, 44.84, 103.89, 44.84, 103.18, 42.72, 102.19, 43.57, 99.78, 44.98, 99.07, 43.43, 97.37, 42.86, 97.09, 42.43, 94.26, 46.97, 94.26, 50.37, 94.82]], "area": 97.67039999999994, "iscrowd": 0, "image_id": 11197, "bbox": [42.43, 94.26, 7.94, 15.3], "category_id": 10, "id": 1382049}, {"segmentation": [[7.27, 157.1, 12.22, 145.79, 12.6, 143.08, 15.03, 140.84, 17.55, 142.8, 18.02, 145.23, 21.29, 147.1, 21.48, 150.37, 21.48, 152.24, 24.19, 153.55, 24.28, 156.82, 24.19, 161.77, 23.44, 162.99, 23.16, 164.39, 20.92, 171.4, 16.8, 174.29, 12.69, 173.64, 10.26, 168.22, 10.17, 165.79, 5.96, 165.6, 4.56, 163.27, 5.12, 161.58]], "area": 400.6877999999999, "iscrowd": 0, "image_id": 11197, "bbox": [4.56, 140.84, 19.72, 33.45], "category_id": 27, "id": 1422630}, {"segmentation": [[115.44, 367.25, 109.22, 372.36, 106.78, 370.58, 91.9, 352.37, 90.12, 346.6, 89.45, 335.94, 89.45, 329.05, 93.45, 322.17, 102.34, 321.5, 111.44, 321.06, 118.77, 323.28, 118.77, 330.61, 118.55, 337.05, 116.99, 347.71, 116.99, 356.15, 116.99, 363.92]], "area": 1161.5609999999997, "iscrowd": 0, "image_id": 13659, "bbox": [89.45, 321.06, 29.32, 51.3], "category_id": 47, "id": 1507735}, {"segmentation": [[75.51, 474.61, 0.0, 474.61, 0.0, 357.03, 72.27, 398.02, 83.06, 408.81, 87.37, 415.28, 62.56, 440.09, 74.43, 473.53]], "area": 7101.842100000003, "iscrowd": 0, "image_id": 14226, "bbox": [0.0, 357.03, 87.37, 117.58], "category_id": 62, "id": 1579697}, {"segmentation": [[600.59, 225.25, 609.8, 155.19, 603.66, 131.16, 595.99, 105.08, 595.99, 80.02, 599.06, 62.63, 618.49, 36.55, 640.0, 27.86, 639.97, 142.92, 640.0, 231.39, 628.72, 224.74, 621.05, 220.14, 614.4, 218.6]], "area": 6957.147500000005, "iscrowd": 0, "image_id": 14226, "bbox": [595.99, 27.86, 44.01, 203.53], "category_id": 62, "id": 1582509}, {"segmentation": [[239.46, 295.55, 257.8, 332.22, 257.8, 332.22, 429.3, 366.74, 527.46, 319.28, 636.4, 351.64, 639.64, 470.29, 445.48, 470.29, 154.25, 352.72, 225.44, 296.63, 225.44, 296.63]], "area": 46650.441000000006, "iscrowd": 0, "image_id": 14226, "bbox": [154.25, 295.55, 485.39, 174.74], "category_id": 67, "id": 1619249}, {"segmentation": [[231.1, 79.09, 194.92, 79.7, 196.15, 115.88, 233.55, 115.06, 234.98, 78.88]], "area": 1398.5539, "iscrowd": 0, "image_id": 13659, "bbox": [194.92, 78.88, 40.06, 37.0], "category_id": 72, "id": 1625798}, {"segmentation": [[286.07, 230.44, 290.04, 225.06, 291.91, 223.19, 291.91, 220.62, 291.21, 217.11, 291.45, 214.77, 293.32, 212.67, 297.76, 212.9, 301.74, 221.08, 300.33, 226.0, 302.44, 228.57, 304.54, 241.2, 300.8, 259.91, 298.7, 266.92, 298.7, 269.73, 291.91, 268.09, 288.87, 268.56, 289.11, 259.91, 287.7, 257.57, 288.64, 250.79, 286.53, 237.46]], "area": 729.4708500000006, "iscrowd": 0, "image_id": 19109, "bbox": [286.07, 212.67, 18.47, 57.06], "category_id": 1, "id": 1680320}, {"segmentation": [[305.89, 193.68, 313.93, 204.19, 321.65, 216.86, 325.36, 228.92, 328.14, 237.26, 326.6, 240.04, 322.27, 240.04, 306.82, 240.97, 304.66, 239.12, 305.89, 198.63]], "area": 672.3748999999993, "iscrowd": 0, "image_id": 18837, "bbox": [304.66, 193.68, 23.48, 47.29], "category_id": 1, "id": 1682653}, {"segmentation": [[448.65, 265.68, 449.17, 262.28, 445.64, 254.84, 447.34, 253.4, 446.95, 244.25, 451.52, 241.9, 456.1, 245.43, 455.31, 252.88, 453.74, 254.58, 450.87, 253.14, 448.0, 252.09, 447.6, 256.54, 452.31, 261.37, 451.52, 263.33, 449.82, 265.68, 447.87, 266.07]], "area": 112.45500000000025, "iscrowd": 0, "image_id": 19109, "bbox": [445.64, 241.9, 10.46, 24.17], "category_id": 1, "id": 1691370}, {"segmentation": [[554.91, 244.23, 560.7, 239.34, 562.04, 237.56, 562.63, 235.63, 562.93, 231.92, 563.37, 230.29, 565.45, 228.36, 569.45, 227.77, 571.83, 230.14, 571.97, 233.55, 572.27, 237.41, 571.68, 238.45, 577.46, 242.16, 578.35, 246.76, 581.47, 252.84, 581.77, 254.03, 581.77, 254.47, 578.95, 251.8, 577.17, 250.76, 574.65, 250.32, 569.75, 251.65, 569.16, 254.77, 569.75, 256.1, 571.83, 259.07, 572.57, 259.66, 575.83, 259.66, 575.68, 261.29, 574.65, 263.07, 569.6, 262.78, 568.41, 260.85, 567.82, 258.33, 564.41, 258.03, 563.07, 258.18, 562.93, 259.51, 562.93, 259.96, 555.36, 255.95, 552.84, 252.54, 552.39, 245.12, 555.06, 244.83]], "area": 509.1810999999998, "iscrowd": 0, "image_id": 19109, "bbox": [552.39, 227.77, 29.38, 35.3], "category_id": 1, "id": 1692596}, {"segmentation": [[540.75, 237.85, 542.73, 235.08, 545.3, 233.69, 546.89, 233.29, 548.67, 233.29, 552.63, 234.68, 554.22, 235.67, 554.61, 236.86, 554.61, 239.04, 554.61, 240.42, 554.02, 242.2, 554.22, 243.39, 554.22, 243.79, 552.63, 244.58, 551.05, 246.36, 549.46, 246.76, 548.87, 246.56, 548.28, 247.35]], "area": 130.22425000000015, "iscrowd": 0, "image_id": 19109, "bbox": [540.75, 233.29, 13.86, 14.06], "category_id": 1, "id": 1699564}, {"segmentation": [[598.9, 271.39, 599.38, 265.98, 599.99, 264.18, 599.99, 261.41, 599.5, 260.69, 597.22, 260.33, 596.5, 259.61, 596.74, 257.81, 597.34, 251.79, 598.54, 243.62, 599.38, 239.41, 599.87, 235.08, 601.19, 231.84, 598.66, 231.12, 597.1, 229.55, 596.74, 226.19, 596.74, 224.74, 596.74, 223.3, 598.3, 221.86, 600.11, 221.74, 602.15, 222.34, 603.71, 223.06, 604.19, 224.5, 604.67, 226.07, 606.6, 227.63, 606.84, 229.07, 610.32, 232.44, 611.41, 234.6, 610.93, 238.09, 609.96, 238.69, 604.67, 239.29, 601.07, 240.61, 600.47, 243.14, 600.95, 260.57, 604.19, 262.01, 606.96, 262.25, 604.31, 263.34, 603.47, 263.94, 603.11, 265.62, 602.99, 267.66, 602.75, 270.91, 602.63, 273.8]], "area": 274.67395000000084, "iscrowd": 0, "image_id": 19109, "bbox": [596.5, 221.74, 14.91, 52.06], "category_id": 1, "id": 1704009}, {"segmentation": [[25.4, 261.91, 25.96, 242.3, 27.61, 233.73, 32.31, 224.9, 35.9, 223.52, 41.15, 224.62, 45.01, 227.93, 45.29, 230.97, 45.29, 236.5, 47.78, 245.34, 47.78, 247.54, 46.95, 250.03, 46.12, 258.32, 44.74, 258.59, 39.21, 256.94, 37.56, 258.87, 35.9, 261.63, 35.35, 263.01, 35.35, 264.67, 30.1, 263.29, 26.23, 262.46]], "area": 691.7104499999999, "iscrowd": 0, "image_id": 19109, "bbox": [25.4, 223.52, 22.38, 41.15], "category_id": 1, "id": 1705615}, {"segmentation": [[366.56, 230.1, 369.6, 227.31, 375.69, 228.07, 379.49, 235.68, 382.79, 235.42, 390.14, 244.3, 386.84, 250.13, 388.87, 266.36, 382.03, 274.22, 380.76, 281.58, 377.46, 271.69, 370.87, 269.15, 370.61, 250.13, 368.84, 244.04, 368.33, 236.18, 368.33, 236.18]], "area": 724.9064999999999, "iscrowd": 0, "image_id": 19109, "bbox": [366.56, 227.31, 23.58, 54.27], "category_id": 1, "id": 1726831}, {"segmentation": [[157.76, 232.42, 115.32, 232.73, 118.11, 214.45, 126.78, 206.71, 125.54, 187.5, 124.62, 181.62, 129.88, 173.87, 141.96, 172.01, 150.64, 175.73, 157.14, 186.57, 160.86, 205.78, 163.95, 210.43, 157.76, 231.18]], "area": 2118.3906999999995, "iscrowd": 0, "image_id": 18837, "bbox": [115.32, 172.01, 48.63, 60.72], "category_id": 1, "id": 1728910}, {"segmentation": [[8.34, 246.33, 12.48, 258.29, 9.26, 267.49, 18.0, 295.09, 17.08, 329.13, 16.62, 372.78, 2.36, 371.86, 0.0, 289.98, 0.0, 245.37, 0.06, 236.63, 2.82, 235.25]], "area": 1887.4875000000002, "iscrowd": 0, "image_id": 19109, "bbox": [0.0, 235.25, 18.0, 137.53], "category_id": 1, "id": 1757640}, {"segmentation": [[475.24, 250.58, 476.96, 246.99, 481.7, 247.14, 482.42, 250.87]], "area": 21.92360000000008, "iscrowd": 0, "image_id": 19109, "bbox": [475.24, 246.99, 7.18, 3.88], "category_id": 1, "id": 1758059}, {"segmentation": [[602.12, 254.64, 611.21, 256.59, 624.18, 281.24, 624.5, 301.67, 614.45, 294.21, 606.02, 289.35, 592.39, 289.67, 591.1, 278.32, 599.2, 265.67, 599.53, 255.94]], "area": 911.3174999999992, "iscrowd": 0, "image_id": 18837, "bbox": [591.1, 254.64, 33.4, 47.03], "category_id": 3, "id": 1770129}, {"segmentation": [[582.36, 309.67, 577.88, 305.88, 575.12, 298.64, 572.37, 290.71, 568.57, 284.16, 565.82, 280.03, 560.65, 271.75, 559.27, 269.0, 565.82, 263.14, 567.2, 261.41, 568.92, 256.93, 568.92, 252.11, 569.26, 250.73, 575.47, 250.04, 583.74, 255.55, 596.84, 278.3, 604.07, 290.37, 608.9, 297.26, 611.66, 304.5, 612.35, 311.04, 612.0, 317.59, 611.66, 318.97, 606.83, 316.21, 600.28, 313.11, 596.15, 312.08, 596.49, 323.45, 594.77, 325.18, 590.29, 325.18, 587.19, 325.18, 585.12, 322.07, 583.74, 317.94]], "area": 1958.5072499999997, "iscrowd": 0, "image_id": 19109, "bbox": [559.27, 250.04, 53.08, 75.14], "category_id": 4, "id": 1789837}, {"segmentation": [[592.04, 269.01, 603.21, 274.04, 612.43, 278.51, 612.43, 288.0, 610.19, 290.52, 613.27, 295.54, 619.97, 299.73, 620.25, 308.11, 614.66, 313.42, 613.27, 314.53, 610.19, 300.01, 600.7, 286.05, 594.56, 272.92]], "area": 385.6857499999986, "iscrowd": 0, "image_id": 19109, "bbox": [592.04, 269.01, 28.21, 45.52], "category_id": 4, "id": 1790834}, {"segmentation": [[632.67, 294.79, 637.8, 297.17, 639.45, 295.52, 639.08, 281.95, 629.0, 271.14, 624.42, 264.17, 617.82, 260.87, 601.32, 264.9, 600.4, 269.85, 615.8, 281.59]], "area": 678.7150000000017, "iscrowd": 0, "image_id": 19109, "bbox": [600.4, 260.87, 39.05, 36.3], "category_id": 4, "id": 1791159}, {"segmentation": [[324.69, 312.44, 334.91, 318.05, 336.23, 320.69, 338.54, 326.29, 340.52, 331.57, 340.52, 337.84, 339.53, 342.12, 336.56, 344.43, 333.26, 346.74, 329.31, 349.38, 322.38, 349.71, 318.42, 349.05, 316.77, 345.09, 316.11, 339.81, 315.79, 335.86, 315.79, 332.56, 315.13, 331.57, 313.81, 327.28, 318.09, 325.3, 319.41, 323.98, 320.4, 319.37, 319.08, 316.4, 315.79, 311.12, 312.49, 309.14, 308.2, 305.19, 303.58, 301.89, 296.33, 296.61, 289.07, 284.74, 283.79, 270.89, 290.06, 266.93, 286.43, 258.35, 285.11, 252.42, 290.06, 250.77, 291.71, 253.08, 291.71, 256.04, 291.71, 259.67, 293.69, 266.6, 297.32, 269.57, 300.28, 271.55, 303.91, 273.85, 304.24, 279.13, 304.9, 281.77, 306.88, 283.09, 310.84, 286.72, 310.84, 287.71, 312.82, 290.67, 316.77, 294.3, 320.07, 298.92, 322.05, 301.56, 324.03, 305.52, 325.02, 307.49, 326.01, 309.14, 326.01, 309.8]], "area": 1589.229399999998, "iscrowd": 0, "image_id": 19109, "bbox": [283.79, 250.77, 56.73, 98.94], "category_id": 4, "id": 1791194}, {"segmentation": [[238.53, 184.3, 238.53, 184.3, 261.63, 189.91, 262.25, 250.78, 257.26, 250.78, 255.39, 260.76, 197.33, 259.2, 192.34, 256.4, 194.21, 218.63, 226.36, 183.67, 238.84, 182.74, 238.84, 182.74]], "area": 4511.170749999998, "iscrowd": 0, "image_id": 15440, "bbox": [192.34, 182.74, 69.91, 78.02], "category_id": 6, "id": 1794201}, {"segmentation": [[142.33, 253.24, 120.77, 253.54, 114.19, 243.96, 113.59, 192.16, 118.68, 191.86, 144.73, 217.31]], "area": 1488.5892499999998, "iscrowd": 0, "image_id": 15440, "bbox": [113.59, 191.86, 31.14, 61.68], "category_id": 6, "id": 1794431}, {"segmentation": [[116.14, 280.01, 116.32, 267.24, 128.04, 265.84, 128.04, 265.49, 133.11, 264.79, 134.86, 265.84, 135.39, 265.84, 136.44, 264.79, 142.56, 264.79, 142.73, 265.14, 143.61, 265.14, 144.13, 264.09, 149.38, 263.74, 151.66, 265.31, 159.36, 264.09, 165.13, 263.04, 169.68, 264.79, 171.25, 267.76, 172.13, 268.81, 171.25, 269.69, 170.03, 269.34, 170.03, 274.41, 161.28, 277.56, 146.76, 279.14, 145.88, 281.59, 142.91, 281.94, 142.56, 282.64, 135.04, 282.46, 126.29, 282.11]], "area": 811.9457999999998, "iscrowd": 0, "image_id": 15517, "bbox": [116.14, 263.04, 55.99, 19.6], "category_id": 6, "id": 1794468}, {"segmentation": [[403.06, 276.34, 402.54, 263.45, 338.57, 263.45, 338.57, 280.47, 351.47, 279.95, 355.08, 282.53, 358.18, 282.53, 361.27, 280.47, 362.3, 276.86]], "area": 943.6624500000008, "iscrowd": 0, "image_id": 15517, "bbox": [338.57, 263.45, 64.49, 19.08], "category_id": 6, "id": 1794789}, {"segmentation": [[273.56, 262.83, 273.71, 276.16, 336.23, 275.12, 336.52, 271.57, 337.56, 269.94, 337.56, 269.64, 336.23, 268.76, 336.23, 265.06, 273.88, 263.0]], "area": 729.8530000000011, "iscrowd": 0, "image_id": 15517, "bbox": [273.56, 262.83, 64.0, 13.33], "category_id": 6, "id": 1794891}, {"segmentation": [[519.42, 302.18, 519.42, 290.61, 516.37, 285.73, 502.97, 285.73, 493.83, 285.13, 489.56, 282.08, 492.0, 276.6, 492.61, 272.94, 527.95, 275.38, 535.26, 281.47, 538.3, 288.78, 536.48, 302.79, 518.81, 305.23]], "area": 812.3689500000012, "iscrowd": 0, "image_id": 15517, "bbox": [489.56, 272.94, 48.74, 32.29], "category_id": 6, "id": 1794936}, {"segmentation": [[232.0, 297.54, 190.2, 292.36, 190.57, 286.44, 173.56, 283.86, 163.57, 293.1, 145.82, 288.66, 147.66, 276.83, 182.06, 275.72, 236.8, 274.98, 236.8, 277.94, 230.15, 279.79]], "area": 1340.9209000000003, "iscrowd": 0, "image_id": 15517, "bbox": [145.82, 274.98, 90.98, 22.56], "category_id": 6, "id": 1795152}, {"segmentation": [[312.15, 194.95, 308.63, 199.12, 304.72, 198.6, 299.12, 193.65, 290.39, 190.39, 289.61, 165.63, 332.61, 170.71, 333.26, 176.83, 350.6, 178.66, 355.16, 190.13, 355.42, 199.77, 352.68, 199.25, 350.34, 202.9, 344.99, 203.29, 341.73, 200.29, 339.65, 197.82]], "area": 1642.8896500000003, "iscrowd": 0, "image_id": 11615, "bbox": [289.61, 165.63, 65.81, 37.66], "category_id": 8, "id": 1799592}, {"segmentation": [[222.88, 410.38, 226.87, 398.83, 234.43, 393.06, 240.2, 386.39, 245.98, 381.06, 256.64, 389.5, 262.86, 397.94, 261.52, 408.61, 261.52, 415.71, 269.96, 427.0, 245.09, 425.49, 234.43, 422.82, 225.1, 411.71]], "area": 1281.5749999999998, "iscrowd": 0, "image_id": 15751, "bbox": [222.88, 381.06, 47.08, 45.94], "category_id": 16, "id": 1814016}, {"segmentation": [[131.0, 328.79, 160.49, 251.58, 186.52, 185.65, 185.65, 162.23, 173.51, 160.49, 163.1, 169.17, 125.79, 184.78, 80.68, 170.04, 86.75, 161.36, 117.98, 144.01, 169.17, 128.39, 188.25, 110.18, 194.33, 94.56, 188.25, 69.4, 191.72, 44.24, 212.55, 49.45, 217.75, 73.74, 241.17, 58.99, 235.1, 40.77, 253.32, 34.7, 268.07, 60.73, 270.67, 74.61, 275.88, 83.28, 275.88, 90.22, 296.7, 117.98, 302.77, 124.92, 303.64, 133.6, 304.5, 143.14, 317.52, 143.14, 340.94, 152.69, 360.03, 170.9, 360.03, 177.84, 340.94, 185.65, 307.97, 175.24, 288.89, 164.83, 281.95, 161.36, 289.76, 179.58, 297.56, 195.19, 294.09, 202.14, 287.15, 220.35, 269.8, 223.82, 253.32, 229.03, 236.84, 235.1, 233.37, 243.78, 217.75, 294.09, 204.74, 334.0]], "area": 30882.77995, "iscrowd": 0, "image_id": 17031, "bbox": [80.68, 34.7, 279.35, 299.3], "category_id": 25, "id": 1823362}, {"segmentation": [[371.32, 254.35, 373.28, 254.95, 372.98, 257.51, 375.99, 257.51, 376.59, 255.25, 381.11, 256.0, 379.61, 264.29, 370.12, 263.54]], "area": 77.43375000000034, "iscrowd": 0, "image_id": 19109, "bbox": [370.12, 254.35, 10.99, 9.94], "category_id": 31, "id": 1838054}, {"segmentation": [[314.1, 294.94, 320.01, 294.7, 323.08, 290.69, 325.68, 290.45, 326.86, 292.1, 324.73, 295.41, 332.05, 298.24, 331.58, 300.13, 329.93, 301.55, 334.18, 305.8, 334.42, 308.4, 330.17, 312.18, 327.09, 310.05, 320.95, 310.05, 314.34, 303.44, 311.98, 298.48, 313.63, 294.23]], "area": 276.5560500000005, "iscrowd": 0, "image_id": 14226, "bbox": [311.98, 290.45, 22.44, 21.73], "category_id": 53, "id": 1906808}, {"segmentation": [[310.5, 220.77, 326.47, 217.81, 331.79, 220.77, 319.96, 254.47, 314.05, 281.67, 313.46, 305.91, 307.55, 310.64, 302.23, 302.95, 304.0, 276.94, 291.58, 273.39, 282.71, 268.66, 282.12, 259.79, 288.63, 252.1]], "area": 1981.2406999999996, "iscrowd": 0, "image_id": 13659, "bbox": [282.12, 217.81, 49.67, 92.83], "category_id": 62, "id": 1934026}, {"segmentation": [[567.8, 229.98, 575.32, 233.56, 582.12, 261.12, 586.06, 281.89, 587.49, 284.75, 589.64, 279.03, 587.49, 263.99, 582.84, 247.52, 578.9, 232.48, 591.07, 232.48, 593.58, 223.89, 601.45, 204.2, 607.54, 173.05, 610.76, 164.81, 603.24, 160.52, 595.37, 165.53, 589.64, 172.33, 582.12, 175.55, 574.24, 178.78, 572.81, 178.78, 572.09, 184.15, 572.81, 190.59, 572.45, 191.31, 573.53, 193.81, 575.32, 194.53, 577.11, 195.6, 577.82, 200.26, 578.9, 207.78, 578.9, 213.86, 573.17, 216.12, 567.8, 221.84, 567.44, 228.65]], "area": 1927.1629000000012, "iscrowd": 0, "image_id": 13659, "bbox": [567.44, 160.52, 43.32, 124.23], "category_id": 62, "id": 1941594}, {"segmentation": [[492.69, 78.86, 494.08, 75.24, 498.55, 76.35, 500.5, 78.86, 504.41, 79.7, 508.87, 81.1, 512.78, 83.61, 515.57, 88.07, 517.52, 92.53, 518.63, 96.16, 517.24, 101.74, 515.84, 108.16, 515.84, 114.01, 517.24, 119.59, 517.8, 125.73, 517.52, 132.98, 517.24, 137.45, 516.68, 142.75, 515.57, 149.44, 515.84, 153.07, 515.57, 154.46, 500.5, 152.23, 499.66, 148.05, 499.39, 141.35, 496.6, 135.22, 492.41, 132.15, 488.51, 127.96, 485.99, 123.5, 484.6, 119.59, 482.93, 113.18, 480.14, 109.83]], "area": 1996.0132, "iscrowd": 0, "image_id": 13659, "bbox": [480.14, 75.24, 38.49, 79.22], "category_id": 1, "id": 2008612}, {"segmentation": [[81.82, 227.99, 80.11, 200.55, 78.39, 182.84, 75.54, 177.7, 71.53, 174.84, 58.96, 184.55, 56.11, 195.41, 57.25, 210.84, 55.53, 223.41, 69.82, 230.27, 73.25, 232.56]], "area": 1149.92285, "iscrowd": 0, "image_id": 19109, "bbox": [55.53, 174.84, 26.29, 57.72], "category_id": 1, "id": 2025750}, {"segmentation": [[474.84, 304.99, 472.79, 300.03, 472.79, 287.74, 469.51, 282.41, 457.22, 269.3, 457.22, 265.2, 460.91, 258.65, 472.79, 261.51, 480.58, 261.51, 485.08, 254.55, 496.15, 255.78, 496.96, 251.68, 503.93, 260.28, 513.35, 280.77, 514.58, 295.52, 513.35, 299.62, 526.06, 315.19, 527.28, 323.38, 526.47, 329.12, 518.27, 334.45, 512.94, 336.08, 504.75, 336.9, 501.88, 335.27, 496.96, 332.81, 494.1, 327.89, 489.18, 320.51, 489.18, 315.6, 488.77, 313.96, 482.62, 310.68]], "area": 3163.526349999999, "iscrowd": 0, "image_id": 19109, "bbox": [457.22, 251.68, 70.06, 85.22], "category_id": 4, "id": 2048655}, {"segmentation": [[251.53, 270.25, 186.01, 270.61, 182.43, 272.76, 242.94, 273.48, 242.58, 278.13, 254.03, 276.7]], "area": 228.70974999999976, "iscrowd": 0, "image_id": 15517, "bbox": [182.43, 270.25, 71.6, 7.88], "category_id": 6, "id": 2050429}, {"segmentation": [[558.97, 107.31, 558.56, 116.6, 571.73, 116.73, 571.73, 106.89, 559.25, 106.89]], "area": 126.6013000000003, "iscrowd": 0, "image_id": 11197, "bbox": [558.56, 106.89, 13.17, 9.84], "category_id": 10, "id": 2058468}, {"segmentation": [[578.63, 152.53, 581.36, 152.35, 584.1, 153.08, 585.47, 153.72, 589.12, 154.45, 592.04, 156.0, 593.95, 157.82, 595.23, 161.29, 593.86, 166.03, 590.85, 166.86, 589.03, 165.12, 587.11, 161.02, 584.65, 156.46, 583.01, 154.17, 581.73, 153.17, 578.72, 153.08]], "area": 92.62910000000045, "iscrowd": 0, "image_id": 11197, "bbox": [578.63, 152.35, 16.6, 14.51], "category_id": 27, "id": 2073987}, {"segmentation": [[300.58, 190.41, 304.62, 207.9, 302.47, 222.96, 303.54, 229.42, 304.62, 236.68, 307.58, 239.64, 308.65, 245.56, 314.3, 239.64, 316.99, 214.08, 320.22, 182.07, 319.68, 170.24, 319.68, 161.63, 319.41, 141.19, 316.45, 130.43, 309.73, 128.81, 307.85, 157.86, 307.85, 174.54, 306.77, 180.19, 300.58, 183.42]], "area": 1424.9449000000006, "iscrowd": 0, "image_id": 11197, "bbox": [300.58, 128.81, 19.64, 116.75], "category_id": 1, "id": 2157164}, {"segmentation": [[237.42, 305.81, 251.61, 343.23, 258.06, 369.03, 264.52, 392.26, 256.77, 412.9, 255.48, 430.97, 256.77, 452.9, 256.77, 465.81, 263.23, 481.29, 267.1, 486.45, 276.13, 489.03, 280.0, 499.35, 283.87, 507.1, 280.0, 510.97, 277.42, 514.84, 273.55, 516.13, 267.1, 518.71, 260.65, 521.29, 261.94, 526.45, 265.81, 534.19, 281.29, 541.94, 286.45, 536.77, 287.74, 531.61, 295.48, 521.29, 304.52, 509.68, 312.26, 510.97, 326.45, 507.1, 335.48, 494.19, 335.48, 486.45, 339.35, 473.55, 350.97, 464.52, 350.97, 450.32, 349.68, 437.42, 347.1, 428.39, 350.97, 423.23, 362.58, 425.81, 366.45, 425.81, 370.32, 421.94, 369.03, 410.32, 362.58, 405.16, 353.55, 397.42, 352.26, 393.55, 345.81, 369.03, 344.52, 358.71, 341.94, 343.23, 338.06, 325.16, 331.61, 308.39, 331.61, 287.74, 332.9, 278.71, 335.48, 268.39, 338.06, 252.9, 340.65, 230.97, 341.94, 221.94, 347.1, 218.06, 349.68, 209.03, 350.97, 206.45, 350.97, 196.13, 361.29, 192.26, 378.06, 200.0, 380.65, 201.29, 387.1, 206.45, 389.68, 206.45, 389.68, 206.45, 390.97, 206.45, 401.29, 190.97, 405.16, 184.52, 405.16, 184.52, 405.16, 184.52, 405.16, 175.48, 405.16, 175.48, 402.58, 172.9, 398.71, 166.45, 393.55, 160.0, 384.52, 156.13, 381.94, 154.84, 369.03, 138.06, 367.74, 132.9, 361.29, 113.55, 361.29, 113.55, 339.35, 107.1, 325.16, 105.81, 320.0, 108.39, 313.55, 122.58, 312.26, 130.32, 300.65, 139.35, 291.61, 141.94, 281.29, 145.81, 278.71, 150.97, 289.03, 174.19, 289.03, 174.19, 291.61, 167.74, 290.32, 176.77, 281.29, 183.23, 278.71, 185.81, 268.39, 190.97, 252.9, 200.0, 243.87, 211.61, 242.58, 212.9, 237.42, 221.94, 232.26, 233.55, 229.68, 243.87, 225.81, 245.16, 194.84, 245.16, 193.55, 245.16, 181.94, 242.58, 176.77, 242.58, 174.19, 242.58, 170.32, 237.42, 161.29, 232.26, 154.84, 237.42, 154.84, 243.87, 154.84, 251.61, 158.71, 256.77, 162.58, 263.23, 162.58, 264.52, 175.48, 270.97, 187.1, 278.71, 194.84, 282.58, 205.16, 289.03, 218.06, 294.19, 234.84, 301.94]], "area": 40990.855599999995, "iscrowd": 0, "image_id": 17029, "bbox": [154.84, 105.81, 250.32, 436.13], "category_id": 18, "id": 12032}, {"segmentation": [[276.13, 29.12, 332.22, 52.85, 365.66, 78.74, 381.84, 93.84, 420.67, 99.24, 468.13, 80.9, 468.13, 118.65, 464.9, 144.54, 484.31, 173.66, 468.13, 199.55, 443.33, 227.6, 439.01, 243.78, 426.07, 285.84, 399.1, 318.2, 416.36, 415.28, 423.91, 432.54, 413.12, 454.11, 385.08, 439.01, 374.29, 431.46, 346.25, 443.33, 330.07, 434.7, 321.44, 407.73, 305.26, 373.21, 276.13, 326.83, 268.58, 286.92, 251.33, 254.56, 229.75, 239.46, 239.46, 266.43, 221.12, 281.53, 196.31, 286.92, 156.4, 307.42, 83.06, 304.18, 32.36, 254.56, 35.6, 184.45, 50.7, 114.34, 96.0, 73.35, 146.7, 30.2, 215.73, 20.49, 284.76, 29.12]], "area": 113647.79000000001, "iscrowd": 0, "image_id": 15497, "bbox": [32.36, 20.49, 451.95, 433.62], "category_id": 17, "id": 51186}, {"segmentation": [[155.06, 305.62, 184.27, 348.31, 201.12, 359.55, 228.09, 369.66, 264.04, 313.48, 270.79, 294.38, 282.02, 306.74, 276.4, 352.81, 237.08, 389.89, 247.19, 500.0, 194.38, 497.75, 215.73, 455.06, 195.51, 383.15, 153.93, 342.7, 142.7, 319.1]], "area": 8496.704749999995, "iscrowd": 0, "image_id": 19924, "bbox": [142.7, 294.38, 139.32, 205.62], "category_id": 32, "id": 295058}, {"segmentation": [[182.65, 297.71, 211.42, 314.97, 238.74, 283.33, 241.62, 316.4, 230.11, 336.54, 235.87, 424.27, 228.67, 510.56, 182.65, 494.74, 201.35, 444.4, 201.35, 384.0, 220.04, 342.29, 215.73, 327.91, 179.78, 309.21, 178.34, 300.58, 182.65, 296.27]], "area": 6695.2979, "iscrowd": 0, "image_id": 20333, "bbox": [178.34, 283.33, 63.28, 227.23], "category_id": 32, "id": 295083}, {"segmentation": [[242.61, 301.14, 262.6, 301.91, 277.98, 312.68, 279.52, 348.82, 300.28, 394.19, 327.96, 450.33, 341.04, 518.49, 341.04, 552.05, 345.65, 637.9, 267.98, 640.0, 263.37, 554.08, 256.45, 457.71, 244.91, 405.95, 239.53, 386.72, 242.61, 347.01, 224.15, 321.63]], "area": 22546.875699999997, "iscrowd": 0, "image_id": 16598, "bbox": [224.15, 301.14, 121.5, 338.86], "category_id": 32, "id": 295130}, {"segmentation": [[347.84, 175.94, 352.46, 193.76, 361.04, 215.54, 348.5, 235.34, 335.96, 257.78, 318.14, 286.82, 306.26, 311.9, 293.06, 338.96, 276.56, 377.24, 268.64, 344.24, 286.46, 291.34, 318.14, 217.15, 325.4, 194.71, 331.34, 181.51]], "area": 5500.258500000002, "iscrowd": 0, "image_id": 18770, "bbox": [268.64, 175.94, 92.4, 201.3], "category_id": 32, "id": 295246}, {"segmentation": [[208.64, 206.36, 201.45, 202.76, 195.45, 207.56, 201.45, 219.55, 207.45, 227.95, 195.45, 307.09, 244.62, 424.6, 256.61, 359.85, 224.23, 229.14, 215.84, 200.37, 202.65, 197.97]], "area": 6649.593500000003, "iscrowd": 0, "image_id": 11051, "bbox": [195.45, 197.97, 61.16, 226.63], "category_id": 32, "id": 298197}, {"segmentation": [[404.36, 150.52, 373.38, 150.52, 347.36, 151.34, 341.17, 156.3, 340.75, 188.51, 342.41, 267.4, 353.14, 264.51, 356.45, 254.6, 372.56, 248.4, 412.62, 250.05, 412.62, 247.16, 396.1, 245.1, 379.16, 242.62, 370.49, 236.84, 368.43, 228.99, 373.38, 221.97, 395.27, 218.25, 412.62, 220.73, 413.03, 192.23, 413.86, 159.19, 408.9, 152.17, 404.45, 150.67]], "area": 6270.100049999997, "iscrowd": 0, "image_id": 16598, "bbox": [340.75, 150.52, 73.11, 116.88], "category_id": 77, "id": 325853}, {"segmentation": [[378.25, 28.76, 404.13, 25.89, 440.09, 31.64, 497.62, 58.97, 522.07, 58.97, 547.96, 57.53, 555.15, 80.54, 563.78, 106.43, 569.53, 112.18, 565.21, 138.07, 543.64, 148.13, 501.93, 149.57, 480.36, 149.57, 444.4, 178.34, 414.2, 172.58, 409.89, 158.2, 378.25, 151.01, 396.94, 128.0, 417.08, 89.17, 376.81, 77.66, 339.42, 73.35, 379.69, 30.2], [113.62, 87.73, 80.54, 96.36, 64.72, 104.99, 60.4, 123.69, 56.09, 138.07, 56.09, 148.13, 76.22, 159.64, 97.8, 162.52, 110.74, 172.58, 143.82, 168.27, 165.39, 168.27, 171.15, 151.01]], "area": 26342.933849999998, "iscrowd": 0, "image_id": 17029, "bbox": [56.09, 25.89, 513.44, 152.45], "category_id": 3, "id": 359663}, {"segmentation": [[156.28, 250.48, 154.09, 249.02, 157.01, 245.36, 160.3, 241.34, 172.0, 243.53, 173.09, 249.38, 177.84, 253.4, 175.65, 255.59, 168.71, 256.32, 170.9, 261.07, 168.34, 263.63, 179.3, 273.13, 181.5, 288.84, 182.23, 308.94, 180.76, 312.23, 176.75, 314.42, 177.48, 318.81, 176.38, 319.9, 178.57, 322.82, 178.94, 326.84, 193.19, 363.02, 183.69, 369.59, 182.23, 366.31, 180.76, 353.52, 167.61, 350.59, 170.17, 368.5, 155.55, 369.96, 146.42, 367.77, 146.42, 365.94, 155.92, 364.84, 161.4, 360.09, 159.57, 352.06, 157.01, 350.59, 145.69, 349.13, 143.13, 346.94, 152.26, 274.23, 158.11, 265.82, 152.99, 262.17, 152.99, 256.69, 156.28, 252.3, 156.28, 250.84]], "area": 3545.2962500000003, "iscrowd": 0, "image_id": 12280, "bbox": [143.13, 241.34, 50.06, 128.62], "category_id": 1, "id": 426225}, {"segmentation": [[8.67, 625.91, 24.56, 514.67, 20.23, 406.32, 28.89, 323.97, 95.35, 267.63, 111.24, 191.06, 138.69, 102.93, 173.36, 23.48, 257.16, 17.7, 290.38, 42.26, 294.72, 89.93, 313.5, 157.83, 319.28, 253.18, 314.94, 305.19, 348.17, 282.08, 385.73, 227.18, 440.63, 228.62, 459.41, 295.08, 466.64, 362.98, 478.0, 404.88, 478.0, 543.57, 401.63, 520.45, 397.29, 611.47, 405.96, 624.47]], "area": 197548.36384999997, "iscrowd": 0, "image_id": 16598, "bbox": [8.67, 17.7, 469.33, 608.21], "category_id": 1, "id": 430275}, {"segmentation": [[86.49, 530.45, 87.93, 554.95, 77.84, 552.07, 76.4, 533.33, 70.63, 547.75, 60.54, 543.42, 51.89, 517.48, 83.6, 481.44, 92.25, 386.31, 82.16, 363.24, 103.78, 347.39, 118.2, 285.41, 128.29, 266.67, 142.7, 256.58, 131.17, 236.4, 121.08, 229.19, 100.9, 210.45, 98.02, 196.04, 110.99, 161.44, 121.08, 129.73, 142.7, 113.87, 164.32, 106.67, 198.92, 110.99, 232.07, 128.29, 243.6, 144.14, 265.23, 168.65, 265.23, 183.06, 255.14, 194.59, 256.58, 197.48, 253.69, 204.68, 253.69, 219.1, 255.14, 227.75, 276.76, 239.28, 292.61, 246.49, 320.0, 262.34, 330.09, 266.67, 347.39, 275.32, 366.13, 327.21, 367.57, 345.95, 367.57, 364.68, 357.48, 376.22, 343.06, 381.98, 348.83, 407.93, 351.71, 428.11, 344.5, 439.64, 338.74, 445.41, 338.74, 459.82, 340.18, 480.0, 341.62, 491.53, 340.18, 500.18, 341.62, 513.15, 347.39, 527.57, 332.97, 546.31, 307.03, 565.05, 269.55, 566.49, 252.25, 550.63, 258.02, 534.77, 272.43, 520.36, 269.55, 510.27, 273.87, 495.86, 272.43, 477.12, 262.34, 471.35, 247.93, 455.5, 233.51, 458.38, 233.51, 461.26, 229.19, 510.27, 201.8, 495.86, 184.5, 497.3, 172.97, 495.86, 170.09, 491.53, 149.91, 480.0, 138.38, 467.03, 138.38, 449.73, 131.17, 441.08, 131.17, 436.76, 119.64, 472.79, 125.41, 495.86, 134.05, 510.27, 122.52, 531.89, 116.76, 526.13, 119.64, 513.15, 116.76, 507.39, 105.23, 517.48, 105.23, 527.57, 113.87, 534.77, 109.55, 541.98, 99.46, 541.98, 90.81, 534.77]], "area": 86087.77294999996, "iscrowd": 0, "image_id": 20333, "bbox": [51.89, 106.67, 315.68, 459.82], "category_id": 1, "id": 446896}, {"segmentation": [[288.29, 631.35, 282.52, 539.1, 278.2, 482.88, 273.87, 448.29, 269.55, 428.11, 242.16, 420.9, 226.31, 418.02, 223.42, 405.05, 224.86, 381.98, 227.75, 356.04, 229.19, 340.18, 221.98, 330.09, 220.54, 325.77, 220.54, 281.08, 220.54, 255.14, 217.66, 245.05, 213.33, 227.75, 213.33, 210.45, 213.33, 196.04, 213.33, 188.83, 211.89, 181.62, 203.24, 200.36, 194.59, 211.89, 187.39, 188.83, 191.71, 180.18, 203.24, 161.44, 207.57, 154.23, 211.89, 136.94, 219.1, 116.76, 233.51, 103.78, 252.25, 99.46, 275.32, 99.46, 292.61, 115.32, 304.14, 128.29, 311.35, 144.14, 315.68, 162.88, 322.88, 170.09, 332.97, 178.74, 337.3, 178.74, 351.71, 183.06, 369.01, 196.04, 390.63, 224.86, 413.69, 256.58, 428.11, 276.76, 432.43, 292.61, 419.46, 309.91, 403.6, 322.88, 389.19, 328.65, 377.66, 334.41, 366.13, 344.5, 354.59, 354.59, 344.5, 363.24, 337.3, 366.13, 337.3, 366.13, 322.88, 389.19, 321.44, 413.69, 318.56, 436.76, 312.79, 495.86, 307.03, 531.89, 302.7, 553.51, 309.91, 572.25, 315.68, 586.67, 321.44, 601.08, 325.77, 616.94, 325.77, 632.79]], "area": 53233.094850000016, "iscrowd": 0, "image_id": 11699, "bbox": [187.39, 99.46, 245.04, 533.33], "category_id": 1, "id": 509752}, {"segmentation": [[60.54, 418.74, 118.2, 401.44, 149.91, 404.32, 168.65, 418.74, 197.48, 408.65, 209.01, 359.64, 223.42, 307.75, 221.98, 261.62, 206.13, 225.59, 193.15, 206.85, 209.01, 159.28, 216.22, 131.89, 216.22, 113.15, 197.48, 87.21, 174.41, 82.88, 147.03, 94.41, 138.38, 114.59, 125.41, 133.33, 126.85, 153.51, 126.85, 170.81, 115.32, 176.58, 87.93, 176.58, 69.19, 241.44, 66.31, 293.33, 66.31, 320.72, 64.86, 363.96, 61.98, 395.68]], "area": 39898.78195, "iscrowd": 0, "image_id": 11699, "bbox": [60.54, 82.88, 162.88, 335.86], "category_id": 1, "id": 516637}, {"segmentation": [[27.17, 268.06, 29.29, 267.53, 26.11, 263.29, 22.4, 254.28, 26.11, 248.45, 30.35, 243.15, 35.65, 240.5, 46.78, 243.68, 54.2, 249.51, 55.79, 255.87, 57.38, 261.7, 52.08, 272.3, 53.14, 275.48, 56.85, 280.25, 49.43, 280.78, 33.0, 280.78, 28.23, 283.96, 24.52, 297.22, 18.16, 308.35, 10.21, 301.46, 8.09, 296.69, 5.44, 290.85, 10.74, 283.43, 19.22, 273.89]], "area": 1579.1349999999993, "iscrowd": 0, "image_id": 11699, "bbox": [5.44, 240.5, 51.94, 67.85], "category_id": 1, "id": 517883}, {"segmentation": [[173.91, 421.0, 187.43, 407.47, 206.75, 383.32, 216.42, 360.13, 226.08, 339.84, 231.87, 313.75, 244.43, 273.18, 260.86, 238.4, 284.05, 197.82, 297.57, 174.63, 322.69, 147.58, 327.52, 139.85, 324.62, 133.09, 294.67, 117.63, 259.89, 101.2, 249.26, 84.78, 241.53, 52.9, 236.7, 20.05, 236.7, 7.49, 260.86, 1.69, 329.45, 0.72, 370.03, 5.56, 404.81, 12.32, 438.63, 6.52, 467.61, 4.59, 503.36, 0.72, 527.51, 16.18, 544.9, 31.64, 565.19, 52.9, 577.75, 67.39, 592.24, 88.64, 618.33, 106.03, 638.62, 112.8, 640.0, 135.02, 640.0, 151.44, 640.0, 170.77, 640.0, 191.05, 640.0, 217.14, 638.62, 242.26, 638.62, 273.18, 638.62, 306.02, 640.0, 331.14, 640.0, 381.38, 640.0, 397.81, 640.0, 412.3, 640.0, 420.03, 640.0, 422.93]], "area": 154390.84090000004, "iscrowd": 0, "image_id": 18770, "bbox": [173.91, 0.72, 466.09, 422.21], "category_id": 1, "id": 527264}, {"segmentation": [[626.34, 529.98, 623.93, 510.71, 634.77, 502.27, 632.36, 483.0, 625.13, 458.91, 619.11, 450.48, 611.88, 444.46, 609.47, 439.64, 622.72, 367.37, 626.34, 334.85, 617.91, 296.31, 579.36, 239.69, 578.16, 224.04, 590.2, 181.88, 599.84, 160.2, 597.43, 140.93, 601.04, 125.27, 587.79, 108.4, 586.59, 98.77, 574.54, 86.72, 564.91, 86.72, 550.45, 77.09, 538.41, 78.29, 532.39, 80.7, 527.57, 89.13, 519.14, 80.7, 505.89, 85.52, 502.27, 96.36, 502.27, 99.97, 490.23, 107.2, 483.0, 112.02, 472.16, 134.9, 483.0, 173.45, 484.21, 190.31, 493.84, 207.17, 498.66, 250.53, 483.0, 255.35, 467.34, 258.97, 416.76, 364.96, 362.55, 289.08, 358.94, 283.06, 361.35, 251.74, 369.78, 239.69, 350.51, 205.97, 331.24, 201.15, 320.4, 211.99, 317.99, 222.83, 309.56, 219.22, 309.56, 239.69, 317.99, 245.72, 317.99, 250.53, 317.99, 274.62, 302.33, 255.35, 291.49, 245.72, 273.42, 245.72, 263.78, 244.51, 258.97, 252.94, 258.97, 258.97, 256.56, 263.78, 260.17, 271.01, 249.33, 272.22, 252.94, 280.65, 267.4, 289.08, 279.44, 308.35, 303.53, 321.6, 354.12, 383.03, 372.19, 403.51, 426.39, 438.44, 445.66, 449.28, 444.46, 457.71, 433.62, 505.89, 430.0, 527.57, 431.21, 536.0, 623.93, 533.59]], "area": 84787.13445, "iscrowd": 0, "image_id": 11051, "bbox": [249.33, 77.09, 385.44, 458.91], "category_id": 1, "id": 530192}, {"segmentation": [[7.23, 526.36, 14.45, 240.9, 104.79, 193.92, 106.0, 160.2, 130.09, 108.4, 134.9, 50.59, 150.56, 15.66, 205.97, 2.41, 279.44, 53.0, 267.4, 134.9, 240.9, 190.31, 319.19, 219.22, 319.19, 269.81, 287.87, 245.72, 266.19, 251.74, 252.94, 272.22, 286.67, 316.78, 315.58, 337.26, 367.37, 396.28, 393.87, 527.57]], "area": 130170.74170000001, "iscrowd": 0, "image_id": 11051, "bbox": [7.23, 2.41, 386.64, 525.16], "category_id": 1, "id": 539627}, {"segmentation": [[377.57, 425.79, 362.09, 386.59, 341.46, 337.08, 340.43, 307.16, 333.21, 279.31, 333.21, 244.23, 333.21, 221.54, 345.59, 196.78, 377.57, 186.46, 398.2, 176.15, 438.43, 182.34, 458.03, 193.68, 468.35, 214.32, 480.73, 232.88, 490.01, 258.67, 496.2, 283.43, 501.36, 325.73, 506.52, 368.02, 510.64, 403.1, 496.2, 419.6, 478.66, 415.48, 468.35, 402.07, 462.16, 422.7, 452.87, 435.08, 427.08, 420.64, 426.05, 396.91, 423.99, 383.5, 410.58, 386.59, 417.8, 410.32, 423.99, 430.95, 408.51, 439.2]], "area": 35139.281200000005, "iscrowd": 0, "image_id": 20247, "bbox": [333.21, 176.15, 177.43, 263.05], "category_id": 23, "id": 587181}, {"segmentation": [[8.22, 36.66, 11.3, 15.09, 30.81, 16.12, 59.56, 25.36, 85.24, 29.47, 86.27, 50.01, 83.18, 59.25, 72.91, 100.33, 55.46, 137.3, 44.16, 190.7, 39.02, 231.78, 48.27, 253.35, 39.02, 264.64, 1.03, 258.48, 1.03, 27.41]], "area": 14133.482649999998, "iscrowd": 0, "image_id": 20247, "bbox": [1.03, 15.09, 85.24, 249.55], "category_id": 23, "id": 588042}, {"segmentation": [[342.29, 122.25, 325.03, 115.06, 319.28, 104.99, 326.47, 86.29, 348.04, 77.66, 381.12, 77.66, 405.57, 87.73, 414.2, 102.11, 401.26, 112.18, 385.44, 119.37, 368.18, 120.81, 355.24, 120.81, 343.73, 119.37]], "area": 3224.9854499999997, "iscrowd": 0, "image_id": 17029, "bbox": [319.28, 77.66, 94.92, 44.59], "category_id": 34, "id": 603297}, {"segmentation": [[224.17, 361.92, 219.18, 354.6, 213.52, 348.28, 205.54, 342.29, 200.21, 339.62, 191.89, 337.96, 183.24, 336.63, 170.27, 339.29, 164.94, 342.29, 156.62, 347.94, 151.97, 353.93, 148.97, 360.59, 147.64, 368.57, 147.64, 376.23, 148.97, 383.88, 150.63, 388.87, 152.96, 395.52, 157.62, 405.17, 161.61, 411.16, 167.27, 420.15, 172.6, 428.47, 178.25, 436.45, 183.58, 442.44, 188.9, 448.76, 193.56, 453.42, 198.22, 456.08, 208.86, 455.42, 215.19, 454.09, 219.18, 452.76, 227.83, 449.76, 232.49, 446.77, 239.14, 443.11, 245.13, 439.45, 245.13, 434.46, 246.13, 428.47, 244.47, 416.15, 241.14, 403.51, 236.81, 389.87, 232.82, 378.89, 228.5, 369.24, 224.17, 361.92]], "area": 8247.795649999996, "iscrowd": 0, "image_id": 15497, "bbox": [147.64, 336.63, 98.49, 119.45], "category_id": 74, "id": 1106517}, {"segmentation": [[358.11, 478.92, 323.6, 483.24, 316.4, 470.29, 317.84, 445.84, 323.6, 422.83, 323.6, 419.96, 323.6, 405.57, 317.84, 394.07, 299.15, 381.12, 290.52, 372.49, 287.64, 343.73, 287.64, 309.21, 260.31, 235.87, 257.44, 225.8, 258.88, 218.61, 287.64, 256.0, 312.09, 327.91, 317.84, 332.22, 323.6, 348.04, 332.22, 375.37, 335.1, 382.56, 345.17, 365.3, 355.24, 372.49, 362.43, 388.31, 362.43, 418.52, 366.74, 442.97, 366.74, 467.42]], "area": 8476.824750000003, "iscrowd": 0, "image_id": 11699, "bbox": [257.44, 218.61, 109.3, 264.63], "category_id": 31, "id": 1180493}, {"segmentation": [[2.88, 500.49, 17.26, 417.08, 99.24, 412.76, 106.43, 407.01, 119.37, 407.01, 128.0, 399.82, 138.07, 407.01, 140.94, 404.13, 158.2, 422.83, 163.96, 414.2, 176.9, 421.39, 169.71, 408.45, 194.16, 407.01, 260.31, 422.83, 279.01, 629.93, 1.44, 632.81, 1.44, 503.37]], "area": 57762.926649999994, "iscrowd": 0, "image_id": 11699, "bbox": [1.44, 399.82, 277.57, 232.99], "category_id": 33, "id": 1183379}, {"segmentation": [[176.63, 323.52, 188.3, 313.97, 201.04, 320.12, 224.19, 362.8, 204.44, 372.78, 196.58, 371.5, 183.63, 347.72, 174.29, 329.68]], "area": 1581.3299499999994, "iscrowd": 0, "image_id": 12280, "bbox": [174.29, 313.97, 49.9, 58.81], "category_id": 33, "id": 1185876}, {"segmentation": [[8.63, 396.94, 28.76, 404.13, 54.65, 389.75, 67.6, 326.47, 76.22, 264.63, 79.1, 222.92, 67.6, 224.36, 57.53, 248.81, 8.63, 243.06], [103.55, 208.54, 113.62, 172.58, 128.0, 184.09, 119.37, 220.04]], "area": 9896.783449999999, "iscrowd": 0, "image_id": 11699, "bbox": [8.63, 172.58, 119.37, 231.55], "category_id": 31, "id": 1436493}, {"segmentation": [[1.44, 592.64, 1.44, 595.51, 21.57, 630.03, 208.54, 624.28, 264.63, 543.74, 220.04, 506.34, 132.31, 494.84, 126.56, 543.74, 66.16, 562.43, 51.78, 536.55, 61.84, 506.34, 15.82, 526.48, 2.88, 537.98]], "area": 24508.585249999996, "iscrowd": 0, "image_id": 20333, "bbox": [1.44, 494.84, 263.19, 135.19], "category_id": 51, "id": 1538251}, {"segmentation": [[2.1, 126.71, 53.85, 139.27, 51.63, 150.36, 56.81, 155.54, 50.89, 191.03, 0.62, 187.33, 2.84, 128.92]], "area": 2926.4472000000005, "iscrowd": 0, "image_id": 12280, "bbox": [0.62, 126.71, 56.19, 64.32], "category_id": 72, "id": 1624294}, {"segmentation": [[339.75, 250.26, 346.39, 253.11, 353.98, 285.37, 350.19, 288.21, 348.29, 300.55, 348.29, 300.55, 353.98, 306.24, 341.65, 312.88, 343.54, 300.55, 340.7, 253.11]], "area": 467.69994999999994, "iscrowd": 0, "image_id": 12280, "bbox": [339.75, 250.26, 14.23, 62.62], "category_id": 1, "id": 1705693}, {"segmentation": [[14.61, 494.38, 14.61, 405.62, 40.45, 353.93, 141.57, 317.98, 42.7, 267.42, 41.57, 164.04, 70.79, 123.6, 129.21, 100.0, 133.71, 84.27, 183.15, 33.71, 247.19, 29.21, 288.76, 44.94, 305.62, 78.65, 384.27, 95.51, 428.09, 132.58, 412.36, 193.26, 347.19, 247.19, 353.93, 307.87, 401.12, 330.34, 441.57, 442.7, 449.44, 491.01]], "area": 149804.31675, "iscrowd": 0, "image_id": 19924, "bbox": [14.61, 29.21, 434.83, 465.17], "category_id": 1, "id": 1705814}, {"segmentation": [[1.13, 44.59, 9.47, 44.59, 12.49, 48.29, 13.65, 49.92, 14.8, 53.86, 15.04, 57.33, 16.43, 55.71, 16.89, 55.25, 19.21, 55.01, 20.6, 55.71, 21.06, 55.94, 21.53, 56.4, 21.76, 56.64, 21.76, 57.56, 19.67, 58.49, 16.43, 58.49, 16.43, 60.34, 18.05, 60.81, 18.98, 61.27, 19.9, 62.43, 20.83, 66.6, 19.9, 69.38, 18.98, 72.16, 18.05, 77.26, 17.12, 79.35, 17.12, 82.13, 16.89, 84.45, 14.11, 85.37, 13.88, 82.82, 13.18, 87.69, 12.02, 88.39, 6.93, 88.85, 5.77, 86.76, 4.61, 82.82, 0.0, 81.9]], "area": 689.3531500000001, "iscrowd": 0, "image_id": 17029, "bbox": [0.0, 44.59, 21.76, 44.26], "category_id": 3, "id": 1770576}, {"segmentation": [[308.77, 286.83, 310.93, 284.24, 312.51, 281.37, 314.38, 280.65, 316.82, 281.22, 318.26, 295.46, 313.95, 298.19, 309.49, 296.32, 307.47, 292.44]], "area": 133.42794999999973, "iscrowd": 0, "image_id": 12280, "bbox": [307.47, 280.65, 10.79, 17.54], "category_id": 1, "id": 2022239}, {"segmentation": [[429.86, 249.39, 485.35, 409.31, 512.54, 478.93, 640.0, 478.93, 636.56, 75.32, 637.65, 5.69, 48.01, 1.34, 0.14, 1.34, 1.23, 268.97, 0.14, 479.02, 198.14, 480.0, 229.69, 479.02, 223.16, 457.26, 199.23, 458.35, 167.68, 423.54, 147.01, 375.67, 151.36, 348.47, 168.76, 335.42, 199.23, 338.68, 225.34, 361.53, 244.92, 409.4, 251.45, 431.16, 234.04, 452.91, 242.74, 480.0, 303.66, 474.67, 321.07, 463.79, 342.83, 454.0, 351.53, 450.74, 343.92, 444.21, 331.95, 437.68, 294.96, 344.12, 278.64, 282.11, 268.85, 270.15, 264.5, 265.79, 250.36, 260.35, 238.39, 283.2, 212.28, 278.85, 182.91, 297.34, 137.22, 288.64, 85.57, 269.06, 56.2, 210.31, 56.2, 120.01, 109.51, 61.27, 167.17, 34.07, 265.08, 24.28, 317.3, 31.89, 347.76, 52.56, 369.52, 86.29, 408.68, 104.78, 430.44, 93.9, 468.52, 76.5, 482.66, 86.29, 465.25, 133.07, 479.39, 153.74, 484.83, 166.79, 489.19, 173.32, 433.7, 248.39]], "area": 171088.63380000004, "iscrowd": 0, "image_id": 15497, "bbox": [0.14, 1.34, 639.86, 478.66], "category_id": 63, "id": 2224611}, {"segmentation": [[387.24, 261.25, 380.64, 278.21, 372.16, 292.35, 381.58, 312.13, 390.06, 327.21, 395.72, 342.28, 376.87, 340.4, 372.16, 330.98, 362.74, 333.8, 358.03, 325.32, 356.15, 316.84, 357.09, 301.77, 358.97, 288.58, 356.15, 280.1, 359.91, 262.2, 355.2, 253.72, 348.61, 240.53, 343.9, 231.1, 340.13, 221.68, 344.84, 211.32, 354.26, 200.95, 373.1, 185.88, 421.16, 193.42, 442.83, 185.88, 463.55, 172.69, 486.17, 167.04, 497.47, 164.21, 495.59, 156.67, 498.42, 152.9, 508.78, 163.27, 510.66, 157.61, 514.43, 159.5, 518.2, 170.8, 528.57, 183.05, 534.22, 201.9, 537.99, 225.45, 532.33, 234.87, 517.26, 233.93, 513.49, 222.62, 507.84, 216.97, 497.47, 212.26, 490.88, 227.34, 488.05, 232.99, 483.34, 247.12, 479.57, 266.91, 472.98, 290.46, 473.92, 313.07, 475.8, 328.15, 483.34, 339.46, 487.11, 350.76, 486.17, 352.65, 463.55, 350.76, 460.73, 340.4, 460.73, 323.44, 458.84, 293.29, 459.79, 277.27, 456.02, 275.39, 447.54, 273.5, 437.17, 281.04, 432.46, 306.48, 419.27, 331.92, 411.73, 342.28, 408.91, 343.22, 399.49, 335.69, 410.79, 322.5, 422.1, 301.77, 422.1, 281.04, 420.21, 269.73]], "area": 18147.233050000006, "iscrowd": 0, "image_id": 16228, "bbox": [340.13, 152.9, 197.86, 199.75], "category_id": 19, "id": 54058}, {"segmentation": [[229.45, 223.79, 228.25, 251.27, 229.32, 259.17, 227.82, 267.93, 230.17, 279.03, 230.17, 281.38, 231.1, 286.4, 230.1, 289.56, 225.61, 290.39, 224.44, 292.06, 226.27, 297.38, 225.28, 301.21, 224.61, 302.37, 222.95, 303.2, 209.47, 300.87, 214.79, 294.05, 215.13, 292.72, 220.78, 286.4, 222.39, 276.97, 221.83, 266.61, 219.57, 259.26, 219.57, 251.91, 212.22, 224.58, 205.43, 220.99, 202.79, 220.62, 198.08, 227.03, 185.45, 240.78, 181.31, 251.72, 184.13, 258.69, 188.09, 269.62, 193.93, 275.46, 192.61, 279.42, 195.63, 280.18, 197.89, 279.99, 203.55, 285.83, 189.79, 290.35, 184.51, 292.62, 183.19, 287.53, 177.35, 284.32, 176.22, 277.54, 174.9, 275.65, 175.65, 272.83, 174.71, 266.79, 169.87, 250.59, 173.73, 241.44, 180.07, 230.89, 183.58, 216.82, 180.77, 205.22, 176.55, 196.42, 176.55, 186.57, 177.25, 180.24, 177.25, 178.84, 172.24, 168.06, 171.6, 161.65, 165.2, 161.01, 160.5, 161.22, 157.3, 161.65, 153.45, 161.86, 149.4, 164.85, 148.76, 167.84, 149.4, 170.19, 149.82, 173.4, 148.12, 175.53, 146.19, 175.74, 144.91, 176.38, 143.84, 178.31, 143.2, 179.37, 140.64, 179.16, 136.58, 176.38, 132.1, 171.47, 131.89, 164.43, 132.31, 137.31, 132.53, 125.57, 130.39, 120.44, 130.82, 117.88, 132.1, 115.53, 134.24, 113.82, 135.3, 112.97, 129.54, 102.93, 133.17, 105.49, 137.23, 109.76, 139.15, 107.63, 139.57, 104.64, 139.57, 104.21, 139.36, 95.67, 142.35, 86.49, 143.42, 85.42, 147.69, 84.78, 150.46, 85.0, 154.31, 86.49, 156.44, 88.84, 157.08, 92.26, 157.3, 95.89, 157.08, 99.52, 156.87, 101.65, 156.44, 104.0, 156.44, 106.99, 156.44, 109.34, 157.72, 111.05, 158.36, 113.18, 169.25, 115.74, 179.08, 120.87, 193.81, 130.9, 207.26, 143.72, 213.45, 147.77, 230.32, 150.98, 244.82, 160.1, 258.77, 163.69, 285.06, 159.7, 302.2, 159.7, 314.15, 161.3, 324.51, 159.3, 334.47, 159.7, 341.64, 163.29, 345.23, 166.08, 347.22, 170.86, 348.42, 180.82, 352.8, 197.95, 354.0, 212.3, 357.58, 224.65, 359.18, 233.42, 359.58, 239.79, 353.2, 238.2, 350.01, 235.41, 347.62, 233.02, 343.64, 227.84, 335.27, 210.31, 330.49, 199.15, 328.5, 203.93, 325.71, 221.46, 333.68, 232.62, 341.64, 234.21, 344.83, 238.2, 356.39, 274.06, 357.58, 278.44, 365.55, 287.6, 359.97, 297.17, 342.84, 277.64, 340.45, 268.08, 334.87, 244.17, 326.5, 235.01, 316.14, 227.04, 311.36, 223.45, 308.57, 221.06, 306.64, 214.56, 302.1, 217.68, 300.41, 219.62, 301.45, 228.56, 303.78, 237.12, 307.16, 243.86, 301.19, 266.84, 298.69, 275.33, 298.69, 281.48, 297.03, 284.65, 291.2, 286.81, 292.87, 291.97, 287.88, 294.63, 276.56, 293.63, 279.89, 289.8, 285.55, 284.48, 290.54, 278.99, 294.2, 265.35, 294.89, 243.23, 290.32, 236.2, 286.45, 227.76, 282.58, 216.85, 272.38, 221.78, 254.45, 225.3, 241.78, 224.24, 231.58, 221.78]], "area": 18372.4854, "iscrowd": 0, "image_id": 15956, "bbox": [129.54, 84.78, 236.01, 218.42], "category_id": 19, "id": 54081}, {"segmentation": [[219.74, 518.68, 241.72, 482.98, 238.97, 436.28, 168.93, 298.94, 166.18, 248.13, 135.97, 202.8, 122.23, 162.98, 137.34, 143.75, 144.21, 90.19, 126.35, 127.27, 103.0, 139.63, 85.15, 135.51, 92.02, 105.29, 75.54, 76.45, 76.91, 50.36, 57.68, 80.57, 37.08, 123.15, 4.12, 136.88, 1.37, 417.05, 39.83, 419.8, 120.86, 496.71, 135.97, 511.82, 145.58, 539.28, 175.79, 555.77, 178.54, 550.27, 208.76, 539.28]], "area": 66767.92135, "iscrowd": 0, "image_id": 12748, "bbox": [1.37, 50.36, 240.35, 505.41], "category_id": 19, "id": 55490}, {"segmentation": [[256.0, 450.16, 258.88, 421.39, 276.13, 412.76, 358.11, 379.69, 348.04, 398.38, 345.17, 432.9, 346.61, 458.79, 345.17, 470.29, 381.12, 496.18, 396.94, 481.8, 405.57, 481.8, 402.7, 500.49, 412.76, 499.06, 419.96, 516.31, 455.91, 494.74, 480.0, 458.79, 480.0, 430.02, 463.1, 405.57, 457.35, 381.12, 457.35, 362.43, 454.47, 349.48, 480.0, 366.74, 480.0, 329.35, 458.79, 313.53, 448.72, 300.58, 431.46, 291.96, 415.64, 287.64, 434.34, 267.51, 441.53, 248.81, 434.34, 215.73, 434.34, 211.42, 421.39, 191.28, 407.01, 188.4, 368.18, 192.72, 327.91, 225.8, 325.03, 260.31, 332.22, 279.01, 330.79, 299.15, 346.61, 313.53, 349.48, 316.4, 336.54, 337.98, 323.6, 355.24, 287.64, 369.62, 266.07, 384.0, 251.69, 396.94, 235.87, 402.7, 222.92, 404.13, 217.17, 425.71, 225.8, 445.84, 243.06, 455.91, 256.0, 445.84], [373.93, 572.4, 395.51, 566.65, 425.71, 552.27, 430.02, 549.39, 437.21, 585.35, 447.28, 608.36, 465.98, 631.37, 470.29, 631.37, 431.46, 632.81, 412.76, 616.99, 396.94, 599.73, 382.56, 585.35]], "area": 43323.950949999984, "iscrowd": 0, "image_id": 12748, "bbox": [217.17, 188.4, 262.83, 444.41], "category_id": 1, "id": 208131}, {"segmentation": [[222.42, 399.78, 235.34, 320.86, 284.13, 293.6, 261.17, 273.51, 233.9, 223.28, 220.99, 203.19, 223.86, 183.1, 255.43, 151.53, 278.39, 138.62, 299.91, 141.49, 330.04, 181.67, 337.22, 204.63, 321.43, 244.81, 335.78, 306.51, 345.83, 326.6, 312.83, 362.48], [235.34, 457.18, 233.9, 510.28, 258.3, 540.41, 266.91, 541.85, 252.56, 622.21, 255.43, 630.82, 444.84, 632.25, 373.09, 570.55, 427.62, 547.59, 449.15, 612.16, 469.24, 632.25, 462.06, 540.41, 480.0, 507.41, 480.0, 465.79, 427.62, 517.45, 404.66, 494.49, 401.79, 480.14, 377.4, 497.36, 345.83, 468.66, 351.57, 384.0, 255.43, 424.18, 256.86, 454.31], [450.58, 349.56, 462.06, 409.83, 477.85, 427.05, 480.0, 369.65], [420.45, 287.86, 431.93, 272.07, 446.28, 270.64, 472.11, 317.99, 469.24, 323.73]], "area": 58405.78259999999, "iscrowd": 0, "image_id": 12748, "bbox": [220.99, 138.62, 259.01, 493.63], "category_id": 1, "id": 215760}, {"segmentation": [[283.42, 287.44, 285.95, 281.67, 285.68, 279.26, 284.47, 281.47, 283.73, 281.07, 283.39, 279.53, 281.65, 281.14, 280.51, 279.79, 286.95, 272.54, 288.5, 265.63, 291.05, 265.02, 294.54, 264.75, 293.67, 262.86, 294.74, 260.77, 295.82, 259.23, 296.29, 260.77, 295.28, 262.92, 295.55, 263.59, 298.77, 262.32, 300.58, 262.32, 302.13, 263.46, 303.81, 264.2, 305.55, 264.87, 305.95, 261.45, 307.5, 262.25, 308.1, 264.33, 306.83, 266.95, 305.69, 268.76, 303.6, 268.5, 303.07, 268.63, 301.25, 274.69, 297.16, 280.8, 294.54, 284.63, 294.41, 288.32, 294.94, 289.67, 293.2, 289.46, 291.72, 288.25, 293.06, 283.29, 294.81, 279.93, 292.59, 279.32, 291.25, 281.54, 290.04, 286.51, 288.3, 288.59, 287.29, 289.46, 286.55, 288.05, 289.44, 276.71, 288.56, 276.71, 286.28, 284.16, 285.27, 288.12, 283.8, 290.2, 282.59, 289.73, 283.66, 286.91]], "area": 343.10035000000005, "iscrowd": 0, "image_id": 16010, "bbox": [280.51, 259.23, 27.59, 30.97], "category_id": 21, "id": 278208}, {"segmentation": [[500.25, 147.28, 493.25, 141.73, 493.01, 133.52, 497.6, 127.97, 503.87, 126.28, 511.12, 128.45, 514.74, 137.62, 513.77, 143.66, 509.18, 146.07, 505.56, 146.79]], "area": 354.5723499999999, "iscrowd": 0, "image_id": 15956, "bbox": [493.01, 126.28, 21.73, 21.0], "category_id": 85, "id": 336552}, {"segmentation": [[43.24, 99.43, 42.6, 93.69, 44.3, 88.59, 47.06, 85.4, 49.83, 84.12, 55.99, 83.27, 57.27, 83.27, 63.43, 84.33, 67.26, 93.26, 67.89, 100.28, 65.56, 103.68, 62.15, 105.38, 56.42, 106.87, 52.38, 107.08, 49.61, 105.8, 47.49, 105.17, 46.21, 104.32, 44.94, 102.4]], "area": 482.2635000000001, "iscrowd": 0, "image_id": 15956, "bbox": [42.6, 83.27, 25.29, 23.81], "category_id": 85, "id": 340211}, {"segmentation": [[194.31, 294.95, 184.71, 258.0, 186.85, 254.8, 193.95, 243.79, 209.23, 235.62, 233.74, 233.84, 250.09, 233.84, 239.78, 235.97, 242.63, 265.82, 241.56, 287.49, 194.66, 293.89]], "area": 2835.5094499999996, "iscrowd": 0, "image_id": 17182, "bbox": [184.71, 233.84, 65.38, 61.11], "category_id": 62, "id": 377970}, {"segmentation": [[297.36, 185.24, 319.19, 184.49, 330.48, 176.96, 328.22, 154.38, 336.51, 142.33, 344.03, 138.57, 361.35, 140.83, 364.36, 155.13, 362.1, 169.43, 375.65, 181.48, 389.96, 204.81, 397.48, 220.62, 412.54, 234.17, 420.07, 255.25, 429.1, 271.81, 447.92, 271.81, 466.74, 265.79, 483.3, 260.52, 494.6, 258.26, 497.61, 260.52, 499.11, 296.66, 492.34, 300.42, 486.31, 286.87, 459.97, 294.4, 431.36, 297.41, 389.2, 264.29, 368.88, 252.99, 353.07, 249.23, 350.06, 256.76, 355.33, 270.31, 351.56, 285.36, 338.01, 285.36, 323.71, 289.88, 322.2, 274.83, 328.98, 264.29, 320.7, 248.48, 320.7, 219.87, 328.98, 207.83, 314.67, 208.58, 298.87, 207.07, 288.33, 195.03]], "area": 11459.433249999996, "iscrowd": 0, "image_id": 13291, "bbox": [288.33, 138.57, 210.78, 161.85], "category_id": 1, "id": 442908}, {"segmentation": [[235.68, 241.29, 260.6, 186.79, 272.78, 165.34, 294.81, 139.25, 309.88, 144.47, 313.36, 134.61, 304.67, 125.92, 306.78, 108.42, 318.58, 84.81, 338.47, 80.77, 360.53, 82.94, 383.83, 99.72, 389.11, 117.12, 390.35, 126.75, 379.17, 126.44, 376.99, 136.07, 385.38, 141.35, 372.95, 170.87, 370.69, 178.55, 367.98, 187.58, 354.43, 179.0, 357.59, 192.55, 355.34, 210.62, 391.47, 232.75, 427.16, 247.66, 446.77, 224.18, 464.17, 217.01, 480.04, 212.92, 483.62, 219.57, 470.82, 241.58, 464.17, 265.12, 458.54, 279.45, 432.44, 270.75, 421.18, 267.17, 410.44, 285.08, 404.3, 314.25, 383.83, 338.81, 330.6, 371.05, 349.03, 371.56, 355.68, 382.31, 348.0, 392.54, 338.28, 395.61, 269.71, 395.1, 257.94, 382.82, 263.05, 356.21, 236.44, 345.97, 224.16, 321.41, 221.09, 305.55, 218.53, 295.31, 221.6, 289.17, 221.6, 266.65, 227.74, 255.91, 235.93, 242.09]], "area": 41177.207800000004, "iscrowd": 0, "image_id": 10764, "bbox": [218.53, 80.77, 265.09, 314.84], "category_id": 1, "id": 471070}, {"segmentation": [[248.19, 194.15, 248.84, 189.38, 247.76, 185.7, 249.28, 178.98, 254.04, 171.83, 254.69, 169.23, 250.36, 164.9, 246.24, 163.82, 239.74, 157.97, 239.96, 151.68, 238.44, 148.0, 238.23, 144.75, 239.53, 141.07, 244.08, 138.47, 246.03, 138.03, 249.06, 135.43, 256.64, 137.38, 261.19, 140.85, 265.53, 148.65, 265.96, 154.07, 268.78, 154.07, 271.38, 152.33, 276.36, 153.85, 283.08, 156.67, 286.54, 158.83, 294.13, 164.47, 296.73, 173.13, 296.73, 182.23, 295.86, 182.67, 290.01, 183.53, 288.71, 187.22, 288.71, 188.95, 293.91, 186.35, 290.23, 190.25, 292.18, 192.42, 294.78, 203.25, 297.81, 205.85, 302.14, 208.88, 313.63, 209.53, 319.04, 208.67, 311.24, 216.9, 306.91, 223.62, 303.44, 226.0, 302.36, 228.17, 301.28, 239.65, 304.09, 246.59, 304.96, 251.14, 296.73, 257.64, 298.89, 261.75, 298.46, 266.74, 293.91, 273.89, 285.46, 280.39, 281.13, 282.55, 278.09, 280.39, 275.71, 277.57, 276.36, 273.45, 284.16, 266.74, 288.06, 258.5, 284.81, 260.24, 276.58, 259.8, 271.38, 255.9, 271.38, 252.87, 272.68, 252.65, 283.94, 249.4, 283.73, 247.67, 273.11, 240.3, 269.21, 238.79, 255.99, 235.54, 254.26, 228.39, 263.79, 216.47, 265.96, 207.15, 261.19, 204.77, 260.33, 210.4, 255.34, 213.43, 248.41, 215.6, 246.03, 213.22, 247.98, 208.67, 249.71, 201.3]], "area": 5149.0828999999985, "iscrowd": 0, "image_id": 13291, "bbox": [238.23, 135.43, 80.81, 147.12], "category_id": 1, "id": 475509}, {"segmentation": [[245.98, 468.33, 306.13, 359.84, 356.62, 339.43, 441.48, 350.18, 486.59, 359.84, 523.11, 357.69, 528.49, 360.92, 538.15, 380.25, 552.12, 399.59, 547.82, 414.62, 545.67, 421.07, 517.74, 461.89, 498.41, 474.78, 244.91, 474.78]], "area": 31987.406849999992, "iscrowd": 0, "image_id": 19221, "bbox": [244.91, 339.43, 307.21, 135.35], "category_id": 1, "id": 502731}, {"segmentation": [[227.0, 210.05, 240.1, 191.72, 261.93, 199.57, 270.66, 209.18, 273.28, 223.15, 290.74, 237.99, 310.82, 243.23, 318.68, 250.22, 318.68, 254.58, 319.55, 261.57, 303.84, 255.45, 294.23, 252.83, 282.88, 267.68, 286.38, 272.92, 294.23, 292.13, 278.52, 264.19, 275.9, 259.82, 267.17, 264.19, 269.79, 279.9, 266.29, 291.25, 250.58, 320.94, 228.75, 327.05, 214.78, 334.91, 211.29, 338.4, 229.62, 354.12, 223.51, 365.47, 213.03, 384.68, 229.62, 399.52, 232.24, 413.49, 209.54, 437.84, 185.09, 457.05, 184.22, 460.54, 180.73, 470.15, 171.12, 470.15, 172.0, 478.0, 172.0, 493.72, 180.73, 500.7, 165.88, 510.31, 160.64, 505.07, 159.77, 499.83, 123.1, 470.15, 123.97, 448.32, 130.09, 437.84, 138.82, 435.22, 129.21, 423.87, 126.59, 417.76, 137.94, 410.77, 150.17, 399.42, 153.66, 390.69, 117.86, 377.59, 103.89, 359.26, 97.78, 324.33, 103.89, 294.65, 128.34, 269.33, 147.55, 261.47, 160.64, 251.86, 166.76, 237.89, 158.9, 194.38, 142.31, 169.94, 130.96, 157.71, 123.97, 137.63, 108.26, 127.15, 95.16, 114.93, 93.41, 100.09, 108.26, 86.99, 136.2, 128.03, 148.42, 144.62, 170.25, 159.46, 175.49, 175.18, 181.6, 189.15, 199.94, 200.5, 209.54, 206.61, 219.14, 206.61, 229.62, 205.73]], "area": 34807.5968, "iscrowd": 0, "image_id": 13201, "bbox": [93.41, 86.99, 226.14, 423.32], "category_id": 1, "id": 508301}, {"segmentation": [[285.49, 328.97, 283.13, 346.77, 281.46, 365.58, 274.07, 362.89, 276.75, 358.53, 276.42, 324.27, 275.07, 320.91, 272.72, 330.31, 270.37, 329.64, 271.04, 307.81, 273.73, 296.05, 282.13, 294.04, 282.13, 290.01, 281.12, 286.31, 282.46, 283.63, 284.48, 282.28, 287.5, 281.95, 290.52, 284.97, 288.84, 293.03, 288.84, 294.04, 295.23, 296.05, 300.6, 313.52, 301.61, 326.28, 301.61, 329.98, 298.25, 331.66, 295.56, 329.31, 297.24, 324.27, 294.55, 312.18, 293.21, 325.95, 295.23, 345.09, 294.55, 357.18, 293.21, 368.27, 287.84, 366.59, 289.18, 355.84, 287.84, 341.4, 286.49, 331.99]], "area": 1495.2492499999992, "iscrowd": 0, "image_id": 13774, "bbox": [270.37, 281.95, 31.24, 86.32], "category_id": 1, "id": 509934}, {"segmentation": [[81.3, 93.35, 80.55, 88.83, 89.58, 67.0, 97.11, 66.25, 108.4, 67.0, 116.69, 76.03, 116.69, 92.6, 112.92, 106.15, 124.97, 111.42, 142.28, 123.46, 148.3, 145.29, 148.3, 167.88, 143.03, 179.17, 160.35, 197.24, 159.6, 214.55, 159.6, 224.34, 158.09, 234.12, 155.83, 246.92, 156.58, 255.96, 160.35, 266.49, 166.37, 280.04, 147.55, 275.53, 141.53, 267.25, 131.74, 255.2, 137.01, 248.43, 143.03, 229.61, 143.79, 216.06, 123.46, 205.52, 115.93, 203.26, 106.9, 211.54, 98.62, 233.37, 94.85, 236.38, 88.08, 246.92, 92.6, 264.99, 94.1, 280.04, 86.57, 293.6, 78.29, 298.87, 62.48, 298.11, 62.48, 293.6, 60.22, 253.7, 57.21, 230.36, 67.0, 161.1, 61.73, 152.07, 43.66, 135.51, 41.4, 132.49, 44.42, 118.94, 48.18, 113.67, 60.98, 94.85, 73.78, 84.31, 79.8, 87.33]], "area": 15137.624950000005, "iscrowd": 0, "image_id": 13291, "bbox": [41.4, 66.25, 124.97, 232.62], "category_id": 1, "id": 547120}, {"segmentation": [[527.12, 260.42, 529.55, 257.61, 538.55, 251.8, 540.23, 241.69, 540.79, 233.07, 623.78, 235.5, 620.22, 247.49, 620.22, 251.8, 619.47, 263.04, 616.85, 268.85, 614.42, 282.15, 608.05, 284.02, 605.05, 284.21, 600.74, 292.27, 596.99, 291.7, 599.62, 281.78, 555.97, 278.4, 560.28, 283.46, 551.66, 278.78, 546.23, 279.15, 541.54, 286.27, 538.55, 285.9, 543.23, 270.54, 540.23, 262.85]], "area": 3807.737349999998, "iscrowd": 0, "image_id": 16228, "bbox": [527.12, 233.07, 96.66, 59.2], "category_id": 15, "id": 575192}, {"segmentation": [[399.47, 267.04, 399.47, 267.04, 425.5, 266.77, 437.3, 272.14, 440.52, 284.48, 445.08, 302.46, 445.08, 302.46, 447.5, 309.97, 446.69, 312.38, 443.47, 306.48, 436.23, 290.92, 436.23, 290.92, 436.23, 296.28, 436.23, 296.28, 439.45, 303.26, 439.45, 319.63, 432.74, 320.16, 432.74, 320.16, 430.86, 325.26, 425.88, 323.28, 428.59, 319.47, 428.59, 319.47, 430.49, 313.76, 430.49, 313.76, 430.87, 308.68, 430.87, 308.68, 421.86, 292.56, 421.86, 292.56, 421.86, 292.56, 413.74, 293.58, 413.74, 293.58, 402.82, 295.35, 402.57, 295.35, 401.43, 296.88, 401.43, 296.88, 403.33, 314.9, 401.17, 315.4, 401.17, 315.4, 400.41, 318.32, 394.45, 319.21, 398.76, 312.87, 398.76, 312.87, 398.38, 306.65, 398.38, 306.65, 397.62, 302.21, 395.84, 294.72, 393.69, 294.08, 391.4, 297.0, 391.27, 318.83, 390.39, 322.64, 390.51, 325.05, 384.67, 324.54, 384.93, 304.62, 383.79, 298.4, 382.26, 294.97, 379.09, 295.08, 376.02, 299.92, 374.94, 305.66, 375.13, 310.11, 372.76, 317.82, 372.17, 323.16, 370.19, 323.36, 370.19, 324.84, 368.61, 324.35, 365.64, 321.48, 363.76, 318.12, 363.96, 312.28, 361.78, 307.24, 361.49, 303.19, 361.49, 303.19, 360.96, 300.34, 358.93, 300.53, 358.57, 296.1, 365.58, 286.69, 365.21, 278.02, 365.39, 277.83, 374.8, 268.42, 383.66, 266.58, 394.73, 266.58, 400.08, 267.5]], "area": 2996.3666000000003, "iscrowd": 0, "image_id": 16010, "bbox": [358.57, 266.58, 88.93, 58.68], "category_id": 24, "id": 589000}, {"segmentation": [[365.51, 409.93, 365.51, 443.16, 365.51, 466.28, 365.51, 480.72, 372.73, 495.17, 372.73, 515.4, 372.73, 545.73, 372.73, 580.41, 372.73, 583.3, 404.51, 602.08, 418.96, 602.08, 417.52, 576.07, 410.29, 539.95, 405.96, 509.62, 408.85, 459.05, 416.07, 431.6, 418.96, 408.49, 430.52, 357.92, 431.96, 331.92, 440.63, 279.91, 423.3, 213.45, 408.85, 199.01, 403.07, 197.56, 416.07, 190.34, 427.63, 177.34, 434.85, 164.33, 431.96, 144.11, 410.29, 141.22, 387.18, 158.56, 381.4, 158.56, 374.18, 158.56, 369.84, 158.56, 355.4, 155.67, 323.61, 122.44, 296.16, 136.88, 300.5, 177.34, 252.82, 238.01, 249.93, 269.8, 242.71, 308.8, 251.38, 349.26, 265.82, 372.37, 278.83, 385.37, 283.16, 404.15, 287.49, 467.72, 297.61, 531.29, 294.72, 567.4, 294.72, 589.07, 294.72, 590.52, 316.39, 590.52, 340.95, 581.85, 340.95, 547.18, 340.95, 511.06, 343.84, 480.72, 346.73, 447.49, 345.28, 435.94, 332.28, 409.93, 359.73, 399.82]], "area": 60087.8676, "iscrowd": 0, "image_id": 17115, "bbox": [242.71, 122.44, 197.92, 479.64], "category_id": 24, "id": 589088}, {"segmentation": [[525.28, 87.87, 538.65, 106.97, 566.35, 99.33, 571.12, 125.11, 583.54, 146.12, 605.51, 198.65, 603.6, 229.21, 566.35, 274.1, 560.62, 323.76, 557.75, 355.28, 562.53, 396.35, 547.25, 409.72, 540.56, 396.35, 528.15, 386.8, 524.33, 400.17, 496.63, 418.31, 486.12, 407.81, 491.85, 386.8, 496.63, 343.82, 489.94, 325.67, 493.76, 297.98, 483.26, 264.55, 456.52, 233.99, 453.65, 189.1, 475.62, 149.94, 482.3, 147.08, 458.43, 127.02, 459.38, 108.88, 475.62, 97.42, 490.9, 113.65, 498.54, 117.47, 507.13, 102.19, 510.96, 91.69]], "area": 30324.790750000004, "iscrowd": 0, "image_id": 11760, "bbox": [453.65, 87.87, 151.86, 330.44], "category_id": 24, "id": 589666}, {"segmentation": [[268.9, 136.0, 279.88, 130.93, 292.56, 136.85, 301.85, 127.55, 314.53, 108.96, 329.73, 100.52, 346.63, 105.59, 348.32, 136.0, 366.07, 130.09, 376.21, 138.54, 368.6, 155.44, 385.5, 176.56, 388.03, 226.41, 371.14, 247.53, 364.38, 274.57, 357.62, 315.97, 351.7, 361.6, 355.08, 396.24, 344.1, 394.55, 319.59, 393.71, 311.15, 395.4, 309.46, 362.44, 308.61, 321.89, 306.08, 299.07, 304.39, 281.33, 290.02, 237.39, 284.11, 215.43, 280.73, 191.77, 280.73, 168.95, 284.95, 159.66, 269.74, 151.21, 272.28, 137.69, 284.95, 134.31]], "area": 20181.378099999998, "iscrowd": 0, "image_id": 11760, "bbox": [268.9, 100.52, 119.13, 295.72], "category_id": 24, "id": 590311}, {"segmentation": [[61.89, 485.34, 64.31, 515.65, 59.46, 522.92, 59.46, 532.62, 59.46, 552.02, 64.31, 567.78, 59.46, 595.66, 90.99, 583.54, 83.71, 552.02, 86.14, 504.74, 86.14, 491.4, 89.77, 457.46, 87.35, 423.51, 84.92, 393.2, 97.05, 379.87, 99.47, 384.71, 92.2, 387.14, 104.32, 416.24, 104.32, 453.82, 109.17, 481.7, 107.96, 507.16, 115.23, 531.41, 112.81, 561.72, 120.08, 585.96, 128.57, 592.03, 130.99, 559.29, 126.14, 539.89, 123.72, 507.16, 123.72, 467.15, 132.21, 433.21, 143.12, 497.46, 143.12, 542.32, 150.39, 559.29, 166.15, 553.23, 161.3, 493.83, 158.88, 465.94, 161.3, 430.78, 167.36, 399.26, 173.43, 379.87, 194.03, 327.91, 197.67, 280.62, 177.06, 227.91, 158.88, 189.12, 158.88, 185.48, 173.43, 176.99, 192.82, 156.38, 207.37, 129.71, 180.7, 129.71, 158.88, 141.84, 149.18, 144.26, 138.27, 140.62, 134.63, 132.14, 128.57, 117.59, 116.45, 96.98, 101.9, 98.19, 97.05, 104.25, 83.71, 111.53, 81.29, 113.95, 75.23, 124.86, 69.16, 118.8, 52.19, 112.74, 48.55, 149.11, 54.62, 164.87, 59.46, 170.93, 47.34, 173.36, 38.86, 185.48, 35.22, 190.33, 36.43, 189.12, 27.94, 200.03, 25.52, 209.73, 23.09, 217.0, 17.03, 237.61, 12.18, 252.16, 10.97, 263.07, 7.33, 266.71, 2.48, 271.56, 7.33, 291.48, 14.61, 349.68, 21.88, 372.71, 30.37, 371.5, 41.28, 394.53, 44.92, 404.23, 50.98, 419.99, 58.25, 435.75, 59.46, 447.88, 60.68, 463.64, 61.89, 469.7, 61.89, 478.19, 64.31, 483.03, 64.31, 483.03]], "area": 56492.645699999994, "iscrowd": 0, "image_id": 17115, "bbox": [2.48, 96.98, 204.89, 498.68], "category_id": 24, "id": 590562}, {"segmentation": [[76.23, 362.11, 63.85, 299.22, 46.69, 221.08, 35.26, 184.87, 50.5, 144.84, 70.52, 121.97, 96.24, 113.4, 126.74, 127.69, 129.6, 101.96, 149.61, 119.11, 159.14, 99.1, 176.29, 107.68, 179.15, 134.36, 202.97, 110.54, 215.36, 117.21, 209.64, 142.94, 185.82, 154.37, 181.05, 218.22, 175.34, 251.57, 160.09, 269.67, 150.56, 316.37, 146.75, 387.84, 123.88, 385.93, 127.69, 337.33, 117.21, 280.16, 113.4, 268.72, 96.24, 291.59, 100.06, 344.96, 92.43, 379.26, 74.33, 376.4]], "area": 27830.795599999998, "iscrowd": 0, "image_id": 11760, "bbox": [35.26, 99.1, 180.1, 288.74], "category_id": 24, "id": 590625}, {"segmentation": [[114.52, 250.7, 114.52, 272.99, 116.79, 304.38, 123.16, 306.65, 120.89, 278.9, 122.25, 266.16, 125.44, 280.27, 125.44, 302.56, 131.35, 307.11, 129.53, 288.91, 130.9, 277.54, 129.53, 267.07, 130.9, 252.52, 138.18, 258.89, 140.45, 266.16, 139.54, 278.9, 148.18, 301.65, 156.83, 306.2, 155.01, 295.28, 155.01, 288.91, 161.38, 270.26, 165.93, 265.25, 165.93, 254.79, 175.93, 250.24, 175.48, 261.16, 168.65, 287.09, 174.57, 292.55, 179.12, 291.64, 175.48, 284.36, 181.39, 262.98, 187.76, 250.24, 188.67, 264.34, 194.58, 275.72, 201.86, 286.64, 207.32, 274.35, 205.5, 267.98, 209.14, 252.06, 209.14, 249.33, 217.79, 239.78, 215.51, 239.78, 206.41, 241.6, 196.4, 217.94, 188.67, 202.93, 175.48, 200.2, 156.83, 200.2, 130.44, 200.2, 124.07, 202.48, 109.97, 217.03, 109.52, 236.59]], "area": 6907.305150000001, "iscrowd": 0, "image_id": 20059, "bbox": [109.52, 200.2, 108.27, 106.91], "category_id": 24, "id": 591261}, {"segmentation": [[466.85, 246.73, 474.14, 255.39, 485.54, 287.3, 487.37, 290.04, 488.73, 293.69, 491.93, 296.88, 503.32, 289.13, 503.32, 276.36, 505.6, 262.23, 506.52, 254.93, 506.52, 238.52, 499.22, 235.33, 449.52, 196.12, 434.02, 193.38, 406.21, 193.38, 398.46, 193.38, 367.91, 185.17, 355.6, 192.92, 348.3, 207.51, 346.93, 221.65, 345.11, 233.05, 342.38, 241.25, 341.46, 270.89, 348.3, 286.39, 355.6, 290.95, 357.88, 294.6, 361.07, 294.14, 362.44, 283.2, 358.79, 271.8, 358.79, 264.05, 362.44, 255.84, 368.82, 249.01, 373.84, 242.17, 378.39, 246.27, 406.21, 249.01, 423.99, 250.83, 418.06, 266.79, 416.69, 280.92, 415.33, 294.14, 415.33, 300.53, 429.46, 293.23, 433.11, 266.33, 434.02, 264.05, 435.84, 261.32, 443.14, 261.77, 444.51, 277.27, 447.24, 286.39, 451.35, 291.86, 455.45, 294.14, 460.92, 298.7, 462.74, 292.32, 460.46, 286.39, 455.45, 274.99, 455.45, 252.65, 465.94, 249.92]], "area": 10740.670599999998, "iscrowd": 0, "image_id": 20059, "bbox": [341.46, 185.17, 165.06, 115.36], "category_id": 24, "id": 592307}, {"segmentation": [[236.31, 219.32, 237.35, 213.84, 243.36, 209.66, 248.84, 209.66, 253.02, 214.88, 253.02, 221.41, 248.06, 226.37, 243.1, 227.42, 236.83, 225.07, 235.78, 220.89]], "area": 237.83700000000005, "iscrowd": 0, "image_id": 13774, "bbox": [235.78, 209.66, 17.24, 17.76], "category_id": 34, "id": 602311}, {"segmentation": [[106.65, 155.46, 113.52, 180.37, 122.32, 202.48, 119.1, 204.41, 117.17, 199.91, 112.23, 181.23, 105.36, 155.25]], "area": 103.96229999999969, "iscrowd": 0, "image_id": 18491, "bbox": [105.36, 155.25, 16.96, 49.16], "category_id": 39, "id": 629357}, {"segmentation": [[313.57, 217.13, 306.97, 225.2, 300.67, 235.76, 298.03, 242.06, 300.08, 244.85, 305.36, 245.29, 311.96, 235.32, 314.75, 231.36, 318.85, 229.3, 319.0, 218.74, 316.21, 216.69]], "area": 285.53729999999996, "iscrowd": 0, "image_id": 18491, "bbox": [298.03, 216.69, 20.97, 28.6], "category_id": 40, "id": 634537}, {"segmentation": [[400.29, 238.18, 412.62, 242.92, 434.43, 241.02, 439.18, 229.64, 441.07, 221.1, 451.51, 223.0, 459.1, 218.26, 471.43, 210.67, 480.91, 212.57, 483.76, 224.9, 474.27, 240.07, 466.68, 250.51, 459.1, 268.53, 457.2, 278.02, 445.82, 278.02, 438.23, 278.02, 429.69, 268.53, 420.21, 267.58, 415.46, 257.15, 406.93, 253.35, 393.65, 253.35, 388.9, 251.46, 396.49, 239.13]], "area": 2867.833599999999, "iscrowd": 0, "image_id": 10764, "bbox": [388.9, 210.67, 94.86, 67.35], "category_id": 40, "id": 635135}, {"segmentation": [[323.24, 142.51, 331.53, 142.51, 331.68, 146.21, 329.46, 153.31, 328.42, 154.94, 327.54, 157.6, 323.98, 158.34, 320.58, 154.79, 318.95, 151.39, 319.99, 148.57, 322.5, 146.8, 322.8, 143.69]], "area": 138.23775000000003, "iscrowd": 0, "image_id": 18491, "bbox": [318.95, 142.51, 12.73, 15.83], "category_id": 40, "id": 635185}, {"segmentation": [[107.9, 492.04, 113.18, 485.71, 117.93, 483.07, 121.62, 474.63, 129.54, 457.21, 124.79, 455.1, 122.15, 452.99, 126.37, 447.71, 131.12, 442.96, 134.81, 442.96, 139.56, 431.88, 145.37, 427.13, 153.28, 427.13, 159.09, 429.77, 166.48, 435.05, 170.7, 440.85, 174.92, 448.24, 175.98, 458.8, 167.0, 485.71, 152.23, 519.48, 146.42, 516.84, 142.73, 523.18, 137.98, 521.06, 134.29, 511.57, 125.32, 502.07, 118.98, 497.32, 111.6, 496.79]], "area": 3725.12715, "iscrowd": 0, "image_id": 13201, "bbox": [107.9, 427.13, 68.08, 96.05], "category_id": 41, "id": 638543}, {"segmentation": [[177.65, 165.88, 234.12, 148.24, 309.41, 147.06, 321.18, 145.88, 343.53, 134.12, 320.0, 90.59, 244.71, 72.94, 156.47, 85.88, 117.65, 103.53, 104.71, 114.12, 74.12, 147.06, 48.24, 201.18, 44.71, 231.76, 55.29, 272.94, 76.47, 290.59, 97.65, 284.71, 116.47, 241.18, 158.82, 184.71]], "area": 26679.727, "iscrowd": 0, "image_id": 13004, "bbox": [44.71, 72.94, 298.82, 217.65], "category_id": 52, "id": 1043946}, {"segmentation": [[280.05, 355.41, 267.68, 376.78, 285.68, 384.65, 290.17, 402.64, 291.3, 419.52, 262.06, 442.01, 219.32, 448.76, 191.2, 446.51, 178.83, 434.14, 167.58, 428.51, 147.34, 400.4, 121.47, 389.15, 111.35, 377.9, 97.85, 354.28, 92.23, 319.42, 85.48, 283.43, 87.73, 255.31, 101.22, 233.94, 119.22, 210.32, 142.84, 178.83, 169.83, 157.46, 214.82, 134.96, 239.56, 128.22, 227.19, 140.59, 213.69, 158.58, 219.32, 172.08, 238.44, 200.2, 264.31, 227.19, 283.43, 254.18, 307.04, 269.93, 330.66, 269.93, 338.54, 263.18, 338.54, 228.32, 316.04, 203.57, 287.92, 178.83, 296.92, 152.96, 301.42, 133.84, 326.16, 136.09, 348.66, 145.09, 363.28, 154.08, 377.9, 164.21, 381.28, 175.45, 374.53, 187.83, 366.65, 205.82, 354.28, 208.07, 346.41, 220.44, 349.78, 235.06, 355.41, 256.43, 373.4, 260.93, 395.9, 273.3, 424.01, 278.93, 448.76, 282.3, 442.01, 300.3, 435.26, 323.92, 428.51, 339.66, 427.39, 352.03, 399.27, 338.54, 373.4, 335.16, 347.53, 345.28, 328.41, 356.53, 311.54, 347.53, 298.05, 350.91]], "area": 62490.61550000001, "iscrowd": 0, "image_id": 19221, "bbox": [85.48, 128.22, 363.28, 320.54], "category_id": 56, "id": 1056513}, {"segmentation": [[123.94, 113.35, 152.11, 141.52, 178.03, 135.89, 197.18, 121.24, 218.59, 114.48, 216.34, 76.17, 241.13, 50.25, 274.93, 40.11, 290.7, 52.51, 340.28, 67.15, 403.38, 87.44, 452.96, 55.89, 496.9, 81.8, 507.04, 107.72, 552.11, 94.2, 583.66, 89.69, 602.82, 89.69, 597.18, 103.21, 619.72, 132.51, 640.0, 116.73, 640.0, 259.83, 640.0, 351.1, 638.87, 405.18, 602.82, 400.68, 573.52, 392.79, 538.59, 381.52, 505.92, 369.13, 500.28, 382.65, 486.76, 419.83, 438.31, 444.62, 401.13, 454.76, 323.38, 440.11, 307.61, 472.79, 287.32, 464.9, 297.46, 435.61, 271.55, 414.2, 250.14, 410.82, 214.08, 422.08, 193.8, 414.2, 160.0, 427.72, 150.99, 446.87, 110.42, 450.25, 47.32, 458.14, 24.79, 425.46, 58.59, 389.41, 52.96, 347.72, 65.35, 328.56, 52.96, 288.0, 33.8, 354.48, 1.13, 355.61, 0.0, 189.97, 7.89, 195.61, 7.89, 164.06, 21.41, 160.68, 43.94, 168.56, 66.48, 157.3, 65.35, 134.76, 74.37, 132.51, 86.76, 113.35, 119.44, 114.48]], "area": 205946.95595000006, "iscrowd": 0, "image_id": 15278, "bbox": [0.0, 40.11, 640.0, 432.68], "category_id": 56, "id": 1057752}, {"segmentation": [[79.27, 126.07, 69.72, 137.53, 76.4, 189.1, 483.26, 415.45, 498.54, 410.67, 520.51, 420.22, 526.24, 407.81, 518.6, 401.12, 519.55, 380.11, 531.01, 385.84, 524.33, 358.15, 308.48, 29.61, 243.54, 42.98, 170.0, 68.76, 104.1, 107.92]], "area": 82770.7217, "iscrowd": 0, "image_id": 13597, "bbox": [69.72, 29.61, 461.29, 390.61], "category_id": 61, "id": 1086039}, {"segmentation": [[30.41, 10.14, 375.0, 6.76, 375.0, 476.35, 3.38, 484.23, 1.13, 14.64]], "area": 175772.03385, "iscrowd": 0, "image_id": 13004, "bbox": [1.13, 6.76, 373.87, 477.47], "category_id": 67, "id": 1091866}, {"segmentation": [[240.5, 234.44, 265.52, 230.8, 297.83, 236.26, 299.19, 300.86, 286.45, 300.86, 251.88, 298.59, 242.09, 306.07]], "area": 3853.217499999999, "iscrowd": 0, "image_id": 17182, "bbox": [240.5, 230.8, 58.69, 75.27], "category_id": 84, "id": 1139750}, {"segmentation": [[300.64, 301.67, 299.16, 238.38, 275.92, 230.97, 288.28, 229.48, 308.06, 235.42, 311.02, 297.22, 302.12, 300.18]], "area": 725.5337999999992, "iscrowd": 0, "image_id": 17182, "bbox": [275.92, 229.48, 35.1, 72.19], "category_id": 84, "id": 1145467}, {"segmentation": [[321.66, 235.95, 322.04, 265.58, 322.04, 296.91, 315.39, 298.05, 309.89, 296.91, 309.32, 246.97, 307.42, 235.19, 292.8, 229.5, 295.26, 226.84, 301.53, 227.98, 316.91, 232.15]], "area": 891.7369000000022, "iscrowd": 0, "image_id": 17182, "bbox": [292.8, 226.84, 29.24, 71.21], "category_id": 84, "id": 1147579}, {"segmentation": [[333.97, 295.27, 322.27, 297.22, 321.78, 235.78, 305.45, 229.2, 307.15, 226.76, 334.46, 233.1, 333.97, 295.76]], "area": 855.8296000000017, "iscrowd": 0, "image_id": 17182, "bbox": [305.45, 226.76, 29.01, 70.46], "category_id": 84, "id": 1148280}, {"segmentation": [[346.0, 232.83, 314.81, 228.57, 335.37, 236.37, 334.3, 294.86, 344.58, 293.09]], "area": 695.3083499999989, "iscrowd": 0, "image_id": 17182, "bbox": [314.81, 228.57, 31.19, 66.29], "category_id": 84, "id": 1149094}, {"segmentation": [[356.3, 231.15, 318.46, 228.11, 346.63, 234.19, 345.53, 293.29, 355.19, 291.36]], "area": 646.0348500000011, "iscrowd": 0, "image_id": 17182, "bbox": [318.46, 228.11, 37.84, 65.18], "category_id": 84, "id": 1149374}, {"segmentation": [[220.55, 295.05, 224.11, 300.13, 228.68, 302.16, 233.76, 299.62, 231.73, 291.49, 234.27, 274.71, 236.3, 264.04, 232.75, 256.42, 226.65, 252.35, 222.58, 248.28, 220.55, 242.69, 223.6, 238.63, 238.34, 237.61, 242.4, 236.59, 243.42, 229.99, 241.9, 217.79, 235.29, 211.18, 233.76, 207.62, 237.32, 194.91, 234.78, 191.36, 227.16, 189.32, 212.42, 193.9, 211.91, 201.52, 206.82, 209.15, 199.2, 226.43, 196.15, 243.71, 200.72, 252.86, 207.33, 264.55, 212.92, 267.09, 214.96, 280.81, 218.01, 290.98]], "area": 2937.9041, "iscrowd": 0, "image_id": 16228, "bbox": [196.15, 189.32, 47.27, 112.84], "category_id": 1, "id": 1206679}, {"segmentation": [[319.31, 178.53, 330.17, 179.05, 334.31, 179.74, 335.17, 219.56, 335.0, 220.77, 324.31, 225.94, 323.97, 224.56, 324.14, 220.08, 321.38, 221.28, 319.83, 223.52, 319.31, 226.11, 317.93, 223.6, 316.55, 226.01, 315.18, 227.05, 314.31, 224.46, 315.87, 221.88, 320.17, 218.43, 323.28, 216.7, 324.83, 210.33, 326.04, 204.29, 326.04, 199.98, 326.04, 191.36, 321.9, 189.64, 321.04, 188.78, 320.86, 184.64, 321.21, 182.74, 321.04, 181.37, 319.14, 180.5, 318.28, 179.64, 318.97, 178.95, 318.97, 178.95], [337.59, 187.4, 342.93, 193.09, 346.38, 202.57, 346.55, 210.5, 347.76, 214.29, 351.03, 217.39, 338.1, 230.32, 337.24, 220.5, 335.69, 187.23], [334.14, 224.12, 328.1, 227.56, 331.38, 231.53, 333.79, 233.43, 336.55, 231.53, 336.21, 228.25, 335.86, 223.43, 333.62, 223.6]], "area": 919.7349499999996, "iscrowd": 0, "image_id": 16228, "bbox": [314.31, 178.53, 36.72, 54.9], "category_id": 1, "id": 1218312}, {"segmentation": [[347.98, 280.81, 354.39, 282.41, 361.2, 278.41, 366.01, 275.2, 368.81, 281.61, 363.2, 292.83, 358.4, 296.84, 353.99, 302.85, 349.18, 305.25, 344.77, 302.44, 341.97, 303.25, 331.55, 302.44, 322.34, 302.04, 319.53, 299.64, 321.94, 295.23, 315.53, 285.22, 309.12, 278.81, 307.11, 273.6, 300.7, 274.4, 287.48, 277.2, 277.86, 281.21, 265.44, 280.81, 259.03, 275.2, 250.22, 267.99, 244.61, 240.34, 243.01, 235.13, 245.41, 221.91, 254.63, 207.09, 260.64, 203.08, 261.84, 199.08, 261.84, 196.27, 265.84, 189.06, 269.45, 184.65, 282.27, 186.25, 287.48, 191.06, 288.28, 199.08, 293.09, 204.28, 290.69, 207.49, 286.28, 205.49, 279.47, 219.11, 285.88, 223.52, 290.28, 229.93, 292.29, 233.93, 288.68, 237.14, 283.87, 235.54, 284.28, 242.35, 286.68, 249.56, 293.09, 250.76, 299.9, 252.76, 305.51, 254.37, 311.92, 253.56, 315.53, 254.77, 322.34, 263.98, 322.74, 265.18, 333.15, 274.0, 339.97, 278.81, 350.38, 282.41]], "area": 5264.408100000001, "iscrowd": 0, "image_id": 18491, "bbox": [243.01, 184.65, 125.8, 120.6], "category_id": 1, "id": 1235753}, {"segmentation": [[90.23, 206.77, 92.55, 215.4, 92.55, 225.83, 96.03, 230.08, 95.13, 237.42, 100.79, 250.95, 104.01, 254.55, 105.17, 254.94, 107.49, 255.07, 109.04, 255.2, 109.04, 256.87, 106.85, 259.58, 101.82, 261.38, 98.73, 261.38, 94.61, 253.78, 87.66, 243.09, 84.82, 247.86, 83.28, 255.71, 84.44, 258.81, 88.3, 259.84, 89.46, 261.77, 80.7, 263.06, 77.48, 262.15, 77.87, 254.94, 77.87, 248.89, 78.64, 234.85, 78.38, 231.5, 76.84, 227.12, 78.25, 224.03, 77.22, 209.09, 78.64, 206.64, 80.7, 203.81, 82.12, 202.77, 82.5, 199.3, 86.11, 197.24, 90.49, 196.72, 92.55, 197.88, 92.55, 203.42]], "area": 986.9378500000001, "iscrowd": 0, "image_id": 16228, "bbox": [76.84, 196.72, 32.2, 66.34], "category_id": 1, "id": 1242637}, {"segmentation": [[359.83, 292.66, 351.2, 275.39, 343.52, 260.04, 343.52, 246.6, 348.32, 239.89, 351.2, 227.41, 341.6, 222.62, 333.92, 221.66, 322.41, 231.25, 315.69, 242.77, 306.1, 250.44, 301.3, 244.69, 301.3, 233.17, 307.06, 225.49, 318.57, 215.9, 323.37, 213.02, 330.09, 207.26, 330.09, 199.59, 336.8, 186.15, 345.44, 189.99, 355.03, 197.67, 356.95, 203.42, 366.55, 208.22, 374.22, 213.98, 389.58, 224.53, 390.54, 231.25, 406.85, 242.77, 404.93, 256.2, 394.38, 260.04, 386.7, 267.71, 390.54, 273.47, 393.42, 277.31, 405.89, 283.07, 412.61, 288.82, 422.2, 300.34, 422.2, 304.18, 410.69, 307.06, 382.86, 312.81, 377.1, 308.02, 375.18, 292.66]], "area": 5928.673350000003, "iscrowd": 0, "image_id": 18491, "bbox": [301.3, 186.15, 120.9, 126.66], "category_id": 1, "id": 1247297}, {"segmentation": [[343.03, 183.99, 354.43, 151.3, 378.0, 207.55, 390.92, 206.03, 375.72, 146.74, 378.76, 95.04, 364.32, 94.28, 359.76, 69.96, 342.27, 82.88, 343.03, 96.56, 332.39, 113.29, 331.63, 147.5, 330.11, 180.19, 344.55, 188.55]], "area": 4403.250250000003, "iscrowd": 0, "image_id": 18491, "bbox": [330.11, 69.96, 60.81, 137.59], "category_id": 1, "id": 1250410}, {"segmentation": [[328.32, 156.97, 331.5, 148.84, 329.73, 141.41, 329.02, 126.91, 324.07, 115.59, 316.29, 94.02, 305.68, 89.07, 303.21, 86.95, 304.97, 84.12, 305.68, 72.8, 294.36, 68.91, 288.71, 72.45, 288.0, 82.0, 293.66, 94.37, 282.34, 97.2, 281.28, 121.25, 274.91, 132.92, 275.62, 138.23, 284.11, 136.81, 285.52, 135.4, 283.05, 130.8, 289.77, 121.96, 291.53, 134.34, 285.88, 160.51, 285.17, 173.24, 286.94, 190.92, 289.41, 203.67, 285.17, 211.81, 298.25, 216.41, 296.84, 204.38, 300.73, 188.47, 302.14, 175.03, 303.21, 164.77, 304.62, 154.87, 307.8, 166.54, 311.69, 185.64, 313.82, 189.88, 311.34, 191.3, 314.52, 190.24, 315.58, 202.26, 309.57, 207.21, 316.29, 201.91, 317.71, 206.86, 313.11, 211.46, 314.52, 215.7, 330.79, 212.52, 328.32, 205.44, 326.9, 185.99, 321.24, 173.61, 319.83, 153.1, 321.95, 144.69, 315.23, 130.54, 318.06, 125.94, 315.94, 119.93, 321.6, 124.53, 323.72, 141.86, 321.6, 148.93, 322.66, 157.42, 325.84, 158.13]], "area": 4446.742150000001, "iscrowd": 0, "image_id": 18491, "bbox": [274.91, 68.91, 56.59, 147.5], "category_id": 1, "id": 1266544}, {"segmentation": [[195.83, 150.11, 208.25, 145.34, 209.2, 94.71, 199.65, 88.02, 192.96, 77.51, 183.41, 77.51, 181.5, 91.84, 177.68, 105.21, 177.68, 132.92, 180.54, 152.02, 193.92, 150.11]], "area": 1959.6433999999997, "iscrowd": 0, "image_id": 18491, "bbox": [177.68, 77.51, 31.52, 74.51], "category_id": 1, "id": 1269631}, {"segmentation": [[76.05, 214.29, 83.77, 217.47, 88.76, 213.39, 84.22, 205.22, 83.77, 196.59, 89.21, 177.07, 92.85, 162.55, 101.02, 175.71, 104.19, 189.33, 106.46, 203.4, 106.01, 206.58, 120.53, 213.84, 121.44, 211.57, 122.8, 209.76, 113.27, 200.68, 111.91, 197.5, 109.64, 173.44, 106.92, 153.93, 107.37, 136.68, 104.19, 118.52, 94.66, 113.53, 99.2, 106.27, 95.57, 98.1, 88.76, 95.37, 85.58, 95.37, 82.86, 108.99, 81.04, 114.89, 78.32, 119.43, 69.7, 139.4, 71.51, 153.93, 74.69, 157.1, 78.77, 157.1, 81.95, 163.0, 76.96, 193.42, 76.05, 205.8, 75.14, 213.06]], "area": 2735.70945, "iscrowd": 0, "image_id": 18491, "bbox": [69.7, 95.37, 53.1, 122.1], "category_id": 1, "id": 1277912}, {"segmentation": [[65.21, 119.75, 60.06, 111.38, 61.77, 104.08, 61.56, 99.78, 60.06, 95.06, 58.77, 89.69, 59.41, 80.25, 62.63, 75.74, 67.14, 71.01, 66.93, 65.22, 71.65, 61.57, 79.16, 63.28, 80.02, 72.09, 87.32, 76.38, 89.47, 87.76, 88.83, 90.34, 95.05, 97.42, 89.9, 96.13, 86.46, 95.92, 83.89, 100.21, 81.1, 106.01, 82.17, 109.02, 80.24, 114.81, 76.59, 117.18, 79.16, 108.16, 77.45, 104.08, 74.23, 103.65, 71.22, 107.3, 70.36, 110.52, 69.5, 115.24, 68.21, 117.61, 67.14, 118.25]], "area": 1137.3147999999997, "iscrowd": 0, "image_id": 18491, "bbox": [58.77, 61.57, 36.28, 58.18], "category_id": 1, "id": 1280740}, {"segmentation": [[122.79, 118.53, 125.71, 85.54, 133.23, 74.68, 138.66, 50.04, 141.16, 44.61, 150.35, 26.65, 157.04, 35.83, 158.71, 49.2, 164.14, 51.71, 159.96, 126.47, 153.69, 126.47, 151.61, 122.71, 151.61, 115.61, 147.01, 111.01, 146.18, 85.54, 139.08, 84.7, 133.23, 92.64, 132.81, 125.22, 122.79, 126.05]], "area": 2216.2866499999996, "iscrowd": 0, "image_id": 18491, "bbox": [122.79, 26.65, 41.35, 99.82], "category_id": 1, "id": 1287702}, {"segmentation": [[34.51, 146.57, 34.08, 139.27, 37.51, 135.41, 39.88, 134.55, 41.16, 129.18, 42.24, 123.38, 42.45, 120.38, 43.31, 116.08, 44.81, 109.86, 44.81, 104.49, 43.95, 99.98, 35.15, 94.18, 35.37, 86.45, 34.29, 82.59, 29.35, 81.09, 24.63, 83.45, 23.56, 85.81, 20.98, 90.53, 16.9, 98.91, 13.25, 109.86, 13.04, 120.38, 15.18, 129.61, 19.05, 136.91, 23.34, 146.14, 27.85, 147.65, 33.65, 147.0]], "area": 1449.07155, "iscrowd": 0, "image_id": 18491, "bbox": [13.04, 81.09, 31.77, 66.56], "category_id": 1, "id": 1290047}, {"segmentation": [[119.25, 255.0, 117.94, 249.25, 120.29, 241.68, 122.12, 232.01, 120.03, 221.04, 119.51, 218.95, 118.46, 216.33, 117.42, 212.15, 120.81, 204.57, 121.08, 203.27, 119.77, 199.61, 120.29, 196.74, 123.17, 195.69, 127.87, 198.04, 130.22, 199.61, 127.61, 206.66, 127.35, 213.72, 128.91, 221.3, 126.82, 228.35, 126.56, 234.88, 124.47, 244.03, 121.08, 252.65]], "area": 383.46764999999976, "iscrowd": 0, "image_id": 16228, "bbox": [117.42, 195.69, 12.8, 59.31], "category_id": 1, "id": 1291466}, {"segmentation": [[141.05, 219.12, 134.53, 218.3, 133.31, 193.67, 134.94, 190.61, 136.97, 188.98, 140.64, 190.0, 142.06, 201.61, 139.82, 204.46, 141.25, 211.18, 142.88, 213.41, 144.51, 216.67, 143.08, 218.91], [133.11, 200.79, 128.42, 204.46, 127.0, 213.62, 129.44, 220.74, 126.79, 228.28, 125.98, 238.46, 121.5, 250.87, 121.3, 256.78, 124.96, 257.39, 131.88, 257.19, 134.73, 256.57, 131.68, 254.54, 129.24, 252.5, 129.85, 249.86, 132.7, 244.56, 132.5, 213.82, 132.7, 206.29]], "area": 567.2201499999994, "iscrowd": 0, "image_id": 16228, "bbox": [121.3, 188.98, 23.21, 68.41], "category_id": 1, "id": 1294336}, {"segmentation": [[5.27, 92.66, 6.49, 97.29, 10.39, 100.95, 11.85, 110.21, 12.34, 115.57, 10.39, 125.08, 10.14, 133.61, 7.71, 139.95, 5.51, 145.8, 5.51, 145.8, 6.98, 147.51, 0.39, 147.75, 0.39, 83.64, 3.08, 82.91, 4.78, 85.59, 5.51, 87.29]], "area": 550.3268999999999, "iscrowd": 0, "image_id": 18491, "bbox": [0.39, 82.91, 11.95, 64.84], "category_id": 1, "id": 1307857}, {"segmentation": [[39.77, 233.8, 40.52, 240.08, 42.28, 244.61, 40.77, 257.67, 40.52, 262.69, 49.06, 261.69, 49.31, 252.39, 49.56, 251.89, 52.83, 250.38, 53.58, 244.1, 50.32, 236.07, 50.32, 229.79, 51.07, 226.77, 48.31, 220.99, 46.8, 213.96, 48.06, 208.68, 48.81, 203.91, 46.3, 200.9, 38.51, 203.16, 38.26, 211.7, 38.26, 223.0]], "area": 607.4024000000001, "iscrowd": 0, "image_id": 16228, "bbox": [38.26, 200.9, 15.32, 61.79], "category_id": 1, "id": 1311594}, {"segmentation": [[159.23, 219.16, 159.63, 216.1, 159.84, 212.03, 159.23, 210.61, 156.38, 210.61, 156.17, 208.77, 157.6, 207.35, 158.41, 205.72, 158.41, 204.29, 158.82, 201.65, 159.43, 199.82, 161.06, 198.59, 163.71, 197.98, 165.74, 202.67, 166.76, 219.16, 159.63, 219.77]], "area": 151.30675000000025, "iscrowd": 0, "image_id": 16228, "bbox": [156.17, 197.98, 10.59, 21.79], "category_id": 1, "id": 1321605}, {"segmentation": [[149.44, 143.43, 210.85, 141.07, 223.94, 141.29, 223.94, 144.29, 192.6, 146.22, 148.58, 146.65], [142.35, 144.29, 104.57, 144.51, 105.64, 147.73, 139.78, 148.59, 144.93, 148.37, 144.29, 145.79, 143.86, 145.58], [68.07, 146.05, 2.46, 147.53, 0.0, 150.99, 0.49, 152.96, 69.55, 151.97, 71.52, 150.99], [79.91, 146.55, 74.48, 146.55, 74.48, 149.01, 80.4, 149.51]], "area": 845.11925, "iscrowd": 0, "image_id": 18491, "bbox": [0.0, 141.07, 223.94, 11.89], "category_id": 15, "id": 1394556}, {"segmentation": [[408.63, 170.83, 406.8, 193.48, 414.11, 191.65, 415.2, 170.1, 427.26, 163.16, 440.41, 167.55, 461.22, 159.87, 471.09, 163.89, 477.3, 150.01, 470.36, 144.9, 417.4, 129.92, 406.07, 130.66, 376.12, 138.69, 349.82, 154.76, 349.46, 168.64, 356.4, 170.83, 367.72, 166.81, 382.7, 169.01, 396.58, 164.62, 407.17, 166.45]], "area": 3626.221100000001, "iscrowd": 0, "image_id": 16228, "bbox": [349.46, 129.92, 127.84, 63.56], "category_id": 28, "id": 1425221}, {"segmentation": [[591.69, 169.62, 601.49, 164.59, 610.03, 162.08, 615.31, 161.33, 626.36, 165.6, 632.64, 168.36, 633.39, 170.12, 632.14, 172.13, 616.06, 173.38, 604.25, 174.39, 599.23, 174.89, 594.46, 173.89, 591.94, 172.38]], "area": 364.80684999999886, "iscrowd": 0, "image_id": 16228, "bbox": [591.69, 161.33, 41.7, 13.56], "category_id": 28, "id": 1425987}, {"segmentation": [[226.04, 214.83, 224.69, 214.46, 223.08, 216.19, 223.82, 217.8, 223.7, 221.51, 225.67, 228.06, 226.29, 231.15, 225.8, 238.69, 226.66, 241.65, 228.76, 243.88, 228.52, 230.53, 228.76, 225.71, 227.03, 220.03, 225.8, 216.69, 226.54, 215.21]], "area": 80.16185000000007, "iscrowd": 0, "image_id": 16228, "bbox": [223.08, 214.46, 5.68, 29.42], "category_id": 32, "id": 1441803}, {"segmentation": [[428.1, 280.5, 428.38, 272.49, 432.24, 265.86, 438.32, 265.03, 439.7, 264.76, 443.02, 261.72, 445.78, 261.44, 444.12, 265.59, 444.12, 265.59, 446.05, 264.76, 450.75, 264.76, 454.62, 267.8, 455.72, 270.56, 455.72, 270.84, 455.72, 274.15, 455.44, 276.08, 455.44, 276.08, 455.44, 276.36, 455.17, 276.91]], "area": 359.12915000000055, "iscrowd": 0, "image_id": 17182, "bbox": [428.1, 261.44, 27.62, 19.06], "category_id": 53, "id": 1550078}, {"segmentation": [[414.49, 1.91, 507.13, 36.29, 590.22, 100.28, 612.19, 136.57, 639.89, 184.33, 639.89, 0.0], [2.87, 148.03, 33.43, 96.46, 113.65, 42.98, 169.04, 18.15, 217.75, 2.87, 0.96, 2.87], [593.09, 416.4, 621.74, 383.93, 631.29, 361.97, 639.89, 347.64, 639.89, 419.27, 596.91, 419.27], [0.0, 381.07, 13.37, 399.21, 23.88, 412.58, 30.56, 420.22, 1.91, 417.36]], "area": 27365.62059999999, "iscrowd": 0, "image_id": 13597, "bbox": [0.0, 0.0, 639.89, 420.22], "category_id": 67, "id": 1617660}, {"segmentation": [[71.21, 260.41, 72.35, 256.72, 71.5, 251.89, 70.08, 247.63, 68.94, 239.96, 67.81, 234.28, 67.81, 229.46, 68.37, 226.05, 67.52, 221.51, 66.67, 217.53, 69.23, 214.98, 69.51, 212.7, 68.66, 209.86, 69.79, 207.31, 73.49, 205.61, 77.18, 207.88, 77.18, 210.15, 76.61, 212.99, 76.89, 216.4, 77.46, 221.79, 77.18, 227.75, 76.61, 230.59, 76.61, 234.0, 77.18, 236.84, 78.88, 245.07, 80.58, 251.61, 78.31, 255.86, 76.04, 258.99, 75.47, 260.12]], "area": 454.97255, "iscrowd": 0, "image_id": 16228, "bbox": [66.67, 205.61, 13.91, 54.8], "category_id": 1, "id": 1676785}, {"segmentation": [[18.7, 223.18, 18.7, 228.54, 17.04, 230.94, 19.9, 237.41, 22.03, 243.69, 27.75, 252.74, 28.95, 254.41, 29.23, 255.88, 30.71, 259.49, 27.66, 261.43, 25.26, 261.06, 19.25, 251.45, 15.84, 258.19, 15.84, 261.61, 19.81, 262.91, 12.6, 263.28, 8.26, 259.3, 14.17, 252.19, 11.13, 247.57, 9.74, 241.38, 10.39, 238.06, 8.72, 234.55, 11.4, 228.91, 11.59, 225.4, 14.36, 222.72, 17.22, 222.44, 17.31, 222.44]], "area": 418.1907999999998, "iscrowd": 0, "image_id": 16228, "bbox": [8.26, 222.44, 22.45, 40.84], "category_id": 1, "id": 1703142}, {"segmentation": [[264.48, 216.5, 264.48, 212.42, 265.59, 209.83, 267.63, 207.79, 267.91, 207.42, 268.37, 207.24, 268.65, 209.09, 269.29, 214.37, 269.66, 217.52, 266.7, 218.26], [270.41, 206.13, 270.78, 202.33, 271.05, 198.17, 271.98, 196.87, 273.65, 195.67, 275.5, 196.22, 277.16, 198.35, 277.81, 200.67, 278.46, 202.52, 277.81, 204.09, 279.29, 206.78, 281.7, 209.0, 283.09, 211.59, 283.09, 214.18, 281.05, 217.52, 280.87, 217.79, 280.87, 218.91, 279.29, 219.46, 274.48, 219.18, 274.02, 219.18, 271.24, 219.28, 270.59, 218.53]], "area": 254.53865000000008, "iscrowd": 0, "image_id": 16228, "bbox": [264.48, 195.67, 18.61, 23.79], "category_id": 1, "id": 1704592}, {"segmentation": [[530.65, 200.27, 540.31, 199.7, 540.59, 191.46, 547.97, 193.17, 547.97, 193.17, 541.16, 185.5, 537.18, 180.39, 538.6, 177.83, 538.6, 177.83, 536.9, 170.45, 531.22, 175.56, 531.22, 175.56, 533.21, 178.12, 528.67, 186.35, 531.79, 191.18]], "area": 254.42455000000007, "iscrowd": 0, "image_id": 16228, "bbox": [528.67, 170.45, 19.3, 29.82], "category_id": 1, "id": 1705724}, {"segmentation": [[409.89, 280.45, 407.73, 316.04, 403.42, 336.54, 365.66, 336.54, 368.9, 326.83, 384.0, 325.75, 394.79, 276.13, 395.87, 262.11, 386.16, 254.56, 394.79, 235.15, 399.1, 224.36, 399.1, 193.08, 405.57, 180.13, 396.94, 155.33, 401.26, 138.07, 427.15, 142.38, 434.7, 163.96, 431.46, 172.58, 437.93, 196.31, 428.22, 240.54, 432.54, 280.45, 446.56, 334.38, 412.04, 332.22, 414.2, 325.75, 424.99, 323.6, 427.15, 297.71, 412.04, 280.45]], "area": 7072.564200000001, "iscrowd": 0, "image_id": 15956, "bbox": [365.66, 138.07, 80.9, 198.47], "category_id": 1, "id": 1719503}, {"segmentation": [[91.51, 211.77, 93.26, 210.15, 92.18, 207.04, 92.72, 204.21, 94.21, 202.99, 96.91, 202.72, 99.48, 203.13, 99.62, 205.96, 99.08, 209.07, 97.99, 210.29, 98.8, 213.8, 99.75, 216.23, 99.75, 220.02, 99.75, 221.23, 101.37, 222.58, 101.24, 224.75, 100.02, 225.15, 98.94, 224.88, 98.13, 227.85, 97.99, 231.23, 98.67, 232.85, 100.16, 232.45, 102.32, 245.69, 105.56, 248.8, 105.43, 252.04, 104.08, 253.13, 102.86, 251.37, 101.37, 247.31, 100.02, 245.29, 97.05, 243.94, 95.29, 237.18, 95.97, 231.91, 93.8, 227.18, 93.13, 225.56, 91.78, 215.56, 91.64, 212.45], [87.72, 243.8, 85.29, 252.45, 85.02, 255.83, 87.32, 255.96, 89.35, 256.64, 92.18, 257.18, 93.26, 256.5, 91.51, 254.88, 90.16, 254.48, 88.67, 253.8, 90.29, 250.15, 91.37, 247.04, 90.56, 245.42, 88.8, 243.8]], "area": 325.05034999999987, "iscrowd": 0, "image_id": 16228, "bbox": [85.02, 202.72, 20.54, 54.46], "category_id": 1, "id": 1739202}, {"segmentation": [[207.0, 319.27, 123.55, 280.26, 133.3, 262.92, 130.05, 254.25, 126.8, 175.13, 119.21, 169.71, 138.72, 161.04, 139.8, 151.29, 222.17, 135.03, 295.86, 136.12, 299.11, 150.21, 346.8, 156.71, 335.96, 163.21, 339.21, 295.43, 290.44, 312.77, 290.44, 300.85, 259.01, 303.01, 237.34, 314.94]], "area": 33878.41649999999, "iscrowd": 0, "image_id": 16228, "bbox": [119.21, 135.03, 227.59, 184.24], "category_id": 7, "id": 1795625}, {"segmentation": [[332.13, 266.04, 335.22, 265.2, 336.65, 265.08, 337.12, 263.3, 339.26, 262.59, 341.88, 262.35, 344.85, 263.18, 346.51, 263.78, 348.65, 266.15, 350.08, 267.22, 351.03, 267.22, 351.03, 266.39, 351.03, 265.2, 351.62, 263.78, 352.22, 263.3, 355.19, 263.78, 356.02, 264.73, 356.26, 266.51, 355.78, 267.82, 355.31, 268.53, 355.78, 271.98, 355.78, 275.9, 354.83, 277.44, 353.05, 277.44, 351.98, 277.33, 350.67, 277.09, 350.08, 276.61, 349.25, 276.14, 348.65, 275.66, 348.53, 275.42, 347.46, 275.42, 346.04, 274.83, 345.8, 274.24, 345.56, 274.71, 343.42, 275.9, 344.85, 276.97, 344.85, 278.99, 343.3, 285.29, 341.28, 286.83, 341.05, 284.81, 341.88, 282.2, 342.47, 279.94, 342.71, 278.39, 342.47, 276.85, 341.16, 279.46, 340.93, 281.25, 339.14, 283.62, 337.6, 283.62, 338.67, 281.25, 339.14, 279.35, 339.62, 277.8, 339.98, 276.26, 336.29, 276.49, 334.87, 274.71, 333.44, 269.96, 332.25, 267.7]], "area": 307.4943499999999, "iscrowd": 0, "image_id": 16010, "bbox": [332.13, 262.35, 24.13, 24.48], "category_id": 21, "id": 1820374}, {"segmentation": [[307.58, 285.56, 305.92, 283.07, 305.42, 276.27, 307.08, 273.95, 307.91, 270.31, 309.57, 266.33, 314.37, 264.67, 318.52, 264.17, 322.0, 263.68, 325.81, 263.18, 328.79, 263.68, 330.62, 265.33, 332.44, 269.64, 335.59, 277.93, 338.57, 276.77, 338.9, 278.43, 337.08, 280.09, 337.58, 283.73, 336.58, 287.71, 334.1, 290.2, 330.95, 288.54, 330.45, 287.05, 330.12, 286.72, 330.34, 283.62, 327.5, 282.07, 325.69, 280.13, 324.66, 277.55, 322.98, 287.62, 322.59, 289.56, 321.43, 288.53, 321.3, 286.46, 322.33, 283.62, 323.11, 280.26, 323.62, 277.94, 323.36, 276.77, 321.43, 277.94, 318.2, 277.94, 315.74, 277.94, 315.62, 277.16, 313.16, 281.68, 314.71, 286.98, 316.0, 289.82, 314.84, 289.82, 311.87, 284.52, 310.71, 281.42, 312.13, 278.71, 313.16, 277.16, 311.22, 276.65, 310.19, 282.97, 310.19, 288.92, 309.16, 290.08, 308.64, 288.53, 309.16, 279.62, 309.16, 274.32, 308.9, 274.19, 308.25, 274.71]], "area": 507.7857499999995, "iscrowd": 0, "image_id": 16010, "bbox": [305.42, 263.18, 33.48, 27.02], "category_id": 21, "id": 1820429}, {"segmentation": [[618.39, 161.03, 633.02, 153.29, 633.39, 164.78, 630.61, 165.51, 625.65, 164.78, 618.15, 162.12]], "area": 107.22555000000007, "iscrowd": 0, "image_id": 16228, "bbox": [618.15, 153.29, 15.24, 12.22], "category_id": 28, "id": 1830129}, {"segmentation": [[99.47, 155.72, 105.28, 152.75, 113.5, 151.95, 124.34, 153.55, 132.1, 160.28, 134.04, 163.82, 133.24, 167.47, 135.98, 172.04, 134.15, 182.42, 128.22, 189.15, 117.61, 194.4, 108.59, 194.29, 99.47, 190.41, 92.85, 183.67, 92.16, 179.0, 90.11, 170.44, 90.45, 166.67, 93.19, 162.0]], "area": 1515.3847000000003, "iscrowd": 0, "image_id": 13291, "bbox": [90.11, 151.95, 45.87, 42.45], "category_id": 34, "id": 1844890}, {"segmentation": [[250.6, 211.44, 250.6, 211.44, 246.25, 187.95, 227.1, 185.34, 217.53, 199.26, 217.53, 215.79, 222.75, 218.4, 233.19, 216.66, 237.55, 221.01]], "area": 896.86995, "iscrowd": 0, "image_id": 13291, "bbox": [217.53, 185.34, 33.07, 35.67], "category_id": 34, "id": 1844909}, {"segmentation": [[212.31, 229.71, 215.79, 213.18, 214.92, 201.0, 203.61, 195.78, 190.56, 199.26, 182.73, 210.57, 184.47, 226.23, 191.43, 229.71, 200.13, 232.32]], "area": 954.8293500000001, "iscrowd": 0, "image_id": 13291, "bbox": [182.73, 195.78, 33.06, 36.54], "category_id": 34, "id": 1844920}, {"segmentation": [[256.4, 174.3, 259.6, 170.76, 262.68, 167.45, 265.53, 166.43, 277.4, 165.63, 287.78, 169.62, 294.63, 180.8, 293.71, 181.94, 289.95, 184.45, 286.87, 187.42, 292.12, 188.79, 293.37, 188.33, 293.49, 196.32, 285.73, 203.62, 278.2, 206.13, 270.89, 206.48, 257.54, 200.2, 257.43, 197.8, 258.46, 196.44, 259.48, 193.93, 258.34, 191.76, 254.46, 188.56, 252.41, 184.0, 255.49, 176.7]], "area": 1283.6699499999993, "iscrowd": 0, "image_id": 13291, "bbox": [252.41, 165.63, 42.22, 40.85], "category_id": 34, "id": 1844923}, {"segmentation": [[16.2, 205.04, 15.69, 215.76, 14.41, 221.62, 10.33, 225.19, 9.82, 231.57, 9.06, 242.54, 9.57, 246.11, 7.02, 253.6, 6.51, 200.55, 9.57, 198.51, 10.08, 194.68, 15.69, 194.94, 16.96, 197.74, 18.75, 199.27, 17.22, 201.83, 16.71, 204.89]], "area": 330.39009999999996, "iscrowd": 0, "image_id": 16228, "bbox": [6.51, 194.68, 12.24, 58.92], "category_id": 1, "id": 2018451}, {"segmentation": [[421.16, 266.88, 439.5, 265.02, 444.17, 270.61, 446.34, 276.21, 446.34, 286.16, 446.66, 305.13, 443.24, 292.69, 441.99, 281.81, 437.95, 270.3, 432.35, 269.99]], "area": 197.07139999999964, "iscrowd": 0, "image_id": 16010, "bbox": [421.16, 265.02, 25.5, 40.11], "category_id": 24, "id": 2070488}, {"segmentation": [[225.36, 136.61, 219.27, 142.7, 214.92, 149.66, 213.18, 154.01, 210.57, 156.62, 195.78, 157.49, 170.55, 174.03, 167.94, 177.51, 175.77, 206.22, 164.45, 213.18, 160.97, 214.05, 159.23, 225.36, 159.23, 229.71, 160.97, 232.32, 170.55, 242.77, 176.64, 246.25, 182.73, 251.47, 176.64, 254.95, 174.03, 263.65, 174.9, 267.13, 195.78, 257.56, 197.52, 256.69, 189.69, 243.64, 183.6, 235.81, 187.95, 234.06, 192.3, 241.03, 198.39, 241.03, 201.87, 241.03, 211.44, 239.29, 220.14, 230.58, 225.36, 227.97, 230.58, 228.84, 221.01, 249.73, 217.53, 252.34, 232.32, 261.04, 243.64, 260.17, 238.42, 251.47, 234.94, 249.73, 233.19, 242.77, 241.03, 227.1, 241.9, 222.75, 233.19, 220.14, 225.36, 220.14, 218.4, 213.18, 217.53, 203.61, 219.27, 196.65, 225.36, 187.08, 238.42, 183.6, 244.51, 187.95, 244.51, 187.95, 241.9, 185.34, 237.55, 180.12, 237.55, 172.29, 237.55, 161.84, 237.55, 153.14, 237.55, 141.83, 234.94, 138.35, 230.58, 137.48, 227.1, 137.48]], "area": 5920.345849999999, "iscrowd": 0, "image_id": 13291, "bbox": [159.23, 136.61, 85.28, 130.52], "category_id": 1, "id": 2155598}, {"segmentation": [[528.49, 136.83, 546.54, 143.48, 562.69, 140.63, 562.69, 140.63, 576.94, 128.28, 586.43, 117.83, 586.43, 113.08, 587.38, 109.28, 592.13, 110.23, 600.68, 97.88, 606.38, 87.44, 606.38, 87.44, 603.53, 67.49, 591.18, 54.19, 574.09, 52.29, 566.49, 53.24, 556.04, 62.74, 547.49, 72.24, 537.99, 73.19, 531.34, 77.94, 537.04, 88.39, 537.04, 100.73, 531.34, 113.08, 531.34, 113.08, 528.49, 130.18, 527.54, 136.83]], "area": 4814.376850000001, "iscrowd": 0, "image_id": 18575, "bbox": [527.54, 52.29, 78.84, 91.19], "category_id": 44, "id": 91656}, {"segmentation": [[10.12, 12.47, 221.45, 15.85, 224.82, 1.23, 359.72, 14.72, 483.37, 16.97, 522.72, 3.48, 567.68, 5.73, 640.0, 5.73, 638.5, 472.24, 7.87, 466.62]], "area": 288776.07965, "iscrowd": 0, "image_id": 18575, "bbox": [7.87, 1.23, 632.13, 471.01], "category_id": 67, "id": 121076}, {"segmentation": [[152.16, 149.23, 156.16, 153.54, 162.31, 154.77, 167.85, 156.0, 173.39, 156.62, 180.16, 156.62, 180.16, 154.15, 185.7, 156.0, 218.94, 153.23, 223.55, 155.38, 225.71, 151.69, 229.09, 159.08, 265.71, 156.92, 264.79, 150.15, 273.1, 147.69, 284.79, 148.31, 285.4, 145.23, 265.71, 132.31, 244.48, 124.0, 209.4, 123.07, 184.47, 128.92, 163.54, 138.77, 152.77, 143.08, 152.16, 147.69]], "area": 3273.6866499999996, "iscrowd": 0, "image_id": 16451, "bbox": [152.16, 123.07, 133.24, 36.01], "category_id": 28, "id": 282644}, {"segmentation": [[180.13, 122.97, 154.25, 139.15, 116.49, 158.56, 98.16, 182.29, 87.37, 196.31, 43.15, 208.18, 29.12, 222.2, 28.04, 234.07, 37.75, 280.45, 48.54, 335.46, 56.09, 366.74, 75.51, 403.42, 89.53, 429.3, 111.1, 456.27, 119.73, 470.29, 194.16, 467.06, 145.62, 430.38, 115.42, 407.73, 87.37, 357.03, 99.24, 326.83, 114.34, 288.0, 113.26, 266.43, 116.49, 243.78, 129.44, 220.04, 138.07, 201.71, 142.38, 192.0, 163.96, 169.35, 177.98, 158.56, 187.69, 125.12], [346.25, 220.04, 396.94, 229.75, 394.79, 250.25, 381.84, 275.06, 368.9, 334.38, 364.58, 334.38, 364.58, 273.98, 344.09, 264.27]], "area": 23100.089600000003, "iscrowd": 0, "image_id": 18193, "bbox": [28.04, 122.97, 368.9, 347.32], "category_id": 62, "id": 375844}, {"segmentation": [[180.11, 193.23, 203.49, 194.95, 209.33, 206.98, 206.93, 232.08, 203.32, 241.19, 199.53, 227.09, 186.12, 230.53, 178.73, 235.35, 174.95, 222.45, 175.29, 195.81]], "area": 1203.375250000001, "iscrowd": 0, "image_id": 16451, "bbox": [174.95, 193.23, 34.38, 47.96], "category_id": 62, "id": 377860}, {"segmentation": [[223.93, 230.79, 225.37, 243.79, 244.15, 251.02, 260.05, 243.79, 280.27, 238.01, 293.27, 238.01, 304.83, 243.79, 304.83, 265.46, 309.16, 281.35, 319.28, 294.36, 336.61, 305.91, 339.5, 316.03, 338.06, 327.58, 346.73, 330.47, 351.06, 330.47, 355.4, 342.03, 338.06, 355.03, 326.5, 362.26, 314.94, 375.26, 300.5, 388.26, 293.27, 396.93, 278.83, 399.82, 274.49, 391.15, 239.82, 378.15, 235.49, 373.81, 257.16, 340.59, 257.16, 337.7, 257.16, 323.25, 257.16, 323.25, 252.82, 317.47, 239.82, 330.47, 228.26, 339.14, 199.37, 353.59, 170.47, 355.03, 141.58, 356.48, 131.47, 359.37, 124.24, 359.37, 124.24, 342.03, 135.8, 339.14, 151.69, 340.59, 180.59, 333.36, 200.81, 326.14, 216.7, 313.14, 223.93, 304.47, 235.49, 291.47, 232.6, 284.24, 216.7, 277.02, 206.59, 268.35, 184.92, 255.35, 192.14, 236.57, 193.59, 229.35, 213.81, 226.46, 222.48, 225.01, 225.37, 232.23]], "area": 16779.1999, "iscrowd": 0, "image_id": 18519, "bbox": [124.24, 225.01, 231.16, 174.81], "category_id": 1, "id": 423290}, {"segmentation": [[531.97, 235.61, 526.24, 239.43, 521.46, 243.25, 511.91, 246.11, 513.82, 258.53, 555.84, 250.89, 558.71, 248.98, 559.66, 244.2, 541.52, 184.99, 545.34, 177.35, 560.62, 164.93, 576.85, 145.83, 570.17, 124.82, 537.7, 65.61, 536.74, 59.88, 531.01, 50.33, 525.28, 49.37, 510.96, 46.51, 509.04, 48.42, 488.99, 23.58, 479.44, 19.76, 477.53, 8.3, 470.84, 4.48, 468.93, 8.3, 468.93, 13.08, 473.71, 23.58, 503.31, 52.24, 504.27, 53.19, 501.4, 68.47, 508.09, 78.02, 516.69, 92.35, 518.6, 105.72, 521.46, 108.58, 509.04, 118.14, 502.36, 116.23, 497.58, 117.18, 515.73, 128.64, 525.28, 121.0, 530.06, 118.14, 531.01, 119.09, 531.97, 121.96, 530.06, 137.24, 501.4, 142.01, 492.81, 148.7, 493.76, 163.02, 510.0, 184.99, 512.87, 192.63, 512.87, 192.63, 517.64, 194.54, 515.73, 198.36, 507.13, 198.36, 501.4, 203.14, 499.49, 213.64, 507.13, 213.64, 510.0, 213.64, 515.73, 210.78, 521.46, 206.96, 522.42, 205.05, 523.37, 202.18, 518.6, 186.9, 518.6, 182.12, 520.51, 180.21, 527.19, 191.67, 528.15, 202.18, 535.79, 221.28, 536.74, 227.01, 536.74, 231.79, 535.79, 233.7]], "area": 8977.680499999997, "iscrowd": 0, "image_id": 13546, "bbox": [468.93, 4.48, 107.92, 254.05], "category_id": 1, "id": 479061}, {"segmentation": [[459.08, 97.45, 462.22, 84.86, 459.08, 75.23, 460.45, 64.02, 456.32, 63.82, 455.93, 62.25, 457.31, 58.32, 464.98, 51.63, 464.78, 48.49, 465.96, 48.09, 470.29, 44.55, 474.61, 46.52, 472.84, 53.01, 474.81, 62.64, 470.88, 68.54, 469.89, 85.06, 465.37, 96.47, 467.34, 101.78, 457.7, 100.4]], "area": 570.1451999999997, "iscrowd": 0, "image_id": 13546, "bbox": [455.93, 44.55, 18.88, 57.23], "category_id": 1, "id": 480899}, {"segmentation": [[524.01, 163.14, 522.65, 157.41, 532.47, 160.41, 532.74, 165.6, 532.74, 172.69, 530.02, 180.06, 527.01, 179.51, 518.56, 169.69, 516.92, 165.32, 525.1, 163.96]], "area": 215.9518000000007, "iscrowd": 0, "image_id": 16451, "bbox": [516.92, 157.41, 15.82, 22.65], "category_id": 1, "id": 557373}, {"segmentation": [[107.88, 375.34, 124.12, 365.97, 185.95, 328.5, 197.2, 319.75, 195.32, 331.62, 192.2, 338.49, 180.96, 342.86, 195.32, 345.98, 191.57, 353.48, 180.33, 359.1, 171.59, 358.48, 174.71, 351.61, 169.71, 352.23, 147.23, 369.09, 135.98, 373.47, 143.48, 377.84, 139.73, 381.59, 134.11, 382.21, 130.99, 382.21, 126.61, 384.09, 120.37, 379.71, 119.74, 378.46, 109.13, 379.71, 104.13, 380.34]], "area": 1544.6851499999987, "iscrowd": 0, "image_id": 15597, "bbox": [104.13, 319.75, 93.07, 64.34], "category_id": 41, "id": 639627}, {"segmentation": [[510.23, 212.53, 525.35, 208.95, 533.05, 231.22, 534.15, 237.81, 523.43, 245.79, 518.2, 245.24, 515.73, 240.29, 510.23, 215.0], [520.95, 254.86, 532.77, 254.86, 541.84, 252.66, 547.34, 252.11, 550.09, 252.93, 548.17, 256.51, 536.35, 258.71, 523.98, 258.43, 519.3, 257.61, 518.48, 254.58]], "area": 713.107399999998, "iscrowd": 0, "image_id": 13546, "bbox": [510.23, 208.95, 39.86, 49.76], "category_id": 41, "id": 644648}, {"segmentation": [[246.37, 329.25, 264.74, 351.79, 280.6, 364.32, 298.97, 371.0, 321.52, 363.48, 329.87, 345.95, 322.35, 325.91, 308.99, 305.87, 283.11, 295.85, 264.74, 292.51, 246.37, 298.36, 239.69, 309.21, 243.87, 315.89]], "area": 4650.782999999999, "iscrowd": 0, "image_id": 16451, "bbox": [239.69, 292.51, 90.18, 78.49], "category_id": 42, "id": 648278}, {"segmentation": [[623.02, 384.94, 576.05, 379.99, 520.42, 198.28, 513.0, 174.79, 489.52, 161.19, 462.32, 45.0, 452.43, 9.15, 491.99, 37.58, 627.97, 371.34]], "area": 15594.414550000012, "iscrowd": 0, "image_id": 15079, "bbox": [452.43, 9.15, 175.54, 375.79], "category_id": 49, "id": 694531}, {"segmentation": [[611.54, 234.66, 542.55, 263.75, 534.24, 254.61, 510.13, 261.26, 481.04, 271.23, 475.22, 250.45, 475.22, 247.13, 496.84, 237.15, 514.29, 232.17, 524.26, 220.53, 545.88, 213.88, 561.67, 211.39, 612.0, 191.44]], "area": 5149.121449999999, "iscrowd": 0, "image_id": 10583, "bbox": [475.22, 191.44, 136.78, 79.79], "category_id": 49, "id": 697623}, {"segmentation": [[524.48, 43.07, 526.06, 37.99, 549.14, 27.41, 568.37, 65.88, 565.49, 110.12, 552.98, 129.35, 623.19, 391.9, 615.5, 398.63, 601.07, 391.9, 545.29, 145.7]], "area": 7438.18450000001, "iscrowd": 0, "image_id": 15254, "bbox": [524.48, 27.41, 98.71, 371.22], "category_id": 50, "id": 701534}, {"segmentation": [[391.5, 173.74, 381.9, 186.22, 380.94, 199.65, 382.86, 333.99, 386.7, 363.73, 404.93, 384.84, 467.3, 390.6, 573.81, 382.92, 592.04, 356.06, 552.7, 183.34, 540.23, 173.74, 460.58, 163.19, 391.5, 171.82]], "area": 41047.939, "iscrowd": 0, "image_id": 15254, "bbox": [380.94, 163.19, 211.1, 227.41], "category_id": 51, "id": 714498}, {"segmentation": [[65.25, 166.96, 358.87, 168.88, 372.31, 185.19, 376.14, 279.23, 379.02, 361.75, 374.22, 378.06, 351.2, 383.82, 242.77, 380.94, 9.6, 375.18, 1.92, 366.55, 1.92, 351.2, 40.3, 181.36, 50.86, 169.84, 64.29, 166.0]], "area": 75021.1945, "iscrowd": 0, "image_id": 15254, "bbox": [1.92, 166.0, 377.1, 217.82], "category_id": 51, "id": 1038814}, {"segmentation": [[341.6, 165.04, 81.56, 166.0, 71.01, 154.49, 63.33, 134.34, 90.2, 31.67, 111.31, 15.35, 155.45, 10.56, 215.9, 8.64, 276.35, 9.6, 333.92, 9.6, 363.67, 23.03, 365.59, 75.8, 370.39, 126.66, 367.51, 158.33, 353.11, 167.92, 334.88, 166.96, 322.41, 166.0]], "area": 44504.08415000002, "iscrowd": 0, "image_id": 15254, "bbox": [63.33, 8.64, 307.06, 159.28], "category_id": 51, "id": 1039006}, {"segmentation": [[397.86, 33.16, 400.88, 165.78, 441.07, 158.74, 418.96, 21.1, 402.89, 34.16]], "area": 4220.173699999998, "iscrowd": 0, "image_id": 15254, "bbox": [397.86, 21.1, 43.21, 144.68], "category_id": 57, "id": 1061708}, {"segmentation": [[479.12, 28.67, 502.18, 48.71, 521.22, 159.97, 503.18, 155.97, 473.11, 27.66]], "area": 2562.5592000000006, "iscrowd": 0, "image_id": 15254, "bbox": [473.11, 27.66, 48.11, 132.31], "category_id": 57, "id": 1063967}, {"segmentation": [[404.84, 11.58, 378.66, 19.64, 383.7, 68.98, 381.68, 91.14, 379.67, 127.4, 387.72, 149.55, 395.78, 155.59, 403.84, 155.59, 397.79, 33.74, 406.86, 26.69]], "area": 2694.4661499999984, "iscrowd": 0, "image_id": 15254, "bbox": [378.66, 11.58, 28.2, 144.01], "category_id": 57, "id": 1064137}, {"segmentation": [[279.46, 164.06, 286.9, 167.25, 289.56, 172.04, 287.43, 184.8, 278.92, 195.97, 271.48, 196.5, 260.31, 190.65, 256.59, 187.46, 253.93, 180.01, 251.8, 173.63, 265.63, 172.57, 270.42, 172.57, 278.39, 172.57, 278.39, 171.51, 270.95, 160.34]], "area": 765.5433000000003, "iscrowd": 0, "image_id": 18193, "bbox": [251.8, 160.34, 37.76, 36.16], "category_id": 58, "id": 1067128}, {"segmentation": [[502.61, 398.37, 513.37, 449.85, 524.12, 452.15, 556.39, 452.92, 562.54, 442.17, 565.61, 429.87, 567.92, 415.28, 569.45, 392.23, 569.45, 390.69]], "area": 3329.4693999999986, "iscrowd": 0, "image_id": 16451, "bbox": [502.61, 390.69, 66.84, 62.23], "category_id": 31, "id": 1181954}, {"segmentation": [[565.08, 455.65, 571.52, 459.95, 596.22, 464.24, 606.96, 459.95, 612.0, 413.77, 611.26, 390.14, 597.3, 380.47, 580.11, 381.55, 565.08, 378.32, 548.97, 377.25, 535.01, 383.69, 541.45, 391.21, 562.93, 392.29, 570.45, 396.58, 570.45, 409.47, 570.45, 428.8, 567.23, 438.47, 562.93, 448.13]], "area": 3738.074199999998, "iscrowd": 0, "image_id": 16451, "bbox": [535.01, 377.25, 76.99, 86.99], "category_id": 31, "id": 1182620}, {"segmentation": [[110.02, 413.12, 85.21, 358.11, 118.65, 238.38, 122.97, 217.89, 177.98, 154.25, 193.08, 142.38, 183.37, 115.42, 186.61, 66.88, 212.49, 45.3, 265.35, 46.38, 293.39, 79.82, 291.24, 169.35, 303.1, 193.08, 318.2, 189.84, 332.22, 197.39, 344.09, 226.52, 339.78, 307.42, 298.79, 314.97, 300.94, 325.75, 387.24, 340.85, 334.38, 358.11, 319.28, 376.45, 323.6, 409.89, 345.17, 430.38, 420.67, 437.93, 443.33, 429.3, 472.45, 404.49, 481.08, 434.7, 461.66, 472.45, 199.55, 472.45, 143.46, 435.78, 142.38, 424.99, 113.26, 415.28]], "area": 82944.30595, "iscrowd": 0, "image_id": 18193, "bbox": [85.21, 45.3, 395.87, 427.15], "category_id": 1, "id": 1207285}, {"segmentation": [[208.73, 115.35, 296.58, 115.07, 299.04, 120.0, 298.22, 122.19, 285.9, 123.01, 285.63, 137.24, 282.89, 137.79, 280.16, 136.69, 278.52, 122.19, 228.16, 123.56, 225.7, 142.17, 218.59, 142.44, 216.94, 135.87, 217.76, 124.1, 210.1, 124.65, 205.18, 122.74]], "area": 986.5886000000002, "iscrowd": 0, "image_id": 13546, "bbox": [205.18, 115.07, 93.86, 27.37], "category_id": 15, "id": 1395158}, {"segmentation": [[102.78, 116.41, 176.28, 115.16, 176.59, 121.08, 176.28, 123.26, 162.26, 124.81, 161.33, 144.75, 151.05, 144.12, 152.92, 126.99, 102.78, 127.62]], "area": 969.7507500000003, "iscrowd": 0, "image_id": 13546, "bbox": [102.78, 115.16, 73.81, 29.59], "category_id": 15, "id": 1395366}, {"segmentation": [[174.54, 168.45, 211.63, 167.94, 211.63, 163.37, 195.88, 159.3, 185.21, 156.25, 173.53, 161.33, 170.99, 165.4]], "area": 336.8364999999994, "iscrowd": 0, "image_id": 16451, "bbox": [170.99, 156.25, 40.64, 12.2], "category_id": 28, "id": 1427561}, {"segmentation": [[465.04, 101.25, 458.53, 101.08, 456.3, 100.92, 458.61, 99.6, 465.87, 99.35, 467.27, 100.34, 466.61, 101.91]], "area": 16.46515, "iscrowd": 0, "image_id": 13546, "bbox": [456.3, 99.35, 10.97, 2.56], "category_id": 41, "id": 1474947}, {"segmentation": [[0.01, 139.13, 7.42, 135.14, 20.82, 134.85, 15.98, 149.96, 7.71, 189.87, 0.58, 198.13]], "area": 748.6730000000002, "iscrowd": 0, "image_id": 18575, "bbox": [0.01, 134.85, 20.81, 63.28], "category_id": 49, "id": 1524383}, {"segmentation": [[376.59, 15.95, 381.13, 13.22, 402.92, 9.14, 406.55, 19.12, 418.81, 15.04, 426.07, 28.2, 441.95, 32.74, 449.22, 27.75, 469.19, 30.47, 472.37, 29.11, 479.17, 29.11, 498.24, 44.99, 514.12, 115.8, 524.11, 160.74, 502.78, 160.74, 399.29, 159.38, 386.13, 152.11, 379.32, 141.22, 379.32, 73.59, 376.14, 57.7]], "area": 17563.99925, "iscrowd": 0, "image_id": 15254, "bbox": [376.14, 9.14, 147.97, 151.6], "category_id": 57, "id": 1563326}, {"segmentation": [[232.49, 195.35, 264.92, 196.39, 266.47, 211.18, 262.84, 220.26, 269.85, 224.41, 272.96, 222.59, 276.33, 217.66, 277.11, 216.88, 278.41, 221.81, 277.63, 223.11, 272.96, 228.04, 275.29, 251.12, 276.85, 257.35, 268.81, 257.61, 267.25, 256.05, 261.29, 248.53, 247.8, 230.89, 243.13, 230.37, 248.06, 212.47, 260.77, 204.69, 258.95, 201.06, 243.91, 208.06, 228.86, 200.02]], "area": 1278.7054500000006, "iscrowd": 0, "image_id": 16451, "bbox": [228.86, 195.35, 49.55, 62.26], "category_id": 62, "id": 1579921}, {"segmentation": [[437.73, 17.29, 612.0, 106.48, 612.0, 599.1, 610.63, 612.0, 0.0, 612.0, 0.0, 250.56, 65.87, 197.05, 39.79, 180.58, 27.44, 172.35, 9.61, 63.94, 100.17, 62.57, 189.36, 37.87, 215.43, 14.55, 238.76, 2.2, 388.33, 0.0]], "area": 346540.82444999996, "iscrowd": 0, "image_id": 10583, "bbox": [0.0, 0.0, 612.0, 612.0], "category_id": 67, "id": 1619221}, {"segmentation": [[313.33, 460.84, 335.95, 462.89, 367.31, 456.21, 372.97, 452.61, 389.42, 443.36, 420.78, 440.79, 425.41, 438.73, 421.81, 433.59, 425.41, 431.53, 425.92, 420.74, 415.13, 420.74, 399.7, 423.31, 385.31, 427.42, 380.17, 431.02, 374.51, 436.67, 377.6, 439.76, 363.72, 445.93, 359.6, 442.33, 339.55, 443.36, 320.53, 445.41, 311.28, 453.64, 312.82, 459.81]], "area": 1896.0828, "iscrowd": 0, "image_id": 15597, "bbox": [311.28, 420.74, 114.64, 42.15], "category_id": 2, "id": 1765348}, {"segmentation": [[503.19, 543.39, 523.84, 548.41, 565.68, 550.08, 568.47, 550.08, 580.75, 491.5, 580.75, 487.6, 572.94, 465.84, 531.09, 455.79, 526.63, 454.68, 522.72, 453.56, 518.82, 454.68, 513.24, 456.91, 508.21, 460.26, 505.42, 461.37, 507.1, 470.3, 503.75, 471.97, 495.94, 503.78, 499.29, 535.02, 500.96, 541.16, 503.19, 543.39]], "area": 6704.131800000002, "iscrowd": 0, "image_id": 16451, "bbox": [495.94, 453.56, 84.81, 96.52], "category_id": 31, "id": 1837105}, {"segmentation": [[426.95, 483.06, 451.86, 478.22, 474.69, 445.01, 471.93, 400.72, 451.17, 365.44, 436.64, 358.52, 420.72, 350.91, 397.2, 353.67, 384.05, 363.36, 375.06, 382.73, 374.37, 427.02, 381.98, 451.93, 409.65, 480.99, 431.1, 483.75]], "area": 10443.619800000002, "iscrowd": 0, "image_id": 16451, "bbox": [374.37, 350.91, 100.32, 132.84], "category_id": 42, "id": 1862621}, {"segmentation": [[504.48, 73.76, 479.71, 87.91, 467.92, 105.02, 459.66, 125.07, 464.97, 142.76, 472.63, 157.5, 492.1, 165.17, 510.97, 159.86, 528.66, 135.68, 533.97, 105.02, 537.51, 90.86, 532.79, 80.25, 520.4, 74.35, 503.89, 71.99]], "area": 5052.268299999999, "iscrowd": 0, "image_id": 18575, "bbox": [459.66, 71.99, 77.85, 93.18], "category_id": 44, "id": 1865579}, {"segmentation": [[476.26, 91.01, 468.78, 66.08, 480.0, 37.4, 486.23, 29.92, 499.95, 9.97, 508.68, 2.49, 538.6, 4.99, 553.56, 26.18, 532.36, 74.81, 508.68, 71.06, 481.25, 87.27]], "area": 4538.105649999999, "iscrowd": 0, "image_id": 18575, "bbox": [468.78, 2.49, 84.78, 88.52], "category_id": 44, "id": 1869111}, {"segmentation": [[368.36, 411.95, 419.07, 455.85, 452.37, 469.47, 515.2, 470.23, 572.72, 442.98, 583.32, 432.38, 603.75, 426.33, 622.68, 420.27, 637.06, 390.0, 631.0, 380.16, 631.76, 361.99, 625.7, 350.64, 624.19, 351.4, 616.62, 290.09, 615.11, 271.92, 598.46, 253.76, 575.75, 224.99, 574.23, 202.29, 562.88, 192.45, 513.68, 196.99, 511.41, 185.64, 498.54, 184.88, 493.25, 190.93, 474.32, 186.39, 454.64, 172.77, 437.99, 162.93, 434.21, 174.28, 428.15, 194.72, 425.88, 198.5, 407.72, 206.83, 383.5, 224.24, 355.49, 264.35, 355.49, 266.62, 330.51, 264.35, 323.7, 268.14, 332.78, 284.79, 339.6, 286.3, 344.14, 292.36, 331.27, 299.17, 323.7, 322.63, 317.65, 346.86, 328.24, 371.83, 341.11, 391.51, 372.14, 411.95]], "area": 68002.80745000002, "iscrowd": 0, "image_id": 18575, "bbox": [317.65, 162.93, 319.41, 307.3], "category_id": 51, "id": 1903575}, {"segmentation": [[1.97, 293.31, 17.6, 321.28, 43.92, 336.08, 62.84, 341.02, 74.36, 341.02, 101.5, 340.2, 117.13, 331.97, 116.31, 360.76, 124.53, 379.68, 141.8, 407.64, 167.3, 416.69, 201.85, 425.74, 251.2, 396.13, 263.54, 368.98, 268.48, 332.79, 262.72, 295.26, 259.43, 294.44, 245.45, 296.91, 223.24, 270.58, 203.5, 259.07, 196.92, 260.71, 201.03, 283.75, 204.32, 295.26, 198.56, 301.02, 197.74, 296.08, 182.93, 268.12, 179.64, 268.94, 182.11, 285.39, 171.42, 287.86, 162.37, 283.75, 144.27, 222.92, 122.06, 203.18, 106.43, 192.49, 76.82, 191.67, 59.55, 191.67, 34.87, 196.6, 21.71, 205.65, 10.2, 222.1, 1.97, 236.08]], "area": 36377.26175000001, "iscrowd": 0, "image_id": 18575, "bbox": [1.97, 191.67, 266.51, 234.07], "category_id": 54, "id": 1908510}, {"segmentation": [[197.13, 351.31, 233.48, 345.81, 351.31, 278.63, 351.31, 274.22, 384.35, 263.21, 383.25, 241.18, 371.14, 233.48, 379.95, 223.56, 377.75, 197.13, 337.0, 165.19, 298.45, 145.37, 262.11, 125.55, 210.35, 113.43, 183.92, 103.52, 139.86, 112.33, 90.31, 120.04, 60.57, 136.56, 60.57, 159.69, 71.58, 188.32, 58.37, 200.44, 55.06, 223.56, 62.77, 259.91, 87.0, 298.45, 127.75, 332.59, 153.08, 332.59, 179.51, 352.42]], "area": 58874.72895, "iscrowd": 0, "image_id": 15079, "bbox": [55.06, 103.52, 329.29, 248.9], "category_id": 54, "id": 1909873}, {"segmentation": [[206.59, 108.29, 203.36, 96.3, 204.29, 83.86, 223.65, 65.88, 269.75, 17.93, 284.51, 10.09, 326.0, 8.25, 372.57, 13.32, 403.92, 25.3, 430.2, 37.29, 444.95, 47.43, 456.94, 64.49, 457.86, 67.26, 461.55, 82.47, 476.76, 131.8, 470.31, 162.23, 461.08, 180.21, 438.49, 216.17, 405.3, 223.09, 393.77, 222.17, 377.64, 200.96, 337.53, 162.23, 308.94, 143.33, 248.55, 122.12]], "area": 35861.601400000014, "iscrowd": 0, "image_id": 15079, "bbox": [203.36, 8.25, 273.4, 214.84], "category_id": 54, "id": 1910679}, {"segmentation": [[539.5, 341.23, 543.93, 328.59, 549.93, 316.9, 554.67, 310.59, 559.41, 307.43, 578.37, 306.48, 612.0, 310.27, 612.0, 343.44, 605.54, 383.89, 576.15, 383.25, 533.19, 379.78, 530.66, 369.67, 532.24, 357.66]], "area": 5286.277399999999, "iscrowd": 0, "image_id": 16451, "bbox": [530.66, 306.48, 81.34, 77.41], "category_id": 62, "id": 1932578}, {"segmentation": [[326.63, 134.39, 328.07, 121.42, 315.58, 117.58, 319.42, 110.37, 341.04, 113.73, 366.51, 112.77, 397.26, 111.33, 393.42, 117.1, 386.69, 118.06, 385.73, 127.67, 381.89, 130.55, 377.56, 125.26, 379.48, 119.5, 334.32, 124.3, 333.36, 134.87]], "area": 816.1281500000002, "iscrowd": 0, "image_id": 13546, "bbox": [315.58, 110.37, 81.68, 24.5], "category_id": 15, "id": 2061131}, {"segmentation": [[415.43, 118.1, 413.9, 115.22, 413.73, 111.33, 418.31, 110.31, 490.83, 107.77, 491.34, 110.14, 491.17, 112.34, 489.31, 114.21, 486.42, 115.39, 475.41, 116.07, 474.22, 116.92, 473.72, 130.13, 468.97, 130.47, 467.79, 129.46, 467.45, 117.43, 433.05, 117.93, 431.69, 122.0, 432.03, 132.34, 427.63, 133.69, 423.73, 129.8, 423.39, 118.61, 417.8, 119.12]], "area": 832.2201000000006, "iscrowd": 0, "image_id": 13546, "bbox": [413.73, 107.77, 77.61, 25.92], "category_id": 15, "id": 2062913}, {"segmentation": [[495.25, 510.78, 502.1, 486.59, 507.12, 470.61, 507.12, 465.13, 509.86, 460.57, 515.79, 455.54, 519.45, 451.89, 525.84, 450.98, 539.08, 458.74, 550.03, 460.57, 566.01, 463.3, 571.03, 463.76, 576.96, 471.07, 579.7, 483.39, 578.79, 498.45, 575.14, 512.61, 575.14, 512.61]], "area": 3979.3375999999994, "iscrowd": 0, "image_id": 16451, "bbox": [495.25, 450.98, 84.45, 61.63], "category_id": 27, "id": 2071818}, {"segmentation": [[8.7, 203.24, 42.41, 191.62, 52.87, 191.62, 72.05, 196.56, 91.22, 200.04, 103.43, 200.92, 102.56, 197.14, 91.8, 196.56, 93.84, 190.45, 99.36, 186.68, 106.33, 184.93, 110.98, 178.54, 124.35, 177.38, 131.03, 179.7, 132.48, 188.42, 138.59, 191.33, 141.49, 198.01, 143.24, 211.38, 132.77, 213.41, 129.58, 213.41, 138.3, 221.55, 140.62, 225.9, 149.92, 240.14, 161.83, 262.52, 176.94, 277.63, 182.17, 283.44, 191.47, 301.16, 203.67, 314.82, 201.06, 324.12, 195.25, 319.47, 183.92, 308.43, 173.45, 292.74, 158.64, 279.37, 160.67, 293.61, 166.77, 307.56, 176.36, 322.96, 185.66, 320.92, 192.34, 321.79, 183.62, 330.8, 164.16, 339.23, 149.63, 316.85, 151.37, 309.01, 144.4, 295.93, 141.49, 279.08, 131.03, 275.59, 111.56, 271.23, 106.91, 276.17, 104.59, 297.09, 105.46, 313.95, 109.53, 332.54, 110.69, 340.68, 113.6, 343.59, 118.54, 344.17, 119.99, 346.2, 121.15, 365.96, 111.85, 375.55, 99.07, 375.84, 98.49, 371.48, 103.43, 365.38, 98.49, 344.46, 90.06, 323.25, 82.22, 294.77, 79.02, 270.65, 82.8, 241.89, 88.03, 234.04, 87.74, 221.26, 79.89, 212.54, 67.69, 209.05, 52.0, 203.24, 44.44, 202.08, 37.76, 205.27, 32.82, 207.31, 20.32, 209.34, 24.68, 218.93, 17.42, 215.15, 19.74, 223.87, 16.55, 224.16, 9.28, 211.09]], "area": 10613.482650000002, "iscrowd": 0, "image_id": 15597, "bbox": [8.7, 177.38, 194.97, 198.46], "category_id": 1, "id": 2159220}, {"segmentation": [[363.13, 0.0, 359.23, 30.84, 346.57, 53.24, 327.09, 74.67, 322.22, 75.64, 292.03, 79.54, 278.4, 76.61, 259.89, 62.01, 242.36, 41.55, 234.57, 27.92, 231.65, 1.62]], "area": 8008.663750000001, "iscrowd": 0, "image_id": 18575, "bbox": [231.65, 0.0, 131.48, 79.54], "category_id": 46, "id": 2183095}, {"segmentation": [[221.88, 129.87, 233.63, 151.02, 252.42, 169.81, 295.88, 196.82, 335.81, 205.04, 398.06, 209.74, 436.82, 202.69, 440.34, 180.38, 427.42, 149.84, 403.93, 129.87, 383.96, 107.56, 374.57, 92.29, 351.08, 77.02, 315.84, 81.72, 288.83, 64.1, 251.24, 66.45, 241.85, 81.72, 233.63, 95.81, 227.75, 100.51, 233.63, 107.56, 220.71, 122.83]], "area": 21564.3236, "iscrowd": 0, "image_id": 10583, "bbox": [220.71, 64.1, 219.63, 145.64], "category_id": 54, "id": 2219494}, {"segmentation": [[94.97, 340.17, 110.04, 308.51, 170.33, 246.71, 179.38, 230.13, 171.84, 195.46, 155.26, 186.41, 174.86, 180.38, 174.86, 162.3, 206.51, 139.68, 221.59, 135.16, 254.75, 162.3, 289.42, 187.92, 322.58, 203.0, 394.94, 207.52, 426.59, 207.52, 450.71, 203.0, 464.28, 209.02, 462.77, 230.13, 479.35, 269.32, 471.81, 358.26, 471.81, 397.45, 443.17, 433.63, 396.44, 453.22, 342.18, 472.82, 280.37, 456.24, 274.34, 424.58, 232.14, 420.06, 132.65, 389.91, 107.02, 368.81, 90.44, 344.69]], "area": 83762.15575, "iscrowd": 0, "image_id": 10583, "bbox": [90.44, 135.16, 388.91, 337.66], "category_id": 54, "id": 2219694}, {"segmentation": [[294.54, 190.25, 295.75, 185.14, 293.32, 181.74, 291.86, 179.31, 289.19, 181.74, 290.89, 176.63, 291.13, 176.39, 289.92, 172.74, 292.35, 171.04, 293.32, 167.39, 293.32, 164.71, 295.27, 161.55, 294.16, 157.88, 292.65, 156.04, 293.82, 153.7, 294.16, 150.35, 294.83, 149.35, 294.16, 144.5, 297.34, 143.49, 299.34, 144.33, 299.85, 142.99, 302.19, 140.48, 304.36, 141.48, 303.86, 145.0, 303.86, 147.0, 305.7, 149.35, 305.37, 151.35, 303.53, 152.86, 302.69, 154.7, 301.85, 157.21, 301.52, 158.71, 302.36, 159.89, 304.03, 158.88, 304.36, 158.21, 306.2, 157.71, 307.37, 159.22, 307.88, 159.22, 310.39, 158.55, 312.73, 159.72, 313.06, 162.9, 311.39, 164.07, 312.73, 165.57, 314.74, 166.58, 314.23, 168.75, 308.71, 168.92, 307.21, 169.59, 306.87, 171.93, 309.05, 173.77, 307.71, 177.45, 307.04, 178.46, 304.36, 181.13, 303.19, 182.3, 304.2, 184.64, 303.53, 184.81, 307.2, 189.47, 306.63, 193.64, 306.06, 197.05, 303.6, 198.57, 297.72, 200.65, 295.45, 200.27, 294.5, 198.0, 295.45, 195.35, 295.64, 194.21, 294.69, 193.07, 292.61, 192.5, 291.85, 190.8, 292.61, 190.04, 293.55, 189.85, 294.12, 189.28]], "area": 750.6299500000002, "iscrowd": 0, "image_id": 13923, "bbox": [289.19, 140.48, 25.55, 60.17], "category_id": 64, "id": 25639}, {"segmentation": [[265.95, 199.8, 270.84, 200.52, 276.47, 200.16, 277.55, 197.62, 279.01, 192.36, 278.1, 190.18, 274.47, 188.37, 272.84, 185.65, 272.84, 180.75, 273.02, 176.76, 274.29, 170.95, 274.29, 168.05, 272.48, 165.88, 272.48, 160.98, 273.02, 155.9, 274.29, 154.27, 272.11, 152.63, 268.67, 160.43, 265.95, 163.34, 263.59, 160.8, 262.86, 162.97, 261.95, 170.41, 262.14, 174.58, 260.68, 175.85, 263.22, 179.06, 264.31, 181.24, 264.31, 184.32, 266.67, 184.32, 267.94, 184.86, 267.4, 188.49, 262.14, 188.67, 262.14, 190.67, 261.05, 192.12, 261.59, 195.75, 263.59, 198.29, 266.85, 199.74]], "area": 467.7418500000002, "iscrowd": 0, "image_id": 13923, "bbox": [260.68, 152.63, 18.33, 47.89], "category_id": 64, "id": 27164}, {"segmentation": [[401.89, 159.68, 400.41, 147.35, 341.21, 143.4, 339.24, 197.66, 397.94, 211.47, 406.82, 205.06, 405.83, 181.88, 389.06, 180.4, 386.59, 166.09, 397.45, 165.11, 396.95, 159.68]], "area": 3536.8818499999998, "iscrowd": 0, "image_id": 13923, "bbox": [339.24, 143.4, 67.58, 68.07], "category_id": 72, "id": 28853}, {"segmentation": [[446.93, 124.66, 480.0, 121.21, 480.0, 41.59, 462.42, 41.59, 420.24, 42.45, 418.09, 101.85, 425.41, 105.72, 426.27, 112.61, 433.59, 113.04, 443.06, 111.74, 446.07, 114.76, 443.49, 122.51]], "area": 4610.519150000002, "iscrowd": 0, "image_id": 12576, "bbox": [418.09, 41.59, 61.91, 83.07], "category_id": 72, "id": 29816}, {"segmentation": [[214.26, 390.13, 219.37, 391.31, 225.54, 391.08, 228.04, 390.01, 229.11, 387.99, 228.04, 359.37, 227.32, 356.05, 224.83, 352.61, 223.88, 351.77, 222.81, 331.35, 221.27, 330.4, 219.25, 330.28, 217.35, 330.64, 215.69, 331.71, 215.81, 333.37, 215.09, 350.94, 214.15, 351.89, 214.15, 353.67, 212.13, 355.93, 213.78, 389.77]], "area": 757.57145, "iscrowd": 0, "image_id": 10707, "bbox": [212.13, 330.28, 16.98, 61.03], "category_id": 44, "id": 84825}, {"segmentation": [[276.95, 260.8, 274.71, 254.51, 276.95, 250.01, 282.35, 242.83, 281.45, 239.23, 281.9, 234.29, 280.55, 232.49, 283.69, 230.69, 289.09, 230.24, 292.23, 230.24, 295.38, 233.39, 294.03, 240.58, 299.42, 246.87, 303.91, 256.75, 307.96, 273.83, 308.41, 287.31, 294.93, 284.61, 281.9, 272.48, 276.95, 259.45, 276.95, 259.45]], "area": 1157.656850000001, "iscrowd": 0, "image_id": 18150, "bbox": [274.71, 230.24, 33.7, 57.07], "category_id": 44, "id": 91276}, {"segmentation": [[524.41, 242.45, 527.11, 241.91, 528.55, 242.99, 528.73, 248.03, 529.27, 253.43, 527.29, 253.79, 528.73, 260.99, 530.17, 261.71, 529.09, 272.86, 527.83, 283.3, 518.11, 282.94, 518.47, 260.09, 522.43, 254.87, 523.51, 242.45, 525.31, 241.91]], "area": 359.65620000000024, "iscrowd": 0, "image_id": 13729, "bbox": [518.11, 241.91, 12.06, 41.39], "category_id": 44, "id": 91322}, {"segmentation": [[244.79, 302.3, 313.81, 285.74, 315.65, 296.78, 329.45, 290.34, 335.89, 279.3, 329.45, 278.38, 335.89, 263.65, 335.89, 237.89, 331.29, 232.37, 306.45, 236.97, 289.88, 240.65, 264.11, 242.49, 260.43, 244.33, 259.51, 267.34, 259.51, 278.38, 242.95, 279.3, 229.14, 280.22, 215.34, 286.66, 213.5, 293.1, 214.42, 333.59, 216.26, 342.8, 250.31, 370.4, 265.03, 365.8, 253.07, 352.92, 245.71, 332.67, 242.03, 305.07, 244.79, 304.15], [265.95, 361.2, 266.87, 367.64, 315.65, 350.16, 325.77, 344.64, 304.61, 331.75, 295.4, 332.67, 314.73, 347.4, 266.87, 361.2]], "area": 7257.563049999998, "iscrowd": 0, "image_id": 13923, "bbox": [213.5, 232.37, 122.39, 138.03], "category_id": 62, "id": 108331}, {"segmentation": [[285.74, 402.45, 276.96, 393.67, 262.59, 386.48, 265.78, 377.7, 253.0, 347.36, 246.62, 340.17, 244.23, 304.24, 312.89, 286.67, 327.27, 329.78, 332.86, 338.57, 324.07, 347.36, 308.9, 355.34, 307.3, 372.9, 313.69, 384.88, 330.46, 399.26, 337.65, 404.84, 311.3, 410.43, 291.33, 402.45, 283.35, 400.06]], "area": 7032.8252999999995, "iscrowd": 0, "image_id": 13923, "bbox": [244.23, 286.67, 93.42, 123.76], "category_id": 62, "id": 108430}, {"segmentation": [[494.95, 363.33, 512.52, 341.77, 527.69, 313.01, 555.64, 330.58, 570.81, 355.34, 543.66, 405.64, 532.48, 413.63, 538.87, 419.22, 514.92, 422.41, 444.65, 419.22, 482.18, 408.04, 502.94, 390.47, 500.54, 375.3, 495.75, 364.13]], "area": 5709.348249999997, "iscrowd": 0, "image_id": 13923, "bbox": [444.65, 313.01, 126.16, 109.4], "category_id": 62, "id": 108630}, {"segmentation": [[474.03, 244.16, 480.49, 246.01, 491.56, 260.77, 491.56, 259.84, 492.48, 282.9, 486.95, 305.03, 485.1, 328.09, 482.33, 338.23, 475.88, 334.54, 436.22, 324.4, 408.56, 333.62, 406.71, 324.4, 410.4, 308.72, 406.71, 292.12, 411.32, 282.9, 413.17, 278.29, 420.54, 277.37, 429.77, 281.98, 434.38, 285.67, 442.68, 283.82, 450.06, 272.75, 462.05, 262.61]], "area": 4938.046050000001, "iscrowd": 0, "image_id": 13923, "bbox": [406.71, 244.16, 85.77, 94.07], "category_id": 62, "id": 109275}, {"segmentation": [[142.55, 60.54, 101.24, 79.17, 97.19, 72.69, 92.33, 72.69, 104.48, 105.9, 107.72, 115.62, 111.77, 131.01, 111.77, 154.5, 106.1, 173.93, 93.95, 186.08, 89.9, 192.56, 72.08, 192.56, 71.27, 204.71, 73.7, 224.96, 85.85, 275.18, 87.47, 283.27, 112.58, 287.32, 145.79, 247.64, 154.7, 248.45, 153.08, 159.35, 152.27, 111.57, 149.03, 58.92, 142.55, 60.54], [123.92, 288.13, 157.13, 293.8, 157.13, 254.93, 150.65, 253.31, 118.25, 285.7], [156.32, 64.59, 166.85, 72.69, 172.52, 96.99, 176.57, 101.85, 186.29, 101.85, 195.19, 165.83, 198.43, 200.66, 214.63, 235.49, 218.68, 253.31, 218.68, 273.56, 213.82, 288.13, 164.42, 244.4], [161.99, 251.69, 162.8, 297.04, 213.82, 305.14, 214.63, 296.23, 164.42, 250.88], [289.96, 159.35, 306.97, 162.59, 322.35, 234.68, 324.78, 273.56, 322.35, 305.95, 320.73, 317.29, 320.73, 318.1, 298.06, 312.43, 294.01, 239.54, 290.77, 195.8, 294.01, 169.88]], "area": 25186.966450000004, "iscrowd": 0, "image_id": 19786, "bbox": [71.27, 58.92, 253.51, 259.18], "category_id": 63, "id": 111323}, {"segmentation": [[540.34, 477.27, 532.58, 433.42, 533.93, 419.93, 544.73, 400.03, 566.65, 344.72, 574.07, 315.04, 576.43, 293.11, 575.42, 289.4, 577.11, 281.65, 580.48, 258.04, 582.5, 247.92, 640.0, 261.41, 640.0, 480.0]], "area": 18650.655, "iscrowd": 0, "image_id": 10707, "bbox": [532.58, 247.92, 107.42, 232.08], "category_id": 63, "id": 113866}, {"segmentation": [[165.65, 264.57, 94.79, 311.51, 95.71, 326.23, 91.11, 327.15, 89.27, 310.59, 56.14, 310.59, 53.37, 286.66, 43.25, 274.7, 34.05, 273.78, 34.97, 256.29, 23.01, 249.85, 14.72, 251.69, 15.64, 238.81, 19.33, 228.68, 76.38, 215.8, 115.03, 202.92, 118.71, 201.08, 132.52, 207.52, 146.32, 205.68, 164.73, 213.96, 171.17, 216.72, 176.69, 235.13, 179.45, 244.33, 175.77, 253.53, 161.05, 266.41]], "area": 11637.646799999997, "iscrowd": 0, "image_id": 13923, "bbox": [14.72, 201.08, 164.73, 126.07], "category_id": 63, "id": 114321}, {"segmentation": [[264.91, 182.17, 264.91, 184.06, 266.17, 229.9, 267.42, 238.07, 270.56, 248.12, 274.96, 229.9, 297.57, 190.34, 296.31, 201.02, 303.85, 195.99, 303.85, 185.94, 309.5, 168.99, 312.01, 159.57, 303.22, 128.16, 302.59, 102.41, 301.34, 91.11, 310.13, 93.62, 286.26, 82.32, 264.91, 84.83, 256.74, 87.34, 240.42, 87.97, 233.51, 94.25, 222.83, 98.65, 214.04, 106.81, 210.9, 128.16, 221.57, 137.58, 227.86, 147.63, 241.04, 163.96, 258.63, 166.47]], "area": 8557.35595, "iscrowd": 0, "image_id": 18150, "bbox": [210.9, 82.32, 101.11, 165.8], "category_id": 63, "id": 115127}, {"segmentation": [[1.03, 238.56, 186.04, 201.56, 203.51, 205.67, 205.57, 210.81, 176.79, 229.31, 171.65, 248.84, 137.73, 255.0, 126.42, 242.67, 78.12, 232.39, 68.87, 251.92, 68.87, 292.01, 81.2, 310.51, 99.7, 312.56, 106.9, 318.73, 153.15, 323.87, 160.34, 339.29, 142.87, 330.04, 119.23, 329.01, 103.81, 334.15, 91.48, 347.51, 92.51, 364.98, 88.39, 395.82, 82.23, 405.07, 81.2, 420.48, 55.5, 427.68, 51.39, 414.32, 17.47, 383.48, 2.06, 300.23, 0.0, 241.64], [196.32, 322.84, 206.6, 314.62, 225.1, 316.67, 235.37, 313.59, 236.4, 339.29, 223.04, 343.4, 224.07, 332.09, 215.85, 333.12, 212.76, 349.56, 199.4, 353.68, 196.32, 327.98]], "area": 18782.9575, "iscrowd": 0, "image_id": 10707, "bbox": [0.0, 201.56, 236.4, 226.12], "category_id": 63, "id": 116290}, {"segmentation": [[111.81, 472.17, 100.52, 390.85, 230.4, 351.32, 308.33, 406.66, 308.33, 474.43, 290.26, 474.43, 283.48, 425.86, 172.8, 458.62, 175.06, 474.43, 141.18, 472.17, 141.18, 458.62, 120.85, 425.86, 128.75, 474.43]], "area": 16145.946999999996, "iscrowd": 0, "image_id": 10707, "bbox": [100.52, 351.32, 207.81, 123.11], "category_id": 67, "id": 120550}, {"segmentation": [[173.39, 2.42, 166.13, 79.03, 176.61, 102.42, 188.71, 107.26, 199.19, 211.29, 208.87, 232.26, 219.35, 244.35, 220.16, 370.16, 271.77, 370.16, 275.81, 356.45, 303.23, 312.1, 295.16, 237.9, 290.32, 204.84, 291.94, 187.9, 294.35, 162.9, 288.71, 147.58, 273.39, 137.1, 258.06, 118.55, 253.23, 108.06, 254.84, 97.58, 261.29, 79.03, 262.1, 59.68, 261.29, 39.52, 271.77, 22.58, 271.77, 16.94, 266.94, 0.81, 172.58, 1.61]], "area": 31031.758850000013, "iscrowd": 0, "image_id": 19786, "bbox": [166.13, 0.81, 137.1, 369.35], "category_id": 1, "id": 187695}, {"segmentation": [[325.02, 445.69, 344.39, 430.62, 346.55, 416.63, 345.47, 375.73, 348.7, 345.6, 361.61, 331.61, 368.07, 316.54, 372.38, 296.09, 384.22, 269.18, 387.44, 251.96, 397.13, 233.67, 396.05, 220.75, 396.05, 207.84, 376.68, 196.0, 367.0, 191.7, 370.22, 183.09, 371.3, 175.55, 372.38, 169.09, 365.92, 155.1, 358.39, 149.72, 347.62, 147.57, 341.17, 147.57, 334.71, 147.57, 322.87, 155.1, 317.49, 162.64, 316.41, 175.55, 317.49, 194.92, 313.18, 198.15, 303.5, 198.15, 285.2, 204.61, 280.9, 214.3, 262.6, 236.9, 251.84, 249.81, 246.46, 263.8, 255.07, 275.64, 259.37, 282.1, 260.45, 287.48, 258.3, 293.94, 252.91, 298.24, 245.38, 299.32, 228.16, 301.47, 232.47, 325.15, 241.08, 334.83, 252.91, 350.98, 260.45, 363.89, 284.13, 385.42, 295.96, 396.18, 299.19, 413.4, 315.34, 413.4, 316.41, 398.33, 280.9, 353.13, 269.06, 324.07, 264.75, 304.7, 265.83, 295.01, 270.13, 288.56, 287.35, 281.02, 299.19, 284.25, 301.35, 291.78, 319.64, 304.7, 319.64, 307.93, 316.41, 316.54, 316.41, 324.07, 316.41, 329.45, 317.49, 346.67, 317.49, 374.65, 321.79, 397.26, 321.79, 401.56, 318.57, 409.09, 314.26, 417.7, 303.5, 445.69, 303.5, 445.69, 316.41, 457.52, 337.94, 436.0, 337.94, 436.0]], "area": 22882.21915000001, "iscrowd": 0, "image_id": 10707, "bbox": [228.16, 147.57, 168.97, 309.95], "category_id": 1, "id": 193096}, {"segmentation": [[302.53, 368.26, 316.85, 322.75, 318.54, 266.29, 310.96, 176.97, 307.58, 145.79, 289.89, 141.57, 265.45, 120.51, 250.28, 91.85, 268.82, 33.71, 287.36, 20.22, 298.31, 16.01, 365.73, 53.09, 364.89, 78.37, 399.44, 101.97, 464.33, 130.62, 479.49, 144.1, 474.44, 369.94, 422.19, 371.63, 435.67, 315.17, 417.98, 323.6, 397.75, 341.29, 356.46, 353.93, 355.62, 367.42, 300.84, 370.79]], "area": 49923.1806, "iscrowd": 0, "image_id": 19786, "bbox": [250.28, 16.01, 229.21, 355.62], "category_id": 1, "id": 196714}, {"segmentation": [[430.28, 187.53, 420.06, 187.84, 411.69, 191.24, 403.02, 198.37, 396.82, 209.83, 398.37, 224.7, 399.92, 230.27, 401.78, 233.99, 401.78, 237.71, 399.3, 241.12, 392.49, 245.76, 389.7, 251.34, 386.6, 261.87, 382.89, 272.71, 377.62, 285.41, 358.28, 322.28, 354.05, 344.82, 348.89, 351.86, 347.01, 366.41, 354.05, 381.91, 360.16, 386.6, 367.67, 391.3, 373.77, 390.83, 385.51, 413.34, 372.37, 429.3, 364.85, 433.53, 359.69, 434.0, 354.99, 439.63, 356.87, 451.37, 367.67, 452.31, 390.21, 449.96, 408.05, 450.88, 413.21, 405.8, 413.21, 405.8, 410.87, 376.22, 417.91, 371.06, 427.3, 374.82, 431.05, 374.82, 443.29, 361.27, 465.98, 360.27, 469.21, 348.4, 465.98, 316.04, 472.45, 253.48, 472.45, 253.48, 471.37, 235.15, 465.98, 222.2, 461.66, 216.81, 453.03, 209.26, 445.48, 212.49, 433.62, 212.49, 431.9, 207.37, 430.96, 194.22, 430.96, 187.65]], "area": 18923.138400000003, "iscrowd": 0, "image_id": 10707, "bbox": [347.01, 187.53, 125.44, 264.78], "category_id": 1, "id": 221149}, {"segmentation": [[293.39, 307.42, 298.79, 339.78, 268.58, 346.25, 286.92, 354.88, 269.66, 358.11, 265.35, 368.9, 288.0, 373.21, 316.04, 363.51, 308.49, 337.62, 318.2, 284.76, 336.54, 221.12, 330.07, 159.64, 322.52, 120.81, 305.26, 94.92, 305.26, 77.66, 285.84, 65.8, 266.43, 73.35, 252.4, 80.9, 262.11, 90.61, 265.35, 111.1, 279.37, 118.65, 270.74, 138.07, 268.58, 196.31, 277.21, 226.52, 277.21, 296.63]], "area": 13876.206750000001, "iscrowd": 0, "image_id": 13729, "bbox": [252.4, 65.8, 84.14, 307.41], "category_id": 1, "id": 222432}, {"segmentation": [[475.69, 34.52, 489.71, 8.63, 511.28, 2.16, 540.4, 5.39, 550.11, 32.36, 536.09, 76.58, 560.9, 94.92, 594.34, 111.1, 600.81, 146.7, 585.71, 213.57, 574.92, 283.69, 569.53, 298.79, 570.61, 335.46, 544.72, 388.31, 528.54, 435.78, 536.09, 472.45, 470.29, 473.53, 474.61, 439.01, 476.76, 396.94, 476.76, 364.58, 476.76, 313.89, 474.61, 265.35, 475.69, 229.75, 480.0, 207.1, 474.61, 180.13, 458.43, 200.63, 440.09, 210.34, 434.7, 211.42, 422.83, 142.38, 423.91, 91.69, 426.07, 75.51, 437.93, 53.93, 445.48, 105.71, 439.01, 122.97, 451.96, 176.9, 464.9, 143.46, 471.37, 114.34, 474.61, 99.24, 467.06, 72.27, 473.53, 45.3, 475.69, 35.6]], "area": 45726.941900000005, "iscrowd": 0, "image_id": 10707, "bbox": [422.83, 2.16, 177.98, 471.37], "category_id": 1, "id": 233159}, {"segmentation": [[397.27, 150.52, 407.3, 132.0, 411.16, 124.29, 408.08, 112.71, 395.73, 107.31, 388.79, 86.48, 391.87, 61.01, 413.48, 54.07, 432.77, 56.38, 439.71, 68.73, 440.49, 84.16, 435.08, 99.59, 459.78, 130.46, 470.58, 179.84, 465.18, 200.68, 459.05, 215.54, 466.34, 221.92, 464.52, 242.88, 455.41, 273.87, 443.56, 288.45, 438.09, 321.25, 460.88, 342.21, 476.37, 372.29, 491.86, 386.87, 475.46, 426.05, 466.34, 432.43, 451.76, 429.7, 462.7, 410.56, 464.52, 394.16, 459.05, 377.75, 419.87, 342.21, 413.49, 380.49, 412.58, 395.98, 377.04, 395.07, 360.63, 392.33, 358.81, 382.31, 386.15, 373.2, 396.18, 362.26, 393.44, 330.37, 389.8, 320.34, 385.24, 312.14, 395.26, 268.4, 387.06, 257.46, 388.88, 246.53, 399.82, 240.15, 400.73, 215.54, 397.09, 166.33, 386.15, 166.33, 371.57, 147.2, 375.22, 140.82]], "area": 21120.806099999983, "iscrowd": 0, "image_id": 13729, "bbox": [358.81, 54.07, 133.05, 378.36], "category_id": 1, "id": 258665}, {"segmentation": [[540.4, 285.32, 540.89, 274.67, 540.89, 264.01, 543.31, 259.17, 544.76, 252.39, 546.7, 246.09, 550.57, 244.64, 551.54, 258.2, 550.09, 284.35, 547.67, 290.65, 540.89, 288.22]], "area": 373.89345000000077, "iscrowd": 0, "image_id": 13729, "bbox": [540.4, 244.64, 11.14, 46.01], "category_id": 44, "id": 288369}, {"segmentation": [[113.66, 289.41, 174.79, 242.61, 209.18, 196.76, 226.37, 189.12, 288.46, 187.21, 439.37, 188.17, 431.73, 332.39, 412.63, 376.33, 95.52, 374.42, 93.61, 312.34, 114.62, 285.59]], "area": 55302.32280000001, "iscrowd": 0, "image_id": 10092, "bbox": [93.61, 187.21, 345.76, 189.12], "category_id": 65, "id": 315160}, {"segmentation": [[132.08, 411.38, 191.14, 368.43, 277.05, 329.77, 373.69, 279.3, 428.46, 244.94, 461.74, 212.72, 588.46, 230.98, 640.0, 243.86, 640.0, 339.43, 635.7, 416.75, 636.78, 473.66, 525.1, 474.73, 429.53, 468.29, 328.59, 471.51, 252.35, 474.73, 197.58, 472.59, 135.3, 471.51, 107.38, 469.37, 132.08, 403.86]], "area": 95589.10889999998, "iscrowd": 0, "image_id": 10995, "bbox": [107.38, 212.72, 532.62, 262.01], "category_id": 65, "id": 315527}, {"segmentation": [[570.26, 279.99, 576.2, 274.05, 581.63, 243.4, 590.04, 236.97, 617.73, 234.99, 628.11, 247.85, 620.69, 298.77, 617.73, 340.31, 609.32, 340.8, 609.82, 309.65, 597.46, 311.63, 585.59, 359.59, 579.66, 357.61, 586.08, 312.62, 568.29, 304.71, 565.81, 279.99, 572.24, 277.02]], "area": 4339.788350000003, "iscrowd": 0, "image_id": 16958, "bbox": [565.81, 234.99, 62.3, 124.6], "category_id": 62, "id": 376025}, {"segmentation": [[344.09, 163.63, 352.38, 59.92, 385.57, 58.26, 416.27, 63.23, 404.66, 166.95, 399.68, 151.18, 352.38, 151.18, 349.07, 166.12]], "area": 5872.678250000003, "iscrowd": 0, "image_id": 19432, "bbox": [344.09, 58.26, 72.18, 108.69], "category_id": 62, "id": 378536}, {"segmentation": [[194.49, 19.09, 222.33, 15.99, 238.57, 17.54, 233.93, 57.75, 224.65, 56.21, 190.62, 53.11, 197.58, 36.1, 196.03, 22.18]], "area": 1569.4438999999998, "iscrowd": 0, "image_id": 19432, "bbox": [190.62, 15.99, 47.95, 41.76], "category_id": 62, "id": 382669}, {"segmentation": [[317.14, 229.91, 348.95, 241.47, 348.95, 281.0, 377.87, 294.49, 327.75, 304.13, 325.82, 359.08, 308.47, 351.36, 319.07, 298.35, 309.43, 287.74, 309.43, 276.18, 309.43, 227.01]], "area": 3605.6617499999984, "iscrowd": 0, "image_id": 16958, "bbox": [308.47, 227.01, 69.4, 132.07], "category_id": 62, "id": 382759}, {"segmentation": [[540.4, 59.0, 587.87, 57.92, 596.49, 73.02, 584.63, 173.33, 580.31, 170.1, 577.08, 157.15, 531.78, 156.07, 529.62, 170.1, 522.07, 170.1, 532.85, 65.47, 532.85, 61.15]], "area": 6399.3884999999955, "iscrowd": 0, "image_id": 19432, "bbox": [522.07, 57.92, 74.42, 115.41], "category_id": 62, "id": 383277}, {"segmentation": [[284.32, 151.89, 287.57, 143.24, 291.89, 124.86, 292.97, 103.24, 292.97, 79.46, 292.97, 63.24, 292.97, 41.62, 295.14, 26.49, 302.7, 16.76, 315.68, 16.76, 341.62, 15.68, 351.35, 23.24, 354.59, 53.51, 348.11, 108.65, 344.86, 128.11, 343.78, 149.73, 342.7, 165.95, 336.22, 162.7, 336.22, 146.49, 320.0, 148.65, 299.46, 147.57, 285.41, 156.22, 282.16, 161.62]], "area": 7672.035949999999, "iscrowd": 0, "image_id": 19432, "bbox": [282.16, 15.68, 72.43, 150.27], "category_id": 62, "id": 384172}, {"segmentation": [[364.87, 20.4, 372.62, 14.51, 412.57, 15.75, 416.6, 18.85, 419.7, 19.16, 415.05, 64.07, 402.97, 60.98, 392.13, 58.81, 356.82, 60.05, 361.46, 31.24]], "area": 2528.3536, "iscrowd": 0, "image_id": 19432, "bbox": [356.82, 14.51, 62.88, 49.56], "category_id": 62, "id": 385840}, {"segmentation": [[420.54, 57.3, 422.7, 33.51, 423.78, 16.22, 434.59, 14.05, 464.86, 14.05, 476.76, 18.38, 480.0, 27.03, 478.92, 52.97, 475.68, 61.62, 455.14, 59.46]], "area": 2511.9208500000004, "iscrowd": 0, "image_id": 19432, "bbox": [420.54, 14.05, 59.46, 47.57], "category_id": 62, "id": 386016}, {"segmentation": [[479.08, 61.7, 479.08, 61.7, 484.06, 25.41, 489.04, 15.44, 536.01, 17.58, 540.28, 28.96, 536.01, 66.68, 526.76, 60.99, 484.77, 59.56, 479.08, 63.12]], "area": 2481.1789999999996, "iscrowd": 0, "image_id": 19432, "bbox": [479.08, 15.44, 61.2, 51.24], "category_id": 62, "id": 387128}, {"segmentation": [[417.16, 60.41, 411.74, 116.75, 417.16, 167.67, 464.83, 167.67, 467.0, 60.41]], "area": 5520.135899999997, "iscrowd": 0, "image_id": 19432, "bbox": [411.74, 60.41, 55.26, 107.26], "category_id": 62, "id": 387701}, {"segmentation": [[224.96, 161.01, 237.0, 58.1, 251.78, 58.64, 282.43, 58.64, 292.84, 63.02, 286.82, 165.39, 278.61, 166.49, 281.89, 147.87, 234.81, 148.97, 229.89, 167.03]], "area": 5495.6161999999995, "iscrowd": 0, "image_id": 19432, "bbox": [224.96, 58.1, 67.88, 108.93], "category_id": 62, "id": 388156}, {"segmentation": [[172.62, 79.18, 173.33, 69.26, 176.16, 60.76, 183.25, 57.22, 196.71, 57.22, 210.17, 56.51, 222.92, 58.64, 232.84, 64.3, 230.71, 77.77, 229.3, 91.93, 225.76, 94.77, 225.76, 108.23, 225.76, 123.82, 224.34, 135.15, 225.05, 141.53, 226.46, 145.78, 226.46, 152.15, 225.05, 155.7, 222.92, 157.82, 220.09, 162.78, 217.25, 166.32, 216.55, 162.78, 211.59, 161.36, 200.96, 160.66, 190.33, 157.82, 184.66, 157.11, 180.41, 153.57, 181.12, 159.95, 179.0, 162.07, 177.58, 159.95, 172.62, 150.03, 172.62, 147.19, 169.08, 141.53, 166.24, 134.44, 166.24, 126.65, 169.08, 107.52, 169.08, 94.77, 172.62, 84.85]], "area": 5778.258949999999, "iscrowd": 0, "image_id": 19432, "bbox": [166.24, 56.51, 66.6, 109.81], "category_id": 62, "id": 388869}, {"segmentation": [[310.63, 376.51, 317.36, 388.05, 336.6, 402.48, 347.18, 408.25, 365.45, 416.9, 402.0, 421.71, 433.73, 422.67, 465.47, 422.67, 491.43, 411.13, 500.09, 392.86, 500.09, 377.47, 500.09, 357.28, 491.43, 349.58, 477.97, 340.93, 460.66, 336.12, 449.12, 335.16, 435.66, 331.31, 423.15, 331.31, 402.96, 326.5, 387.57, 324.58, 363.53, 326.5, 363.53, 327.46, 351.99, 332.27, 338.52, 336.12, 328.91, 339.97, 318.33, 345.74, 309.67, 358.24, 307.75, 363.05, 310.63, 371.7, 310.63, 373.63, 310.63, 377.47]], "area": 15030.829199999998, "iscrowd": 0, "image_id": 13923, "bbox": [307.75, 324.58, 192.34, 98.09], "category_id": 67, "id": 390122}, {"segmentation": [[57.43, 110.25, 62.84, 98.33, 63.93, 80.99, 81.26, 65.82, 91.02, 49.57, 104.02, 34.4, 122.44, 26.82, 144.11, 35.49, 147.36, 49.57, 147.36, 71.24, 149.53, 92.91, 154.94, 113.5, 204.79, 205.6, 209.12, 216.43, 184.2, 219.68, 172.28, 180.68, 157.11, 153.59, 146.28, 136.25, 141.94, 127.58, 128.94, 175.26, 146.28, 225.1, 154.94, 246.77, 161.44, 277.11, 150.61, 303.12, 144.11, 328.04, 138.69, 349.71, 134.36, 368.13, 134.36, 381.13, 136.52, 386.55, 149.53, 395.21, 165.78, 406.05, 172.28, 409.3, 157.11, 412.55, 141.94, 411.47, 127.86, 402.8, 117.02, 400.63, 114.85, 411.47, 102.93, 416.88, 117.02, 429.89, 112.69, 430.97, 100.77, 429.89, 63.93, 427.72, 55.26, 416.88, 62.84, 393.05, 92.1, 308.53, 89.93, 286.86, 70.43, 244.6, 65.01, 218.6, 57.43, 175.26, 55.26, 160.09, 65.01, 111.33, 62.84, 102.66]], "area": 30702.014250000004, "iscrowd": 0, "image_id": 19432, "bbox": [55.26, 26.82, 153.86, 404.15], "category_id": 1, "id": 428692}, {"segmentation": [[360.0, 239.46, 323.24, 180.0, 303.78, 165.95, 260.54, 127.03, 285.41, 70.81, 315.68, 3.78, 477.84, 0.54, 534.05, 62.16, 567.57, 70.81, 593.51, 127.03, 582.7, 169.19, 556.76, 209.19, 541.62, 227.57, 619.46, 257.84, 637.84, 281.62, 636.76, 443.78, 636.76, 475.14, 431.35, 475.14, 364.32, 475.14, 367.57, 465.41, 403.24, 418.92, 404.32, 378.92, 392.43, 323.78, 395.68, 287.03, 367.57, 248.11, 353.51, 232.97]], "area": 117542.00074999998, "iscrowd": 0, "image_id": 19402, "bbox": [260.54, 0.54, 377.3, 474.6], "category_id": 1, "id": 452266}, {"segmentation": [[425.77, 201.2, 429.06, 188.96, 423.41, 180.96, 417.77, 172.02, 407.42, 172.49, 401.77, 167.79, 396.59, 160.73, 387.18, 156.02, 386.71, 142.37, 382.95, 135.32, 373.53, 137.2, 371.18, 133.43, 374.95, 128.73, 382.48, 127.32, 389.06, 122.14, 389.06, 109.43, 398.47, 101.44, 405.53, 96.73, 406.94, 89.2, 414.94, 79.79, 427.18, 70.85, 446.0, 60.97, 448.83, 56.73, 454.0, 43.08, 469.06, 37.91, 478.0, 42.14, 489.76, 34.61, 504.35, 32.73, 506.7, 28.03, 510.47, 27.09, 525.06, 28.03, 539.64, 37.91, 557.06, 47.32, 557.53, 47.79, 566.0, 52.03, 579.17, 61.91, 582.94, 67.55, 585.76, 65.2, 591.41, 59.08, 597.05, 63.79, 597.52, 69.44, 596.11, 81.67, 606.94, 92.49, 606.94, 97.67, 606.94, 102.38, 603.64, 116.02, 608.35, 122.61, 616.82, 129.67, 605.99, 142.85, 605.52, 143.32, 610.23, 155.08, 613.52, 167.31, 616.35, 179.55, 613.99, 181.9, 604.58, 187.55, 603.17, 195.08, 594.23, 201.2, 589.52, 201.67, 587.17, 203.08, 587.17, 205.9, 601.76, 226.61, 622.46, 248.25, 636.11, 250.61, 638.93, 253.9, 639.88, 295.78, 640.0, 389.42, 639.41, 473.65, 617.76, 475.07, 605.52, 475.07, 600.35, 473.18, 597.52, 471.77, 585.29, 476.48, 571.64, 474.13, 560.82, 467.54, 544.82, 464.71, 542.94, 464.24, 537.76, 464.71, 529.29, 465.18, 518.0, 480.0, 406.94, 479.77, 407.42, 477.42, 410.71, 477.42, 417.77, 476.95, 420.59, 476.95, 420.12, 475.07, 425.3, 475.54, 433.77, 474.13, 441.77, 477.89, 448.83, 478.36, 452.12, 471.3, 452.12, 470.36, 452.59, 464.71, 452.59, 462.36, 456.82, 457.66, 456.82, 452.48, 457.77, 446.36, 454.47, 443.54, 434.71, 434.6, 424.83, 427.07, 422.47, 415.77, 421.06, 395.54, 425.77, 378.13, 424.83, 379.07, 408.83, 371.07, 384.36, 357.42, 371.65, 351.31, 365.06, 345.19, 360.83, 336.25, 356.12, 327.78, 358.95, 324.01, 361.3, 319.31, 366.95, 315.07, 371.65, 315.07, 374.0, 315.07, 391.89, 313.66, 406.0, 315.54, 415.41, 323.54, 423.89, 322.6, 425.77, 321.66, 428.12, 318.84, 432.36, 315.07, 434.71, 313.19, 436.59, 310.84, 444.59, 312.72, 447.88, 312.25, 446.0, 302.37, 452.12, 293.9, 472.35, 283.07, 481.29, 271.31, 485.06, 256.72, 487.88, 251.08, 468.59, 253.9, 455.41, 248.25, 454.47, 242.14, 453.53, 240.72, 446.94, 237.9, 444.59, 235.55, 444.59, 229.43, 439.41, 223.78, 439.88, 215.78, 434.24, 212.49, 430.94, 213.43, 425.3, 211.55]], "area": 86553.94925, "iscrowd": 0, "image_id": 18150, "bbox": [356.12, 27.09, 283.88, 452.91], "category_id": 1, "id": 521385}, {"segmentation": [[7.55, 121.89, 44.22, 104.63, 86.29, 80.9, 98.16, 35.6, 112.18, 16.18, 156.4, 2.16, 204.94, 34.52, 222.2, 78.74, 212.49, 122.97, 230.83, 157.48, 276.13, 253.48, 298.79, 273.98, 321.44, 286.92, 326.83, 250.25, 377.53, 226.52, 412.04, 223.28, 389.39, 259.96, 388.31, 302.02, 344.09, 333.3, 294.47, 371.06, 232.99, 387.24, 188.76, 366.74, 94.92, 432.54, 31.28, 432.54, 11.87, 428.22, 3.24, 127.28]], "area": 96617.92659999996, "iscrowd": 0, "image_id": 18150, "bbox": [3.24, 2.16, 408.8, 430.38], "category_id": 1, "id": 532200}, {"segmentation": [[150.92, 248.11, 149.02, 242.4, 161.39, 245.26, 155.68, 252.88, 151.87, 243.35], [139.49, 258.59, 145.21, 255.73, 149.02, 267.16, 139.49, 288.1, 144.25, 349.04, 132.83, 372.84, 123.31, 379.51, 99.5, 375.7, 88.08, 353.8, 94.74, 334.76, 94.74, 325.24, 116.64, 299.53, 126.16, 296.67, 133.78, 285.25]], "area": 3830.6329500000006, "iscrowd": 0, "image_id": 19432, "bbox": [88.08, 242.4, 73.31, 137.11], "category_id": 43, "id": 655150}, {"segmentation": [[163.34, 344.39, 140.27, 215.2, 151.04, 206.74, 176.41, 200.59, 197.18, 202.13, 214.86, 209.05, 217.17, 209.82, 213.32, 296.71, 214.09, 335.93, 209.48, 345.93, 165.65, 345.93]], "area": 8977.492099999998, "iscrowd": 0, "image_id": 12576, "bbox": [140.27, 200.59, 76.9, 145.34], "category_id": 47, "id": 678023}, {"segmentation": [[366.96, 355.72, 365.21, 231.14, 364.34, 219.82, 383.51, 214.59, 406.16, 209.36, 434.91, 212.85, 455.82, 219.82, 453.2, 229.4, 438.39, 323.49, 426.2, 370.53, 407.03, 377.5, 388.74, 377.5, 370.44, 366.17, 368.7, 360.95]], "area": 12199.483799999998, "iscrowd": 0, "image_id": 12576, "bbox": [364.34, 209.36, 91.48, 168.14], "category_id": 47, "id": 678923}, {"segmentation": [[147.81, 414.02, 134.56, 415.67, 126.51, 386.5, 121.92, 367.11, 122.74, 362.02, 127.84, 358.45, 137.03, 357.43, 146.21, 359.98, 148.76, 362.53, 148.76, 372.23, 147.23, 384.47, 147.23, 384.47]], "area": 1162.5563, "iscrowd": 0, "image_id": 10707, "bbox": [121.92, 357.43, 26.84, 58.24], "category_id": 47, "id": 682380}, {"segmentation": [[369.49, 311.12, 351.72, 312.0, 317.07, 297.2, 317.67, 287.43, 330.99, 292.46, 347.87, 297.79, 367.41, 299.27], [480.0, 304.78, 461.25, 305.26, 440.76, 304.29, 442.23, 296.97, 480.0, 298.43]], "area": 881.472649999999, "iscrowd": 0, "image_id": 12576, "bbox": [317.07, 287.43, 162.93, 24.57], "category_id": 48, "id": 686666}, {"segmentation": [[480.0, 493.49, 439.18, 456.56, 392.85, 408.98, 396.61, 403.35, 417.27, 415.24, 449.82, 439.65, 479.87, 464.7]], "area": 1894.063649999999, "iscrowd": 0, "image_id": 12576, "bbox": [392.85, 403.35, 87.15, 90.14], "category_id": 49, "id": 693155}, {"segmentation": [[0.83, 640.0, 446.95, 640.0, 449.93, 608.76, 392.43, 497.73, 370.62, 461.04, 301.22, 414.45, 235.79, 384.71, 133.68, 375.79, 46.43, 392.64, 0.0, 408.5]], "area": 98073.03180000001, "iscrowd": 0, "image_id": 12576, "bbox": [0.0, 375.79, 449.93, 264.21], "category_id": 59, "id": 1073128}, {"segmentation": [[320.36, 300.61, 317.12, 279.04, 317.12, 265.02, 324.67, 249.92, 351.64, 241.29, 378.61, 230.5, 401.26, 227.27, 409.89, 227.27, 412.04, 230.5, 402.34, 244.52, 384.0, 265.02, 355.96, 282.28, 340.85, 288.75, 336.54, 293.06]], "area": 3391.5886999999984, "iscrowd": 0, "image_id": 18150, "bbox": [317.12, 227.27, 94.92, 73.34], "category_id": 59, "id": 1076324}, {"segmentation": [[444.1, 90.17, 448.31, 124.72, 466.01, 131.46, 483.71, 130.62, 482.02, 86.8]], "area": 1499.873349999999, "iscrowd": 0, "image_id": 19786, "bbox": [444.1, 86.8, 39.61, 44.66], "category_id": 73, "id": 1101948}, {"segmentation": [[380.44, 155.15, 378.09, 150.88, 373.61, 147.04, 378.09, 141.7, 385.78, 148.96, 381.72, 149.6, 381.3, 151.95, 386.85, 153.01, 391.97, 157.5, 396.88, 160.27, 396.67, 162.41, 392.4, 166.47, 390.05, 165.4, 390.05, 161.13, 387.92, 159.21, 384.5, 160.49, 382.58, 158.99, 384.29, 157.71, 381.72, 155.58, 380.66, 155.15], [257.42, 270.82, 266.18, 271.25, 266.18, 280.22, 259.99, 279.79, 259.56, 273.17, 257.85, 271.04], [256.78, 278.94, 255.08, 273.6, 250.59, 269.97, 251.45, 274.03, 252.73, 278.51, 257.21, 279.37], [248.43, 280.03, 247.63, 276.04, 244.84, 275.64, 246.04, 279.63, 248.03, 278.43], [237.67, 276.84, 231.69, 272.06, 232.09, 276.84, 237.27, 276.84]], "area": 270.0995000000001, "iscrowd": 0, "image_id": 13729, "bbox": [231.69, 141.7, 165.19, 138.52], "category_id": 75, "id": 1109128}, {"segmentation": [[433.6, 65.92, 434.38, 60.94, 441.2, 57.53, 436.75, 52.81, 439.89, 46.77, 447.5, 48.87, 443.83, 67.23], [430.75, 95.91, 429.06, 102.12, 433.57, 106.07, 431.5, 112.27, 438.84, 113.78, 439.78, 104.94, 443.16, 103.62, 440.91, 96.1]], "area": 326.82705, "iscrowd": 0, "image_id": 10707, "bbox": [429.06, 46.77, 18.44, 67.01], "category_id": 75, "id": 1109589}, {"segmentation": [[445.31, 238.53, 427.04, 223.14, 470.32, 212.56, 497.25, 226.02, 446.27, 242.37]], "area": 1053.42085, "iscrowd": 0, "image_id": 16958, "bbox": [427.04, 212.56, 70.21, 29.81], "category_id": 84, "id": 1144744}, {"segmentation": [[422.83, 312.79, 445.0, 321.56, 452.14, 324.94, 445.13, 328.32, 406.41, 339.1, 401.9, 339.1, 375.72, 325.82, 351.28, 314.67, 349.53, 312.04, 353.29, 309.15, 382.11, 302.39, 391.63, 299.88, 404.16, 304.89, 417.31, 310.03]], "area": 2081.5555500000014, "iscrowd": 0, "image_id": 16958, "bbox": [349.53, 299.88, 102.61, 39.22], "category_id": 84, "id": 1145311}, {"segmentation": [[439.5, 269.92, 438.14, 266.75, 438.14, 261.3, 439.5, 254.49, 439.5, 245.87, 440.41, 240.87, 442.68, 237.7, 443.59, 237.7, 446.31, 237.7, 450.39, 238.15, 452.21, 241.78, 450.39, 247.68, 449.94, 253.58, 449.94, 257.67, 449.94, 264.48, 449.94, 267.65, 441.77, 271.28, 440.86, 271.28]], "area": 353.8353999999995, "iscrowd": 0, "image_id": 13923, "bbox": [438.14, 237.7, 14.07, 33.58], "category_id": 86, "id": 1152315}, {"segmentation": [[385.3, 335.03, 381.51, 360.43, 382.46, 366.3, 387.96, 368.01, 400.65, 367.06, 401.79, 366.11, 400.47, 334.08, 391.75, 331.81]], "area": 612.6138000000011, "iscrowd": 0, "image_id": 13923, "bbox": [381.51, 331.81, 20.28, 36.2], "category_id": 86, "id": 1153517}, {"segmentation": [[281.4, 90.85, 286.01, 97.12, 286.84, 102.99, 279.73, 104.24, 278.47, 108.85, 279.31, 115.55, 279.31, 119.73, 279.31, 124.34, 282.66, 129.78, 284.75, 132.29, 285.17, 133.97, 285.17, 138.57, 296.89, 140.66, 304.43, 140.25, 303.59, 132.29, 301.5, 126.01, 304.85, 118.89, 306.1, 112.61, 304.85, 105.92, 303.59, 101.31, 304.43, 96.29, 298.57, 87.91, 292.71, 87.5, 286.84, 88.75, 279.73, 88.75]], "area": 1124.7253999999998, "iscrowd": 0, "image_id": 16958, "bbox": [278.47, 87.5, 27.63, 53.16], "category_id": 86, "id": 1154080}, {"segmentation": [[23.1, 75.6, 32.5, 84.01, 40.41, 92.41, 28.05, 91.42, 26.56, 96.37, 24.09, 108.24, 29.04, 113.18, 27.55, 122.57, 33.98, 129.0, 35.46, 135.43, 34.47, 136.42, 52.27, 138.39, 57.71, 137.9, 56.23, 129.5, 59.2, 122.57, 62.16, 117.63, 65.13, 113.67, 63.15, 107.25, 62.16, 99.83, 61.17, 94.89, 56.23, 91.42, 50.3, 91.42, 52.27, 86.48, 58.21, 81.54, 62.66, 80.55, 62.16, 77.09, 57.22, 77.58, 45.85, 73.63, 42.88, 73.63, 39.91, 74.12, 33.49, 75.6, 25.57, 76.59]], "area": 1858.8759999999997, "iscrowd": 0, "image_id": 16958, "bbox": [23.1, 73.63, 42.03, 64.76], "category_id": 86, "id": 1156571}, {"segmentation": [[116.62, 138.36, 94.87, 137.86, 96.35, 134.9, 101.29, 130.45, 102.28, 126.0, 99.32, 116.11, 93.38, 107.21, 93.38, 99.79, 96.84, 95.84, 93.38, 87.43, 94.87, 77.05, 95.86, 66.17, 94.87, 53.81, 95.86, 43.92, 107.23, 45.41, 108.71, 63.21, 112.67, 83.48, 110.19, 90.4, 116.62, 97.82, 112.67, 109.19, 109.7, 116.11, 108.22, 126.49, 113.16, 131.93, 117.61, 134.9]], "area": 1395.50215, "iscrowd": 0, "image_id": 16958, "bbox": [93.38, 43.92, 24.23, 94.44], "category_id": 86, "id": 1156677}, {"segmentation": [[220.82, 135.77, 210.39, 125.76, 210.17, 117.88, 211.24, 111.06, 212.73, 107.65, 231.47, 105.1, 243.61, 110.63, 249.57, 124.05, 250.64, 133.64, 251.49, 149.82, 251.07, 155.57, 235.94, 159.83, 229.98, 160.69, 228.49, 149.61, 225.51, 143.22]], "area": 1571.6321000000005, "iscrowd": 0, "image_id": 18150, "bbox": [210.17, 105.1, 41.32, 55.59], "category_id": 27, "id": 1420782}, {"segmentation": [[165.5, 368.35, 171.39, 371.79, 171.89, 374.25, 174.84, 408.66, 181.72, 403.75, 180.74, 372.29, 175.33, 364.42, 173.85, 350.65, 165.0, 348.69, 165.0, 363.93, 162.55, 366.88, 166.97, 368.35]], "area": 507.0550500000008, "iscrowd": 0, "image_id": 10707, "bbox": [162.55, 348.69, 19.17, 59.97], "category_id": 44, "id": 1484033}, {"segmentation": [[427.23, 89.48, 431.99, 99.95, 431.64, 101.25, 429.74, 103.07, 427.49, 105.31, 425.06, 105.75, 422.04, 108.43, 420.22, 107.48, 418.83, 102.37, 418.58, 99.52, 421.26, 92.77, 422.21, 89.48, 423.42, 76.42, 426.36, 76.16, 426.54, 87.15]], "area": 215.77320000000057, "iscrowd": 0, "image_id": 13923, "bbox": [418.58, 76.16, 13.41, 32.27], "category_id": 44, "id": 1488664}, {"segmentation": [[421.97, 80.47, 421.46, 90.15, 419.16, 97.03, 418.91, 102.37, 418.91, 109.51, 415.09, 109.76, 413.31, 100.08, 417.13, 93.21, 418.91, 84.55, 418.4, 79.96, 421.97, 78.64]], "area": 120.71215000000049, "iscrowd": 0, "image_id": 13923, "bbox": [413.31, 78.64, 8.66, 31.12], "category_id": 44, "id": 1490683}, {"segmentation": [[277.85, 191.96, 276.09, 170.4, 276.09, 154.6, 274.59, 145.32, 272.33, 137.55, 272.33, 129.78, 272.33, 126.27, 273.08, 122.5, 277.35, 121.5, 281.11, 120.25, 284.87, 119.5, 294.4, 118.99, 300.66, 118.99, 305.43, 119.24, 308.44, 120.5, 311.2, 122.25, 306.68, 156.86, 304.68, 162.37, 301.92, 170.65, 299.41, 187.45, 297.66, 191.21, 289.63, 194.22, 281.86, 192.46]], "area": 2209.591200000002, "iscrowd": 0, "image_id": 12576, "bbox": [272.33, 118.99, 38.87, 75.23], "category_id": 47, "id": 1506295}, {"segmentation": [[132.07, 359.07, 127.8, 358.85, 126.09, 349.88, 130.79, 344.97, 136.34, 343.69, 143.6, 343.26, 148.94, 343.9, 151.5, 347.11, 150.22, 370.81, 149.37, 371.88, 148.73, 362.48, 145.1, 359.92, 138.48, 358.0, 133.57, 358.21]], "area": 375.7898500000002, "iscrowd": 0, "image_id": 10707, "bbox": [126.09, 343.26, 25.41, 28.62], "category_id": 47, "id": 1506809}, {"segmentation": [[415.65, 168.99, 403.98, 171.11, 395.5, 171.11, 382.25, 168.46, 381.72, 117.05, 410.35, 112.81, 426.25, 115.99]], "area": 2161.795799999999, "iscrowd": 0, "image_id": 12576, "bbox": [381.72, 112.81, 44.53, 58.3], "category_id": 47, "id": 1509406}, {"segmentation": [[2.88, 323.6, 89.17, 319.28, 110.74, 326.47, 143.82, 326.47, 107.87, 337.98, 86.29, 332.22]], "area": 1024.8209000000027, "iscrowd": 0, "image_id": 12576, "bbox": [2.88, 319.28, 140.94, 18.7], "category_id": 48, "id": 1518224}, {"segmentation": [[591.3, 34.48, 601.81, 50.72, 616.14, 69.83, 604.68, 106.13, 583.66, 123.32, 578.89, 120.45, 570.29, 105.17, 566.47, 80.33, 567.42, 57.41, 576.98, 40.21]], "area": 2947.335499999998, "iscrowd": 0, "image_id": 13923, "bbox": [566.47, 34.48, 49.67, 88.84], "category_id": 51, "id": 1536045}, {"segmentation": [[640.0, 128.72, 633.89, 128.1, 623.88, 132.48, 614.18, 150.0, 610.43, 184.42, 614.18, 210.39, 625.76, 227.59, 636.08, 227.59, 640.0, 227.59]], "area": 2431.2010500000047, "iscrowd": 0, "image_id": 13923, "bbox": [610.43, 128.1, 29.57, 99.49], "category_id": 51, "id": 1539705}, {"segmentation": [[536.57, 122.55, 543.23, 117.14, 548.65, 120.89, 556.98, 127.55, 560.32, 133.39, 561.15, 159.64, 555.32, 172.14, 549.48, 180.48, 544.48, 185.06, 536.98, 185.06, 532.81, 177.56, 531.15, 167.14, 531.98, 143.39, 537.4, 122.14]], "area": 1558.4840500000016, "iscrowd": 0, "image_id": 13923, "bbox": [531.15, 117.14, 30.0, 67.92], "category_id": 51, "id": 1540774}, {"segmentation": [[288.92, 480.0, 288.41, 475.58, 281.26, 466.39, 272.59, 459.76, 256.77, 461.8, 222.59, 477.11]], "area": 780.9657500000004, "iscrowd": 0, "image_id": 18150, "bbox": [222.59, 459.76, 66.33, 20.24], "category_id": 59, "id": 1570250}, {"segmentation": [[306.75, 207.74, 316.3, 203.07, 323.94, 200.31, 330.53, 198.4, 337.32, 196.7, 340.93, 196.49, 341.35, 196.49, 349.21, 195.43, 366.41, 196.7, 373.84, 190.76, 379.99, 191.18, 387.21, 193.52, 393.58, 194.37, 398.47, 192.88, 406.53, 192.24, 411.42, 195.43, 416.51, 195.64, 420.55, 195.22, 424.16, 198.83, 425.43, 199.25, 428.4, 196.07, 430.74, 195.43, 434.98, 199.89, 447.3, 201.37, 459.19, 201.16, 470.44, 203.07, 476.6, 206.47, 480.0, 207.74, 479.57, 234.28, 454.52, 232.16, 455.37, 220.27, 448.78, 217.3, 435.2, 212.41, 422.46, 210.72, 392.95, 211.35, 378.51, 215.17, 371.08, 216.87, 367.04, 219.63, 364.92, 226.64, 364.71, 227.91, 341.78, 226.43, 311.42, 223.24, 306.32, 216.24, 306.11, 213.26, 306.53, 206.89]], "area": 3897.9527999999996, "iscrowd": 0, "image_id": 12576, "bbox": [306.11, 190.76, 173.89, 43.52], "category_id": 59, "id": 1571077}, {"segmentation": [[231.63, 202.02, 233.51, 228.37, 248.57, 212.68, 251.71, 197.0, 237.9, 190.1, 220.33, 181.94, 196.49, 176.92, 173.91, 173.16, 156.34, 176.29, 134.38, 181.31, 101.12, 193.86, 87.32, 205.78, 122.46, 205.15]], "area": 3650.014600000002, "iscrowd": 0, "image_id": 12576, "bbox": [87.32, 173.16, 164.39, 55.21], "category_id": 59, "id": 1571233}, {"segmentation": [[538.25, 63.64, 542.56, 19.42, 560.9, 18.34, 593.26, 18.34, 596.49, 29.12, 594.34, 47.46, 595.42, 65.8]], "area": 2525.8217000000013, "iscrowd": 0, "image_id": 19432, "bbox": [538.25, 18.34, 58.24, 47.46], "category_id": 62, "id": 1593544}, {"segmentation": [[590.44, 390.68, 639.32, 393.48, 639.72, 419.92, 639.32, 424.73, 594.85, 426.0, 589.24, 425.53, 589.24, 412.31, 579.62, 395.08, 580.83, 389.47]], "area": 1806.1752000000004, "iscrowd": 0, "image_id": 10092, "bbox": [579.62, 389.47, 60.1, 36.53], "category_id": 62, "id": 1598158}, {"segmentation": [[546.22, 275.9, 546.22, 275.9, 561.34, 268.34, 603.18, 263.69, 639.79, 265.44, 639.21, 342.73, 609.57, 341.57, 610.15, 367.72, 608.99, 390.97, 590.39, 392.13, 594.46, 328.78, 594.46, 328.78, 574.7, 311.93, 568.31, 424.68, 553.2, 425.26, 555.52, 411.31, 554.36, 299.14]], "area": 8324.60595, "iscrowd": 0, "image_id": 10092, "bbox": [546.22, 263.69, 93.57, 161.57], "category_id": 67, "id": 1613191}, {"segmentation": [[92.04, 161.17, 4.31, 220.14, 1.44, 628.59, 477.48, 624.28, 480.0, 176.99, 451.6, 181.31, 438.65, 149.67, 437.21, 141.04, 424.27, 113.71, 350.92, 100.77, 339.42, 112.28, 332.22, 120.9, 332.22, 141.04, 323.6, 135.29, 313.53, 126.66, 289.08, 115.15, 264.63, 132.41, 264.63, 159.74, 238.74, 155.42]], "area": 226460.51669999998, "iscrowd": 0, "image_id": 12576, "bbox": [1.44, 100.77, 478.56, 527.82], "category_id": 67, "id": 1620693}, {"segmentation": [[199.09, 260.48, 196.9, 265.97, 154.1, 274.38, 124.1, 257.55, 170.19, 249.14, 201.29, 259.75]], "area": 1101.245200000001, "iscrowd": 0, "image_id": 10707, "bbox": [124.1, 249.14, 77.19, 25.24], "category_id": 73, "id": 1628363}, {"segmentation": [[233.93, 389.5, 250.62, 363.86, 265.13, 366.04, 252.55, 392.16, 244.09, 395.07, 239.73, 395.07, 237.56, 393.37, 236.1, 392.41]], "area": 516.80155, "iscrowd": 0, "image_id": 10707, "bbox": [233.93, 363.86, 31.2, 31.21], "category_id": 75, "id": 1630006}, {"segmentation": [[257.93, 266.48, 253.11, 265.52, 246.59, 262.14, 249.0, 261.17, 260.35, 261.17, 262.28, 263.83]], "area": 54.222799999999644, "iscrowd": 0, "image_id": 13729, "bbox": [246.59, 261.17, 15.69, 5.31], "category_id": 75, "id": 1630509}, {"segmentation": [[193.97, 119.78, 217.79, 102.57, 225.73, 89.34, 219.11, 50.96, 231.02, 31.11, 254.85, 15.23, 281.31, 36.4, 276.02, 82.72, 274.7, 109.19, 281.31, 134.33, 285.28, 150.21, 281.31, 150.21, 257.49, 151.54, 213.82, 133.01, 199.26, 125.07]], "area": 7332.252549999997, "iscrowd": 0, "image_id": 12576, "bbox": [193.97, 15.23, 91.31, 136.31], "category_id": 1, "id": 1725035}, {"segmentation": [[101.61, 342.07, 101.14, 304.04, 99.26, 280.56, 100.2, 266.48, 97.85, 239.25, 97.85, 227.98, 96.44, 185.8, 95.51, 168.89, 98.32, 162.32, 102.08, 157.63, 109.12, 152.93, 115.69, 152.93, 109.59, 146.83, 104.43, 138.84, 101.14, 134.62, 101.14, 120.09, 99.73, 106.47, 100.2, 101.31, 116.16, 91.45, 126.49, 89.57, 135.88, 90.98, 143.4, 94.74, 147.15, 98.02, 154.19, 114.92, 155.6, 123.85, 157.01, 140.75, 156.54, 144.03, 161.71, 150.14, 181.35, 161.23, 192.62, 180.02, 205.3, 206.78, 220.32, 221.33, 243.8, 259.83, 261.17, 273.92, 257.41, 280.02, 250.84, 283.78, 242.86, 279.55, 236.75, 275.33, 235.82, 278.61, 224.55, 259.83, 196.85, 229.31, 181.35, 203.02, 177.6, 208.66, 184.17, 241.05, 192.15, 265.0, 194.03, 290.82, 191.21, 334.48, 187.46, 340.49, 188.4, 350.82, 197.79, 367.72, 201.07, 395.42, 203.89, 421.72, 207.18, 431.57, 199.19, 433.92, 181.35, 422.65, 175.72, 416.55, 179.0, 413.26, 186.05, 414.67, 175.25, 387.44, 167.27, 361.62, 161.63, 347.53, 157.88, 347.06, 139.1, 350.82, 133.46, 357.39, 128.77, 378.52, 132.99, 400.04, 127.36, 427.75, 115.15, 460.61, 111.4, 475.17, 89.33, 474.23, 82.76, 468.12, 77.59, 462.02, 77.59, 460.14, 78.53, 456.39, 94.96, 449.34, 98.25, 439.48, 99.66, 398.64, 100.6, 362.48, 100.13, 347.46]], "area": 28375.149850000005, "iscrowd": 0, "image_id": 13729, "bbox": [77.59, 89.57, 183.58, 385.6], "category_id": 1, "id": 1729676}, {"segmentation": [[217.89, 224.36, 207.1, 213.57, 197.39, 195.24, 189.84, 174.74, 179.06, 161.8, 166.11, 152.09, 156.4, 142.38, 159.64, 124.04, 161.8, 118.65, 154.25, 107.87, 153.17, 90.61, 157.48, 83.06, 169.35, 79.82, 179.06, 86.29, 196.31, 96.0, 200.63, 103.55, 187.69, 107.87, 194.16, 118.65, 208.18, 138.07, 218.97, 173.66, 228.67, 208.18, 227.6, 226.52], [183.37, 207.1, 220.04, 257.8, 213.57, 314.97, 216.81, 335.46, 209.26, 339.78, 197.39, 343.01, 195.24, 338.7, 201.71, 322.52, 199.55, 290.16, 199.55, 279.37, 190.92, 262.11, 184.45, 237.3, 177.98, 221.12, 174.74, 201.71]], "area": 7349.56295, "iscrowd": 0, "image_id": 13729, "bbox": [153.17, 79.82, 75.5, 263.19], "category_id": 1, "id": 1730702}, {"segmentation": [[0.0, 124.04, 47.46, 84.13, 133.75, 52.85, 225.44, 96.0, 323.6, 176.9, 392.63, 288.0, 394.79, 339.78, 403.42, 412.04, 366.74, 472.45, 336.54, 480.0, 0.0, 478.92, 2.16, 122.97]], "area": 140541.77395000003, "iscrowd": 0, "image_id": 19402, "bbox": [0.0, 52.85, 403.42, 427.15], "category_id": 1, "id": 1734330}, {"segmentation": [[196.54, 139.18, 194.02, 138.97, 192.77, 132.89, 187.74, 129.12, 185.22, 123.25, 185.01, 107.95, 186.48, 105.01, 188.78, 104.38, 191.09, 106.06, 192.77, 112.98, 193.4, 115.07, 205.55, 124.93, 212.68, 139.6, 213.31, 141.28, 210.59, 141.07, 205.55, 136.46, 202.83, 133.94, 199.27, 133.94, 197.8, 136.25, 197.17, 139.39]], "area": 436.96835000000016, "iscrowd": 0, "image_id": 10092, "bbox": [185.01, 104.38, 28.3, 36.9], "category_id": 16, "id": 1814184}, {"segmentation": [[101.27, 428.88, 88.81, 394.61, 92.97, 361.9, 89.33, 349.95, 100.75, 332.82, 124.64, 323.47, 153.2, 329.7, 163.58, 346.32, 161.5, 366.57, 150.6, 370.2, 151.64, 344.24, 138.14, 342.17, 129.31, 344.76, 126.2, 352.03, 126.2, 358.78, 119.97, 365.01, 124.12, 379.03, 103.87, 385.78, 106.47, 425.76, 106.47, 436.14, 106.99, 444.45, 102.31, 446.01, 100.75, 441.34, 77.91, 450.16, 74.27, 443.41]], "area": 3391.0124499999993, "iscrowd": 0, "image_id": 10707, "bbox": [74.27, 323.47, 89.31, 126.69], "category_id": 27, "id": 1825577}, {"segmentation": [[321.67, 288.93, 320.67, 287.29, 320.12, 282.56, 320.12, 279.83, 321.49, 275.83, 323.22, 273.55, 326.49, 271.64, 329.95, 271.0, 334.95, 271.46, 338.5, 273.1, 340.23, 276.01, 342.23, 280.29, 342.05, 284.29, 340.69, 287.66, 336.86, 289.2, 333.22, 290.11, 329.77, 291.21, 322.94, 290.2]], "area": 359.60995, "iscrowd": 0, "image_id": 19432, "bbox": [320.12, 271.0, 22.11, 20.21], "category_id": 37, "id": 1853933}, {"segmentation": [[476.06, 441.83, 446.04, 433.87, 431.95, 413.65, 422.14, 389.14, 419.19, 380.0, 425.8, 385.04, 441.23, 415.28, 424.22, 375.91, 428.32, 374.02, 449.11, 416.22, 451.0, 414.96, 430.84, 376.54, 456.98, 413.07, 458.87, 412.76, 434.93, 370.55, 442.81, 378.74, 472.41, 417.17, 480.0, 429.77, 479.97, 434.49, 480.0, 438.9]], "area": 1719.0022999999992, "iscrowd": 0, "image_id": 12576, "bbox": [419.19, 370.55, 60.81, 71.28], "category_id": 48, "id": 1888354}, {"segmentation": [[21.19, 386.49, 82.29, 304.21, 130.91, 331.64, 211.95, 340.36, 228.16, 347.84, 236.88, 372.78, 234.39, 390.23, 164.57, 421.4, 145.87, 448.83, 114.7, 443.84, 71.06, 466.29, 24.94, 468.78, 6.23, 472.52, 3.74, 398.96]], "area": 23284.81415, "iscrowd": 0, "image_id": 19402, "bbox": [3.74, 304.21, 233.14, 168.31], "category_id": 59, "id": 1924077}, {"segmentation": [[541.85, 378.49, 543.94, 319.87, 538.19, 304.17, 561.22, 304.17, 561.22, 321.97, 560.17, 340.81, 557.03, 383.2, 556.51, 402.57, 551.27, 406.76, 549.7, 403.09, 551.27, 368.55, 548.13, 363.84, 547.09, 382.16], [572.98, 379.41, 593.8, 380.75, 591.12, 371.34, 572.98, 372.02], [573.65, 356.57, 595.15, 357.24, 595.15, 351.86, 575.67, 349.18], [575.67, 339.77, 596.49, 341.79, 594.47, 327.68, 574.32, 310.89, 574.32, 340.44], [617.03, 266.55, 621.06, 224.23, 631.13, 204.74, 640.0, 204.74, 639.87, 267.89, 631.13, 266.55, 623.07, 263.86]], "area": 3310.2827499999967, "iscrowd": 0, "image_id": 10092, "bbox": [538.19, 204.74, 101.81, 202.02], "category_id": 62, "id": 1938423}, {"segmentation": [[444.3, 315.25, 442.2, 308.94, 440.09, 303.16, 451.14, 301.06, 460.6, 298.43, 463.76, 291.59, 464.81, 287.91, 464.81, 282.65, 464.81, 280.02, 477.43, 272.66, 497.94, 244.79, 506.88, 242.16, 515.29, 240.58, 528.44, 240.58, 543.69, 243.21, 555.78, 246.37, 564.2, 250.05, 567.35, 253.2, 568.93, 255.83, 564.72, 297.37, 564.72, 304.21, 563.15, 309.99, 558.94, 322.62, 555.26, 333.66, 551.58, 340.49, 544.74, 345.75, 538.43, 351.01, 537.38, 352.06, 538.43, 355.74, 535.28, 364.68, 525.28, 372.57, 525.81, 376.25, 508.46, 379.93, 511.09, 383.09, 516.87, 385.72, 527.91, 388.87, 534.75, 392.56, 540.01, 396.76, 543.69, 403.6, 545.79, 411.49, 546.32, 415.69, 537.38, 413.59, 533.7, 406.23, 518.97, 399.92, 507.93, 396.24, 498.99, 393.08, 500.04, 394.13, 501.09, 414.12, 502.67, 419.9, 502.15, 423.06, 503.72, 427.79, 493.21, 426.74, 492.15, 420.43, 491.63, 412.54, 490.05, 403.6, 489.53, 394.13, 489.0, 389.4, 487.42, 388.35, 484.27, 388.87, 477.96, 392.56, 466.91, 395.18, 460.08, 397.29, 452.72, 398.34, 452.72, 393.61, 453.77, 388.87, 453.24, 388.35, 454.29, 385.19, 463.23, 383.62, 470.07, 379.93, 474.8, 374.68, 475.33, 373.62, 472.7, 372.05, 461.66, 365.74, 455.87, 363.11, 454.82, 361.0, 454.82, 358.9, 459.03, 356.8, 466.39, 353.12, 473.22, 348.38, 476.38, 339.44, 473.22, 334.18, 469.54, 328.93, 462.18, 323.14, 456.4, 320.51, 449.56, 316.83], [444.3, 388.87, 442.72, 393.61, 437.99, 405.7, 443.25, 407.81, 443.78, 404.65, 443.78, 399.92, 445.35, 393.61]], "area": 13529.487949999999, "iscrowd": 0, "image_id": 16958, "bbox": [437.99, 240.58, 130.94, 187.21], "category_id": 62, "id": 1939880}, {"segmentation": [[447.82, 270.69, 441.13, 269.73, 436.99, 261.77, 436.04, 254.44, 441.77, 251.58, 441.13, 239.47, 439.54, 235.01, 436.04, 231.51, 428.71, 222.27, 429.35, 221.64, 433.81, 221.64, 437.31, 219.41, 443.36, 226.1, 440.18, 213.99, 435.72, 207.62, 434.76, 202.21, 442.09, 201.89, 444.95, 206.35, 457.06, 208.58, 456.1, 213.67, 449.73, 214.31, 457.69, 219.73, 457.38, 223.87, 451.96, 222.91, 451.32, 227.69, 451.64, 236.92, 447.82, 238.52, 448.29, 252.04, 450.59, 257.77, 449.77, 264.32]], "area": 856.5159999999997, "iscrowd": 0, "image_id": 13923, "bbox": [428.71, 201.89, 28.98, 68.8], "category_id": 64, "id": 1954318}, {"segmentation": [[386.65, 334.87, 383.46, 337.1, 381.55, 343.79, 381.55, 350.48, 381.87, 353.98, 380.28, 359.71, 382.83, 366.4, 387.92, 368.31, 392.38, 368.95, 393.65, 368.0, 397.16, 365.77, 400.98, 363.85, 400.66, 357.48, 399.39, 352.71, 398.75, 346.97, 400.03, 341.56, 400.03, 337.1, 398.75, 332.0, 395.57, 325.32, 397.8, 321.49, 400.66, 323.72, 407.99, 324.04, 407.35, 321.49, 412.13, 321.18, 415.31, 320.86, 419.14, 317.35, 416.59, 312.26, 413.4, 308.75, 411.49, 303.34, 405.12, 295.06, 400.66, 286.46, 391.11, 282.64, 383.46, 280.41, 373.59, 282.32, 366.9, 286.78, 363.4, 289.32, 360.53, 291.55, 357.98, 296.33, 361.8, 302.7, 361.17, 308.75, 361.17, 311.62, 361.8, 315.44, 373.91, 314.81, 373.91, 320.86, 375.82, 323.4, 376.14, 328.5, 384.1, 328.5, 389.83, 328.18, 392.7, 329.77, 388.56, 335.19]], "area": 2564.863350000001, "iscrowd": 0, "image_id": 13923, "bbox": [357.98, 280.41, 61.16, 88.54], "category_id": 64, "id": 1954498}, {"segmentation": [[640.0, 369.73, 628.69, 368.51, 610.44, 368.51, 575.15, 386.76, 543.1, 416.37, 478.21, 467.48, 478.21, 478.84, 640.0, 478.43]], "area": 11664.891299999997, "iscrowd": 0, "image_id": 13729, "bbox": [478.21, 368.51, 161.79, 110.33], "category_id": 67, "id": 1966637}, {"segmentation": [[289.44, 316.05, 368.04, 309.5, 368.36, 316.05, 340.53, 318.67, 290.75, 320.96, 288.13, 316.7], [442.7, 302.62, 480.0, 303.93, 480.0, 311.13, 439.75, 315.72, 441.39, 307.53]], "area": 881.6853500000002, "iscrowd": 0, "image_id": 12576, "bbox": [288.13, 302.62, 191.87, 18.34], "category_id": 49, "id": 2104032}, {"segmentation": [[270.4, 427.0, 254.99, 415.65, 245.92, 397.51, 240.48, 379.38, 240.48, 369.41, 249.55, 378.48, 283.09, 397.51, 310.29, 412.93, 332.04, 421.08, 339.3, 420.18, 339.3, 427.0, 271.31, 425.62]], "area": 2115.54865, "iscrowd": 0, "image_id": 13923, "bbox": [240.48, 369.41, 98.82, 57.59], "category_id": 62, "id": 2123120}, {"segmentation": [[207.71, 361.75, 193.15, 369.34, 194.38, 375.8, 201.56, 380.11, 213.35, 374.88, 212.74, 362.27]], "area": 254.56780000000032, "iscrowd": 0, "image_id": 10707, "bbox": [193.15, 361.75, 20.2, 18.36], "category_id": 75, "id": 2135228}, {"segmentation": [[305.24, 367.86, 295.79, 355.27, 304.34, 345.38, 310.78, 350.77]], "area": 170.51259999999968, "iscrowd": 0, "image_id": 19786, "bbox": [295.79, 345.38, 14.99, 22.48], "category_id": 75, "id": 2135614}, {"segmentation": [[261.31, 91.94, 254.29, 83.51, 257.7, 76.09, 262.31, 73.28, 263.52, 82.91]], "area": 98.12794999999994, "iscrowd": 0, "image_id": 19786, "bbox": [254.29, 73.28, 9.23, 18.66], "category_id": 75, "id": 2136418}, {"segmentation": [[74.29, 56.66, 77.35, 34.96, 79.14, 23.98, 82.72, 16.06, 88.85, 13.25, 91.91, 12.48, 126.64, 13.25, 131.75, 16.57, 133.54, 19.12, 133.54, 27.3, 132.26, 30.36, 128.69, 28.83, 125.11, 25.25, 123.83, 24.74, 118.98, 26.79, 116.43, 27.3, 113.87, 27.3, 110.81, 30.11, 109.53, 30.62, 108.0, 31.64, 106.21, 34.19, 101.87, 37.77, 98.55, 41.34, 96.51, 42.36, 93.44, 43.13, 91.14, 45.17, 86.29, 46.96, 83.48, 47.98, 81.18, 51.56, 78.89, 54.62, 77.35, 55.9]], "area": 1275.47215, "iscrowd": 0, "image_id": 19432, "bbox": [74.29, 12.48, 59.25, 44.18], "category_id": 62, "id": 2192372}, {"segmentation": [[615.41, 281.19, 615.99, 275.88, 616.1, 271.15, 618.87, 270.92, 622.45, 271.15, 624.07, 271.61, 625.34, 272.07, 625.57, 272.3, 625.11, 279.92, 624.41, 283.27, 622.22, 283.04, 620.26, 282.92, 618.53, 283.16, 616.57, 282.35]], "area": 109.40540000000038, "iscrowd": 0, "image_id": 13729, "bbox": [615.41, 270.92, 10.16, 12.35], "category_id": 47, "id": 2214578}, {"segmentation": [[329.14, 241.75, 331.37, 231.59, 332.36, 224.65, 334.34, 218.21, 336.82, 206.81, 345.49, 208.54, 401.5, 217.71, 401.25, 232.83, 398.03, 240.01, 392.58, 249.93, 391.34, 256.62, 396.79, 262.07, 390.84, 285.61, 378.7, 292.05, 373.5, 328.48, 373.25, 339.88, 327.9, 327.49, 312.54, 322.04, 312.54, 316.34, 320.71, 275.94, 325.17, 263.06]], "area": 7926.755249999999, "iscrowd": 0, "image_id": 13729, "bbox": [312.54, 206.81, 88.96, 133.07], "category_id": 63, "id": 2231408}, {"segmentation": [[389.28, 202.3, 389.65, 201.46, 390.27, 201.09, 391.06, 200.83, 391.48, 200.78, 392.37, 200.67, 393.11, 200.67, 393.63, 200.67, 394.0, 200.99, 394.1, 201.41, 394.37, 202.14, 394.16, 203.03, 394.05, 203.56, 393.79, 204.03, 393.11, 204.19, 391.9, 204.29, 391.53, 204.34, 390.64, 204.34, 390.33, 204.29, 389.7, 204.13, 389.33, 203.77, 389.12, 203.14]], "area": 16.039750000000094, "iscrowd": 0, "image_id": 12120, "bbox": [389.12, 200.67, 5.25, 3.67], "category_id": 37, "id": 305373}, {"segmentation": [[76.25, 133.97, 76.07, 123.82, 76.59, 122.27, 78.14, 122.27, 83.47, 123.31, 91.21, 122.79, 95.34, 122.62, 96.03, 123.13, 95.85, 129.33, 96.2, 135.52, 96.89, 138.44, 99.98, 137.58, 99.64, 142.05, 97.75, 142.74, 94.99, 144.81, 94.82, 146.7, 94.99, 153.75, 94.48, 153.06, 94.31, 139.13, 89.15, 139.3, 81.92, 138.27, 77.97, 135.52, 76.42, 134.14]], "area": 336.7431500000001, "iscrowd": 0, "image_id": 14439, "bbox": [76.07, 122.27, 23.91, 31.48], "category_id": 62, "id": 372865}, {"segmentation": [[375.33, 33.24, 375.02, 24.93, 375.02, 20.57, 376.74, 19.25, 380.8, 19.45, 384.14, 20.06, 385.97, 20.47, 385.46, 28.88, 386.07, 33.84, 378.57, 33.24]], "area": 145.84575000000024, "iscrowd": 0, "image_id": 12120, "bbox": [375.02, 19.25, 11.05, 14.59], "category_id": 62, "id": 373319}, {"segmentation": [[118.23, 153.48, 117.49, 147.68, 117.0, 144.48, 116.5, 142.13, 116.13, 137.45, 116.01, 135.6, 115.52, 133.75, 114.28, 131.53, 112.93, 131.03, 109.47, 131.16, 101.71, 131.28, 99.12, 131.28, 98.5, 134.24, 98.5, 136.34, 103.43, 135.23, 104.91, 135.84, 103.56, 140.65, 101.46, 142.75, 100.97, 143.98, 101.71, 144.72, 107.75, 145.09, 111.82, 145.22, 114.9, 144.48, 115.64, 144.48, 116.26, 152.37, 116.5, 155.08, 117.98, 154.71, 118.35, 153.23], [99.24, 143.74, 98.01, 155.7, 99.86, 155.45, 100.23, 151.26, 100.35, 145.83, 102.32, 153.97, 102.32, 155.58, 102.94, 154.71, 103.06, 152.74, 108.86, 152.74, 112.93, 152.74, 112.93, 155.82, 113.91, 155.21, 114.04, 149.66, 114.04, 147.07, 114.41, 145.96, 103.8, 146.33, 101.95, 146.2, 101.21, 145.09, 101.09, 142.87, 99.61, 142.75, 99.36, 143.37]], "area": 325.07545000000005, "iscrowd": 0, "image_id": 14439, "bbox": [98.01, 131.03, 20.34, 24.79], "category_id": 62, "id": 375587}, {"segmentation": [[362.47, 20.74, 361.45, 29.79, 360.14, 30.52, 359.85, 33.73, 371.31, 33.88, 371.52, 28.91, 371.31, 21.91, 368.39, 18.84, 362.55, 19.28]], "area": 141.66634999999977, "iscrowd": 0, "image_id": 12120, "bbox": [359.85, 18.84, 11.67, 15.04], "category_id": 62, "id": 380029}, {"segmentation": [[349.56, 7.55, 355.39, 8.26, 356.74, 8.98, 358.98, 12.57, 360.41, 13.73, 360.59, 18.75, 357.81, 19.83, 356.02, 16.87, 354.14, 12.3, 350.37, 10.95]], "area": 61.62440000000016, "iscrowd": 0, "image_id": 12120, "bbox": [349.56, 7.55, 11.03, 12.28], "category_id": 62, "id": 385411}, {"segmentation": [[15.1, 340.31, 14.91, 336.49, 18.73, 334.86, 15.82, 339.76], [21.64, 336.13, 24.55, 337.95, 24.55, 343.22, 24.55, 346.85, 12.73, 369.03, 11.28, 371.58, 9.1, 369.03, 9.1, 361.4, 9.64, 355.22, 10.37, 350.49, 11.28, 348.13, 12.55, 346.49, 15.28, 344.67], [27.15, 347.75, 13.7, 371.93, 8.97, 381.39, 8.24, 400.47, 5.7, 404.29, 3.33, 405.2, 1.7, 405.2, 5.33, 408.29, 13.7, 406.11, 15.15, 404.66, 16.24, 400.66, 18.06, 396.47, 18.24, 391.38, 18.97, 390.11, 18.97, 401.02, 18.6, 403.56, 21.69, 404.84, 23.88, 404.11, 25.15, 402.29, 26.6, 371.75, 27.69, 366.11, 28.78, 364.48]], "area": 1007.6924500000001, "iscrowd": 0, "image_id": 17959, "bbox": [1.7, 334.86, 27.08, 73.43], "category_id": 1, "id": 449302}, {"segmentation": [[130.17, 401.45, 129.41, 380.01, 127.99, 379.77, 127.64, 365.4, 123.78, 362.53, 122.96, 346.2, 123.67, 344.67, 126.41, 345.28, 127.63, 341.32, 129.86, 340.41, 134.74, 342.34, 135.65, 345.28, 140.22, 346.7, 142.86, 347.11, 144.08, 349.85, 142.25, 355.64, 137.98, 371.21, 132.74, 392.67, 131.1, 400.85], [143.23, 392.9, 143.23, 396.32, 142.16, 398.2, 142.56, 401.88, 145.71, 402.18, 145.71, 402.99, 137.68, 403.91, 138.6, 402.18, 138.6, 402.18, 138.6, 399.24, 137.79, 398.32, 142.66, 393.34]], "area": 653.1867500000004, "iscrowd": 0, "image_id": 17959, "bbox": [122.96, 340.41, 22.75, 63.5], "category_id": 1, "id": 478072}, {"segmentation": [[198.63, 264.32, 193.16, 250.25, 196.29, 244.77, 202.54, 232.26, 205.67, 224.44, 205.67, 221.31, 205.67, 217.4, 208.02, 211.15, 208.8, 204.89, 208.02, 197.85, 207.24, 193.16, 188.47, 189.25, 186.9, 192.38, 188.47, 196.29, 189.25, 199.42, 182.99, 207.24, 165.01, 222.09, 159.53, 226.79, 155.62, 233.82, 154.06, 245.56, 155.62, 252.59, 157.97, 253.38, 160.31, 247.12, 169.7, 229.13, 173.61, 226.0, 175.17, 227.57, 175.17, 243.99, 175.17, 258.85, 179.08, 260.41, 192.38, 258.85]], "area": 2014.4765500000005, "iscrowd": 0, "image_id": 15660, "bbox": [154.06, 189.25, 54.74, 75.07], "category_id": 1, "id": 478703}, {"segmentation": [[81.98, 556.14, 64.72, 544.64, 58.97, 544.64, 48.9, 548.95, 38.83, 543.2, 24.45, 523.07, 21.57, 511.56, 25.89, 507.25, 28.76, 501.49, 21.57, 479.92, 21.57, 466.98, 21.57, 439.65, 35.96, 397.94, 47.46, 382.12, 51.78, 364.86, 53.21, 361.99, 46.02, 347.61, 46.02, 328.91, 46.02, 318.84, 51.78, 311.65, 71.91, 310.21, 92.04, 310.21, 103.55, 311.65, 115.06, 320.28, 116.49, 349.04, 116.49, 364.86, 120.81, 364.86, 133.75, 361.99, 133.75, 361.99, 169.71, 347.61, 182.65, 357.67, 169.71, 374.93, 172.58, 395.07, 174.02, 403.7, 151.01, 393.63, 139.51, 380.68, 122.25, 379.25, 96.36, 385.0, 112.18, 420.95, 104.99, 438.21, 96.36, 456.91, 172.58, 462.66, 178.34, 491.43, 109.3, 520.19, 94.92, 527.38, 104.99, 550.39]], "area": 22642.328600000008, "iscrowd": 0, "image_id": 12639, "bbox": [21.57, 310.21, 161.08, 245.93], "category_id": 1, "id": 507402}, {"segmentation": [[23.58, 238.16, 24.54, 224.01, 29.05, 220.14, 29.05, 211.13, 31.62, 203.73, 38.38, 201.8, 47.71, 205.34, 45.14, 209.52, 47.07, 212.74, 45.14, 216.93, 45.78, 219.82, 51.9, 228.51, 51.9, 232.69, 59.3, 240.42, 80.54, 239.77, 85.37, 234.95, 93.09, 226.26, 97.27, 225.61, 106.28, 243.64, 89.87, 255.54, 68.95, 253.93, 48.36, 253.29, 39.67, 250.72, 35.81, 245.57, 27.44, 239.13]], "area": 1910.9380999999998, "iscrowd": 0, "image_id": 12639, "bbox": [23.58, 201.8, 82.7, 53.74], "category_id": 1, "id": 543629}, {"segmentation": [[84.01, 231.05, 77.25, 227.19, 76.61, 220.43, 75.64, 214.0, 69.53, 206.92, 67.27, 202.41, 70.49, 192.11, 77.57, 189.22, 77.25, 186.64, 73.71, 182.78, 73.71, 177.63, 75.96, 174.41, 79.5, 173.45, 83.69, 172.81, 87.23, 178.92, 84.65, 189.22, 90.44, 191.15, 96.24, 197.26, 97.2, 205.31, 97.52, 207.56, 100.74, 211.1, 100.74, 215.28, 94.31, 218.18, 91.73, 225.58, 88.83, 224.94, 84.33, 227.51]], "area": 1045.0987, "iscrowd": 0, "image_id": 12639, "bbox": [67.27, 172.81, 33.47, 58.24], "category_id": 1, "id": 564675}, {"segmentation": [[86.84, 187.88, 88.05, 190.3, 91.85, 190.64, 96.35, 188.39, 100.84, 189.95, 102.05, 192.54, 102.05, 197.04, 101.36, 201.18, 99.8, 203.26, 101.01, 205.51, 104.64, 207.06, 108.1, 208.27, 109.66, 209.13, 109.14, 204.99, 109.66, 200.67, 109.83, 196.0, 109.48, 193.41, 111.38, 190.47, 112.42, 187.53, 113.46, 187.53, 113.11, 185.8, 113.98, 183.21, 113.63, 180.44, 110.52, 178.71, 107.41, 177.68, 103.78, 178.54, 101.7, 180.44, 100.49, 182.0, 100.49, 184.59, 98.77, 185.28, 96.0, 186.32, 93.24, 187.18, 90.99, 187.53, 88.91, 187.53, 86.84, 187.36]], "area": 325.1160999999999, "iscrowd": 0, "image_id": 12639, "bbox": [86.84, 177.68, 27.14, 31.45], "category_id": 1, "id": 568141}, {"segmentation": [[144.79, 229.87, 143.89, 229.52, 143.71, 228.44, 143.36, 225.94, 141.92, 223.97, 140.49, 222.72, 135.84, 218.6, 135.3, 216.99, 135.3, 215.74, 132.62, 213.95, 131.72, 212.69, 130.29, 210.19, 129.58, 209.11, 127.07, 208.22, 127.07, 209.11, 125.82, 208.93, 123.85, 208.4, 122.42, 206.97, 122.24, 204.82, 121.88, 202.67, 122.42, 201.24, 122.95, 199.09, 123.31, 198.38, 122.95, 196.05, 122.6, 194.26, 122.77, 192.29, 124.39, 190.14, 125.64, 189.78, 128.5, 189.78, 130.83, 190.68, 131.9, 192.29, 132.62, 194.44, 132.26, 195.87, 132.26, 197.66, 131.9, 199.27, 131.9, 199.27, 132.98, 200.52, 134.41, 200.52, 136.2, 200.52, 137.99, 202.31, 138.34, 204.64, 141.39, 206.61, 143.0, 209.65, 145.15, 212.69, 146.04, 215.56, 148.19, 219.14, 151.95, 222.18, 153.02, 223.79, 153.56, 226.65, 153.38, 228.44, 150.52, 229.16, 148.73, 229.87, 146.58, 230.23]], "area": 476.2708999999998, "iscrowd": 0, "image_id": 12639, "bbox": [121.88, 189.78, 31.68, 40.45], "category_id": 1, "id": 569493}, {"segmentation": [[172.58, 189.4, 176.9, 179.34, 178.34, 163.52, 186.97, 164.95, 189.84, 179.34, 198.47, 198.03, 201.35, 223.92, 192.72, 228.23, 169.71, 231.11, 169.71, 187.97]], "area": 1503.5066499999996, "iscrowd": 0, "image_id": 12639, "bbox": [169.71, 163.52, 31.64, 67.59], "category_id": 1, "id": 570997}, {"segmentation": [[227.87, 85.34, 163.42, 237.86, 288.7, 340.45, 284.16, 307.77, 288.7, 275.99, 282.35, 246.94, 299.6, 226.06, 347.71, 217.89, 398.55, 184.3, 432.14, 191.56, 477.54, 190.65, 523.84, 185.2, 546.53, 192.47, 589.2, 191.56, 620.98, 187.02, 621.89, 171.59, 583.76, 177.94, 528.38, 177.03, 496.6, 179.76, 475.72, 179.76, 432.14, 167.05, 385.84, 172.49, 376.76, 173.4, 368.59, 183.39, 316.84, 179.76, 311.4, 173.4, 293.24, 178.85, 275.08, 168.86, 256.93, 128.01, 242.4, 111.67, 243.31, 95.33, 240.58, 88.06]], "area": 24565.449300000007, "iscrowd": 0, "image_id": 14439, "bbox": [163.42, 85.34, 458.47, 255.11], "category_id": 38, "id": 622491}, {"segmentation": [[237.12, 249.41, 242.67, 256.03, 242.31, 258.9, 238.2, 262.12, 234.26, 261.94, 231.57, 259.61, 230.5, 256.03, 231.22, 253.17, 233.9, 251.74], [250.54, 197.15, 247.5, 216.3, 243.92, 226.86, 241.42, 237.06, 235.87, 237.78, 236.41, 226.86, 234.79, 215.94, 237.12, 196.97, 241.24, 192.5, 244.1, 192.68, 248.4, 194.47]], "area": 570.7298999999998, "iscrowd": 0, "image_id": 12639, "bbox": [230.5, 192.5, 20.04, 69.62], "category_id": 39, "id": 627314}, {"segmentation": [[237.73, 315.16, 185.34, 319.85, 153.28, 334.71, 162.66, 342.53, 203.33, 340.96, 257.29, 329.23, 307.33, 315.16, 320.63, 291.69, 272.14, 301.86, 245.56, 306.55, 223.66, 314.37]], "area": 3341.5383999999985, "iscrowd": 0, "image_id": 15660, "bbox": [153.28, 291.69, 167.35, 50.84], "category_id": 42, "id": 651146}, {"segmentation": [[103.32, 140.38, 111.45, 136.94, 114.58, 135.69, 118.02, 132.87, 120.84, 131.31, 123.03, 131.31, 124.91, 131.31, 125.53, 131.31, 126.47, 133.18, 127.72, 135.38, 127.1, 138.19, 124.91, 140.38, 120.53, 140.69, 116.14, 140.69, 115.21, 140.07, 111.76, 139.76, 108.95, 139.76, 105.82, 140.69, 104.88, 141.95]], "area": 124.56849999999991, "iscrowd": 0, "image_id": 12120, "bbox": [103.32, 131.31, 24.4, 10.64], "category_id": 43, "id": 658529}, {"segmentation": [[218.97, 167.94, 369.98, 167.94, 361.35, 263.94, 359.19, 282.28, 350.56, 288.75, 349.48, 296.3, 358.11, 300.61, 307.42, 354.55, 135.91, 331.9, 134.83, 320.03, 186.61, 288.75, 198.47, 282.28, 209.26, 285.51, 212.49, 283.36, 211.42, 274.73, 201.71, 273.65, 215.73, 165.78]], "area": 29331.165500000003, "iscrowd": 0, "image_id": 16439, "bbox": [134.83, 165.78, 235.15, 188.77], "category_id": 73, "id": 1101993}, {"segmentation": [[201.52, 82.2, 238.85, 72.38, 279.87, 73.96, 308.44, 78.16, 319.37, 85.73, 338.7, 124.39, 338.7, 199.19, 307.6, 273.15, 289.11, 284.07, 295.0, 304.24, 287.43, 347.11, 224.4, 345.42, 219.36, 316.85, 219.36, 297.52, 219.36, 293.32, 174.81, 205.07, 172.29, 124.39, 187.42, 91.61]], "area": 34394.36045, "iscrowd": 0, "image_id": 19742, "bbox": [172.29, 72.38, 166.41, 274.73], "category_id": 86, "id": 1151441}, {"segmentation": [[385.59, 237.14, 380.77, 248.7, 378.84, 259.31, 380.77, 268.95, 382.69, 292.08, 375.95, 305.58, 363.41, 318.11, 361.49, 333.53, 356.67, 343.17, 349.92, 345.1, 342.21, 348.95, 336.42, 339.32, 340.28, 319.07, 334.5, 301.72, 325.82, 276.66, 314.25, 267.98, 301.72, 263.16, 315.22, 257.38, 327.75, 259.31, 332.57, 260.27, 333.53, 244.85, 339.32, 235.21, 335.46, 224.6, 340.28, 216.89, 352.88, 212.37, 364.01, 218.15, 367.94, 223.05, 382.99, 226.31, 391.15, 237.06]], "area": 5564.19405, "iscrowd": 0, "image_id": 12670, "bbox": [301.72, 212.37, 89.43, 136.58], "category_id": 88, "id": 1161855}, {"segmentation": [[324.83, 249.93, 324.83, 241.46, 326.38, 235.29, 327.15, 232.6, 330.23, 233.37, 331.0, 237.6, 329.84, 241.84, 329.84, 248.78, 327.15, 252.24, 327.15, 253.4, 325.22, 255.32, 325.6, 250.32]], "area": 90.85039999999984, "iscrowd": 0, "image_id": 12670, "bbox": [324.83, 232.6, 6.17, 22.72], "category_id": 27, "id": 1169165}, {"segmentation": [[89.32, 160.29, 93.98, 169.18, 93.98, 171.22, 98.79, 171.65, 103.3, 169.61, 104.61, 164.08, 100.24, 160.15, 94.27, 156.36, 88.45, 157.09, 86.84, 159.27]], "area": 156.5958999999999, "iscrowd": 0, "image_id": 14439, "bbox": [86.84, 156.36, 17.77, 15.29], "category_id": 27, "id": 1170759}, {"segmentation": [[307.31, 109.79, 303.22, 98.87, 302.31, 92.04, 302.76, 84.76, 304.13, 78.39, 306.4, 75.21, 312.32, 73.84, 316.87, 73.84, 319.6, 75.66, 323.69, 78.85, 325.06, 79.76, 325.06, 83.4, 325.06, 83.85, 319.6, 82.03, 314.14, 79.3, 311.86, 79.76, 307.77, 88.4, 307.31, 97.05]], "area": 243.00409999999988, "iscrowd": 0, "image_id": 12670, "bbox": [302.31, 73.84, 22.75, 35.95], "category_id": 27, "id": 1171715}, {"segmentation": [[39.43, 309.7, 53.86, 311.62, 58.67, 309.7, 61.56, 302.97, 50.98, 292.39, 53.86, 277.96, 59.63, 271.23, 50.01, 264.49, 38.47, 255.84, 34.62, 253.91, 41.36, 245.26, 36.55, 235.64, 27.89, 235.64, 22.12, 241.41, 16.35, 250.07, 6.73, 249.11, 7.69, 265.46, 3.85, 287.58, 9.62, 293.35, 14.43, 302.0, 15.39, 310.66, 25.01, 306.81, 23.08, 301.04, 33.66, 292.39, 44.24, 288.54, 34.62, 306.81]], "area": 2649.9406999999997, "iscrowd": 0, "image_id": 12120, "bbox": [3.85, 235.64, 57.71, 75.98], "category_id": 1, "id": 1203494}, {"segmentation": [[26.88, 329.59, 28.02, 329.87, 29.57, 330.44, 30.99, 331.57, 31.42, 332.84, 30.71, 334.83, 32.41, 336.24, 26.03, 345.73, 24.47, 344.6, 24.47, 342.9, 24.47, 341.34, 24.47, 340.35, 22.49, 336.81, 21.92, 335.82, 21.78, 334.83, 23.62, 331.85, 25.18, 330.72], [33.26, 337.94, 38.64, 345.17, 38.64, 347.15, 33.68, 362.45, 28.87, 385.96, 25.75, 402.25, 24.62, 403.53, 23.91, 401.12, 24.47, 384.69, 24.76, 381.15, 25.47, 376.33, 27.31, 366.98, 26.88, 366.56, 27.31, 365.57, 28.16, 363.72, 27.87, 356.64, 26.88, 351.68, 26.74, 350.41, 26.88, 348.28, 26.6, 346.44, 32.55, 337.52]], "area": 474.89009999999996, "iscrowd": 0, "image_id": 17959, "bbox": [21.78, 329.59, 16.86, 73.94], "category_id": 1, "id": 1207016}, {"segmentation": [[461.2, 179.76, 413.08, 166.14, 416.71, 124.38, 423.07, 122.56, 423.07, 99.87, 435.78, 90.79, 440.31, 89.88, 453.93, 96.23, 454.84, 120.75, 447.58, 122.56, 470.27, 139.81, 486.62, 124.38, 495.69, 119.84, 507.5, 118.93, 494.79, 140.72, 474.81, 151.61, 468.46, 153.43, 462.1, 177.03], [455.75, 193.38, 421.25, 193.38, 432.14, 203.36, 433.96, 224.24, 415.8, 280.53, 439.41, 288.7, 444.85, 286.89, 439.41, 274.18, 444.85, 248.76, 450.3, 239.68, 455.75, 282.35, 486.62, 277.81, 470.27, 245.12, 470.27, 228.78, 461.2, 192.47]], "area": 7641.4994000000015, "iscrowd": 0, "image_id": 14439, "bbox": [413.08, 89.88, 94.42, 198.82], "category_id": 1, "id": 1213473}, {"segmentation": [[119.32, 174.69, 114.7, 170.07, 114.35, 162.25, 113.28, 152.31, 112.57, 148.4, 111.15, 144.49, 110.44, 142.71, 109.73, 138.81, 109.37, 135.61, 110.08, 134.19, 111.86, 134.19, 112.57, 135.96, 113.28, 136.32, 113.64, 131.7, 113.28, 128.5, 112.92, 122.46, 112.92, 119.98, 111.86, 118.55, 110.79, 116.07, 108.66, 113.23, 105.82, 112.51, 103.69, 115.36, 103.33, 117.84, 102.98, 120.33, 101.56, 122.46, 96.58, 124.24, 90.54, 132.77, 96.58, 136.32, 93.74, 140.23, 93.38, 142.71, 94.45, 148.75, 96.23, 151.6, 95.16, 155.86, 91.61, 163.68, 90.9, 167.58, 90.54, 172.2, 89.83, 173.62, 90.19, 175.76, 92.32, 177.18, 94.81, 178.24, 95.16, 178.24, 94.81, 175.05, 93.74, 172.56, 93.74, 170.07, 95.16, 167.94, 98.0, 163.32, 99.07, 161.54, 99.42, 156.22, 99.42, 154.08, 100.84, 148.04, 102.62, 148.04, 108.66, 151.95, 108.66, 156.57, 108.66, 163.32, 109.37, 164.74, 110.08, 170.43, 111.15, 173.62, 113.28, 175.4, 117.54, 176.47, 118.25, 176.47, 117.9, 175.4]], "area": 820.40285, "iscrowd": 0, "image_id": 12120, "bbox": [89.83, 112.51, 29.49, 65.73], "category_id": 1, "id": 1213619}, {"segmentation": [[317.12, 136.22, 314.23, 143.42, 311.35, 157.84, 312.79, 169.37, 311.35, 193.87, 312.79, 209.73, 320.0, 216.94, 320.0, 195.32, 322.88, 186.67, 325.77, 190.99, 332.97, 186.67, 328.65, 170.81, 328.65, 157.84, 328.65, 143.42, 321.44, 143.42, 318.56, 134.77]], "area": 1018.3404499999979, "iscrowd": 0, "image_id": 12639, "bbox": [311.35, 134.77, 21.62, 82.17], "category_id": 1, "id": 1215138}, {"segmentation": [[279.88, 177.93, 276.04, 144.27, 276.04, 126.0, 269.3, 106.76, 263.53, 92.33, 268.34, 75.98, 281.81, 71.17, 276.04, 58.67, 283.73, 46.17, 304.89, 46.17, 308.74, 65.4, 315.47, 73.1, 336.63, 86.56, 340.48, 100.99, 329.9, 109.64, 321.24, 127.92, 315.47, 142.35, 316.43, 168.31, 316.43, 201.98, 310.66, 234.68, 299.12, 242.37, 289.5, 231.79, 288.54, 217.37, 285.65, 208.71, 285.65, 199.09]], "area": 7830.536100000001, "iscrowd": 0, "image_id": 12670, "bbox": [263.53, 46.17, 76.95, 196.2], "category_id": 1, "id": 1231358}, {"segmentation": [[350.07, 220.41, 342.64, 218.76, 341.81, 211.32, 331.07, 205.95, 327.35, 191.5, 333.14, 187.78, 336.85, 184.07, 335.2, 177.46, 340.16, 170.85, 347.59, 176.63, 347.18, 179.11, 356.68, 192.74, 355.85, 196.46, 348.83, 193.15, 350.07, 199.76, 355.85, 208.85, 359.57, 214.22, 357.09, 215.45, 349.66, 220.0, 349.24, 220.0]], "area": 830.1729499999997, "iscrowd": 0, "image_id": 12639, "bbox": [327.35, 170.85, 32.22, 49.56], "category_id": 1, "id": 1242094}, {"segmentation": [[505.67, 150.36, 514.31, 144.44, 514.31, 124.88, 528.87, 105.31, 549.8, 103.04, 564.81, 126.7, 564.36, 145.35, 563.9, 152.18, 572.09, 165.82, 573.45, 196.76, 548.89, 194.49, 539.79, 202.22, 537.51, 202.22, 548.43, 180.38, 540.7, 174.92, 527.5, 194.94, 523.86, 202.22, 519.31, 196.31, 519.31, 195.85, 518.86, 176.29, 518.86, 174.92, 507.03, 152.63]], "area": 4379.644600000002, "iscrowd": 0, "image_id": 12670, "bbox": [505.67, 103.04, 67.78, 99.18], "category_id": 1, "id": 1281554}, {"segmentation": [[580.54, 120.24, 584.67, 112.54, 584.67, 108.69, 584.39, 106.77, 586.59, 102.37, 583.57, 93.02, 578.34, 91.37, 579.44, 86.42, 575.59, 84.77, 572.57, 85.6, 572.02, 90.27, 572.02, 92.2, 570.37, 93.85, 569.54, 96.05, 568.44, 100.17, 570.09, 101.0, 572.84, 96.87, 577.24, 99.62, 575.04, 105.12, 575.32, 106.77, 574.22, 111.17, 574.77, 111.44, 577.24, 111.44, 577.79, 115.02, 577.79, 117.49, 578.89, 119.42], [570.09, 100.72, 571.19, 102.65, 571.48, 105.8, 571.9, 106.59, 572.69, 107.0, 573.17, 107.83, 573.51, 104.25, 573.89, 101.44, 573.72, 100.85, 572.41, 100.92]], "area": 321.9169500000001, "iscrowd": 0, "image_id": 12120, "bbox": [568.44, 84.77, 18.15, 35.47], "category_id": 1, "id": 1287176}, {"segmentation": [[439.54, 422.23, 432.81, 375.1, 443.39, 373.18, 439.54, 304.89, 423.19, 299.12, 389.53, 289.5, 355.87, 320.28, 365.48, 331.82, 358.75, 344.32, 351.06, 344.32, 346.25, 379.91, 334.71, 419.34, 337.59, 422.23]], "area": 10978.319500000003, "iscrowd": 0, "image_id": 12670, "bbox": [334.71, 289.5, 108.68, 132.73], "category_id": 1, "id": 1289729}, {"segmentation": [[386.64, 286.62, 384.72, 252.95, 383.76, 227.95, 407.8, 219.29, 431.85, 238.53, 435.69, 245.26, 453.01, 271.23, 462.62, 278.92, 481.86, 310.66, 489.56, 325.09, 494.36, 338.55, 492.44, 356.83, 478.01, 364.52, 482.82, 377.99, 478.98, 383.76, 481.86, 387.6, 478.01, 401.07, 478.01, 402.03, 478.01, 406.84, 478.01, 413.57, 467.43, 414.53, 440.5, 400.11, 436.66, 390.49, 452.04, 349.13, 443.39, 319.32, 442.43, 310.66]], "area": 9101.397749999996, "iscrowd": 0, "image_id": 12670, "bbox": [383.76, 219.29, 110.6, 195.24], "category_id": 1, "id": 1290414}, {"segmentation": [[541.58, 360.03, 540.59, 351.32, 539.6, 351.2, 540.37, 347.89, 541.47, 346.02, 543.13, 345.8, 543.46, 349.11, 544.01, 351.54, 545.11, 356.06, 545.33, 360.26, 542.8, 360.59]], "area": 50.99424999999972, "iscrowd": 0, "image_id": 17959, "bbox": [539.6, 345.8, 5.73, 14.79], "category_id": 1, "id": 1292393}, {"segmentation": [[238.61, 344.24, 242.98, 337.99, 259.21, 332.68, 265.46, 329.56, 269.51, 318.32, 272.01, 307.08, 275.76, 299.28, 275.13, 288.04, 278.26, 277.74, 283.88, 272.43, 294.49, 263.69, 310.72, 262.44, 323.21, 272.43, 331.64, 290.54, 334.45, 305.52, 340.07, 322.69, 336.95, 338.3, 350.02, 347.86, 350.03, 368.36, 343.15, 393.26, 339.29, 410.23, 336.28, 418.39, 340.36, 422.47, 352.6, 423.33, 356.25, 422.04, 363.34, 423.76, 363.98, 426.55, 362.69, 428.0, 276.16, 428.0, 275.3, 425.04, 278.31, 421.18, 281.53, 419.03, 282.17, 413.02, 282.6, 400.78, 281.74, 388.54, 282.82, 379.95, 274.87, 369.43, 265.85, 358.48, 254.69, 350.32, 242.23, 344.52]], "area": 10949.096749999995, "iscrowd": 0, "image_id": 12670, "bbox": [238.61, 262.44, 125.37, 165.56], "category_id": 1, "id": 1292520}, {"segmentation": [[568.47, 100.24, 572.12, 102.68, 571.39, 108.77, 571.39, 113.89, 570.9, 116.33, 566.76, 114.38, 561.4, 112.67, 555.55, 111.45, 556.76, 104.38, 559.93, 101.21, 560.18, 98.04, 561.4, 93.65, 563.83, 90.73, 567.25, 91.46, 569.69, 94.39, 568.95, 97.31, 568.47, 99.75]], "area": 262.514200000001, "iscrowd": 0, "image_id": 12120, "bbox": [555.55, 90.73, 16.57, 25.6], "category_id": 1, "id": 1295280}, {"segmentation": [[138.19, 403.05, 144.91, 378.1, 159.3, 355.07, 167.94, 333.96, 166.98, 312.84, 164.1, 295.57, 166.98, 278.3, 179.45, 266.78, 196.73, 262.94, 210.16, 266.78, 222.64, 286.93, 225.52, 309.96, 232.23, 328.2, 242.79, 343.55, 259.1, 353.15, 268.7, 362.74, 275.42, 373.3, 282.13, 387.7, 283.09, 410.73, 276.38, 422.24, 134.35, 419.36, 141.07, 402.09]], "area": 14381.618300000002, "iscrowd": 0, "image_id": 12670, "bbox": [134.35, 262.94, 148.74, 159.3], "category_id": 1, "id": 1296661}, {"segmentation": [[58.55, 283.69, 66.2, 259.14, 71.83, 248.67, 78.67, 240.62, 91.55, 234.18, 100.41, 230.96, 116.51, 230.96, 123.75, 232.17, 149.51, 298.98, 154.34, 309.45, 153.54, 324.74, 154.34, 331.59, 154.34, 340.84, 147.9, 349.7, 144.68, 379.48, 139.45, 391.96, 137.04, 413.29, 135.83, 428.0, 60.56, 427.38, 57.74, 417.32, 56.13, 406.85, 54.52, 400.81, 55.33, 397.59, 55.73, 391.96, 56.13, 389.95, 55.33, 386.73, 55.33, 386.73, 40.84, 362.17, 42.05, 358.15, 44.46, 356.54, 58.55, 355.73, 62.57, 342.85, 64.99, 334.8, 68.21, 335.21, 68.61, 334.8, 69.01, 326.76, 63.78, 319.51, 60.96, 315.08, 60.96, 313.88, 63.78, 309.85, 63.78, 303.41]], "area": 16034.45445, "iscrowd": 0, "image_id": 12670, "bbox": [40.84, 230.96, 113.5, 197.04], "category_id": 1, "id": 1299579}, {"segmentation": [[537.06, 112.84, 537.06, 106.49, 532.99, 102.42, 537.57, 95.56, 541.12, 93.78, 541.38, 89.46, 543.67, 86.41, 549.0, 86.41, 551.8, 90.48, 550.02, 94.8, 554.85, 98.36, 559.42, 101.15, 557.14, 103.95, 551.8, 101.41, 551.8, 106.24, 555.36, 109.03, 554.34, 114.11, 541.38, 117.16, 537.57, 113.35]], "area": 452.98854999999975, "iscrowd": 0, "image_id": 12120, "bbox": [532.99, 86.41, 26.43, 30.75], "category_id": 1, "id": 1302229}, {"segmentation": [[57.84, 422.7, 53.98, 400.53, 55.91, 391.85, 42.41, 368.72, 41.45, 356.18, 54.95, 352.33, 60.73, 352.33, 64.59, 351.36, 65.55, 338.83, 70.37, 334.98, 69.41, 324.37, 63.62, 319.55, 66.51, 308.95, 64.59, 288.71, 56.87, 279.07, 44.34, 269.43, 25.06, 266.54, 13.5, 270.39, 1.93, 277.14, 0.0, 422.7]], "area": 8687.98255, "iscrowd": 0, "image_id": 12670, "bbox": [0.0, 266.54, 70.37, 156.16], "category_id": 1, "id": 1305161}, {"segmentation": [[108.39, 230.47, 104.63, 225.45, 105.05, 205.4, 104.63, 190.37, 106.72, 185.35, 122.17, 173.66, 122.59, 161.96, 127.18, 152.77, 129.69, 150.27, 129.27, 144.42, 128.44, 138.15, 128.86, 130.63, 137.21, 123.95, 144.31, 118.52, 155.17, 122.7, 164.36, 133.14, 165.2, 146.09, 174.39, 153.61, 170.63, 166.56, 173.97, 169.06, 173.55, 171.99, 181.9, 174.91, 183.58, 174.49, 188.17, 177.83, 192.77, 200.81, 196.11, 225.39, 191.51, 236.67, 185.66, 239.17, 182.74, 237.92, 183.99, 245.44, 172.72, 246.63, 161.85, 246.63, 155.59, 257.07, 153.92, 265.0, 153.5, 283.8, 153.08, 290.48, 149.32, 298.42, 130.53, 247.04, 122.17, 230.33]], "area": 8663.100849999997, "iscrowd": 0, "image_id": 12670, "bbox": [104.63, 118.52, 91.48, 179.9], "category_id": 1, "id": 1310729}, {"segmentation": [[566.39, 358.45, 566.59, 356.73, 567.4, 354.19, 567.0, 353.07, 566.79, 352.36, 565.47, 352.05, 565.47, 350.02, 566.18, 348.7, 566.69, 347.69, 566.59, 346.77, 566.49, 345.25, 568.01, 345.15, 568.62, 345.35, 568.82, 346.37, 569.33, 347.89, 569.33, 349.41, 569.84, 350.53, 570.45, 351.65, 570.96, 352.76, 570.55, 352.87, 570.25, 352.87, 570.75, 354.59, 571.77, 356.22, 572.58, 356.73, 572.48, 357.23, 572.07, 357.23, 570.35, 357.33, 569.74, 355.71, 568.93, 354.39, 568.42, 355.71, 568.32, 356.83, 568.72, 357.94, 568.72, 358.45, 568.11, 358.55, 567.2, 358.45]], "area": 44.05905000000021, "iscrowd": 0, "image_id": 17959, "bbox": [565.47, 345.15, 7.11, 13.4], "category_id": 1, "id": 1311792}, {"segmentation": [[242.56, 339.24, 230.7, 314.52, 224.27, 297.21, 220.32, 256.17, 231.69, 228.49, 228.23, 206.73, 235.64, 200.3, 231.19, 181.52, 228.72, 168.66, 238.61, 156.3, 258.88, 159.76, 269.76, 165.7, 275.2, 178.06, 288.05, 202.78, 294.97, 234.42, 292.5, 261.12, 280.14, 277.43, 265.8, 328.85]], "area": 9283.1788, "iscrowd": 0, "image_id": 12670, "bbox": [220.32, 156.3, 74.65, 182.94], "category_id": 1, "id": 1313606}, {"segmentation": [[576.24, 357.01, 573.84, 356.8, 573.32, 355.39, 572.17, 354.55, 571.59, 352.73, 572.22, 351.42, 573.53, 350.17, 575.77, 349.65, 577.81, 349.49, 576.66, 351.73, 577.02, 352.99, 575.67, 354.29, 575.51, 354.66, 576.08, 355.7, 576.81, 356.59]], "area": 28.21764999999978, "iscrowd": 0, "image_id": 17959, "bbox": [571.59, 349.49, 6.22, 7.52], "category_id": 1, "id": 1313720}, {"segmentation": [[522.0, 100.23, 513.47, 99.68, 512.37, 96.11, 514.85, 87.58, 518.7, 84.83, 519.52, 78.51, 525.57, 76.58, 527.77, 81.26, 527.5, 85.38, 533.82, 90.33, 537.4, 94.46, 536.02, 98.85, 534.65, 99.95, 533.0, 98.3, 533.0, 96.66, 531.35, 96.11, 531.07, 99.4, 529.15, 99.4, 526.95, 95.28, 523.1, 97.2]], "area": 331.00515000000007, "iscrowd": 0, "image_id": 12120, "bbox": [512.37, 76.58, 25.03, 23.65], "category_id": 1, "id": 1316481}, {"segmentation": [[460.16, 97.43, 453.47, 99.52, 452.63, 105.38, 448.44, 104.96, 447.6, 98.68, 453.47, 94.92, 451.79, 91.57, 453.05, 86.54, 456.81, 84.45, 456.4, 79.84, 461.0, 77.33, 463.09, 77.75, 463.51, 83.61, 468.54, 88.22, 466.44, 99.1, 461.42, 97.43]], "area": 282.6418499999998, "iscrowd": 0, "image_id": 12120, "bbox": [447.6, 77.33, 20.94, 28.05], "category_id": 1, "id": 1316505}, {"segmentation": [[502.92, 125.43, 482.8, 120.75, 483.04, 114.67, 485.38, 112.33, 484.44, 106.48, 490.52, 99.47, 492.63, 92.69, 496.13, 93.15, 498.94, 97.6, 499.64, 100.4, 503.38, 103.44, 504.55, 109.29, 503.85, 113.27, 504.32, 120.75]], "area": 483.83000000000015, "iscrowd": 0, "image_id": 12120, "bbox": [482.8, 92.69, 21.75, 32.74], "category_id": 1, "id": 1318073}, {"segmentation": [[384.06, 228.16, 393.18, 225.12, 393.18, 221.53, 390.14, 217.66, 389.59, 215.18, 388.76, 212.14, 387.65, 209.65, 386.27, 206.34, 384.89, 204.13, 384.89, 201.09, 384.61, 197.5, 382.68, 195.02, 381.58, 191.98, 380.19, 189.77, 378.81, 187.83, 377.71, 185.9, 374.67, 183.14, 372.46, 181.21, 369.42, 179.0, 368.04, 176.79, 364.73, 175.41, 362.24, 173.47, 357.82, 172.64, 354.23, 172.64, 350.09, 172.92, 346.77, 174.3, 343.46, 175.13, 340.97, 175.96, 337.11, 177.89, 332.41, 180.93, 331.31, 183.41, 329.1, 189.22, 328.27, 194.74, 328.27, 197.5, 328.27, 201.37, 326.06, 202.47, 325.78, 203.85, 326.61, 204.68, 326.89, 206.62, 326.33, 208.0, 325.51, 209.65, 325.23, 211.59, 325.23, 212.97, 324.95, 214.9, 323.57, 215.45, 323.57, 216.28, 323.57, 217.39, 323.85, 218.49, 322.47, 219.6, 321.64, 220.43, 321.92, 221.53, 322.47, 222.91, 322.19, 224.02, 321.36, 224.85, 320.81, 225.67, 319.98, 227.06, 319.43, 228.44, 318.88, 229.26, 319.43, 229.82, 320.26, 229.82, 322.74, 229.26, 323.3, 228.99, 323.85, 229.26, 324.13, 230.37, 324.68, 232.03, 324.4, 233.41, 322.74, 235.34, 322.19, 236.45, 322.19, 237.27, 320.53, 238.93, 319.98, 239.76, 318.88, 240.31, 319.15, 241.97, 318.88, 244.73, 318.33, 245.84, 317.77, 246.67, 317.5, 247.77, 316.94, 250.53, 316.39, 252.19, 315.56, 254.68, 315.29, 256.33, 315.29, 256.61, 316.67, 256.89, 318.6, 257.44, 319.98, 257.16, 321.64, 256.89, 323.02, 256.61, 325.78, 256.33, 326.89, 256.89, 329.37, 257.99, 331.58, 259.65, 331.86, 259.65, 329.93, 257.44, 329.65, 255.78, 329.93, 253.85, 329.93, 252.74, 329.93, 251.64, 330.75, 250.26, 331.03, 249.43, 331.58, 248.88, 332.14, 248.05, 332.96, 246.67, 333.24, 245.01, 333.24, 243.63, 333.52, 242.8, 334.62, 241.14, 335.73, 238.93, 336.0, 238.1, 337.11, 235.89, 337.38, 235.34, 338.49, 235.07, 339.87, 234.79, 340.15, 234.51, 339.59, 233.68, 338.49, 232.58, 337.66, 231.47, 336.55, 230.09, 336.0, 228.71, 336.0, 227.61, 335.73, 226.5, 335.73, 224.29, 335.73, 223.74, 335.73, 223.19, 336.28, 221.53, 336.55, 220.43, 336.83, 219.32, 337.66, 218.49, 338.21, 217.66, 339.59, 216.84, 340.15, 216.01, 341.25, 215.18, 342.91, 214.63, 343.74, 214.07, 344.56, 214.07, 346.22, 213.52, 347.05, 213.24, 347.88, 213.24, 348.98, 213.24, 349.81, 212.97, 350.36, 212.97, 351.19, 212.69, 352.3, 212.69, 354.23, 212.69, 355.06, 212.69, 356.44, 212.69, 357.82, 213.8, 359.2, 214.63, 360.31, 215.73, 360.86, 216.28, 362.52, 217.66, 362.79, 218.49, 363.07, 219.6, 363.07, 220.98, 363.07, 221.53, 363.07, 223.46, 363.07, 223.19, 364.17, 223.19, 365.0, 222.91, 365.83, 222.91, 366.66, 222.91, 367.49, 222.91, 368.32, 222.91, 369.42, 222.91, 370.53, 222.91, 371.36, 223.19, 372.46, 224.02, 374.12, 224.29, 374.39, 224.29, 374.67, 224.57, 375.5, 224.85, 376.6, 225.4, 377.43, 225.95, 377.99, 226.5, 379.09, 227.06, 379.92, 227.06, 381.3, 227.88, 381.85, 227.88, 383.51, 227.88, 383.79, 227.88]], "area": 2982.624900000001, "iscrowd": 0, "image_id": 12670, "bbox": [315.29, 172.64, 77.89, 87.01], "category_id": 1, "id": 1319466}, {"segmentation": [[593.2, 358.22, 592.81, 356.91, 592.94, 350.92, 593.59, 349.09, 593.46, 348.57, 593.33, 346.75, 592.29, 346.49, 592.29, 344.92, 593.2, 344.4, 593.2, 342.44, 594.64, 341.53, 595.33, 342.85, 595.4, 343.83, 596.31, 344.25, 597.08, 345.3, 597.64, 346.56, 597.92, 348.02, 597.85, 349.49, 598.33, 350.4, 598.13, 353.54, 598.33, 355.15, 598.47, 357.87, 597.78, 358.71, 596.17, 357.66, 595.54, 357.94, 594.98, 358.5, 593.79, 358.5]], "area": 75.22300000000003, "iscrowd": 0, "image_id": 17959, "bbox": [592.29, 341.53, 6.18, 17.18], "category_id": 1, "id": 1321325}, {"segmentation": [[471.28, 290.46, 449.16, 265.46, 429.92, 234.68, 419.34, 219.29, 433.77, 207.75, 422.23, 185.63, 430.89, 169.28, 444.35, 162.54, 469.36, 170.24, 474.17, 195.24, 468.4, 221.21, 462.62, 239.49, 471.28, 268.34, 477.05, 293.35]], "area": 4137.523649999998, "iscrowd": 0, "image_id": 12670, "bbox": [419.34, 162.54, 57.71, 130.81], "category_id": 1, "id": 1323932}, {"segmentation": [[535.03, 113.58, 535.78, 105.33, 533.62, 102.33, 530.44, 100.46, 528.76, 99.95, 528.76, 97.51, 527.96, 96.48, 525.97, 96.31, 524.95, 96.37, 523.87, 97.22, 522.9, 98.19, 522.85, 98.99, 522.9, 100.63, 522.33, 101.94, 522.45, 102.63, 520.06, 103.88, 518.92, 107.17, 519.09, 113.03, 519.26, 114.51, 521.37, 115.31, 526.03, 114.91, 533.71, 114.85, 534.62, 113.26]], "area": 237.06269999999998, "iscrowd": 0, "image_id": 12120, "bbox": [518.92, 96.31, 16.86, 19.0], "category_id": 1, "id": 1324175}, {"segmentation": [[450.17, 351.18, 451.71, 349.36, 452.97, 348.59, 453.74, 345.37, 457.1, 343.83, 457.73, 345.79, 458.01, 348.24, 458.15, 348.73, 458.22, 350.34, 458.36, 351.18]], "area": 35.253050000000044, "iscrowd": 0, "image_id": 17959, "bbox": [450.17, 343.83, 8.19, 7.35], "category_id": 1, "id": 1324179}, {"segmentation": [[556.37, 384.69, 559.13, 375.03, 557.06, 368.83, 557.75, 359.86, 559.82, 351.59, 561.89, 344.0, 575.68, 336.42, 593.61, 341.24, 599.82, 352.97, 603.27, 360.55, 611.54, 369.52, 618.44, 386.07, 616.37, 394.34, 613.61, 396.41, 623.95, 404.69, 626.02, 413.65, 626.71, 419.17, 629.47, 427.44, 605.34, 428.0, 606.02, 392.96, 610.85, 383.31, 608.09, 374.34, 603.27, 363.31, 590.85, 350.9, 577.75, 350.9, 567.41, 355.04, 562.58, 364.0, 562.58, 376.41, 562.58, 383.31, 556.37, 385.38]], "area": 1485.1226, "iscrowd": 0, "image_id": 12670, "bbox": [556.37, 336.42, 73.1, 91.58], "category_id": 27, "id": 1416967}, {"segmentation": [[249.42, 401.25, 251.79, 403.25, 254.7, 401.07, 259.42, 405.43, 260.51, 409.07, 262.51, 415.25, 264.15, 419.07, 257.79, 421.07, 247.24, 418.34, 242.7, 418.16, 240.52, 412.89, 249.06, 400.89]], "area": 305.6836499999998, "iscrowd": 0, "image_id": 17959, "bbox": [240.52, 400.89, 23.63, 20.18], "category_id": 27, "id": 1418162}, {"segmentation": [[1.54, 263.21, 10.01, 240.63, 0.0, 225.26, 3.74, 221.5, 15.97, 231.22, 20.99, 240.94, 27.89, 237.49, 36.98, 225.26, 44.82, 217.11, 38.86, 240.0, 42.63, 250.35, 51.41, 263.21, 52.35, 273.24, 51.72, 274.5, 51.72, 276.38, 29.45, 269.48, 4.05, 272.3, 0.29, 276.07]], "area": 1677.5977500000008, "iscrowd": 0, "image_id": 12670, "bbox": [0.0, 217.11, 52.35, 59.27], "category_id": 27, "id": 1422343}, {"segmentation": [[549.78, 66.5, 561.04, 71.71, 564.57, 81.62, 562.89, 94.06, 561.21, 112.04, 561.38, 115.91, 567.76, 116.58, 569.95, 116.07, 576.5, 112.21, 578.86, 103.81, 575.66, 90.53, 572.97, 80.61, 570.62, 77.25, 570.29, 75.4, 568.27, 76.92, 563.9, 71.87, 558.18, 67.17, 552.47, 64.65, 550.79, 64.65]], "area": 566.7530999999992, "iscrowd": 0, "image_id": 12670, "bbox": [549.78, 64.65, 29.08, 51.93], "category_id": 27, "id": 1422414}, {"segmentation": [[227.84, 52.0, 235.81, 49.41, 238.6, 52.8, 240.98, 63.15, 240.59, 69.32, 238.79, 71.12, 234.61, 72.71, 231.83, 70.12, 229.24, 62.36, 228.24, 55.59]], "area": 218.73834999999968, "iscrowd": 0, "image_id": 15660, "bbox": [227.84, 49.41, 13.14, 23.3], "category_id": 38, "id": 1464301}, {"segmentation": [[303.76, 173.34, 242.58, 141.91, 270.08, 121.7, 300.95, 159.87, 308.81, 164.36, 320.59, 166.6, 344.17, 174.46, 356.52, 183.44, 375.04, 192.98, 413.76, 209.82, 426.67, 214.31, 459.23, 229.47, 424.43, 221.61, 378.97, 202.52, 352.02, 190.74, 331.26, 181.2, 309.93, 172.22]], "area": 2456.223600000001, "iscrowd": 0, "image_id": 17959, "bbox": [242.58, 121.7, 216.65, 107.77], "category_id": 38, "id": 1465879}, {"segmentation": [[578.71, 310.45, 561.63, 301.41, 564.64, 296.39, 548.57, 284.33, 548.57, 296.39, 534.5, 290.36, 519.43, 267.25, 505.37, 268.26, 508.38, 279.31, 496.32, 280.31, 481.25, 271.27, 470.2, 258.21, 451.11, 247.16, 446.09, 238.12, 465.18, 214.0, 518.43, 201.95, 538.52, 220.03, 534.5, 229.07, 550.58, 238.12, 554.6, 238.12, 567.66, 260.22, 599.81, 280.31, 584.74, 307.44]], "area": 7668.203399999998, "iscrowd": 0, "image_id": 17959, "bbox": [446.09, 201.95, 153.72, 108.5], "category_id": 38, "id": 1467191}, {"segmentation": [[406.91, 267.25, 393.84, 252.18, 382.79, 254.19, 355.67, 237.11, 335.57, 229.07, 332.56, 244.14, 321.51, 248.16, 304.43, 229.07, 292.37, 228.07, 271.27, 215.01, 278.3, 188.88, 303.42, 176.83, 337.58, 183.86, 343.61, 191.9, 345.62, 196.92, 353.66, 194.91, 383.8, 208.98, 416.95, 222.04, 419.97, 224.05, 412.93, 259.21]], "area": 6586.9691, "iscrowd": 0, "image_id": 17959, "bbox": [271.27, 176.83, 148.7, 90.42], "category_id": 38, "id": 1469129}, {"segmentation": [[192.35, 292.56, 225.58, 281.48, 240.69, 282.48, 264.86, 272.41, 275.94, 309.68, 290.04, 325.79, 297.09, 349.96, 321.26, 351.97, 324.28, 369.09, 317.23, 377.15, 294.07, 394.27, 285.0, 383.19, 272.92, 376.14, 272.92, 393.26, 234.65, 398.3, 247.74, 365.06, 236.66, 345.93, 227.6, 358.02, 223.57, 336.87, 217.53, 331.83, 199.4, 312.7, 191.34, 303.63]], "area": 8236.113599999993, "iscrowd": 0, "image_id": 17959, "bbox": [191.34, 272.41, 132.94, 125.89], "category_id": 38, "id": 1469183}, {"segmentation": [[164.13, 160.82, 193.19, 141.29, 215.11, 185.59, 213.68, 191.79, 236.54, 230.85, 255.12, 250.86, 287.52, 281.34, 317.05, 300.88, 323.72, 309.45, 331.34, 331.84, 330.87, 344.7, 324.2, 340.41, 318.48, 308.5, 288.94, 284.68, 260.84, 261.34, 236.07, 235.14, 210.34, 214.18, 205.58, 201.31, 199.86, 206.08]], "area": 2665.4564000000023, "iscrowd": 0, "image_id": 17959, "bbox": [164.13, 141.29, 167.21, 203.41], "category_id": 38, "id": 1469432}, {"segmentation": [[23.11, 407.91, 51.24, 302.42, 79.37, 224.05, 95.45, 203.96, 118.56, 248.16, 172.81, 266.25, 159.75, 301.41, 114.54, 252.18, 96.45, 223.04, 95.45, 266.25, 84.4, 296.39, 80.38, 326.53, 69.32, 349.64, 63.3, 377.77, 42.2, 396.86, 25.12, 408.92]], "area": 6913.322649999998, "iscrowd": 0, "image_id": 17959, "bbox": [23.11, 203.96, 149.7, 204.96], "category_id": 38, "id": 1469484}, {"segmentation": [[640.0, 277.3, 606.84, 273.28, 589.76, 249.17, 564.64, 233.09, 547.56, 218.02, 518.43, 198.93, 497.33, 184.87, 448.1, 165.78, 428.0, 146.69, 417.96, 134.63, 386.81, 111.52, 360.69, 95.45, 349.64, 126.59, 385.81, 129.61, 414.94, 152.72, 474.22, 178.84, 556.61, 228.07, 573.69, 256.2, 602.82, 269.26, 610.86, 277.3, 608.85, 274.28]], "area": 2788.935549999991, "iscrowd": 0, "image_id": 17959, "bbox": [349.64, 95.45, 290.36, 181.85], "category_id": 38, "id": 1469614}, {"segmentation": [[325.73, 248.01, 312.1, 294.69, 285.86, 277.32, 311.07, 233.7, 320.96, 249.03], [309.03, 302.19, 299.49, 323.32, 291.99, 331.49, 285.52, 319.57, 280.41, 314.8, 272.23, 302.19, 280.41, 284.47, 282.45, 279.7]], "area": 2170.817199999999, "iscrowd": 0, "image_id": 17959, "bbox": [272.23, 233.7, 53.5, 97.79], "category_id": 38, "id": 1469712}, {"segmentation": [[359.33, 240.58, 380.65, 253.12, 380.03, 266.92, 377.52, 295.45, 372.81, 319.28, 370.93, 329.63, 365.6, 337.16, 366.23, 363.81, 365.6, 374.16, 358.71, 378.55, 350.87, 384.19, 342.09, 390.46, 334.56, 398.61, 332.68, 402.06, 331.43, 402.69, 335.82, 367.57, 340.83, 329.94, 348.04, 280.09, 353.37, 261.28]], "area": 4085.2117499999986, "iscrowd": 0, "image_id": 17959, "bbox": [331.43, 240.58, 49.22, 162.11], "category_id": 38, "id": 1469717}, {"segmentation": [[195.23, 385.29, 211.35, 385.29, 215.26, 384.8, 222.1, 386.26, 221.12, 388.46, 231.38, 390.42, 217.95, 393.1, 203.04, 393.59, 192.29, 394.57, 194.0, 384.8], [186.68, 386.26, 192.54, 384.55, 189.85, 396.04, 186.43, 394.33, 185.7, 393.59, 176.41, 392.86, 174.7, 392.86, 174.95, 390.91, 182.52, 391.64, 182.77, 387.73]], "area": 337.9363999999995, "iscrowd": 0, "image_id": 17959, "bbox": [174.7, 384.55, 56.68, 11.49], "category_id": 38, "id": 1469806}, {"segmentation": [[132.93, 365.0, 140.55, 353.95, 151.98, 352.05, 167.97, 350.52, 175.97, 349.0, 184.73, 352.81, 184.73, 359.28, 175.97, 365.38, 168.73, 375.66, 169.11, 384.42, 171.4, 388.23, 178.25, 393.18, 177.11, 399.27, 159.97, 394.7, 150.07, 387.46, 141.31, 384.42, 136.74, 380.23, 133.7, 376.8, 132.55, 369.18]], "area": 1584.0033999999996, "iscrowd": 0, "image_id": 12639, "bbox": [132.55, 349.0, 52.18, 50.27], "category_id": 40, "id": 1470364}, {"segmentation": [[492.25, 237.08, 493.35, 236.86, 493.9, 237.03, 494.4, 237.3, 494.4, 238.4, 494.23, 238.95, 493.63, 239.23, 492.69, 239.34, 492.2, 239.28, 491.92, 239.12, 491.7, 238.73, 491.87, 238.24, 492.2, 237.74, 492.42, 237.08], [495.28, 235.1, 495.17, 232.95, 495.0, 231.69, 495.0, 231.63, 495.44, 230.75, 495.99, 230.2, 496.93, 229.49, 498.53, 228.77, 500.12, 228.11, 501.33, 226.95, 502.38, 225.19, 502.66, 223.43, 502.05, 222.44, 500.78, 221.34, 499.74, 220.68, 497.81, 220.35, 496.71, 220.4, 495.88, 220.68, 494.95, 221.06, 493.57, 221.45, 492.31, 222.0, 492.25, 221.94, 490.38, 222.27, 489.17, 223.26, 488.34, 224.09, 488.18, 224.75, 487.85, 226.13, 488.29, 227.28, 488.67, 228.49, 489.28, 229.32, 489.83, 229.65, 490.38, 229.87, 491.59, 230.7, 492.31, 231.3, 492.25, 232.79, 492.2, 234.44, 492.2, 235.16]], "area": 128.9662999999999, "iscrowd": 0, "image_id": 12120, "bbox": [487.85, 220.35, 14.81, 18.99], "category_id": 43, "id": 1481890}, {"segmentation": [[417.36, 267.67, 423.01, 263.27, 431.18, 262.02, 439.97, 262.02, 446.88, 262.02, 453.78, 265.16, 455.67, 277.72, 455.67, 302.83, 448.13, 311.63, 439.34, 325.44, 439.97, 331.72, 441.23, 334.86, 450.02, 339.26, 454.41, 347.42, 453.16, 348.68, 436.2, 353.07, 423.01, 353.07, 417.99, 350.56, 421.13, 340.51, 430.55, 328.58, 426.15, 321.67, 416.11, 313.51, 412.34, 303.46, 412.34, 290.28]], "area": 2882.545150000001, "iscrowd": 0, "image_id": 16439, "bbox": [412.34, 262.02, 43.33, 91.05], "category_id": 46, "id": 1497036}, {"segmentation": [[311.73, 10.06, 312.1, 21.21, 310.7, 20.46, 309.86, 19.24, 307.61, 18.68, 304.7, 18.49, 304.7, 15.59, 301.61, 14.18, 299.74, 14.93, 300.02, 7.72, 311.45, 8.28]], "area": 112.83430000000028, "iscrowd": 0, "image_id": 12120, "bbox": [299.74, 7.72, 12.36, 13.49], "category_id": 62, "id": 1586452}, {"segmentation": [[387.75, 22.11, 381.91, 18.55, 377.84, 19.57, 375.81, 18.8, 375.81, 14.99, 376.06, 10.42, 380.38, 9.15, 385.46, 8.64, 387.24, 10.92, 387.5, 17.79]], "area": 118.48469999999995, "iscrowd": 0, "image_id": 12120, "bbox": [375.81, 8.64, 11.94, 13.47], "category_id": 62, "id": 1597360}, {"segmentation": [[133.2, 27.02, 148.4, 27.02, 148.56, 36.08, 131.66, 36.54, 131.66, 27.48]], "area": 155.92200000000005, "iscrowd": 0, "image_id": 12120, "bbox": [131.66, 27.02, 16.9, 9.52], "category_id": 62, "id": 1599619}, {"segmentation": [[472.25, 123.95, 480.43, 125.02, 480.64, 127.61, 479.35, 155.15, 472.25, 154.29, 473.33, 149.56, 475.26, 146.54, 476.34, 143.1, 477.41, 136.64, 478.28, 129.11, 474.4, 126.96]], "area": 131.0995500000004, "iscrowd": 0, "image_id": 12120, "bbox": [472.25, 123.95, 8.39, 31.2], "category_id": 62, "id": 1600157}, {"segmentation": [[285.81, 167.01, 283.46, 152.9, 283.98, 135.66, 292.08, 166.23, 294.69, 168.06, 298.61, 166.75, 298.09, 159.7, 296.52, 158.91, 295.48, 151.07, 293.39, 144.28, 293.65, 137.23, 296.26, 136.44, 296.26, 125.73, 297.83, 122.59, 294.69, 112.4, 293.36, 103.72, 289.08, 100.24, 284.0, 97.3, 283.73, 93.02, 281.33, 90.35, 277.85, 89.82, 274.11, 91.69, 272.77, 92.76, 271.97, 95.16, 273.04, 97.3, 274.37, 99.44, 271.97, 102.38, 269.83, 104.79, 268.64, 116.2, 269.15, 122.32, 273.06, 128.62, 273.92, 130.16, 272.89, 132.03, 275.28, 137.14, 276.39, 155.0, 276.95, 162.26, 277.51, 164.49, 272.49, 166.72, 273.6, 168.95, 278.63, 167.28, 285.33, 167.28]], "area": 1481.6397999999997, "iscrowd": 0, "image_id": 14439, "bbox": [268.64, 89.82, 29.97, 79.13], "category_id": 1, "id": 1681269}, {"segmentation": [[279.52, 89.03, 279.72, 82.53, 284.39, 79.88, 290.28, 81.1, 291.7, 85.37, 294.95, 93.09, 298.0, 103.25, 295.97, 112.59, 294.75, 108.32, 292.52, 103.04, 284.59, 97.76, 282.56, 90.45]], "area": 271.4347000000001, "iscrowd": 0, "image_id": 14439, "bbox": [279.52, 79.88, 18.48, 32.71], "category_id": 1, "id": 1684258}, {"segmentation": [[383.02, 112.91, 377.86, 113.77, 375.72, 113.77, 376.15, 106.04, 374.43, 103.04, 367.13, 100.89, 366.7, 96.59, 365.84, 88.43, 367.56, 81.99, 366.7, 79.42, 363.69, 77.27, 363.69, 73.4, 365.41, 67.39, 364.12, 62.24, 366.7, 58.8, 367.56, 57.51, 374.0, 59.66, 374.0, 66.53, 379.58, 69.11, 380.87, 78.99, 380.44, 81.99, 378.72, 98.31, 380.87, 105.61, 382.16, 112.91]], "area": 623.4129500000006, "iscrowd": 0, "image_id": 14439, "bbox": [363.69, 57.51, 19.33, 56.26], "category_id": 1, "id": 1695019}, {"segmentation": [[416.61, 292.96, 420.4, 219.9, 413.76, 215.15, 410.91, 162.01, 427.04, 151.58, 427.99, 131.65, 434.63, 125.01, 445.07, 129.75, 445.07, 147.78, 460.25, 162.96, 467.84, 185.74, 461.2, 185.74, 463.1, 224.64, 455.51, 224.64, 458.36, 253.11, 445.07, 278.72, 445.07, 278.72, 451.71, 292.96, 433.69, 292.96, 435.58, 244.57, 431.79, 257.85, 427.04, 278.72, 431.79, 292.96]], "area": 6073.2352, "iscrowd": 0, "image_id": 12639, "bbox": [410.91, 125.01, 56.93, 167.95], "category_id": 1, "id": 1710025}, {"segmentation": [[436.14, 361.33, 433.88, 361.47, 433.03, 356.37, 432.46, 353.82, 431.19, 353.82, 432.46, 351.27, 433.17, 349.57, 434.87, 349.43, 435.15, 351.7, 436.57, 356.94]], "area": 36.056650000000076, "iscrowd": 0, "image_id": 17959, "bbox": [431.19, 349.43, 5.38, 12.04], "category_id": 1, "id": 1711987}, {"segmentation": [[339.29, 79.74, 335.11, 79.22, 334.59, 69.05, 333.03, 67.75, 333.29, 59.93, 328.34, 50.54, 330.68, 45.85, 333.29, 44.81, 334.07, 40.11, 336.68, 38.55, 339.81, 41.16, 340.07, 45.07, 342.94, 45.85, 347.11, 49.5, 342.15, 57.84, 339.55, 78.7]], "area": 366.50915000000003, "iscrowd": 0, "image_id": 14439, "bbox": [328.34, 38.55, 18.77, 41.19], "category_id": 1, "id": 1720080}, {"segmentation": [[564.54, 353.92, 565.21, 348.4, 565.55, 346.56, 564.38, 345.72, 563.37, 341.87, 562.54, 341.21, 561.37, 341.37, 560.86, 346.22, 560.2, 347.23, 560.2, 351.41, 560.36, 353.25, 564.21, 353.25]], "area": 47.31054999999961, "iscrowd": 0, "image_id": 17959, "bbox": [560.2, 341.21, 5.35, 12.71], "category_id": 1, "id": 1725965}, {"segmentation": [[463.58, 351.15, 464.3, 349.59, 464.3, 348.03, 464.42, 346.83, 466.09, 346.59, 466.45, 346.59, 467.05, 347.91, 467.77, 350.07, 468.01, 351.03], [463.46, 354.15, 463.7, 358.11, 463.82, 359.55, 464.78, 360.99, 465.97, 360.75, 467.77, 359.91, 468.01, 358.95, 467.65, 356.67, 467.53, 353.19, 463.7, 353.79]], "area": 42.29759999999989, "iscrowd": 0, "image_id": 17959, "bbox": [463.46, 346.59, 4.55, 14.4], "category_id": 1, "id": 1727181}, {"segmentation": [[385.01, 44.81, 385.01, 42.96, 385.92, 40.69, 388.76, 40.08, 390.59, 41.3, 390.79, 44.35, 390.39, 45.98, 391.81, 48.21, 394.04, 50.65, 394.45, 53.09, 396.08, 63.24, 394.45, 63.45, 393.23, 59.99, 392.83, 56.13, 391.81, 55.93, 391.0, 59.99, 392.22, 79.49, 392.01, 82.95, 389.37, 82.95, 388.97, 80.51, 388.76, 69.74, 387.34, 67.71, 385.51, 66.9, 383.28, 68.52, 383.89, 82.13, 380.84, 79.29, 381.65, 65.27, 382.87, 56.34, 380.23, 65.07, 378.2, 62.43, 378.61, 59.79, 380.64, 53.49, 382.47, 49.63, 383.68, 47.6, 384.9, 46.18, 385.92, 46.38]], "area": 367.1871000000001, "iscrowd": 0, "image_id": 14439, "bbox": [378.2, 40.08, 17.88, 42.87], "category_id": 1, "id": 1729788}, {"segmentation": [[558.52, 176.32, 540.34, 177.32, 517.62, 177.32, 516.61, 175.81, 511.06, 170.76, 510.55, 163.19, 509.54, 155.61, 508.03, 151.07, 505.5, 142.49, 509.54, 140.47, 519.64, 142.49, 525.7, 146.53, 527.44, 143.42, 529.46, 140.79, 529.86, 140.19, 529.86, 138.57, 526.02, 135.74, 524.81, 131.49, 523.8, 125.22, 525.18, 117.15, 529.47, 114.39, 532.84, 114.39, 539.58, 114.08, 546.74, 120.26, 547.92, 128.52, 545.96, 138.75, 545.96, 139.54, 551.07, 141.9, 551.46, 148.98, 553.04, 160.39, 554.61, 167.07, 555.79, 174.15], [560.12, 192.25, 562.48, 207.59, 566.41, 221.76, 578.61, 233.95, 590.41, 245.36, 597.1, 244.97, 597.88, 249.29, 594.34, 269.75, 587.26, 270.93, 587.26, 270.93, 583.33, 271.72, 582.54, 265.42, 582.94, 260.7, 577.43, 263.06, 575.85, 260.31, 551.46, 228.84, 545.17, 213.1, 542.41, 213.1, 538.87, 222.94, 534.55, 231.59, 532.58, 250.87, 532.19, 257.16, 532.19, 261.49, 533.76, 266.21, 534.94, 269.36, 534.94, 270.15, 514.88, 265.82, 514.48, 261.1, 516.06, 255.2, 519.2, 240.64, 517.24, 234.35, 516.84, 224.12, 520.78, 212.31, 520.78, 206.41, 520.78, 197.76, 520.78, 188.71, 523.92, 189.1]], "area": 5222.28025, "iscrowd": 0, "image_id": 14439, "bbox": [505.5, 114.08, 92.38, 157.64], "category_id": 1, "id": 1733380}, {"segmentation": [[640.0, 124.81, 637.98, 123.36, 638.24, 120.73, 637.58, 117.58, 636.27, 116.13, 634.03, 115.48, 632.46, 114.82, 633.51, 113.9, 634.95, 113.11, 635.22, 112.06, 635.22, 110.35, 634.82, 108.77, 634.82, 107.33, 634.69, 105.88, 635.35, 104.96, 637.06, 104.04, 638.64, 103.91, 639.29, 104.43, 640.0, 105.35]], "area": 79.85544999999946, "iscrowd": 0, "image_id": 12120, "bbox": [632.46, 103.91, 7.54, 20.9], "category_id": 1, "id": 1740684}, {"segmentation": [[290.31, 205.38, 288.13, 202.65, 287.77, 198.83, 285.4, 195.93, 283.59, 193.93, 279.04, 193.56, 276.5, 196.83, 275.95, 200.83, 275.59, 204.1, 279.41, 203.38, 284.68, 203.92, 289.04, 205.01]], "area": 106.37539999999967, "iscrowd": 0, "image_id": 12639, "bbox": [275.59, 193.56, 14.72, 11.82], "category_id": 1, "id": 1742643}, {"segmentation": [[581.15, 176.44, 605.82, 176.86, 607.07, 168.08, 608.74, 160.55, 610.83, 146.34, 613.76, 146.34, 609.16, 130.03, 603.31, 127.52, 604.14, 120.83, 603.31, 115.4, 597.87, 112.47, 593.27, 115.81, 590.76, 122.09, 591.6, 129.61, 585.75, 139.65, 585.75, 146.34, 586.58, 150.1, 582.82, 160.55, 583.66, 164.73, 585.33, 163.48, 584.49, 171.84, 582.4, 176.02], [579.06, 188.57, 579.06, 192.33, 578.64, 197.35, 589.93, 198.6, 590.76, 190.66, 593.27, 188.15], [594.95, 188.15, 592.44, 192.75, 594.53, 196.51, 602.05, 196.93, 605.4, 191.49, 604.56, 186.9]], "area": 1524.5267499999989, "iscrowd": 0, "image_id": 14439, "bbox": [578.64, 112.47, 35.12, 86.13], "category_id": 1, "id": 1749825}, {"segmentation": [[53.38, 153.89, 47.3, 149.55, 46.87, 146.95, 42.53, 146.95, 41.22, 149.55, 38.18, 149.55, 32.1, 145.21, 26.89, 139.56, 25.16, 132.62, 26.46, 124.8, 28.63, 120.46, 33.84, 117.85, 38.62, 116.99, 44.26, 117.42, 46.87, 124.37, 49.91, 127.41, 52.95, 133.92, 54.68, 138.26, 58.16, 143.04, 63.37, 146.08, 65.54, 150.42, 59.46, 154.76]], "area": 840.4303499999999, "iscrowd": 0, "image_id": 14439, "bbox": [25.16, 116.99, 40.38, 37.77], "category_id": 1, "id": 1751086}, {"segmentation": [[187.53, 60.92, 187.8, 53.01, 188.85, 50.9, 190.96, 49.58, 192.02, 44.57, 195.18, 45.89, 195.97, 50.37, 200.71, 53.01, 197.02, 61.18]], "area": 138.24575000000004, "iscrowd": 0, "image_id": 14439, "bbox": [187.53, 44.57, 13.18, 16.61], "category_id": 1, "id": 1754508}, {"segmentation": [[170.36, 60.39, 169.82, 57.81, 169.82, 56.46, 170.09, 54.83, 170.61, 52.29, 171.49, 51.55, 172.36, 51.03, 172.01, 47.75, 173.26, 47.27, 174.86, 47.82, 176.61, 49.01, 176.61, 51.1, 175.49, 51.86, 175.98, 52.84, 177.65, 54.09, 178.21, 56.74, 178.14, 60.08, 177.44, 61.41, 174.52, 61.41, 171.73, 61.27, 170.54, 61.06, 170.27, 60.5]], "area": 88.33755, "iscrowd": 0, "image_id": 14439, "bbox": [169.82, 47.27, 8.39, 14.14], "category_id": 1, "id": 1755416}, {"segmentation": [[175.25, 92.49, 173.87, 88.76, 174.66, 84.63, 176.62, 82.07, 183.7, 83.45, 186.06, 88.36, 187.04, 93.87, 192.54, 99.17, 195.1, 103.89, 196.47, 111.55, 197.06, 117.06, 195.1, 120.79, 193.53, 121.77, 191.76, 124.72, 193.53, 138.09, 195.69, 148.5, 198.44, 153.81, 198.83, 156.17, 194.12, 166.98, 191.76, 166.78, 191.76, 164.82, 186.65, 143.0, 184.49, 138.28, 181.93, 134.75, 179.96, 140.64, 179.96, 146.73, 179.57, 153.22, 180.55, 159.51, 182.32, 160.1, 182.52, 162.06, 180.75, 164.23, 178.2, 166.39, 175.64, 165.21, 174.27, 161.28, 173.48, 155.38, 172.1, 138.87, 172.1, 130.23, 172.3, 124.13, 171.91, 121.77, 171.51, 123.74, 168.76, 122.56, 167.58, 119.02, 164.83, 112.93, 165.81, 105.46, 168.17, 98.98, 171.51, 95.44]], "area": 1622.7973000000002, "iscrowd": 0, "image_id": 14439, "bbox": [164.83, 82.07, 34.0, 84.91], "category_id": 1, "id": 1755623}, {"segmentation": [[435.0, 246.18, 441.86, 239.32, 445.29, 237.04, 448.14, 235.32, 450.43, 235.32, 451.0, 235.32, 453.29, 234.18, 451.0, 230.18, 446.43, 231.32, 436.14, 232.47, 433.29, 235.32, 433.29, 240.47], [457.29, 276.47, 463.0, 266.18, 462.43, 249.04, 464.72, 246.75, 465.86, 259.33, 461.29, 277.61]], "area": 219.4885500000003, "iscrowd": 0, "image_id": 12670, "bbox": [433.29, 230.18, 32.57, 47.43], "category_id": 27, "id": 1825310}, {"segmentation": [[118.79, 167.73, 108.85, 169.52, 103.68, 168.92, 104.28, 164.35, 100.1, 160.17, 102.49, 157.59, 105.27, 154.8, 112.83, 156.2, 113.02, 157.19, 118.79, 160.17, 119.59, 163.75]], "area": 197.40875000000005, "iscrowd": 0, "image_id": 14439, "bbox": [100.1, 154.8, 19.49, 14.72], "category_id": 27, "id": 1826473}, {"segmentation": [[64.42, 157.03, 69.92, 156.07, 72.53, 155.38, 75.15, 155.24, 79.14, 155.93, 85.88, 158.82, 92.9, 166.94, 92.76, 171.89, 88.22, 172.72, 75.7, 173.54, 60.7, 172.31, 57.54, 166.94, 58.09, 162.95, 58.64, 160.89, 59.05, 159.65, 61.25, 158.27]], "area": 509.22274999999985, "iscrowd": 0, "image_id": 14439, "bbox": [57.54, 155.24, 35.36, 18.3], "category_id": 27, "id": 1826731}, {"segmentation": [[65.88, 153.79, 85.42, 151.09, 82.11, 138.46, 77.91, 132.45, 72.2, 134.25, 70.09, 138.16, 64.08, 144.47]], "area": 300.87115, "iscrowd": 0, "image_id": 14439, "bbox": [64.08, 132.45, 21.34, 21.34], "category_id": 27, "id": 1827291}, {"segmentation": [[408.93, 350.53, 408.48, 348.57, 409.23, 347.37, 412.09, 347.67, 413.14, 349.47, 412.24, 350.07, 413.14, 350.68, 412.24, 353.83, 411.94, 356.84, 411.79, 358.49, 413.29, 360.89, 413.29, 362.1, 409.38, 362.85, 406.98, 360.59, 407.13, 357.44, 407.28, 354.88, 407.88, 352.78]], "area": 70.2078000000001, "iscrowd": 0, "image_id": 17959, "bbox": [406.98, 347.37, 6.31, 15.48], "category_id": 1, "id": 2009873}, {"segmentation": [[167.89, 193.93, 161.26, 197.72, 161.58, 204.66, 160.0, 208.45, 158.11, 212.24, 154.32, 214.77, 160.95, 217.93, 160.95, 225.19, 159.05, 228.35, 160.0, 230.24, 163.79, 230.87, 165.68, 231.19, 170.74, 228.98, 169.16, 224.87, 166.95, 220.77, 169.79, 219.82, 170.11, 194.56]], "area": 338.75715000000025, "iscrowd": 0, "image_id": 12639, "bbox": [154.32, 193.93, 16.42, 37.26], "category_id": 1, "id": 2014077}, {"segmentation": [[111.07, 93.68, 105.56, 89.26, 109.97, 88.16, 112.73, 82.64, 114.39, 74.64, 113.56, 70.78, 112.18, 66.92, 111.35, 65.81, 106.66, 71.33, 103.9, 68.85, 110.52, 60.57, 111.9, 55.33, 113.56, 54.23, 110.8, 51.47, 112.73, 45.68, 114.39, 45.12, 116.87, 46.23, 117.7, 50.37, 117.7, 51.19, 122.11, 53.95, 125.97, 64.16, 128.18, 70.78, 126.52, 73.54, 122.11, 66.64, 122.11, 69.12, 121.01, 76.3, 122.11, 79.06, 123.49, 86.78, 124.87, 91.47, 121.56, 92.3, 118.25, 92.02, 120.45, 89.81, 121.01, 88.71, 117.42, 79.06, 115.21, 85.12, 112.73, 90.09, 112.45, 93.12]], "area": 486.7893, "iscrowd": 0, "image_id": 14439, "bbox": [103.9, 45.12, 24.28, 48.56], "category_id": 1, "id": 2016432}, {"segmentation": [[605.78, 355.78, 605.88, 354.13, 604.59, 353.03, 604.59, 352.11, 605.42, 351.84, 605.78, 350.19, 606.88, 350.46, 607.25, 351.56, 609.45, 351.84, 608.9, 353.4, 607.89, 353.95, 607.89, 356.15]], "area": 15.385749999999973, "iscrowd": 0, "image_id": 17959, "bbox": [604.59, 350.19, 4.86, 5.96], "category_id": 1, "id": 2025196}, {"segmentation": [[351.64, 131.21, 361.56, 116.81, 361.56, 108.49, 357.72, 98.88, 355.16, 94.72, 358.68, 85.44, 360.92, 78.72, 362.2, 74.24, 367.96, 73.6, 378.84, 73.92, 383.01, 77.76, 384.29, 86.4, 384.29, 98.56, 389.41, 109.77, 393.25, 119.69, 392.93, 136.97, 393.25, 144.02, 394.85, 156.82, 396.45, 168.98, 384.61, 167.06, 386.21, 148.18, 385.89, 142.1, 383.97, 133.13, 381.73, 127.37, 377.88, 126.09, 370.84, 126.09, 366.68, 126.09, 363.48, 128.65, 357.4, 136.01, 355.48, 140.17, 351.32, 140.81, 349.4, 139.21]], "area": 1955.6273000000012, "iscrowd": 0, "image_id": 12670, "bbox": [349.4, 73.6, 47.05, 95.38], "category_id": 1, "id": 2026694}, {"segmentation": [[508.82, 99.45, 509.4, 95.95, 509.59, 94.2, 510.18, 91.29, 509.01, 85.46, 506.48, 84.49, 507.07, 80.02, 507.07, 77.49, 504.73, 75.94, 500.65, 77.3, 499.88, 82.74, 499.88, 84.49, 496.96, 87.21, 496.57, 93.43, 498.91, 97.51, 500.65, 101.39, 501.24, 102.37, 503.57, 99.64]], "area": 234.4547500000002, "iscrowd": 0, "image_id": 12120, "bbox": [496.57, 75.94, 13.61, 26.43], "category_id": 1, "id": 2030099}, {"segmentation": [[512.36, 138.93, 513.36, 132.98, 518.57, 131.74, 518.32, 125.78, 520.06, 124.05, 525.02, 125.29, 524.77, 131.49, 528.49, 133.97, 531.22, 138.69, 531.96, 142.16]], "area": 187.85259999999954, "iscrowd": 0, "image_id": 12120, "bbox": [512.36, 124.05, 19.6, 18.11], "category_id": 1, "id": 2031548}, {"segmentation": [[134.39, 193.17, 157.14, 254.14, 164.39, 245.92, 174.56, 245.43, 189.56, 248.34, 192.46, 263.34, 191.01, 269.63, 177.46, 272.53, 169.72, 278.34, 165.36, 287.05, 163.91, 296.24, 161.98, 303.02, 155.68, 304.95, 151.33, 301.56, 152.78, 267.21, 152.78, 258.5, 144.56, 245.92, 132.46, 202.37]], "area": 1806.0620999999983, "iscrowd": 0, "image_id": 12670, "bbox": [132.46, 193.17, 60.0, 111.78], "category_id": 31, "id": 2078052}, {"segmentation": [[162.75, 379.36, 182.76, 410.67, 190.12, 427.78, 201.24, 427.44, 192.68, 407.59, 175.41, 381.42, 171.47, 374.74, 164.11, 370.64, 162.92, 364.82, 160.86, 364.82, 154.53, 367.39, 162.92, 379.53]], "area": 687.3572000000007, "iscrowd": 0, "image_id": 12670, "bbox": [154.53, 364.82, 46.71, 62.96], "category_id": 31, "id": 2078792}, {"segmentation": [[588.13, 180.91, 580.79, 198.47, 579.83, 207.73, 587.49, 224.33, 589.73, 224.33, 596.11, 195.91, 600.26, 190.49, 590.05, 187.29], [608.56, 175.8, 621.65, 163.03, 633.15, 137.81, 633.78, 131.74, 638.25, 132.7, 633.78, 148.98, 623.57, 168.46, 612.4, 178.67]], "area": 676.2805500000015, "iscrowd": 0, "image_id": 12670, "bbox": [579.83, 131.74, 58.42, 92.59], "category_id": 31, "id": 2079349}, {"segmentation": [[532.03, 76.34, 534.14, 92.98, 530.13, 96.77, 522.97, 101.4, 521.92, 111.93, 528.24, 106.67, 533.29, 103.09, 542.35, 103.09, 538.56, 92.13, 535.82, 76.13]], "area": 241.7636500000001, "iscrowd": 0, "image_id": 12670, "bbox": [521.92, 76.13, 20.43, 35.8], "category_id": 31, "id": 2079406}, {"segmentation": [[312.08, 71.92, 313.14, 61.18, 316.72, 45.6, 321.98, 39.7, 325.14, 41.59, 324.72, 45.17, 320.93, 46.65, 319.25, 56.97, 316.93, 74.45]], "area": 172.19735000000006, "iscrowd": 0, "image_id": 12670, "bbox": [312.08, 39.7, 13.06, 34.75], "category_id": 31, "id": 2079438}, {"segmentation": [[88.67, 46.29, 98.39, 36.57, 103.49, 34.43, 110.72, 36.09, 118.54, 42.26, 117.83, 43.32, 117.36, 43.68, 110.13, 40.83, 102.31, 40.12, 96.5, 42.26, 93.3, 50.79, 94.96, 58.26, 101.48, 67.03, 101.24, 69.64, 98.99, 69.28, 90.22, 59.44, 87.96, 50.91]], "area": 244.36524999999997, "iscrowd": 0, "image_id": 15660, "bbox": [87.96, 34.43, 30.58, 35.21], "category_id": 38, "id": 2089043}, {"segmentation": [[485.07, 34.07, 478.29, 29.34, 474.51, 28.71, 469.0, 31.55, 464.74, 36.27, 465.69, 42.73, 467.1, 44.31, 467.89, 45.1, 466.47, 46.36, 462.85, 39.74, 463.95, 34.54, 465.84, 31.23, 469.63, 27.92, 472.93, 26.66, 479.24, 26.97, 483.65, 31.07]], "area": 73.13659999999989, "iscrowd": 0, "image_id": 15660, "bbox": [462.85, 26.66, 22.22, 19.7], "category_id": 38, "id": 2089894}, {"segmentation": [[456.65, 120.31, 456.56, 115.57, 457.46, 115.53, 458.19, 116.25, 459.4, 115.71, 459.59, 112.91, 457.82, 112.05, 454.94, 111.29, 454.35, 112.55, 452.0, 115.26, 452.41, 117.61, 455.03, 120.77, 456.11, 120.68]], "area": 41.09249999999979, "iscrowd": 0, "image_id": 15660, "bbox": [452.0, 111.29, 7.59, 9.48], "category_id": 38, "id": 2090079}, {"segmentation": [[134.21, 157.31, 140.76, 161.47, 139.17, 171.18, 130.65, 163.55, 129.95, 160.28, 130.65, 158.4, 132.53, 157.11, 133.72, 157.01]], "area": 87.71535000000002, "iscrowd": 0, "image_id": 12670, "bbox": [129.95, 157.01, 10.81, 14.17], "category_id": 77, "id": 2137256}, {"segmentation": [[504.53, 223.71, 503.18, 235.86, 498.45, 238.56, 491.7, 231.14, 489.0, 241.26, 484.28, 241.94, 482.26, 247.34, 493.73, 249.36, 501.15, 250.71, 498.45, 260.16, 493.05, 266.23, 497.1, 268.26, 490.35, 294.58, 482.93, 313.48, 489.68, 318.2, 497.1, 301.33, 505.2, 281.08, 510.6, 275.01, 517.35, 279.06, 534.9, 312.8, 537.6, 320.9, 541.65, 324.28, 547.05, 318.88, 543.67, 310.78, 529.5, 283.78, 525.45, 263.53, 527.47, 247.34, 531.52, 239.24, 534.9, 230.46, 537.6, 225.74, 532.87, 220.34, 524.1, 208.19, 518.02, 210.22, 516.0, 221.69, 507.23, 222.36]], "area": 2817.1480000000006, "iscrowd": 0, "image_id": 12120, "bbox": [482.26, 208.19, 64.79, 116.09], "category_id": 1, "id": 2152647}, {"segmentation": [[100.31, 227.36, 100.31, 224.45, 100.31, 219.26, 100.52, 216.35, 105.3, 212.81, 107.17, 209.9, 107.38, 208.66, 106.96, 203.46, 106.96, 200.97, 108.42, 197.02, 113.27, 193.73, 120.34, 195.6, 121.79, 200.79, 123.04, 206.2, 123.46, 209.73, 128.23, 211.18, 128.86, 213.68, 130.1, 217.21, 134.47, 220.95, 138.62, 224.69, 136.34, 230.51, 137.59, 232.38, 143.4, 230.51, 146.52, 231.55, 146.31, 235.29, 146.52, 239.44, 142.36, 243.81, 139.46, 246.09, 138.42, 246.51, 133.85, 247.96, 127.82, 247.55, 119.92, 247.34, 109.53, 245.68, 105.38, 245.68, 102.88, 243.6, 102.68, 238.82, 100.18, 234.46, 98.94, 231.34]], "area": 1565.9484000000007, "iscrowd": 0, "image_id": 12639, "bbox": [98.94, 193.73, 47.58, 54.23], "category_id": 1, "id": 2159540}, {"segmentation": [[295.64, 243.79, 286.18, 266.4, 290.39, 271.66, 305.63, 259.56, 298.8, 252.72]], "area": 233.39200000000037, "iscrowd": 0, "image_id": 12670, "bbox": [286.18, 243.79, 19.45, 27.87], "category_id": 27, "id": 2175880}, {"segmentation": [[601.82, 112.59, 601.99, 114.13, 604.38, 115.16, 605.24, 123.89, 608.67, 123.89, 609.35, 122.52, 609.35, 113.62, 608.32, 111.9, 605.41, 110.53, 601.64, 112.59]], "area": 64.69290000000022, "iscrowd": 0, "image_id": 15660, "bbox": [601.64, 110.53, 7.71, 13.36], "category_id": 38, "id": 2180609}, {"segmentation": [[285.4, 18.66, 285.19, 8.34, 296.35, 7.08, 297.62, 20.56, 296.99, 22.67, 294.67, 19.51, 286.03, 18.24]], "area": 136.48975000000027, "iscrowd": 0, "image_id": 12120, "bbox": [285.19, 7.08, 12.43, 15.59], "category_id": 62, "id": 2192396}, {"segmentation": [[307.94, 262.82, 301.47, 296.08, 295.93, 302.55, 301.47, 366.3, 306.09, 376.46, 317.18, 422.65, 305.17, 459.61, 300.55, 473.46, 317.18, 501.18, 295.93, 500.26, 270.98, 491.02, 279.3, 469.77, 291.31, 430.97, 271.91, 385.7, 250.66, 421.73, 240.5, 449.44, 233.1, 464.23, 222.94, 481.78, 230.33, 515.96, 210.93, 518.73, 199.85, 505.8, 205.39, 482.7, 207.24, 456.83, 228.49, 407.87, 227.56, 378.31, 237.72, 327.31, 234.03, 289.43, 219.25, 303.29, 198.92, 301.44, 199.85, 289.43, 219.25, 259.86, 232.18, 237.69, 242.34, 236.95, 244.19, 241.57, 245.11, 252.66, 254.35, 250.81, 247.89, 228.64, 253.43, 213.86, 271.91, 204.62, 284.84, 204.62, 295.93, 212.01, 303.32, 224.02, 316.25, 226.79, 309.78, 235.1, 298.7, 250.81, 299.62, 260.05]], "area": 19730.2787, "iscrowd": 0, "image_id": 12639, "bbox": [198.92, 204.62, 118.26, 314.11], "category_id": 1, "id": 2204643}, {"segmentation": [[421.65, 427.54, 416.65, 411.05, 408.65, 402.55, 404.15, 396.55, 397.65, 395.55, 393.65, 394.05, 389.15, 394.55, 383.16, 401.05, 377.16, 409.05, 372.16, 413.55, 364.66, 424.55, 360.66, 426.04, 361.66, 416.55, 369.16, 406.05, 373.66, 404.55, 384.16, 391.05, 392.65, 389.05, 399.15, 388.55, 407.15, 391.05, 411.65, 396.55, 419.15, 405.05, 426.65, 424.05, 427.65, 427.04]], "area": 577.4524999999998, "iscrowd": 0, "image_id": 12670, "bbox": [360.66, 388.55, 66.99, 38.99], "category_id": 31, "id": 2210874}, {"segmentation": [[503.98, 256.15, 499.08, 254.81, 493.95, 251.92, 495.07, 242.79, 488.39, 240.34, 485.27, 241.67, 484.16, 247.69, 469.68, 239.22, 469.9, 188.0, 478.36, 187.33, 501.75, 192.9, 504.42, 196.02]], "area": 1935.829100000001, "iscrowd": 0, "image_id": 14038, "bbox": [469.68, 187.33, 34.74, 68.82], "category_id": 72, "id": 33179}, {"segmentation": [[354.85, 298.42, 356.67, 283.83, 341.16, 266.49, 340.25, 248.25, 353.94, 230.92, 357.58, 219.06, 355.76, 209.94, 362.15, 197.17, 362.15, 185.31, 364.88, 177.1, 368.53, 174.36, 375.83, 157.94, 377.65, 153.38, 386.78, 166.15, 389.51, 178.92, 402.28, 182.57, 411.4, 178.01, 414.14, 183.48, 409.58, 192.61, 415.97, 206.29, 414.14, 217.24, 407.76, 223.62, 405.93, 229.09, 413.23, 243.69, 416.88, 251.9, 415.05, 259.2, 414.14, 264.67, 403.19, 259.2, 394.07, 274.7, 358.5, 296.6]], "area": 6369.582550000001, "iscrowd": 0, "image_id": 14007, "bbox": [340.25, 153.38, 76.63, 145.04], "category_id": 17, "id": 48706}, {"segmentation": [[76.85, 128.56, 76.03, 122.19, 79.93, 117.87, 80.55, 105.54, 80.55, 103.28, 84.24, 103.69, 87.74, 104.31, 88.15, 117.67, 90.0, 121.57, 91.85, 123.83, 91.02, 126.5]], "area": 236.76289999999995, "iscrowd": 0, "image_id": 14038, "bbox": [76.03, 103.28, 15.82, 25.28], "category_id": 44, "id": 82834}, {"segmentation": [[46.39, 121.53, 50.05, 118.22, 50.22, 115.09, 48.48, 114.22, 48.48, 112.66, 49.18, 111.79, 48.66, 106.22, 52.83, 106.22, 53.01, 113.0, 53.7, 114.57, 53.01, 118.22, 53.01, 118.92, 56.49, 121.35, 56.83, 123.44, 55.79, 124.49, 47.09, 123.09, 46.74, 122.22, 47.44, 121.01]], "area": 89.52940000000002, "iscrowd": 0, "image_id": 14038, "bbox": [46.39, 106.22, 10.44, 18.27], "category_id": 44, "id": 90888}, {"segmentation": [[2.06, 147.61, 5.16, 143.48, 34.06, 144.52, 45.42, 169.29, 2.06, 227.1], [179.61, 161.03, 260.13, 171.35, 269.42, 200.26, 258.06, 217.81, 270.45, 237.42, 271.48, 241.55, 248.77, 267.35, 222.97, 288.0, 192.0, 207.48, 179.61, 174.45], [358.19, 176.52, 438.71, 164.13, 547.1, 171.35, 473.81, 209.55, 434.58, 244.65, 419.1, 317.94, 410.84, 315.87, 369.55, 260.13, 349.94, 263.23, 353.03, 250.84]], "area": 22449.340150000004, "iscrowd": 0, "image_id": 15335, "bbox": [2.06, 143.48, 545.04, 174.46], "category_id": 63, "id": 98619}, {"segmentation": [[537.0, 421.1, 525.0, 412.1, 528.0, 422.1, 505.0, 420.1, 512.0, 373.1, 500.0, 368.1, 503.0, 357.1, 531.0, 353.1, 537.0, 319.1, 560.0, 307.1, 581.0, 303.1, 602.0, 311.1, 614.0, 324.1, 617.0, 336.1, 620.0, 346.1, 630.0, 346.1, 639.0, 343.1, 640.0, 420.1, 536.0, 420.1]], "area": 12500.5, "iscrowd": 0, "image_id": 14038, "bbox": [500.0, 303.1, 140.0, 119.0], "category_id": 67, "id": 118573}, {"segmentation": [[126.79, 268.3, 134.72, 98.49, 417.74, 84.91, 527.55, 81.51, 542.26, 101.89, 553.58, 263.77, 569.43, 326.04, 566.04, 374.72, 568.3, 443.77, 559.25, 469.81, 463.02, 472.08, 281.89, 469.81, 117.74, 460.75, 117.74, 410.94, 97.36, 340.75, 120.0, 279.62, 129.06, 267.17]], "area": 165524.46034999998, "iscrowd": 0, "image_id": 17714, "bbox": [97.36, 81.51, 472.07, 390.57], "category_id": 67, "id": 123020}, {"segmentation": [[305.09, 246.31, 303.03, 187.4, 315.36, 187.4, 329.06, 193.57, 340.02, 203.84, 344.13, 213.43, 348.24, 224.39, 356.45, 244.94, 356.45, 245.62, 344.81, 246.31, 344.81, 257.95, 344.81, 259.32, 337.28, 260.0, 332.48, 255.21, 331.11, 250.42, 324.26, 250.42, 306.46, 247.68]], "area": 2552.801500000002, "iscrowd": 0, "image_id": 14038, "bbox": [303.03, 187.4, 53.42, 72.6], "category_id": 65, "id": 319540}, {"segmentation": [[580.91, 423.42, 588.35, 407.59, 590.5, 406.87, 592.06, 406.87, 612.09, 412.03, 610.66, 417.9, 605.62, 427.0, 592.06, 426.78, 580.67, 426.42, 580.91, 423.3]], "area": 465.28155, "iscrowd": 0, "image_id": 14038, "bbox": [580.67, 406.87, 31.42, 20.13], "category_id": 77, "id": 321540}, {"segmentation": [[352.29, 304.66, 427.91, 255.84, 541.83, 297.96, 586.83, 416.67, 306.34, 422.41, 300.59, 333.38]], "area": 34540.20885000002, "iscrowd": 0, "image_id": 14007, "bbox": [300.59, 255.84, 286.24, 166.57], "category_id": 82, "id": 330699}, {"segmentation": [[18.27, 153.39, 59.63, 153.39, 67.32, 172.63, 75.01, 179.36, 91.36, 180.32, 105.79, 179.36, 114.44, 176.47, 122.14, 172.63, 126.95, 171.67, 129.83, 231.29, 148.1, 414.02, 136.56, 419.79, 72.13, 421.71, 57.7, 416.9, 43.28, 357.28, 41.35, 345.74, 33.66, 290.92, 25.97, 293.8]], "area": 25975.8725, "iscrowd": 0, "image_id": 14038, "bbox": [18.27, 153.39, 129.83, 268.32], "category_id": 82, "id": 331203}, {"segmentation": [[5.62, 336.43, 53.06, 332.73, 59.74, 333.47, 67.89, 340.14, 81.97, 356.45, 85.68, 373.5, 94.58, 388.32, 84.2, 390.55, 79.75, 376.46, 1.91, 387.58, 0.96, 376.9]], "area": 3695.744649999997, "iscrowd": 0, "image_id": 11813, "bbox": [0.96, 332.73, 93.62, 57.82], "category_id": 62, "id": 384799}, {"segmentation": [[123.89, 420.29, 209.66, 249.7, 257.32, 171.55, 284.0, 127.71, 352.62, 121.99, 513.68, 385.98, 536.55, 426.0, 123.89, 424.53]], "area": 73967.79544999999, "iscrowd": 0, "image_id": 18380, "bbox": [123.89, 121.99, 412.66, 304.01], "category_id": 67, "id": 393944}, {"segmentation": [[228.43, 140.41, 202.88, 135.07, 199.45, 149.18, 212.79, 158.71, 226.14, 164.43, 228.43, 177.4, 236.06, 189.22, 246.35, 196.08, 259.7, 201.8, 273.05, 202.19, 287.54, 199.52, 300.13, 189.6, 308.9, 173.2, 308.9, 158.71, 305.46, 143.84, 296.69, 130.87, 287.92, 124.01, 278.01, 119.43, 268.09, 118.29, 257.79, 118.29, 247.5, 120.19, 238.34, 127.06, 230.72, 133.54]], "area": 6167.2139, "iscrowd": 0, "image_id": 17714, "bbox": [199.45, 118.29, 109.45, 83.9], "category_id": 47, "id": 682310}, {"segmentation": [[512.12, 444.55, 512.12, 442.12, 496.35, 433.23, 477.07, 420.55, 476.66, 419.2, 482.19, 422.17, 497.43, 430.26, 514.68, 439.56, 515.22, 438.89, 514.41, 437.27, 502.14, 430.26, 479.76, 416.37, 479.09, 415.43, 480.84, 414.89, 509.56, 431.47, 516.17, 435.25, 517.25, 434.84, 516.98, 433.36, 513.34, 430.8, 503.76, 425.41, 494.19, 419.47, 487.45, 415.02, 484.62, 413.27, 484.75, 412.06, 490.82, 414.08, 504.57, 422.17, 515.63, 428.78, 519.4, 430.53, 520.35, 429.72, 519.4, 427.97, 516.44, 426.62, 493.78, 412.87, 491.22, 410.44, 481.25, 403.16, 471.94, 396.42, 465.2, 396.15, 461.16, 397.63, 459.54, 397.36, 443.49, 384.42, 438.37, 381.32, 425.02, 370.53, 413.96, 362.44, 404.53, 354.08, 387.54, 342.48, 368.8, 330.35, 367.99, 331.02, 368.39, 336.15, 374.86, 347.34, 392.39, 360.55, 407.76, 370.12, 432.98, 383.74, 441.87, 389.27, 449.69, 395.34, 455.9, 405.85, 458.86, 412.87, 465.47, 418.39, 477.34, 425.14, 488.39, 432.28, 501.07, 438.75]], "area": 1927.435099999998, "iscrowd": 0, "image_id": 17714, "bbox": [367.99, 330.35, 152.36, 114.2], "category_id": 48, "id": 688294}, {"segmentation": [[321.78, 434.97, 305.26, 429.62, 293.25, 424.63, 294.44, 422.25, 321.78, 431.41, 321.78, 428.91, 293.73, 419.52, 294.56, 418.09, 321.9, 424.39, 321.66, 421.54, 296.34, 414.53, 295.75, 413.34, 323.92, 419.4, 323.44, 416.67, 297.29, 410.01, 298.01, 408.23, 332.6, 415.36, 363.15, 423.09, 416.4, 431.65, 466.93, 434.14, 479.05, 435.21, 483.33, 439.85, 482.14, 448.29, 479.29, 451.62, 472.99, 452.33, 430.19, 440.2, 393.82, 433.55, 365.29, 431.53, 333.79, 435.09]], "area": 2086.9935500000015, "iscrowd": 0, "image_id": 17714, "bbox": [293.25, 408.23, 190.08, 44.1], "category_id": 48, "id": 689203}, {"segmentation": [[430.87, 383.76, 438.47, 378.36, 443.98, 376.38, 458.51, 362.95, 466.99, 354.03, 471.83, 349.52, 475.14, 354.47, 468.75, 362.18, 456.97, 371.32, 449.81, 377.92, 446.73, 384.2, 443.43, 390.26, 436.82, 392.9, 432.08, 391.36, 430.43, 385.85]], "area": 408.4520000000003, "iscrowd": 0, "image_id": 18380, "bbox": [430.43, 349.52, 44.71, 43.38], "category_id": 48, "id": 689218}, {"segmentation": [[203.0, 426.0, 217.16, 425.87, 216.16, 407.38, 213.66, 402.72, 204.0, 402.72, 203.67, 415.71]], "area": 294.70059999999984, "iscrowd": 0, "image_id": 18380, "bbox": [203.0, 402.72, 14.16, 23.28], "category_id": 48, "id": 691095}, {"segmentation": [[247.99, 222.45, 257.77, 228.3, 261.71, 231.43, 262.82, 235.26, 266.95, 237.78, 272.9, 235.06, 268.16, 234.96, 264.83, 232.74, 263.12, 230.02, 249.91, 219.73, 247.59, 220.13]], "area": 71.72710000000009, "iscrowd": 0, "image_id": 18380, "bbox": [247.59, 219.73, 25.31, 18.05], "category_id": 48, "id": 691625}, {"segmentation": [[486.38, 429.54, 479.9, 436.02, 399.54, 410.96, 374.92, 405.35, 302.34, 384.18, 301.04, 379.43, 302.34, 375.54, 317.46, 372.51, 339.92, 373.81, 355.48, 377.7, 373.19, 388.07, 387.88, 394.11, 411.64, 402.76, 419.42, 406.21, 433.67, 413.99, 448.8, 420.47, 462.62, 423.06, 472.56, 424.36, 478.17, 425.65]], "area": 2427.6952500000007, "iscrowd": 0, "image_id": 17714, "bbox": [301.04, 372.51, 185.34, 63.51], "category_id": 49, "id": 695922}, {"segmentation": [[171.86, 354.01, 198.79, 353.04, 211.65, 352.55, 215.29, 353.53, 244.17, 354.5, 243.44, 349.4, 237.62, 348.91, 233.98, 349.16, 224.51, 349.64, 213.11, 349.64, 199.03, 349.4, 181.32, 349.4, 176.22, 348.67, 172.34, 348.67, 170.16, 349.64, 169.67, 352.55, 170.16, 353.77, 172.1, 353.28]], "area": 310.9677000000006, "iscrowd": 0, "image_id": 18380, "bbox": [169.67, 348.67, 74.5, 5.83], "category_id": 49, "id": 697699}, {"segmentation": [[494.25, 357.47, 499.17, 360.47, 497.46, 362.18, 473.9, 380.18, 471.11, 382.32, 470.04, 383.82, 468.97, 386.18, 449.69, 403.53, 445.41, 396.46, 463.61, 381.68, 468.97, 378.04, 484.18, 366.04, 493.17, 357.9]], "area": 390.7774499999987, "iscrowd": 0, "image_id": 18380, "bbox": [445.41, 357.47, 53.76, 46.06], "category_id": 49, "id": 700005}, {"segmentation": [[424.98, 354.74, 424.74, 358.47, 432.43, 363.82, 442.2, 364.05, 447.56, 358.47, 451.51, 355.67, 467.58, 354.51, 471.07, 349.85, 475.03, 352.41, 481.78, 350.55, 478.98, 346.59, 449.65, 352.65, 445.23, 354.98, 440.11, 356.84, 429.87, 354.28, 427.07, 353.35, 424.51, 354.98]], "area": 304.4475000000013, "iscrowd": 0, "image_id": 18380, "bbox": [424.51, 346.59, 57.27, 17.46], "category_id": 50, "id": 703294}, {"segmentation": [[250.25, 219.66, 261.04, 228.63, 264.42, 231.1, 271.06, 234.61, 271.06, 237.08, 267.42, 237.73, 263.51, 237.21, 262.34, 236.17, 262.47, 234.09, 261.3, 231.36, 249.34, 222.52, 247.78, 221.22, 247.78, 220.05, 248.17, 219.4]], "area": 87.68955000000028, "iscrowd": 0, "image_id": 18380, "bbox": [247.78, 219.4, 23.28, 18.33], "category_id": 50, "id": 703843}, {"segmentation": [[394.77, 359.01, 409.94, 373.09, 414.82, 383.92, 416.08, 389.52, 412.11, 402.16, 402.36, 416.43, 394.59, 424.19, 387.19, 426.0, 359.38, 426.0, 352.7, 426.0, 348.91, 423.83, 341.51, 419.32, 333.38, 411.19, 340.06, 407.94, 339.7, 405.23, 334.11, 401.8, 325.62, 401.98, 320.56, 392.59, 318.76, 385.73, 318.76, 373.81, 327.6, 361.72, 335.37, 355.4, 339.52, 350.7, 346.93, 348.53, 354.15, 347.27, 359.02, 348.9, 368.23, 350.88, 384.84, 354.31]], "area": 5753.44605, "iscrowd": 0, "image_id": 18380, "bbox": [318.76, 347.27, 97.32, 78.73], "category_id": 51, "id": 717021}, {"segmentation": [[257.89, 258.94, 291.32, 242.71, 332.39, 260.85, 334.3, 278.05, 307.56, 290.46, 300.87, 296.19, 277.0, 289.51, 263.62, 275.18]], "area": 2621.348499999999, "iscrowd": 0, "image_id": 18380, "bbox": [257.89, 242.71, 76.41, 53.48], "category_id": 51, "id": 717977}, {"segmentation": [[328.64, 157.5, 324.69, 156.78, 318.35, 156.18, 305.43, 156.18, 297.77, 158.45, 295.14, 160.97, 294.78, 164.08, 298.49, 165.99, 306.62, 170.66, 308.54, 174.85, 317.63, 175.44, 316.92, 171.73, 318.23, 169.94, 320.74, 170.9, 322.78, 172.21, 326.73, 171.85, 330.8, 174.25, 333.67, 177.96, 341.09, 174.85, 343.24, 169.46, 343.36, 165.39, 341.45, 161.32, 339.53, 163.0, 337.02, 164.91]], "area": 671.2061499999999, "iscrowd": 0, "image_id": 18380, "bbox": [294.78, 156.18, 48.58, 21.78], "category_id": 51, "id": 1039990}, {"segmentation": [[443.57, 425.41, 452.69, 415.03, 468.46, 406.32, 485.88, 406.74, 501.64, 412.96, 518.65, 421.26, 523.21, 426.0, 497.49, 426.0, 466.38, 426.0, 450.2, 426.0]], "area": 1048.1505000000006, "iscrowd": 0, "image_id": 18380, "bbox": [443.57, 406.32, 79.64, 19.68], "category_id": 51, "id": 1041015}, {"segmentation": [[311.6, 192.53, 313.1, 208.38, 315.89, 214.8, 329.81, 216.52, 350.59, 215.23, 351.66, 214.37, 352.52, 208.16, 353.16, 204.95, 349.73, 195.74, 347.59, 191.88, 346.52, 190.81, 331.31, 192.1, 319.32, 191.88, 315.03, 192.31]], "area": 917.8527000000001, "iscrowd": 0, "image_id": 18380, "bbox": [311.6, 190.81, 41.56, 25.71], "category_id": 51, "id": 1041025}, {"segmentation": [[304.2, 226.07, 309.14, 233.13, 321.85, 239.83, 344.07, 238.77, 356.07, 234.89, 359.6, 228.19, 354.66, 221.84, 349.72, 218.66, 342.66, 219.02, 338.43, 216.19, 331.73, 218.66, 327.84, 218.31, 323.26, 215.84, 321.49, 216.55, 319.02, 218.31, 316.2, 219.37, 312.67, 219.72, 306.32, 223.25, 305.97, 224.31]], "area": 955.3017500000005, "iscrowd": 0, "image_id": 18380, "bbox": [304.2, 215.84, 55.4, 23.99], "category_id": 51, "id": 1041183}, {"segmentation": [[235.15, 353.47, 250.25, 359.94, 266.43, 362.1, 292.31, 363.18, 306.34, 364.25, 325.75, 364.25, 334.38, 341.6, 325.75, 321.11, 313.89, 297.38, 305.26, 279.04, 293.39, 270.41, 280.45, 260.7, 262.11, 252.07, 242.7, 248.84, 218.97, 246.68, 187.69, 248.84, 162.88, 259.63, 148.85, 287.67, 143.46, 307.09, 140.22, 331.9, 134.83, 347.0, 132.67, 363.18, 132.67, 379.36, 145.62, 394.46, 155.33, 407.4, 163.96, 422.5, 177.98, 439.76, 196.31, 448.39, 217.89, 454.86, 242.7, 459.18, 264.27, 458.1, 277.21, 446.23, 283.69, 434.37, 270.74, 425.74, 262.11, 413.87, 252.4, 400.93, 249.17, 386.91, 241.62, 378.28, 238.38, 370.73, 238.38, 370.73]], "area": 28204.1199, "iscrowd": 0, "image_id": 17714, "bbox": [132.67, 246.68, 201.71, 212.5], "category_id": 59, "id": 1072602}, {"segmentation": [[5.41, 457.57, 37.61, 453.55, 41.06, 451.82, 79.01, 390.3, 168.71, 386.85, 137.09, 451.82, 131.91, 457.0, 120.99, 458.72, 40.48, 463.9, 34.73, 462.75, 3.11, 466.2, 0.23, 467.35, 0.23, 459.3]], "area": 7008.352999999999, "iscrowd": 0, "image_id": 11813, "bbox": [0.23, 386.85, 168.48, 80.5], "category_id": 73, "id": 1102694}, {"segmentation": [[508.26, 275.22, 517.13, 283.15, 543.03, 284.09, 543.96, 281.75, 544.2, 280.59, 544.2, 277.55, 522.73, 277.55, 515.5, 270.55, 508.5, 270.55, 507.8, 274.05, 508.96, 275.45]], "area": 253.86084999999926, "iscrowd": 0, "image_id": 14038, "bbox": [507.8, 270.55, 36.4, 13.54], "category_id": 84, "id": 1138773}, {"segmentation": [[503.52, 292.57, 513.61, 303.52, 544.74, 303.09, 544.95, 304.81, 513.82, 306.52, 504.8, 297.29, 501.8, 293.86, 502.66, 291.71]], "area": 109.23585000000037, "iscrowd": 0, "image_id": 14038, "bbox": [501.8, 291.71, 43.15, 14.81], "category_id": 84, "id": 1138926}, {"segmentation": [[514.79, 300.39, 543.21, 300.26, 544.12, 300.13, 544.12, 295.83, 514.4, 295.31, 502.67, 285.8, 502.28, 289.97, 514.27, 300.0]], "area": 196.55980000000022, "iscrowd": 0, "image_id": 14038, "bbox": [502.28, 285.8, 41.84, 14.59], "category_id": 84, "id": 1141001}, {"segmentation": [[518.83, 239.89, 522.05, 242.74, 543.47, 242.55, 543.47, 246.15, 522.24, 245.96, 519.21, 243.11]], "area": 81.96849999999985, "iscrowd": 0, "image_id": 14038, "bbox": [518.83, 239.89, 24.64, 6.26], "category_id": 84, "id": 1142874}, {"segmentation": [[510.08, 200.93, 520.81, 204.93, 549.9, 205.48, 550.08, 211.11, 520.27, 209.11, 507.54, 205.3, 509.18, 201.3, 509.18, 201.3]], "area": 202.3378000000003, "iscrowd": 0, "image_id": 14038, "bbox": [507.54, 200.93, 42.54, 10.18], "category_id": 84, "id": 1148460}, {"segmentation": [[514.09, 291.36, 504.46, 282.76, 505.23, 275.28, 508.24, 274.93, 516.84, 283.02, 539.46, 284.22, 539.2, 290.24, 539.28, 291.27]], "area": 296.45120000000037, "iscrowd": 0, "image_id": 14038, "bbox": [504.46, 274.93, 35.0, 16.43], "category_id": 84, "id": 1148880}, {"segmentation": [[620.99, 19.37, 605.92, 32.29, 590.85, 51.66, 583.32, 78.57, 566.1, 153.9, 555.34, 171.12, 534.89, 189.42, 470.31, 223.86, 444.48, 272.29, 434.8, 311.03, 419.73, 347.62, 398.21, 389.6, 390.67, 424.04, 374.53, 461.7, 373.45, 462.78, 365.92, 473.54, 416.5, 472.47, 438.03, 463.86, 447.71, 441.26, 450.94, 415.43, 457.4, 393.9, 469.24, 369.15, 481.08, 343.32, 495.07, 330.4, 509.06, 335.78, 516.59, 360.54, 513.36, 393.9, 524.13, 416.5, 570.4, 432.65, 602.69, 421.88, 627.44, 421.88, 640.0, 419.73, 640.0, 407.89, 639.28, 15.07, 622.06, 23.68]], "area": 56257.02764999998, "iscrowd": 0, "image_id": 15335, "bbox": [365.92, 15.07, 274.08, 458.47], "category_id": 1, "id": 1216332}, {"segmentation": [[296.02, 114.23, 302.88, 95.69, 317.98, 88.83, 317.98, 73.04, 322.1, 64.12, 333.08, 70.99, 335.83, 86.09, 346.81, 91.58, 359.16, 114.23, 357.1, 123.84, 343.38, 123.15, 326.9, 130.01, 317.29, 129.33, 314.55, 121.09, 296.02, 118.34]], "area": 2233.3998, "iscrowd": 0, "image_id": 18380, "bbox": [296.02, 64.12, 63.14, 65.89], "category_id": 1, "id": 1225902}, {"segmentation": [[256.72, 454.11, 208.18, 399.1, 193.08, 384.0, 180.13, 362.43, 173.66, 346.25, 192.0, 311.73, 220.04, 279.37, 229.75, 269.66, 248.09, 264.27, 265.35, 259.96, 277.21, 252.4, 259.96, 215.73, 267.51, 181.21, 278.29, 148.85, 300.94, 139.15, 327.91, 145.62, 347.33, 157.48, 354.88, 170.43, 361.35, 187.69, 355.96, 223.28, 347.33, 254.56, 354.88, 267.51, 367.82, 275.06, 376.45, 279.37, 379.69, 305.26, 378.61, 334.38, 381.84, 376.45, 375.37, 407.73, 371.06, 434.7, 367.82, 462.74, 365.66, 472.45, 255.64, 474.61]], "area": 44578.0246, "iscrowd": 0, "image_id": 15335, "bbox": [173.66, 139.15, 208.18, 335.46], "category_id": 1, "id": 1230490}, {"segmentation": [[263.38, 78.51, 266.11, 64.86, 275.67, 55.3, 279.76, 46.43, 296.14, 47.11, 307.74, 58.03, 307.74, 73.05, 305.01, 71.68, 307.74, 77.83, 313.2, 82.6, 314.57, 88.06, 313.88, 97.62, 311.84, 105.81, 311.15, 112.63, 318.66, 109.9, 327.53, 120.14, 334.36, 134.47, 337.09, 148.12, 322.76, 140.61, 312.52, 138.56, 300.24, 138.56, 276.35, 150.85, 273.62, 153.58, 237.45, 151.53, 240.86, 126.96, 247.69, 116.72, 261.34, 108.54, 259.29, 98.3, 259.97, 88.74, 263.38, 79.87]], "area": 5927.082549999999, "iscrowd": 0, "image_id": 15335, "bbox": [237.45, 46.43, 99.64, 107.15], "category_id": 1, "id": 1248228}, {"segmentation": [[5.74, 228.5, 11.49, 192.13, 29.68, 171.06, 62.22, 168.19, 97.64, 186.38, 108.18, 214.14, 100.52, 247.65, 76.58, 275.41, 82.33, 285.94, 100.52, 340.51, 112.96, 384.54, 129.24, 412.31, 121.58, 418.05, 84.24, 419.01, 0.96, 419.96, 0.96, 264.88]], "area": 23863.4946, "iscrowd": 0, "image_id": 18380, "bbox": [0.96, 168.19, 128.28, 251.77], "category_id": 1, "id": 1255873}, {"segmentation": [[69.22, 275.06, 67.47, 276.81, 81.45, 283.22, 88.44, 296.03, 105.92, 365.93, 128.63, 409.61, 144.94, 386.9, 156.59, 368.26, 157.17, 362.43, 172.9, 332.73, 169.99, 323.99, 175.81, 313.5, 175.81, 301.86, 172.32, 289.04, 176.4, 278.56, 176.4, 272.15, 171.15, 256.42, 173.48, 252.93, 173.48, 248.85, 175.81, 241.28, 173.48, 227.3, 160.67, 205.75, 161.25, 193.03, 156.59, 187.2, 156.59, 177.88, 148.44, 162.74, 137.37, 156.91, 130.96, 151.67, 121.06, 152.84, 98.34, 165.65, 92.52, 178.47, 98.34, 184.29, 104.17, 195.94, 107.66, 202.93, 108.25, 212.25, 104.75, 222.74, 103.0, 233.22, 94.27, 247.78, 91.94, 251.28, 83.2, 261.18, 77.96, 272.25, 73.3, 273.41]], "area": 16176.037199999995, "iscrowd": 0, "image_id": 18380, "bbox": [67.47, 151.67, 108.93, 257.94], "category_id": 1, "id": 1258473}, {"segmentation": [[209.73, 407.03, 174.05, 348.65, 188.11, 321.62, 206.49, 301.08, 211.89, 281.62, 214.05, 238.38, 206.49, 214.59, 185.95, 198.38, 171.89, 176.76, 160.0, 133.51, 149.19, 95.68, 131.89, 78.38, 104.86, 71.89, 82.16, 71.89, 78.92, 71.89, 56.22, 83.78, 44.32, 102.16, 36.76, 129.19, 36.76, 134.59, 42.16, 163.78, 44.32, 177.84, 22.7, 192.97, 2.16, 204.86, 1.08, 448.11, 23.78, 434.05, 36.76, 429.73, 41.08, 411.35, 44.32, 391.89, 44.32, 390.81, 43.24, 385.41, 68.11, 374.59, 87.57, 370.27, 120.0, 369.19, 137.3, 377.84, 149.19, 389.73, 184.86, 405.95]], "area": 53323.984500000006, "iscrowd": 0, "image_id": 15335, "bbox": [1.08, 71.89, 212.97, 376.22], "category_id": 1, "id": 1277736}, {"segmentation": [[487.27, 340.8, 512.16, 341.76, 539.92, 301.55, 527.47, 278.58, 542.79, 253.69, 545.66, 219.22, 554.28, 209.65, 544.71, 179.97, 554.28, 151.25, 585.87, 133.07, 612.67, 133.07, 624.16, 156.04, 633.73, 201.03, 640.0, 223.05, 640.0, 414.51, 639.48, 421.21, 640.0, 426.0, 552.36, 426.0, 538.96, 426.0, 519.82, 399.2, 488.22, 342.71]], "area": 30090.851249999996, "iscrowd": 0, "image_id": 18380, "bbox": [487.27, 133.07, 152.73, 292.93], "category_id": 1, "id": 1279796}, {"segmentation": [[512.23, 83.52, 515.21, 70.95, 516.28, 50.72, 515.43, 35.38, 525.22, 37.51, 533.11, 39.85, 545.25, 45.39, 554.83, 65.84, 558.24, 95.87, 549.93, 113.12, 543.54, 127.82, 540.56, 163.6, 528.42, 163.81, 515.64, 164.66, 512.87, 164.02, 509.89, 156.57, 508.83, 147.41, 511.81, 112.69]], "area": 4577.374699999999, "iscrowd": 0, "image_id": 15335, "bbox": [508.83, 35.38, 49.41, 129.28], "category_id": 1, "id": 1282318}, {"segmentation": [[458.81, 199.8, 463.28, 187.12, 500.58, 184.88, 509.53, 202.79, 514.0, 235.6, 515.5, 250.52, 534.14, 283.34, 532.65, 312.43, 512.51, 343.76, 486.41, 341.52, 463.28, 308.7, 455.82, 293.78, 454.33, 276.63, 461.05, 250.52, 457.32, 220.69, 459.55, 202.79]], "area": 9113.590549999997, "iscrowd": 0, "image_id": 18380, "bbox": [454.33, 184.88, 79.81, 158.88], "category_id": 1, "id": 1282440}, {"segmentation": [[395.53, 197.82, 396.79, 186.48, 395.53, 170.1, 398.68, 153.71, 402.46, 139.22, 424.52, 137.33, 429.56, 144.89, 427.67, 163.8, 427.04, 171.36, 439.01, 177.66, 447.83, 195.3, 456.66, 213.58, 454.77, 233.11, 449.72, 247.61, 442.79, 250.76, 437.12, 250.76, 436.49, 247.61, 436.49, 247.61, 433.97, 250.76, 425.78, 232.48, 414.44, 217.36, 404.98, 205.39, 398.05, 197.82]], "area": 4010.0322, "iscrowd": 0, "image_id": 18380, "bbox": [395.53, 137.33, 61.13, 113.43], "category_id": 1, "id": 1299617}, {"segmentation": [[236.84, 211.36, 228.5, 175.52, 223.09, 171.77, 226.84, 158.86, 224.34, 146.36, 221.42, 137.6, 213.5, 133.85, 198.5, 134.27, 188.92, 140.1, 188.92, 166.36, 190.17, 178.02, 187.67, 186.36, 191.83, 206.78, 195.17, 213.44, 192.67, 231.78, 194.75, 238.86, 217.67, 226.78, 222.25, 219.69, 227.67, 220.53, 235.17, 216.36]], "area": 3630.373600000001, "iscrowd": 0, "image_id": 18380, "bbox": [187.67, 133.85, 49.17, 105.01], "category_id": 1, "id": 1309723}, {"segmentation": [[228.46, 173.8, 224.86, 165.38, 224.86, 158.57, 224.86, 152.16, 222.86, 144.15, 221.65, 140.55, 220.45, 136.14, 223.26, 125.72, 232.87, 115.71, 238.48, 110.1, 239.28, 107.69, 237.68, 102.49, 236.88, 99.28, 236.88, 96.88, 236.88, 94.07, 238.48, 87.26, 246.09, 79.65, 254.1, 78.45, 260.51, 82.86, 263.72, 88.46, 264.92, 98.48, 264.12, 104.49, 259.71, 112.9, 259.31, 116.51, 262.12, 123.72, 257.71, 126.52, 252.5, 134.14, 252.5, 139.34, 246.49, 149.76, 243.29, 157.77, 242.49, 162.18]], "area": 2273.3313000000003, "iscrowd": 0, "image_id": 18380, "bbox": [220.45, 78.45, 44.47, 95.35], "category_id": 1, "id": 1310638}, {"segmentation": [[458.36, 187.11, 459.69, 177.1, 458.02, 173.26, 457.19, 171.59, 459.19, 167.25, 459.19, 153.11, 457.19, 144.6, 454.02, 136.59, 453.18, 128.51, 451.18, 123.0, 448.84, 118.49, 441.83, 109.98, 438.33, 104.97, 437.33, 102.85, 436.99, 98.34, 434.99, 97.18, 434.49, 95.17, 434.49, 93.34, 437.33, 88.0, 437.33, 85.83, 436.33, 84.32, 437.49, 77.53, 437.16, 73.69, 436.16, 71.85, 433.49, 69.02, 430.65, 67.18, 427.98, 66.01, 424.81, 64.84, 420.8, 63.68, 417.13, 63.84, 414.13, 64.34, 413.96, 64.34, 413.63, 64.84, 413.13, 65.51, 412.96, 66.51, 410.62, 68.35, 408.95, 70.19, 407.95, 72.02, 406.95, 74.69, 405.78, 77.03, 405.28, 79.2, 404.95, 81.7, 405.12, 84.04, 404.62, 85.87, 403.61, 88.21, 403.28, 90.38, 402.78, 92.72, 402.78, 94.22, 404.11, 99.85, 405.62, 101.68, 406.95, 104.52, 408.45, 106.69, 408.95, 109.19, 409.46, 108.53, 409.62, 109.86, 408.62, 111.53, 407.45, 112.7, 406.62, 114.03, 405.45, 115.87, 403.95, 117.54, 402.78, 119.37, 402.28, 119.71, 399.78, 120.88, 398.77, 121.38, 397.94, 122.54, 397.27, 124.21, 396.44, 127.38, 392.26, 143.86, 392.26, 151.87, 391.76, 156.88, 389.76, 161.29, 387.26, 164.29, 384.75, 167.97, 381.58, 170.47, 379.91, 172.14, 383.42, 178.81, 384.56, 180.11, 386.96, 177.71, 387.38, 177.0, 386.96, 182.65, 386.96, 185.34, 389.22, 190.71, 390.92, 193.39, 391.91, 193.82, 393.6, 192.12, 393.88, 190.0, 392.37, 183.54, 391.35, 181.77, 393.63, 174.94, 396.16, 169.62, 396.67, 163.55, 397.43, 157.23, 398.94, 151.41, 401.47, 147.61, 405.52, 140.78, 415.64, 138.0, 417.92, 133.95, 423.99, 133.45, 428.04, 140.78, 432.08, 141.54, 432.34, 144.07, 433.85, 148.12, 434.87, 151.91, 434.36, 155.96, 432.08, 158.49, 431.83, 159.76, 433.6, 162.79, 434.36, 163.3, 436.89, 164.56, 440.43, 166.08, 440.68, 167.85, 444.98, 169.62, 448.02, 171.39, 446.0, 175.44, 444.23, 180.5, 444.98, 187.33, 448.53, 196.44, 449.79, 199.47, 451.56, 196.94, 455.1, 190.11, 458.14, 186.83]], "area": 4303.59345, "iscrowd": 0, "image_id": 18380, "bbox": [379.91, 63.68, 79.78, 135.79], "category_id": 1, "id": 1317070}, {"segmentation": [[557.44, 87.5, 554.15, 65.9, 560.25, 53.69, 567.3, 44.3, 571.99, 44.3, 572.93, 34.44, 581.38, 24.58, 584.67, 23.64, 590.77, 26.46, 585.14, 44.3, 574.81, 49.94, 564.48, 71.53, 558.85, 86.56]], "area": 696.98475, "iscrowd": 0, "image_id": 15335, "bbox": [554.15, 23.64, 36.62, 63.86], "category_id": 1, "id": 1318954}, {"segmentation": [[378.48, 168.94, 383.29, 160.39, 380.08, 157.71, 377.95, 151.83, 377.95, 142.2, 380.08, 135.25, 383.29, 130.44, 383.83, 128.83, 383.83, 127.23, 374.74, 119.21, 370.46, 105.84, 372.06, 100.49, 377.41, 88.73, 379.02, 83.91, 381.69, 78.03, 388.64, 76.96, 398.27, 82.31, 401.48, 88.73, 403.62, 95.14, 407.36, 107.44, 406.29, 114.4, 396.13, 127.23, 393.99, 139.0, 392.38, 158.25, 391.32, 160.92, 384.36, 168.94]], "area": 1856.7338000000007, "iscrowd": 0, "image_id": 18380, "bbox": [370.46, 76.96, 36.9, 91.98], "category_id": 1, "id": 1321626}, {"segmentation": [[238.37, 215.39, 227.84, 175.19, 248.9, 154.13, 252.73, 135.94, 267.09, 121.58, 278.58, 139.77, 276.66, 166.57, 265.17, 197.2, 241.24, 205.82, 239.33, 214.44]], "area": 2496.4767500000003, "iscrowd": 0, "image_id": 18380, "bbox": [227.84, 121.58, 50.74, 93.81], "category_id": 1, "id": 1329602}, {"segmentation": [[226.29, 116.44, 232.12, 90.19, 233.37, 76.02, 238.37, 59.77, 254.21, 52.69, 255.87, 44.77, 260.04, 36.44, 272.12, 31.44, 276.71, 42.27, 277.12, 51.44, 273.79, 58.94, 269.21, 64.77, 265.04, 64.36, 264.21, 68.11, 264.62, 78.52, 265.46, 90.19, 275.87, 90.19, 280.87, 92.27, 277.96, 95.61, 273.37, 100.19, 267.12, 100.19, 265.46, 93.11, 260.87, 78.11, 249.62, 75.19, 245.45, 80.19, 240.04, 86.02, 237.12, 91.02, 238.37, 101.44, 238.37, 107.69, 230.45, 117.28, 227.95, 118.11]], "area": 1566.5604500000002, "iscrowd": 0, "image_id": 18380, "bbox": [226.29, 31.44, 54.58, 86.67], "category_id": 1, "id": 1330599}, {"segmentation": [[243.82, 312.61, 238.47, 304.87, 239.26, 302.49, 236.68, 297.73, 243.43, 292.17, 245.61, 295.74, 249.38, 297.53, 257.91, 308.44, 258.71, 310.83, 255.13, 312.21, 243.82, 312.41]], "area": 251.38490000000021, "iscrowd": 0, "image_id": 14038, "bbox": [236.68, 292.17, 22.03, 20.44], "category_id": 44, "id": 1491536}, {"segmentation": [[407.52, 331.59, 392.97, 327.62, 389.66, 320.34, 402.23, 316.38, 402.89, 294.55, 391.65, 278.02, 395.61, 258.84, 407.52, 257.52, 422.07, 266.78, 415.45, 292.57, 405.53, 297.2, 406.19, 317.7, 408.84, 324.97, 409.5, 331.59, 405.53, 332.25, 402.89, 332.25]], "area": 1094.0496999999996, "iscrowd": 0, "image_id": 18380, "bbox": [389.66, 257.52, 32.41, 74.73], "category_id": 46, "id": 1497149}, {"segmentation": [[238.29, 326.99, 248.75, 367.67, 256.88, 372.32, 261.53, 372.32, 265.6, 371.16, 271.41, 360.69, 274.9, 323.5, 269.09, 319.43, 259.79, 317.11, 253.98, 317.69, 236.54, 325.24]], "area": 1497.9717500000006, "iscrowd": 0, "image_id": 18380, "bbox": [236.54, 317.11, 38.36, 55.21], "category_id": 47, "id": 1511357}, {"segmentation": [[411.32, 306.52, 423.8, 304.44, 436.27, 309.01, 442.09, 313.59, 442.09, 318.99, 440.84, 323.15, 432.11, 353.5, 426.29, 354.33, 423.8, 358.49, 409.66, 355.16, 406.75, 319.41, 405.92, 312.75, 410.08, 306.93]], "area": 1473.2216499999995, "iscrowd": 0, "image_id": 18380, "bbox": [405.92, 304.44, 36.17, 54.05], "category_id": 47, "id": 1512624}, {"segmentation": [[239.65, 319.56, 236.48, 320.46, 235.12, 310.05, 235.12, 306.42, 239.2, 297.82, 251.42, 295.1, 265.01, 296.92, 269.54, 303.25, 269.54, 311.41, 268.18, 314.12, 267.73, 314.58, 264.1, 315.48, 256.86, 315.93, 251.88, 316.39, 243.27, 321.37, 241.46, 321.37]], "area": 683.4626999999999, "iscrowd": 0, "image_id": 18380, "bbox": [235.12, 295.1, 34.42, 26.27], "category_id": 47, "id": 1514444}, {"segmentation": [[364.53, 234.42, 364.53, 232.2, 367.01, 230.41, 369.57, 229.81, 373.76, 229.64, 377.51, 229.64, 382.3, 230.32, 384.52, 231.52, 386.74, 232.63, 387.34, 233.99, 386.82, 236.73, 385.8, 239.29, 384.6, 246.89, 384.18, 249.45, 379.82, 244.84, 374.61, 243.9, 370.34, 243.9, 367.09, 243.9, 365.22, 243.99]], "area": 311.31845000000044, "iscrowd": 0, "image_id": 18380, "bbox": [364.53, 229.64, 22.81, 19.81], "category_id": 47, "id": 1515310}, {"segmentation": [[307.27, 207.14, 302.05, 205.21, 296.55, 204.11, 293.8, 202.74, 292.15, 186.79, 301.5, 183.77, 309.47, 187.07, 307.82, 206.59]], "area": 311.0243500000004, "iscrowd": 0, "image_id": 18380, "bbox": [292.15, 183.77, 17.32, 23.37], "category_id": 47, "id": 1515344}, {"segmentation": [[281.14, 219.5, 284.16, 237.92, 285.26, 242.04, 293.78, 242.32, 301.48, 241.77, 303.4, 233.8, 304.23, 228.57, 304.5, 224.18, 304.5, 221.43, 303.4, 218.68, 302.03, 217.03, 300.93, 216.48, 294.06, 215.1, 287.46, 215.38]], "area": 535.11985, "iscrowd": 0, "image_id": 18380, "bbox": [281.14, 215.1, 23.36, 27.22], "category_id": 47, "id": 1515900}, {"segmentation": [[350.02, 176.91, 351.02, 195.98, 353.03, 196.98, 355.87, 195.31, 363.23, 192.47, 364.74, 176.91, 362.06, 175.24, 356.71, 173.56, 351.36, 174.4]], "area": 273.2422000000004, "iscrowd": 0, "image_id": 18380, "bbox": [350.02, 173.56, 14.72, 23.42], "category_id": 47, "id": 1515940}, {"segmentation": [[344.32, 165.63, 345.7, 174.26, 345.7, 182.54, 348.47, 184.61, 349.85, 184.04, 350.19, 176.56, 352.84, 173.68, 357.21, 172.19, 357.9, 165.63, 356.63, 164.02, 352.03, 163.56, 348.24, 163.21, 345.47, 164.36, 344.09, 165.05]], "area": 170.0991499999999, "iscrowd": 0, "image_id": 18380, "bbox": [344.09, 163.21, 13.81, 21.4], "category_id": 47, "id": 1516054}, {"segmentation": [[357.59, 247.94, 360.62, 279.35, 366.4, 282.38, 373.57, 282.66, 377.15, 281.0, 382.94, 250.42, 382.94, 250.42, 381.56, 246.56, 381.56, 246.56, 373.57, 244.08, 365.85, 243.53, 365.85, 243.53, 359.52, 246.29]], "area": 782.9148999999999, "iscrowd": 0, "image_id": 18380, "bbox": [357.59, 243.53, 25.35, 39.13], "category_id": 47, "id": 1516080}, {"segmentation": [[292.54, 184.65, 292.16, 176.14, 290.27, 169.15, 293.3, 167.45, 296.32, 166.88, 300.48, 166.5, 301.81, 166.69, 303.7, 167.82, 305.02, 168.58, 305.4, 169.53, 305.02, 171.42, 304.45, 173.5, 303.51, 183.9, 300.48, 183.33, 298.78, 184.27, 296.7, 185.22]], "area": 216.15659999999963, "iscrowd": 0, "image_id": 18380, "bbox": [290.27, 166.5, 15.13, 18.72], "category_id": 47, "id": 1516094}, {"segmentation": [[356.89, 214.32, 363.94, 211.11, 372.69, 211.33, 377.82, 212.39, 382.73, 215.6, 387.0, 217.95, 388.92, 218.8, 423.51, 215.17, 442.09, 211.97, 453.41, 205.77, 456.61, 212.18, 457.04, 216.88, 455.97, 219.87, 454.26, 223.71, 449.56, 222.43, 387.64, 225.85, 378.46, 234.17, 369.06, 238.23, 360.31, 236.95, 360.09, 234.39, 359.24, 229.26, 358.17, 223.28]], "area": 1292.5555000000002, "iscrowd": 0, "image_id": 17714, "bbox": [356.89, 205.77, 100.15, 32.46], "category_id": 50, "id": 1530842}, {"segmentation": [[21.85, 438.48, 33.38, 434.0, 52.38, 430.37, 68.82, 429.52, 83.77, 430.37, 93.59, 436.56, 98.93, 444.89, 98.93, 463.68, 89.75, 474.78, 85.48, 480.0, 0.28, 480.0, 0.92, 451.72, 19.5, 439.13]], "area": 4289.2145, "iscrowd": 0, "image_id": 15335, "bbox": [0.28, 429.52, 98.65, 50.48], "category_id": 51, "id": 1538947}, {"segmentation": [[449.51, 292.14, 456.94, 281.6, 461.28, 274.17, 472.43, 275.41, 478.94, 279.13, 475.53, 295.23, 471.19, 305.77, 464.07, 302.05, 449.51, 294.0]], "area": 580.1357999999994, "iscrowd": 0, "image_id": 17714, "bbox": [449.51, 274.17, 29.43, 31.6], "category_id": 52, "id": 1541515}, {"segmentation": [[439.76, 318.91, 434.15, 314.32, 428.54, 312.28, 424.96, 310.24, 425.47, 297.99, 426.49, 295.44, 432.11, 291.36, 437.21, 290.85, 444.86, 293.4, 447.92, 293.91, 451.5, 295.44, 452.52, 296.46, 453.03, 296.97, 451.5, 301.57, 448.43, 306.16, 446.9, 309.22, 445.37, 312.28, 444.35, 314.83, 442.31, 319.42]], "area": 532.9654999999999, "iscrowd": 0, "image_id": 17714, "bbox": [424.96, 290.85, 28.07, 28.57], "category_id": 52, "id": 1542205}, {"segmentation": [[456.77, 299.28, 452.57, 301.95, 444.56, 314.16, 443.8, 318.35, 457.53, 327.5, 465.54, 331.32, 469.73, 332.46, 473.93, 332.84, 482.32, 324.84, 486.89, 322.55, 483.84, 311.11, 475.07, 306.91, 465.54, 303.48, 457.91, 298.9, 457.91, 298.9]], "area": 903.9799999999993, "iscrowd": 0, "image_id": 17714, "bbox": [443.8, 298.9, 43.09, 33.94], "category_id": 52, "id": 1544267}, {"segmentation": [[489.5, 309.56, 500.31, 303.26, 506.62, 302.36, 511.12, 308.21, 512.02, 319.02, 508.42, 333.43, 501.21, 343.34, 485.45, 337.94, 483.2, 330.28, 487.7, 316.77, 487.7, 313.61]], "area": 838.6250500000001, "iscrowd": 0, "image_id": 17714, "bbox": [483.2, 302.36, 28.82, 40.98], "category_id": 52, "id": 1544966}, {"segmentation": [[515.49, 323.16, 512.86, 324.86, 510.6, 328.81, 507.59, 337.46, 506.09, 344.23, 507.59, 351.18, 529.78, 363.03, 532.04, 361.72, 535.43, 349.3, 534.86, 341.59, 534.11, 335.76]], "area": 779.6114999999998, "iscrowd": 0, "image_id": 17714, "bbox": [506.09, 323.16, 29.34, 39.87], "category_id": 52, "id": 1545032}, {"segmentation": [[222.67, 285.41, 210.57, 295.78, 198.04, 299.67, 188.97, 300.96, 185.08, 300.1, 179.89, 295.35, 179.46, 291.46, 180.33, 288.0, 187.67, 282.39, 195.02, 278.5, 201.06, 276.34, 209.7, 273.75, 216.62, 274.18, 225.26, 278.93, 224.39, 284.11, 222.23, 286.71]], "area": 802.5652500000001, "iscrowd": 0, "image_id": 17714, "bbox": [179.46, 273.75, 45.8, 27.21], "category_id": 52, "id": 1545967}, {"segmentation": [[153.3, 332.29, 169.1, 333.53, 184.28, 323.62, 185.21, 309.99, 179.94, 304.72, 165.38, 306.58, 150.82, 320.21, 147.42, 324.24]], "area": 743.9523000000002, "iscrowd": 0, "image_id": 17714, "bbox": [147.42, 304.72, 37.79, 28.81], "category_id": 52, "id": 1546781}, {"segmentation": [[473.52, 303.58, 476.18, 301.41, 484.63, 303.58, 488.49, 310.58, 486.32, 315.89, 485.11, 317.34, 484.14, 312.03, 482.94, 310.1, 478.83, 307.2]], "area": 85.47070000000002, "iscrowd": 0, "image_id": 17714, "bbox": [473.52, 301.41, 14.97, 15.93], "category_id": 52, "id": 1546978}, {"segmentation": [[283.26, 271.0, 286.88, 269.93, 287.74, 265.03, 285.6, 262.89, 283.9, 261.83, 281.13, 261.83, 278.14, 264.81, 278.78, 268.65, 280.06, 270.78]], "area": 68.42420000000023, "iscrowd": 0, "image_id": 18380, "bbox": [278.14, 261.83, 9.6, 9.17], "category_id": 57, "id": 1564982}, {"segmentation": [[308.9, 258.03, 308.35, 254.77, 309.8, 253.5, 312.34, 253.86, 313.25, 254.59, 313.25, 256.95, 309.99, 257.67]], "area": 16.719399999999933, "iscrowd": 0, "image_id": 18380, "bbox": [308.35, 253.5, 4.9, 4.53], "category_id": 57, "id": 1565695}, {"segmentation": [[230.37, 244.04, 203.15, 242.78, 196.82, 226.32, 182.25, 226.32, 174.02, 227.59, 170.86, 232.02, 170.23, 233.92, 169.59, 228.85, 169.59, 226.95, 168.96, 225.69, 171.49, 221.25, 168.96, 216.82, 190.48, 214.92, 198.71, 218.09, 207.58, 218.72, 215.17, 215.56, 219.61, 225.05, 233.53, 244.04]], "area": 943.4883999999998, "iscrowd": 0, "image_id": 14038, "bbox": [168.96, 214.92, 64.57, 29.12], "category_id": 63, "id": 1604128}, {"segmentation": [[554.4, 82.87, 554.4, 67.03, 550.65, 51.61, 550.24, 38.28, 534.4, 62.45, 532.73, 61.61, 530.65, 66.61, 525.23, 66.61, 522.73, 82.03, 519.4, 82.03, 511.9, 87.87, 508.15, 90.78, 498.56, 111.2, 496.48, 116.2, 506.48, 117.04, 505.64, 124.96, 515.65, 131.62, 521.06, 131.62, 520.23, 121.2, 516.48, 105.37, 516.06, 95.78, 531.07, 93.7, 527.31, 116.62, 533.98, 121.2, 536.48, 104.95, 536.9, 87.03, 548.57, 82.03, 556.07, 83.7, 556.07, 79.11]], "area": 1831.63675, "iscrowd": 0, "image_id": 14038, "bbox": [496.48, 38.28, 59.59, 93.34], "category_id": 64, "id": 1605902}, {"segmentation": [[506.41, 210.05, 515.96, 216.77, 551.32, 218.19, 551.32, 221.37, 513.48, 222.43, 498.27, 213.94]], "area": 261.4922500000004, "iscrowd": 0, "image_id": 14038, "bbox": [498.27, 210.05, 53.05, 12.38], "category_id": 84, "id": 1651488}, {"segmentation": [[516.09, 89.24, 513.69, 107.04, 513.69, 110.29, 513.97, 112.69, 515.81, 117.5, 516.52, 118.35, 523.16, 118.06, 524.85, 98.85, 524.29, 94.32, 524.57, 88.81, 520.9, 88.39, 517.36, 88.81]], "area": 279.0357499999989, "iscrowd": 0, "image_id": 18380, "bbox": [513.69, 88.39, 11.16, 29.96], "category_id": 86, "id": 1668246}, {"segmentation": [[561.65, 162.93, 548.86, 162.93, 541.45, 162.25, 544.48, 125.22, 557.95, 95.6, 563.33, 78.43, 572.42, 56.89, 579.15, 51.5, 586.22, 42.08, 591.61, 24.24, 599.35, 21.21, 608.1, 21.88, 616.52, 22.89, 589.93, 55.21, 575.45, 109.07, 573.43, 120.17]], "area": 2982.312849999994, "iscrowd": 0, "image_id": 15335, "bbox": [541.45, 21.21, 75.07, 141.72], "category_id": 1, "id": 1694331}, {"segmentation": [[400.45, 53.65, 382.13, 70.08, 379.79, 79.0, 378.38, 84.16, 376.97, 88.86, 383.07, 107.64, 385.89, 111.4, 385.89, 116.09, 385.42, 123.13, 383.07, 124.54, 373.21, 125.48, 364.29, 128.3, 356.31, 130.18, 352.09, 135.34, 348.33, 142.38, 345.51, 148.49, 343.63, 152.24, 344.57, 156.47, 350.68, 157.88, 511.25, 165.39, 506.55, 146.61, 500.45, 137.22, 493.41, 131.58, 487.77, 127.83, 479.79, 125.01, 468.99, 124.54, 458.66, 123.6, 445.99, 119.85, 440.35, 115.15, 449.27, 95.43, 449.74, 73.84, 444.11, 65.85, 438.48, 63.04, 430.96, 59.75, 422.51, 57.4, 416.41, 55.99, 411.24, 54.59]], "area": 9835.369400000001, "iscrowd": 0, "image_id": 15335, "bbox": [343.63, 53.65, 167.62, 111.74], "category_id": 1, "id": 1705756}, {"segmentation": [[168.32, 151.37, 165.88, 141.01, 161.61, 133.09, 160.39, 93.49, 176.24, 72.16, 192.08, 66.68, 218.88, 67.29, 234.11, 80.08, 237.77, 91.05, 232.29, 97.75, 233.51, 108.11, 236.55, 112.37, 234.11, 116.64, 234.11, 125.78, 234.72, 131.26, 233.51, 139.79, 231.07, 143.45, 238.38, 150.15, 174.41, 151.37]], "area": 5697.13675, "iscrowd": 0, "image_id": 15335, "bbox": [160.39, 66.68, 77.99, 84.69], "category_id": 1, "id": 1753431}, {"segmentation": [[317.22, 330.57, 313.51, 326.37, 303.36, 322.9, 293.95, 324.14, 284.79, 331.07, 285.04, 337.26, 285.78, 345.43, 285.04, 356.82, 287.27, 363.5, 290.98, 368.95, 297.42, 372.91, 298.41, 373.9, 298.16, 389.5, 299.15, 396.18, 292.47, 399.65, 286.03, 405.1, 286.28, 412.03, 289.0, 417.23, 293.21, 420.45, 298.41, 421.93, 306.33, 421.19, 309.8, 420.94, 315.0, 417.23, 316.73, 413.27, 317.97, 410.3, 313.02, 408.07, 312.27, 404.6, 312.52, 399.9, 315.99, 399.9, 315.0, 398.17, 308.06, 394.45, 304.85, 394.2, 305.59, 373.41, 311.53, 367.96, 316.23, 363.26, 320.2, 346.17, 317.72, 331.32]], "area": 2227.0983499999998, "iscrowd": 0, "image_id": 18380, "bbox": [284.79, 322.9, 35.41, 99.03], "category_id": 46, "id": 1874376}, {"segmentation": [[331.12, 147.76, 342.05, 147.35, 343.29, 150.94, 342.6, 156.06, 341.63, 159.93, 339.28, 162.98, 337.34, 165.19, 337.48, 176.12, 340.28, 179.48, 341.92, 180.13, 338.65, 180.95, 338.16, 180.3, 336.85, 179.64, 334.89, 179.32, 334.57, 179.32, 335.55, 178.01, 335.87, 174.91, 335.55, 167.88, 335.22, 164.94, 333.91, 162.66, 331.14, 157.76, 330.81, 152.53, 331.79, 147.95], [347.98, 124.27, 350.09, 124.12, 355.95, 124.12, 356.55, 127.42, 355.65, 131.93, 353.99, 135.09, 352.19, 138.1, 352.64, 148.02, 351.29, 148.17, 350.99, 137.8, 349.34, 135.09, 347.53, 131.93, 347.08, 128.03, 347.38, 124.12, 349.03, 123.97], [334.45, 122.31, 343.02, 122.16, 343.47, 127.12, 342.42, 129.53, 340.77, 133.14, 339.87, 134.79, 339.41, 140.2, 339.57, 142.0, 337.76, 142.15, 337.61, 135.69, 337.76, 133.59, 336.26, 132.54, 334.0, 128.93, 333.4, 125.32, 334.0, 123.22, 334.61, 122.31]], "area": 425.16774999999996, "iscrowd": 0, "image_id": 18380, "bbox": [330.81, 122.16, 25.74, 58.79], "category_id": 46, "id": 1875540}, {"segmentation": [[264.43, 296.4, 264.43, 279.27, 255.87, 269.9, 252.2, 257.25, 253.42, 247.87, 257.09, 243.39, 270.96, 242.98, 276.67, 244.61, 278.71, 258.07, 276.26, 269.08, 272.18, 276.01, 268.51, 278.05, 267.69, 296.4, 273.4, 297.22, 277.48, 302.52, 277.89, 307.01, 269.73, 310.68, 268.92, 304.15, 263.62, 299.67]], "area": 925.0581499999994, "iscrowd": 0, "image_id": 18380, "bbox": [252.2, 242.98, 26.51, 67.7], "category_id": 46, "id": 1875981}, {"segmentation": [[640.0, 425.34, 634.94, 424.12, 623.96, 422.9, 613.38, 424.12, 608.1, 425.74, 604.03, 430.62, 600.78, 437.54, 599.96, 480.0, 640.0, 479.83]], "area": 2162.5128, "iscrowd": 0, "image_id": 15335, "bbox": [599.96, 422.9, 40.04, 57.1], "category_id": 47, "id": 1879878}, {"segmentation": [[307.0, 156.11, 305.53, 148.27, 306.02, 145.5, 309.78, 145.17, 315.5, 145.17, 318.27, 146.31, 317.13, 148.11, 316.8, 149.74, 317.29, 154.64, 316.64, 155.95, 312.07, 155.62]], "area": 116.7201500000004, "iscrowd": 0, "image_id": 18380, "bbox": [305.53, 145.17, 12.74, 10.94], "category_id": 47, "id": 1880331}, {"segmentation": [[376.52, 253.09, 344.1, 236.88, 335.38, 216.94, 314.18, 205.71, 319.17, 193.25, 340.36, 194.49, 359.06, 179.53, 387.74, 177.04, 407.69, 195.74, 412.68, 210.7, 410.18, 234.39, 396.47, 253.09]], "area": 4901.9827, "iscrowd": 0, "image_id": 17714, "bbox": [314.18, 177.04, 98.5, 76.05], "category_id": 47, "id": 1882059}, {"segmentation": [[223.39, 253.89, 227.51, 253.89, 226.93, 256.0, 225.88, 256.86, 220.42, 256.76, 220.14, 255.14, 220.14, 253.7, 220.33, 253.22], [231.34, 254.75, 236.89, 255.81, 236.22, 256.38, 231.81, 256.67, 230.47, 255.81, 229.61, 255.33]], "area": 28.893200000000142, "iscrowd": 0, "image_id": 18380, "bbox": [220.14, 253.22, 16.75, 3.64], "category_id": 49, "id": 1891275}, {"segmentation": [[379.23, 220.44, 403.31, 224.24, 419.48, 226.14, 418.52, 228.99, 390.32, 225.19]], "area": 98.14925000000011, "iscrowd": 0, "image_id": 18380, "bbox": [379.23, 220.44, 40.25, 8.55], "category_id": 49, "id": 1891995}, {"segmentation": [[265.04, 324.06, 259.52, 330.68, 262.83, 353.85, 271.66, 363.78, 279.39, 353.85, 282.7, 329.58, 278.28, 318.54, 269.46, 318.54]], "area": 736.8537999999998, "iscrowd": 0, "image_id": 17714, "bbox": [259.52, 318.54, 23.18, 45.24], "category_id": 52, "id": 1905012}, {"segmentation": [[454.76, 134.74, 464.39, 128.47, 472.58, 129.92, 472.58, 131.36, 472.58, 150.63, 472.1, 181.45, 461.02, 186.75, 459.58, 172.78, 458.61, 170.86, 457.65, 142.92]], "area": 771.4241000000003, "iscrowd": 0, "image_id": 18380, "bbox": [454.76, 128.47, 17.82, 58.28], "category_id": 62, "id": 1937487}, {"segmentation": [[563.51, 286.83, 575.78, 287.65, 576.59, 302.37, 570.46, 302.77, 563.92, 303.18, 562.7, 286.83], [583.13, 302.37, 598.67, 308.5, 605.21, 314.22, 621.56, 315.45, 620.33, 310.95, 620.33, 309.72, 628.92, 306.86, 632.19, 312.58, 639.95, 313.4, 639.95, 299.91, 585.59, 301.96]], "area": 733.107450000001, "iscrowd": 0, "image_id": 14038, "bbox": [562.7, 286.83, 77.25, 28.62], "category_id": 62, "id": 1941759}, {"segmentation": [[26.58, 318.6, 47.35, 323.29, 46.01, 315.92, 9.16, 306.54, 2.47, 310.56, 3.81, 318.6, 21.89, 318.6]], "area": 380.79115000000024, "iscrowd": 0, "image_id": 15335, "bbox": [2.47, 306.54, 44.88, 16.75], "category_id": 77, "id": 1976132}, {"segmentation": [[505.39, 283.67, 519.38, 291.17, 542.36, 291.17, 542.86, 294.66, 514.88, 296.16, 500.9, 284.67]], "area": 191.10030000000046, "iscrowd": 0, "image_id": 14038, "bbox": [500.9, 283.67, 41.96, 12.49], "category_id": 84, "id": 1987215}, {"segmentation": [[519.51, 245.7, 539.38, 245.89, 540.34, 248.59, 521.05, 249.56, 518.93, 246.86]], "area": 66.72250000000052, "iscrowd": 0, "image_id": 14038, "bbox": [518.93, 245.7, 21.41, 3.86], "category_id": 84, "id": 1987615}, {"segmentation": [[550.35, 171.17, 549.52, 172.55, 521.79, 173.38, 508.76, 171.86, 511.26, 168.12, 524.29, 170.19]], "area": 111.2164000000003, "iscrowd": 0, "image_id": 14038, "bbox": [508.76, 168.12, 41.59, 5.26], "category_id": 84, "id": 1989043}, {"segmentation": [[506.23, 175.6, 506.52, 171.79, 522.94, 174.72, 553.71, 173.54, 553.12, 177.94, 522.35, 178.23]], "area": 182.03309999999993, "iscrowd": 0, "image_id": 14038, "bbox": [506.23, 171.79, 47.48, 6.44], "category_id": 84, "id": 1989219}, {"segmentation": [[362.44, 128.22, 364.36, 119.75, 366.28, 115.14, 370.13, 108.79, 373.98, 105.13, 377.63, 102.44, 383.4, 104.55, 385.71, 110.13, 386.67, 112.06, 386.67, 119.75, 386.48, 124.18, 383.4, 125.72, 363.21, 130.14]], "area": 453.39979999999986, "iscrowd": 0, "image_id": 15335, "bbox": [362.44, 102.44, 24.23, 27.7], "category_id": 1, "id": 2025828}, {"segmentation": [[565.97, 49.29, 559.87, 48.21, 561.3, 36.36, 559.87, 29.54, 556.28, 25.95, 553.05, 21.64, 543.71, 25.59, 540.12, 35.29, 535.82, 41.39, 543.71, 49.64, 551.97, 60.77, 554.84, 68.31, 554.84, 68.67]], "area": 701.5897999999987, "iscrowd": 0, "image_id": 15335, "bbox": [535.82, 21.64, 30.15, 47.03], "category_id": 1, "id": 2028889}, {"segmentation": [[140.16, 143.42, 146.78, 113.62, 157.82, 102.58, 174.37, 102.58, 182.1, 112.51, 186.51, 129.07, 188.72, 147.83, 194.24, 172.11, 194.24, 194.18, 189.82, 198.6, 194.24, 226.19, 199.76, 233.91, 227.35, 217.36, 233.97, 227.29, 215.21, 243.85, 197.55, 252.68, 201.96, 279.16, 186.51, 303.44, 176.58, 295.72, 175.48, 263.71, 172.17, 244.95, 176.58, 219.57, 164.44, 196.39, 153.4, 166.59, 143.47, 154.45]], "area": 6514.457450000002, "iscrowd": 0, "image_id": 18380, "bbox": [140.16, 102.58, 93.81, 200.86], "category_id": 1, "id": 2030411}, {"segmentation": [[349.82, 276.07, 354.39, 285.44, 357.2, 291.53, 358.14, 297.39, 359.54, 300.08, 363.06, 303.48, 363.88, 305.0, 359.9, 304.53, 359.66, 302.07, 358.26, 302.77, 358.02, 304.65, 356.62, 304.18, 354.98, 302.19, 356.5, 299.73, 355.68, 292.12, 352.52, 286.73, 349.47, 283.33, 346.43, 276.07, 346.9, 274.08, 349.12, 274.67]], "area": 93.23754999999967, "iscrowd": 0, "image_id": 18380, "bbox": [346.43, 274.08, 17.45, 30.92], "category_id": 50, "id": 2105467}, {"segmentation": [[283.51, 255.99, 285.93, 251.96, 289.16, 249.8, 294.0, 249.26, 296.69, 249.53, 298.57, 250.88, 295.07, 254.11, 291.58, 255.18]], "area": 61.06944999999999, "iscrowd": 0, "image_id": 18380, "bbox": [283.51, 249.26, 15.06, 6.73], "category_id": 57, "id": 2115749}, {"segmentation": [[160.48, 286.89, 234.09, 286.17, 232.29, 324.78, 162.29, 323.7, 161.93, 289.42]], "area": 2683.3680499999987, "iscrowd": 0, "image_id": 14038, "bbox": [160.48, 286.17, 73.61, 38.61], "category_id": 78, "id": 2138715}, {"segmentation": [[282.83, 365.14, 279.33, 363.98, 274.32, 360.48, 272.34, 353.96, 271.29, 339.28, 274.09, 328.56, 274.21, 327.74, 276.3, 325.29, 278.87, 323.66, 281.78, 323.31, 283.88, 322.96, 286.44, 322.73, 290.28, 322.96, 292.03, 324.13, 289.12, 325.64, 285.39, 330.07, 284.93, 333.92, 284.46, 342.89, 284.69, 353.26, 286.91, 361.3, 289.47, 363.74, 287.95, 365.96, 285.74, 366.19, 286.21, 374.93, 290.52, 374.35, 293.2, 375.51, 294.94, 377.26, 296.11, 378.89, 298.21, 382.97, 295.41, 387.16, 292.15, 389.96, 288.54, 391.94, 286.56, 392.05, 287.49, 385.53, 284.34, 381.34, 282.01, 378.07, 278.75, 376.44, 280.85, 375.51, 282.71, 374.93]], "area": 731.8126000000001, "iscrowd": 0, "image_id": 18380, "bbox": [271.29, 322.73, 26.92, 69.32], "category_id": 46, "id": 2182899}, {"segmentation": [[301.99, 185.09, 295.05, 186.32, 293.32, 187.07, 292.33, 187.56, 294.56, 200.68, 294.56, 203.66, 298.52, 204.65, 303.97, 205.39, 305.7, 205.64, 307.43, 205.64, 308.18, 191.03, 308.18, 189.54, 308.92, 186.57, 308.42, 186.32, 304.96, 185.83, 302.73, 185.58]], "area": 272.3815500000001, "iscrowd": 0, "image_id": 18380, "bbox": [292.33, 185.09, 16.59, 20.55], "category_id": 46, "id": 2183182}, {"segmentation": [[538.62, 323.51, 539.83, 321.09, 530.16, 312.46, 510.99, 310.73, 511.68, 315.57, 511.68, 317.98, 508.75, 320.4, 504.77, 323.16, 503.22, 327.14, 504.77, 328.35, 503.39, 330.76, 502.87, 332.84, 511.86, 345.1, 533.79, 345.44, 534.31, 335.94, 535.86, 327.14, 538.8, 322.99]], "area": 938.0186499999996, "iscrowd": 0, "image_id": 14038, "bbox": [502.87, 310.73, 36.96, 34.71], "category_id": 84, "id": 2197005}, {"segmentation": [[242.4, 398.12, 243.13, 386.36, 249.57, 378.08, 261.15, 374.04, 278.06, 374.04, 286.7, 381.21, 287.8, 389.85, 285.05, 399.22, 284.13, 411.36, 281.92, 426.0, 250.12, 425.88, 245.15, 402.17]], "area": 1971.7296499999998, "iscrowd": 0, "image_id": 18380, "bbox": [242.4, 374.04, 45.4, 51.96], "category_id": 47, "id": 2214844}, {"segmentation": {"counts": [5943, 2, 437, 2, 435, 4, 427, 13, 422, 18, 422, 18, 7, 4, 411, 31, 409, 33, 407, 36, 405, 35, 406, 34, 408, 32, 410, 38, 401, 40, 394, 48, 391, 51, 388, 53, 6, 1, 379, 57, 2, 3, 378, 62, 378, 62, 378, 62, 378, 62, 378, 62, 378, 62, 379, 60, 381, 14, 6, 38, 408, 16, 6, 8, 3475, 1, 434, 8, 427, 13, 427, 13, 427, 13, 427, 13, 427, 13, 427, 13, 427, 13, 427, 12, 428, 12, 429, 10, 431, 8, 434, 4, 16739, 1, 433, 8, 12, 2, 412, 3, 4, 7, 13, 4, 409, 4, 2, 13, 9, 5, 407, 25, 6, 3, 406, 28, 5, 2, 386, 48, 6, 1, 384, 50, 4, 2, 383, 57, 378, 63, 376, 64, 375, 37, 2, 26, 374, 39, 2, 24, 375, 64, 376, 62, 378, 56, 384, 56, 384, 56, 384, 56, 385, 55, 386, 19, 4, 30, 389, 4, 1, 10, 9, 26, 397, 6, 14, 21, 425, 11, 434, 1, 8330, 8, 429, 13, 425, 16, 5, 1, 417, 19, 2, 3, 415, 25, 414, 26, 414, 26, 414, 26, 414, 26, 414, 26, 414, 25, 415, 24, 417, 21, 420, 9, 433, 5, 6156, 18, 420, 21, 417, 24, 415, 26, 413, 27, 412, 28, 412, 28, 412, 28, 412, 28, 412, 28, 412, 27, 413, 26, 415, 23, 418, 23, 419, 21, 420, 20, 420, 20, 420, 20, 420, 20, 420, 20, 420, 19, 421, 18, 422, 19, 420, 21, 418, 22, 418, 22, 418, 22, 417, 23, 416, 24, 415, 25, 415, 25, 415, 25, 415, 25, 415, 25, 415, 25, 415, 23, 418, 20, 421, 17, 425, 12, 116652, 6, 433, 8, 431, 10, 429, 12, 426, 14, 425, 15, 424, 16, 421, 40, 397, 44, 395, 46, 393, 48, 377, 63, 376, 64, 374, 66, 370, 70, 360, 8, 1, 71, 359, 81, 358, 81, 358, 81, 359, 79, 360, 78, 362, 78, 362, 78, 362, 78, 362, 78, 362, 78, 362, 78, 362, 77, 364, 75, 366, 74, 368, 73, 368, 73, 369, 71, 372, 69, 371, 70, 370, 70, 370, 70, 370, 70, 370, 70, 370, 70, 370, 70, 370, 57, 1, 12, 370, 57, 1, 12, 371, 56, 1, 12, 372, 67, 374, 66, 373, 67, 373, 67, 373, 67, 373, 67, 373, 67, 373, 66, 374, 65, 375, 64, 376, 63, 377, 63, 378, 61, 379, 60, 380, 58, 382, 48, 392, 47, 393, 45, 396, 43, 397, 41, 399, 37, 404, 31, 410, 30, 412, 27, 416, 23, 418, 21, 420, 18, 423, 10, 432, 6, 378, 6, 433, 8, 431, 10, 429, 12, 423, 17, 421, 19, 420, 25, 414, 27, 412, 29, 410, 31, 409, 31, 409, 31, 409, 31, 409, 31, 409, 31, 409, 31, 409, 31, 409, 31, 410, 30, 411, 29, 411, 28, 412, 28, 412, 27, 414, 25, 416, 23, 419, 20, 429, 9, 5271, 6, 433, 8, 431, 10, 429, 12, 428, 13, 427, 14, 426, 15, 424, 17, 422, 18, 421, 19, 421, 19, 421, 19, 421, 19, 421, 19, 420, 20, 419, 21, 419, 20, 420, 19, 421, 19, 421, 18, 422, 18, 422, 18, 422, 17, 423, 16, 425, 17, 424, 17, 425, 16, 425, 16, 423, 17, 422, 18, 421, 19, 421, 19, 420, 20, 420, 20, 420, 20, 420, 20, 420, 20, 420, 20, 420, 19, 421, 18, 422, 17, 423, 15, 425, 14, 426, 13, 428, 11, 430, 9, 433, 5, 4657], "size": [440, 640]}, "area": 9419, "iscrowd": 1, "image_id": 16228, "bbox": [13, 166, 616, 127], "category_id": 1, "id": 900100016228}, {"segmentation": {"counts": [62771, 6, 397, 8, 355, 12, 28, 10, 352, 33, 1, 19, 346, 58, 344, 60, 342, 63, 340, 63, 341, 63, 338, 69, 333, 20, 2, 54, 328, 13, 11, 54, 324, 13, 15, 57, 317, 12, 21, 56, 315, 11, 24, 54, 313, 12, 26, 54, 310, 12, 28, 54, 310, 12, 27, 55, 309, 12, 55, 28, 309, 6, 1, 4, 66, 18, 309, 2, 7, 1, 71, 14, 306, 3, 83, 11, 305, 5, 83, 11, 305, 5, 84, 8, 306, 6, 83, 9, 306, 6, 58, 15, 9, 10, 306, 6, 55, 22, 4, 11, 306, 7, 51, 25, 3, 12, 306, 7, 53, 38, 306, 8, 53, 37, 307, 9, 53, 34, 308, 11, 53, 32, 310, 14, 51, 27, 316, 11, 395, 10, 1241, 2, 377, 1, 22, 5, 398, 4, 399, 4, 384, 4, 11, 4, 385, 12, 1, 3, 390, 14, 392, 10, 42792, 6, 397, 8, 395, 10, 393, 12, 392, 12, 392, 12, 392, 13, 391, 12, 392, 12, 392, 12, 393, 10, 395, 8, 398, 4, 12901, 6, 397, 8, 395, 11, 8, 13, 352, 8, 11, 15, 3, 16, 349, 37, 1, 18, 348, 57, 346, 58, 346, 58, 346, 59, 345, 58, 346, 58, 346, 58, 347, 57, 347, 58, 348, 56, 352, 26, 5, 21, 354, 13, 4, 3, 10, 20, 354, 11, 19, 9, 2, 9, 355, 9, 22, 4, 370, 7, 397, 7, 398, 7, 398, 6, 400, 4, 404, 1, 35505, 25, 377, 29, 375, 29, 374, 31, 371, 33, 371, 33, 370, 34, 370, 34, 370, 34, 370, 33, 371, 33, 371, 31, 373, 29, 376, 25, 379, 24, 382, 20, 385, 19, 387, 27, 381, 25, 378, 26, 378, 27, 377, 27, 377, 27, 377, 27, 377, 27, 378, 26, 378, 25, 381, 23, 388, 14, 21397, 6, 396, 10, 394, 10, 393, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 13, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 13, 391, 12, 392, 12, 392, 12, 392, 13, 391, 13, 391, 13, 391, 13, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 392, 12, 393, 10, 394, 10, 396, 6, 15319], "size": [404, 640]}, "area": 5646, "iscrowd": 1, "image_id": 14439, "bbox": [155, 7, 447, 170], "category_id": 1, "id": 900100014439}, {"segmentation": {"counts": [346, 6, 390, 12, 8, 9, 1, 10, 386, 42, 379, 3, 1, 45, 374, 54, 371, 57, 369, 59, 367, 60, 360, 68, 357, 70, 356, 63, 362, 61, 361, 65, 359, 67, 358, 68, 358, 60, 2, 6, 354, 65, 3, 4, 352, 67, 2, 5, 351, 69, 1, 5, 18, 1, 332, 74, 18, 3, 331, 74, 17, 5, 324, 79, 17, 5, 324, 79, 1, 1, 15, 6, 323, 79, 17, 6, 324, 76, 1, 2, 16, 6, 320, 81, 17, 7, 320, 81, 20, 4, 320, 75, 27, 1, 323, 75, 26, 2, 319, 78, 27, 1, 317, 75, 32, 2, 317, 75, 32, 1, 317, 75, 33, 1, 317, 75, 345, 79, 37, 1, 23, 2, 283, 75, 42, 4, 18, 5, 282, 75, 43, 5, 14, 8, 281, 74, 45, 6, 10, 11, 275, 78, 47, 8, 5, 14, 272, 75, 53, 27, 271, 75, 54, 27, 269, 75, 57, 26, 264, 78, 59, 25, 262, 74, 66, 26, 259, 75, 68, 25, 258, 75, 69, 26, 254, 1, 1, 74, 71, 26, 249, 78, 74, 26, 247, 75, 79, 26, 246, 75, 80, 27, 244, 74, 82, 27, 237, 79, 84, 26, 236, 75, 90, 26, 234, 75, 92, 26, 233, 75, 93, 26, 227, 79, 95, 27, 224, 74, 102, 27, 222, 75, 103, 26, 222, 75, 104, 26, 217, 78, 106, 26, 214, 77, 110, 26, 212, 75, 115, 25, 210, 75, 117, 24, 210, 75, 118, 24, 204, 78, 120, 26, 200, 75, 126, 26, 199, 75, 127, 26, 198, 75, 128, 26, 197, 73, 131, 27, 195, 68, 137, 27, 195, 67, 138, 26, 195, 66, 140, 26, 195, 64, 142, 26, 194, 58, 149, 26, 194, 57, 151, 24, 195, 56, 152, 24, 195, 54, 153, 26, 194, 51, 156, 26, 194, 46, 161, 26, 194, 45, 162, 26, 194, 43, 164, 27, 193, 41, 166, 27, 194, 33, 173, 26, 195, 32, 174, 26, 196, 30, 175, 26, 197, 27, 177, 26, 197, 20, 185, 25, 199, 17, 186, 24, 201, 15, 187, 24, 203, 11, 188, 26, 205, 5, 191, 26, 401, 26, 401, 26, 401, 27, 400, 27, 400, 26, 401, 26, 401, 26, 401, 26, 402, 24, 403, 24, 402, 26, 401, 26, 401, 26, 401, 26, 401, 27, 400, 27, 400, 26, 401, 26, 401, 26, 401, 26, 402, 25, 402, 24, 403, 24, 402, 26, 401, 26, 401, 26, 401, 26, 401, 27, 400, 27, 400, 26, 401, 26, 401, 26, 401, 26, 402, 5, 18, 1, 403, 5, 421, 7, 420, 5, 422, 3, 424, 2, 425, 2, 424, 3, 424, 4, 423, 4, 423, 5, 423, 5, 422, 7, 420, 7, 420, 8, 418, 9, 418, 9, 417, 10, 14, 2, 401, 10, 10, 7, 400, 11, 6, 10, 400, 13, 1, 13, 400, 27, 400, 27, 400, 27, 400, 26, 402, 25, 401, 26, 401, 25, 401, 26, 401, 26, 401, 26, 400, 27, 400, 27, 400, 27, 400, 27, 400, 27, 401, 26, 401, 26, 401, 25, 401, 26, 401, 25, 401, 27, 400, 28, 399, 28, 399, 28, 399, 28, 399, 28, 399, 28, 399, 28, 399, 28, 400, 26, 400, 27, 399, 28, 399, 28, 399, 28, 398, 29, 398, 29, 398, 29, 398, 29, 398, 29, 398, 28, 400, 27, 400, 26, 401, 26, 400, 28, 399, 29, 397, 31, 396, 31, 396, 31, 396, 31, 396, 31, 396, 31, 396, 31, 396, 31, 396, 31, 396, 32, 395, 33, 393, 34, 393, 34, 393, 34, 392, 35, 392, 35, 392, 35, 392, 35, 392, 35, 392, 35, 393, 34, 393, 34, 393, 34, 392, 35, 392, 35, 391, 36, 391, 36, 391, 36, 391, 36, 391, 36, 391, 36, 391, 36, 391, 36, 391, 36, 391, 36, 391, 36, 390, 37, 390, 37, 389, 38, 389, 38, 389, 38, 389, 38, 389, 38, 389, 38, 389, 38, 390, 37, 390, 36, 390, 37, 390, 25, 1, 10, 390, 26, 2, 8, 391, 26, 4, 4, 393, 26, 401, 26, 401, 27, 400, 27, 400, 26, 401, 27, 400, 27, 400, 27, 400, 27, 400, 27, 400, 27, 400, 27, 401, 26, 401, 25, 402, 25, 403, 25, 402, 25, 402, 26, 400, 27, 400, 27, 400, 27, 400, 27, 400, 27, 400, 27, 401, 26, 401, 26, 401, 25, 403, 25, 402, 25, 402, 26, 401, 26, 401, 26, 400, 27, 400, 27, 400, 27, 401, 26, 401, 26, 401, 26, 401, 26, 402, 25, 402, 25, 402, 26, 401, 26, 401, 26, 401, 27, 400, 27, 400, 27, 400, 27, 400, 26, 401, 26, 401, 26, 402, 25, 402, 25, 403, 25, 401, 26, 401, 26, 401, 27, 400, 27, 400, 27, 400, 27, 400, 27, 400, 26, 401, 26, 402, 25, 402, 25, 403, 25, 402, 25, 401, 27, 400, 27, 400, 27, 400, 27, 400, 27, 400, 31, 396, 33, 394, 34, 394, 34, 393, 35, 393, 34, 393, 35, 392, 36, 390, 38, 389, 38, 389, 39, 388, 39, 388, 39, 388, 40, 387, 40, 388, 39, 388, 39, 389, 38, 389, 38, 389, 38, 389, 38, 389, 38, 388, 39, 388, 38, 389, 37, 390, 27, 3, 5, 393, 26, 401, 26, 401, 26, 402, 25, 402, 25, 402, 26, 401, 26, 401, 26, 401, 26, 401, 27, 400, 27, 400, 27, 400, 27, 400, 28, 399, 28, 399, 28, 399, 28, 399, 29, 398, 29, 398, 29, 398, 28, 399, 28, 399, 28, 399, 28, 400, 27, 400, 27, 400, 27, 399, 28, 399, 29, 398, 29, 398, 29, 398, 29, 398, 29, 398, 29, 398, 29, 398, 29, 399, 28, 399, 28, 399, 28, 399, 29, 397, 30, 397, 29, 398, 29, 398, 29, 398, 29, 398, 29, 398, 28, 399, 28, 400, 28, 399, 28, 399, 28, 399, 28, 399, 29, 397, 30, 397, 30, 397, 29, 398, 29, 398, 29, 398, 29, 398, 29, 399, 27, 400, 27, 400, 28, 399, 28, 399, 28, 399, 28, 398, 30, 397, 30, 397, 29, 398, 18, 9, 2, 398, 13, 15, 1, 398, 13, 15, 1, 399, 12, 15, 1, 399, 12, 9, 2, 4, 1, 399, 15, 1, 9, 2, 1, 400, 27, 399, 29, 398, 29, 398, 28, 398, 29, 398, 29, 398, 29, 398, 29, 398, 28, 400, 27, 400, 27, 400, 28, 400, 27, 399, 28, 399, 28, 399, 28, 399, 28, 398, 29, 398, 18, 1, 10, 398, 15, 7, 6, 399, 15, 12, 1, 400, 15, 412, 19, 7, 1, 400, 27, 401, 26, 401, 27, 399, 28, 399, 28, 399, 28, 399, 29, 398, 29, 398, 29, 398, 29, 398, 29, 398, 29, 398, 29, 399, 27, 400, 14, 1, 11, 401, 13, 2, 10, 401, 13, 3, 10, 401, 10, 6, 10, 401, 9, 7, 11, 399, 10, 7, 12, 397, 10, 8, 13, 395, 16, 3, 14, 394, 34, 393, 34, 392, 35, 392, 35, 392, 35, 392, 19, 1, 2, 6, 7, 392, 15, 5, 2, 7, 6, 392, 15, 5, 2, 7, 5, 393, 16, 4, 2, 7, 4, 394, 19, 1, 11, 397, 30, 398, 29, 399, 28, 399, 28, 400, 27, 400, 26, 401, 26, 400, 27, 400, 27, 400, 27, 400, 28, 399, 28, 399, 28, 399, 28, 399, 28, 399, 28, 399, 28, 400, 27, 400, 26, 401, 26, 400, 27, 400, 27, 400, 28, 399, 28, 399, 28, 399, 28, 399, 28, 399, 28, 399, 28, 399, 28, 400, 27, 400, 26, 400, 27, 400, 27, 400, 28, 399, 28, 399, 28, 399, 28, 399, 29, 398, 29, 398, 28, 399, 28, 399, 28, 399, 28, 399, 27, 400, 27, 400, 28, 399, 28, 399, 28, 399, 29, 399, 28, 399, 28, 399, 28, 398, 29, 398, 28, 399, 28, 399, 28, 399, 27, 400, 28, 399, 28, 399, 29, 398, 29, 398, 29, 399, 28, 398, 29, 398, 29, 398, 29, 398, 28, 399, 28, 399, 28, 399, 28, 399, 15, 2, 11, 399, 12, 8, 9, 398, 11, 15, 3, 399, 10, 15, 3, 399, 16, 9, 3, 399, 20, 5, 3, 398, 29, 398, 29, 398, 29, 398, 29, 398, 28, 399, 28, 399, 28, 399, 29, 398, 29, 398, 29, 399, 28, 399, 28, 399, 28, 398, 29, 398, 29, 398, 10, 9, 10, 398, 7, 12, 10, 398, 7, 12, 9, 399, 10, 9, 9, 399, 12, 4, 13, 398, 15, 3, 11, 398, 11, 8, 2, 3, 5, 398, 11, 13, 5, 398, 12, 8, 10, 397, 16, 6, 8, 396, 21, 3, 6, 397, 18, 3, 2, 1, 7, 396, 17, 5, 9, 396, 17, 6, 7, 397, 16, 7, 7, 397, 16, 4, 2, 1, 7, 397, 16, 2, 1, 1, 10, 397, 29, 398, 29, 398, 30, 397, 30, 396, 31, 396, 31, 395, 33, 394, 33, 394, 32, 395, 32, 395, 32, 395, 32, 395, 32, 394, 32, 395, 32, 395, 14, 2, 4, 7, 6, 394, 11, 17, 5, 394, 12, 16, 5, 394, 14, 13, 6, 394, 15, 13, 6, 393, 19, 9, 6, 393, 33, 394, 33, 394, 33, 394, 33, 394, 32, 395, 32, 395, 21, 2, 10, 394, 20, 5, 8, 394, 20, 5, 8, 394, 21, 2, 10, 394, 21, 2, 11, 393, 34, 393, 33, 394, 33, 394, 33, 394, 33, 394, 33, 394, 32, 395, 32, 395, 33, 394, 33, 394, 33, 394, 33, 394, 34, 393, 34, 393, 33, 394, 33, 394, 33, 394, 33, 394, 32, 395, 32, 395, 33, 394, 33, 394, 33, 394, 33, 394, 34, 393, 34, 394, 32, 396, 31, 398, 29, 401, 26, 63], "size": [427, 640]}, "area": 23866, "iscrowd": 1, "image_id": 17959, "bbox": [0, 132, 639, 239], "category_id": 1, "id": 900100017959}, {"segmentation": {"counts": [112572, 10, 413, 16, 409, 19, 404, 21, 405, 23, 403, 24, 402, 26, 400, 27, 399, 29, 397, 30, 395, 33, 392, 36, 381, 1, 7, 38, 380, 1, 6, 41, 377, 3, 4, 42, 377, 3, 3, 44, 376, 3, 2, 45, 376, 50, 376, 50, 376, 50, 376, 50, 376, 50, 376, 50, 376, 50, 376, 50, 377, 49, 377, 48, 379, 47, 380, 45, 382, 43, 384, 41, 386, 39, 389, 13, 2, 21, 393, 7, 12, 12, 414, 9, 25496, 17, 406, 23, 402, 25, 399, 29, 1, 8, 385, 44, 381, 46, 378, 50, 375, 52, 373, 54, 372, 54, 370, 57, 366, 60, 356, 71, 352, 73, 352, 70, 354, 70, 355, 69, 357, 67, 358, 65, 360, 64, 362, 61, 364, 59, 367, 57, 369, 55, 370, 54, 372, 54, 372, 54, 372, 54, 372, 54, 372, 54, 372, 54, 372, 54, 372, 54, 372, 55, 371, 55, 371, 56, 370, 56, 370, 57, 369, 58, 368, 58, 368, 59, 368, 59, 367, 61, 366, 62, 365, 64, 363, 64, 363, 59, 368, 52, 1, 2, 373, 45, 384, 40, 402, 21, 405, 20, 407, 18, 408, 17, 410, 15, 412, 13, 414, 10, 417, 9, 418, 8, 420, 5, 424, 2, 20127, 16, 407, 21, 403, 23, 402, 24, 400, 26, 399, 27, 375, 51, 372, 54, 371, 55, 368, 58, 366, 60, 360, 66, 357, 69, 356, 70, 354, 72, 353, 73, 352, 74, 351, 74, 351, 75, 350, 76, 350, 76, 349, 77, 349, 77, 348, 78, 348, 78, 348, 78, 348, 78, 348, 78, 348, 78, 348, 78, 348, 78, 348, 78, 348, 78, 348, 78, 348, 77, 349, 77, 349, 78, 348, 80, 346, 82, 344, 84, 343, 85, 341, 87, 340, 88, 339, 89, 338, 90, 337, 94, 333, 100, 327, 106, 322, 112, 317, 116, 315, 121, 307, 125, 303, 125, 304, 123, 315, 113, 314, 114, 313, 115, 312, 115, 312, 116, 311, 117, 310, 118, 309, 118, 309, 117, 310, 116, 311, 115, 312, 114, 313, 113, 314, 112, 316, 110, 318, 107, 320, 105, 323, 101, 326, 99, 328, 96, 332, 92, 335, 90, 338, 86, 342, 82, 346, 77, 352, 62, 368, 46, 392, 25, 404, 21, 406, 19, 409, 16, 413, 12, 418, 7, 423, 2, 37275], "size": [426, 640]}, "area": 13422, "iscrowd": 1, "image_id": 18380, "bbox": [264, 24, 288, 244], "category_id": 1, "id": 900100018380}, {"segmentation": {"counts": [489, 22, 24, 10, 5, 5, 414, 22, 23, 22, 27, 6, 380, 22, 23, 22, 25, 10, 378, 22, 22, 23, 24, 12, 377, 22, 22, 23, 24, 12, 378, 21, 22, 23, 20, 17, 378, 20, 22, 23, 18, 19, 378, 19, 23, 23, 17, 20, 378, 19, 23, 23, 17, 20, 378, 19, 9, 6, 1, 6, 1, 24, 15, 21, 378, 19, 7, 16, 1, 23, 15, 21, 378, 24, 1, 41, 15, 21, 379, 65, 15, 20, 381, 64, 15, 19, 28, 6, 349, 63, 15, 18, 27, 10, 346, 64, 15, 17, 27, 12, 345, 64, 15, 17, 27, 13, 344, 64, 15, 17, 26, 14, 344, 64, 15, 17, 26, 16, 342, 63, 17, 16, 26, 17, 341, 63, 17, 16, 26, 17, 341, 41, 1, 21, 17, 18, 24, 18, 3, 11, 327, 39, 2, 21, 17, 20, 22, 34, 326, 22, 3, 4, 3, 4, 4, 21, 17, 21, 21, 35, 325, 21, 19, 21, 17, 24, 19, 34, 325, 19, 21, 21, 18, 25, 16, 36, 324, 18, 22, 21, 18, 26, 15, 36, 323, 19, 22, 21, 18, 29, 11, 37, 323, 19, 22, 21, 18, 31, 6, 40, 322, 20, 22, 21, 18, 33, 2, 42, 322, 20, 22, 21, 18, 77, 322, 20, 22, 21, 18, 77, 322, 20, 4, 6, 13, 19, 19, 76, 322, 21, 2, 15, 2, 23, 19, 75, 323, 21, 1, 41, 19, 74, 324, 21, 1, 41, 19, 72, 326, 63, 2, 85, 330, 150, 330, 150, 330, 150, 330, 150, 330, 150, 330, 149, 331, 21, 1, 128, 330, 21, 2, 127, 330, 21, 3, 126, 330, 21, 5, 4, 1, 119, 330, 21, 12, 4, 4, 4, 1, 103, 331, 21, 25, 103, 331, 21, 25, 102, 332, 21, 25, 27, 2, 10, 1, 61, 333, 21, 26, 23, 17, 60, 333, 21, 26, 21, 13, 66, 333, 21, 26, 20, 12, 27, 3, 38, 333, 21, 25, 21, 11, 26, 7, 36, 333, 21, 25, 20, 12, 24, 13, 32, 333, 21, 25, 20, 11, 25, 16, 29, 333, 22, 23, 21, 11, 24, 19, 27, 333, 35, 10, 21, 11, 24, 21, 25, 333, 37, 8, 20, 12, 24, 21, 25, 332, 39, 7, 19, 13, 23, 23, 23, 333, 41, 5, 19, 13, 22, 24, 22, 334, 42, 4, 19, 13, 21, 26, 20, 335, 65, 14, 12, 2, 4, 29, 10, 2, 5, 337, 65, 15, 10, 37, 8, 345, 65, 16, 8, 40, 4, 347, 66, 17, 4, 393, 66, 414, 66, 414, 66, 414, 66, 414, 66, 415, 23, 1, 41, 415, 21, 10, 33, 417, 20, 12, 7, 5, 18, 419, 18, 25, 17, 421, 16, 25, 16, 425, 13, 26, 12, 432, 5, 24004, 4, 477, 5, 475, 6, 475, 5, 462, 1, 10, 8, 460, 20, 460, 20, 459, 21, 458, 22, 457, 23, 457, 23, 456, 23, 457, 23, 15, 7, 435, 23, 13, 11, 433, 23, 12, 13, 432, 22, 13, 13, 432, 22, 12, 15, 431, 22, 12, 15, 431, 22, 12, 16, 5, 7, 418, 22, 12, 16, 3, 11, 415, 23, 12, 16, 2, 13, 414, 22, 13, 16, 2, 13, 413, 23, 13, 16, 1, 15, 25, 13, 374, 23, 14, 15, 1, 15, 22, 18, 372, 23, 15, 14, 1, 15, 15, 26, 371, 23, 15, 30, 13, 29, 370, 23, 15, 73, 369, 23, 15, 73, 369, 23, 15, 74, 368, 23, 15, 74, 368, 23, 15, 74, 368, 23, 15, 74, 368, 23, 15, 74, 368, 23, 15, 74, 368, 23, 15, 74, 367, 24, 15, 73, 367, 25, 15, 72, 368, 25, 15, 59, 4, 8, 369, 25, 15, 51, 14, 4, 371, 25, 15, 48, 392, 25, 16, 26, 1, 10, 2, 6, 394, 25, 16, 24, 415, 25, 16, 23, 416, 25, 16, 21, 418, 25, 16, 14, 1, 4, 420, 25, 16, 14, 425, 25, 16, 14, 425, 25, 16, 12, 427, 25, 14, 13, 428, 25, 13, 13, 429, 25, 13, 13, 429, 25, 6, 19, 431, 24, 2, 23, 431, 48, 433, 47, 434, 46, 434, 46, 435, 45, 436, 44, 437, 43, 439, 41, 444, 36, 444, 31, 1, 4, 444, 28, 4, 4, 444, 26, 6, 4, 444, 23, 458, 14, 2, 1, 464, 11, 476, 2, 19214, 12, 463, 17, 461, 19, 458, 22, 448, 6, 3, 23, 447, 33, 446, 34, 441, 39, 440, 40, 439, 41, 438, 42, 437, 43, 436, 43, 436, 33, 102, 1, 343, 32, 104, 2, 341, 30, 107, 2, 341, 29, 108, 2, 341, 27, 110, 3, 340, 25, 112, 3, 340, 25, 112, 3, 340, 25, 112, 4, 339, 24, 113, 5, 338, 24, 113, 5, 338, 24, 113, 5, 338, 24, 113, 5, 338, 24, 113, 6, 338, 23, 113, 7, 337, 23, 113, 7, 337, 23, 113, 8, 336, 23, 113, 8, 336, 23, 113, 8, 336, 23, 113, 9, 335, 23, 113, 9, 335, 23, 113, 10, 334, 23, 113, 10, 334, 23, 113, 10, 334, 23, 113, 11, 333, 23, 113, 12, 332, 23, 113, 12, 332, 22, 114, 12, 332, 22, 114, 13, 331, 22, 114, 13, 331, 22, 114, 13, 331, 22, 114, 10, 334, 22, 115, 3, 340, 22, 458, 22, 458, 22, 458, 22, 458, 23, 457, 23, 127, 3, 327, 23, 119, 12, 326, 23, 119, 12, 326, 23, 118, 13, 326, 23, 118, 14, 325, 23, 118, 14, 326, 21, 120, 14, 326, 19, 122, 13, 326, 13, 128, 13, 326, 11, 130, 14, 326, 9, 131, 15, 326, 6, 134, 14, 328, 3, 136, 13, 468, 13, 467, 13, 467, 14, 466, 14, 467, 14, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 13, 468, 13, 467, 13, 467, 14, 466, 14, 467, 14, 467, 13, 467, 13, 467, 14, 466, 15, 466, 14, 467, 13, 468, 12, 468, 13, 467, 14, 466, 14, 467, 14, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 13, 467, 13, 468, 13, 467, 14, 466, 14, 467, 14, 467, 13, 467, 13, 467, 14, 466, 15, 466, 14, 467, 13, 467, 13, 468, 13, 467, 14, 466, 14, 467, 14, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 13, 467, 13, 468, 13, 467, 14, 466, 14, 467, 14, 467, 13, 467, 13, 467, 14, 466, 15, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 14, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 13, 467, 13, 468, 13, 467, 14, 466, 14, 467, 14, 467, 13, 467, 13, 467, 14, 466, 15, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 14, 467, 13, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 14, 467, 13, 467, 13, 467, 14, 466, 15, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 14, 467, 13, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 14, 467, 13, 467, 13, 467, 14, 466, 15, 466, 14, 467, 13, 467, 13, 467, 14, 467, 14, 466, 14, 467, 14, 467, 13, 6, 6, 455, 13, 5, 8, 454, 13, 4, 10, 453, 14, 2, 12, 453, 27, 453, 27, 454, 26, 454, 26, 454, 26, 455, 25, 455, 24, 457, 22, 459, 20, 460, 20, 459, 19, 460, 19, 460, 20, 459, 20, 458, 22, 457, 23, 457, 24, 455, 25, 453, 28, 355, 47, 49, 29, 325, 25, 3, 50, 47, 30, 324, 27, 2, 51, 46, 30, 323, 82, 43, 33, 321, 83, 42, 35, 304, 99, 41, 36, 303, 100, 41, 22, 1, 13, 302, 101, 39, 24, 1, 13, 301, 102, 37, 25, 2, 14, 299, 103, 37, 25, 3, 14, 298, 65, 3, 34, 37, 25, 4, 14, 297, 61, 10, 31, 37, 24, 7, 14, 294, 61, 19, 22, 37, 26, 8, 13, 293, 59, 24, 20, 36, 26, 9, 13, 294, 31, 11, 15, 26, 19, 36, 26, 9, 14, 292, 31, 12, 13, 28, 19, 35, 26, 10, 15, 291, 29, 14, 12, 28, 20, 33, 26, 13, 14, 290, 22, 1, 4, 17, 12, 28, 20, 32, 27, 14, 13, 290, 21, 23, 12, 28, 20, 31, 27, 15, 13, 289, 22, 23, 12, 28, 20, 31, 27, 15, 14, 288, 22, 23, 12, 27, 21, 29, 28, 17, 14, 287, 22, 23, 12, 27, 21, 28, 27, 19, 14, 287, 22, 23, 12, 27, 21, 27, 28, 20, 13, 287, 22, 23, 12, 27, 21, 26, 29, 21, 13, 286, 22, 23, 12, 27, 21, 25, 29, 22, 13, 286, 22, 23, 12, 27, 21, 23, 30, 23, 13, 286, 22, 23, 12, 27, 21, 22, 29, 25, 14, 285, 22, 23, 12, 26, 22, 22, 29, 26, 14, 284, 22, 23, 12, 26, 22, 21, 30, 26, 14, 284, 22, 23, 12, 26, 22, 19, 31, 28, 13, 284, 22, 23, 12, 27, 21, 18, 31, 29, 13, 284, 22, 23, 12, 26, 22, 17, 31, 30, 14, 284, 21, 23, 12, 26, 23, 16, 30, 32, 14, 283, 21, 23, 12, 26, 23, 14, 32, 32, 14, 283, 21, 23, 12, 26, 23, 13, 32, 34, 14, 282, 21, 23, 12, 26, 23, 12, 32, 36, 13, 282, 21, 23, 18, 20, 23, 11, 32, 37, 13, 283, 20, 23, 19, 19, 23, 9, 33, 38, 14, 282, 20, 23, 20, 18, 24, 7, 34, 38, 15, 281, 20, 23, 21, 17, 25, 5, 34, 40, 14, 281, 20, 23, 21, 17, 25, 5, 33, 42, 13, 280, 22, 22, 22, 16, 12, 1, 12, 3, 34, 43, 13, 280, 22, 22, 22, 16, 25, 2, 34, 44, 14, 279, 22, 22, 23, 15, 25, 1, 35, 45, 14, 278, 22, 22, 23, 15, 60, 46, 14, 278, 22, 22, 23, 15, 42, 1, 16, 48, 13, 278, 22, 22, 23, 15, 13, 1, 27, 1, 16, 50, 13, 277, 22, 22, 24, 14, 13, 1, 27, 1, 16, 50, 13, 277, 22, 22, 25, 14, 12, 1, 25, 2, 16, 51, 13, 277, 21, 23, 25, 14, 37, 2, 16, 52, 14, 276, 20, 24, 25, 15, 12, 1, 22, 2, 16, 54, 14, 275, 20, 24, 25, 15, 34, 2, 16, 55, 14, 275, 20, 24, 26, 12, 35, 3, 16, 56, 13, 275, 20, 24, 30, 6, 35, 4, 16, 57, 13, 275, 20, 16, 79, 3, 16, 58, 14, 274, 20, 9, 85, 3, 16, 60, 14, 273, 113, 3, 16, 61, 14, 273, 101, 9, 1, 5, 16, 62, 14, 272, 91, 25, 15, 64, 13, 272, 81, 33, 16, 65, 13, 272, 71, 42, 16, 66, 14, 272, 61, 50, 16, 67, 15, 271, 51, 60, 16, 68, 14, 272, 40, 70, 15, 70, 13, 272, 31, 77, 16, 71, 13, 273, 20, 78, 2, 6, 16, 72, 14, 273, 9, 83, 5, 7, 16, 73, 15, 364, 5, 7, 16, 74, 14, 364, 4, 8, 15, 76, 13, 364, 3, 7, 16, 78, 13, 363, 1, 8, 16, 79, 13, 372, 15, 80, 14, 370, 16, 80, 14, 370, 15, 82, 14, 367, 16, 83, 14, 366, 16, 85, 13, 366, 16, 85, 13, 365, 16, 86, 14, 364, 15, 88, 14, 361, 16, 89, 14, 360, 16, 91, 14, 359, 16, 92, 13, 358, 16, 93, 13, 358, 15, 94, 14, 357, 14, 95, 15, 356, 13, 97, 14, 356, 13, 98, 13, 356, 12, 99, 13, 356, 12, 99, 14, 355, 10, 101, 15, 354, 9, 103, 14, 354, 9, 104, 13, 354, 8, 106, 13, 353, 8, 106, 13, 353, 6, 108, 14, 352, 5, 109, 14, 352, 5, 110, 14, 351, 4, 111, 14, 351, 4, 112, 13, 351, 2, 114, 13, 351, 1, 115, 14, 350, 1, 116, 14, 349, 1, 116, 14, 467, 13, 468, 13, 467, 13, 467, 14, 466, 14, 467, 14, 467, 13, 467, 13, 467, 14, 466, 15, 466, 14, 467, 13, 468, 13, 467, 13, 467, 14, 466, 14, 356, 3, 108, 14, 346, 12, 108, 14, 338, 20, 109, 13, 329, 29, 109, 13, 321, 37, 108, 15, 311, 46, 106, 18, 302, 54, 102, 22, 293, 62, 101, 24, 248, 1, 36, 70, 97, 28, 248, 3, 32, 71, 96, 30, 224, 17, 7, 5, 30, 70, 92, 35, 202, 8, 6, 39, 5, 2, 21, 68, 93, 36, 201, 62, 20, 66, 90, 40, 201, 64, 19, 37, 2, 25, 89, 1, 1, 40, 201, 65, 19, 32, 8, 21, 89, 43, 203, 66, 18, 30, 12, 17, 87, 42, 208, 66, 18, 30, 17, 12, 85, 42, 210, 66, 18, 15, 1, 14, 17, 12, 80, 43, 213, 67, 18, 15, 2, 13, 17, 12, 79, 42, 215, 29, 5, 33, 18, 15, 2, 13, 17, 12, 74, 42, 220, 29, 6, 32, 18, 15, 2, 13, 18, 12, 71, 43, 221, 29, 11, 27, 18, 15, 2, 12, 18, 13, 67, 42, 226, 28, 12, 26, 19, 15, 2, 12, 18, 13, 65, 42, 228, 27, 13, 26, 19, 15, 1, 13, 18, 13, 60, 43, 232, 25, 15, 26, 19, 15, 1, 13, 18, 13, 59, 42, 233, 24, 17, 26, 19, 15, 1, 13, 19, 12, 54, 43, 237, 24, 17, 26, 19, 16, 1, 12, 19, 12, 50, 42, 242, 24, 17, 26, 19, 29, 19, 12, 48, 43, 243, 24, 17, 26, 19, 28, 20, 12, 44, 42, 248, 24, 17, 26, 19, 29, 19, 12, 42, 42, 250, 24, 17, 26, 19, 29, 19, 12, 37, 43, 254, 24, 17, 26, 19, 29, 19, 12, 36, 42, 256, 24, 17, 26, 19, 28, 20, 12, 31, 43, 260, 24, 17, 26, 19, 28, 20, 12, 30, 42, 262, 24, 17, 26, 19, 27, 21, 12, 25, 42, 266, 25, 17, 26, 19, 28, 20, 12, 23, 42, 268, 25, 17, 26, 19, 28, 20, 12, 19, 42, 272, 25, 17, 26, 19, 28, 19, 13, 15, 41, 1, 1, 275, 25, 17, 26, 19, 28, 18, 14, 12, 43, 278, 25, 17, 26, 19, 27, 19, 13, 9, 42, 283, 25, 17, 26, 19, 27, 19, 13, 7, 43, 284, 26, 16, 26, 19, 27, 19, 13, 3, 42, 289, 27, 15, 26, 19, 27, 19, 13, 1, 42, 291, 28, 14, 26, 19, 32, 14, 52, 295, 28, 14, 26, 19, 33, 13, 50, 297, 28, 14, 26, 19, 34, 12, 46, 301, 28, 14, 26, 19, 35, 11, 44, 303, 28, 12, 28, 19, 35, 11, 39, 309, 27, 11, 29, 19, 35, 11, 37, 312, 26, 10, 30, 19, 35, 11, 33, 316, 25, 10, 31, 19, 35, 11, 28, 321, 24, 11, 31, 19, 35, 11, 27, 323, 21, 13, 31, 19, 35, 11, 22, 329, 17, 16, 31, 19, 34, 12, 21, 331, 16, 16, 31, 19, 33, 13, 16, 317], "size": [480, 640]}, "area": 33435, "iscrowd": 1, "image_id": 19432, "bbox": [1, 9, 638, 288], "category_id": 62, "id": 906200019432}, {"segmentation": {"counts": [212508, 4, 385, 8, 29, 6, 382, 12, 27, 6, 380, 15, 25, 7, 379, 17, 25, 6, 379, 18, 24, 6, 378, 20, 26, 1, 341, 5, 33, 33, 355, 6, 33, 34, 353, 7, 33, 32, 355, 7, 33, 32, 18, 3, 334, 1, 1, 6, 31, 31, 21, 3, 335, 6, 31, 28, 25, 3, 335, 6, 30, 28, 26, 3, 3, 3, 328, 7, 21, 36, 27, 3, 3, 3, 327, 7, 18, 39, 28, 3, 3, 2, 301, 12, 14, 8, 8, 48, 28, 4, 3, 1, 298, 18, 12, 7, 8, 48, 29, 4, 301, 20, 10, 7, 8, 48, 30, 3, 3, 1, 297, 22, 8, 7, 1, 1, 6, 49, 29, 3, 3, 2, 291, 1, 4, 24, 7, 8, 6, 50, 28, 3, 3, 2, 291, 1, 4, 26, 5, 8, 6, 50, 28, 3, 3, 3, 291, 1, 3, 27, 4, 8, 6, 18, 1, 32, 27, 3, 3, 4, 285, 1, 4, 1, 3, 27, 5, 7, 6, 18, 3, 2, 3, 26, 26, 3, 3, 4, 284, 2, 4, 1, 4, 26, 5, 7, 6, 19, 3, 1, 4, 26, 25, 3, 3, 5, 238, 8, 36, 3, 4, 1, 4, 26, 5, 8, 5, 20, 7, 27, 24, 3, 3, 5, 223, 8, 5, 12, 33, 4, 4, 1, 4, 26, 5, 8, 5, 20, 7, 28, 23, 3, 3, 5, 221, 12, 1, 15, 32, 5, 3, 1, 4, 26, 5, 8, 5, 20, 7, 28, 23, 3, 2, 6, 219, 31, 30, 6, 3, 1, 4, 27, 4, 8, 5, 20, 7, 28, 23, 3, 2, 6, 218, 33, 28, 7, 3, 1, 4, 27, 4, 8, 5, 20, 7, 28, 23, 3, 2, 7, 217, 34, 27, 7, 3, 1, 4, 27, 4, 8, 5, 20, 7, 28, 23, 3, 2, 7, 216, 36, 25, 8, 3, 1, 4, 27, 4, 8, 5, 20, 7, 28, 23, 3, 2, 7, 215, 38, 24, 8, 3, 1, 4, 27, 4, 8, 4, 21, 7, 28, 23, 3, 2, 7, 215, 38, 24, 8, 3, 1, 4, 27, 4, 8, 4, 21, 7, 28, 23, 3, 2, 7, 215, 39, 22, 9, 3, 1, 4, 27, 4, 8, 4, 21, 7, 28, 23, 3, 2, 7, 215, 39, 22, 9, 3, 1, 4, 27, 4, 8, 4, 21, 7, 28, 23, 3, 2, 7, 214, 40, 22, 9, 3, 1, 4, 27, 4, 8, 4, 21, 6, 29, 23, 3, 2, 7, 214, 40, 22, 9, 3, 1, 4, 27, 5, 7, 4, 21, 6, 29, 23, 3, 2, 7, 214, 40, 22, 9, 2, 2, 4, 27, 5, 7, 4, 21, 6, 29, 23, 3, 2, 7, 215, 39, 22, 9, 2, 2, 4, 27, 5, 7, 4, 21, 6, 29, 6, 1, 16, 3, 2, 7, 215, 39, 22, 9, 2, 2, 4, 27, 5, 7, 4, 21, 6, 29, 6, 1, 10, 1, 5, 3, 2, 7, 215, 39, 22, 9, 2, 2, 4, 27, 5, 7, 4, 21, 6, 29, 6, 1, 10, 1, 5, 3, 2, 7, 215, 39, 22, 9, 2, 2, 4, 27, 5, 7, 4, 21, 6, 29, 6, 1, 10, 1, 5, 3, 2, 7, 214, 40, 22, 9, 2, 2, 4, 27, 5, 7, 4, 21, 4, 1, 1, 29, 6, 8, 3, 1, 5, 3, 2, 6, 215, 40, 22, 9, 2, 2, 4, 27, 5, 7, 4, 21, 4, 31, 7, 7, 3, 1, 5, 3, 2, 6, 216, 39, 22, 9, 2, 1, 5, 27, 5, 7, 4, 21, 4, 31, 7, 7, 3, 1, 5, 3, 1, 6, 216, 40, 22, 9, 2, 1, 5, 27, 5, 7, 4, 21, 4, 31, 7, 11, 5, 3, 1, 6, 216, 40, 22, 9, 2, 1, 5, 27, 5, 7, 4, 56, 4, 14, 5, 3, 1, 5, 217, 40, 22, 9, 2, 1, 5, 27, 5, 7, 4, 88, 217, 40, 22, 10, 1, 1, 5, 27, 5, 7, 4, 87, 218, 40, 23, 9, 1, 1, 4, 28, 5, 8, 3, 87, 218, 40, 23, 9, 1, 1, 4, 28, 5, 8, 3, 86, 219, 40, 24, 8, 1, 1, 4, 28, 6, 7, 3, 85, 220, 39, 25, 10, 4, 31, 3, 7, 3, 84, 222, 38, 26, 9, 4, 41, 3, 83, 223, 37, 27, 9, 4, 126, 224, 36, 29, 8, 4, 124, 226, 35, 30, 135, 228, 33, 32, 132, 230, 32, 34, 100, 4, 24, 234, 30, 36, 97, 10, 16, 239, 28, 38, 94, 268, 25, 41, 90, 272, 22, 45, 84, 279, 17, 48, 71, 297, 8, 53, 61, 368, 55, 373, 48, 381, 45, 385, 40, 391, 33, 402, 8, 5, 8, 30527], "size": [427, 640]}, "area": 9151, "iscrowd": 1, "image_id": 14038, "bbox": [497, 100, 71, 212], "category_id": 84, "id": 908400014038}, {"segmentation": {"counts": [92732, 6, 421, 8, 419, 10, 417, 12, 416, 12, 415, 13, 414, 14, 413, 16, 411, 18, 409, 20, 407, 21, 407, 21, 407, 21, 406, 22, 406, 22, 406, 22, 406, 23, 405, 24, 404, 25, 403, 26, 401, 28, 399, 31, 396, 33, 395, 34, 394, 35, 393, 36, 392, 38, 390, 39, 389, 40, 389, 4, 1, 35, 388, 4, 1, 36, 387, 4, 1, 37, 386, 4, 1, 38, 385, 4, 1, 39, 384, 4, 2, 39, 384, 3, 2, 39, 385, 2, 2, 39, 385, 1, 3, 38, 386, 1, 3, 42, 382, 1, 4, 42, 381, 1, 4, 17, 3, 23, 385, 16, 5, 23, 384, 9, 14, 21, 384, 8, 17, 19, 385, 5, 20, 18, 414, 14, 414, 14, 414, 14, 416, 11, 419, 8, 421, 5, 30320, 1, 426, 2, 425, 5, 423, 6, 422, 8, 420, 9, 419, 11, 417, 12, 416, 14, 414, 15, 413, 17, 411, 18, 410, 20, 409, 20, 409, 21, 407, 22, 407, 23, 406, 23, 406, 24, 405, 25, 404, 25, 404, 25, 404, 24, 404, 24, 405, 23, 29, 2, 375, 10, 33, 10, 377, 5, 30, 17, 411, 17, 411, 18, 33, 1, 376, 19, 31, 3, 375, 21, 28, 5, 376, 20, 27, 5, 377, 20, 25, 6, 378, 20, 23, 7, 381, 18, 22, 7, 384, 18, 18, 8, 387, 41, 390, 38, 392, 36, 393, 35, 394, 34, 395, 33, 397, 31, 400, 27, 403, 24, 406, 20, 409, 19, 411, 16, 414, 13, 418, 6, 13165, 6, 421, 8, 419, 10, 417, 12, 416, 12, 416, 13, 415, 15, 413, 15, 413, 16, 412, 18, 410, 19, 409, 20, 409, 20, 409, 20, 410, 20, 410, 14, 3, 1, 410, 13, 414, 14, 413, 18, 410, 21, 407, 23, 405, 24, 404, 25, 403, 25, 403, 26, 403, 25, 404, 25, 405, 23, 413, 16, 412, 16, 412, 15, 413, 3, 3, 8, 414, 3, 5, 6, 414, 3, 7, 3, 415, 4, 424, 5, 423, 8, 420, 11, 416, 15, 413, 16, 412, 15, 413, 14, 414, 13, 415, 11, 417, 9, 420, 8, 421, 8, 422, 6, 851, 5, 422, 7, 420, 8, 419, 9, 419, 9, 419, 10, 418, 10, 418, 10, 418, 10, 418, 10, 418, 10, 417, 11, 417, 11, 417, 11, 417, 11, 417, 10, 418, 9, 419, 7, 421, 6, 422, 4, 424, 4, 424, 4, 425, 3, 426, 2, 428, 1, 6415, 12, 415, 15, 412, 18, 409, 22, 406, 24, 404, 26, 402, 28, 400, 28, 400, 29, 399, 41, 9, 3, 376, 53, 376, 53, 377, 53, 383, 46, 382, 47, 381, 48, 380, 49, 379, 51, 378, 51, 378, 51, 18, 1, 360, 50, 17, 2, 365, 46, 14, 4, 334, 13, 17, 52, 4, 8, 331, 17, 16, 64, 330, 21, 13, 64, 329, 23, 12, 64, 328, 26, 10, 64, 328, 27, 9, 64, 328, 28, 8, 63, 329, 33, 1, 64, 330, 98, 330, 98, 330, 97, 331, 96, 332, 95, 333, 94, 334, 94, 334, 94, 335, 93, 336, 92, 338, 90, 339, 89, 340, 88, 342, 86, 345, 83, 348, 80, 349, 79, 350, 78, 350, 78, 351, 78, 350, 78, 351, 77, 352, 76, 352, 77, 352, 76, 353, 14, 2, 59, 355, 11, 5, 57, 359, 6, 7, 56, 374, 54, 376, 53, 376, 52, 378, 50, 379, 49, 381, 47, 382, 46, 384, 44, 386, 42, 388, 40, 390, 38, 393, 34, 402, 25, 403, 25, 403, 25, 405, 22, 407, 20, 409, 17, 412, 12, 418, 6, 24507], "size": [428, 640]}, "area": 9083, "iscrowd": 1, "image_id": 19109, "bbox": [216, 234, 366, 116], "category_id": 4, "id": 900400019109}, {"segmentation": {"counts": [428, 33, 395, 33, 395, 33, 395, 34, 394, 34, 394, 35, 393, 35, 393, 36, 392, 36, 392, 36, 392, 36, 392, 36, 392, 36, 392, 36, 392, 36, 392, 36, 392, 36, 392, 36, 392, 37, 391, 37, 391, 38, 390, 38, 390, 38, 390, 38, 390, 39, 389, 39, 389, 39, 389, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 207, 21, 160, 39, 203, 31, 155, 38, 201, 36, 153, 38, 199, 42, 149, 37, 190, 54, 148, 35, 189, 58, 153, 27, 189, 60, 154, 23, 190, 62, 154, 21, 190, 64, 155, 18, 191, 65, 157, 13, 192, 67, 160, 6, 195, 68, 360, 68, 360, 69, 359, 69, 359, 69, 359, 69, 359, 69, 359, 69, 359, 69, 359, 69, 359, 69, 359, 69, 359, 69, 359, 69, 359, 69, 359, 68, 360, 21, 2, 45, 146, 8, 207, 19, 10, 37, 144, 14, 204, 18, 16, 31, 144, 16, 204, 16, 21, 25, 145, 18, 204, 14, 28, 17, 146, 22, 203, 10, 192, 29, 199, 6, 194, 32, 396, 34, 394, 35, 393, 36, 392, 37, 391, 38, 390, 39, 389, 39, 389, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 40, 388, 41, 387, 41, 387, 42, 386, 42, 386, 42, 386, 42, 386, 43, 385, 43, 385, 44, 384, 44, 384, 45, 383, 45, 383, 45, 383, 45, 383, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 45, 383, 45, 76, 9, 298, 45, 46, 8, 16, 18, 295, 45, 43, 46, 294, 45, 42, 48, 293, 45, 41, 50, 292, 44, 41, 52, 291, 44, 33, 61, 290, 43, 32, 63, 290, 43, 31, 65, 289, 43, 30, 66, 289, 43, 29, 67, 289, 43, 29, 67, 289, 44, 27, 68, 289, 44, 27, 68, 289, 44, 27, 68, 289, 44, 27, 68, 289, 45, 26, 68, 289, 45, 26, 68, 289, 46, 25, 68, 289, 46, 25, 67, 290, 46, 25, 66, 291, 46, 26, 65, 291, 46, 26, 64, 292, 47, 26, 62, 293, 47, 27, 60, 294, 47, 28, 57, 296, 47, 28, 54, 299, 47, 29, 46, 306, 48, 29, 16, 3, 13, 1, 6, 312, 48, 31, 12, 337, 48, 33, 8, 339, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 47, 381, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 49, 379, 49, 379, 49, 380, 48, 382, 47, 383, 45, 384, 45, 385, 43, 387, 41, 384, 44, 381, 47, 378, 50, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 52, 376, 52, 376, 52, 376, 52, 376, 53, 375, 53, 375, 53, 375, 53, 375, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 374, 54, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 376, 52, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 375, 53, 376, 52, 375, 52, 376, 52, 376, 52, 376, 52, 376, 52, 376, 52, 376, 52, 376, 52, 376, 52, 376, 52, 376, 52, 377, 51, 376, 51, 377, 51, 377, 51, 377, 51, 377, 51, 377, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 50, 379, 49, 379, 49, 378, 50, 378, 49, 379, 49, 379, 49, 379, 49, 379, 49, 379, 49, 379, 49, 379, 49, 379, 49, 379, 49, 379, 48, 379, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 47, 381, 46, 382, 17, 6, 23, 382, 14, 10, 21, 383, 12, 13, 19, 44, 13, 329, 7, 17, 17, 43, 17, 353, 13, 44, 19, 355, 7, 46, 21, 405, 24, 399, 29, 396, 32, 395, 33, 394, 34, 393, 35, 392, 36, 391, 37, 391, 37, 390, 37, 391, 37, 391, 36, 392, 36, 392, 36, 392, 36, 347, 11, 34, 36, 343, 18, 31, 36, 340, 22, 30, 36, 339, 24, 29, 35, 335, 30, 28, 36, 331, 34, 28, 35, 330, 36, 28, 34, 329, 37, 28, 34, 328, 39, 28, 33, 327, 40, 29, 32, 326, 41, 30, 31, 324, 43, 31, 30, 324, 43, 31, 29, 325, 43, 31, 29, 325, 43, 32, 27, 326, 43, 32, 26, 327, 43, 33, 23, 329, 43, 34, 22, 329, 43, 35, 20, 330, 43, 35, 19, 331, 43, 36, 17, 332, 43, 37, 14, 334, 43, 40, 10, 335, 43, 43, 4, 338, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 98, 12, 275, 43, 95, 17, 273, 43, 94, 19, 272, 43, 81, 9, 3, 21, 271, 43, 78, 37, 270, 43, 77, 39, 269, 43, 76, 41, 268, 43, 75, 42, 268, 43, 74, 44, 267, 44, 72, 45, 267, 44, 72, 45, 267, 44, 54, 8, 9, 46, 267, 44, 54, 11, 6, 46, 267, 44, 54, 16, 1, 46, 267, 44, 54, 63, 267, 44, 55, 62, 267, 44, 55, 62, 267, 44, 55, 62, 267, 44, 41, 2, 10, 64, 267, 44, 40, 4, 4, 68, 268, 44, 39, 76, 269, 44, 39, 76, 269, 44, 39, 75, 270, 44, 39, 74, 271, 44, 39, 73, 272, 45, 38, 71, 274, 45, 38, 35, 1, 35, 274, 45, 38, 34, 3, 33, 275, 45, 38, 33, 6, 30, 276, 45, 38, 32, 9, 27, 277, 45, 38, 31, 12, 23, 279, 45, 38, 30, 16, 17, 282, 45, 38, 30, 19, 10, 286, 45, 39, 28, 316, 46, 39, 26, 317, 46, 39, 25, 318, 47, 39, 20, 322, 47, 40, 18, 323, 48, 40, 16, 324, 48, 42, 13, 325, 48, 45, 7, 328, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 48, 380, 47, 381, 47, 381, 47, 381, 48, 380, 49, 379, 49, 379, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 50, 378, 49, 379, 48, 380, 48, 380, 47, 381, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 46, 382, 45, 383, 44, 384, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 43, 385, 44, 90, 6, 288, 44, 88, 10, 286, 44, 86, 14, 284, 44, 85, 16, 283, 44, 84, 18, 282, 44, 82, 21, 281, 44, 81, 23, 280, 43, 81, 25, 279, 43, 80, 26, 279, 43, 79, 28, 278, 43, 78, 29, 278, 43, 78, 29, 278, 43, 77, 30, 278, 43, 77, 30, 278, 43, 76, 31, 278, 43, 75, 32, 278, 43, 77, 30, 278, 43, 77, 30, 278, 43, 77, 31, 277, 43, 75, 34, 276, 43, 73, 36, 276, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 39, 275, 43, 71, 38, 276, 43, 71, 37, 277, 43, 71, 37, 277, 44, 70, 36, 278, 44, 71, 35, 278, 44, 71, 35, 278, 44, 72, 34, 278, 44, 73, 33, 278, 44, 76, 29, 279, 44, 79, 27, 278, 44, 80, 26, 278, 44, 80, 27, 277, 44, 80, 28, 276, 44, 78, 30, 276, 44, 71, 38, 275, 44, 66, 43, 275, 44, 64, 46, 274, 44, 63, 47, 274, 44, 62, 49, 273, 44, 61, 51, 272, 44, 60, 52, 272, 44, 60, 53, 271, 44, 59, 54, 271, 44, 59, 54, 271, 44, 59, 54, 271, 44, 59, 54, 271, 44, 59, 54, 271, 43, 60, 54, 271, 45, 58, 54, 271, 46, 57, 54, 271, 46, 58, 53, 271, 47, 57, 53, 271, 47, 58, 51, 272, 47, 58, 50, 273, 47, 58, 50, 273, 47, 59, 48, 274, 47, 60, 46, 275, 47, 60, 45, 276, 46, 62, 7, 1, 34, 278, 45, 64, 5, 2, 32, 280, 44, 66, 3, 3, 32, 280, 42, 75, 31, 280, 39, 78, 30, 282, 38, 81, 27, 290, 29, 87, 21, 282], "size": [428, 640]}, "area": 36639, "iscrowd": 1, "image_id": 12120, "bbox": [1, 0, 638, 289], "category_id": 1, "id": 900100012120}, {"segmentation": {"counts": [488, 34, 4, 1, 4, 4, 2, 3, 4, 3, 1, 7, 4, 10, 1, 5, 3, 6, 2, 10, 3, 7, 2, 2, 2, 4, 4, 12, 8, 2, 28, 22, 222, 163, 3, 4, 3, 35, 218, 212, 215, 214, 213, 216, 211, 218, 208, 221, 207, 222, 205, 224, 203, 224, 203, 224, 203, 225, 203, 224, 203, 225, 203, 224, 203, 225, 202, 226, 202, 225, 203, 225, 202, 226, 202, 225, 203, 225, 202, 226, 202, 225, 203, 225, 203, 225, 203, 225, 203, 225, 203, 226, 202, 226, 202, 226, 202, 226, 202, 226, 202, 226, 202, 227, 201, 227, 201, 227, 201, 227, 202, 226, 202, 226, 202, 226, 202, 227, 202, 226, 202, 226, 203, 225, 203, 226, 203, 226, 202, 227, 202, 227, 200, 228, 198, 231, 197, 232, 195, 234, 192, 236, 191, 238, 190, 239, 188, 239, 189, 239, 188, 239, 188, 240, 188, 239, 189, 236, 191, 234, 194, 231, 197, 227, 200, 225, 203, 223, 205, 221, 207, 219, 209, 218, 210, 216, 212, 214, 214, 213, 215, 212, 216, 210, 218, 209, 219, 208, 220, 207, 221, 206, 222, 205, 223, 205, 224, 203, 225, 203, 225, 202, 226, 197, 232, 195, 233, 193, 236, 192, 236, 192, 237, 191, 237, 191, 238, 190, 239, 189, 239, 189, 240, 188, 241, 187, 242, 186, 243, 185, 244, 184, 245, 183, 246, 182, 247, 181, 249, 178, 252, 176, 253, 136, 14, 4, 18, 2, 255, 133, 296, 130, 300, 127, 301, 126, 302, 125, 303, 125, 303, 124, 304, 123, 305, 122, 306, 122, 306, 121, 307, 120, 308, 119, 309, 119, 309, 118, 310, 117, 311, 116, 312, 104, 324, 102, 326, 100, 328, 98, 330, 96, 332, 94, 334, 73, 12, 8, 335, 72, 356, 71, 357, 71, 357, 70, 358, 69, 359, 68, 360, 67, 361, 67, 361, 66, 362, 65, 361, 66, 360, 68, 359, 68, 359, 68, 359, 68, 358, 70, 358, 71, 356, 72, 355, 73, 354, 75, 352, 76, 352, 77, 350, 78, 350, 78, 349, 80, 347, 81, 347, 82, 346, 83, 344, 85, 343, 87, 341, 88, 339, 90, 338, 91, 337, 92, 336, 93, 335, 95, 333, 96, 332, 97, 331, 97, 331, 99, 329, 101, 327, 103, 325, 105, 2, 5, 316, 113, 315, 114, 1, 4, 309, 121, 307, 122, 307, 121, 307, 122, 306, 123, 305, 123, 306, 123, 305, 123, 306, 123, 305, 125, 304, 125, 303, 127, 302, 127, 302, 127, 300, 137, 289, 144, 51, 17, 215, 150, 45, 21, 212, 155, 39, 23, 210, 162, 31, 27, 207, 170, 21, 31, 206, 178, 11, 33, 205, 186, 1, 37, 204, 225, 203, 225, 203, 225, 203, 225, 203, 226, 202, 226, 202, 226, 202, 226, 202, 226, 202, 226, 202, 226, 203, 225, 203, 225, 204, 224, 205, 223, 205, 223, 205, 223, 205, 223, 205, 223, 205, 222, 206, 222, 206, 221, 207, 221, 207, 220, 208, 213, 215, 211, 217, 208, 221, 205, 223, 202, 227, 199, 229, 196, 233, 193, 235, 124, 2, 36, 5, 24, 238, 122, 8, 30, 12, 15, 241, 120, 15, 24, 20, 6, 244, 118, 20, 19, 272, 116, 26, 13, 274, 114, 31, 8, 276, 111, 37, 3, 278, 109, 321, 106, 322, 105, 323, 104, 324, 104, 324, 104, 324, 104, 324, 105, 323, 105, 323, 105, 323, 105, 323, 105, 323, 105, 323, 106, 323, 105, 323, 105, 324, 104, 291, 12, 22, 103, 288, 18, 20, 102, 286, 22, 19, 102, 283, 26, 18, 101, 281, 30, 17, 100, 280, 32, 18, 98, 279, 34, 20, 95, 278, 36, 23, 92, 276, 38, 24, 90, 275, 40, 26, 88, 273, 42, 29, 85, 272, 42, 45, 69, 271, 44, 47, 67, 269, 46, 48, 65, 269, 46, 51, 63, 267, 48, 52, 61, 267, 49, 54, 59, 266, 51, 69, 43, 265, 52, 69, 44, 262, 54, 69, 45, 260, 55, 70, 46, 257, 56, 70, 47, 255, 57, 71, 47, 253, 58, 72, 47, 251, 55, 95, 29, 249, 53, 106, 22, 247, 51, 117, 15, 245, 50, 126, 9, 243, 48, 132, 7, 241, 46, 137, 6, 239, 45, 142, 4, 237, 44, 385, 43, 385, 43, 385, 43, 386, 42, 386, 42, 387, 41, 387, 41, 388, 40, 389, 39, 389, 39, 390, 38, 391, 37, 392, 36, 393, 35, 395, 33, 396, 32, 396, 32, 396, 32, 396, 32, 395, 33, 395, 33, 395, 38, 390, 43, 385, 48, 380, 52, 376, 53, 375, 54, 374, 56, 372, 57, 371, 58, 370, 59, 369, 60, 368, 61, 98, 25, 244, 61, 96, 29, 242, 62, 84, 42, 240, 62, 81, 46, 239, 63, 78, 49, 237, 65, 75, 52, 234, 67, 73, 55, 232, 69, 71, 57, 230, 71, 69, 59, 228, 72, 68, 55, 2, 3, 227, 74, 66, 56, 230, 77, 64, 56, 231, 77, 63, 45, 242, 79, 61, 43, 244, 80, 26, 2, 31, 43, 245, 82, 24, 4, 28, 42, 247, 84, 23, 5, 26, 42, 248, 84, 22, 7, 24, 42, 248, 86, 20, 9, 22, 43, 248, 87, 18, 11, 20, 43, 249, 88, 16, 12, 19, 43, 250, 92, 12, 13, 17, 44, 250, 96, 7, 15, 16, 43, 251, 100, 2, 16, 15, 44, 251, 119, 13, 44, 252, 119, 13, 44, 252, 119, 12, 45, 252, 120, 11, 44, 253, 120, 11, 44, 253, 120, 10, 45, 253, 120, 10, 45, 253, 120, 10, 44, 254, 120, 10, 44, 254, 120, 10, 8, 2, 33, 255, 120, 8, 6, 7, 32, 255, 120, 8, 3, 10, 32, 255, 120, 7, 3, 11, 32, 255, 120, 6, 2, 13, 32, 255, 120, 5, 2, 14, 32, 255, 93, 4, 23, 4, 1, 15, 33, 255, 90, 8, 22, 17, 36, 255, 88, 12, 20, 16, 37, 255, 85, 18, 16, 16, 38, 255, 82, 23, 14, 14, 41, 254, 79, 29, 10, 14, 42, 254, 75, 56, 43, 254, 75, 55, 45, 253, 75, 54, 46, 253, 74, 54, 48, 252, 74, 53, 49, 252, 74, 53, 50, 251, 74, 53, 50, 251, 74, 53, 52, 249, 74, 53, 53, 249, 73, 53, 54, 249, 72, 53, 54, 249, 72, 53, 55, 249, 71, 53, 56, 249, 70, 53, 57, 249, 69, 53, 58, 249, 68, 53, 59, 249, 67, 53, 60, 249, 67, 52, 62, 248, 66, 52, 63, 249, 65, 52, 64, 249, 64, 52, 65, 248, 64, 53, 65, 249, 68, 49, 63, 251, 81, 37, 25, 5, 37, 246, 80, 42, 6, 17, 38, 245, 82, 63, 41, 242, 84, 61, 43, 240, 86, 59, 46, 237, 89, 56, 50, 233, 91, 55, 50, 232, 94, 52, 52, 230, 97, 14, 5, 30, 53, 229, 128, 18, 53, 229, 135, 11, 54, 228, 143, 3, 55, 228, 200, 228, 199, 229, 199, 229, 199, 230, 197, 231, 197, 232, 196, 232, 195, 234, 194, 234, 193, 236, 192, 236, 192, 237, 192, 237, 192, 236, 192, 237, 192, 237, 192, 237, 192, 237, 191, 238, 190, 239, 189, 238, 189, 238, 190, 238, 185, 2, 2, 239, 184, 4, 1, 238, 185, 243, 152, 3, 29, 244, 150, 7, 26, 244, 149, 10, 24, 245, 147, 14, 21, 246, 145, 18, 19, 246, 143, 22, 16, 247, 141, 26, 13, 248, 139, 30, 10, 249, 138, 33, 7, 250, 137, 36, 5, 250, 137, 38, 2, 251, 136, 292, 136, 292, 135, 293, 135, 293, 134, 294, 134, 294, 133, 295, 133, 295, 132, 296, 132, 296, 131, 297, 131, 297, 132, 296, 132, 296, 132, 296, 132, 296, 133, 295, 133, 295, 133, 295, 134, 294, 134, 294, 134, 294, 135, 293, 135, 293, 135, 293, 136, 292, 136, 292, 136, 292, 136, 292, 137, 70, 2, 219, 137, 67, 9, 215, 137, 63, 16, 212, 138, 59, 22, 209, 138, 56, 29, 31, 1, 173, 138, 53, 35, 29, 1, 172, 139, 48, 42, 27, 2, 171, 141, 41, 50, 25, 2, 169, 146, 31, 58, 23, 2, 168, 151, 22, 66, 19, 4, 166, 157, 11, 75, 16, 5, 165, 161, 2, 84, 11, 6, 164, 251, 8, 7, 163, 254, 4, 8, 162, 268, 161, 269, 159, 270, 58, 4, 30, 13, 54, 271, 56, 7, 12, 3, 9, 17, 54, 272, 53, 10, 8, 6, 4, 22, 53, 273, 52, 13, 4, 34, 53, 273, 50, 53, 53, 273, 49, 55, 52, 273, 47, 56, 53, 272, 47, 57, 53, 272, 1, 5, 39, 59, 53, 279, 37, 60, 52, 281, 34, 62, 50, 284, 32, 63, 48, 288, 28, 64, 48, 290, 26, 65, 47, 293, 17, 72, 45, 297, 4, 83, 43, 386, 41, 387, 40, 389, 39, 390, 37, 391, 36, 392, 36, 392, 35, 393, 34, 394, 33, 395, 33, 395, 32, 396, 32, 118, 3, 275, 31, 118, 6, 273, 30, 119, 8, 271, 30, 118, 11, 269, 30, 117, 14, 267, 29, 118, 15, 266, 29, 117, 18, 264, 29, 116, 21, 262, 28, 96, 44, 260, 28, 95, 47, 258, 28, 94, 50, 256, 28, 92, 54, 254, 28, 91, 64, 245, 27, 91, 80, 230, 27, 89, 83, 229, 27, 88, 85, 228, 26, 88, 88, 226, 26, 86, 90, 226, 26, 85, 89, 228, 26, 84, 88, 230, 26, 82, 88, 232, 26, 81, 88, 233, 26, 80, 87, 235, 26, 80, 86, 236, 26, 80, 84, 238, 26, 79, 84, 239, 26, 79, 82, 241, 26, 79, 81, 242, 25, 80, 79, 244, 24, 81, 78, 245, 23, 82, 76, 247, 23, 82, 75, 22, 1, 225, 22, 83, 73, 22, 3, 225, 21, 84, 71, 22, 5, 225, 21, 83, 72, 20, 6, 226, 20, 84, 72, 18, 7, 227, 20, 84, 73, 15, 8, 228, 20, 84, 74, 12, 9, 229, 19, 85, 74, 10, 10, 230, 19, 85, 75, 7, 11, 231, 19, 85, 76, 4, 13, 231, 18, 86, 77, 1, 14, 232, 18, 86, 91, 233, 18, 86, 91, 233, 18, 87, 90, 233, 18, 89, 88, 233, 18, 91, 86, 233, 18, 92, 85, 233, 18, 94, 84, 232, 18, 95, 83, 232, 18, 97, 81, 232, 18, 98, 80, 232, 18, 100, 78, 232, 18, 102, 76, 232, 18, 103, 75, 232, 18, 105, 73, 232, 18, 106, 72, 232, 19, 107, 25, 2, 43, 232, 19, 136, 41, 232, 20, 136, 41, 231, 20, 138, 39, 231, 21, 139, 37, 231, 21, 140, 36, 231, 22, 141, 34, 49, 4, 178, 22, 143, 32, 48, 9, 174, 23, 143, 31, 48, 14, 169, 24, 163, 10, 47, 16, 168, 24, 220, 17, 167, 24, 219, 19, 166, 24, 218, 21, 165, 25, 217, 22, 164, 25, 216, 25, 162, 25, 215, 27, 161, 25, 214, 30, 159, 25, 213, 34, 156, 24, 214, 38, 152, 24, 239, 19, 146, 23, 405, 22, 406, 21, 407, 21, 407, 20, 408, 20, 408, 19, 409, 18, 410, 18, 410, 18, 410, 17, 411, 17, 411, 17, 411, 16, 412, 16, 412, 16, 412, 16, 412, 16, 412, 16, 412, 16, 333, 1, 78, 16, 334, 1, 77, 16, 335, 1, 76, 16, 335, 2, 75, 16, 335, 3, 74, 16, 336, 3, 73, 16, 336, 4, 72, 16, 336, 6, 70, 16, 337, 7, 68, 16, 337, 8, 67, 16, 337, 10, 64, 17, 337, 12, 61, 18, 337, 14, 58, 19, 337, 15, 56, 20, 337, 18, 51, 22, 337, 21, 47, 23, 337, 27, 6, 6, 27, 25, 337, 46, 17, 28, 337, 50, 9, 32, 337, 91, 337, 91, 337, 91, 337, 92, 336, 92, 336, 92, 335, 93, 335, 94, 334, 94, 334, 95, 332, 96, 332, 97, 330, 98, 330, 99, 328, 101, 327, 101, 326, 103, 324, 81], "size": [428, 640]}, "area": 147779, "iscrowd": 1, "image_id": 12670, "bbox": [1, 0, 638, 427], "category_id": 1, "id": 900100012670}, {"segmentation": {"counts": [14269, 13, 620, 21, 618, 25, 613, 28, 611, 30, 609, 32, 607, 33, 607, 33, 607, 33, 607, 30, 610, 28, 612, 28, 612, 28, 613, 26, 615, 25, 617, 5, 1, 17, 623, 16, 624, 17, 614, 26, 613, 27, 612, 29, 610, 29, 611, 28, 612, 28, 612, 29, 13, 5, 593, 32, 1, 15, 592, 49, 591, 51, 590, 51, 590, 52, 590, 50, 596, 44, 598, 42, 602, 38, 602, 37, 603, 36, 605, 32, 609, 26, 616, 20, 624, 16, 624, 16, 624, 16, 625, 14, 627, 12, 630, 7, 16622, 2, 638, 3, 636, 5, 635, 6, 633, 9, 631, 15, 625, 20, 621, 12, 2, 6, 620, 11, 4, 6, 621, 7, 7, 5, 635, 3, 19190, 1, 634, 7, 633, 7, 633, 7, 633, 7, 633, 8, 633, 8, 632, 11, 629, 11, 629, 11, 630, 11, 629, 11, 629, 11, 629, 12, 628, 18, 622, 19, 622, 19, 621, 19, 621, 19, 621, 19, 621, 19, 622, 18, 622, 17, 623, 17, 623, 14, 626, 14, 614, 11, 1, 14, 613, 26, 613, 25, 615, 23, 616, 15, 625, 14, 626, 14, 626, 13, 627, 13, 627, 12, 628, 11, 630, 11, 629, 5, 638, 2, 65884, 7, 2, 5, 623, 18, 4, 6, 1, 4, 606, 35, 605, 35, 605, 35, 605, 35, 605, 35, 606, 3, 3, 21, 2, 3, 615, 5, 1, 3, 1, 3, 1263, 12, 626, 15, 624, 16, 624, 16, 620, 24, 5, 7, 603, 26, 3, 9, 2, 4, 3, 6, 586, 39, 1, 6, 1, 8, 585, 39, 1, 21, 579, 62, 578, 63, 577, 63, 578, 64, 577, 7, 1, 4, 1, 53, 598, 44, 596, 46, 594, 47, 593, 49, 592, 11, 2, 37, 590, 11, 2, 38, 591, 6, 5, 40, 600, 40, 600, 39, 602, 38, 602, 35, 607, 23, 622, 3, 1, 3, 5, 3, 109233], "size": [640, 480]}, "area": 3957, "iscrowd": 1, "image_id": 12639, "bbox": [22, 144, 287, 83], "category_id": 1, "id": 900100012639}, {"segmentation": {"counts": [94823, 6, 473, 8, 471, 10, 469, 11, 469, 11, 469, 11, 469, 11, 469, 11, 469, 11, 469, 11, 469, 11, 3, 1, 465, 11, 3, 1, 465, 11, 3, 1, 466, 10, 3, 1, 466, 10, 3, 1, 467, 9, 3, 1, 468, 8, 3, 1, 468, 8, 3, 1, 468, 8, 3, 1, 467, 9, 3, 1, 467, 9, 3, 1, 467, 9, 3, 1, 467, 9, 3, 1, 466, 10, 3, 1, 466, 10, 3, 1, 466, 10, 470, 10, 470, 10, 470, 10, 470, 10, 470, 10, 470, 10, 3, 1, 466, 10, 3, 1, 466, 10, 3, 1, 466, 10, 3, 1, 466, 10, 3, 1, 467, 9, 3, 1, 467, 9, 3, 1, 468, 8, 3, 1, 468, 8, 3, 1, 468, 8, 3, 1, 468, 8, 3, 1, 468, 8, 3, 1, 468, 8, 3, 1, 467, 9, 3, 1, 466, 10, 3, 1, 465, 11, 468, 12, 468, 12, 468, 12, 468, 12, 468, 12, 468, 12, 468, 12, 468, 12, 468, 13, 467, 13, 467, 14, 467, 14, 466, 15, 465, 16, 464, 16, 464, 16, 465, 15, 465, 15, 466, 14, 467, 13, 467, 13, 467, 13, 466, 13, 466, 13, 466, 15, 465, 15, 464, 16, 463, 17, 463, 17, 463, 17, 462, 7, 473, 7, 473, 7, 473, 7, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 472, 8, 471, 9, 470, 10, 469, 11, 469, 11, 469, 11, 469, 11, 469, 11, 469, 12, 468, 12, 468, 12, 468, 12, 468, 12, 468, 12, 468, 12, 469, 11, 470, 10, 470, 10, 470, 10, 470, 10, 470, 10, 12, 8, 450, 10, 11, 15, 444, 10, 11, 18, 441, 10, 11, 18, 442, 9, 11, 18, 443, 8, 11, 18, 445, 4, 13, 18, 462, 18, 462, 17, 442, 7, 14, 15, 442, 10, 13, 14, 442, 12, 12, 14, 441, 14, 11, 14, 440, 15, 11, 14, 440, 15, 11, 14, 440, 15, 11, 14, 439, 16, 11, 14, 439, 16, 11, 13, 439, 18, 10, 13, 439, 18, 10, 13, 439, 22, 1, 1, 4, 12, 440, 24, 4, 12, 440, 16, 17, 7, 440, 16, 17, 6, 441, 16, 17, 5, 442, 16, 17, 3, 444, 16, 464, 16, 464, 16, 464, 16, 464, 16, 464, 16, 464, 16, 465, 15, 466, 14, 468, 12, 471, 9, 471, 9, 471, 9, 471, 9, 471, 9, 471, 9, 471, 9, 471, 9, 471, 9, 470, 10, 470, 10, 470, 10, 470, 10, 470, 10, 469, 11, 469, 11, 468, 12, 467, 13, 467, 13, 467, 13, 467, 13, 467, 13, 467, 13, 467, 13, 468, 11, 470, 8, 474, 4, 11548, 2, 2, 2, 474, 2, 2, 2, 474, 2, 2, 2, 474, 2, 2, 2, 473, 3, 2, 2, 473, 3, 2, 2, 473, 3, 2, 2, 474, 2, 2, 2, 474, 2, 1, 3, 474, 2, 1, 3, 474, 2, 1, 3, 474, 2, 1, 3, 474, 2, 1, 3, 474, 2, 1, 3, 474, 2, 1, 3, 475, 1, 1, 3, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 475, 5, 472, 8, 475, 5, 475, 5, 476, 4, 476, 4, 476, 4, 476, 4, 476, 4, 476, 4, 476, 4, 476, 4, 476, 4, 476, 4, 476, 4, 476, 4, 475, 5, 475, 5, 475, 6, 474, 6, 474, 6, 474, 6, 474, 6, 475, 5, 475, 5, 475, 5, 477, 3, 478, 2, 479, 1, 479, 1, 85626], "size": [480, 640]}, "area": 3773, "iscrowd": 1, "image_id": 15517, "bbox": [197, 248, 264, 45], "category_id": 6, "id": 900600015517}], "categories": [{"supercategory": "person", "id": 1, "name": "person"}, {"supercategory": "vehicle", "id": 2, "name": "bicycle"}, {"supercategory": "vehicle", "id": 3, "name": "car"}, {"supercategory": "vehicle", "id": 4, "name": "motorcycle"}, {"supercategory": "vehicle", "id": 5, "name": "airplane"}, {"supercategory": "vehicle", "id": 6, "name": "bus"}, {"supercategory": "vehicle", "id": 7, "name": "train"}, {"supercategory": "vehicle", "id": 8, "name": "truck"}, {"supercategory": "vehicle", "id": 9, "name": "boat"}, {"supercategory": "outdoor", "id": 10, "name": "traffic light"}, {"supercategory": "outdoor", "id": 11, "name": "fire hydrant"}, {"supercategory": "outdoor", "id": 13, "name": "stop sign"}, {"supercategory": "outdoor", "id": 14, "name": "parking meter"}, {"supercategory": "outdoor", "id": 15, "name": "bench"}, {"supercategory": "animal", "id": 16, "name": "bird"}, {"supercategory": "animal", "id": 17, "name": "cat"}, {"supercategory": "animal", "id": 18, "name": "dog"}, {"supercategory": "animal", "id": 19, "name": "horse"}, {"supercategory": "animal", "id": 20, "name": "sheep"}, {"supercategory": "animal", "id": 21, "name": "cow"}, {"supercategory": "animal", "id": 22, "name": "elephant"}, {"supercategory": "animal", "id": 23, "name": "bear"}, {"supercategory": "animal", "id": 24, "name": "zebra"}, {"supercategory": "animal", "id": 25, "name": "giraffe"}, {"supercategory": "accessory", "id": 27, "name": "backpack"}, {"supercategory": "accessory", "id": 28, "name": "umbrella"}, {"supercategory": "accessory", "id": 31, "name": "handbag"}, {"supercategory": "accessory", "id": 32, "name": "tie"}, {"supercategory": "accessory", "id": 33, "name": "suitcase"}, {"supercategory": "sports", "id": 34, "name": "frisbee"}, {"supercategory": "sports", "id": 35, "name": "skis"}, {"supercategory": "sports", "id": 36, "name": "snowboard"}, {"supercategory": "sports", "id": 37, "name": "sports ball"}, {"supercategory": "sports", "id": 38, "name": "kite"}, {"supercategory": "sports", "id": 39, "name": "baseball bat"}, {"supercategory": "sports", "id": 40, "name": "baseball glove"}, {"supercategory": "sports", "id": 41, "name": "skateboard"}, {"supercategory": "sports", "id": 42, "name": "surfboard"}, {"supercategory": "sports", "id": 43, "name": "tennis racket"}, {"supercategory": "kitchen", "id": 44, "name": "bottle"}, {"supercategory": "kitchen", "id": 46, "name": "wine glass"}, {"supercategory": "kitchen", "id": 47, "name": "cup"}, {"supercategory": "kitchen", "id": 48, "name": "fork"}, {"supercategory": "kitchen", "id": 49, "name": "knife"}, {"supercategory": "kitchen", "id": 50, "name": "spoon"}, {"supercategory": "kitchen", "id": 51, "name": "bowl"}, {"supercategory": "food", "id": 52, "name": "banana"}, {"supercategory": "food", "id": 53, "name": "apple"}, {"supercategory": "food", "id": 54, "name": "sandwich"}, {"supercategory": "food", "id": 55, "name": "orange"}, {"supercategory": "food", "id": 56, "name": "broccoli"}, {"supercategory": "food", "id": 57, "name": "carrot"}, {"supercategory": "food", "id": 58, "name": "hot dog"}, {"supercategory": "food", "id": 59, "name": "pizza"}, {"supercategory": "food", "id": 60, "name": "donut"}, {"supercategory": "food", "id": 61, "name": "cake"}, {"supercategory": "furniture", "id": 62, "name": "chair"}, {"supercategory": "furniture", "id": 63, "name": "couch"}, {"supercategory": "furniture", "id": 64, "name": "potted plant"}, {"supercategory": "furniture", "id": 65, "name": "bed"}, {"supercategory": "furniture", "id": 67, "name": "dining table"}, {"supercategory": "furniture", "id": 70, "name": "toilet"}, {"supercategory": "electronic", "id": 72, "name": "tv"}, {"supercategory": "electronic", "id": 73, "name": "laptop"}, {"supercategory": "electronic", "id": 74, "name": "mouse"}, {"supercategory": "electronic", "id": 75, "name": "remote"}, {"supercategory": "electronic", "id": 76, "name": "keyboard"}, {"supercategory": "electronic", "id": 77, "name": "cell phone"}, {"supercategory": "appliance", "id": 78, "name": "microwave"}, {"supercategory": "appliance", "id": 79, "name": "oven"}, {"supercategory": "appliance", "id": 80, "name": "toaster"}, {"supercategory": "appliance", "id": 81, "name": "sink"}, {"supercategory": "appliance", "id": 82, "name": "refrigerator"}, {"supercategory": "indoor", "id": 84, "name": "book"}, {"supercategory": "indoor", "id": 85, "name": "clock"}, {"supercategory": "indoor", "id": 86, "name": "vase"}, {"supercategory": "indoor", "id": 87, "name": "scissors"}, {"supercategory": "indoor", "id": 88, "name": "teddy bear"}, {"supercategory": "indoor", "id": 89, "name": "hair drier"}, {"supercategory": "indoor", "id": 90, "name": "toothbrush"}]} \ No newline at end of file diff --git a/src/taming-transformers/data/coco_annotations_100/annotations/stuff_train2017.json b/src/taming-transformers/data/coco_annotations_100/annotations/stuff_train2017.json new file mode 100644 index 0000000000000000000000000000000000000000..30f4d50c2eee533ea1abdd48579b5735917a6787 --- /dev/null +++ b/src/taming-transformers/data/coco_annotations_100/annotations/stuff_train2017.json @@ -0,0 +1 @@ +{"info": {"description": "COCO 2017 Stuff Dataset", "url": "http://cocodataset.org", "version": "1.0", "year": 2017, "contributor": "H. Caesar, J. Uijlings, M. Maire, T.-Y. Lin, P. Dollar and V. Ferrari", "date_created": "2017-08-31 00:00:00.0"}, "images": [{"license": 4, "file_name": "000000010442.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010442.jpg", "height": 426, "width": 640, "date_captured": "2013-11-19 21:00:09", "flickr_url": "http://farm4.staticflickr.com/3188/2662753853_11d673a05d_z.jpg", "id": 10442}, {"license": 1, "file_name": "000000010142.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010142.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 22:51:01", "flickr_url": "http://farm6.staticflickr.com/5171/5408281064_c3f8d3e67b_z.jpg", "id": 10142}, {"license": 1, "file_name": "000000010393.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010393.jpg", "height": 480, "width": 640, "date_captured": "2013-11-15 00:40:34", "flickr_url": "http://farm3.staticflickr.com/2743/4192626071_8f54f4578e_z.jpg", "id": 10393}, {"license": 6, "file_name": "000000010077.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010077.jpg", "height": 259, "width": 640, "date_captured": "2013-11-18 21:04:46", "flickr_url": "http://farm3.staticflickr.com/2112/2273706470_b115ccda6b_z.jpg", "id": 10077}, {"license": 3, "file_name": "000000010123.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010123.jpg", "height": 427, "width": 640, "date_captured": "2013-11-21 05:12:31", "flickr_url": "http://farm5.staticflickr.com/4085/4948947491_1c37f153fc_z.jpg", "id": 10123}, {"license": 4, "file_name": "000000010432.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010432.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 19:52:48", "flickr_url": "http://farm6.staticflickr.com/5457/9690393462_ba33edf573_z.jpg", "id": 10432}, {"license": 1, "file_name": "000000010192.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010192.jpg", "height": 497, "width": 640, "date_captured": "2013-11-14 20:22:48", "flickr_url": "http://farm9.staticflickr.com/8196/8125509122_e8348e8d89_z.jpg", "id": 10192}, {"license": 3, "file_name": "000000010039.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010039.jpg", "height": 640, "width": 428, "date_captured": "2013-11-15 14:11:21", "flickr_url": "http://farm5.staticflickr.com/4098/4751788411_7b6a63cd92_z.jpg", "id": 10039}, {"license": 2, "file_name": "000000010023.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010023.jpg", "height": 427, "width": 640, "date_captured": "2013-11-20 09:15:13", "flickr_url": "http://farm4.staticflickr.com/3397/3201363151_ea35e217e3_z.jpg", "id": 10023}, {"license": 3, "file_name": "000000010428.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010428.jpg", "height": 640, "width": 427, "date_captured": "2013-11-14 23:33:26", "flickr_url": "http://farm3.staticflickr.com/2685/4078908984_668deecc62_z.jpg", "id": 10428}, {"license": 1, "file_name": "000000010400.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010400.jpg", "height": 640, "width": 427, "date_captured": "2013-11-24 15:06:26", "flickr_url": "http://farm9.staticflickr.com/8323/8134674673_d9489c39b9_z.jpg", "id": 10400}, {"license": 5, "file_name": "000000010249.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010249.jpg", "height": 640, "width": 426, "date_captured": "2013-11-16 21:44:34", "flickr_url": "http://farm9.staticflickr.com/8335/8402579163_8363ba0c7e_z.jpg", "id": 10249}, {"license": 1, "file_name": "000000010290.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010290.jpg", "height": 640, "width": 482, "date_captured": "2013-11-15 04:16:50", "flickr_url": "http://farm6.staticflickr.com/5048/5238196330_aeeaf4d917_z.jpg", "id": 10290}, {"license": 2, "file_name": "000000010205.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010205.jpg", "height": 426, "width": 640, "date_captured": "2013-11-21 22:57:22", "flickr_url": "http://farm2.staticflickr.com/1316/1243676572_54ae68d563_z.jpg", "id": 10205}, {"license": 2, "file_name": "000000010217.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010217.jpg", "height": 480, "width": 640, "date_captured": "2013-11-24 23:26:35", "flickr_url": "http://farm8.staticflickr.com/7284/8742930563_207f40cd15_z.jpg", "id": 10217}, {"license": 5, "file_name": "000000010263.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010263.jpg", "height": 375, "width": 500, "date_captured": "2013-11-22 01:41:21", "flickr_url": "http://farm3.staticflickr.com/2602/3909329409_085a7c9f41_z.jpg", "id": 10263}, {"license": 2, "file_name": "000000010040.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010040.jpg", "height": 480, "width": 640, "date_captured": "2013-11-16 21:57:07", "flickr_url": "http://farm9.staticflickr.com/8213/8264511585_0a5e6212c2_z.jpg", "id": 10040}, {"license": 4, "file_name": "000000010324.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010324.jpg", "height": 640, "width": 425, "date_captured": "2013-11-18 15:34:49", "flickr_url": "http://farm2.staticflickr.com/1059/5150417990_0d7762864e_z.jpg", "id": 10324}, {"license": 3, "file_name": "000000010008.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010008.jpg", "height": 427, "width": 640, "date_captured": "2013-11-20 20:26:10", "flickr_url": "http://farm7.staticflickr.com/6076/6088064448_2690929cbc_z.jpg", "id": 10008}, {"license": 2, "file_name": "000000010149.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010149.jpg", "height": 484, "width": 640, "date_captured": "2013-11-14 21:39:00", "flickr_url": "http://farm8.staticflickr.com/7235/7169336131_521711d854_z.jpg", "id": 10149}, {"license": 1, "file_name": "000000010463.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010463.jpg", "height": 446, "width": 640, "date_captured": "2013-11-15 12:19:52", "flickr_url": "http://farm8.staticflickr.com/7250/6910961220_961bf73cae_z.jpg", "id": 10463}, {"license": 3, "file_name": "000000010138.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010138.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 21:12:31", "flickr_url": "http://farm9.staticflickr.com/8098/8506152881_ecf43c76c3_z.jpg", "id": 10138}, {"license": 4, "file_name": "000000010014.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010014.jpg", "height": 426, "width": 640, "date_captured": "2013-11-16 15:41:53", "flickr_url": "http://farm9.staticflickr.com/8185/8145478875_28543f87be_z.jpg", "id": 10014}, {"license": 1, "file_name": "000000010219.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010219.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 12:18:01", "flickr_url": "http://farm1.staticflickr.com/116/293545180_9be1f625c9_z.jpg", "id": 10219}, {"license": 4, "file_name": "000000010114.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010114.jpg", "height": 640, "width": 480, "date_captured": "2013-11-14 18:59:23", "flickr_url": "http://farm9.staticflickr.com/8509/8528792276_824cb10b59_z.jpg", "id": 10114}, {"license": 3, "file_name": "000000010211.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010211.jpg", "height": 424, "width": 640, "date_captured": "2013-11-17 00:23:46", "flickr_url": "http://farm4.staticflickr.com/3032/2751379693_252d3c8e44_z.jpg", "id": 10211}, {"license": 2, "file_name": "000000010216.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010216.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 03:03:18", "flickr_url": "http://farm9.staticflickr.com/8436/7926050860_db828d8494_z.jpg", "id": 10216}, {"license": 1, "file_name": "000000010115.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010115.jpg", "height": 640, "width": 427, "date_captured": "2013-11-15 03:15:50", "flickr_url": "http://farm8.staticflickr.com/7200/6854804253_f7fa6e98b8_z.jpg", "id": 10115}, {"license": 4, "file_name": "000000010440.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010440.jpg", "height": 427, "width": 640, "date_captured": "2013-11-16 05:51:18", "flickr_url": "http://farm3.staticflickr.com/2865/9443592476_3c3ce98973_z.jpg", "id": 10440}, {"license": 1, "file_name": "000000010256.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010256.jpg", "height": 360, "width": 640, "date_captured": "2013-11-16 22:33:29", "flickr_url": "http://farm9.staticflickr.com/8480/8214519939_ee9d1486b6_z.jpg", "id": 10256}, {"license": 2, "file_name": "000000010056.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010056.jpg", "height": 482, "width": 640, "date_captured": "2013-11-17 00:42:05", "flickr_url": "http://farm9.staticflickr.com/8472/8138318480_cf2cd6fa5a_z.jpg", "id": 10056}, {"license": 2, "file_name": "000000010107.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010107.jpg", "height": 640, "width": 480, "date_captured": "2013-11-18 14:17:26", "flickr_url": "http://farm5.staticflickr.com/4039/4471901818_ac8353d2e5_z.jpg", "id": 10107}, {"license": 3, "file_name": "000000010449.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010449.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 02:08:04", "flickr_url": "http://farm4.staticflickr.com/3732/9431336544_e6345159b7_z.jpg", "id": 10449}, {"license": 3, "file_name": "000000010012.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010012.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 21:21:03", "flickr_url": "http://farm2.staticflickr.com/1039/1374745468_a4cb23032f_z.jpg", "id": 10012}, {"license": 1, "file_name": "000000010395.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010395.jpg", "height": 476, "width": 500, "date_captured": "2013-11-18 11:37:47", "flickr_url": "http://farm5.staticflickr.com/4005/4468891744_00bb759e17_z.jpg", "id": 10395}, {"license": 3, "file_name": "000000010104.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010104.jpg", "height": 457, "width": 640, "date_captured": "2013-11-15 21:47:19", "flickr_url": "http://farm7.staticflickr.com/6237/6282305534_1b1fb1f8a1_z.jpg", "id": 10104}, {"license": 1, "file_name": "000000010386.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010386.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 01:56:20", "flickr_url": "http://farm4.staticflickr.com/3279/2982566887_93e5d316a9_z.jpg", "id": 10386}, {"license": 1, "file_name": "000000010046.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010046.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 11:50:10", "flickr_url": "http://farm8.staticflickr.com/7363/9675286251_78248282b6_z.jpg", "id": 10046}, {"license": 1, "file_name": "000000010430.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010430.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 07:44:21", "flickr_url": "http://farm4.staticflickr.com/3678/9477571775_99039714f4_z.jpg", "id": 10430}, {"license": 1, "file_name": "000000010166.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010166.jpg", "height": 351, "width": 470, "date_captured": "2013-11-19 21:19:23", "flickr_url": "http://farm4.staticflickr.com/3248/3015319163_b0a61a7c77_z.jpg", "id": 10166}, {"license": 2, "file_name": "000000010275.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010275.jpg", "height": 427, "width": 640, "date_captured": "2013-11-18 09:32:30", "flickr_url": "http://farm9.staticflickr.com/8177/8029583325_02172d3a6f_z.jpg", "id": 10275}, {"license": 3, "file_name": "000000010321.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010321.jpg", "height": 640, "width": 480, "date_captured": "2013-11-19 03:39:00", "flickr_url": "http://farm9.staticflickr.com/8330/8374378941_80fda27ffa_z.jpg", "id": 10321}, {"license": 2, "file_name": "000000010176.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010176.jpg", "height": 480, "width": 640, "date_captured": "2013-11-22 00:19:33", "flickr_url": "http://farm1.staticflickr.com/164/335653813_61b9a128e2_z.jpg", "id": 10176}, {"license": 1, "file_name": "000000010037.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010037.jpg", "height": 426, "width": 640, "date_captured": "2013-11-19 18:06:00", "flickr_url": "http://farm3.staticflickr.com/2602/3741919994_d9d0343f82_z.jpg", "id": 10037}, {"license": 4, "file_name": "000000010313.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010313.jpg", "height": 640, "width": 427, "date_captured": "2013-11-20 07:30:18", "flickr_url": "http://farm3.staticflickr.com/2595/3691544165_5f8f5d92de_z.jpg", "id": 10313}, {"license": 3, "file_name": "000000010421.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010421.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 11:47:35", "flickr_url": "http://farm4.staticflickr.com/3286/2704773968_ed600e2d11_z.jpg", "id": 10421}, {"license": 2, "file_name": "000000010161.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010161.jpg", "height": 427, "width": 640, "date_captured": "2013-11-25 13:54:08", "flickr_url": "http://farm9.staticflickr.com/8385/8583133395_109ca97781_z.jpg", "id": 10161}, {"license": 4, "file_name": "000000010405.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010405.jpg", "height": 453, "width": 640, "date_captured": "2013-11-18 01:11:58", "flickr_url": "http://farm6.staticflickr.com/5068/5694693358_890d562b38_z.jpg", "id": 10405}, {"license": 4, "file_name": "000000010444.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010444.jpg", "height": 500, "width": 375, "date_captured": "2013-11-20 16:02:25", "flickr_url": "http://farm3.staticflickr.com/2205/2342560721_8a9545fd1a_z.jpg", "id": 10444}, {"license": 3, "file_name": "000000010084.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010084.jpg", "height": 424, "width": 640, "date_captured": "2013-11-17 07:31:31", "flickr_url": "http://farm8.staticflickr.com/7428/9977327403_ec9211b17d_z.jpg", "id": 10084}, {"license": 3, "file_name": "000000010179.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010179.jpg", "height": 502, "width": 640, "date_captured": "2013-11-23 01:23:34", "flickr_url": "http://farm3.staticflickr.com/2753/5765793056_50a8694618_z.jpg", "id": 10179}, {"license": 4, "file_name": "000000010125.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010125.jpg", "height": 436, "width": 640, "date_captured": "2013-11-24 00:31:28", "flickr_url": "http://farm9.staticflickr.com/8051/8100436361_e70cea2ba0_z.jpg", "id": 10125}, {"license": 2, "file_name": "000000010082.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010082.jpg", "height": 425, "width": 640, "date_captured": "2013-11-24 02:46:01", "flickr_url": "http://farm6.staticflickr.com/5103/5660629949_220d6cb304_z.jpg", "id": 10082}, {"license": 3, "file_name": "000000010318.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010318.jpg", "height": 400, "width": 640, "date_captured": "2013-11-16 21:21:19", "flickr_url": "http://farm4.staticflickr.com/3730/9164843685_66a5f3834b_z.jpg", "id": 10318}, {"license": 3, "file_name": "000000010130.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010130.jpg", "height": 427, "width": 640, "date_captured": "2013-11-24 09:51:10", "flickr_url": "http://farm8.staticflickr.com/7055/6802904874_5313b371f7_z.jpg", "id": 10130}, {"license": 1, "file_name": "000000010403.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010403.jpg", "height": 416, "width": 640, "date_captured": "2013-11-19 18:10:23", "flickr_url": "http://farm5.staticflickr.com/4120/5416067648_a01a1d2872_z.jpg", "id": 10403}, {"license": 6, "file_name": "000000010041.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010041.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 21:28:20", "flickr_url": "http://farm8.staticflickr.com/7157/6791989693_84a9ec0060_z.jpg", "id": 10041}, {"license": 3, "file_name": "000000010343.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010343.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 08:20:12", "flickr_url": "http://farm4.staticflickr.com/3768/9317101988_c25e7800c3_z.jpg", "id": 10343}, {"license": 3, "file_name": "000000010388.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010388.jpg", "height": 426, "width": 640, "date_captured": "2013-11-14 21:36:08", "flickr_url": "http://farm8.staticflickr.com/7376/9612632350_fe5f9d2e02_z.jpg", "id": 10388}, {"license": 2, "file_name": "000000010414.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010414.jpg", "height": 420, "width": 500, "date_captured": "2013-11-19 20:53:38", "flickr_url": "http://farm1.staticflickr.com/68/187106012_c60041a5fa_z.jpg", "id": 10414}, {"license": 2, "file_name": "000000010265.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010265.jpg", "height": 427, "width": 640, "date_captured": "2013-11-23 04:52:56", "flickr_url": "http://farm2.staticflickr.com/1153/1340250930_630cae707b_z.jpg", "id": 10265}, {"license": 3, "file_name": "000000010222.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010222.jpg", "height": 333, "width": 500, "date_captured": "2013-11-16 17:51:33", "flickr_url": "http://farm1.staticflickr.com/145/406189235_49af59f7aa_z.jpg", "id": 10222}, {"license": 1, "file_name": "000000010241.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010241.jpg", "height": 480, "width": 640, "date_captured": "2013-11-16 16:15:07", "flickr_url": "http://farm5.staticflickr.com/4034/4618195712_406d349d8c_z.jpg", "id": 10241}, {"license": 4, "file_name": "000000010239.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010239.jpg", "height": 360, "width": 640, "date_captured": "2013-11-16 22:41:38", "flickr_url": "http://farm9.staticflickr.com/8527/8640248164_346015db59_z.jpg", "id": 10239}, {"license": 6, "file_name": "000000010369.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010369.jpg", "height": 424, "width": 640, "date_captured": "2013-11-18 16:30:42", "flickr_url": "http://farm6.staticflickr.com/5210/5279959659_617eb40ec2_z.jpg", "id": 10369}, {"license": 3, "file_name": "000000010136.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010136.jpg", "height": 640, "width": 316, "date_captured": "2013-11-24 12:57:39", "flickr_url": "http://farm1.staticflickr.com/48/143700223_df3abd2533_z.jpg", "id": 10136}, {"license": 3, "file_name": "000000010445.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010445.jpg", "height": 349, "width": 500, "date_captured": "2013-11-19 17:56:31", "flickr_url": "http://farm2.staticflickr.com/1133/973971082_0524b5a07c_z.jpg", "id": 10445}, {"license": 3, "file_name": "000000010015.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010015.jpg", "height": 633, "width": 640, "date_captured": "2013-11-19 18:15:10", "flickr_url": "http://farm4.staticflickr.com/3422/3393927411_26ab4342e9_z.jpg", "id": 10015}, {"license": 1, "file_name": "000000010434.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010434.jpg", "height": 426, "width": 640, "date_captured": "2013-11-15 11:54:59", "flickr_url": "http://farm1.staticflickr.com/8/7845077_9cbe3bd89d_z.jpg", "id": 10434}, {"license": 2, "file_name": "000000010097.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010097.jpg", "height": 360, "width": 640, "date_captured": "2013-11-14 20:26:22", "flickr_url": "http://farm5.staticflickr.com/4018/4255629097_9a832c6dae_z.jpg", "id": 10097}, {"license": 2, "file_name": "000000010058.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010058.jpg", "height": 426, "width": 640, "date_captured": "2013-11-17 19:16:50", "flickr_url": "http://farm9.staticflickr.com/8349/8197861619_93df634c02_z.jpg", "id": 10058}, {"license": 3, "file_name": "000000010108.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010108.jpg", "height": 453, "width": 640, "date_captured": "2013-11-17 02:20:45", "flickr_url": "http://farm4.staticflickr.com/3360/3444049112_fc8b6acf6e_z.jpg", "id": 10108}, {"license": 3, "file_name": "000000010232.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010232.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 15:38:00", "flickr_url": "http://farm4.staticflickr.com/3675/9453111678_c2cb8874d9_z.jpg", "id": 10232}, {"license": 4, "file_name": "000000010069.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010069.jpg", "height": 640, "width": 427, "date_captured": "2013-11-16 16:09:44", "flickr_url": "http://farm8.staticflickr.com/7229/7167720922_420895b285_z.jpg", "id": 10069}, {"license": 3, "file_name": "000000010024.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010024.jpg", "height": 640, "width": 480, "date_captured": "2013-11-19 20:21:14", "flickr_url": "http://farm9.staticflickr.com/8528/8463731510_53f79a717b_z.jpg", "id": 10024}, {"license": 3, "file_name": "000000010327.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010327.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 14:53:56", "flickr_url": "http://farm5.staticflickr.com/4025/4461943910_f88106188f_z.jpg", "id": 10327}, {"license": 1, "file_name": "000000010337.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010337.jpg", "height": 640, "width": 480, "date_captured": "2013-11-15 06:08:56", "flickr_url": "http://farm8.staticflickr.com/7064/6801977878_94d6095195_z.jpg", "id": 10337}, {"license": 1, "file_name": "000000010248.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010248.jpg", "height": 427, "width": 640, "date_captured": "2013-11-18 17:00:29", "flickr_url": "http://farm7.staticflickr.com/6013/6015945247_2d03377c4c_z.jpg", "id": 10248}, {"license": 2, "file_name": "000000010276.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010276.jpg", "height": 426, "width": 640, "date_captured": "2013-11-18 19:59:57", "flickr_url": "http://farm4.staticflickr.com/3746/9895771396_45554292ba_z.jpg", "id": 10276}, {"license": 6, "file_name": "000000010196.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010196.jpg", "height": 443, "width": 640, "date_captured": "2013-11-19 19:58:23", "flickr_url": "http://farm9.staticflickr.com/8505/8405340354_90e8d1757d_z.jpg", "id": 10196}, {"license": 2, "file_name": "000000010145.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010145.jpg", "height": 427, "width": 640, "date_captured": "2013-11-22 00:21:49", "flickr_url": "http://farm5.staticflickr.com/4118/4740387609_ce9bb3f14a_z.jpg", "id": 10145}, {"license": 1, "file_name": "000000010407.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010407.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 07:19:18", "flickr_url": "http://farm3.staticflickr.com/2037/2071235362_a8f850624b_z.jpg", "id": 10407}, {"license": 3, "file_name": "000000010243.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010243.jpg", "height": 500, "width": 375, "date_captured": "2013-11-20 13:39:40", "flickr_url": "http://farm3.staticflickr.com/2212/2416407264_ca4e59c12e_z.jpg", "id": 10243}, {"license": 4, "file_name": "000000010230.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010230.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 19:40:06", "flickr_url": "http://farm5.staticflickr.com/4094/4788218715_e64dbe9bb7_z.jpg", "id": 10230}, {"license": 6, "file_name": "000000010245.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010245.jpg", "height": 427, "width": 640, "date_captured": "2013-11-21 01:16:08", "flickr_url": "http://farm8.staticflickr.com/7253/7459060240_5e24c744f6_z.jpg", "id": 10245}, {"license": 1, "file_name": "000000010319.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010319.jpg", "height": 427, "width": 640, "date_captured": "2013-11-22 22:31:20", "flickr_url": "http://farm3.staticflickr.com/2521/4128276778_bb74ec1296_z.jpg", "id": 10319}, {"license": 4, "file_name": "000000010229.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010229.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 20:53:03", "flickr_url": "http://farm6.staticflickr.com/5312/6915913274_7d268c51fd_z.jpg", "id": 10229}, {"license": 4, "file_name": "000000010073.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010073.jpg", "height": 469, "width": 640, "date_captured": "2013-11-21 05:37:17", "flickr_url": "http://farm5.staticflickr.com/4038/4663314869_680cc1b4c9_z.jpg", "id": 10073}, {"license": 1, "file_name": "000000010342.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010342.jpg", "height": 640, "width": 478, "date_captured": "2013-11-16 14:34:19", "flickr_url": "http://farm9.staticflickr.com/8436/7984397533_7a232d7e44_z.jpg", "id": 10342}, {"license": 3, "file_name": "000000010244.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010244.jpg", "height": 640, "width": 475, "date_captured": "2013-11-16 16:56:12", "flickr_url": "http://farm9.staticflickr.com/8453/8055076139_cd811120a4_z.jpg", "id": 10244}, {"license": 5, "file_name": "000000010005.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010005.jpg", "height": 400, "width": 500, "date_captured": "2013-11-18 11:09:03", "flickr_url": "http://farm3.staticflickr.com/2558/4197396435_45d477dc72_z.jpg", "id": 10005}, {"license": 5, "file_name": "000000010083.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010083.jpg", "height": 480, "width": 640, "date_captured": "2013-11-22 00:56:30", "flickr_url": "http://farm3.staticflickr.com/2033/2033435444_1b91e9988c_z.jpg", "id": 10083}, {"license": 5, "file_name": "000000010420.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010420.jpg", "height": 375, "width": 500, "date_captured": "2013-11-17 06:42:55", "flickr_url": "http://farm2.staticflickr.com/1213/1165637087_cf1cc6a168_z.jpg", "id": 10420}, {"license": 2, "file_name": "000000010281.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010281.jpg", "height": 427, "width": 640, "date_captured": "2013-11-22 14:50:06", "flickr_url": "http://farm9.staticflickr.com/8337/8244811136_bd49523ae1_z.jpg", "id": 10281}, {"license": 3, "file_name": "000000010175.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010175.jpg", "height": 480, "width": 640, "date_captured": "2013-11-14 20:17:42", "flickr_url": "http://farm9.staticflickr.com/8103/8549598429_22f161d92e_z.jpg", "id": 10175}, {"license": 5, "file_name": "000000010303.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010303.jpg", "height": 468, "width": 640, "date_captured": "2013-11-19 21:21:59", "flickr_url": "http://farm3.staticflickr.com/2509/4198054407_db61df57cc_z.jpg", "id": 10303}, {"license": 6, "file_name": "000000010346.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010346.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 20:02:54", "flickr_url": "http://farm4.staticflickr.com/3498/3456906266_7257a4a061_z.jpg", "id": 10346}, {"license": 4, "file_name": "000000010309.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010309.jpg", "height": 500, "width": 333, "date_captured": "2013-11-19 21:48:30", "flickr_url": "http://farm1.staticflickr.com/71/191429048_ad837c4f93_z.jpg", "id": 10309}, {"license": 5, "file_name": "000000010094.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010094.jpg", "height": 500, "width": 500, "date_captured": "2013-11-22 20:54:17", "flickr_url": "http://farm3.staticflickr.com/2289/2461849747_8a952aac05_z.jpg", "id": 10094}, {"license": 3, "file_name": "000000010358.jpg", "coco_url": "http://images.cocodataset.org/train2017/000000010358.jpg", "height": 640, "width": 478, "date_captured": "2013-11-18 15:08:37", "flickr_url": "http://farm7.staticflickr.com/6188/6135058772_4d7a2c78c7_z.jpg", "id": 10358}], "licenses": [{"url": "http://creativecommons.org/licenses/by-nc-sa/2.0/", "id": 1, "name": "Attribution-NonCommercial-ShareAlike License"}, {"url": "http://creativecommons.org/licenses/by-nc/2.0/", "id": 2, "name": "Attribution-NonCommercial License"}, {"url": "http://creativecommons.org/licenses/by-nc-nd/2.0/", "id": 3, "name": "Attribution-NonCommercial-NoDerivs License"}, {"url": "http://creativecommons.org/licenses/by/2.0/", "id": 4, "name": "Attribution License"}, {"url": "http://creativecommons.org/licenses/by-sa/2.0/", "id": 5, "name": "Attribution-ShareAlike License"}, {"url": "http://creativecommons.org/licenses/by-nd/2.0/", "id": 6, "name": "Attribution-NoDerivs License"}, {"url": "http://flickr.com/commons/usage/", "id": 7, "name": "No known copyright restrictions"}, {"url": "http://www.usa.gov/copyright.shtml", "id": 8, "name": "United States Government Work"}], "categories": [{"supercategory": "textile", "id": 92, "name": "banner"}, {"supercategory": "textile", "id": 93, "name": "blanket"}, {"supercategory": "plant", "id": 94, "name": "branch"}, {"supercategory": "building", "id": 95, "name": "bridge"}, {"supercategory": "building", "id": 96, "name": "building-other"}, {"supercategory": "plant", "id": 97, "name": "bush"}, {"supercategory": "furniture-stuff", "id": 98, "name": "cabinet"}, {"supercategory": "structural", "id": 99, "name": "cage"}, {"supercategory": "raw-material", "id": 100, "name": "cardboard"}, {"supercategory": "floor", "id": 101, "name": "carpet"}, {"supercategory": "ceiling", "id": 102, "name": "ceiling-other"}, {"supercategory": "ceiling", "id": 103, "name": "ceiling-tile"}, {"supercategory": "textile", "id": 104, "name": "cloth"}, {"supercategory": "textile", "id": 105, "name": "clothes"}, {"supercategory": "sky", "id": 106, "name": "clouds"}, {"supercategory": "furniture-stuff", "id": 107, "name": "counter"}, {"supercategory": "furniture-stuff", "id": 108, "name": "cupboard"}, {"supercategory": "textile", "id": 109, "name": "curtain"}, {"supercategory": "furniture-stuff", "id": 110, "name": "desk-stuff"}, {"supercategory": "ground", "id": 111, "name": "dirt"}, {"supercategory": "furniture-stuff", "id": 112, "name": "door-stuff"}, {"supercategory": "structural", "id": 113, "name": "fence"}, {"supercategory": "floor", "id": 114, "name": "floor-marble"}, {"supercategory": "floor", "id": 115, "name": "floor-other"}, {"supercategory": "floor", "id": 116, "name": "floor-stone"}, {"supercategory": "floor", "id": 117, "name": "floor-tile"}, {"supercategory": "floor", "id": 118, "name": "floor-wood"}, {"supercategory": "plant", "id": 119, "name": "flower"}, {"supercategory": "water", "id": 120, "name": "fog"}, {"supercategory": "food-stuff", "id": 121, "name": "food-other"}, {"supercategory": "food-stuff", "id": 122, "name": "fruit"}, {"supercategory": "furniture-stuff", "id": 123, "name": "furniture-other"}, {"supercategory": "plant", "id": 124, "name": "grass"}, {"supercategory": "ground", "id": 125, "name": "gravel"}, {"supercategory": "ground", "id": 126, "name": "ground-other"}, {"supercategory": "solid", "id": 127, "name": "hill"}, {"supercategory": "building", "id": 128, "name": "house"}, {"supercategory": "plant", "id": 129, "name": "leaves"}, {"supercategory": "furniture-stuff", "id": 130, "name": "light"}, {"supercategory": "textile", "id": 131, "name": "mat"}, {"supercategory": "raw-material", "id": 132, "name": "metal"}, {"supercategory": "furniture-stuff", "id": 133, "name": "mirror-stuff"}, {"supercategory": "plant", "id": 134, "name": "moss"}, {"supercategory": "solid", "id": 135, "name": "mountain"}, {"supercategory": "ground", "id": 136, "name": "mud"}, {"supercategory": "textile", "id": 137, "name": "napkin"}, {"supercategory": "structural", "id": 138, "name": "net"}, {"supercategory": "raw-material", "id": 139, "name": "paper"}, {"supercategory": "ground", "id": 140, "name": "pavement"}, {"supercategory": "textile", "id": 141, "name": "pillow"}, {"supercategory": "plant", "id": 142, "name": "plant-other"}, {"supercategory": "raw-material", "id": 143, "name": "plastic"}, {"supercategory": "ground", "id": 144, "name": "platform"}, {"supercategory": "ground", "id": 145, "name": "playingfield"}, {"supercategory": "structural", "id": 146, "name": "railing"}, {"supercategory": "ground", "id": 147, "name": "railroad"}, {"supercategory": "water", "id": 148, "name": "river"}, {"supercategory": "ground", "id": 149, "name": "road"}, {"supercategory": "solid", "id": 150, "name": "rock"}, {"supercategory": "building", "id": 151, "name": "roof"}, {"supercategory": "textile", "id": 152, "name": "rug"}, {"supercategory": "food-stuff", "id": 153, "name": "salad"}, {"supercategory": "ground", "id": 154, "name": "sand"}, {"supercategory": "water", "id": 155, "name": "sea"}, {"supercategory": "furniture-stuff", "id": 156, "name": "shelf"}, {"supercategory": "sky", "id": 157, "name": "sky-other"}, {"supercategory": "building", "id": 158, "name": "skyscraper"}, {"supercategory": "ground", "id": 159, "name": "snow"}, {"supercategory": "solid", "id": 160, "name": "solid-other"}, {"supercategory": "furniture-stuff", "id": 161, "name": "stairs"}, {"supercategory": "solid", "id": 162, "name": "stone"}, {"supercategory": "plant", "id": 163, "name": "straw"}, {"supercategory": "structural", "id": 164, "name": "structural-other"}, {"supercategory": "furniture-stuff", "id": 165, "name": "table"}, {"supercategory": "building", "id": 166, "name": "tent"}, {"supercategory": "textile", "id": 167, "name": "textile-other"}, {"supercategory": "textile", "id": 168, "name": "towel"}, {"supercategory": "plant", "id": 169, "name": "tree"}, {"supercategory": "food-stuff", "id": 170, "name": "vegetable"}, {"supercategory": "wall", "id": 171, "name": "wall-brick"}, {"supercategory": "wall", "id": 172, "name": "wall-concrete"}, {"supercategory": "wall", "id": 173, "name": "wall-other"}, {"supercategory": "wall", "id": 174, "name": "wall-panel"}, {"supercategory": "wall", "id": 175, "name": "wall-stone"}, {"supercategory": "wall", "id": 176, "name": "wall-tile"}, {"supercategory": "wall", "id": 177, "name": "wall-wood"}, {"supercategory": "water", "id": 178, "name": "water-other"}, {"supercategory": "water", "id": 179, "name": "waterdrops"}, {"supercategory": "window", "id": 180, "name": "window-blind"}, {"supercategory": "window", "id": 181, "name": "window-other"}, {"supercategory": "solid", "id": 182, "name": "wood"}, {"supercategory": "other", "id": 183, "name": "other"}], "annotations": [{"segmentation": {"counts": "P[Y22^\\DBd;>]D^Of;<[DEi;;YDCg;>500O1000000GoC1Se9@\\Fb0c9]O]Fe0a9ZO`Fh0^9WOcFB[OX1P:UOdFC_OY1j9SOPGk0o8UOSGj0m8TOVGj0j8UOZGh0e8YO]Ge0c8ZOaG1fN4k9HcGNfN:h9EoG;S:00010O000000001O01O0001O000FCaD=_;F_D9a;J\\D7c;;000010O0000000000N1N5N5K4Ja\\7MhcHMla1OR^N1N3N2N3L1120N2M3K6LojZ2", "size": [400, 500]}, "area": 18332.0, "iscrowd": 0, "image_id": 10005, "bbox": [0.0, 85.0, 308.0, 315.0], "category_id": 124, "id": 10012151}, {"segmentation": {"counts": "doQ21^<100O00100O010O10O1000O100000OO2O1N2O1N101N2002M1O1O001O1OTD6FNP;LVEh0j:WOREn0n:ROnDR1Q;700O10000O10000O100O10000O10000O10000O100O10000O10000O100O10000O10000O10000O100O10000O10000O100O10000O10000O10000O100O10000O10000aLlMaLU2]3mMcLS2Z3PNeLQ2[3oMeLQ2^3mMaLS2Z3jM_I3V3T2`3lM`LT2`3lM`LT2`3lM_LU2a3lM^LT2b3lM^LT2b3lM]LU2`3iM[I0U3W2\\3lM`INR3W2^3iMbI0P3W2]3hMeI1n2W2]3fMgI3k2X2g3iMYLW2e3lMZLT2e3mMZLT2d3nM\\LR2c3oM\\LR2b3QN]Lo1a3SN_Lm1a3SN^Ln1b2kMUK7Y2n1c2jMSK9Z2m1d2iMRK;X2m1f2hMRK;X2m1c2kMUK8W2n1b2lMVK7X2m1b2lMVK8W2l1b2mMWK7V2m1c2lMVK8W2l1c2lMYK5T2o1d2kMcKKh1[2c2mMeKHg1[2e2lMfKGe1]2h1cMgKL6>c3T2`0cMeKM5?e3Q2:_MjK61L1b0j3m1:_MjK8NM0a0n3k1:`MhK\\1m3T1;QOEo0;QOEo0;RObLaNi1JbMc2S4RO`LgN[ODV21kMc2T4RO]LhN^OBV21kMc2U4RO^LeN\\OFT21mMb2U4SO]LdN\\OGT21nMa2U4TO]LbN\\OIR21PN`2U4TO]L`N^OLn11RN_2U4SO]LZNI0c14RN_2U4ROTO`NgL^2V4QOROcNfL]2X4oNPM_Nc06UN\\2X4oNmLcNd03WN[2X4nNmLeNd02WN[2X4mNiL`NmN031f18YNZ2X4nNeL`N[OO^1:YNZ2Y4oN_L\\NH1U1;[NY2Y4PORM]N7<^NW2Y4QORM[N6>_NV2Z4QOPM\\N5>`NV2\\4nNnLaN4U3o2XNiLiN6P3P3WNfLoN7l2S3TNdLSO8j2U3QNbLXO7h2W3oM`L^O6d2[3mM]LB5c2^3jM[LG5`2`3hM[L2G[2n3bM\\L9YO\\2[4ZM\\L;YO[2[4ZM\\L;YO[2[4ZM\\L;YO[2\\4YM[L0001O0000001O00001O13L4M1N001O1O00O1O12N01M101O100O1L400M3000O11OO100000000O100000000M31O2N0000000000O100000000000000000000O1", "size": [400, 500]}, "area": 56847.0, "iscrowd": 0, "image_id": 10005, "bbox": [0.0, 0.0, 500.0, 159.0], "category_id": 169, "id": 10012154}, {"segmentation": {"counts": "X7m0c;d1\\N^1bN5J100000000O1000000O100000000O1000000O100000001N1000000O100000000O100000000O1000000O10000000000O1000000000000O10001O000000000O100000000000000O1000000000000O100000000000000O1000000000000SI^Kl5b4nIdKQ6\\4kIiKU6W4aISLR3YO0d4hLYLW3VOOa4jLYLV3YOJb4PMULV3\\OCc4WMRLT3^O_Od4]MnKS3BXOe4eMiKR3ESOf4kMeKQ3HoNf4PNbKQ3JkNf4TN`KP3MhNe4XN^Ko20fNc4[N]Kn24bNa4_N\\Ko28[N^4fNZKn2=VN[4lNXKm2`0TNY4oNWKm2b0QNX4ROVKl2d0PNW4TOUKk2g0nMT4XOUKj2j0jMR4\\OTKi2m0hMP4_OSKi2P1eMm3BSKh2T1bMj3FRKh2V1_Mi3IQKg2Z1\\Mf3MPKg2]1XMd30PKg2a7YM_Hf2b7ZM^Hf2b7ZM^He2c7[M]He2c7[M]Hd2d7\\M\\Hd2k2[Mk01ZLd2k2[Mk00[Le2j2[Mk00[Le2j2[Mk00[Le2j2[Mk00[Le2j2[Mk00[Le2j2[Mj01\\Ld2i2\\Mk0O]Le2h2\\Mk0O]Le2h2\\Mk0O]Ld2i2]Mj0O]Ld2i2]Mj0O]Ld2i2]Mj0O]Ld2i2]Mo1c2QN]Mo1c2QN]Mo1c2QN]Mo1b2RN^Mn1b2RN^Mn1a2RN`Mn1a2QN_Mo1b2PN^M?NUMe2[2]M?0UMd2[2\\M?2^LLOf2T3\\M?1]LO0e2S3[M?2\\L11c2S3ZM?2SLLO7;b2S3YM?3TLKM9=`2S3YM?2ULLL8>b2Q3XM?2WLLM6NR23QMN2W39SM_OZ22SMO2^3LTMe0]OZ21TM01c3DRMm0ZOY21VM00n4a0QKY20WM1On4a0QKX21XM0Oo4`0PKY20XM2On4`0PKa1NgM2920n4`0oJ_11gMO:40m4`0oJ^14eML<61k4`0oJ]17cMI?71j4`0oJ\\19cMF?:2h4`0oJZO2U19[NEe092i4>SL6YObNCg0:3g4?bKbN1Y1_OmN1JNk0:4e4a0YKjN?e0ZOAN>91g4\\1hL]O^NXOj4_1aL[OeNWOj4a1[L[OjNUOk4c1mKCWOkNm4j4SKgJ1Bm4f5QK]Jk5c5TJYJR6e5nIXJV6h5:N2O001N2O001N101N2O00JaJ\\I]5d6dJ]I[5a6fJ`IZ5_6gJbIW5]6kJeIS5Z6nJhIP5W6QKkIl4T6UKoIi4P6XKRJe4m5]KTJb4k5_KWJ_4h5bKZJ[4e5fK^JX4a5iKaJU4]5mKeJP4[5QLgJm3X5SLkJ>VOP2P6bMmJ7Bl1`5nMPK0XO^2g5cMiI\\OX1=lNR3T6UMgI_OZ1m3n4dLiIBV1j3Q5dLhIEV1e3R5gLhIFT1c3S5hLiIHQ1`3V5ZMhJe2X5iLiIN:^O4k3h5cMnIfN:e3i5QNWJo1h5lLjI=>g2g5SNYJl1h5mLjI>?d2f5VNZJj1e5oLlI>?b2f5bLkI20k0>a2f5ZNZJe1g5QMkI`0?^2e5RMmI`0>^2d5`LmI;0h0?\\2e5SMmIa0>\\2d5_LmI?0g0`0Z2c5^LmIb01g0>X2d5_LmIc01;OYO?Z3d5]LmIf01;3TO;^3e5TMmI:6QO8`3d5VMnI:j0_2W5WMPJ;h0]2W5ZMQJ9h0]2V5ZMRJ:h0\\2T5\\MTJ8i0Z2S5_MSJ8j0Y2Q5aMUJ6j0Y2P5bMVJ6i0W2P5dMWJ6i0V2o4eMXJ5j0T2m4iMXJ3l0T2j4kMZJ0m0U2i4kMZJ3j0Q2m4\\OhJ[MEX3c5QMYJT2:dMJW3d5N\\J1e5O[J1X5QMfJONe24;W5^MeJW259W5`0hJ@W5`MeJY246X5aMdJS25WMNU3Y5:jJcLMR3X5bMeJR24\\MOo2Y5cMdJY10hN2_O1m2X5dMeJX10gN1A3l2W5cMeJZ11nN4T2V5eMeJ11=0G7U2S5fMeJ13;NG9V2S5fMcJ179JI:W2R5eMcJ25=KC=Y2Q5dMbJ30b00]O?X2Q5eM`J30d00[O`0Y2S5`M^J[2`05U5YM_J?K5`0I1Y2X5SMaJe0F;a0D4W2c5gMhI=c0E2W2c5dN]JTO1W2c5bN_J[OJS2g5fMgI:j08]Oh1R6eMgI:m09ZOf1R6gMgIO1Lm0j0WOd1T6fMjIK3Ni0j3Z5\\LoIHO0j0k3X5]LPJF01h0l3W5]LRJFT1m3j4\\LeKb3]4\\LdKd3]4ZLdKe0TNk1M^M[61fKc0XNi1HcM[6OfKc0\\N\\OCW20kM\\6MgKb0\\N_OAV21lM[6LiKg0UN[OGT21nMc8b0eG\\OGS22nMd8b0cG]OHQ22PNc8b0aG^OLo10QNb8a0\\GKNb15RN`8Y3aGgL_8W1[Gd08TN\\8V1`Gd05VN[8S1dGe02WNZ8R1\\GmN8j12WNY8P1`GoNN31e19YNY8k0aG^OL]1;ZNZ8f0\\GI0T1<\\NZ8c0WG43k0=^NZ8[1YG6>_NZ8Z1YG5>aNX8V1`G7T9ERG8o8FUG8k8FXG9h8F[G8e8F`G7a8GbG6_8HeG4]8MQH_OT8b0mGYOV8h0jGXOV8h0jGXOV8h0jGXOV8h0jGXOV8g0kGYOi6NkHi0_8YOdFDm0P1b8YOgFCh0P1e8[OhG`0a8TOUF1\\1g0X:K6K4L4N3O01O01O100O100O100O01M2N2N3M01O3L4MST]1", "size": [400, 500]}, "area": 64590.0, "iscrowd": 0, "image_id": 10005, "bbox": [0.0, 83.0, 384.0, 317.0], "category_id": 183, "id": 10012155}, {"segmentation": {"counts": "kd]27W:n2oEmLh9[30000000001O=C>B>B>B6J00000000000000000000000000000000000000000000O100000000000000000000000000PKUH`4\\8O1jL`G_1d8\\NbG`1P9lMWGJHY1Z9aNPG5OQ1S:mNnES1S:kNnEU1U:fNmEZ1R;00000001O0gNYDn0h;QOXDo0h;nNXDL071d0h;XOWDM162c0g;XOXDNO553L5i;DWDOO48ON8i;EQD2:O16e;IPD1l02V;MoC0W=0Sm[20PfcM5[:MZE3`1NdN8a:3PFKEGEe0[:[OmE?TGCh8b0WG^Oh8c0WG^Oh8h0PGbM1f1o8k0PGUOi8ZNWG^4a8:_Oa0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000RLPHa2f^f1", "size": [427, 640]}, "area": 19514.0, "iscrowd": 0, "image_id": 10008, "bbox": [186.0, 0.0, 324.0, 172.0], "category_id": 109, "id": 10012156}, {"segmentation": {"counts": "ogZ1X4S900000000000000000000000000000000000000000000000000000000000000000000O10000001O000000000000001O000000O1O1O1O1O1N2N2O1N2N2N2N2O1NC]LVGa3k8`LhFO8b3Q9bLlF`3U9`LhFa3Y971O010O2N1O2O0O2O1O001N101O001O0O2O001O001N2O001O001N@QMgFo2Z9`01O1O1O1N2O1O1O1O1N2O1O1O1O1N2O1O1O1O1N2O1O001ROgEiNZ:m0eEZN8h0T:l0QFROQ:n0oEQOR:n0oEQOR:o0oEoNR:0^E^O0n0?CT:0mE0ONV:2kEO0NV:2kE0OMW:3kEONMX:4jEONLY:5iENOKZ:6hEONKZ:6hEONKZ:6iENNKZ:I^GORZW5", "size": [427, 640]}, "area": 15804.0, "iscrowd": 0, "image_id": 10008, "bbox": [102.0, 170.0, 137.0, 188.0], "category_id": 110, "id": 10012157}, {"segmentation": {"counts": "Uhl0b0i<0000000000000000000000000000000^Ob000000000000000000000000000000000nNR100000000000000000000000000000000000000000000000000000000000000000000O10000001O000000000000001O000000O1OiNQE4n:ZOfEe0Y:oNTFQ1S;01O00001O00001O00001O00001O00001O0000001O00001O00000000000000000000001O00000000000000000000001O00000000000000000000001O00000000000000000000001O00000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000O1L4L4L4L4L4L4L4G9F:F:J6M3h2XM0000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "size": [427, 640]}, "area": 12266.0, "iscrowd": 0, "image_id": 10008, "bbox": [68.0, 335.0, 572.0, 92.0], "category_id": 115, "id": 10012158}, {"segmentation": {"counts": "Q9Z4Q900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000^Ob000000000000000000000000000000000^Ob00000000000000000000000000000000mQP7", "size": [427, 640]}, "area": 13158.0, "iscrowd": 0, "image_id": 10008, "bbox": [0.0, 289.0, 102.0, 138.0], "category_id": 156, "id": 10012159}, {"segmentation": {"counts": "R^Y8;P=[1eN[1eN5]H", "size": [427, 640]}, "area": 264.0, "iscrowd": 0, "image_id": 10008, "bbox": [636.0, 238.0, 4.0, 102.0], "category_id": 167, "id": 10012160}, {"segmentation": {"counts": "0X4S9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_Oa000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O10000001O`0@000000001O00_OZG]Lf8c3a000O100O10000O100O10000O100O10000O100O10000O100O10000O1000000000000000000001O0000@YF\\MlB>A?B>A?B4L0O100O1UKZMQOf2CD=g0BXO?h0@XOa0h0_OWOb0i0]OVOe0Q1TOnNm0`1dN`N]1n1UNQNl1]2eMcM\\2k2VMSMm2Z3dLfL]3c61O1O1O1N2O1O1O1O1N2O2N1O1O1N2O1O1O1O1N2O1O1O2N1O1N2O1O1O1O1N2O1O1O1O2M20000000000000000000001O0000000000000O1TOSKWIP5h6RKUIP5j6RKRIQ5l6RKPIQ5o6QKlHS5S7nJiHV5V7`0O1O1O1O001N2O1N2O1N2O1O1O100O1O1O100000000O100000000000000O0100000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000001O00000O1000000000001O000000006J5K3M3M4L2N1O1]J_HZ5b7cJaH\\5i7iJRHm4W8O2N1O1O1O2N1O1O1O1O2N1N2O3M2L5I6J6J7I6J7H7Hf0VO>B=D=I7I\\N`4dLc00000O10000O1000000O1000000000000000000000000O10000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O100000O100000000000000000000W1iN\\1dN[1eN[1eNdC", "size": [427, 640]}, "area": 88635.0, "iscrowd": 0, "image_id": 10008, "bbox": [144.0, 108.0, 496.0, 314.0], "category_id": 183, "id": 10012164}, {"segmentation": {"counts": "S^]51o>0M301O000VALh>7YAIc>:00000002N00O1000000L]AKc>4^ALb>4^ALb>4^ALb>3_AMa>3_AMa>3_AMa>3`AL`>4`AKa>58MO11O0O2OoV42mhK2ZAL_>6`AK_>=N00001OO1001O0000O1000000001OO100002NO100O1001O1O00O10000001OO1O11O000000001OO11O00N2001O00O11O00O10000001O1O0000003MO1N20000000000000000001OO1O1000000O1001O000000000000001O000bAA[>a011O000000O1001O00N21ON2000000000000O1001OO1001OO1001O0000O10000001O001O00O12NO1000000000000000000000000001OO1001OO1000000000000001OO10000001OO100001OO1000000001OO11OO11OO1001O00000000000000000000000000000000001OO100000000000000000000000000001O000000O11O00000000000000000000", "size": [480, 640]}, "area": 4226.0, "iscrowd": 0, "image_id": 10012, "bbox": [370.0, 0.0, 270.0, 20.0], "category_id": 99, "id": 10012165}, {"segmentation": {"counts": "n0R>n0000000000000000000000000000000000000000000000001OO100001O00O10000001O00000000000000001O00O1001OO11O00O11O00000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000001O00001O1O00O100O10000000000000000000000001O00O100001O0000000000000000000000000000000000001OO11O00000000N2000UBmNi=U1000O11O00O100N2001OO1000000O11O1OO10000001O00000000001O002NN2O11O000000O13MN20VBlNh=V10002N00L40000O11O1O00N21O1OO1000000000000O11O00000000O1001O00O11O00000000000000001OO11O1OO1001O003MO1N200000000001O00O100O1001O0000O11OO11OO11O00001O00001OO100O1O11O0000000000000000001OO10000001O1O00O12N2N00M30000O1000000MZBlNf=T1ZBmNe=S1[BlNf=T130000O1001O0000O100000000000000N21OO100001O1ON26J2N3M00000000001O000000000000001O0000000000000000000000001OO1001O0000000000000000000000O11O00001O000000000000O11O0000000000O11O00000000OhHkNg0U1jN[OU1f0WLkNeNm0T58UL]OkMg0P6LTLCbMf0Z6GRLJYMf0d6@QLU2o3kMPLV2P4jMnKY2Q4gMnKZ2R4fMlK\\2T4dMjK^2V4bMiK`2V4`MjK`2V4`MiKa2W4_MiKa2W4_MhKc2W4^MgKc2Y4]MgKc2Y4]MdJbNAS4j5\\M[JkNJn3f5WMXJTO0j3d5RM\\JVOMo3a5kLaJXOMS4\\5eLgJZOJX4Y5^LmJ[OI]4T5XLSK\\OGb4Q5RLXK^OEe4n4mK]K_OCi4l4hKaK@Am4j4cKeKA@P5T1PJQ2_1[MB^OT5o0RJT2X1_MC\\OX5j0QJZ2T1`MDZOg6V3eI`MEXOg6X3dI`Mf7`2ZH`Mf7`2ZH`Mf7`2ZH`Mf7`2ZH`Mf7`2ZH`Mf7`2ZH`Mf7`2[H_Me7a2ZHaMf7^2[HaMe7_2ZHbMf7^2[HaMe7_2[HaMe7_2ZHcMn3WOSNV3oMcMR4\\OfMQ3XNeMS4AZMk2cNhMS4BQMf2lNlMR4DiL`2UOPNQ4FaLZ2^OTNQ4HWLT2IWNo3KoKn11\\NP4KeKj1<^Nn3N]Kd1e0bNn30SK^1o0fNm32kJX1X1gNP46_JS1a1gNS4a3mK`LV4\\3jKdLY4Y3gKgL]4U3cKlL_4Q3aKoLc4m2]KSMf4j2ZKWMi4e2WK[Ml4b2SK_MQ5]2oJdMS5Y2mJgMV5V2jJjM[5Q2eJPNa5i1_JWNh5b1XJ^NU2lMN_3nMeNS2RN0R3mMlNR2YNMi2QNnNR2`NFb2XNoNP2fNB[2^NoNP2lN]OT2cNQOn1ROYOm1hNROo1XOROf1POQOn1_OlN`1VOROl1EiNX1[OSOl1KcNR1ASOk12^Nk0FUOk17YNc0LVOk1=SN=3UOi1e0nM69VOh1i0jM1>VOg1n0hMKa0WOg1Q1eMHd0ZOc1S1dMDi0^OZ1V1fM_OP1AQ1W1hM[OW1Dg0X1lMWO]1G>l4BhK@VLQOV8_1YLbNnKKi7c1U5000000001O001O00O11O0000O11OO1000000O100001OO1001O00O100001OO10000001OO11O001OO11OO10000001OO11O0000O1001O00000000000000000000000000000000001O0000O11O00O11O001ON21O0000O12NO1", "size": [480, 640]}, "area": 261093.0, "iscrowd": 0, "image_id": 10012, "bbox": [0.0, 30.0, 640.0, 450.0], "category_id": 145, "id": 10012166}, {"segmentation": {"counts": "0n0R>0000000000000000000000000000000000000000000000001OO100001O00O10000001O00000000000000001O00O1001OO11O00O11O00000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000001O00001O1O00O100O10000000000000000000000001O00O100001O0000000000000000000000000000000000001OO11O00000000N2000UBmNi=U1000O11O00O100N2001OO1000000O11O1OO10000001O00000000001O002NN2O11O000000O13MN20VBlNh=V10002N00L40000O11O1O00N21O1OO1000000000000O11O00000000O1001O00O11O00000000000000001OO11O1OO1001O003MO1N200000000001O00O100O1001O0000O11OO11OO11O00001O00001OO100O1O11O0000000000000000001OO10000001O1O00O12N2N00M30000O1000000MZBlNf=T1ZBmNe=S1[BlNf=T130000O1001O0000O10000oNUBm0k=SOUBm0o=01O000ROPBj0U>WOkAf0W>O1000011OON17J2N3M0LPOXBP1g=QOYBo0g=QOYBo0g=QOYBo0f=ROZBo0e=QO[Bo0e=QO[Bo0e=ROZBn0f=ROYBo0g=5JkNaBU1_=jNbBV1^=kNaBV1^=jNaBW1_=jN`BV1`=500000000000000000dNbBV1^=hNdB4Lo0f=PO[Bn0n=N01O01OO1001O0000O10000000O20N100011NO100O1001O1N11N10000001OO0020O0000000O2OO20O00N2001O00O11O00O10000001O10O000012MO1N20000000000000000001OO1O1000000O1001O01OO11OO11O00O2O000oNTBn0n=11O0001OO02O01O00N21ON2000000000000O0101OO1001OO1010O0000O1000O110O001O0O012ON1000000000000000000000000001OO2O010N10O11O0000O11OO2OO1000O101OO2OO1010N10O1000010N011OO110N0110O01OO11OO10000001OO11O0000O1001O0001OO100000000000000000000000000010O000O11N11N11O001ON21O0000O12NO]O", "size": [480, 640]}, "area": 22444.0, "iscrowd": 0, "image_id": 10012, "bbox": [0.0, 0.0, 640.0, 56.0], "category_id": 172, "id": 10012167}, {"segmentation": {"counts": "gdc6;V>?]MBVFm0g9E]Eg0b:_OTEf0j:AkDe0S;f1N1N2O1N3M2O101N100O1O2O0mNoKVGS4`8WL_Gn3T8[LjGj3R8XLkGo3n7SLQHS4i7oKTHX4f7iKYH]4a7dK]Hb4^7`K`He4[7\\KcHi4Y7XKeHm4W7TKhHP5T1PJ^4Q1\\JT5o0RJa4k0^JX5j0PJh4i0\\Jf6d5[IZJf6f5Z101O000000000001O000000001YL^JnMb5V2cJaMa5^2eJYM_5g2gJoL]5P3iJfL\\5Y3jJ^LZ5b3lJTLX5k3nJlKV5T4oJcKU5\\4RKZKR5f4SKPKQ5P5VKfJj4^5Z23N3L3M4M2M4L3N3L3M4M2M3M5L6I7I\\LcHLW73oHNj61]IJb66dIE\\6:kI_OU6`0RJZOo5e0WJVOh5i0_JQOa5o0fJjN[5U1kJeNU5Z1RKaNm4_1YK[Nh4c1`KVN`4j1fKPNZ4P2lKkMT4S2QLiMo3W2TLfMl3Y2YLcMk3W2[LcMm3S2ZLgMo3o1YLjMP4m1WLlMY4b1Z5POWB_OPoY1", "size": [480, 640]}, "area": 19210.0, "iscrowd": 0, "image_id": 10012, "bbox": [451.0, 77.0, 100.0, 300.0], "category_id": 183, "id": 10012168}, {"segmentation": {"counts": "RXY33W=3M3M4L5K1[C^O`l7LTH9g7GXH>e7A[Hd0_7\\OcHg0Y7YOfHh0Z7XOfHh0Z7WOfHc0lMUO]99hH?mMXO[99gH;gM_O7M[98gH=gM^Oj96bH8eMBi98_H7hMAi99_H3jMCe9=cHAeM0520Oc9`0kH@cM0b9a0SI^Om6d0l2001O0O01O12M010O2OOgN", "size": [426, 640]}, "area": 1871.0, "iscrowd": 0, "image_id": 10014, "bbox": [253.0, 0.0, 387.0, 170.0], "category_id": 96, "id": 10012169}, {"segmentation": {"counts": "0a1i;00O1000000M300000000002N00000000002N2N1OO10000000000O10000000000O11O1O001O000000000000O10000000000001O1O001O00000000000000000000000000O1000000000000000000000000O1O1O1O1000000001O000000001O00000000O1O100O1001O0000001O00001O001OO10000000000001O00001O00001O000000O1O100O1O100000000001O00001O001O00O1O1O100O1O10000001O0000000000001O00000000O100O11O00001O0000000000000000000000O1001O000000000000001O0000000000O1O10000001O000000001O000000001OO100O10000000000001O00O11O00000000;E4L2NO100001O0000000000000000000YEmMZ:`23N2N3M4K1nMkDm1Z;ON28H2N0O4M4L4L3hNPDP1YgDA[;X<0O10000O100O100O10000O100O100002N2N1O001O001O1O001M2O2N2N00001O001OndU7", "size": [426, 640]}, "area": 4012.0, "iscrowd": 0, "image_id": 10014, "bbox": [0.0, 337.0, 87.0, 89.0], "category_id": 115, "id": 10012173}, {"segmentation": {"counts": "]XU33ha42^kK0N>lN^OgDe0S;^OlDf0h:CWEK_O99BZ:>nEEB<3Af:6dEME>LAd:X:BiE94ML3b8AkH6dN87LI0c8JeH2fN:8MJIa86cHJlN:3>b8_OXGO=S2_8cN\\G^1b8e1\\Od0[Oe02N2N2O1N2O1N2O1N2aKQH^OLn3T8_L[H7Bh0L7X8iN[H0Mg0J9P8oN[HI2o0G3n7VOWIf0nNOm7[OWIKbN8>=j7@iI0aN;h7EgI0eN5f7KfICgM7S17a70UKKm43VKJl46XGDi36P58PKFR58RKDP5`0kJ@V5=m30UCCi<`0O1O00001O00001OO1N2L4K5K[QX4", "size": [426, 640]}, "area": 3830.0, "iscrowd": 0, "image_id": 10014, "bbox": [243.0, 0.0, 70.0, 202.0], "category_id": 132, "id": 10012174}, {"segmentation": {"counts": "^6_4`9[Oh0WOh0YO9F4L4M3L4M3L4M3L4M3L4L4M3L4L5L3L4M3L3Odd\\33_nbLMY<`0\\CAak79TGYOP1?k7=gF@IE0N022NQ1b0\\8?cFc1\\9V1N2O1O1O1O1N2O1O1O1O1N2O1nNR11O1O1O[2eM1O1O001O1O001O1O1O001O1O001O1O001O1O0000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O10000000000000000000000VN^MlHb2o6hMlHX2R7nMjHR2U7TNfHl1X7WNfHj1X7ZNbHj1\\7YN^Hl1_7YN[Hk1`7\\NZHh1\\7cN^Hb1X7]2H8OnIQIk5X7O000000000000001O0000000000000000000000000000000000001O000000", "size": [426, 640]}, "area": 33519.0, "iscrowd": 0, "image_id": 10014, "bbox": [296.0, 226.0, 344.0, 200.0], "category_id": 149, "id": 10012176}, {"segmentation": {"counts": "\\hf71Y=4L5K4L5K4L5K4L5L3L5K4M4K4L5L3L1O002M1N2O0O2O2OO10O0mElMR9U2kFmMU9R2gFgM_O7i9R2iFgM^O8h9T2fFeMB7j9Q2eFhMA7k9Q2aFjMC7k9Q2SFeM0520O8k9V2UFcM096GU9e2dFfM2H\\9\\35102M3LO1120MO2M4OO1nM", "size": [426, 640]}, "area": 3511.0, "iscrowd": 0, "image_id": 10014, "bbox": [593.0, 60.0, 47.0, 131.0], "category_id": 169, "id": 10012177}, {"segmentation": {"counts": "a1b32YM:WOQ8_3gGYMf8^2[GlL1d0e8^2^GkLNg0d8]2hGaMY8_2gGaMV8b2jG]MW8c2jG\\MV8d2jGoL]O4j8m2mGjLZO9i8m2QHRMP8n2QHQMQ8m2PHQMQ8o2oGQMQ8n2QHQMo7o2V1O102M3N1N00100O100O10O10000000000O11O1O001O00000001O000O101O1O001O1O01000O010O001O1O001cFoL_8R3^GPMb8P3\\GSMc8n2ZGUMe8k2YGXMf8i2WGYMi8h2TG[Mk8e2SG^Ml8c2PG`Mo8b2nFaMQ9]3O1O001O1O001O1O001O1O1N1O2N2N101O1O1O010OMaG\\K^8`48O1O2MQHdKT7[4n0O1O1O0XOXGoLh8P3]GlLd8S3_GjLa8W3`GeLc8Z3h0N1O10001O00001O001OO1000001O000010O00010O01O0^FfLU9Z3iFiLU9W3kFjLT9W3jFlLT9U3iFmLV9c30010O0001O1O1O1O101N10001N101O0O01O1O10O01O10000001O0000000001O10O01O001O0O2O0O3O1N2N2O1N3M00000000001OO1MoFmKQ9o37N101O2M2O1O1O1N2O1O1N3M2N2N2O1000O2N100000010O000000100O1bFiLg8Y3PGQMm8\\3:O2OO01O010O1I7N2N200O2NlFdL\\8\\3h0020O00001O0;F3LjERMR:l2501O1O2N1O1O1000000O100001OgM_Ej1P;2OL400N1YOlDYOS;e0PEZOP;>YEAg:;]EEc:c0UE\\Ol:=\\ECb:>^EBb:2nDFa06a:2TEE9:c:0UEF94g:6PEG87c:3UED:8b:4TEF:3a:7e1K^Pi4", "size": [426, 640]}, "area": 30075.0, "iscrowd": 0, "image_id": 10014, "bbox": [0.0, 45.0, 272.0, 176.0], "category_id": 173, "id": 10012178}, {"segmentation": {"counts": "S52k0:U;HjDo0U:ROUE0e0g1\\9]NlENg0\\2e8oMZG[2]8fMbG]2[8cMdGa2Y8_MgGd2V8]MhGg2U8]MZGYO:]3Y8^MeGf2X8[MgGh2V8XMiGl2T8UMkGn2Q8TMnGo2o7Y1L4MhKSHV3i7Z1L3L4L4M2M3N1N3N2N2N2N2N1O2N2N2N2N1O2N2mJTId3n6YLTIf3n6WLTIh3n6ULTIk3l6SLVIl3l6QLVIn3l6oKUIQ4m6lKTIU4m6hKSIZ4m6dKTI\\4n6aKSI`4n6]KRIe4o6XKRIh4P7UKPIm4Q7PKPIQ5P7mJQIS5b72O0O2O1N101jHhJX6Y5eIiJZ6X5cIlJ\\6U5aInJ]6S5aIPKm4GoKZ5QOQK`6Q5]IRKb6n4\\IUKc6l4ZIVKe6l4XIWKh6f51O1NXLcIc0^6XOdIk0\\6TObIo0]6PObIR1_6m20O01000O10O01N2O0O2N2N2O0O2NNdIYIZ6d652N2VJYIP5h6WKWIb4k6l02N2N2NZOTJSJj5d0oIU4fJa4MmJ]5;PKg4i1VKg0LjMm4a1UKb0IVNQ5Y1VKV2j4kMTKV2l4kMRKV2n4kMPKV2P5jMoJW2Q5jMnJV2R5kMlJW2S5P3000000001O00001O00001O001YHiJY7W5fHkJY7V5fHlJX7T5gHoJX7Q5eHRKZ7Q5bHPK^7]51O100O1O1O1O1O1O100O10000O10000O1000000O1000000000000000000001O1O001O001O001O002N2N2N3M2N2O2M3M4L3M2N2N2NZOYIkJe6Q5eIjJZ6T5jIlJ:An4b5lJlJ3CQ5`5oJlJNES5]5SKnJFGW5Z5WKkJ^O1Z5S5[KcJG5n4W5[LeJe3Y5W2O1O1N2N2N2N2O100001O0000000cIPK`4Q5]KmJg4S5WKmJk4S5SKmJo4S5nJnJCO]4T5mKmJHO[4U5QKlJ60`0OY4V5jJWK5Dj0OW4X5bJ\\K1^O3OU10T4d5QK`Jm0LR4c5TK]Jl00P4c5SK\\Jo01n3b5SK]JP12l3`5ZL^JeN2Q5`5[L^JdN1Q5`5Z2I7N2N]HjJV7V5hHkJY7T5fHkJN0U7T5lHlJ31n6S5j0O11O00001]MkJoLU5eMkJT55SMQ5hMjJT59QMm4gMoJY3W1VMROg1g4V1aLlLmNj1a4o3oJmKP5m0oJ[2P5VKoJQ20W1=_Mc4[ORKk1Me1V1ULj3>RKf1NP2R6W3H8H8H8G2O0001O2N1mInJl3T5jKPKZ4R5_KPKd4]5kJdJX5`5cJ^J`5e5TJTJF5Z6U5dIVK8CG0`6U5dIZK1F^6o4cI]KJCf6P5`IfKb6[4^IbKd6^4\\I`Kf6b4YI[Ki6f4XIUKk6m4VInJl6T5TIhJn6h52N2N2N2N2N2N2N2O1N2O1N2O1N2OAiJmHV5R7UKeHi4[7b00001O00001I6I7I8G8I7O2NSOcJQJ[5P6hJPJU5Q6mJnIQ5S6QKlIl4U6S11O0O2O2N110O01H8I7I72M3N2N2N3M2M3N2N2N3L3N2N2ZNf1N3`MlGgMLc1Z8=mGTNI_1\\85kGcNIW1M>1eNT5X1nJeN0o0M_1h46ZK\\NN^1^4?eKRNMa1\\4>fKQNNc1[4T;\\OPEd0Q;VOUEi0m:QOWEo0c;O00001O001O00001O001O00cI", "size": [426, 640]}, "area": 156542.0, "iscrowd": 0, "image_id": 10014, "bbox": [0.0, 47.0, 640.0, 375.0], "category_id": 183, "id": 10012179}, {"segmentation": {"counts": "bg\\:4cc01b\\OOVc0Ni\\O7Qc0Jm\\O=Rc051N1000O2O000O10O11O0O10000O10001O0O101O1N102V]OSOdb0l0\\]OUOONbb0S1^]OmN20\\b0U1b]OmN^b0X1OO0101OO0101N10000O10000O100O1000000O10000O101O1OO010000O2O000O1000O0KT^O_Nla0]1:L3M4L4L4K4M4L4L4M3J3Ncf>", "size": [633, 640]}, "area": 2767.0, "iscrowd": 0, "image_id": 10015, "bbox": [538.0, 138.0, 78.0, 62.0], "category_id": 92, "id": 10012180}, {"segmentation": {"counts": "c0d0j=0mF0S90mF0S90mF0S90mF0S90mF0S90mF0S90mF0S90mF0S90mF0S90mF1Y50TI2O[OPM3R1c0lNYO00011O0U31Z;d0b4000000000000O2O01N1001OO10000000000000O1000000000000000000000000000000000000000000000000000T@`0lLkN17MI20m=e0VEX1i:hN_EU1\\:kNdEV1\\:iNeEV1Z:kNgET1Y:lNhES1X:nNhEQ1X:oNiEQ1V:nNlEP1U:POlEo0T:QOlEo0T:QOmEn0S:ROnEn0Q:ROPFm0P:SOQFm0n9SOSFk0n9UOSFk0l9WOSFg0n9YOSFf0m9YOTFg0l9XOVFc0n9]OSF?Q:UOZFi0h9WOYFb0m9^OSFb0m9^OTF`0m9@SF`0m9@SF`0m9@TF?l9ATF?l9ATF?l9ATF?l9AUF>k9BUF>Y1ZOi28nK=X1^Oi25PLAi0XIjNW7=@i0YIlNV7;@i0YInNW79_Oj0XInNZ78^Oj0VIoN]77\\Oj0WInN`77XOl0VIlNe79TOj0VImNh79ROj0UIlNk7:QOi0RImNo79POi0kHdNA9f8:nNi0gHUO]82lNh0dHYOa8OlNg0[H@k8IkNd1W1\\NjNb1W1^NjN_1X1aNiN\\1Y1dNhNX1[1hNfNU1\\1kNdNU1\\1mNcNQ1^1mNeF\\On7f1]1nNfNP1[1POeNP1[1POfNn0[1ROfNm0Z1SOhNi0Y1XOjNa0Z1_OhN9^1GeN0a10aNId17_NAf1?\\N\\Og1d0g80000000001O00O11O000000O1000000000000000000000000000000000000000000000000000000000000000000000O10000F:00000000000000000000000000000000000000:F00001O0000000000000000000000000000O100F:00000000000000000000000000000000000000:F001O000000000000000000000000000000O100F:00000000000000000000000000000000000_@Gb;9]DIb;a0TD_Ol;a0TD_Ol;b0TD\\Om;d0RD]On;c0nC[OfL2\\?c0nC\\OeL1]?c0mC^OeLO^?c0mCBS<>mCBS<>mCBS<>\\BE\\OKY>`0XBL[OD]>`0UB0^O^O^>b0QB4@ZO_>b0oA7AWO`>b0nA:ASOa>c0mA?^OnNe>c0lAh0SOcNC2^?c0kAP1lN\\NK1^?c0kAR1iN\\NMO_?c0jAS1jN[NMO_?c0jAT1fN^N0K`?c0iAa1X>_NhAa1X>_NiA`1W>`NiA]1Z>cNgA\\1Y>dNgA\\1Y>dNhAZ1Y>fNhAY1X>gNhAY1X>gNiAX1W>hNiAX1W>hNjAW1V>iNjAU1X>kNhAT1aNXNe?d0kAm0dNbN`?a0lAn0cNaNa?a0mAm0bNbNa?a0mAm0aNcNb?`0PB3UO]Ok>`0TBMSO_OUO1d?c0XBGQOESO1d?c0\\BBnNJRO1d?c0cC\\OiL1d?c0fC]OZe0oBT1UNVNl>e0nBV1WNUNk>f0lBU1\\=kNbBX1]=hNbBU1XNVNV?e0`BU1]NVNR?d0bBS1_NYNo>e0aBP1cN[Nk>e0bBm0fN^Nh>e0bBk0aNbNKNQ?e0dBg0\\NnNOEQ?f0dBX1a=hN_BX1a=hN_BX1a=hN`BV1a=jNeBP1[=POfBo0Z=QOfBf0c=ZO^B;l=EUB9l=GUB6m=JSB5n=JTB4m=LeB@]=`0n20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000jA^OU9b0iF_OZKOe=b0QG\\OYK7e==mF]O\\K=f=6nFOR91oFMR93nFMR93nFMR93mFOR91nFOR91nFOR91mF0S90mFOT91lF0S90mF0S90lF1T9OlF1T9OlF1T9OkF2U9NkF2U9NkF3T9MlF3T9MkF4U9LkF5T9@WGa0h8_OWGb0i8^OWGd0VKSO]=9]Gc0VKUOON\\=:^Gi0VKmN20V=:bGk0VKmNX=8bGP1]8POcGo0^8QOaGP1_8POaGQ1^8oNbGP1_8PO`GQ1`8oN`GR1_8nN`GS1`8mN`GS1`8mN`GS1`8mN_GT1a8lN_GT1a8lN_GT1a8lN^GU1b8kN^GU1b8kN]GV1c8jN]GV1c8jN]GV1c8jN]GV1c8jN\\GW1d8iN\\GW1d8iN\\GW1d8iN[GX1e8hN[GY1d8gN\\GZ1c8fN]GY1d8gN[GZ1e8fN[GZ1e8fN[GZ1e8fNZG\\1e8dN[G\\1e8dN[G\\1e8dNZG]1f8cNZG]1f8cNZG\\1g8oNmFl0QL_NR=f0lFg0^9YObFc0b9]O]F`0g9_OZF=j9DUF8o9GRF4S:LlE1X:0gEL]:3dEI`:7`EFc::]E@i:`0TE^OQ;b0S4000000000000000UE[Ob2e0oL[OcH3]:c0oLZO]H013c:d0mLD\\HHh2NS5e0`HZOG1o0OoN002c5b0UMAXMK00`7b3`H^L00017O=0[O6T3Q1lLQO0H211OW1e0iN[ON000O02e0b0h;=RF3_O]Ob:`0oE3_O]Ob:`0oE3_O]Oc:?nE4_O]Oc:?nE4_O]Oc:?nE3@^Ob:?nE3@^Oc:>mE4@^Oc:>mE4@^Oc:>mE4@^OR4", "size": [633, 640]}, "area": 369757.0, "iscrowd": 0, "image_id": 10015, "bbox": [0.0, 0.0, 640.0, 623.0], "category_id": 159, "id": 10012181}, {"segmentation": {"counts": "lnS1V13kN17MI20ia0m17MK10O1O1O1O100N2O001O100O100N200N2O001K5L3N3I601N10001O0000001O000O2O0010OO110N110O002^Ok\\O4O0Wc0Lj\\O4O0Wc0Kk\\O5N0Sc0On\\O100Rc0Oo\\O1N0WZY:", "size": [633, 640]}, "area": 1802.0, "iscrowd": 0, "image_id": 10015, "bbox": [58.0, 113.0, 50.0, 70.0], "category_id": 167, "id": 10012182}, {"segmentation": {"counts": "iVi12ec03M3N2N1O1O1O00O1O10O01O100O2O1NK1e\\OM[c04e\\OJ[c0821N2H7O2O1O01O01O01O010O00A?I7O2N1O1O00000m^ObNn?^1Q@eNm?Z1T@gNk?X1V@jNh?V1X@kNg?U1Y@lNf?U1X@mNg?S1X@nNi?R1U@nNl?R1T@mNm?T1Q@lNQ`0T1m_OlNU`0S1k_OlNX`0S1f_OmN\\`0R1^_OeN@8Ta0S1X_OUOj`0k0R_OWOQa0g0h^O_O[a0^12M3N2L4L4O0O2O1N2O0O2O1N4I6J7G9G8H9JWbl2Nm]SM100001OO1LNa\\O2_c0O`\\O1_c01`\\OO`c050O10_N4V_OKg`0f^OBTO0Zb08d^OHRO0]b04b^OKRO1bc0O^\\O1ec000O`ZV11`eiN1O100M3M3N2M3M3N2K5L4L4L4K5M3M3M3L4MNQ^O_Nma0c1S^O]Nja0e1W^OZNha0f1Z^OYNda0h1^^OWN`a0j1a^OVN^a0k160V^OVNha0h1[^OXNca0h1`^OXN_a0e1d^O[N\\a0c1g^O]NXa0`1k^O`NUa0^1f^OdNINaa0[1a^OnNea0o0W^OXOia0\\1004L3M1L3E_1AdN=\\1CfN;Z1DhN;X1EgNd0o0P3]NiN7cM>b0o0Q3\\NkN8bM?U1c1VO[Nn0l1_NeM9a0Q1g1XOWNo0j1bNeM7b0n0l1ZORNo0j1eNcM4f0k0n1]OnMP1j1fNbM3h0g0R2@jMo0h1jNcM0h0e0W2AfMP1g1H\\NDZ2EaMP1h1H]N@^2G]MQ1f1J^N\\Oc2IWMR1g1I`N\\Ob2ITMU1i1GaN[Oc2IQMV1b1OiNSOe2GPMW1`11kNPOf2InLV1`12lNoNg2HmLW1^14mNnNi2GkLW1^14oNnNh2GkLW1\\16QOkNj2HhLW1\\17QOkNl2FgLX1Z19SOiNl2GfLW1Z1:TOhNm2FeLX1Y1:UOiNn2EcLX1Y1;VOjNl2CeLX1X1XOlNk2]OfLY1V1?YOmNi2\\OgLX1V1`0YOoNn0_N2i0bNX1V1`0XOTOh0_N7e0bNX1W1b0VOVOc0aN;?eNX1X1b0SOZO`0`N`0m6[OaK8bM>k6[OcK7cM=j6[OcK:cM;i6[OdK:cM;h6[OfK:cM;f6[OgK:dM:e6[OhK;cM;c6[OjK:dM:b6[OkKb1dLiNn2D=d1eLjNl2C=d1gLkNk2@QL_Am3a>UL`Ah3a>ZL^Ad3b>^L^A`3c>aL^A\\3c>fL\\AX3e>iLXAX3i>iLUAW3l>jLQAW3o>lLn@T3S?mLk@S3U?oLh@R3V?SMg@m2W?o00000000000DaKWA_4g>>ZM`K`DC=o4l:eKgDHOe4S;iKoDMA\\4Y;oKUEW5d:TKXEl4b:\\2I7M31OI7001OBnFnER9R:>0000000000000000000000000000O100O11O2N00OXFUF]9W:02NN21O001O00000000001O00001O00000gG]EU7d:iH]EW7c:hH^EX7c:dHaE[7^:dHeE[7_;100O100O10000O1O100O11O00001O001hGYDU8g;kGZDT8i;0N2001O001O002N000QH\\Db7R;0g;0\\DNgmMdAKYOU12U1n>nMfAR1[OQ1a>cM^A01e08\\ONl3X>SLbAi06a3V>cLiA_3W>`LeAe3[>P1N22NO1O11O1O001OhN`JkB1P1`5Q<_JoB1O2P1^5Q<`JoB5f0KAa5`<^J`C91JKN004b5l;]J[D1B06>L0OA3d5h;\\JTD87f0KAOB2d5f;kJWDa02^OO]5h;fKYDmNO^5g;eKZDmNO_5g;dKYDnNO_5g;X2O1O1FhGeD0001X8Y;nGiDQ8Q;b0O1K5IPGYE10O1o8X:RGhE32T9S:TGkEm8S:a0L4BTFeFNIo9b9SFeFo9Z9`58KdAdJ^>[54K5JXAPKl>m45N2L4Hj@aK[?Y4d@iK2OZ?V4k@jKV?U4;O1O1oNW@jMj?S2Z@SMMa0j?Y2d@TM@?l?Y2m@dMT?Y2QAbMR?^2PA`MP?`2RA]Mo>c2RA\\Mn>d2RAZMP?f2U100000000001O3M3M3M2N6b_OjLf?X3V@kLi?W3m_OeL29o?d3O2N1O001O1O1O2N5K3M2N5K1O5K3M5K5K2N3M4L1eA^JV>g5O3M6J1O2N6J3M6J2N3fBYIU=j6kBVIR=m6RCSIg\\NmAc1S>^NlAb1T>_NlA`1T>\\NX@Fd1n1\\>PNQ@101c1m1`>RNl_O3b1k1f>UNZAj1g>SN[Am1]`0O00O10000O1000000O10000O1000oMT^On1Tb0TNk]Oc1aa0[NV_O1YO`1[b0_Nf]O`1^b0bNa]OY1db0fN^]OT1bb0lN^]OT1fb015K2N2QOo\\Ok0Uc0N2N2N006J4L2N6J1OST[1", "size": [640, 428]}, "area": 77791.0, "iscrowd": 0, "image_id": 10039, "bbox": [41.0, 87.0, 317.0, 553.0], "category_id": 96, "id": 10012194}, {"segmentation": {"counts": "0oWj01P\\VO0N2O1O1O1O1O1O1O1M3O11OO1O100N200N200O1O1N200N200N200N2O1O1O1O1N200O1O1N200O1O1BiNj]OO4Y1Qb0hNk]O03Y1h`0fN[@0jN14Y1e`0kN__ON:O]OO6Y1a`0mNb_OL:O]O50T1d`0QO[_OE51M1;h1T`0hNd_OF7c1U`0eNd_OI7c1U`0cNd_OJ5f1W`0`Nd_OI5h1X`0_Na_OI5k1Y`0\\Nb_OI5l1Y`0ZNc_OL2j1Y`0[Nc_OM5h1W`0[Nd_OM5i1V`0ZNd_ON6i1U`0jNk_OW1T`0iNl_OX1T`0hNe_OPO3Y2T?gMcAOXOV12T1o>mMdAKYOU12U1n>nMfAR1[OQ1a>cM^A01e08\\ONl3X>SLbAi06a3V>cLiA_3W>`LeAe3[>P1N22NO1O11O1O001OhN`JkB1P1`5Q<_JoB1O2P1^5Q<`JoB5f0KAa5`<^J`C91JKN004b5l;]J[D1B06>L0OA3d5h;\\JTD87f0KAOB2d5f;kJWDa02^OO]5h;fKYDmNO^5g;eKZDmNO_5g;dKYDnNO_5g;X2O1O1FhGeD0001X8Y;nGiDQ8Q;b0O1K5IPGYE10O1o8X:RGhE32T9S:TGkEm8S:a0L4BTFeFNIo9b9SFeFo9Z9`58KdAdJ^>[54K5JXAPKl>m45N2L4Hj@aK[?Y4d@iK2OZ?V4k@jKV?U4;O1O1oNW@jMj?S2Z@SMMa0j?Y2d@TM@?l?Y2m@dMT?Y2QAbMR?^2PA`MP?`2RA]Mo>c2RA\\Mn>d2RAZMP?f2U100000000001O3M3M3M2N6b_OjLf?X3V@kLi?W3m_OeL29o?d3O2N1O001O1O1O2N5K3M2N5K1O5K3M5K5K2N3M4L1eA^JV>g5O3M6J1O2N6J3M6J2N3fBYIU=j6kBVIR=m6RCSIg[KgAf00[O3d4Z>gKeAEN0102c4]>]K`A52KO0O04b4`>cK]ALOO1030L^4m>cKTAO0O31M]4m>dKSAOO040M\\4o>cKRA0O041L[4S?eKl@050NX4R?gKl@042MW4^?hKc@W4^?iKb@V4^?jKb@V4e?O00000VLX@\\3P`0XLQ@10f3S`0ZLl_Of3X`0O1[Lj_O^3]`0O2N1O2N1O2N1O2N2N1O2N2N1O2N2mMj^OX1Za0bNm^OBHc1aa0dNm^OHB`1ha0_Ni^O0@`1^b0bNa]OY1db0fN^]OT1bb0lN^]OT1fb015K2N2QOo\\Ok0Uc0N2N2N006J4L2N6J1OST[1", "size": [640, 428]}, "area": 192500.0, "iscrowd": 0, "image_id": 10039, "bbox": [0.0, 0.0, 428.0, 640.0], "category_id": 106, "id": 10012195}, {"segmentation": {"counts": "doR52mc05J6K;E3M3M3N1O1O2N1O1O2N1O1O2N1O100O100O1O2O0O100O100O10000O10O010000O100O01000O100000O1000O1000O10000O101N010O100O010O2O0O2O0O2N1O2M2O2N1N3N2N1O2M3N1O2M3N7H7H]je1", "size": [640, 428]}, "area": 3596.0, "iscrowd": 0, "image_id": 10039, "bbox": [260.0, 493.0, 81.0, 84.0], "category_id": 183, "id": 10012196}, {"segmentation": {"counts": "Q5o8Q61O00O1O12N000000000O10O02N010O0O3N2O01N100000000O2O000O1O2O000001O100O1O100OO100O10001O0O10000O100K6GPJ`GP6`88O101N1O1O1O20OO21O06J6I8H=D;Cc0@fGdIQ8W6mGmIT8P6lGQJW8o3jG^MMeN[8c3QHfMChN`8V3WHPNVOnNe8g2`HhNd7l0fHSO\\7b0oH[OU77WIGn6K^I2h6_OcI2TMUO_9:iI@gM5f8LRK5m9O1N2O0100OMWANlb<0okC6oAOk<5lB3P=P1N3L4M2N3N2M2O2M3N2M2O2M3M2L5L4K4L4L4M4K4L4O100000MaDeL_;[3bDdL^;Y3bDgL10\\;W3iDiLX;V382OO12OOO01O3O1M3N2N1O2N2JmC[MUL4L\\ke6", "size": [480, 640]}, "area": 25956.0, "iscrowd": 0, "image_id": 10040, "bbox": [0.0, 154.0, 183.0, 301.0], "category_id": 96, "id": 10012197}, {"segmentation": {"counts": "R_Q23i>4L4L4L4000001OO2O0001OO10000JEGnAN26OOk=K]B7HOk=KUB201O8R>KoA5V>LjANZ>75K5KjP81ToG3J;D:F4L4L4H8D=M2O100000000O@YB\\ON26Oc=7WB17Hj=0PB0201OY>1jA0[>0fA0Wm00YA4PS>0olA5[AFa>4L5M3TOEmB>mh0_Ob0@>11M20O10011M1000O11VOlBFT=:nBDQ==SC_OmTOZSOXa0B?@6JN^OhN`CX1^=j0V;iN\\D=?i0o:bNbD9N=a0h0P;PO_D8a0h0P;JPE6Q;IoD6m:ORE2n:ORE0o:OQE2m:OSE1m:OSE1m:OUEOk:1VENb3", "size": [480, 640]}, "area": 11579.0, "iscrowd": 0, "image_id": 10040, "bbox": [212.0, 217.0, 428.0, 129.0], "category_id": 124, "id": 10012200}, {"segmentation": {"counts": "Pkd71P?0N2O1O1O1O3M4L4K3N0000000O100001O1OL3012L6OM00O01000000O2OO100001O0O1001O001O0000O1001ON22N000001O00O4M3M3L3M3M1NTA0_]l0", "size": [480, 640]}, "area": 951.0, "iscrowd": 0, "image_id": 10040, "bbox": [522.0, 155.0, 58.0, 25.0], "category_id": 128, "id": 10012201}, {"segmentation": {"counts": "iUf4121h>0WA11Ne>1ZA20Ne>0[A20Ne>5[ALd>4\\ANb>2^AMc>801OO1O1002N000000000000001M202M2O1O0O11O00000000001O000O1O1O1N3N2O00000000000000000000000000O11O0O100N\\AHd>8\\AHd>8\\AHd>8\\AHd>8\\AHd>8\\AHc>9]AGd>8\\AHd>8\\AHd>8\\AHd>8\\AHd>8\\AHd>8\\AHd>8\\AHd>820000000000000000000000000O100000000O1O2N3M2M3O0000000001O0O10000003N2M11O0100N00NjAZOV>f02LhA@X>`0iA^OW>b04O1O1N3E:N2OYfk2", "size": [480, 640]}, "area": 1748.0, "iscrowd": 0, "image_id": 10040, "bbox": [320.0, 177.0, 124.0, 32.0], "category_id": 136, "id": 10012202}, {"segmentation": {"counts": "cRi72n>4L4L3M4L00GcAK0O]>ObA21NO3b>MbA1NOg>1[W^1", "size": [480, 640]}, "area": 93.0, "iscrowd": 0, "image_id": 10040, "bbox": [531.0, 179.0, 10.0, 17.0], "category_id": 142, "id": 10012203}, {"segmentation": {"counts": "RSh4142d>NYA8d>2O2N1MDbA<_>2O1N@dA`0\\>30ON200I\\ORBe0m=\\OQBe0n=\\ORBc0o=\\ORBe0l=]OQBe0m=8L5N100000000000000000000O2N1O1N2O10001O000000001O000bBaNO0Z=d1000000000000O010N\\NhBd1X=\\NhBb1Z=^NfBb1Z=^NfBb1Z=^NfBb1Z=^NfBb1Z=^NfBb1Z=^NfBb1Z=^NfBb1Z=^NfBb1Z=^NfBb1Z=^NfBc1Y=]NgBc1Y=]NgBc1Y=200000000000001O00000000000000WOjBHV=8PCBP=9jB[O3=S=9SCGm<9TCFm<9RCIo:m`=N2NM33M00O10001O000J64L00O1N21O2N1OO21N1O2NO2K41NN34LN20000N3N11OO10000001O2N4CaAMO0`>1`021O001O00N21O00N2^OfA?f>Ff\\`0M^c_O2N4L3M4L001O0000000000001OO1001O00O100000010OO11O01O0000000000000000000000000000000000001O0000O101O0000000001O000000000000000000000000000000001O01O0O10000001O00000000000000000000000001OO11O0000000001O000000000000000000000000000000000001O00000000000001O00000000000000000000000001O00000001O0000000000000000000000000000000010O0000000O10000001O00O100001O0O11O0000000000010O0000O11O0001O1O3MON22ZOlA>\\>N01O100000010;FUALm>06O\\TQ28a\\nMHb>:03M2N21O000000000000000001O000000O1001O00000000O20O0000002N1WG", "size": [480, 640]}, "area": 4373.0, "iscrowd": 0, "image_id": 10040, "bbox": [214.0, 261.0, 426.0, 41.0], "category_id": 149, "id": 10012205}, {"segmentation": {"counts": "P>P1Q>O00O1O12N000000000000O11OO100O11O1O00O100000000O10000O1O10000001O1O1O1O1O1OO100O1000000O10000O100K5HQO_Bo0a=8O100O1O1O1O11OO12N1O1O00001OO12lN^Bf0b=XObBf0^=ZOcBe0^=YOdBf0\\=YOeBg0[=VOiBi0g=01O00000000001O00O1001O1OMXOmAi0P>51O00001O00001O00001O001O00001O000000N2O1N2001O001O001O1O001O000000000000000000000000000000O1000000000000O1]OVOPCj0P=WOoBi0nQE_OLaNQ;R2QE]OS;d0lD[OU;f0jDYOW;W2100O1O1O100O1O1O1O100O1O1O100O1O1O1O100G9A?E;0000O100000000000000O100000000000000O10000000000000000>BM31O00001O00001O001O2N4L4RDWM];l2ZDZMf;P30O100O100O1O1]OWDoMi;n1`DkMa;R2iDgMW;V2k000O1O100O10000000000001O0[DlM^:T2bEmM]:S2dEmM[:S2eEnMZ:R2fEoMY:R2fEnMZ:R2eEPNZ:Q2dEQN[:P2cERN\\:n1cETN\\:m1aEVN^:k1`EWN_:j1^EZN`:g1]E]Na:c1REeM2l0j:i1SEZN4VOW:a2bEmN]:`2eEoK]:T46J6O1O1N22N1O000000O11OM34LN2M36JL43M001O00N22NO11OO12NO1O1O11O1OO12NO1O11ON2002NO1O100001O00O1001O000000O11O00O100000000O1O11O0000O11OO11O000000O10000001O0000O100001O00O100O11O00001OO100O10000001O00000000O100001OO100000000001O00000000O1O11OO100001O0000O10000000000001O00001OO10000001O001O0000001OO100001OO10000O1O11O001O001O00000000000000001O00O1001O00O11O0000000000000000O1001O000000000000O1001O002N002N2N1OO1O1O100O1O10000O10000O1BYEcLg:o2hEPMX:P3iEnLX:Q3jEnLV:Q3m00000000`DmLS;S3=00001\\DlLZ;T3eDmL[;S3eDmL[;S3eDmL[;S3eDmL[;S3eDmL[;S3eDmL[;S3eDmL[;S3eDmL[;S3dDmL];T3bDlL^;[30000000001O001O1O1Ob;S1PE_Oo:?PECQ;=nDFP;:PEHn:8REEQ;;oDHn:8REHo:8PEGQ;9nDHQ;9oDGQ;9oDGR;8nDHR;8QE_OT;c0nD^Oo:a0RE^On:d0QEZOP;g0QEUOQ;m0oDROP;n0PETOn:l0PE[NZOj0e;k0QEVOP;j0lD[N@m0b;h0nD\\N^On0b;f0PE@n:`0QE^NBj0_;g0XETOl:l0UETOj:m0^DbN;>Z;6^DGKE`0MAM^:9UEGb0OX:8XEFb02Y:4nFJR95o2M3Nmg4OnS;1ST@2]A2T>>N200O1O001O01000N101N20O01N2O0O21OM300O10O01OO10O1N2O11ON20O2OjClN_:U1`ElN_:U1`ElNa:S1[EQOd:o0SE\\On:b0iDnNVO0O`0U`0@=C8H8G:G>B=Cc0]O6J4L5TIWLX2m3^M\\L_2i3UMaLg2d3nLgLn2^3fLlLW3X3^LSM^3R3TLZMi3l2iK`MS4g2^KdM2TMU3_5ZLiM@gMh2VOYN`5POROf2_KYN`:f1`EYNb:e1`EYNb:e1_EZNb:e1_EZNb:e1_EZNc:d1_EZNb:e1`EYNb:e1aEXN`:e1eEXN\\:f1iEVNY:f1lEmM_:j1`101O0O101O00001O00001O00O1N3N1N30O00100OmMVNQFOLk1P:\\NjE16c1m9aNdE3?[1j9DVF=g9FXF:P1ZNc6_1\\H7Q1\\N_6_1`H6o0\\N_6a1aH3P1\\N]6d1bH0Q1]N[6d1dH0P1\\NZ6g1eHMP1^NY6g1fHKQ1^NW6j1gHIQ1]NW6k1hHHl0QNbN=g7m1jHFk0SNaNlH\\5T7dJmH[5S7fJmHY5S7gJnHX5S7gJmHY5S7eJPIZ5Q7dJQI[5P7cJRI\\5n6cJTI\\5m6aJVI^5k6`JXI;Dh3T7iK\\I:0a3e6RL_I73f2UO[MY7YOiH4j0;8h2SOZM\\7@]IMf0U3dN]MY7^O]K5QMV23gM8?k:]1kEaNY:n0VFPOn96jFIW[IV6H]IT74VI_6F]Il7b6TH^Il7b6TH^Il7b6TH^Im7a6SH_Im7a6SH^In7c6QH]IP8i60000000001O00100Nb0ZHcHf6^7TIiHk6g7N2N2UObHRJ_7i5n0L5ZOe001O1N101O1O001O1fMmEES:3SF3j9GXF`0e9]O[Fj0a9SO^FT1_9jN`F\\1]9cN`Fe1\\9YNcFk1\\9m10O1O101N4L4M3L3kKQFT3R:gLoEY3U:bLlE^3X:]LiEg3W:kKSFY4Y:4K4L4L000000001O0000000000001O00000001O01O000000I7H8I7H8M30000001O0000001O0001O01O0000001O001O2N2N2N2N2N2N2N2N2N2N2O1N2N0000000000O10000000000bMlE0T:N]FCc9WGSOl8h0ZGTOj8f0l2K5K5K5K5Kjb9", "size": [480, 640]}, "area": 74429.0, "iscrowd": 0, "image_id": 10040, "bbox": [60.0, 30.0, 559.0, 425.0], "category_id": 183, "id": 10012209}, {"segmentation": {"counts": "0_6a81O00000000001O00000000001O000000001O00000000000000001ON2O10000001O001O00002N1OO11O00001ON2001O001OLhG`IX8`6iG_IW8`6jG`IV8`6kG_IU8a6500000000001O1O001O00001O001O00001O00000000000000001O00001ON2001O001O0000000000001O00O100O10000001OM300O10000O1O11O00000000000000O100000000001O00000000000000O11O0000O10000O1NdG`I\\8`6dGbIZ8^641OO100O10000001O00O10000N21O001O2N0000001O00001O00O100O1McGcI]8]6dGbI\\8^6300000000O1001O000000001O00001O00000000001O0000001O00O1000000000000000000000000000000001O00000000000000001OO100002N1O0gG[IW8h6O2NO1001O00N22NN21OO100000000O1O1O100O11O00O11OO1O11OO1001O00001O0000001O1O00000000000000000000O1000000001O1O2N1O00000000000000O100000000001O2N2N2N2N1O1O1OO11O00001O0000O100001O3M1O001O0000O100001OO100001O001O00O1O1O1N2O11O1ON21OO1000000000000000000007I3M0dH_HO0X7b7hHaHW7c71001O1O000000001O00O11OO100N20000000000000000001O0000O100000000001O1O1O0000001O000000000000000000O1005kHRHn6\\8D00000000001O00000000001O000000O1O1O1O100O10000001O00000000001O00H_IPHb6R85M3H8N200O100000000000000O1000000O100000000000000000000000000000000O10000O1O10000000000001O000000001O001O1O001O000000000000O100O100O1O10000001O00001O00001O00001O001O0000000000O1O1O11O0000001O000000000000O10000000000O1O10000000000000000000000O1000000O1O1O1O1N2O1O100O11OO1000000O100O1\\O[HlIf7T6aHcIa7]6a00000000000O10000000000O11TH]IY7b6hH^IX7c6dH]IC4f7_6eH_IF1e7a6cHfI\\7[6_HiIa7X6[HmIc7j6N0000000000N_HeHa7[7200O1O1000000N2O10000000000N200000000", "size": [480, 640]}, "area": 146399.0, "iscrowd": 0, "image_id": 10041, "bbox": [0.0, 0.0, 640.0, 271.0], "category_id": 106, "id": 10012210}, {"segmentation": {"counts": "_6a8`6O00000000001O00000000001O000000001O00000000000000001ON2O10000001O001O00002N1OO11O00001ON2001O001OLhG`IX8`6iG_IW8`6jG`IV8`6kG_IU8a6500000000001O1O001O00001O001O00001O00000000000000001O00001ON2001O001O0000000000001O00O100O10000001OM300O10000O1O11O00000000000000O100000000001O00000000000000O11O0000O10000O1NdG`I\\8`6dGbIZ8^641OO100O10000001O00O10000N21O001O2N0000001O00001O00O100O1McGcI]8]6dGbI\\8^6300000000O1001O000000001O00001O00000000001O0000001O00O1000000000000000000000000000000001O00000000000000001OO100002N1O0gG[IW8h6O2NO1001O00N22NN21OO100000000O1O1OXI[IW5e6iJ\\IV5c6kJ]IU5d6jJ]IU5c6kJ]IU5b6lJ^IT5c6kJ]IU5b6lJ^IT5a6mJ_IS5b6lJ^IT5a6mJ_IS5a6mJ_IS5b6\\J_IZO1X6`6^J`IPOL56\\6^6_J`IoN:c6W6]J^IQO;b6W6ZJaISO9c6V6PJ\\I@8M6d6V6mI\\JT6e5kIRJ^6o5aIPJ`6P6`ISJ]6m5dIUJY6k5hI[JQ6e5QJZJn5f5VJVJj5j5ZJbIWO3_6[6jJbIV5^6mJ_IS5a6PK[IQ5e6e1O1000000001O1O2N1O00000000000000O100000000001O2N2N2N2N1O1O1OO11O00001O0000O100001O3M1O001O0000O100001OO100001O001O00O1O1O1N2O11O1ON21OO1000000000000000000007I3M0dH_HO0X7b7hHaHW7c71001O1O00000^I^Hf5b7XJeHc5\\7[JhHb5X7]JjHb5U7^JmHa5T7]JmHc5R7]JPIb5P7]JQIc5m6^JUIa5k6^JVIb5j6_JUIa5k6_JVI`5j6`JVI`5j6aJUI_5k6aJUI_5k6aJUI_5k6aJUI_5k6aJTI`5m6`JiHFBk5e7`JgHFDj5e7`JfHGEi5d7cJdHFFh5f7hJ\\Hd5d7l00000001O1O1O0000001O000000000000000000O1005kHRHn6\\8D00000000001O00000000001O000000O1O1O1O100O10000001O00000000001O00H_IPHb6R85M3H8N200O100000000000000O1000000O100000000000000000000000000000000O10000O1O10000000000001O000000001O001O1O001O00000000000[JYHQ4f7mK^HR4b7lK`HT4_7kKdHT4\\7kKfHT4Y7kKiHU4V7jKmHU4S7lKlHT4T7mKlHR4T7oKbHcN2^5]7l100001O00001O00001O001O0000000000O1O1O11O0000001O000000000000O10000000000O1O10000000000000000000000O1000000O1O1O1O1N2O1O100O11OO1000000O100O1\\O[HlIf7T6aHcIa7]6a00000000000O10000000000O11TH]IY7b6hH^IX7c6dH]IC4f7_6eH_IF1e7a6cHfI\\7[6_HiIa7X6[HmIc7j6N0000000000N_HeHa7[7200O1O1000000N2O10000000000N200000000", "size": [480, 640]}, "area": 159757.0, "iscrowd": 0, "image_id": 10041, "bbox": [0.0, 206.0, 640.0, 274.0], "category_id": 159, "id": 10012211}, {"segmentation": {"counts": "Wme31o>1O00000000001O0000000@1oA1o=OhAM45T>NgA;Y>EgA:W>HiA9m=CUB8M5m=:WBZOj=e09003N2N6LM5L3XOoA9`>L3L4LTgY16eXfN7J4L2N1O2N1O2N1O20O00001O0000000O2FoABS>:PBFU>4Zjg1JUVXN4M2N3N1N3M210000CeA3Yng1", "size": [480, 640]}, "area": 982.0, "iscrowd": 0, "image_id": 10041, "bbox": [251.0, 232.0, 270.0, 73.0], "category_id": 183, "id": 10012212}, {"segmentation": {"counts": "k6W3i;e0\\O1N1000010O00010O0001O010O000O2L3N3L3N2M4M2M3M4M2M4M2M3N3L3N3L3M3N1N3N2M2O2M2N3N3L3N3L3N3L3N3L3M4M2M4M2M4MQNA`EU1W3POP3J\\I0\\4TNZI94U1n1i0c4iM[I93U1k1o0f4bM^I9OV1j1T1i4]M^I:MU1h1Z1l4VM`I;JU1g1`1n4PMaI;IT1e1g1P5jLbIU2Z1V1S5eLeIR2T1^1bNWLd69fIQ2P1e1fNQLb6:hIn1m0m1iNkKa69jIn1i0S2]5PLkIj1g0Z2]5lKlIh1f0_2]5iKnIg1d0c2\\5gKPJd1c0i2\\5cKQJc1a0n2\\5_KUJ`1?T3[5\\KVJ^1>Z3[5XKUJ^1?^3Z5TKWJ^1>a3Z5QKVJ^1?e3Z5mJUJ^1`0i3Z5hJVJ^1`0m3X5fJVJ^1`0P4Y5bJVJ]1`0U4Y5]JWJ]1`0Y4W5[JWJ\\1a0]4W5WJWJ\\1`0a4X5RJXJ\\1`0e4W5jI]J`1;j4V5eI`J`19o4V5_IbJb17R5U5[IeJb15W5U5VIfJb14\\5`5cJ`J`5^5`J`Jb5_5^J`Jd5`5[J`Jf5`5YJ_Ji5a5WJ]Jk5c5TJ]Jm5c5RJ\\JP6d5PJZJR6f5mIZJT6f5kIZJV6e5jI\\JV6d5jI[JW6e5hI[JY6e5fI\\JZ6d5eI\\J\\6d5cI\\J^6d5bI\\J^6d5aI\\J`6d5_I\\Jb6c5^I^Jb6b5^I]Jc6c5\\I]Je6c5ZI^Jf6b5YI^Jh6b5WI^Jj6b5VI^Jj6b5UI^Jl6b5SI^Jn6a5RI`Jn6`5RI_Jo6a5PI_JQ7a5nH`JR7_5nHaJS7_5lHaJU7_5kHaJU7_5jHaJW7^5iHcJW7]5hHdJX7\\5hHcJY7\\5gHeJY7[5fHfJZ7Z5eHfJ\\7Z5cHgJ]7X5dHhJ\\7X5cHhJ^7X5aHiJ_7W5RHXKn7g4nG^KR8g510000O10000O10000O1000000O10000O2O000O10000O1000OjMdGjM\\8U2eGjM\\8V2dGjM[8V2gGiMY8V2hGiMY8V2hGjMW8W2jGhMV8W2kGiMU8V2lGiMT8X2lGhMT8W2nGhMR8W2oGiMP8W2QHhMP8]1fG\\M;V1o7_1hGWM:Z1m7a1jGQM;^1k7b1lGkL8Q7]3`H[L`08o6]3bH[L`07n6^3cHYL`09k6_3gHWL?:g6a3kHTL?:d6c3_J]L_5e3bJ[L\\5\\3UH]L`27Y5[3ZH^L^26V5[3_H^L\\28R5[3cH]La0Ol08n5^3eHZLc00i08m5_3hHYLb02h06k5a3kHWLb0OSO2c17k5c3mHTLc00SO2b16j5d3oHTLa01UO2_16i5e3QIRLc00WO3[15h5g3TIQLb00XO3Y15g5i3VIoKa00[O4V14e5k3YJmKnN3S15d5l3[JlKPO3Q14b5o3]JjKQO3o05`5o3aJiKRO2m05_5Q4aIhKa00D2j05^5S4bIfKc00D2i05[5T4fIeKa00H1e06Z5V4gIdKb0OI1d05X5X4gIeKd0NJ0c05T5Z4jIeKe0KL0a06R5[4jIeKi0JX15R4^4lIbKl0K30M6U5_4lI_KS1LN2N3R5b4nI\\KV1ML3N2o4d4oIYK\\1NG312j4g4aKTKE205e4d4iKUKl07X3c4oKVKi08T3a4VKWK60b18n2d4XKVK8Nc18j2f4[KTKl26e1h4iJPKe019Oe1:`2g4VKoJ41a0Of1:[2j4TKlJM3>M`01g19V2m4XKnJ;K`00h1;R2n4\\KkJ:L`00i1;m1Q5aKfJ:N>1k1:i1T5dKbJ:O>1l1;c1V5jK^J90=1n1<^1Y5^LZJ61o12R2;Q1a5gLRJ61S2>k0b5lLoI61T2>f0f5oLkI62V2=b0f5_LkIb0072V2>>h5XMhI41X2a04j5mLdI>190Y2i0]Oo5dMWI<1:0Z2P1hNT6XNkH<191[2W1SNY6nN^H;091]2`1\\M]6CRHV11l1Q:oLnET11m1P:PMoES10o1P:oLPFP11R2n9nLQF:110g2n9oLQF84OMj2n9oLQF94MMj2o9QMPF73CN50P3n9RMQF62F0N0T3m9SMQF41I4HMW3n9TMQF21K8o2f9UMPF11M7n2h9TMQFKOJ1;6k2j9VMoEK0G1?5i2j9WMQFI193g2k9XMPFI193e2m9YMPFH0:3e2m9ZMoEH0:3b2P:\\MnEGO<2_2R:`MlE;2S2U:`MkE=OQ2Y:aMiE=NP2\\:bMfE?Mm1`:cMaEB0m0Ol1c:bM`EFMl00j1f:_M`EMJ`3i:^L`E3G]3V;eLjDX3X;hLhDV3Y;lLgDQ3Z;PMfDn2\\;SMdDj2];UNdDj0];ZNbD?2S1^;_N`D=6n0[;fN_D<R;YO]D9h05m:C[D9l0Lj:m0ZEjNg:7YDXF@DRNT:^2XF]ODVN0OT:^2XF\\OEWNU:]2VF\\On9d0SF\\Ol9d0TF]Ok9c0UF]Ok9c0UF[OCXNW:]2VF[OCXNW:]2WFZOCXNV:^2WF[Ok9f0TF[Ok9e0UF[Ok9e0UFZOl9f0UFYOk9g0UFYOk9g0UFXOl9i0SFWOm9i0TFcNB\\O\\:Q2RFcNBYO_:T2oEbNCnNO:_:W2oE`NEYO\\:W2oE]NBRO53L0^:^2PF\\NASO53LO_:_2oEiMAG0<1C34NM^:`2oEfMAJ004OM78IJ0^:a2oEeM@K0O96h:\\2^EdMAJ>2e:`2]EcM@K>2e:`2]EbM1Oa:_2_EbMNOd:_2^E_M@1>Ne:c2\\E^MA0?Od:c2]E]M@0f;c2jD]MY;", "size": [482, 640]}, "area": 87816.0, "iscrowd": 0, "image_id": 10056, "bbox": [0.0, 0.0, 640.0, 207.0], "category_id": 106, "id": 10012214}, {"segmentation": {"counts": "U;d0`>N0O1O11O10M`AB`>>20^AB_>a01M2001O0100O1N01O11O00O1O1000000O100000001O0000000000000001O0000000000000000O1000000000000O11O000000000000O11O001O0000001O000000000O10000000000O11O0O11O0000000000000000O10000000000000O110O000000000000010O0000000000000O100O11O1CCSB=m=DPB>P>BPB>P>BmANMa0V>AlAb0U>_OiAa0W>6O1O1O1O0000010OL4N2M3M3N2M3M3N3L3M]`P6c0S_oIO10O0101O0O20O0O11O00UE@S7a0mH_OT7`0kHAV7>jHBV7>hHDV7\\7BdH>]7AbH`0^7@bH`0c7[O]He0P;00000N2O100O10000O100O10000O11O00N2000000O1N2001O00O10000N2", "size": [482, 640]}, "area": 4787.0, "iscrowd": 0, "image_id": 10056, "bbox": [0.0, 340.0, 640.0, 142.0], "category_id": 124, "id": 10012215}, {"segmentation": {"counts": "SPR61Q?2PA1i>4000000O1001OWAKe><[AB`>`001OAeA7[>HdA8^>HbA6e>11K4000001O2N00o`W10RPhN030a>6^AO\\>>M10000000O1000001O000000001N1H`AO_>0cAO]>1cAKb>3Zc6LQ]I0O2O2N001N101O001O00000O1001O000000000000000000000000000000000001O0000000000000000001O0000000000001O000000001O000000001O01O000001O0001O01O00010O001O000010O01O001O01O01O0\\M", "size": [482, 640]}, "area": 1580.0, "iscrowd": 0, "image_id": 10056, "bbox": [412.0, 71.0, 228.0, 31.0], "category_id": 132, "id": 10012216}, {"segmentation": {"counts": "Qf]51Q?000N0RA0m>3NMUA3k>2N2O1N2N2M3O1001O001OO11O2N001O000000001O00O1O100O100O100O10000O1000000O10000002N00O11O00O100O1000000000000HAiAc0T>7O1001OO1000000000000000000O10000000000000000000000001O000000000000000000000000001O00000000O100000000000000001O00O11O00001O00000000001OO1000000O1O1KSOSB0Om0n=SOSBo0l=ROTBn0k=5O11OO11O0000000000NlNVBT1j=20000O100N2M3L400001O000000001O00O1000000000000MbNbB^1\\=dNdB\\1\\=5O1001OO100O11OO100001OO1001O1O1O1O0000000000001N011N100N2N2000N2ON30N11O002O0O100N20001O000O1O10N020JlN[B00T1c=8HiNeBW1[=iNdBX1[=80O1001O00O2L3OO2L_NgB`1Z=`NfB`1Z=`NdB00`1\\=400000N3N100O1000M2100O10000O3O1N1M3OO1N2O00O2001O00O1000OO`C", "size": [482, 640]}, "area": 9386.0, "iscrowd": 0, "image_id": 10056, "bbox": [368.0, 402.0, 272.0, 80.0], "category_id": 140, "id": 10012217}, {"segmentation": {"counts": "c:651?R3Z:PMdEP3\\:PMcEQ3\\:PMcEQ3]:oLdEP3\\:PMeEo2Z:SMcEEBX3k:SMcEo2]:QMcEEBX3j:SMgEm2Y:TMdEn2[:SMeEm2[:SMfEl2Z:TMfEl2Y:VMgEi2Z:WMeEi2]:VMaEk2`:SMaEm2`:QMaEo2`:QM_Eo2b:PM^EP3c:nL^ER3b:mL_ES3a:mL_ES3a:mL_ES3a:mL_ES3b:kL_EU3a:kL_EU3a:kL_EU3a:kL_EU3a:kL`ET3`:lL`ET3a:kL_EU3a:kL_EU3a:kL_EU3a:kL_EU3`:lL`ET3_:mLaES3^:nLbER3]:PMbEP3]:QMcEo2\\:RMdEn2[:SMeEm2Z:TMfEl2Y:UMgEk2Y:UMgEk2X:VMhEj2W:WMiEi2W:VMjEj2W:UMiEk2W:UMiEk2W:UMiEk2W:UMiEk2W:UMiEk2X:TMhEl2X:SMiEm2W:TMhEl2X:TMhEl2Y:SMgEm2Y:SMgEm2Z:RMfEn2Z:RMfEn2[:QMeEo2[:PMfEP3[:PMdEP3\\:PMdEP3]:PMbEP3^:PMbEP3^:PMbEP3^:PMbEP3^:QMaEo2_:QMaEo2_:QMaEo2_:QMaEo2`:PM`EP3`:PM_EQ3`:PM`EP3`:PM`EP3`:PM`EP3_:QMaEo2_:QMaEo2^:RMaEo2_:QMbEn2^:RMbEn2]:RMdEn2\\:SMcEm2]:SMcEm2\\:TMdEl2\\:TMdEl2\\:TMdEl2[:UMeEk2[:UMeEk2\\:TMdEl2\\:TMdEl2\\:SMeEm2[:SMeEm2[:SMeEm2[:SMeEm2[:SMeEm2[:SMeEm2[:SMeEm2\\:RMcEo2]:QMdEn2\\:SMcEm2]:SMcEm2]:SMcEm2]:SMcEm2]:SMcEm2]:SMcEm2]:SMcEm2^:RMcEm2]:TMbEl2^:TMbEl2^:TMbEl2^:TMbEl2^:TMbEl2^:TMbEl2^:TMbEl2^:TMaEm2`:RM`En2`:RM_Eo2a:QM`En2`:RMaEm2a:QM_Eo2b:nL`ER3`:nL`ER3`:kLPEMa0X3_:jLdEV3^:hLbEX3U;O1O1O1O0cMWDa1i;XN^Dh1b;QNfDn1[;jMlDV2P<0001O0000001O00001O0000001O0000001O00001O0000001O0000001O00001O0000001O0000001O0000001O00001O0000001O000000001O0000001O0000001O000000001O0000001O0000001O000000001O0000001O000000001O0000001O0000001O000000001O0000001O0000001O000000001O0000001O0000001O000000001O0000001O000000001O0000001O0000001O0000001O000000001O0000001O0000001O0000001O000000001O0000000000000000O1000000000000O100000000000000O100000000000000O100000000000000O100000000000000O100000000000000O100000O1000N0UBmNh=U12OVBlNg=W100101N1O2M5M3N2OL3010N11O2N0_OPOnBS1nO10000O1000O10O100000O3N00O11O0O0100O1000O10000000HiAA[><601001OO10O100000000O100000O10O100000000O10000000000O2O00000000000O10000000000O101O000O1000O10O1000000O1000001N10O11O0O101O000O1000001N0100000O0K5E7]BiN0O_=\\1aBeNb=Y1_BgNa=X15O02OO11O00000003M4JSBoNQ>m07KO10O10OO2M3L310001N10000O101O0O01000O10000O10MhA\\OX>b0jA^OU>c05O10O2OO10O011OO0100@a0WOg001O2O1N2O1O0O11O00000001OO11O000N2O1O10YNXCR1jb08HhAFX>:hAEZ>98000000000010O0N2LWAOi>1WAOi>1WAM00i>3401O0001O0000000l[1MWdN001RAOi>51OO100000000000001O1O1O010O1gD", "size": [482, 640]}, "area": 33699.0, "iscrowd": 0, "image_id": 10056, "bbox": [0.0, 339.0, 640.0, 143.0], "category_id": 149, "id": 10012218}, {"segmentation": {"counts": "Z3c2_<0N201O01O000001O0000001N1N2N201O0O100O1O2O000O101N1O10001O01OO100O2N1O1O13NM20000MfL]D[3c;3O0N200010OO100010O1OO11O01O0000001K4O1000001O0001O01O0001O101N1O00O101O000O1010O2N1O00010ON\\LgDc3U;aLkD_3U;aLjDa3V;500O1010O00O11O01O0O100010O0TLmD02d3R;[LmD10d3Z;1O0000000LZLlDg3S;YLlDh3S;4O1O2O0O10000NPLREQ4m:oKSEQ4k:QLUEo3k:41WLUEJ2U3h:RMZEEMY3i:RM[EDOW3f:VMbEj2^:TMcEn2\\:RMcEo2]:oLdER3\\:lLfET3[:jLfEV3[:dLlE[3m:00000O2O000LcLbD^3];cLcD]3];cLbD_3^;`LbD`3];3O110N1N200N30O1OO11O10OYLhDd3Y;[LgDe3[;]LfD^3[;aLfD_33fLj:KSEX3f;OMhL]DX3a;500O1O1O10000M`LdD`3\\;31O1O000000N201O0O1O1001O00O10ZLfDd3\\;01O1OO1G]LSEc3l:^LQEOMc3R;^LPE0Nc3o:\\LPE041Mc3o:\\LPE04h3l:ZLSEg3m:7001OO10000002NNRLQEm3o:SLQEm3n:TLQEm3m:ULSEk3i:SLWET4g:4O100000000O100001O001O1jKXEP4h:PLYEOOO1i3l:YLWEg3j:WLUEONj3l:XLUEk3k:VLTEj3R;0001O1O001O1O1O2XLgDc3\\;000N200M[LiDf3V;ZLiDg3V;3O1O1O1O100O100002N1O1OO110O00_LmDS3S;bLlD83U3T;jLlDV3W;fLkDY3U;fLlDZ3U;eLjD\\3V;cLkD2j6R7hHlH>2j6Q7YIPIf6Q7XIoHi6n6iHQI>Nj6Q7hHPI?Oi6Q7hHoHl7P73iL", "size": [482, 640]}, "area": 71752.0, "iscrowd": 0, "image_id": 10056, "bbox": [0.0, 83.0, 640.0, 277.0], "category_id": 169, "id": 10012219}, {"segmentation": {"counts": "m5c0Y4Bh5d1PH^OP8i32O0O10000O2O0O10001N10000101N1O1O1O10O0001O01O00000010O00000001O000O1O2N1O1O1O1O2N1O100O2O00000010O000000010O000010O01O001O010O0000010O000001O0000000O2O0O10001N10000O101O0O10001O0000001O01O000001O0000001O01O0001O000000001O01O0001O000000001O01O0001O0000001O0001O0hFPL^7P4[HWLf7h3SH_Lm7a3lGgLS8Y3gGmLY8S3eGoL\\8P3aGSM_8m2^GWMa8j2\\GXMd8h2YG[Mg8e2VG^Mk8a2SGbMl8^2QGeMo8[2nFhMR9T41oMlFSNS9j1mFYNS9d1mF_NS9Z1RGiNn8n0VGVOj8c0TGFl82TG6l8BSGh0l8^NeGk1\\8kMdG^2\\8]M`Gl2`8oL]GZ3b8SLhGV4l8f0WOj0O01O0001O0000001O00001O0000001O0001O01O0000001O0000001O0000001O01O000001O0000001O0000001O000000010O0000001O000000001O0000001O0001O01O000000001O0000001O0000000010O000001O0000001O000000001O0001O01O000000001O0000001O0000001O01O000001O0000001O0000001O00000010O000001O000000001O0000001O0000010O0000001O0000O100000001O00000O2O00001O0000001N1000001O0000001N10001O0000001O0O101O00001O00000O2O00001O00001N1000001O00001O0O101O0K5K5J7J5K5J7K4M3N3L3M3N2M4M2O101O0O101O0000001O0O101O0005L7H7I8YFZKb8c51O000O2O00001O0O10001O000O2O00001O0O10001O000O2O00001O0O10001O00001N10001O000O101O00001N1000001O0O101O00001O0O10001O00001O0O101O00000O2O00001N10001O0O10001O0O101O000O2O00000O2O00001N10001O0O10001M2E;Ej<01MUCEh<1XC:jO101O000000O1O1O1O1DTC9o<0O1O20OO1000000000000O101O000N3O01O0000O1001O0001O01ON200000N22XC_O_<9I3_ji2CaVVM1N100000O010000O11OO1O10001O001O1O001O001N101O001O1N101O0O2O001N2O001N101N101O0O2O1O0O2O0O2O1O1O1N10000O010O100O1000O010O11N011O00O11N01000M3000000001N11N010O1O10000O10O0100O100O100ON34K2O0O1000N1N33MO10O10001O0000000O10O10lE_N_8a1bGaN[8^1gGdNV8\\1jGfNS8[1mGhNP8W1QHlNl7T1SHoNk7P1UHQOk7o0UHQOk7o0THROl7o0RHROn7n0RHROm7n0UHQOk7o0UHQOl7n0THROl7n0UHQOk7o0VHPOl7n0THSOh7P1XHSOe7m0[HWOa7i0^H\\O^7d0bH^O\\7b0cH_O]7a0cH_O]7a0bH@^7?cHA]7?bHB^7>bHB^7>bHB^7>cHA]7?bHB^7>cHA]7?cHA]7?cHA]7>dHB\\7>aHEo4", "size": [426, 640]}, "area": 10027.0, "iscrowd": 0, "image_id": 10058, "bbox": [0.0, 80.0, 640.0, 141.0], "category_id": 127, "id": 10012223}, {"segmentation": {"counts": "Rn[21Y=1O1O2N2mBKm<5SCJn<7QCKm<;M20OO1N3^C^OZJ1O1000002NN21OO1001O1O0O021N00O101N11OO12N1N2O012L102N1O_OdC5[_OXA`0g>BYAEZA:f>GZA8e>I\\A6c>L]AOeMJo`08\\ALfMKn`0:\\AIhMMk`0<]ADj><\\22N101N2N101O010O010O010O10O0101N1O1O2M2O2N1N3N1N3N1O1N3N1N3N1O2M2OO0101N10000j]OZNQb0l1O1N01O12M100Q^OQN31ca0o1Z^OWNea0T2N2M2O1N2O1N3N1O1N100O10O10O010O100O01000O010O1000O0100O10O10O010O101N1O10001O00000010O01NaMT_Ok1m`0UNS_Ol1l`0nM[_OQ2e`0nM]_OEGY2m`0QNa_Ol1_`0mMT_O1a0=_Om0m`0bNo_O?UOE0NO?2DSb06m]OH0M0`01CWb04i]OK5=LBYb01b]OO505>hb0BW]O`0hb0_OZ]O?fb0BY]O8FH0O`c08md1Ib[N1L4M3L5L3L4M3M4K4N2L4L4N3UCfNh6]1UIhNe6[1WIjNg6U1[ImNa6S1`InN^6Q1cIPO\\6P1eInN[6R1eIQOY6o0fIROZ6o0eIQO\\6m0dITO[6m0eIPO^6P1bIPO1", "size": [640, 427]}, "area": 25990.0, "iscrowd": 0, "image_id": 10069, "bbox": [0.0, 205.0, 427.0, 389.0], "category_id": 111, "id": 10012229}, {"segmentation": {"counts": "S8\\7d<02N0OOkHaJM_53aJM_52bJN^52aJO_50bJ0^50aJ0_51aJ0^5OcJ1\\50cJO_50bJ0^50aJ2^5NbJ1^5ObJ3]5McJ2e<10001N010O100O2O0O01O1O010N110O1O2N1NiS80\\XG2hc03O2O0O10000O10O0010O100O01000O100O01O02OO010000O010O10O0100O1000O1O2N3L3Ml_7NZlG1gc07L4O0O100O101N01000O100O01M2100O10000O100O10O02OO001L4M2N3M2N3MXjg41hUXK2N2N2000001O00Ol\\OIab07_]OI`b08Z]OOeb01Z]O1EGY26T>2m_O6l1LT>Mi_OJ1a0=_Om0:l>Lf_Of0?UOE0NO?2D?T`0g0R@jNH0M0`01C`0V`0h0n_OhNK5=LBa0O[OV`0\\1l_OcNO505>g0f?i0l_O_N`0h0c?i0l_OaN?h0d?f0n_OaN8FH0OU1S`0Q1U@UOk?_21000000O00100O1O10000000O100000^Nm_OWOS`0i0R@RO_HgCh2RN]MX>LeCd2WN^MS>0fC`2ZN^Mo=4gC\\2]N^Mn=6dCZ2`N_Ml=8dCW2aNaMk=NdA311m1\\2dNbMj=NkA4g1Z2eNdMT>2WCW2fNgMU>1UCV2gNiMU>2SCS2iNkMU>2RCQ2jNmMU>2QCo1kNoMU>2PCm1lNQNV>2mBk1nNSNV>2lBi1oNUNV>2kBf1QOXNT>3kBc1ROZNS>5jB_1TO\\NR>6jB\\1UO^NP>8kBX1VO`No=9kBQ1[OfNi=GUO]=>lB6M\\OW=?lBN3CP=b0lBD:Jj`1iAaNW>d1cA]N]>i1\\AXNd>m1VATNj>R2o@oMQ?W2h@jMX?_3000000O100O1000000", "size": [640, 427]}, "area": 35123.0, "iscrowd": 0, "image_id": 10069, "bbox": [0.0, 454.0, 427.0, 186.0], "category_id": 140, "id": 10012231}, {"segmentation": {"counts": "0S8m;002N00N20000000000O100O1000000O1001O0000O100O10000O100jL[DPNf;j1fDPNZ;l1lDRNT;l1oDRNR;a1\\E^Nd:b1^E\\Nb:d1_EZNb:f1_EYNa:g1_EXNb:h1^EXNb:h1_EWNa:h1`EWNa:j1^EVNb:l1\\ESNe:n1ZERNf:P2XEPNh:Q2YElMh:[2TEbMl:_2VE]Mk:d2WEYMi:h2YEUMg:l2[EPMf:Q3dD`KH\\1d;[3_D[KKW1g;e3YDUKNU1i;l3UDQKNS1m;n3TDRKKo0RXKiNQ4g0f0b0YKfNR4g0e0d0YKcNT4g0d0g0XKaNU4g0c0i0YK^NV4f0b0n0WKZNY4g0?Q1XKWNZ4g0>S1YKRN\\4i04N2M2O1O10000O1O10001OOO3N1O1N2N2XBXO`=S1K4N1O3M3M1O1N101O000O2O001O001N2O1O3L2O0O10000O100O100O1O1N2N2iMfMQH\\2n7fMnG]2Q8eMmG\\2S8dMmG\\2R8gMkGZ2T8gMlGY2S8hMmGX2S8gMmGZ2R8hMlGY2S8hMmGX2R8iMnGW2R8iMmGX2R8iMmGX2R8jMnGU2R8kMnGU2Q8lMPHS2o7nMRHQ2m7oMUHP2k7PNbF@Y1`2T8RNbF_OY1_2T8RNcFAX1]2T8SNdFAW1\\2T8TN_F\\O26Z1Z2R8eNnG[1P8gNPHY1Q8fNnG[1S8dNlG]1U8cNiG^1X8aNjG]1W8bNiG^1Y8`NgG`1Z8]NfGe1[8YNfGg1[8WNcGl1^8RNbGo1_8PNZGYOnNO0j2h9mM[GX2f8gMZGY2f8gMZGY2f8gMZGY2g8fMYGZ2g8fMYGZ2h8eMXG[2h8eMXG[2i8eMVG[2j8eMVG[2k8eMTG[2l8eMTG[2l8fMSGZ2n8eMRG[2n8eMTGY2m8fMSGZ2m8fMSGZ2n8eMTGY2l8gMUGX2l8gMSGZ2m8eMSG\\2m8dMSG\\2n8cMRG]2n8cMRG]2o8bMPG_2P9`MQG`2P9aMoF^2Q9bMoF^2Q9cMnF]2S9cMlF]2T9eMiF\\2X9dMgF\\2Y9fMeFHVOT2V:XN_FC]OT2T:YN_FA@U2R:\\N]FWO\\O36Y2Q:^N_FVOZO06\\2R:^NhEWOm0[2\\9aNdF_1\\9aNdF_1]9aNbF_1_9`NaF`1_9`NaF`1`9_N_Fb1b9]N^Fc1b9]N^Fc1c9\\N\\Fe1e9ZN[Ff1e9ZN[Ff1f9YNZFg1f9YNYFh1h9WNXFi1i9VNjE_OEL1_2`:WNgEX2Z:gMeEZ2\\:fMbE[2^:gM_EZ2b:gM[EZ2e:k01O001O001O001O1O001O001O001O001O001O00000000O10000O10000O10000O10000O10000O10000O100000000O10000000000O10000000000O10000000000O100000000O10000000000O10000000000O10000000000O10000000000O10000000000O100000000O10000000000001O1O1O1O1O1O1O1O1O1O1O1O2N1O1O1O1O1O1O1O1O1O1YNjDMV;3kDLU;4lDKT;6kDJU;6lDIT;7mDHS;8mDHS;8nDGR;9oDFQ;:oDFQ;:PEEP;;QEDo:SEBm:>TEAl:?UE@k:?VEAj:?WE@i:`0XE_Oh:a0XE_Oh:`0ZE_Of:a0[E^Oe:b0[E^Oe:b0\\E]Od:b0^E]Ob:c0^E]Ob:c0_E\\Oa:d0`E[O`:e0`E[O`:d0bE[O^:e0cEZO]:f0cEZO]:e0eEZOZ:f0hEYOX:f0iEZOV:f0lEYOS:g0oEXOQ:h0oEXOP:h0RFWOm9i0TFWOl9h0UFXOk9g0WFXOi9h0WFXOh9h0YFXOg9h0YFXOg9g0[FXOd9i0\\FWOd9i0\\FWOd9h0]FXOb9i0^FWOb9i0_FVOa9j0_FVOa9j0_FVO`9l0_FTOa9l0`FSO`9m0`FSO_9o0`FQO`9o0`FQO`9P1_FPO`9Q1aFnN_9S1`FmN`9S1`FmN`9T1_FlN`9U1`FkN`9V1_FjNa9V1_FjN`9X1_FhNa9X1^FiNb9X1]FhNb9Y1^FgNb9Z1\\FgNc9Z1]FfNb9\\1]FdNb9]1^FcNa9_1]FbNb9_1^FaNa9a1^F_Na9b1_F^N`9d1^F]Na9e1^F[Na9f1_FZN_9i1`FWN_9j1aFVN^9l1cFRN\\9o1iFlMV9V2kFhMT9Z2jFgMT9[2lFeMR9]2nFcMP9`2oF`Mn8c2RG]Ml8e2TG[Mj8g2VGYMh8i2WGXMf8l2YGTMe8n2[GRMb8Q3^GoL`8S3`GmL]8V3cGjL[8X3eGhLX8\\3fGeLW8^3iGbLS8b3mG^Lo7f3QHZLk7j3UHVLg7o3XHQLf7Q4ZHoKd7S4[HnKb7U4^HkK`7W4`HiK^7Y4bHgK[7\\4eHdKY7^4gHbKW7_4jHaKS7a4mH`KQ7b4oH^Ko6c4RI]Kk6f4UIZKi6g4XIYKf6h4[IXKd6i4\\IWKb6j4^IWK`6j4aIVK]6l4dISKZ6P5eIPKY6R5gInJX6S5hImJo1\\OW1j5iLjJe1L[1\\5PMhJc13V1W5WMfJb19o0U5^MbJa1`0h0R5gM^J`1g0`0n4PN[J_1n08k4YNVJ]1_1H_4kNRJ[1l2\\NU39oIZ1X3nMn2g0jIZ1Y:fNgEY1Z:gNfEY1[:fNeEY1\\:gNdEY1]:fNcEZ1]:fNcEY1^:jN_EV1`:oN\\EP1c:VOYEj0d:\\OYEc0g:^OYEb0f:_OZE`0g:@YE`0f:AZE>g:BYE>h:AXE?h:AXE>i:BWE>i:BWE4LbNo:Y1UE4NbNm:Z1UE31`Nl:\\1SE34_Ni:^1SE2Y;NgD0\\;0cDO^;kN`D]2a;_MbDb2^;[MdDe2g;0O00010O0010O000010O0001O000100O0001O00001O0O101O00001O0O2O00001O00000O100000000000000000000000000O1000000000000001O0001O0001O01O1O001O1O1O1O1O1O00100O1O1O1TNaC`1`<^NdC_1\\c:B^E=b:C^E=b:D^E;b:E_E:a:F_E:a:F`E9`:GaE8_:HaE8_:HbE7^:IcE6]:JcE6]:JdE5\\:KeE5Z:KfE5Z:KgE4Y:LhE3X:MhE3X:LjE3V:MkE2U:NkE2U:NlE1T:NnE1R:OnE1R:OoE0Q:0PFOP:0QF0o90RF0m90TFOl91TFOl91UFNk91WFNi92WFNi92XFMh92ZFMe93\\FMd92^FMa93aFL^94cFL]94dFK[95gFJY95hFLW93jFMU93lFMT93lFMT92nFMQ94oFLQ93PGMP93PGMo84RGKn84SGLm84SGLl85TGKl85UGJk86UGKj86UGJj87VGIj87VGIj88VGGi8:WGFi8;VGEj8;VGEi8=WGBi8>WGBi8?VGAj8?VGAi8a0UG@k8`0UGAj8`0UG@j8a0VG_Oj8b0TG_Ol8a0TG_Ok8c0TG]Ok8d0UG\\Oj8f0TG[Ok8f0UGZOj8h0UGXOj8i0UGXOj8j0UGVOj8k0VGUOh8n0WGSOg8o0WGROh8o0XGQOg8Q1XGoNg8R1YGnNf8T1\\GiNc8X1bGcN]8_1cG`N[8c1dG]NZ8e1fG[NX8g1hGYNV8j1hGWNV8k1jGUNT8m1lGSNQ8P2oGQNn7Q2RHoMl7T2SHlMj7W2VHiMg7Z2XHgMf7[2ZHeMc7^2]HbMa7`2_H`M^7d2aH\\M[7h2eHXMW7l2iHUMR7o2mHRMo6R3QIoLk6U3TIkLj6W3VIiLh6Y3XIhLd6[3\\IeLb6]3^IcL`6_3_IcL]6`3cI`L[6b3eI^LY6c3hI^LT6d3mI\\LQ6f3oIZLo5g3RJZLj5i3UJXLj5h3WJXLg5i3ZJXLc5j3]JVLa5k3`JUL^5l3cJULZ5m3fJSLY5o3fJRLW5P4iJPLU5R4kJnKh0`N\\2e5kLlKa0kN]2[5SMiK?ROW2W5ZMhK_I@a6=eI@[6`0gI]OZ6c0hIWOC2d6h0c00N21O00001\\OjH9V7HkH5U7JnH1KJX7NWI2ANo70Vi10gVN3THMn61_IOO5a60]IM03c66WIH0MM9j65VIEOM2m5FTJ8j5MXJLj55fI[O?=m5:TJEl5;RJGm5;RJEo59QJBEJX6f0QJAW6>iIXOF6a6d0mIYOT6g0lIYOT6g0lIXOU6h0lIVOT6k0lIUOW6h0a02N2O00000O11OO010kHTOR7P10ON1O4L2VInNa6[101O00000O10000O13MN2001ON21OO10000001ON_NbIa1^62001O001OO1001OO1O0100O01O0012N1O0`N_I]1d6000O11O2M01O12NM31N011O00O1N110O1N22M10N21O1O2M4MM311O2J5ON2NN33L2ON1010ON13ONcN^I\\1c62100O3MON131M5K10N3O0O012M10O011O1N101O001ONlNXIP1h6QOUIS1i6nNXIQ1i63013MSIlNj6U1VIkNk6V1M3100N101ON2003MN20NVIkNj6U1VIkNk6S113002HSISOm6n03KoH[OP7e0RIVOS7g0lH[OQ7h0QIWOn6i07OO1N21N101O000001O00O003M2ON21O001OO100O1002OO001O2M1O2N21M010OO23M1O10N1L304mHoNo6S11O01OON11mNRIR1o61M20010N11O2O0O01N2O1O00OO40NOO40TIkNd6\\1N2O1O1O001O1O001N011O1O2N1O2N1O1O1O1O1O00100N01O2N001OGUNXJM1m1f5<000001N10000001O002NWJhMh50YJV2j503M0000001O00O1O100O100O01O01O1O1001O0OO2001OO1O0O3O1N21OO02N00[JfMb5Y2^JgMc5X2\\JiMe5V2[JjMa5Y2_JhMc5[2McM`J]2`53N102O02OaJaMW5f2O12NO10OO021O0IWMTKi2l4WMQK1Nh2Q5XMoJl2P55O11NO1011N01K41O2KSKQMn4m2RKSMR5j2nJUMT5i24OO2O0011M101O00>B6K3K2O2N2N002N3M4L2kN^Ie0f6UO\\Ik0W5oNXL1`NP1Q5SOnJ7]1d0d3GbLZO]N91HO3P5d0YKXO_15W3f0UKYOb11Y3j0QKWO0Ka14]3S1RKjN`14]3X1jKcNL6Y4Y1eK`NB35\\4Y1dKgNN3_4T1dKhNM4`4S1aKkNO2_4T1bKjNO2^4U1^K^NI=;0]4V1\\K`NN893[4V1_K^NJ=f4S2WKnMh4f2200FWK[Mh4f2WKZMi4f2WKYMj4e2[KWMe4OUKi26VMe41VKj2Q5UMoJl2Q5TMoJm2T5N1O1OjJWMV5j204L5MM2OMRMQKP3l43012NN2110OM13KO50N01O1O35H1O0aMPK_O0\\2n4hMUKMNO114Z2g4gMhKZ2P5O11O001OO1000O110OO11O1O001O00O10O4M2NO10O2cJ]MT5k21000O02NMVMmJk20TMQ5Q30OoJQMn4Q323MN002N01010OO10001OO20O0O11O01NO22N00000001MSKPMk4P34O101O01O0000O1001O000O01002L04NZL", "size": [259, 640]}, "area": 35220.0, "iscrowd": 0, "image_id": 10077, "bbox": [0.0, 88.0, 640.0, 133.0], "category_id": 97, "id": 10012238}, {"segmentation": {"counts": "X6k1X601O00000000001OO10000000000O100O100O1000000001O000000000000000000001O001O00N2M3M3O1001ON21O00001O1O001O00O11OO100O100N200O1O1003M000000O1000mMRJQ2P60LPNTJQ2m520000O1O100O100000000O1000hMWJV2l5O6J5K001O00O100O10000001O0000N21OMUNmIl1S620000O11OO100000000001O0000O1NQNPJo1P6QNPJo1P620000001O1O1O0000O10000000000000000000000O11OO1000000O10000O1N2O1M3N20000001O5K:FEcNUJX1i5b0O13M3M2WNoI\\1T6[NYJ^1^6H3M00O10000@lNQJT1n5SOkIn0S6ZOgIf0X6c0N2O1N2O1O1000000000000000000000000000000000000000000000000007I8H8H5K1O00O10000O1M3H8H8J61O0000O1000000001O000000O1000000000000O100O1N2001O00UOQNaKP2^4TN_Kl1`4XN\\Ki1d4ZNYKf1f4[NYKf1g4YNZKg1e4ZN\\Ke1d4ZN[KGCl1Q5^NlKW1R4jNoKV1Q4dNRKJn0b1o3eNSKHo0c1n3eNRKHQ1c1n3dNUL\\1k3eNTL[1l3eNTL[1i3gNWLZ1j3eNVL[1i3fNWLZ1h3hNWLX1i3gNXLY1i3fNWLZ1i3dNYL\\1f3dN[L\\1g3[NTK0Y1e1R5000000000001OO1000000000000000_NdI[1[6fNfIY1Z6dNeIO1]1[6cNdI02\\1Z6dNeIO1]1Y6dNgIO0]1U6cNiI0025[1o5dNlIO045Y1P6eNkI25Y1o5kNRJU1n5jNSJV1n5jNnIIN]1S6kNoIHN]1U6iNlIKO\\1U6jNkIJ0\\1U6iNlIKN]1V6iNkIJ0\\1V6iNjIK0\\1U6jNkIJO]1U6nNkIR1U6>O1O100000000000000001O0000O10000001O1O00O11O001OO1O100O1001O00000000001O3M3M1O0000000000000000000000L4L4O1001O0000000000O11O00000000O12N00N21O001O000000001O1O00000000O1O10000BUNdJk1[5XNcJh1\\5ZNbJKIi1d5^NgJ`1X5cNhJ[1W5hNlJS1T5mNlJS1T5nNkJR1U5nNkJR1V5mNjJS1V5lNkJT1U5lNkJT1U5nNiJR1W5nNiJR1W5nN^JA8a1Z5nN^JA8a1Z5_N]Ja00_O4c1a5i0000000000000000000000000O1O10000000000O100000000O11O1O1O1O00000fM[JV2e5jM[JV2e5iM\\JW2d5iM\\JW2c5iM^JW2g500000O11O001iMYJP2m50000000O1N21O000000001O1O00001O001O0000MRNRJm1n5SNRJm1o5SNPJm1P63001O001OO1000000001OO10000000000000000000000001O00001O0000001O000000001O00N2MRNSJl1m553M001OO1O12N00N2N200FQNaJn1`5QN`Jo1`5QN_JP2_5UN]Jl1d5TNZJm1g57001OO1O1OfM[JX2h504L5KO1002NO10000002N1OO1M31OO100002NO1O1002N1OO11O001OO10000001OO11O1O001O00O1003M2NO1001XNhIc1\\601O1O00001_N_I^1d6O0cN]IZ1e614LO1O1O1001O0000001OO11O0000001ON22N00000000NiNZIU1f64O100001O0000O1001O0000O1002NN200", "size": [259, 640]}, "area": 39572.0, "iscrowd": 0, "image_id": 10077, "bbox": [0.0, 156.0, 640.0, 103.0], "category_id": 124, "id": 10012239}, {"segmentation": {"counts": "m\\f01R82N4L2N2NO12N0000O10000000000O100N2O2N[\\m0LhcRO3M2O1O001N2O1O1O2M2O1O1N101O1001O1O1O0O3N1N2M3O2O0O1NN3N1LH]H:c720101NOaHC\\7m0D1JSOUIn0k6ROTIo0l6POTIQ1l631O00O010001OO100N2O1IkN\\IY1c64O10000O10001OO10O11O00O1000_N`I_1`6aN`I_14aNX6^1iIcNV6]1gIbNO1[6]1eIbN02Y6]1gIbNO1Z6\\1gIdNO0Z6X1fIfN0025X6R1gIiNO045V6S1hIhN25V6R1nIoNR6Q1mIPOQ6IhIX17kNINX6OhIW18lNHNW6[1oIfNKOW6Z1oIfNJ0X6Y1mIhNKNT61lIZ16fNJ0S6_1RJaNK0m5OWJ^12cNJOn52QJ^1<`Nb51TJ_1Z6cNeI[1\\65100000O10000000010O0O1O001000001O1O00O11O0010N1O2O2M10100OO100O10001O3N2M1N13UNgIf1\\6O1O2N00O11O1O00001K4L4O2O010O1O1O00O12M11M22kNTIo0Q7O1O1N21N01M30O010N11O1O2N101O0O1O1O1O1N1O2O1O1O2N1NXHIg7;0003K01O0000O1002N000E[H8e7H[H8i7GWH4cfh1", "size": [259, 640]}, "area": 6974.0, "iscrowd": 0, "image_id": 10077, "bbox": [88.0, 141.0, 328.0, 72.0], "category_id": 154, "id": 10012240}, {"segmentation": {"counts": "0l4W3000000O11O0000O10000000fMVK[1j4dNYKZ1g4cN_KZ1a4fNaKX1_4hNcKWOCm1i4mNhKQ1X4oNhKQ1V4QOiKP1X4oNhKQ1X4oNhKQ1X4oNhKQ1Y4[NXK9?\\1Y4\\NYK5`0^1V4\\N]K1KJb0i1W4UNfK2ANf0k1f4UN\\Kk1^50000000000000EUN_Jj1\\5YNZJM:j1^4WNeKOO5Od1\\4\\NcKM031d1\\4bN]KH0MM96b1`4cNZKEOM2<2b1c4`NYKF0M1:1f1e4gNYKh1g4j0O100000000000000000gLZKU3n4LL42NO1K500O100O100001O00000000O1000000000000003M3M0000J6001O001O2NLgL^KY3b4400000000000000000000000000000000001gL]KP3i4lLUKT3k421OO10YMUKA2a2j4gMTKL0L0c2n4^MRK0233\\2j4`MQK1401`2[502N001O001O002N001OO11O1OO1LhM]JX2^5fMcJ`2\\5bMdJ]2\\55N200O100001OO100EZMWKh2[4YMfK4Ig2a4UMcKV3]4jLaKX3_4600O1O100O1N]LeKb3Y4`LfKa3V4^LjKg3U44M3O10000O11OO11OO1000000O13MO1O1000000O11OO100O11ON2N2N2N200000000O10000O13MN2001ON21OO10000001ONeK\\L[4d32001O001OO1001OO1O10000O1O1O12N1O0cK\\L[4f3000O11O2NO1O12NM31OO11O00O1N200O1N22N00N21O1O2N3MM31O1OM31O1OM33M1ON2O100M31ON`KaL`4_321O1O3MO1N22N4L00N200O100O100O11O1O001O001ONeK_LX4`3iK]LZ4b3gK_LX4b34O13MO11OM31O1O001ON2003MN200001ON21O3MO1O1002NM3001OO1N21O001O0000000000O12N1ON21O001OO100O1002N000000O1O1O12NO100N23M1O1OO1L4O11O2N1O1ON20cK\\L[4f30N2001OO11O2N1O00O1000000N22NO12NN2O100000000000000O10000000000000000000000001OO1001OO100FfKgLM1]4V3<000000O10000001O002N1YKfLc4]303M0000001O00O1O100O100O100O1O1O1001O00N2001OO1O1N200O12N002N001O1O1OL42NMZKiLf4W33N2O1002NO1O12NO100N20000ISKXMm4h2SKUM1Nl4m2TKSMP5l24002NO1002N00L41O2N2N4L2N1OO100002N001O00>B6J4L1O2N2N002N3M4L2jL_Kf2e4TM]Kl2V3nLYN1`NQ3P3RMoL7]1e2c1fMcNZO]N91HOT2o2cNZMXO_1U2W1fNUMYOb1Q2Y1jNQMWO0Ka1T2]1SORMjN`1S2^1YOiMcNLU2Z2ZOdM`NB3T2]2ZOcMgNNQ2a2VObMhNMR2b2UO_MkNOP2a2VO`MjNOP2`2WO\\M^NI=;n1_2XOZM`NN89P2^2YO\\M^NJ=kGBU8f0cGZO]8m0\\GSOd8U1TGkNl8\\1mFdNS9c1fF]N[9j1]FVNc9Q2VFoMj9Y2nEgMR:`2gE`MY:h200001O0000000000001ON2N2N2M3N2O1000000000000000000000000001O00001O2N1O1O0000000000000000000000=Ci0WOg0YO1O1O2N1O2N1O1O2N1O1O2N1O2N1O1O2N2N2N2N2N1LlB1V=0_ke12^TZN6K6I6J7J5J7J5J011O001O001O010OO12N000N3O000N\\N_Dd1a;101000O10N06MOM42L2O1OO100N211^NYD^1i;1O0001O2N0O1004K2O001O001\\D^N_;g1O00001]E[N`9e1aF`NR9g1lF^NQ9b1oF_NP9a1PG_NP9a1oF`NQ9a1nF_NR9`1PG_NP9a1PG_NP9a1oF`NQ9a1oF^NQ9b1hFQN_O>i9a1fFTN@;k9_1fFVN^OHg9HoE?;Gf9IRF>d0]O[91UFa0?_O[90\\FJBJO7h05^9NmG2V8KjG5Y8GiG8d:0000000000DWC8m<0M3007FmB0ojW1", "size": [425, 640]}, "area": 16746.0, "iscrowd": 0, "image_id": 10082, "bbox": [48.0, 307.0, 496.0, 118.0], "category_id": 118, "id": 10012245}, {"segmentation": {"counts": "^3>P16W:Hf11O1O1O00010O001aDBQ:>kEFU:;fEJY:7bEN]:3^E1b:1XE3h:NRE7n:ImD=R;DhDa0W;k0M2O1O1O001O100N3N1O1O1N2M4K4L4M3N3J5M3N2005LO0O4M3L4K6K4M3L5K4K5L4Lb0^OT1lNd0\\O3M4L1O2M3O0QJgHm5^7M00N2OO100O10000O100O10000O10000O101N10000006JJ600O01\\JoJP3Q5oLfK\\2Y4dMhK[2X4dMkKZ2U4fMmKX2R4hMPLW2P4iMZLl1h3RNfLa1Z3_NTMS1l2lNoM:Q2FkN_OS1a0ClN;T1:XNEg1?XN_Oh1b0YN\\Of1g0ZNWOf1j0ZNUOe1n0YNROg1X6O100O4M?@2O2M3N2L3N3L3N3L3N2M4M2M]k<5ZTC7QOFgDb0W;C_Dc0];VOZD_1d;5M2O1N101O00001O00001O0JWNmDh1b;H01O0O1010O0000O2O00001O0N210O0000001O00001N2O1O1O1O1N2O1O1N2O1M3O200N4L5K4L5K5K4L5\\FPMe8n3L5K5J6K5K5K5K5K5K5K2NM4M2M3M3N1N4L3M2O1N2N3M2O2MNWKiGg4Z811XKcGf4[834L1O3M3N3L5H7J7IV1iN7JfIgMP2R2SNPNn1j1UNXNl1c1UN`Nl1]1TNeNm1X1SNjNn1S1RNoNo1n0QNTOQ2h0QNXOP2e0SNZOn1c0TN]Om1`0UN@l1Bi0WOi0WOakb1FiT]N3M3M4K4L4K5L4K6K4K5L5J7J5K6I6K6I6K5J5L3E;nNS1L3M3M4M2M3M4L3M3M4L3M3M3M4L3M3M3M4L2N1O1]KgIl12nKX6V2fIm14iKW6Y2fIn1a6QN`Io1`6WLhIo0Hj2`6WLRJ`0DX3Z6XL\\JKEm3o5XL[Kh3e4XL[Kh3e4XL[Kh3e4QL^IM0Mg1W4j4PL_I4c1l3S5]LjJc3P5fLkJQOeNY4Z6oLnJT3k4TMRKm2i4ZMUKg2d4`M[K`2a4eM^K[2^4jM_KX2]4lMgKP2V4TNiKl1T4XNlKg1R4\\NlKd1R4`NmK`1P4dNoK\\1P4fNoKZ1m2eK\\L0d0S33X1m2eKYL3e0b1\\OEj0Q3k2fKXL4e0`1CBg0iNQOW4g3RLmL\\1H^Of0S3e2RLmL]1M[Oa0T3g2SLjL_12UO?Z3U2ULiL2;[1a:F^E9a:J]E7_:M`EOc:7fDBJO77[;\\1O0O1N24M1N3M3M3N1O2L4N1N3N2M3:EM4M3M3N1N3M3M3M2N3M3M3M2N3N\\\\P1", "size": [425, 640]}, "area": 1236.0, "iscrowd": 0, "image_id": 10082, "bbox": [516.0, 338.0, 45.0, 75.0], "category_id": 132, "id": 10012248}, {"segmentation": {"counts": "b1l1];0000000000001O000000000O10000002NO01O10O100000001OO1000000O0O2M4L3N3N1L3O2O11O6J1O0O2O00O01L5N1L4M2011O0000000000000O11O1O1N2N2OO100O10000O100O2O000O10000O10O010000006KI511N10000000000O1001M200000O10001O000000000000000F:O1O010O101N1O100O1O100O1O100O1O10000000000000010_OTDCl;=[D\\Oe;d0\\D[Od;e0\\D[Od;e0\\D[Od;e0]DZOb;g0^DYO^;k0bDUO\\;m0dDSOZ;n0gDSOV;o0jDQOT;Q1?3000IRDSOm;n0XDQOe;n0_DTO[;k0jDWOP;i0h0O1000001O011N2N2N3M3NO2N1O2N6J5J10001TDmN`;S1ZDoNj;Q1VDoNj;Q1VDoNj;Q1VDoNj;Q1VDoNj;R1UDnN8NW;T1aDnN8NV;U1bDmN8NW;T1aDnNk;R1UDmNl;T1SDlNm;T1SDlNm;X10:FlN_Da0b;\\OeD>[;BiD:W;EmD8S;HUE0k:0UE0l:NUE2k:NUE2k:NUE1l:OTE1l:OTE1n:MRE3l:0SE0m:0RE0Q;NoD2o:0QE0n:2QEMP;5nDKR;:iDDY;a0ZDGf;IVDm0h;ROiD>V;CmD:S;EPE9P;GQE8o:HRE7n:HSE8m:HSE8k:JUE6g:BaD8h06g:BaD8h06g:BaD8h05a:6_EJa:6_EJa:6`EI`:7aEH^::bEE]:i0WEVOi:P1mDTOS;l0oDROP;o0REPOm:P1SEPOm:Q1nDSOR;m0oDROR;m0PEPOQ;Q1oDoNQ;T1kDlNV;V1fDjN[;a11OO2NROjDLW;1mDNS;OREJD@[;b0WELm:1WELZOC_;>\\EIj:3\\ELc:3_EJc:5`EI`:6Z1O1O1O1O1O1O1OhTQ20YknM00000000000000001O0000000000000000001O00000000000000001O002N3M3M3M3M3M3M3M3M001O0000000000000000000000001O001O000000000000O1000000000000O1N21O0000001O000000001O00000000O100O1O1O1O1O12N1O00001O0000N2WOdCh0eMQ`AC>Ak0VOl0SOf0[Oe0ZO4M1N3N1N3N1N3N1N3nMnIiLS6U3]J[Le5c3]J\\Le5b3]J[Le5c3^J[Ld5c3^JYLe5e3]JYLl6^2WI^M\\7Q2eHmM\\7R2gHjM[7U2gHiMZ7W2gHfM[7Y2hHdMY7[2iHbMY7^2i1O1O1000000000000001O@\\E[Nd:e1cETN]:l1dESN\\:m1dESN\\:m1dESN\\:m1dESN\\:m1dESN\\:m1dESN\\:m1eERN[:m1fETNY:l1gETNY:l1gETNY:l1gETNY:l1hESNX:f1\\E[NlNPN6c5\\2WLZN:WO]3b2`LPNg5R2aJfM\\5]2kJ\\MR5h2d23RJRM_1P3^NTM^1o2_NVM\\1m2`NYM[1j2bNZM[1h2bN]MY1g2bN_MY1d2fN^MV1e2iN^MR1e2mN^Mo0d2PO^Ml0c2UO`Mc0c2_O_M;d2F_M3d2N^NkNf1V1\\NdNf1^1\\N\\Ng1e1\\NTNg1m1[NnMg1S2[NjMd1X2^NeMb1\\2`NaM`1a2aN\\Ma1c2aNZMa1f2aNVMa1i2aNTMb1k2_NRMc1n2^NnLe1Q3]NlLf1S3[NjLg1U3[NhLg1X3ZNeLi1Y3ZNcLl0GWLf3n2`Lj02TL]3S3^Lh0=PLT3Z3\\Lf0g0kKm2o7[MmGc2Q8fMiGZ2T8_1N1N3M2N3N1a0@i0WOi0XOg0XOi0WOg0ZO0O101N1O2O0N2O2N1O1O2N1N3N1O1O2N1O2N1N1000000000000O101O00000000000000000000000000000000000000000000000000001O00000000000000000000000000000001O00000000000000000001O000000000000000000000000000001O2N2N000000O10000O101O0O10000O100O10000O100000hFMZ53fJ0W50hJ4U5LkJ8Q5ImJ;P5EnJ`0o4@PKd0m4\\OQKi0l4WOSKm0j4SOTKR1i4nNVKW1f4iNYK\\1c4dN[Kc1`4^N^Kg1^4YN`Kn1\\4QNcKT2Y4lMeK[2V4eMiK`2S4`MkKf2Q4ZMnKi2P4WMoKm2n3SMVKk3h4ULkJZ4S5gKkJ]4R5cKmJ`4Q5`KnJc4P5]KoJg4n4YKQKj4m4VKRKm4k4TKUKo4h4QKWKR5f4oJYKT5e1dJJ:_NU5e1gJF4dNY5b1iJB4hNV5d1lJWO8QOo4e1oJmN=ZOg4g1RKcN`0Bb4g1TK`N?E`4i1WKYN?J]4j1ZKUN>M[4k1^KoM<3Z4k1_KkM<6X4l1lMPNW2n1lMnMW2o1n4D:E:]Oc0\\OUW11ohN:E:G9G9G8I7H7K5K5K4M4L4M3L4L4N2MbNnEHQ:9RFEl9;YFAg9>^F_O`9b0dFYO\\9h0hFTOW9l0mFQOS9o0QGlNo8U1UGgNj8Z1YGbNg8_1\\G^Nd8a1_G\\Na8e1bGXN]8i1`14M1N3M2O2N2N1O2gEfM`9c1kETOb0^O]9_1QFUO?B[9Y1WFWO;EX9U1]FYO8GV9P1cFZO4LS9l0hF[O2MR9h0mFa0o8APGa0n8_OSGc0`6jM_Ke1QNc0^6VNQKY1`Nd0]6XNmJT1gNe0[6ZNiJS1kNf0Z6YNhJQ1oNh0W6ZNeJP1SOi0V6YNeJn0UOj0U6[NcJj0XOn0S6ZNcJh0ZOP1R6YNbJf0\\OT1P6YNaJc0_OU1o5ZN`J`0AY1m5ZN_J?Fa02lMg5V1^Je0P1iNQOZO`5X1^Jm0R1VNUOC[5[1\\JS1R1gM^OIR5_1\\JX1Q1ZMGMk4b1[J^1Q1lLN3e4d1ZJd1U2eLa3\\8RO5L5K3L4M3M3L4M4L2M4L4L4L3M4M3L3M4L4L4L3N3L4L4L3M4L4M3L3N3M3M3M2N3L4M3M2N3M3M1O0000000000000000O1000001O0000000000001O00000000001O0000000000001O00000000000O2O001O001O001O001O001dEmN`8S1]GQOb8P1[GROe8n0XGVOg8k0UGYOj8g0TG[Ol8f0QG]On8c0PG@o8a0nFAR9?lFDS9=iFGV99gFJY97cFM\\93`F2_9N^F5b9LZF8e9HXF0O1O1O1O1O1O1O100O100O1O1O10000O1O100O1O100N200N200O1N2N2O100O1O1O1001O00O1O10000O1O1O100O1O100N20000O1O1O1O1O1O1O100O1O1O100O1O100O1O100O1O100O1O1O1O1O100O1O1O100O1O100O1O100O1O100O1O1O1O100O1O1O1O1O100O1O1O100O1O10000O1O1O1O100O1O100O1O1O100O1O12N1O1O1O1O2N1O1O000000000000000000000000004L7I4L001O000000001O000000001WNWCY1Y=O001O001O0POaBF99W=1oBOR=OPC0P=MXCNi0\\A0O11OY>3hAMN8X>=O1O1O11OM300O100001O[OYOPCh0n<\\OoBe0n<^OgBE9m0ni5[7cJfH\\5Z7dJfH\\5Y7fJgHY5X7hJhHX5X7gJiHZO@m5i7gJgH\\O@m5k7eJgH[5\\7bJdH^5^7`JbH`5`7^J`Hb5`7^JaHa5^7`JbH`5^7_JcHa5\\7`JeH_5[7bJdH^5[7fJbHZ5^7hJbHV5^7mJ^HT5a7oJ\\HR5d7QKXHP5g7SKVHn4i7U1O100O1O1O1O1O1O1N2N2O1O1O1O1N200M31O1O1O1O2N1O1O2N2N1O1O1O1O0]JZHl3f7SL]Hk3b7TLaHk3_7SLdHl3\\7SLgHk3Y7TLiHk3W7ULjHj3W7TLkHk3U7ULmHi3T7ULnHj3S7ULnHj3S7TLoHk3R7TLPIj3P7ULRIj3n6VLSIi3l6WLVIh3j6XLXIf3h6YLZIf3e6[L\\Id3d6[L_Ic3`6^LaIa3_6^LcIa3]6_LdI`3[6`LhI^3X6bLiI]3V6cLlI\\3T6dLmI[3S6dLPJZ3o5gLRJX3n5gLTJX3l5hLUJW3j5iLYJU3g5kLZJT3e5lL]JS3c5mL^JR3b5mLaJQ3^5PMcJo2]5PMeJo2Z5RMhJl2X5SMjJl2V5TMkJk2T5UMnJj2R5VMPKh2o4XMSKg2m4YMTKf2l4YMVKf2i4[MYKc2g4\\M[Kc2e4]M\\Kb2c4^M_Ka2a4_MaK_2_4`McK_2\\4bMeK]2[4bMhK\\2W4eMjKZ2V4eMlKZ2S4gMnKX2R4gMQLW2o3iMRLV2m3jMULU2k3kMVLT2i3lMXLT2h3lMXLT2h3kMYLU2f3lMZLT2f3kM[LU2e3kM[LU2d3kM\\LV2d3jM\\LV2d3iM]LW2f3fMZLZ2h3cMYL]2k3_MULa2l3]MULc2l3\\MTLd2Q4VMPLj2Q4UMnKl2R4SMoKm2Q4SMoKm2P4SMQLm2P4RMPLn2P4QMQLo2o3QMQLo2o3PMQLQ3o3oLQLQ3n3oLSLQ3n3nLQLS3Q4jLPLV3Q4iLoKW3l710000O10000O10000O10000O1000000O1O100O10mLaDe2^;[MdDd2\\;\\MeDc2Z;]MiDa2W;^MkDa2T;`MmD_2S;`MPE^2o:cMRE\\2m:dMUE[2k:eMVEZ2i:fMYEY2g:fM\\EX2c:iM^EV2b:iM`EV2_:kMbET2^:kMdET2[:mMfER2Z:mMiEQ2V:oMlEP2S:QNnEn1R:QNPFn1o9SNRFl1n9SNUFk1j9VNWFi1i9VNYFi1f9WN\\Fh1d9XN]Fg1b9YN`Ff1`9ZNbFd1]9\\NeFc1Z9^NgFa1Y9^NiFa1V9`NkF_1U9`NnF^1Q9bNQG]1o8cNRG\\1m8dNUG[1k8eNVGZ1i8fNYGY1g8gN[GW1d8iN^GV1a8jNaGU1_8kNbGT1]8lNeGS1[8mNfGR1Y8nNjGP1V8POkGo0T8QOnGn0R8QOPHn0o7SOQHm0^3hN\\N:WNn0]3kNXN8ZNn0^3mNTN5^No0]3oNSN2`No0]3POQN1bNP1\\3QOQNNcNR1\\3ROoIBm3;hNQ1\\3TOlMJhNS1[3TOlMJhNS1\\3SOlMIiNT1[3SOkMJiNT1[3ROlMJjNT1Z3SOkMIjNU1Z3TOjMGlNV1Z3SOjMFmNW1Y3SOiMGmNW1Y3ROkMFlNY1Y3QOjMGmNX1X3QOlMFlNZ1X3POkMGlNZ1Y3nNlMGlN[1W3oNlMFmN\\1W3mNlMHmN[1V3nNmMFmN]1V3lNmMHlN]1W3kNmMGmN^1U3lNmMGmN^1V3kNmMFmN`1V3jNlMFoN`1T3kNmMEnNa1U3jNlMEoNb1T3jNmMDoNb1T3jNlMDPOc1T3iNkMEQOb1S3jNlMCQOd1S3iNkMCROe1R3hNmMCQOe1R3hNlMCROf1R3gNlMCQOg1R3gNlMBSOg1Q3gNlMBROh1Q3gNlMASOi1Q3fNkMAUOi1P3fNkMATOj1P3fNkM@VOj1o2fNkM@UOk1P3eNjM@VOl1o2eNkM_OVOl1o2eNjM_OWOm1n2eNkM^OVOn1o2dNjM^OXOn1n2dNjM]OXOP2m2cNkM^OWOP2n2bNjM^OYOP2l2cNkM]OXOQ2m2bNjM]OZOQ2l2bNjM]OYOR2l2bNjM\\OZOS2l2aNjM[O[OT2j2bNjM[O[OT2k2aNjMZO[OV2k2_NjM\\O[OU2j2`NkMZO[OW2j2^NkM\\OZOW2k2]NjM\\O\\OW2i2]NlM[O[OY2i2\\NkM\\O\\OX2h2\\NmM[O[OZ2h2[NlM\\O[OZ2h2ZNnM[O[O[2f2ZNoM\\OZO[2g2YNoM[OZO]2f2XNPN[O[O[2g2ZNmM\\O[O[2g2YNoM[OZO\\2h2YNmM\\O[OZ2i2YNmM\\OZO[2j2YNkM]O[OY2k2YNkM]OZOZ2l2YNiM^OZOY2m2YNjM]OZOY2m2YNiM^OZOZ2m2XNhM_OZOY2o2WNhM_OZOZ2n2WNgM@ZOY2o2YNfM]O[OZ2[2]MiKl0`2^O\\OX2[2hM`Kc0h2\\O]OZ2[2kM\\K`0j2[O@Z2Z2mMZK>l2[O_OZ2\\2PNUK=n2YOAZ2]2PNTK=m2ZOBY2]2SOPNcNCZ2^2TOmMcNDY2_2UOmMaNEZ2_2UOjMaNGY2b2UOgMbNFZ2a2WOgM_NIX2c2YOcM_NIY2d2XObM_NKX2e2YO^M`NLV2h2ZO\\M_NLV2j2\\OXM^NOU2j2^OVM]NOV2j2^OVM\\N0V2j2@UMZN1U2i2CUMXN2U2k2CQMYN3U2l2CPMWN5W2j2BPMWN6X2j2BnLWN8V2l2BkLXN9V2m2CgLYN;U2n2CeLXN>U2m2CdLYN>T2o2DaLXN`0T2P3D_LYNa0R2R3E[LYNc0S2R3EYLXNe0S2S3EXLXNe0R2T3GULWNg0S2U3ETLXNg0Q2W3HPLWNi0R2W3HoKVNi0S2X3GnKVNk0R2Y3aMZJT2a1XNl0S2_3CdK[Nl0R2`3EcKXNn0R2`3G`KXNo0Q2b3G_KWNo0R2c3H\\KWNQ1P2d3I[KVNQ1R2d3IYKUNT1Q2d3KVKUNU1P2g3JTKUNU1Q2i3JPKVNW1P2i3JPKUNW1Q2j3KmJUNX1P2l3LkJSNZ1Q2k3LjJSN[1Q2l3MhJRN[1Q2o3LeJSN]1Q2m3NeJQN]1Q2n30cJoM`1P2m32cJnM_1Q2m33bJlMa1Q2l35cJjMa1P2l38aJhMc1P2l3:_JfMe1P2l3;_JeMe1o1l3>]JcMg1P2h3a0aJ_Mf1P2i3c0_J]Mi1o1`3kMUJj2a0\\Mi1o1`3P1fJQMk1o1_3Q1eJoLl1P2_3R1dJoLl1o1a3S1bJmLn1P2_3U1aJlLo1o1a3U1`JlLn1o1b3W1^JlLo1m1d3V1]JnLm1l1g3W1ZJnLn1k1j39WJQNOMo1i1k37]JoMI2m1h1o3TNQJ]1>cNC6n1e1Q4QNnIF3i1`0_O\\1Q1U4PNUJ]1=@X1S1W4oMWJ[1=BT1T1X4lMZJ^1;BQ1T1\\4hM[Ja1;Bl0U1_4fM]Jb1:Aj0V1X5XOQJAe0W1[5YOoIAd0V1]5ZOPJ@b0V1^5ZOPJA`0U1a5ZOPJ@?U1b5[OoIA=T1e5ZOoIC:T1g5YOPJC8S1g5\\OQJA7S1i5\\OQJA4T1j5\\ORJA3S1j5^OSJ_O1S1m5^ORJ@OR1n5@TJ]ONR1o5BSJ\\OLR1Q6DSJZOKR1Q6FSJYOJQ1R6ITJUOIR1T6ISJVOHQ1U6ITJVOEQ1Y6HRJXOCP1\\6HRJXOAo0_6HPJYO@P1`6HoIYO_Oo0c6HnIZO^Om0e6ImI[O\\Ol0i6HkI\\O\\Ok0j6JjI[OZOk0m6KhI[OYOk0o6KgI[OYOi0R7LdI\\OXOh0V7LaI\\OXOh0X7M_I\\OXOf0[7N\\I]OWOf0]7N[I]OVOe0`70XI[OXOd0a72VI[OWOc0f71RI]OWOb0h71oH_OWO`0k73lHe1U7\\NjHd1W7]NgHb1Z7_NeH`1\\7bNaH^1a7cN]H]1d7fNXHY1j7m21O2N2O0O2N1O101N1O1O101N1O2OYImIa4R6WKXJh4h5WKYJj4e5VK]Jj4a5WK_Ji4`5hJQKW5n4iJSKVOmNF9[5e5iKWKVOZOQ5^5\\KSJ_OW12ZOT5Z5[KiK^OUOR5Q5`KlKZO[OQ5h4fKmKVO_OT5b4fK\\MX4c2iK]MW4c2hK^MY4`2gKaMY4^2hKbMZ4[2fKfMZ4Z2fKfMZ4Y2[KeJBS3S5W2[KUNf4i1ZKXNg4g1YKYNg4f1YK[Ng4d1YK]Nh4b1hJhJ:g3n4g1QKYNP5i1lJXNU5h1iJYNW5i1gJWNZ5j1cJWN^5e5001O00001O001F_JmF12`5l8`JRG0O11a5g8aJZGMNl5d8=O1O1O200L300O2O00010ZOaIhH`6V7dIgH^6U7eI`HE9f6U7kIhHV6U7oIiHR6T7PJhHXO2i6R7Q1N3L3M4L3N3M2M3N3M3M2M3N3L3N3L3L5M2M4M2M3M4M2N3L3N3L3O2OfEaKS:g400OAnEQLQ:l3SFTLm9g3WFZLi9^3^FcLa9Z3bFgL]9V3fFkLZ9R3hFnLX9o2kFQMV9k2mFUMS9i2oFWMQ9f2RGZMo8c2TG[Mm8c2UG]Ml8`2VG`Mj8]2YGcMh8Z2ZGfMV2", "size": [480, 640]}, "area": 105680.0, "iscrowd": 0, "image_id": 10083, "bbox": [0.0, 122.0, 640.0, 358.0], "category_id": 165, "id": 10012256}, {"segmentation": {"counts": "0n62VJj6[5VInI0h0i6Z5[IjILm0h6Y5aIdIHT1f6X5hIhJX6W5jIkJS6V5mIjJR6T5QJlJn5V5QJkJm5W5SJhJl5Z5SJgJk5[5UJfJh5[5YJeJe5]5[JcJc5_5^J`J`5c5_J`J\\5b5dJ]J[5e5eJYJ[5i5eJUJ[5j5iJSJW5l5lJQJU5o5oJlIR5S6QKkIo4W5oIkJS1Mn4X5PJiJU1Ll4Z5QJiJU1Kj4\\5RJgJW1Jh4^5RJhJX1Ie4_5TJgJX1Id4_5VJfJZ1H`4b5WJeJZ1H_4b5YJdJ\\1F\\4f5XJdJ^1C[4h5YJcJ_1DW4i5ZJcJa1DS4h5_JaJb1En3j5dJ]Ja7b5dHYJ]7g5n000O100O100O10000O12N3M5K2N001O1O1O001O1O001O1O1O1O000000001O3MOhGdIn7\\6QHhIl7h6N2N1O5SHjHf7X70001O0000O1K51O0000O1002N1O1O2N2NO`HfH\\7b7M3M2N2N2N3M2N2N00O100O100O10000O100O1O1O100O1O1VJlHg3U7YLQI`3P7`LWIX3j6hL\\IQ3e6nLbIj2`6VMfIb2\\6^MjI[2W6eMoIT2R6kMVJm1k5SN[Jf1f5ZN`J^1b5bNdJX1\\5hNjJo0Y5POoJj0P5VOVKe0i4[O]K`0b4@dK;[4DlK8R4HTL3k3M\\LMc33cLI[36lLFR3:TMAk2?[M\\Od2d0cMVO\\2i0kMROT2n0RNlNn1T1XNfNh1Z1^N_Nc1a1cNYN]1f1eNYN[1g1fNXNZ1h1o500O1000000O1000000O100000000O1000000O1000000O100000000O1000000O1000000O1000000O100000000O1000000O1000000O1000000O100000000O1000000O1000000O100000000O1000000O1000000O1000000O100000000O1000000O1000000O100000000O1000000O1000000O1000000O100000000O1000000O1000000O1000000O100000000O1000000O1000000O100000000O1000000O1000000O1000000O100000000O1000000O1000000O1000000O100000000O1000000O1000000O100000000O1000000O1000000O1000000O100000000O1000000001O001O000hC:V9GTFn0l9RO_Ec1a:]NkDW2U;j001]DmLW;S3hDnLX;S3gDnLX;]300hDZLV;f3jDZLV;h30O1002N001O1O0000O10000O11O000000001O001O00001O0000O1O100O1O11O001O001O00001O001O1O0_EQLC0[:P4mEYLQ:g3kE\\LV:W4000000000001O1O00000000001OO1O1O1O1N2O1O1O1O1L4O1G`ERL`:l3;00O100hNPEiMO6R;o1REhM25l:Q2VEbMH08;k:R2SFbMn9[2]1N2N21]EjMZ8V2bGhMRN3[:U2cGQN[8P2cGSN[8m1bGVN^8j1_GYNa8g1]G\\Nb8d1\\G^Nd8c1[G]Ne8c1[G\\Nf8f1XGZNh8h1oF_NQ9d1eF`MROP1Y:d1^FbNb9a1ZF`Nf9`1ZF^Nh9b1XF^Nh9b1XF]Ni9c1WF\\Nj9d1VF\\Nj9d1VFZNl9f1TFZNl9f1TFYNm9g1SFXNn9h1RFVNP:j1PFVNP:j1PFVNP:j1PFWNo9]301O0000001O0000001O1O001O0000002N1O00001O00001O1O1O001O1O001O00001O0000001O001O00001O1O00001O002N00001O00001O002N0000001O1O00001O001O1O001O1O001O00001O001O00002N0000001O1O00001O00001O001O00001O1O001O001O001O00001O1O00001O001O001O001O00001O001O001O001O001O00001O1O00001O001O00001O001O001O", "size": [480, 640]}, "area": 78263.0, "iscrowd": 0, "image_id": 10083, "bbox": [0.0, 0.0, 640.0, 288.0], "category_id": 172, "id": 10012257}, {"segmentation": {"counts": "P\\g12n>6J7I6I7J6J6J6I8I6J6J6J6I8I6J6J6I7J6J7I6I7J6J6J7H7J6]HjJP5\\5iJgJU5_5cJdJ\\5b5\\JaJb5a5\\JbJb5_5\\JcJc5^5\\JcJc5]5\\JeJb5]5]JeJa5\\5]JfJb5[5]JfJb5[5\\JgJb5[5]JgJa5X5_JjJ`5V5`JkJ_5U5`JmJ^5S5cJoJ[5Q5dJQK[5n4fJSKY5m4fJVKX5j4hJWKV5i4jJYKU5g4kJZKT5f4kJ]KS5b4nJ_KP5b4oJ`KP5_4QKbKn4^4QKeKm4[4SKfKk4Z4UKhKj4X4VKiKi4V4WKmKg4S4YKnKf4R4YKPLe4P4\\KQLc4o3\\KTLb4k3_KVL`4j3_KXL_4i3aKYL]4f3cK\\L\\4d3dK]L[4c3dK_LZ4a3gKaLW4_3hKcLW4\\3jKeLU4[3jKgLT4Z3lKhLR4W3nKkLQ4U3oKlLP4S3PLoLo3Q3QLQMl3P3SLRMl3m2ULTMj3l2ULWMi3h2XLYMf3h2YLZMf3f2ZL[Me3d2[L_Mc3a2]L`Ma3a2^LaMa3^2`LcM_3]2`LcMa3\\2`LdM_3]2`LdM`3\\2`LdM`3[2`LfM`3Z2`LfM`3Y2`LhM_3Y2aLgM_3Y2`LhM`3W2aLiM_3W2`LiM`3W2aLiM_3W2`LjM`3V2`LjM`3U2`LlM_3U2aLkM_3U2`LlM`3S2aLmM_3S2`LnM`3Q2aLoM^3R2aLnM`3R2`LnM`3Q2`LPN`3P2`LoM`3Q2`LPN`3P2`LPN`3P2_LPNb3o1_LQN`3P2_LQNa3n1`LQNa3o1^LRNb3n1^LRNa3n1_LRNb3n1^LRNb3n1]LSNc3l1^LSNc3m1]LSNb3m1^LTNb3l1^LSNc3m1\\LTNd3k1]LUNb3l1]LTNd3k1]LUNc3k1\\LVNd3j1\\LUNd3k1\\LVNd3j1\\LUNe3j1[LVNf3j1ZLVNBULe3e5hLVNCWLc3c5kLVNBXLb3b5kLVNC[L`3_5mLVNB]L`3\\5nLWNC^L]3\\5PMVNBaL\\3X5RMWNCbLZ3W5SMWNBdLZ3U5SMWNDeLW3T5VMVNChLV3R5WMVNBkLU3n4YMWNClLS3m4ZMWNBnLR3l4[MVNDoLP3j4]MWNBQMP3h4]MWNDRMn2f4_MXNBUMm2c4`MXNCWMk2b4bMWNCXMj2`4cMXNCZMi2^4dMWND\\Mg2]4dMXND^Me2Z4hMWND`Mc2Y4hMXNDaMc2V4jMXNCdMb2T4jMYNDdM`2T4lMWNDgM_2Q4mMYNDhM]2o3oMXNDkM\\2l3PNZNDkMZ2l3RNXNDnMY2j3RNXNFoMW2h3TNYNDRNV2e3VNXNDUNU2b3WNZNDUNS2b3YNXNDXNR2`3YNYNEXNQ2^3[NYND[NP2\\3[NZNE\\Nm1[3^NXNE_Nl1X3_NZND`Nl1V3`NYNEbNj1T3aNZNEdNh1S3cNYNEeNg1R3cNYNFhNe1n2fNZNEiNd1m2fNZNFkNc1j2hN[NDmNb1i2iNZNFlNb1j2hNZNEmNc1h2hN[NFlNc1i2gN[NEmNc1h2hN[NFlNc1i2gNZNFmNd1i2eN[NFmNe1g2fN[NFmNd1i2fNZNEmNf1i2dNZNGmNe1h2eN[NEmNg1h2cN[NGlNf1i2dN[NEmNg1h2cN[NGlNg1i2bN[NFmNh1g2bN\\NFmNi1g2aN[NGmNh1h2aN\\NFmNi1g2aN[NGmNi1h2_N\\NGlNk1g2_N\\NGmNi1h2_N\\NGlNk1g2_N\\NFmNl1g2]N]NGlNl1g2]N\\NGmNl1g2]N\\NHmNk1g2]N\\NGmNm1g2\\N[NHmNm1g2\\N\\NFnNm1g2]NZNFoNn1f2]N[NEnNo1g2\\NZNEPOo1f2\\NZNEoNP2f2\\NZNDPOP2g2\\NYNDPOP2f2]NYNCQOQ2f2\\NXNCSOQ2e2[NYNDQOQ2f2\\NXNCROR2f2[NXNCROR2e2\\NXNBSOS2e2[NXNBROS2g2[NVNBTOS2e2\\NWN@TOU2e2[NVNATOU2f2ZNVN@UOV2d2[NVN@UOU2f2[NTN@WOU2d2\\NUN_OVOV2e2[NTN_OWOW2e2ZNTN_OWOV2e2\\NSN^OXOW2e2[NSN]OXOY2d2ZNTN^OXOX2d2ZNTN]OXOY2e2ZNRN^OXOY2e2ZNSN\\OYOZ2d2ZNRN]OYOZ2d2ZNRN\\O[OY2d2[NQN[O[O[2d2ZNPN\\O[O[2d2ZNQNZO\\O\\2c2YNQN\\O[O\\2d2XNQN[O[O]2d2XNQN\\O[O\\2d2XNQN[O[O^2c2WNRN[O[O_2c2VNRN[O[O_2c2UNRN\\O[Oa2W2^N]NRO\\O`2c1QORO^N[Oc2m0CHkMZOc2:6TGAn8=RGCP9;QGEo8;PGER99nFGS99mFGT97lFIV96jFIW96iFKX94hFKY94gFMZ91fFO\\90dFO]90cF1^9NbF1_9NaF2a9M_F3b9K^F5c9J]F6e9H\\F8d9F]F:e9D\\F;f9CZF>f9A[F>g9@YFa0g9^OZFa0h9]OXFc0j9\\OUFe0k9ZOVFe0l9ZOSFf0n9YOSFg0n9XOQFh0Q:VOPFi0Q:WOnEj0S:TOmEl0T:SOmEm0T:ROkEn0W:POjEo0W:QOhEP1Y:nNhEQ1Y:oNfEQ1\\:mNdET1]:kNcET1^:kNbEU1`:jN`EV1`:iN`EW1b:hN^EX1c:fN]EZ1d:eN\\E[1f:dNZE\\1f:cNZE]1h:bNXE]1j:aNVE`1j:`NVE_1l:_NTEa1m:_NSEa1n:]NREc1P;\\NoDe1Q;ZNPEe1R;ZNmDf1T;YNmDg1T;XNkDh1W;VNjDi1W;VNiDk1X;TNgDl1Z;SNgDl1[;SNdDn1];PNdDo1];QNcDo1^;oMdDo1];QNdDm1^;QNcDo1`:QNdEOMn1^:YNaEH3m1\\:_NZF`1e9cNZF[1f9hNXFW1h9lNWFS1i9nNWFP1i9SOVFl0j9VOTFi0l9ZOSFd0o9[ORFd0n9\\OSFb0n9_ORF?o9AQF?o9BQFZ49XJY3c1`L]4LRJc3_1cLi4]OjIR4\\1bLW5[3iJeLZ5X3fJgL[5Z3dJfL\\5Z3dJdL_5\\3bJbL^5^3bJcL]5]3dJbL\\5^3eJaL[5_3fJ`L[5g0RI]1d1jMc5:dH[O<;HH5^1^1kNX3E]Ma0SNCAKf0b0E1[1Ig2EmKOH8NH64c1=FOnN2Y1Ld2T1WL_N;>e0OnN3V1Nd2V1ULaN;5l0J\\NKd0>Q11^2AoKg19fN7C]O0n11RN1h0;o03[2CnKe12ZN1?b2_OXN;j04\\2\\2@_MVN4Y2^2C[MVN7V2]2FYMUN;T2_2EUMYN;R2`2FRMXN`0Q2_2h1_MXNb24`MPMNk2a25bMSLBKMO1a0>]3`23dMULG:5]3b2UMRMVO4n1?jMI`0O^3d2RMRMROL2=k1k0aNUO]3h2QMRMROJ1e06ZOW1Y1SOSO[3n2WLhL`0^1^O`N`00@0?Z1@fN90H?j3Z3`LRNJ_N7Q2[3fMYLc6:iK[3[4cLgK]3X4cLiK\\3\\4^LeKc3R7NO02O00001O00N13\\O`F\\M`9c2fFXMY9h2hFWMX9j2c0O11N11O1N11O000001OOYMgEa2`:04YN_E@OB00Nb0i:2aE[OG0;0Kc0a:N`F_OhNmDAL17=KE^;;SEN@D_;?PEC@1h;V8EfG=Y8HaG9_8I^G9`8I_G7a8J^G6k6VOWIe0M6k6XOTId0JYOkNj0l6YO^IM68e0a0O:`4nNZK8nNH5OJ0b0:e0f0SOPO91_OR1g5nNWJO0010c0m0\\OUO`079L\\Oo04mN7Y1;hNo3=iKc0]OPO59b0F@W1MmN;V15nNP4=mK`0CVOLFa0d1_OZN15:Y15QOY3OcL72W1I?3UO3ROJCP3R9BYF0n11RN1h0;S;CRE;n;O3M2M2O2MRm_6", "size": [424, 640]}, "area": 22110.0, "iscrowd": 0, "image_id": 10084, "bbox": [17.0, 0.0, 120.0, 408.0], "category_id": 113, "id": 10012262}, {"segmentation": {"counts": "fVU52P=1QC1k<8MFXC:h<3N21O00M33M00O100001O00O11O0000JB`C`0a<3M32N1O1O00M3M300O1HWORDh0n;]OmCc0S<91OKPOPDR1i;:N2M3O10000L4O1DZNTENJh1P;]NUEKLg1n:`0M3JhM]EW2b:80_M\\E^2f:1J63MO100M31O00M[MbEf2S:=1O00MoLoEQ3Q:3N2O1001O001O1OO1002N00O12NO11OO1O100NkLQFU3n9lLRFT3m942N0000O1001O1O1O00O12N0000O100M33M00O13MN2O100000000O100O11O1O000RNQFc0o9[OPFkN2h1n9\\OVFd0j9ZO[FmNFc1o9^O]FPOD7OP1P:H^FROC22T1m9IcFPO]OO2Y1o9EoEROf00\\O2NS1R:POnEa0h0[OYO10>i:@WE3ORQ;@nDL17=KEk0n:F[E@Dk0S;DoD@1T1P;]OmDA0T1S;j012NO100001OO1O020O0N012AkD^N43R;_1>O0O1O100000O1001N01000O20O1O1O1O00000O0102N00N`N\\D_1b;aN_Db1_;`N`D_1`;bN`D_1Z;_NfDg1V;80A?00O11O0000O1001OO1000000000000O12N0000O1O11OO1O100O11OO100O1O100HVDmN00l;R170000M3002N1O002N00000000O10000^OnC_OO009U<6TDHl;8ZDAg;>b0001OO100000000000000O1002NO12N1O1O00M31O1ON200001OO1O1N200O1O10000000000O1004L1O00O1O100O1O100O1O100O1O100O1O100O1O100O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000`V_1", "size": [424, 640]}, "area": 8123.0, "iscrowd": 0, "image_id": 10084, "bbox": [175.0, 0.0, 351.0, 132.0], "category_id": 125, "id": 10012264}, {"segmentation": {"counts": "0Sl;BSDa0k;_OUD`0l;@SDb0l;^OTDb0l;^OSDc0m;]OSD`0FBVfb0_4Q3ZMZMgMRO00a0c0^4S3XM\\MiMQO114?i4W3RMWLPNX11lN2>j4\\3nLgMWNmNj4^3mLgMXNkNj4`3mLeMYNkNj4a3kL[NT3i1hLXNW3l1fLTNY3U2^LlM_3X2`LhM`3X2_LiMb3V2]LkMb3W2\\LjMd3R2_LoM`3S2^LnMa3S2^LnMb3V2eK_KO[2[4m5O100O1O1O1O100O1O100O1O100O1O1O1O100O1O1O1O100O1O100O1O100O1O1O100O1O1O100O1O1O100O1O1O100O1O100O1000000O1O100O1N2O1O100O1O1O1O1O1O100O1O100O1O1O100O1O1O100O1O1O100O1O1O100O1O1O100O1O100O1O1O1", "size": [424, 640]}, "area": 37032.0, "iscrowd": 0, "image_id": 10084, "bbox": [481.0, 76.0, 159.0, 348.0], "category_id": 148, "id": 10012267}, {"segmentation": {"counts": "eiP2Y14QOi:R2]Ob0O2N1O2N2O0O2N1O2N2O0O:F;E1O100O2N1O1O101N1O001O100O2N1O100O2N1O101N1O100O2N1O100O2N1O100O1O101N1O1O100O1O1O010O00100O1O1O100O2N100O1O1O100O1O2N4M0O1O01N1O11O100O1O1O100O1O101N1O1O100O1O2N100O1O010O000010O0001O100O1O100O1O1O100O000010O00010O01O00M4N11O01O00000010O002N2OO00001O00000010O0000K6N100O2O000O101N100O1J7O00001O0000001O00001O00001O00001O00001O00001O001O00001O00001O00001O00001O00001O000O2O001O00001O00001O00001O00001O00001O00001O0O2O00001O00001O00001O00001O00001O00001O00001O0O2O1O1O100O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O001O1O1O1O1O1O1O100O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1N2O1O1O1O1O1O1O1O1O1O1O1002N1O1O0000O10000O100O10000O100O1O100O100O100O1O100O100O100O1N2N2M3N2N200O1O1O1O100O1O100O1O1O100O100O100O100O100O10000O100O1O100O1O1O100O1O1O1O100O1O1O1O100O1O1O1O100O1O1O100O1O1O1O100O1O1O1O100O1O1O100O1O1O1O100O1000000000000O1O1N2O100O100O100O100O100O100O100J600O100OPb`0", "size": [424, 640]}, "area": 56436.0, "iscrowd": 0, "image_id": 10084, "bbox": [156.0, 1.0, 444.0, 303.0], "category_id": 183, "id": 10012268}, {"segmentation": {"counts": "\\S71c?1N2f@MQ?4n@LR?5m@KR?7m@JR?7m@IS?8l@IR?9m@GS?9m@HQ?>O2M2M4M2M3NL4K4M4O10O100O10000O2O0O10000O10001N100O10000O2O0RDGc89[Gg0f7ZOYHn0`7RO^HX1Y7iNeH`1T7`NkHh1n6YNRIm1f6TN[IR2UNfMk68RKX2dMlMU7LXKf3c4[L^Ki3]4WLeKl3U4ULlKn3P4SLQLP4j3PLWLR4e3oK\\LS4a3mKaLT4[3mKfLU4W3kKkLV4R3jKoLX4m2jKTMW4i2iKXMY4e2gK]MY4`2hKaMZ4\\2fKfM[4W2eKjM]4S2cKoM^4n1cKRN^4l1bKUN_4i1aKYN_4e1aK]N_4a1aK`N`4^1`KdN`4Z1`KhN`4V1aKjN`4T1`KkMnNWNb5l3`KjMZOSNV5Q4`KhM@WNP5o3`KgMEYNl4n3_KjMGWNj4n3^KmMHUNj4l3_KoMHSNk4l3]KRNJPNj4l3\\KUNKmMk4c3RJXLX1Z2KjMl4`3TJ[LU1\\2LgMm4^3VJ]LQ1_2NaMo4_3VJ_Ln0b2X6l0XJVOh5h0XJZOh5c0YJ_Og5>ZJDf5:ZJHf57YJKg54YJMf52ZJ0c52\\JOb52^J0_52`J0Z54fJNT58jJJo4<_I^LV1W3X5=bI[L[1U3R5a0bIYLh1l2e4k0cIXLP2g2\\4Q1cIXL^2\\2n3b1dLnM[3Q2hLnMW3R2kLlMV3R2mLmMS3Q2PMnMP3P2SMoMm2o1VMQNi2m1ZMRNf2l1\\MUNb2j1aMUN_2i1dMWN[2g1hMXNX2f1kMYNU2e1nM[NP2d1TKhL`1d1kN]Ne2U3PMlLa1b1hNaNd2o2TMnLb1b1eNdNb2k2VMQMd1`1bNgNb2f2XMTMf1^1^NlNb2`2ZMXMf1\\1]NnNa2]2\\MaM`1T1bNQO`2X2^MkM[1k0eNUOa2S2_MUNU1c0jNWOa2o1aM^No0;nN^O]2g1fMhNi03oNDoNkN[3e2mMQOe0K_N6H`Nm2_2UNUOd0G_N5NcNf2\\2WNXOe0D^N44gN^2Y2YN[Og0A\\N39oN_O2j1P2ZO]Og0@[N1?IS1Z1ZO_Oi0\\OZN0d0YOYOAe1[2YOBj0ZOXNOj0UO]OB\\1_2YODk0XOWNMo0QOCCn0g2]OBl0UOVNLT1oNF93S2OGm0b0_OVMI71X2IKm0=DUMM3N^2B0n08HRM21Jd2]O3o03m2JRL5Q11m2JQL6R10m2KnK7U1Nm2NjK5Y1Ln21eK5]1Jn23bK4`1Io25\\K4e1Go2]3QMbLP3^3PMbLP3_3oLaLQ3_3oLaLQ3_3oL`LR3`3nL`LS3_3mLaLS3_3mLaLS3_3mL`LT3`3lL\\KVObNn3R6lL\\KVObNn3R6mL[KUOcNn3R6mLZKUOdNP4Q6kL[KUOdNP4Q6kL[KUOdNP4Q6kL[KUOdNP4Q6kL[KUOcNQ4R6jL[KUOcNS4P6hL]KUOcNT4o5gL^KUOcNV4m5eL`KUObNY4l5bLaKVOcNY4k5aLbKVOcN[4i5_LdKVObN]4i5]LeKVO`Na4h5ZLhKh4V4XKjKi4U4WKkKk4R4VKnKk4Q4UKoKi4R4YKmKf4T4ZKkKf4U4[KkKd4V4\\KjKb4W4_KiK`4X4aKgK^4Y4cKgK\\4Z4dKfK[4[4fKdKX4]4iKcKV4^4jKbKU4^4lKaKT4`4mK_KQ4b4PL^Km3e4SL[KnMfNh5P6\\L^Ka3e4_L\\K^3f4bL[KZ3g4hLYKU3i4kLXKR3i4oLXKm2k4TMTKj2n4WMRKe2P5]MPK`2R5aMnJ[2T5fMmJW2U5jMkJS2W5nMhJo1Z5SNfJj1\\5WNdJe1^5]NbJa1_5`NaJ^1`5cN`JSN_N[2P7D`JoMcN[2n6G_JlMeN\\2l6I_JiMgN\\2k6L^JeMjN^2h6N^JbMlN^2g62\\J]MPO`2d65ZJZMTO_2c69XJVMXOP1]O1S7l1VJPM]Oo0A0m6S2TJlL@n0EOg6Y2SJgLDm0INa6a2PJbLHk0NNZ6g2nI_LLh03MT6n2nJRMTOLn5U3lJkL]OKh5`3fJaLIKa5l3`JTL6K[5Y4XJhKQOk0Z7d3_I^KVOY1R7b3QJhLh5`3lIiLo5\\3iIlLR6Y3eIoLW6U3bIkMa5[6I6J6J3M4L4L3M4L4L3M4L4L5K5K6I6K0000000000000O1000000O1000000O10000O1000000N2M3aN[DlNh;S1]DgNe;X1`DaNc;^1cDZN`;e1eDUN];k1U101O1AYBPOh=P1XBoNi=Q1XBnNh=R1XBmNi=R1YBlNh=T1XBkNi=U1XBiNi=W1WBiNi=V1YBhNh=X1XBgNi=Y1900O1000000O1000000O1000000O1000000O1000000O1000000O10000000O10000O100N2N2M4M2M3N2M3N2M3N2M3M3M4L3M3M4K6K4L5K4K5L5K4L5K4K6K4L5K4L4jKeKmL`4\\MYK`4:nMa4aMYK]4O`J6[3g4eMYKHKf3NdK9S3i4jMYKALm3IfKd0`2e4ZNoKi2fNnL2@g0T2j4dNgKj2gNmL1Bk0h1m4mNbKi1dN]N3AOEo0[1P5YO\\Kh1eN\\N2BNG4:7d0k5CVKj1fNZN1AOK0<<5o5OPKi1gNXN2@M1N=`0FR6:lJi1gNSN5CJ5J?f0VOV6f0dJi1iNoM9EEX1[7[OoIh1jNiM=IA]1W7XOSJh1jNdMk0]1X6VOSJi16QOg5UOUJi14ROg5UOVJh12TOi5ROWJh11VOh5ROWJh11UOi5ROXJh1OVOj5POYJi1MWOk5mNZJm1JVOm5jN\\JP2FVOo5gN^JS2AWOR6cN_JW2^OVO_8j0`GVOa8k0]GUOc8l0\\GTOe8l0ZGTOg8l0WGUOi8l0VGTOk8l0TGTOm8l0RGTOo8m0oFROR9o0mFQOT9o0kFPOW9P1gFQOY9P1fFoN\\9Q1cFoN^9Q1aFoN_9R1`FmNb9R1^FnNc9R1\\FmNe9T1YFmNh9S1WFlNk9S1UFmNl9S1SFlNn9U1PFlNQ:T1mElNU:S1jEnNV:S1iElNY:T1eEmN\\:S1bEmNa:Q1^EPOc:P1[EPOh:n0XEQOj:n0UEROn:l0QETOR;l0kDTOW;l0gDTO\\;l0`DUOb;k0[DVOh;Y2PM\\LSJb3j5eLnHEAc3_7nLjHCH\\3[7XMfHAOU3X7aMcH^O6n2T7kM`H[Of9BZF>f9CYF=g9CYF1YEJZ:8dEH\\::aEF`:;_EEa:=]ECc:a01N10000O01000O01001N5L4L4L00`J", "size": [360, 640]}, "area": 9280.0, "iscrowd": 0, "image_id": 10097, "bbox": [30.0, 109.0, 610.0, 94.0], "category_id": 124, "id": 10012272}, {"segmentation": {"counts": "b4_3i701O001O00001O0000001O0000001M2000001O00001O00001O3M00000O1O011OO10000O100O1000000O101N101N100O1O100O10000O10000O0DeLlH\\3S7gLjH[3T7gLjH[3U7fLiH[3W7fLgH[3Y7:0000001O000000000O10010O000010O0O010000000O10000000001O00000O10000O10000000000001O000000001O000000000000001O00000O1O1O2O0001O0000000000000001OO110O00000000000001O0000000000000O2O00O100000000001O1O001O00001O001O00001O0000O10000O10000O001000000O1O1L\\LcHe3\\7_LfH\\3Y7bLeHM4`3X7`LlH`3_7O001N11O01O0000001O00001O00000000000000001O0000000000001O0000001OO11O00000000001O01O000000000000000000000000000000O2O00000001O1O10O000XOSHUNl7j1WHUNi7h1[HVNg7g1\\HXNd7f1^HZNb7d1aH[N_7c1gHXNZ7f1]HoMM:g7d1[HWNL5i7b1[H]NJ1k7:[H40DINl77cH0IMGLm74lHK@8E0i7J[IFWOc0CO1B`75UJY1j5fNWJ[1i5dNWJ]1k5`NTJb1l5]NTJd1l5\\NRJc0]N9a7SORJa0bN;U9@QG?o8]OVGb0j8XO]Gg0c9OUNXOWIg0_6GPIDQOd0e76QI\\OYO?b7=lHZOA8b7c0dH[OI2c7g0\\H\\O0Me7e21O001O001O00001O1O1N101O1O00001O00100O1O001O1O00O01O100000O1O1N3N100O10000O11O1OO10000O10000000000000000001O2N1O1O1O00000000N2O1O100THkLd7V3\\HjLd7V3\\HkLd7T3\\HlLc7U3]HkLd7k0WHj1c7gM^HM1[2b7fM^HN1\\2b7eM]HN2]2b7dM]HN1^2c7`M`H0N`2c7^MaHMG07e2b7\\MmHc2l700000jN\\MhId2Y6\\MfIe2Z6[MeIe2\\6[MbIf2`6ZM^If2c6ZM\\Ie2f6[MYIe2e7000^N[MQI0d004e2W6]M[JNgNf2m6^M[Je2d5]M[Jc2e5_MYJa2g5_MZJ`2e5cMZJ\\2f5dM[J[2e5eM\\JZ2e5eM\\JZ2d5fM]JY2c5gM^JX2a5iM`Ja0dNg0l6hNbJ=dNk0k6fNcJ;fNn0g6gNTJG]O`0KR1d6gNUJG\\O>LT1c6gNUJH\\O;NU1a6hNWJGZO:OW1a6fNWJKXO61Z1a6cNVJKlN0<63[1`6bNZJMTO33^1o7_NnG05a1m7aNaH]1a7dN_H[1^7iNaHV1_7lN`HT1_7nN`HR1`7PO]HQ1b7QO\\HQ1c7PO\\HP1d7QOZHP1g7POWHQ1i7QOUHo0k7ROSHo0m7RORHn0n7SOQHm0o7UOPHj0P8XOnGh0R8YOmGg0S8[OkGf0T8[OlGe0S8]OkGc0U8_OiGa0W8@iG?W8ChG1EW:m0G9N200O1040oN]F6j9\\O^Fa0V:L[ECf::6N5K1O]ab05\\^]O8RFDf8`0kF^OH4[2L[4V1XIQO5Kg1Nl4V1XIVO0Gk1Mk4Y1YIUONGm1Kk4Z2TKfMl4Z2cJfMdN2O21Li6[2iIPOV6R1cISOV6S3O100000000000`McI5]6ClI9CkMa6j1nI0DYN0L^6j1PJMNYNR6j1PJVNC9070J=FW6;\\I61ELJY1:e9J_YP4OdfoK4L3M2GDcE=X:KdE7[:;0010O0O0001000NK7N3M002O2OO0200O00O1001O00VN", "size": [360, 640]}, "area": 3265.0, "iscrowd": 0, "image_id": 10097, "bbox": [156.0, 0.0, 484.0, 150.0], "category_id": 132, "id": 10012274}, {"segmentation": {"counts": "Xei03U;5K4L1O000000000000001O001ZFB`8>^GETOMV9`0bGFVOMV9l8o002N000000O1O1O10000O10000N2N2N2O100O1000000001O00O1K5K5L4N20000O1001OO11O00O1G9M3N2N2FoE\\OR:b0;00O1O11O0000001O00001O2N3M3M1O001O001OO1O100O100O1O1N2K5N2O10000O100O100O100000kEE]9<_FB@4P:;^FHb9:[FHd99ZFHf9=TFEk9l001O001O001O00O1O1O100O1O10000O11O00001O2N1O2N1O0000QO^F9a9DgF8X9HlF4T9KU100N2O1000000Iok36]iKN61ELX9j1M1OO100O1000000001O001O00O1000000O10000O100O100000000001O001O1O0000O1O1000000O1O1HeFaN]9\\19O11O0000000000O1000000001O;E2N001O00001hFWNo8i1PGYNo8Q2O000000O1000000000000001O1O0SGnMd8\\2O1O1O1O0000O100000001^M\\G^2d8bM]G]2h801cNVG8k8FVG:l8CUG=l8AVG>k8@WG?k8QOTGL5S1e902O0OO101N11ON12O0O2N101O1N101O1O001N2O001O1O001O0O2O1O001O1O0M]EG^:8eEE\\:9hEDX:;U6a3PJ_Lo5^3fITL;=P6^3UJaLk5_3UJaLk5^3VJaLk5_3UJaLk5^3WJ`Lj5`3UJaLk5`3UJ_Lk5a3UJ_Lk5c3SJ\\Ln5d3RJ\\Ln5d3RJ[Lo5d3RJ\\Ln5c3SJ\\Ln5d3SJ[Lm5d3TJ[Lm5d3TJ[Lm5d3VJZLj5e3m000O1O100O1O100O1001O1O001O00O100O1O1O1O1O4M5I6K2O02N3M1O001O1O2ON13NiMSHR1l7lNWHTOMh1n7POXHVOMg1k7TOYHSO3c1c7[OZHQO5b1b7\\OiHb0W7_OiH`0Z7_OeHa0[7_OeHa0[7_OfHa0Y7@fHa0Y7^OiHa0W7\\OmHc0S7XOSIh0l6VOWIh0j6WOWIi0i6UOZIk0e6SO\\In0d6QO]In0f6dNoG:[1Q1S7eNmH[1`802M1N2000O2N2N10001N101O1M2N3M2O01N1011O000001O0O00L5K5L4N5M2N2M8UG_Ma8e20OO11O01N1G9M3N2N2FoL\\HR3b7;01N1OL6BZHnLP8[2]HdMn7n1m0G:M200O2OiGlN\\6V1cHfN63Z7\\1RHiNa0L`7k1\\HjMC;R8k1XHYNi7h1UHYNl7j1oGVNR8j1mGWNT8^2O1O10O0100O2N1N4I:I5L01000O10O001LcH\\L]7d34O1O1RM^HV2c7fM[H@4h2c7fM`HY2c7dM_H[2b7cM_H]2f7]M\\Hc2T8010O100O100O1N2N1O101N1O101OO002N100O2M4N1O2N10O1O01O1eMaGl1`8QNbGn1_8PNdG5KZ1a8aNiG0G_1`8`NkGNGa1^9N1L\\FdNe9b0o0I\\^2HiaM9\\GCY6?\\IDYN0Y8>ZINf62cGC9070J=R8i0nGKS86gGMZ8`1O101N1000000001O010O00O01001O0O10000O2O0O10000000O1O2O02OO1O000D;M30100000O1O1HeMaG]2\\89O11O01O1O1O4L2M1000002N1019F1N001O00001YMfG^2Z8aMhG^2b8O0001O0O100000O100O1^N\\G`0d8@`Ga8A`G?`8AaG7f8H\\G6d8J]G5c8M]G1b82]GMc84^GJb88^GDd8=\\GAe8a0[G[Og8g0XGVOj8k0WGQOl8P1e01O2N2N1O2O1N101N1O2O1N1O1N2O2MM3O200O010O10ZH_Ne5a1jH`Nb00ZO1Y7_1kHbN?O\\O1Y7`1jHbN`0M\\O2Z7_1jHcN?M\\O1[7`1jHbN;1^ON]7_1kHcN72\\OG07b7]1mHbN3`0o6n0mHdN2?Q7m0lHfN4;o6P1lHgN58o6Q1kHiN65o6R1kHjN63o6S1kHkN61o6R1lHoN5MP7T1kHQO4JW7n0fHYO3HW7n0gH[O3EV7Q1fH\\O3BW7R1gH\\O2AX7S1eHeNCO0d0`0DX7T1eHeNEe0=]OANi7[1dHdNGf0;\\O^7Y1gH[OK[O^7Z1iH[OHZO_7[1iH\\Of7e0[HZOd7f0^HYOb7f0_HZO`7f0aH[O]7f0cHZO\\7h0dHWO\\7h0dHYO[7g0gHXOX7g0jHZOT7e0nHZOR7f0nH[OR7d0nHfNoNd0S8e0UIYOi6h0WIWOi6k0UIUOjN@n7[1YIXOg6g0ZIYOe6h0[IWOe6k0YIUOg6IUHb0U1Ai6LTHb0S1SOoN6l73UHb0Z1XOb65WHb0Y1VO`67YHb0\\9]OgFa0]9[ObFg0n9100O1O1O001O1O01O0002N1O1O1O010O001O1O001O100O1O001O1O1O010O1O1O1O1O1O100O2N1O1O2N2iFYNj8h1UG]Ni8b1VG_Nj8b1SG`Nl8o1O001N1000000O10000000000000O11O001N1O2M3N1O2N101O000001O0000O10000001O3M1O1O2N2N6I101O1O001O0000001XOoFVOQ9j0QGTOo8m0SGPOm8P1TGoNm8P1TGoNl8R1TGnNl8R1TGlNn8S1VGiNk8W1UGhNl8X1UGeNl8\\1`001OO1000010O000O1O1O1O100O2L3O1N110O101N100O1000000001O00001O001O1O1O0000000000001O000001O0000000O101N105K1hFRN00Q9T201OO1O2OOO4M101O00001O2N1O2N2N10O0000000000001O0000002NO1N2N1O2N3M2N2O100O10O0000NUFiNk9W1UFhNj9Y13O2N1N2M4O00O1O102N2N00001N1UFkNc9V1\\FjNe9\\1O11O001O01O2N1O0YM", "size": [360, 640]}, "area": 48254.0, "iscrowd": 0, "image_id": 10097, "bbox": [0.0, 0.0, 640.0, 200.0], "category_id": 169, "id": 10012279}, {"segmentation": {"counts": "imj22T;3L4M3M2N3M6JDfEOW:1mEMQ:4QFKg86gGOEJa8?cGGOH\\8j0]G^O:FW8U1WGVO^9Y1010O10001NWG^No7c1mGbNb7m1ZHYNa7k1[HZNc7h1VH_Ni7a2OnM_H3EnNk7f0mH3_OVOc7`0YI1ZO^O]7`0_IH[OFV7a0dIA[OMQ7b0f2O1O2N2M3J^S9JmlF4M3L4M0O2N101SFEi8=UGCk8>TGBn8>PGBR9=mFCT9>jFCW9=eFE]9:aFG`9:\\FHU6EQMb0gLKX6DQMb0cLL\\6CRMS1m2oNSMo0m2ROSMm0m2TOTMj0l2XOTMf0l2[OTMd0l2^OTM?m2BSM4^Lk1V3PN<5^Lj1Y3PN86_Li1[3QN55aLi1]3QN16bLi1_3oMO8aLi1b3oML8bLh1d3PNI7dLh1d3RNG6eLg1f3RNE7eLf1g3TNC6fLe1i3UN@5gLg1j3TN^O5hLf1k3UN]O5hLe1m3VNZO5iLd1o3WNWO4kLd1o3YNUO3kLd1R4XNSO4kLc1S4ZNQO3nLa1R4\\NoN2SM^1P4`NlN2WMZ1n3dNlN1YMW1m3gNjN2\\MS1k3jNjN3^Mo0j3mNhN3bMl0`7TOmH>T7BnH_GL3HX99hFN2GW99hF0i9MYF3h9JZF6g9H[F7[:0000O10000O21N4N2M3MOQK", "size": [360, 640]}, "area": 12465.0, "iscrowd": 0, "image_id": 10097, "bbox": [258.0, 2.0, 382.0, 246.0], "category_id": 183, "id": 10012280}, {"segmentation": {"counts": "[5R2W<001O00O10000000000O1000000000000O1O10O100000hNiCYOOS1XUOWZj0OfWUO100O100O10001O015K00N1014YBGT=j0MO2N2N2N1O1OO010O100O10O01000000O10000000000O10000000000O0100001OO10000000000O1K5004ZB[O`=g0000000000000000O100000000000000000000O20O000001O0O101O01O0PO]O[Da0f;@YD`0g;@YD`0g;AYD>g;CXD=g;EXD;g;FYD:g;GYD9f;HYD8g;HYD8g;IYD6g;KXD5h;LWD4i;LXD3h;NWD2i;OVD1j;OVD0k;1UDNk;3TDMl;3TDMk;5UDJl;6SDJm;6SDJn;6RDJm;6SDJm;7RDIo;6QDJo;7QDHo;8QDHo;7RDIn;7SDHm;8SDGn;9RDGn;9RDGn;9SDEn;;RDEn;;RDDo;UDBk;>UDBk;>UDB\\OMVh<2gCNY<1iCNV<3iCNW<2iCNW<2iCNW<2iCNW<2iCNW<2iCNV<3jCMV<3jCMV<4iCLW<4iCLW<4iCLW<4iCKX<5hCKX<5hCKV<7iCJT<8mCHP<;PDEm;>SDBk;`0UD@k;`0UD_Ol;a0TD@k;`0UD@k;`0UD_Ol;a0TD_Ol;`0UD@k;`0UDAj;?VDAj;?VD_Ol;a0TD_Ok;b0UD^Ol;a0TD_OT<9kCH[<2fCMZ<3fCMZ<3fCMZ<3eCN[<2eCN[<2eCN[<2eCM\\<3dCN[<2eCN[<2eCM\\<3dCMl;DSD?1Mj;HSD;3Mg;MTD65Mg;ORD47Mf;2QD19Me;5oCOLd;k0[DVOe;j0[DVOe;j0[DVOe;j0[DVOe;j0[DVOf;i0ZDWOf;h0[DXOe;h0[DWOf;i0ZDWOf;i0ZDWOf;i0ZDWOf7", "size": [457, 640]}, "area": 14541.0, "iscrowd": 0, "image_id": 10104, "bbox": [0.0, 127.0, 640.0, 111.0], "category_id": 113, "id": 10012281}, {"segmentation": {"counts": "d3e0d=0000]O]B00=c=C`B=a=B_B>f=00000O1O1O1N_O\\Ba0c=3001O00O10000000000000000000O100000000N2000O02O0000000O10O100O11O1N1O1000O2O003M001O10OO01N2O2N0L5J6006J6JOYBAf=?20000000001N10000002N1O000O1001OO2]B^O]=f01O100O2N100O11O1O1N200O1N2OJdB@\\=<0000000000000O11O00O101OO1000O010010O1OO20O01O001O0O2O002N4L3M1O00KfBXO]=e05M3O1000001O0000000000000000O11_OYB>1Cb=O^Bc0b=01O1OO_O\\B`0e=11O1O100O2OO010000O100O10O10O100O1000O0100O3N1O0O010O10O1O0101N101O0O1001N20000O001O1N2O1N1000000001O0O10000000001O00000000O100N20000001O0000000001O000001O00001O1O1K4M30cT71\\kH0O2O000O10001N2O2N1N2O1O2OO1M2O2M2O101O001O00O1O100O2N1O3M2O1O1O00000000000001O0000000O2O1KZnd4", "size": [457, 640]}, "area": 4198.0, "iscrowd": 0, "image_id": 10104, "bbox": [0.0, 114.0, 306.0, 31.0], "category_id": 135, "id": 10012282}, {"segmentation": {"counts": "]7l6]701O00O10000000000O1000000000000O1O10000000000001O0000O11O00000000000000001O00NTIgHl6Y72001O0000000000O11O0000O100O10000000000000000000000000000001OO1O10000000000000000O100000000000000O10000000000000000000000000000O100000000000000O100001O001O001O1O001O1O000000O10000O10000O10000O10000O100000000O10000BoHdIQ7\\6VI\\Ik6d6=000000000000001O0000001O0000001O0000001O0eKYIT1h6fNbIU1_6dNlIW1V6cNSJX1n5cN[JX1g5cN`JY1a5bNdJ]1^5]NfJc1[5YNiJf1X5UNmJj1U5UNjJk1W5TNjJk1X5SNhJm1Y5RNhJm1Z5QNgJn1Y5RNgJn1Z5QNgJn1Z5RNfJm1[5RNeJn1\\5QNeJn1[5RNeJn1\\5QNeJn1\\5QNeJn1\\5QNdJo1]5QNcJn1]5TM[He0X2W2^5SMZHf0Y2V2]5SM\\Hf0X2V2`5PMXHj0X2V2\\5PM[HO3j0W2V2e5kMZJU2f5kM[JT2f5kM[JT2f5kMZJU2\\5RM`H8J5[2`2W5TM\\H192L8X2a2Q5UMdH37MN8Y2b2o4^MjHGO2IOb2i2m4\\MSLd2n3YMULf2l3WMVLi2f7O1O001O0000O10000000000O10000000000O100000000O10000000000O1000000N2O1N2O1N2O1O1N2O1N2O1N2O1O1N2O1N2O1N2O1N2O1O1N2O1O11O001O001O001O001O001O001OO1H81O001OcMoKbJQ4^5oKcJP4\\5RLdJm3]5SLbJm3`5QLaJn3^4RLcLn3]3TLbLk3^3VLbLi3[3TL[I4X3h3]3TLYI006Y3e3^3WLYI31KV3k3a3]LYIIV3i3a3^LZIJT3g3b3^L[IMQ3e3d3^L\\IMP3d3e3]L\\I1n2a3g3]L\\I3k1ImNg3m5[L\\I6h1JoNd3m5\\L]I7d1ISOd3m5[L\\I9a1JWOa3k5\\L^I;]1H\\O`3i5]L^I=Y1GA_3h5\\L_I?V1GD]3g5]L_Ia0R1FI\\3R6oLSJFLZ3R6PMPJFOZ3Q6PMnIH1X3Q6QMlIG4X3P6QMjIH7W3o5RMhIG:W3n5RMfIHf0HWOg8i3aGPMHWOg8i3aGoLIXOf8i3aGoLIXOf8h3bGPMHXOf8g3cGPMHYOe8f3dGQMGYOe8d3SG\\La0g0GYOe8c3gGTMDYOe8c3gGTMDYOe8d3fGSMEYOe8d3fGSMEYOe8c3gGTMDYOe8c3gGTMCZOf8b3gGTMCZOf8b3gGTMCYOg8c3fGRME[Oe8c3fGRME[Oe8c3fGRME[O>1YOOR8c3bHQMF\\O=3[7`3bHQMF\\O=4Z7_3cHQMF\\O=4Z7_3bHQMH\\O;5[7^3bHPMI]O:6Z7]3cHPMI]O:6Z7]3cHoLJ^O98X7[3eHnLK_O88X7[3cHoLf0Fg6[3cHoLf0Fg6[3cHnLg0Fg6[3bHoL0_O56Z7]3`HnL1_O56Z7]3`HmL2@46Z7]3`HlL3A26\\7]3_HlL3A26\\7]3^HlL5A15]7^3]HhL9EM5]7]3^HhL9FL5]7]3^HhL9FL5]7\\3_HiL8FL4^7^3]HgLQ1Jc6`3ZHgLS1Ka6^3[HhLT1L_6\\3]HhLT1O\\6Y3`HhLT11Z6V3dHgLS14X6U3eHgLS17U6R3kHcLQ1;T6R3kHbLR1R6R3mH^LR1`0Q6S3dJmL\\5R3eJnL[5R3eJnL[5R3eJnL[5S3dJmL\\5R3eJnL[5R3eJnL[5R3eJmL\\5S3dJmL\\5S3dJmL\\5S3gH^LA4d11C1k9a3TF^La:d310000N^E]Lb:c32000000001OO1000000000000O10000000000O100002N1O00O10000O1O1001O001O000000O11O1O000000O100O1000000001O0000000000001O00000000O100N20000001O00000000000000001O00001O1O1aE]LV:c3gE`LY:`3gE`LY:h3000O1O1O100O1000000000000001O00N200O10000O10000O10000O100001lE\\La9e3\\F]Ld9c3[F_Ld9b3YF`Lg9`3XFbLg9^3YFbLg9_3XFbLg9^3YFcLf9^3YFbLg9^3YFcLf9\\3[FeLd9Z3]FfLk0Be7h3`GgLi0Bg7f3bGhLf0Bh7e3cGiLd0Ci7c3fGiL?Ek7a3hGjL;Fm7`3iGjL9Fn7`3jGiL7D[OOd8d3jGjL5B_O0b8d3jGkL9Bm7c3jGlL8An7c3jGmL7@o7c3jGnL6_OP8c3jGmL7@o7c3jGkL8Cn7c3iGjL9Cn7c3iGiL:Dm7c3iGhL;Dm7d3hGhL;Dm7d3gGhL=Dl7e3fGgL=Em7e3aGiLc0Bl7^4UHaKl7_4THaKl7^4UHaKl7_4SHbKm7]4THbKm7]4THcKl7]4THcKl7\\4Q100O100O100O1O100O100O100O100O1H8M3N2O1O1OSF\\LW9b3i0ORF_LV9`3jF`LW9`3iF`LW9`3hF`LY9_3hFaLX9_3gFaLZ9_3eFbL[9^3eFaL\\9_3cFbL]9^3cFaL^9_3aFbL_9^3aFaL`9_3`FaL`9_3e00jEaLb9_3d0000000001O1O2N1O1O2N1O2N2NO10000O1000000O1000000O1000000O1000000O1000000O10000000000000000000000000000000000000000001O001O001O001O001O001O001O001O001O1O001O001O001O001O001O1O001O001O001O1O001O001O1O001O001O001O1O001O1O1O001O1O1O001O1O1O000000000000O1O100000000000000000000000000O11O001O00001O00000SGXKY8h4gGXKY8h4gGYKX8g4hGYKX8g4hGZKW8f4iGZKW8f4iG[KV8e4jG[KV8e4jG\\KU8c4kG^KU8b4kG_KT8a4lG_KT8a4lG`KS8`4mG`KS8`4mGaKR8_4nGaKR8_4nGbKQ8^4oGbKQ8^4oGcKP8]4PHcKP8]4PHcKP8]4PHdKo7\\4QHdKo7\\4QHcKP8]4PHcKP8]4PHaKR8_4nG`KS8`4mG_KT8a4lG_KT8a4lG_KT8a4lG_KT8a4lG_KT8a4lG`KS8`4lGaKT8_4lGaKT8_4lGaKT8_4lGaKT8_4lGbKS8^4mGbKS8^4mGbKS8^4mGaKT8_4lG_KV8a4jG]KX8c4hG[KZ8e4fGYK\\8g4dGXK]8h4b00000000000O1000000000000000000000000000000000000000000000VG]Kn7c4lGfK@C_8g4QHhKo7X4PHjKo7U4RHjKo7V4QHjKo7V4QHjKo7V4QHjKo7V4QHjKo7V4QHjKo7U4RHkKn7U4RHkKn7U4SHjKm7V4SHjKm7V4SHjKm7V4SHjKm7V4SHjKm7V4SHjKm7T4UHkKl7R4VHoKj7n3YHRLg7k3\\HULd7i3^HWLb7i3^HWLb7i3^HWLb7i3^HWLb7i3^HWLb7i3^HWLb7i3]HXLc7h3]HXLc7h3]HXLc7h3]HXLc7h3]HXLc7g3^HYLb7h3]HXLc7P4UHoKl7W4nGjKQ8V4oGjKQ8V4oGjKQ8V4oGiKR8W4nGiKR8W4nGiKR8W4nGiKR8W4nGiKR8W4nGiKR8W4nGiKR8W4nGiKR8g3_GXL?1R8e3cGXL;3R8b3hGYL65R8b3jGWL47R8a3mGVL19R8`3PHTLOQ8_3fH`L[7`3eH`L[7`3eH`L[7`3eH`L[7`3eH`L[7a3dH_L\\7a3cH`L]7`3cH`L]7`3cH`L]7`3cH`L]7`3cH`L]7", "size": [457, 640]}, "area": 86466.0, "iscrowd": 0, "image_id": 10104, "bbox": [0.0, 0.0, 640.0, 209.0], "category_id": 155, "id": 10012284}, {"segmentation": {"counts": "U54U>0O10000O100O10000O100000000000000000000NIRB7n=200O100^BFU=:jBHT=9lBGS=:lBHS=8lBIS=8mBHR=9mBGS=:mBFS=:mBFR=;nBEQ=SCBihGBW8?hGAY8>hGBX8[NfGP11e0Y8ZNgGHO?2X1_8_NaGJN?3U1a8aN^GKN`02T1b8`N_GKNa02T1a8^N`GMMb02S1a8\\NaGOLb03R1a8\\N`GOMc02S1`8ZN^G[OOe01e01P1b8YN\\G_O0c01_O4k0L[1c8WN[GC1`0`0<_O[1e8\\N\\GMb0W1]OCf8WO\\GOc0U1[OFf8UO\\G0e0R1ZOId8VO]GNh0P1XOM`8WO`GLi0m0YO1]8VOaGLh0\\OWO^144[8WObGJi0^OWOY14:X8UOdGJj0^OXOS3Z8eMdGI3C;NDQ3X8fMfGG3K5GLS2JeN[8OgGF3N3GNo1KgNY80hGD312E1k1JmNV8NjGE123E2g1KoNU8NjGE043C5c1JUOR8MkGE133C7`1IYOP8LlGD161B:\\1I]On7LlGD251C;X1HoNJ1R8=nGC26OC>T1IEj7JoGD070B`0Q1GJh7IQHB1e0`04GMf7HRHB1e0a01G1d7HSHA0f0b0OH1d7IRH_O2h0a0LH5b7HTH^O2i0`0KH7b7GTH]O3k0?GI;`7GUH\\O2l0`0CK?]7GVHZO2n0`0^ONd0Z7FVHYO1Q1b0WO0i0W7GVHRONL3_1b0oN3n0T7EWHRO2]1a0iN3V1R7CYHPOO`1c0cN3^1R7_OYHoNOb1d0]N2g1Q7[O\\HnNKe1]15]6XO]Hn3b7XKVH`08Y4Z7YLdHS3JWL_7NaH74f3LUL]7OcH62h3ORL\\71cH50j30QL\\70dH50j31QLZ70fH5Oi30TLY70gH31a4W7\\KiH30a4V7]KiH31_4W7]KiH31`4V7\\KiH50`4V7\\KjH31a4U7[KjH51`4U7[KjH42`4U7[KiH61`4V7YKjH70`4V7YKiH71a4V7XKiH71i17eMIi1V7bNhH81h1b0Ae6^NiH90g1?Ei6[NgH:0f1=Il6WNgH:0f1:Lo6ROgHR1:Lo6SNgH;1f19Lo6QOhHS19KP7ROgHS19KP7ROgHT18JR7QOfHV17IT7POeHX16HW7nNcHZ16HX7mNbH[17FY7nN`H\\17F[7lN^H_16E^7jN\\Ha16E_7iN[Hb16Ea7fNZHe15Da7hNZHd15Da7hNZHe14Cb7hN[Hd13Da7iN\\Hc13Da7iN\\Hc13Cb7jN[Hc13Cb7jN[Hc13Ca7kN\\Hb13Ca7kN\\Hb12Db7kN\\H`12Eb7kN\\H`12Db7nN[H^13Db7nN[H^12Ec7nNZH\\14Fb7nNZH\\14Fa7PO[HY14Fb7QOZHY13Gc7QOYHX14Gc7QOYHX14Gb7SOZHU14Hb7SO[HT12Jc7SO[HR12Jd7TO[HQ11Kc7VO\\Hn01Lc7VO]Hm0ONd7VO]Hj000c7WO^Hf002c7YO`H?O8a7[OcH7LlNJi0g76bH3Na0`7^O`HmNJJ2K5aIZNQOPOVOe9<[G>QOUOe9=YG?ROROg9>WG`0SOQOg9>VGa0TOPOf9`0UG`0VOnNg9a0SGa0WOmNg9a0RGb0WOlNi9b0oFc0XOjNi9c0oFc0YOhNj9d0mFd0ZOgNj9d0lFe0[OeNj9g0kFc0\\OeNj9g0jFe0\\ObNl9h0hFf0]OaNl9i0fFf0^O`Nm9j0eFg0^O^Nn9j0dFh0l9XOTFh0k9XOUFh0l9WOTFj0l9UOTFk0m9UORFk0n9UORFl0n9SORFm0o9SOQFm0n9SORFm0o9ROQFo0o9QOPFo0P:QOPFo0Q:POoEQ1Q:oNoEP1Q:POoEQ1Q:nNoER1Q:nNoES1Q:mNnES1R:mNnET1R:kNoET1Q:mNnET1R:kNnEU1R:kNoEU1Q:kNoET1Q:lNPFT1P:kNQFU1n9kNSFT1n9kNSFU1l9lNTFS1m9lNTFT1k9lNUFT1l9kNUFU1j9kNWFT1j9lNVFT1i9lNXFS1i9lNXFT1g9lNZFS1g9lNZFT1e9mN[FS1e9lN\\FS1d9mN]FS1b9lN`FT1`9jNbFV1]9iNeFW1[9gNgFY1X9fNjFZ1V9cNmF]1R9bNoF_1P9`NRG`1n8^NTGb1k8]NWGb1i:0000O100O1lNXCf0ho15QNcP24QNcTO[NfTO\\Nf2dAN[>8`AH_>=]ACb>b0ZA^Oe>h0VAXOi>m0SASOl>S1o@mNf:JlG^1ZMhNj:LhGb1ZMbNn:MfGg1WM\\NS;OcGj1VMWNe9KVE1Z16b2m1TMQNj96XFOg2o1SMlMl99iE>U3b1RMgMm9o1mH`0QMaMR:R2hHc0RM[MV:U2dHc0TMXMX:X2`Hc0VMUM[:Z2[Hd0XMRM\\:^2XHc0ZMoL^:a2THc0\\MlLa:l2eGd:_400", "size": [640, 480]}, "area": 60927.0, "iscrowd": 0, "image_id": 10107, "bbox": [0.0, 342.0, 480.0, 298.0], "category_id": 118, "id": 10012287}, {"segmentation": {"counts": "0`4Z32Z4MgK3Y4MgK3Y4MgK3Y4MgK4X4LhK4X4MgK3Y4MgK3Y4MhK2X4NhK2X4NgK3Y4MgK3Y4MgK4X4LhK4X4LhK4X4LhK4X4FaHiKNNV3c4\\4F`HkKR3]4b4HeK5_4KaK1c4O]KLeLlKP8X4ZKMgLjKo7Y4[KLh44XKLh44XKLh44XKLh44XKMg43YKMg43YKMg43YKMg43YKMg43YKMg43XKNh42XKNh42UK1k4ORK4n4LmJ9S5GkJWLAi3?XLAg3?ZLBd3>]LBb3>^LBb3?]LAc3?^LcKPLk3b7b0`L^O`3b0_L_Oa3a0`L^O`3b0`L^O`3b0_L_Oa3a0]LAc3?`L^O`3b0cL[O]3f0bLZO^3f0eLWO[3i0fLVOZ3j0gLVOX3j0iL[OQ3e0RM]Oi2c0[M[Oc2e0`MYO_2h0aMWO_2i0dMTO\\2l0iMPOV2P1kMoNU2Q1mMmNS2S1nMlNR2U1nMjNR2V1oMiNQ2W1PNhNP2X1QNgNo1Z1QNeNo1[1RNdNn1\\1RNdNn1\\1SNdNl1\\1UNcNk1]1UN_KlJP3o6a1[N]Ne1d1[N[Ne1e1^NXNb1h1_NXN`1h1aNWN_1i1bNVN^1j1bNVN^1j1cNUN]1l1bNUN]1k1dNTN\\1l1dNTN\\1l1cNUN]1k1bNWN]1i1`NZN`1g1]N\\Nb1d1]N]Nc1c1\\N_Nc1a1[NaNe1`1XNbNh1^1VNdNj1\\1UNeNk1[1SNgNm1X1SNiNm1V1RNlNn1U1oMmNQ2R1mMQOS2Q1jMPOV2n0jMTOV2n0fMTOZ2k0fMUO[2k0dMUO]2k0]M\\KgKj3m6l0QI[KX4i3i2o0oHYK0NS4h3o2X1oHQKn3e3T3]1mLaNU3_1lL`NT3`1lLaNS3^1nLbNR3^1nLbNR3]1PMbNP3^1PMbNP3]1QMdNn2\\1SMcNm2]1SMcNm2\\1TMdNl2\\1UM^KhKf2S7l1UM^KjKe2P7m1VM]KlKe29oLV6o4fM[KnKe24SMX6m4fMZKQLj2JQM^6k4hMXKRLm2EQMa6k4hMVKSLU3U6e1iMTKTLV3S6f1jMRKULW3Q6g1kMPKVLW3P6h1aNWN_1j1aNTN`1k1bNTN^1l1cNRN^1n1cNQN]1o1eNoM[1Q2fNnMZ1R2gNmMY1R2iNmMW1T2iNkMW1U2iNlMV1T2kNkMU1V2kNiMU1W2lNhMT1X2lNhMT1Y2lNgMS1Z2mNeMS1[2nNeMQ1\\2oNcMQ1^2oN`MR1`2oN`MP1`2QO_Mo0a2RO^Mn0b2SO]Mm0c2SO]Mm0c2TO]Mk0c2VO\\Mj0d2WO[Mi0e2WO\\Mh0d2XO\\Mh0d2XOlLYJ^N^6f4YOlLZJ]N]6f4ZOmLYJ]N]6e4[OnLYJ\\N\\6e4\\OoLXJ\\N\\6f4\\OmLXJ]N\\6f4\\OnLWJ\\N]6f4\\OkLUJTN3:\\6g4\\OYLUJTO7MW6f4]ORLVJlN5<20V6e4^ORL]JSOIK8;T6f4]OmKbJVO37n5e4^OhKgJ[OO7l5f4^OeKbKEP5g4]OeKbKEP5f4_OhK]KBT5e4@fK_KEQ5f4_OYKoKNb4h4@WKSLIQN2\\6n4UJPKf45oLLV4R5QJnJj44`3P5bGmJo45]3o4ZGiJ64V51Z3V5\\GkJW>V5gAkJY>_5O0000000000000000000000001O0000001O001O00001O00001O00001O00001O00001O001O00001O001O001O001O00001O001O001O00001O001O0000000000001O00000000001O00000000001O00000000001O00000000001O00000000001O001O001O1O001O1O1O001O1O001O1O1O001O1QC[IaX1\\AdNg>X1P211O1O001O010O1O1O1O1O1O2N1O0O2O2M1O100O1O100O3N002N10O02O0O2O0O1O101N101N3N2M3N1N100O10O010WZf5", "size": [640, 480]}, "area": 8733.0, "iscrowd": 0, "image_id": 10107, "bbox": [37.0, 175.0, 151.0, 153.0], "category_id": 141, "id": 10012289}, {"segmentation": {"counts": "`4e1Zb0101O0000O2O000O11O00O12NO11O0J]No]ONNc1Sb0_NQ^Oa1oa09O1O00000000000000000000000000O100001O010O1O1O00O10000O10000000000001O00010N11O02N00001O00001O001O000010O01O001O01O0001O00001O001OO1010OO11O0000001O010ON21OO11OO2OW^OmMea0W201OO2O00000O1O11OM4M2N200N200O1O2N1O1O100N2O2N1O1O1N3N1N200N10002N0O4MO220MO200O3oNR]Om0Pc0SOQ]O0Ne0Zc0\\Og\\O?\\c010O10O010O100O10000O2O00O1001OO1O2N1O1O1O020N02O00O11O001N11O00010O01O2O1O1N10O1O000O1000000O1000000O1000O1O1O11O00000000O11OO1001O00O11OO10N5L3L3F[\\O6jc0L3NdZR5", "size": [640, 480]}, "area": 10025.0, "iscrowd": 0, "image_id": 10107, "bbox": [0.0, 138.0, 220.0, 81.0], "category_id": 152, "id": 10012290}, {"segmentation": {"counts": "oXj32nc01O001O0001OMNX\\O3Uc0MY]O7`b0JQ]O5<2bb01X]OIK8ib03[]O3_b03`]OO\\b0l01O4LM3D?J5Q^OQNga0V2O3OOGhMh^OX2Xa0720O10O0O20O01O0N3O001O010O2L5N2J6I7H8H7^OnSm1]OnlRN7L5L3K6M2O2M201O00001O00001N100O2N11O01O000O2O00001O001O00001O1N12OO1O1O1O001N20000O1O1O1O2N1O101N1N2O2i^OTNU`0n1h_OTNW`0n1f_OUNX`0n1d_OTNZ`0o1a_OVN]`0l1^_OYN``0j1Z_OZNd`0c2N101O001O001O001O1O010O001O00hMb_OhN0U2]`0\\Nd_O31a1Qa0lMQ_O9OHM00l1Sa0RNT_O6NKL0Om1]a0TNc^OO50L0On1la0QNV^On1ja0RNV^Oo1ma01O1O1O1O1O1O2N1O00lN\\^OMca0Gj^O8Va0BQ_OP23i3[4aNVKfK2O2N7H5K1M32N1O1O1O1O1O1O1O1O1O1O0K]R7Mj_H2j=X;@iD`0X;_OhD`0Z;_OeDb0\\;]OdDc0];[OdDe0];ZObDf0_;VOeDj0[;SOhDm0W<2O001N101N3N1OCVC\\OmgBLSb;C]D>P1[O[8U2dGnMY8P2iGSNiNAZ3f0Y1f1dL`NU2GV1j1eL`NV2DQ1R2gL\\NW2AR1V2dKhM4c0U3]OT1Y2bKjM2`0Z3[OR1[2aKkM3?[3ZOQ1\\3bKZM]3ZOP1_3aKWM_3ZOP1a3_KUMb3YOo0b3[KQL2T1d3YOo0l4QOSKo0n4ROQKn0n4SORKd0EjKZ5b3QKd0EhK\\5d3oJd0W5_OmJ9U5NhJNX51lJJV56iJJX55hJK[5VL]Jb379g5FYJ:g5FYJ:g5FYJ:h5EXJ;h5FVJ;j5EUJn5AQJ`0Q6^OnIc0U6ZOiIh0Y6VOeIl0\\6_30O1O0001O0001O000001O00O01000000N2O1000001O000001O1O2O0O1O1O1UK^IQ2b6oM^IQ2b6nM`IQ2`6nMcI_M3S4Q1jKm3c2`Ka1b0nK7[1g0T1eN`1=RLFj1V1f0gN^1X2@M]2QLfMh1=Z2\\O1a2mKgMg1;\\2\\O1c2kKhMe19a2[OOe2jKgMf18b2\\ONe2jKgMe19c2[ONT3_MaMc2[ONT3^MaMf2ZOLU3XMlLdNf0`8^2gHhM]7X2aHiM`7W2_HkM`7U2`HkM`7U2`HkM`7U2`HkM`7U2`HkM`7U2_HlMZ3oNFU3WLkL;R1g3nNGU3nKVMb0h0h3mNHf3_L]Mi3nNGf3]L^Ml3lN]L0]2g3XM^Mn3kNmK2L8l2]3[M`MP4iNhKk0l2m2ZM`MR4hNeKP1m2i2ZM_MU4iNbKR1m2g2[M]MW48RMbN]Ol3YOYMY4:mLfN[Ol3_ORMZ4>fLkNZOj3FlLZ4a0`LPOXOh3OfLY4d0YLVOVOg37^L[4g0jKW4KoJ]4k0gKW4LkJ_4n0dKY4MhJ`4n0\\Kb43`Ja4_7_KaH`4`7`K`H_4a7aK^H_4c7aK]H^4d7bK[H^4f7bKZH]4f7dKYH]4g7cKYH\\4h7dKWH\\4j7dKUH\\4k7eKRH]4o7bKoGa4Q8_KnGa4S8_KkGb4V8^KgGd4Y8]KfGc4[8\\KdGe4]8[KaGf4`8ZK_Gf4b8ZK^Ge4c8[K\\Ge4e8[KYGf4h8<0O1O0000O1O100N31NN2O1001O001N2O1O1O1O2OO0001O000O0100O2N1O100O2N1011N1O0000001O001O000lJYGj4Q900000000O02O0000000O1000001O001O0ROoJgHR5X7PKgHP5Y7QKQH48l4f7PKoG7:j4h7\\KWHd4i7\\KWHd4i7[KXHe4h7\\KVHe4j7[KVHe4j7\\KUHd4k7\\KUHd4k7\\KUHd4k7\\KUHd4k7]KSHd4m7[KTHe4l7[KTHe4l7[KRHg4n7YKQHh4o7YKnGj4P8WKPHi4P8g0O000O100O10O11OO2O1O01N11N10001O10106J0O00000O0010O00000001PMjG0U80nGMR82QHLo74SHJm76SHJm76SHIm77THIk78UHGl79THEn7;RHEm7QHBo7=RHCn7=RHCn7=SHBl7?THAl7?THAl7?THBk7>UHBk7>UHCi7=WHDi7bMiGf2>Il77SHJm76RHLm74SHLm74RHMn73RHMn73QHOn71RHOo70QH0R8LnG5R8KnG5S8JlG8S8HmG8S8HlG9T8GnG7R8IPH5P8KQH4P8KRH3o7LRH4m7LUH2l7LVH3i7NWH2h7OXH1h70WH1h70WH0i70WH0h71YHNg71ZHOe72[HNe72[HMf74YHLg74XHLh76XHIh78WHFj7;VHFj79WHFj79VHGj78WHHh79XHG`7eMQHc2`0H_7fMkGg2f0C_7`0aH@_7`0aHA^7?cH@]7`0cH@]7`0cH@]7?dHAYOfMP8h2gHBYOfMP8h2gHCXOeMQ8g2hHGX7OSI0m6OTI1l6NUI2k6NUI2k6NUI2l6MTI3l6MTI3l6MSI5m6aMQHR2S1=[7bN]I^1d91O0L5O1O0001000O1001O001O0O2O001O000fMdDd0c0ZOP;1aD>b0_OQ;1^Da0a<@`C>b<@_C?c<@]C?dR:CmE`0P:AnEb0o9@oEc0k9AUFa0i9@UFP1\\9QOcFR1_OPN^9n0SGb1k8^NUGc1i8_NUGd1i8\\NWGe1g8]NWGe1h8[NWGg1h8YNWGi1h8WNXGj1f8WNYGk1f8UNZGl1d8UN\\Gl1a8UN_Gm1^8UNbGl1]8TNcGl1\\8TNeGm1W8VNiGj1U8XNkGh1T8XNmGh1R8YNnGf1R8[NmGf1S8YNnGg1Q8ZNnGf1R8[NnGe1R8[NnGd1S8[NmGf1R8[NmGe1T8[NkGe1V8[NjGd1W8[NjGd1X8[NhGd1Y8\\NgGc1\\8ZNeGe1`8WNaGf1i8RNXGl1k8QNWGl1P9oMRGo1n8QNWGi1j8WNWGg1j8XNWGg1k8XNVGf1o8UNRGj1o8UNRGj1o8TNSGk1n8SNUGk1k8TNWGj1l8SNVGk1l8QNXGn1n7mMZG6h0l1n7UNRG2n0i1P8WNmF5R1c1R8YNfF9W1^1S8[NdF;V1Z1V8YOhGf0Y8ZOgGe0Z8\\OeGc0\\8^OcGa0^8@aG?_8C`GeNR7n0]H?b0bNR7n0ZHb0e0`NR7m0XHc0f0`NS7l0WHd0g0`NR7l0VHd0i0`NQ7k0WHd0i0aNR7i0THf0k0aNQ7j0SHd0m0aNT7h0nGf0P1bNQ7j0nGa0U1cNn6l0mG`0W1cNl6m0mG?X1bNm6o0kG>Z1aNl6Q1jG>X:AhE=Z:CfE=[:BeE<^:BcE=_:BaE=a:B_E=c:A^E>W1mNZ7c0_G?W1ROY7=`G`0V1WOY77cG?V1[OW75cG>W1^OY6^OgHe0I=X1AV6AhH?L=W1DR6CjH`7JUIEJd0d0AkN=`7JXJ6_OEdN?d7GXJ4Ag0X6UOWJ3Bh0X6SOVJ5Bi0X6ROVJ4Cj0W6QOVJ5Ck0X6oNUJ5Cm0S6ROZJ1Cm0Q6SO^JOBn0n5TOaJMAP1m5TOaJLCP1k5UObJJDQ1i5VOcJHDS1i5UOdJFaNG8_1c6TOeJD_NL8\\1d6TOfJB]N18Y1e6TOgJ_O\\N77V1f6TO`KGjMU1e6UO`KGkMT1f6UO]KHmMS1f6VO[KHoMR1e6XOZKFSNQ1b6[OYKEUNP1b6\\OWKEXNn0_6_OXKDZNl0_6POeHMa27[Nl0`6nNeHO_27]Nl0_6mNfH0_26\\Nm0`6kNfH2^26\\Nm0a6jNeH3^26\\Nm0c6gNdH6]26[Nm0f6dNeH8Z26\\Nn0S7oN^J3_N8TOGR8NYJ3aN7ZOBn76TJ0dN6^OBm77hG@V2`0gN6@AP89iIOgN6C_On7>fILkN4X81mHJkNO^88fHImNM_8:cHHoNN^8:bHIQOK^8lGCbNgBLSb;C]D>P1[O[8U2dGnMY8P2iGSNiNAZ3f0Y1f1dL`NU2GV1j1eL`NV2DQ1R2gL\\NW2AR1V2dKhM4c0U3]OT1Y2bKjM2`0Z3[OR1[2aKkM3?[3ZOQ1\\3bKZM]3ZOP1_3aKWM_3ZOP1a3_KUMb3YOo0b3[KQL2T1d3YOo0l4QOSKo0n4ROQKn0n4SORKd0EjKZ5b3QKd0EhK\\5d3oJd0W5_OmJ9U5NhJNX51lJJV56iJJX55hJK[5VL]Jb379g5FYJ:g5FYJ:g5FYJ:h5EXJ;h5FVJ;j5EUJn5AQJ`0Q6^OnIc0U6ZOiIh0Y6VOeIl0\\6_30O1O0001O0001O000001O00O01000000N2O1000001O000001O1O2O0O1O1O1UK^IQ2b6oM^IQ2b6nM`IQ2`6nMcI_M3S4Q1jKm3c2`Ka1b0nK7[1g0T1eN`1=RLFj1V1f0gN^1X2@M]2QLfMh1=Z2\\O1a2mKgMg1;\\2\\O1c2kKhMe19a2[OOe2jKgMf18b2\\ONe2jKgMe19c2[ONT3_MaMc2[ONT3^MaMf2ZOLU3XMlLdNf0`8^2gHhM]7X2aHiM`7W2_HkM`7U2`HkM`7U2`HkM`7U2`HkM`7U2`HkM`7U2_HlMZ3oNFU3WLkL;R1g3nNGU3nKVMb0h0h3mNHf3_L]Mi3nNGf3]L^Ml3lN]L0]2g3XM^Mn3kNmK2L8l2]3[M`MP4iNhKk0l2m2ZM`MR4hNeKP1m2i2ZM_MU4iNbKR1m2g2[M]MW48RMbN]Ol3YOYMY4:mLfN[Ol3_ORMZ4>fLkNZOj3FlLZ4a0`LPOXOh3OfLY4d0YLVOVOg37^L[4g0jKW4KoJ]4k0gKW4LkJ_4n0dKY4MhJ`4n0\\Kb43`Ja4_7_KaH`4`7`K`H_4a7aK^H_4c7aK]H^4d7bK[H^4f7bKZH]4f7dKYH]4g7cKYH\\4h7dKWH\\4j7dKUH\\4k7eKRH]4o7bKoGa4Q8_KnGa4S8_KkGb4V8^KgGd4Y8]KfGc4[8\\KdGe4]8[KaGf4`8ZK_Gf4b8ZK^Ge4c8[K\\Ge4e8[KYGf4h8<0O1O00mJQKP1o4nNSKQ1n4gNZKX1g4fN[KZ1e4eN\\KY1g4eNZK]1d4dN[KZ1g4fNYKY1h4gNXKY1h4gNXKZ1g4gNXKY1h4gNXKZ1f4hNYKY1f4hNYKY1f4gNZKZ1e4gNZKZ1e4gNZK[1e4dN[K\\1e4dN[K\\1e4dN[K]1d4cN\\K]1d4bN]K^1b4cN^K\\1c4cN^K]1b4cN^K\\1d4cN\\K\\1e4cN\\K\\1e4bN]K^1c4aN^K^1d4_N^K`1c4WNiJSMf0f4b4UNfKm1X4SNhKn1W4QNjKo1V4QNjKo1V4QNjKo1V4PNfKYMQOh4X5oMeKX2[4hMdKZ2[4gMcKZ2]4fMaK\\2[OnJj4g2iKf2W4\\MgKd2Y4\\MgKd2Y4^MdKc2\\4]MbKe2]4\\MbKd2`4[M`Ke2`4[MaKd2_4\\MaKd2_4\\MaKd2_4\\MaKc2`4]M`Kc2`4\\MbKc2^4]MaKd2`4ZMaKf2_4ZMaKf2`4YM`Kg2`4YM`Ki1_OVLR5Q2_Kh1AVLP5R2^Ki1C_K48l4_2[Kl1EZK7:j4a2WKn15`Kd4b2TKQ28]Kd4d2oJR2<[Ke4h7\\KVHe4j7[KVHe4j7\\KUHd4k7\\KUHd4k7\\KUHd4c3kJ;a0RLd4b3lJ>oKg4i2iJhM3`3=nKh4f2mJjMOb3=kKj4f2nJiMMe3fI`1S7aNmHX1Y7iNfHV1\\7jNcHV1]7jNbHV1_7jNaHU1b7iN\\HW1h7gNlGCbN`1L]Nl9=eGI`N]1P:jN_Ga1c8]N\\Ge1e8YN[Gh1e8WN\\Gi1e8UN[Gm1f8PNYGR2]:0O10O100DSD^No;b1SDZNn;g18O01O000kEWNP8i1mG_Nm7a1RHcNl7\\1THeNl7[1SHfNm7Z1RHgNn7Y1QHhNP8W1PHiNP8W1oGjNR8U1nGkNS8U1lGkNV8=QFDh10[88mEHh10\\86mEKe10_84lELd11b81jENb13d8OjENa14j8IfE2^17S9_OaE9[19U9\\OaE;Z19W9XOaE?W1:e9E[Fk3d6XMZJ:QO\\2e6YM[J:PO^2@gJS7a2]J;oN_2d6UM^J>lN]2f6UM]J`0`NPM7_5k6PM^Jd0dN^2o6nL\\JcMaNR30\\2T7nL\\JbMbNf8R7hI`JW6a5iI_JW6a5hI`JX6`5hI`JZ6^5fIbJZ6^5fIbJZ6^5XIPIZNa1_8_5VIQIYNb1a8]5QI[IYNW1g8^5oHZI\\NY1e8]5mH^I[NT1i8^5kHWKT7i4mHVKT7k4jHVKV7j4jHVKV7j4jHVKW7i4iH_I]NS1i8_5jHlH\\N?3U1g8`5lHZI^NV1f8`5mHXI^NX1e8`5mHXI^NX1d8a5oHVI]NY1d8a5PIUI]NX1d8c5QISI[N[1b8c5UIPIYN[1J_Nh8V7VIoHXN\\1e8d5TIoHWN^1c8d5XImHTN^1f8d5WImHSN_1e8e5XIkHTNc1a8b5dI]J^6b5bI^J^6b5bI^J^6b5cI\\J^6d5bI\\J^6d5bI\\J^6e5aI[J9_N`3V7WL[J9_N]M0P6V7ZL[JYNbN\\ON2OO62Mn0MoN004o5Q7\\L]JXNRO]O@o0OQO3P6n6[LbJeM]N9o0GoNb00^O;n5i6]LnJfMRO8kNG02d0j5a6`LXLgM`Mj5W6_LYLeMbMl5U6_L[Ma3e2_L[M`3f2`LZM`3f2`LYMa3g2_LYMa3g2_LYMa3g2_LYMa3g2_LYMa3g2`LXM`3h2`LXM`3h2`LXMa3g2_LYM`3h2`LXM`3h2ZL^Mg3b2XL^Mh3b2XL_Mh3`2XL`Mh3`2XL`Mg3a2YL_Mg3a2YL`Mf3`2ZLbMd3^2\\L`Mf3`2XLbMh3^2XLbMh3^2XLbMh3^2XLbMh3^2XLbMh3^2XLcMg3]2ZLbMf3^2ZLbMe3_2[LaMd3_2^L`Mb3`2_L_Ma3a2`L^M`3R2]JZIK3Z2_4`3U2mLkMS3U2mLkMS3S2oLmMQ3S2oLmMR3R2nLnMR3R2nLnMR3P2PMoMQ3Q2oLnMS3Q2mLoMQ3Y1UJXJO`0m2P4m2QOVJ_LOj0j0UOVO13O4b0g2n3o2oNWJaLL011Oc0^1L`1P4n2nNdJSMo0O_1R4SM_Kd5]3lJSMZ1@VNOm2f4g2hNlJRM_4V4e0fNnJTM]4X4b0aN^JgL00c0=]OCR5i4?VN`KXMPOJT5j4mJUKY5n2gKYMoNIU5k4kJVKZ5l2iKUMX4n4OmMiKSMZ4P5NkMZ1T2fNlMZ1T2fNlMZ1T2gNjMZ1V2fNiM[1W2dNkM[1U2eNjM\\1V2eNiM[1W2cNiM_1W2`NkM_1S2bNoMeJTMf6l4fNRN[1n1dNRNeJRMe6k4gNVNX1PM\\I00d4[5\\N`1c1bN^N\\1c1cN\\N^1d1cN[N]1f1bNYN_1f1bNZN_1e1aN[N_1e1aN[N_1d1aN\\N`1d1`N\\N`1d1`N\\N`1d1aN[N`1d1aN[N_1f1SI]K[5l2b1g1SI]K\\5l2`1j1aNTN`1m1`NRN`1n1`NRN`1n1`NRN`1n1`NRNa1m1_NRNb1n1^NRNb1n1^NRNb1Q2[NoMf1n1\\NRNd1n1[NSNe1l1\\NTNd1l1]NSNc1n1[NSNe1m1[NSNe1k1]NUNc1m1[NSNe1l1\\NTNd1l1\\NTNd1k1]NVNb1j1^NVNb1j1^NVNb1j1^NUNd1j1\\NVNd1j1\\NWNc1i1]NWNc1i1^NVNb1j1^NUNc1l1\\NTNd1l1\\NTNd1l1\\NUNc1k1]N\\KbJg2R7l1\\N]KbJg2R7l1^NTNb1l1]NVNb1j1]NVNd1k1[NTNf1l1ZNTNf1l1YNTNi1k1VNWNi1i1WNVNi1k1WNWNh1h1XNWNi1j1VNVNj1j1VNVNj1j1WNUNi1k1WNUNi1k1WNUNi1k1WN\\KeJg2T7o1WNRNh1m1YNSNg1n1XNRNi1m1WNSNi1n1VNRNj1o1TNoMo1Q2PNPNP2Q2mMPNT2P2mMoMS2P2mMQNS2o1lMSNT2m1kMTNT2k1mMUNlJUMU7f4oMUNlJUMU7f4PNVNo1l1PNSNR2j1PNVNP2j1PNUNQ2k1PNTNP2l1PNTNP2l1PNRNR2n1nMRNR2o1mMPNT2Q2jMPNV2P2iMPNX2P2hMPNX2P2fMRN[2m1eMUNY2k1gMUNY2k1hMTNX2l1hMTNX20gHoNQ5R1W2_OQIiMHf1P5S1VMoMk1]1ZLjMEg1P5R1gLUMZNW1o3Q1aLAf1XN=j2XNWMSOa0Oj0R4k0bL@e1YN=k2dMTMH0O0O20Z2S4LaLAd1XN>l2bMO7UMP3W2UMoN\\OYOY2A;n2]MTMOj2]1^5S1iJ[OEoM5b1^5T1iJVOj1G\\3S1jJoNQ2MV3T1hJkNW22Q3R1iJeN\\28l2S1hJ`Na2>f2R1iJ]Nd2a0b2T1hJ[Ng2a0b2S1gJ[Nh2b0a2S1gJ[Nh2b0a2S1iJWNh2f0_2R1iJXNi2e0_2Q1gJ]Nj2", "size": [640, 480]}, "area": 112485.0, "iscrowd": 0, "image_id": 10114, "bbox": [87.0, 17.0, 393.0, 623.0], "category_id": 98, "id": 10012298}, {"segmentation": {"counts": "Yng1>ac0?^O41O000O11OO100000000O14L4LlNW]OT11kNcb00\\]OY1eb003M1O01O0000001O000O12OJ5000M_]OgNab0X1a]OhNoa01n]O25MKT17lNja00[^OS1Pb0mNT^Oo0ma0QOY^O3B9Tb0E\\^OOI4ja0N`11O1a\\OMQc0a02I5L5Mb1LdN1O000ROOn]O0_V11a\\O0[mb6", "size": [640, 480]}, "area": 1407.0, "iscrowd": 0, "image_id": 10114, "bbox": [89.0, 307.0, 53.0, 67.0], "category_id": 100, "id": 10012299}, {"segmentation": {"counts": "d\\f13mc02M2N5ZOEo\\O1030L100`0lb0@S]O<15kb0_OT]OP1lb03ON22NO11OO100O1001O00O1NS]OQOmb0l0S]OTOPc0a0V]O_OJ0Sc0`0;0000000000001OO11O0000O11O00001O1O00000000O100000000O11OO1000000001O00005e\\OYOSc0P1l\\OROjb0R10000000O10000000000O11OO100000[]OnN\\b0R1d]OnN\\b0U1^]OlNO0bb0\\1O4LO11O001O0000O11O1O00001O00001OO1O1O100N22N000000O11OO11O0000O1001OO12NO100O100000000000000000c]O_N[b0c1000002NO12NO1O100000f]O\\NXb0f10001OO1O100O100002N00000000001O00O10000001OO1000000O10000O1001OO11OO1001O000000000000001O1OO1001O0000O100000000000000001OO1001O001O00O10000000000000000000000O1O1000000000000001O0000001ON2001OO1O10000O11O0000001O00001O00O1001ON2O1O1000000O11O001O00000000O100001O1O1O1O1O1O0000000000000000O1001OO10000000000000000000000001O000000000j]OXNTb0h1l]OXNTb0j10O1O10000O1O100000000001O00000i]OYNUb0i1000000000O1O1N21OO1O10000001O0000001O00000000O1O100N200001O00000000000000O11O0000O10000000000O11O0000O1001OO11O1O1O1OO11OO11OO11O0000000000O1", "size": [640, 480]}, "area": 18889.0, "iscrowd": 0, "image_id": 10114, "bbox": [87.0, 0.0, 393.0, 59.0], "category_id": 102, "id": 10012300}, {"segmentation": {"counts": "b[[22mc02K4M4N101O02N3M010O00O101H71O0001M_Oe\\Oa0[c0200A`0M200000001N1001OO20O001O010O000010NPOZ]O1O>hb0@[]OM0c0fb0[Oe]Oe0kb01O00000010O001O01O0MZOm\\Oe0Sc0\\Ol\\Od0Qc0[Oo\\Oj0Pc0WOo\\Oi0Qc030001ON2O1O100O100O1O100O10001O0O1N21O00O10O010000O10000O1O1000O0100O100OO2M201N22M1O10000O10000O100O100O100O01000O1000O13M0N7KN23MoS30PlL2N1O1000001O00000001O00O100O12N01M200L4000000000001O01OO1O100MCc\\O=]c0Gc\\O5]c0Kc\\OM04^c0Kb\\O045[c0Jh\\O7ac0O0000000J^\\R10kolN0jc0300000000O2O00000000001O000000000000010O0000001O000000000001O00000000000001O000001O0000000001O0000000001O01O00O11O00000000000001O0001O0EIm\\O7Sc0Im\\O7Rc0Jn\\O6Sc0Im\\O7Rc0Jn\\O6Sc0Im\\O7Sc0Im\\O8Rc0Ho\\O7Qc0Io\\O7Qc0Io\\O7Qc0Io\\O6Rc0Jn\\O7Qc0Jn\\O6Rc0Jn\\O6Sc0Im\\O7Xc06O10000000000O2O000L4001O1O001O2N00N21O3M001O0000001O0000O20O00O1N2O100O1O1O1O1000000001ON22O2M1OO10ON1kD", "size": [640, 480]}, "area": 4460.0, "iscrowd": 0, "image_id": 10114, "bbox": [120.0, 340.0, 360.0, 48.0], "category_id": 107, "id": 10012301}, {"segmentation": {"counts": "o_l21mc02L400000000000000O1O1O1O1O1N2O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1N2O1O1O1O1O1O1O1O1O1O1O1^NmNV@T1j?a100O100001O1OM32NO1002N002N001O0bLa_O[3_`0eLc_OY3c`0O1O00N22NO10000002NO10000O1MgL__OY3a`03O1M3N2L4000000000000000000O11OO1O1O1O1O1N2N2H82N0000000000O100000000000000000000001O0000001O2NN200000000001O000000000000N2000000000000O1O1002NO1002kKW@o3m?0002N2N2VLl_Od3T`0[Lm_Oe3W`0000000000000000000000N2O11OO100O11O001OO10000O1000000001WLk_Oe3U`0[Lk_Oe3X`001O0000000000003MN200O1001O00N22NO100O100000000000000001O000000000000001O0000000000001O00000000002NO11O001O1O001O00O1001OO100001ON200000000001O1O000000000000000000000kNa_OiN_`0W1a_OiN``0V1`_OjN``0W1`_OhN``0W1a_OiN_`0U1e_OiN\\`0S1h_OjN\\`0]O__OHLW1b^OA_a0>c^O_O_a0Io]Oa0c0E_a0Fn]O00g0d0@da0=`^OC_a0:j^O_OXa0;f]OF`c07;JSn6", "size": [640, 480]}, "area": 31088.0, "iscrowd": 0, "image_id": 10114, "bbox": [147.0, 504.0, 321.0, 136.0], "category_id": 117, "id": 10012302}, {"segmentation": {"counts": "ZRj41mc03T\\OOgc01Y\\OO1Nbc0;O2N101N2I8HZOS]Og0jb09I7N3N10OO3NO12N0OO200L3100000000000001OO1O100M_]OgNbb0X1b]OhNZb00a]OV15jNM0[b0W1d]OiN04\\b0T1c]OoN]b0[1O01O0000102M1OO12N2N1O3M0N3O1O00000001O00001O1OO102M2QOR]O618mb0CR]OO7=ib0A^]O>Rc0O2N2N1O2O002JW\\O1Pf=OPZB014OK`c0b0L000000000O110O0O11O000000f\\O@Uc0?j\\ODTc0h0l\\OSOmb0T1J12OO100N22N0000O1001ON4NN3000NO21ON2O3N2mNX]Oj0Sc0L100O1O1O000002NO20M13OO00N200O2N7KWZb1", "size": [640, 480]}, "area": 4249.0, "iscrowd": 0, "image_id": 10114, "bbox": [246.0, 284.0, 153.0, 74.0], "category_id": 132, "id": 10012303}, {"segmentation": {"counts": "kQP22lc06L3[\\OF\\c0>b\\OB_c0?O4M1N1000000001O001N12NK6O001O1Ca\\O5MK[oh18]QWN>^a0Ba^Oh0Ua0YOk^Of0Ua0ZOl^Of0a`0ROi^OO61I8OHe0m0d`02\\_OMe`03Z_ONe`04[_OKe`08V_OJj`07j^O9Ra0]1MO11O2[_OSMR`0o2a_OPM74W`0o2f_OVMW`0Ie_OR30UM[`0Gg_O`3\\`00c_O`LZ`0`3f_ObLX`0d3O1O00N13NO011OO102M010000O1Mk_O[LU`0e33O1M3N2L311ONdL`_O\\3``021OO1003MO10O11N01O1O1ZO\\_OoMe`0Q2[_O]M0>f`05]_O\\ON2OO62Mn0MoN004:e`09k_O]O@o0OQO38i`0HT_O9o0GoNb00^OPb01T_O8kNG02bc019NZeo3", "size": [640, 480]}, "area": 6278.0, "iscrowd": 0, "image_id": 10114, "bbox": [102.0, 310.0, 173.0, 226.0], "category_id": 143, "id": 10012304}, {"segmentation": {"counts": "ejb82^c09f\\OHXc0;g\\OEYc0a001O000m]O\\Oj`0d0Q_OAo`0?Q_OAo`0?P_OCPa0=k^OGTOFna0c0l^OMSa03j^O2Ta0Nk^O3Ua0Mf^O9Ya0Gc^O=^a0B_^Oa0aa0_O\\^Od0da0]Oa^O=_a0CY^Oe0ga0[OU^Oi0ka0i0MOL4N32M101O0K6K4I6L6I6K5M201O102L10N3RB", "size": [640, 480]}, "area": 1853.0, "iscrowd": 0, "image_id": 10114, "bbox": [439.0, 445.0, 41.0, 79.0], "category_id": 168, "id": 10012305}, {"segmentation": {"counts": "SeQ91nc03S\\OMic09W\\OGcc0>MO1O10010N11ON1200OM32N00NoF", "size": [640, 480]}, "area": 192.0, "iscrowd": 0, "image_id": 10114, "bbox": [463.0, 290.0, 17.0, 15.0], "category_id": 171, "id": 10012306}, {"segmentation": {"counts": "0e8[;000000000000001O00000000000000001O00000000000000001O00000000000000001O00000000000000001O000000000000001O00000000000000001O00000000000000001O00000000000000001O00000000000000fGQER2Ni2R;UKREJLg10mM30MO30M\\20fM0O1OOW10nN6[^Oa0OPOO7ga09Z^Oa0M]Oha0h101M3O001UOgMX_OO`0[2Q>eM_AOj0j0UOVO13O4b0W2_ObMZ>4eAL011Oc0^1LV1f=lM[Bo0OU1e=mM\\BZ1@VNOc2U>mM[BU4c=mK]BS4_=ZKQB00c0=]OCg49YKR=Q1lBPOJj47UKR=R1mBoNIk48TKQ=T1iBo3a=QL]BQ4b=W10000O1O11OO100N30O1`IaB]6a=oM`BdK014OKa1a=_N_BZ4b0SMR=l2nBTMQ=m2oBSMGdNP=W4YCUMGdNo1OO100O1000000001O001O01O01O001OO1O1O100O1O1O2N1002N001OO100O100000000001O4L2M3O1GZOS]Oi02BUb0Fi]O[1Wb0eNi]O\\1Vb0dNj]O[1Wb0eNh]O]1Vb0eNi]O[1Wb0eNi]O\\1Vb0dNj]O\\1Vb0dNj]O]1Ub0cNj]O^1Vb0601N0R^OXN1O\\a0j1b^OYNM0aa0h1]^OcNca0m10000000001O001O0000M_^OhM`a0X2a^OgM_a0Oc^OR2MoMda0O_^OR2NnMha0R230O11O000000O100000^O[^OiNda0X1^^OfNba0Y1_^OgNaa0Y1_^OgNaa0Y1_^OgNaa0X1`^OiN_a0W1a^OiN^a0X1a^OiN_a0W1`^OjN`a0V1`^OjN`a0V1`^OjN`a0V1`^OjN`a0V1`^OiNaa0W1a^OgN_a0Y1a^OgN_a0Y1a^OgN^a0Z1b^OfN^a0V1X^OdN:6^a0l0c^OmNO7^a0k0d^OnNN7^a0j0f^OnNM7]a0k0f^OoNL6]a0k0i^OnNJ6^a0l0h^OnNJ6^a0l0T_OTOl`0l0T_OTOl`0k0U_OUOl`0j0T_OTOl`0n0T_OoNo`0P1R_OoNo`0R1n^OnNTa0R1l01000000000001O0Z]OlNM0O0_b0_10000000001O1O1O1O1O1O1O1O2NO2N1O011N100If]OhNZb0V1i]OeNO0Xb0[1i]OeNO0Xb0Z1:O1O100O1J6JV]OWOib0h08J6O1001OO1000000O101O0O100000000000000000000001O0c\\O_O[c0c000000001O00010O3M1OO12N2N1O3M001O1O00000000000O100000KT]OUOlb0:T]OE14Vc01U]OJnb04a0Oama20]R^M3GJc\\O:_b0T1N002N000KaNh]Oa1Wb04000O11O001O0000O1ZNh]Oc1]b0]Nc]O^1db0bN\\]OV1kb0L01O0101OO11ON21O1OM32N00N2cF", "size": [640, 480]}, "area": 9845.0, "iscrowd": 0, "image_id": 10114, "bbox": [91.0, 283.0, 389.0, 81.0], "category_id": 176, "id": 10012308}, {"segmentation": {"counts": "e8S;m800000000000001O00000000000000001O00000000000000001O00000000000000001O00000000000000001O000000000000001O000000000001O0001O00000000000000001O00000000000000001O00000000000000001Oe2[M0[Nd1T1mNb0^O0O100O100O100001O0000001O0000001O0000001O0000001O0000001O00SNZH`Gf7_8^H^Gb7b8dHUFBg0i7T9gHRFIb0`7\\9aI]F_6c9dHSF78U7S:VImEi6S:XIlEh6o9\\IRFd6j9`IVF`6h9ZITFfN6o7`9aIgF_6Y9aIgF_6X9bIhF^6X9bIiF]6W9eHXF6b0U7V9bIjF^6V9RIYFROj0l7m8RI[Gm6f8RIZGn6k8mHUGS7l8lHTGT7n8jHRGV7P9\\HSFGP1l7o8WH_Gi7\\:0001O0000001O000O1O2N1N2O1O2N1O1O1O2N1O1O1O2N1O1O1O2N1O1O1O2N1O1O1O2N1O1O1O_NbIbE]6_:eI`EY6`:hI`EW6a:iI_EV6b:jI^EU6b:kI`ES6a:mI_ER6b:mI_ER6b:mI_ER6b:nI_EP6b:PJ^En5d:RJ\\Em5e:TJZEk5g:WJXEg5i:YJWEf5j:ZJVEe5k:[JUEd5l:\\JUEb5l:^JTEa5m:_JSE`5n:`JRE_5P;`JQE^5P;bJPE]5Q;cJoD\\5R;dJnD[5S;fJSER5n:nJQGR3m8fL`C7b5S1o6QOo61OM3K_\\O1\\c0;N100000000001O000O1000001O1O1N2O1O1N2N2NcT[1KckdN0O1O1O101N1O1O1O10000000000000001O01O000000000000000001O0001O0000000000000001O000001O00000000000001O0000000001O0000000001O000000000001O00000001O00000000000001O000001O0000000000000001O0001O000000000000000000010O0000000000000000000010O0000iTP1", "size": [640, 480]}, "area": 63322.0, "iscrowd": 0, "image_id": 10114, "bbox": [0.0, 277.0, 428.0, 356.0], "category_id": 183, "id": 10012309}, {"segmentation": {"counts": "ZmY41^34PMM[?2WCNZM60OY?1]CLWM5KIOO1:_?O]CLTMi0_?\\O\\Ck0eWNbAS2o=WLZBd5c=^J\\Bd5a=^J]Bd5b=]J]Bd5a=^J\\Bg53WJR=2jBj5NWJX=^6O2OO1000000001O01O00000005K7I2M2O1O00001O0O1nCgH^OOl;[7eDjHX;X7fDmHV;U7iDkHW;U7gDnHY;Q7fDPIV;^7_DcH];R86J00O15K1O000000000000000000000000001O00002N2N3M003M1O00002NM32NO1000F:B>cIUCY5W=eJlBo4^=RKcB`4k=^KWBT4V>kKlAj3_>ULbAa3f>`L[AV3n>YLg@>=R3R?`La@>>Q3S?oLn@W3k>hLVAn2T?RMm@g025X?UOg@6`07Y?AW@Ng06`?IW_OHS26T?NY^o1", "size": [640, 427]}, "area": 20773.0, "iscrowd": 0, "image_id": 10115, "bbox": [220.0, 366.0, 105.0, 274.0], "category_id": 98, "id": 10012310}, {"segmentation": {"counts": "Rlh11oc0001O0NOU\\O1kc0OU\\O2jc0NV\\O2jc0NV\\O2jc03O001O6i\\OD_Om0Y3ZOX:G`B=l3DT`n2", "size": [640, 427]}, "area": 30609.0, "iscrowd": 0, "image_id": 10115, "bbox": [132.0, 167.0, 144.0, 319.0], "category_id": 109, "id": 10012312}, {"segmentation": {"counts": "m3c0i3g1`9[N]Fg1b9ZN^Fh1`9YN^Fg1c9YN_EZOhM5Ec2na0YBI63Z12]=OUAJ6GB0l1?Y=OTAIa27\\Pb0_OR^OKIOO1:e0ma0[Og^Oe0Yb0201k\\OXOnb0m01O1O1O02OO01O20O002N100N11O20YOQ]O7Rc0CQ]O?Wc0100N2O2N002N100O2N002N2N14K7K0O000O01O10O000O1O1N3O0N2O;EbXP3", "size": [640, 427]}, "area": 5774.0, "iscrowd": 0, "image_id": 10115, "bbox": [117.0, 484.0, 155.0, 148.0], "category_id": 117, "id": 10012314}, {"segmentation": {"counts": "WbT62mc0:_O:XOf0ZOg0YLRNdDd2[;]MPDX3P[2_BdMa=e1WCUNog3\\BhLj>V3VAiLl>V3UAiLl>V3VA]LV?`3f0K6F9E;L4N2N2O100O[OgMe_OY2h?dMX@7KV2m?mMm_O4OP2S`0W1100001O002N1O2N1O3M2N3TJlKfKW4V4TL`Kn3^4SLbKo3Z4SLdKR4V4PLaGMg2U4d5RLcGKh2X4c5kK\\G@[O`0e3Y4`5gKZG]O@11h0e3V4^5dK[G=V3P4]5dK]G=U3Q4]5aKWGj0W3h3^5\\M\\Jg2a5ZM^Jh2_5ZM`Jj2\\5XMbJl2Y5\\MhGRM`2e5c5dM\\J]2`5hM^J_2W5eMhI^L]OU6b6]MPJbL\\Ol6XOaIi5R3aKdLjNL4a8I]Gc4b3hK_L79^ON1Y9_2dF`N`3XO`LKMMm0Y3o:cNRDUN=l3DgKb;Z8J2O0O11O0000O100000000000000010O1O02M3N3M0O4M1O000O3OL23M010001OO1I7G83OO0OSNbE[J^:c5lESJU:e5UFYJ[O`N^:a6mFoJeN`N^:k5dGfK[8e0gEd0d2gNe7d0hE0X3\\OQ7c0hEXOo34Z6d0hE[Nk4R1[5b0^K^Ob4b0_K^O_4b0bKYOc4g0^KjNg4_1YKQNP5DRE^2\\a031O000O2OO10O10000O100mNT1ZOYf=_OdZB9G9G9G9I7F:F:DF:D<@`0_Oa0_Oa0C=A?D<^Ob0A?C=B>D[4e0_Oa0_Oa0]Oc0fNZ1_Oa0\\OdP:", "size": [640, 427]}, "area": 43895.0, "iscrowd": 0, "image_id": 10115, "bbox": [152.0, 8.0, 275.0, 632.0], "category_id": 172, "id": 10012318}, {"segmentation": {"counts": "0m3c0Lg1`9[N]Fg1b9ZN^Fh1`9YN^Fg1c9YN_EZOhM5Ec2nDF:D<@`0_Oa0_Oa0C=A?D<^Ob0A?C=B>D[4e0_Oa0_Oa0]Oc0fNZ1_Oa0\\OdP:", "size": [640, 427]}, "area": 37976.0, "iscrowd": 0, "image_id": 10115, "bbox": [307.0, 0.0, 104.0, 640.0], "category_id": 182, "id": 10012320}, {"segmentation": {"counts": "eQZ34kc0:G9G9G8H8H8G9H8H8H4L0O100000000O10000000001N100000000O100000000O10000000001N100000000O100000000O1000000002N101N1O2N1O2C=XOg0G:G8G:G8HSc]1LV]bN3O1N2N2O1O1N2O1O0O2O1O1O0001I6Eegn1", "size": [640, 427]}, "area": 5396.0, "iscrowd": 0, "image_id": 10115, "bbox": [169.0, 405.0, 157.0, 118.0], "category_id": 183, "id": 10012321}, {"segmentation": {"counts": "^YW2;^;GmE>d8R1XGQOd8T1TGSOh8WO_Fe1?\\On8oNlFa14Ad9T;XOSEb0U;lNWER1d;M6J>BTml5", "size": [427, 640]}, "area": 920.0, "iscrowd": 0, "image_id": 10123, "bbox": [170.0, 307.0, 16.0, 120.0], "category_id": 123, "id": 10012322}, {"segmentation": {"counts": "0neQ1;QgnN;DQNGP26nMNR20lM4T2JjM:W2CgMb0X2\\OfMh0Z2VOdMGfLJe5S2BjM?Y2_OeMb0]2[ObMg0`2UO`Mm0c2mN_MT1a2iN`MY1a2cN`M_1`2^NaMd1_2XNcMj1]2VNbMk1_2TN_Mn1a2RN]MP2c2PN[MR2e2nMYMT2h2kMVMW2j2U40cIWMX2i2hMYMV2h2iMZMU2f2kM\\MS2d2mM^MQ2b2oM`Mo1a2PNaMn1_2RN_MP2a2]41O0000001O00000000000000O10000000000O1000000000000O1001O001O000N3L3MoLoEo2m9PMWFP3f9PM]FQ3_9nLeFR3X9nLkFS3f9001O001O1O1O1O1O1YOg0J6K5M3N2O1O1O1N2O1O1O1O1NXLbGf2d0XLS7n0]Hk2>ZLS7f0eHQ35\\LT7>lHW3M_LT77SIZ3HaLT70YI_3BdLS7I_Ic3\\OhLS7@fIh3VOjLY8V3eGnLY8R3fGQMX8o2gGSMX8m2fGWMX8P4O1N1O2L4G8H9L42M2O2N2N0O01N1O1O1O1O1iIUJl4l5TKUJj4k5VKWJh4j5XKWJf4i5ZKZJc4g5]KZJa4g5^K[J`4e5aK\\J]4e5bK^J[4b5fK_JX4b5gK`JW4a5iK`JU4a5jKbJS4_5mKbJQ4^5oKdJo3]5QLdJm3]5RLeJl3\\5TLeJj3\\5ULeJj3\\5VLeJh3\\5WLeJh3\\5XLdJg3]5XLeJ[OoNl3]6iLdJYOSOk3Z6kLeJWOTOl3X6mLdJUOXOk3U6oLeJSOYOl3S6QMdJQO\\Ol3Q6RMYKl2h4TMYKj2h4UMZKi2g4WMZKg2g4XM\\Ke2e4[M\\Kc2d4]M^Ka2c4_M^K_2c4`M_K^2a4cM`K[2a4dMaKZ2`4fMaKX2_4hMcKV2^4jMcKT2^4kMdKS2\\4mMfKQ2[4oMfKo1[4PNgKm1Z4SNiKo0[MlNm65iKh1W4XNkKg1U4YNlKe1U4ZNlK@RMj1R7fNnK^OQMk1R7gNmK]OQMl1S7fNmK]OPMm1S7fNoK[OnLo1T7fNnKZOnLo1V7fNmKZOnLS1Q8DUK0X5OhJ0Z5OfJO\\52cJM_52aJN_52aJM`53`JMa53^JLc54]JLc54]JLd53\\JMd54[JKf55YJLh53XJMh54WJLi55VJKk55TJKl56SJJm58QJHo59oIHR68mIHS69lIGT6;jIEV6=hICX6e0`I[Oa6h0[IYOd6g0[IZOe6g0ZIYOf6g0ZIYOf6g0ZIB]65mI5h5F^Jd0W5]OiJl0n4UOQKP1i4QOWKn0i4TOVKk0j4VOWKh0i4ZOWKd0i4]OXKa0h4AXK=h4fN`H`0i2h0g4gNbHb0g2e0g4iNcHb0i2a0d4mNdHc0j2d^7CM1P<0lC971m;7SDIm;6SDKl;6TDJl;5TDKm;5RDLm;7QDIo;9nCHR<:kCFUmLCR3>nLBP3`0PM@o2a0PM@o2a0QM_Om2c0RM^Om2c0SM]Ok2e0UM[Oh2h0WMYOf2j0ZMVOc2m0]MSOc1cMeL\\3h1ROc1oMULR3X2oNc1k1\\NVNd1j1\\NVNc1m1ZNTNf1m1YNSNg1n1WNSNi1o1UNQNk1o1UNQNk1o1UNQNj1P2UNQNk1n1VNRNj1n1VNRNj1n1RN]KnMf2P4m1RNVNn1j1RNVNn1j1RNVNn1j1RNVNn1j1RNVNS2e1mM[N]1ZMQMZ4c1\\NR1eMZMo3@eKP2g2U1gMZMm3AeKP2g2U1hMYMP4b1XNU1iMXMo3b1YNV1iMWMn3c1YNV1jMVMn3b1YNX1iMVMn3b1YNW1iMXMn3a1YNX1hMWMo3`1ZNY1fMXMP4_1ZNY1fMWMQ4]1\\N\\1bMXMQ4]1]N[1bMQM_OOb4e1]N[1bMQM_OOb4d1^N\\1bMPM_OOa4e1^N[1cMQM_ON`4f1^NZ1eMmLB2[4g1^NY1PNoLb3h1^NX1QNPMa3h1^NW1RNPM_3k1_NU1RNPM_3j1`NV1QNPM_3h1bNX1oMPM^3i1cNW1oMPM^3h1dNX1nMPM^3h1dNX1mMQM_3f1eNY1lMPM`3f1eN[1jMoLa3f1eN[1jMoLa3f1eN[1jMoL`3f1gN[1iMoL_3g1hNZ1[2aN^J_NX3P3Z2aN^J_NX3P3Z2aNiMb1S2nLbJ\\1\\3j1n1jLfJ]1[3l1n1eLgJ_1[3n1l1cLiJ^1\\3o1k1cLiJ^1\\3n1l1dLhJ^1\\3n1o1QNQNo1o1QNQNo1o1PNRNQ2m1oMSNQ2m1nMTNR2l1PNRNP2P2PNnMP2U2PNhMo1Y2SNeMm1[2TNdMk1^2TNbMk1`2UN_Mi1c2WN]Mh1d2XN\\Mf1e2ZN\\Mf1d2YN]Mg1d2WN]Mi1b2YN]Mg1b2XN`Mh1`2XN`Mg1a2ZN^Mf1b2YN_Mh1`2WNaMi1_2VNbMj1^2iMYJ\\OZ3k2]2iMZJ[OY3l2]2iM]JWOW3P3UMkLf4l0QKWOT3a3eL]LT5m0cNh2U1ZLVKQ1NoNg3f3U1_MmNa2R1`MnN`2P1bMPO^2P1aMQO_2o0aMQO_2o0aMQO^2P1aMQO_2P1`MPO`2o0aMQO_2o0aMQO_2o0aMQO_2o0`MRO`2n0_MSO`2m0`MTO`2k0aMUO_2k0aMUO_2k0aMUO_2>mMCS2=YMdKEo3R3=WMfKGm3R3=WMgKUO13NOo3b3;WMmKVOK1m3b3:XMnKUOK0n3c3:VMVLVO`3d3:VM:l2DTMbCB_<eEA]:=cEC_:;aEE_::bEF_:9bEF^:9cEG]:9dEF\\:9eEG\\:8eEG[:9eEG\\:7fEH[:7dEJ\\:5dEL]:3cEM]:4bEL^:5`EL`:1PETO>7CM1Om:j0SESO971Mc:h0dE[OIMc:h0cE[OKMb:g0dE\\OJMb:g0cE\\OKNb:f0cE[OLOW:IZET1f0ROI1T:R1UFjNH4S:R1WFgNF8Q:R1lFnNT9R1kFoNT9Q1mFoNS9Q1nFnNR9Q1oFoNP9R1kFfNhN9]:P1kFjNfN6_:P1mFSOR9n0PGPOP9o0RGPOn8P1RGPOn8P1RGPOm8P1UGoNk8Q1TGPOm8o0SGQOm8n0UGQOk8o0UGQOk8o0UGQOk8n0UGSOk8l0WGSOi8m0XGROh8n0YGQOh8m0ZGROf8n0ZGROf8m0]GQOc8o0\\GROd8n0_GoNa8P1aGoN^8R1R2O01O100O02OLnNfCQ1[QYV1CkNe0ODO3c1T1\\NCP1`0WO]O>nN[O0110>d07\\O30B14`1S1^NCP1`0WO\\O8SOAg0:6GH0C06^1X2@lNXOYO85LLGH0CO:[1U2ClNXO\\O431KEH1CO9\\1V2BkNXOAM39FDIOE15^1X2eNUMe0f1^OQ17DBWNX1^OoNk2MUMe0f1^OQ185h0WMPOh2MUMf0e1]OR182h0]MPOe2MUMf0e1\\OS1:Ng0bMmNf20RMf0e1\\OS1;Ld0gMlNf23oL21m0TO^L11^1IR1=OI]MHc3NYLM8>a1EP1b0OD]1IkKO9;`1GP1c00_Ob1MmK3JMh11o0d01[Ob10mKNG0R23g0e0T7YOmHi0n900001O0000O100VOXCi0gi0V4]LYKm2a0g0U4\\LXKo2a0g0W4ZLmJ01l7P5\\HmJf7S5[HjJh7V5;000001O00O1000000000000M3GiJQH[5o7eJRHZ5n7fJQH[5o7eJQH[5o7dJQH]5o7400000000000000O1O100O100O11O0000O1O100O1001O0000000000O10000000000000000O1N2000000XLjJROV5n0kJQOU5o0kJQOU5o0lJ_LYOQ2k5`1QKZLTOV2k5`1UKVLPOZ2k5`1ZKQLkN_2k5`1ZKQLkNU2U6j1RKVNn4j1RKVNn4j1RKVNn4j1RKVNn4T2SJhK:U2b5S2PJlK>Q2b5S2mIoKb0m1a5_2_JaMa5a2]J_Mc5c2[J]Me5d2ZJ\\Mf5d2ZJ\\Mf5d2ZJ\\Mf5d2ZJ\\Mf5c2[J]Me5c2[J]Me5c2[J]Me5b2\\J^Md5b2\\J^Md5b2\\J^Md5b2\\J^Md5b2\\J^Md5d2ZJ\\Mf5g2WJYMi5i2UJWMk5k2SJUMm5l2RJTMn5l2RJYLJ_OT6X4RJXLK@S6X4RJWLLAR6h5nIWJS6h5nIXJR6g5oIYJQ6f5PJZJP6=[Jb3EQLP6=\\J`3GQLm5?\\J_3HRLl5?\\J_3HRLl5?\\J_3HRLl5?\\J_3HRLl5?\\J_3HQLm5`0[J_3MlKh5e0[J_3MmKg5d0\\J^3OlKf5f0[J^30kKe5g0QJh3;`Kd5n5]JQJc5o5]JkIi5U6k0O10000000000UKhHZ3X7eLXIk2i6UMWIl2h6TMYIm2e6SM[Io2c6QM]Io2c6PM^IP3b6PM_Io2a6PM`Io2a6RM^In2b6QM_Io2a6RM^In2b6SMeIe2[6\\MeIc2[6]MeIc2[6^MdIcNWOj3U7dMcIbNXOj3U7dMdIaNWOj3V7fMbI^NXO06f3P7mMkIS2U6nMjIR2V6nMjIa1YOoLo6_1iIc1VOPMP7]1iIa1@lLg6b1jIb1h6^NWH_NU1j2f6kNYIV1f6kNYIV1f6kNbIm0]6TObIn0\\6oNgIQ1Y6iNnIn0Z6QOaIU1_6kN^IX1b6hN^IX1b6jN\\IV1d6jN\\Ia1Y6dN]H[N040L>[3U7jNhHV1X7iNjHc0CiMc7e1iH6DnM14d7e1kH7APN14b7Y1UId0_OjMK9`7Y1SIg0FcMJ:]7\\1QIh03kMl6]1QIg05kMj6^1QIg06jMi6_1PIh09gMg6j1iHO1O100O11O3M6JbM`GEc8=[GEc89`GEa8<_GCa8=_GBb8>_G@b8>`GAa8>`GAa8a0^GB^8=dGB\\8;_GVN_O_1R9<_GTN_O`1R9<_GTN^Oa1S9;_GKa85_GKa86]GAm8=UGCk8>VG@j8?VGEg8>VG_Om8a0SG_Om8b0PG]OS9a0nF]OU9h0gFUO[9k0ZFlM4]1b9Y251OO1N2N2O1O1O100O1O100O1O1H800000000000000000000000000001O1O004L000000000000001O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O3M3M3MN2000000O10000000000O100000000000000005KZOgFQMY9e2RGZMn8e2TGZMl8f2UGYMk8g2VGXMj8h2WGWMi8i2XGVMh8j2XGVMh8i2XGXMh8i2WGWMi8i2VGXMj8h2VGWMk8i2TGXMl8h2TGQM_OO]9P3TGQM_OO]9P3UGPM_OO\\9P3VGQM_ON[9P3XGmLB2V9P3cGoL]8P3dGPM\\8o2eGPM\\8P3dGPM\\8P3dGPM\\8P3dGPM\\8P3dGPM\\8P3dGPM\\8P3cGQM]8o2cGPM^8Q3aGoL_8Q3aGoL_8Q3aGoL_8Q3aGoL_8Q3R100003M4L3M2N00O10000001O00000000O100O1O1N2O1N20000000000O1001O000000000SFkL[9d3UF]Lk9e31000000000000O1000000000000O100000000000000000000002N000000001O001O00001O0000000000001OO1001O00O16J1bFQLU9o3hFTLX9T4000000000002N0000NhFhKX9X4hFiKW9V4jFjKV9V441O001O000000000000L45KK55K00000000004hFbKR9`40001O002N2N001O001O001O0000O11O00001O000mGWK\\O0k7j4hHVK]O0k7j4hHVK]O384m6d4UIYKDi0V7o3SIZLl6f3SI[Lm6f3RIZLn6f3RI[Lm6e3SI[Lm6f3RI[Lm6e3SI[Lm6f3QI[Lo6e3PI\\LP7e3nH\\LR7S507mHZIj6l6L2NM31YIVIb6n6000000000000000000000000000000000000000001O00O11O00000000000000000000000000M33M1O00000000000000000000000000N2000000001OO1O1N21O00O12N1O00N200000000M\\IUIe6k62O11ON2000000O10000000000000000", "size": [436, 640]}, "area": 105340.0, "iscrowd": 0, "image_id": 10125, "bbox": [17.0, 0.0, 623.0, 270.0], "category_id": 157, "id": 10012330}, {"segmentation": {"counts": "SV\\7111_=3N100O10000N20001O0000000O100]OI[CM:C<[O^DiNb;MdDn0LRO_<B`0@4L1O0000001O00aJVI]4j6dKVI[4j6fKTI\\4k6dKVIa4d6_K[Ii4^6WKbIi4^6WKbIj4]6VKcIj4]6VKcIj4]6VKcIj4]6VKcIi4^6VKdIi4\\6YK`Ii4`6VKcIHAd4l6cKgIF^Of4k6dKgIE@f4i6fKgI@[O07i4g6fKTJY4l5gKTJY4Z6XKhIg4_7N2YO\\GeLe8X3]GgLd8W3^GhLc8U3`GkL_8T3cGlL]8R3eGnL[8P3gGPMY8n2iGSMV8k2lGUMT8h2oGXMQ8f2QHZMn7e2THZMm7d2UH\\Mk7b2WH_Mi7]2ZHcMj7W2XHiMn7o1SH_MnN?U9k1SHiMhN4X9o1UHkMeN3V9P2ZHRNg7j1bHPN_7m1Q2L4M3L4L4I7K5K4K6I7N3NjM3PGLQ95nFJS9d0aFQOhN6h:i0cFUO^9l0bFQO`9o0`FPOa9P1]FQOd9o0\\FPOe9P1[11O001iCnNS_7C_H>a7C]H>c7C[H>e7CYH>g7>\\GCd8>ZGCf8?WGBi8`20O100O100O1O1N2O11O00001O001O1O000000001O000000000000O1O10000`N[GZNe8c1aGZN_8d1eG[NZ8c1jG\\NU8c1mG]NR8b1PH]NP8b1SH\\Nm7c1VH\\Ni7c1ZHZNg7\\OcGe1g0iNk7B]Ge1j0eNl7FZGd1l0cNl7IXGd1m0`Nm7LVGd1n0^Nm7NUGc1o0^Nm7OTGc1P1\\Nm71TGb1P1[Nm73RGc1Q1YNn74QGc1Q1YNn74PGd1a:\\N_Ed1T;01O00O1001O1O6KO07bNXDl0i;RO\\Di0_;[ObDf0`;UOTDO=l0P<00100O1O2O0O3M2MM4O:FlM_OcG=X8IjG5V8KlG2U8NlG0T81mGMT83mGKT85mGIS88nGFS8:mGFS8:nGDS8gNAa3MTJ3e3>eNCj3MbM?dNDQ2J[M0S2b0_NFQ2JZ1a0cLEo1JiK2d5`0aLFo11`19`LFn14a16`LGo13b15_LHn14d13^LIn14d13_LIl14f12^LJl14f12^LKk13g12^LKk13h11]LMj12i11]LLk13h11]LLk12i12\\LLk12i12\\LLk12i12\\LLk12i12\\LLk1d0W1@nLLk1e0QLQOQ5>SMLk1g0T1]OQMLk1f0U1^OPMLk1e0V1_OoLLk1d0W1@nLLk1c0X1AmLLk1b0Y1BlLMj1`0Z1DlLLj1?[1EkLMi1<]1HjLLi1;^1IhLNi18_1KhLNh16a1LgLNh15a1NgLNg14b1NgLOf14a1NiLOe14`1NkL0c13`1NmL0b12`1OnLOb13^1OPMMc15Z10SMLa15[10TME_1d0Z1IWMC`1d0U1L[M_Oa1e0Q1O^M\\Ob1c0Q11]M\\Ob1c0Q11]M\\Ob1c0Q11]M\\Oc1b0P12]M\\Oc1b0P12]M\\Oc1b0P12]M\\Od1a0ZNRO?Q1C\\Od1`0ZN@3c00]Od1?XNNH3i4O^K:^OEU52\\K;^OCV52[K=^OAV53[K>^O_OW54XK`0@\\OW55XKa0@ZOW57WK8JAo47VK9K@n49UK9L^On4:UK9M]On4;SK9XO^NMn0g5cIf1FlL?Q1V6oN[Ib13g1SL\\OUO6h4?PL_OXO0h4b0nK@[OLg4e0lK@]OKg4e0jKB_OIg4f0hKB@Ih4f0fKBBHh4g0dKBCHi4W1cJZM5h1?Gi4c1eJgNa0Gj4d1bJfNd0Fj4g3UKZLk4f3UKZLk4e3UK\\Lk4d3UK\\Lk4c3UK^Lk4b3UK^Lk4a3UK`Ll4^3UKbLk4\\3WKdLi4[3WKfLi4[3VKeLj4[3VKeLj4[3UKfLk4[3SKfLm4Z3SKfLm4[3SKdLm4]3RKcLn4]3SKbLm4^3SKbLm4^3TKaLl4_3lJhJIi1[5`3kJhJIh1\\5`3jJiJKf1[5a3jJjJJe1\\5a3jJjJKd1[5b3jJjJKd1[5b3iJlJLa1[5c3iJlJLa1[5c3iJmJL_1[5d3iJmJL_1[5d3iJnJL]1[5e3hJoJM]1Z5d3iJoJN\\1Y5e3iJPKM[1Z5f3gJPKOZ1Z5g3fJPK0X1Z5j3dJnJ2X1Z5l3aJhL_5Y3`JgL`5b50000000000000000O100O100I7RNn1RNUd6lNf^I9F9H9G8N3M2N3N1N2N2N1O2N1ZEUNk9m1QFXNm9h1QF[Nm9g1oE]No9d1nE`NP:b1mEaNR:_1kEeNS:\\1kEgNT:Y2O1O1O1nEdMS9Z3O10000000000O10000000001N10000GoKXGQ4g8:0000000000000hKYGl3T9OBoKcGP4]8YL[Gf3e8[L[Gd3e8]L[Gb3e8^L\\Ga3d8`L\\G_3d8bL\\G]3d8cL]G\\3_4VL]O>UL[3Z4[L_LIS2a0UMZ3V4_LbLGSO0m2?YMZ3S4cLcLFk2f3?gLdLES2<[MW3l3jLdLFS2:`MS3f3PMeLEU28bMQ3a3UMfLDW26dMo2]3YMeLEZ23gMl2W3`MeLB^22hMj2S3eMdLAa20jMh2n2lMcL^Oe2NmMe2i2RNbL\\Oi2MnMc2d2RO^O[NPNa2`2VO@YNRN_2[2[OY1b0eN_O^1?_NDc1:[NHh15UNLo12oM0S2NjM5Y2HdM;^2C`M>c2A\\M?g2^OXMc0k2ZOTMg0n2WOQMi0S3TOlLm0W3POiLP1Z3mNeLT1^3iNaLW1b3gN]LZ1f3cNYL^1j3_NVLa1m3\\NRLe1Q4XNnKh1U4VNjKk1Y4RNfKo1]4nMcKR2`4kM_KU2d4iM[KX2g4fMYKZ2j4cMUK^2m4`MSK_2P5_MPKa2S5\\MmJd2U5ZMcJ@XNV3W7XM`JDXNS3\\7VMZJKXNo2`7TMWJOWNn2d7QMTJ3WNl2h7nLPJ^3S6`LlIa3V6]LiId3n71N101O1O1O001O1N2O001O1O1O001N2O1OJlFVLT9k3PGQLo8P451O1O1N2O001O1O1001O1O1O001O1O001O1O00O10000000O100oMQGFn8:`GYO`8f0nGmNR8R1SHiNn7V1THiNl7V1VHiNj7V1XHiNi7T1ZHkNf7T1\\HjNf7T1SHTOm7k0THUOm7i0UHVOk7i0VHWOk7g0VHXOT4YOnM]1QNYOo3]OPNW1SN\\Ok3@QNR1WN]Of3DSNm0XN_Oc3GTNh0[N@b3ISNe0]N^Ob3NQNa0d4@^K:d4H_K1d40^KJd4:]K@e4b0\\KXOf4k0l33M2M4M2M4M2M4M2M4M3L3N3L3N3L3N3L4M2M4M2M4M1N2O1N2O1N101N101N101N101N10O010O010OQKfLN[31hLMX32kLLT34nLJS35PMIo27TMFm29UMFj2:YMCh2;\\MCc2>^MeKYOY3Z3Q1`McKZOY3U3T1dMaKZOW3S3W1eM`K[OW3o2Z1hM]K\\OU3m2]1jM[K\\OV3i2_1mMYK^OT3f2U1fLPLQ2i2X1c0MYO4d02YONd07YOIf0;XOEe0>ZOBd0a0\\O_Oa0d0^O\\Oc0d0]O\\Ob0e0]O[Od0e0\\O[Oc0f0\\OZOe0f0[OZOd0g0[OYOf0g0ZOYOe0h0ZOXOg0h0YOXOf0i0YOXOg0h0YOWOg0j0XOWOh0i0XOVOh0k0WOVOi0i0XOVOi0j0VOWOj0i0VOVOk0j0TOWOl0i0TOVOm0j0ROWOn0i0ROVOo0j0QOVOo0j0POVOQ1j0oNVOQ1j0nNVOS1j0mNVOR1k0mNVOIfLTOT4S1UOJYMaNb3d1VOKXMaNb3d1UOLYM`Nb3c1VOMXM`Nb3c1UONYM_Nb3b1VOOXM_Nb3b1UO0YM^Nb3a1VO1XM^Nb3a1UO2YM]Nb3`1VO3XM]Nb3`1UO4ZM\\N`3_1WOa1g0`NXOb1g0]NZOn0VMQM_3Q2ZOo0WMPM_3P2[OP1VMQM^3o1\\OP1VMRM]3m1]OR1VMRM\\3l1^OR1VMSM[3j1_OT1VMSMZ3i1@T1VMTMY3g1AV1VMTMX3f1BV1UMVMX3c1CY1TMUMX3b1DX2;gMEg1fLlLd3]1FZ1UMYMS3\\1H\\1VMYMP3[1J\\1UM]Mn2V1M^1UM^Ml2T1O^1UM`Mj2Q11`1UMaMh2o03`1UMcMf2l06a1TMeMd2j07b1VMeMa2i09b1VMgM_2f0;g1RMfM`2d0>c1UMkM[2a0`0d1VMmMX2?b0d1UMPNW2;d0f1UMQNU29f0f1UMSNS26h0h1UMTNQ24j0h1UMUNP22k0j1VMTNn12l0j1VMVNl1On0m1UMUNl1No0W4POhKP1Z4oNfKQ1[4nNdKS1]4lNcKS1_4lN`KU1b4iN_KU1c4jN]KV1d4iN\\KV1f4iN[KV1e4jN[KU1g4jNZKU1g4jNYKU1h4kNYKT1h4kNYKS1i4kNZKS1f4mN[KQ1g4nN[KP1f4oN\\Ko0d4eM^Ij0P2^1d4eM_Il0o1]1c4eMaIl0n1\\1b4gMbIl0n1[1a4fMeIm0l1Z1a4gMeIn0l1Y1_4hMhIm0j1Y1`4gMiIo0i1X1W5fNkJW1W5hNkJV1W5hNkJU1W5jNkJT1W5jNkJS1W5lNkJR1W5lNkJQ1W5nNjJQ1X5mNjJQ1W5nNkJo0X5oNjJo0W5POkJm0X5QOjJm0W5ROkJl0W5QOlJl0V5SOlJk0V5SOkJl0V5TOkJj0W5TOkJi0W5WOjJf0Y5XOiJe0Y5[OhJb0S9M4K6K`\\7", "size": [427, 640]}, "area": 99598.0, "iscrowd": 0, "image_id": 10130, "bbox": [8.0, 32.0, 614.0, 389.0], "category_id": 183, "id": 10012337}, {"segmentation": {"counts": "Sfb0?ac0O11OO100000000O100000000O2O2N2N1N2O1OO;F00001OO11N2ON2N20^\\OD`c0>0N200001OO03NO1001OO1N200O1000000000O1000001O1O0000M300000000O1001N101OO11ON20001N100000002N001N2O1O00O1O1O1N2O10000O100O0100000000001O0^\\OE10O0Xc0b0g\\OBVc0c01N21O1O1ONj\\OZOVc0f02002NO10000M30000O10001O000001OO11O001N3N1O00001OO1001OO20O001OO1O2L3O2O0000000000O10001N1000000O3N00O11O00O2N1000000O11OO3N01O000001O0O110_Ob\\O>`c001O000O10O3M100O1O100N2O1000O1000000O1001OO11O001OO11O00002N0001O7I1N1O2O0N22M011O000O2O1O0O10O108HM23M2N]QS1", "size": [640, 316]}, "area": 3754.0, "iscrowd": 0, "image_id": 10136, "bbox": [29.0, 579.0, 230.0, 28.0], "category_id": 100, "id": 10012338}, {"segmentation": {"counts": "Tc51oc02M1U\\OMic05O2O1Y\\OHcc0;00f\\OEG6ob07Y]OKgb06X]OJgb0:W]OEib0=R]OFmb0g00000O1O10000O1O1H8O11OO100000000O100000000O1000000O10000:F00001OO11O1ON2N20gN[]OW1gb00N200001OO12NO1001OO1N200O100000000000000001O1O0000M300000000O1001O001OO11ON20000O1000000000000O1000000000000000000000000O100000000001O0bNa]O10O0T1fb0kN^]OR1gb01N21O1O1ONnNV]OR1jb02002NO10000M30000O100000000001OO11O001O2N1O00001OO1001OO11O001OO1O1M3O100000000000000001O000000002N00O11O00O1O1000000O11OO1001O00000000O11O00000000O1002N0000000000000000O1000000O1001OO11O001OO11O00002N00000000O1O100N22NO11O00001O1O0000O10000O1O1O100001O000000NnNY]OM0P1ob0O3QOn\\Oj0Vc0NO100N21O001O002NO1N2HVOW]Om0gb07000000000000000000000LV]OQOkb0?hi=", "size": [640, 316]}, "area": 10959.0, "iscrowd": 0, "image_id": 10136, "bbox": [8.0, 590.0, 285.0, 50.0], "category_id": 101, "id": 10012339}, {"segmentation": {"counts": "hjY51o19g?Hl_Oe0o?\\O`^O0T1P1[`0UO[_OU1e`0kNQ_O_1Pa0aNe^Oi1[a0?A>M4O1O2N2N3M1O00000O1O1N2O2O00O1N2kN__OhMda0X22000ON3@`0TOoZ8", "size": [640, 316]}, "area": 2597.0, "iscrowd": 0, "image_id": 10136, "bbox": [271.0, 445.0, 31.0, 114.0], "category_id": 110, "id": 10012340}, {"segmentation": {"counts": "[]51oc00N4N000O2N11NZ@4fLHXO0\\>:RB]4[:mK\\G@lMN1b09T4\\:mKXGd0[Na3]:jK]F3lNc0:a3\\:iKoEP2CY2]:UL]Ei1NTM001o4\\:\\LdEh6k9n1A?C>A?B=DbIlI_KhNR3T7g1dJ`JaNQ3X7h2SKWMg4n2[KQMP4c3QL]Lb3P4^LPLV3\\4jLdKj2h4VMXKb2i0dJ1j2VOU2h0nJZL63:e2]26j1R1mKRLU2=4_2]1Z1`LiKW26Lg2X1P1TMSLh16Kh2Y1e0^M]L^15Kj2Y1>dMcLX14Kl2Y15lMkLP13Ko2X12oMkLn04KQ3V1NSNmLl04KS3T1KVNnLk03LU3R1SOWLiMQ2Lj02MW3P1fNdLTNg1Lh03MX3o0YNQM`N[1Li02LX3P1nM\\MlNo0Li02LX3P1eMeMUOf0Mh01MX3Y1\\M\\M^Of0Mh01LY3[1YM\\M@e0Mh01KZ3]1WM[MAe0Mh02\\O0aM[3[4UM[MAe0Mh03E[3e1SMXMCf0Lh05FV3d1VMXMCf0Lh07DT3f1VMXMDe0Ki0;@P3j1VMXMEd0Jj0;@P3j1VMXMFc0Ik0;@P3j1VMXMFc0Ik0;@P3j1VMRMLi0Ck0;Ao2i1WMlL1P1^Oj0;Bn2h1XMeLImNLZ2Jj0;Cm2g1YM_LHZOMS2Jj0;Dk2g1[MXLGGNl1Ki09Fl2f1[MQLG5Ne1Ki08Gm2e1[MkKFb0O^1Ki07Im2d1[McKGo00X1Ji07Jl2c1hMiL\\OP1Ij06Km2b1aMPMCi0Ij05Ln2a1`MQMDh0Ij04Mo2`1`MRMCh0Ii05Nn2_1aMSMBg0Jj04Nn2^1bMTMAf0Kj04Om2]1dMTM_Of0Lj04Om2]1dMTM@e0Kk040l2\\1dMUMBc0Jl041j2\\1eMUMCb0Jl041j2]1cMUMDc0Jj051j2]1bMVMEc0Jh052j2]1bMVMEd0Ig062j2]1bMVMEe0Hf072j2]1bMVMEe0Hf081i2^1bMVMEe0Hf080j2_1aMVMEe0Hf09Nj2a1`MVMEe0Hf09Mk2b1`MUMEe0Gg0:Im2f1\\MWMFb0Gh0;Gm2h1[MWMFa0Hi0;Fl2i1[MWMG?Hk0;Fj2j1ZMWMG`0Ji0:Hj2h1[MWMFa0Kh0:Hi2i1[MWMFa0Lg0:Hi2i1[MWMEb0Mf0:Hi2i1[MXMDb0Nd0:Ii2j1ZMXMDa0Od0:Ii2j1ZMXMDa0Od0:Ii2j1ZMXMDa0Od0;Hh2k1ZMXMDa0Oe0;Fi2k1YMYMDa0Oe0;Fi2k1YMYME`0Nf08Il2h1XMZMF?Nf07Jm2g1XMZMF?Nf06Kn2f1XMZMF>Og04LQ3c1VM\\MG1T14kM@h0T3W3[MnLJ64Q13Fd2U2ZMoLJ65P13Fd2U2ZMoLJ65P12Ge2U2YMoLJ56P11Hf2T2YMPMI47P1NKi2Q2YMQMH38P1MLj2o1ZMSMF1:Q1KMk2l1\\MUMD1:Q1JOk2j1]MUMD1:Q1I0l2h1^MVMC0;R1G1m2g1^MVMC0;R1G1m2g1_MUMB2:Q1H1m2g1`MTMA49P1I1m2g1aMSMA39R1H1m2g1^MUMF_OL`NN8>l2G1m2g1^MUMHQNIV1n0k1VO1n2h1]MUMNWOa0k1WOOn2j1\\MUMNWOa0k1WO0m2i1]MUMNWOa0k1WO0m2i1]MUMNWOa0k1WO0m2i1\\MUM0WO`0k1WO0n2h1\\MTM0YO?k1WO0n2h1[N`KhN09m0?k1WO0n2i1PO]K]Nn0?l1WOOm2j1QO[K]NP1>l1WOOm2j1SOVK^NU1;m1VONn2j1M[LoMm1VONn2j1aMYK_1S1kNl1WOMo2k1_M[K_1T1iNi1ZOMn2l1_M\\K_1P1lNk1XOMn2l1^M^K_1o0mNi1XONn2l1^M^K_1P1lNh1YONn2l1^M^K`1o0kNi1YOMo2m1]M^K_1P1lNh1ZOVOHZNW3Z4\\M^K_1o0mNi1YOQO4nMD3Z3h4YM^K_1o0mNi1YOjNP4Q3ZL]K`1n0nNj1YO`NX4[3RL[K`1Q1lNi1ZO\\N]4^3nKZKa1S1iNi1[O\\N]4^3PLVK`1X1hNh1\\O[N\\4_3[N^LmMh1]OZN[4`3[N^LmMh1^OYNZ4a3[N]LnMi1_OXNX4a3[N]LoMj1^OXNX4a3\\NZLPNm1\\OXNY4_3[N]LQNk1[OYNY4_3[N]LQNk1[OYNY4_3[N\\LRNl1ZOYNY4_3[N]LQNk1[OYNY4`3ZN[LSNl1[OWNY4b3ZN[LQNl1\\OWNX4c3[NYLRNn1ZOVNY4c3ZNZLSNm1ZOVNY4c3ZN[LRNl1\\OUNW4e3[NYLSNm1\\OTNV4g3ZNYLSNl1_ORNT4i3ZNYLSNl1BoMQ4l3[NYLQNl1CoMP4m3[NZLQNj1DoMP4m3[NYLRNk1CoMP4m3[NYLSNj1BPNP4m3[NYLSNj1BPNP4n3ZNXLTNj1BoMS1X2XOGP3U2C^KSM;T1[2VOGP3U2B_KUM:R1\\2VOFQ3U2B_KUM;a0]OFn21FR3XMcLj4n2bKTM=?^OHk22GS3Q2@bKSM>=AJg24FS3Q2@bKRM`0;ALf24FS3Q2@bKQMa0;AMe24ET3R2^OcKRMa08B0c24ET3R2^OcKRMb00H8\\24ES3S2_OZMZMn04ER3T2@YMZMn05EP3T2AYMZMn05Eo2V2BVMZMo04Fo2V2CVMYMn05Fo2V2BWM[Ml04Gm2X2DUM[Ml04Gl2Y2ETM[Ml04Gl2Y2ETM[Ml04Gl2Y2FSMZMm04Gl2W2hLQKn2T2ZMm04Gl2W2hLQKm2U2[Ml04Gl2W2hLQKm2U2[Ml04Gl2W2GVMYMl04Gl2W2GVMYMl04Gl2X2G[KQM\\18Z14Gl2X2G[KRM[17[14Hk2W2G\\KTMY16\\14Hk2W2G\\KSMZ17\\13Gl2W2G\\KSMZ17\\13Gl2W2G\\KRM\\18Y13Hl2W2HUMYMl03Hl2W2HUMYMl03Hl2W2HUMYMl03Hl2U2IXMXMk03Hl2T2JWMYMm01Hl2R2LYMWMm01\\OY3[2B[MTMn01nN7VNn2W4KgMoLn01_N:QOl2j3JhMoLn01QN=Ji2_3IiMPMm01cM?e0g2Q3IjMPMm01TMc0_1c2f2IjMPMm0j0oN]2Z2JiMoLn0?ZOg2P2KhMoLn06CP3g1KgMPMo01GT3d1IgMSMm0NKU3b1mLcK^2S2bMm0NKT3d1mLaK_2S2bMm0NKT3d1lLbKa2P2bMo0NJS3d1mLcK`2P2bMo0NJR3g1fLfKh2n1^Mk02JR3g1dLhKj2l1^Mk02JR3S2]OYM_Mj02KY3j1VObM^Mj02JW3n1YO]M^Mk02JY3l1WO_M^Mk02JZ3k1VO`M^Mk02J_3f1QOeM^Mk02J_3f1POfM_Mj02K_3d1POgM_Mj02K_3d1QOfM_Mj01L_3e1POeM`Mj01L_3g1nNcMbMj01L]3\\1YLQL0Gg2V2bMj01GZ3h1]LjKh2n1_Mi02]O^2hMlMb4B`Kb2Q2`Mh02ROi2TNSMl42UK`2Q2`Mh02hNS3f3oLgJ]2R2_Mi02]NY3T4mLbJY2T2_Mi02SNV1mN>m5dNUJW2U2_Mi02hMa1YOFZ6POfIX2V2_Mi02^Mg1DoM0T1h6U2UKXMQ1JRMP25_Nm6_2XIkNd2f0WMfMW7j2mHkNd2f0XMZMa7U3cHe0j0lNP7`0VHX4\\8dKdGVNJZ4j8`M\\GUNLl3X9iJaFQ3;YNN]3h9ZNZFXN0g2HoK_:R3iEXN0]2f:[OZEXN0j1Y;QOcEVOTOgNJo0KPOh0=^;BjCb15bNT17YO23IP18k=LXBI0:i=KYBKM9l=JXBMM8k=KXBMM7m=KVBNN6m=KUBON5n=LTBON5n=LUBNMOWN0k?3RBML0U>3oAMm?3S@Mm?3S@Mm?3S@Mm?3S@Mm?3S@Mm?4R@Ln?4Q@Mo?4P@Mo?3Q@Mn?MZ^O3h10Qb00O1O10=C0000000O1]G", "size": [640, 316]}, "area": 60429.0, "iscrowd": 0, "image_id": 10136, "bbox": [8.0, 78.0, 308.0, 528.0], "category_id": 156, "id": 10012341}, {"segmentation": {"counts": "\\b0d1]b0O000000O1001OOUOe]O3[b0Mg]O1Zb0Mg]O[OMf0^b0Mg]O3Zb0Kh]O4Xb0Li]O_OHb0bb0Ki]O5Wb0^O_]O007:2EGPc05]]O3fb0L[]O3fb0K^]O3bb0L`]OOfoh5", "size": [640, 316]}, "area": 772.0, "iscrowd": 0, "image_id": 10136, "bbox": [0.0, 588.0, 20.0, 52.0], "category_id": 167, "id": 10012342}, {"segmentation": {"counts": "jf:j6V=O11O0]Mc20H8_Oa0@`0B>A?B>C=G9F:J6[Oe0C:f`0\\1k^OZN?:f`0a1Y_O_Ng`0b1X_O_Ng`0d1l^OoM8>4BY`0T2b_O[N4AZ`0T2b_O[N3B[`0R2d_OnMG9;GZ`0R2d_OmMH<2Kb`0l1f_OZNFLd`0j1f_OfNZ`0[1f_OdNZ`0]1e_OdNZ`0]1f_ObNZ`0]1f_OdNZ`0\\1e_OeN[`0[1d_OfN\\`0Y1c_OiN]`0X1`_OjN``0U1__OnN``0[2NC__OYM0Ga`0o2`_OZMb`0c2c_O[M]`0c2e_O]M[`0a2i_O]MW`0a2m_O]MS`0b2o_O]MQ`0e2n_OZMR`0i2a0000000O14L002P_OQMk`0R30NT_OPMl`0P3T_OPMl`0P3T_OPMl`0n2400000000000000O1000000O1000000001O001O001O001OO1O10000003M", "size": [640, 316]}, "area": 28936.0, "iscrowd": 0, "image_id": 10136, "bbox": [17.0, 0.0, 299.0, 308.0], "category_id": 172, "id": 10012343}, {"segmentation": {"counts": "n>^3b`01O000000O1001QMlM_Bd3bj0_@lNc0:n>;\\BCS>JTBNTM001i`00Xcg4OokWK0`c0?iNF[^Oh0\\OSOTb06R^OX1la0=L5M130O001O002ON1NlLTNYDS1oLiN071KO1]>?eD6WM[OZ>n0aDEW;]OeA_1V3QOl:^1WE^NW:U2jEjM\\8B[Dh0=[2l2\\Ma7V1cE^1l2\\M_7Y1dE[1m2\\M`7X1bEn0DgM[33_7Y1aEk0LcMU39^7Y1`Ek02]MR3?\\7Z1_Eh0f3mMk6[1^Ei0g3lMk6[1^Ej0e3lMm6Z1WEWN0h2i3bMW7_1PEU1S?k111O00O1O100iNW101O0000000000=C000001O000iF", "size": [640, 316]}, "area": 8502.0, "iscrowd": 0, "image_id": 10136, "bbox": [0.0, 280.0, 316.0, 336.0], "category_id": 177, "id": 10012344}, {"segmentation": {"counts": "X\\g0f0Zc0Y2gM8H0000000000000gLTM^El2V:`MjE`2j9lMVFT2^9XNbFh1U9aNlF^1T9bNlF^1cMlLl:g1aG]1cMhMP:k0]H]1cMcNU90XI]1cM^OZ8UOSJ]1cMAW8ROVJ]1cMAW8ROVJ]1cMAW8ROVJ]1cMAW8ROVJ]1cMAW8oNYJ`1`MAW8hN`Jh1XM@X8bNfJn1RM@X8\\NjGPO\\2T3bM@X8UNjG^O\\2m2bMWOa8XN`GJ_2f2P9ZM`D7`2_2P9SM`De0`2X2P9mL_DR1a2Q2\\9UNeFk1T9\\NlFd1S9]NmFc1S9ZNPGf1P9oM[GQ2e8eMeG[2\\8YMoGg2Q8oLYHQ3[<000001O00000000000001O00000000000001O0000000000000000000000EmLi_OS3o?UMQ@k2g?]MY@c2`?dMa@[2W?mMi@S2a=mLbCY1lNj1]=RM_C\\1TOc1U=XM`CV1Ab1i<^M^CQ10a1[^NnR1fAdNd>]1[AXNP?h1PAnMZ?R2f@cMe?]2[@YMo?g2e00e0[OU2kM_\\g0", "size": [640, 316]}, "area": 35799.0, "iscrowd": 0, "image_id": 10136, "bbox": [37.0, 113.0, 241.0, 367.0], "category_id": 183, "id": 10012345}, {"segmentation": {"counts": "0n0R>00000000000000000000000000000000000000000000000000000000O100000000000000000000000000001O6JM3N2001O1OO1NUGSOg3m0kKTO^K0L3k8h0kKUO[K:j8a0iKEW4<_KN`40VGUOW4n0c4M_K3a4M]K5c4K]K6b4J]K7c4I]K8b4H^K9a4G_K9a4G^Ka0[4_OeKh0T4XOlKj0R4VOnKj0R4WOmKi0S4WOmKj0ZL`NR7f0dLj0ZLhN9Do00m2k0@j0ZLTOFUO094Kf05f3c0A[3bLSLm3c0_O`3oKdK;9X4c0^On3nK`Ke4b0]OZ4d0fK\\OZ4d0gK[OX4f0iKYOV4h0lKVOS4k0lKVOS4k0nKUOP4l0QLSOn3n0RLROn3n0RLROm3o0SLROk3o0VLPOi3Q1VLPOi3Q1WLoNh3R1WLoNi3Q1WLoNh3R1WLnNi3S1WLdNSO\\Lf4Q5VLcNR4^1nKbNQ4_1nKaNR4`1mKaNS4_1nK_NR4b1PL\\No3e1RLYNn3h1QLYNn3h1SLVNm3k1TLTNk3m1TLTNl3l1TLSNl3n1SLSNl3n1ULQNj3P2ULQNj3P2WLoMh3R2WLoMh3R2XLnMh3R2XLnMg3S2ZLlMe3U2[LjMe3W2[LiMd3X2\\LgMd3Z2]LeMb3\\2]LeMc3[2]LeMb3\\2_LbMa3_2_LaM`3`2`L`M_3a2aL^M_3c2aL]M_3c2fLXMY3i2eLXM[3i2eLWMZ3j2gLUMY3k2fLVMY3k2gLUMX3l2iLRMW3o2hLRMX3n2hLQMX3P3hLPMW3Q3iLoLW3Q3iLoLV3R3jLmLV3T3iLmLV3T3lLiLU3W3jLjLU3W3kLkLR3V3nLgLT3Z3lLfLT3Z3lLfLS3[3kLfLU3[3kLeLU3[3kLdLU3]3kLcLT3^3lLbLS3_3mL`LT3`3lL`LS3a3mL_LR3b3nL]LS3c3mL]LR3d3nL[LR3f3nLZLQ3g3oLYLQ3g3oLXLQ3i3oLWLP3j3PMVLP3j3PMULQ3k3mLWLS3i3mLWLS3i3kLWLW3i3hLVLZ3j3eLWL[3i3fLVLZ3j3fLUL[3k3eLUL[3k3eLUL[3k3eLTL\\3l3dLTL\\3l3eLSL[3m3eLRL\\3n3cLSL]3m3dLRL]3m3cLSL]3m3`LVL`3j3^LYLa3g3]L\\Lb3d3[L`Ld3`3\\LaLc3_3\\LcLc3]3^LcLa3]3_LdL`3\\3_LeLa3[3_LfL`3Z3`LfL`3Z3`LfL`3Z3`LfL`3Z3`LgL_3Y3aLYI\\OZ3T4^3`LXI\\OX3P4f3dLRI\\OW3o3i3eLPI\\OV3m3m3iLSLV3n3mLoKS3Q4SMiKl2X4VMfKb2XM`LR7n0fKQ2`MnLL3n6o0eKb1XN^MT6P1dK]1]NcMo5P1dK[1_NeMm5P1dKY1aNfMl5P1dKX1bNhMj5Q1cKU1eNjMh5Q1cKS1gNkMg5R1bKQ1iNmMe5R1bKo0kNoMc5R1bKm0mNQNa5S1aKj0oNSNa5R1aKi0[6WOeIg0]6XOdIf0^6YOdId0^6[OcIc0_6]OaIa0a6^O`I`0b6A]I=e6B\\Ia0QB_OO2V>>lA@X>a0300001O0000001O1O0000O10000000002N3L2N4L2N2O3MfW[19mgdN7M00001O00001O00001O00001O00001O00001O0000001O000010O0010O00001N2O1O001O1O1O1O1O001O1O1O1O10O4M5K4LN2OJfn^3", "size": [480, 640]}, "area": 30131.0, "iscrowd": 0, "image_id": 10138, "bbox": [0.0, 0.0, 403.0, 332.0], "category_id": 98, "id": 10012346}, {"segmentation": {"counts": "ieb52]>0SB0D=d=FfBOC=b=K_BE6e0[=f01N11000001O1O0010O1O1M3N3N0N2O1001O1O1OXO`d]3", "size": [480, 640]}, "area": 907.0, "iscrowd": 0, "image_id": 10138, "bbox": [381.0, 66.0, 25.0, 46.0], "category_id": 100, "id": 10012347}, {"segmentation": {"counts": "o3V2i<10000O100O10XNZCV1e<[N[C<1Y1g`=B`B>`=B`B>`=B_B`0`=@`B`0`=@`B`0W=WOdB0590`0W=IhB8U=WOgBa048U=KkB4U=MjBK0BV=d0jBI^=8bBH`=6_BJb=6^BJb=6^BIc=7\\BJd=6\\BIe=7[BIe=7ZBIg=h0000O10001O1mNWBm0P>N1O00000O100O1000O10O10000O01000O10O1O1000O101N01001OO02O0O0102OL21000OO2O01000O02O000O100O10001N0100O010O1OO2N1100O0M41O]O[OnBa0S=_OlBb0T=^OlBb0T=^OlBa0U=_OlB`0T=BjB>V=BjB>U=CkB=U=DjB=U=FhB;W=FgB\\=CcB`0\\=c0MjNkBe0V=ZOnBc0Q=]OSC?l5000000000000000000000000000000O100O1000000000000001O000O1000000000001O001O000000000010O6JM4MDiA4V>LjA2Y>MgA2_>HbA6e>O2MgSc8", "size": [480, 640]}, "area": 1062.0, "iscrowd": 0, "image_id": 10138, "bbox": [0.0, 29.0, 53.0, 26.0], "category_id": 130, "id": 10012349}, {"segmentation": {"counts": "U6n5R9^Ob0O1O100O1O100O01N1O1O2N1N2N31N1O101N011N1O100O2N10O02O0O1O100O0001N1O1011N2OO02N011N1O101N1O011N010O1bKnEm3S:eKnE40L3[4Q:fKVFY4Y:O2O0O10001O001O1O007I7I2N000O2kLjD^2V;bMRE9Do0^;gN[EFUO094Kf0S>I6[OdA;k>DURX8", "size": [480, 640]}, "area": 11415.0, "iscrowd": 0, "image_id": 10138, "bbox": [0.0, 178.0, 76.0, 209.0], "category_id": 132, "id": 10012350}, {"segmentation": {"counts": "WiU32m>3QBLS=0lB0m[15jQO8I6J5C=01O000O1N2O1M7L3MO100OH90O10000O100O100O100O100O2O5J5L5J2O0O20O]O^BJa=1nBFP=7n0LkSa5", "size": [480, 640]}, "area": 1692.0, "iscrowd": 0, "image_id": 10138, "bbox": [217.0, 55.0, 45.0, 62.0], "category_id": 139, "id": 10012351}, {"segmentation": {"counts": "^kX11n>2O2M3N2M3M6K9G4K3N000O10000000000000000O2O1YBkNa=\\1N1O00000001O00000O1000001O0O2O1O1O0O2N2OK53M10N0N301M13O0O0O2OOmN`Bi0k=O10O16UOhA`0d>H3JmQV7", "size": [480, 640]}, "area": 2143.0, "iscrowd": 0, "image_id": 10138, "bbox": [87.0, 71.0, 62.0, 47.0], "category_id": 143, "id": 10012352}, {"segmentation": {"counts": "odk01n>100O1O1O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000QSP3", "size": [480, 640]}, "area": 1229.0, "iscrowd": 0, "image_id": 10138, "bbox": [58.0, 475.0, 376.0, 5.0], "category_id": 165, "id": 10012353}, {"segmentation": {"counts": "c1\\2dhC]OHZO_NO101QB]O_=Q11N21M2^BnNV=R1bB\\O1@T=P2I2UCQNaUOk0UOk0N2001O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000000000SR>MmmA3000000000000000001O00000000000^E2R6NeI;[6E]Ic0c6]OTIl0l6TOkHU1U7kNcH]1]7cNZHf1f7ZNRHn1n7RNiGW2W8iMaG_2_8aMXGh2h8XMoFQ3Q9oLgFY3Y9gL^Fb3b9^LVFj3j9VLmES4S:=000000000@jEVLV:f3nEZLR:b3SF]Lm9_3WFaLi9[3[FeLe9Z3]FeLc9Z3^FfLb9Z3_FeLa9Z3`FfL`9Z3`FfL`9Y3bFfL^9Y3cFgL]9Y3dFfL\\9Y3eFgL[9Y3eFgL[9X3gFgLY9Y3gFgLY9X3iFgLW9Y3iFgLW9X3jFhLV9W3lFhLT9X3lFhLT9W3nFhLR9X3nFhLR9W3oFiLQ9W3PGhLP9W3QGiLo8W3]1O1O100O100O100O100O1O100L4L4M3L4M3L4N2001O1O1O001O1O001O1O001O1O001O1O1O1O1O2N1O1O1O2N1O1O2N1O1O", "size": [480, 640]}, "area": 36051.0, "iscrowd": 0, "image_id": 10138, "bbox": [0.0, 0.0, 640.0, 149.0], "category_id": 172, "id": 10012354}, {"segmentation": {"counts": "U=k1a;d1O1O100O1O100oH^Lc2c3]M]Lc2c3]M^La2c3_M]L`2d3_M]La2c3_M]L`2d3`M\\L_2e3`M\\L`2d3`M\\L_2e3aM[L^2f3aM[L_2e3aM[L^2f3bMZL^2f3aM[L^2f3bMZL]2g3cMYL]2g3bMZL]2g3cMYL\\2h3dMXL\\2h3cMYL\\2h3dMXL\\2h3dMXL[2i3dMXL[2i3eMWL[2i3eMWLZ2j3eMWLZ2j3fMVLZ2j3fMVLY2k3fMVLY2k3gMULY2k3gMULX2l3gMULY2k3gMULX2l3hMTLW2m3iMSLW2m3hMTLW2m3iMSLV2n3jMRLV2n3jMRLU2o3kMQLT2P4lMPLT2P4lMPLS2Q4mMoKS2Q4aLkK^N4P5R4[LeKcM?j0JW5S4\\L`LUN]O_5S4[LiLnMUOe5S4]LmLiMPOi5T4^LnLgMnNk5T4_LlLgMPOi5T4eLhLbMTOi5S4gLhL`MUOi5R4iLhL^MVOi5R4jLgL^MVOh5R4lLfL]MXOg5Q4QMcLXM\\Og5Q4VM^LSMAg5P4]MYLlLGg5P4bMTLgLLg5P4hMmKbL3f5P4mMhK]L7g5Q4YNoKf1S4YNmKg1S4YNmKg1S4YNlKh1T4XNlKh1T4XNlKg1U4YNjKg1W4YNiKf1X4ZNhKf1X4ZNgKf1Z4ZNfKe1[4[NeKd1\\4\\NcKd1^4\\NbKc1_4^N`Ka1a4_N^Kb1b4^N^Ka1c4_N]K`1d4`N[K`1f4`NZK_1g4aNYK^1h4bNXK^1h4bNWK^1j4bNVK]1k4cNUK\\1l4dNSK\\1n4dNRK[1o4eNQKZ1P5fNoJ[1Q5eNoJZ1R5fNnJY1S5gNlJY1U5gNkJX1V5hNjJW1W5X4100O1O1O1O1O1O100O1O1O1O1O1O100O1O1O1O1O100O1O1O100O1O1O1QI`J^4`5bK`J]4a5cK]J^4d5_20O1O1TIZJ]4g5cKYJ]4g5cKYJ\\4h5]21jIQJZ3P6`LVJ`3j5aLTJ_3m5aLlIe3U6c20O1O1O100O1O100O1O1O100O1O1000000000000000000000001O00000001O000000000000000000bJbIZ2^6fMfIV2Z6jMjIR2V6nMoIm1Q6SNSJi1m5YM^I_N3Id0]4k5[MSJWN2]4l5\\MRJWN2W4R6aMnIWN0V4T6cMlIWN0S4W6hMgIUN2R4X6nMbIoM6S4X6SN]IjM;R4Y6XNYIeM>k3[OULn6^2VIbMa0Z3BdLM2j6a2TI^Mc0m2:SMP6e2PI[M=Q3h0oLk5`2hI??QMi5^2jI??RMh5^2iI?`0TMg5i1SI`Ng0a2a0VMe5h1^JP1OWMd5i1]Jn01YMb5h1^Jm02[M`5h1^Jk04]M^5i1]Jh07^M]5j1\\Jf09`M[5P2VJ>a0bMY5X2nI4k0dMW5Z2lI0o0fMU5[2kIMR1hMS5P2lHYNn0m1U1jMQ5n1RIYNf0m1X1mMP5m1ZIRN=R2[1nMo4n1WJ2l0PNm4o1VJOo0RNk4Q2kI4\\1kMi4S2dI6d1gMh4U2]I9k1bMh4a2lH1]2^Mg4W5YKiJg4V5ZKjJf4V5ZKjJf4U5[KkJe4U5[KkJe4k3lHXLa3Ob3h3SJVLY12d4f3TJXLY12c4f3SJYLZ11c4e3SJZL[11b4e3RJZL]11a4d3SJ[L\\11a4d3RJ[L^11`4c3SJ\\L]11`4c3RJ\\L_11_4c3RJ\\L_12^4a3TJ\\L`12\\4b3SJ]Lb10[4b3TJ]Lc10Y4c3TJ]Lc10Y4b3TJ^Le10V4b3UJ^Lf10T4a3[40kE_Lk8`3[100O10PIaLmK1S6]3SNoLm1Q3TNnLl1Q3VNnLj1T3VNjLj1b2kI_MZ4Nk1_2ZJZMk35k1^2UOaMk0[2ZOfMd0V2BiM=T2GkM9Q2LnM4o11oMOP22PNNP22PNNP22QNMo13QNMo13QNMo13QNMn14RNLn14RNLn15QNKo15QNLn14RNLn14RNLm15SNKm15TNJl16TNJl16TNJl16TNJl17SNIl18TNHl18TNHl18TNHl18TNHl18TNHl18UNGj1:VNFj1:VNFj1:VNFj1;UNEk1;UNEk1;UNEj1MaK7RNIo53`00YK2[NKl53b03PKNeNLi53d05gJKPOMe53f08^JG[OMa54i09jJC]44k0n1WO\\NYK\\Oc4Y2HeNfKROb4Z2]OlNSLjN`4[2QOSObLbN]4[2fN\\OoLYN[4\\2ZNC^MQNX4]2oMIlMjMU4]2dMoNYMYOP1[OS4^2XMQOoMQOi0@P4_2WMmNUNPOf0Dn3_2[MfNUNSOe0Ij3_2_M]NXNWOa0Mh3`2fMQN0_OZ2`2oMeMJKW2a2]1_McNb2\\1^MdNc2[1]MeNd2Z1\\MfNe2Y1[MgNg2W1YMiNh2V1XMjNi2S1ZMlNg2R1\\MlNf2Q1^MlNc2Q1bMlN_2?ZMdJ;j4]2FSO7n0mN0P1S7M", "size": [480, 640]}, "area": 211153.0, "iscrowd": 0, "image_id": 10138, "bbox": [0.0, 2.0, 640.0, 478.0], "category_id": 183, "id": 10012355}, {"segmentation": {"counts": "\\7d7\\70000000001O001O1O003M:F6J5K6J3M000000000000000000O12NO1O10000O1O100O11O000000001O001O1O001O001dIeGNJQ6m801O001O1O000000O100O100O100O11O001O001O1O1O1O00001OO100000000O10000000000O100001O00001OO1000000O1000000O1000000O1BPJlGP6S8QJdGO4P6W8RJcGNO61j5\\8SJcGN0X6]88M30000O11O00000000O1O1002N1O2N0000001O1ON2O13M001OM31OLaIgG_6Z831O00O10000O10000O100O10000000000O12NO12NO11O00000000O100O100O1O1O1O1O1J61O001O00001OO1O1O11O0000O11O1OO1O100EoHfHR7U7oHcHO01004Q7S7nHkH8NJ2Q7U7]IiHe6X7a0N2M31O000000002N1eHiHC5Q7V7PIkHO1Q7U7oHSIQ7]711O0000O1000000M3000000O1000000O100000000001OO12N1kHVHR7j7nHWHQ7k710000000000O100O1MmHYHS7f74O1N2JeHdH^7\\7300O100000000000000001OO11O001O:F1O001O00O100CkHlHX7W77O1N2000000K_HlH`7T7aHkH_7W741O1O00N2002N00001gLdHlN]7R1gHkNY7V1iHgNW7Z1jHdNV7]1lH`NT7a1lH^NU7XMbHU4:bNS7ZMcHU4:`NX7a1hH^NY7b1gH]NX7e1hHZNX7g1hHXNZ7g1eHYNX7\\M_H]49VNX7]M_H^49TNW7P2iHoMX7Q2hHnMY7R2gHmMZ7R2gHmMX7U2hHjMX7W2hHhMX7Y2hHfMX7[2hHdMW7^2iHaMX7_2hH`MX7a2hH^MW7d2iH[MW7f2iHYMS7mMcHk4[JAe57dJH\\5OmJ1S5HjJjNmL]1Y8FnJmNiL\\1Y8DQKQOfLZ1Y8BUKTObLY1Z8@VKXO`LW1Z8^OQKDeLm0Z8\\OkJ1kLb0Z8ZOmJ6iL?Z8XOoJ;gL3O1`AIT>b001O10N4M7H`b8Ao]G4N2N1O2N0O10000000O10000000000000O100000000000000000002M001O0O2O0kKDfI=T6HlI9n5LQJ6i50TJ3f52WJ2e51YJ2e5OYJ4f5MWJ6h5JVJ9i5GTJ=k5DjIg0U6YObIQ1]6oN^IW1a6jNYI\\1f6dNUIb1S5aMWJm0a0h1U5`MWJh0?m1Y5_MUJd0:V2_5[MSJ?5`2f5UMRJ<0\\2jNmLR7?PJ91_2mNiLP7c0lI84_2QOfLl6g2PJf0UOcLi6h2PJf0YObLe6i2oI:KmLT6k2mI92lLo5l2lI:7jLk5m2kI;e:]1VEcNj:n11100O2O1L20001_E\\MY:d2eEfMS:[2kEjMQ:i2O4N10000M4L4L5K3M2N0000000000000O100000000O10000JoKRGQ4n86O1O100O1O100O1O1O1002N2N1O1O001OO10000000000O1000000O1O15K3M0000000000000000000bM^G3b8L`G3_8McG2]8MdG3\\8LfG3Z8LgG4Y8JjGMQOjNU9X1kGLROlNS9W1mGGUOROn8V1nGROW9JiEg0j;UOSDL5o0U<00O7J00000O101O000\\Oc\\l3", "size": [427, 640]}, "area": 11235.0, "iscrowd": 0, "image_id": 10145, "bbox": [234.0, 284.0, 107.0, 143.0], "category_id": 101, "id": 10012359}, {"segmentation": {"counts": "S_V21Z=1O1O001O1O1O1O001O1O1O001O1O001O1O001O1O001O1O1O001O1O1O001O1O1O2N001O1O001O1O1O1O1O00000000O1O10000O100O1000000000000001O000000000000001O0fCUO1LPaCK\\k:Q1000000O100001O0000O1000000O11O@PN]EK11NU2d:?0000000000O1000000000mM^E^OO10g1c:bNoE\\1Q:cNPF]1P:cNPF]1P:dNnE]1T:aNlE_1V:`NiE`1W:XNZE6>b1`:YN`Eg1Q;11O1O2N2N00001bNYDV1g;hNcDP1^;nNgDn0l;O4L3M3M3M4L4L5K3MVn6=YQI31O01N100N3O0FAjC>Wj7BI>6CJ<3HM9NK25I070G29`600000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O1000000000000000000[JFYN:g1GXN9f0FiI40O`01P56:a0`J_OU50;b0[JCY5K\\1AdN?\\1AdN?]1@cN`0^1_ObN`0`1_O`Na0a1^O_Nb0a1^O_Nb0b1]O^Nc0c1\\O]Nd0d1XO_Nh0a1UObNk0?WJMk4Gn08[J2j1ROi0g0R30aJ6d1SOg0i0T3JeJ;_1SOd0k0X3EgJ=]1UO?l0]3CfJ<^1WO:m0c3^OfJ?]1WO5o0h3[OfJ?]1YO0P1n3VOgJa0Z1[OLQ1S4SOgJa0Z1]OGR1X4POgJa0Z1_OBS1\\4nNhJa0Y1@^OT1a4kNhJa0Y1BYOU1g4hNfJa0Z1DTOV1k4fNgJa0Y1KjNQ1Z5_NdJd0X19ZNg0R6TNgJLUOb0g1m2e5RM[Jn2e5RM[Jn2e5SMZJm2f5SMZJm2f5TMYJl2g5TMYJl2g5TMYJl2g5UMXJk2h5UMXJk2h5UMXJk2h5VMWJj2i5VMWJj2i5WMVJi2j5WMVJi2i5XMWJh2h5ZMXJe2h5[MXJe2h5\\MWJd2i5\\MWJd2i5\\MWJd2h5^MWJb2i5^MWJb2i5^MWJb2i5_MVJa2j5_MVJa2i5aMVJ_2j5aMVJ_2j5aMVJ_2j5bMUJ^2", "size": [427, 640]}, "area": 30325.0, "iscrowd": 0, "image_id": 10145, "bbox": [0.0, 13.0, 640.0, 414.0], "category_id": 123, "id": 10012363}, {"segmentation": {"counts": "a\\W41X=2000000O1RC0a<0[CML5i<;O115I1O1N20001_OWO^Di0b;[OZDe0JGV;DPE[1P;iNlDW1T;`000000001O0O1N2001O01O00001O02O00O010O1N101O001O1O001O1HdM_E\\2a:dM\\E`2c:kM\\El1c:TN^Ek1_:XNbEh1Z:[NfEf1X:ZNiEf1W:ZNiEg1T:[NkEf1T:nMkE21o1U:kMnE6Mn1T:jMSF8Im1R:jMZF8Dn1c:RN]En1c:RN]Em1d:SN\\Em1d:SN\\Em1d:SN\\El1e:TN[El1e:TN[Ek1f:UNZEk1f:UNZEk1f:UNZEj1g:VNYEj1g:VNYEj1g:VNYEi1h:WNXEi1h:=0O10000O10000hMSEQ2n:nMUEP2k:oMXEo1h:PNZEn1e:SN]El1c:SN^Em1P;OBSNaEl1o:O1000@UN`Ej1a:VN_EW1CYOn:@_EV1U;jNkDU1V;kNjDS1X;mNhDR1Y;nNgDP1l;N1N2O1O1N2O1O100000O0L53M3M4L1N4N1N100O1O2O0O01O00001O0O2O000101N010O1M2N2N2NlmY2", "size": [427, 640]}, "area": 6769.0, "iscrowd": 0, "image_id": 10145, "bbox": [324.0, 249.0, 138.0, 104.0], "category_id": 165, "id": 10012364}, {"segmentation": {"counts": "0=n<00004L7I6Jf5[OeL6UOW2V4[NlKMlNRO1g2h4YMnJR2KSN18L2N]OQ7b0SIM1]OO=OL8J16NNIM1c0LZOT7d0TICNH6:KKj00]ONIL2f0o6NSIBNK350Mi00ZO231^O7X76VI_O=3j00hNMEOa03]O6[7FeH01>>C4VO3^7IiH0J4X3MiL0[11cN4j7OeKKoM1bN5j7JjK0nM1^NOb;0PF1mYT2=[QlMO1N3N2M4M2000O11O00000000O11O\\ONmC4d7XHGT28eM5o7GVH3m1V1m5DiId0T6AYIQ1`6\\OPIn0o6WOkHj0T7XOkHi0T7XOjHj0U7WOjHj0T7XOiHj0W7XOgHi0W7g2O1ON@UJdIk5[6YJ`Ig4FUK40O`0h6HZIX4f0jKT62QIV4l0cKW6l4S1100O1O100O1O010O1O10000O1O1PIgJn5Y5nIkJQ6V5jIPKT6Q5hISKX6m4fIUKY6l4hISKW6o4gIRKY6n4gIRKX6P5fIRKX6o4hIQKW6P5iIPKV6P5kIPKU6P5kIPKT6R5lImJS6S5nImJQ6X5kIiJT6_5dIlJLUOP6X7N100O1O1O100000000000000000O1O100000000O100000000O1000000", "size": [427, 640]}, "area": 31875.0, "iscrowd": 0, "image_id": 10145, "bbox": [300.0, 0.0, 340.0, 291.0], "category_id": 173, "id": 10012366}, {"segmentation": {"counts": "Rao21Z=1O1O1O0kH0o01POOP12\\NKTK6@Kk65_NMRK7`6L\\N1PK7b6IiI^5U6cJhIa5V6`JjI`5U6aJaIh5_6b00O1O1001OaNfImJEi0h6Z4[1MlGQKT8n4oGPKQ8o4600O1OOSKfGl4[8TKeGl4[8TKeGk4\\8UKdGj4]81010O1VKbGe4`8[K`G[45eK^8O]G\\4k8dKUG\\4m8O10000000>A012NI1330O0011N101O0[HRLl5P4RJWLh5j3VJ^Lc5b3\\J_Ld5b3ZJ_Lg5`3XJ`Li5a3VJ]LPO^Oa6T4_JbLjN\\Oh6R4]JbLhN@k6m3^JbLfNBm6l3\\JbLgNBm6l3]JaLfNCm6m3\\J`LgNCm6m3\\JkLb5V3\\JkLd5V3[JkLc5V3\\JlLd5T3[JnLc5R3\\JoLc5W3WJjLi5Z3RJgLn5Y3oIjLP6W3mIlLS6U3iInLW6m2lIUMT6j2jIULA`0e6Z1]I@18L]6k0dIWOM1]OO=OL8J16NNIM1n6i0cI[OCNH6:KKj00]ONIL2Q7d0cI^OBNK350Mi00ZO231^Ob6m0kIA_O=3j00hNMEOa03]Od6m0XISO01>>C4VOd6m0XIZO0J4X3MiL0[11cNf6X1]IW2KoM1bNe6Z1ZIZ20nM1^Na6P5^IbL1^N`6h60^O`IWJb6i5aIQJd6m5_ImId6S6:0000000001OO100000000000000000000000010O0000000000000001O2N7I4LO11OK5O11OO100000000000000000BlHeJT7[5oHbJQ7^5>00000000000O1O1O1O001001OO100001O0000O1001O00001O1O001O000N2N2N2O1O2N1O100O100O000100O00100O1O1O010001O002N003L8JN11OH9I6O1000O1000NiJPHX5o7hJQHY5n7gJRHZ5m7fJSH[5l73O1O1O1O_JXH`5g7`JYHa5f7_JZHb5e7^J[Hc5d7]J\\Hd5e71O1O1O1O00001O0fI[Jn4f5gJdJY5\\5]JnJc5T5QJWKn5S60000000000000O1N2M3N2M3N2M3N2N2M3N2M3_Oa0O1O100001O0000O11O00000000O20O\\O_H\\Kc75mHFJj2NRM_79mHIGT28eMe7?WHF3m1e8^NUHX1T8dNQHi0h:@>J2O1N2O1M4NUjk0", "size": [427, 640]}, "area": 47808.0, "iscrowd": 0, "image_id": 10145, "bbox": [229.0, 37.0, 344.0, 233.0], "category_id": 181, "id": 10012367}, {"segmentation": {"counts": "lVb1m1R:\\1H7101O0O1000000O10000O101O0O1000000O10000O101O0O1000000O10000O10001N10000O1000000O10001N10000O1000000O10001N10000O1000000O10001N10000O1000000O1HZPg0eMXRYO3M3N2M2N3M3N2M3M3M3N2M3L4DQOVDS1h;:N2M3N2N2N2N2M3N2N1I8N2M3M3O1N2O1NiNhE\\OX:b0RFTOP:j0QFVOo9i0SFUOo9i0SFVOm9i0^FlNd9S1Z1010O010O010OO2N2O0O2O1N7J2K3M3M4L4M3M3M3NUZ4c0XeK2N1O2N1O2M2O2N1mDUOe9m0dEI\\:c10000O1000000O1000000O10000000000001O00000000001O00001O001O1O001O1O001O001O1O001O1O001OgMlM\\IR2e6oMZIQ2f6oM[IP2e6PN\\Io1c6RN]In1c6RN^Im1b6SN^Im1U6RNkG1o1n1R6UNoGMn1o1]5oMkH9JIm1P2^5QNdH:1Em1P2^5TN]H;8Am1P2^5iNeHWOl1Q2_5hNeHWOl1Q2_5hNeHWOl1Q2_5hNeHWOk1R2`5gNeHWOk1R2`5gNeHWOj1S2a5fNeHWOj1S2a5fNeHWOj1S2a5fNeHWOi1T2b5eNeHWOi1T2b5fNdHVOj1T2b5fNdHVOi1U2c5eNdHUOj1V2b5eNjJ[1V5eNiJ\\1W5dNiJ\\1W5dNiJ\\1W5dNhJ]1X5cNhJ]1X5cNhJ]1Y5bN_HTOQ2[2`5aN^HWOP2X2b5`N^H[On1U2d5`N]H]Om1T2f5]N^H@l1S2f5]N]HBl1Q2g5]N[HDm1P2h5\\N[HDm1P2h5kNWJV1i5jNWJV1i5jNWJV1i5[N[HDk1R2j5ZN[HEW1CYO^2U7ZN[HEV1e2_6fM[HEU1f2`6eM[HES1h2b6cM[HER1i2c6bM[HEP1k2e6`M[HEo0l2f6_M[HEm0n2h6mMWIT2i6]M[HCk0Q3j6\\M[HCi0S3l6ZM[HCh0T3m6YM[HDf0S3P7iMPIW2P7iMPIW2b6hLkHb0MAg0U3a6kLhH?3]Od0Z3a6gMlHjNg0_3]6SN`Im1`6VN]Ij1c6ZNYIf1g6[NWIf1i6\\NVIc1j6_NTIa1l6`NTI_1l6cNRI]1n6dNQI\\1n6gNQIX1o6iNPIW1P7hNRIW1n6iNRIW1n6iNRIW1n6iNSIV1m6jNSIV1m6jNTIU1l6kNTIU1l6kNTIU1l6kNUIT1k6kNVIU1j6kNWIT1i6lNWIT1i6lNWIT1i6lNXIS1h6mNXIS1h6oLiHc1`0]1g6nLkHe1>]1R7cNnH]1Q7cNQI\\1o6dNQI\\1o6dNRI[1m6mMfH]O=f2m6mMhHROI0:MHT3]7mMeHWO13Oh2Z7oMdH1OP2]7oMaH61j1^7]ObHc0]7_ObHa0^7_OcH`0\\7BcH>]7BdH=\\7DcH<\\7EdH;\\7FdH9\\7GdH9[7HfH7Z7JeH6[7JfH5Y7MfH3Z7MfH2[7OeH0Z71fHOZ71gHNX7_NgH70Z1U7cNkH30Z1Q7gNoH00X1l6mNTIK0X1j6oNVIJ0V1j6POVIJ0V1j6POVIg2j6YMVIg2j6YMVIg2i6ZMWIf2i6ZMWIf2i6ZMWIf2j6YMVIg2k6XMUIh2l6WMTIi2m6VMSIj2n6UMRIk2o6TMQIl2P7SMPIm2Q7RMoHn2R7QMnHo2S7PMmHP3T7oLlHQ3U7nLkHR3V7mLjHS3W7`KiHX10X3X7kLhHU3Z7iLfHW3Z7iLfHW3Z7iLfHd00b0Z7jNfHd00b0[7iNeHd00d0[7_NnHm0Gd0\\7SNYIW1[Og0\\7hMcIa1QOg0h8XOXGi0h8VOYGj0g8VOXGk0h8TOYGl0g8TOXGm0h8ROYGn0g8ROXGo0h8POXGQ1g8oNZGQ1d8QO[GP1b8RO_Gn0_8TO`Gm0]8UOdGk0Z8WOeGj0X8XOiGh0U8YOkGh0S8ZOlGg0Q8[OPHd0o7^OPHc0m7_OSHb0k7_OVHa0h7AWH`0f7BZH?d7C\\H=a7E_H<_7i20lLaH<_7CaH>_7g20jLaH`0_7f2000000000000000000001O1O001O1O1O001O1O1O001O1O1O1O0`LUH`1l7_NTHa1m7^NSHb1n7^NRHa1n7`NRH_1o7aNQH^1P8n11O1O001O1M3L3M3M4UM_Gg0d8YO\\Gd0h8[OYGa0j8_OXG=j8CXG8l8GVG4m8LUGOo80SGKP95RGFQ9:QGAS9>oF]OT9c0nFXOU9h0nFROV9m0VGdNm8\\1b1O01O01O001O00001O00001O001O00001O001O00001O00001O001O01O01]OVH", "size": [427, 640]}, "area": 52754.0, "iscrowd": 0, "image_id": 10145, "bbox": [120.0, 128.0, 520.0, 291.0], "category_id": 183, "id": 10012368}, {"segmentation": {"counts": "k_l15o>000000000O10000000000000000000000000000000000000000`NMoC3P<=VCNi50100000000O100000O10O11O00000000000O1000000000O10000O100YMNWF7h9KnECXNf0j;HkE?V:AiE`0V:@jE`0V:AjE>V:BjE>V:BhEa0X:_OgEa0Y:BeE=[:BgE=Y:CgE>X:BdE@aNn0k;J]E9c:H]E8b:I^E6b:K_E]OhN:h;:_EYOmNZ;m0_FSO`9m0aFSO]9n0dFSO\\9k0eFUO]9h0dFYO]9d0eF\\O[9b0fF_OZ9?hFBW9VGBj8?TGCk81UAOh>9F]1lN000000000006J00001O00001O00000aNaBY1h=M2N1O000000O100000000000000000000000LSBQOm=?TBK1Dl=`0WBIm=7SB@K4T>@bAa0]>_OcAa0]>_OcA`0^>AaA>`>AaA?_>AaA?_>AaA?b>10N3L5K4M3NceZ20[kdM<`>6O1OO1101O1OO1002M2O0O2ON2O10O01HjABU>5b000000O10001O0001OO100000O11O01N3O1NRANh>OXA=0D]>e0M011O10L6K031O1N10O003M00N2O2N1O1000000003M1O1O00M3O100O\\ADb><^AEa>;_AE>Ob=c0000000000000000000000000O1001O0000001OO10000001O000000", "size": [484, 640]}, "area": 13167.0, "iscrowd": 0, "image_id": 10149, "bbox": [140.0, 300.0, 500.0, 184.0], "category_id": 107, "id": 10012371}, {"segmentation": {"counts": "W]T24o>=C4cA\\OS>k010O1O0010N1002N2M2N101O1O1O001N01O100HSBXOn=h0701O001O00000001O000N200000000O1000000O1O2K4aBjNo9eAG[>a00001OM3O02N4M1O00N@^O[B0La0\\9@`F080a31[L4L<`9OYJBZLg0^9GXJb0h5^OXJa0i5_OVJb0j5^OUJb0l5^OTJb0eNnNg4`0cLb0fNPOf4>dLa0gNQOe4>dLd0^LlNO6a1M^5=dLe0\\LkN2;Z1Id5cNAeMRM^2^3L_OeMjMi1h2b0]OeM`NU1R2iM_LY3n2hMVOb0]1\\N`LZ3m2hMVOc0a1f1XOgMXOa0a1i1VOeMZOb0`1l1SObM]Ob0`1o1ZL^L\\23cMm0X2d0^1Q2hNaMJ>^1o1jNcMH>^1n1kNdMG>^1m1lNdMG>^1m1lNeMF>^1l1mNfME>fM^Ne3\\3ROgMDb0Z1f1TOgMBd0eMYNa3\\3YOgMAd0eM]N\\3X3_OgM@h0T1_1]OhM@m0o0Z1BiM_On0n0W1EkM]On0o0U1EmM\\Om0P1U1EnM[Om0P1S1GPNYOm0P1o0LSNTOn0P1j01XNoNn0P1f05]NjNm0Q1b09aNfNm0Q1b09aNfNn0P1`0;bNeNP1n0>=bNeNQ1S178hNeNQ1S178hNeNl0eMTN_3X27hNeNj0iMTN[3Z28gNdNk0[1<2jNbNg0_1?OjNbNb0hM\\Nh3X2NkNaN`0h1c0GmNaN`0i1b0FoN`N?j1a0GPO_N?k1`0FRO^N>l1`0FSO]N=m1`0FSOYNa0Q29W1b4jLVKP27V1X6jNgIW1Y6iNfIW1Z6jNfIV1Z6jNfIV1Z6jNfIV1m3]LSM]2POV1b3mLYMm1UOV1W3^M^M\\1ZOW1S3hM]MQ1@W1n2XNWMa0JX1j2dNTM42Z1S1XLSOa2FM4Z1S1XLoNh2HE6\\1R1ZLiNj2N@6]1kNXLQ2l2c0\\O6c1l0dLYN`2e0YO5d1m0eLSNb2k0VO4d1m04POWN3e1l05QOVN3e1l05QOVN2f1m04QOVN2f1m04QOVN2f1m04ROUN1g1m04ROUN1g1m04ROUN2f1l05SOTN0h1m04SOTN0h1m03TOUNOh1m03UOTNNi1m03UOTNNi1n02UOTNMj1n02UOTNNi1m03UOiM;R2`05VOWMm0b2MRLnM50g3]1kLV1YO^Mm3Q2SLVNk3a46dMH[29jMBV2>PN\\OP2d0VNVOk1i0WNUOl1h0VNVOh1l0ZNROh1l0ZNROh1l0ZNQOh1n0ZNPOf1P1\\NnNd1R1_NkNa1U1eNcN]1Z1kN_NW1_1]NoMd2o1ZMeNU2W1kM^Od1`0[NDd1;YNJf17VNMi14SN0l10PN5o1KnM9Q2G^MeLlM`3n4KVM;Q3EoL4X3LhLM_33aLEg3;\\MeMa3[2d4002N1cD_LU;n3K0O000000000000000000O100000O0101N1001OO2OO101O0001O00000TM", "size": [484, 640]}, "area": 83368.0, "iscrowd": 0, "image_id": 10149, "bbox": [290.0, 57.0, 350.0, 411.0], "category_id": 123, "id": 10012373}, {"segmentation": {"counts": "]UU22Q?6K6I7J6I7I6J5K4L4L4J5I6N1000O10QCnMlm1AY7k1XHmNa9R1_F^OR9b0nFMc82]G=U8BlGi0i7WOWHj0h7UOYHl0f7TOZHm0e7RO\\Ho0c7PO^Hn0d7RO\\Hm0e7RO\\Hm0e7TOZHl0f7TOZHl0f7TOZHk0g7nNkFcN^1_2g7kNeHS1[7jNhHU1Y7hNmHS1U7lNlH]M_OV5j2TMZM7=\\MCX5f2]LWMiN3U2=\\MDY5e2ZL[MmNNS2?XMG^5c2XLZMcNH15]2m0f2l1XL\\MdNF11G0e2Q1g2l1XL]MdNE10H1c2Q1h2l1XL^MdNEO0K0a2P1i2l1YL`McNDOOb2R1b2f1^LgM_NBOOa2R1c2d1`LjM]NANOb2S1b2b1bLlM]N_OM0a2S1ZMmNU5f0nJQ1i1kN\\N^Of2W1X2\\OoJS1h1mN[N]OR20TNX1h4[OoJo0l1ROQO^O:1oNV1l4YOoJn0k1VOPO]O92oNU1n4XOoJ6JKR24mN_O83lNT1T5UOPKN2Ml1=gN_O8f1R4cNSKG;Ig1h0_NA8e1T4UNcKM`22fL`0j0H7f1W5oMSM2fLb01[Oa0>m1o8YNaFM`0i1P9VNaF3`0e1S9UN^F5>h1T9RN_F4Hc1e9ZNZF30c1f9EXF=f9EYF=e9C[F>c9D\\F>b9B]F`0a9@`Fa0^9@bFa0`9VM^FO6a1MZ1`9TM]F2;Z1Ia1^9SM^F2;Y1Jb1^9QM^F3;MCV1:f1FUMf97iFj0Mi1FUMg97ZFU1:[1^:UNZ300O100000001O5VOfA=eUZ3CZYfL003L3WAKK4]>1mALT>3?0O10O100O10000000000000001O0002N1OJTA5k>KUUm0", "size": [484, 640]}, "area": 21744.0, "iscrowd": 0, "image_id": 10149, "bbox": [146.0, 0.0, 432.0, 444.0], "category_id": 132, "id": 10012374}, {"segmentation": {"counts": "hc61S?6XA2NKc=6[Bb0`=A\\Ba04WOS=Y1kBkNS=U1lBoNQ=Q1mBSOQ=b1N000000000000000000000000001O1O1O0000000000000000000000000000000000000000000000000000000000000000N2K5K5L400000000000000000000000000001O9G00O1O1O1O1O1O1O1O1O1N2O1O1O1O1O1O100O1000000O1000000O1000000O1000000O100000000001O00001O00001O000fInNbNS1^1WOWNi0j1]OoMc0Q2^OnMc0R2[OoMe0R2ZOnMf0S2YOmMh0S2VOnMj0R2VOnMj0S2UOmMl0S2SOmMm0T2QOmMP1R2POnMP1S2oNmMR1S2mNmMT1S2kNnMU1Q2jNPNV1Q2iNoMX1Q2gNoMZ1Q2eNoM\\1@ZN_M9Q3Z1aJ]No44[M5a36UJOY5IoL1n93PFLP:IjC;T2KU:7jEGW:0O100O2O01000HUOUBl0l=60L^BoNX=n0hBTOZ=j0a0000O010O100O101O10O01O1O0O2O1O2M3N2M3M1O10000001O0O10000O1O2M101N2O2OO1M30000:FEQOcBn0k=N10000002NO01O1OO11O1O1OZOSB5m=GYB6h=HZB8e=H]B0BOQ>1^B0CLP>3^B1f=O\\B0b=1_BO`=2g01O101O11O0000000a0_O2M101N1N3M2N2O2O001O00O100O1O1JWBPOk=d0RB_OY>a05O3N0O1O10O0L6M3N2gKCjGHMf0X8GeGE2e0W8KdG@1j0P7XO]H=c0BNl0f6_OjHOe0FSOJKT1LoNBLZ7b0dIMi0IhN2MQ1OQOl67fILj0KaN;Il08mNm64hIM<;gNf16oMn67fIKLj0YOW16mMo67fIL[OQ4NkKR79kHYOc0b5]OmJU7>\\IZ5d6c10000000O1O1000000^OhHQI0LX7e2iHWM080a31[L4LS7i2XIP1BZL_7f2oHP1Z7POfHP1Z7POfHo0[7QOeHn0\\7ROdHn0\\7ROdHm0]7SOcHm0]7SOcHm0]7SOcHm0]7SOcHm0]7SOcHm0]7SOcHl0^7TObHl0^7WNYJ\\NZ8d1gG[NY8e1gGZNZ8f1gGYNY8g1b2001O2N5K001O002N00O100O1N2N22N0000O1O1N2N2O100001OG9O1000000001O09iNaB8Y>M4L1OO2O00O1N2O1O001O1O1O1NiTn3", "size": [484, 640]}, "area": 22296.0, "iscrowd": 0, "image_id": 10149, "bbox": [14.0, 0.0, 359.0, 312.0], "category_id": 172, "id": 10012375}, {"segmentation": {"counts": "XiX21S?000000000aB1]NOf23i79PFEO9S2Nn7a1lGdNT8]1iGeNW8\\1eGgN[8Z1cGgN]8Y1cGgN]8Z1bGeN_8^1_GaNa8b1\\G^Nd8e1YGZNh8i1UGVNl8CRFb14bNK9o9AXFc1FiN2OT:EWFc1ZOoN;HW;R2iDmMY;Q2gDoM\\;o1cDQN_;m1n0N2M3N1M4M2N2N2O1O001O001O10O0010N101O1O001O1O1L6L30O3L01O100O00001O0000O100000O11M2O100O2O00000O1N2N20O0101N100OMaBbN`=^12010O00100O100O1O100O11O0000IbNhB^1U=NVQS5", "size": [484, 640]}, "area": 8546.0, "iscrowd": 0, "image_id": 10149, "bbox": [154.0, 0.0, 141.0, 148.0], "category_id": 173, "id": 10012376}, {"segmentation": {"counts": "hVY59k>:FM300O10000O10000O10000000000000000000000000000000000O100O100O100O100O1000000001O00001O00001O1O2N1O2N2N1O2N2N000000000000O10000000000000000000lBZOj;f0WDZOh;f0XD[Og;e0YD^OkNO`d0YEYOh5\\1YI]OhMXO]7o1kIDXNbNh7_2QIHiNmMR8o2VH2e7g3RHnHj7W7VHiHd7]7\\HcH_7b7bH]HY7g7hHYHR7m7nHSHm6Q8TIoGf6U8\\IkG_6Y8bIfGY6^8iIbGR6a8PJ_Gj5e8XJ[Gc5h8:4M3L4L4M3L6J5L4K6K4K5K6K4K2N2O0O1O1O2O0O1O2N1O1O2N100O1O2N1O1O2N1O1O1O2N1O1O2N1O1O1O1O1N2N2N2N2N2N2O1N2N2N2N2N2N2N2O1O1O1O1O1O1O1O1N2O001O1O1O1O1O1O1O1O1O1N2O1O1O1O1O1O100O1000000O1000000O1000000O1000000O100000000001O00001O00001O0kIcNcN]1^1mNWNT1i1WOkMi0U2B`M>a2MSM4m27gLIZ3a0[L_Of3l0nKUOQ4W1cKiNb0_N3k2WOfNf0eNNd2\\OhNd0kNK]2@hNd0QOGX2DhNd0VOCQ2IiNc0]O_Oj1MjNb0B]Ob12mN?E]O]1]NVM`0i1d1H\\O\\1ZNdM6Z1S2J[OX1WNVNZO\\1R3ZO[OT1UNo0Z2TN@l0RNU1X2WNCe0QNX1V2[NG=PNZ1T2aNJ5oM]1S2dNLNoMa1Q2gNMIQNa1n1kN0BSNd1j1oN0\\OWNe1f1UO1UOYNg1c1YO1hNVNcM7_4\\1\\O5aNfNV2P1^O8[NhNZ2g0C?SNjN^2>Gf0jMlNb26Lk0bMoNe2M1S1YMPOi2E4Z1SMQO[8n0dGRO^8m0bGRO_8m0aGSOa8l0^GTOc8k0]GUOe8j0ZGVOg8i0YGWOi8h0VGXOl7GcFQ1`1XOi7NPFG`0Q1g1ZOg77bF?f1ZOh78cFhFMX1EP8a0gFIX1FR8?iFJT1GT8>iFJS1HV8H\\Ok0R8^OaHG[Om0U8^O]HE]On0V7nNYHa0Q1C^OP1U7QO[H>o0A@Q1T7SO]H=l0_OAS1V7QO^H?h0^OBS1W7QO`H`0d0\\ODT1X7POaHb0a0YOFU1X7PObHb0?YOGU1X7oNdHd0;XOHV1Y7nNeHd09XOIV1Y7mNgHf05WOKV1Z7kNgHi03VOLV1Z7jNiHj00VOLW1\\7gNjHm0LUONW1]7bNnHR1GTONX1n8ERGSO0X1o8EQGRO0Y1P9FoFPO0[1R9EmFPO1[1S9FkFmN3]1W5fN[MP1ZMmN4]1W5hNZMo0ZMkN5^1V5kNZMl0[MjN4`1h2gN[N5^1j0[MiN4a1g2jNYN4`1i0\\MgN4b1g2KXMTOa2h0\\MeN5d1g2NQMTOg2e0\\N9l11mLSOk2b0\\N:m14gLQOQ3a0ZN:R25\\LQOZ3`0WN:W27QLPOb3?UN:d2h0XOnNRN;U38jN]OPN;d3J]NKnM;T4[OoM:lM;X4XOmM=jM;Z4WOmM>hM;\\4UOnM?fM<]4SOoMa0cM<_4ROoMb0aM<^4SOSNa0]M=_4QOVNc0ZM<_4POZNd0VM<`4oN\\Ne0SM`4mNQL@e0R1jNa0`4mNRL@h0m0fNf0_4nNTL_Ol0g0aNl0]4QOVL]Oo0a0^NQ1e3IoLeNS1;YNW1Y2dNfLl1g1nM_1LkMf1P2]1gNRMg2a1cN\\1gNSMe2a1dN[1jNSMb2a1dNZ1XNRMdN033\\4a1eN3TMmNU1_O`N051[4`1hNgNgNNBL]N07OZ4`1\\1aNgK:cNEZ4_1^1^NhK?_NDZ4_1\\3mNZHEX4^1^3nN[HCV4_1`3oNYHBW4^1`3QOYHAV4^1b3QOXHBT4]1e3ROVHAU4\\1f3SOUHAT4\\1i3SORHAU4[1k3SOQHBR4[1n3SOPHAR4\\1o3TOnG_OT4\\1o3iNhG15IT4]1P4iNgG15HU4]1P4jNfG06HT4^1Q4jNfGOb4V1i3kNeGOa4V1k3kNdGNb4V1k3lNcGNa4V1m3mNaGMb4U1n3nN`GLb4V1o3nN_GKb4W1P4nN^GJc4W1P4nN^GIc4Y1P4mN^GIc4Y1Q4lNULS1l3mNTLR1m3lNVLR1k3mNWLQ1j3mNXLR1i3mNYLQ1R9K7DVll0HSTSO8I8K2M101O1N2O1O1N101O1O1O1O5K4L1RCaNg2j0U5f0QHbNi2h1W4GmHdNk2c2Z3jNhIeNm2k2R3aNnIfNo2j2S3`NlIiNo2h2U3`NiIjNQ3g2V3`NfIkNS3f2W3TOhLl0X3TOgLm0Y3SOQLhMTNU3k5UOPLjMPNR3P6TOPLoMjMn2U6TOQLRNeMk2Z6TOPL^1o3cNPL^1P4bNPL]1P4eNoK[1Q4eNoK[1P4fNPLZ1P4fNPLZ1P4fNPLZ1P4eNQLZ1P4fNPLZ1Q4eNoK[1Q4eNoK[1Q4eNoK[1R4dNnK\\1R4dNnK[1S4eNmK[1T4dNlK\\1V4bNRLV1o3iN]Lk0e3SO\\Ll0e3SO[Ll0h3ROYLm0h3QOZLn0mMWNa3i0bNP1lM`N\\3>iNQ1kMiNT3[OZLWOh2e2jMQOl2ROmLnN^2o2hMYOe2hNa0n1jL]Ob2dNe0o1iL]Ob2bNh0P2fL^Ob2cNg0o1gL^Oa2gNf0j1iL_Oa2hNf0h1iL@a2hNm0lNhK_2j0Ma2hNl0MTL3?X1a2iNj0m0ZM:l1iNi0f1cLAd2iNg0h1eL_Od2iNf0i1fL^Od2iNe0j1gL]Od2jNc0j1iL\\Od2jNb0k1jL[Od2jNb0k1jL[Od2jNa0l1kLZOd2jN`0m1lLYOe2iN>o1mLYOd2gN`0P2lLYOd2gN?Q2mLXOd2fN>T2nLVOd2fNKUOiLU3h0POe2dNKi2`McNf2`NMm2]McNg2]NNP3[McNj2WNNV3XMcNQ3mMJ`3UMcNX3cMFj3RMcNS7]1mHcNS7]1mHcNS7]1lHdNT7\\1lHdNT7\\1lHdNT7\\1lHdNT7\\1lH_NY7a1gHmMk7S2UH\\M\\8d2gGgLj8Z3`1001O_LlDR3T;mLREn2n:nLWEQ3_;O1O1O1O001O1OUERMa9m2^FjMm8U2SG`NY8_1fGVOf7j0ZHVOg7i0YHWOi7SNUGU11CP1W1l7lMTGU2OoMQ1P2n7hMSG]2U1Lk75UHKi77WHIh79WHGh7:WHGh7:XHFg7;YHEe7=ZHDe7=[HCd7>\\HBc7?]HAb7`0]HAb7`0^H@`7c0_H]O`7d0`H\\O_7e0aH[O]7g0cHYOY7k0gHUOT7P1lHPOP7T1QIkNk6Y1UIgNk6Y1UIgNj6[1UIeNk6[1UIeNk6[1UIeNk6[1UIeNk6[1UIeNk6[1UIeNj6\\1WIcNi6]1WIcNi6]1XIbNh6^1XIbNh6_1XI`Ng6a1YI_Ng6a1ZI^Nf6b1[I]Ne6c1[IjMX7V2iHnLR8R3Q2O001O8I1N3M2N2N2N1O1O1O1O100O00QEYMb9f2]F[Nd8d1\\G]Nd8b1\\G`Nc8_1\\GdNF`NT8k2VHfN^OfN]8c2THjNUOkNh8Z2SHAm7=UHCl7:UHGS80nG0T9lNnFT1`;101O0O10000cMcMSH]2b7SNYHm1\\7dN^H\\1]7oN]HQ1^7_OWHa0d7LTH4g73WHMe7:YHEc7`0\\H@b6hMTIl2:\\Ob6mMlHj2b0YOa6SNdHh2k0UOa6c1`I\\N`6d1`I\\N_6e1aI[N_6d1bI\\N]6e1cI[N]6e1dIZN\\6f1dIZN\\6f1dIZN\\6f1eIYN[6g1eIYN[6g1eIYN[6g1fIXNZ6h1fIYNY6g1hIXNX6h1hIVN\\6h1dIgMn6X2SIVM`7g2iH`Li7_3Q2M6J6J4L2N2N2N2N2N2N2N5I8Hk>UOoAj0UOe0\\O4K5L4L4K5L0B`LZE\\3n:67I7I7Anm?", "size": [484, 640]}, "area": 107185.0, "iscrowd": 0, "image_id": 10149, "bbox": [3.0, 8.0, 603.0, 476.0], "category_id": 183, "id": 10012378}, {"segmentation": {"counts": "i^S53W=100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00000000001O000000001O000000001O00000000001O000000001O000000001O00000000001O000000001O000000001O00000000001O000000001O000000001O00000000001O000000001O00k2UM9G", "size": [427, 640]}, "area": 1946.0, "iscrowd": 0, "image_id": 10161, "bbox": [392.0, 0.0, 248.0, 120.0], "category_id": 115, "id": 10012379}, {"segmentation": {"counts": "YP:1Z=0O10000000000000000000001O000000000000000000000000000000001O1O1O1O001O1O1O1O001O1O1O1O1O001O1O_OXC`0gj:^O`E3Ad0n:YObE3ZOh0U;UOcEQ1^:nNdEQ1\\:oNfEo0\\;O2M01O1O1O1O100O010O100O1000O10O1000BlCEU<:lCET<:mCET<;lCET<;lCET<;mCDS<;nCER<8QDFQ<8SDDP<:a0O6J3MYTg6", "size": [427, 640]}, "area": 1545.0, "iscrowd": 0, "image_id": 10161, "bbox": [24.0, 0.0, 100.0, 67.0], "category_id": 132, "id": 10012380}, {"segmentation": {"counts": "0gj0Z8ZZOP5PK000000000000000000000000000001O00000000O10RQP8", "size": [427, 640]}, "area": 1043.0, "iscrowd": 0, "image_id": 10161, "bbox": [0.0, 0.0, 26.0, 268.0], "category_id": 165, "id": 10012381}, {"segmentation": {"counts": "gj0Z8Q5P5PK000000000000000000000000000001O00000000000000000000000000000000001O000000000000000000000000000000001O1O1O1O001O1O1O1O0`IJK7KN93BNa03]OJXLIW2>`1F_LMm1>b1BhLOd1?c81O1O_OXC`0gT5_OmM1dL9T1I\\O?k4^OPN1gL8P1JC`0b4^ORN0jL8l0JLb0W4\\OVN0mL7h0K4a0n3^OWNOPM7:LYO0]1a0e3]OZNOSM54;o05\\3]O\\NNVM5M?Z11T3]O^NNYM4Ec0g1Ni2^O`NM]M3^Og0Q2L_2^OdNL_M3WOk0\\2FY2@dNLbMQ1f1@T2CcNLdMP1j1\\OP2GbNMfMn0l1ZOm1K`NMhMm0o1WOj1O^NMjMk0S2UOf12]NNiMl0Q7VOUKNiMm0S7TOTKOhMn0U7SORKOhMo0W7ROPKOhMP1Y7POoJ0gMQ1[7oNmJ0gMQ1^7oNjJ0gMR1`7mNiJ1gMR1`7nNhJ0hMR1`2mNg10QN1hMR1_2mNj10nM1iMR1_2mNk10lM1jMQ1_2nNl41eHQ1d:oN\\EQ1d:oN\\EQ1d:oN\\EQ1d:oN\\EQ1d:oN\\EP1e:PO[EP1e:PO[EP1e:PO[EP1e:PO[EP1e:PO[EP1e:PO[Eo0f:QOZEo0f:QOYEP1g:POXEQ1h:oNWER1i:nNUET1k:lNUES1l:mNTES1l:mNTES1l:mNSET1[2kNc51RHT1m:lNSET1\\8kNaI1SNT1Y2kNV30^L1SNS1^8lN^I1SNT1_8kN^I1SNT1Y2kN[30XL1TNT1X2kN]31VL0UNT1`8lN[I0UNT1W2kN`31SL0UNU1W2jNb32QLOVNU1b8lNXIOVNT1W2kNd32nKOXNS1U2lNf32mKOYNR1T2mNg32kKOZNR1S2mNi33iKN\\NQ1Q2nNk33hKN\\NQ1Q2nNl33fKN^NP1o1oNn34dKM_No0o1POP43bKN`Nn0n1QOP44aKMbNm0l1SOQ43aKMbNm0k1SOT43^KMdNl0j1TOT43^KMdNl0i1UOV41]KNeNk0g1VOX42[KMfNj0h1WOW42[KMgNi0g1WOY42YKNgNi0f1XOZ42XKMhNi0f1XOZ42XKMgNj0g1VO\\42VKNfNk0g1VO]42UKMfNl0h1TO_42SKNeNm0i1SO_42SKNdNn0i1SO`41SKNcNo0j1QOb42PKNcNP1k1POb42PKNbNQ1k1POd40oJOaNR1l1nNe42mJNaNS1m1mNe42mJN`NT1m1lNh41kJO_NU1n1kNh42jJN_NV1o1jNi41iJO^NW1o1iNk41hJO]NX1P2hNk41hJO[NZ1R2eNm42eJO[N[1R2eNn41eJOZN\\1S2dNo40dJ0XN^1U2aNP52bJOXN_1U2aNQ51bJOVNa1W2^NS51`J0UNc1W2\\NT52_Je1j0Y7VOgHj0U5SO^J3Q4AWK1i0>n3AZK1j0Q9CoINRM=9AV84^JNVM:8DS84^JMZM96FR84^JL]M75Io74QK1RMKl74TKNQMNk74UKLRM0h74QLMn33SLMl33ULLk34ULMj33WLMh33XLMh33YLMf33[LMd33\\LMd33]LMHOXO4Q1MEO[O4Q1MA0_O3Q1L_O1A3Q1L[O2E2X5NiJ2U5OlJ1S5OnJ1P50QK0n40SK0k40WK0h40YK0e41\\KOc41^KO`42aKN^42cKN[43fKNX42iKNU44kKLT46kKJS4:kKFT4j2T8e3[L2O2M2N2N3N1N2N3N1N2N1O100O1O1O1O100O1O1O100O1O1O1O2O0N2O1N2O1N2N2O1N2O1N2N2O100O1O1O101N1O100O1O1O100O1O100O1O1O100O1O100O1O1O100O1O1O100O00100O100O1O100O1O100O1O100O1O100O100O1O100O1O100O1O100O1O100O100O00100O1O100O1O100O100O1O100O1O100O1O100O1O10000O100O10000O10O010000O1000O0100O1N101O1N2O1O0O200O1O010O1O100O00100O1O00100O1O010O100000O1000000O100000000O1000000O100O100O100O100O100O100O10000O100O100O1000000O10000O1000000O10000O1000000O10000O10000O1000000O10000O1000000O10000O1000000O1O1O100O1O1O1O100O1O1O1O2O0O1O1O100O1O1O1O100O1O1O1O100O1O1O100O1O1O1O100O1O1O1O100O1O1O1O1O1O1O1O1O1O1O1O100O1O1O1O1O1O1O1[OWMSIj2k6cMiH^2U7g0N2O1N2N2N2N2N2O1O1O1O100O1O1O1O100O1O1O1O100O1O1O100O1O1O1O100O1O100O1O1O100O1O100O1O100O10000O10000O10000O10000O10000O10000O10000O100O10000O10000O100O10000O100O10000O10000O100O100O100O1O100O100O1O100O100O1O100O100O1O100O100O1O100O100O1O100O100O1O100O100N3N1N2O1O1N2O1N2O1O1N2O1N2O1N2O1O1N2O1N3N1N3N2N1N3N1N3N2M2O9G`:SOYF>4J`AIc>46NdR_6", "size": [480, 640]}, "area": 22810.0, "iscrowd": 0, "image_id": 10175, "bbox": [0.0, 0.0, 198.0, 144.0], "category_id": 98, "id": 10012384}, {"segmentation": {"counts": "Ui51i>1ZA0f>1YAOf>60OJJcA7X>;L40000001O1O000000M3O0100000O100001ON2M3K5L4000O1000O1000000003M2N001O1O0O101UOnAf0R>ZOnAN2d0R>\\OPBd0V>0O10000000000000O2O1LeAA[>?eAA]>=cAC_>;aAEb>8^AHe>46N1OUYW8", "size": [480, 640]}, "area": 1533.0, "iscrowd": 0, "image_id": 10175, "bbox": [12.0, 125.0, 66.0, 41.0], "category_id": 100, "id": 10012385}, {"segmentation": {"counts": "`Tj85g>003L6K4kN@fCd0Y<@_Ce0a<]OYCg0f<\\OTCh0l<[OlBi0T=b00O001O1N1O2L3J7K4KWBQOm=j06L5L3D=K501OO1_i4", "size": [480, 640]}, "area": 817.0, "iscrowd": 0, "image_id": 10175, "bbox": [601.0, 369.0, 28.0, 68.0], "category_id": 105, "id": 10012386}, {"segmentation": {"counts": "`>`0n>B00000000O10000000000000000000000O10000O10000O1000000O10000O10000O10000O10000O100O100O100O100O100O1_IAaN?\\1EWHMV6?`1L`N4^1NaN3]1NdN2Y11fN0[1OeN1\\1NdN2]1MbN4_1KaN5`1I`N8`1H`N8_1I`N8`1H_N9a1G^N:b1F]N;b1E^Nc1C]N=c1C\\N>d1A\\N`0d1@[Na0d1@ZJCR2n0d3_OZJDP2n0f3^OZJEn1n0h3UO^HK02k13l1l0j3SOdJ3_1k0m3ROdJ5\\1j0P4POeJ8X1i0R4POfJ7W1j0S4oNeJ8W1j0T4nNeJ8V1k0U4lNfJ9T1l0U4lNgJ8R1n0W4jNfJ8R1P1X4hNfJ8P1R1Y4fNhJ8m0T1[4dNhJ8j0W1^4`NiJ9g0Y1`4^NhJ:f0Z1a4]NiJ9c0]1d4ZNiJ9?a1h4VNiJ9]NBd1>ZNDf12L3M4L3M4M3O000010O0001O010O1O0010O01O0010O01O1O010O1O00010O1O00010O001O011N0000010O001O010O00ZObBI\\Rb22Wm]M5o=b0I7H8N2L4O11O0000000dN`BX1`=gNbBX1a=gN]BY1b=300002N1O001O00001O0jNYBS1g=mN[BQ1f=oNYBQ1g=oNYBQ1h=nNXBR1l=O002N0ROQBk0S>O2N1O001O1O001O001O", "size": [480, 640]}, "area": 2664.0, "iscrowd": 0, "image_id": 10175, "bbox": [374.0, 359.0, 266.0, 121.0], "category_id": 117, "id": 10012388}, {"segmentation": {"counts": "dXo03k>2VAMf>8KI_A7`>5O100O1N2O100N22O1N2N0000000000O100000001O00000010O0001O001O001O002N2N2K5RBPOh=T1O000002N1O2J6ElAGV>8jAFY>8hAC^>;5N1O00111M10002OO1O1O0\\AK[>8cAIY>;fAE4MP>f0mA[OT>m0J100001OO1000001O1N1O0VBnNg=V100O1O3N0O11N1O02O11]O\\BHb=8^BGb=:_BEa=;_BEb=;^BDb=6_B^O1;a=6dBJ]=3fBK[=MnB1T=HXB0h05R>LjYn6", "size": [480, 640]}, "area": 2370.0, "iscrowd": 0, "image_id": 10175, "bbox": [66.0, 322.0, 99.0, 46.0], "category_id": 121, "id": 10012389}, {"segmentation": {"counts": "n4U3m;N1SMkDm1V;RNkDm1U;RNmDm1S;SNmDl1R;VNoDi1Q;WNPEh1P;XNQEg1o:YNREf1n:ZNSEe1m:[NTEc1m:\\NUEb1m:\\NUEc1l:\\NUEc1U8mAEV>78M0O1000000O0100000O100O010000000O01000O10000O010U]`0EVc_O1O1N2O0O2O1O001O001N101O001O000O2O001O1O001O001N2O001O001N101O001O001O001N101O001O1N101O001O1O00N1O2N2N2N2N2N2N1O2O1O1O0O2O1O001N2O1O1O1O1N10eBLl;3TDNl;1TD1k;MVD4j;KWD6W=2O2M2N3N1N3M2O1N1O2O0O2N101N2N2O1N2N2O1N2N2O1N2N2N2O1N2N200a0_Ob0]Oa0@001O00000000001O000000001O0000mL0VG0m;0kL0ZG0lW20hnN0WUO00000o>0PA1O1O1O1O1O1N101O1O1O1O1M3M3L310001O1O001O1O1N101O1O001O1O1O0O2O1O001O1O1O00000O10O1aje4", "size": [480, 640]}, "area": 5780.0, "iscrowd": 0, "image_id": 10175, "bbox": [0.0, 158.0, 320.0, 134.0], "category_id": 123, "id": 10012390}, {"segmentation": {"counts": "S8V3j;0000SOXDaNi;Y1^DfNa;U1dDlN\\;n0jDQOW;i0oDWOQ;c0UE]Ok:=[ECe:7`EJ_:1gENY:MmE3S:GSF9o9ATF`0P:\\OQFb0T:ZOmEe0X<_OhA8a>C^A105e>J]A5h>N103MnkP9", "size": [480, 640]}, "area": 1208.0, "iscrowd": 0, "image_id": 10175, "bbox": [0.0, 256.0, 23.0, 105.0], "category_id": 132, "id": 10012391}, {"segmentation": {"counts": "mag03l>3M101O1O00001\\AG_>9aAGN2\\>:dAH\\>>0O1000O10000000001O1TB]OY=c0gB]OY=e0eB[OZ=h0dBXO\\=k0aBUO_=n0]BTOb=n0\\BROc=P1\\BPOd=V100000O2O00001O001O001O1O1O1O2N1N2O00000000000000001O1KmA[OU>`0nA@S>=oABS>;oAER>8PBHQ>5QBKP>2U\\g7", "size": [480, 640]}, "area": 1554.0, "iscrowd": 0, "image_id": 10175, "bbox": [50.0, 119.0, 62.0, 42.0], "category_id": 139, "id": 10012392}, {"segmentation": {"counts": "fW_13l>2ON10O1N2O111N2N3M3M3M2J7DUO^Bn0`=RO^Bm0d=TOWBR1g=4O1[BhNa=\\1eBdNQ=`1lBbNS=]1kBgNR=f1N2N2O1O1O1NPNWCj1ij0QBUOo=i051OO003N1N3N1N01000O11O001O001N010000O1O2N101N2O0N3O1L3O4K_lP5", "size": [480, 640]}, "area": 7939.0, "iscrowd": 0, "image_id": 10175, "bbox": [100.0, 340.0, 196.0, 94.0], "category_id": 143, "id": 10012393}, {"segmentation": {"counts": "PWY51o>000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O001O00001O001O001O00001O001O00001O001O00001O001O001O00001O001O001O1O001O001O1O001O1O001O001O1O001O001O1O001O001O1O001O1O001O001O2N1O2N1O2N1O1O2N1O2N1O2N1O1O2N1O2N1O2N1O2N1O1O2N1O2N1O2N1O1O2N1O3M2N3M3M2N3M2N3M3M2N3M3M2N3M2N3M2N2N3M2N3M2N2N3M2N3M2N2N3M2N3M3M3M3M3M3M2N3M[LfFg1W9[MjFG2Q3Q9mLUHV3h7hLZH[3c7cL_H`3^7_LcHd3Z7XLjHk3S7ULmHm3Q7SLnHo3Q7QLoHP4P7PLPIR4n6SLmHn3R7TLlHm3S7TLhHR4V7VL`Hm3_7XL[Hj3d7_LQHd3n7i1N1O1O1O2N1O1O1O2N1O1O2N1O1O1O2N1O1O5K8H", "size": [480, 640]}, "area": 15619.0, "iscrowd": 0, "image_id": 10175, "bbox": [361.0, 0.0, 279.0, 250.0], "category_id": 156, "id": 10012394}, {"segmentation": {"counts": "\\[71o>1O1XAO_>:\\AE1050o=>kAD\\>a0gA]OS>c0mA]OS>f012O000000O0100000O010000000O01000000O010000000O0100000O1000O1000O1000000O10O100000O1000HnABR>?;LdAD\\>;5O10O03L3N2OmbW8", "size": [480, 640]}, "area": 1330.0, "iscrowd": 0, "image_id": 10175, "bbox": [15.0, 319.0, 62.0, 38.0], "category_id": 168, "id": 10012395}, {"segmentation": {"counts": "m`X22n>001O010oNNVB1a02^O1h=4iB1W=0fB3KDQ=:lB;1\\OQ=2L1WAMi>221O1O3L3M2L5H7K5JSOUBR1e=7\\BgN\\=^1dBdNV=a1jB^Ni2kAMZ=6aBM]=6`BL_=6^BLa=6\\BLc=6ZBLe=6XBMg=f01O010N1000001O00gBQOaiTOi1a4jMYL>VOg1b4lMWL=VOh1c4lMVL\\1P5ZOcJZO<\\1R5ZObJZO<\\1R5ZObJYO=\\1R5ZObJZO<[1S5[O`J[O=Y1T5\\O_J[O=X1U5]O^JZO>X1U5]O^J[O=W1V5^O]J[O=V1W5_O\\J[O=U1X5@ZJ\\O?R1X5AZJ\\O?R1X5BYJ\\O?Q1X5DYJ[O?P1Y5DYJ\\O>o0Z5EXJ[O?o0Z5FVJ\\O`0m0[5GUJ\\O`0k0]5HTJ]O?i0_5JRJ]O?f0b5MoI\\O`0e0c5NnI]O?c0e50kI^Oa0>g54hI^Oa0mNlK=e3f0>mNnK>c3f0=lNPL?c3f0;jNTLa0`3e0:jNWLc0^3d09iNZLd0\\3d08gN]Lf0[3d06eNaLh0X3c05fNcLi0W3b04dNgLk0T3c02aNkLn0R3b01`NnLn0Q3d0N]NRMQ1o2d0K[NXMR1l2d0JZNZMT1k2d0HWN_MU1i2e0FUNcMW1f2f0CTNhMW1d2f0BRNlMY1a2h0_OnMRN[1^2j0\\OkMWN[1]2m0WOhM^NZ1\\2Q1ROdMdN[1Z2T1nNaMiN[1Y2W1jN]MoN[1X2[1oMXLnNQ1m0\\1V2_1_MhLTO>X1Z1V2b3[LSKa1[1T2b3ZLRKd1\\1R2a3ZLSKe1[1R2a3XLTKh1[1P2`3XLWKg1X1R2`3WLjKV1f0c2i5jLXJV3X6ZLgIg3Y6YLgIg3Y6YLfIh3Z6XLfIh3[6WLeIi3[6WLeIi3[6WLeIi3[6WLdIj3n2XLQNNQOj3m2WLTNOoNj3n2ULUN0mNk3]6ULcIk3]6ULbIl3R3WLlMMROl3S3[LfMIWOl3T3[LdMIXOl3U3ZLdMIVOn3W3VLeMLTOn3X3ULdMMTOn3X3ULdMMTOn3Y3TLcMNTOn3Y3SLLn34RLLn34RLeMOPOo3[3RLeMOPOo3[3RLeMOoNP4\\3QLeMOoNP4\\3QLKo35QLKo35QLKo35PLKQ44PLhMOkNQ4\\3QLMo32RLNn31SLOm30TLOm3OUL1k3NVL2j3MVL4j3KWL4j3KWL5i3JXL6h3IYL7g3G[L9e3D^L;b3BbL>^3@cLa0]3_OcLa0]3@bL?_3B`L>`3B`L>`3C_L=a3D^L`LB`3>`LB`3>`LB`3=aLC_3=aLC_3=aLC_3=aLC_3=aLC_3B=C=C>Bd0\\Oc0]O_H", "size": [480, 640]}, "area": 178488.0, "iscrowd": 0, "image_id": 10175, "bbox": [0.0, 1.0, 640.0, 476.0], "category_id": 183, "id": 10012399}, {"segmentation": {"counts": "n][62j>4N20000000000000000000000000000001O000000000000000000000000000000kIJ`M6W2JRN6m1KSN5m1KSN5n1KRNOgI0lg^2", "size": [480, 640]}, "area": 286.0, "iscrowd": 0, "image_id": 10176, "bbox": [433.0, 266.0, 39.0, 214.0], "category_id": 105, "id": 10012400}, {"segmentation": {"counts": "i`k14l>1O1O010O000000000000000000000eNKkC5UlElA8T>HnA6R>IRB4n=LSB3m=LTBNF2W>OWB1i=OXB0h=OYB1\\>O00_X3a0PgL000O1006JN22NJ62N5KJ6M30000O100000000000000000000O10000000000000000000000O10000000000000000000000O100000000000000000000O100000000000000000000O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O10jN]Bo0b=RO^Bn0b=QO_Bo0`=QObBn0^=RObBn0]=ROeBm0[=ROfBn0Z=ROgBm0X=SOiBm0W=ROkBm0T=TOlBl0T=SOnBl0R=SOoBm0P=SOQCm0o1O1N2O1N2O1N2O1N2O1O1N2O1N2O1N2O1N2O1K5O100O1O100O1O100O1O1O100O1O100O1O100O1O100O1O100O1O1O100O1O100M30000O1000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "size": [480, 640]}, "area": 5786.0, "iscrowd": 0, "image_id": 10176, "bbox": [520.0, 420.0, 120.0, 60.0], "category_id": 167, "id": 10012402}, {"segmentation": {"counts": "0c>=00O10000000000O1001O00O10000000000O1O1000000O100N2O1N2O1N2N2O1N2O1N2O1N2O1N2O1N2O1N2O1N2N2O1000000O100000000O100000000O100000000O100000000O100000000O10000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000000001O0000000000001O0000001O001O00001O002N1O00\\OcNeC]1YT3BlL>T3BlL>T3BlL>T3BmL0O100O100O100O2N100O1N2O1N2O1N2N2O1N2O1N2O1N2O1N2O1N2O1N2O1N2N2O1000000O101O00000O100000000O100000000O100000000O100000000O100000000000001O0000000000000000000000000000000000000000000001O000000000001O000000000000000001O0000000000001O0000001O001O00001O002N1O1O[OkN`CU1]fMBZ2>fMBZ2>fMA[2?eMfKBQ2i2Y2fMeKHk1b2`2fMdKKj1_2b2fMcKLj1_2c2eMbKMk1^2c2eMbKMk1_2b2eMaKMm1^2b2eMaKMm1^2b2eMaKMl1_2c2dMaKMl1_2c2eM`KMl1^2d2eM`KMl1^2d2eM`KMl1^2d2eM`KMk1_2e2dMaKLj1`2e2eM`KKk1`2e2eM`KKk1`2e2eM`KKk1`2e2eM`KKj1a2f2eM_KJk1a2f2eM_KJk1b2e2dMaKIj1c2e2dMaKIj1c2e2dMaKIi1d2f2dM`KHj1d2f2dM`KHj1d2f2dM`KHj1d2f2dMZKNo1_2g2dMSK3V2Y2g2dMlJ:]2R2g2dMfJk0X2a1R3dM`Ja1n1k0b3dMZJW2c16S4l50001O00000O100000000000000000000O2O0O100O1dNYG_Lg8Z3cGbL^8]3fG_L[8a3gG]LY8b3kGZLV8f3mGWLS8i3PHSLQ8l3b100O100O10000O100O10000O010O11O000000000000001N101O1O2_FPLn7Q4PHPLP8Q4nGQLQ8Q4lGQLS8P4kGQLU8P4hGSLW8o3fGSLj4EcMY4aMSLl4DcMZ4_MTLa2ClNOS1\\4^MTL^2EQOKS1^4[MSL\\2IVOFS1_4XMULY2K[OBT1_4WMULU2N@^OT1`4UMVLQ21FYOT1a4SM_Lf1K3UOT1c4QM@l1lKS1e4oL@\\5a0bJ@^5a0`J@`5P5O1000O100000000000000000O10000000000O100O1O100O2O0O2N101N1O2O1N1O2O0O2N101N2N101N1O2O0ORFVKi9h4XFYKh9f4WF[Ki9e4VF]Kj9a4WF_Kh9b4WF_Kg9b4YF`Kd9b4\\F^Kb9d4]F^K`9c4`F^K_9c4aF^K]9b4cF_K]9a4bFaK]9^4cFcK]9]4cFdK\\9\\4cFeK]9Z4cFgK]9Y4cFhK[9X4eFiK[9W4dFkK[9U4eFkK[9T4eFnKZ9l401O00001OQMhF6X9IiF8V9HkF7U9JjF7U9j201O00001O001O001O001O0OfMPGfNP9_1QG\\Nn8k3010O01O0010O0001O010O001O010O00001O010O001OROWGeKj8Y4]GaKc8^4dGZK^8f4`G\\K`8c4]GaKd8]4YGgKg8X4VGlKj8U5010O000000001OUJaJU2_5iMSKg1m4WNeKY1[4eNiKZ1]OlK^3h2YMZ1VO]LU3X2hMY1POXLb3_2`MW1kNVLl3b2\\MW1dNULU4d2YMU1_NVL\\4e2WMS1YNYLc4c2WMoMfMX2=UMj4d2TMbMVNT2BhM6NQ5d2QM_M_NQ2YOnM3MY5d2lL]MgNo1QOSN0M_5c2jL\\MnNj1jNZNLLf5d2fLYMVOh1bNbNe5]2^NkNmKcNj5a2`NfNfKfNm5d2ZOiMiJBn5e2[OfMhJEm5e2^OcMeJGn5e2AaMg0_2\\O^Md0b2_O\\M`00hI^2\\<0000000000O1000000000000000000O11O1O1O001O1O1O1O001O1O1O1O010O1O2N3M2N3M2SEmLc5ObMW3`LSMS:o2cEYM]:f3O1O001O1O0VLeKoL\\4Q3fKlL[4W3eKdL\\4_3dK\\L_4g3`KULa4o3^KlKe4W4[KdKg4^4YK]Ki4g4VKUKl4n4TKlJo4W5QKdJP5`5PK[JR5g5PKRJR5R6nJiIT5\\6kJ]IX5T81N3N1O2M3N1N3JZJoFh5o85O10O00001O0O1100O00100O00nNRGTLm8m3UGfKODl8e4aG[KFMi8h4RHVKm7i4WHUKi7h4X1N2N3OQH]Kb5c4`J]K^5c4`2O0000YKPL`No3f1aKdN`4m500010M2100001O0000000QJ\\Kb1d4aN_KY1a4jNbKP1^4TOdKf0\\4BbK8^40[KNg4U5001iF[KQ8e4nGdKj7\\4THgKk7Z4SHgKm7[4oGhKP8Z4lGiKY4ZOlNo4fLkK[4XOoNQ5^LkKa4TOSOX6j0gIYOZ6d0eI_O[6c41TLeIQO\\6n0eIQO[6n0fIRO[6m0eISO[6m0eISO\\6k0eIUO\\6i0eIWO[6g0hIXOY6f0hIZOY6c0iI]OX61^IcL>\\3U6ARJiLMf3R6YOmJg0T5QOTKn0m4iN[KW1e4fN^KZ1d4aN_K_1b4UNiKk1Y4kMoKU2R4fMRLZ2P4^MWLa2j3PMYI^On2b3k3fLjLZ3W3\\LRMd3U70001O0000000000001O00000000001O00^F", "size": [480, 640]}, "area": 120338.0, "iscrowd": 0, "image_id": 10176, "bbox": [13.0, 77.0, 627.0, 403.0], "category_id": 183, "id": 10012404}, {"segmentation": {"counts": "0k9k51O00000000ifF^O[9;nFBR97YGEh84aGI_81kGKV8NTHNl7K^H2c7GgH5Y7HnH4S7IRI4n6IYI3h6J]I3c6JdI2]6KiI1W6LnI2S6KnI6i:0O1O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000YOKmA5S>OiA1W>3eAMZ>9aAG^>>^ABa>j00000O11O000000001OO1O1O1O1O1GQOjAP1V>800O10000O10000O10000O100O100O1M3N2M3N2M3N2M36J8H5K5Km0SO=C0000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000O1O1O1O100O1G9XL\\OmGU1R8lN]Ge1d8ZNQGQ2X;2TNnMRFT2n9oMkEU2T:PNcEU2]:b100O100001O1O1O1O1O001O00000000001O000000000000O100O100O100O100iMQLfF7c1i3g7PLeF;a1e3j7PLdF`0]1a3o7oKdFd0Y1]3R8PLdFg0V1Z3Z8iLbGX3^8jL`GV3`8kL^GV3a8mL\\GT3e8lLYGU3g8oLTGR3l8RMoFo2Q9TMkFm2W9SMfFn2[9TMaFm2_9UM^Fl2d9b1O1N23MO1O100O1IoIhFR6X9oIfFR6Z9nIfFR6Y96FgIoF021NY6Q9900001OO10000000000000000000000O1000000000000O1N[ITGd6l8]ITGb6l841O1O0[IRGb6n8^IRGb6n8^IRGb6Q900000002N000000O11O0000O1O10cInFV6R9jInFV6R9jInFV6T9hIlFX6T9hIlFX6T9hIlFX6U9gIlFX6S9iImFW6_9JO100000000", "size": [502, 640]}, "area": 58794.0, "iscrowd": 0, "image_id": 10179, "bbox": [0.0, 286.0, 640.0, 216.0], "category_id": 167, "id": 10012407}, {"segmentation": {"counts": "Wdi11b?5L3M4K4M3M4K4M4L3M3N3M2N2N3M2M4M2N2N3M2N3L3N2N3M2N3M2M2O2N1O2N1O2N1N3N1O2N1O2N1N3N1O2N1O2N1N3N1O2N1O2N1O2M2O2WGWLb5j3WJ`Le5b3TJhLg5Y3SJQMi5P3PJYMl5h2mIcMo5^2jIkMR6V2hITNT6m1eI]NV6d1cIfNZ6[1_IoN\\6R1aIUO[6l0bIYOZ6h0cI_OY6b0dICX6>eIIW68fINU63hI1W60fI1Z6f40O0010O100O100O100O2O0O10000O100O100O100gM^G]Mc8a2bG\\M^8c2eGZM\\8e2hGXMX8f2mGVMT8i2oGUMQ8i2THSMm7l2VHRMj7l2[HPMf7o2]HoLc7P3aHlL`7R3dHlL\\7S3hHiLY7U3kHiLU7V3f20000001O000000001O000000001O0000001O000000001O0000001O1O001O1O001O1O001O1O001O1O001\\OZLVEg3j:ZLTEf3m:[LQEf3o:YLQEh3o:WLQEi3n:WLSEj3j0cL[8CkFk3O]MT9iNmFa5S9^JoFb5o8_JQGa5o8_JQGb5m8^JTGb5l8^JTGc5k8\\JVGd5i8]JWGd5h8\\JXGd5g8\\JZGe5e8[J[Ge5d8\\J\\Ge5c8ZJ^Gf5b8ZJ^Gg5`8ZJ`Gf5`8YJaGh5]8YJcGg5]8YJcGh5[8XJfGh5Z8XJfGi5X8WJiGi5W8WJiGj5V8VJjGj5U8VJlGk5S8UJmGk5R8VJnGk5Q8TJPHl5o7UJQHl5n7TJRHl5n7SJSHn5k7SJUHm5k7SJUHn5i7RJXHn5h7RJXHo5R3oId02[Lo5S3nIUM0V23bMP6U4UJSNLhMo5T3mIlL?]1A\\N38Q6S3lIgLg0U2\\OQNQ6S3mIcLn0\\1QOfN48Q6S3lI_LU1\\1jNjN39R6R3mIZL]1[1aNPO49R6R3lIVLd1[1ZNTO49R6R3mIQLl1Z1QNZO4:S6Q3QLWMhM^O4:S6Q3ULRMeMC3:T6P3YLnL_MH4;T6P3\\LhL]MM3;U6o2`LdLXM14Z6h2mLjLiL>\\6g2iLlLjL>_6d2gLmLkL?`6b2eLoLkL?b6a2aLPMmL`0c3lNWOb39RMmL`0_3PO\\Og3NhLZM?Y3UO]Ok3JbLdM:Q3]O@m3E]LoM4k2C_OT4^OYL[NLh2G^OZ4fNhLWOSOd2L]O`4ZNjLJeN_21\\Oe4TNiL4]N[27ZOj4PNdL?WNW2;YOP5iMaLV4`NoMU5eM^L[4]NoMa7P2`HoMa7Q2_HoMb7P2^HoMc7P2^HoMc7Q2`HlMa7R2eHhM\\7W2jHcMW7\\2oH_MR7_2UIZMl6e2[ITMf6k2`IPM`6o2eIlL[6T3jIgLW6W3nIfLR6Y3SJbLm5^3WJ^Lj5`3[J]Le5b3\\J]Ld5c3^J[Lc5c3_J]La5b3`J]L`5d3aJZL`5f3`JZL_5f3bJYL_5g3bJWL_5i3aJWL^5j3bJUL_5k3aJTL`5l3aJSL^5m3cJRL\\5P4R33N2M3N2M4M2M38I7H5K5Ll0SOc0G:00O100000000000001O2O5J10O001OO100000O02O1N2O1O002M01M4L3N3N2N1MkAjNU>V1300000O10000O100lBhNo;X1nCkNQ_EDc::^EFf:4\\EKd:5]EJc:6]EJb:7^EJa:6_EJa:6_EJa:6_EK`:5`EK`:5`EL_:5_E\\OoNCb;T1`DZOKL4^A1a>`0O0010O01O2M11NO0HUOlAm0S>90O01000O10000O10001N2ON110003L10O12UOeA;]>CdA=^>AbA?_>^OcAb0g>O1O001O00002Bn@:Q?EPA;S?0\\BFaNO]=;QDJo;6QDJo;6PDKP<6oCJQ<6nCKQ<7mCJS<7kCKT<5kCLU<5iCLW<4hCMX<4fCMVo0PBnN_=c1O1O0`EfNYMDl8g1iI[OV6f0cFdNg2h0e6R1ZIPOe6Q1VG\\Nm0e0l7P1UGV1GbLj8X2_G^1a8cN]G^1c8cN[GW1I`Ll8Y2RG_14WLj8W6PGiIV9Z6OIkFnIY9Q64O13M00@fFgJ\\9Y5dFeJ^9Z5=1O1OM3O1001O000000O1001O1O00002N1O000000000000001O1ON200003M00AdFfJ_9Y5=00J60000000000O11O1O1fEkJ00S:_5L001O1O3MaJVFY5W:I0O10000O101oJeEj4\\:RKiEk4^:10O01OF^EgKa:Y4`EgK`:W4bEiK]:V4eEiK]:V4dEhK]:X4dEfKU:LiE]4c:fK]E[4Z:bKbE0061Y4]:a00N22N1O001OO1001O0000000000O10000O11O000000001O1O", "size": [497, 640]}, "area": 66911.0, "iscrowd": 0, "image_id": 10192, "bbox": [0.0, 0.0, 640.0, 355.0], "category_id": 181, "id": 10012414}, {"segmentation": {"counts": "o>b0c=\\10000O100000000O100000000O10000000000O100000000O100000000O10000000000O100000000O100000000O10000000000O100000000O100000000O10000000000O10000000000O10000000000O10000000000O100000000O10000000000O10000000000O10000000000O10000000000O10000000000O1000O100000O100000000O10000000000O10000000000O10000000000O10000000000O10000000000O100000000O10000000000O10000000000gDbM^9_2`FeM^9[2`FjM]9V2aFnM]9R2aFRN]9n1aFUN^9k1aFWN]9j1bFYN\\9g1cF[N\\9e1cF]N\\9c1dF^N[9b1eF`NY9`1fFaNY9`1gF`NY9`1gFaNX9_1hFaNX9_1hFaNX9_1hFbNW9^1iFbNV9_1jFaNV9_1jFaNV9_1jF`NW9`1jF_NV9a1jF_NV9a1kF]NU9d1kF[NV9e1kFYNV9g1kFXNU9h1lFVNU9j1lFTNT9m1mFRNS9n1nFPNS9P2nFmMT9S2nFiMT9W2nFeMT9[2nF`MT9a2nFZMU9f2k10000000O1000000000000O100QJTMfI4S5h2W1hMeNX2Z1lMcNT2]1oM`NQ2`1PN_NP2a1QN]NP2c1RN[Nn1e1SNZNm1e1UNZNk1b1[N\\Ne1c1]N\\Nc1d1^N[Nb1e1_NYNb1g1_NPM\\NPNU3P5_NcLQOUN`2X5`NTLG[Ni1b5`NiK9\\NW1k5gNXKf0dNb0T6WO`Ji3`5T300001OGjFWJV9i5kFVJU9k5lFSJl5NVMo5PMQJj50VMo5R3QJnLP6P3QJPMo5P3QJPMo5P3QJPMo5P3PJQMQ6m2PJSMl5Q3TJoLk5R3UJnLj5S3VJmLi5T3VJmLi5S3XJmLg5T3YJlLh5S3XJmLj5Q3VJoLn5m2QJTMR6i2nIWMV6e2jI[MY6nN`Jb0WO`0b6^NiIfN0W2Ee0g6fMVJk5n5hIYJZ6^71N2]LUI_Nl6[1_ITNm6g1[ISNh6i1^ISNd6l1`IoMb6P2aIlMa6S2bIiM`6V2cIgM^6X2eIeM\\6Y2hIeMX6Z2jIdMW6[2kIcMV6\\2lIcMT6\\2nIbMS6]2oIbMQ6]2RJ`Mo5^2XJ]Mh5b2]JYMd5f2`JWM`5h2cJVM]5i2gJSMZ5l2jJQMV5n2mJPMS5o2QKmLP5S3RKkLn4T3TKkLl4U3VKiLj4V3YKgLh4X3[KfLe4Z3]KdLc4[3`KcL`4]3aKaL`4^3cK`L]4_3fK_LZ4a3k3O1O100O100O1O1000000000hLcL\\J\\3m800000iLdLYJ\\3g5dLYJ\\3g5dLYJ]3f5cLZJ]3f5cLZJ]3g5cLXJ]3h5cLXJ]3h5cLXJ]3n81jLbLWJ^3i5bLWJ^3n8OmLcLTJ]3l5cLTJ\\3m5dLSJ\\3n5dLQJ[3P6eLPJ[3P6eLPJ[3Q6eLnIZ3S6fLmIZ3S6fLmIZ3T6fLkIZ3U6fLkIZ3V6fLiIZ3W90JfLUDZ3U9gL`IY3U9fLWD[3[:fLQGZ3S9fLaFOQO[3^9eL^G08[3Z8eLaH0RN[3m;0FeL^D\\3\\9dL_H0UN\\3`;dLaD\\3_;dLaD\\3^;dLcD\\3];dLcD\\3Z;fLgDZ3X;gLhDZ3W;fLiDZ3V;fLkD[3T;eLlD[3T;dLmD]3Q;dLoD]3P;bLQE_3m:bLSE^3m:aLTE`3j:aLVE`3i:`LWEa3h:^LYEb3f:_LZEb3e:]L\\Ed3b:]L^Ed3a:[L`Ee3_:\\LaEe3^:ZLcEh3Z:YLfEh3Y:XLgEi3X:VLiEl3T:ULlEl3S:SLnEo3o9RLQFo3n9PLSFR4j9oKVFR4Z8kK]H2ZOU4f9kKZFV4d9kK\\FV4V8gK^H2]OY4S8eK_H3^OZ4Q8cKaH2_O`4^1_KS40nJ2Ad4m0gKd4BnJ2Bj4N[Lb5iNmJ3Cn4YOfLW6ZNlJ1El6^5SImJ1El6^5SIlJ2Fl6]5SIlJ0Hm6\\5SIkJ1Im6[5RIlJ0Jn6Z5SIjJ0Lm6Z5SIjJOMo6Y5QIjJ0Mo6Y5RIhJO0P7W5QIiJO0P7W5QIhJ01o6W5RIgJN3Q7U5QIgJO4P7U5PIhJO4R7S5oHiJO4R7S5oHhJO6S7Q5nHiJO6S7Q5mHiJ16R7Q5mHiJ07T7o4lHiJ18S7o4kHjJ18U7m4jHjJ29T7m4jHjJ1:V7k4iHkJ1:V7k4hHkJ2;V7g5jHYJV7f5kHZJV7e5iH\\JW7c5jH]JV7c5iH^JX7a5hH_JX7`5hHaJX7_5hHaJY7]5gHdJY7\\5gHdJY7[5hHeJY7Z5fHgJZ7Y5fHgJZ7X5fHiJ[7V5eHjJ[7U5eHlJ\\7S5dHmJ\\7R5dHoJ]7P5cHPK^7n4cHRK]7n4bHSK_7l4aHTKb7h4^HYKd7e4\\H[Kg7a4YH`Kk7\\4UHdKo7hNeH^4\\OkLR9S3nFmLb7lN^IU4POoLa7oN`In3oNTM_7QOnIH5]6;XKSOcNa65UKVOhN5B`0a65UKWOhN3Ab0b64UKWOjN2^Oc0b65VKVOkNo1o5kNVKVOmNm1m5mNVKVOoNk1k5oNVKVOQOi1i5QOVKVOSOg1h5ROUKWOUOe1f5TOUKWOWOc1d5VOUKXOXO`1c5WOVKYOYO^1a5YOVKYO[O\\1_5[OVKYO]OZ1]5]OVKYO_OX1[5_OVKYO]OZ1]5]OVKYOTOc1f5TOWKZOgNl1Q6oLoIU1Y13[NR2\\6dLSJW1V1h3e4oJZJX1Q1i3`5VLaJj3`5TLaJl3_5SLbJm3_5PLcJP4]5oKdJQ4]5lKeJT4[5kKfJU4[5hKgJX4Y5gKhJY4U5hKmJX4P5fKUKZ4h4lKUKT4j4PLSKP4j4ULTKk3i4[LTKe3k4_LRKa3b4SKbIb1j1Z3d4QMZKP3e4QMZKo2f4QMZKo2f4QMZKo2e4RM[Kn2e4RM[Kn2e4RM[Kn2e4RM[Kn2e4RM[Kn2e4RM[Kn2e4RM\\KP1VNgN^69\\Ki0]NnNW69]Ka0cNVOP69]K:jN]Oi59^K2POEb59_KJVOM[59_KC]O4T59`K[OD;l4:`KTOKb0e4:bKkN0k0^4:dKbN5T1W4:fKYN:]1P4:cNF\\1;dNE\\1;dNE\\1;eND[1kM;U9WOSILVNn0h8UOmIi0R6WOmIj0S6VOnIi0R6WOmIj0T6UOkIl0U6UOnIg0R6YOkIj0U6WOkIh0U6XOlIg0T6YOkIh0U6YOkIf0VMROD11Of89iJ:dLBL3f81nJl0\\LkNc8:PKm0Q5SOnJi0^LoNc89oJh0`LmNa8_4\\OaKe0a4XO_Kh0b4WO_Kh0b4WO^Kj0c4TO]Kl0d4SO\\Kn0d4QO]Kn0d4QO\\Ko0f4oN[KQ1e4nN[KR1f4mNZKT1g4jNZKU1g4jNYKW1g4hNZKW1h4gNYKX1g4hNYKY1i4dNXK[1j4cNWK]1k4`NUKa1o4ZNRKf1T5SNmJk1T5UNlJj1T5WNmJh1T5WNmJa1dNaL`6n1mJ\\1gNfL\\6n1nJX1iNiLZ6o1nJV1jNiLY6Q2nJT1_5lNbJS1_5lNbJR1^5oNcJP1]5POdJn0^5QOcJm0^5SOcJl0]5TOdJj0[5XOfJf0Y5\\OiJ`0X5AiJ>V5ClJ9T5ImJ3V5MlJ0V5OlJMV53kJKW54kJIV57kJGW58jJGV59oJAR5?SK[Ok4h0[KPOg4P1_KhNd4W1_KcNe4\\1]K]Ni4b1XKWNn4i1SKmMW5R2Z3O001O1O0000000000001O0000002NNRNWDn1l;O1O1O1O1O13MO2M2OO0100000O1001OO100003MN22N0000O11OO100N21O0001N10000002N6J3M001O00001O00001O001O001O001O100O1O1O1O2IYCVOiQIDo6>mHDU7kGDV8a0`GC`8b0QGIn8=cFL]99TF1l9o1000001O000O1000000010O000000001O01O0001]L^Fk2`:I4L4M2M4L3M3M3NiGhMl4U2TKnMl4P2SKPNo4n1QKSNP5l1oJTNR5l1mJTNU5j1kJWNU5h1kJXNV5g1jJYNX5d1iJ]NW5b1iJ^NY5`1gJaNY5^1gJbN[5[1fJeN[5X1gJhNZ5X1eJiN_5R1aJnN`5Q1`JoN`5Q1`JnN`5S1`JlNb5S1^JmNc5S1\\JmNe5R1[JnNf5P1[JPOf5P1YJPOh5n0YJROh5n0WJROj5m0VJSOj5j0YJVOh5e0mFTO\\37h5c0\\J]Od5b0]J^Od5`0]J@d5>]JBd5<]JDd5;\\JFc59^JGc58]JHc57^JIc56]JJc55^JJc56]JJd55\\JKe53\\JMd53\\JMe52[JNe52[JOe50[J1d5O[J3e5MUJ9j5GQJ?n5AmId0T6ZOkIi0T6WOkIj0V6UOmIi0R6WOmIj0S6VOnIi0R6WOmIj0T6UOkIl0U6UOnIg0R6YOkIj0U6WOkIh0U6XOlIg0T6YOkIh0U6YOkIf0VMROD11Of89iJ:dLBL3f81nJl0\\LkNc8:PKm0Q5SOnJi0^LoNc89oJh0`LmNa81O001O0O2OO11N10001N3N2N2M3N2N2M3N1O3MO1001O2N4L001ON2002MC]OdCd0]<^OXCN0j0h<61O100000fMSOhGk0W8A^G?b8C[G>f8AZG?e8CZG=e8C]Gb70bHO]71dHO]70dHO]71cHN[74cHN]73cHLg7JYH6j7GWH8k7EVH;e:01OM33MK51OO1M31O0000O17II700003M00001O00002NO14LL41OO100000000001OM3RGB`4=`KD\\4`0cKA\\4?dKC[4VMl1YL[M\\6j0ZMW2`2hM^MY2a2hM^MY2b2hM\\MP2n2oMQMn1U3PNjLo1X3RNfLm1\\3TNbLk1a3TN^Lk1c3WN[Lg1h3YNWLf1j3\\NTLc1o3]NnKc1T4]NkKb1X4^NeKb1[4`NdK`1]4aN`K`1a4`N^K`1d4`NYKa1i4`NSK`1P5aNmJ_1U5bNgJ_1[5cNaJ]1`5eN\\J\\1f5fNVJZ1l5gNPJZ1R6hNiIY1X6iNfIV1\\6lN`IT1b6nN\\InNnNS1g72ZIdNXOU1`79VI\\NCW1Z7=mGZNP2V1T6P1gInNY6R1hIlNY6R1jImNV6Q1lInNU6Q1lIoNT6Q1nIlNS6S1nImNR6S1oIkNR6U1oIjNQ6Q1VJlNk5Q1YJnNg5Q1[JmNf5R1\\J]NVM8^8Y1`J[NVM9[8[1kJbNU5\\1PK`NQ5`1e3N200O1O1O100O1O1O100O1O100O100O100O10000O100000000O1000000O100000000O1000000O1000000000000000000000000000000001O0000001O0000001O001O00001O001O1O0[MjNeHW1[7jNcHW1\\7lNaHT1`7PO[HQ1d7VOUHk0k1eNR2?SLl0j1gNR2YO[OQOf1KbNm19UOAUOm3g1^LhN2Ba3h1ZLYNa01U3h1VLXNCJSO8T5>gJG]1IGQ1V4^ORK_On02Om0Q4AXK\\Of065j0m3B`KYO=:;f0i3F]MEmNb0f3H]MFRO>a3K\\MHWO9^3NZMJ[O6[3OXMM_O3Y3OTM2EMX30nL8LGV30fLa07]OS31fLb09]OP31hL`0:^On21kL>9@l22lL<:Aj22oL;8Bi23PM99Cg23RM89Ed23TM6;Ea24VM5;F_25WM3f6_O\\Ia0f6[O\\Ie0f6WO\\Ii0f6SO\\Im0e6QO\\Io0f6mN]IR1e6jN]IV1d6gN^IY1d6cN^I]1h6[NZIe1k6TNWIl1o6gMXIY2m6XM^Ig2h6iLbIW3a800000001O0000000000001O0000000000001O00000000001O000000001O001O001O1O001O001O1O001O001O1O001O001O1O001O001O1O001O2N1O2N1O2N1O2N1O2N2N1O2N1O2N1O2N2N2N2N2N3H7J6I8H7@Tka0K\\U^O6J6K5L4L4L3L3N2N2N2N2M3N3M2M3N2N2M3N1O1N2O001N2O1O1O1O001O001O1O001O1O1N2O1O1O2N10001O001O001O1VEZM]:g2^EcM\\:o2O1O0000001O0000001O0000001O0000001O0000001O1O001O001O1O001O001O1O001O001O1O001O1O001O001O1O001O1O1O1O1O1O1O1O1O10N100O101O0O100O2O0O2O0O2O001N100O2N1O2N1O2N1O2OWIbLU3]3cLoL[3o2]L]M`3b2]LdMa3[2^LjM`3T2_LPN`3n1_LWN^3h1aL\\N^3b1`LcN^3\\1aLgN_3V1aLmN_3Q1`LRO_3l0aLWO_3g0`L\\O_3b0bL@^3>bLD]3:dLH\\36dLL]30cL3_3IaL8a3D`L>b3]O_Le0b3XO^Lj0c3RO^LP1d3lN\\LV1f3eN[L]1f3`NZLb1h3YNYLi1i3QNYLQ2i3eM]L]2e3XMcLh2W7101N101N101N100O2O0O2O0O101N101N101N01000O100O10O0100O100O10O10O100O10000O01000O100O10O1000O0100O10O010000O10O010000O100O2O000O2O0O2O001N10QFTMo8k2oF^Ml8m3K6K4K6K2M1O101N100O1O2O0O101N100O2N010O0100O10O10O100O010O100O01000O100O0]LRHZ1n7cNTH]1m7`NTHa1m7\\NUHe1j7YNXHg1d7[N^Hf1R7[MdH;;[2c6kMXI_O7g2_6oMdJQ2c1oLNT1[Nn1f1ZMCm0cNj1h1_M_Ok0fNf1i1gMZOh0hNc1l1lMVOd0kN`1n1RNQOc0mNX1T2\\NhN`0POU1W2bNbNh7_1hHRN@`0h7Q1kG]Nm02@?i7a0aJ^O`5b0`J^O`5a0aJ_O_5a0aJ]Oa5c0^J^Ob5b0^J]Oc5c0]J^Ob5a0_J_Oa5a0_J^Ob5b0]J_Oc5a0]J^Od5b0\\J^Od5b0\\J_Oc5`0^J_Oc5a0]J^Od5b0[J^Of5b0ZJ^Of5b0ZJ^Of5b0ZJ_Oe5`0\\J_Oe5a0[J_Oe5a0ZJ_Og5a0YJ^Oh5b0XJ]Oi5c0WJ]Oi5b0XJ_Og5a0XJ@h5`0XJ@h5`0XJ@h5`0XJ_Oi5`0XJ@h5a0WJ_Oi5a0WJ_Oi5b0YJ[Og5e0[JZOd5g0^JVOb5k0`JSO_5m0cJRO\\5o0fJoNY5Q1`31O001O2N2N1O2N1O2N2N1OO1O11O001O00000000O11O0000000000001O0000000000000000000000000000000000002N2N2N2N2N2N3M2N2N0000O1003M2N2N2N1O001O000000001O000000000000001O0000000000001O0000000000000000001O0000001O000000001O00000000000000O10000O10000O100000000O1000000O1O10000O10000000000O1001O000000NVEdMj:[23O100O100O1000000O1000000O1000000O100O100O10000000000O10000O10000O1000000O10000000000N200001ONfDTNZ;k13O10000O1O100O1000000000000O100O10000O100000000O1O100000000O1000000O1O100O1O100000000O10000O10000O100O10000O100O10000O100000000O10000", "size": [426, 640]}, "area": 36996.0, "iscrowd": 0, "image_id": 10205, "bbox": [0.0, 0.0, 640.0, 158.0], "category_id": 102, "id": 10012419}, {"segmentation": {"counts": "nXn41aj01gBOVnX10lQgN1N2N010SCNb<0\\C0hO0O2O0]HjJQ7X5`01O0O2WHdJb7b500O1O100010O1O1O2N1YM[HGf76\\HJd78[HGg74]HKc72`HNa7mNcHkN:V2S7mNoIk0Q6hNTH]OZ2^1a5UOYHTOS4Od3k0\\HUOm;3lCb0]<_OdC`0\\<_OfC>b4_OS33\\H1g^;_ObDe0`;UO`Dn0_;POaDS1h;32N6L4J2N000M012ML]OdCd0cf9DWF=h9FTFW2L3N1N2N2N102M2N2O0Odkc3", "size": [426, 640]}, "area": 11891.0, "iscrowd": 0, "image_id": 10205, "bbox": [235.0, 152.0, 126.0, 164.0], "category_id": 156, "id": 10012429}, {"segmentation": {"counts": "n^f49Q=7PCCe4\\O49b6Q1[IkNK>5\\O4:a6Q1[IkNK>U1Ee5R1]IiNI`0U1Df5S1\\IgNUONd0d0U1\\OXN0O2a7X1[IfNKd0Y1\\Oa5Z1TJXOP8h0PHWOQ8i0oGVOa0@Y5Z1VJVOa0@Y5[1UJXO>^O^5Y1TJYO?]O]5Z1VJVO>@\\5Z1WJSO?CZ5Z1XJQO?EY5Z1XJRO>DZ5Z1ZJoN=GY5Z1^JfNRN10OW20Y5Z1`JgNPNOj9Z1UHfNRN0i9Z1XHfNh7Z1T200000000010O00000000000001O0000000001O0001O0000000001O01O00001O001hNoCU1UmGCS8=mGCS8=mGCS8=mGCS8=lGDT8Q8@QH?P8_OQHa0P8]OPHe0P8YOQHi0n7UORH[1`7cNaH`1]7^NeHc1Z7[NfHg1Z7XNeHj1\\92O002O0N2O0O1O1O01O2O0O1aNgDl0Z;SOgDl0Y;UOgDk0Y;ROkDFKQ1[;XOPEg0Q;YOREd0n:[OSEd0o:[OSEb0n:\\OSEe0n:XOUE3\\OK0M42^;2b[5MQfJ11O001O00000000O11O000000000000\\e;1cZD2M3N210O00000O1N2O2M3M3M3M3N2M3M3M3M3M2N3M3N2M3M3M3M3M3M3N3L5K4L5QG\\Mn6h2kHZMV7k2bHWM_7m2ZHVMf7n2SHUMm7P3jGSMW8Q3bGRM_8R3YGQMg8i300001O000000001O00000000000000O1000O010000O01N200000O0100000O]LTGj2k8WMTGj2l8TMVGl2j8SMWGm2h8TMXGl2h8TMWGm2i8RMYGl2h8TMXGk2i8UMWGk2i8UMWGK=m1[8XNkHX1V7hNXIj0i6UOkI6V6J_JAa5>bJ@^5`0d3^O\\Cb0c<3O01M2N3N11000000O1000O10O10001OO0100O100O1000O100000O10000O10000O01001O0O1000O100000N20O101ON[O_Ce0`<2010000O00100OD=00O100O1000O010O10O1O010001O1O1N3M2TF@l6a0QIAo6?SI@l6b0oHBP7>mHER7=iGGkN:Z9OiGS1o7mNdGXO]OZ2a8^NRH\\OTOS4Q7bLiI^OUOQ4P7bLSIVOb0c4Z6VLUIXO`0b4Z6WLUIYO>b4\\6VLVIYO1n4h6iKWIa4i6_KVIb4j6^KVIa4k6aKSI`4k6P10000O2O;E?@;RJ^H`5b7`JhHU5i7N1O1N2O2M10000O10O11O00O001000jN", "size": [426, 640]}, "area": 100478.0, "iscrowd": 0, "image_id": 10205, "bbox": [0.0, 17.0, 640.0, 349.0], "category_id": 172, "id": 10012432}, {"segmentation": {"counts": "W]R3b0Q9_OeJf1T4]NkK]2Z3dMfL\\2Y3eMgL[2Y3eMgL[2Z3eMeLj1hLUNc62dLi1m3XNRLh1n3ZNPLf1Q4ZNnKf1R4[NmKe1T4[NkKe1U4\\NjKd1W4[NiKe1W4[NiKe1X4ZNhKf1X4ZN`HGS3o1^4_NaKa1^4aNaKl1R4TNnKl1R4UNmKl1S4TNlKl1T4TNlKGQM^1]7lNbKE]MR1R7ZOXLf0i3YOWLh0h3YOXLf0h3ZOXLh0g3VOZLo0a3QO_LS1]3mNdLS1[3mNeLS1\\3lNdLT1\\3lNfLR1Z3nNlMLU23a50000000O100000000O100000O10O1000000O100000000O1000000O10O100000O10O1000O100000O10O10000000O01000000nF_OZ5a0bJG[59dJKY55fJNX52hJ1U5OkJ4SNXO]5e0`L6lMYOd5`0aL9eMZOk5=`L<^MWOV6=\\L?XMSO_6?XLa0SMPOi6?TLg0iLjN4Me6b0_Lg0cLjN:Oe6?aLi0kLhNh6?\\Lg0lLjNj6`0ZLf0iLjN_6LgId0P3g0gLiN[55]KN[O=V3@cLn01SOP5f0iKCWO6\\3CbLP1U5FcK:S2WOWMMNg0V5M`K9T2XOWMMOa0X52\\K9V2JVMHd0]Of3i0YL8V2MWMb0Z4ZOWL8W2OXM>Y4\\OVL7Z21XMMOoNZ4n0SL6[24[M[O3]OW4o0nK6\\2:\\MbN_MUN67W4Q1dK6_2h0bMQN^4R1_K6`2h0`MPNd4S1ZK5c2i0[MoMj4U1VK4d2R1X2kNSK3d2V1V2:iMMQ23oM3k1MTN6j1IVN8i1IWN3_MmLd01m2o2oN4VNTMf2h2SO_OSNaM1>f2b2VO_OhNQNR2_2VOAeNSNU2\\2UO6PN`Mj2[2VO[1k0eNTO\\1l0dNSOZOeMiMNm00EZ3[2RO]OhMbMM9h0;a2\\2SO@mNRNP2_2ROAnNoMQ2_2POEmNlMS2`2oNEkNmMW2`2jNFkNkM\\2a2fNGjNjMa2a2bNFjNkMe2a2]NGjNjMi2a2[NGhNjMn2a2VNGiNiMR3c2QNGiNhMW3b2nMHgNhM[3c2jMGhNhM`3a2fMIfNgMf3b2`Mn0b2SOZMn0g2SOWMm0k2TOQMl0R3UOkLiMYO[1m3m0gLiM@V1k3R1bLhMFS1i3W1]LgMNn0f3\\1YLgM4i0d3c1ULdM;e0`3i1RLcMa0a0]3o1oK`Mh0=Y3o3jLmKW3S4lLjKT3V4nLhKR3X4nLgKS3X4nLhKR3X4mLiKS3W4mL]JmNj0W4h4mL_JnNf0U4k4mLaJoNa0T4n4mLbJPO>S4o4nLeJoN9T4R5mLfJoN7T4S5mLhJoN3T4T5nLjJoNOT4W5mLkJPOLS4Y5nLlJoNIS4Z5oLnJoNES4]5eLYKWOYOT4a5YL`KDmNS4i5iKfK4^NT4P8lKnGT4S8mKkGS4W8mKgGS4b7fKnH8]OS4f7eKnH7[OT4g7fKnHd4S7]KmHa4S7`KnH^4S7cKlH\\4U7dKjH\\4X7cKgH]4\\7bKcH_4]7bK`H`4a7aK[Hb4d7`KYHa4g7bKTH`4m7?001O00010O001O001UMlGl6V1_H^Nf09m6Z1ZH_Nk03m6_1XH^Nl00m6d1WHZNn0Nm6i1UHXNP1Km6o1SHTNR1Jl6U2PHQNU1Fm6S3TIjLn6]3kHbLV7_3jH^LX7b3hH\\LZ7d3gHZLZ7f3fHXL\\7i3R100O1kMnFbNIR1Y9nNaFS1?VO08o8_ObFP1c0K_O^O_9E_FR1e0=m8`N^FS1f0=l8GTG:k8FVG:h8HlFiNJ_1Z9aFD^9T2O1000000000hMcFc0]9^OfF>Z9ChF:Y9GfF9Y9IgF5Z9JhF4Y9KhF4X9MhF2Y9MgF3Y9MgF3Z9LfF4[9KeF5[9KdF6]9I`F:a9E\\F=e9d11O3M4L4KOkLSFQ3m9RMQFm2o9UMPFj2Q:VMoEi2Q:XMoEf2S:80TMmEa2S:`MmE_2T:aMlE^2T:cMlE[2U:fMkEY2f9\\MgF;CX2a9eMiF4FV2^9lMiFOJS2[9RNiF^2V9gMgFY2Y9f0510eM`Fk0a9VO_Fh0b9XO`Fe0a9\\O^Fc0b9_O^F?c9B]FB?A?Anh6", "size": [426, 640]}, "area": 52539.0, "iscrowd": 0, "image_id": 10205, "bbox": [236.0, 30.0, 387.0, 390.0], "category_id": 183, "id": 10012433}, {"segmentation": {"counts": "kWe74Q=4H700O102ON15KO100O1O100O10000O101N1O2O0O100O101N100O1O100MoBNR=1_`6", "size": [424, 640]}, "area": 413.0, "iscrowd": 0, "image_id": 10211, "bbox": [592.0, 112.0, 32.0, 22.0], "category_id": 96, "id": 10012434}, {"segmentation": {"counts": "SOCR1d0YOAn9eFQOUOY:=gFe0Y9ZOhFf0W9[OjFd0V9]OiFc0X9\\OhFd0X9[OhFf0X9WOgEAS1W1T9ZOnFf0Q9ZOQGe0o8WOTGj0l8WOTGh0k8YOWGe0i8[OWGe0i8[OUGAfNT1U:[OUGg0k8YOUGg0k8YOTGh0l8XOTGh0l8XOTGh0l8YOSGg0m8XOTGh0l8WOUGi0l8WOSGi0m8WOSGi0n8VORGj0n8VORGj0n8UOTGj0m8SOUGm0l8POVGP1j8oNWGQ1j8jNfE1`1V1_:01OO100001OO1\\NkNeEN^1W1k8POUGo0j8UORGl0n8UOQGDgNU1X:XORGh0n8ZOoFg0Q9\\OlFd0T9^OjFb0V9@hF`0X9@hF`0X9@iF?W9AhF`0X9_OjF`0V9_OjFb0V9\\OlFd0T9[OnFd0R9[OoFASO9H0V:6_GD^N6]:KaG5j:O000000001O0000001O00`MKmG5P80nG0o76nGJo7:QHEm7a0cG\\O`N3m9c0aG_O]NN^91jFf0g0WOPOh0^9f0aGA^8a0aG_Oi87WGIV9IkF7b9\\O^Fd0S;06J5K4G_CCc<9_CGc<5_CKc<2^CNdm42d1_ObI=k43o1LRN4o1ISN8l1GUN9k1FVN:k1DXN:h1DZN;h1CZNZ7EWCMk[52XQK;D001O00O1001O2NM4O0001O001O0000O11O0010N11O2N00NZCBf<>201N100000001O000000O110O000000O1001OO100010OO1001OO01UCEi<=0O1000000001OO110N10O2O0RNFnF2ol43V^K2N3M>B5K1nMAZG>m8ZOTG5eNB\\<>70O100003MXc4DT]K0^N2jENV:?^E@c:`0\\E@c:a0]E_Od:?lDAO0U;?lDCMNW;?lDFJKZ;?lDHHI\\;?lDK[;5eDMY;3gD0V;0jD2T;NlD2T;NmD1S;0mDOS;1mDOS;1nDNR;2nDNR;2nDNR;2nDNR;2nDNS;1lD0S;2lDNT;1mDOS;1mDOT;0lD0T;0lD0g5AhI1X5>XK1h5GlN:YK0k5EmN:YK1j5FmN8YK2j5DhIKU5?YK2j5DoN:VK3k5CnN;WK2k5CoN:VK3k5BPOkCBNON2n;0YDm0Z;RO_DO31O03P1[;UOaDKO22Q1];SOaDO0P1_;b0O1E82001OO01O1O2O0000O1O1@mDiNQ;Z1RE[NM1V;d15ZNgDg1Y;41OO1M32MO20O3N1O1EcDiN^;S1iDiNY;T1?N^DlNR;S1kDSOFI\\;0cDQ1>UOBJ01\\;o0PE_Ol:a0TE_Ol:c0RE_Om:a0SE^On:`0SEAn:>RECm:=SEDl:TEAj4Bi0m0]JB`4KTKEj5o0cJ^OZ48S1;aJ]O[4:U1:^JZO\\4?V19XJZOa4a0U1g0kN[OU1d0iN_OX1a0dNA]1?aNC`1<]NGc18\\NJd17YNJh16WNKi15UNNj13TNNl11SN1m1ORN0P2BRJjN0=0D1O20\\3d1a2@QJlN2>MB30Z3f1b2\\OXJ@Z3U1^2[O\\J^OE@[3h1_2XNZJR17@o2W1Z2XN_J00P19@m2Z1\\2VN\\JV1WOb2o1e2gM\\JO0T1;XOd2o1e2fM_JR19WOc2R2f2eM^JR18WOd2R2g2dM^JR1:TOb2W2l2fNbJQOc2Z2k2fN`JPOf2Y2i2fNcJmNA1T3]2lLbMj5R1gJnNd2a2c2cNhJlNf2`2a2dNRN\\1n1cNSN\\1n1eNQN[1P2dNeJmNj2`2b2bNbJoNl2`2b2`NmM`1T2_NlM`1V2^NlMa1S2`NnM`1U2]NjMd1V2ZNlMf1S2[NmMe1T2ZNkMg1U2YNkMg1T2ZNlMf1T2YNlMh1T2YNkMg1U2YNkMg1X2VNgMk1W2WNiMi1W2WNiMi1X2VNhMj1Y2TNhMY1k2bN\\I@j3^1Z3aNmHO010OO0U4l0e3TOgL5]j>Oj]A:oNQ1L4M3M3M3M3L5L3K7I7J4K6M2N2N3M2N2N2N2N2N2K5O10000O100O11ONWLeFi3[920000O101N1000000000O10002N011N1O1O0000000000000010O0[O\\LfGd3Z8]LWGK;i3^8`L_Ga3a8bL[G`3d8b0000000000000000000000001O00O10001OO1001O001O1O001O0gKTGV4l8iKXGT4n8001O000000000000000000000000000N22N0000000000000000K51O0000000000O1O1N20O011O001O00000000001O00000000nMhKTKm0TNX2d6oLXKf0WN\\2_6PMYKc0YN]2\\6RM[K`0[N]2Y6RM]Kb0ZN\\2X6SM^Ka0[N[2U6VM`K?ZN\\2U6XM_K;\\N^2T6VMbK;[N_2Q6YMbK8^N`2n5YMdK7_N_2j5]MgK3`N`2g5^MkK0_Nb2e5_MnKL^Ne2d5_MmK]OQN6b0n2U5hLdJ0Fb0m1@RNN17d0Q3R5hLjJ?a1AoM7d0Q3R5hLjJ?d1I_NP3T5hLgJ>ABU29^No2U5hLfJ>j1LZNn2V5hLgJ>h1K]Nn2T5iLfJ?i1J`Nl2c5VMnKMbNk2`5XMnKLfNi2[5\\MoKJiNh2Y5]MnKLkNd2W5`MnKLmMIi0i2]5`MnKNjMLm0c2[5cMnKNiMLQ1a2W5fMoKMhMLU1_2Z5^MmKUI9R1XOi5=WIZIc0l0POk59YIj0k0mNl59XIl0k0kNm59WIm0l0jNm59WIn0k0iNn59WIn0k0iNn57YIQ1h0hNP67WIQ1j0gNo59VIQ1i0gNQ69UIP1j0hNP67WIR1g0hNR67VIQ1j0gNn59WIQ1m0dNl5TOlHV1:S1o0aNm5;UIT1P1_Nl5;UIV1Q1]Nj5T3XJjLh5W3YJgLi5W3YJgLg5Y3ZJeLg5[3\\JaLe5`3]J\\Ld5d3^JVLWN0\\7j3P2OO21OO1O0O2N2MQLkFP4T93oGTLd6m3TI]Li6d3RIbLl6^3PIhLm6Z3mHmLP7T3mHPMR7P3mHVMn6k2QIUMP7j2oHWMQ7i2oHXMo6j2PIUMQ7l2oHSMS7l2lHTMS7n2mHQMU7n2lHQMS7dNhHZ46PMT7Q3PIiLQ7NgHU2d0`Md6;QIm1`<6O0I_OgCa0Y<700oCSOg;n0XDROh;o0SDSONN40e;P1YDTO1Me;P1XDTO0K01i;Y1WDgNi;\\101O00O11O1O2ON10MaN\\Da1c;20N2O1001O00M30001O0O1O1O10000000000L40OLQDPOQBEnC@R<`0RD\\On;a0iCAa", "size": [424, 640]}, "area": 424.0, "iscrowd": 0, "image_id": 10211, "bbox": [532.0, 0.0, 73.0, 11.0], "category_id": 157, "id": 10012442}, {"segmentation": {"counts": "T4b1[2m0`4ROSL6S4IQLNU41PLEW49^4M1O4L1O2N2O0O2N3M3M2N2O4K2N2N2O1O1O1O1N2O1O001O001O00U^10jaN2M3ZO0RD2k;5oCMm;;mCGo;k0L4M4K4L4L4SMWNXJl1f5bNjIb1T6iN`IZ1^6lN[IW1d6mNTIV1l6POlHT1R7QOhHR1V7TOcHn0\\7XO\\Hl0b7YOXHj0g7[ORHg0m7[2N3M2WHcJe7_5[HbJb7c5N2O0O3M2N2N2N2O1N2N3M2N1O2N3N1M3M31O00O20O0O010000O11N1000000000O2O1N1NWJiIf4U6YKmIg4o5[KSJe4m5YKUJg4k5YKUJROFb5W6ZKSJSOHb5W6XKRJVOHa5U6ZKSJUOI`5T6YKUJWOG_5T6\\K[JXO^ONOT5Y6dK\\JZO^OR5V6dKgJY4Z5nJfIg0o0[4]5eKcJ[4[5RKfIL2>o0c4f5PKYI02OQ1R5Q7N101000000001N01000O011OO101O002N1O`NTKcJm4Y5YK_IIL0S1m4c5bK[J_4d5bK]J]4b5bK`J^4a5eK[J[4g5cKYJ]4h5^K\\Jb4d5_K[Ja4e5`KXJb4h5^KWJc4j5\\KWJc4i5^KVJb4j5^KTJe4k5\\KTJd4l5]KTJb4l5`KRJa4m5_KRJa4n5aKQJ_4n5bKRJ^4n5bKRJ^4n5bKRJ^4P6`KoIa4R6^KnIb4R6^KnIb4R6_KnI`4S6^KkI@\\OR5i6_KjI_O]O>OS4l6oKhIA]O71HOa4j6RLWI]O:jf<2O13MO001O11O2NN10O102OM1111N2OO1VCDg4H`hb1", "size": [424, 640]}, "area": 32586.0, "iscrowd": 0, "image_id": 10211, "bbox": [0.0, 115.0, 517.0, 227.0], "category_id": 162, "id": 10012443}, {"segmentation": {"counts": "0T4T9O1O1O1001OO12NO10000O1001O1O00003M000000000000000000O100O100O12NO1O1O1O1O1O100O1O1O1O1O1O1N2O1O1O1O1O1O1N2O1O1N2O1N2O1N2N2O1O1N2O1O1N2O1O1N2O1O1N2O1N2O1O1N2BXE[Ni:]1aE_NR1Ok7b1UG\\Nn05m7_1aHdN`7\\1]HhNb7Y1ZHjNf7V1WHlNj7T1SHoNm7Q1RHPOn7P1QHPOP8P1oGROP8n0oGSOQ8n0nGROR8n0mGSOS8m0lGTOT8k0lGVOT8j0kGVOV8i0jGXOV8h0iGXOX8g0iGWOY8i0gGVOZ8j0gGQO]8n0dGRO\\8n0dGRO\\8m0fGTOX8l0hGVOV8k0iGTOX8m0hGROX8n0hGQOY8P1fGQOY8P1gGoNY8Q1gGoNY8R1fGnNZ8S1fGlNZ8U1eGjN\\8W1dGgN]8W1eGiN[8W1eGiN[8V1gGiNY8W1gGiNY8V1iGiNW8X1gFYNe0?d8X1hFYNd0>d8V1]F^N:0c0e0Jf8Z2[GiM_8Y2aGbMb8_2`G_M_8b2`G]Ma8d2]G\\Md8e2ZG]Me8e2XG^Mf8c2XG_Mg8b2VG`Mj8d2QG]Mo8h2kFYMU9^3O0000000000AmFaLO2T9^3kF^L40MOU9b3>O11OL4001O0000001O1OeN\\FlM0P1e9T1\\FkMOR1d9n0[FQN4NOQ1b9P1\\FoM8S1[9o0hFPOX9o0jFQOU9o0lFiN[9T1hFkNY9Q1UFXNb0h0X9o0XFXN>j0[9n0kFROT9n0lFQOU9h0ZF^Na0k0T9g0SGYOm8g0SGfNSON71^9[1YGeNROOU:\\1jF`NSONN4W:^1iF`NTO1S:_1jF^NTO0K0X:b1RG^Nn8b1\\10000000000001O00M]D`Nd;`1200000000000000001O00000000000000000000O11O00000000001O000000000000000000000000000000000000001O000000000000000000000000O10000000000001O00001O000000000000000^D\\N`;d1`D\\N`;d1`D]N_;c1aD]N_;c1aD]N_;c1aD]N_;f10001O1ONcDZN\\;f1eDYN[;h1200MbD\\N^;d1bD\\N^;d1bD\\N^;d1bD[N_;e1aD[N_;e1aD[N_;e1aD[N_;e1aD[N_;e1aD[N_;e120000O1000000000cF\\NV7d1eH\\NRN1Y9c1nG_NhNNO010OO0hGEY8:iGEW8iG@X8b0fG]O[8b0hG`NjNh0^9h0lGXOT8h0nGUOS8l0lGTOT8l0jG_NeNe0a9m0iGUOW8j0jGUOW8k0jGTOV8m0iGSOW8m0iGSOW8m0jGROV8o0iGQOW8o0`F]NT1f0[8Q1_FYNU1e0\\8R1_FYNU1e0\\8R1_FYNT1f0]8Q1_FYNT1g0\\8S1fGjNZ8V1hGhNX8X1eGkN[8U1eGkN[8U1eGlNZ8T1gGkNY8U1hGjNX8V1hGjNX8V1hGkNW8S1bFXNX1c0W8U1aFXN\\1?S8X1bFYN\\1>R8X1cFZN\\1=Q8V1ZHfNf7X1\\HhNd7V1]HkNc7S1_HmNa7S1_HlNb7V1\\HjNd7V1ZHlNf7T1ZHlNf7T1THROl7m0WHQOi7Q1UHoNk7R1THnNl7R1THnNl7R1QH`N`N<`9V1fG_NiNN120;`9[1_FYNQ11PO`0`9Y1`GlN`8T1]GoNc8Q1^GnNb8R1^GnNb8R1^GnNb8S1^GkNc8V1\\GjNd8T1_GkNa8V1\\GlNd8T1]GkNc8U1^GjNb8V1]GkNc8U1\\GlNd8T1]GjNd8V1YGmNg8S1XGnNh8R1XGnNh8R1oFTNAn0`9n0oFWOQ9i0PGVOP9j0PGVOP9k0nFUOS9j0lFTN@R1d9j0lFXOT9h0mFWOS9i0nFVOR9k0mFUOS9j0oFUOQ9l0nFTOR9m0jFRNBQ1e9l0jFVOV9j0kFUOU9k0lFTOT9l0lFTOT9l0mFSOS9m0mFSOS9m0nFROR9o0nFPOR9o0kFSNCl0c9Q1jFTN@m0f9o0kFSOU9m0lFROT9n0lFROT9n0mFQOS9P1mFoNS9R1lFnNT9S1lFlNT9T1hFPNDk0e9V1fFnNZ9o0jFPOV9P1fFRNCP1g9n0fFTOZ9l0gFSOY9m0gFSOY9m0hFROX9n0iFQOW9o0iFPOX9P1iFoNW9Q1hFPOX9P1fFRNBn0h9Q1eFQO[9n0gFPOZ9P1gFoNY9Q1cFRNFl0h9R1bFSNDl0j9Q1YFRN000n0h9P1XFSNO0Nn0l9P1WFRNOP1j9o0TFPN0U1m9T20O1O100O100O1O100O100O1O100nNlEoNU:Q1PFQNK7d:h1dEYN[:g1gEXNX:h1gEZNX:f1hE[NW:e1kEZNT:g1lEYNS:g1nEZNP:f1QFZNn9f1QF[No9e1QF[No9e1PF\\NP:d1PF\\NP:d1QF[No9e1PF\\NP:c1RF\\Nn9d1RF[No9e1RFYNo9g1PFXNR:h1oEVNR:j1mEUNU:k1kETNV:l1iETNX:l1iEQNY:o1`000000^ETNh9l1SFYNm9g1VFVNj9j1WFUNi9k1YFQNi9n1i00000000000001O000000000]EVNh9j1XFZNd9f1YFQNA97IGOg9n1jF^NGL\\9f1mF^NFM]9e1mF_NDL`9e1kF`NEJa9f1iFaNEKa9d1jFaNDKc9d1jFbN@Nc9`1mFSOS9m0lFSOU9m0jFUOU9k0kFUOU9k0lFUOS9l0kFUOU9k0^FPN;T1X9l0]FPN8n0HSO090K_8U1cFYN0023l0?_8U1cFYN10T1b0Y8T1cFYNX1d0R8U1QHlNn7T1RHlNn7T1RHlNo7S1RHkNP8T1PHmNo7S1QHlNo7U1PHmNo7S1QHlNn7V1RHkNi7[OnFh1Z1mNh7Z1VHdNk7]1UHbNn7\\1RHdNn7\\1RHbNP8^1PHbNP8^1PHcNn7^1RHbNn7^1RHaNn7`1RH`Nl7b1TH_Nk7a1VH^Nj7a1WH_Ni7a1VH`Nj7a1UH^Nl7b1TH_Nk7a1UH_Nk7AmFi1X1fNk7@nFj1X1hNl7Z1SHhNl7Y1THlNf7T1ZHnNe7TOPGk1[1ROg7m0YHQOj7n0VHTOg7m0YHSOg7m0YHSOh7l0XHSOj7l0VHTOh7n0XHQOj7n0VHROh7P1YHoNh7P1XHoNi7Q1WHnNj7Q1WHnNj7n0iF]N\\18gNOU9[1XHcNgN1Q9]1gHbNX7`1hH`NX7`1hH_NX7a1W21N2M22OO0101NO2000N2O100O1NaD[N_;e1200O1O1001ON21OO11ON2O1N21OO100O10000O100O11O00O100001O", "size": [424, 640]}, "area": 53268.0, "iscrowd": 0, "image_id": 10211, "bbox": [0.0, 0.0, 640.0, 176.0], "category_id": 169, "id": 10012444}, {"segmentation": {"counts": "RoX2884T<`0O11OO1000O2O00dCVOYb0f<000000000000010O000000001O000N20000O10000O10010OZO`Cd0`<\\OaCc0b<000O11O0000000000001O00O1001O00000000001O00O01000000O010001O000010O1N110N100001O001O000O10O11O000000000N10101O000001N02O001N11OO1000O100N200O1O1001O00O1001OO100001O011N1O01OO2O00000000001O00O11N3NO02L31O0000NSOiCn0V<2001OO010000O200O0O2O1UOdCg0`S8BYHOj70^HFe79aH_Ob7`0cHZO_7e0gHTOZ7l0kHnNW7R1nHfNU7Y1PIaNQ7_1UIZNm6e1Z201O00010O1O001O1O010O1O001O1O0010O01O1O0OEcNPE[1k:oNQEP1R;ROkDl0X;?3L5L3M3N2O1O1O101N1O1O001O001O02O000O2O0O1010O1O010O1O010O1O100O2O0O2O0O2O0O2O0O1O2O0O2O1N2O10O01001O0O2NN2N2N3L3N2N7IY[`0Z1\\c_O3L4\\E[ND0X9i1lFbNFG[9k1fFjNJ\\O]9n1aFYO]9Z2M3XLcLbM`3]2cL^M`3a2aL^M`3a2aL]Ma3b2`L\\Mb3c2\\L^Mf3b2ZL\\Mi3b2[LZMX3YM_L]5:WMP3fMeLS5;UMh2SNlLh4PMQ2WO`Mi3?nLk1BeMa3?kLh1KgM[3a0`Ll1n3j5WNQJi1m5^NnIa1P6gNlIW1U5NfJ1U5T4J6J5Y1hN=C=CS1lNe0\\O5K4RLTGX3n8dLTG\\3n8`LTG`3n8]LSGd3n8XLTGh3V9000010O00nLUMgKk2n3lNfJT1V42hKOS48jKHS4=kKCR4c0lK\\OQ4i0mKXOn3o0oKPOo3U1oKkNn3[1oKeNm3a1QL_Nj3b5L4K5L4N1O2O1N2fNSFWOo9e0XFVOj9e0^FVOd9f0cFUO_9k0dFPO^9P1\\1010000O10000O10O10O10000O10000O010O10000O10000O01000O10000O100O01000O100O10000O10O010000O100O10000O010O10000O100O1000O0100O1000O010O010O1O01O010O01O01O010O00010O0010O00010O0B?1N2N2O1N2N2O2M2N100O12N3M3M3M2M4L4K5L4K5L3M1N2O1O10nMVEe1k:SN]Ek1Q;M3[Oe0N2ORGPOf5o0XJTOg5k0ZJVOd5k0\\JVOc5j0^JWO`5i0aJWO^5h0dJWO\\5i0dJXO[5h0eJYO[5e0fJ\\OZ5b0hJ^OX5`0iJBd5N]J3c5M\\J4d5KYJ9h5EVJ>j5AWJ?i5@YJ?h5@YJ?g5@[J?e5@[Jb0d5]O]Jf0P93M4L3O2MPOPDj0n;UOSDn0j;QOVDR1n;3M3N2N2NkNWDm0g;QO]Do0a;oNbDR1\\;mNfDS1i;O010O001O1O0010VDTOS2O\\6m0^GZOn1Nd6h0[G^On0FZO?_8U1SHCn7=mGGU8:WG7j8]1hNjLkIn2[6VM^HCf0W3BoLZ6h0UJ_2TOnLg6c0WJS3h5dLbJ\\3^5fLYI\\Ol0m3k5SMVJk2k5UMUJm1\\OZMa6i0TJh1HTMV6T1SJX1Z7gNgHk0g7SO\\Hf0j7ZOVHd0m7[OTHd0m7[OTHc0o7ROZHn0l7`NdF0e1^1m901N2O00100O010O100O1O1O001O001O001N101O02N2O1N2N2N2O1N2N1O3N2M2N3M4SFoM\\8T2[GQNf8S2jFXNW9l2001N2O1O1fM^Fk0d9PObFn0_9mNhFMMH\\96mFMOFX98oFNV:0mELV:3a1O0O1010000O1001O103L=C16[ObC2l<0oB0e<=M0000N2M4HUCLP=4n[8", "size": [424, 640]}, "area": 55673.0, "iscrowd": 0, "image_id": 10211, "bbox": [0.0, 51.0, 619.0, 372.0], "category_id": 183, "id": 10012448}, {"segmentation": {"counts": "WSf41o>3I5OO2O000001O0001O4Lf\\1:PcN001OO001O[OEgB:P>0YOFhB:V>JSm0;aROb0^O00001O0000001O0000O101N1001O002N0000001O1O0000001O3M2N11N:F3M011NN21OO10000000001O000000000001O0001O0001O0000000000001ONSOQBm0o=30OLROVBn0j=400000000000O10000001O0001O000000000001O00000001O000001O000000000001O00O1O11O0001O00001O01O0O11N101O01O000000000001O00000000000000000102M2N00000000000001O00000000000000001O0000000000000000001O00000000000000001O0O11O000000O2O000O10000O2O0O10000O10001O01O7I1mNVBn0k=QOXBl0n=0O2O0001O00000000000001O0000000001O0001O000000000000000O110O0001O1O001O00O10001O01O00O101OO1000O1N3N1O1001O0000000001O000000000001O00000001O0000000000O10001O000000001N1I7O1DnACY>5=Oc[2L^dM4G9^L", "size": [480, 640]}, "area": 10201.0, "iscrowd": 0, "image_id": 10216, "bbox": [320.0, 71.0, 320.0, 74.0], "category_id": 92, "id": 10012449}, {"segmentation": {"counts": "W1m0U>GnA]OV>b05O001O01O000O01O001O000100_OB_B?Q>0NKiAEW>;7O010O01@E[B;e=E[B;T>010O10000O011N2O1O10KcAF\\>8iAGU>9oAEo=:<00O2O004L1O2N1OQ]10obN001O0Tnf43iQYK0O4K2I7O01O01000O10000000001O000001O000O11OO20O01O0001O01OO1000000000000000000NcAA^>=3O1ObAEY>;60001O1L3Lf]1NgSN0b>2\\ANd>704L1OO]OEcB;]=EcB;]=EcB;]=EcB;T=EaB0;;T=EaB09=V=CaB07?X=AaB15?Z=@aB15?Z=@aB14`0[=@aB0Kh0d=XOaBm0`=RO`Bn0cR;BkD`0V;@gDc0Y;]OdDe0];[OUDR1l;oNRDQ1o;oNQDP1PHiA6b>OlAK]=5cBL\\=3eBNZ=2fBNZ=2fB0X=0hBM[=3eBMQ=O`B5?LQ=1\\B5c0JQ=>nBBR=`0lB@T=b0kB]OU=d0c02N000000001O2N1O000VBWO]=i0cBVO^=h0dBXO\\=g0?O100FmAGS>8;O1000000000000001O2N2N2N4L000PC[Oe;f0XD]Og;d0VD]OQ<=_C@I3k<;\\CCH1n<;ZCEF0R=:lBD220OT=;iBD32OOV=;TCFFNW=On;d0gC^O523LQ1N2O0O2O1]ANK3Q>0oA:R>91O10QBWOf=i0[BWOe=e0^B\\Ob=NO1O0010OWANe>2\\ANc>2^ANb>1VQe0", "size": [480, 640]}, "area": 277.0, "iscrowd": 0, "image_id": 10216, "bbox": [571.0, 37.0, 24.0, 37.0], "category_id": 132, "id": 10012451}, {"segmentation": {"counts": "e6[8d61000000O1000000O10000O10000O10000N2O100O1O100000000O100O10000000000001O000000001OO11OO1001O00O11O00000000O11O00000000O100N2N2000000000000000000000000000000000000001O0000000000000000O1O1N2N20000O10000000000O1N2O100001O000000000000O10000O100O1O100000000CjFPKV9o4kFQKU9n4lFRKT9m4nFQKS9o4nFoJS9Q5oFkJS9T5=0000O1O100000000O11O0000O100O1000000O1004L3M3M2N3M3M2N4L2N3M2N3MlNWGSLg8m3\\GTL`8m3cGPL\\8P4eGSLW8m3mGQLQ8o3PHTLl7l3XHQLg7o3[HSLa7m3cHPL\\7P4eHSLW7m3mHQLQ7o3PITLl6j3ZISLe6l3^IVL^6i3fIULY6i3kIYLQ6f3TJYLi5g3YJZLd5f3_JZL^5f3dJZLZ5g3hJYLU5g3mJYLQ5g3SKYLi4h3XKXLf4h3]KXL`4h3cKWL[4j3fKWLW4i3mKULQ4k3QLWLk3i3YLTLf3l3[LWLa3i3cLUL[3i3hLZLT3f3PMWLo2g3UM[Lg2d3^MYLa2e3bM^LZ2`3lM^LR2a3PNbLl1]3YN`Lf1_3]N`Lb1`3aN^L^1b3dN\\L\\1d3hNXLX1i3iNULW1k3lNRLT1n3nNPLR1P4QOmKo0R4UOkKk0T4VOlKj0T4VOlKj0S4WOmKi0R4XOmKi0R4XOnKh0R4WOoKi0P4XOPLh0o3YOQLg0o3ZOPLf0o3ZOQLg0o3YOQLg0P4XOQLg0o3YOQLg0o3YOPLh0P4XOPLh0P4WOQLi0n3XORLh0n3XORLh0l3ZOTLf0k3[OULe0l3ZOSLg0k3ZOVLf0j3ZOVLf0j3ZOVLf0i3\\OVLd0i3\\OXLd0g3]OXLd0g3]OZLb0f3^OZLb0e3_O[La0d3@[La0d3@\\L`0c3@^L`0b3@^L`0a3A_L?`3B`L>_3CaL=X3aJ^LS59=W3KiL5Y3HhL8X3IgL7Z3HfL8Z3GgL9Z3FfL:[3EeL;\\3DdL<]3CcL=^3BaL?n2]JWMl2FSO5d3m2`JWMc2MWO0f3l2`JXMa2NXONg3l2`JZM^2NZOLh3m2`JXM]21ZOJi3d3lLbL[OIj3f3iLcL\\OGk3h3gLaL^OHj3g3hL`L_OIi3h3gL_L@Hj3k3cL^LCGj3l3bL\\LDIj3k3aL\\LFIi3l3`LZLHJh3n3]LWLMKf3o3[LVL0Ke3o3ZLVL2Je3^3[JhLm1O3Le3]3]JhLh1N8Mc3]3]JiLf1Lo2j2TKmLX1Ig0e0h2e2ZKmLU1HiNHd1Q1R3b2\\KnLS1FmNM\\1Q1V3^2`KmLo0GPONS1X1]3V2bKmLl0FTONc0h1k3g1cKmLf0AjN3a00?j1m3e1dKmLc0H^OL@Z1G`NY5k2aJoLn0=]OV11cNS5k2aJPMn0;]OS14hNP5j2aJPMo0;ZOP1:kNl4k2aJnLQ1000O1ZAO]>1dAO[>1:0[AO[>1;0O0O10000000000000000JN^A2b>9MEaA2i>N100010O000000000000000WlR3", "size": [480, 640]}, "area": 79.0, "iscrowd": 0, "image_id": 10216, "bbox": [395.0, 17.0, 34.0, 18.0], "category_id": 146, "id": 10012453}, {"segmentation": {"counts": "g214h3T;N2O00000O1000000O10O1O02O000O1000OO1010O01O0100O1O10O10O0010000F]LWEc3h:^LXEb3g:`LWEa3i:`LUEb3i:;O1O11O010N11OO1010O00O20O01OO100O011N1O1002N1N101M2N2000000XOPEnL1;o:`2_E_Ma:V2kEiMU:U2oEiMP:R2WFmMi9R2YFmMg9l1aFSN^9i1hFVNW9i1lFVNT9i1nFVNQ9j1PGVNP9g1SGYNn8]1TEcNP2Ol8]1]GcNd8Z1^GfNb8X1d2O2N002N100000^DnNV9R1hFPOW9Q1_FYO`9h0^F[Oa9d0ZFCe9=[FE\\9XOQET1o1[Om8ASET1V2VOg8FQEO0U1Z2TOe8Q1\\GmNe8S1\\GlNd8T1]GkNc8P1cGoN]8P1dGPO\\8o0eGQO[8n0fGQO[8n0gGoN[8P1j2100O100`CoNgNOU1O01OQMMQG3m8OjDLe15a93bD2e06AEW;P1gDLLTO];a2cD_M];b2bD^M^;c2aD]M_;d2`DZMZ;n2fDQM[;P3dDoL];Q3cDmL_;T3_DlLb;T3^DlLb;U3]DkLb;;bD\\2^;cMdD]2\\;aMfD^2Y;bMiD]2W;cMiD^2V;aMlD^2T;bMmD]2S;cMnD]2Q;dMnD[1HUOZ;@oDW1MVOT;DoDR12XOn:HPEm06YOk:JnDl09YOi:KoDj09YOj:NlDh0;ZOh:0nDc0;[Oi:3kDb0fDG;KP;?dDFj;AZDl=DTB2N:F3ITOTBl0Q>1NN21OO10001O000000000000000010O0000000O2I60POWBi0i=VOXBj0h=TOZBl0m=00001ONPBTOP>l030OLoAYOQ>g040000000000000000000001OO2N1N2O10XOoAa0S>]OmAc0X>04L1OO10001O0000000000000000001O01N2N20O0000000000001O01OO0100010N100N2G]OTBd0k=]OoAO3e0o=^OoAc0R>50XOnAb0X>000000000000DlALT>4=N1O1O3N1N`m0OaU53llI2WAMf>Nmn00[QO001O1O1N3M3N2_OKTB7i=HXB:f=E[B=c=B^Ba0_=^ObBc0]=]OcBd0\\=[OeBe0[=[OfBd0[=[OeBe0k=O10000O101O0O100O10000O101O00CBXB?j=BRBe0j=\\ORBe0OYOj=o0UBTOh=R10O1000@lNTCU1n2N1O1O0O2OO100000O02N101N4M2ML4N112kAFb=9_BI^=8aBL\\=4dBL\\=3dBN\\=2dBO[=0fB1Y=OgB3W=LiB6W=IiB7W=IiB7W=HjB8V=HjB7X=GhB9Y=GhB7Y=IhB6Y=HiB7Y=GhB8Y=FdBOC:Z>KeA3[>1cAL]>8cAE]>a011O000000O10000O101O0O2O1O2M3N1O2N1N2OfeZ12lldNS9BnF>P9DPG;P9FoF;P9FPG:o8FRG9i8YOmD`0Y28g8OYG0h80XG0g80ZG0f80YG0g81YGOg80ZG0f80YG0h8OYG1h8NXG2h8NWG2j8OUG1S9ZOdD8Z2=X9BhF>X9BkF;U9ERG3o8LZGLg83S30000O1000000O10002KZ[56^dJ6N2N1O2O1N100000O010O001N1000lLL]G4m7c0SH[Oo7e0PHZOQ8g0nGXOS8i0lGVOV8j0iGUO17Q5e0nJROLe0Q59RKROjMIc1Q1^55TKPOmMN[1Q1b51UKoNPNOR1X1h5KUKmNSN0a0h1V6\\OQKiNgM2b01>l0QOJV7?QKnN[NM;l0C\\Of6m0oJoN]NL;k0IYO`6Q1nJoN_NL8k0_7:kImN_NN5j0d7;hImN_NN4i0g7f6O\\K\\OeM\\2n6lMkKFRMc2S7ZMYL[3g3^LaLm2S4RMPLf2V4WMSH4_3_2c4\\MoGo0f2^1`5aMkGR1g2V1c5fMhGi0R3\\1_5ZNoJb1R5^NlJc1U5^NhJ_1\\5bNaJZ1f5fN^GAU2c1d6mNVGBR2`1l6nNRGBR2\\1P7ROnFBQ2Y1m6]OSGYOP2W1n6CQGVOP2T1S7FbI8b6F]I:d6F]I9d6F]IClL4i98]I@mL9e97^I]OPM>_95bIZORMc0Z92eIWOVMh0R91ZJ1c54YJMe5b0mI_OQ6c0TJXOj5g0^JTO`52]KMa42bKL^44eKI[47gKFZ4:iKCV4>mK_OS4`0PL^Oo3c0W51M9I8O0=\\Ocd4AbZK0bC2]]CA`jB_Of04b<;hBFa0Og<;hBFa0Oh<:gBGa0Oh<:gBGa0Oi<9fBHa00h<2hBIO4b01h<7fBHb01g<6iBI`01f<8jBFa01d<:kBEa01b<MP=0bB3>MQ=OaB4>MQ=OaB4>M[=2fBN]=0bB0S=N^B5?MQ=1^B3?FA6`=3`B1>GB6]=4cBO=1P=0dBO:JE2\\=6eBN:JE2\\=6eBN:2P=1fBM:2h<:mBE:1h<;nBE6NLGP=f0nBE26P=6nBC08T=5lBC07U=6kB6V=JjB5Y=IgB7Z=g03ZOcBCa=9_BGa=9_BGb=8^BHb=8^BHb=8^BHc=7]BIc=M^BIO:g=G\\BOM7l=HWB1M6l=KVBOO4k=NVBNO4j=OWBMO1a=NbB4OLi=a0WB_Oi=a0WB_Oh=b0XB^Oh=b0XB^Oh=b0XB^Oh=c0WB^Oh=b0XB^Oh=b0XB^Oi=a0WB_Ok=?VB@o=;QBEU>5kAK6:T=KfBJ3`0W=EfBI2f0W=AgBGMO3j0[=@dBFN?2N^=C`B27>0Ge=;`B@_=j061O2M201O1O001XBmNa=Y100000000N2M3jBfNfi0]=1O1O1O1001O001O1O001O1O1O1O2N1O001O1OI_OPB`0n=BTBFjA:U>900O1O1O101O000FXO\\Bh0d=ZO[Be0e=\\OZBd0f=OZB^Of=e0[BXOd=k0]BPOe=o06O1000000ARBLo=6QBGP>;PBBQ>OoANO70IS>NQB2L90EZ>3fA9\\>GdA9[>IfA4Z>NeA1[>;O0J^OWB9i=IUB7k=KRB6n=KPB6o=MmA6R><01O0O101O0O11O1N2O1O001^OUBNk=M\\B0Y>1O1O010O0M4H7O20OH^OnA20a0P>9oATOP>m0SBSOi=l0WBUOh=k0YBUOg=k0XBVOh=i0XBXOh=g0XBZOi=d0WBDc=8_BGc=8]BHe=HXB82Oo=0QB0Q>OnA1S>NmA3S>MlA4T>KlA6T>JkA7U>HlA8U>FRm?", "size": [480, 640]}, "area": 17604.0, "iscrowd": 0, "image_id": 10216, "bbox": [0.0, 0.0, 606.0, 326.0], "category_id": 183, "id": 10012455}, {"segmentation": {"counts": "d`72Z>3TB11KX=<]BN7G\\=l0`BVOm3M^5P1`FUOi3KWL9]9o0YJXOf5i0XJYOg5g0XJ^Od5b0[J@d5a0UJEk5;hI1Y60ZI:h6GlHc0U7^ObHi0_7WOmGiNgNK5X2X9UO_GWOXOd1Z9VO]GWOWOe1[9TO^GWOVOf1\\9RO`GXOTOZOO10V2\\9WO`GTOTO^O:V2R9WOaGTO@f1n8UOdGSO@d1o8XOcGRO@c1o8ZObGTO^O`1R9[OaGXOmN_O010o1h9YOYG_1i8aNWG^1j8bNVGR1V9oNhFQ1Y9oNhFo0Y9UOaF`0WO[NY:V1_F=\\O[NU:Z1]F:CVNR:b1jE`N4g1`:IZEbN5d1c:LTEeN6^1g:;WEDj:X21N2O1O1N2O1@jDSMY;m2gDkLa;T36I700M3N2N2O1N2N2O1O1K5O1M3O1O100000000O100O1000000O100O100O100000000O1000000O100000000O1001O0000000000000000000000002N000000O10000000000001O000000000000001O1O00O11O000000000000000000001O00000000000000\\NlC_OCd0`430000NVANj>2Rlc6", "size": [480, 640]}, "area": 12525.0, "iscrowd": 0, "image_id": 10217, "bbox": [16.0, 0.0, 172.0, 184.0], "category_id": 110, "id": 10012456}, {"segmentation": {"counts": "iYQ2410e>601O2N1N2N2O2N0eA]O10U>h000jAYOR>l0O001O1O2N1N2O3N1N4L3M3L1jB]NoHAS:g3\\FdLk9Z3WFcLk9\\3ZF_Lg9`3[F]Lh9\\3Q1C>C=DJlA5W>GnA6`>NlRc8", "size": [480, 640]}, "area": 4582.0, "iscrowd": 0, "image_id": 10217, "bbox": [0.0, 41.0, 53.0, 176.0], "category_id": 132, "id": 10012458}, {"segmentation": {"counts": "i6m1Q=4M002N2O1N3N0O2O0O2N1O2M2O1O2N1N201N1JXMQDl2k;6N2O1N3N1O1N3N1O2N1O110O01O0010L3N2N3I6N2O2CN3N1O1O1N3N1O1N2O2_O]J`Gf5`8ZJXGn5g87H701L3N2N3N1N2N3N1O1K6N1M3O2N1000N2NZHjHf7V71100O2O002N0O100O100O100000000O10O1000O100000000O0101O000000000O100000000000002N000O11N10O1O100001O100O1O001O1O1O0001TKdH\\M0b4\\7PNjHS2S7mMnHS2P7nMRIQ2n6nMSIR2l6mMVIS2i6lMYIT2f6lM\\IS2c6mM]I`M]O10^4U7QNcIP2\\6PNdI`MYO^4R7QNjIn1V6RNjIo1U6QNlIn1T6RNmIn1S6QNoIn1P6RNQJm1o5RNSJm1m5SNVJk1i5VNXJh1h5XN\\Je1c5[N`Jb1`5^NcJ`1]5^NdJiM]Nc3n6dNhJdM`Nd3h6hNRKW1m4iNUKU1k4kNWKT1h4lNYKT1f4lN[KS1e4mN[KT1d4lN]KS1c4mN`KQ1`4mNdKP1\\4POfKo0Z4POgKP1W4QOjKo0U4QOmKm0S4SOmKn0R4ROQLl0n3TOTLk0k3UOVLk0i3UOYLj0f3VO\\Lh0d3XO]Lh0b3XO`Lg0_3YOcLf0[3[OfLd0Z3\\OgLd0X3\\OjLc0U3]OlLc0S3^OnL`0R3@oL`0P3@RMRNeLl1W63UMoMfLn1T63XMkMgLQ2Q64ZMiMfLS2o54]MfMgLU2k55nMJR26oMJP27PNIo17RNIm16UNIk17VNIh17YNIg16ZNKe15[NLd15ZNLf14ZNMe14ZNMe13\\NLd15\\NKc15ZNaMmKZ2h55[N0d10^NNb13_NL_15cNJfKeMd5c2fN1Q11oNMQ15ZNYMnL`2h49WNWMUM]2c4h1AXN`0h1_OXNb0h1]OYNc0h1[OYNe0g1ZOZNg0e1XO[Ni0e1WO[Ni0f1UO[Nl0d1SO\\Nn0d1QO_Nn0`1QO`NP1a1nNaNR1^1mNbNT1^1kNcNV1\\1iNhNU1X1iNiNW1W1hNjNY1U1fNlNZ1T1eNmN[1T1cNmN]1S1bNnN_1Q1`NPO`1P1_NQOa1P1]NPOd1P1[NQOf1n0YNSOg1m0WNUOi1l0UNSOm1m0RNTOn1l0QNUOo1k0PNVOQ2j0lMXOT2h0kMZOT2f0kM[OU2e0jM\\OV2e0hM]OW2c0hM]OZ2b0dMA[2?dMC[2>cMC]23M3M3M3M3N2M4L3M3M3M3N2M3M3M3M3N2M3M3M4L3L4M3M3L4M3M3M3L4M3M3_MoLnHT3P7mLmHX3P7hLoH[3o6fLoH]3o6dLoH_3o6aLPIb3n6_LPId3n6]LoHg3o6YLPIj3n6WLPIl3n6ULPIn3n6RLQIQ4m6PLPIT4n6mKPIW4m6iKRIZ4l6gKRI\\4l6gKoH]4o6hKkH[4S7kKfHX4X7mKbHV4\\7oK]HU4a7f1O0000001O000000001O0001O000001O000000001O000000001O01O00000001O000000001O00000000010O000001O01O0001O0001OO2N1O1O1O2N1O1O1O1O2N1O1O1O2O0O1O1O2N1O1O1O2N1O1O1O1O2N1O1O1O2N1O1O1O2O0O1O1O2N1O1O1O1O2N1O1O1O2N1O1O1O2N1O1O101N1O1O1O2N1O1O1O2N1O1O1O2N1O1O1O2N1O1O1O2O0O1O1O2N1O1O1O2N1O1O1O2N1O1O1O2N1O1N2O2N1O1O1N3N1O1O1O2N1N2O1O2N001N2O1O1O1O1N2O001O1O1N2O1O1O1OfMgMnGX2a7\\N^Hc1P7QOoHn0n6WOQIh0n6[OQId0n6_OQI?o6EoH:P7IoH6P7MnH3Q70nHOP75oHJP79oHEQ7>nHAQ7b0nH]OQ7f0nHYOQ7j0mHVOR7m0mHQOS7R1lHmNS7V1lHiNS7[1kHdNT7_1kH`NT7c1kH[NU7h1jHWNU7l1iHTNU7P2jHoMU7T2jHkMU7X2jHfMV7]2iHbMV7a2iH^MV7e2iHZMV7i2iHVMV7n2gHQMY7R3fHmLY7V3fHiLZ7Y3eHfL\\7[3cHdL^7]3aHaLa7`3^H_Lc7b3\\H]Ld7e3ZH[Lg7e3YHZLh7g3WHXLj7h3VHVLl7j3THULm7k3SHTLm7n3SHPLn7P4RHoKo7Q4RHlKP8T4PHkKQ8U4PHiKQ8X4nGgKR8Z4nGeKS8[4nGbKT8^4lGaKU8`4kG^KW8a4iG^KX8b4iG\\KX8d4hGZKZ8g4fGWK[8i4eGVK\\8j4dGUK]8k4l010O000001O0000010O0000001O0001O01O0000001O01O0001O0000000010O000001O0000010O0000010O0000010O0000010O0001O01O0001O01O0001O01O0001O0001O01O0001O01O00010O0000010O0000010O1O1O100O1O2N100O1O1O100O1O1O100O1O1O100O1O1O1O1N2O1N2O2M2O1N2O1O1N2O1N2O1N2O1N2O1O1N2O1N2O1N2O4K7J6I8lNaM", "size": [480, 640]}, "area": 65157.0, "iscrowd": 0, "image_id": 10217, "bbox": [212.0, 17.0, 428.0, 385.0], "category_id": 183, "id": 10012461}, {"segmentation": {"counts": "0ekY11YcfN3M3M4L3M3N2M4L3M3M4L3M3M3N3L3M3M4L3hCdNg:_1jDQO\\2ZOa5h1dG_Ob2SOd5S3TJVMg5n2RJ[Mi5h2oIaMl5c2lIgMn5]2jIlMQ6X2gIRNS6S2eIUNV6o1bI[NX6i1`I`N[6d1]IaNc6n4O1O1O1O1O1O1O1O100O1O1O1O1O1O1O100O1O1O1OM3G9F:G:G8M4M20100O1O100O1O010O1O100O1O10O01O100O100000O100000O100000O100000000000O010000000000O1000O10000000O10000000O2O001O001O00001O001N101O001O001O001O0O110O00ZJbIk2]6UMdIj2\\6VMeIj2Z6VMhIh2X6XMiIh2W6WMkIg2U6YMlIg2S6YMmIg2S6YMnIf2R6ZMoIf2P6ZMPJf2Q6YMPJg2o5YMQJg2o5YMRJf2n5[MQJe2o5[MQJf2n5ZMSJe2m5[MSJe2n5ZMSJe2m5[MSJe2m5\\MRJe2m5[MTJd2l5\\MTJd2l5\\MUJc2l5]MSJd2l5\\MTJd2l5\\MUJc2k5]MVJb2j5^MWJa2i5`MVJ`2j5`MWJ_2j5`MXJ^2h5bMZJ[2g5fMYJY2g5gMZJX2f5hMZJX2g5gMYJX2i5hMWJW2j5hMVJX2k5gMUJY2l5gMTJW2n5hMRJX2n5hMSJW2n5hMRJX2o5hMPJW2R6hMoIW2R6hMnIX2S6gMmIY2T6gMlIW2V6hMjIX2V6hMjIX2W6hMiIV2Y6iMgIW2Z6hMfIX2[6hMeIW2\\6hMdIW2^6hMbIX2_6hMaIW2`6hM`IX2`6hM`IW2b6hM_IW2b6iM]IW2d6hM\\IX2e6gM\\IW2f6iMYIW2h6hMXIX2i6gMXIX2h6iMWIW2X4nKUMj1cNX2W4SLSMd1gNX2U4XLRM`1hNX2V4[LPM\\1kNX2T4`LoLW1mNY2S4eLmLR1oNY2S4iLlLm0ROY2Q4nLjLi0UOY2P4SMhLd0WOY2Q4UMgLa0XOZ2P4XMgL=ZOZ2n3[MhL;YOZ2n3^MhL7ZO[2m3`MiL4ZO\\2l3cMiL1[O[2l3eMiLO[O\\2k3gMjLL[O]2j3jMkLHZO^2j3lMmLDYO`2i3oMnL_OZOa2h3QNnL^OYOa2h3TNoLYOYOc2g3VNQMUOXOe2f3XNSMROWOe2e3\\NSMnNXOf2d3^NUMjNWOh2d3`NUMgNVOi2d3bNWMcNUOk2c3eNXM^NVOl2a3hNYM[NVOm2`3jN[MXNTOn2`3mN\\MSNTOP3`3nN]MPNTOQ3^3RO]MlMUOR3]3TO_MiMSOS3]3WO`MdM[NYO`0l3d3YObM`MZN[O`0l3d3ZOcM]MYN]Oa0k3b3^OcMZMYN]Ob0k3a3@dMWMYN^Ob0k3`3CdMSMZN@a0j3`3EeMPMYNBb0i3_3HeMlLZNCc0h3^3JeMkLYNCd0h3]3LfMhLYNDd0h3\\3OfMdLYNGd0f3\\31gMiLnNU3Z35gMeLoNV3Y37hMbLoNW3Y39hM^LoNY3X3;iM\\LnNY3X3>iMXLPOZ3U3`0kMULPO[3T3b0lMRLPO\\3T3d0kMPLPO\\3T3f0lMmKPO]3S3i0lMiKRO]3Q3l0kMiKSO[3Q3o0jMfKUO[3P3Q1iMeKWOZ3P3R1gMfKXOX3P3U1eMdK\\OV3n2X1dMcK^Of2BmL[3m4cM`K@d2]3n1QM`KA_2`3T2lL^KD[2c3X2gL^KGV2d3^2cL]KIR2f3d2_L[KJn1i3i2[LZKLj1k3o2VLXKOf1n3S3QLXK1b1Q4X3kKWK5]1S4]3gKWK5Y1X4`3aKXK7U1[4e3[KWK:R1]4h3WKWK3M3M4L3M3N2M4L3M3M4L3M3M3N3L3M3M4L3hCdNg:_1jDQO\\2ZOa5h1dG_Ob2SOd5S3TJVMg5n2RJ[Mi5h2oIaMl5c2lIgMn5]2jIlMQ6X2gIRNS6S2eIUNV6o1bI[NX6i1`I`N[6d1]IaNc6n4O1O1O1O1O1O1O1O100O1O1O1O1O1O1O100O1O1O1OG9G9F:G:F910O00100O1O100O1O010O1O100O100O00100O1000000O01000000000000O10O1000000000O100000O1000O1000000000000O0100000001O001O001N10001O001O001O001N101O001O00001O00ZJcIj2]6UMdIj2\\6VMeIj2Z6VMhIh2X6XMiIh2V6XMlIf2T6ZMmIf2S6YMmIg2S6YMnIf2R6ZMnIg2Q6YMPJf2P6ZMPJg2o5YMRJf2n5ZMRJf2o5ZMQJe2o5[MQJf2n5ZMRJf2n5ZMSJe2m5[MSJe2m5[MTJd2m5\\MRJe2m5[MSJe2m5[MTJd2l5\\MTJd2l5]MTJc2k5]MUJc2k5]MVJb2k5]MVJb2j5^MVJb2j5_MVJ`2j5`MWJ_2i5aMYJ]2g5cM[JZ2g5fMYJY2g5gMYJY2g5gMZJX2g5gMYJX2i5hMVJX2k5gMVJX2k5gMUJY2l5gMSJX2n5hMSJW2n5hMRJX2o5gMRJX2o5hMPJW2R6hMnIX2S6gMnIX2S6gMmIY2T6gMkIX2V6hMkIW2V6hMjIX2W6hMhIW2Z6hMgIW2Z6hMfIX2[6hMdIX2]6gMdIW2^6hMbIX2_6hM`IX2`6hMaIW2`6hM`IW2b6iM]IW2d6hM]IW2d6hM\\IX2e6gM[IX2g6hMYIW2h6hMXIX2h6hMXIX2X4kKVMm1bNW2W4PLUMh1dNX2V4ULSMb1gNY2U4YLRM^1iNX2U4]LPMZ1kNY2T4bLnLT1nNZ2S4fLmLP1POY2R4kLkLl0SOY2Q4PMiLf0VOZ2P4TMhLb0XOY2P4WMgL?YOZ2o3YMhLm0`4m3PKWK`0k0a4o3nJWK`0i0d4Q4iJWKd0f0d4Z5\\KeJe4[5[KdJg4\\5XKcJi4]5WKbJj4^5VKaJl4^5TKbJl4^5TKaJm4`5RK_Jo4a5QK^JQ5a5oJ^JR5b5oJ\\JS2bN5R7hM[JS2fN4o6hMZJT2iN3m6iMZJS2lN2j6kMYJR2QO1f6mMXJR2TO1d6lMWJS2XOOa6nMVJR2]ON]6PNUJR2AMY6PNVJR2DMV6QNVJQ2GLT6RNTJQ2LLo5SNTJQ20Jl5UNSJP24Ji5VNRJo19Ie5XNQJo1=Hb5XNQJn1`0I_5YNQJl1c0J\\5ZNQJk1d0LZ5YNRJg1i0OU5ZNQJd1o01P5[NQJ`1T14l4[NPJ\\1Y1:f4ZNQJX1^1=a4[NQJT1c1`0\\4\\NQJS1e1a0Y4\\NRJR1f1b0X4]NPJP1k1b0U4^NPJo0m1c0R4^NQJn0o1c0P4_NQJl0Q2e0n3_NQJk0S2e0l3`NQJi0V2g0h3`NRJh0X2g0f3aNQJh0Z2g0e3aNQJf0]2i0a3`NSJf0^2i0_3aNSJe0`2i0]3aNTJd0a2k0[3aNTJc0c2l0X3`NVJc0d2l0V3aNUJc0g2k0T3_NXJe0e2m0R3[N\\Jh0c2l0Q3YN_Jj0a2m0_4SObKm0]4ROdKn0\\4ROeKm0Z4TOfKl0Z4SOgKn0X4ROiKm0W4ROjKn0V4ROkKm0U4ROlKn0T4ROlKm0T4SOnKk0T4TOlKk0U4TOmKj0U4UOkKj0V4UOkKj0W4UOjKi0W4VOjKj0W4UOjKi0W4VOjKi0X4VOiKh0X4WOiKh0Y4WOgKh0Z4WOhKg0Z4XOfKg0[4YOfKe0\\4YOeKg0[4YOdKg0^4WOaKj0a4UO^Kk0d4SO[Kn0g4QOWKP1k4nNUKR1m4mNRKS1P5kNQKU1]9O1O1O1O001O1O100O1O001O1O1O10000O010O100O100O10O10O100O100O01000O100O100O010O10000O100O010O100O100O100O101N1O101N100O2O0O100O2O0O101N100Ogkc1", "size": [480, 640]}, "area": 74104.0, "iscrowd": 0, "image_id": 10219, "bbox": [89.0, 15.0, 440.0, 451.0], "category_id": 183, "id": 10012463}, {"segmentation": {"counts": "0cQa06_n^OLk9>J6J6K5M3O1N2O1N2O100L4M3N2N2M3ZNXNbJm1T5ZN^II32l0R2P5oMQJa00G;Z2a5iN[JX1e5kNXJV1f5oNWJP1`5\\McJ^4]590001O00000000001ON22N1O0000001O0000O1O11O00001O1bJSKZ5Q5O1mJVKa4j4_KWK`4j4\\KYKd4h4\\KWKd4k4ZKVKe4Y5000O1001OO11OM31O2N1O000000000000004Le0[O1O00b0^O001O00000000000000001O001TMkH^2U7bMkHg1;XNX74jH0BCf\\<1cmC1K52NO1O100N2N2O1FDcF0000O100O100000000001OO1O1O1M3O1O100O1O1O1O1000000000000000000O1O11O1OJ6M3O12NO1O1O1000000O11OO1L4K5O1O100000000001O000000001O1O0000000000000000000000001O0000O1M3O1O1O1FmJYKT5f4nJUKM0V5j4:O100O11O00001O1O2`JUKZ5Q5N1O1O2N1O1O1O2N1O001O001O001O1O001O001O1O1O001O1O001O001O0000000000000000000000000000M^K[Jb4e533M0000000000000000000000000000O1O100000000000000000000002N3M4L1OO100000000000000000000O100O100O100O100O10000000000000000000000000000000000000000", "size": [333, 500]}, "area": 70259.0, "iscrowd": 0, "image_id": 10222, "bbox": [0.0, 0.0, 500.0, 333.0], "category_id": 96, "id": 10012464}, {"segmentation": {"counts": "cQa062Lk9>J6J6K5M3O1N2O1N2O100L4M3N2N2M3ZNXNbJm1T5ZN^II32l0R2P5oMQJa00G;Z2a5iN[JX1e5kNXJV1f5oNWJP1`5\\McJ^4]590001O00000000001ON22N1O0000001O0000O1O11O00001O1bJSKZ5Q5O1mJVKa4j4_KWK`4j4\\KYKd4h4\\KWKd4k4ZKVKe4Y5000O1001OO11OM31O2N1O000000000000004Le0[O1O00b0^O001O00000000000000001O001TMkH^2U7bMkHg1;XNX74jH0BCQg54UcJ2O0O2O0MHPF:f0F_8>aGDi3N2`0dKC56?J^1NjNO`3a0aKF55OKMIN3X22`NKWO2l3NTL16W1NVO16b0H]O6NM82`3h1[L^N5YOFl2i3f3O1L400MYI`La00@:d5U3mJdL^O9\\1DE:f1U3kMTMh0@\\Oc2ZOYMb0`31SMe0C\\Ok2H?8SMA^Oi07Ei2I?9TM\\OAj05AGDR3=8=bMAVON81S3MKe0fMZOYO043S3N2<`M_O[O0EN<5W30M=fN@^14M:^2GcM8]2HgM4W2NjM0U22mLHoM6S53nL1fMKR5HfJQKH5YOFl2S5\\20nJmJj4\\5OO1F:0hKPKO:f1e4[NTKDc2ZOYMb0P5>VKDk2HP2b0WKEi2IR2?WKAGDR3;S20mJN81S3Jk12oJ043c8I]G0EN<5j9MWf2NhYM500O2oIe0dMYOY14R1h2fN\\MROI3P4HVL33Nm5ORJ3P6\\NWJb0]O`1[6mMYJd0[Ok1l6UNTI]3Z5cLfJn4i3RKWL`6W2aIhMn6i1RIXNm6h1SIXNm6h1SIXNm6h1TIWNl6i1TIWNl6i1TIWNl6i1l00008H1O1O002Ng0YOUo2ZO`QM1O00100O010O10O10000O1000001OmXa2", "size": [333, 500]}, "area": 4124.0, "iscrowd": 0, "image_id": 10222, "bbox": [167.0, 20.0, 83.0, 313.0], "category_id": 132, "id": 10012467}, {"segmentation": {"counts": "^Vn14Y::F00001O000000J6O1O100001ojo2", "size": [333, 500]}, "area": 152.0, "iscrowd": 0, "image_id": 10222, "bbox": [191.0, 91.0, 14.0, 15.0], "category_id": 157, "id": 10012468}, {"segmentation": {"counts": "g[R2S1Z9a1_Nb1^Na1_Nb1^N?BO0000000O100000000000000000000000000000O10000O10000O10000O10000O10000O1000000000000000000001O00001O1O1O001O1TI`Mi5`2QJgMn5Z2kImMT6T2eISNY6R3O1O1O0bJTL[4m3^KZLa4g3YK_Lf4b3SKeLl4\\3mJlLQ5Y4O1O1O1O1O1O1O1]Oc0VOj0VOj0VOj0VOk0TOg`T2", "size": [333, 500]}, "area": 18367.0, "iscrowd": 0, "image_id": 10222, "bbox": [204.0, 22.0, 85.0, 253.0], "category_id": 183, "id": 10012469}, {"segmentation": {"counts": "j6U1k=O1000O1001O000000O1001N01O2O01]OVBMl=2WBLh=3]BFHKk=F`A;`>22NMEaA;`>2100OO02N11N2O1N2O002N1N11N1N110O100000000O1000O1O1N2L5L4M3O1<^OXUm6A[kRI3N001N2N1M4M3L3N2N21N100O11O00O11OO10001O000000001004K6I2O01O0000O100001O00000000000000N20OO200000000000000000000000000001O1O001O0000000O10000000O1O100O11O000000000000K5002N3M000DRBFn=9UBEk=;VBDj=NVB1Y>MR_6", "size": [480, 640]}, "area": 3797.0, "iscrowd": 0, "image_id": 10229, "bbox": [0.0, 103.0, 626.0, 152.0], "category_id": 96, "id": 10012470}, {"segmentation": {"counts": "\\g71o>3L5\\AHU>c002M1O11O000000001O00O0020N2O1O1O002N1O00O1N200O100000000O100000000001O1O1BRRa8", "size": [480, 640]}, "area": 784.0, "iscrowd": 0, "image_id": 10229, "bbox": [16.0, 230.0, 41.0, 24.0], "category_id": 119, "id": 10012471}, {"segmentation": {"counts": "0i3W;0000O11O0000000000N2O1O1O1O100O10000O100000000001O001O00000000001O002N2N1O2N001O001O1O1OO1O10000000000O1L4O1O1O1N2001O1O00JhDcLY;]3gDbLZ;_3300O100O1000000000000001O1O00000000O100O10000O11O00000000O1001O00000000O10000001O000000O1000000O1000000000000000000000000001O000000O100000000O11O001O001O0000O100O10000000000001O00000000000000O11ON2M3N2O1O1O1N2O1O1O1O1O1O1O1N2O1O1O1O1O1O1O1O100000000O10000000000000000000000000000O1000000O10000O100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000O100000000000000000000000000000000O1000000001O000000000000000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000001O000000000?fMmBi1d>WN_A0N2c_6c0enIV1QBYNY1O0O11O01ON2002N0N3N001O1O101oAROm=R1OO11N10O100O1O1N30O010O00O11ON2100O02K5O0M4N010O010O1O1OO1O2OO11O00000O0M5N2N1O2M20N31OO00JUOVBk0k=UOTBl0m=210O2O0O10O12N0000000001N2O0001O000O100O10000ONXBnNi=Q1VBPOj=P1300000OO22OO0001OO10OM44L1O01O0004L6I01O1000O1000O100000000O100000000O101O00000O010000000O011O001O001N1000O01N1O2N2N2N2N2N2N3M2M3FaA1a>N9O100O1O00e]g3=_SXLB^>o1bATN0NgoBAQ==RCBn<;UCEj<:XCFh<8ZCHe<:YCGf<:ZCFe<;ZCFg<9ZCFh<8XCHh<8WCIi<7XCHh<8WCIh<8XCHh<8XCHh<9WCGi<9WCGi<9WCGf<\\CBc<`0]C_Obm03M3L3N6I6DSh\\8", "size": [480, 640]}, "area": 4527.0, "iscrowd": 0, "image_id": 10229, "bbox": [0.0, 253.0, 66.0, 85.0], "category_id": 172, "id": 10012476}, {"segmentation": {"counts": "UQj0d0g=i0H7fNnN[D[1a;V1K4M4K5L3L8gEgL]8_3nFTMm8c4M4K4M4K4M4K5L3M4K4M1N100O100O100O100O100O1N2N2N1O2N2N2N2N2N2N3M2N20O0100O1O100O100O1O100000000O100000000O100000000O10O1O1N20O1000O1O1N101N2N2M3K5K4L5K5K4L3L42N2N2N2N2N2N2N2M3FiHiHY7V79O100O1O1O1O1N2M3N2O1O1O1N2O1O2N1O1O1O1O1N2O3M2N1O1O2N1O2N10001O001N10001O00001O001O0000JSJZGl5f8VJXGj5h8XJVGh5j8YJVGf5k863N1O2N1N2O2N1N2O001O1O001O3M2N3M1O0000000000O1000000000000000000O10000000000000000O10000000000000000O100000O100000M3L4O10000O10000O10000O100O01000O10000O10000O10000O1000000O10O10O1O10001N100O10000000000000000O1000000000000000000O100000000000000000000000O10000000001O000000000000009G0000000000000000000000000000000000M3L4M30000000000000000000000001O000000000000000000000001O00000000000000000001O001O3M3M3M3M3M8H8I7H9G4L0000000000000000000000000000000001O0000001O0000001O00001O00001O0000001O00001O00001O00001O0000001O00001O00001O000N3I7H8I6I8I6I8I7H8I7H8L4O100O1000000O10O100000O=E2M2O1600O101O01ON2O100O1KSOVBn0Q>N2M4JkXj0BagUO8H5K4L5K4L5J5El0Ia<3`CLb<2^CNb<2^CNd<0[C1e_=o00001O0000iNfBh0Z=WOkBe0U=ZOnBd0S=[OmBe0S=XOPCh0P=XOPCh0P=XOPCh0P=XOPCh0P=YO_B39d0X=e0O00000000000000000O1010O0jNbBj0^=WOcBg0]=YOjB`0V=ZOdBL7j0U=ZOPCf0P=ZOPCg0P=YObBL:k0W=VO`BO9j0W=VObB0O4Nf0h=<6I1O0000L4001OUOSOcCm0YQ1[<_OVC@=S1Yf52oK0Z4@QJ>g52mK1Z4OI0mK0[40H0mK1\\4MG2mK1Z4OI1lKN^40E4lKL^41F4kKK_41F4kKK_41F4kKK_4APJ>f56kKL`4NCF_J8_14_4NEB`J<[14`4NMMdK5^4ONLcK5^41LMfK2^41OJcK6]4_OSJ>m5McK6`4MG3iK0_4NH2iK0a4LF4jKO_4NH2iK0_4NG2kK0^4NG2kK0^4NG2lKO]4OG2mKN\\40F3nKM\\40F3nKM]4OE4nKM]4OJOgKD]N>R6OKNfKE]N>Q60LMeKF^N=S6NJOeK5a4MH0hK2`4ND4lK_O]N=S60D4nKL_4OC5nKL^40D4nKM^4ND5nKM^4ND5nKN]4ME5nKN]4ME5nKN\\4NF4mKN_4MF3kKO`4NC5mKM`4NC5nKL_4OC5nKM]4OE4mKN^4NE4mKN`4LD5lKN`4NC5mKMa4MB6lKNb4LB6mKN`4LC6nKM^4ND5nKM^4ND5nKM^4ND5mKN_4MD5mKM`4NC5mKN_4MD5mKO\\4NH1nKO[40G1nKO[40G1nKOZ41H0nKOZ41H0nKOZ41H0nKOZ41H0nKOZ41H0nKOZ41H1mKN\\40G2mKN\\40G2mKN\\40G2mKN]4OF3mKN]4OF3mKN]4OF3mKN^4NE4mKN^4NE4mKN\\40G2mKN\\40G0oK0Z40GKTL5U40GFYL:P40n10RN0n10RN0n10SNOm11SNOm11SNOm11SNOm11SNOm11SNOm11SNOm11SNOm11SNOm11TNNl12TNNl12SNOm11SNOm11RN0n10QN1o1OQN1P2NPN2P2NQN1n10RN0o1OQN1o1ORN0n10QN1o1ORN0n11QNOn11SNOm11RN0o1OQN1n10SNOm11SNOm11TNNm11RN0n10QN1o1OQN1o1OQN1o1OQN1o1OQN1o1OQN1o1NRN2n1NRN2n1OQN1o1OQN1o1OoM3Q2MQN1o1OQN1o1OQN1o1OQN1o1OQN1o1OQN1k1BUH>P60k1BUH>P60k13UNMk14TNLl14UNKk15UNKl14TNLl14UNKk15UNKk15TNLl14SNMn12RNNn12SNMm13TNLJDSLa0S4KGHVL;T4MDKVL:U4KDMVL7W4LAOYL4V4M_O3_JAh1>X40C5SLJZ41IOmK0Y42NKhK3Y431HfK5Y432GeK6Y432GeK6Z42@DlJ4Z16[41_OGjJ2\\16Z42@LdJLb16Z42@9VLEZ42@9VLEZ42A8ULFZ42I0mKNZ42E5oKK[4AQJ=f56nKK\\4BPJ=g55mKL[4CQJR6Y6aKYI]N>Q6Z6aKYI^N=S6X6_KjIa4W6`KhI`4X6`KYI]N=S6Z6bKfI_4Y6aKgI^4Z6bKgI^4X6bKhI^4X6bKiI]4W6cKiI]4W6cKiI\\4X6cKhI_4W6aKhI`4X6`KhI`4X6aKgI_4Y6aKhI]4Y6bKhI^4X6bKhI`4V6`KiI`4X6`KhIa4W6^KjIb4V6_KjI`4V6aKiI^4X6bKhI^4X6bKhI^4X6aKiI_4W6aKhI`4X6`KiI_4W6aKjI\\4W6fKgI[4Y6eKgI[4Y6eKgIZ4Z6fKfIZ4Z6fKfIZ4Z6fKfIZ4Z6fKfIZ4Z6fKfIZ4[6eKeI\\4Z6dKfI\\4Z6dKfI\\4Z6dKfI]4Y6cKgI]4Y6cKgI]4Y6cKgI^4X6bKhI^4X6bKhI\\4Z6dKfI\\4X6fKhIZ4S6kKmIU4n5PLRJP4i5ULWJk3i5ULWJk3i5ULWJl3h5TLXJl3h5TLXJl3h5TLXJl3h5TLXJl3h5TLXJl3h5TLXJl3h5TLXJl3h5TLXJl3h5TLXJm3h5RLXJn3h5RLXJm3i5SLWJm3i5SLWJl3k5SLUJl3P6PLPJP4P6QLoIo3n5TLRJm3Q6nKPJR4o5PLPJP4l5TLTJm3k5SLUJl3k5ULUJl3k5SLVJl3i5TLWJm3i5SLWJl3j5ULUJk3k5TLVJm3i5SLWJm3i5SLWJn3h5SLWJl3j5TLVJk3k5ULUJk3k5ULUJk3k5ULUJk3k5ULUJk3k5ULUJk3k5ULTJl3l5TLTJl3l5TLUJk3k5ULUJk3k5ULUJi3m5WLSJk3k5ULUJk3k5ULUJk3k5ULUJk3k5ULUJk3k5ULUJk3k5QLhIoM>P6j5QLhIoM>P6j5QLYJo3g5QLZJn3g5QLYJP4f5PLZJP4f5QLYJo3g5PJkIk1>V4l5jKTJV4m5iKSJV4n5jKRJU4l5oKSJQ4l5PLTJQ4k5oKUJR4j5mKWJS4j5mKTJT4m5jKUJU4l5jKSJW4m5jKRJV4P6nIaIh1>X4Y6fKfIZ4Z6fKfIY4\\6fKdIY4]6gKcIY4]6gKcIY4]6gKcIZ4\\6fKdI[4[6eKeIZ4\\6fKdIZ4\\6fKdIZ4\\6fKdIZ4\\6fKdIZ4\\6fKdIZ4]6dKeI[4AQJh6d1fI\\4BPJh6d1fI[4CQJg6d1fI[4BRJh6c1fI^4Z6bKfI^4Z6cKeI]4[6bKfI^4Z6bKfI_4Y6aKgI_4Y6aKgI_4Y6aKgI_4Y6aKgI_4Y6aKhI^4X6cKgI]4Y6cKgI\\4Z6cKgI]4Y6cKgI_4W6aKhI`4X6`KhI_4Y6bKfI_4Y6aKgIb4V6^KjIe4EfIN0Z6e1SJk4m5UKSJk4m5UKSJk4m5UKSJk4m5UKSJk4m5UKSJk4m5UKSJk4m5UKSJk4m5UKSJk4m5TKTJl4l5UKSJk4n5TKRJl4n5SKSJm4l5UKSJk4m5UKSJk4n5UKQJk4o5UKQJk4X6lJhIT5Y6kJgIU5[6jJdIV5^6hJcIW5_6gJaIY5a6eJ_I[5c6cJ]I]5e6aJ[I_5g6_JYIa5h6^JXIb5j6\\JVId5l6ZJTIf5n6XJRIh5P7VJPIj5R7TJmHm5W7oIiHQ6\\7jIdHV6a7eI_H[6f7`IZH`6S8oMgG[MZ8T2]HeMc7k1SIoMR7\\1dI^Na6m0VJlNo5?gJ[O^50XKJm4AiK9f9I6JP?0[mh1OgcVN010Q?000o@0O001M2O2M2O2M2ZBFc<=WCGH2X<8jCKN8m;OoCM42M011N2O1N100O1O100O1O101N1O1O1O1O100O11O1O1O1O1O1O001O1N10100O001O00001O01O3M01M200002N1O1aAGU>:hAHX>9gAHX>`03\\OdA>]>AcA=_>CaAa0[>_OeA;a>E_A:b>F^A210f>0PPd0", "size": [480, 640]}, "area": 656.0, "iscrowd": 0, "image_id": 10230, "bbox": [540.0, 146.0, 57.0, 37.0], "category_id": 166, "id": 10012482}, {"segmentation": {"counts": "m1g2[TCCgHhA10610\\>JdA203^>KaA124]>JhA5b>01N2O0O11O01OQj2OlUM7NO00003NN1O12O0OO100O2N1M3010O00N201O0O402L4L4L4K5K5J9G1N2N200000O020O3M2N1OO11OO2N10ON3L4004L1O1O1O002N3MO11ON2M300002NdBaNY=]1gBcNX=^1hBbNV=e101N100NVNnBj1R=21OM300O11O1O1O1O000K6O1O1O002NO100O11O2NJaNhB00_1X=aNhB00_1U=aNkB30\\1U=9N22NO2O02ZNlB\\1W=aNiB_1V=aNkB_1T=aNlB`1S=_NoBa1W=`NeB\\1[=cNgB^1\\=cNbBZ1]=fNeBY1[=eNgB[1^=100O1O10000M3M3I\\NRCd1m<]NRCd1o<[NoBg1k3E90O11215GjV4L[iK0M=F10O2N0DdPn05^oQO32N24OET]`03]T_OOW>3hANX>6cAK]>94HbAJbV42TXL9I5M10N2N2O1NZ[`0Kgd_O=gNA\\Ch0Yg0W5_5cJlJV5U5dJXKT5a7I8H7I8H7I8H4EjDdLX;^35N2N2O2M2N2N2N1O2N101N2N1O2N2N2O0O1O1O2M2N2N4L6I4M3L3N3L2N3L6I8_Od0[OncW1O^\\hN2N3O1O100003M2N2N`f;5ZYD5K2O0M4O0000AdA:h>IlR6LYmI1N7CJaA7_>5004LMG`A8_>JaANc>637I02N1M3I7N2OTj25cUM5M2O100O1N21O0O4M2Leh?", "size": [480, 640]}, "area": 60272.0, "iscrowd": 0, "image_id": 10230, "bbox": [23.0, 74.0, 583.0, 406.0], "category_id": 183, "id": 10012484}, {"segmentation": {"counts": "0f3e9WMVH1j7TOQIl0o6TORIk0n6UORIk0n6UORIk0n6UOSIj0m6VOSIj0m6VOTIi0l6WOTIi0l6WOTIi0l6WOUIh0k6XOUIi0j6WOVIi0j6WOWIh0i6XOWIh0i6XOXIg0h6YOXIf0i6ZOWIf0i6ZOXIe0h6[OXIe0h6[OXIe0h6[OXIe0h6[OXIe0h6[OWIf0i6ZOWIf0i6ZOWIf0i6ZOVIg0j6YOVId0m6\\OSI`0Q7@nH=V7CjH1XM4Q:KmH0W70R3000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O2N0000000000000000000000000000000000000000000000000000000000000000000000000000000GL[C4e<2UCNl<800000000001O000000000000000000000000000000000000000000001O000O10000000000000000000000000000000000000001O000000000000000000000000000000GMZC3n<16J000000]K0kK0U48cKH]4?\\KAc4g0VKYOj4h0UKXOk4h0UKXOj4i0VKWOj4i0VKWOj4k0TKUOk4l0UKTOg4o0ZKQOh4>gKB^40kK0h8000lN0mD0V;4cDLa;7XDIk;n<2M3M3N2M2N3M3M3M3N0O2N1O2N2O0O2N10O0O1002O1N2N2N1O2O1N1O2N1O2N010O0000O100000000O100000000O10O1N3N2N2O1O000000O10N21OO1000000000O1000011N2N0000000000O100000000O11OO1kDmMS;Y2lDhMl:c2I01O1O001O0000000O20OO10010O0lMVEf1k:UNUEL1P2i:QN_En1c:oM^EQ2o:O000000001O0000000002O1M4N1NNnDnMP;m19O2N1000000000000000000001O0101N1O000000O100000O2O000001O002N100O100001N02OO01M2O101O001O2N4LN2N20001O000000010O0001O01O01O2N4L3M3M002NK5O1O2N1001O01O0000010O01O1O001O1O1O100O1O001O00100O002eM", "size": [427, 640]}, "area": 14108.0, "iscrowd": 0, "image_id": 10232, "bbox": [425.0, 31.0, 215.0, 129.0], "category_id": 132, "id": 10012486}, {"segmentation": {"counts": "WjT61Z=000M30000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000CKdC5]001O1O00O11O0000000000000000005@TC7U=K]ch0", "size": [427, 640]}, "area": 795.0, "iscrowd": 0, "image_id": 10232, "bbox": [471.0, 407.0, 109.0, 20.0], "category_id": 167, "id": 10012487}, {"segmentation": {"counts": "X>k1e:k00001O001O00001O00001O00001O001O00001O00O100O1000^FWMb8h2[G^Mc8b2YGcMf8]2VGiMh8V2UGoMj8Q2SGTNk8l1QGYNn8f1QG^Nm8a1SGaNl8^1UGcNj8]1UGfNi8Y1WGiNh8V1XGmNf8R1[GoNd8Q1[GROc8m0]GUOb8j0^GYO`8f0aG[O^8e0aG]O^8b0bGA\\8>dGD[8;fGGX88hGJW86hGMV82jG0U8OlG3R8LnG6Q8JnG8Q8GoGm7ASHb0k7^OTHd0k7[OUHh0i7WOXHj0g7VOXHl0g7SOYHP1e7PO[HQ1d7nN\\HU1b7kN^HV1a7iN_HZ1_7fNaH[1^7eNaH^1]7aNcHa1\\7_NdHb1a3eLKh1dLf1\\3jLK`1iLg1X3mLN[1jLk1R3PM2U1lLl1n2SM5P1mLP2j2SM8m0mLR2g2VM:g0PMU2b2WM=d0PMW2`2XM?`0RMY2\\2[M`0b1C`N9a1G^N9d1GZN9h1FWN:j1GTN9n1FQN:Q2EnM;a70000000000000000000000000000000O100000000000000000000000000000000000O10000000O10000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O100000000000000000000_IB5>JE4;LG29MJ16OLO40APJ5o5:1AB1N0O110O\\I^Kb6e4O1N101O1N2O1N2J50100O10OO2O10O01O1O001O14fJoIT5X6J10O1O1O1O001O1O001O1O001O1JjJVJY5b5:K6O1O1O1O001O1N2O001O00iM", "size": [360, 640]}, "area": 87762.0, "iscrowd": 0, "image_id": 10239, "bbox": [0.0, 0.0, 640.0, 254.0], "category_id": 106, "id": 10012491}, {"segmentation": {"counts": "l9;m:10OO1001OO100000001O2N2N3M2N1_EZO10[:j00000000000000000000000000000OKeE[O^:f02I8M200O1000O11O0O101LSEKn:3hec2M]o[MO_8Y1WH6MaNo4i4lJ^KW4]5hKeJCHb3o7\\LXHo1n8UOl0SOo^7JRbH2XELZ:8aEOl1IX6;iG1c1Mb6h0UI^Oj6e0SI\\O7FnNf02NQ3`0cMWO[O6GMJe1^3XObMPO^OW1A?i1WOZN7m0lN^Od8b0\\G]Oe8c0ZG^Og8a0YG^Oh8b0XG]Oi8c0WG\\OX1Ei5n0oH\\OS1Ln5h0oHZOR11Y6;eHB[1MX7NPlj1OojTN0N0P;6O100000000O10000O10009HO00000000O101O001ON2000000O1J[EE01f::\\EEe:;40O2N101[IBoMO[2`0EAPNO[2`0DCPNM\\2`0DC_2;RMCkL4d1K[2>iNCRM515f1E]2?aMEWOOQO530i1I[2>_M5iN0^OK5Ej0N]O0n3=dLCAP3a0QMZO0o3]:7N2N2O1O100001OO1O100001O1OO1000000O100O1MQOlEP1S:3001OO1LmNQF00S1o9mNQF00S1o94O10000001O00000000000000000000O11O00000000000000002N4L1O00001OO100OEmECS:`7l1ZITNf6l1ZITNf6l1ZITNf6l1ZITNf6l1ZITNf6l1ZITNi6i1WIWNi6i1WIWNg6k1YIUNf6l1ZITNd6n1\\IRNd6n1\\IRNg6k1YIUNg6k1YIUNf6J`Hg1j0_NQ7`1jHQN[Oc0k7[1kHgNU7Y1dHnN\\7S1aHoN_7Q1aHoN_7Q1`HPO`7P1`HPOa7o0_HQO_7P1bHPO^7Q1aHoN_7Q1`HPO`7P1`HPO^7POXHQ26oMKP1b7QO_HS22PO_7mN_H]3a7cL_H]3`7fL^HZ3a77000000O100O11O1ON21OO10\\LcH]3f7NO10000000000001O0000001O00O11O00O11O000000000000002N00002N6J5KO100000000000000000000O10000M30000M3O10000a0_O000000000000A[MWH0Ie2P8ZMXH2Gd2Q8ZMXHj2h7VMXHj2T8O6J0000000000000000O100O1O1O1O1O10000001O0000001O1O1jMbG`1_8PNPHP2e8O00000000000000003M001O001O1O001O001O001O1O001O001O001OO^N]Fa1c9200O100000000000000000000O100000000000000000000O100000000000000000000O1000000000000000000O100000000000000000000O100000000000000000000O100000000000000000000O100000000000000000000O1000000000000000000O1000jNhF\\OOk0m8WOXG8Xb;?T^DN\\8_12N00001O1OM3L400001bNVG[:N1O3M3N2M4L3M4L4MiV<7\\hCd0F>LO100O1O1O100000000000000003M3M1O0fFfNf8Z1VGjNj8V1UGkNk8U1UGjNl8V1TGjNl8V1SGkNm8U1SGkNm8U1SGkNm8U1SGjNn8V1QGkNn8V1RGjNn8V1RGjNn8W1PGiNQ9W1oFiNQ9X1nFhNR9X1nFhNR9X1mFhNT9Y1kFgNU9Y1kFgNU9Z1jFfNV9Z1iFgNW9d11000000O1EgFgNX9e1000000000OdJUN]1k1bNVN^1j1bNVN^1j1aNWN_1i1aNWN_1i1`NXN_1i1aNWN_1i1`NYN_1g1aNYN_1g1`NZN`1f1lJUN[36h1P2UNQNj1R2SNoMm1R2RNnMl1V2hMTNW2o1cMUN\\2n1bMRN]2P2bMPN]2S2aMmM^2X2^MiMa2[2[MfMe2]2WMdMh2`2TMaMl2b2PM^MP3f2lLZMT3j2hLVMX3l2fLTMZ3n2dLRM\\3o2cLQM]3Q3aLoL_3S3_LmLb3S3]LmLd3R3\\LnLe3R3ZLnLg3Q3YLoLh3Q3WLoLi3Q3VLPMj3Q3ULoLl3U3oKkLT4W3gKiLY4]3aKcL_4b3\\K^Ld4h3VKWLl4i3SKWLm4i3SKVLn4k3QKTLP5l3PKTLQ5k3oJULQ5Q3hJkL63S5U3eKkL[4X3bK^Li4j3nJkK]5_4a01O01O0000001O00001O0000001O000O101O0O10001N1000001O00000O20OO101O8]OP3eLbX5IYgJT10O1O03LN3O1N2N6J2@`0L4KoZg0", "size": [360, 640]}, "area": 55914.0, "iscrowd": 0, "image_id": 10239, "bbox": [110.0, 57.0, 463.0, 299.0], "category_id": 183, "id": 10012498}, {"segmentation": {"counts": "^8b6^800000001O1O0000O1000000O10000000000O10000O11O0000000000000000001OO11O00O1O10000001O00O11O00M3N]IjG`6[8000001O00N2O1O1O100002N00000000000000000000001O1O1O000000000000000000000000000000b0^O00000UOUGmJL10LO1001O1OO2O01N11O010O0O11N2HdAJ]>OiA0f>NTWV7", "size": [480, 640]}, "area": 24449.0, "iscrowd": 0, "image_id": 10241, "bbox": [0.0, 264.0, 148.0, 216.0], "category_id": 94, "id": 10012499}, {"segmentation": {"counts": "UWV8514_>700O2O000010O01O0001O01O00010O00010O00010O0000010O000010O10O000010O0001O010O0001O01O01O01O010O01O00010O00010O0010O00010O01O01O01O01O0000001O01O01O01O01O01O01O0VI", "size": [480, 640]}, "area": 1544.0, "iscrowd": 0, "image_id": 10241, "bbox": [559.0, 195.0, 81.0, 43.0], "category_id": 132, "id": 10012500}, {"segmentation": {"counts": "0^8b6000000001O1O0000O1000000O10000000000O10000O11O0000000000000000001OO11O00O1O10000001O00O11O00M3N]IjG`6[8000001O00N2O1O1O100002N00000000000000000000001O1O1O000000000000000000000000000000b0^O00000UOUGmJL10LO1001O1OO2O01N11O010O0O11N2HdAJ]>OiA0f>NWSS39`llL:F;D;F;E:E700O2O000010O01O0001O01O00010O00010O00010O0000010O000010O10O000010O0001O010O0001O01O01O01O010O01O00010O00010O0010O00010O01O01O01O01O0000001O01O01O01O01O01O01O0VI", "size": [480, 640]}, "area": 233972.0, "iscrowd": 0, "image_id": 10241, "bbox": [0.0, 0.0, 640.0, 480.0], "category_id": 157, "id": 10012501}, {"segmentation": {"counts": "SlX5:f>:F;D;F;E:Eh07N10O010000O10O001O001OJZA\\Oh>e07L100N200N20O01O1N2O1O1O1N3O2Lomm3", "size": [500, 375]}, "area": 1295.0, "iscrowd": 0, "image_id": 10243, "bbox": [42.0, 0.0, 75.0, 82.0], "category_id": 96, "id": 10012503}, {"segmentation": {"counts": "i9k5h9100000000O10000O1000000O1000000O10000O1000000O10O100O010O100O10O0100RJ\\Fk5g900O10002N002N5J6K5K5K5K5K5K5J4M3M3M3M3M3M3L4M3M3M4L3M3L4M3M3M3M3M3L4L4L4M3L4M;E4L4L4K4M4J6E;I7K4M]ji0NbUVO2VN9gCHVEZo0ObPO6MO2O1O110Ke@O`ci00PlVO1O1O100O10001O000O1g@NP?3m@OQ?;I7M3O1001O4L4L3M4L2N00000000O100000000000000I7G92N3M2N2N2N1O1O1O1O1O1O1O1O1O1O00001O00001O001O00001O001O1OQVe3", "size": [500, 375]}, "area": 1135.0, "iscrowd": 0, "image_id": 10243, "bbox": [0.0, 205.0, 134.0, 295.0], "category_id": 105, "id": 10012505}, {"segmentation": {"counts": "_8Z1Z>O010000000O108HK4O21OM3N1O200HeNRB1O\\1n=601N2O001O11O2M4M2N2N2M3N3M2N2N2M3N3MWAWOi>i02N2N3M=E3Kfk[1O[TdN0000009G5J100ZACU>=kAGQ>8PB3e=M[Ba0W=_OkBj0ja0i9hNiEg0`0a0e9hNiEh0c0b0b9fNjEi0e0b0_9eNlEh0g0d0[9eNmEg0h0f0X9dNoEg0i0f0W9cNPFg0i0h0U9bNPFg0l0h0R9`NSFg0o0g0m8bNTFg0o0h0l8bNRFf0V1f0h8fNoEe0[1c0cNUNo9Q2^GJcNVNn9o1aGJaNYN6M\\9o1oGJ^N]N10`9h1SH?k7@WHa0g7_OXHc0g7]OYHc0g7XOgFWNc1a2e7WObHh0^7XOaHi0_7VOaHl0^7SObHo0]7QOcHP1\\7oNdHT1Z7lNfHV1X7jNhHX1V7hNjHZ1T7eNnH[1Q7eNPI\\1n6dNRI^1l6bNTI_1j6aNXI_1g6aNYIb1d6^N\\Ic1c6]N]Ie1a6[N_Ig1_6XNbIi1]6WNcIl1Z6TNgIm1W6SNiIo1U6QNjIQ2U6oMkIT2R6lMnIV2P6jMoIX2P6hMPJZ2n5fMRJ[2m5fMRJ\\2l5dMSJ^2l5cMSJ`2j5`MVJa2i5_MWJb2h5_MVJe2g5[MYJ_NVNo3_7bM[J[N]NS4U7bMlJ]2S5dMlJ_NiMe3Y7lMoJZNPNh3o6oMPKYNRNh3m6oM`KQ2_4PNaKQ2\\4SNaKo1]4SNaKo1b4nM\\KS2g4iMYKZ2h4bMYK\\2j4bMVK^2_MRLV7`1[Kd2c4]M]KcNbMd3Q7iM]KbNdMd3o6jM]K`NgMe3e6XLWIc1\\2`NjMd3b6TNdKWNlMd3`6UNdKVNnMd3^6QNUI\\N^2NQNd3\\6PNXI]No2b3h3PN\\I^Nl2a3h3QN\\I`Nk2^3i3QN^IcNf2\\3l3eMWIQO8Nd2\\3n3mLTIO:G3Ob2^3n3iLVI2:DB0>2c2_3o3`L[I;f0DQ2a3\\4jLhLV3X3iLiLW3W3hLjLX3V3gLlLX3T3hLlLX3T3hLlLX3T3gLmLY3S3gLmLY3S3gLmLY3S3fLmLKULm2n6XMmLJWLm2l6YMmLJWLm2m6WMlLMWLl2m6WMlLLXLm2n6UMiLOYLl2o6TMhLOYLn2[;RMfDn2P<0XOSMnDh2R;WMPEh2o:YMREf2n:ZMSEe2l:\\MUEc2j:^MWEa2o5^MfM3[L^2o5bMaM2bLZ2m5gM[M2iLV2k5lMVM0QMS2h5PNTMOTMP2f5SNVMERLNQ1Z2f5TNVMBWL0l0Z2h5SNdMAdL\\2j5QNcMDaL[2m5PNcME_L[2m5QNeMD]L[2o5PNeMFZLZ2Q6oMhMEWL\\2P6QNhMBYL]2o5QNiNo1W1QNiNo1h0eMjI>^5m1d0jMjI;c5k1`0nMiI:g5h1?gNBX1?fNBZ1=gNCY1>eNC[1=eNC[1dNA]1?dN^O^1b0bN]O_1h0\\NVOf1m0VNSOk1o0SNoNo1Q1QNnNP2S1oMkNS2U1mMkNS2U1lMnIZO\\4j2f1lMlNT2R1oMmNQ2R1PNnNP2T1nMlNR2U1mMkNS2U1nMjNR2Y1kMgNU2X1ZM]IiFKbNG\\O8g;6[FL`NF_O9d;6]FL^NFA9c;5^FM\\NED<_;2aFM[NEF;i:DhE?^1NUNHN6f:FhE?`1MnMK63d:FhE>a16VNEb:GfE?b12XNI]:IhE=c10ZNHZ:GXE4`0>e1NZNHY:HXE5=?i1J[NHX:1cE>j1H\\NIW:1bE?l1E^NIT:NgEd0g1BbNKP:NiEd0e1BdNKn9NiEg0c1@c9JbDOJi0Q2]Oe9J`Do0j1WOS:i0mEVOT:j0kEWOU:i0kEVOV:k0hEUOY:l0fESOZ:n0fEROZ:o0dEQO]:P1bEoN_:V1[EjNf:W1YEiNg:l0dCYOe1Kg:k0iCVO_1Oi:j0lCTO[12j:g0dEYO]:f0bE[O_:d0_E_Oa:OcC5\\1EkN;WROgAX1W>4O00000000000000O1000000O10000001O1O001O00O100000000O1O1O1O1O1G9001ON200O103L6K6J5K5JQmo3", "size": [500, 375]}, "area": 1832.0, "iscrowd": 0, "image_id": 10243, "bbox": [61.0, 0.0, 52.0, 46.0], "category_id": 139, "id": 10012509}, {"segmentation": {"counts": "m3`2T=01OO11O;F3VOi0L4L4L1O2N1O2N1O2N1O2N1O2N1O2N1O2N1O2N2N1O2N1ObXk04SgTOMm@8P?:K4M4K4M3M4K5L4K5L4K7J:_OhMnB`2PN^9d3SF\\Mh:b2]E`L3=`:S3oEiLQ:V3VFdLj9\\3W11O001O3M5K1O4L5REjKT:Z4`EoK_:U4[EmKe:a40O11O00N22NN2000000O1000000000000001O000000001O0000O1O11OO100001O000000O11O1O002N0000000000000000000gERKl9o4RFVKj9k4TFYKi9f4WF^Kf9c4XF_Kg9b4XF^Kh9a4WFaKi9b4TF]Km9V5O0000O11O00001O000000001O000000001O00000000001O000000001O000000001O0000001O0000001O0000001O0000001O1O1O00001OO11OO10000001O00O100001O0000000000001O0000", "size": [500, 375]}, "area": 48266.0, "iscrowd": 0, "image_id": 10243, "bbox": [0.0, 0.0, 375.0, 206.0], "category_id": 172, "id": 10012510}, {"segmentation": {"counts": "gX^43`?7I2N2N2O001N020O00O0110O00014K3M2N0010O00000N2O21N1O003MO]AWO]>g0bA\\O_>m0O00000001N100O12NO2O0O11O10O0000001O0000001N1001O01O11O0O1O10OO11OO10000001O02M3N3M100cAjNZ>X100000000001O0000kI", "size": [500, 375]}, "area": 2387.0, "iscrowd": 0, "image_id": 10243, "bbox": [291.0, 182.0, 84.0, 55.0], "category_id": 173, "id": 10012511}, {"segmentation": {"counts": "d0Q1o=d00000kC_NW:`1QEDd:`0S6QO]Id0Nb6QOmHU1?Je6QOjHW1`0Hg6QOfH[1a0Dj6QObH^1c0Al6PO_Hc1c0\\OP7QO\\Hd1c0[OR7Y2lHgMU7Z2iHfMX7Z2gHfMZ7[2dHeM]7[2bHeM_7\\2_HgM_7Y2`HjM^7W2`HmM\\7T2cHoM[7R2cHQNZ7P2eHSNY7n1eHUNX7W5M2M3N2M3N3L3N2M3N3M_HcIX6P6hIPJ]6k5cIVJa6e5_I[Jf6_5[IaJj6Z5UIhJo6S5QImJT7n4lHSKX7h4hHXK]7c4cH]Kb7^4^HcKf7W4mFdKT16R8S4jFgKT17T8o3hFjKT17W8l3eFmKT17Z8i3bFPLT18\\8e3`FSLT18_8b3]FVLS1:b8\\3\\F\\LP18g8Y3YFdLk03o8V3VFkLg00U9R3TFRMc0L]9n2PF[M>Hd9j2nEbM9El9e2lEkM3@T:b2iERNO]OZ:^2gEmN\\:P1dEQO^:l0bETOa:j0^EVOe:g0[EZOg:c0YE]Oj:`0VEAl:fEA`NZOd;U1lE@^N@e;o0lEA^NEc;j0oE@^NHb;h0PF_O^NJc;f0oE_O^NMb;d0PF_O]NNd;b0oE_O]N0d;a0oE^O^N1c;a0oE^O]N2e;?nE^O]N5d;a1]OYN>g0Cj7EgHg0hN6h16nNZOAEl73QH3a0a0[O4h16mN\\O]OKm7=aH3A2h16kN^O^OKk7c0ZH0INi16kN_O\\OLl7h1UHfNj15hNB]OLl7g1THfNm13eN5Z7R1THfNQ2NaN;[7Q1SHjNl1IfNL^OKR8a1nGSOh1EjN=c7h0kGZOd1@oN>d7g0iG[Oc1_OQO?h7BbHb0e0\\ORO`0k7TOeHS1>YORON[OM7DP8OnHZ1?VOSO0YOM6FY9k0eFVO`1;TO1XOM4IY9i0dH_OhN2WOM3KW9i0gH\\OiN3VOM2MV9h0iHZOjN4UOM1OU9g0fHlNVN;k05SON01T9e0gHoNVN6n07QOM04R9d0gHQOXN3m06SOd0o83iHPO[N51C>?_Of0m84jHPO^N2KGa0;@h0l82_HlNjN7M8`0H@j0i81\\HVOmNOM9d0D]Om0i8ATGDZ13kNOK9T1a0f7_OXGCZ16hNOJ:V1>e7_O\\G@Y1;fNNJ:g0\\OEQ1_8^O^G@X1?dNd0`0QOGm0_8]OSI2WNc0>UONb0Z8BTI6UNa0=ZOM=]8@VI8SNb0:_OL7a8^OXI:QNb09BK4d8XO[Ia0nMDKb0SO]ONl06LMOi9_OSG4=MCh9BPHl0ZN0NBh9CoGj0\\N1MBh9CVGDGV1^O2LAi9CUGIDP1B4M^Oi9ESGMBl0E5MZOl9GnF2Bg0G7NWOl9IlF4Bb0J>JQOo9LiF4D1LFG<[1DhNR:4PFI6?2IGF<\\1L`Nj9=nEL4=5IH@>a1P:mNaEN2;8G;R1j9oN`E019:E;R1k9PO^Em0=oN;T1k9oN]En0?lN:V1k9C\\EH>B9S1m9A]EKa0]:OVE@=a0]:OVE@=a0]:OUEA?>]:1TEA?>]:0TEC`0;]:XOPE538`0:^:YOoD538`0:^:YOoD538a09]:YOPE539`08^:WORE809`08^:UOPE>24b08]:TOnDa043a07^:4QEDb08]:3REDc07]:4PEEc07]:3QEEc08]:2PEEe07]:2oDGd06_:1nDHe05^:2nDId04b:RO`Dk0;Oc03d:NjDOc01d:MlD2a0Ne:0jD1d0Lc:3iD1e0Jc:5hD1f0Hc:7gD1h0Dc:;eD1Q=OoB1Q=OoB0R=0nB0R=0oBOQ=1PCNP=2QCMo<3RCJP=6QCHP=8PCFR=:QCAQ=>TC]Ome^ODZa0b1O001OM30000N2O1O1O1000000O1000000O11O1O00002NKT^OVNla0j1T^OVNla0h172N00001O001O001OBR^OjNna0>X^OZO4LF=ma04c^OBL:aa0Kl^OKB=`a0@V_O3YO9ib0Gkl;NoSD0O1O10OO2O1N1_O5o\\OKib0a0R]O@ib0n00O100000000O1000000O100000000O1000000O100000000O1000000O1000000O100000000O1000000O100000000O1000000O100000000O1000000O100000000O1000000O1000000O100000000O1000000O100000000O1000000O100000000O1000000O100000000O1000000O100000000O1000000O100M3M3LTTb0", "size": [640, 475]}, "area": 6262.0, "iscrowd": 0, "image_id": 10244, "bbox": [211.0, 0.0, 235.0, 73.0], "category_id": 120, "id": 10012515}, {"segmentation": {"counts": "SX]52nc02N001O0O1BMo\\O3Pc0Oo\\O1Vb0K[^O6\\OOWb0Kc]O051=6C1Tb0Lg]O2<6E0Xb00P^Ob0n`0ROh_O>XOa0X`0WOe_O4LFn0g1X?iNm_OLh0^1R?oNV@B>h1V?nN\\@YO9o1Z?iN]@o1c?W100000M3K5K5K5K5L4K5K5K5K5K5K5K5K5K5K5ZOn]OYOWb0g0i]OTO\\b0k0e]OQO_b0n0b]OmNcb0S15N2O1N2^O[]OIeb0Og]OLZnn2", "size": [640, 475]}, "area": 3039.0, "iscrowd": 0, "image_id": 10244, "bbox": [277.0, 0.0, 47.0, 139.0], "category_id": 132, "id": 10012516}, {"segmentation": {"counts": "g3Y`0g30001OO11O000000000000000000000000000000000000000000000000001O00000000000000000000000000001O00000000O1000000O11OO10000001O000000002NO1O10000000k_OYLQ`0m3N1O2N1O1O1O001O1O1O00O1000000O1000000O1000000O10000O1OZ@SL[?Z4O2N1O1O2VAcK5Km<]5oBhJP=Y5lBlJR=T5jBQKU=V6G2N2N1O0000K5FkBdIZ=\\651O00H8N2N2M3L48He0VB`Ijk2jAWLNk0Y>m2VBRMj=n2WBQMi=n2YBQMg=o2YB\\LWO=a>V3`BjL`=V3SBYLFa0W>V3RB[L_OO0a0_>U3RB[L^O1O`0a>U3QB[L^Ob0e>S3mA[L^Ob0e>S3mA[L^Ob0e>T3lAZL_Oc0d>T3lARMT>n2lARMT>n2lARMT>o2jARMV>n2jARMV>o2iAQMW>o2iAQMW>o2jAPMV>o2kARMT>n2lARMT>m2mA^Mh=b2XB_Mg=`2ZB`Mf=`2ZBaMe=_2[BaMe=^2\\BcMc=\\2^BdMb=\\2^BeMa=[2_BeMa=[2_BfM`=Z2`BfM`=Z2`BfM`=Z2`BfM`=Z2`BeMa=[2_BdMb=^2\\BbMd=]2]BbMd=^2]B`Md=_2]BaMc=_2]BaMc=_2]BaMc=_2]BaMc=^2^BbMb=^2^BcMa=]2_BcMa=X2kA`Ld0X1a=W2mA`Lb0Y1a=U2jAaL31b0X1b=S2iAdL70=[1b=l1nBPNV=^1\\CcNc<]1^CbNb<\\1_CdNb<[1]CfNdd2lA]MLbNT>o3nAdMM]NU>n3lAjMT>Q401O0000001O00000000001O0000001O00001O00000000001O0000001O0000N2O100N2O11O1O00000000O10000000000001PBZJd=R6O2N00003M1ON21O1OO11O1OO10000001O2NO11O001O0000001O001O2N2N1O00000000000000001O00001O00001RETIf8m6YGSIg8n6VGUIi8k6XGUIg8l6XGUIg8l6XGUIg8k6XGVIh8k6XGUISNJ`:R7\\GUISNIa:S7ZGXITNF_:S7]GZIb8f6\\G[Ie8f6[GYIe8h6YGYIg8h6XGWIi8j6VGWIi8j6UGXIj8j6SGWIm8k6PGVIP9k6iFbHkNf0[:l6cFbHQOc0[:T7WFWIi9g6XFYIi9o6dETH3m0Y:Z7cEhH\\:]811O1OO11O00O11O3eEZFV:i9O4L001O1O001O001O1OO12NO1000TFoEi9V:N003M00001O001O001O001O1O00001O1OO11O1O0000000000O11O0000O1O12N00O11O002kF\\Ej8e:oF\\E05n8k:O1O001O001OO11OO11O000000001YGkDa8U;\\GlD00c8[;aGdDN1U8\\;iGdD0000X8\\;hGiDY8_;00000O11O1O1O1OO11O001O00002N001O001O001O2N0000001O1O1OO100", "size": [640, 475]}, "area": 203961.0, "iscrowd": 0, "image_id": 10244, "bbox": [0.0, 82.0, 475.0, 558.0], "category_id": 140, "id": 10012517}, {"segmentation": {"counts": "^\\P32;OVc03b\\OO01\\c00c\\O1O8Vc0Hj\\Ob0Rc0^On\\Ob0Rc0^On\\Ob0Rc0^On\\Oc0Qc060000O10000001O01O00;E1O001O001O001O001O000000O1O100O2N100000000001O000000O02OL410OO0O11M1N4M31O01O00000000002N00000000O2O5J2M4N1N100001O1OO2OO11O000hNfNj_OZ1V`0oNb_Oo0]`0ZO\\_Of0d`0ZOi^O[O`0\\1e`0[Oj^OZO11O24Y1Va0Ck^O>LbNUa0n0m^Oe0M]NUa0n0l^Oj0Ta0Q110O0MXMn^Oh2Ra0XMn^Oh2Ra04O01O00000TMn^Oj2Ra0VMn^Ok2Qa0UMo^Ok2Ta0O0001O00010O00000000001O00000MUMQ_Ol2o`0SMQ_Om2n`0TMR_Ol2n`0TMR_Oj2Qa0UMo^Oj2Qa0XNP_Of0Qa0YOQ_Oc0Qa0]Oo^Ob0Ra0^Oo^Ob0Pa0^OP_Oc0o`0\\OR_Od0n`0nNo^OH3Z1n`0mNQ_OH1[1n`0nNS_ODO^1n`0nNT_OC1[1m`0lNW_OE0_1i`0iNi_OW1X`0gNi_OY1_a0000N201g]OcNma0i1O2NUNT^Ob1la0YNY^Og1Qb02M1ON30O1OO20O10N10001O01O2ON11O010O0001O01O03N3N2N0OO01O1O1O1O001O1O100O00100O1O10__OgNY>Z1fAfN[>Z1bAiN^>V1cAjN]>V1bAkN^>U1aAlN^>T1aAmN_>T1aAlNSNJW`0[1eAlNSNIW`0]1dAnNTNFU`0]1gAPOW>Q1gAPOZ>Q1fAnNZ>S1dAnN[>T1dAkN]>V1bAkN\\>W1bAkN]>W1`AjN`>X1]AiNb>Y1WATNkNf0m?Z1QATNQOc0l?c1f@hNZ?V1g@jNY?_1T@dM3m0j?i1R@YNm?l211O10N11O01N11O3R@mKj?U4O4L010O1O010O00100OO12ON1000\\@gKa?^4OO03M01O01O010O0010O01O10O000100OO1100O0001O00000O20O0001N1O12OO0O110O02g@`Kn>a4k@`K05S?f4O1O010O0010N11OO20O000001O01PATKj>l4SAUK00m>Q5WAnJN1_>R5_AnJ0000b>R5^ASKd>T500001N11O100O1OO20O0010O0002N010O0010O01O2OO000010O1O10N10\\I", "size": [640, 475]}, "area": 29198.0, "iscrowd": 0, "image_id": 10244, "bbox": [154.0, 93.0, 321.0, 295.0], "category_id": 149, "id": 10012518}, {"segmentation": {"counts": "Xld83jc03L3010000000O1000000O100000000O1000000O100000000O1000000`0@0000", "size": [640, 475]}, "area": 275.0, "iscrowd": 0, "image_id": 10244, "bbox": [443.0, 0.0, 32.0, 21.0], "category_id": 157, "id": 10012519}, {"segmentation": {"counts": "a0S1mb00O1010N11N011O001ON21OO01N02010O1OO21M1O011N0101O2N001O001O0UOU]O`0nb0^OT]O`0kb0@W]O?lb0\\OW]Oc0Uc0L3N5G[\\OOfc0M^\\O2[Rb0O^a^O2Y\\O2Xc0;01O00000000000000000000001O0000O1O11O1O0000M31O1ON21ON200O12N00O1O1001OO11O00M3001O000e\\OEQc0k\\OBVc0>j\\OCUc0=l\\OBTc0>j\\OF1Ojb0;T]O1kb0b000000O1001O000000000000O1O10S]OPOjb0T1O002N2N001O1OO10000N21O1OO11\\]OhN^b0]10O12N1O4LO11O2N000000000Q^O[Nca0d1^^O\\Nba0e1\\^O\\Nda0a1U^O]N72da0b1]^O`Nba0a1\\^OaNca0b1Y^O_Nga0a1V^OcNia0j10001O00O1001ON21O00000000O11OO10010O1lMV^OP2ja0PNY^Om1ma002M200O2M10002M4NOdNc]OU1]b0kNd]OOO21LON0f0[b0[Of]O12O`0a0ha0@l]OO=c0na0]OR^Ob0gb012Ni\\O^Onb0k0O00O14L1O02N00O1O2O01N3ZOR]O6Qc0FR]OMIR]O[O05Pc0?T]O\\OQc0c06O2N1M5CWfa3", "size": [640, 475]}, "area": 8575.0, "iscrowd": 0, "image_id": 10244, "bbox": [0.0, 0.0, 293.0, 102.0], "category_id": 169, "id": 10012520}, {"segmentation": {"counts": "0a0S1b1V?^Nj@b1V?]Nk@c1U?]Nl@c1S?^Nk@b1V?^Nk@b1T?]Nl@d1T?\\Nm@c1S?]Nm@c1S?]Nn@b1R?^Nl@d1T?\\Nm@c1S?]Nl@d1T?[Nm@e1S?YNm@i1S?WNm@i1S?XNm@g1S?YNn@f1R?ZNm@g1S?ZNn@d1R?[No@e1Q?ZNo@g1Q?YNPAf1P?YNPAh1P?XNPAh1P?YNo@g1Q?[Nm@e1S?[Nm@e1S?\\Nl@d1T?\\Nl@d1T?]Nk@c1U?]NP@A`0T2_?]No_OA`0R2a?\\No_OD?P2b?_Nj_ODc0m1c?kNY@W1g?jNW@W1i?mNn_OkNOX2S`0nNj_OnN2T2T`0`100000000000001O00000000O1000000O11OO10000001O0000000020M3_Ll_OQ3b`001O00000K5I7I7K5O1O1O1O1O2N1N2O00011N2N1O10M22N2ON12EQ^ObNna0`1X^OZNha0g1712OO1N2N1001N011O00M30O2O000\\Nn]OZ1Sb0eNm]OZ1Vb0cNj]O^1Vb0bNk]O]1Ub0dNj]O\\1Vb0bNn]O1OR1Sb0lNY^OR1[b01O1O0O2O010O1O001O001O1N1O2OcN`]OZ1db00O11N2OO10O10N2O2N1M4O000N3O]Ng]O^1]b02M210d]O\\NYb0e14K020OQ^O_Naa0_1[^OgNca0Y1\\^OiNca0X1T^OcN26ja0i101OVNV^O_1ha0bNX^O^1ia0`NX^O`1ea0YNY^O72a1ea0`N]^O_1da0_N^^Oa1da0[N]^Oe1ca0XNa^Og1la0O101N10O0101ON12N10000000O11OO10011NO100O10O11O0O01000Ke]OeNZb0[1h]OdNYb0Y1d]OfN31Yb0V1d]OiN70Wb0P1`0^Oe0MN03N2MhQX5", "size": [640, 475]}, "area": 14585.0, "iscrowd": 0, "image_id": 10244, "bbox": [0.0, 0.0, 206.0, 126.0], "category_id": 172, "id": 10012521}, {"segmentation": {"counts": "kS]12gc09G8H9I6N1O2N2N2N2N1N2O1O010O1O1O010O1O10O01F^NU^Oc1ka0cNo]O]1Rb07101N2MQ^O_Nda0o1OSOU^OGia09W^OHga08Y^OJfa06Z^OLb0UO5KW?S1R@i0c0YNZ?n0S@j0?]N\\?h0U@l0;aN^?d0W@R2`?nM`@T2^?kMb@X2\\?hMd@X2[?hMe@Y2[?gMe@W2]?iMc@R2b?mM^@m1i?SNW@m1h?SNY@m1h?RNX@l1k?SNT@g1S`0XNn_Of1U`0YNk_Oe1W`0ZNi_Oa1^`0^Nb_OY1h`0fNX_Ol1V`0SNj_Oc20jLW?b0i@P3V?oLk@R3U?mLk@T3U?jLk@X3T?iLk@X3U?gLk@Y3U?hLj@j23hLT?>i@i25gLS??i@i25gLR?`0i@h27gLQ?a0h@g29eLQ?c0g@h1f`0XNZ_O_1Pa0`NQ_O\\1Ta0cNk^OZ1Ya0eNj^OY1Va0fNl^Om01eNSa0;P_OZ1Qa0dNR_OZ1Pa0dNR_O8@>_a0XOY_O1[Of0]a0WOi_Og0Y`0WOh_Og0Z`0WOh_Oh0Z`0VOg_Oi0ha0WOP]Ob0Wc001N6K7IXkf2MfTYM5K5K6J5K5K6K4K5K6J5K6J5K5K6J5K5K6J5K5L5J5N201O0O4M4L4L1N2O1O1O1O0O2O1O1O1N101O1O1O1N101O1O1N2O001OO10O10O100O010O1000O0100O1000O0100000O2O00001O0O101O000O2O00001O0O101O000O2O0000001N10001O0O101O000O2O00001O0O101O000O2O00001O0O10001O0O101O00001N10001O0O101O00001N10001O0O10001O000O2O00001N10001O0O101O00001N10001O0O101O00000O2O00001N10001O000O2O00001\\1cNQ2oMP2QN\\J", "size": [640, 475]}, "area": 34017.0, "iscrowd": 0, "image_id": 10244, "bbox": [72.0, 5.0, 403.0, 228.0], "category_id": 183, "id": 10012522}, {"segmentation": {"counts": "_eW51V=4K5I7WO@aDg0^;c00000000001O0000000000001O00000000000000000000000000000000000000000000000000000000000000000000000000001O0000001O00001OO10000000000000000000000000000003M4L4L4L3M2N0000000000O10000000000O1000000_NlDk0T;UOaE6_:JlEJU:6kEJU:6lEIT:9jEGV:f0]EZOc::iEEX:<]E_O]O6V;;]E_O^O5U;<]E_O_O4T;>]E]O@3T;`0\\E]OA2S;b0[E]OA1T;b0[E]OBOT;d0ZE]OBOT;e0ZE[OCOS;f0ZE[OR;e0nD[OR;f0mDZOS;f0nDZOQ;g0nDYOR;g0nDYOR;h0mDXOS;n0gDROY;S1cDmN\\;Y1^DgNb;b1O1O1O2NO10000O100O1O1O1O1O100O1O1O1O100O1O1O1O1O100O1O1O1O100O1O100000000000000O10000000[Sk0", "size": [427, 640]}, "area": 7566.0, "iscrowd": 0, "image_id": 10245, "bbox": [402.0, 0.0, 173.0, 67.0], "category_id": 156, "id": 10012523}, {"segmentation": {"counts": "W=4W=000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "size": [427, 640]}, "area": 3844.0, "iscrowd": 0, "image_id": 10245, "bbox": [0.0, 419.0, 640.0, 8.0], "category_id": 167, "id": 10012524}, {"segmentation": {"counts": "fdh4<SFBm9>SFBm9f0kEZOU:R1`EmN`:b0fEYO^O4m:d0eEWO]O6n:c0eEWO^O5m:d0eEWO_O4l:f0dEVOA2l:h0cEVOB1k:j0cEUOA1l:j0cEUOBOl:l0bEUOBOl:m0aETODNk:n0aETOk:l0VESOj:n0UEROk:n0UESOj:n0UEROk:n0VEQOj:R1SEnNm:X1mDhNS;^1gDcNX;c1bD]N^;i1O1O3M00O10000O100O1O1O1O1O100O1O1O1O100O1O1O1O1O100O1O1O1O100O1O100000000000000O1000000000000000000O10000000000000000O10000000000000000O010000000000000001O0000000000001O00000000001O2N1O1O1O1O2N1O1O1O1O1O2N1O1O1O1O2N1O1OXN", "size": [427, 640]}, "area": 249726.0, "iscrowd": 0, "image_id": 10245, "bbox": [0.0, 1.0, 640.0, 422.0], "category_id": 183, "id": 10012527}, {"segmentation": {"counts": "0md:5WhE:E;E7J6I8H5L3L3M3N2O100O1O100O100O1O100O1L4L4L4L3M3SO\\MQGh2o8\\MhFh2X9]M`Fg2`9a001O01O0O2O0O101O0O01M2O2N2M2O20O100O20O2N2YOYLgGi32^LV73`H`33oLP7i3nHeLd6^3ZIgLa6[3^IiL^6X3`ImL[6T3dIRMW6U5L4K5L5K4K5L4K6K4L4K5L4L5\\LWG[2n8\\MYGb2k8VM[Gh2i8oL]Go2b9N2M2O2N2M2O000O100O100N2N2N2N2N2O1N2N2N2N2O1N2FhD_NZ;`19O1O1O1O1O1O100O1O1O1O1O1O1O1O1O1O1O10eNQOZFn0a9XO_Fg0b9ZO]Fe0e9ZO[Fe0f9[OZFd0g9]OXFb0i9^OWFa0k9_OTF`0m9@SF?n9BQF=P:CPF=P:DoE;S:DmEa<7O1O001O00000000000000000000000WOXOoDh0P;[OnDe0Q;^OmDb0R;AlD?S;DkD000000000000O1000000000000O1000000000000O1000000000000O100PI]LX4c3gK_LW4b3hKaLU4`3iKcLU4^3jKeLS4\\3lKgLR4Y3lKjLR4W3mKlLP4U3nKoLo3R3oKQMo3P3nKUMo3l2XKRLZOV1[5i2[KSLUOX1^5f2]KTLPO[1`5b2`KVLkN\\1c5^2cKWLeN_1f5[2eKRNX4o1hKSNU4n1QKmK5V2h4d2WK_Me4b2[KbM`4`2`KcM[4_2dKeMW4]2hKgMS4[2lK7b1I^N9^1JbN7[1KdN7Y1KfN6X1LgN6V1KjN7S1KmN6P1LoN6n0LQO6l0LSO6i0LWO6f0LZO5c0M\\O5a0M^O5?M@4>MB59OG224MNM72a601O1O1O1N101NVnl2", "size": [427, 640]}, "area": 157853.0, "iscrowd": 0, "image_id": 10248, "bbox": [0.0, 0.0, 640.0, 427.0], "category_id": 124, "id": 10012528}, {"segmentation": {"counts": "md:5T=:E;E7J6I8H5L2M3M3N2O100O1O2O0O100O1O100O1L4L3M4L3M4RO\\MQGg2P9]MgFh2X9]M`Ff2a9b0O0001O0O2O0O101N10O1M2O2N1N3N110000O21N2N2YOYLgGh33_LU73`H_34PMo6i3nHeLd6^3ZIgLa6[3^IiL^6W3aInLZ6T3dIRMW6U5L4K5L5K4K5L4K6K4L4K5L4L5\\LWG[2n8\\MYGb2k8VM[Gh2i8oL]Go2b9N2M2O2N2M2O000O100O100N2N2N2N2N2O1N2N2N2N2O1N2FhD_NZ;`19O1O1O1O1O1O100O1O1O1O1O1O1O1O1O1O1OhNnNYFR1b9TO]Fk0a9XO_Fg0b9ZO]Fe0d9[O\\Fd0f9[OZFd0g9]OXFb0i9^OWFa0j9@UF?l9ATF>n9BQF=P:CPF=P:DoE;R:EmEc:CPEi0P;h02O0000001O000000001O0000001O0O1N2M3M4L3L40001O000000001O0000001O0000001O000GPDWOPTDAZR;ElD;R;IlD7S;LkD4T;OjD0V;3hDMW;6gDJW;:gDFX;W10O010O0100O010O010O2N2O0O2O1N2O1N01O0010O01O001O00001O001O001O001O001O001O001O0100O1O100O100O1O1O0O2O1N2O1N2O1N2N2O1N2O1N2O1N2^Ob0M30000O1000000000000O1000000000000O100000000000000O1000000PI[LZ4e3eK^LX4c3gK`LV4a3hKbLV4_3iKdLT4]3kKeLT4[3kKhLR4Y3lKkLQ4V3nKlLP4U3nKoLo3R3nKSMo3n2VKQL]OU1[5k2XKRLYOW1\\5h2[KTLSOY1_5d2_KTLnN[1a5b2aKULiN^1d5]2cKQN[4P2eKRNX4o1hKSNU4n1fJXLa0j1g4e2XK_Mc4b2]KbM^4`2aKdMZ4^2eKgMU4[2kK6c1K\\N7a1J_N8]1KbN7[1KdN7Y1KgN6V1LiN6T1KlN7Q1KnN7o0KPO7m0KSO5j0NUO4h0MXO5e0MZO5c0M\\O5a0M_O4>NA4;NE451J1O50MJ86^601O1N2O1N10a[m2", "size": [427, 640]}, "area": 114974.0, "iscrowd": 0, "image_id": 10248, "bbox": [25.0, 1.0, 391.0, 422.0], "category_id": 183, "id": 10012529}, {"segmentation": {"counts": "0`1`b000000000000000O100000000OQ^OfNZa0Z1b^OdNC2la0[1`^OhN`a0X1W^ObN46ea0X1V^OcN55ea0m1O001O3M0000003M00O1001O0000001O0000001O0000001O00O1001O00N2001O0000O1N22N000000L4O11O1O1OK51OL4N2O10000O1N2001O000000Ko]O[NQb0e1500O100K56J0000O1N2O100000000O100O1O1001O1O00Lf]ObNZb0_1300O1J6001O0000O1O100O1N2N20U]OoNgb0V1O1O001O002N001O1O0000O12N1O00000000N200O1L400MZ]OlNfb0S1\\]OmNcb0S15001O1OLY]OoNgb0R1Y]OmNgb0S13SOU]OM1NOO2303jb0Oc]OMC1mb0MQ]O2g00Xb0NodZ5", "size": [640, 426]}, "area": 8489.0, "iscrowd": 0, "image_id": 10249, "bbox": [0.0, 0.0, 153.0, 78.0], "category_id": 94, "id": 10012530}, {"segmentation": {"counts": "X2R5m>10dM\\2jNW10N2N2O1N2N3M2O1O100N2O1O1O2O0O1002NO1O1O12ON1N6K6K2M001O100O1O00100O1O00100O1N2O010O1M3O100O2N1N2M31OO1O1O1K5N2000000J7O1J5M4MNZ@nKd?m3:O01N2001O000O10KTLV@l3j?500O100K56J01O0O2M102OO100000O100O1O010100O00LjK^@V4c?6M1N4G6010O0000O1O100O2M2N20PKTAl4Q?O1O001O002OO01O1O0001N12N1O0001O000N02N1ON22NO\\Kj@b4W?`Ki@]4Y?32N3N2NMeKc@Z4_?fK`@Y4a?20O2O1O2N001O2M3N00001O2N0O101O2M2O00N2OSNR@Jk?9\\@Ad?>c@\\O^?b0m@gN`?Y1d1O0O11O100001000O2M2O1O1O1O010O000N20000O20O1ON2O10010O0002N10O1O0011OO1N2M31N01O1O1b_OdMV?]2f@fMY?\\2c@gM_?W2]@mMc?T2Y@oMf?Z2n_OkMQ`0R32N2OO0O2O1O1O000100O1OO10000O12N0001O02N10OO4M0001O01OO11O001O0000O2O000O100000000N21O00O11O0000000000O13L011O1O10O1O0N21O1O4M1M3N2N00001O00001O0N12L20110O000O1N3O00001N0O22N__OcL``0^32N10O2OO010O5K00MkL^_OS3a`0kLa_OT3f`0001N101M3M4N1O1b_O`LZ`0b33M11O1O1N11M11O3N12M001N1O10O10Ld_OdL\\`0V391002N0lLY_On2h`0QMZ_On2l`00001N102N1O0O3M2O1N10001N100O1O11O01O0O2O01O01O00O010O1O1001O1O1O002N01O000O10O100OKhMb^ON0Y2_a06O1001N2O1O03M0L5N1O2O10O001O2OOON4O00N30000O0O2N2N2O0O1000001N10iM", "size": [640, 426]}, "area": 44975.0, "iscrowd": 0, "image_id": 10249, "bbox": [0.0, 17.0, 426.0, 217.0], "category_id": 97, "id": 10012531}, {"segmentation": {"counts": "n_c42jc04O1O1O100O1O1001OO11O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008Go[>0mcA8M00000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000001OVX;", "size": [640, 426]}, "area": 1296.0, "iscrowd": 0, "image_id": 10249, "bbox": [235.0, 629.0, 172.0, 11.0], "category_id": 105, "id": 10012532}, {"segmentation": {"counts": "Vb0h0Yc0OO01001N10O11N101OO010O1O001O1000O10N2O010002M10N20O10O10O01000O2OO1O02O000O2O00N1101O1ON110001N2ON20OO21O1N10KQ]OYOob0h035L1OO02O00N1012N0`DROm3n0oKZOn3f0QL]Om3b0TL@i3b0VL@h3a0WLCe3;]LJ^36bLOhHYOT:i0SM;m2ESM;m2DTM`MB`2>`MB`2bMB^2>bMA_2?aMA^2a0aM_O_2`0lEhNc7g0b2e0]M[Oc2f0\\MZOc2i0XM`NdHg0T:h0PGaNR51iIf0U:h0jFdNRONU6`0mIAS:]1iFkNT58QJ^OS:_1gFlNU57Z4m0bFkNT58Y4n0bFkNU56Z4o0aFkNU56Z4P1_FkNW54Z4R1_FjNW54Z4R1_FjNX53Y4R1`FkNW54W4R1bFjNW54W4R1bFjNW55V4R1cFhNW56U4S1cFhNX55U4S1dFgNW56U4S1cFhNX56S4S1eFgNX56S4S1fFfNX57Q4S1gFfNX57P4T1gFfNY56P4T1gFfNY57o3R1iFgNX55Q4U1eFgN[51Q4Z1cFeN\\5OS4[1bFfN[5MU4]1_FgN\\5JV4_1_FgN[5HX4a1]FgN\\5EY4e1QFZN_OO2=U6CZ4h1PFYN@OO>k`0[1c_OoN]`0Q1a_OQO^`0R1__OoNa`0Q1^_OPOb`0P1^_OPOa`0S1\\_OnNd`0U1Y_OkNg`0W2O10000O10000O10000O1000000O10000O10000O10000O\\M__Ok1a`0UN`_Oj1``0QNa_O^OOa2_`0RNf_On1Z`0PNh_OP2X`0QNj_Ol1U`0TNl_Ol1U`0QNn_On1Sa0O002N001O0000O11OO1O10000N20000O11O2NO10000O1N20000000000M3M3K5001O001O00001O00O1O1O1001O1O000000N2O11O2N1O2N2_Oi^OUNYa0e1k^O[NVa0`1n^O`NTa0Y1Q_OgNca0a0a^O_Ofa06^^OJia0J\\^O6gb000N2L4O1O1O100OQX10RXT16PliNJfc0800000000hBIg67YI3W63iI3h56XJJ_5?aJ@V5j0kJUOl4T1SKmNd4\\1\\KdN[4e1eK[NU4k1kKUNU4k1lKTNT4l1lKTNS4m1mKSNY4g1hKYN`4^1`KbNj4T1VKlNS5k0mJUO]5a0cJ^O[JE\\:d0YKGZJGe:5aDH`6U100000O1000000W^OA[NOda0`0Q@Dn?VE_OUO:V5K]6?TE^OVO;X5I]6b0QE[OVO=\\5HZ6f0nDJg4CY6d0oDIh4EW6b0QEJh4DV6b0REJh4FT6`0SEKj4FQ6`0TEJk4GP6?UEIl4Jm5=WEIl4Lk5@hDa0a05k4Li5_OlD?b05h4Ni5^OnD>b04h42f5\\OQE=a0J\\OJ\\5e0d5YOVE;?BZO46NW5j0b5WOYENI4f0KZO36MX5m0^5VO\\EMI3f0MZO1j5n0o4TO^EMI2g0MZO2i5P1m4ROaELH2i0MYO0i5W1i4nNdEMHOQ1Oj4Y1g4lNmEKc0Oj4\\1d4jNPFJb00j4^1b4hNZMX1d2hN\\M[1b2bN`M`1`:1N2M301K4N2N2N2M4M2O1N2N2N3M2N2O1N2N5K5K6I7J5K6UAVLT=P4fBVLU=n3eBSLX=V4aBkK_=[4ZBfKg=^4SBcKn=b4kA_KU>g4eAYKZ>W500O11OO1002NO1O100O100", "size": [640, 426]}, "area": 24633.0, "iscrowd": 0, "image_id": 10249, "bbox": [0.0, 187.0, 426.0, 453.0], "category_id": 111, "id": 10012533}, {"segmentation": {"counts": "`1h0Xc0O100001OO1O10O01O1O1000ON3Ld\\OC^c0<3G^\\O4bc0K_\\O5Y^b2Iia]M1NOO230Vc0=i\\OC10jb0NU]Og00[Okb0P1N01001O1OO1O1001OO1O1001O00O1M3N2K5O100O100O1O1O100001O1O00O1000000001O0000N20000O11O1ON2O1001O00002N1O0000001OO1M30000O1O1N22N1O000000O100002N0000O100004LO100001O2N3M2N0000002N1O003M0000001OO11O001O0000O10000O100000000N21O00O11O0000000000O13MO11O1O1O0000N20000001OO100O1O1O1001O00001O00001OO11O00001O1OO11O000000001OO1O100O100O1O100O1O1O1000000O11O1O1O1OO1N200002N1OO1O100001O1O0000O1O100001O1O1OO100001OO1O11O1O00000000001O001O00001O0000O11O3M1O1O1O5K1O1O001OO11O00O1000000000000O1000000O10000001O3M1O000o]O\\Nfa0o101O2N00M300001O1O1O001O1O1O000000001O00", "size": [640, 426]}, "area": 9848.0, "iscrowd": 0, "image_id": 10249, "bbox": [0.0, 0.0, 426.0, 72.0], "category_id": 120, "id": 10012534}, {"segmentation": {"counts": "nb0R1nb00O1001O00O11O001OO100O1O1O1O1000000N2O100002N00N20000O100O100001OO1O11O00001O00N2001O1ON200001O1ON200N21O1O00KfNd]OZ1]b044L1OO11O00N2O12N00O100O11O1ON2000000O100LcNf]O\\1Zb0dNe]O]1[b0cNd]O^1]b0200O11O0`Ne]O[1U7dNP4^1PLcNo3]1PLfNn3Z1QLhNo3W1QLhNP4X1oKiNQ4W1mKkNS4U1mKjNT4V1lKjNR4X1mKiNS4W1mKhNT4X1kKiNU4W1kKjNU4U1kKkNQIHo:0PE[1o6nNQIGU;Z1jKROW4m0iKSOY4k0gKUOX4h0iDmNo6:Y4c0kDRON0e62\\I;U;a0jKUOoH:X;`0jKFV4;iKEW4:iKEY4;gKD[4:eKG[49eKG[49eKGZ4:gKEY4;gKFX4:iKEX4;gKDZ4;gKC[4>dK@^4?dK^O^4b0bK]O_4d0aKYOa4g0_KWOc4h0^KVOd4j0X711N2OO10O01001Fn\\O_OO2Sc0?n\\O@OOUc0>:N4M1O102M4M]Z>NeeA1J1Y\\OOgc05N212L1\\OEa]O>^b0c0N102N0O2O000O011OO1O01000N3O1O1N1101ON2O001N2M3O0000001O0M3M3K50cDFT3;gLH[37bLL_34\\L0e3OXL3i3MSL7n3InK9T4FhK>Y4@eKb0\\4]OeKc0\\4[OeKd0]4[OcKe0^4[OaKd0a4\\O^Kd0b4\\O_Kb0c4]O]Kc0d4\\O\\Kc0f4ZO]Ke0o;01N2O1N100O2O000O1000000000001O00001OO100001O00000000000000001O000000000000000000000000000000000000O101O001000O01O001O10OO2O001O1O001O1O1O1M301M2O101N1O1O101N1O100N3N2NgN[]OZ1db03M3N3NOO01O0000010N0]Oc]OE]b0;d]OUOO;^b0?c]OTO1<]b0`0g]O^O[b0a0f]OZO_b0e0b]OVOdb0h0;N_B]Oh7McBb0f5Fc7;]HJ]77cHOX70hH6S7ImH0Ig1La1[2a7aMWE?OJi1Gc1_2_7`MWE?LM_5P2d5bN\\J^1d5bN\\J_1c5aN]J_1l4cM[Fm0i4a1j4dMlEN9m0P5b1l4bMiE2:j0Q5b1l4bMhE3;i0R5a1k4cMiE38j0KSOP5]2S5dMjE50JOl05UOR1O`2]2`6QNhEC1k05VOQ1O`2\\2b6QNfEC2k05WOo0Oa2\\2c6TNhE:4ZOm0MPOL^3`2i6SNiE93\\ONIg03XOM`3]2f6UNjEGO44KMIg02YON`3[2e6WNkEC271KMIg02XOOb3Y2d6XNkEA3:0KLHh03WOOc3V2e6ZNkE_O2=0JMHf0:k2n1e6ZNVFLG1c0Kk2n1e6ZNUFMH1b0Jm2E[LU2Y:^NUFMH1b0JP3l1_6\\NWFMH1a0KQ3k1_6\\NWF]OC<37c0IR3j1^6]N[FIB7c0HS3l1\\6\\N[FJD5b0IT3k1\\6]NYFJE5b0IU3i1\\6_NXFJE6a0GW3l1Y6^NYFHH6?HX3i1Z6aNWFHH6?HY3h1X6cNWFHI5?H]3d1T6hNWFFJ4?J^3b1Q6kNYFDI5?Ia3`1n5oNXFDK3=Kc3^1m5POXFDK3=Kc3_1l5kNlE\\O<UM^@2P1g2d>^M^A`2a>bM_A]2a>bM_A_2a>aM_A_2a>aM_A^2b>bM]A_2c>aM]A_2c>aM]A_2b>bM]A^2d>bM\\A^2e>aM\\A^2d>bM\\AFoNd2e?fM\\AEoNf2e?eM_AZ2e>cM[A]2f>_MU@MU1d2i>\\MS@OS1f2j>[MYAe2P`001000N2O10O1aMl^OR2Ta0lMR_OP2n`0nMY_Om1h`0PN^_Ok1c`0SNc_Oi1^a0L5K4L4K5L5K4L4L3L4M3M2N3M2M4MoSd3ORl[L1T\\OOgc01W\\O1Zb0Bg]O=Yb0Cf]O>c4BT8ORC16?d4AT80QC17=d4CR81RCO7>U2@F7k:OoBM;8AHd2OA9o:KPCM<6BHc22[O0IM\\25ROb0W;GSCE?OJN[26mNe0\\;DRCE?Ld27ZNk0^;BjFDcMn0b;_OkFE^Mo0g;\\OjFGZMQ1l;YOiFGQMY1W<_NUC9c30fLa1cRFd2n9\\MRFd2n9\\MlBCh\\ODWc0c0O1O0100N2N111O1O11OOO1N20O111M2N01O4M0010O1O0O10O1O01002OOi\\O\\OSc0c0l\\O_OTc0f0O101O011M2N111O0O1O00001O01O001O00010O01O0O1102M1N2O1N6J2O10O100N111N0O1000O1000000Jj\\O@N0Wc0a06O1001N2O1O0001K7L2N1000[^<", "size": [640, 426]}, "area": 2648.0, "iscrowd": 0, "image_id": 10249, "bbox": [207.0, 14.0, 199.0, 60.0], "category_id": 169, "id": 10012537}, {"segmentation": {"counts": "QkS66jc01N3N2N1O2N2N1O2N2N101N2N1O2MO2O1O0O2000O101N1000000m\\OUOPc0l0P]OTOQc0P1N2M102M000k]OkN_a0U1a^OlN^a0T1a^OnN^a0R1b^OPO\\a0P1e^OPOZa0P1e^OROZa0n0g^OROXa0n0i^OROVa0n0j^OROVa0n0j^OROVa0n0j^OROWa0l0j^OTOYa0h0i^OWO[a0e0e^O[O`a0?a^OA`a0>`^OB`a0>a^OA_a0?a^O@`a0?a^OA`a0>`^OB`a0>_^OCaa0=_^OC`a0=b^OB^a0>c^OA]a0?b^OA_a0>W^O@F2Rb0>W^OEDNSb0>Y^OEBNTb0>Y^OOfa02Z^ONea03Y^OOfa02Z^ONea03Z^ONfa02Z^OLga05X^OMga02Z^ONfa02Z^ONfa02Y^OOga01Y^OOga01Y^OOha00W^O1ia0OW^O1KZOea0e0`^O1I_Oda0`0c^O1HAca0?e^O>Za0Be^Oa0Ya0^Oh^Ob0Xa0^Oh^Ob0Xa0^Og^Od0Xa0\\Oh^Od0Xa0\\Oi^Od0Va0[Ok^Od0Wa0[Oi^Oe0Wa0[Oi^Oe0Wa0[Oi^Oe0Wa0[Oj^Od0Wa0ZOj^Of0Va0kN\\^O9`0k0Sa0mN^^O7?l0Ta0lN]^O8?l0Ta0kN_^O8=m0Ua0iN_^O9=o0Sa0hNa^O7=o0aa0kN_^OT1Xb0N1O1O2M2M402L2N1O1N200O10000000_G", "size": [640, 426]}, "area": 4091.0, "iscrowd": 0, "image_id": 10249, "bbox": [313.0, 220.0, 113.0, 87.0], "category_id": 178, "id": 10012538}, {"segmentation": {"counts": "l`0Z1j:ROQJc3m1>`KV2Z3nNnKk1T4SNmKm1T4PNnKP2S4nMmKR2U4kMmKU2T4hMnKX2T4^MYJXKe1Y7T4]MSLc2n3\\MQLe2P4YMQLf2Q4YMoKg2R4WMoKi2R4UM[KbKTOX7c5TMUKkKUOR7h5PMoJULWOk6k5nLkJ]LXOd6o5nLfJdLXO^6S6lLcJkLWOZ6W6iL`J_4b5`K[Jc4f5[KXJh4i5VKUJm4m5QKQJP5T6lJiIW5\\6dJaI_5d6]JYId5i6\\JSIg5m6[JnHh5S7a32O1O1N101O1N2O001N2O1O1N101O1N2O1O1N3N1O1O1N2O1O1N2O1O1N2O1O1N3N2N2M3N1O2M3WFQH7UO`5l8TJeHDdNX6j8mIiIR6\\6gIgIY6^6YIjIh6g9O1000O10O10000O01000O1000O010000O10O10O1000O010000O10O10O100000O010000O10O1aMRIlGm6S8YIiGg6U8`IfG`6X8fIcGZ6\\8lI`GT6^8RJ^Gn5`8YJ[Gf5d8`JXG`5f8fJUG[5j8jJRGU5m8RKnFn4P9XKlFh4R9^KjFa4U9dKgF]4W9hKfFX4X9mKeFR4Z9RLdFn3Z9WLcFi3[9[LbFf3\\9_LaF`3^9b3N2N1O2N2N1O2N2N1O2N2N101O1O001O1N101O1O001O1N101O1O1O001N2O001N2O001O1QN^D^Kc;a4dDYK];e4jDUKW;i4TE`JY;`5d1O1N110000O101O1N3N1O1N200O0100O1O001O1O010O1O1O001O01O0000010O1dDjIl8V6PGnIP9S6kFPJW9P6dFTJ]9l5_FWJa9j5ZFYJh9g5TF\\Jm9c5oE`JS:`5iEcJX:]5dEeJ]:\\5^EhJc:X5YEjJi:V5REnJo:Q5nDQKS;S5eDQK\\;W5XDkJj;e61N2O001N3N1N3N2\\JlCW3WFgNK0l7k0dH?^OeN32M0o7j0aHc0AhNn7e0`Hm0a7TO_Hk0a7UO_Hi0c7WO\\Hk0d7TO\\Hl0d7VOXHn0g7ROWHR1e7ROVHnNNo1l7Z13O4KO1O2O2NOO2O1O1O001O013OOVHbLg7_3I8N2N01100O0001O010N03N104K000O1lHPLQ7S41N4M0O100O12N00O2O001O0N20O010AYLVIM0l3i6ZLUIJO10k3l6>01O1O0000O101OO010O100ON21O00O12ON6L000kKQIP4o6QLQIo3R72O12N00L41O0000O10O2O0O1O20O2ON2N012ULlH^3a7N1_LZH]3i700O2M12O00000000O100O100M2N23MN32N0O02N05L00O1O1O1001M2J4N401OO1O010001O0^H]L_7c3`H^L`7b3`H^L_7f30MaH\\L`7d3`H\\L`7c330N3O1O00N200000O2O00O101OO100KMgHaLU7c3mHZLT7e34ZLfHg3X7[LfHf3[7301N2NO2O110O0OIULTIj3l6WLnHn3o6QLPI11o3o64202M12OO0O0100000O11O02M20K40001O1O00O10O100O02O1N3N000M3000O1O1O1O01010O2N012L11O1N2N100001ONNRLnHi32VLo6m3710OMTLjHl3V7TLjHm3V7O30000101N01N1N1100N2001N11M4M011OO1O2N1001N101N10MlHQLT7P4211N0O2O01OO001O12ON11ONgHULY7k32O1N2O002N1000000OfIbLl4_3nJhLQ5Y3hJnLW5R3cJUM\\5k2`J[M^5d2bJ^M]5a2bJbM\\5]2dJfMZ5Z2fJhMX5Y2fJjMY5V2fJlMW5V2gJlMV5V2iJkMV5V2jJkMU5U2jJmMT5T2kJmMS5V2lJkMS5U2lJlMT5T2kJnMT5R2kJPNT5Q2jJPNW5o1hJSNW5o3010O01O10=Ba0_O5K5J5I8J6J2N2N1O2N2N2N2O001O1O1O1O1O001OO100000001O000O1000000000000O10000000000O1000001O00000O100001O00000000M3M3M3M3M3M3M3M4K4I7H8I7H8I7I7ROn0002N001O1OO1001oIjJn5Y53L8G:H8G8eKmHR4V7N01O1O00000000O3N030nKiHn3X70005K01O001O00N21N10100O0N4N1N110O0O20lKoHo3T71OOOQLmHo3S7QLlHo3T7311ON5L0LhHWLZ7e35102OOO11N02OO2O02MkLcHa21nL2NQ7=mHEOX31hLU77TIGGS3OPM2MQ70mH003?o2AQM2MU72YIU3AjLV7O]IU3\\OnLi7NWHT30oLh7Z3000000XHbLf7`30000010ONgL]HJOT3e7QM[HL0T3R8OO01OO101O2N00000010OO100N2KgLZHZ3b780O11O02N00001ON3O2O0O0O00cLbHR3e7fL\\HY3l7L3OoGkLP8V3O101O0O2O001ON21OO01THfLj7Z3VHgLk7OWHW3n70PHiLl72THQ31mLm70RHT30lLS8U3N0100N02N1O2O0100O0O100O11O00001O001SHhLh7\\30O20OOkJ", "size": [360, 640]}, "area": 150874.0, "iscrowd": 0, "image_id": 10256, "bbox": [0.0, 0.0, 640.0, 360.0], "category_id": 119, "id": 10012540}, {"segmentation": {"counts": "l1S1T:11O100N01001O0NjEROV:n0021O1N9TO_EO0`01Aa:`0^E@b:c001O1_E[O]:h0OXOdEf0_:1M3N21OOO1UOeEk0[:0O2O3LROoENMf00ZO]:h01\\OaEFgNK0l7k0dH?^OeN32M0o7j0aHc0AhNn7e0`Hm0a7TO_Hk0a7UO_Hi0c7WO\\Hk0d7TO\\Hl0d7VOXHn0g7ROWHR1e7ROVHnNNo1l7Z13O4KO1O2O2NOO2O1O1O001O013OOVHbLg7_3I8N2N01100O0001O010N03N104K000O1lHPLQ7S41N4M0O100O12N00O2O001O0N20O010AYLVIM0l3i6ZLUIJO10k3l6>01O1O0000O101OO010O100ON21O00O12ON6L000kKQIP4o6QLQIo3R72O12N00L41O0000O10O2O0O1O20O2ON2N012ULlH^3a7N1_LZH]3i700O2M12O00000000O100O100M2N23MN32N0O02N05L00O1O1O1001M2J4N401OO1O010001O0^H]L_7c3`H^L`7b3`H^L_7f30MaH\\L`7d3`H\\L`7c330N3O1O00N200000O2O00O101OO100KMgHaLU7c3mHZLT7e34ZLfHg3X7[LfHf3[7301N2NO2O110O0OIULTIj3l6WLnHn3o6QLPI11o3o64202M12OO0O0100000O11O02M20K40001O1O00O10O100O02O1N3N000M3000O1O1O1O01010O2N012L11O1N2N100001ONNRLnHi32VLo6m3710OMTLjHl3V7TLjHm3V7O30000101N01N1N1100N2001N11M4M011OO1O2N1001N101N10MlHQLT7P4211N0O2O01OO001O12ON11ONgHULY7k32O1N2dNdHkN\\7o0lHoNV7m0nHQOS7n0oHQOQ7n0QIQOo6n0SIQOm6o0TIoNm6P1UIPOk6n0WISOh6l0YITOg6j0[IVOe6h0\\IXOe6g0\\IXOd6g0^IWOc6h0^IXOb6h0_IXOa6f0aIZO]6f0dI[OY6f0iIYOV6h0kIWOU6h0lIXOS6h0oIWOo5k0QJVOn5i0TJVOl5j0UJUOk5j0VJVOj5i0XJWOh5a0`J^O`58jJHV53PKKR51T3L4M4L3L4M3LTQh0h0RnWO6J8dNPOVHV1f7]OeGj0V8W1K3M4L5PHiLi7^3K4L3M5K4M41N01O1O00000000O3N030nKiHn3X70005K01O001O00N21N10100O0N4N1N110O0O20lKoHo3T71OOOQLmHo3S7QLlHo3T7311ON5L0LhHWLZ7e35102OOO11N02OO2O02MkLcHa21nL2NQ7=mHEOX31hLU77TIGGS3OPM2MQ70mH003?o2AQM2MU72YIU3AjLV7O]IU3\\OnLi7NWHT30oLh7Z3000000XHbLf7`30000010ONgL]HJOT3e7QM[HL0T3R8OO01OO101O2N00000010OO100N2KgLZHZ3b780O11O02N00001ON3O2O0O0O00cLbHR3e7fL\\HY3l7L3OoGkLP8V3O101O0O2O001ON21OO01THfLj7Z3VHgLk7OWHW3n70PHiLl72THQ31mLm70RHT30lLS8U3N0100N02N1O2O0100O0O100O11O00001O001SHhLh7\\30O20OOkJ", "size": [360, 640]}, "area": 57292.0, "iscrowd": 0, "image_id": 10256, "bbox": [0.0, 55.0, 640.0, 219.0], "category_id": 175, "id": 10012541}, {"segmentation": {"counts": "_RV43n:8L4N2N2N2O1dGAl5a0nIFo5XEA0031d:`0XE_O050L0Oe:P1N3]GmN`6V1aGlNR1OPOON006ON14Q8Y1nG`0R8c1O000000102M00YLRHe3Q8XOoGfMT8X2QH`MS8Y2i00000000O11O00002N1OL41ON2N23M10M2O01010O00001OO101O07RG^MZ8U3J0O2OO0101N2N01O100000000WOoGZM:KG2P8X1oGhN1N510OY11c6T7AnH=R7CnH=R7CoH0O11OO1001O00N21mI", "size": [375, 500]}, "area": 1711.0, "iscrowd": 0, "image_id": 10263, "bbox": [394.0, 181.0, 106.0, 32.0], "category_id": 156, "id": 10012550}, {"segmentation": {"counts": "nPb41e;1]D5Z;5iJEPO9Q1ImN9Q1IcJLY1a0GL[4LQJH;OJ1^1c0jN\\O88YO6a5BkJ?2AC7OI10O022NNP1l0ZOYO8g0m4VOkJ>3nK^OJiLX4i3oK\\OT4ZNdKcN1015OK7c0IK8@GW20jM5?W4l0nKeNf01PO6477Q1c0jNTOG[4Z1WMeNkN9NV1`0jNf3S1bMnNWNU1a0jNf3S1cMmNWNU1a0jNf3S1bMnNXNT1a0jNe3T1bMnNYNS1`0kNd3U1cMmNYNS1=eNTO;_4o0gMmNZNT1;SOd3l0hMmNYNU1?iNb3J_K[1W2mNYNT1a0iN`3X1gMjNYNS1a0kN_3X1gMjNXNT1c0iN_3W1gMmNWNQ1d0kN[3Z1iMkNXNo0e0lNY3[1iMkNYNn0e0kNZ3U1dKhNV2;VNn0e0jNZ3U1QNSOPNn0e0jNX3V1TNROoMn0h0gNT3Z1UNQOoMo0T50mLQOoMo0S51nLPOnMP1T50nLoNPNP1Q52oLnNPNP1P53PMnNPNn0P54PMnNPNn0f0gNP3^1[NlNPNP1b0hNR3^1[NjNQNP1[4d0ZNoNVN0WO>X4c0JnNnK>X4e0>[OCc0>^OAb0?^OAa0`0]OBc0>^OAK", "size": [375, 500]}, "area": 17180.0, "iscrowd": 0, "image_id": 10263, "bbox": [398.0, 23.0, 102.0, 342.0], "category_id": 171, "id": 10012551}, {"segmentation": {"counts": "o1i6o4O1O0O2O1N100O2O1O00001MiJdIX5[62O100O2N101N2O0O100O2O1O1\\LZJT1h5kNXJeM020X3h5QO`JeMJT3g5VOdJh0^5WObJh0_5XOaJh0`5VOaJj0_5VOaJj0`5UOaJi0`5WO`Jh0b5SObJm0^5TOoInM`0n2b5UO^Jk0b5UO^Jj0d5ROlIQNa0l2d5hNlI]NO0f0l2_5gNeJ[1]5eN^J^1c5cNYJ`1g5`NWJb1h5_NXJa1g5^N[Ja1i5^NUJa1m5^NSJb1n5]NRJc1o5\\NPJd1R6[NnI1B0a6OmI1B0b6NlI2BD0TOd6g0]IZO>k0BTOOM0K67KHO162JNg6o0^IPOM1>c0A\\Oc00g7o0cHTORON020NX9m0`10O01O100O0001O01O0100O01O0001XESOe:T1K1O00O11O00O1001O0O1O10000O1000O11N10O2O1O0001O00iNbEU1a:N11O00001O00000O10GbEYO_:f0aEZO_:f0cEUOa:j060O01001O000000000MTOZEm0f:110O1000O1001OO11O001O0000O10O01SOZEh0g:VO\\Ei0d:WO\\Ei0i:01N1O13L100UEVOj:i0VEWOj:k0000001OO10000N2O12N0000002NO1001O0O1cHUOn3l0WJTOaNN02Ob13]Nm6l0QIUO0Y30gLo6k0PId20aLQ7^4oHdKo6b40O11OO11OO11O00O1O100O2O0O11O000000YMmHj0S7UOnHk0R7[NmHPO11O10<1X2Q7ZNRIPOL110O:1[2Q7ZNXIPOH1N61_2Q7YN]IROA0031b2Q7XN_IRO_O050L0Oc2S7ZNmIf1T6WNoIV1mN_NU7;QJWOlNR1OPOON006ON1\\7i0QJVOg7k0b10000000O20O00WETOg:o0O1O00E[E\\O14d:>bEA^:>eE@Z:`0`0N010O1010O0000001O0102L10O2L31OO02O0O0101VE_O\\:a0dE@[:a0cE@]:`0cEA\\:`0aEB_:j0100O100O1O1000001O0000QHUOZM:KGZ7h0PJWOhN1N510OY1Z7ZOSIXOF0Mi2Z7oMjHXOO4Mj2[7QNeHX2[7R11O000000O1001OMhKgHX4Y73O1000000001O00000000O11OO10001O0001O00O11OO100000000001O1O00O11O0O20M21O00000000O10000000000001OO100000000000000000000000000001O0000000000O1000010OO1000O11O01O00000000000O10000001O000O100001O00000002N00N2000bNiHQMOY1X7\\1hH[MZIDg1Nn4?[ICg1Om4=^IVO^O30N000OW2=m4=aIXOk1:c4?cIUOj1=b4?WLAh3?XLBkLFc6f0dLEfLJ`6c0kLCdLIa6e0lLAcLK`6c0nLMQ34PMKP34QMMm24SMLm24SMMk24UMLk24VMKi2IfIIb3QHCl7?UH_Ok7ROoGo0:gN7PLCP4=oKDQ4jFCT9a0jF^OW9c0hF]OX9d0fF\\O^OMl8h0eG[O^O1j8d0cGAALl8c0aGCCJl8d0^GCFJl8c0[GDJJk8b0YGFLHk8b0WGHMGm8`0TGKOEm8`0RGL1En8b0iFIi9@WFb0i9ROYFTOOk1h9QOaFP1_9PO`FQ1`9PO^FQ1b9oN]FBF3=G`9d0\\FCKJ?L[9g0ZFD1@?3W9j0WFCS1@g8m0VFCX;=gDDY;=eDC];TD60\\O02f;=ZD40Ee;6[Da0c;d00N20O2O0\\D]Na;0_D`10_Ne;c1N2000O200I[DdNh;[17J3K5L5J5L4K5N110000L4O11O1OVD@SO1c;`0WEEi:;UEHk:7nD0R;0mD0T;0iD7T;IgD;Y;DbD>c;c011OO2ON3L3O1000O1N2N21YD^Nd;e1O1O1O1OO100O2O000O101O0000O1000N2O2O1O00000001M1110N11OO110N2OM3O10N2010O01O0O1bNVD\\1m;O1OO1O11O00M12MTDiNm;T1TDjNn;U1RDmNm;S1SDlNn;S15M5N01O1O00O00011O0O1O101ON1000FhCCY<:iCE[<9gCDZ<<91O1001L4O00M3N3K4ON_C]O`m0P9g25N200O100000PG_LW8a3iG_LW8b3gG_LY8a3XG]L74`8_3YG^L63a8_3XG_L4NH508]8^400000001O000fHTKV6l4iIUKW6k4]IUKB2Q7i4]ITKA5R7h4\\ITK^O7V7e4UIhKj6\\50O10000O1000000O1FkH`JT7m4gHPKg00c6l4Q1O100001O0000001[HRKl6l4VITKj6m4TIVK\\OMZ7m4ZIZK^OIR7m4_I\\K\\OIU7l4\\IcKc6]4YIRKCc01]On6n4]ISKDg0n6V4^IoKCSOl6m4cIQL]6Q4_IQLa6T4ZImKe6X4UIiKk6[50001O1OO1001OhMXIoMg6S2ZInK6[1`6j2[IgKb0R1S6Z3UJcLk5_3SJbLl5a3RJ^Ln5e3oIYLS6j3kI[K]OKOe0i6W4dI_KE8i6\\4UIfK3Mh6U5XIjJh6W5WIiJi6W5WIiJi6X5WIgJi6Y5VIhJj6Y5UIgJk6f4VIZK0Nj6j4aIkJE:k6b4WIPKe0=T6a4TIRK30e0=T6_4UJaKk5_4VJ^Kl5b4TJ]Km5c4UJYKm5g4TJTKP6l4W12N00N21O00O11O1O0000O11O1O004L00001O00O11O1O00LnGoJS8Q53001O1O0000M3O1O1M300M300000000000WHYKo6g4oH`Kl6a4RIfKh6Y4WIlKf6R4ZIPLf6o3ZIQLg6o3WISLi6n3TISLm6m3RIhKDK[7_4mHgK_7Z4_HeKc7]4YHdKh7n41O1NhHhJb6W5[IoJc6P5[IUKc6i4\\IZKd6e4ZI]Kg6c50O1O1O1O100O1O1O100O1O1O1O1^Ob0000000001O1O0000000000O11OO11OO11O00O1jMRHQOm7o0THQOk7o0VHQOi7n0YHQOg7P1ZHnNf7R1[HhNIWNm7Q3[HgNi7Y1XHfNh7Z1YHeNg7\\1YHcNg7]1ZHbNf7^1ZHbNf7^1[HbNd7^1]HaNc7_1^H`Nb7a1^H^Nb7c1]HQNGoNl7P3^HkMOQOc7U3^HeM4UO^7V3_H^MC\\Ob00[7V3aHTMKF90[7U3fHjLM1T8T3]10000000000000000000000001O0000001O00000000O11O00M3001O4L000000000000000000000000O1000000ORJQMc1n2\\NXM`1h2_N]M]1c2cN_M[1_2gNcMW1[2jNhMT1W2mNkMQ1R2QOQNm0P2RORNl0o1SORNl0n1SOTNl0n1ROSNm0n1QOTNn0m1QOTNn0m1QOTNn0m1POTNP1l1POUNo0k1POVNP1k1oNSO3m0M^OH`09BF>:CE=;@H?8YO1d0ULPMj3X25h0RLoLh3n1b0S1AcNi0^1VO`Nl0`1SObNl0^1TOeNi0\\1UOQO?o0ASO=n0BUO;l0CWO;h0FYO9h0EZO:f0F[O9e0F]O9c0G^O8b0G@8`0HA7?HWO_LmMi3l2HVOaLnMf3l2HWOcLmMd3l2InNnLUNX3m2ZLlL]3o1UMXNS3m2[LlL]3l1XM\\No2o2IbN\\M_Nj2o2JbN\\M`Ni2n2KbN]M_Nh2n2nMjLTO5;d1K^Ni2P3gLhLH1l00]OOE>n0]1L[Nj2R3cLoLg0i0Ok0MYNl2U3ZLTMn0c00j0MWNm2h3TMYM1i0h3o1nKaM9`0i3o1kKdM`1@bN`0^1@bN`0^1@bN_OiNRMf2_3aNYOe2g0\\MSOi2m0XMmNm2S1SM^LnMY2Q5Y1RM\\LnMY2R5[1SMbNP3^1QM_NQ3a1oL]NS3b1nL\\NT3d1lLWNY3i1gLRN^3P2`LkMe3U2ZLjMh3W2WLhMj3X2VLgMk3Y2ULfMl3Z2SLeMo3Z2RLeMo3[2PLeMQ4\\2nKbMT4^2kKbMV4]2jKcMW4^2hK`MZ4`2eK_M]4a2cK]M_4c2`K]Ma4c2_KmLQ5S3nJjLV5V3jJgLY5X3hJeL[5Z3fJcL]5]3cJ`L`5`3`J\\Ld5d3Q2O1O1001OO11OO1002N1O1O1O1OO11O1O000000000000000000O1O100O10000000000001O00O11O00001dIYLS3h3jLWLoL0R62nIj3m2ZLR3NPJi31SLi27S3S4iLoKV3R4jLnKV3S4aLdKgM;g5R4bLULZ3n3eLSL[3n3cLSL\\3n3dLQL]3o3bLRL^3n3bLQL_3o3_LSL`3n3`LRLa3m3_LRLb3n3_LQL`3P4_K]KoN1LOa0b0V5P4\\KaKPONK2b0?W5o3ZKRL_OOW5P4YKRL@MX5P4WKTLALY5o3VKULALZ5m3UKXL@L\\5k3UKVLAOZ5l3SKVLCN[5k3lJcKYOe0`0M]5BQJQ4e0hLMEd5c3\\JkL0Bd5c3[JlL1Ad5c3XJoL6\\Ob5e3WJoL6^Oc5c3VJPM7]Oc5c3WJoL7\\Oc5e3TJQM6^Oe5b3QJSM:[Oe5c3iIXM7aN5b0k5[5iISJ01<`0k5c5oImIL?OAR6X6nI\\J0\\O02l5W6TJZJ0Ej5Q6VJfJj5]60N2001O0TJeHi5[7WJdHj5^700000O11O3M00O1001O00O100000000O100000000001O00O14L00L4O11OO1001O000000O1N2N21RJeHk5^7bKeHk2\\7SMhHj2Y7TMjHj2W7TMlHj2S7WMoHg2Q7XMRInNEZ3X7hMVImNFV3T7lMYImNCV3T7mM[IlN@W3T7mMlIR2T6mMnIR2R6nMnIR2R6nMoIQ2Q6oMPJP2P6PNPJP2P6PNQJo1m5SNTJl1k5UNUJk1k5UNVJj1j5VNWJi1i5WNWJi1i5WNWJi1i5WNWJi1j5VNVJj1i5WNWJi1j5VNWJi1h5YNWJTOdNn1V7mNVJSOiNm1P7QOWJPOmNm1m6ROVJPOPOl1i6UOWJmNROn1g6UOTKj0l4VOTKj0l4VOUKi0i4ZOVKf0j4ZOWKe0j4ZO[Ka0e4_O[Ka0e4_O[Ka0d4@\\K`0d4A[K?e4A[K?e4@\\K`0d4@\\K`0d4_O]Ka0c4_O]Ka0c4^O^Kb0`4@`K`0]4TNnHZ1f2b0[4UNmHZ1i2a0Y4UNPIY1g2b0Y4UNoHY1Y2iNlMn1k6^OXKn0e4TO\\Kl0d4TO\\Kl0e4SOZKn0g4POZKP1f4POYKQ1f4POYKQ1f4oNZKR1f4nNYKS1g4lNYKU1f4lNYKU1f4lNYKU1g4jNYKW1g4iNWKY1h4hNWKY1h4gNXKZ1]4WMhI`1j1Z1[4XMjI`1j1Y1\\4YMgI_1l1Y1]4ROaKo0_4RO_Ko0a4ROZKR1f4oNWKS1f4QOZKn0f4SO[Kk0e4VOaKc0_4^OcK?^4AcK=]4DcK;Z4[MjI\\2k18[4]MiI\\2m15j3`M[J0OO01O]2l12l3kMXJ[2j1Hn3h0QLWOo3l0oKSOR4n0YKgL\\O\\2[5Q1TKjLZOV2c5R1nJPMXOo1j5U1hJ@V5[4001O00N21O1O001O1OO100M32NO1000`HXJ^7j500000001O", "size": [426, 640]}, "area": 155253.0, "iscrowd": 0, "image_id": 10276, "bbox": [0.0, 72.0, 640.0, 354.0], "category_id": 124, "id": 10012561}, {"segmentation": {"counts": "R[^511020P=601TCJb<7[CKf<4ZCLf<6WCLh<;001O0O1000O1001O2N0OO21O000O11O1O0000002NO1002N1N4MM300100N0N3PGZOdL1LO^8f0QK]OdLNK2]8e0QKKn46RKKm46QKKo45QKKo46oJKQ56oJGS5:kJGT59gJSOPMe0Y87eJ1[5ObJ4_5L_J5a5K\\J8d5IZJ7g5JWJ7i5JWJ5i5KUJ7k5JQJ9o5HRIPOTO^1k7DoHROnN_1R8_OmHVOnN]1U8\\OkH\\OkN[1Z8YOkH[1T7gNiH\\1V7cNkH[1W7eNiH[1W7eNiH[1W7eNhH[1Y7eNgH[1Y7eNfH\\1lNaM[8R1gHc1X7^NfHb1\\7^N^Hh1d7WNWHm1i7XNoGl1P8\\NfGg1Y8e1O4M00001O000000O101OOM3WKdGc4_8]KaG^4e8`K\\G[4i8eKXGU4m8kKSGP4W9KhFULY9f38H^FfLe9Y36L5K4M3L4L4K5K3M3M4M2M4M2N3L5K5L4K5K5L4I8K4L4M3BZC5iZFS1J^Nl9?[FQ1K\\Nm9c0XFo0L^Nm9b0XFQ1S:oNmEP1T:POlEk0Y:UOgEd0`:\\O`E?e:A[E9k:BgDE>a0S;J`DD=j8BVG8P9HQG3S9MRGKQ95WGAk8?P20000000000000000000000O100000000O1O1O1O100O1O10000001O1O1O001O1O2N00001O0000O1O11OO1O1O10000O10_EDT8eG1VNBS:=fG3VNAS:<_G<]NXOT:<`G;]NYOR:h8BYG>f8BZG>f8A_G;a8D`G<`8CaG=_8CaGTOkNP10lNe9P1gG2\\8NjGH^NYOi9o0iGE]8hGCW8=hGDX8kEESOMQ;>mEB^:`0U1IXCLj<0YCOg<0\\CNd<1R;IlEi0m9]OSFc0^7SOmIa0a2_OQMN`0OA3=_7C`H=[\\D]Oa0c0_OYOd0h0\\OSOi0m0WOQOk0o0UOQOk0o0UOQOk0o0VOPOi0Q1VOPOj0o0VOfIGc41mKR1j5VOfIG^47QLl0k5WOdIG[4RN<\\8TO_Ic0WN7]8ROZIk0ZN1]8SOUIP1_N@0\\O]84oHT1fNWOl8DZHY1jNnNQ9IPHa1lNaNY9NfGe1j8\\NRGf1o8[NjFj1Y9VNbFn1]9SN_FP2a9QN\\FR2c9oMoEI5[2l9lMmEL3[2P:8PF`Mo9a2VFXMl9W2oERN^:j1fEnMI3b:k1jEQNE3a:h1nEVNBOa:j1oEVNAO`:[1]EhNn0Mj9c0XE]O88o0I`9b0eEDk0I_9d0dECh;=VD^OPmCFm;=RDBn;`0QD@m;P1N101O1O1O001O1O001O00001O00000001OgDeNc:[1[EjNb:V1\\EnNb:S1\\EoNc:Q1[EROd:j101O10O01O5K000001O00O100O100O100O1O10O0A`00O0100O010O1O001O001N2O001O1O001O1O1O2N2M3K5O1001O6J2N1O01O012M2O0O1N3ZOaDZOd;`0cDZOa;a0h0Ddk8", "size": [426, 640]}, "area": 23621.0, "iscrowd": 0, "image_id": 10276, "bbox": [30.0, 51.0, 588.0, 314.0], "category_id": 183, "id": 10012568}, {"segmentation": {"counts": "[XQ633Ok<8SCIj<>O0002N002M0O23M00O2O0OO3N1O1O1002N101NO11O1ON2O1O1002OO0000000001O00O10000O100O100N21O001O1O01OO10001O000000O2O0M31OO1001O0O11OO02O000001O1O00ON3N3M3O2L3O1O01O0O2mBJn<7RCLj<930N3N00O21N0O100001O1O00O1O10O3N6I2MlBMgb>0Z]A1Q=2nB0o<8L4M3L311NM31O1OOO\\O]Cd0c<21O0O01O10000000003M01OO12N10O1M4N2M12N2NO12NO11O00O1SJ", "size": [427, 640]}, "area": 2449.0, "iscrowd": 0, "image_id": 10281, "bbox": [463.0, 185.0, 177.0, 32.0], "category_id": 96, "id": 10012569}, {"segmentation": {"counts": "e;f1e;00000_N\\N[Gd1e8^NZGa1f8`NYG`1g8aNXG_1h8bNWG^1i8dNUG\\1k8dNVG[1j8eNVG[1^:O00001O001O00001O00001N1O]NdNZGZ1e8iNZGW1_8PObGm0`8SO`Gl0a8TO`Gj0a8WO^Gh0c8XO^Ge0e8ZO[Gd0h:M6J3M3M3M2N2N2N2N2N2OY:6aXOIl<:SCFl<=K500O1VD]Ol:c0SE^On:a0QE@o:`0jD@^O2h;>jDGV;9kDEV;;jDEV;;hDGX;9iDFW;:eDI\\;7cDJ];6`DM`;4_DL^;9_DGa;=\\DCd;>[DBe;`0XDAg;Q1L50O10000O100O2N010O1O1000000O01000O10;E5K0001@UO^Dl0a;a0O0O2O4K1O001O001O0O36MM00O_OYNZEj1e:`0aEcMm9]2PFeMQ:[2mEfMT:Z2kEfMU:^2fEcMZ:g200000010O01O000000000001O001O000O1O101M201O1N2O1O0001lLoEl2R:RMQFl2X:O1O00O100001O00000000O2N10000O2O001O00N10_FRMg8m2ZGTMe8l2[GVMc8j2]GWMb8i2^GYM`8h2_GYM`8g2`GZM_8a1hFZOi0WO]8^1mFZOe0YO]8]1PGYOa0\\O^8Z1UGXO<@]8X1YGWO8C^8U1[GXO6E]8S1]GZO4E\\8S1`GYO2F]8P1aG]OMGa8l0bG_OGJf8f0dGg0Z8YOeGk0Y8SOhGm0X8SOgGn0Y8QOhGo0X8POiGP1W8POhGQ1X8nNiGR1V8nNjGS1V8lNkGT1T8lNmGT1S8kNnGU1Q8kNPHU1P8jNPHW1o7jNQHV1o7iNRHW1n7dMcGe0`0g1m7`MhGg0g2R7VMSH9=K=f2R7ZMPH6a0KhNDOS2l5PNkJJb0?hNEIW2R6kMkJIc0`0gNEC]2W6gMjJHe0?gNZ2j5_MhJIh0>fNZ2k5^MfJKi0=fNZ2k5^MdJLl0;gNZ2i5_MbJMo0:fNZ2i5_MaJNP19fNZ2i5_MaJMR19dN[2i5_MaJMR19dN[2j5^M_JNT19cN[2j5_M^JK[OMg1>fN[2j5_M^JK^OMa1>iN[2j5^M_JKANZ1>lN[2j5^M^JJGOR1>oN[2j5^M^JJJOl0>RO[2j5_M]JHO0e0>UO[2j5_M]JH20?>XO[2j5_M\\JH708?[OY2j5`M\\JH904?]OY2i5aM]JG^1?]NA_Oe2X6eMbKFVO?DU2d5fMbKH_O2[O`2e5eMaKK7`2X4eMaKM5^2Z4eMaKO4[2[4gM`KN5[2\\4fM^KO8Z2Z4gM^KN9[2Y4fM_KN9\\2X4gM^KL;]2W4gM^KK=]2U4hM^KJ>^2T4hM^KJ>^2T4iM\\KIa0^2S4hM\\KJb0^2R4hM]KHb0`2Q4hM]KHa0a2R4gM]KGa0c2Q4gMhMY2X2hM\\KEc0d2Q4gMeMZ2\\2eMcM\\2]2dMcM\\2]2dMbM]2^2cMaM^2`2aM_M`2a2`M_M`2a2`M^Ma2b2`M]M`2c2`M]M`2c2_M]JGW2j2\\3_M\\JIW2h2]3_M]JJ\\OMb2j2e3YMeI1h05n1a2k3ZMWJ4n1b2l3YMVJ5n1b2l3YMWJ3o1c2j3YMXJ4n1c2k3WMYJ4m1e2g700000000000jKWMjMi2W2WMhMi2]60000000000000000000000000000000dMeMhI[2]4WM_K`04X2]4\\M[K<8X2]4`MWK7=Y2\\4cMTKEiN6h1b2[4fM[KE;e2Y4gM]KC:f2Y4gM^KA:h2W4hMaMX2_2hMaMX2_2iM`MW2`2iM`MW2a2iM^MW2b2iM^MW2b2iM^MW2b2iM^MW2c2hM]MX2a2jM_MV2c2hM^MW2b2iM^MW2c2hM]MX2d2gM\\MY2e2fM[MZ2d2gM\\MY2d2gM]MX2c2hM]MX2c2hM]MX2e2fM[MZ2e2gMZMY2e2hM[MX2d2iM]MV2c2jM]MV2c2jM]MV2c2jM]MV2c2jM]MV2d2iM]MV2a2lM_MT2a2\\MgI=h3W2a2\\MhIoLU2U3iMlLW2T3iMlLV2V3_MXI7b3X2X3aMYI4`3Y2\\3iMdLV2^3jMaLU2b3iM^LW2b3jM]LV2b3lM]LT2e3kMZLR2i3PNULo1l3WNnKf1U4\\NiK`1[4cNbK\\1_4cNaK_1^4aNbK_1^4_NdKb1[4]NeKd1[4\\NeKc1[4]NfKb1[4^NdKa1]4`NcK`1]4`NcK_1]4cNkH]OX2Q2m4bNjH^OY2o1m4eNhH\\O\\2m1n4XNbH32I]2l1o4XNdH4LIb2j1o4XNeH<\\2\\1o4WNgH[MTO_7?VK<]MnNc7f0QK:_5G`J8a5H_J7b5I^J6d5I\\J6e5[OcGNh2f0f5YOhGNc2f0g5\\OfGNc2e0f5BeGGf2f0i5@^GMi2c0i5MXJ1j5OVJ0l5OTJ0n5OSJN^O]OR4e0_LM@^OQ4d0`LM_O@S4a0^LN_OBP4b0bLK^ODQ4`0cK]OiN>b1GS4=bK_OhN`MF[23h69kF_OJOf29f69hF_Ob2O[M9]99cF^Og2<[4DWKd0>H[4FVK`0`0JY4GYK2S29d3h0jISO^OJg02^29", "size": [427, 640]}, "area": 55829.0, "iscrowd": 0, "image_id": 10281, "bbox": [0.0, 200.0, 640.0, 227.0], "category_id": 154, "id": 10012570}, {"segmentation": {"counts": "R6R2Y;0000000000000000O1000000000010O0000001O01O1O0O2O1O1O1O001O1O100O001O1O100O1O1O100O1O1O1O1O1O2N0000O2O10O01O00001O2N1O1O2N1O2K4N2O2N1N2J7N1O1O1O1O1O100N3N1O1O1O1O1O1N2O1kNmCP1f06Ko_23o_M001O0000000^CM_ONZ<5UD3j;MVD3k;LUD5k;JTD2BNY<1UDLG3T<0^D1`;O`D2_;McD4\\;KdD6\\;IS10fk01P_21mdL;01N101O10O01O001O1O00O1N2O2M2N2O10O10O2O00000O1000000O101O01O001O0O200O0000000000K5O1N3O_U40`jK2O2O2M1O00O11O001O0010O010N2Ihb>0^]A1O1O2N001O1O1O2N1O001O1O2N10O0K5O1N200O100O1000000001O00100O1O2N6J001O10O0000000IWCG02kkFBU9[2O00010O001O000010O1O01hG[Li6d3VI]Lk6R1iGG0i0Z1_Nn6o0lGDOm0W1`No6m0PHZO2Z1l0aNR7k0fHd07bNT7i0eHf05bNW7h0dHe04dNY7f0cHg01eN]7e0`Hf01gN_7e0^He00hNc7d0\\Hg0KgNj7e0WHe0LhNn7f0RHc0MiNR8h0iGc02gNV8j0_Gc09eNY8l2eGVM\\8i2bGYM_8f2_G\\MZ49bNZ2RM_MX4XOEf0;ZOFe0:ZOIc08\\OJc06]OKb05]ONa02^O0`01@UNcLe0l3V1@RNiLi0e3U1AoMoLl0_3U1BjMVMQ1U3V1DfM\\MT1o2V1DdMbM:UOKd3W2EbMeM6WO3]3U2FbMhM0ZO:V3U2G`MmMKZOa0Q3T2I]MjNa0Z1S2L[MkNc0X1R2MZMlNe0V1Q2OXMmNg0R1R22UMmNj0P1Q23TMnNl0m0Q26QMnNo0j0Q29nLnNR1h0P2;lLnNV1d0o1l2RNRMo1n2RNQMn1o2SNPMm1P3TNoLl1Q3UNmLl1T3TNkLl1U3UNjLk1W3UNgLl1Y3UNfLk1[3UNRKoN3l2k4VNQJ3o0g1Q5HoJ8Q5HPK7Q5SOZJnMf0n2Q5kNnKS1S4hNRLW1n3gNVLW1k3gN[LT1f3kN[LT1g3jNYLV1h3iNYLV1_3\\MRJ]1^2W1_3^MSJ[1^2V1^3aMUJY1[2V1_3cMVJ[1X2P1a3hMWJk1h18Q4QNTJh1k15Q4UNTJO1P1i1k0S4VNTJk0;iNa1U2P4\\NTJHO3h2JXM\\1n5CSJSOk2KVM_1l5BSJUOl2HVMa1l5@RJWOn2GTMb1o5]OnI[OS3AQMg1Q6XOmI_O\\3Y1j2TOjID\\3X1m2POgIH]3X1o2lNeIK]3Y1P3iNdIM^3Y1R3eNaI1^3Z1T3aN`I3]3\\1U3_N^I5]3\\1h3bNYL^1g3bNYL^1g3bNYL^1g3cNXL]1i3cNWL\\1g3gNXLY1g3hNZLW1f3jNYLV1g3kNXLU1f3nNYLR1b3XNmHi0a3o0b3TO^Lk0a3WO^Li0b3WO_Lh0b3WO_Lh0a3^NoHc0a3n0i3POXLo0i3POWLP1j3oNVLQ1j3POULP1UMeNd5;WMP1TMmN^53^MP1SMnN_53]Mo0TMnN^54^Mn0TMoN]53_Mn0UMnN\\54_Mn0UMnN\\55^Mm0VMnN\\55^Mm0VMnN\\55^Mm0VMnN\\55^Mm0VMmN]56]Mm0WMkN]59[Ml0XMjN_59ZMl0m3TOSLl0m3TOSLl0n3SORLm0n3SOSLl0n3SORLm0n3SOSLl0m3UORLk0o3TOoKn0Q4ROnK5aLOa7LmK6cLMa7MkK6fLK_70jK5hLJ`70gK6kLH`71eK6lLHa71bK7nLGc70YJ@oNi0WOEb72VJCPOe0YOEa74UJDPOa0\\OF`75RJHPO<@E^78QJIPO8CF]79nIJRO6EF[7;lIIVO4EGZ7hIH]OMGLT7?hIH_OGJ1o6`0gIIg0Eb5b0gIHk89SGHm88SGGn89QGHo88PGIk7EcGb0b0Hh7KeG=b0Ig7LgG:b0Ja73mG3a0KU7H]G:o02?MU77aHL9NU73fHN50U7NjH200W7NiH111V71]GAQ1=;2X78\\HE<4Y7c07d72iGGb08e73gGDd0:e75dGAf0:i75^GAj0:f78_G^Oj0;b7=cGWOk0=`7?dGTOk0>`7`0dGQOl0`0_7`0eGPOk0a0`79XGmN=8k0c0_78YGSO82P1c0_78YGUO6OR1d0_7i0]GcNT1d0`7j0ZGaNV1f0b75UG^O1GW1g0l7KlFF2GW1h0k7KlFE3HU1i0l7]NNV9HZH;aNLl8^OPG>`19fNJi8d0QHBXOJe8c0UHCXOIb8a0XHGWOHa8:UGUOP1i0]OG]8:[GSOi0m0AD\\89^H4WOC`82YH;YOC^8O[H>WOD]8L]Ha0VOD]8F`Hf0TOE^8D[Hh0WODa8CUHj0YOEe8@oGj0]OGS::mEFR:;nEER::oEFm8YO]GR1FEi8^O`Gm0GDg8C`Gi0JDc8FcGf0JD`8JdGc0LB]8OgG?KC[8c0WGK>An7\\OdGV13N;@n7B]Gn0=17^OP8i0kGJ5]OP8e0oGN1]OQ8f0kGO3ZOS8j0gGL6ZOS8m0cGJ:XOU8U1XGEb0VOZ8R1SGHb0VO_8^2aGbMc8i0lF3`0SOi8>nF`09ROm82RGl01QOR9DWG\\1GPOR:Q1nEnNS:R1mEnNP9A^Gb1BmNP9B]Ga1BmNQ9C\\Ga1ClNQ9C\\Ga1CkNR9DZGb1DjNR9B[Ge1ChNS:X1mEhNR:Y1nEgNR:Y1nEgNQ:Z1oEfNQ:Z1oEfNP:[1oEgNo9Z1QFfNo9Z1QFfNn9\\1QFdNo9\\1QFdNn9]1RFcNQ:Z1oEfNT:W1lEiNW:T1iElNZ:Q1fEoN]:n0cERO`:k0`EUOc:h0]EXOf:e0[E[Of:c0ZE]Og:b0YE_Oh:?XEAj:=VEDk::UEFm:8SEIn:5SEKl:5TEKk:6UEKi:5XEKg:6YEKe:6[EJd:7\\EIc:8^EGb:9^EH`:9`EG_::aEF^::cEF]::cEE]:cEB]:>dE@\\:a0dE^O\\:c0dE\\O]:c0dE]O[:d0eE[O[:f0eEYO\\:g0dEXO\\:i0eEVOZ:j0gEUOZ:k0fEUOY:l0gETOR9IYGS1DUOR9IZGQ1CXOQ9J[Gn0CYOf8BQG6f0o0A[Od8ETG2f0m0B]Ob8GUGOh0k0@Ab8FPGG18m0h0@Ea8DPG6d0l0I\\Oc8CnF7?o00XOc87UGf07UOd86nFj0>QOd8P2\\GQNd8o1ZGSNf8h1nF\\Mj:AUE`0m:^OSEb0o:[OQEf0Q;XOoDh0S;UOnDk0T;SOkDo0V;oNjDQ1X;lNhDU1Z;iNfDW1\\;fNdD[1[;fNeD[1Z;eNeD\\1Z;;00O10\\NgDV1X;lNhDT1W;lNjDS1U;oNkDo0V;QOkDn0T;SOmDl0S;SOoDl0Q;SOQEk0P;TOQEl0o:ROTEm0l:ROVEm0k:QOWEn0i:QOYEm0h:ROZEm0f:QO]En0c:QO_En0a:RO`El0a:UO_Ej0a:XO^Eg0b:ZO^Ee0b:\\O^Ec0b:^O^Eb0a:_O_E`0a:A_E?`:C_ESj1C`JOh3>h1C^JOm3;g1E[J0Q49e1HWJOV47e1KRJN\\44d1OmIMb42b12iIMf4Oc1k0`NROc1k0`5N2N3M2N2JZd3", "size": [427, 640]}, "area": 46829.0, "iscrowd": 0, "image_id": 10281, "bbox": [0.0, 23.0, 631.0, 404.0], "category_id": 183, "id": 10012574}, {"segmentation": {"counts": "YfU83ic08L2M1O1O2O1O0O2O1O1N2O4L4L101N100OO11N1001ON3O0O1001O0003W]OiNab0b1K1N2N3M00O100010M2000000O10On]OVNO0oa0j1R^O\\N0K1Oca0Y21O2M100001O001N10000O2O0o^OjMX`0V2Z_OXNf`0a2000000PB", "size": [640, 482]}, "area": 3211.0, "iscrowd": 0, "image_id": 10290, "bbox": [418.0, 445.0, 64.0, 103.0], "category_id": 107, "id": 10012575}, {"segmentation": {"counts": "RV:5hc04e]ONb`07R_O4j`00U_O2k?EV_OI9l0c0Gh?2]_O?OTO7a0[`0a1`_OdNV>ZObBL1W2WOcNP>IUBQ3LTMb1XOb:a0RDT4]1YKa:e0PDV4[1WKd:f6[D_Ie;g7F`0Ac0]Ok0bNQFfFP;g8h0_O`0^Of0YO8IOYJSC]4mlLWI^O;c1Y6P2]1eMmNS2d9L3O]_OjL_`0\\30N6H50OON^O]_OmMa`0o1e_OQN[`0g1P@nMXOOn`0j1V1J6Gf]OeNab0W16K7H6J6K\\V^6", "size": [640, 482]}, "area": 48768.0, "iscrowd": 0, "image_id": 10290, "bbox": [16.0, 46.0, 136.0, 488.0], "category_id": 109, "id": 10012576}, {"segmentation": {"counts": "0RV:5f]F4e]ONm;n0VFYOaM4S;FiDR1[2XOhM2S;DjDR1\\1oNhMI9l0c0GU;DjDQ1X1]OnM?OTO7a0h;^OkDR1Y1Q1oMdNk;D`Do0=cN1W2WOcNk;KVDT14k1LTMb1XO\\8e0QFT17l2]1YK\\8j2UFQ2[1WK_8k8`FZG`9l9G?Ac0]Ok0UOb0^Oc0]Ob0^OQ1oN=aL\\Ah0b>UNRA7n0U1[?^NPAT1Xa0Fb0^Oac03M2O00O10O1O10000O100O0BBU]OK4c0gb0?0000O10000h^OoNa?R1U@mNlN5l`0m0W@Ba?b0P@LS`03b_O6^`0MZ_OfNK`1k`0LW_O7i`0`1000000001OO100000000000000000\\MU_OS2k`0lMZ_OP2f`0oM__Om1a`0SNb_Oj1^`0UNg_Og1Z`0WNk_Oe1V`0ZNl_Od1U`0ZNn_Od1S`0ZNP@d1Q`0[NR@b1o?\\NT@b1m?\\NV@b1Va0N2N3M2N2N1O00000000000000000000000000000000000000000000000000001O0000000000000000000000000000YNlNb@T1^?]OQ@c0o?O__O1``0h10000O10000O1000000O1O100000000001OKRMW_Oo2i`040000O1O1O100O1O100O10000O11O000000001O1ON24L4L6J6J4L1OO^Oe^OaNWa0[1k^OXNN212Va0d1m^OVN74l`0f1Z_O\\Nj`0`1R_OdNo`0[1n^OhNPa0Z1m^OiNQa0Y1m^OiNUa0U1n^OhNPa0Z1k00O1O13M4WNS^OW1\\b0O1OO13M001OOWO^]O4dTl0", "size": [640, 482]}, "area": 11381.0, "iscrowd": 0, "image_id": 10290, "bbox": [265.0, 531.0, 172.0, 109.0], "category_id": 117, "id": 10012578}, {"segmentation": {"counts": "]Qg06jc0?A>B:H`0A9F6G1O1003MO1O]Of^ObNYa0V1Q_OiNo`0o0Y_OQOg`0f0b_OZO]`0?k_OAV`05S@Kl?H`^O3l15ia000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000RL4hCLl;`0TD@b;j0^DVOX;T1hDlNa:k1_EUNb:j1^EVNb:j1^EVNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUN`:l1`ETN`:l1`ETNa:k1_EUNb:j1^EVNb:j1^EVNb:j1^EVNb:j1^EVNb:j1^EVNb:j1^EVNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUNa:k1_EUN`:l1`ETNa:k1_EUNb:j1^EVNb:j1^EVNc:i1]EWNc:i1]EWNb:j1^EVNb:j1^EVNb:j1^EVNb:j1^EVNb:j1^EVNb:j1^EVNb:j1]EWNc:i1cDQO\\;P1kCIV<6oBe0P=]OUB]1k=\\21O00000000001OO10000000000O11O000000O100000000000000000000000_KSBo2m=hLeBo2[=lLPBROi0P4W=bLoA_OU1P4kWLhA[O0d4X>o0N23M1O1O003M2N2N0nJ`Ad4a>TKhAj4Y>TKiAk4h>N2NOaKm@e1:2i>[No@^1;5h>TNXAb129^?Bb@>a?_O^@b0g?YOY@g0l?SOU@m0n?TN`_Oh0c0T1T`0SNY_Oc0c0Z1X`0dNh_O\\1X`0cNi_O]1Z`0`Nf_O`1[`0^Ne_Oc1_`0RNn^O4c0j1\\a00000000000DS^OeNna0Q1Q^OlN50ia0S1h0A`0Ee2SC^MVN7d>\\2VCjMlQ2oAoMP>Q2WA]M4d0f>n30000001O00000000003WKi@c4`?J2N2N3M00O100001O0000000000OkKY@O0R4g?oK_@0K1Od3X`0000O100001YOP@\\MP`0[2X@fMi?n1b@RN^?\\1g_OYNY1;P?S1]AmNc>k0eAUO\\>a0mA_OS>6XBJh=HfB8a`00000000", "size": [640, 482]}, "area": 29354.0, "iscrowd": 0, "image_id": 10290, "bbox": [36.0, 449.0, 446.0, 191.0], "category_id": 123, "id": 10012579}, {"segmentation": {"counts": "PTl51oc01O1O1O1O3M2N5K3M00000000000000000000000000I7N2M3O1O100OQPo2", "size": [640, 482]}, "area": 342.0, "iscrowd": 0, "image_id": 10290, "bbox": [301.0, 0.0, 29.0, 18.0], "category_id": 130, "id": 10012580}, {"segmentation": {"counts": "nPg0?^c03@E^]O8cb0b0O3N3M2M02N1003MO001O101OO0111jN^]Oi0JVOPc0i03I7H;FmPd11^[[N2dc00\\\\O0dc01[\\OOec01[\\OOdc02\\\\ONdc02\\\\OOcc01]\\OOcc0700000000000000001O01O000000000000000010O00000000O101OO10N2O101O000000000001O0000000000000010N1000000000001O0000000000000O12N2N2N2N^]OF^a0:`^O6Sa0In^O6Ra0Fm]OMP1?Sa0Cn]OMo0a0Ra0AS_Oa0l`0^OT_O?o`0AQ_O?o`0AQ_O?Pa0@n]O0l0`0Ua0Bm]OOn0?Ua0Bm]OOn0?Ua0Bm]OOm0`0Va0Gi^O4TOCVb08f^O6]a0IR^OK1>la0FQ^O109oa0Go]O5N4Tb0Ij]O7ONYb0Nd]Of0_b0<11OO2O0O11O010O00L4N2O1O1N10001O1O0O2O0OO24L1O4M1N101M2N3M2O1O3L3OSRU4", "size": [640, 482]}, "area": 3402.0, "iscrowd": 0, "image_id": 10290, "bbox": [36.0, 38.0, 233.0, 527.0], "category_id": 132, "id": 10012581}, {"segmentation": {"counts": "`af83kc04L:E3M5M10000001O1XOj\\Od0Vc0\\Ok\\Od0Xc0N3O001O0O2O0O101L3L5L4O_f7", "size": [640, 482]}, "area": 395.0, "iscrowd": 0, "image_id": 10290, "bbox": [445.0, 421.0, 24.0, 27.0], "category_id": 139, "id": 10012582}, {"segmentation": {"counts": "VY;U1jb05L000O1NN1M52M12O1O2M10002[OS]OD\\c0;52M11N5LYZ[3JU_dLL[If0\\6ZO_I1hIi0g01O1O1O00001JeBcI]=^631N01O2LOfI`BX6a=311OO100OM5XObI]C02c6`ERCWOQN22Oi0OUO30g0m>_OQEGWL`0l>@`E0_K7bW^4", "size": [640, 482]}, "area": 15164.0, "iscrowd": 0, "image_id": 10290, "bbox": [18.0, 28.0, 237.0, 513.0], "category_id": 143, "id": 10012583}, {"segmentation": {"counts": "Pl;8hc0001O00;E7I001O1O1O2N00002N0000O11O4L;E000000000000001O3MN2001O2N1OO1L4001O000000O11O00O11O00000000000000000000002NN22N0000O12N00O100O11OO12N1O0000M300000000000000O1001OO1O1O10000003M1O2NN2I71OO11O00O1001O0000O1002bAfNmKK30M2j=h1nE]NXL1i=b1nEiNQ:X1mEiNS:U1nEmN\\LZO:d1U;5UHS1k7lNRHX1n7hNjG`1V8`NfGd1Z8[NeG\\NjLV3a;]NkGc1U8]NiGe1W8_NaGe1_8\\NaGc1_8]N`Gd1`8YNnF_NmMX3U;WNjFgNQNR3U;kM`DgN22P2e0nMXOOe3a;cMbDiN02g1h4g9]LcDhNO3a1n4m9WLcDhNO3X1MeNX5a;oKdDiNN3T1[5Z:iKdDiNO2n0a5_:dKdDiNO4f0e5g:^KjDmN9k5m:XKjDmN4P6R;SKjDb5V;^JjDb5V;^JjDb5V;^JjDb5V;^JjDb5V;^JjDb5V;^JjDb5V;_JiDa5W;_JjD_5W;aJiD_5W;aJiD_5W;aJiD_5W;aJiD_5W;aJiD_5W;aJiD_5W;aJiD_5W;aJiD_5W;aJjD^5V;cJiD]5W;cJiD]5W;cJiD]5W;cJiD]5W;cJiD]5W;bJjD^5V;bJkD]5U;cJjD^5V;bJjD^5V;`JlD`5T;_JmDa5S;_JnD`5R;`JnD`5R;`JnD`5R;`JnD`5R;`JnD`5R;`JnD`5R;`JnD`5R;aJmD_5S;aJmD_5S;aJmD_5S;aJmD_5S;aJmD_5S;aJmD_5S;aJmD_5S;aJmD_5S;bJmD]5S;bJnD^5R;bJnD^5R;bJnD^5R;bJnD^5R;bJnD^5R;bJnD^5R;bJoD]5Q;cJoD]5Q;cJoD]5Q;cJoD]5Q;cJoD]5Q;cJoD]5Q;cJoD]5Q;cJoD]5Q;bJPE^5P;dJnD[5S;gJkDZ5T;hJjDo0Dl1c;WMgDEFN9VOGe3c;bMgDC6B;EFM@L94HMNh1c;EfDC6_O[2m0VMdN01c;\\1bDbNMP1?_OY2IWMJ02b<[1aCbNMo0a0]Ob?R1o_OFh0nNZ?]1m_OESa0;m^OESa0;m^OESa0V1BlN070:0]O11Oe:i3dGiLgM^O100040<0@070:0]O11O>0f9i3eFWLd0e0dN[O0041;OA00030=1^O01O<2h9i3kEVLe0Oi0e0dN[O0000000000000000O11O311OK055JK:5k9k3ZFPLC0000000i00ZOe0L\\O1O00000000000000O11OO1000O11OO100:2NQ:j3nEnK10N00000000000000040L0101f0L@1K10OO10000001N011O0070h0U:P3oEoK00N000000000000000000000101e3Q:=nEnK01N01OO11O000001O0000000000g3T::mEoKNO1]5T:\\4000000000000000000000O1000000000000000000000000000000000000M3[OoEVGV:X8R1M3O1O100O1000000001O00001O00001O00001O00000000001O0000001O00001O000000001O000000001O00001O000000001O00001O000000001O00O1O100", "size": [640, 482]}, "area": 76821.0, "iscrowd": 0, "image_id": 10290, "bbox": [19.0, 0.0, 463.0, 314.0], "category_id": 172, "id": 10012584}, {"segmentation": {"counts": "ZgU99^c08F;^OUOa]OY1Vb0=H8G9J60000000000l^O", "size": [640, 482]}, "area": 755.0, "iscrowd": 0, "image_id": 10290, "bbox": [469.0, 548.0, 13.0, 79.0], "category_id": 173, "id": 10012585}, {"segmentation": {"counts": "aZf0;lc06BO2K3F_\\O8cc01Wh3HQXL01OO0Z\\O0`c008000cn\\11TQcN0\\\\O000ec00Z\\O6o>o0]DSOc;`2RAYM_10aN9m>b3dATL^O;n>e4Ob0^O1O00O10000000000000000O1001O1O0000000000O1000000000O10O11O1O001O00O100000000000000O11OO1001O00000000001OO10000000000O11O000000O1000000000000000000000000eJfAP5Z>PKfAP5Y>QKgAo4Z>PKfAo4[>QKeA^40YK0011O010]>7bAT40eK0O10o>8PAQ13iNQb04l]OJ00PYb0>lY^OBT]OP1la0R1UOk0nNR1VNj10N14L2N2O003M2N2N0bBlIP=U6hBTJV=m5hBUJW=\\6N2NOUCYI_c4iA[KW>c4SBUKn=g4UBWKm=f4h0O2O000001O1g@[KV?d4j@]KU?g401O0010O01O0ZAUKX>j4hAXKV>i4fA[KY>e4cAaK[>`4aAcK_>^4`AbKa>n400001N10000O101O00O1O100\\G", "size": [640, 482]}, "area": 49288.0, "iscrowd": 0, "image_id": 10290, "bbox": [35.0, 265.0, 447.0, 279.0], "category_id": 176, "id": 10012586}, {"segmentation": {"counts": "f`[51oc00Z\\O0H206mb0KS]OM0n0_b0ROa]Oc1m`0aNT_OL11Oc2Y`0]Mf_O1001O1R3g?nLX@1O0001OO60Q3X?oLh@K0000001O000005OR3i>hLXA2O0090G000000001O01O41Q3_>kL`A0000000090G0<0D090m2`>jL`A000000l4`>TK`AX5Z>fJfA111OX5W>gJiAO0b5V>`JjAb5U>500N2O1O1O2M5N0OO4M1O2OO0000010OO12N00O11OO1001O00O11O0000000000O1O1000000000000O100001O0000000000000001O0000000000000O100001OO100000000000O1K1UBSJh=0VBm53SJg=o550000000000000000000000lLQB7o=@RB`MOO1[20WNm=l1SBbM00000Y1OoN0<1Nn=j1_BmNBoN0<1Nn=h1QBeM>V1BlN070:0]O11O?o=j1cBgM^O100040<0@070:0]O11O>P>;PBd0e0dN[O0041;OA00030=1^O01OCmAe0Oi0e0dN[O0000000000000000O11O311OK055JK:\\>5dAC0000000i00ZOe0L\\O1O00000000000000O11OO1000O11OO100:2W>O_A10N00000000000000040L0101f0L@1K10OO10000001N011O0070P?4g@00N000000000000000000000101na0OR^O01N01OO11O000001O0000000000Pb01P^ONO1ckk1", "size": [640, 482]}, "area": 19606.0, "iscrowd": 0, "image_id": 10290, "bbox": [274.0, 121.0, 113.0, 201.0], "category_id": 180, "id": 10012587}, {"segmentation": {"counts": "RWh0h0jb0YOb]OR1Sb0POk]OR1Sb0>0000001O0gNc]Oo0]b0POe]OP1[b0nNf]OR1R3QOi;LXAQ1f2\\OSUN\\A\\1VORAR1e`09H8G9H8O1000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000C=VOj0WOi0VOSim1[OZXRN8J7I6J6J6_^OnNh?Y1n_OkNQ`0[1e_OkNY`0[1^_OiNa`0]1U_OiNi`0]1m^OiNQa0T2O2N1O2N1O2N1O1O1O3M4L4L4L4L4L4L3M1O1O1n@fK\\>[4bAjKZ>W4dAnKX>S4gAPLV>Q4hATLT>m3jAXLR>i3mAYLQ>h3mA[LP>g3nA\\LP>e3oA^Ln=c3PB`Ln=a3PBbLn=j4N2N3M2N2N000000001O00000000000000000000000000000000000000000000000000000000000000000000XL^BR1b=mN`BR1`=mNaBS1_=lNcB]O3^OY=U1eB\\Oe0mNfb0SA\\On>c0TA\\Ol>c0UA]Ok>b0WA\\Oj>c0WA]Oi>b0YA]Og>b0ZA]Og>b0[A]Oe>b0\\A^Od>a0^A]Oc>?dA\\O^>a0hAYO[>c0lAXOY>b0lAYOY>a0nAYOX>`0oAZOV>a0PBYOU>a0RBYOT>a0QBZOT>;o2FZSi1", "size": [640, 482]}, "area": 31277.0, "iscrowd": 0, "image_id": 10290, "bbox": [38.0, 395.0, 352.0, 236.0], "category_id": 183, "id": 10012588}, {"segmentation": {"counts": "2P6d8\\8dG00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]LVb0", "size": [468, 640]}, "area": 293345.0, "iscrowd": 0, "image_id": 10303, "bbox": [0.0, 1.0, 639.0, 461.0], "category_id": 183, "id": 10012589}, {"segmentation": {"counts": "0j1j=000000O1000000O1O100O100O1O100000000000000O10000001OO11O00000000000000O1001O2N2N00001O00001O00O11O000000000000000000O1O1O1N200O100O1O100001O00O11O00O1002N1O1O2N1O00001O00O100O100000000000000000000001O00000000000000001O00O11O00001O00001O00001O001O00O10000O10000O100O100O1001O0000001O001O00001O00000000O100O10000O10000O1O10000000000000000O1000000O1000000O100O1001O2N001O00000000000000000000000000O100O100000000002N001O001O001O001OO10000O1000000O10000O1000000000000000000000000000000O1O1000000O100O11OO10000001O00000000001O001O0000000000000000O1000000O100000000001OO1O100O100O1000000000000000000001O1O1O1O000000001O00O1000000000000O10000000000000000000000000000000000", "size": [500, 333]}, "area": 18387.0, "iscrowd": 0, "image_id": 10309, "bbox": [0.0, 0.0, 333.0, 62.0], "category_id": 97, "id": 10012590}, {"segmentation": {"counts": "b5T2d3]1g2cNYM]1g2dNXM[1i2eNWM[1i2eNWMZ1j2fNVMZ1j2fNVMZ1j2fNVMZ1i2gNWMX1j2hNVMX1j2iNUMW1k2iNUMX1j2hNVMX1j2hNVMX1j2hNVMX1j2hNVMW1k2iNUMW1k2iNUMW1k2iNUMX1j2hNVMX1j2hNUMZ1j2fNVMZ1j2fNVM[1i2eNVM]1i2cNWM]1i2dNVM]1i2]N]Mc1c2\\N^Md1b2[N_Me1a2YNbMf1^2YNcMh1\\2XNeMh1Z2YNeMe1]2[NbMe1_2[NaMe1_2[NaMe1_2[NaMd1`2\\N_Mb1YLaLX6n1^Ma1e2_N[Ma1e2_N[Mb1d2^N\\Mb1d2^N\\Mb1d2^N\\Mb1d2_N[Ma1e2_N\\M`1d2`N\\M`1d2`N\\M`1d2`N[Ma1e2_N[Mb1d2_N\\M`1d2`N\\M`1d2`N\\M_1e2aN\\M]1e2dNZM\\1f2dNZM\\1f2dNZM\\1f2dNZMZ1ZLeL\\6R2YMY1i2gNWMY1i2gNWMZ1h2gNWMY1i2gNWMZ1h2fNXMY1i2gNWMZ1h2gNWMZ1h2fNXM[1g2eNYM[1g2fNXMZ1h2fNXM[1g2eNYMZ1h2fNXMX1j2iNUMW1k2iNVMV1j2jNVMT1l2jNbIlMb3Z3l2jNbImMa3Z3l2iNcImMa3[3k2hNXMX1h2hNeIlM`3]3i2hNZMW1g2iNYMW1g2iNZMT1h2kNYMU1g2kNYMU1g2kNYMW1e2iNZMX1f2gN\\MV1f2jNZMW1e2iN[MY1d2fN\\MY1e2gN[MY1e2gN[MY1e2gN[MX1f2hNZMW1g2kNXMT1h2lNWMV1h2jNXMV1h2jNXMT1j2lNWMS1i2mNWMT1h2lNXMT1h2lNXMU1g2kNYMU1g2kNYMV1f2jNZMU1g2kNYMU1g2kNYMU1g2kNYMT1h2lNYMT1f2lNZMS1g2mNYMS1g2mNYMS1g2lN[MS1e2mN[MR1f2nNZMS1e2mN\\MR1d2nN]MS1a2mN_MU1_2kNaMX1\\2hNeMW1[2iNeMZ1X2fNhMZ1X2fNhMX1Z2hNgMW1Y2iNfMX1Z2hNhMV1X2jNgMV1Z2jNfMU1[2gNiMY1W2cNmM]1S2_NQNb1n1[NUNc1m1YNWNg1i1UN[Nk1e1QN_No1a1nMcNQ2]1kMgNU2Y1gMkNY2U1cMoN]2Q1bMPO^2o0cMQO]2o0bMRO^2n0aMTO^2l0aMUO^2k0bMVO^2j0bMVO]2k0bMVO^2j0aMWO`2h0_MZO`2f0`MYOb2f0]M[Ob2e0^M]Oa2c0^M^Ob2a0^M@b2>`MB`2;bMF_29`MH`28_MIa27^MJb26]MLb24]MMASJo2P6_MNBRJn2Q6_MOBPJP3P6]M3c2N[M3d2M\\M3e2MZM4f2MXM4h2MVM4j2NSM2[1kI1T6bN3Y1RJOWRi1DVNh1CWN=j1BUN>l1AWNJX1YMYNn2?IX1YMYNn2`0HW1ZMXNo2a0GX1YMWNP3a0GX1YMVNQ3b0FX1YMUNR3c0EX1YMUNR3c0EW1ZMVNQ3c0EW1ZMVNQ3c0EW1ZMVNQ3c0EX1YMUNR3c0EX1YMUNR3c0DZ1YMSNS3c0DZ1YMRNT3d0C[1XMQNU3d0B]1XMoMV3d0mLZNY1S3dNoMV3P1^LRNg1P3dNoMV3S1WLRNo1l2dNnMW3R2TN0eNoMV3R2TNOfNoMV3S2TNMfNPNV3T2SNMfNoMW3T2TNMdNoMX3U2SNJgNQNV3V2QNIjNQNU3V2QNIjNQNU3U2RNJiNPNV3T2SNKhNQNU3S2SNJQNaLg0c1T3P2VNLiNVNo2l1ZNNgNXNm2i1]N0eNWNn2g1_N2cNWNn2e1aN4aNXNm2b1dN6_NXNm2a1eN7^NXNm2`1gN7\\NZNl2]1jN9ZNZNl2\\1kN:YNYNm2\\1jNWNXNm2Y1nN>UNYNm2W1PO`0SNYNm2V1QO`0SNZNl2U1SO?RN\\Nk2S1UOa0PN\\Nk2R1VOb0oM\\Nk2n0ZOf0kM\\Nk2m0[Oe0oLeLk0i1k2m0[Oe0lM]Nj2n0ZOe0lM\\Nk2o0YOf0kMZNm2P1XOf0kMXNo2R1VOg0jMWNP3S1UOe0lMWNP3T1TOf0kMVNQ3T1TOg0jMTNS3U1SOh0iMRNU3V1ROh0iMRNU3W1QOg0jMRNU3W1QOh0iMRNU3V1ROg0jMSNT3V1ROe0lMTNS3W1QOe0lMUNR3V1SOd0kMVNR3W1ROa0nMWNQ3c0RL_No2g2nMWNQ3c0RL_No2h2mMXNP3a0TL_No2i2lMXNP3`0WL]Nm2k2lMYNo2?WL^Nn2k2kMZNm2>[L]Nl2j2mM\\Nk2=\\L]Nl2j2mM\\Nk2=\\L]Nm2g2nM_Ni2<]L^Nl2g2nM`Nh2;]L_Nm2f2nM`Nh2;]L`Nl2g2mM]Nk2<\\L`Nk2h2nM\\Nk2;]LaNk2e2oM^Nj2<\\LaNk2f2nM]Nk2<[LbNl2g2lM[Nn2;ZLcNl2f2mM\\Nm2;ZLdNk2e2nM\\Nm2;ZLdNk2e2nM\\Nm2;ZLdNk2d2oM]Nl2;ZLdNk2c2PN^Nk2U1VO[K\\2c1YMP3;]K\\2c1[MFD4f0eNY2`1aMAC9d0fNX2_1dM\\OI:;lNW2^1gMVOL=8oNU2]1jMQOMc04POS2\\1PNjNMj00POS2\\1RNcN1P1JROR2Z1VN^N2V1FROR2Y1YNYN3\\1BSOQ2X1]NQN6b1]OTOQ2X1_NlM8g1XOUOQ2W1bNfM:n1SOUOQ2V1U1FjLSOR2W1T1FjLSOR2V1U1GiLSOR2U1V1IgLROb1f1g1ZOeLoNc1h1i1ZOcLnNb1i1m1WObLPO`1j1m1WOcLnN_1l1o1UOcLoN\\1m1R2TObLoNZ1o1T2RObLoNZ1n1U2SOaLoNY1o1V2SO`LnNZ1o1W2RO_LoNY1Q2W2oNaLPOX1R2V2nNbLPOW1T2V2lNcLPOV1U2V2lNdLoNV1V2V2jNdLPOU1W2X2hNcLQOU1X2W2fNeLROS1Y2X2eNeLROS1Y2Y2eNcLROT1Y2Z2bNdLTOS1Z2X2cNeLROT1[2W2eNcLPOV1[2W2dNdLQOU1[2W2dNdLQOT1\\2Y2bNcLQOU1]2X2cNbLPOV1\\2Y2dNaLoNW1]2Y2dN_LPOW1\\2X2eNbLnNW1]2W2fNaLmNX1]2W2gN`LlNY1]2W2eNbLnNW1]2W2eNbLoNV1\\2X2fNaLnNX1[2W2gNaLnNX1[2X2eNaLPOX1Z2X2eN`LQOY1Y2W2fN`LQOY1Y2U2hNbLPOY1W2U2iNbLPOY1W2V2iN`LQOZ1U2U2kNaLPOZ1U2U2kNaLPO[1S2U2mN`LPO[1S2U2mN`LPO\\1R2T2nN`LPO\\1R2S2oNaLoN]1Q2R2QO`LnN^1Q2R2QO`LnN_1WOVN\\1k3>aLnN_1PO]Nd1d3=`LoN`1kN`Ni1`3\\LkNR3i0a0<]LkNR3i0a0=\\LjNS3h0b0>[LjNS3i0a0=\\LjNT3h0?>^LjNS3g0b0<\\LmNR3g0a0<^LnNP3f0b0;_LPOo2d0b0:aLSOl2c0c0:aLTOk2b0d09bLUOk2a0c0:bLUOk2a0c0;aLTOl2a0c0;aLTOk2b0e0:_LUOk2a0f0:_LUOk2a0e0;`LSOl2b0d0;`LSOl2b0d0;`LSOl2b0d0;`LSOk2c0e0;_LROl2c0e0;_LROl2c0e0<^LQOm2c0f0;]LQOn2d0e0;]LQOn2d0d0<^LPOm2e0e0;^LPOm2e0f0:]LQOm2e0f0:]LQOl2f0f0:^LPOl2f0f0:^LPOl2f0g09]LQOl2f0g09]LQOl2f0g09]LQOl2f0g08^LROk2f0g08^LROk2f0g08^LROk2g0f07_LROk2f0g08^LROk2f0g08^LROk2f0g08^LROk2f0h07]L", "size": [500, 333]}, "area": 77284.0, "iscrowd": 0, "image_id": 10309, "bbox": [0.0, 50.0, 333.0, 450.0], "category_id": 124, "id": 10012592}, {"segmentation": {"counts": "co;a0Y>JSB:f=0RB4m=k0N2M3N10100O1OO1N2O1N3N1N2N2N2O1N3M2O1O1O1O1N3N1O1O1O2M2N2L401O01O01O00000010O0001O0000010O00000010O00000000001O0O1000001O0O100000001O0O100000001O000000001O00007Ioa0Ij]O:Rb0l0N1100O100O1N2N2N3M2N4M1N3L5I7J8I9DiPn07RoQO9H6K5K7I5K4L4M4L2N2N1O2O001O1N101O0010O0000O1000O100000000O100O100O1O2O0O1N3N1O1O2M3M4K5N1L6J6IQL\\An3d>RL\\An3d>SL[Am3e>SL[Am3e>SL\\Al3d>TL\\Al3c>UL]Ak3c>UL^Aj3b>WL]Ai3c>WL]Ai3c>WL]Ai3c>WL^Ah3b>XL^Ah3b>YL]Ag3c>YL]Ag3c>YL^Af3b>ZL^Af3b>ZL^Af3b>ZL_Ae3a>\\L^Ad3b>\\L^Ad3b>\\L^Ad3b>\\L_A6ZOo2W?kL_A6@i2Q?QM_A5Bi2o>SM^A4Dh2n>TM_A2Dj2m>TM_A2Dj2m>TM_A2Ck2n>SM_A1Dl2m>SMaALEQ3j>TMRBl2n=TMRBl2n=TMRBl2n=TMRBl2n=TMQBm2o=SMlAR3T>oLkAQ3U>oLkAQ3U>oLkAQ3T>PMlAP3T>PMlAP3T>PMlAP3T>PMlAP3T>QMkAo2U>QMjAP3V>PMjAP3V>PMjAP3V>PMjAP3V>PMjAP3V>QMiAo2W>QMiAo2W>QMiAo2W>QMiAo2W>QM[AGHX3m>QMZAHHX3n>PMYAJHV3o>PMXAKIU3o>PMXAKIU3o>PMWAMIS3P?QMVALKR3o>RMVALLQ3n>SMVAKNQ3l>TMUAK1P3j>UMUAJ3P3h>VMUAJ3P3h>VMUAJ3P3h>VMUAJ3P3h>VMTAK4o2h>WMSAI5Q3g>WMTAH5Q3g>WMTAH5Q3g>XMSAH5P3i>WMQAK4o2k>VMQAMOP3P?TMPA`3P?`LPA`3P?aLn@`3R?`Ln@`3R?`Ln@`3R?`Ln@`3R?`Ln@`3R?`Lm@a3S?_Lm@a3S?_Lm@a3S?_Lm@a3T?^Lk@c3W?[Li@e3X?ZLh@f3Y?YLg@g3Z?XLf@h3Z?XLe@i3[?>0000001O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O10000", "size": [640, 427]}, "area": 59013.0, "iscrowd": 0, "image_id": 10313, "bbox": [0.0, 487.0, 427.0, 153.0], "category_id": 140, "id": 10012596}, {"segmentation": {"counts": "]`CBa<<_CEd<8[CIf<5[CKg<3XCN\\O\\MS=c2aC=b<_O_Ca0c<]O\\Cf0bce0f;d0gCmN`0a0h;c0dCoNb0`0j;]2RDgMHWNY;T4hDjMNTNY;T4cDmM2PN[;W4\\DlM8nM\\;\\4PDmMb0hM];n6aDSI_;n6_DSIa;o6\\DRId;o6ZDRIf;P7WDQIi;P7VDPIj;R7SDoHm;R7QDoHo;a701O2N1O1O1N10000000001O000O1000000000000O100000000000000000000000nG]Dg7n;0002N1O1O00OQMTDlMk;Q2^DjMa;T2eDiM[;U2jDhMV;V2QEeMd:d2aEYM]:g2gEWMV:j2nETMR:k2RFRMn9m2TFRMl9m2VFRMj9m2WFSMi9l2YFSMg9m2YFSMf9n2[FQMe9o2\\FPMd9o2]FQMc9o2^FPMb9P3^FPMb9P3_FoLa9R3^FnLb9R3^FnLb9R3^FnLb9Q3_FoLa9Q3_FoLa9Q3^FPMa9Q3_FoLa9Q3_FoLa9Q3_FoLa9Q3_FoLa9Q3^FPMb9P3^FPMb9P3]FQMc9o2]FQMc9o2\\FRMd9n2[FSMe9n2ZFRMf9n2YFSMg9m2WFUMi9l2UFUMk9k2TFVMl9j2SFWMm9j2PFXMo9j2nEXMR:j2iEYMW:i2gEWMY:j2cEYM]:j2]EYMc:j2VEZMj:n2hDXMX;h500000000O1000000000000000000000nLhDdJJd2^;c2VEXMj:f2\\EVMd:h2aEUM_:i2eEUM[:j2hETMX:j2lETMT:k2nETMR:k2oEUMP:k2RFTMn9k2TFSMm9m2TFRMl9m2UFSMm2", "size": [640, 427]}, "area": 36024.0, "iscrowd": 0, "image_id": 10313, "bbox": [232.0, 222.0, 195.0, 273.0], "category_id": 172, "id": 10012599}, {"segmentation": {"counts": "n33mc06K5K6I6K6J2NO001O1O001O1O0010O01O00001O001O001O001O00001O0000O10000000000O10000000000O2O0000000O10000000000O10000000000O10000000000O100000000O101O0000000O10000000000O100000000O10000000000O1YB>P7BlHc0S7]OiHg0W7YOeHl0Z7TObHQ1]7oN_HU1a7kN[HZ1d7gNXH\\1h7dNVH_1i7aNTHc1k7]NRHf1n7ZNPHi1P8VNmGm1S8SNjGQ2U8oMiGS2W8mMfGW2Y8iMdG[2[8eMcG]2]8cM`Ga2`8^M]Ge2c8[M[Gh2d8XMYGl2f8TMWGo2i8QMUGR3j8nLSGU3m8kLPGX3P9hLmF[3T9dLjF^3V9bLgFa3Y9_LcFe3]9[L^Fj3b9VLZFn3f9RLUFS4k9oKoEU4R:lKgEY4Y:iK`E\\4`:fKZE^4f:dKSEa4R2VJi5Z1PHd4R2XJm5U1mGf4P2[JS6o0kGh4P2\\JT6m0iGi4R2[JV6k0eGm4T2ZJV6j0cGn4V2ZJV6h0bGP5W2YJW6h0_GQ5Y2YJW6f0]GT5[2WJX6Z7gIhHX6X7gIiHY6W7fIkHY6U7ZIYIe6g6ZIZIf6f6XI]If6d6XI^Ih6b6WI`Ih6`6VIbIj6^6TIeIk6[6TIfIl6Z6RIiIm6W6QIlIn6T6QImIo6S6oHPJP7P6nHRJQ7o5nHRJR7n5lHTJT7l5jHVJV7j5iHVJX7j5fHXJZ7h5dHZJ\\7f5cH[JZOeMe7P8oH]J[OfMd7m7oH_J]OeMc7l7nHaJ^OeMb7k7oHaJ_OdMb7k7mHcJAcMa7j7lHdJCcMa7i7kHeJDcM`7h7jHgJF`Ma7i7hHhJG_Ma7i7fHjJI\\Mb7j7cHlJKZMb7j7bHmJMXM`7l7aHnJOUMa7m7^HoJ3RM`7o7\\HPK4nLc7R8WHRK5mLd7^;[HcDe7];ZHdDf7\\;YHeDh7Z;XHfDh7[;VHeDk7h;001N1000001N10000\\ORHVEn7h:THXEm7d:VH\\Ej7b:WH_Ei7a:WH_Ei7a:VH`Ek7_:THaEm7_:RHbEn7^:QHcEo7]:nGgER8X:mGjER8S;O1OO2QOnGnER8[3PH\\2OXJQ8Z3RH^2MWJR8Y3SH`2KWJR8W3VHa2HXJR8U3XHc2FWJS8T3YHe2DVJT8R3\\Hg2@VJU8Q3]Hi2^OSJW8S3]Hj2\\OSJW8Q3_Hl2ZOSJW8o2bHm2WOTJW8m2dHo2UOTJW8j2gHR3SOSJV8i2jHS3POTJV8g2lHU3nNUJU8d2oHW3lNUJU8b2RIX3iNVJU8`2TIZ3gNVJU8^2VI\\3eNWJT8Z2[I^3aNXJ_7m2RJk2_NXJ]7m2VJk2^NWJ[7m2YJl2\\NXJY7k2^Jl2YNYJW7k2bJl2WNYJV7i2fJn2TNZJT7g2kJn2RNZJQ7h2oJn2PNZJP7g2RKo2nMZJo6f2VKo2kM\\Jl6e2[Ko2iM\\Jk6d2^KP3gM\\Jj6b2cKQ3dM\\Jh6c2eKQ3cM]Jg6a2gKR3bM]Jg6a2gKR3bM]J7[OP6V3YLP3aM`J5@k5o2`LQ3`M`J4Bk5m2aLQ3aM_J3Ck5l2cLQ3_M`J2Dl5j2dLR3^MaJ1Cl5j2fLR3]MaJ1Cl5i2hLR3[MbJ0Dm5g2iLS3ZMdJKER6c2jLT3ZMUKl5e1mLU3WMVKk5e1oLU3VMUKl5e1oLV3UMUKl5d1QMV3SMRKP6f1oLX3QMQKP6g1PMX3QMPKo5g1QMY3PMPKo5f1SMY3nLQKo5f1SMY3nLPKP6f1SMZ3mLPKo5g1UMX3lLQKo5g1UM`1cL]M9\\Oo5f1VM]1kL\\M1@n5g1WMW1SM^MHDn5g1WMR1\\M_M_OHm5h1XMm0`McM[OHm5g1ZMh0dMhMUOIm5g1ZMc0iMmMPOHn5h1YM>oMQNkNHm5h1ZM;RNUNgNHl5i1\\M4WNZNaNIl5i1\\MO\\N_N\\N\\OGGW6\\2[MMaNcNVN\\OHHW6[2[MIdNhNRN[OIIW6Z2ZMFiNkNmM[OKIV6Z2YMDlNnNjMZOLJV6X2ZMBnNQOfM[OLIX6X2XM_OROTOcM\\OLHX6X2WM]OVOVO`M[OLLW6S2YM\\OWOZO]M[OLMW6Q2YMZO[O\\OYM\\OKOX6n1YMXO^O_OVM\\OJ1Y6k1ZMUOABRM]OI3Z6g1\\MSOBFoL\\OJ4Z6f1[MQOFHkL]OJ3\\6e1[MoNGLhL]OJ3^6c1ZMmNJOdL^OJ3_6a1ZMlNL2bL]OH5a6^1[MiNO5^L^OH5b6^1R2oNdG^OH5c6\\1S2oNdG_OG5f6X1P2SOdG@G2k6W1k1UOdGBHNP7U1e1ZOeGA^7P1o0]OdGC_7m0o0^OdGD^7m0o0]OdGF^7k0Q1\\ObGH_7j0Q1\\OaGJ_7i0R1ZO`GM_7g0S1ZO_GO]7g0W1WO]G2\\7g0X1VO\\G2\\7h0Z2XOeMh0\\2XOdMh0\\2XOcMh0^2WObMi0_2WOaMh0`2XO_Mi0a2WO_Mh0l:0010O0010O00010O00010O01O00010O00010O0010O00010O01O00010O00010O0100O1O100O100O1O100O100O1000000000000O100000000000000O1000000000O2O1N1O2O1N1O2O1N2N101N2N2O0O2N2O0O2N2O1N1O2O1NZX>", "size": [640, 427]}, "area": 64197.0, "iscrowd": 0, "image_id": 10313, "bbox": [0.0, 92.0, 404.0, 448.0], "category_id": 183, "id": 10012600}, {"segmentation": {"counts": "Pgn12]<5dCJT<:02M2O0O11O0001O01O00001ORDDh;iDEJM];>iDEKM[;?hDENKZ;a0fDE1JX;l060000001O]O`D6`;IaD7_;HbD8k;00000CFdD:\\;J`D6`;J`D6\\;@eD;N5T;j0mDhNj:a13OM1O11M20M41OO2N0000000O0100N00202N00N30N1O1O1CXEQOi:n0YEPOh:o0ZEPOf:o0\\EPOc:Q1]EoNd:P1\\EPOd:P1\\EPOh:k0YEUOg:k0YEUOc;O]D1P<1hNf0ZEZOg:h0VEXOj:h0VEXOi:j0UEWOj:k0VETOi:l0YESOi:k0WEUOg:m0YESOi:k0WEUOi:k0WEUOg:m0YESOh:l0XETOh:m0VETOi:n0UESOj:P1REROP;n0mDSOR;n0nDROR;V1O1001O0000000010L25MQEeNg:[1YEfNc:]1]EcNe:[1[EfNd:Z1\\EfNc:[1]EfNc:Y1]EgNc:Y1]EgNb:Z1^EfNc:Y1\\EhNc:Y1]EgNc:Y1\\EgNe:Y1\\EfNd:Z1ZEcNN2i:[1XEdNl:T1TEPO0KV;j0nDYOKM^;0bD=;EEN`;0`D7W0]O_;5aD>b;]O`DO72aaA9NN22N000O10000000000O10000001O1O002N001000M20100N1[D_O[;b09O2L2O20^DDR;;mDET;7^DIX<3iUa0MY^^O0G0k;1SDO78b;JWD00O0;g;>M2L21O01O0O01010O000000O010BdDF_;9lDAP;n;3O2N1O2N2O1N2_EWOX9i0[FUO_O0J5[:7eE4d0A^O;W:IgE02:a02h9AfE32<=0Q:BeE=91S:BdE=80a:0^E0d:O[E0h:0VE0k:0TE0n:1oDOS;3iDMo:n00000O1N25LOlN[E=e:B`E9`:G`E:_:G`E:`:E`E<_:DaE=^:DaE<`:C`E>_:BaEO@8`6BmM6TLM_OM2=^6CbI0V46ZLL_ON0>_6FaNOUK9n5ETJ4X2K`M3Z2NoMOI7l41lKM[O2W1IhN0b0>Y1BUN1:3CLm4>RKB=;EEN7?J8;M2Q2F\\2:TO7901Y7Y1_H_N6731X7Y1^HaNOIF`0e0MX7Y1^HbNFGO0002d0b0LW7`1WH\\O?RO\\7`1VH\\O`0UOZ7R3bHnL^7R3bHmL_7S3aHnL^7R3]H_LH`0l7Q3VHXM\\1ZOjN7Y5V4mJbK;l0f4_3oJlK5f0k4[OaJf3>_L0l0AeNa11o1OaL166II6^31_M2c0Gg08iMU3i4cLWK0h40XKh2Q1YMf7b2[H^Md7b2XHdMf7\\2ZHjM`7U2`HiMc7W2\\HjMd7V2[HmMc7R2ZHUNc7j1]HUNe7k1[HVN8En5V2gIXN:Bo5R2kI^N2DR1B_N1n3[2VLdM_O03m0NRO20>?m0ClN8K5=D_O2n0K_O2o0[2ROjMCg0NSO3O>`0l0GdNJO948;DBOg06XO2[1P2TOlMAe00SO3ON1O19?KCn03oN8OU12\\O1\\OV1U2nN`MI]10bN0?0A0P1l0XOUOf30O20OO10N20M2001N0101O010AQD70IT<0lC0O0Q=0ZO1eC1Z<3M4O1L4NDQD9m;EVDkDAX;;iDEX;9jDFV;8e0L2O2N2NRc20m\\M1oN4eDK1O>1B1Z;>PE@G2Y;i0eDUO22Z;P11OO1O100002NN23MM24M^IRO_1Q1`NRO`1l0]NQOWK3Z6n0^NPOXK2Z6n0\\NXOe1g0YN[Oh1d0WN]Oj1b0UN_Oj1b0UN_Ol1`0SNAl1`0UN_Ok1a0TN@m1?TN@l1`0UN_Ok1a0UNYO^KL]6k0VNWO^KN^6i0VNWO\\K0_6h0UNXO\\K0`6g0VNWOZK2`6g0XNUOXK4`6g0[NYOe1f0^NXOb1h0_NWOb1h0j4XOiDi0V;ZOhDf0Y;[OeDe0Z;9[GmNn5R1PJPOQ6o0oIQOS6m0mISOT6l0kIWOT6h0lI\\Oo5e0QJ\\Om57`GFh26TNCc6`0cKLkMH^6=fKLfME[O1Y7>fKLaMC^O014OO[7>fKLaME_O7Z78fKM_M1k62fKL`M2j60eHAQ3>_M1k60hK0[M1m6OhK0[M1m6OgK1^MNk61gK2]MMl61gK1\\M05@]O0d6`0]L1[M04E@O\\6;eL2PM9>Cm53lK_O^N`1HoNn52kKAkM1;^11nNn52iKJXNV1G_NN0N01`0[63gKHZN\\1C]N0=\\62gKH[NT2n5UNeKH\\NT2o5TNeKH[NU2P6SNdKI[NU2R6QNcKJZNV2R6QNdKIXNX2U6lMeKLVNX2T6oMdKIXNX2U6oMbKIXNY2U6nMdKIWNY2V6lMdKKXNW2S6nMfKNVNR2U6nMfK0TNS2U6lMjKNTNU2S6lMiK0TNS2R6mMjKn2U4SMkKm2V4QMkKo2T4SMkKm2V4RMjKn2V4RMiKo2V4RMjKn2V4RMjKn2V4RMjKn2V4RMjKn2V4fLeI7U2]1kMM\\6^NdI50JU2e1mMMo8MPGcN15O1Od0Q9BoF=0UO104OK425NG2i0V9_OiFIO00525NF11=6Ga0U:WOoFi0\\:000000000000000O11OO1000000d0VOhC4Pa4M]_K1o:0nD8K5=D_O2n0K_O2P85cGJO948;DBOg06XO2\\8JeG8OU12\\O1\\OV8LhGf3]4_6kKQIJc0\\4]6iKPIJc0^4^6gKoHKc0^4_6fKeIY4\\6eKgIY4Z6fKeI[4]6cKbI^4X7000O12NNcKQH]4o720000`NdKaIN08n0U4a5SLaJk3_5ULaJk3_5UL`Jl3`5TLaJk3_5UL`Jl3`5TL`Jl3`5TL`Jl3`5TL`Jl3`5TL`Jl3`5TL`Jl3`5TLaJk3_5ULaJk3_5UL`Jl3`5TL`Jl3`5WL]Ji3c5ZLaIYOf0^4i5ZLUJi3k5VLVJj3j5ULSJo3m5QLSJo3m5QLSJo3m5QLSJo3m5QLSJo3l5RLTJn3m5_KaIFD2Fb89eG=e0YOg7<`Ga0k9@lEFJc0_:J_ELN;b:EfEDJo0`:\\OmEc0S:^OnEa0Q:@mEa0S:BeEd0Z:]O`Ei0_:d001ON2O1O10M211O000000000000O1000OIaE]Na:c1`EZNc:e14ZNXEc1k:O1eNTEQ1m:oNUEn0m:POVENi;3:0010OO1000000MImC7SnH[4R7aKSI`4k6ZKnHL017i4=_K\\OHR60oIOO17j4U20f0H[MQ43WLl10h3:aLc1O=2fMV3]OZLS1?]1O=2fMl2l0SMQ1O=EUM6a0m2R1YMk0Oi0GYMP3T1ZMj0Oi0GYMo2U1[Mi0Oi0GYMP3T1ZMj0Oh0HZMQ3R1XMl0Oh0H[MY3h0PMV1Of0I[MV3j0SMV1Me0J\\MV3h0SM", "size": [400, 640]}, "area": 62866.0, "iscrowd": 0, "image_id": 10318, "bbox": [0.0, 77.0, 640.0, 323.0], "category_id": 140, "id": 10012610}, {"segmentation": {"counts": "QVl33_;NbD1g04f:OWE4JKZ:3mE1H3S:NPF4LNT:OmE6MLV:NmE7LKW:0kE6MJX:1jE7LHY:3jEh0V:YOiEg0d9jNeF`0Ff0e9jNeFa0Df0\\9iNhF0G0?o1n8VNkFKH0?o1b8QNYG6LN4MFo1b8QNhG3N4LM5n1Z8RN]GL2446LJ4Q2[8UN`GK4l2[8ZMaGJ5k2Y8iMbGX2^8hMaGY2^8m01O000000000000O10000HPLnGR4R8oKkGS4U84O1O1O1OkKYHc3Z801O001O001O1O001O001O1O3M1O1O1O0000O100O100001O001O001O001O001O001O00001O001O00^IjLk3U3ULkL]M010R6U3^LmL]M10MO0Z6Q3XL\\M^MC]6n2RLRMbM440X6j2RLRMbM361U6j2RLSMcM181S6k2RLSMcM0:1Q6l2RLSMcM0:1Q6l2oKZMPNJQ6l2RLWMmMMQ6l2RLWMmMLR6m2QLRMdM190S6l2PLSMdM190S6l2PLSMdM190S6l2PLSMdM190T6k2SLUMiM0T6k2SLUMiM0U6j2RLVMiM0U6j2RLVMiM0U6j2RLVMiM0V6i2QLXMgM0X6h2QLXMgM0X6h2QLWMiM0V6i2QLWMiM0V6i2QLWMiM0V6i2PLXMjMOV6i2PLXM^4h2bKXM^4h2`KZM`4f2bKYMhMMZ6j2nKYMhMMZ6j2nKXM^4h2bKXM^4h2bKWM_4i2aKVM`4j2_KVMb4j2b2000[IVMd3j2[LWMe3i2YLYMg3g2YLYMg3g2YLYMg3g2XLZMh3f2nKVMfM5\\6e2nKXMbM5`6c2nK\\MdMK^6i2nK[MfMK\\6j2nKZM\\4f2dKYM]4g2cKYM]4g2cKWM_4i2d20000000000000M300000000000000mHWMkMLZ6l2mKWMgMO[6j2PLWMaM1_6N^If2`2fMR4CbId2\\2_McM1`6O^I`2^2`MfM1]6KcId2Z2_MhM1b6`2fK^MjM1`6a2fK]MlM1^6b2fK]MlM1^65WIT2_2fMlM1^65WIT2_2fMlM1^65WIT2^2gMmM0_64VIM5n1Z2oMmM2`62TIM9n1V2QNmM2a60TIN;m1`2VNR4OdIg1^9WNeFg1U:M2N0000005K2N1O2N000000000iNjDT1Z;O3M0ClD\\OW;c0:13FiPm0KcoROO10000000O1O200N0oCJi;6YDIi;49010O1O1RX67f[ICo;?001DVD0i;0YDOg;0[DOe;0]DOc;1]DOc;1]DOc;1]DOc;1]DOc;1]DOc;1]DOc;2[DOe;2YDOg;3VDMjT6", "size": [400, 640]}, "area": 17233.0, "iscrowd": 0, "image_id": 10318, "bbox": [317.0, 76.0, 308.0, 324.0], "category_id": 149, "id": 10012611}, {"segmentation": {"counts": "d3Q3_90000001OO100O10aFQM]9Q3000001NO0N0QMeFo2\\95I234LM3O12NO1O100002N001OO200hLiFT3Z9O2O0001O02OO1OO11O003MON5JfLRGX3P9hLPGX3P9hLPGV3NjLR91nFU3U9kLkFT3U941N012N1O02N00002M01001O00000O0O20O0CUGUMIMR9m2?O011ON20N21N101O01N101O02O3L3L3N1O1OO001000LhLPGZ3n8fLQGY3Q96MM33MbLSGV3U920L2001M3O10N201M1001O000O102L3M3O000001O10OGQGPMP9o2SGoLm8R3TGlLl8S391O1O2N1O1OO1O100000000000000000000000000000000000001O000001OO11OO11OOJiLUGX3R9VMjFI3Q2U9UNlFCK14X2T9SNXGk1j8TNWGl1h8SNWGn1k8QNUGn1l8SNSGn1l8RNTGm1m8SNRGo1m8RNSGm1m8RNSGn1m8SNSGm1m8TNRGl1n8TNRGe0C4[9XOPGd0GRO5e0T9FoF?FTO?4AK3;Z94kF4HA0Nh:=`E1m:NTE1m:NTE1m:NTE1m:NSELFI[;;PEED002g;0c01Xm3NlRL0K6N6IN21O3J7LO21M3O2NM31O0PF[OT8d0iGFR8M^FF0OO0a1:W80[FFd1?m7K_FFb1=T8MPH:j7DXH6m7JTH:i7EWH7m7IRH;j7FUH8o7GQH:m7GWH5j7JXH3S:O2LjCLV<1jCO0O[<03000aj32]UL2M2iCKQ<:000O100000000001OO1000000000\\DHP;9kDEF6\\;7kDNT;2eDD0>Z;2fDNZ;e0O0000001OJ63M00000O2O00O1O100L4O1O10000000000001O1O1N0N4NN210000000O10O^Oc01N0100000eE@e8a0ZGAh8?SGFcNJ1OP:Q1kF]OV9c0nEoN070O7:k9`0nEPO0?62n9?lE_O53P:=kEB13T:m0lETOT:l0kEUOU:b111O1OO1O1000jEhMS92UGO:[2Z8lMZGKKM=^2Z8mMZGKNL=\\2[8lM\\Gm2c8UMYGm2g8>0YLYGe3i8O01O1001O0TM\\Gl1d8SN^Gl1b8SN`Gl1e8nM]GP2e8oM[GQ2T9`MlF_2U9aMkF^2V9bMjF]2g9M100001O00000000001O000O1\\ObMdF011<[2m8PNfFD7]2W9b0100YMfFX2Z9gMhFX2X9gMjFX2V9gMlFX2T9hMlFX2T9hMlFX2T9hMlFX2T9hMlFX2T9hMlFX2T9hMlFX2T9dMaF29[2V9cMaF37[2IaM60o81kF53]23]Mo80mF0O0005_2KcMO7_9f20O12NM35KJ65KK54LL45KM300M32ON20O00O12NN25KJ57IKPGUMC2o8o2UGXMj8m2\\GjLb8U3`GkL_80UGR3=nL^80UGQ3[9oLeFQ3]9O2O000O100000O01000000O100001O000000001O00000N3O1O1O1O0QGkLc8T3=O1eNeF@\\9;dF`N0T1?iN]8^1TGeN0N6h00XOX9\\1RGTO^9k0cFUOL@Q9[1SGUO]9k0bFVO^9k0aFUO_9l0aFRO`9m0aFSO_9m0aFSO_9m0aFSO_9m0`FTO`9l0aFSO_9m0bFQO_9P1`FPOa9o0VFcNI050KRGBn8=RGFl8:TGFl8:TGDn8R<2N1O2N1OO1L44LL45KO1L44L1OK54L1OM3N200O13M0000000000001O000000O1N2O11OO11OO11OO1001O00N23MO11ON2001OO1001OO100O10000000000001OOakk4", "size": [400, 640]}, "area": 1022.0, "iscrowd": 0, "image_id": 10318, "bbox": [176.0, 0.0, 65.0, 20.0], "category_id": 158, "id": 10012613}, {"segmentation": {"counts": "e6a4o7002NNTH`Km7\\442O1N01aKQH^4P8N21O011L0YIbK\\5_4gJaKW5c4gJ]K[5a4eJ_KX5d4hJ\\K\\5a4cJ_KZ5h4bJXK]5k4aJUKa5n4ZJRKe5T5_ImJd0Ol5`5fIgJY6j5N02N001OO1WKTJZNMc4n5oLYJ^NJa4n5RMWJ]NL_4n5PM]JQ3`4bKRL\\1@Q3[4fKULX1AS3X4fKWLY1_OQ3Y4gKXLV1AT3R4jK]LS1@T3n3^KdK;o0S1_OS3o3nKaLl0CW3j3nKcLl0BV3l3lKcLn0POdN>f4m3gKeLo0POdN>e4m3kKcLo0_OX3h3lKjLk0_OW3i3nKhLh0BZ3f3mKiLi0CV3]O_KX4b0gLc0KZ3b3SL\\Lh05R3b3ULSL_O^O^1i0Q3e3ULlK^OFN0_1k0n2g3UL`K^ON02f1j0f2g3TN[Lk1d3TN]Lm1d3TNXLP2f3PN\\Ln1f3PNYLQ2g3oMZLR2d3nM\\LQ2f3nMYLS2g3mMYLT2h3eM]KlMk0_4j3bM]KmMj0a4k3`MZL`2g3_MYL`2j3^MVLb2j3^MVLa2n3\\MRLd2o3[MQLd2P4\\MPLe2R4XMnKh2S4WMmKj2T4TMlKl2V4aKhJ^1R1Q3Y4oLfKR3Z4nLgKQ3K`K_3_1fLQ3JlKW3Q1nLT3KbL_2;fMT3JbLa2;bMU3K`Ld27dMX3GcLe25dMY3EcLf25eMX3PO\\K>1BV1[37cM]3\\OUKGW1Y36fMi3oNjJ2W1X37gMU5W2mJiMS5V2QKgMo4Y2TKbMn4^2lJhMT5Y2kJgMU5X2lJhMT5X2mJiMQ5W2PKhMP5X2PKhMP5X2nJfM_NUOc6U3nJ]M_5c2`JZMd5g2[J\\Mb5e2]JZMd5h2]JTMd5o2ZJQMe5n2\\JRMd5m2_JnLd5Q3ZJTMd5k2]JUMc5l2\\JTMd5k2]JUMc5l2]JSMc5n2\\JRMd5n2UIdLl0>P6o2RIdLl0?R6o2PIbLn0?R6o2PIbLn0=T6S3lH`LQ1Q6W3oIiLQ6Y3nIdLT6]3kIdLT6^3jIbLV6^3jIbLV6^3kIaLU6_3jIbLV6R1kHk0R1PNS6S1mHm0P1PNS6S1mHm0P1oMT6T1lHm0o0QNT6o0RIn0i0TNU6c0PIRO9S2b0\\NQ6>gIU1:[No5a0iIMVO6R1YOR6d0eIN[O1n0Bm5>lIIWO[O1l0m0CP6b0Bo5;nIFA=c0@n5=PJE_O>b0@P6>oIB@`0a0Bn5=PJAA`0`0AQ6>nIC_O>c0Bn5=QJB^O?b0Co5oI_OA4E@n0b0l5IRI3o0CJ>c02c5EoHJ54K3o17^O4f5@YIOF1Q2b8APF0\\1a0]:03L10O2O0O12N00O20L43nEBVN3T9>fHCoMK14Z9;hH1V72hHOV72iHM]7NdH2X73hHL[71eHO\\7OeH0Y74gHLY72gHNX74hHLf0BlN0U3c0ZMJe0CiN0_N2i49WKJS28nNCd00UO0J1\\O0T50nJ2R28mNGRO5i0I^O19421_1Jm00PM0T2:hNFTO?f0B[OO50J1a0513]OIn10^36aK;A;NEKKMC]10bN15O1O_46UL>A:De02_N;N=0UO104OK425NG2e43WL?C:AV18mMIO00525NF11=6G]40WL?Bc3BRMf4kNULa0Cm4Y4`JULc0Bm4Z4_JTLc0Dm4Z5PKdJR5Y5PKhJP5\\5lJdJT5\\5lJcJU5]5kJdJT5\\5gJUJH`0`5]5bJlJ\\1ZOjN7n2a6XMWI;l0X2m5]M^I5f0]2l5]MdI0l0AeNa11@j6VORJ2c0Gg08Q6HhG0cj3;`aL0N4nNFREK20>?_:EPEM3O>`0^:DQEM3ON1O19?c:ITEF0?0A0a0_:AbE0OO0:0j0_:oNaEd1`:\\N`Eb1c:4O2O1000O1O1004TGQNiN1Z7O]HQ2^1oMiN2]7X2WIlMYOJH054ILf7[2TIRN_OCI0O?c7l1VISN^OBI2N>e7l1TITN_O@Jc0d7h1TIVN]O_OJc0f7h1SIWN\\O^OKc0f7h1SIXN[O4a7g1QIVN\\O6a7d1eHkMJ_1U7jNhJGSNf1l6eNdKS1d4lN\\KZ1^4fNbKT1c4mN]KX1`4fNaKT1f4jNTK`1iMXNY69QL[1gM\\NY69oK[1hM\\NX6:PL[1gM[NY6:PLZ1eM\\N@0a10f3:eM[1bM[NB0a10oN1V44XN^1bM]N@0a10iN7EKc42\\Nj1TMRNO0O0a10hN:^4FWNf1]MZNF0O0a10gN;`7d1ZHQNN1O0b1OeN0I=c7`1fHSNI0N1b1OeN0I=b7]2eIWMPOOIP7MVLLTL1c74ZLJSLJ06b77\\LHUL0_78[LIWLK_7O^H>i3IP4:PLFP4:PL_OVL4k7=SLAl3`0VL^Oi3c0WL]Oh3c0S40001O0N21OO1O101N100O1JnC0PY6F\\MOZL:Z6G\\M0ZL8Z6H\\M2YL5[6I\\M4XL2\\6J]M5WLO\\6L`M3ULO[6NcM2TLLY62eMOS31g4O0000lGMk33UL2f3NZL7a3I_L6SL3g6GVM6RL7e6CYM5RL8f6CXM4SL8f6DWM4RL8h6DVM3RL9i6CWM3PL9j6DVM2PL:k6CVM2oK[Mn1a8SN_Gm1a8SN_Gn1`8RNaGm1`8QNaGP2^8PNbGP2^8PNbGP2^8PNcGo1]8QNcGo1^8PNbGP2^8PNcGo1]8QNcGo1]8QNcGo1^8PNbGP2_8oMbGP2_8oMaGQ2`8mMaGS2_8mMbGR2]8oMcGQ2\\8QNcGo1\\8RNdGn1[8SNfGl1Y8UNgGk1Y8UNgGk1Y8UNhGj1X8VNhGj1X8VNhGj1X8WNgGi1Y8WNhGh1X8XNhGh1X8WNiGi1W8WNjGh1V8XNjGh1V8XNjGh1V8WNkGi1U8WNlGh1T8XNlGh1T8WNmGi1S8WNnGh1R8XNnGh1R8XNnGh1R8WNoGi1Q8WNPHh1Q8WNoGi1R8VNnGj1R8VNnGj1S8TNV3O001M15I3N3O02N2N2N2N101NDK_D3_;0bDN_;2bDL\\;0WD5W<3O2N1O1O1O1O1O1O01O000000001O1N1Ob^>IfaA;C2XM_OaI;e6FZIa0^6AcI5^MIg83VGLO3j20X6:P3OgFL^6LaI5`6J`I7_6I`I8`6H_I9[91O2N100O101O0000001O00O100O10000O2O0O2O1N1OmCFS<;1ON2N20000O10000mLDRJQ90O10000000000O1000O101O1N2O001N2O0O3M4LmZ26kdM4L4ON2O[DHT;8kDIU;7kDJS;7mDIS;7lDJT;6lDOo:1QE2l:NTE2l:NSE1o:0PE0P;1nD0Q;1oDOQ;2mDOS;1mDOS;1mDOS;0nD0S;OmD2R;MoD3R;KoD5Q;KoD5R;JnD6R;JnD6S;ImD7V;FjD:X;@kDa0b;000C@jD`0R;IjD6T;LlD5Q;LPE4P;KQE5n:LRE4n:LSE4k:MUE4R5", "size": [400, 640]}, "area": 15198.0, "iscrowd": 0, "image_id": 10318, "bbox": [12.0, 47.0, 628.0, 261.0], "category_id": 183, "id": 10012616}, {"segmentation": {"counts": "P7f0e3O\\73SH@N6b00^ON0d00YO03>;31?@j5o0fIf0F\\NLa0>O>B]57dIh0>k0CkN?I0FEMS6^1VJV1B[M9a05GCKW6\\1lI`NOl3:gLi5[5UJjJg5W5WJlJg5`6LO11O00001O00N2[ITJk5l5UJVJ\\ONW6m5XJ`J\\5k5bJXJ[5k5bJWJ\\5m5`JXJ\\5l5^J`JV5e5gJ_Jn4T71M01O1ZOgGTL_8l3bGmKd8R4;00O1O0hMbGD`88kGiNYOJl86]G1f0^O[O:b86^G1\\1@QNN14T9<`GA[O;c;3WEKj:5WEHk:8UEAVO3f;;Y1CQC5Pk3MoTLNk<>XJB`N`0bK@b40YJ2e3MSNc0]OAnNM[56TNI^L2\\1l0G_OY4LTNLaLNR1n0UOUO:9h4KgJMn2:TNQ1]OnNj44eMMSNS1\\OmNl42fMNPNU1^OlNk41gMNcMB_O0Ne19nNP5MgMNbMe1^OhNY5FeMNdMd2g4]MfMObMe2h4\\MfM0aMd2i4ZMhM1`Me2h4YMiM3]Me2j4XMiM2^Mf2i4WMXMAnMd00c2k4XMVMCjMe06`2j4XMUMFfMe0:\\2m4YMQMIeMc0>9Ci0Y5cN_LC`NS17MGc0U5jNZLH^NP1X7jN_Hm0c0DHd0g6`NiH55:Ml0P1TOAn0`6PORI`1R1\\N]OS1_6V1VJeM[Oo0e6]1PJ]MgN4c0n0k6c1cJ_N\\5b1cJ]N]5c1dJ]N\\5a1fJ`NY5`1gJ_NZ5b1eJ^N[5a1fJ`NV5c1jJ]NT5d1kJ^NT5c1lJ]NU5_1mJ`NW5[1jJdNX5_1cJbNY5]1hHaMo1Q1X5a1nJ]NT5c1mJ]NR5c1oJ\\NQ5d1nJ\\NS5d1kJ]NV5c1jJ]NU5e1jJ[NV5c1lJ]NT5d1kJ\\NU5d1lJ[NS5f1lJ[NT5f1kJZNj4oNZIh2j1YNl4SOWIc2d0XM>R1h5R2aI[Ma0a0o5T2aI\\M>a0P6T2bI[M=d0n5R2fIWM?e0j5U2iIVM=d0j5V2fIZM?`0j5W2hIXMc0l5T2fIXM?d0k5U2eIWM`0c0m5V2aIXMc0a0l5X3TJeLo5\\3RJ`Lo5]3QIhKP1j0P6]3TJdLk5\\3TJeLm5`3lIaLU6]3lIcLT6]3kIdLV6[3jIeLQ6]3RJcL_5o3]JRLc5o3\\JQLd5n3]JRLc5o3[JQLf5m3\\JSLd5j3RJWKHP1V6j3nIaKDe0^6k3mI[LCjN31^6i4mIWL`6i3aIVL_6j3`IVLa6j3_IULb6j3aISL`6m3aIRL_6R4PISK8n0g6T4TIoKl6X50O1001O1O0000001O2N1O2N1OO1O11O2N00O100O11ON29G3M5K1O00O10000O1M3M3004LO1O10000O11O001O00SOcImJ\\6R5eInJ[6Q5gIlJ[6R5gIlJ[6S5fImJZ6R5hInJW6P5kIQKT6n4mIQKT6n4nIQKR6m4PJSKP6l4QJTKo5k4SJTKm5j4UJSKn5X3hI^M;]Oj5T3mI\\M<_Og5R3RJjLCLe07g5o2VJjLCMa0;e5m2YJfLGN>>b5l2^JbLG1:a0a5h2[LWMf3h2\\LWMd3e2`LZMa3f2_LZMa3f2`LXMa3h2_LXMa3i2^LVMc3j2^LVMa3j2_LUMb3k2^LTMc3l2^LTMa3l2_LRMc3n2]LQMd3P3\\LQMb3o2^LQMb3o2^LRMa3n2`LRM_3n2aLTM]3i2fLWMZ3g2hLZMW3_2PMaMP3a2oL^MQ3b2oL^MQ3_2RMaMn2]2TMcMl2\\2UMdMk2]2TMcMl2^2RMcMn2[2TMeMl2X2WMhMi2X2WMhMi2X2WMhMi2X2XMgMeLFc5b2jMiMXL0l5W2mMYNR2g1oMXNQ2h1PNXNo1i1QNWNn1j1RNVNm1j1TNTNm1l1TNSNl1m1TNSNl1m1UNSNj1m1WNQNj1P2VNoMj1P2XNPNg1P2ZNmMh1S2YNiMj1V2WNgMl1W2WNeMl1Z2VNcMl1^2SN_MP2a2]400O100001O00000000000000000aEdMo9m2O1WFkLZ9V3bFnL]9S3aFVMW9l2dFgL0=\\9_300000001O00001O1O001O1O001ONiFQLV9j38J61OO100O11O3MO1M30^G_LZ7a3eHlLo6T3QIlLo6T3QIkLP7U3QIhLQ7X3oHeLT7T3iGcLY16P7P3ZIkLj6T3g10000000000O1000000000000O11[FmLP9T3iFSMV9n2dFXM[9]3O00000000O100000000O10000O10000N2002N1ON200O10000O10000000000nN^F_MN40;e9Q2kFnMU9R2kFmMV9R2nFjMS9U2RGfMo8Z2QGdMQ9[2P1K5O1J6O1000000O100000000N21OO1L4H80000000000001O00O100002NOlF\\Nc6h1mF]N7Ma11Z7m1TGTNc03IO_8l1QGVNd07BLg8S2fGTN@Ki8Q2cGcM_OW1m8W1]GdMFZ1l8T1WGVOi8f201O002N00001O1fH^Ki5b4UJ`Kk5`4UJaKUONQ6a4gJeKUONR6]4fJiKUONS6Z4eJkKUOWOhKAX4?jK_OV4a0kK^OU4b0mK\\OT4c0nK[OR4e0PLYOP4g0SLVOm3j0VLcN_L7[7V1YL^N_L;X7W1`LiNY3^1jL_NX3^1RMYNT3`1\\4O1O3M2N001O1OTDhNg;W1YDiNh;V1XDjNi;U1WDkNj;U1501O1O001O2N1O1O1O010OZESOP9l0PGYOl8f0PGBj8CgEi0^1Le8\\OmEf0^17]8TOUFc0^1b0U8DfFVOf0^1]8]OmFTOe0d1Z8XOQGUOc0f1Z8UOTGTOa0j1Z8ROTGVO?k1[8oNWGVO=l1o7VN^Gh07VO;m1n7[OfGjN:m1m7ZOjGmN4j1P8[OkGjN3o1Q8WOmGkNNR2R8TOQHhNL[2m7oNVHdNNa2h7lN[H`NNg2e7iNkHY1W7eNgH]1V7eNhH^1W7cNaHf1^7YN[HP2d7oMVHZ2NYLc7d5O1N2jH\\Jb6e5\\I[Jh6d5TI]Jm6d5QI\\Jl6i5RIWJl6U61O00M3N200I7L40000O10000O1001O00000000O1001O2N2N4L5K2N3M001OO1O11O0000O100O1O100O100001O001O1O00O1O1O1N200000000O100001O1O001O00001O000dIaIl5o60001O00000000001O000000000000001OO1", "size": [427, 640]}, "area": 88490.0, "iscrowd": 0, "image_id": 10319, "bbox": [0.0, 201.0, 640.0, 226.0], "category_id": 123, "id": 10012618}, {"segmentation": {"counts": "kUb15o<7K6O1O001O00O100O2OO11N011OO10O01[DCZ:?eEGU:9kELP::iEHY:b0ZEAd:d0VE]Oj:e0TE[Om:e0lDgN4c0S;^12OO1N2001OO100OO20M2N14KLQNQEo1P;601O1OO1N201ON21O01OO2O1N0gNjD>W;YOXEa0g:@ZE>g:BYE=h:DUE?i:CWE=h:@\\E?d:B[Eg:BXE?i:@WE`0j:^OWEc0i;011JPOkCP1T<40O7I010O10M33L2OO11NO2MFfCH\\<4oCDR<;>101OO10O3N13_OUC8R=KiTh06SkWO2L5J5N2M5I30M013M30001O0O1000000O101O000O1000M3N1J72N00M3N2O02O1ON2M3000O10O100000O2O1O0000000O101OO10000O1N2O11O0000O100001O000000000001O0000POUD`0\\WOT;g0oDVOR;j0PETOP;m0g0O11OCgCJV<7kCHV<8iCGX<8hCIX<3kCNU<1mCDJ7Y<6oCDG2\\<8c0I9Mc\\i1", "size": [427, 640]}, "area": 16475.0, "iscrowd": 0, "image_id": 10319, "bbox": [120.0, 52.0, 382.0, 201.0], "category_id": 142, "id": 10012619}, {"segmentation": {"counts": "0P7f0`J_3`5`LaJ`3_5_LcJ`3]5`LcJ`3]5`LcJ`3]5_LcJb3]5^LcJb3]5^LcJb3]5_LbJa3^5^LcJb3]5]LdJc3\\5^LbJc3^5\\LdJc3\\5]LdJc3\\5]LdJc3^5ZLdJe3`5WL_Jj3c5TL\\Jm3h5oKVJS4a7000N2O100O11O1O0000O1O1O1O10000001O00O11O000000000000O11O00001O2N2N2N001O1OO1O1O100O100ZLjKXNU4BjKfM271`2S4QNmK_NOS1O]O0B2l06QOGe03g1S4UOPL`NOm0O]O1IMJ0:N7>3Ob1i3\\OZLaN@N6b00^ON0d00YO03>;31?@1V4?iLPOf0F\\NLa0>O>B1S44TLlNh0>k0CkN?I0FEMj0S41[M^OV1B[M9a05GCKl0R44ZMSO`NOl3:gL`0c32h1\\OjJ>^36i1ZOlJ>[38U3DkLU3BkL>S3ElL;_LROk5c0fM;_LTO\\ONW6c0nM0n4_2dJ`M`0Ol4b2eJ\\Ma02j4b2iJRMjNNe19l4g2gLPMb3n2]3100N2O100O_OjEnMW:Q2kEjMY:U2jEfMY:X2jEeMY:i1bE`Nk:]1ZE^NX:P2kEoMV:a1_EZN55:MS:_1kEdNg:[1e0000000O100000000M3N2O11O2NO1J6M30000000000O1000000O100EhCCX<^;G_D:^;k0L5L3M301O000O2O00001N10001O0O101O000O10001O00000O100jKaM`M^2_2dMaM\\2^2eMbM[2]2fMcMZ2[2hMdMY2[2hMeMY2Y2hMgMY2X2gMhMZ2V2gMjMZ2T2gMkM[2S2fMmM[2Q2fMoM[2o1fMQN[2m1fMSN[2k1fMUNZ2j1gMUN[2h1gMXNZ2f1gMZNZ2d1gM\\NZ2b1gM^NZ2`1gM`NZ2gLPMm3g0\\OY2dLUMm3c0_OY2`LYMn3>CZ2ZL^MP49FY2WLcMP45IY2SLgMQ41LX2oKmMR4LO]3LeL4]3IdL7^3FcL:_3CbL=`3A`L?b3_O^La0d3]O\\Lc0f3[OZLe0i3YOVLh0k3VOULj0m3TOSLl0o3ROQLn0Q4POoKP1S4nNmKR1U4mNjKT1W4jNiKV1Z4gNfKY1\\4eNdK[1^4cNbK]1`4aN`K_1c4_N\\Ka1g4\\NYKe1i4XNWKh1k4VNUKj1n4SNRKn1P5oMPKR2T5jMkJV2\\5cMdJ^2a5\\M_Je2g5TMXJm2o5lLQJU3U6eLjI\\3[6mKVJT4`7001O1O1O001O1O003M`0@9i1\\9hM[F?9m1Y9cM^Fa09S2Q9\\MfFa0:V2l8YMjFa0:Y2i8VMmFa0;Y2g8VMnFa0;Z2f8UMoFa0;[2e8TMPGa0;\\2d8SMQGb0:\\2d8RMRGb0:]2c8QMSGb0:^2b8PMUGa09`2a8oLVGa09a2`8nLWGa09b2`8mLVGa0:c2_8lLWGb09c2_8cMaG^2^8bMbG_2]8aMbGa2]8_McGb2\\8^McGd2\\8\\MdGe2[8\\McGf2\\8ZMdGg2\\8XMdGALh2_8gMeGA0d2[8kMfG@4a2U8oMgG@8^2P8RNhG@?X2h7gMcG56Kh0Q2^7PNfG14NQ1i1U7WNiGO11Y1b1n6^NhGM13^1^1i6bNjGJ05`1]1f6eNjGG07d1Z1c6gNkGFM9h1X1`6jNSHM`1W1]6mNQHLe1U1[6nNoGMi1S1X6QOmGLo1P1U6SOlGLR2o0R6VOiGLX2l0o5YOfGL^2i0m5ZOcGNc2f0j5]O`GNi2c0g5M]J0d5N_J0a5NcJ0^5HkJ6U5CTK;l4_O]K>j8N2N2N2N3L3N2NlkS1", "size": [427, 640]}, "area": 43357.0, "iscrowd": 0, "image_id": 10319, "bbox": [257.0, 123.0, 296.0, 299.0], "category_id": 183, "id": 10012621}, {"segmentation": {"counts": "0h1S1\\On>d0RA\\On>e0QA[Oo>d0RA\\On>d0RA\\On>d0SA[Om>e0RA\\On>d0QA]Oo>c0SA[Om>e0SA[Om>e0SA[Om>e0SA\\Ol>d0TAZOn>f0RA[Om>e0SAZOn>f0RA[Om>1Q@^OR1a0m>^OQ@@0947P1AmNO9d1AYN5P`0:e@AZO0N5Zb0:U1O100000000O11O00002N00000eABT9>kFDT9i0\\=MXBH^1h0`NlN030KOO117i0d=c0cCJaNA2YONk0l=c0bCd1^<]NaCc1_<]NaCd1^<]NaCe1]^NoAj1R>TNPBk1Q>P22O1001O0000J6M3O10000000QBbJ\\=^5dBdJZ=`5_B]JH3OMh=b5bB_JF6f=c5\\BWJN7e=c5\\BVJO9c=b5]BaJc=m511OO11OO1O11O0000O1O1O1001OO1N2001OO100N2001OO1O1N21O0000@[BaJHNo=a5>0000M32N00N21OI71O6JO10000O12N1O2N1OO11O0eA`JV>f5O00O1001OO10000002N0000GmAbJV>^560eA_JW>e50N2001OO11O00N2O1O13M1ON22NO1O12iA\\Jn=d5nA]J0OR>o5L0000O12N1O0000O12N1O00O11O00O13M00N2O10000001O1O00001O0000O1002NO1O100N2O11O0000001O00001O00001O00000000O1O1CUBZJV>a5700000000000000000000YOcAkK]>a1cAjM2=O_13fNZ>d1iATNJ`15gNY>d1SBkM@e18iNX>f1XB^OAjNX>i1^BUO[OPOX>k1bBoN[OoNV>o1bBnMgNS1b0mNV>R2aBnMhNQ1\\?Q1kAoMiNP1\\?Q1oAoNQ>Q1oAoNQ>P1PBPOP>P1oAQOQ>o0oAQOQ>o0PBoNQ>P1PBPOP>>b@bN1<[1g0R>;e@bN03MM]1T1Q>:e@bN03a1N\\N;01_?P1dBcNnM:0I0MO4`?Y1fBkNmMIMO34]?V1kBkNSNMR?V1nBkNe=T1d2O1001O0000000000000g_OjNh=W1VBjNj=V1nAiNmM7S`0P1PBVOn=j0RBXOl=n0P@bN06d1:cNAIO01a?h1_@WNa1?fNIY?c1PBVOP>j0mAZOR>f0kA^OT>b0PBVOT>h0UBUOg=l0YBROh=m0YBTOf=m0YBSOg=l0ZBUOe=k0[BSOg=m0YBUOe=k0[BPOj=Q1UBTOf=l0WBVN]Nl0g2D]9Y1`EWN[No0>ROf1a0P:W1UEIPOaNj0OG?\\;[1nDOnNXNn08D8`;Y1RE6TOTN3655d;^1]DYNAS2MnM85HF;TB>0000O1O100O10000O2ON21OO11O0000000VKm@g4T?XKl@h4S?YKm@g4S?YKn@f4S?YKm@g4U?1000001N12N1O1O000iLj@d1V?[Nl@d1T?[Nm@fNKO1f2W?\\N]AlN\\Oh2X?hMg@1i0V2`>dMi@FO>i0Y2^>YMk@030KOO117i0a2^>WM`A2YONk0j2X`00010O2OO0O20000N2O1N1MQMT_Oo2m`02O0O1000001N2e_OlLi?U3a001O0001I7L5M3NOQ@\\Ld?c3^@^L`?b3?mLf_O`2Z`0`Mh_O^2\\`0[Ma_OH3OMl2^`0^Mc_OF6j2_`0XM[_ON7i2_`0XMZ_OO9h2]`0XMf_Oi2g`011N011N00011N1000O001O1001OO1N2001OO100N2001OO1O2M210O001_OWMe_OHNS3]`0>0000M32N00N210H80O6JO10000O12N1O2N1OO11O0_Lf_O\\3``0O01N1001N010000002N0000GgLh_O\\3X`060_Le_O]3_`00N2001OO11O01M2O1O13M1_O>13M0O103WMn^O_2Sa0]Mn^O0Oa2`a0K1O1O003N1N100O012M2O0O011N10O04M0OO2O0100O101O1O00001O0O10O1002^Ok]OUOTb0j0X^OlNga0R1e0N001O3M2N2M3N3M2N201O0O101O00000O10O1O1C^OQ]Ol0kb07000001O001O00001O001h^OjNm>OX@W1g0oNn>NX@T1f0ROP?LY@T1b0UOP?K[@S1a0WOS?GZ@T1=[OX?BY@T1;_OZ?BT@S1=@_?^OQ@S1oNj@f1a0YOk>lNf@j0OG?e0S?cN_@n08D8h0[?nNX@3655l0d?cNT@85HF;\\1Q`0iNW@KO\\1j?bNa_O2h0NM]1Q`0cNm@]1k`0000000001N11OOcNa]O[1bb00010O0001O0N3N2O001O1O01N10FaNR^O_1ha0^NY^O21^1ga0cNT^O14\\1ha0jNW^OV1ia0kNW^OT1ja0mNV^OQ1ka0nNU^OR1ga0dNW^O:2R1da0VOZ^Ol0fa0TOX^On0ha0ROX^On0ha0e0004jMV^Oo1na00O0001O0UNQ^O1O^1Sb0^No]O3N_1\\b004MOROa]O:`b0Cd]O<\\b0_Of]Od0Zb0[Og]Oe0Zb0XOj]Of0hb001O00O11O1O0000000001O0N2001O00LVOQ]Ok0ob03N12O0000000000001O0000000000003NO02N2M10000O1O0010000000000001MZOj\\Og0Tc0ZOl\\Of0Tc03N3O0N3O00O102M10001N100000000000000000000000000001O001O0000O10000O10000O102N1O00001O00O1001OO1O101O000N2MVOo\\Ok0Qc0110000O10000UOm\\Oi0Uc0000000000000000002N1O00000000000000000001O001O001aG", "size": [640, 480]}, "area": 36615.0, "iscrowd": 0, "image_id": 10321, "bbox": [0.0, 126.0, 480.0, 181.0], "category_id": 99, "id": 10012623}, {"segmentation": {"counts": "c:]9R;A003M1O1O1O1O001O1O001O001O00001O0000000000000000000000000000O1001O1O000000000000O1O1O1000000000000O1O1N2006J00000000O100J6C=O1O17I8H5K1OO1O1_O\\GfEd8i9VHmEk7T:THlEl7U:SHjEn7Y:oGfER8\\:eGiE]8\\:]GfEb8[:\\GgEc8Z:[GhEd8Y:[GgEe8j:000000000O100O1OZLkDcNT;nMoD]1R3TAnLm>o2T1kNZ_OlNh`0l0d_OiNe`0P1a1B?Al^47j`K8H8J6N2N2N2O1N2SO\\N\\_Of1_`0bNY_Oc1c`0cNW_Oa1e`0fNS_O_1h`0o0L4M3L4L4L4M3O10000O10oNR@PNm?o1X@mMi?P2]@kMe?S2a@eMb?X2U1B=C>L4Cd1AYN5O[`0f0`_OZO0N5Y2LgM\\`0_3c_OaL\\`0_3e_OaL[`0_3e_ObLZ`0_3e_OaL[`0a310O11O0O120OO1O000000kLe_OB1Y28SNS`01i_Oi1Qa0TNR_Oi1Ra0RNR_Oc1Xa0[Nk^O^1Pb0N2O0O001OO11O000O10000M3J6L4ROP]Oa01C]c05d\\OHbc02`\\ONac0O72X`[3NlkcL2=Omb06P]OJob0a0g\\O@Wc0h0N7H5H3[]OgNcb0Y1]]OhNbb0W1_]OiNab0[100O10O1001N1^ObNR^O1<[1ea0gNo]O03MM]1Rb0fNn]O03a1N\\N;0o`0S2e^OnM:0I0MOSa0V2U_OmMIMO3Pa0X2U_OSNg`0P2W_ORNg`0d2O1001O0001O00000000YOX_OVNi`0h1X_OXNh`0`1W_OmM7`0c`0c1c_O[N]`0e1e_OXNb`0Dn^O06d1:cNAIO0]a00c^Oa1?fNVa0Y1i0M3M34J9J0N11OO10000001O0Mi]O]NVb0d1j]O[NWb0Y1a0K221]O]]OAcb03W]OLNN=1ob0OQ]O0ac0OQid3", "size": [640, 480]}, "area": 7279.0, "iscrowd": 0, "image_id": 10321, "bbox": [0.0, 14.0, 293.0, 128.0], "category_id": 130, "id": 10012625}, {"segmentation": {"counts": "PTl51oc01O1T\\ONhc0;W\\OEac0?N1O0000O100001OO100001O0000O12NO10000000000O10000000000000000000000001O00002N1O0000O11ONe\\O_O[c0a02002NNe\\O_O[c0a02001OO100003MN2002N1OM3001O0000O11O00O1O11O00O11O0000000000O100000000001O1OO1O12N1OO11O2N1OO11O3MMm\\OYOSc0f041O1OO1O12N00O1N21O00Jh\\O@\\c0`0200001O00000000000000001O000000000000000000000000000000O100000000N200000000000000001O00000000000000000000000000001O000000000000", "size": [640, 480]}, "area": 3256.0, "iscrowd": 0, "image_id": 10321, "bbox": [301.0, 0.0, 179.0, 27.0], "category_id": 157, "id": 10012626}, {"segmentation": {"counts": "Q^Q11ec0;M3d\\OJ93ha0]1O010O1I7OO2D_O`Ae0Z>G[A=b>MTA6i>4l@0R?_2O2N1O1N2O2O1O002O7H7YBcJ^b1RNl:a1_C>i1oMh:X4dD_KUO8VM3NoN[KkBc4W=aKeB]4]=hK^BU4e=PLVBn3l=ULQBi3Q>Q12M1O011O2N2N2N1ZKkA`3Z>kK_A6a0h3Q>[LUBb3l=aLSB]3n=dLRBZ3o=gLQBW3Q>iLoAU3S>]LWA6f0[3U>]LYA6b0[3c>cL]AZ3g>eLYAX3l>fLTAW3P?hLPAS3V?lLj@S3Y?kLg@T3Y?lLh@T3S?YMe@f2Z?^Md@a2[?_Mh@`2W?\\Mn@c2R?ZMRAe2o>WMUAh2k>VMXAj2d>YM]Af2c>ZM^Ae2c>ZM^Af2b>YM_Af2c>WM_Ai2i?2H9K5O010O0010O01O010O1N1L5K5N110000O10000O2bLj_OP3V`0mLn_OR3T`0jLo_OU3_`000O10N11mL\\_Oi2c`0WM[_O03a2``0jM^_OV2a`0kM__OV2X`0[Mh_Oa00V2f?XMd@i0FR2c?WMe@h0GU2`?RMi@k0FV2^?oLm@k0EV2m?jMS@V2l?P11iLS@X2Q`0j01hLn_O^2S`0bMm_O^2U`0XMR@i2Q`0RMQ@n2X?lLdAU3W>RMgAm2X>VMfAk2X>XMgAg2U>^MQAM1f2l>_Mo@N5c2l>VNTAj1l>VNTAk1m>iLn@V15Q2Q?gMWAZ2i>YMcAh2]>QMiAo2d?1O1O1O1O2N3M3M3L4K4L3M3M4L3M4M3M3N1O3N11N1O8G2N2N1O1O001OYOjKdAV4Y>mKhAR4X>nKiAR4V>nKkAQ4U>oKlAP4T>PLnAn3S>QLnAn3R>RLoA6VOZ3k>`LQB2YO[3f>cLRBO]O[3a>fLSBL@\\3]>hLeBW3S?00WM^_OQ2e`0kM__OR2d`0jMa_OS2a`0iMd_OS2_`0iMg_OR2Wa0M3L3M4L4L5K7H7I6I6K5K5HP\\2LjcMb0M4Dl0[O0O21O1N2ZOf02Nb0@N3L1nNc]O`0^b0^OX^OLla0OV^OO__6", "size": [640, 480]}, "area": 68911.0, "iscrowd": 0, "image_id": 10321, "bbox": [53.0, 214.0, 417.0, 426.0], "category_id": 183, "id": 10012627}, {"segmentation": {"counts": "Qb0o1Qb000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000@`0000000000000000000000000000000O10000000000000000000000000000N2DC=C=CmQ9b1\\gFc5]Jd5VMj2N2M2O2N2N1O2N2N2N1O2N2N2N1O2N2N2N1O2N1O000000000000000O101O000000000000000000001O00000000000000000000001O0O1000000000000000001O000000000000000000001O000000000O10000000001O00000000000000000000001O000000000000000O10001O000000000000000000001O00000000000000000000001N100000000000000000001O000000000000000000001O0000000O1000000000001O00000000000000000000001O0000000000000O10000001O00000000001O0000000000001O01O00000001O00000000001O0000000000001O00000000001O00000000001O00000000000000000000000001O000001O000000000000000000000000000000001O000000000000000000000000000000`0@P1POP1POP1POP1POP1QOo0POP1POP1POP1POP1POP1POP1POP1POo0QOP1POP1POW[6", "size": [640, 425]}, "area": 168490.0, "iscrowd": 0, "image_id": 10324, "bbox": [0.0, 0.0, 414.0, 560.0], "category_id": 183, "id": 10012630}, {"segmentation": {"counts": "0PZ]18fTcN3M3M2O0N3M2O2M2N2O1N2N101N2N1O2N2N1O2M3N1O2N2N2M3N2N1O2M3M2M2O1N4N2O001O2N6J=C6J4L4L3lFaLd6b3WIeLc6_3WIhLd6\\3WIgLh6^3QIfLm6b3hHbLW7o3cGgL\\8o401N100O100O100OM3iNX1K5N2O1O12N3WGPK\\7S5_HRK^7Q5]HTK`7W6O000O2O00000000000000fN^HVKb7b4kHYKU7d4RIXKn6f4XISKk6j4g1N2M3M4M2M3M4M2O1N2O2N1O101N1O1OmGWLR5i3jJZLV5g3gJ[LZ5e3YJhLf5\\3QJiLP6^3cIgL^6g3mH_LS7f3^HdLc7[5101O00001O0K5lNT1RNeFSN^9m1cFRN\\9o1fFPNY9P2iFnMW9S2iFlMW9T2kFkMT9U2\\G[Md8e2`GWMa8i2aGRMb8n2`GmLc8S3e10RNZLbHf3_7[L_He3b7\\L\\Hd3d7^LZHb3g7`LVH`3k7aL_G1\\O_3]2]Lm34VJ4[O^3]2`LQ40TJS4d1ULX4JoIS4o0nLR5POlIT4=aM\\OQNo5;TJ`7l5bHQJa7n5aHnI_7T6bHiI_7X6c0101N2N2O001eNQJcIP6Z6UJcIl5Y6YJeIg5Y6^JdIa5W6hJfIV5V6SKgIk4V6o1H9J61O0O2O02O2M4M3M3L4M3L4M3K5C3M2N2O1M2N2O2M2N2O1N1O2O1N2N1O2N2N1O2M3N1O2N2N2M3N1O2N2M2N2M2O2M4N101O1O3M6J=C6J4L4L3lFaLd6b3WIeLc6_3WIhLd6\\3WIgLh6^3QIeLn6c3gHbLW7o3cGgL\\8o400O100O100O100OK5iNX1L4O1O1002N3WGPK\\7S5_HRK^7Q5]HTK`7V601O0O10000000000000mNSHSKm7`4fHZKZ7c4nHXKR7e4TIXKl6f4h1M3N2M3M4M2M3N3M2N2N201N1O101N1O10lGWLR5i3jJZLV5g3gJ[LZ5e3YJgLg5]3PJhLQ6_3bIfL_6h3lH^LT7g3]HcLd7\\5001O00001N1kNU1oMgFTN`9k1bFSN^9m1cFRN\\9o1fFPNY9P2iFnMW9R2jFnMU9S2lFkMT9U2]GZMc8g2_GUMc8k2`GoLc8Q3f1000RNZLbHf3_7[L_He3b7\\L\\Hd3d7^LZHb3g7`LVH`3k7aL_G1\\O_3]2]Lm34VJ4[O^3]2`LQ40TJS4d1ULX4JoIS4o0nLR5POlIS4>aM\\OQNo5[101N1O100O2O:EkSQ5", "size": [480, 640]}, "area": 27740.0, "iscrowd": 0, "image_id": 10327, "bbox": [96.0, 123.0, 200.0, 292.0], "category_id": 183, "id": 10012632}, {"segmentation": {"counts": "jbS26jc04L1O01O[\\OHac0:\\AGc>:\\AFd>:[AGe>9ZAHf>9YAHVNAX`0g0bA5Y>KiA4V>MhA5W>KiA5W>KiA6V>KiA6V>JjA7U>JkA5U>KVBHl=9TBEm=;SBDn=TBBl=>UB_Om=b0RB^On=c0QB]Oo=Ki_OJNb0Z2H^>6cAI^>7aAHb>6^AKb>4^AJd>7[AJd>6]AKa>5^AN`>2`AO_>2_A0`>0_A2`>O^A3a>M`A2`>N`A2_>O`A2`>O`A0`>0`AOa>1_AOa>2^ANb>2]AOb>2^A0`>1_A1`>N`A1b>O]A0e>O[AMj>2WAKl>5SAFRNIk`0a0UA@TNNh`0b0^21N11O00O2O01O00O101O0101N3M2N2O1OO00001O1O1O2NN11d\\O_OZc0a0e\\OBXc0b011OLh\\O_OYc0a0g\\O_OYc0a04O1O1O10O00002M10O11O0000001O001OO2L3K6M3KnfS5", "size": [640, 480]}, "area": 3052.0, "iscrowd": 0, "image_id": 10337, "bbox": [108.0, 0.0, 110.0, 127.0], "category_id": 102, "id": 10012633}, {"segmentation": {"counts": "S^b61lc0301N2O1O1N2N6K1O000L_Oi\\Oa0Wc0@h\\O?Yc041O1O0O2O1N1000L31O2G:K5NRZY2", "size": [640, 480]}, "area": 341.0, "iscrowd": 0, "image_id": 10337, "bbox": [336.0, 441.0, 26.0, 22.0], "category_id": 104, "id": 10012634}, {"segmentation": {"counts": "Rfe57gc0202M102N001O0O101OO04M2NM21M5D;O1O10OO10001N02OO10000O1OUOZ]O>gb0@[]O`0db0@\\]O?eb0@]]O?db0@]]O?cb0A]]O>eb0BZ]O>fb0ZOc]Of0lb0O001O0000001O0001O]Of\\O`0]c0010000002N2f\\O\\OWc0c02O000000O011O0001O001O00001O1O0100O1OO110O0000001O01O0001O00000010O00N201N1O1O20O000001O0000001O01O00100O1O1O01O01O0001O01O0001O01O01O00mNEa^O;_a0Ea^O:aa0F^^O:ba0F^^O9ca0G]^O:ba0G\\^O9fa0FZ^O;ea0E[^O;ea0FZ^O:ga0EY^O;ga0EX^O;ia0FV^OkNAJ20`01A<4l;f2UD\\MAGY1m1QO[No;f2RDeMH]Ol0T3g:KcDYN:i1S;i1bDVKIP3f;W50O2O0O010O2O000VJXD\\3h;gL_Do2a;PM`Do2a;fJTD01U2;bN4HHi2i;mL`DX1LYOm0GgNZ2P<^McEK\\N7>>_1[OSNc2f>QNdCd1`R5n>01O1O1O1O1O001O1O001O1O001O001O1O1O001O2N1O1O1O1RLn@l2S?RMTAh2m>WM[Aa2f>]MdAZ2\\>fMnAP2T>mMnAMfNd1b?WNjA2lNb1Ra0\\NS_Oa1fa002N2B>L3M3O3K3O2N2L3N2N3L3NnP^8", "size": [640, 480]}, "area": 4871.0, "iscrowd": 0, "image_id": 10337, "bbox": [0.0, 478.0, 47.0, 162.0], "category_id": 110, "id": 10012637}, {"segmentation": {"counts": "a6U2h3Ae8?[GAe8`0ZG@f8`0ZG@f8b0XG^Og8c0YG]Og8c0YG]Og8c0jCiMW3d1o8l0^DoMW1T1[:m0^DWNP1l0b:m0\\D^Nm0e0g:n0ZD_Nn0c0h:n0YDaNn0a0h:R1UD`NR1>i:R1SDcNS1;j:R1RDeN:hNN`1f;T1QDfNKeNJN67:_1k;o0nClNKgNM2>]1m;k0mCQOIUO4ZOLg1Y1aAd0>kNAJ20`01A<46\\>KfAAGY1m1QO[N9\\>HoAH]Ol0ka0ZO]_O:[b0E]\\OIchV8", "size": [640, 480]}, "area": 10808.0, "iscrowd": 0, "image_id": 10337, "bbox": [0.0, 205.0, 60.0, 259.0], "category_id": 112, "id": 10012638}, {"segmentation": {"counts": "T>j0Vc0001O1O1O1O1O0O2O1O001O1O001N1010000O001N3N1O1N2LbNc]O`1`0oNk`0Ae^Oa1>UOf`0o0Y_OYO``0g0^_OCX`0>h_OLn?6o_OLMfNa?e1Z@G2lN_?U3_@PM^?i311N21O2M2N02OOOXL`@R3_?iLg@W3X?dLm@\\3S?bLo@^3P?`LTA]3m>bLVA[3k>dLXAZ3h>eLZAZ3f>dL]A[3c>eL^AZ3c>dL_AZ3b>fL_AP3UOQM``0m2;M3N2M3N2N20OO2O^_ObMc?^2\\@cMc?^2[@fMc?X2]@iMc?W2]@iMd?V2Z@mMFDa?_2i@nMECc?]2i@PNCDe?[2g@SNBDg?=]@m0:ROBDi?Mj@\\1JUO@Dj`0V1f_OVOACj`0V1d_OYO^ODo`0R1c_O\\O\\OBQa0S1b_OD^`0b_OB^`0>b_OB^`0>a_OC_`0=a_OC_`0=b_OB^`0=c_OC]`0>b_OB^`0>b_OB^`0>c_OA]`0b0Z_OdNFk0o`0e0R_O^NOU1o`0i10000000000O10000O100O100O10000O100O10000O100O100O1EkLk_OU3Q`0RMl_On2o?ZMm_Og2n?h01O1O1O1O1O000000O1000000O1O1O1O1MPLU@Q4g?6O10000001OO11O000000O1000000000000002N0SLX@`00W2W`0QMi_O3143HMl2V`0UMj_O0O0167IIh2V`0ZMi_OO1O06TOh_OO51KOV2l0S>TOP@1F0V2k0T>TOP@1GOW20kMe0d`0[OZ_O1`2?V>AZ_OO`2`0W>AX_OOb2?V>BmA=T>BlA>T>CjA>W>AjA>V>CjACiA=W>DhAChATc0Bl\\O>[c0O2O0001O0001O000010O0000010b_O", "size": [640, 480]}, "area": 13531.0, "iscrowd": 0, "image_id": 10337, "bbox": [266.0, 448.0, 214.0, 150.0], "category_id": 123, "id": 10012640}, {"segmentation": {"counts": "m_a11mc03O2M2O1N100M4J6L3O10000010O00000100O0000XOl\\O>^c004L3J4MWXZ7", "size": [640, 480]}, "area": 423.0, "iscrowd": 0, "image_id": 10337, "bbox": [79.0, 109.0, 26.0, 27.0], "category_id": 130, "id": 10012641}, {"segmentation": {"counts": "anU51oc0000O1U\\O3\\c0`?:l_OVOf0`0^?:m_OSOh0b0[?:n_OPOk0f0W?:n_OoNl0g0V?:XAFh>:XAFh>:XAFi>9UAIk>7TAJl>6g@POTOk0U`05f@QOkNO6m0Y`03e@UOPOi0[`02e@WOnNg0]`02c@;]?Kd_OjNN4=Y1Q`05o_OKR`04o_OKQ`05P@JP`06R@Hn?8S@Gm?9U@Ek?;T@Fm?9R@Hn?9P@HP`08Q@Go?9o_OIQ`07P@HQ`07n_OJR`07j_OLV`07g_OIY`09e_OG\\`09a_OIa`0j1O11O00O1001O0000001O1O00000000O100001O00000000001O0000001O", "size": [640, 480]}, "area": 16104.0, "iscrowd": 0, "image_id": 10337, "bbox": [251.0, 527.0, 229.0, 113.0], "category_id": 165, "id": 10012644}, {"segmentation": {"counts": "d_f0P^OBPb0=R^O@Pb0`0P^OAoa0>S^O^OPb0b0R^O\\Ooa0c0g0O10d\\O^OZc0d01O000O1001N11O00012Ge\\OF_c01_\\OOUic7", "size": [640, 480]}, "area": 1612.0, "iscrowd": 0, "image_id": 10337, "bbox": [35.0, 588.0, 55.0, 52.0], "category_id": 167, "id": 10012645}, {"segmentation": {"counts": "f0d1S1`1R=`NmBa1S=`NkBa1U=_NkBa1U=_NjBb1W=]NhBc1Y=\\NhBd1X=]NfBd1Z=[NfBf1[=YNeBf1\\=[NbBf1^=YNbBh1^=XNbBh1_=XN_Bh1b=WN^Bj1b=VN]Bk1c=XNYBh1i=XNVBi1i=ZNQBZND_3Y>[NoAg1R>[NkAe1U>\\NjAe1L`LU>m1lAi12XLm=n1PBm11ULP>m5000000001O0O2O001O00O11N1NjAZJV>f52O2O0_OfA[K[>d4fAoJO:[>g4jAVKY>i4iAQK[>o4;01O00mNPKVCP5j>_1[OSNZ8g0XHm62fJ[7^NbHP7OQKP7oMQIk:B^D00f01n4f0kJf;EfC`5d0kJSn9o6QHQIo7o6UHmHk7T7WHfHl7Z7UHcHm7]7\\20O001eDfHo9Y7QFkHk9U7UFlHj9T7VFlHk9T7UFkHkNHm:]7WFoHi9Q7XFnHh9R7XFoHh9Q7WFoHi9Q7VFPIj9P7UFQIl9n6TFSISOAa:\\7[F`I_9a6cF^I\\9b6cF`I[9b6dF^Id7WOlH[7@_Ib7ZOWHIE_7b0_Ia7@^G@0010944_7b0^Ia7LaGYO<]7c0]I`78kG]6o0nHX7e0iG]6P1lHX7g0gG^6Q1jHY7i0dG^6U1hHV7j0eG^6U1gHW7k0cG`6U1eHX7l0aG`6X1aHY7o0^Gb6X1_H[7n0]Gd6W1^HZ7EZGZ13n4OhIN`1\\1jN[7X7fGlIP1kNY7Z7hGjIo0kNZ7[7iGhIm0nNY7Z7kGhIk0lN\\7\\7iGhIk0mNZ7\\7kGgIl0nN]7U7gGmIk0QO[7S7jGmIj0QO[7R7kGmIi0SO[7P7lGmIh0UO\\7m6lGnIg0WO[7l6nGmIh0VOZ7m6nGnIg0UO[7m6mGoIg0UO\\7l6mGPJg0SO\\7m6mGPJg0ROa7j6hGUJf0QO_7m6kGRJf0QO_7m6kGRJe0ROc7i6gGVJf0SO^7j6lGSJf0UO^7f6mGUJd0TO\\7k6QHPJc0TO^7k6PHQJa0PO`7R7PHnI`0mNe7R7lGQJ>hNPOI`8d7RHlI?aNSON^8d7PHmIb9P6^FPJ]9U6bFmI\\9T6eFkI_9Q6aFoI]9S6bFnId9l5\\FTJ_9Q6bFmI^9T6bFlIe9m5ZFTJ`9R6`FoI^9R6bFnIc9m5^FRJ_9Q6cFmI\\9T6gFiIZ9V6hFhIW9Y6kFeIU9[6mFdIS9[6mFeIS9[6mFeIS9[6mFfIR9Z6nFfIR9Z6nFfIS9Y6mFgIS9Y6mFhIR9X6mFiIT9V6mFjIR9V6nFjIR9V6nFjIR9V6nFkIQ9U6oFkIQ9U6oFkIP9V6QGiIn8X6SGgIn8X6SGhIk8Y6VGfIj8Z6VGfIk8Y6UGgIj8Z6VGeIl8Z6SGgIn8X6RGiIk8fNSFa7R1jIj8X6VGiIi8W6WGiIk8U6UGkIk8U6UGlIj8T6VGlIh8X6VGiIh8[6UGeIk8\\6UGdIh8_6WGdIe8^6[GcIb8^6hFQH>b1h8]6gFTHa0_1h8f6dFgGb0c1k8e6cFhGb0a1m8g6aFiGa0_1P9g6_FjGa0_1o8h6`FhGb0`1n8g6aFjG`0_1P9f6`FkG?_1R9f6^FlG`0_1Q9e6_FlG`0_1Q9j6nFVIS9l6_FeG6_1[9l8O0O1O2N1N2O100K^ElFc:R9_EmFa:S9_EmFb:P98O10010O00001O04L4M2M4L4M2M004WN\\FnHi9k6^FPIf9k6bFnH^9P7RGcHn8[7SGeHn8Z7SGeHn8Y7SGgHm8^OoEK2g7Q1PIn8YOPF04f7o0QIW9o6iFQI[6YO_Kc7WNSIY6ZOaKb7VNTIY6ZO`K8RML0o6U1cIX6[OeH3T3P7nMbIR6JPLb6PNeIk5LWL]6oMgIi5MYLY6QNiIf5M[LY6oMkIe5L\\LX6PNlId5L[LY6QNkIe5KZL[6PNkIe5JZL\\6RNiId5KZL\\6SNiIb5J\\L]6RNiIb5J[L^6SNhIb5J[L_6RNhIb5I[L`6TNfIa5J\\L`6RNfIb5J[La6SNfIb5H\\Lb6RNeIb5I[Lc6SNdIb5I[Ld6SNbIb5J[Ld6SNbIc5IZLf6RNaIm5ZOiH3Y3R7RN`I\\9a6cF`I\\9`6eF_I[9b6dF^I[9c6fF\\IZ9d6fF]IY9d6fF\\IZ9d6gF[IY9f6gFZIW9g6iFYIW9h6hFXIX9h6hFYIV9h6fEcHm0d0]9j6eEbHn0d0]9k6dEaHo0e0[9k6dEcHQ1a0X9V7eEWHP1c0Q9b7PG^HP9b7QG]Ho8c7QG]HP9b7QG^Hm8c7SG]Hm8c7SG^Hl8b7UG]Hj8d7VG\\Hk8d7TG\\Hk8e7VG[Hi8e7WG[Hi8e7XGZHg8g7YGZHe8h7ZGYHf8f7ZGZHf8g7ZGYHe8g7[GZHe8Q6YFZI0]1R1cNlNc0h9n5dFkJk0VOb8n5dFlJn0QO^8S6dFlJFdNV1`0X8R6mFfK3[NDBK=252[OL4P7_6_IbK2Z2i4W2VK^K1c3_O\\J3Lc3f6jL_K2n5T1dNkN]K1W66eGKg6N^K0X62hGNb60^K1^7_O^FOf6b0]K0^>0bA0^>1aA0^>OcAO_>2aAL`>4`AL`>5]_O\\On1>f>;YADh>=WACi>>VABj>?VA@j>`0VA^Ol>b0TA^Ol>b0TA^OnNFQ?m0o@SO0?JJS?d0i@1AFb0IQ?`0k@j03gNR?`0j@h05iNP?`0i@i08fNn>a0j@o01bNZ8BnMm0mIm0@oN`0VO[30WL1W3NeL024a6k0lIU2DnLM4e3>UO]OWM1O?c6=iIk2EZLT3OjLN1g0OYO]20cMV1b6HgIQ3GVLY13gNI0OY11gNO20Oi0X2d0X4AdI^3S1PL0g0SOPO6>3o0l5]OdIb3S1PLMo0lNhN12O>0_O2K6^1HbN`6b5gJXKiNVO44OL3h1K@OiN6_1\\6S4nI_JG4IV10eN3X3OYNa6R4^I:0eKb6R:]IoEc6f;100002N00N2M3M3N2000000001O00000000005K9G0hI_BQ6`=PJ`BP6`=PJ`BP6`=PJ`BP6`=PJ`BP6`=PJ`BP6`=800001O000000000iI_Bo5a=QJ_Bo5a=QJ_Bo5a=RJ_Bm5a=SJ_Bm5a=SJ_Bm5b=RJ^Bn5b=RJ_Bm5a=TJ^Bl5b=TJ^Bl5b=TJ_Bk5a=UJ_Bk5b2UJS81ZEj5_2PKbMPO4N^98]Fj5_2aNo3eKcIi5^2?aMaI0O\\49dKh5^2l0g1\\IkKh5^2l0h1^OWNc0i1[IjKg5]2n0i1[IjKg5]2n0i1]OVNd0j1[IjKe5\\2P1S1UIRM6_Oe5\\2P1R1XIQMT6m1d0R1ZIoLR6n1e0S1YIoL2Cc5[2R1T1WIoLT6m1e0T1UIQMV6j1f0U1RITM8]Ob5Z2T1U1RITMW6g1g0U1RITMW6g1g0U1SISM8^O`5Y2V1V1RISMV6g1h0V1RISMV6g1h0W1RIQMV6h1h0W1RIQMV6g1i0X1QIQMV6g1i0X1RIPMU6h1i0X1RIQMT6g1j0X1RIfLK3Y6n1k0Y1RIeLK4W6n1l0iMlH^36fLM4U6o1n0X1PIdLM5U6n1m0[1QIaLO6R6n1n0[1QIaL05Q6o1n0[1\\IeLf5o1o0\\1]IdLc5P2P1\\1bI_L^5U2P1\\1JdN6\\1JdN6\\1JcN7\\1JdN6\\1JdN6\\1JcN7]1IcN7]1IcN7^1HbN9]1GbN9_1GaN9_1\\I_Ld5Q2Q1a1ZI^Le5Q2Q1a1YI_Lf5P2Q1a1XI`Lg5n1R1c1UI`Li5m1R1c1UI`Li5m1R1c1TIbLi5k1T1c1QIcLk5i1U1d1mHeLo5g1T1d1gHlLT6_1V1e1fHlLT6_1V1e1fHlLT6_1V1e1fHkLU6`1U1e1fHiLW6a1T1f1eHgLY6c1R1g1dHiLW6`1U1g1dHiLW6_1V1h1cHkLU6]1X1i1bHkLU6[1Z1k1`HjLV6[1Y1m1`HhLW6", "size": [640, 480]}, "area": 142220.0, "iscrowd": 0, "image_id": 10337, "bbox": [0.0, 0.0, 480.0, 457.0], "category_id": 172, "id": 10012646}, {"segmentation": {"counts": "0f0Zc0000000001O0000001O0000001O0000001O00001O00001O1O000000001O001O001O00O11O0000001O0000001O00001O01O1N2O5ROR]Oa0Wc0O001O01N11O01O01O0001O01O01O01ON3O10O003NO10O0001O00000001O01L3YO^Oo]Oc0Qb0Gc]O;]b0Ea]O=_b0C`]O>`b0C_]O=ab0b0O00001O00001O0000001O00001O00001O001O0000001O04Lc0]O10O0001O01O01O01O01O010O010O00000001O01000O0001O00010O0000010O001O0001O010O0010O00001O010O01O100O1O01O01O0001O000O100010O01O0000001O10O000100O1O2NN3OXOk\\Oe0Vc0ZOm\\Od0Vc011OL\\Ok\\Of0Tc0ZOl\\Of0Tc030000010O00002M10O200O1O00010O0YNXOW@h0h?[OT@f0l?[OP@i0o?XOk_OP1R`0QOk_OS1S`0mNo^OJa0_1^`0gNn^OMa0_1a`0mNk^O@b0c1c`0mNk^O@b0a1e`0oNi^OAa0_1g`0POh^OAa0_1g`0POh^O@b0`1f`0oNi^OB`0_1g`0oNi^OB?_1i`0oNg^OC`0_1h`0nNh^OC`0_1h`0SOW_Om0i`0VOi^O[O6_1Qa0V1O00001O000000001O001O0000001O00001O00001O00001O0000[NR_O8n`0FY_O5g`0Ja_OO_`0OQ@Dn?;S@Em?;T@Dl?;U@Ek?=T@Ck?X@Bh?>X@Bh??W@Ai?=Y@Df?;[@Ee?9^@Fb?:^@Ga?8`@H`?8`@H`?9_@H`?8a@G_?9b@G]?9c@G]?9c@G]?:b@G]?9d@F\\?;c@E]?;c@F\\?;d@D\\?d@B\\??c@A]??d@@\\?a0c@@\\?`0e@_O[?b0d@^O\\?b0e@]O[?c0e@^OZ?c0e@]O[?c0f@\\OZ?e0f@[OY?e0g@[OY?f0f@ZOZ?f0f@[OY?e0c_OfNm0d0`?g0b_OeNn0d0`?h0a_OdNo0e0_?g0`_OgNQ1a0_?o0^_O^NP1c0b?Q1_@oNa?Q1`@nN`?R1`@nN`?R1a@nN^?R1b@nN^?R1b@oN]?Q1d@nN\\?R1d@nN\\?S1c@mN]?S1d@mN[?S1e@mN[?S1f@lNZ?T1f@mNY?T1f@mNY?S1g@mNY?T1g@lNX?T1h@mNW?_Og_OL0]1R1cNlNc0g`0i0`@VOk8B^LX1kJQO_80eLo0dIdNV1`0X81nLg1RJ[NDBK=252[OL4P7>@c1QJZ2i4WLV1^1QJc3_O\\J3Lc3f0j2_1RJn5T1dHk4]1QJW66eGKg0n5^1PJX62hGNc0o5]1RJ^7_O^FOg0a6\\1QJ_8o5aGQJ_8P6`GQJ^8o5cGoI_8R6aGlI_8U6aGkI_8V6^E[In1>e8\\6ZGcIf8_6YGaIf8a6YG_Ig8b6YG]Ig8c6YG[Ii8e6WG[Ie8F`Eo6k1[InNFj81\\Fo6j0PI0?JJl8k6PGjIAFb0Ik8f6QGdJ3gNm8e6oFcJ5iNk8e6nFdJ8fNj8e6nFkJ1bNZ8BkGP70jJ@oN`0VO[30WL1W3NeL024>n6ORLDnLM4e3>UO]OWM1O?`0`6LhLEZLT3OjLN1g0OYO]20cMV1;o5NjLGVLY13gNI0OY11gNO20Oi0X2d0QNh5KWMS1PL0g0SOPO6>3o0Ed5K[MS1PLMo0lNhN12O>0_O2K6`10Z:o0PEiNVO44OL3h1K@OiN6b10Y::VDG4IV10eN3X3O^N0Y:OnI0o=O[`W2", "size": [640, 480]}, "area": 25773.0, "iscrowd": 0, "image_id": 10337, "bbox": [0.0, 0.0, 365.0, 449.0], "category_id": 177, "id": 10012647}, {"segmentation": {"counts": "dbQ88dc0k0^\\OPO4N[b0c4kLm1e@aI0OX=m6I0O10000O1000000O10000O1000000O1000000O1000000O100VClHhda0B^^Ona0A]^O1E:Rb0DZ^O3C5Xb0EW^O6B3Xb0EX^O9_O2Yb0DZ^O9]O2Zb0FX^O8_O1Yb0GX^O9^OO[b0HW^O9^OO[b0IV^O9_OL\\b0KU^O9_OL]b0JT^O;_OJ]b0LS^O:@I^b0MR^O:@I^b0MR^O;@F_b00Q^O9@G_b00f]OK3?GEab01e]OL3=HE`b03c]OL5=GCcb03a]ON4c1h`0mNj^O@=c1j`0mNi^O@0O;c1m`0nNh^O@0O;c1m`0nNk^O_O8c1m`0mNi^OAOO;d1l`0lNj^OAOO;d1l`0mNi^O@0O;e1k`0QOU_On0l`0ROT_On0[`0Dd_O;``0B`_O=d`0@\\_Oa0c`0_O]_Ob0F]Ni`0Q1a_Oe0a`0YO__Og0``0ZO`_Oh0\\`0ZOd_Oc0^`0^Ob_Od0]`0[Oc_Od0``0ZO`_Oe0d`0XO\\_Og0k`0SOU_Ol0m`0SOS_O>FXOWa0:S_O>GWOVa0;S_O=HXOUa0;T_O;IZORa0;U_O;I[OQa0:V_O:KZOPa0T_O87ROd`0f0U_O8`a0H`^O79ROb`0g0U_O79ROc`0f0T_O7:SOc`0e0S_O9ea0E[^Oe0\\a0ZOd^Oh0FmN[a0:o^Oi0FmN[a0:o^Oi0GlNYa0;V_Oc0BSOWa0;R_Of0HnNVa0S_Og0KjNRa0?S_Og0KlNPa0>T_Of0LmNo`0=U_Oe0MmNPa0=S_Of0MnNo`0i0N@Vb0G]]Oa0=HZb06g]OAD3fb0j]O@Yb0?e0O10N3N01O00001O0ATke02iaYONnb07Q]OIob07Q]OIob07Q]OInb08R]OHmb09S]OGmb09S]OGob07Q]OInb08R]OHnb09Q]OGPc08P]OHob09Q]OGPc08n\\OHH0Zc08n\\OHH0Zc08n\\OHH0Zc08n\\OHH0Zc08n\\OHH0Zc08n\\OHH0[c07m\\OIUc07k\\OIH0Zc08n\\OHH0Zc08P]OHob09Q]OGob09Q]OGPc08P]OHob09Q]OGPc08P]OHPc08P]OHPc09o\\OGPc0:P]OFPc0:P]OFPc09Q]OHPc06P]OJPc06P]OJPc06<11O1OO10ON3O100004L001OO0001O2N001O1Oc\\>0ScA1e\\OOVc06j\\OJH0[c07m\\OKSc05m\\OKTc04l\\OLUc03k\\OMVc02j\\ONVc02j\\ONVc02j\\ONVc02j\\O0Tc00l\\O0Tc00l\\ONVc02j\\OLH0^c04j\\OLH0^c04<00O10001O000001O2O0N2N2O101M2O2OO0Id\\OJ\\c02h\\OMXc04g\\OMZc01g\\OOXc02h\\ONXc02h\\ONYc01g\\OOYc01g\\ONZc02f\\ONfc00E0f\\O0Yc01f\\O0Yc00e\\90gcF00O10\\\\O0Wc01i\\O0Vc00j\\O0Vc00j\\O0Uc00l\\O0Tc00l\\O0Tc00l\\O0Tc00l\\O0Sc01m\\ONTc02l\\ONTc01m\\OOSc01m\\OORc02n\\ONRc02edn0Of[QO4L4L44MN1000010O000O1010O00000O1O1O1O1O002O00O1]\\OMYc0=001OO10000001OO11OO11O00O11OO1001O000000001O0000O1000000O100001O000000001O10N1O11O0000000O1Aa\\O=_c0Ca\\O;cc0M]\\OHdc01\\\\OO10Q_d0", "size": [640, 478]}, "area": 11220.0, "iscrowd": 0, "image_id": 10342, "bbox": [0.0, 100.0, 446.0, 125.0], "category_id": 95, "id": 10012650}, {"segmentation": {"counts": "0V3j`000000000O1001OO10000000000O1002N1O1O1O1Z_OlL^`0[30001O0000002N:F4L1O000000001O00000000000000000000000000000000_Oa03M3M00002NO1N2O11O2N3M6J1O00000000000000000000001O1O2N1O1O00O10000000000000000001O000000001O000000O1000000O11O0000001OO11O0a0@h0WOl0SOi0XOo0fN_\\O6Peb0HQ[]O0_b02c]O2NLO003008h0K@MF031MQa01P_O6N30E4T2LlMe`0o0\\_OR2j?X1J001O000000O11O0000001O00O11OO10000O1O1002NO1001OO11O00000000001O00O100O1001OO11O0000O100002N0000O11O1OO100M3O100004L001OO1O1001OO10000O1O1O1O1O1N2O1O1O1O1N2O1O1O1N2O1O1O1O1N2O1O1O10000000Y@cLk>]3PAhLP?X3k@nLT?R3h@SMW?m2d@YM[?f3000000000000000000000001O000000001OO1O1001OO1001O0000O11OO1001O00002NO1O1Ob@bK70k>`4VA`Kj>`4VA`Kj>`4VA`Kj>`4VA`Kj>_4WAaKi>_4<00Ok@bKj>]4WAcKi>\\4XAdKh>[4YAeKg>Z4YAfKh>Y4YAgKg>X4ZAhKf>W4[AiKe>V4c0O1O1O1O1O1O1O1O1O1Of@TLb>k3j0N2Oe@XL`>h3_AYLa>g3[A\\Lf>d3VA`Lj>`3SAcLm>]3o@gLQ?Y3l@jLT?V3h@mLY?S3d@PM\\?j301O00O1O1O1O100O1N2O1O1O1N2O1O1N2O1O1O1N2O1O1O1N2O1O1N2O1O1O1N2O1O1O1N2O1O1O1N2O1O1N2O1O1O1N2O1O\\@\\Mn=c2oA`MR>^2lAfMT>Y2iAkMW>U2eAPNZ>P2bATN^>l1^AXNb>h1ZA[Ng>e1UA_Nk>a1QAdNn>\\1n@hNR?X1j@lNV?T1f@POZ?k20000000O11O00O100001OO10000001OO11OO11O00O11OO1001O000000001O0000O1000000O100001O000000001O1OO1O11O0000000000000000L4@`0C=G9DO2N003M000000000000O11O001O1O1O2N1O1O0000001O0000O1000000000000001O1O000000O11O001OO1O11O0000001O001O2N3eJZAV5j>N0000001O00O11OO11O1O00O1O100000000O11O00O11OO11OO1000\\OXAPLi>m3ZARLg>l3ZATLg>i3\\AVLe>n0SAZ1:hMj>c0YAZ10mMEHY?e0_AY1HQNJ0e`0f1[1I7K5K5L1OO001O1O1O001O00K5K6J6J6Jl^c0", "size": [640, 478]}, "area": 37283.0, "iscrowd": 0, "image_id": 10342, "bbox": [0.0, 376.0, 446.0, 264.0], "category_id": 116, "id": 10012652}, {"segmentation": {"counts": "Y=X4XP`2kKfc`M4K5L4L3L5L4K4MN2N1O2N1O2O1N1O2N2N1O1O1O1O1O1O1O1O100O1O1O1O1O1O1Ojmf11URYN100O1000001O000000000O100000001O00000001O1O001O^OMX]O3Zc0100\\OL[]O4Yc00O10000O1000O1O1O2N10eod3", "size": [640, 478]}, "area": 843.0, "iscrowd": 0, "image_id": 10342, "bbox": [0.0, 425.0, 290.0, 180.0], "category_id": 123, "id": 10012653}, {"segmentation": {"counts": "jQ91Zc00g\\O010=0]b04]]OLH001>OC0eb07Z]OI379ID10Oo`00d@g0]NYO87g`0La@g0dNAj`0L]@f0eNSO0;m`00\\@P1d?SOX@o0g?UOU@k0j?XOT@h0l?YOT@g0k?YOT@h0l?XOU@g0k?YOT@i0j?XOV@h0j?XOV@h0k?WOU@i0l?WOS@j0k?WOU@i0k?WOT@j0m?UOn_O]OYO\\1l`0VOk_OP1U`0oNk_Ob0[OjNN8m`0=i_O?h`0Km^O4Ua06`^OJ^a0\\1ON31O100001N101OO100O1O11N2cM_^OY2da00002NM32NO1O1O1O10001O01O1OO1g^OUN]`0h2N200N110O1O0O4N4K4L5KGP@gLl?X3[@aLe?_3\\@_Le?a3>0O0O1002O0OO110O000O1010O00O2N1002OM22N01OO100O1O10000001N1O10000OLk_O]LV`0c32ZOj_ORMNb0Y`0=h_Ol05eNS`0>k_Ok01gNV`0`0g_Oh04gNV`03n_O^OJh12fNT`07\\@\\O[O\\15QOV`05TA1`N]O6^Okc:4okDM\\<5fB7gMDg?0aBo0]=TObBl0R=CkB=X=;lAFT>T1RAmNm>d1X@[MOX1i?l201O0HkKe@V4Z?lKc@V4\\?kKb@V4^?7O1O1N101O1O1O001N1015K6KN2NMg@aKW?_45001N1000001O0000001O0O101O0000001O00001N1000001O00001O000O2O0000001O00001O0O101O00MRATKn>k4SATKm>\\4c0Cb@QLN5`?k3<1O2N1OJ7N2[Ln_O\\3Q`0cLS@X3P`0fLT@X3l?gLW@W3i?hLX@Y3g?fLZ@Y3W`0N2MZ_OlLf`0T3Z_OlLf`0T3DkLS@T3m?nLR@Q3n?PMQ@Q3o?PMP@o2P`0RMo_On2R`0SMl_On2T`0SMk_Om2U`0>11ON20000O1N2000O101OO1001O00000000000O10O1001OO10000001O002N1O2M100000000000cLj_Oo2W`0PMj_OP3Y`0lLi_OS3S`0hLV@W3k?iLV@V3j?jLV@V3i?jL[@S3e?mL\\@Q3e?oL[@Q3e?oL[@Q3d?PM\\@P3d?oL]@P3d?PM[@Q3d?PM\\@P3d?PM\\@o2e?QMZ@P3f?PMX@R3g?oLZ@g2_O]MX`0LY@e2A_MV`0LY@e2B]MU`0OZ@c2o?]MQ@b2P`0^MP@b2o?`MR@^2n?cMS@Z2n?fMT@Y2k?hMT@X2k?fMX@Z2h?eMY@[2g?dMY@]2f?dMT@c2k?\\MU@d2l?[MU@e2k?[MU@e2j?[MW@8Cj1U`0nMX@2JQ2l?mMZ@0NQ2HmMb?3h@ONR2GoM`?0k@OMT2GoM_?Nm@ONS2^OZNe?Dn@0Ng2Q?ZMQAONg2Q?ZMQAOMh2R?YMQAOMg2R?\\MPAMNg2R?\\MPAMNg2R?\\MPAMNf2S?^Mn@LNg2T?]Mn@LNf2U?`Mk@JOg2V?`Mj@I0g2V?bMe@J4d2W?eM_@K:`2W?]N_@d1b?]10O10000O1M30000001O0000O10O10O100O10000O10000O10000002N000O1V@nKf?V400000WMb@P1]?POd@P1\\?POe@o0Z?ROf@k0]?VOc@h0]?WOe@i0[?gNVAX1i>hNXAX1g>iNYAW1e>kN\\AT1c>mN]AS1b>nN^AR1a>oN_AQ1b>nN^AS1`>nNaAQ1_>oNaAP1`>QO_Ao0a>QO_An0b>RO^An0b>RO^An0b>RO^Am0c>SO]Am0c>SO]Am0c>SO]An0b>QO^AP1b>oN_AQ1a>oN_AQ1a>oN_AQ1a>oN^AR1b>jN^@QO2Ok0W2d>hNe@TOd0U2f>gNeAY1[>gNeAX1\\>iNo@RO0U2Q?kNj@SO5R2Q?lNh@SO8P2P?oNa@VO?k1P?^OPAc0o>]OQAc0o>]OQAc0o>]OQAc0o>]OPAd0P?\\On@g0Q?ZOm@g0S?YOf@n0Z?l1000001O0000PNb@^O^?b0b@]O_?c0a@QN2g0^?W1`@bM0=2i0_?X1_@bM2:1b0h?b1U@bM4744P`0S2i_OaM383LZ`0[2`_OaM47i`0X2S_OaM40Pa0^2;I7C=H`D_NQ5V1YKRO`4f0eKAW42WLOg3GcL9_;3H8I8J53NL30gN`]Oo0MPOhb0R12100O1VMXO]Bg0^=^O`Bc0\\=BeB>[=AcB=fMoNg?e0dBLeMAR`0e0ZBHbSOjEP1V:QOjEn0V:ROnEj0Q:WOiE7PL4X>DiEGoK=09W>CjEFPL>OC0c0W>HkE0nKD10Od0W>GlEEmK87

HnEHVL?l=IPFDiK0;c0l=I_F8`9HaF7_9IaF7_9IaF7_9JaF5_9KaF5_9JbF7]9IdF6\\9JdF6\\9KcF5]9KcF5]9IfF6Z9JfF6Z9JfF7Y9IeF9[9FgF9V9J[FEdKN8d0i=JXFf0h9ZOWFg0i9[OUFd0m9YObF9\\9ZOPB>d46]9\\OoA=g44[9_OnA0O;i44[9AmA0O;k41Z9GkA8l4OY9GlAOO;m4MY9IkAOO;o4JY9KiA0O;P5H^98cFF^9:U5O00000000000000000000000000000001O000000000000000000000000000gAEl8a0oFFPKM`=8dGLjJ2]=1jG`0R8AdBFV5m0P8BPHb0l7ZOXHg0g7YOYHh0f7XO[Hf0g7YOYHg0eJmNP=<[Hi0e7WO\\Hh0d7XO\\Hh0c7YO]Hf0d7ZO\\Hf0e7YO\\He0e7[O[He0e7[O[He0e7\\O[Hb0e7_O[Hb0e7]O[Hc0g7[OZHd0f7[O[Hf0c7[O]Hf0b7ZO_He0a7\\O]He0c7[O]Hf0b7ZO]Hf0d7]OXHe0g7YO[Hg0T7lNaC767T5g0T7kNbC767T5h0R7UOiC3V5j0c2XOlKJ[L5U5i0d21SKQOTM5U5c0j2S1PJXNlMD0>U1Bm2k0X4Q2RIZNdNiNm01U3f0]4U3cGTL6\\1c0fNUO0h3NYLh0_8n4ZHaJm2d0j4j4ZHbJT2KQMNb0j0P8l4XHcJ5Hl05eNd0R8m4WHbJ5Kk01gNe0S8n4UHbJ8Hh04gNc0U8n4mGlJ1G^OJh12fNb0W8o4lGjJ45\\O[O\\15QOa0X8Q5jGkJ3m01`N]O6dMjAS228T>eMlAe1?c0f=gMkAi1W1Do8fA8Q1FT`03l^O6P1GU`02k^O7o0HV`01k^O7Q1FT`03k^O7S1CS`05k^O8S1AT`06k^O7cb0I]]O7bb0J^]O6cb0ET]ON:b5B^J>b5B^J>b5B_J>`5B`J?_ISOn;>cJa0_IROk;=gJd0W5]OiJd0U5]OkJd0S5]OnJb0S5]OmJc0S5^OlJc0S5lN[D?b6e0U5[OlJd0T5\\OlJe0S5[OmJd0T5\\OmJc0\\InNe;?oJe0Q5[OoJe0Q5nN[D9d6j0R5kNZD;e6j0R5VOnJk0m4kN_D:d6k0k4jN`D11:e6k0i4jNaD11:e6k0h4nNcD7e6j0i4oNbD7e6j0i4nNcD8e6i0h4oNcD8e6i0f4QOeD6e6i0e4ROfD5f6h0b4UOhD3f6g0a4WOjD2e6g0`4XOkD1e6h0`4VOkD2f6f0a4WOiD3f6f0b4VOhD4f6f0c4UOgD5g6e0c4TOgD7f6g0c4POgD9f6g0d4oNfD:g6i0g4WOYKl0d4TO\\Km0c4SO]Km0VIhNZ;;aKm0TIhN10W;;dKS1[4mNeKQ1]4oNdKP1\\4POdKQ1[4oNeKo0]4QOcKn0^4ROcKo0[4QOeKo0[4QOcKETIX1[;SO`KP1`4PO`KP1`4PO`KQ1_4oNaKP1`4POaKo0_4QOaKP1^4QOaKo0_4QObKm0_4SOaKm0_4SOaKn0^4ROcKm0]4SOcKm0]4SOcKm0]4SOcKn0\\4ROeKn0Z4ROfKP1X4POhKFRIV1V;TOmKl0R4TOnKl0R4TOnKl0S4SOnKl0S4SOmKm0S4SOmKl0T4TOlKl0T4TOmKk0S4UOmKl0R4TOnKl0R4TOnKk0R4VOoKi0Q4WOoKi0Q4WOoKi0Q4WOPLh0P4XOPLh0o3YOQLi0]3mNhE:l6i0[3mNiE:l6j0Z3kNkE;k6i0Z3mNkE:k6i0Z3mNkE:l6i0X3mNlE:l6h0Z3mNjE;l6h0Z3mNjE;m6h0W3mNmE;l6g0W3nNnE;k6f0W3nNPFX3CgL=Y3CgL`0V3@jL`0V3@jL`0V3@jL`0V3@jL`0V3@jL`0V3@jL`0V3@jL?W3AiL`0V3@jL`0V3@iLb0V3^OjLc0U3]OkLd0T3\\OlLf0R3ZOlLi0S3WOlLk0T3TOlLl0T3TOlLl0T3TOlLl0T3TOmLl0R3TOnLl0R3TOnLl0R3TOoLj0R3VOnLj0R3VOnLj0R3VOnLj0R3VOoLi0Q3WOoLi0Q3WOoLi0Q3WOPMh0P3XOPMi0o2WOQMj0n2VOSMi0m2WOSMi0m2WOSMi0m2WOSMh0n2XOSMh0l2XOTMh0l2XOTMi0k2WOVMg0k2YOUMf0l2ZOTMg0k2YO]EDe7S1n2[OTMd0l2]OSMc0m2\\OTMe0k2[OVMd0j2\\OVMe0i2[OQMC^HV1_:WOTMB]HZ1OfN[:>YMS1d2nN\\MR1d2nN\\MR1d2nN\\MR1d2nN[MT1d2lN\\MT1d2lN\\MS1e2mN[MT1d2lN\\MS1e2mN[MT1d2lN\\MU1c2kN]MU1c2kN]MT1d2lN\\MS1e2mN\\MR1d2nN]MQ1c2oN]MQ1c2oN^MP1b2PO_Mn0b2RO^Mo0a2QO_Mo0a2QO]MP1d2PO\\MQ1c2oN`LBXI0g0^1b9PO]LFQJ\\1a9nN]LFSJ[1a9oN[LGSJ[1b9nN[LFkIKDe1V:jNYLH^Il1_:\\NRLj1R4VNeJBeK_2h9oMbJDWKk2W:aMkGA5a3P8nLkGA]O0gNc3Q:lLkGAQN2g0NPOn3^:bLiG@bM0=2i0W4_9WLiG@bM2:1b0`4i9mKiG@bM4744j4X:^KkGAaM383LU5_:TKlGAaM47d5]:fJkGBaM40j5e:`JiGk5W8UJbGR6^8nIUG^6l8bIlFU6_NjIe:1aF_6ROYI]:8YFd6AoHV:>lEQ7X:_HcE`0K[7b:UHaEd8a:]G\\EOH]8T;dGmDOO10Y8W;8Ec0@:J9kE\\Fb9U:I8E^1V6d4XNTJTKJ>^1W6c4WNUJTKJ>^1X6b4VNYJbKU1Y6S2YIjNl4nMbKU1[6P2WInNl4mMbKU1\\6^4RN]JbKT1^6^4QN]JaKU1_6]4PN^JaKU1`6\\4oM_JaKU1b6Z4lMbJbKT1c6Y4kMcJbKT1e6W4iMeJbKT1g6U4gMgJbKT1h6T4fMhJbKT1j6R4dMjJbKT1l6P4bMlJbKS1o6o3_MnJbKS1P7n3]MPKcKR1R7l3[MRKcKR1T7j3YMTKdKQ1U7i3WMlJUK7?T1W7g3UMXKdKQ1X7fNZHQ10d2j4YLUK9?S1_7EUHd2h4fLdKQ1`7ETHc2i4fLcKQ1c7DSHc2e4jLeKo0d7CTHb2b4mLfKn0f7BRHb2a4oLgKm0g7ASH\\OGk2g4\\MhKl0i7_ORH\\OFn2f4\\MiKk0j7^OSHZODR3e4\\MjKj0l7\\OSHYOBV3d4\\MkKi0m7ZOTHb2R4]MmKg0n7YORHd2R4]MnKe0o7ZOPHe2R4]MoKc0P8[OnGf2R4]MPLa0Q8\\OlGg2R4]MQL?R8]OjGh2Q4^MSLh0CXOS8:iGW3f3PMbL_O9h0DWOR8;jGV3e3mLfLC5h0EUOR8=iGV3e3hLkLG1h0U8B[GW3d3dLoLKMh0U8B[GW3d3_LTM0Hh0U8B[GW3d3[LXM4Dh0U8B[GW3h4_LhKh0U8B[GW3h4_LhKh0U8B[GW3h4_LhKh0U8B[GW3h4_LZKI7o0\\8B[GW3h4_LZKI7o0\\8B\\GV3g4`LZKI7o0\\8A]GW3f4`LZKI7o0\\8A]GW3f4`LZKI7o0\\8A]GW3f4`LZKI7o0\\8A]GW3e4aLZKI8m0]8B\\GW3e4aLZKI8m0]8B\\GW3e4_L\\KK6m0]8B\\GW3e4]L^KM4m0]8B\\GW3e4\\L_KN3m0]8B\\GW3e4ZL`K12l0]8A^GW3P5\\LUKl0^8@]G>5`1k4fMUKl0^8@]G=i0n0W4YNUKl0^8A\\G;^1gGJ=?EHd8AN>]GK;>FIXa0Og^OJ;>FIWa00h^OI;=GKTa0Ok^OI:=GKSa00k^OI;V^OBia0?W^OAga0a0Z^O^Oea0c0[^O]Oda0d0\\^O\\Oca0e0]^O[Oaa0g0_^OXOaa0i0_^OWO`a0j0`^OVO_a0k0a^OUO]a0m0c^OSO\\a0n0d^ORO[a0o0e^OQOYa0Q1g^OoNXa0R1h^OnNWa0S1i^OmNVa0T1j^OlNTa0V1l^OjNSa0W1m^OiNRa0X1n^OhNQa0Y1o^OgNo`0[1Q_OeNn`0\\1R_OcNn`0^1R_ObNm`0_1S_OaNk`0a1U_O_Nj`0b1V_O^Ni`0c1W_O]Ng`0e1Y_O[Nf`0f1Z_OZNe`0\\1Q_O_N:5d`0Y1V_ObN65b`0W1\\_OdN25a`0T1a_OgNN4a`0R1f_OiNI5R1Ne=Q1dAlNE5Q10c=m0kAnNA4R11a=j0PBQO]O4R12`=e0VBTOXO4T12^=b0ZBXOTO4R15_=;_B\\OPO3c0f0n=GcB@lN2c0i0m=AiBCgN1e0k0k=]OmBGcN0f0l0j=YOQCK_NNh0n0h=UOUCO[NMi0P1f=POYC4@l0]?UOc@k0\\?VOd@j0[?WOe@i0Z?XOg@h0W?YOi@g0W?YOi@g0W?XOj@h0V?PORAo0Pa000000O1O10O1000LPOW]O2Oj0jb0ZOZ]Ob0fb0<001ZOY]O1ib0KY]O6gb0G[]O:Uc000000000O1N2O2K4IYP10loN3N1N2UMIkA:cc0PB4X1IQNIf>Q2PChNo<]1jBfNT=`1gBbNW=c1dB^N[=g1aBYN_=g1aBYN^=g1bBZN^=e1cB[N]=d1dB\\N[=d1fB\\NZ=c1fB^NZ=a1gB_NX=a1hB`NX=_1cBgN]=X1^BnNb=R1XBTOh=l0RBZOo=f0jA@V>a0cAE^>n21O001O001O1O001O1O001O001O1O001O001O10O01O1O001O001O1O001_O_5", "size": [640, 478]}, "area": 87913.0, "iscrowd": 0, "image_id": 10342, "bbox": [0.0, 88.0, 477.0, 552.0], "category_id": 183, "id": 10012657}, {"segmentation": {"counts": "S5k1`;10O0O1WN`Dh1a;O01O23L0ON4N1000001O001OO11O02NO002O000000TNcDk1^;O1VNaDi1`;00001`DVN];i1dDWN];k101O00001O0eDSNX;P201O00000000000iDoMT;R2kDnMU;R2kDnMS;V2N3O00000O20N100001O000002N1O00M300000NQEhMn:m0UE:m:^O\\E`0d:XOeEi0[:ROiEn0V:SOjEm0V:SOjEm0W:ROiEn0W:ROiEo0V:QOjEn0W:ROiEn0W:SOhEn0W:ROiEn0W:ROiEn0W:ROiEn0W:ROiEl0XOkNo:9iEl0Z:SOfEm0Z:SOgEl0Z:SOfEm0Z:SOfEm0_:nNaER1_:nNaER1[:lNmD3h0Q1[:ROeEn0[:ROeEn0[:ROeEn0[:ROeEn0[:SOdEn0\\:QOdEo0[:ROeEn0[:ROeEn0\\:QOdEo0\\:QOdEo0\\:QOdEo0[:ROeEn0[:ROeEn0[:ROeEo0Z:QOfEn0[:ROeEn0[:ROeEo0Z:QOfEn0[:ROeEo0Z:QOgEn0X:SOhEm0Y:SOfEm0Z:SOfEm0Z:SOfEm0Z:SOfEm0Z:SOfEm0Z:SOfEm0Z:SOfEm0Z:SOfEm0Z:SOfEn0Y:ROgEm0[:ROeEo0Y:ROhEm0X:SOhEm0X:SOhEm0X:SOhEm0X:SOhEm0X:SOhEm0W:UOhEk0X:mNPE4h0o0\\:QOdEo0\\:mNlDN00i0T1[:lNkEU1T:kNlEU1U;O11O0000000001O0000000001O000001O0000000LmCPOSi<111O000O1O1000O1O11N101OM30O2N101O00O1O0MZCAhg2l8oMUGS2k8lMVGS2j8mMVGS2i8nMWGR2i8mMXGS2i8kMXGU2g8lMYGT2g8lMXGU2i8jMVGW2j8iMWGW2h8hMYGX2g8hMZGW2f8iMWGZ2h8gMXGY2h8fMZGY2g8eMZG[2f8eM[GZ2e8fM[G[2d8eM[G\\2e8dMZG]2g8aMVGBAo2Y9_MVGBBn2X9`MUGd2k8\\MTGf2j8[MVGe2j8[MVGe2j8[MUGf2k8ZMWGd2i8[MWGg2h8ZMWGf2i8YMXGg2h8YMXGg2h8ZMVGg2j8YMVGh2h8XMYGh2h8WMXGi2h8WMXGi2h8WMXGi2h8WMYGi2e8XM^Ge2b8[M]Gf2c8ZMZGi2g8VMZGBBU3T9YM\\Gg2d8YM[Gi2d8WM]GC@R3S9[M]GBAS3R9[M`Ge2`8[MaGB\\OP3S9^MaGB^On2Q9`MdGa2\\8_MdGa2[8`MfG_2Z8aMfG_2Z8aMgG_2X8aMhGa2U8`MlGa2Q8`MnGc2Q8\\MPHf2m7ZMSHh2j7YMVHk2f7UMYHo2d7QM^Hh0VOm0W8\\NcHd0YOT1Q8WNfHc0]OlNH[2P8VNjHf0@V1b7TNoHc0AX1`7VNoHb0ES1]7ZNPIa0DU1\\7ZNQIa0BV1\\7YNQI`0EV1\\7YNoHa0EU1]7ZNoH`0DW1\\7YNQI`0BX1[7YNSI=DZ1Y7YNSI=DX1[7[NRI9E_1W7XNSI:F^1W7XNRI;E]1[7XNoH;G]1Y7YNPI=EY1\\7VNRHBl0P1B^1_7PNRIa0QOWO7W2f7RNPIi0YOb1[7eMZIk0VOf1_7_M]Il3c6UL\\Il3c6TL]Il3c6TL]Il3c6TL\\Im3d6SL[In3e6RL[In3e6RL[Io3d6RL^Ik3a6VL^Ik3c6TL\\Im3d6SL\\I\\3VObL^72]I[3VObL]73^IX3VOYLO9\\76]I[3XOTL27[7:ZI\\3W7cLhH\\3[7dLfH]3X7cLhH\\3Y7dLgH[3Z7eLeHZ3]7fLcH]3XOTLo7>iHb3W7^LiHAXOn3:RLZ7?VI_3^OTL\\7=XI^3[OXLZ79_I[3XO]LX78`IZ3XO`LW76bI\\3SO^L\\75bI^3QO]L]75bI^3PO^L^74`I]3TObLMDZ7=eIR4[6nKdIU4Z6jKgIV4X6kKiIS4X6mKgIT4Y6lKfIV4Y6jKiIU4V6kKiIW4V6iKiIV4Z6iKgIU4Y6lKgIT4Y6lKfIV4Y6jKhIT4f3", "size": [427, 640]}, "area": 60830.0, "iscrowd": 0, "image_id": 10343, "bbox": [0.0, 81.0, 640.0, 198.0], "category_id": 169, "id": 10012662}, {"segmentation": {"counts": "inl04o<8G9L5O000000000001O000000000000000000000000000000001O0001O0000000000000000000000000001O00000000000001O000000000000000010O0000000000000001O00000000000000010O00000000000000001O00000000000001O01O00000000000000001O00000000000001O0001O00000000000000001O0000000001O000001O000000000000000010O00000000000000010O0000000000000010O00000000000000010O00000000000000010O00000000000000010O00000000000000010O00000000000000010O0000000000000001O01O000000000001O0001O000000000001O0001O000000000001O0001O000000000001O0001O000000000001O0001O000000000001O0001O000000000001O0001O000000000001O0001O0000000001O000001O0000000001O00000001O00000001O01O0000001O0000010O0000001O00000010O000001O0000001O01O0001O0000001O0001O01O0000001O0001O01O0000001O0000010O0000001O00000010O000001O00000010O000001O0000001O01O0001O0000000010O000001O0000001O01O0001O0000001O0001O01O0000001O0001O01O0000001O0000010O00000000000010O00000000000000010O000000000000010O00000000001O0001O0001O000000001O01O000001O00000000010O00000000000001O0001O2N3M2N2N3L5H8I6J7InXk0", "size": [427, 640]}, "area": 16099.0, "iscrowd": 0, "image_id": 10343, "bbox": [69.0, 173.0, 505.0, 94.0], "category_id": 183, "id": 10012663}, {"segmentation": {"counts": "ojn31=0U<0dD1mNO61L17OU<2cD2oNK2101N0O00Oa`>G7Mlnc0NRQ\\O1ZA002d>;I212N2N2M2O001ML6M20N_OhA?T>@lAf0P>[OoA00g0i==00001OO1000O2O000N1110O0N3O10OO1001O2NNmNWBS1i=2mDlNbM;R:i0WGkN`N0g0?YONY:h0iFkNSO1K92M2k0S:4hFoNPO?1D3j04nNf9W1oF2VOI0oNMO0000l9W1RGmNROn022NSO0Im9U1XGNkN=l9GXGLlN=l9GXG^1g8cNYG]1g8cNYG]1g8cNYG]1g8bNZG^1f8cNYG]1g8aNYGa1g8`NZG^1f8cNZG\\1h8bNXGkNkNS20WNn9k0WGjNkNT20WNP:h0XGP1iNYNo90nGg1WNUNl9IWHR2mMTNn9IUHR2nMoM^1n>100O100O100O1N21O0000O100O10000O10000O100O10000O10000O100O1000000O10000O1O1000000O10000O10000O10000O100O100O10000O1O100O100O10000O100O10000O100O10000O1000000O100O100O100O100O100O100O10000O1O100O100O100O10000O100O1O10000O1000000O1O10000O100O10000O100O1O100O100O100O1O1O100O10000O1O100O10000O10000O100O100O1O10000O100O1O1O100O100O100O1O100O100O100O100O1001O1O2N2N2EZCTN1Nge0PB[OU>e0kB]OoNN32hf400O010O010O10O100O2OO1O1N1010O1000O0100XFDXK1_98YK0f4L\\K6c4E_K?Y9_OnAd0P>^OoAc0Q>6O100001O00O1000000O10000O100O1002NO100000000O1001O000000001ON2O11O@QOaB0O2N1N2O1O2M2O1O1N3N1O1N2O2N1N2O1O2M2O1O1N3N1O1N2O2N1N2O1O2M2O1O1N3N1O1N2O2N1N2O1O2M2O1O1N3N1O1N2O2N1NkkX1", "size": [480, 640]}, "area": 24534.0, "iscrowd": 0, "image_id": 10346, "bbox": [31.0, 302.0, 521.0, 178.0], "category_id": 101, "id": 10012665}, {"segmentation": {"counts": "ecP71n>2DNgA4X>LdA9l0I[9CG=8DH>5CK=3EM?NB292HM83WO`JVO\\5d13SOfJXOW5e14QOgJYOT5c1[J[Nk5g0hJZOR5a1=UO:l0GTO8k0JTO5l0LTO2n0OQO2n0ORO0n00RO0n01QONP13oNMQ13oNLQ16mNKT15jNLV1bJZNf4>h0Y1bJYNh41>OO1[eX5", "size": [480, 640]}, "area": 72027.0, "iscrowd": 0, "image_id": 10346, "bbox": [0.0, 46.0, 280.0, 434.0], "category_id": 123, "id": 10012668}, {"segmentation": {"counts": "Wlh5621k=JZBk0b;VOcEOmN_1\\:aN]F1oN0o0Q2b9SN_EK04g0MYOO>1B`20aMS:0oE`0N^Ob00_O2O20h20VMR:i0WFVOHa3Q:Z11G2N5K7H8I8N3O000000000000O10000N2001O001O1O00000001O0000kNnDbM;4g:U1mD`N0g0?YON;f:g0mDSO1K92M2k06Q:e0REPO?1D3j04nNIT;l0UFVOI0oNMO000U;n0SFTOLNSO0m:c0aF]OP;=UECk:=l100O10O11ON3PBD[=VORBg0U>N1O101OO^OfA`0^>M2O2D^A7c>I]A3h>LXA100``Y2", "size": [480, 640]}, "area": 6035.0, "iscrowd": 0, "image_id": 10346, "bbox": [394.0, 51.0, 90.0, 169.0], "category_id": 156, "id": 10012669}, {"segmentation": {"counts": "^[R32m>2O2M3M3ZCETN1Y<<\\EFXN5Y<8VE@fN=T<4lD_OkN70I2>V<7jD8U;GlD:T;FlD:S;GmD9S;FnD:Q;HnD8R;HmD9R;HnD8R;HnD8Q;SOmCb0Q10O1O1O1O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_KLVJ4k5KUJ5k5KUJ5k5KUJ5[:000000000000000_KKWJ5f4o0YKQOc3g3iJYLP5^4`JbK", "size": [480, 640]}, "area": 1184.0, "iscrowd": 0, "image_id": 10346, "bbox": [493.0, 251.0, 147.0, 229.0], "category_id": 167, "id": 10012671}, {"segmentation": {"counts": "0U2k<00M34L3WChMdm0KLVBXOd=i0XB\\Of=e0ZBZOf=g0YBXOh=i0WBVOj=P10001O0000N22NM30000002hBlN`1B`20e5V1`HkN\\O1`0N^Ob00_O2O20h20Z5U1^ITO]NHe;T1S200N200O1MUBROj=i0UBWOQ>e0PBZO00Q>?=00001OO100001O0000O11O00N2001OO1001O2NNcAA]>?20000O100001OO100O1000000000000002N1O2N1O1O1O1O00000000O100M3O10000O10000O1O11`AA]>b0cA^OZ>f0N0hAZOV>i0O1O001O0000000000000cFUOe4l0lGVOS2NQ6l0kGWOS2NR6l0fG[OW2IS6l0bGSOSO:X3GS6l0fFSO70M120nA0P>5lALS>7kAKm8OXGOD059h31SLE34o7R1oGkNO00h0j3FVLA06a7a1_HYOh3Ji3P2iK_NfLlNX7T3aJZO^5i0lIJT6a4iHZHT7j7OO1O1L4M3N2N2N2N2N2N2N2N2N2N200E;]Oc0ZOTGfJ^9d4`F\\KX:P4f0F:J6O1TNbD]NO61X1^;ZO_E_OROS1c;fNTF0ZN30N14NK093GM0nbl3", "size": [480, 640]}, "area": 6255.0, "iscrowd": 0, "image_id": 10346, "bbox": [337.0, 0.0, 38.0, 252.0], "category_id": 173, "id": 10012673}, {"segmentation": {"counts": "ZV1Q1o=0O100O100O100OMVBROj=n0XBPOg=Q140O100O10O0100O100O1O1O1N2O1O1O1N2O1OFeBQOZ=e0RCZOm[;j5[DkI7=];h5ZDnI2`0d;c5TDSJ5L>9Q2T=TMeBf0?FEGHK0027>f2P=SMeBg0?EHFDN55=g2U=kMoB\\OZO1h0OL>Ca1`=eNVCZOL2L;Ec1]=eNTD\\OjN:Hd1[=eNSD[OmN:Gg1W=dNoDDlMh1U=cNPECmMi1S=dNlE]1S:bNoE]1Q:XN]BOc3i1P:VN]B2d3g1o9XN]B0d3h1P:TNZB004g3g1o9SNbFk1k=1OO1O1O11NO2O1O1O1O100O001O100O010Of]O]NXb0e111OO10O010OO2O001O1O1O00100O100N1O2M3N2M3N10100O01000O01000O0100000O01000O10O101ON20O01O1O010O10O0100N101O1O1N101O1O1N14MN2O010000O01J6O1N110000O10O1N101O00100O012M3Mf_]5", "size": [640, 478]}, "area": 24873.0, "iscrowd": 0, "image_id": 10358, "bbox": [0.0, 0.0, 200.0, 274.0], "category_id": 96, "id": 10012675}, {"segmentation": {"counts": "kmc21oc00O1O1O2FLf\\O3[c0Nd\\O2\\c0O_\\ON04`c0:OO11N1001OO100O2O01OO12M;E4MTW60lhI1S\\O0;Olb01h\\O43L30ob02k\\O222NNQc06P]O7mb0IR]O9lb0>1O1OO100O1100N2O01M11O3ZOP]OI1MO008Pc01f0O1I]\\4OhcK0T\\O0kc0301N3II`\\O8\\c0Hd\\O?Yc0Ae\\Ob0Zc021N10001O0O2O00001N8IVPS1OmolN8I7F8G2O0000000N3O001O001O0N03M2L4N3N101N200O100N1O100O2OO111O0OO2M2Ca\\O8ac0H^\\OO06fc0JZ\\O4jc0M_i3OdVL2M2\\ONX]O5fb0MZ]O2fb00W]O1ib01R]O3kb03R]OKnb06Q]OLPc02P]ONnb0c001O00001O2N0000000000002OO1O02OO000010O0001O0O11O00XOX]O7ib0IY]O6fb0I\\]OJH6kb02c]ON\\b02c]OOZb04e]ONYb02n]OIPb08P^OJla08S^OJla07Q^OKAC]b0a0S^OJAGZb0?U^ONla02S^OOma01S^O0ma0OR^O2ma0OS^O1ma0OS^O4ja0LV^O3la0LQ^O:ma0ER^O^3o@cLQ?]3m@cLU?^3f04Lk_O=L?:iNn?;P@7Kf0OmNW`06S@2KX1Q`0fNT@11T1k?kNT@14Q1h?mNU@23Q1h?mNU@24Q1f?mNW@12T1f?kNX@03U1e?kNX@03T1f?lNW@NACb0e1d?jNY@M6U1\\O_NV`0?X@M6R1h?QOS@N3T1g?nNV@N3T1g?nNV@N2T1i?nNU@N2T1i?kNe_OE`077Y1d?jNZAj0R?UOQAh0Ua000N11O000O100000000O2OO11OO01001N2N2N111N1OO10000O101O0O100000N101O1O002O1El\\OHTc08m\\OHUc0Jk\\O520Sc0Kl\\O430Qc0JQ]O1M7`c0200012M00O2N110OF_\\O5gc0M5M00]\\>0go@0hc05O0O101KI]\\O9`c0Ga\\O;^c0Ga\\O8ac0F`\\O:`c04OON3O10Mc\\OB^c0>2C`\\O9bc0F^\\O:fc0M10Y\\OIec09O013K1002OO1kL", "size": [640, 478]}, "area": 25615.0, "iscrowd": 0, "image_id": 10358, "bbox": [150.0, 0.0, 328.0, 137.0], "category_id": 106, "id": 10012678}, {"segmentation": {"counts": "X6R1c0Q;e5PEYJQ;g5nD\\JP;d5REYJo:g5REXJn:h5SEVJn:j5SEVJl:k5SEUJm:k5SEVJl:j5TEUJm:k5REWJm:i5\\DhI8?\\;i5\\DhI8?\\;i5\\DhI8`0[;i5\\DhI9>[;j5[DkI7=];h5ZDnI2`0d;c5TDSJ5e0S;j3`DaKf0Q;j3aD`K?e0P;m3_D^Ka0f0o:j3aDbK`0d0n:j3bDaKb0d0l:m3`D`Kc0d0l:l3`DaKe0c0j:l3aDaKf0b0i:k3dDbKc0d0h:i3eDdKd0c0f:i3fDdKe0c0d:i3fDfKf0`0d:j3fDfKf0a0c:j3gDdKg0b0a:j3gDeKi0`0`:g3mDfKe0c0]:g3XE[K`1B`Nb6m:aISEN1b0]1^OdN`6j:dIUE?a1o5Y9YJgFg5Y9YJhFe5X9]JgFc5Y9\\JhFc5Y9]JjFa5U9_JjFb5U9`JmF\\5T9eJkF\\5T9dJWEQOa1[6W9fJWEPOa1Z6X9kJhFT5Y9kJhFT5Y9kJgFU5Y9kJgFU5Y9jJhFV5W9kJiFU5W9kJiFW5U9kJjFT5V9jJlFU5V9iJkFW5T9jJlFV5T9jJkFW5U9hJkFX5W9gJhFZ5X9gJeF[5Z9fJeF[5[9dJeF\\5\\9dJdF]5[9dJbF^5^9cJcF[5]9eJcF[5]9eJbF\\5^9dJbF\\5^9dJbF\\5^9eJaF[5_9eJbFZ5]9gJdFX5]9gJcFY5]9gJdFX5[9iJdFW5^9gJcFY5]9hJcFW5]9hJdFX5]9gJcFT5dNhIk:R1bFU5bNjIl:R1`FU5f9kJYFU5h9jJWFW5i9iJkDoNX1Y6m9kJWFQ5i9oJUFS5k9mJUFS5k9mJTFU5k9jJVFV5j9jJVFV5j9jJVFV5j9jJUFW5k9jJTFV5l9jJSFXOkN]5T;ZKSFoNhNNOO5j5P;ZKdFf4\\9[KeFc4XNXJo:V1hFlNZN_5N`JQ;T1oF[4PN`JS;U1lFkNPN^50eJT;Q1nFa4P9^KPGb4P9_KoF`4R9`KmF`4QN\\JP;T1PGb4P9_KoFa4Q9_KoFb4P9^KQG`4P9`KPG`4o8aKPG`4P9`KQG_4k8\\JTEV1R2]4i8gKWGY4i8hKVGX4j8hKWGW4i8iKXGV4h8kKWGT4j8lKXGR4h8oKWGm3nMfJk:]1UGo3o8QLTGm3k8SLUGo3i8QLWGo3i8QLWGo3i8QLTGQ4m8PLTGm3m8SLRGm3o8SLRGl3n8TLRGl3n8TLSGk3m8ULSGk3m8ULUGcNlMQ5o:\\LTGeNmMn4o:^LSGbNTNl4i:bLUGaNQNl4k:cL^G\\3b8cL^G]3c8eLZG\\3f8cL\\G\\3d8dL]GZ3d8gL\\GX3d8hL]GV3d8iL\\GW3e8jLZGW3e8jL[GT3f8lLZGT3f8lLYGU3g8kLZGT3f8lL[GS3Y3", "size": [640, 478]}, "area": 149846.0, "iscrowd": 0, "image_id": 10358, "bbox": [0.0, 135.0, 478.0, 505.0], "category_id": 124, "id": 10012679}, {"segmentation": {"counts": "bho22nc01O4MO0O1000000000000000O1000NR`c3MR`\\L5P]OLla08n]OKQb09j]OKSb05l]O1oa0OQ^O4ka0MU^O3ka0MU^O4ja0MU^O2la0NS^O3ma0MS^O3ma0MQ^OACb0\\b0MP^O6Pb0JP^O6Pb0KQ^O3oa0MQ^O3oa0MQ^O2Pb0NP^O2Pb0Nk]O7Tb0k0110OO1N1O11O0O100000000O1@d]O\\O\\b0d0d]O\\O\\b0b0f]O^OZb0Og]ON22[b0Ke]O23HI4_b0J`]O5643IG3db0K^]O0682HH0N1hb00`]O6_c0L5OO1lbb1", "size": [640, 478]}, "area": 1614.0, "iscrowd": 0, "image_id": 10358, "bbox": [153.0, 15.0, 244.0, 138.0], "category_id": 132, "id": 10012680}, {"segmentation": {"counts": "glc21kc06L2M3O4M01O02OM2011N0001M2O10001O011N1KUT8NmkG5O1OO010O02O1OO100O11N2O1O00N2002N0EER]O;hb0JX]O7GIeb03e]O9[b0Ie]O9Yb0Gg]O9Xb0Hi]O7Xb0Hh]O8Wb0Ij]O6Wb0Ii]O7Vb0Jk]O4Vb0Lj]O2BCdb0;j]O1Yb0Oh]O0Xb00h]OOZb00g]OJ@Njb08f]OF@2nb08d]OF^b0:d01l\\OEab0;c0OO110O00001O00001O000O100000000001OO1001O001OO1002N001O0001O00O1N2N2N2Nn`<0R_C3N2O1N2O0ON]\\OHcc083M2O20O1W\\OOac08O2O1N4L2O101M1M5M3O1O0W]OoNcb0X1IhNd]OX1[b0iNe]OW1[b0kNc]OV1\\b0jNb]OX1^b0gNc]OZ1Zb08N2OZNi]Od1Yb01N11O00104J3O1bN^]O[1gb0LN3O0]]OgN`b0Y1`]OfNO0^b0^1b]ObN]b0a101O000O100000O11O1N10Gh]OhNXb0W18G_]OQOfb0n0\\]OoNN0gb0R1Z]OnNgb0R16N1N11IQOY]OQ1gb0oNY]OQ1gb0310000]OV]O0jb0M[]O1eb0N_]OOab01_]OOcb0O_]OOdb0N_]OMBKQc04b]ONoRb0NT`^O802M2M3O001d\\O@M0Wc0a0j\\O@OO41L0kb0k0U]OYOlb0m0O0LoNY]OS1gb030001OO2O1O3kNT]OQ1mb001VOR]OI2b0lb0@R]ON9a0fb0@]]O?Sc0O00000000000000O011O00O11O00Hb\\ON^c01d\\OIN3_c03f\\OLZc04h\\OJYc01k\\OOcc00jRY1", "size": [640, 478]}, "area": 4930.0, "iscrowd": 0, "image_id": 10358, "bbox": [134.0, 118.0, 278.0, 68.0], "category_id": 142, "id": 10012681}, {"segmentation": {"counts": "cU[22ac0O`\\O60N`c0;O001a\\OA[c0c0O00001N10O20O02M2O2N2M2N2N2O1O1KW\\O0iY=5iYC2000000O100O1IaJiAc5U>53M1O001O1O00O100O11O00O11O00000000000000002N00O1000000O1000000O11O0000000000000000000000O1000000K_JkAa5U>^JlAb5T>50000000000001O0000000000O11O000ZJjAb5V>]JkAc5U>]JjAd5V>[JmAc5[>M00O1O`JdA^5_>0001OO10000000000000000O100LaJgA_5Y>41O2N0000O1O1O100000000000000O100O10000O100O1O11OO100000000", "size": [640, 478]}, "area": 46583.0, "iscrowd": 0, "image_id": 10358, "bbox": [120.0, 165.0, 358.0, 475.0], "category_id": 150, "id": 10012682}, {"segmentation": {"counts": "UYa24kc011NO3N2OOZ\\OLOO_c06b\\OKO2[c0=2O01O101N1O11O00001O1O000O2K6J5K[Va3Oii^L4L4K4M3M1O011O0000001O00O10000010OO1M3N4HgTb0Mbk]O1O1D4`\\OM]c0<01O5K110OL41O3MN21O010OJg\\ODZc0;g\\OEYc0:72L01002N1O1000N30O01N11OLc\\OD^c0;5N11OO2O001MY\\OKgc02Y\\ONkc013OhTo0", "size": [640, 478]}, "area": 1296.0, "iscrowd": 0, "image_id": 10358, "bbox": [130.0, 28.0, 298.0, 97.0], "category_id": 157, "id": 10012683}, {"segmentation": {"counts": "nXX5111jc05K7J4N3M\\Oj\\O>[c0010002N000N3OO11O1O1O0MTle0LQTZO2T\\ONkc01U\\O0ic0401N201N00O01000002NO1002OO1L\\\\OIfc062K[\\OOfc00je54WZJ2M2\\\\OH^c0>OO1O07J00O2M21O00O100O1000000M3O1O1J\\\\OOgc0Oj\\m02RPROO_b03W]OLGOO5Qc02P]OH5K4L3M4L2N1OO100000V]OoNeb0P1[]OSOcb0n0\\]OROm2OdL>9^>g0g@ROf0?FEGHK0027>R?d0g@QOg0?EHFDN55=S?i0_A[O\\OZO1h0OLU?g0_ABZOL2LT?f0_A`0\\OjNU?g0^A?[OmNV?d0_AY1a>hN^AY1a>gN_AT1f>lNYAU1g>kNn@eNO_2T?mNk@dN2_2S?mNl@dN0]2IaM[?_1h@aN004^2JbMZ?_1f@_1]?b10H8N200:F1O00000000O13M9G001OO1N2O1O1Ol@ZKP?P5K1O2N1O00000000000000O1PLYAb11YNf>4ZAa14ZNa>6YA`18WNa>7ZA`17XN_>7\\A`16kMCNl>g0ZAPOLOOY2>nMG0g>i0ZAQOKO2V2;oMI2e>h0dAY1OiMK1g>m0^AY1e?fN\\@Z1d?eN]@[1c?eN^@Z1b?eN_@[1a?dN`@\\1`?eN_@[1a?eN_@[1a?eN_@[1a?fN^@Z1b?gN]@Y1c?gN]@Y1c?gN]@Y1c?hN]@W1c?kN\\@T1d?mN\\@POId1k?]Oh@d0X?\\Oh@d0X?\\Oh@d0X?]Og@d0X?]Oi@a0W?_Oi@a0W?^Ok@a0U?^Om@a0S?_Om@a0S?_Om@a0S?_Om@a0S?_Om@b0R?^Oo@[OnNH0f0S`08n@YOROGNh0Q`08QAmNmN66IJ0111f0P`0;SAnNA0\\Og0P`0JU@Fo0I@0\\Oh0o?IY@Bj1d0m=ZOo_O0000O159Lk1h0Z>XOm_OOi1i0Qa00O1O001O1O2N1OO100AQ]OMTc0Dl\\O08;lb0El\\O08;ob0EQ]O;ob0EQ]O:[c0K5MgPj2N[oUM5^OKT]O9fb0Gn\\O0<9eb0Ho\\O1:9OE10ka02j]O488MBK17OI52K?1i`0;j^O7NA44JJ`00h`0\\1i^OeNO::DH1Wa0\\1g^OUO6]OJ9Xa0l1j^OXNVa0Y2010O00O2O000001OO1001\\Oj^OZNWa0f1m^OWNTa0h1n^OSNUa0j1P_OSNQa0m1n^OSNSa0_1c^OhN^OPDc0WMNh>AdCk0gMBe>EbCj0iMAZ>2lC9lC=mMSO@OO41Lh>`0mC;VNUOQ>?jC=S=DlB;U=EkB6[MZOl?`0iB6Z=JfB6Z=JfB6Z=JfB6Z=JgB6X=JSA@`0>^NJn?8TA@a0=^NMOFi?`0WABb0<`NMg?5d@CN2W1NdNNM<4CI2[?a0m@B23HIi1T2_BmNiNQOINl>T2cBmNgNTOe>o1dBmNgNVOc>l1gBoNaNYOh>i1fB\\OZ=e0gAkM:d1m=a0iAlM:b1m=e0[AiM52b0`1n=e0[AjM43`0_1Q>e0YAnM1Mh0_1n=T1PBZMYOc1g>S1oAQOQ>o0nAROR>Q1lAnNT>R1kAnNV>Q1kAoNU>P1lAmNW>T1fAWM_Oa10bNj>f2WAYM8NGc11]Nl>o2VASMN^1T?b1k@QM0]1U?b1k@cNU?V3N001O0000O1001O00001O00N2O1O100Nk@YKU?g42001O000000gNj@cL0Q1V?\\2o@dMP?\\2PAdMP?[2QAeMo>[2RAeMm>W2l@fL9S1k>T2l@jL;S1h>R2o@jL8U1i>R2m@jL:S1j>S2ZAlMf>T2YAlMh>Q2[AmMg>R2ZAnMf>R2WAmLBQ1X?R2VAoMk>Q2h@mL9R1P?R2f@lL:R1P?V2m@jMT?V2l@hLIQ1Z?W2o@hMR?W2n@jMR?V2QAhMn>V2SAlMl>S2TAnMl>S2SAmMm>R2TAnMl>", "size": [640, 478]}, "area": 27133.0, "iscrowd": 0, "image_id": 10358, "bbox": [0.0, 0.0, 478.0, 206.0], "category_id": 169, "id": 10012685}, {"segmentation": {"counts": "P\\a25ic04M2N2O1N101O1N101O001O001O001O00001O0000001O00000001O00000001O00O101O001O000O2O001O0O2N2O001O2N2N00O100000000000001O001O00001O001O001O00001O001O0010O00XBBn7?nGDR8];\\OZC4a1SO[T5MQK_6NcIR5KSKb6KVIM300W52TKd63WIl40UKf6P6O110N11O1O01M1100H_IhIb6Y6420000DdIkI_6l5`IQJk6i5UISJ42h6k5[ITJg6k5YITJh6j5;1000O11OO11O0DUJZIk5f6VJZIk5e6[JVIe5h61WITJN4i6f5\\IUJNOi6l5ZIUJj6l5VITJj6l5VITJj6l5QISJ20n6P6QIQJP7m5QIRJP7n551O00QJoHh5X710^JdHV5]7iJeHT5\\7kJjHn4Y7PKjHMDm4X8SKgGj4]8N2M2O11OO11N10O02O0O3N0O10O1O01O001O001O2N100O2N10000O1O1fJRKZ2n4aM[KZ2f4aMcK[2]4`MlK[2k3]KUK01T2X1[2b3aKTK10o1d1Z2X3gKTK00j1m1Z2o2nMTMo1l2QNUMo1j2QNXMm1j2QNXMn1h2QNZMm1h2QNYMo1g2QNZMm1\\2TLdKn1R2l1Z2XLcKk1T2k1Y2^LaKf1X2j1X2aL^Ke1\\2h1V2fL[Kb1a2f1U2iLYK`1c2g1S2fNoMW1P2kNRNT1n1kNSNT1o1kNRNT1n1kNTNS1m1lNUNR1m1lNTNS1m1lNUNR1l1mNVNR1k1lNVNS1l1kNVNT1j1lNYNQ1g1nN]Nm0f1RO]Nj0d1VO`Ne0b1ZOaNb0`1^OcN>^1BeN:\\1EiN6X1JkN3W1KkN2V1NkN1V1NjN1W1NkN0W1OjN0V10jNOX10iNNX12hNNX12iNLX13iNMX12iNLX14hNKY15hNIY17gNHZ18gNF[18fNG[19fNE\\1:dNF\\1:eND\\1l8;dGYO_O;o8;`G^O_OC5Lm8S1]GA_OB9Fl8W1ZGE_O^Og9o0hFF_O[Oi9o0fF6Z9IeF9[9FfF8\\9HdF8\\9GeF9[9EhF:X9GgF9Y9HfF8Z9GgF9Y9GgF9e4", "size": [424, 640]}, "area": 108444.0, "iscrowd": 0, "image_id": 10369, "bbox": [0.0, 81.0, 640.0, 343.0], "category_id": 101, "id": 10012687}, {"segmentation": {"counts": "0[7m51O001O00001O001O001O000000000000IZJiHi5U7VJjHn5V720000[KTJm1m5SNXJh1h5WN_Jc1a5]NdJ]1]5cNdJ\\1\\5dNeJ[1[5dNfJ[1[5eNfJX1\\5hNeJV1\\5jN\\JaMDc3R6kNXJeMG^3R6mNSJjMJY3S6mNPJmMNU3R6nNlIRN2Q3P6lNnIUN1P3P6kNnIVN3m2P6mNmIWN3k2P6nNlIXN4k2o5lNnIZN3j2n5lNnI[N5i2l5lNoI\\N4h2m5kNoI^N5g2k5kNoI`N5e2l5kNoIaN5d2k5kNoIbN7b2j5kNPJdN5b2j5jNPJeN7`2i5jNQJgN6`2g5iNRJhN7`2f5gNSJkN7]2f5hNSJkN8\\2e5iNRJmN8[2e5gNTJoN7Z2d50\\J1c5eNUJSO8W2c51^JNb5fNUJVO8U2b52_JN`53`JL`54`JLGbL5OZ5d3jJNJ`LMN\\5e3mJiLHk2[5mMAS2?mM@T2`0SMZLlN84m2m3`0TMZLoNe3n31]MNd21\\M0d20\\MOe21[MOe20\\MOe21ZM0f20[M0d2O\\M2d2N\\M3c2M]M3c2L^MbL\\N[3V43]MaL_N]3S41_M_LaN`3P41_M_LbN_3o32iMMW22jMOU21kMNV22jM_LRN[3U45lMLT24lMLT24kMMU22lMNT22kMOU20lM0T20kM0V20jM0V2OjM2V2NjM2V2NiM5U2KkM4V22jKbLb1]3d2h0lLROZ3n0fLQO[3o0dLQO]3o0cLPO^3P1aLoNa3Q1_LoNa3Q1^LPOb3P1^LoNc3Q1\\LPOd3P1\\LPOd3P1[LPOf3P1ZLPOf3P1YLQOg3o0YLQOg3o0XLROh3n0XLQOi3o0YLmNi3S1YLjNh3U1[L^NPO_Mf4S4[L]NPO^Mf4U4[L[NPO^Mg4W4ZLZNoN]Mi4Y4XLYNo3g1RLXNn3h1SLVNn3j1RLVNn3j1RLUNo3k1PLhKkNZ2U5n1ULjKgNP2T5V2VLiKgNP2S5W2WLhKgNo1S5Y2^LfMb3Z2_L\\MZN]N01W5V4_LYMm3g2SLhKZN^1c5j2TLgKYN_1c5j2VLUMk3k2PLgK_N^1a5k2PLhK]N^1c5j2QLhK[N^1d5j2QLZMn3f2SLYMm3g2TLXMl3g2ULYMk3g2ULXMl3h2TLXMl3h2ULWMk3i2ULWMk3i2ULVMl3j2RLWMo3i2PLVMR4j2nKlK\\NR1f5R3nKkK^NR1d5S3XLjKRNm0e5Y3`LgL_3Y3bLiL[3W3gLfLZ3Z3gLeLY3[3gLdLZ3\\3eLeL[3[3eLdL\\3\\3cLeL]3[3cLeL]3[3cLeL]3[3bLfL^3Z3bLfL^3Z3aLgL_3Y3`LhL`3X3kL]LU3b3aMiK_2W4Y3000000000000000000000000000000000000YOTGRMl8n2]GiLc8X3eG_L[8a3f0001O0000001O00001O00001O0000001O00001O0000001O00001O001O1O2N1O2N1O2N1O2N1O2N1O2N1O1O000000O100O10000O10000O10\\GfKZ8Y4gGgKY8Y4gGgKY8Y4fGhKZ8W4gGhKZ8X4fGhKZ8X4eGhK\\8W4eGiK[8W4dGjK\\8V4dGjK\\8U4eGkK[8U4dGkK]8T4dGlK\\8T4dGmK[8S4dGmK]8R4dGnK\\8R4dGoK[8Q4dGoK]8P4dGPL\\8P4dGPL\\8o3dGQL]8o3cGPL^8P4aGQL_8n3bGRL^8n3bGQL_8o3`GRL`8m3aGSL_8m3aGSLa70oHl3@ULa72WHJb0o3FULa75iHf3HSL^7:hHb3LSL[7>gH_3NRL\\7a0dH]3k7eLSHZ3n7iLnGX3Q8lLkGU3U8n001OgNiGbMW8_2jG`MV8`2kG_MU8a2lG]MU8c2lG\\MT8d2mG[MR8f2nGYMS8g2nGXMR8h2oGVM3TOa7g3]HTM1VOb7f3^HSM0WOa7g3`HPMOYOa7g3aHPMNYO`7h3cHnLMYO`7j3dHkLL\\O_7j3fHiLK]O^7k3mHaLFC]7m3SIZL_OJ]7m3ZISLYO0\\7n3hIQLX6P4gIQLX6P4hIoKV5ObI0M2d0Q4g0nKT54`IL02a0N@R4l7[LeHi3[7WLeHi3\\7VLdHj3]7TLdHl3]7TLbHl3^7SLcHm3^7RLaHo3_7PLeHm3[7SLeHm3\\7SLcHm3]7WL_Hi3a7ULbHj3^7TLbHn3^7RLaHn3b7PLXHKEV4T8nKUHMFW4V8lKSHMHV4V8lKQHOHV4W8lKPHOHU4Y8kKkGML_4Y8fKhG^4Y88001O0000001O0000O13M1O1O001O0000001N10000N2N100O1OYHhK`6Y4_I]Lm5a3SJaLl5^3TJeLk5Z3UJgLk5W3UJjLk5U3UJmLl5m2WJUMh5d2^J^Mb5Z2dJhM]5n1jJTNV5d1PK^No4e1nJ\\NR5h1hJZN`N_N42V6;gI]2X1mNeNYN15OKZ6;lIc2n0WOV5SNoIk2d0SO_5oMPJQ3;ROg5hMRJZ30QO_6T1ZInNf6V1UIjNm6g3100`KTIe2k6[MVIe2j6ZMVIe2j6\\MVIfNJ`3Q7jMUIeNLa3f6YLYIb15dNMa3e6QN_I[NNd3c6QN_IZN0d3a6RN`IXN1f3^6RNbIVN1g3`6QN_IWN3`3CeLk6d1oI`1VOhL42h6f1nI`1]OiLg6f1mI`1\\OiLh6g1mI]1^6dNbI\\1^6dNbI\\1^6dNcIZ1^6fNbI[1]6eNdIY1]6gNcIZ1\\6fNeIY1o5oLZIi1h0V1n5RMZIh1h0W1m5WMVIa1n0X1j5VOWJ^NVO\\9]H5\\N[OY9?ZH6`NXOW9b0YH6aNWOW9b0XHCVNM0;P:5jGBWNM09T:6eGB]N8n96eGA\\NOJ;T:5oGMR82nGNQ83oGNP82PHNP82PHNP82PHOo71QH0n70RH0n70RHOo71RHMo73RHJo77RHGn7:SHDm7=TH@n7`0SH]Oo7c0[2000O11OO100000000O11O001E]CG00i<0YC1[SV1", "size": [424, 640]}, "area": 89131.0, "iscrowd": 0, "image_id": 10369, "bbox": [0.0, 0.0, 548.0, 424.0], "category_id": 105, "id": 10012688}, {"segmentation": {"counts": "[j`52U=2O1M2O2N2N1O2N2O00100O000010O01N101CFjC;U<<01O1O1O1O1O1O001O1O0SDhNj;[100000O100O10000O1O1O1O1O100O1O100001O001O1fNlN^FT1a9oN]FR1a9PO^FP1a9QO_FP1_9QOaFP1]9QOcFo0\\9SOcFn0[9SOeFn0Y9SOgFm0Y9SOgFn0W9SOiFn0U9SOkFm0U9SOkFn0T9SOkFm0T9TOlFm0R9TOnFl0R9TOnFl0Q9VOnFk0Q9YOkFh0S9]OiFc0W9^OhFc0V9^OjFb0U9@jF`0U9AkF`0T9AkF?T9BlF?S9AmF?R9BnF>R9CmF=R9DnF=P9DPG\\MZ7l3fHTLZ7l3fHTL\\7j3dHVL]7i3cHWL`7f3`HZL^4ImMj3eM]L]4OnMBXMh3=gL]4OTNY3_MhL\\40VNW3^MiLZ43WNT3_MiL[42VNU3_MiL\\41VNU3^MjL[42YNR3\\MlL[42\\No2", "size": [424, 640]}, "area": 25690.0, "iscrowd": 0, "image_id": 10369, "bbox": [427.0, 0.0, 213.0, 424.0], "category_id": 115, "id": 10012689}, {"segmentation": {"counts": "[7g0bZ8BfGSOnNR1]9JcGVOROn0[9KdGTOjN071Hm0c9LWHHU85mG_OYNNk9`0oG^OYN2i91QFMO3\\2Nd7Mk\\c6", "size": [424, 640]}, "area": 5327.0, "iscrowd": 0, "image_id": 10369, "bbox": [0.0, 222.0, 129.0, 184.0], "category_id": 165, "id": 10012690}, {"segmentation": {"counts": "RV95S=5J7J5K1O0O2O1O00GeCFY<7kCIU<4oCLP<0TD1k;MXD2g;N[D2d;N\\D3c;L_D3a;L`D5^;LcD4\\;KeD5[;KfD5X;KiD6V;JkD5U;JmD6R;IoD7P;JQE6n:ISE8k:IVE6j:IWE8g:IZE7e:H\\E8k;0gNHaE8g;0fNHeE8e;1cNGjE8c;10O01000O0100O010O10O010O10O10O0100O01000O010O10O010O01O1N9H;E;D3N1N101O0O2O001N101O0O2O1N101O0O2O001N10lNZEGe:9T1100O10000O2O000O10000O101N10000O10000O2O000O100O10001N100004La0_O8H01O0000000000001O0000000000001O000O100000001O0000000000001O0000000000001O00000000000O2O00000000001O1O001O001O1O001O001O1O001O001O1O6Je0[Oe0ZOf0[Oe0[Oe0[Oe0[O2N1O00001O0000001O00001O00001O0YOfJ`IZ5`6oJWIQ5j6WKmHj4R7fMP3\\1eNW1hNK5J6J7J5J6J7J5J6K6I600O1O2O0O1O2O0O1O101N1O101iN[FhNf9U1]FjNe9Q1`FnNa9n0bFQOa9i0cFVO`9>jFBW93SGLP9JXG5j8JWG4l8JTG6m8HTG8n8FRG:o8EQG;Q9BPG>Q9APG>R9@nF`0S9^OnFb0Q9_OoFa0Q9_OoFa0Q9^OPGb0o8_ORG`0n8_OSGa0l8@TG`0l8@TG`0l8_OUGa0j8@VG`0j8@WG?i8@XG`0g8AYG?g8AYG?f8A[G?e8A\\G>d8B\\G>c8B^G>b8B^G>b8A_G?`8B`G>`8BaG=_8BbG>]8CcG=]8CcG=\\8CeG=[8CeG=[8CfGU1MYa3", "size": [424, 640]}, "area": 35421.0, "iscrowd": 0, "image_id": 10369, "bbox": [22.0, 23.0, 609.0, 300.0], "category_id": 183, "id": 10012691}, {"segmentation": {"counts": "m^h33g>N]A3c>500000000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000000000000000002NSXW2", "size": [480, 640]}, "area": 1610.0, "iscrowd": 0, "image_id": 10386, "bbox": [256.0, 471.0, 231.0, 9.0], "category_id": 105, "id": 10012692}, {"segmentation": {"counts": "0h5X90000O1001O000000N2O10000O1000000000000000000O100000000O11cF^JZ9d5000N23MO1O1O10000O100O1O100O1000000O10000000_FcJ_9`5O1OO11O00001O0000001ON21OO1^NcF_M_9_2cFSLOm00]O_9h2`FgM62N\\O]9j2cFcM47MUOM2_9R3eF[M2<2UOX9S3bFPML;8:Cl9d1RF]NJe0c0FQ:X1aE^NKd0b0GR:X1`E\\NOc0?IR:X1kE\\N_O;f01P:X1kE\\NA=?K^OHg:e1kEZNAFc02P;c0SDGa=:`BCa=>aB]OHLg=h0aB[Oa=e0^B[Oc=c0VBZOV>e0kA[OU>5kA9W>HhAJ29W>IgA028X>HfA053W>MnA0T>0lANV>2c0BH];S1oDUODKZ;m0eDbN000O1001O000001M2O01000O101O0000001O2N1O1OO0O2N24L3M1N20dN]BV1h=N20N50NNO1O110O1]ObBD]=000N20O01O10O0000001NO30N01N2BZOaBf0_=]O^Be0a=\\OXBM2g0f=AXB`0h=<0N2N11000O01000O10000O0^OTB2l=GYBHKa0m=E\\B9h=A\\B:CHb>5_AIO0b>2^A1h>NYA0_ko01\\cPO1O3L1N6L4K01O3M101ON2010L12001M02O11OcAEV>9gAFN31MV>EoA910NHn=1RB:1No=7PBJ5Fa=OZBP13POc=T1[BmNf=Q1[BoNd=Q1[BQOe=U10O10O1N21OM3O11OL6N1M3O1O1lB]Nj20O2O0O101O0O101N100O010\\OfAb0]>N101N101O0O101N102N0O011N2ONKYA5g>1010O010O10O10O010O10O10O100000O101O0001OO10001O0001O00O2N1O100001OO2O0O1O100O20O00O1002_ObA=\\>DdA<_>D`A:`>FaA9c>00001O000000010N1001O00O1N3L3N2O1N3O2N3M3M3M3M1O01O000000O10\\O\\BKf=3`BGb=8g0H^AIi>1Vaf0Nl^YO1UAOj>6]OLTB6j=HkA566n=OnA2R>;33M5K2N3NO0M2N3O101L2105K01L3O1MmAYOS>d0lA\\OX>d02M43L2N0hA[OV>i0NM30100O0O2O1O0O2O0O20O010O00010O010O001O0N_OeAb0Z>21O1N100O1O101OMBdA?[>BdA>]>AdA>[>410O000000O1HcAO[>0gAKNO[>6gAI00Z>6hAJN0X>1fAO005ON0W>0RB1GOf>0YA2j>00Nao>3_PA2UAKe>P9R2QG`MY1X1fNhN5>j8i1QGjM10^1V1kNVOe8j1QGiMT2d0ZNHb8h1XI_NXNH`8h1YI`NYNE_8k1XI`NZN@b8R2RI^N_N_O]8S2TI^Nf7a1\\H^Ne7b1ZH^Nf7a1[HZNgMFm9Q2\\HWNiMHk9R2[HWNiMGl9R2[HWNiMFm9R2[HWNiMHk9P2]HoMfM52Kl9S2[HlMgM63Jk9U2ZHkMiM51Ll9V2XHiMkM52Jm9W2[HiMfM2T:W2`200M34L0\\CfMb<\\20001ON12O001ON2O100M3N2O1O1000001N11N10hNYC7g0cA3030M\\>MdA`0[>AeA?[>3001OM32NO11O1OO12N2NO10000O1K@iAa0m;@XENI1RO`0m;AVDNN1g01WOOj02VO?o;_OUD1LOe093JXO>h;_OZDON2241KO0NO4`0b0DZO>_9AeHNnM>0A131?`06l8^O`FJn11TN?OA033?a03j8GYHFXN`00^O143=`05k8FZHEWN`01_OO52>d01i8HYHg0ZN_Ob04k8GXHe0ZNAc04k8FWH]1nNmNj8GXH\\1nNmNl8ETHa1oNjNk8HVH^1mNkNn8FVH^1nNjNj8YOcF?e1^1lNlNl8HXH\\1mNkNj8KYH\\1jNiNl8LZHZ1kNjNk8LRG^Oh0k1ZOlNl8KoF@m0h1XOmNj8MmFCR1a1UOQOl8LhFEX1^1TOQOm8;fFjNX1g1QO[NIh0R9VOnFZ1U1>QO[NJg0R9e0RH9TOYNFk0U9a0RH;SOXNGl0T9a0RHO10000O100O100O10000O100O1000M2100O10N2O010O010O10O3N1N1N4L1N5L2N3M2M2OXTl02ckSO6K401O010O010O1O001O001O010O0010O01O10O0N3O10N04M003H[AOf>O61][i1NadVN5VAMb>9N2O100L4F^OPB1Nd0R>700000000O1000000000000000000@`000000000O1000000O100000000001O001O1O1OO11OO10000O1000000O1N2I7J600N200001O001O000000O11OO1O1O100MPNUCQ2k<20000001ON22N0000000000", "size": [480, 640]}, "area": 26500.0, "iscrowd": 0, "image_id": 10386, "bbox": [0.0, 282.0, 640.0, 198.0], "category_id": 148, "id": 10012695}, {"segmentation": {"counts": "e6[2f2iNU6W1kIiNU6W1kIlNR6T1nIkNS6V1lIjNT6V1lIjNT6V1lIjNT6V1mIiNT6V1lIhNV6X1iIjNU6W1lIiNS6W1lIkNS6U1mIkNS6U1nIlNQ6S1oImNQ6S1jIfMbMX1Z1jNdNNT7Z2\\KgM`MY1X1fNhN5T7T2SKgMjM10^1V1kNm5n1SKhMiMT2d0ZNa6i1oJ1_NXNb6f1nJ3`NYNE^Ob6U2YK4`NZN@Af6R2\\K1^N_N_O\\Oe6V2^KO^NeNR6^1_KO^NcNW6[1[K1^NdNZ6X1WK5ZNgMFl0j6V1WK7WNiMHj0k6U1WK7WNiMGk0h6X1ZK4WNiMFl0g6Y1[K3WNiMHj0f6Z1ZK4oMfM52Kk0j6V1YK6lMgM63Jj0l6U1YK6kMiM51Lk0i6W1]K2iMkM52Jk0i6Y1^K4iMfM2R1g6T1`K\\1_4eNaK[1l3hLQJm1P2^1n3lLmIe1Y2[1i3[OWLSMfM`3R6^OZLb0f3^OZLb0f3^O[La0e3_OYLc0g3\\O[Lc0e3]O[Lc0e3]O\\Lb0d3^OZLd0e3]OZLd0g3[OYLe0h3ZOULi0k3WOSLk0n3TOQLm0P4ROoKo0R4POnKP1R4POnKP1S4oNmKQ1T4oNjKR1V4nNkKQ1U4nNlKR1T4nNdJ\\M7f3U5nNdJ\\M7f3T5oNeJ\\M5f3W5mN\\JZMA4l0d3V5oNWJXMC1O00O26n0d3W5nNWJYMB70NP1d3o2VLWNh2WNZMD`0m0W3o2YLSLOR2h2\\NXMBc01\\Oi0i3X2WLgM6Y1b2\\NoMB[Oj0f3W2\\LcM4^1`2YNWN1ROHm3P3XL[M2c1`2YNYNKX3m2kKPML;8c1`2PNXM7Q1HPO2Y4P3mKoLI<;`1e2SNXN1T3Q3lKnLH?:[1a8W1aG\\M0\\1_8W1bG]MCC:C?6VOIO0o8e1[G]NJe0c0Fd0EeN1T9b1UG^NKd0b0Gf0CeN0T9e1SG\\NOc0?IR:X1kE\\N_O;f01P:X1kE\\NA=?K^OHg:e1kEZNAFc02P;c0SDGa=:`BCa=>aB]OHLg=h0aB[Oa=e0^B[Oc=c0VBZOV>e0kA[OU>5kA9W>HhAJ29W>IgA028X>HfA053W>MnA0T>0lANV>2c0BHd10k6i1mG_NDKa1LQ7e1]GnMU7e1lG@@^N_1>V7c1hGFS1cNZ7e1dGFQ1gNZ7e1bGFT1eNZ7d1ZGoM1k1\\1_N[7e1UGRN025g1X1bN]7c1ZGRN1h0M6Z1^OY7D\\GR20RN1b028LVOU17POEn51SKNI1ROP20jN0UO8U1l0UOmNFN31Mo52TJNN1g01WOOj02VOj2?XNe0WOmNOm5FVJ1LOe093JXOh2?ZNc0jNoN910NHg50[JON2241KO0NO4`0b0DZOh2?ZN?lNRO:1N`3IcNNnM>0A131?`0`2JUN?ZOSOJ5FU35fLJn11TN?OA033?a0]2IUN?kNSOP13POW3=^NFXN`00^O143=`0_2JUN=NVOmNY3<_NEWN`01_OO52>d0Z2IYNOd2ROXM^Oh0k1ZOS1GaN<2b2QOVM@m0h1XOU1EaN<4a2POUMCR1a1UO[1D]N`05_2POQMEX1^1TO[1C^Na05B]Nc2Q1ZMjNX1g1QO[NIf4a0[M]OmM\\20fMZ1U1>QO[NJe4`0_Mi1XOkN9TOYNFi4b0]Mj1VOkN;SOXNGj4a0]Mj1VOkNY;YOSD>=>_;WOoC`0;=0nNS;V1eD17iNT;Y1^D3>dNS;h2mDYMS;j2jDWMa:ObEk2MVM`:5]Ei2KoLO4f9KeF13e3AeLf9FeF5LJIg31dLc9HeF:Hl3c9kKcFh4]9XKaFi4`9SKZF11O2n4e98N3N12OO0O2N1MdJbF]5Z9fJfFZ5Z97O0dN\\JRH0b002e5Y7^J[HMO1;e5l6ZJfH024JL42NNO4`0c5l6_JiH1LMNM13a0b5d6iJjHB170O0N;KHf5P7iJmHM0LOO0K0O0O014e5P7XKmH11h4Q7WKnH11h4Q7WKmHn5R7P101O001O01_IPIM0g3o6mKQI^O1DOo0OQO1020Mo4P7gKQI[O493c0ITO4OMn4m6dKUI@03OK6n02Q4d6bKUIA414k00R4b6`KYI@1068B<<]4b6^KdICK5CI0505?f4^6SKVIMg00D2J1L35K5K5J6K4K2M4K5L4K5L4K5L4Dh<20000000000000000O1O1N2O1N20L4O01001O0O101OO0110NO120OO1010M201O000000100N10000001O00O10000100N101OO100001O00000000000000000000nbP5_O`]oJ0kB122j<8O20000O11OO11O0000O1000O1000008C\\d5", "size": [426, 640]}, "area": 2085.0, "iscrowd": 0, "image_id": 10388, "bbox": [17.0, 183.0, 609.0, 26.0], "category_id": 96, "id": 10012699}, {"segmentation": {"counts": "fbl31Y=0O0J0TC0g<84I50100O200000000000100010N3M7I01Kn`T4", "size": [426, 640]}, "area": 62.0, "iscrowd": 0, "image_id": 10388, "bbox": [299.0, 183.0, 22.0, 18.0], "category_id": 105, "id": 10012700}, {"segmentation": {"counts": "W5T1U<10000O1000000O10000O100000000001^Ob00N10000O00010O2O00O11OOOYObCg0]<3001VOaCe0c<0002M1000001O00O1N201O01O000O110O1b0\\O1001O00001OO11OO1001OO11O00O100001O00O1001O00O100O11O000O1000O12NO2O1O0000000000000O11OO1000000000O0011N11O0000000000O100O10O11OO11O1O1N100000000O10000O1001OO1O11O0000000O10O100001OO1O1000000001O1OO100O10L5L1MQDlNQg<:F:I6L4KBP;ZOSEf0k;L3N3L3M3M1N2O1O1O1O1O1Og^f00WaYO4M3M3M3N2N2M3N2N2M2O2N1N3N1O6I4M2N2M2O2N1O2N1O2N2N101N1O2N1O2N2N1O2N1O2N1O2O0O2N2N1O2N1O2N1O2N2N1O2O0O2N1O2N2N1O2NO100000001O0000000O101O00001O0000001N10001O0000001O00001N10001O0000001O000O2O00001O0000001O0O2O00001O001O00001N101O00001O001O000O2O001O00001O001O0O101O001O00001O001N10001O001O001O001N10001O001O001O001O0O2O00001O001O001O0O2O001O001O00001N1O2N101N101N101N100O2N1M4K4M4K4M4L301O001N1N2N3M2N3M20Z_?", "size": [426, 640]}, "area": 17089.0, "iscrowd": 0, "image_id": 10388, "bbox": [294.0, 184.0, 308.0, 207.0], "category_id": 183, "id": 10012704}, {"segmentation": {"counts": "P3S2k<3O000001OO10O1O02K32O0N4NGoM`CU2\\8Ec0WO]O2?M61m:;^DF0d0d0ZO\\O5;4EGP<=PDE1d0<[OC:92f;ORDD3e01[O1?2Ng;OYD;J]OO=0@O?o;I]D=F^OOS1a0lNf:2YEh0@;`0lN_ONS;OcES2NPN\\O0k;o1hDRN]OO0Of;P2mD_NQ;a1oD^NR;b1nD^NR;b1nD^NR;b1nD^NR;c1mD]NS;e1jD\\NV;d1jD[NV;f1jDZNV;e1kD[NV;d1jD]NU;`1_DYNM7e;d1ZDjNe;W1[DiNe;X22O3L7J4L1O1O1O1O2N1O1N2O1O2N100001OcNfCUOJMON0b0c<:WDGk;4WDLk;0VD1j;OUD1l;NTD2n;KSD6m;HTD7n;HSD7n;GSD9n;FSD:n;CSD=n;CQD0000001O1O1O1O1O1O1O1O1O1OO10000O100O10000O2OO10O10000O100O10000O100O100O100O100O100OSQ7LRoH7I001O001O001O1M210O001O001O001O001ACYB=b=d0O001O001O0O200N101O001O1O0100O01O10O3NN101O1O00000NbNbB_1[=cNeB]1[=cNeB]1[=cNeB^1Z=40001N10001O00001O00ZNmB_1S=_NnBc1X=0N1O2NdNoBl0oJdA0K2Ta<", "size": [480, 640]}, "area": 39322.0, "iscrowd": 0, "image_id": 10393, "bbox": [0.0, 32.0, 614.0, 153.0], "category_id": 96, "id": 10012705}, {"segmentation": {"counts": "\\P`81m>2PO7^BGN3c=P1O10000O10OhBmNd0mfa0", "size": [480, 640]}, "area": 630.0, "iscrowd": 0, "image_id": 10393, "bbox": [580.0, 102.0, 22.0, 58.0], "category_id": 97, "id": 10012706}, {"segmentation": {"counts": "kW[21n>1O1O1GMbA6^>6N201O1N3K33NOO1001N0100O10010N200O001O0N1120N0O1O100O10000O100O100O1O1O1N3N0O2O1000000000000O1O100O1O1000O01O00100MnNWBR1j=200O10O010OaBlNT=T1lBlNT=T1lBmNS=S1jBlNK0[=T1jBnNX=R1gBnNZ=R1fBmN\\=R1cBnN`=0]B0Oh01YOn=k01N4L3M4L2N2N5K3M]OOZB1g=4TBJl==mACT>c01O2N1O2N2M3J6M4Mfa58coIJMON0T>j0N2N11O00O1O101N101N11O00000000O3OO3NVBoNe=o0XBSOj=o03M2N3M3M2N3M3M2O2M3M5IXe6OokH1h>7M2N30O10GDhA?V>BjA`0S>AmA?R>8O1O1O1O1O1O1O001O1O1O1O1O001OO1001O100N2O1O1O1O1O1O0020O1N2O100O20OWO_B1b=KbBGL3c=2cBHO5^=0XCJh<3[CMkcP4", "size": [480, 640]}, "area": 4717.0, "iscrowd": 0, "image_id": 10393, "bbox": [160.0, 129.0, 206.0, 135.0], "category_id": 105, "id": 10012707}, {"segmentation": {"counts": "\\Pk21o>1O1N1YOO_B1a=6VBNi=:mANm=c0O0L4100OO20OaCjNiN1O1Q8Ek;GSDb0IOc0YOe:2QEf0A4i0TO[;i1_D]Na;c1^D^N\\ONo;c1cDiN];X1aDiN^;X1bDjN];T1cDQOY;Q1eDSOW;o0dDVO[;h0gDXOX;h0bD_O];b0^DUN3X1:hNd:c0oD]O2?M61d0O>0`Xe5", "size": [480, 640]}, "area": 3263.0, "iscrowd": 0, "image_id": 10393, "bbox": [194.0, 50.0, 59.0, 186.0], "category_id": 132, "id": 10012708}, {"segmentation": {"counts": "P8h3X;0O11O10N10O100O10O2O010O00000001O00O01000HYLUEi3j:71N2O3M2O1N0O10000001O1O1O1O1O00000O2O000O1000O1000000O1O1O1O1O0O3OO1001OOOiD[LW;a3iD`LZ;`3fD_L\\;`32O10O10000001N1000O100000000000000O1001OO11O000O1000000000O1000000000000000000000000000000000000000O1000000000O11O0000O11O01O00000O1000000000O10000000000\\ObDfM^;X2dDhM];V2eDiM[;U2gDkMY;T2iDkMU;U2nDiMT;U2lDlMT;R2mDoMR;P2oDQNQ;k1SEUNm:g1VEZNk:a1XE`Ng:9cD5i0Cd:8kDIe0O`:8SE]O`0<]:7^FJb95_FKa95]FMc93[FMVNYO_;j0YFOXNWO_;0aDh0f13ZNUOa;g0oE;S:EiE?W:AeEc0[:]O`Ej0^:VOaEk0_:UObEj0_:UObEj0_:UObEj0`:TOaEk0_:UOaEj0a:UO`Ej0_:XOaEf0`:\\OiE8Y:IRFIn9:UFAk9`0UF@i9d0UF[Ok9h0TFVOm9m0PFROo9R1oEmNR:U1lEjNT:V1nEhNR:Y1nEgNQ:Y1PFfNn9]1j102OOUO`B6`=IcB5]=KeB4e0E^;6oC4b0H^;4RD3>J`;2UD2:N`;0XD161a;M\\DO36`;K^DL3:_;IaDI1`0];GdDE0f0[;DaE>^:AbE`0^:@`Ec0`:]O^Ee0`:]O^Ee0a:\\O^Ed0b:]O\\Ee0c:[O]Ef0b:[O\\Eg0c:ZO\\Ef0d:[O[Ef0WOgNn:d0iEg0XOfNn:d0iEf0YOgNm:d0iEf0YOgNm:f0hEb0[OiNl:f0jE?ZOkNl:e0lE`0WOkNm:d0nE`0UOlNm:c0QF`0ROlNl:d0TF?POnNk:b0WF?nNoNj:b0YF`0mNlNk:c0ZF`0kNnNj:a0]F`0iNoNi:a0`F?hNoNh:a0bF?fNPOh:`0cFa0eNnNh:`0eFa0cNoNg:a0oE^OEQ1EPOg:`0PF_OEP1BSOh:7oDKl1k0ZNVOk:4oDIo1l0TNZOn:1PEGP2n0oM\\OQ;LoDKU2X1m8mNPEIS2Y1n8mNXGP1j8POWGn0j8QOXGl0k8QOXGm0^;O2M3N2I6K6IVlZ3KRTeL3M300O010O1O100O100O10O0100O1O100OO20O100O1O010O100O100O1O101N2O1N2O1N3M100O100O100O100O1O100O10OO001N2O1O2N2N2M3N2WN_NQFc1o9^NnEd1R:^NjEd1V:hN\\EZ1e:jNSEY1j:POnDR1T;QOaDU1_;V111M2O2N0001O00O11O0000000000000001O1O00000O110M2001N2O001M200O1O100O001O2OO10000000000000010ON22N00O11OM30000O1O11O0001O0O12N000000O11O00O10O011LkL[DV3d;kL[DU3e;21001OO101O00OO30N12L21OO1002NO1010O020L12O11NN0201O0fH", "size": [480, 640]}, "area": 35086.0, "iscrowd": 0, "image_id": 10393, "bbox": [0.0, 230.0, 640.0, 151.0], "category_id": 140, "id": 10012709}, {"segmentation": {"counts": "h;X3h;000001O00O100O1001O001O000000000000O100000000O100001O00O10000001O1O1O1O1O0000001O00000000O1000000O1O1O1O1O1N200000000NfL^DZ3^;fLcD]3];cLbD^3^;2O10000000000O100000000000000000000000000000000O10HeDkL[;o2QEkLo:o2WEQMi:i2j0J6N2N2N2O1N2N2N2N2O1N2N2N2N2N2O1N2N200O1O001O1O1O1O1O1O100O1O1O1O2N1O1O1O1O100O1O1O001O1O1O1O10000O100O10O10O100O10000O10000O100O10N[OiAe0W>[OiAd0X>\\OhAd0X>110002M100000000O0100O1O1O1001N1000000000001N10N22N1O001O0O101O00001O00001O001O00001O00001O00001IYA3g>MZA2[>MnA0H2f>N[A1Z>OlA0K0Y>1QBOP>0PB0P>0PB0`>0Pn00]dk02`]SO3M2O2M3M2O2N2N1N3N2N1O1O1O1O1O1O1O1O1O1O0O2O1O1O001O1O1O001O1O1O001O1N2O1O001O1O1O001O1O1O1O1O2M2O1O1O1O1O1O1O1O1O1O1O1001O0001O00000O1000000000000O1000000000001N1000000000000O100000001O1O0O2O13L4M4L4KZCnMb0000000O1000000000000000000000000000000000000O10000000000000000\\\\17PcN9F;F:2N4L4K5L4L4L4CaA3d>L_ANe>2500O10000O1000m00nN4L5K1014O0LjZ8J^eG2O2N2N1N3N2N1O2N1O2N2N1N3N1O2N2N1O2L3O2N2N1O2M2O2N2N1O2N00O1O2N2O1N2N2O2M1O100O1O10000O100000000O01N2O1O1O01000000O100000000O100000002M2O2N00000O1000000O100000000O101O1O000O10001O0000O10000N201N1O100O1O1O100000001O0000000001ON22N01N11OM30000O1O11O0001O0O12N000000O11O00O2O0O11O10O0O1010OO2O00001M210O0N30OO1011NO2O01O011NO2O02OM20010O1^E", "size": [480, 640]}, "area": 26007.0, "iscrowd": 0, "image_id": 10393, "bbox": [0.0, 333.0, 640.0, 147.0], "category_id": 149, "id": 10012710}, {"segmentation": {"counts": "0P3P=Q=G\\COVO3`>KaAOO2ZQ6", "size": [480, 640]}, "area": 36137.0, "iscrowd": 0, "image_id": 10393, "bbox": [0.0, 0.0, 628.0, 96.0], "category_id": 157, "id": 10012711}, {"segmentation": {"counts": "mVk81m>2000O10\\BOT<0fB1S1OjN130T=6lBIi00UO;U=9\\C^O_O:U=e2j9oLmEi0OVO3Q3Q:SNjEmNOO2Q3U:d101O1O1O1O00000000000000", "size": [480, 640]}, "area": 3554.0, "iscrowd": 0, "image_id": 10393, "bbox": [604.0, 0.0, 36.0, 159.0], "category_id": 169, "id": 10012712}, {"segmentation": {"counts": "h5X2h<00O11O1OO010000000O1001O000O10010N1N110O10H^CPNdj06L2M2O1N2N2O00OO4H7L^k11cTN7J6J3M2NO11N101O010jA[On=Q1KO10O010O1000001OO1O1N2N2N101N2O1O2N2O2M2N3M2N2O0O1O2N00100O2N1O010Occc10_\\\\N2O0O02NO0WY30lWL1k>0\\R[10cmdN3O2H7L4L4M3[Oe0O2N1O1O1O1O1O2N1O1O1O1O1O2N1O1O1O1N2O2N1O1O00000O110OM32N001OO10000010O00O110O001OL400000000000000000O11ON2001O1N101O0000000000O1001OO1000000000000001O000002NN200O100000000000001O00000000000000000000O100M^ChMbO0000000000000000001N8I2M4JnS5Z1kjJ0000000000000000000000000000000000000001O00000O1000000000000000000000000000000000000000000000000000000000000000000O10000000[KiNaKW1Y4UObKj0X4\\OhKd0R4BnK>l3HTL8j3JVL6h3LXL4f3NZL2e3O[L1c31]LOa33_LM_35aLK]37cLI\\38dLHZ3:fLFX3jLBT3`0lL@R3b0nL^OQ3c0oL]Oo2e0QM[Om2g0SMYOm2g0SMYOl2h0TMXOk2i0UMWOj2j0VMVOi2k0WMUOh2l0XMTOg2m0YMSOf2n0ZMQOf2P1ZMPOe2Q1\\MnNd2R1^MlNa2U1aMiN^2X1dMfN[2[1gMcNX2^1jM`NU2a1mM]NR2d1PNZNo1g1RNXNm1i1TNVNk1k1VNTNj1l1WNSNh1n1XNRNg1o1ZNPNe1Q2\\NnMc1S2d51O1O1O100nHdM0EYLg2e3fM0FYLe2d3hM2EYLc2d3iM1FZLb2e3hM0HZL`2e3iMOI\\L^2e3iMNI]L_2e3hMLJ`L^2d3hMJKbL^2d3gMFOfLZ2d3gMB2kLW2c3gM^O5oLU2c3fMVN@lMh0TOo1h2cMTN?SOn1i2bMUNa0QOm1j2bMUNb0POl1k2bMUNb0oNm1l2aMUNc0nNl1m2aMUNd0mNk1n2`MXNd0iNl1o2`MYNn0]Nb1Z3`M[NY1nMW1h3_M\\N]1gMT1o3]M\\N^1cMV1R4[M^N]1_MX1T4ZM`N]1ZMY1V4YMeN[1TM\\1W4YMhNY1PM^1X4YMjNX1mL_1Z4XMiN[1kL]1]4UMkN^1fL^1a4PMkNc1cL]1j8cNUG]1k8eNSG[1n8eNQG[1T8lLUHi1G[1S8oLTHh0CG6b2S8QMSHd0FI2c2T8RMSHa0II0d2T8TMRH=KKOd2S8WMQH9OLLd2T8YMPH52MJe2S8\\MnG27LHf2S8]MkG2;LFe2S8`MhG0a0JDf2S8bMdGOg0HBg2R8]N^HlN_Og2R8\\NaHmN]Og2R8[NcHnNZOg2T8YNdHoNXOh2U8WNeHPOVOi2V8VNdHROUOh2X8TNeHSOSOi2X8TNfHROROj2Y8SNfHSOPOj2[8QNfHUOoNj2\\8PNfHUOnNk2]8oMfHVOlNk2_8mMgHWOjNl2a8lMdHXOkNl2d8jMaHZOjNl2e8lM`HWOkNm2d8nM`HVOkNl2d8PN`HTOlNl2c8SN_HQOnNl2b8_MYG0V1FnNk2b8`M[GNU1GnNk2a8aM\\GNU1EnNl2`8bM^GMS1FnNk2`8cM`GLQ1FoNk2_8eM`GKQ1EPOk2^8gMaGHQ1GoNj2^8hMbGHQ1EoNk2]8jMcGFP1FoNj2^8jMcGGo0DQOk2\\8lMcGEP1ATOn2X8gNcHXNXOQ3S8jNdHRN\\OT3o7lNRIT1l6oNRIR1m6oNRIR1l6QOQIQ1n6QOPIP1o6ROnHP1Q7QOnHP1Q7ROmHo0Q7TOlHn0R7UOlHl0R7WOgHo0W7SOdHR1Z7QO_HU1_7W3N2N2O1]JeH_3]7[LkHa3W7]LmH_3U7_LoH]3S7aLPI\\3R7bLPI\\3R7dLoHY3S7fLQIT3Z1^K_3]1^Ki2X1jK[3\\1bKc2U1RLY3Z1dKa2T1ULY3Y1eK_2S1YLX3W1gK^2Q1[LY3V1hK\\2P1_LX3T1kKY2n0cLX3T1kKV2n0fLX3S1lKU2l0iLX3Q1nKS2k0mLW3o0PLR2i0PMW3m0RLQ2g0TMV3k0ULn1e0YMU3h0XLn1c0[MT3g0ZLl1b0^MT3e0\\Lk1`0bMS3c0`Lg1=hMR3a0eLb19oMQ3>jL`15RN]N^Oa3P1nM^14VNXN@f3l0oM\\13ZNSNCj3f0SNZ11^NmMGn3a0UNX10aNiMKQ4YONo1VMhN]21?UOOS2UMhN\\20c0nNO[2RMgN\\21Q4Y1cIgN[20Q4Z1dIgNZ2OQ4[1eIgNY2OP4[1gIfNY20n3[1iIfNX20m3[1kIfNW20l3[1lIgNW2Ok3[1nIfNW20i3[1PJfNV20h3[1RJfNU20g3[1TJfNT22d3Y1XJeNT24a3X1[JeNS25_3W1^JeNR28[3T1cJeNQ2;W3Q1hJeNP2>S3n0mJdNP2a0o2l0QKdNo1a0n2l0SKdNn1a0m2l0TKeNn1?m2m0UKdNn1a0j2m0WKcNn1c0g2k0[KcNm1e0c2j0`KbNl1f0a2i0cKbNk1g0_2h0fKbNj1c0b2l0dKcNh1a0c2m0eKcNg1`0c2n0fKcNf1?c2o0gKcNe1>c2P1hKcNd1=c2Q1iKcNc1Z2k0XMgN==[2l0ZMgN:=[2k0^MhN6=]2h0`MkN2<`2g0`MmNOcMYO@9n2h4BZOMlKa0j4AAIdKg0k4^OHE]Kn0j4\\O4h1MVN>dNVKT2\\4VOX1j0hNVOX1k0hNSOY1m0hNQOY1P1gNoNY1R1gNlNZ1T1gNkNY1V1hNgNY1Y1jNdNV1]1iNbNX1^1iNaNW1`1iN^NX1b1hN^NW1d1iNZNX1g1hNXNX1h1hNWNY1j1gNUNY1k1iNSNW1n1jNoMW1Q2kNmMU1T2jNkMW1U2iNkMW1V2gNjMZ1V2gNhMZ1Y2jN`MX1`2d51O001O001O0012NO0@YMgDh2j:cMYE]2Y:mMkET2f9WN]Fj1[9ZNhFf1Y9VNjFk1V9QNmFo1T9lMPGU2P9gMSGZ2m8bMVG^2k8^MXGc2h8PMoE3]1m2e8oLQFN]1T3b8nLbGS3^8mLaGS3`8lL`GT3a8lL\\GV3e8jLVG[3j8dLRG`3o8`LlFd3U9\\LfFi3T:4M3L5K4L4[MXLnIm3P6PLSJQ4m5kKXJT4i5gK\\JY4e5bK^J^4S8O10000OjL`KmK`4Z700O1000000O10000VL`ES3a:jL`EV3n6[L_LgN[AY1`>eNf_O2NNh1\\1a>dNg_O:h1R1`>eNg_O9j1R1`>QO^AP1c>POe_ODd1\\1f>SOYAo0h>POXAP1T>bNg@`0U1@]N]1`?bNc@2;0C:f1DYN[1^?iNc@Ob08V1Q1c=iNd@O>MB=i1m0c=nNRAJD8h1o0`=QOh@E85H6g1o0a=QOh@E94F8h1o0a=UOk@6f1e0\\=4dBK\\=6dBK[=5eBK[=5eBK[=6bBL]=1k@cNi1\\1\\=LjB5W=HgBjNTN`1U?DiB?V=BjBa0S=_OmBa0T=^OkBc0U=\\OmBc0Q=_OoB`0S=_OmBb0nBRC`0l<@TC`0l<_OUCa0k<_OUCa0k<^OVCb0k<\\OXCb0k<[OUCf0d=`N]Ba1`=^NbBc1_=[NaBd1mMZN[?O_@0Y2f1lM\\Ni01a=MlCh1fM\\Nm0Oa=MlCi1eM]Nj00c=KnCP2_NXN_=GSDR2eMnMe0;b=ETDQ2fMoMa00^O;V>FiAOZ2U2YNkM]OFjANZ2W2SNjMD>2Am=4UCLOW2YO[NFAh=3UBJn00TO1Q1V2[O[NG_Of=8QCITO0S1V2YO]NE^Oi=6cBHC03006P1o1\\OeN0UOM0]<;cCIELO010O8S1l1]OgNLYO0MD1d<;cCOINT1j1\\OiNCTOMO3475V<6`CA1k0S1W1ZOZOCgN96MGo;b1_D^N[O28k16LEWNM;1FO2U<_1aD^N[O25Y2J@0UN000e00[OR\\8l8bGhFa0KB`0Z8k7cG_H2ZO=I@44>X8Y7mG[HGJ6125HJ1O63:0BM0d0W8Z7kJ_HkLCX8P8RKXHo4i7TKTHk4m7UKSHi4o7ZKnGd4T8\\KlGc4U8]KiGc4Y8a31N200N2N2dNaGUGa8k8`GSGa8l8bGoFa8k8ZGYF6a0N]Od8h9ZGVFN17?IB4Nf8i9YGWFN08\\:W8cE\\G02O<_:U8bEcGO9_::aEm61RI_:OaEk7\\:XHcEZO0X8k:gGWEM0O5]8Z;N3O0O100000O11OO10002N00000000000O001OO020OO30O1N2O1O1hK^D0c;G[DVL41MP4g;WNXDWO6aNM0Mn3j;VNXDUNOH00Oi0=VOCn3j;RN\\DXN0HLh0>\\O@c3e;_NaDQN5KE315a0I_O90EO00T3a;ROkDjM41E6=K^O10M11:P3V;SOiEmMhN0`0OA0MO1011:Q3T;SOPFlMZOOVO050:Q3R;QOUGoMjMP3o:ROjGm0W8SOjGk0V8VOjGj0W8UOiGk0W8UOiGl0V8TOjGk0W8TOkGk0U8UOmGi0T8UOlGk0U8UOlGh0V8VO[DSN^3e2Y8ROYDXNf3>[Lg1g;^OSH]NUL95S1KSO0Ei;h0ZDFj3_OSL47S1MUOMEj;V2GPFNO?1_O03NNj7TMCi2>XMDf2g2AYM?g2AYM?f2BZM=f2DZM=d2E[M;f2DZMh1AYN?f1BZN`0f1_OYN?g1BZN?f1BXN>i1AWNa0g1_OYN`0a1QOYF>W8`0hGQOM0:0n83iF=8BI0g7T1WHkN61R9d0iFZO00O00124e7T1YHnNY9?hF[OO10004g7_1^1ZOkFXO0Ih7e1]1CeN<_1B`N?_1AaN>a1B^N`0`1@`N`0b1]O_Nc0`1^O`Nd0a1YO_Ne0\\H[No8P1eNf0\\HYNP9o0eNh0[H[NKOQ9l0jNj0VHZNO5Q9h0iNm0VHZNR9i0hNT1W1kNkNU1U1kNkNV1S1lNlNU1R1kNoNU1WHUNNG[8o0@f1`0ZN@e1a0[N_Of1?[NAe1`0ZN@f1b0YN]Oh1`0XNBh1>UNeGVOm7d2>VNgGVOj7e2=QNgG\\O2Nj7e2>mMfG^OV8e27iMdGAV8f26jMLW23jMLV24iMMW22kMMU24gMOZ20fMgGCT8e28mMGU27fMeGBV8h23fMiGDR8f24ZMgG85Ho7f25ZMgG94FQ8h29\\M2h2a81O6S_OlLb`0Z3O0]_OfL``0]3Q@cL[?^3d@cL@0g?^3Z@aLN180J0N0e?_3\\@cL4ML2O3e?\\3[@cL2NN7f?^3^@eLLEb?h3^@WL0?b?n3O00N200Ob@fKX?[4d@eK02Z?Y4e@jK\\?^4f@^KT?d4j@]KU?g401O0aFWKg3i4XLRLn2n3QMRLP3m3nLXK`Jl0`8l3oLZLP3e3QM[Lo2b3UM]Lk2c3oL\\KcJQ1_8b3kL\\KfJ1NR1b8b3fL[KhJ10O0V1b8`3dLgL]3Y3_LjLb3V3^LjLb3V3[LkLg3U3[LiLe3Z3VLgLk3Y3ULfLl3\\3nKhLR4Y3mKfLT4[3iKfLX4]3eKbL\\4_3UGPK[4OfK_1j8e3cKZL^4f3TGlJ]4[1a4k3]KVLd4j3\\KkJgKU1n8P4aKmKa4T4ZKoKg4R4XKlKj4T4PGhJn3T1S5V4jFfJ11R4P1U5[4hFfJl1O8o0U7`4oGdJUOOg1j0W7b4oGcJmNOL2d1MfNk0o8c4lGiJmNIN3c10\\N00j0[9c4bGaJQO=2BN013e12[NMOk0_9c4iFaJ65C80FOO1Mb15]Nk0a9_4dFfJ82Di0^17S8X4bFeJ94Eh0NQO00\\1Q1X8\\4^FbJO2?6Bm0Y1MZ8]4[FgJ?\\1l0^O\\8e4iFPLg0\\Oa8d4hFoKf0^Oc8c4WF\\J=e1DZNc00GP1`9j4aFkKD]N9ONO6l0`9m4aFoKJZNM16i0c9o4\\FoKMXNM35h0f9k4^FTLHXNN0ML40Nk0n9m4\\FTLIYNK43I0e0o9P5RFYJ4o1IhNO2S:o4PFXJ10Mo11AS:W4lEYJO12e3U:W2iEjMX:m52O1N2O1N2O1O1N2O1N2O1O1M3O1N2O1N2O1O1O1N2N2O1O1O1M3O1O1N2N2O1M3N2O1N2O1O1O1O1N2N200M3O1N2O1N2N2N2O1O1N2N2O1N2O1N200N2N2dNnBhKT=X4mBfKT=Y4oBbKT=X4gBlJ6a0N]OW=U5gBiJN17?IB4NY=V5fBjJN08<`=i4P1O1O1O1O1O1O1O1O1O1O11OM3O1O1O1OWKcKQJ\\4o5eKQJZ4n5hKRJW4n5jKRJU4n5lKRJS4m5oKSJP4m5QLSJn3m5SLSJl3m5ULSJj3m5WLSJh3n5XLRJh3m5YLSJf3m5[LSJd3m5]LSJc3l5^LTJa3m5_LSJ\\3aKnK\\:g0SJ\\3o5eLQJ^3k5cLUJ]3j5bLXJ^3h5\\LiE]O`4X4e5]L_Jd3`5[LaJe3^5[LcJf3\\5VLlE@i4Z4Z5VLjJk3U5WLiJj3U5XLjJj3T5TLnJm3P5ULoJl3P5ULoJl3o4ULQKm3m4SLSKn3l4QLUKP4i4QLWKP4h4PLXKQ4g4oKYKS4WKWKX9g0aKZ4\\4fKdKZ4\\4jK`KT4b4oK[KR4d4PLZKQ4d4QL[KP4d4PL\\KR4b4mK_KU4_4kKaKV4]4gKgK[4W4kKcKV4\\4jKdKY4Y4gKgK[4W4eKiK\\4V4dKjK_4S4aKmK`4R4`KnKb4R4\\KnKf4hKaJe7h0cLh4gKaJk0Fe5Q1iMj4dKaJk0Jc5l0nMk4bK_Jm0K`5m0QNk4`K^Jm0M`5j0SN[5\\LmI`5g0UN]5ZLlIUOEX6R1YN]5YLRJ]5a0ZN^5XLRJ]5`0[N_5VLTJ]5=]N_5ULVJDYOF0O0_5o0VOd5PLUJ\\OYO4:OHm4l0Df5mKTJ@WO1>NIn4g0Gi5jKVJC0i4MNn5dK^IB?2oF5\\3^Ob5>SG6Y3^Ob5T3_OXK^O[:d0XG`0U3K_5D[Gc0U3Ie5_OVGj0S3Gf5AVGh0T3Fh5AUGg0T3Hg5AUGg0T3Hf5BVGf0T3Gf5DVGe0T3Hd5EWGb0V3Id5DVGd0U3He5CWGf0S3Jb5CYGd0T3Hc5EYGc0T3F_5SOjEd0c1c0T3E_5TOkEc0c1c0T3E\\5SOkE21c0e1e0Q3C^5SOkE3O:o1o0h2AYKSOT:0lE233S2W1a2C]5SOPF4S2V1_2D\\5TOPF2V2V1^2E[5SOQF4T2S1a2GZ5ROoE4W2S1`2FZ5TOoE3W2T1_2D[5@XHj0]2D]5AVHl0]2C\\5BWHj0^2F[5_OVHj0`2EZ5BWHi0_2FZ5BUHh0a2F[5ATHi0a2HY5_OUHj0b2FS5QOYF>T2k0_2E\\KQOM0:0n83iF=8BI0a1N^NY1g4MXKkN61R9d0iFZO00O00124^1X1X3LXKnNY9?hF[OO10004_1Y1X36^4ZOkFXO0I_1`1X35^4C\\H8V34b4BWH;V34b4AWHk2X1h3ZN^I=j2X1i3[N]I>i2X1h3[N`I:UNfNc4e2i3ZN^Ik2Z1g3XNaI=h2[1g3XNaI=h2Z1g3[N`I;i2[1e3\\N`I:k2Z1f3[N_I;k2Z1i3WN]I?f2^1m3TN[I?i2]1k3UNdGROd1\\1l2^1l3VNWI>i2`1o3SNXI=i2`1n3SNYIoN]N]1[4b1h3PMPHS1d1mNYN[1X4f1k3SMnGo0h19_2f1h3SMPHP1i16_2g1h3YNjIO`2g1c3^NlIKa2g1c3^NlIL^2eNjKQ3l7\\NnINZ2n1b3VNTJK\\2o1^3WNVJKY2eNlK_33aLW7`1aJKY2\\2U3iMbJKZ2[2lKZLU7a1bJL^2[2\\LXLo5^1_IcNi1\\1X2eNoKh3a0WL@0[6X1cK5S2a2PLQLN180J0N0Y6U1dKjNTN`1P4a2PLRL4ML2O3Y6o0fK?Q2`2PLQL2NN7Y6l0fKa0n1c2WLSLLEU6T1jKa0n1e2SLeK0?V6e0hKc0o1X3X2TLkKc0n1X3U2WLmK`0o1W3W2XLjKb0m1W3U2[LlK`0m1V3ZLRKg5X1RLhNRNe1l3Z3ULQK02i5U1WL`0l1U3SLYKk5R1VL`0j1YNULT52mJc5U1]La0i1a3ULjJd5T1^La0j1d3h1jK_Lb0j1d3g1hKbLb0g1f3h1gKaLd0h1c3f1jKcLd0f1a3f1jKfLf0c1XNTLU5a5lJ`JP1X2f0mMZN`3OZLS5`5QL`JlNY2f1lM\\Ni01h1o4k2RLjLd0fM\\Nm0Og1m4P3SLfLf0eM]Nj00i1k4l2PKcJS1Y2m0_NXNf1g4l2PKfJ1NS1\\2n0eMnMe0;i1f4i2oJhJ10O0W1\\2j0fMoMa00^O;_2f4f2^LjJaNZ2U2YNkM]O<`2e4b2bLnJ]NZ2W2SNjMD>2AW2Q5h2dLSL[NOW2YO[NFAT2n4h2gLQKXNn00TO1Q1V2[O[NG_OQ2Q5k2gLkKYNTO0S1V2YO]NE^OV2Q5e2fLaKWNC03006P1o1\\OeN0UOM0k0T5e3gL`KYNELO010O8S1l1]OgNLYO0MD1R1T5d3kLaK[NINT1j1\\OiNCTOMO3475d0o4g3jL[KnM1k0S1W1ZOZOCgN96MG30L0KY5a4mMSLjL[O28k16LEWNM;1FO2530Y5Z4fMWLkL[O25Y2J@0UN000e00[O27OJO_50aJ[4OfKS3c0YM\\Ol30jK0g00_O0^5^4_MdKkLN21NOn;0RD]4a?N20^@gK]?_40K5O0jK]@n3f?mKZ@11R4f?mK[@l1O8j?TOY@UOOg1f?VOY@mNOL2d1MfNg?k0`@mNIN3c10\\N00i?m0U@QO=2BN013e12[NMOl?8S@65C80FOO1Mb15]Nm?5S@82Di0^1Z?eNj_O94Eh0NQO00\\1U`0fNj_OO2?6Bm0Y1S?eNn_O?\\1l0l>UOWAg0k>YOTAf0n>jN__O=e1DZNc00Gg`01n@D]N9ONO6d`01TAJZNM16d`0OSAMXNM35a`04VAHXNN0ML40Ne`0:WAIYNK43I0``01^_O4o1IhNOo?3Z_O10Mo11_?Ob^OO12kc0NYZa20lQ^M000bc0=]\\OC^c0`000N2O1O1O10000O20O1O0\\Oh\\O`0]c0O1O2NiNCn]O0d0;\\a0Jm]OLh00UO4Vb03i]OKk0OUO1Yb05f]OLP1O\\a0:l]OC>2ga0?e]OAc0Ola0O_]Od0Zc0002OO010N1OQ]O@bb0=^]OCbb09d]OGAMO1db0:f]OEE02`3cA^L^>b3cA[L_>e3bAZL^>f3n00WOZLXAf3i>YLWAg3i>YLWAg3e>XLf@011c0g3`4ZLm46bF`3NZLf3NiK41MP:8aF_3O[LT2MjN6aNM0Mm9;dF]31[LP2OgMOH00Oi0=VOCf90ZFa0`0W33[Lj13kM0HLh0>\\O@\\9d0oFV31ZLm12jM5KE315a0I_O90EO00i8e0eGV3O`Li11jM41E6=K^O10M11:]8EaG04i0LYO100o36\\Ln1m0mMhN0`0OA0MO1011:\\8EcGO1[54RKP2S1lMZOOVO050:[8DeG\\50RKR2U2oMjMW8h5kIQMU6o2kIRMV6k2kIUMT6m2kISMV6l2jITMU6m2kISMV6l2iIVMV6j2jIXMR6k2lIUMU6k2kIVMT6j2jIgISN^3R8l2eIfIXNf3>[LY5OiK0aN04Z6^1aM]NUL95S1KSO0E2l2N]M2FNS10kN3OM3Z6i0iIFj3_OSL47S1MUOME2m2O^MOGOf00[O1Mf6e2e@ZMVa0e212O2O0N20J60000001N11\\N", "size": [640, 427]}, "area": 99212.0, "iscrowd": 0, "image_id": 10400, "bbox": [0.0, 0.0, 427.0, 640.0], "category_id": 169, "id": 10012723}, {"segmentation": {"counts": "hbT52kc04K5M3N2N2M3N2O1N2N2O1N2O1N2O1O1N1000000000O1000000O101N1O2N2O0O2N2N2N3N1L6Hdm]2", "size": [640, 427]}, "area": 1053.0, "iscrowd": 0, "image_id": 10400, "bbox": [263.0, 197.0, 39.0, 37.0], "category_id": 183, "id": 10012724}, {"segmentation": {"counts": "V3a3^9QN\\GDd8BVH>j7_OYHb0e7\\O^Hd0b7YOaHh0]7WOeHj0Z7SOiHn0V7oNmHQ1R7mNQIS1o6jNTIW1h6jNZIV1e6jN\\IW1c6iN]IW1c6iN]IW1c6jN\\IW1b6jN^IW1V6TOkIl0U6SOkIn0T6ROlIo0S6QOmIP1R6QOmIP1R6POnIn0T6mNbGEZ2]1T6lNeGGW2\\1U6kNfGIU2[1W6jNeGLS2Z1Y6gNgGNP2Z1Z6fNhG0n1Y1Z6fNkG0k1Z1l6fNTIY1n6gNQIX1\\900O100O2N100O100O1O1M3N2M3N2M3M3N2M3O1O1N2O[EJb85_GJb84_GNa80`G1_8NaG2g:0O2O0O100O102M4M0O100O100O2O0O100O102N3L3N1N10000O101N10O0101O0O1`DoNQ;Q1oDPOl3Ni2T1ZInNl3Oj2R1YISOk3Kl2S1WISOl3Kl2S1UIVOm3Hn2d1QM]Nn2f1oL[NQ3e1oL]No2c1PM_NbMHj3j1bN`NbMHl3i1aN_NaMJm3i1aN]N_MMP4f1aN]N_MMP4g1`N\\N_MNP4f1bN\\N^MNP4f1bN\\N^MNo3g1cN[N^MOn3e1eN\\N_LE114:f4c1hN]N\\LF0268f4b1iN^NYLH1178e4`1kN_NWLI1098Q1DP2k1`0`NTLJ10:7c4_1nN`NRLL3N0N28i4a1PO`NQLK4NN055h4b1PO`NPLK40NN84f4c1POjNRLBNN<3\\1H[1l1m0iNQLCOL=4\\1IX1k1o0\\O]LPO]1KS1j1S1[O]LQO]1KQ1j1T1YO`LQO\\1Mn0i1V1YO`LQO^1NZNJT2o1d1XO`LQO_1OVNLU2l1f1XOTLkN47g10RNMV2j1i1VOSLmN57h1:4]1k1UOSLnN66i1:1_1l1SOSLnN87h163b1j1ZO[LnNi125g1f1YOULeN19d4k1UO\\OWLkNc4j1UOMj05UOKk05UOLj04VOLi06VOKi05WOKh07WOJh06XOJh07WOJg06ZOJf05[OL_OgMjM]2h2L_OfMiM\\2j2O\\OgMgMZ2n2O\\OgMeMX2Q32YOfMfMW2R33YOfMcMV2V34WOgMbMT2X36VOfM`MS2\\37UOfM^MR2^39SOfM^Mo1a3;ROeM\\MR2a3:ULaM`24iMP2c3;TLaMa24fMn1h3>PLaMb23eMj1m3b0lKaMc23cMa1W4l0bK`Me22aM`1[4n0`K_Me23_M_1]4P1^K^Mg22^M`1]4P1^K^Mh21\\Ma1_4Q1\\K]Mj20[Ma1`4R1[K]Mk20YM`1b4S1mNmNS1T1ZK\\MW3`1`1T1YK\\MW3_1a1V1WK[MX3_1a1V1WK\\MV3^1d1W1VKZMV3^1e1X1UKZMV3^1e1Y1UKYMT3^1h1Y1aNfN`1[1_NdNb1\\1]NeNc1\\1\\NcNe1]1[NbNf1^1ZNbNf1_1XNaNi1_1WN`Nj1a1UN^Nl1b1SN_Nm1b1RN]No1c1QN\\NP2e1nM\\NR2d1mM\\NT2e1lMYNU2g1kMXNV2i1iMWNW2i1iMVNX2k1gMTNZ2l1fMTNZ2m1eMRN\\2o1cMPN^2P2bMPN^2Q2aMnM`2R2`MmMa2T2^MkMc2U2]MkMc2V2]MhMd2Y2[MfMf2Z2ZMfMf2[2YMdMh2]2WMbMj2^2VMaMk2`2TM`Ml2`2TM_Mm2b2RM]Mo2d2PM\\MP3d2PM[MQ3f2oLXMR3i2mLWMS3i2mLVMT3k2kLTMV3l2jLSMW3n2hLRMX3n2hLQMY3P3gLnLZ3R3fLnLZ3S3eLlL\\3T3eLjL\\3g0jI\\1i2lM^3d0iITO2Z2h2lM^3e0iIUO6V2b2oM`3e0TJ]1]2jMa39gI0k2CTM=dNeLh3n2cM>dNfLg3m2cM?fNdLg3l2cMa0eNdLg3l2cMc0cNbLj3k2bMe0cN`Lj3l2aMf0^NXL1:P4h2`MV1_2kN`MV1`2jN_MW1`2jN^MX1b2hN]MY1c2gN\\MZ1c2gN\\MZ1d2fN[M[1d2fNZM\\1f2eNXM\\1g2eNXM\\1h2dNWM]1i2cNUM_1k2aNTM`1l2`NSMa1m2_NRMb1n2^NQMc1o2]NoLe1Q3[NnLf1R3ZNmLg1S3YNlLh1T3XNkLi1U3WNjLj1V3VNiLk1V3VNhLl1X3TNgLm1Y3SNfLn1Z3RNeLo1[3QNdLP2\\3PNcLQ2]3PNaLQ2_3oM`LR2`3nM^LT2b3lM]LU2c3kM\\LV2d3jM[LW2e3iMZLX2f3hMYLY2g3gMXLZ2h3fMVL\\2j3dMUL]2k3\\30000000000001O001O001O00001O001O001O001O000000[OVGTMj8a30001O1O00001O1O001O001O2N1O001O2N001O1O1O1O1O1O1O1O2N1O1O2N1GSK]Hn4`7UK_Hk4^7XKbHg4]7[KcHd4[7_KeHa4X7bKhH_4U7cKkH]4S7eKmH[4R7fKnHZ4Q7gKoHY4P7hKPIX4o6iKQIV4o6kKQIU4n6lKRIS4n6nKRIP4o6QLQIn3o6SLQIl3o6ULQIj3o6WLQIh3o6YLQIg3n6ZLRIe3n6\\LRIc3n6^LRIa3n6`LRI`3n6`LRI_3n6bLRI^3n6bLRI^3m6cLSI\\3n6dLRI]3l6dLTI\\3l6dLTI\\3k6eLUI[3k6eLUI[3k6eLUIZ3k6gLUIY3k6gLUIY3j6hLVIX3j6hLVIX3i6iLWIW3i6iLWIV3i6kLWIU3i6kLWIU3i6kLWIU3i6kLWIU3i6kLWI_2KkLn6f0WI`2LhLm6h0WI`20WLV7Y1jH`2^7`MbHa2]7_McHa2]7_McHa2]7_McHb2\\7^MdHb2\\7^MdHb2\\7^MdHc2[7]MeHc2[7]MeHc2Z7^MfHc2Y7]MgHc2Y7]MgHc2Y7]MgHd2X7\\MhHd2X7\\MhHd2X7\\MhHd2X7\\MhHc2Y7]MgHc2Y7]MgHc2Y7]MgHb2Z7^MfHb2Z7_MeHa2[7_MeH`2\\7`MdH`2\\7`MdH`2\\7`MdH_2]7aMcH_2]7aMcH_2^7`MbH_2_7aMaH_2`7`M`H`2`7`M`H_2b7`M^H`2b7`M^H_2d7`M\\H_2e7aM[H_2f7`MZH_2g7aMYH^2i7aMWH^2j7bMVH^2k7aMUH]2m7cMSH[2P8dMPHY2S8gMmGW2V8hMjGV2X8jMhGT2Z8lMfGR2]8mMcGP2`8PN`Go1b8PN^GP2d8nM\\GR2e8mM[GR2h8lMXGT2i8kMWGU2k8iMUGW2l8hMTGX2n8fMRGZ2o8eMQGZ2R9dMnF\\2S9cMmF]2U9aMkF_2LQMY9>kFc2V9\\MjFm2o8QMQGU3j8jLVGV3l8hLTGX3n8fLRG[3n8dLRG[3Q9cLoF^3Q9aLoF]3LaLW90mF_3[91O1OL42N0000ZNaFK_96hFBX9?PGkN]9V1eFiNY9X1gFfNZ9[1fF`N^9a1bF^N^9b1lFSNU9n1n01O2N8H9Gi0WO4L3M4L3M1O000000001O0000000000000RJSLi2m3WMSLi2m3WMTLh2j3ZMWLe2h3\\MYLc2f3^M[La2d3`M]L_2a3cM_L]2`3dM`LQ2LlJc3T3bLh12TK[3V3bL_19\\KT3V3dLo0f0kKd2X3fLi0j0oK_2Y3hLe0k0RL\\2Z3jL`0m0VLX2\\3kLhLHC0^3X1kLS2^3nLeLJn2X1oLo1_3oLZLI44o2W1TMl1a3UM]LHj2Z1XMh1b3WMYLAL5o2]1[Md1c3[MSLIl2Z1^M_1f3kMjNg0`M\\1i3mMdNi0cMW1l3RN]Ni0gMR1o3WNVNi0kMm0S4ZNoMk0nMh0V4`NgMj0SNc0Z4`M]Kn0S2Q1VN>c4aNUMR1XN:f4dNPMT1ZN6h4gNkLU1]N1k4jNfLW1_NLn4PO^LV1dNGQ5TOYLV1fNFQ5SOZLX1dNEQ5UOYLW1fNEP5UOXLW1hNCR5UOULY1iNC;PN^O0Y4X1QMV1mNB8ZNi3o0QMU1nNB7[Nj3n0PMV1oNA6\\Nj3o0oLU1QO@5]Nk3n0nLV1RO@4]Nk3o0lLU1UO_O3^Nc3@XL]1m0V1UO_O3^Nb3DWLY1m0W1WO^O3^Na3GTLX1P1V1XO^O1^Nb3[1SMj0ZO@N\\NX1^Oi0m1fNj0[O_OGkM3a0[1@ENNo1Ji0^OBIYN\\1ACLOm1Ml0\\OCGVN6Eh0NOJSO5`0O@L6Q2c0j0@7IZMk0LJ4DOFj1i0f0_O7IZMi0NL3]ODL>0g1h0g0@e0b0iLM4YOD0e2f07Ac0b0kLMQ3OBBa0c0mLKQ3NCC?d0mLKQ3MEC=e0oLIP3NDDdKB[4?eKA[4>fKB[4=eKC[4aHc2a0oLTO2g7:iHc2;RMUO6b74PIc28_Mg6NSIb2FUM0`;_OaD0g1P4[1jLjLM4YOD0e2n3j0kLkLMQ3X33lLmLKQ3X32mLmLKQ3X32mLoLIP3Y30nLRMGo2[3OnLRMGP3Z3NoLRMHo2Y3OoLRMHo2Y3OPMQMGP3Y3OPMQMGP3Y3OoLRMHo2Y3OoLRMHo2Y3", "size": [416, 640]}, "area": 51105.0, "iscrowd": 0, "image_id": 10403, "bbox": [0.0, 0.0, 640.0, 416.0], "category_id": 165, "id": 10012727}, {"segmentation": {"counts": "ga0i0];j0M3M3M3N2M4L3M3M3N2O100`GfMZ6Z2dIlMY6S2dIRNZ6n1dIVNZ6j1dIXN\\6h1bI[N]6e1bI\\N^6d1`I_N`6`1_IaNa6_1]IdN]6ROUHZ2]1eN[6TOXHW2\\1fNZ6VOYHT2\\1gNZ6VO[HS2Z1gNY6XO]HQ2Y1hNX6ZO^Hn1Y1iNW6\\O_Hk1Z1iNU6^OaHi1Y1jNT6@cHe1X1lNS6AeHc1X1lNQ6o1nIRNQ6o1oIQNo5Q2PJPNn5GlHZ1U1POm5HnHX1U1POm5HnHX1T1QOm5HoHW1T1QOm5HoHW1S1ROm5HPIV1R1SOn5GPIV1o0hMQO[1o6HRIT1l0XOS6DQIU1h0lMWOW1o6IRIT1f0[OY6AQIT1c0^O[6_ORIS1`0@_6^OPIR1?Ba6\\OPIR1m0V39`NYNlMV3d3aNaNV2`1iMaNW2_1iMaNXNjMW3f3aNaNWNiMX3f3aNaNWNiMk11jNf3T1aNVNhMm11hNf3U1aNUNiMo10fNf3V1bNTNhMQ20cNg3X1aNTNhMQ21bNf3Y1bNSNgMS20`Nh3Z1aNSNgMT20^Nh3[1bNRNfMV20\\Nh3\\1bNRNfMV21ZNh3^1bNQNeMX21XNh3_1bNQNeMX22VNi3`1aNQNdMZ21UNk3_1`NRNdM[21SNl3_1_NSNdM[22QNm3`1^NSNcM]22oMn3`1]NTNcM]23mMn3b1]NSNbM_23kMo3b1\\NTNcM_21jMR4b1[NTNcM_21jMR4b1ZNUNcM`21hMS4b1ZNVNbM`21fMU4c1XNWNbMa21dMb1Jc0i19WNbMb2OdM`1Od0d1;WNbMc2OaM`14c0`1=WNbMd2MaMa17a0\\1?YNaMd2M`Ma1;`0W1b0YNaMe2K`Ma1>`0S1c0ZNaMf2K]Ma1c0?o0d0[NbMe2J^Ma1e0>l0f0[NaMS3Z1hM?i0f0]NaMP3Z1kM`0g0f0]N`MQ3Z1lM`0e0f0^N`MQ3Y1mMb0c0f0_N_Mo2Y1QNb0`0f0`N_Mo2Y1QNd0>e0bN]Mo2Y1SNf09e0eN\\Mn2Y1UNh05e0hNZMm2X1WNl00c0mNXMl2Y1WNn0Ke0QOTMm2X1XNR1De0XOQMj2X1[NT1_Oe0\\OoLj2X1[NW1nNQ1M`Li2W1]NY5kN_Ig2X1_NZ5iN^Ih2W1`N[5iN^If2W1aN\\5hN]If2W1cN\\5hN\\Ie2W1dN^5fN\\Ie2V1eN^5fN\\Id2V1gN_5eNZId2V1hN`5dN[Ic2T1jNb5bNZId2T1jNb5cNYIc2T1kNd5aNXIe2R1kNf5`NYId2Q1lNg5_NXIe2P1mNi5^NVIe2P1nNj5]NVIe2P1nNk5\\NUIf2o0oNl5\\NTIe2o0POn5ZNSIf2n0QOo5ZNRIe2o0QOP6YNQIf2n0ROR6T1mImNS6S1mImNT6R1kIoNV6P1iIQOW6o0hIROY6n0fIROZ6n0eISO\\6l0cIUO^6j0bIUO_6k0`IVOa6i0^IXOc6g0]IYOc6h0[IXOg6g0XIZOh6f0WI[Oj6d0VI[Ok6e0TI\\Om6c0RI^On6b0RI]OP7c0nH^OS7a0lH_O6oMU6c2cI^O5VNU6\\2eI^O4[NV6W2dI_O5\\NW6V2`I_O9]NV6a4iIbKW6\\4iIfKV6Z4iIhKW6V4iIlKW6R4iIPLV6P4iIQLX6m3gIULZ6i3fIYLZ6e3fI\\L\\6a3dI`L^6]3bIdL`6Y3_IjLb6S3^InLe6n2[ISMg6j2XIYMi6d2WI]Ml6_2SIcMQ7X2oHiMT7S2lHoMW7m1gHUN\\7h1cHYNa7c1]H_Nf7\\32N3MiHTKl4b0VKW4F_KP5b0VKo3FdKP5c0XKh3FgKn4i0XK`3HjKl4l0YKZ3ImKi4Q1[KQ3KoKg4T1]Km2KQLd4W1`Kh3^4\\LaKd3]4_LbK`3\\4cLdK]3Z4fLeKZ3X4iLhKV3W4lLjKS3S4oLnKb25hJl3h2oK\\2`4fMaKU2b4mM^KP2c4QN^Km1a4VN_Kh1a4YN`Ke1_4^NaK`1_4bNaK\\1_4eNbKY1^4iNbKU1_4kNbKS1^4oNcK5HRMf4i2cK1IWMd4i2cKKM[M`4k2dKE0`M\\4l2dK_O3eMZ4l2dKlNd0XNg3n2eK[O2fMZ4o2eK\\ONfM\\4P3fKZOMeM^4o2hK]OHdM`4l2lKAAcMc4k2oKB]OcMd4i2RLEXObMe4h2WLFROaMh4k1UMY1k2gNVMX1i2hNYMV1h2iNZMT1g2mN[Md0nMUMh4V2\\Mc0RNPMd4]2\\M?P3ARM=o2BTMSNcMf1Z57UMoMbMj1Z56VMmM`Mm1[56XMiM^MQ2[56XMfM_MS2Z56_MJa26`MHb28^MGc28^MGb29^MGc29]MEe2:\\MEe2;[MDe2=ZMCg2PGBP9>QGAo8?RGAm8`0RG@n8a0RG_Om8c0RG\\On8e0QG\\On8f0QGYOo8h0QGXOn8j0QGUOo8l0PGUOo8^201O0000cNTGgNk8[1VGbNj8_1XG_Ng8c1[GXNf8i1`GPN`8R2oG\\MR8e2T12N1O2N1O00001O00001O00001O00001O0000001O00001O00001O00001O0HfLjFZ3T9hLlFY3P9jLPGV3n8lLRGT3k8oLUGR3g8QMYGo2e8SM[Gm2c8UM]Gl2a8UM_Gk2`8VM`Gj2_8WMaGj2]8WMcGi2\\8YMcGg2\\8ZMdGg2Z8ZMfGf2Y8[MgGe2X8\\MhGe2V8\\MjGd2U8]MkGc2T8^MlGc2R8^MnGb2Q8_MoGa2P8`MPHa2n7`MRH`2n7`MRH`2m7aMSH`2l7`MTH`2k7aMUH_2k7aMUH`2i7aMWH_2i7aMWH_2h7bMXH_2g7aMYH_2g7aMYH_2f7bMZH_2e7aM[H_2d7bM\\H^2d7bM\\H_2b7bM^H^2b7bM^H^2a7cM_H^2`7bM`H^2`7bM`H^2`7bM`H_2_7aMaH_2_7aMaH_2_7aMaH`2^7`MbH`2^7`MbH`2^7`MbHa2]7_McHa2]7_McHa2]7_McHb2\\7^MdHb2\\7^MdHb2\\7^MdHc2[7]MeHc2Z7^MfHb2Z7^MfHc2Y7]MgHc2Y7]MgHc2Y7]MgHc2Y7]MgHc2Y7]MgHc2Y7]MgHb2Z7^MfHb2Z7^MfHb2Z7^MfHb2Z7^MfHa2[7_MeHa2[7_MeHa2[7_MeH`2\\7`MdH`2\\7`MdH`2\\7`MdH_2]7aMcH_2^7`MbH`2^7`MbH_2`7`M`H`2`7`M`H_2b7`M^H`2b7`M^H_2d7`M\\H_2e7aM[H_2f7`MZH_2g7aMYH^2i7aMWH_2i7aMWH]2l7bMTH\\2n7dMRHZ2Q8eMoGY2S8gMmGW2V8hMjGU2Y8kMgGS2[8mMeGQ2^8nMbGP2`8PN`Go1b8PN^GP2d8nM\\GR2e8mM[GS2g8kMYGU2h8jMXGV2j8hMVGW2l8hMTGX2n8fMRGZ2P9dMPG\\2Q9cMoF]2S9aMmF_2T9`MlF_2W9_MiFa2X9^MhFb2Z9\\MfFd2\\9ZMdFf2]9YMcFg2_9WMaFh2a9WM_Fi2c9UM]Fk2e9SM[Fm2l900000000001O00kNTFVOl9k0[FmNe9T1bFdN^9]1iF[NW9f1Q11O1O001O1O2N8H9Gi0WO4L3M4L3M1O00000000000000000000001O00N2O1O1O1N2O1OF]LYGb3a8dL`G[3Z8lLfGR3P8ZMPHe2k7aMUH^2j7cMWH\\2g7gMYHW2f7lMZHS2d7PN\\Ho1c7SN]Hl1a7WN_Hh1_7[NaHb1`7`N`H^1a7cN_HZ1b7hN^HU1c7mN]HP1d7RO\\Hk0e7WO[Hf0f7\\OZHa0g7AYH4L8H2N3M1O1O00000000001O00000000O1O1O100O1O10\\BAb=a002N2QD^O_NOd;d0kD_O86l:;hDD=0j:a0eD_O>2m:R1TEnNk:T1oDoNR;Q1nDPOQ;P1aDaN9>W;]1cDcN\\;U2N1O001O00001OO1O1O1L4G]DiMj;U24000000O1O1O1N2O1001OO1O1O11O00O1001O1O1O001O001O2N3M1O2N2NM3N27VDQNOAn:U3SElLg:V3WEjLi:\\3WEcLd:`3\\EcL^:b3^F]LBO_8e3nGnLQ8S3VGgMh8l3O00001O00O1O15KN2K500O1AXGjK_8\\3^HXLk7Q3lHnLU7n2S26JN2K56JL4M36JCSEZMU;f2kDYMV;f2kDYMV;g2jDYMV;e260000000000O10000O1000000O10000O100O10_D_M^;a2bD_M^;a2bD_M^;`2bDaM^;_2bD`M_;`2aD`M_;_2aDbM_;^2aDbM_;^2`DbMa;^2_DcM`;\\2aDcM`;c2N00O100O100001O00001O001O001O00001O001O1O0fDWMX;Q3JO12N1OO12NN21O2NM3004LL41YFTMS8o2TGgMl8_2gFhMY9b301O0000000000000000001OM3L4K5L4O1YOUFdLOL1010N0Q:V3RFPMMM]:S3nEjLU:S3`EmLn:R330000001O0000O11ON2O100002N000000001OO1O1002NN2O1003MM3O1004L6J00O1L41O2NO1O1001O00O1O11OO1O11O0000AQEgMP;Y2PE]M00V;c2jD\\M[;c2fD\\M[;d2300001O1O001O1O2N001O001O1O001O1O001O001O1O00O11O001O1O0TEUM3GL0010O01O010O10O01O010O010O010O010O5050F08e6k2[IR1e6W30000000000000K54LNZIeHf6Z5ZIgJ90G^1i6k3WIgJ9OH_1h6b2ZIRMNnN8OH]1OcNi6P4[IcLLK2B70Hn0O_O0Ci6o3^IbLI@0:`0?@XO070Ik6l3^IaLHBO80G`0i0BWO:0a6m3_I]LR9c3PG^Lm8a3UG^Lk8a3WG]Lj8`3o01OO1O12N00N21O2NO12N1O001O00001O001O001O000000000000O100O10000001O1O1O1O001O1O2N1O1O2YFULLB080I3f0MA0IV7k601O1O000000N2O1N21OO1001O2NO10000000000O1^Ob0001ON2nIWHJNl5X801Nl0WJoF024KT4Z:kKgE\\3l:gLRE27GNl0L8o:lN_G<[;Enh`2", "size": [453, 640]}, "area": 42462.0, "iscrowd": 0, "image_id": 10405, "bbox": [73.0, 0.0, 384.0, 239.0], "category_id": 157, "id": 10012729}, {"segmentation": {"counts": "0l2[9d2fF\\MZ9e2`F^MP9B`FO;R35^Mo8DkFn2HoL9>U9FaFK0000O^35QMZ9FbFK00OY4]9>N12ON10001N01O1O1L4G`FfKg9X44hKVF1OO3m3h9SLVF12n3k9RLUFn3R:N1O1O1N2O2O01OO1O1O20O01N01O2M3O1N101O001O2M4M1O2N2MN3N27SFTLOAQ9R5PGoJl8Q5RGoJm81SGS50kJP9T5PGoJk8U5QHjJBOl6X5aI[K^6f4iHTLU7_5O000O2N10O1O06KN2K410O1AoHSJg6T5VJ`JS6i4dJVK]5f4R27JN2K47JL4M36IDnF_KZ9a4fF^KZ9b4gF]KZ9c4fF]KY9b460O100O1000O01000O1000O10O10O10O10O010bF\\KZ9e4fF[KZ9e4fF[KY9e4gF\\KY9d4gF[KZ9e4fF[KY9e4gF\\KY9d4gF\\KW9f4hFZKZ9e4fF\\Kc1>a5U4mH\\Ka1a0a5Z4\\JfKe5Z4[JfKe5Y4]JgKa5Z4\\JiKd5V4`JfKa5Z4_JfK`5[4^JgKb5Z4^JeKa5\\4`JcK`5]4_JdKa5]4\\JeKc5\\4^JcKY5]O`IQ5X1aKU5@cIo4V1aKX5@bIQ5V1_KW5@cIQ5V1_KV5AdIP5V1_KU5BdIQ5[8RK`GQ5`8;N2M[JdGe50[JZ8o5I0120OOO12MO30O2NM3004KM32XIUJT5n5SJhJl5_5gIhJX6c601O01O1YHdIc7\\6]HdIc7\\6]HcId7c6LN`H_I`7a621O01UO_H[JOa0_7V5eHWJMa0[7Y5nHgJm6Z5jHUJ;>i6_5kHTJ?:g6c5[ISJ_OO11OOb61bIOL1010N0S6T7PJRIMM_6Q7lIlHV6R7_InHo6Q74O0000010oHmHn6U700O11NO10100002OO00001O01OO1O1002NN2O1003MM3OO204K7I1O01L4101NO1O1001O00O1O02N01O11O0000ARIfIo6Z6QI\\I00U7d6kH[IZ7d6gH[IZ7e6301O01N2O001MXIgHi6X74OOO2O001O1O001O1O001O001O1O00O11O001O1N1XIQI3GL0010O01O010O10O01O010O010O010O010O5050F08`2P7`MmLa2[70000000000000K54LN^MaDb2^9^McF90G^1e2o7[McF9OH_1d2f6^MnHNnN8OH]1OcNe2T8_M_HLK2B70Hn0O_O0Cf2R8aM_HI@0:`0?@XO070Ii2n7`M_HHBO80G`0i0BWO:0_2o7aM[HP5e7RK\\Hk4c7WK\\Hi4c7YK[Hh4b7o01OO1O12OO0N12O2NO12N1O001O00001O001O001O0000000O100O001O001O12N10K5N2O1O05L00O2N1OgGXJ38d7d5WHaJj7GeHLB080I3f0MA0Ie3\\:01O1O01O1O0N101N21OO10O2O2NO10N2006J1O0O2]Ob00010M2nIaK`LNl5a4]MkKc2T4]MnKa2R4_MjLhLjN024KT4\\4POVNkL_M\\3[4IiNnLjL27GNl0L8\\4U2kNgLWO`2h9TMkE?:_2k9cMkE_OO11OOQ3V:iNlE5T:JRF1m90XFKh95]FFd98_FFa9:_FFa99`FG`99aFF`9cNiEd1g0Ib96_FJa96`FI`97`FI_97bFI]98dFG\\99dFG\\98eFH[98fFG[98eFH[97fFIZ97gFHZ97fFIZ96gFJY96hFIX97hFIX96iFJW96jFIV97jFIV96kFJU96lFIT97lFIT96mFJS96nFIP99PGGP98PGIo88QGHn89RGGm89TGGl89SGHm88SGHn86SGJm86SGJm86RGKn85RGKn85RGKn84RGMn83RGMn83RGMm84SGLl85SGLm84SGLm84SGLm84SGLm84RGMn83RGMn83RGMn83RGMn83QGNo82QGNo82QGNP91oF0Q90oF0P91PGOP91PGOP91oF0o8bNoE^1R10o81RGOo80QG0n81QG0o80QG0o80QG0o80QG0o80PG1P9OPG1P9OPG1P9OoF2Q9NoF2Q9NoF2Q9NoF2Q9NnF3R9MnF3R9MnF3R9MnF3R9MmF4S9LmF4S9LmF4R90kF0T94hFMY96cFJ]99`FG`9=[FDe9?XFAh9b0UF^Ok9f0QFZOo9^2000000000000001O1O0000000000000000001O00O10000000000000000000000000000000000O100O1O1O1O1O12N1OL4O100005K1O00000oKPF38[3m9`LXF_3V:10000001O1O00O100000000O1000000N2006J1O001O00001O00000000000000JkL\\EU3d:60aL^E[3j:gLTEQ3m:nLSER3n:mLSER3Q;O1O1O0000001O000000001OO11O000000001O00O11O00001O0000O11O1O00001O00N2001O0000001O0000000000MWMjDi2V;WMjDi2V;3O10000001OO11O00O11O001OO100O1O1O1O1N20000001OO10000002N0000001O1O1O1VMiD00M0`2X;`MQE0G^2e;00000001O0000001O0000000000O11O0000O11O001O000000001O001OO11O000000O100000000001O0000001O00002NO1000000001O0000001O0000000kMRDS2P<0O11O001O1O00000000001O000QNmCl1S6K5K5J2O1N10001N10001N10001N10001N10001N10001N10001N10001N10000O1000O01000O0100000O10O1000O1000000O10000O1000000O1000000O10000O0100000O1000000O1000000O10000O1000000O2O3M3M4K4M4L3L5Lifi3", "size": [453, 640]}, "area": 2905.0, "iscrowd": 0, "image_id": 10405, "bbox": [272.0, 370.0, 92.0, 44.0], "category_id": 183, "id": 10012732}, {"segmentation": {"counts": "0V3j;2N001O1O0000002N004LN200N2O1N20000000000000000O1O1O1O1N2O1O100O100YOg0_Oa0O1O1O1O100O1O11O4L4L4L1O1O1O1O001O1O1O1O1O1O001O1O00O100O1O1O100O1O100^NYCMM1O000000001O00001O00001O00001O00001O001O00001O00001O00001O001O00001O00001O001O00001O001O001O00001O001O00001O00001O00001O00001O00001O00001O2N3M3M2N2N2N2N2N2N2N3M2N2N2N2N2N2N2N3M2N2N2N3M000000O10000001OWFUK]9k4bFWK]9i4bFXK^9m4ZFPK04f9T51O2M5L6J1N10001O1N2O1O1O1O001O2`KbEZ4\\:6O10M2N3M2010O100O1O100O100001O00001O00001O0000001O00001O00001O00001O000ULZE\\3f:^L[Eg3i:6K5K5K5K5K5K5K5K5N2000000O1000000000000O10000000000O1000000000000O10000000000O1000000000000O10000000000O11O001O1O001O001O1O001O001O1O001O001O1O001O001O1O001O1O001O001O1O001O001O1O001O001O1O001O001O1O001O001O1O001O001O1O001O001O1O001O1O001O001O1O001O001O1O001O001O1O001O001O1O001O001O1O001O001O00N200001O001O001O0000O11OO11OO11OO1000000000000", "size": [480, 640]}, "area": 130731.0, "iscrowd": 0, "image_id": 10407, "bbox": [0.0, 0.0, 640.0, 360.0], "category_id": 121, "id": 10012733}, {"segmentation": {"counts": "oXi41n>1O1O1O1O1O100O1^OJUB;k=FnA`0R>700000000LYOoAg0P>5K5M3N200001O00001O0000001O0000001O00001O0000001O0000001O0000001O0000001O0000001O0000001O0000001O0000001O0000001O0000oK^OdIb0\\65nHJR79kHGU7=gHCX7b0dH^O\\7e0bHZO^7j0^HVOb7m0[HSOf7n0XHROh7P1WHoNi7R1VHnNj7S1UHmNk7U1SHkNn7U1RHjNP8V1nGjNV8S1iGmN]8o0aGQO`8o0`GPO`8R1^GnNb8S1]GmNd8S1[GmNf8T1YGkNh8U1WGkNj8V1TGjNm8V1RGjNo8W1oFiNQ9f1]F]Nd9\\2_EgMc:VOXEP4V;F6J3M3M3M4L3M3M3M3M3M2N2N1O2N2N2N2N2N1O2N2N2N2N2N1O2IjB`NX=\\1jBdNX=W1kBiNV=S1mBmNU=o0mBQOU=j0nBVOS=g0oBYOS=b0PC^OQ=>RCBP=:RCFo<6TCJn<2TCNo=000000000000000000000000000000000O100oMNTE2n:OoD1S;OkD1V;1gDO[;1cDO_;1_DOc;2ZDNg;3WDMk;4RDLP<4nCLT<4jCLW<6fCJ\\<6bCJ`<7]CIe<7YCIi<8TCHm<:PCFR=;kBEW=`BBa=b0ZB^Oh=d0TB\\On=j02N1O2N2N2N1O2N2N2N1O2N2N2N0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\\LJ^H6`7L`H4`7M_H3a7M_H3b7M]H3c7N\\H2e7M[H3e7NZH2g7NXH2h7NXH2h7OWH1h70XH0i70VH0i72VHNk71UHOj73UHMl72THNk74THLl75SHKm75SHKm79oGGQ8R1VGnNj8k1]FUNc9T2TFlM", "size": [480, 640]}, "area": 8866.0, "iscrowd": 0, "image_id": 10407, "bbox": [326.0, 323.0, 314.0, 157.0], "category_id": 122, "id": 10012734}, {"segmentation": {"counts": "V3j;X3N001O1O0]NXNnEh1Z80fG0b6h1^IZNi4]3WKcLQ3U5oLoJV1h6jNVI0R80_30000000a`]40__bK1O2N1O101N1O1O2O0O1O2O0O1O2N100O000001O00001O0LcAE]>:5K6L\\\\Y4", "size": [480, 640]}, "area": 3308.0, "iscrowd": 0, "image_id": 10407, "bbox": [0.0, 102.0, 346.0, 378.0], "category_id": 170, "id": 10012735}, {"segmentation": {"counts": "]h2b1f;h1XNh1YNg1XNh1YNg1hNX1O1N2O1N20000000000000000O1O1O1O1N2O1O100O100YOg0_Oa0O1O1O1O100O1O11O4L4L4L1O1O1O1O001O1O1O1O1O1O001O1O00O100O1O1O100O1O100O1O1O100O1N20000O100O10000O10000O100001O2N1O1O1O2N1O1O1O1O1O1O1O1O1O1O1O2N1O1O1O1O2N1O1O1O1O1O2N1O1O1O1O1ON2O1N2O1O1N2O1N2O1N2O1N2O100O10000001O001O1O001O1O001O001O1O001O1O1O1O1O1O00000000000000O10000000000O10000000000O1000000O1d0\\O7I000000000001O0000000000000000000000000000000001O1O001O001O001O001O1O001O1O1O001O1O001O1O2N3M2N1O1O1O1O001O1O1O1O001QFcKY9^4]FjKd9h41O1O1O100O1O1O1O1O100O1N2N2N2N2N2N2N2N2N2000000000000000000001O1O1O1O1O2Nd0\\O1O001O1O1TMUKaKl4W4aKcK_4b4`KZKa4j4[KUKf4o4VKPKk4T5QKkJP5Y5lJfJU5[5jJdJV5_5hJ`JY5a5fJ^J[5c5dJ\\J]5f5aJYJ`5c71O1O00i1WN:F0nH^Hf6c7\\I]Ha6c7aI]H]6c7eI^HX6b7jI_HS6b7nIZHT6f7c00000001O0_NWHkKi7U4XHjKi7U4XHjKh7W4YHgKg7Y4ZHfKg7Y4ZHfKf7Z4\\HdKd7]4\\HbKe7]4\\HaKe7_4]H^Kd7b4]H\\Ke7d4[HZKf7f4\\HWKf7h4[HVKf7j4[HTKf7m4[HQKf7n4[HPKf7P5[HmJg7T5ZHdJm7[5TH^JR8b5f0010O01O00010O000010O01O01O01O0010O01O00010O001O01O01O01O01O00010O000010O0001O01O01O3M3N1N2N3M2O1N2N2N2O1N2N2N2O1N3M2N2O1N2N3M2Og0XO;E4M2M4L3M4M2M1O2N101N1O1O2O0O2N1O2O0O2N1O101N1O4Jm0RO[k0KlTO7J3L4M3L5L3L4M3L4L4M2M3N1O2O1N2N2O1N1O2O1N2N2N2O0O2SE`MV9b2fF`M[9a2`FbM`9_2\\FdMd9^2XFcMj9^2QFeMo9\\2nEfMR:\\2iEgMX:2XE]1\\NBd1=^NBc1;`ND`1;bND_1:bNF^19dNF\\18gNGZ17gNIY16iNIX14kNKU14lNLU12mNMS12oNMR10QOOo00RO0o0NSO1m0MVO2k0LVO4j0KXO4h0KZO4g0I\\O6d0I]O7c0H_O7b0FA9?GA9?FC9=GD8=FD:o1CPN?o1APN`0o1APNa0n1@QNa0o1_OPNc0n1^ObILFJm3m0k2]OaI3c3b0j2\\ObI4b3a0k2\\OcI3a3c0k2ZOdI3`3e0j2YOfI3^3e0l2XOfI3\\3h0l2VOhI3Z3h0m2VOiI2X3k0n2SOjI3V3k0o2SOkI2T3n0P3POlI3R3n0Q3POmI2Q3P1P3oNoI2n2Q1S3mNoI2m2S1R3lNQJ2j2U1T3iN_JE\\2c1T3iN`JDZ2f1T3gNbJDW2g1W3eNbJDV2i1V3dNdJDS2j1Y3bNdJDR2l1X3aNfJDo1m1Z3`NgJC]2`1k2mNhJDh2S1_2ZOiJCm2o0Y2^OjJDQ3i0T2DkJ0i28Z2ImJ8c2M_2KnJ7g2KZ2OoJ4l2KT21PK3P3Io15QK1T3Hi18SKNW3If19SKMZ3Ia1;UKK\\3I_1WKGb3KU1?YKEe3JR1a0YKCh3Lm0b0[KAk3Li0c0\\K_On3Me0e0]K]OQ4M`0g0_K[OS4N=g0`KYOW4N8j0bKVOX404k0dKTOZ410l0fKSO[40Mo0iKoN\\42HQ1lKlN^44CQ1oKjN`46]OR1SLhN`48YOR1WLeNb4:TOR1ZLcNd4X3j0m1iNkJ>U3k0P2gNkJ>R3o0R2cNlJ?o2P1T2bNmJ?l2R1V2_NnJa0h2R1Y2^NoJa0e2T1[2[NPKc0a2T1^2ZNQKc0]2W1a2VNRKd0[2W1b2VNSKe0W2X1d2TNUKe0U2X1f2SNUKg0R2X1g2RNWKg0o1Y1j2PNWKi0l1Y1k2oMYKi0j1Y1m2nMYKk0f1Z1o2lM[Kk0d1[1o2kM]Kk0a1\\1R3iM]Km0]1]1T3gM_Km0Z1_1V3dM`Ko0V1_1Y3cMaKQ1Q1_1]3`MbKS1l0a1`3]MdKT1h0a1c3\\MeKV1a0c1i3WMfKX1:g1n3RMhKY13j1U4mLhK_1Hj1^4hLjKf1ZOi1k4aLkKo5T4RJlKo5R4RJnKo5Q4QJoKo5P4RJPLo5m3SJSLn5k3SJULn5i3SJWLm5h3TJXLm5f3TJ[Ll5c3UJ]Lk5b3VJ^Lk5`3VJ_Lm5^3TJbLn5[3SJeLo5X3RJhLP6U3QJkLQ6R3PJnLR6o2oIQMR6m2oISMS6j2nIVMT6g2mIYMU6d2lI\\MV6a2kI_MW6\\2lIdMV6W2mIiMT6S2oImMS6n1PJRNR6i1QJWNQ6d1RJ\\NP6_1SJaNo5[1SJeNo5V1TJjNm5R1VJnNl5m0WJSOk5h0XJXOj5c0YJ]Oi5>ZJBh59[JGa90000000000000000000000000000", "size": [420, 500]}, "area": 51197.0, "iscrowd": 0, "image_id": 10414, "bbox": [0.0, 13.0, 500.0, 407.0], "category_id": 143, "id": 10012737}, {"segmentation": {"counts": "0j0Z<00000000000000000000000000001O000000000000000000000000000000000000000000000000000000001O00000000001O00O100O100O1O100O100O1O100O100O100O1O100O100O1O10000O10000O100O10000O10000O10000O1000000000000O1000000000000O100000000000000000000000000000000001O00000000000000000000001O00000000000000000000001O00000000000000000000001O001O001O001O001O001O00001O001O001O001O001O001O001O00001O001O001O001O00DnCFR<9=O100000000000000000000000000=C000000000000000000000000000000000000000000000000000000001O00001O000000000000O100000000001OO1O100O100O10000O100O10000O100O100O10000O100O10000O10000O10000O10000O10000O10000O10000O10000000000O10000000000000000000000O1000000000000000000000000000000001O000000001O000000001O000000001O000000001O0000001O00001O00001O00001O00001O00001O00001O00001O00001O1O001O001O1O001O0000001O001O0000O1001O0000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000O100000000000000000000000000000000000000000000000000000000000000000000000000000000", "size": [420, 500]}, "area": 9994.0, "iscrowd": 0, "image_id": 10414, "bbox": [0.0, 0.0, 500.0, 31.0], "category_id": 172, "id": 10012738}, {"segmentation": {"counts": "lj55ak0_OYO>h0AZO=h0AZO>f0@]O>e0@\\O`0d0_O^O?d0_O^O?c0_O_Oa0b0]O@a0a0^OAa0`0\\OCb0>]OCb0?\\OCc0=\\OEb0<\\OFd0;ZOGd0:[OHd09YOIf08YOJe08YOJf06YOLe06XOLh04WONg03XOOf02XO0h01WO0h00WO2g0OYO2f0NYO3g0NXO3f0NYO4f0JcNfJg0`5e0K\\O7c0I]O8b0H]O9b0H^O9a0G^O;a0E_OBB>>BA`0>@Ba0=_OBb0>^OBc0=]OBe0=[OCf0;[ODf0XNBh1>WNCi1=WNCi1=WNCh1>WNCi1=WNCi1=WNCi1=WNCi1=VNCk1=UNCk1=UNCk1=TNDl1=SNCm1=SNCm1>QNCo1=QNCo1>PNBP2>PNBP2?nMBR2>nMBR2?mMAS2?lMAU2`0jM@V2`0iMAW2?iMAW2`0gMAY2?gMAY2`0eMA[2?eMA[2`0cMA]2?cMA]2`0aMA_2?aMA_2`0_M@b2`0^M@b2a0\\M@d2`0\\M@d2a0ZM@e2a0ZMAe2?ZMCe2>YMCg2=XMEg2e60kIBC=b60jICFZNEe13DP4e6oKYIO<3DQ4g6PLeIV4[6kKYIK4ON[4b6fK\\I90G000[4d6eK\\I<0R4b6dK^I^21Ia6=^IC[6fMiI`2g0WO`5ZNfIOO\\2o0[Oh4YNeJ0H1MY2R1]Oc4ZNZJO0250L2OU2T1^Ob4bN]JIM^2T1WOa4dN\\JHO]2T1WO_4gN]JW2T1RO_4^1aKbN_4]1bK`Na4a1^K_Nc4_1^KaNb4`1]K`Nc4a1\\K_Nd4`1]K`Nc4`1]K`Nc4`1]K`NY4\\NdJ02V3R1]NT4]NiJ0O10V3T1]NR4]NkJO00OW3T1]Ni3]NXK1KNO20V3T1^NU3[NWL0C4NZ3S1XNT3YNSL0H20e3Q1RNQ3XNVLOE0031f3S1PNlN`Ng3GYL21O50J41d3S1PNlNaNf3FZL21O50JP4T1TNa2oM]LLO03T4P1QNa2oM\\L00S4S1oM`2_2`McM^2[2^L]KV1U2]2^2]L]KU1V2^2]2dMdM[2]2dMcM]2]2bMbM]2@_L]N0d2T1_O^2@^L\\N0g00R1T1OkN^Na3H`L]1`0mNCL2KJV10UOU1Z1kNZNi30WL00_1f0gN2<[OKNDOO05V1`1d2_NVLn04nNM4h0M50RO9E^O[Oo88QGk00mN105j0k8^OoFR2m8>00O1001O001O00O1O1N2N3L2O2000O11O00O2OO10O101OO3N001`GmLZ8T3eGnLX8U3gGRMQ8o2oGoLR8[30010O10O0O11N10000O1O100O0110O0O1001OJ5JkGjLW8U3jGjLV8W3jGhLW8X3iGhLW8W3jGhLW8X3iGhLU8Z3kGfLS8\\3401ON2010NO20bLjG10W3\\801O001O1N1O020O01O02N2NOTM]Gf2e8XM\\Gg2e8XM\\Gh2d8WM\\Gi2d8WM\\Gj20UM_81aGo2_8PMbGe0Ne1]8gMfG>MB0Z2]8eMeG`0NA10OV2b8WN`GB00NW2b8WNhGi1X8WNhGi1X8WNiGf1Y8YNhGg1f7lM^H>`6l0PIhN>>_6h1`IZN]6j1WInL0NO]1j6^3O1000000O10O10000001OO2UKVIg4n60O010OO20OO10O2O06KN1O1O1021OQI]Kg6h430NO100O10000002NNWIVKi6j43O00000001O00O12N3MTKYId41ZKg60]I]4KgKU7U4lHkKV7S4jHkKX7U4hHkKX7T4iHlKW7T4iHjKY7T4eHlK20Y7S4fHmK11X7R4gHmK10Y7R4gHnK00Y7S4fHmK^7R440L5M1\\L", "size": [375, 500]}, "area": 59215.0, "iscrowd": 0, "image_id": 10420, "bbox": [0.0, 0.0, 500.0, 270.0], "category_id": 169, "id": 10012741}, {"segmentation": {"counts": "aQ71e;101O1O2N1N1ROI\\F8c9KXF:e9FPFf0k9f0eNbNfGO^OS2k8nMYGc2f861O1O0100OJUGbMk8^2VGaMj8^270F_MXG00g2g87O0000001O001O2N00O1O100001O2N001O000000001O00001O001O1O1O1O00O10000O10000000dGgLZ8[30001O003MO1001O1O1O00001O^OnG`MQ8InGH0O0g1?[NB01=b8P1WHcNWO=c8:[GXO9OJ1i01VONY:0hE1i01VON];2cDNc;0`mP21^RoM2`DNT;7lDMP;4oDLQ;4mDNS;;00000OO3oD\\Om:e0RE\\Oh:OXEk0T:f0lE_NQ:e1fK]NYJNT4d1b1aN]Na1b1`NaMKlL0a0f1D[NS53mM4ZM\\1G_NP52ULMcN4X16XOg1g4SNZKL_ONa0a0I^O37D9;g1j3kMeL6D4Kb0FXO7f0JTOO_2V4iM_L0J5BC3]1MT2U4iLPLF00L9<_5h3bJjKF11OO6>7Z5i3nJmKH8[5k3nJlKG2B1i5Q4e11000000N200O1001OlMgKjLY4U3hKVK0T1Y4f3gKUK1U1X4e3jKPKMK1`1X4d3kKQKLK10N:1G0i0Y4Z4kKQKLK76IK2h0W4[4kKPKMK770b0Q4\\4kKoJ9MDO9e0S4`4gKoJk0>a3c4gKkJk00mN105f4o4bKkJn5Q5>00O1001O001O00O1O1N2N2M3N200000000001OO100001OO1000000O10000001O001O0000O100[N[InLI;O3OJn6LfJL\\N:221J?0C5LKn6LQINf1:ZN35DK1Q15WOIh62PINf17^N45Eh06]6JcH0e10ZN4734If00c60]H0g13eNNOO[80ZG1g1OgN0N0]80oH0l900000cR^1", "size": [375, 500]}, "area": 19770.0, "iscrowd": 0, "image_id": 10420, "bbox": [19.0, 0.0, 355.0, 240.0], "category_id": 175, "id": 10012742}, {"segmentation": {"counts": "0S4d7O10000O1I]HYLd7g361O2N000000001O00O1GWHcLj7Y3XHaLO5i7Z3\\HdLe7h2UHhM6_Oe7h2VHiM6]Oe7j2VHhMS8X2nGgMR8Y2PHeMP8[2QHeMn7Z2SHfMm7\\1lGQO8]OIHT8j1nGlN:]On7g1hGaNf0Fc7e1SIZNm6lH;cNWO=2_7=kH_OXO9OJ1i01VONb01]Oh7g1WH[N1i01VONh0g7R2[HVMNn0a7R2_HoM`7U3O1O2N2PIeK`6_4\\IbKc6a4[IaKb6c4ZI_Kd6k4O1O1O000000gL^I^1a6bN_Ii03Dj7k2UHSMO<3Dk7m2VH_MP8a2QHSMK4ONU8h2lGVM90G000U8j2kGVM<0l7h2jGXM^21c3g2cLXM]3a2lIcM`2g0Q3f1`J`MOO\\2o0U3n0_J_N0H1MY2R1W3i0`JTNO0250L2OU2T1X3h0hJWNIM^2T1Q3g0jJVNHO]2T1Q3e0mJWNW2T1l2e0dM[O\\2e0cM\\O]2d0dM[O\\2f0bM[O^2e0cMZO]2f0dMYO\\2g0cMZO]2f0cMZO]2f0cMZO]2<_JaN02V3R1Z27`JfN0O10V3T1Y26aJgNO00OW3T1Y2MaJTO1KNO20V3T1Y2ZO`J20C4NZ3S1R2ZO_JM0H20e3Q1j1YO`JNOE0031f3S1h1VO_JF21O50J41d3S1h1VO_JF21O50JP4T1`1UOcJILO03T4P1]1UOcJH00S4S1Z1UOTOk0l0UOROG]KV1_5SOTOG]KU1`5TOSOn0m0ROTOm0l0TOTOk0l0SOVLI]N0d2T1i2TOVLH\\N0g00R1T1e3PO`JL]1`0mNCL2KJV10UOU1T5lN`JO00_1f0gN2<[OKNDOO05V1`5jN]K4nNM4h0M50RO9jI>McN4X16XOo5?kIBL_ONa0a0I^O37D9;Q6?gID4Kb0FXO7f0JTOOo6e0YIJ5BC3]1Mf65mG00L97X:FhE8Z:GfE2B1`Pf04`oYOI;O3On6d1dH\\N:221J?0C5Ln6OgHf1:ZN35DK1Q15WOm6HlHf17^N45Eh06[Oj6DPI10e10ZN4734If00@Q7_OoH10g13eNNOOX1Q7\\NoH11g1OgN0N0X1P7^NPIf10l0P7YOPIg0P7YOPIg0P7YOPIg0P7o1100O1000000N2N2001ON2001ON20hHdK10P7c401O001O1O00O11O00002N2NO[IVK_6l4_IUK`6l4_IUK`6l4_ITKa6l4_ITKa6l4_ITKa6m4^ITKe0NT5n4XJUK>MB0h5o4WJSK`0NA10Oc5U5jJmJB00Nd5U5jJUKV5k4jJUKV5k4jJVKU5j4jJWKV5W4]JmKZ4d2PMlLhN>Y4d2mM[MT2c2PNQMnL0NOW5P3^3O1000000O10000000000001ZGQMb8S3O001O001O0000O1006JO1O1O1003M1O2N0000000000000000001O00000000000000000kGbLQ8^3mGgLP8c3M2N00000000000000000000L4N2", "size": [375, 500]}, "area": 48613.0, "iscrowd": 0, "image_id": 10420, "bbox": [0.0, 0.0, 500.0, 212.0], "category_id": 181, "id": 10012743}, {"segmentation": {"counts": "0;Z1h8n2XGmMl7T2THZO^6f0aIi0S5UOmJZ2c3gM]Lg3T2ZLkMQ5k0oJUOQ5k0oJUOR5k0mJTOT5k0mJUOS5l0eFmNU47W5m0iJROX5n0hJROY5n0fJROZ5m0gJROZ5l0hJTOY5l0fJTOZ5j0hJUOY5k0gJUOZ5k0eJUO[5m0cJRO^5P1`JPOa5n0`JQOa5o0_JQOb5o0]JQOc5o0]JPOe5o0[JQOe5o0[JQOf5n0ZJQOh5n0XJROh5n0XJROi5m0WJSOi5l0XJTOi5k0WJUOi5k0WJUOj5j0VJVOj5j0VJVOk5i0UJWOk5i0UJWOl5g0UJYOk5g0UJYOl5f0TJZOl5f0TJZOm5e0SJ[Om5d0Y4O001O1N101O001O001O001N0100O100O10O01O100O10O0100O10O0100O010O10O1O11O0O10O2O2M101I^ALd>N]A1`X33WVMLXA4g>4M200]AG^>;aAE_>;aAE^>`0N100O100O100O100O010O10O0010O2OO0001O1O0O100000000000002N1O1O001O1O1O2N0010O11WBmNd=R1[BoNe=Q1ZBPOf=U100^BjNZ=V1bBiN02_=T1aBjNO3`=S1`BPO`=X1001O00000000XGcNn3\\1RLdNn3\\1RLdNn3\\1RLdNn3\\1RLdNm3]1SLcNl3^1TLbNl3]1ULcNj3]1WLcNi3V1^GlNj4Ng3W1aGiNh40g3X1^LhNa3V1bLkN\\3V1dLjN\\3U1eLkNZ3W1eLiN[3W1eLiNZ3W1gLiNX3X1hLhNX3X1hLhNW3Y1iLgNW3X1jLhNU3Y1kLgNT3Z1lLfNT3[1kLfNS3[1mLeNS3Z1nLfNQ3[1oLeNP3W1kGiNU50P3X1TMhNk2Z1TMfNl2Z1TMfNk2[1UMeNk2]1SMcNl2^1TMbNk2^1VMcNi2]1WMcNh2_1WMaNi2`1VM`Ni2`1XM`Ng2b1XM^Nh2b1XM^Ng2b1ZM_Ne2a1[M_Nd2a1]M_Nb2b1^M_Na2a1_M_N`2b1`M_N_2`1bM`N]2`1dM`N[2a1eM`NZ2a1eM_NZ2`1hMaNW2`1hM`NW2`1jM`NU2b1jM_NU2a1kM_NT2b1lM_NS2a1dHUNV5:U2f1jMZNV2g1iMZNU2g1kMYNT2j1jMWNU2i1hHkMQ5k0oAVOg6Oa0i0CWO=i0n6O0010lAYOMOV60jI14OY7h0fH\\Om5LRJ6NL]7g0eH]Oj5LUJ8^7`0aH^O_5IhJ?X7e0mMPOhJ;]7f0hMQOjJ9^7h0fMC\\2T6f0lIZOU6g0iIYOW6g0iIYOW6i0gIWOY6j0fIVO[6i0eIWO[6i0eIVO\\6j0WFiNZ3=_6m0aISO`6m0_ISOa6Q1[IoNe6Q1[IoNe6Q1[IoNf6P1ZIoNg6Q1YIoNg6Q1YIoNg6R1XInNh6R1XInNi6R1VInNj6R1VInNj6S1UIlNl6T1TIlNm6T1RIlNn6T1RIlNn6U1QIkNo6U1QIkNP7U1oHkNQ7U1oHkNQ7U1oHjNR7V1nHjNS7T1nHlNR7U1mHkNS7U1mHkNS7U1mHkNS7U1mHkNS7T1nHkNS7U1mHkNT7T1lHlNT7V1jHjNV7W1iHiNW7W1iHiNW7X1hHhNX7W1iHhNX7[1eHeN[7X1hHhNY7W1gHiNY7W1gHiNY7V1hHjNX7V1hHjNX7W1gHhNZ7W1gHiNY7W1gHiNY7V1hHjNY7V1fHjNZ7V1fHjNZ7U1gHkNY7T1hHlNX7T1hHkNY7T1hHlNX7U1gHkNY7R1fEiNQ35Z7Q1fEiNP36Z7Q1iHoNW7P1jHPOV7P1jHoNW7R1hHnNX7Q1iHoNW7Q1iHoNX7P1hHPOX7Q1gHoNY7Q1gHoNY7Q1gHnNZ7Q1gHoNY7P1hHPOX7Q1gHoNY7R1bEjNR34]7S1cHmN]7S1cHmN]7T1bHkN_7U1aHkN_7W1_HiNa7X1`EfNk22e7X1`EgNj21f7\\1`EbNg22j7]1`E`Nd23l7`1TH_Nm7`1TH`Nl7`1TH`Nl7`1TH`Nl7`1TH`Nl7`1TH`Nl7`1TH`Nm7^1THbNl7]1UHbNl7^1THbNl7]1UHcNk7Z1\\EeNj21j7W1\\EhN10i21j7W1\\EhNm21g7W1[HiNf7U1[HkNe7U1[HkNe7U1[HkNe7U1[HkNe7U1[HkNe7U1[HkNe7U1[HkNf7T1ZHlNf7U1YHkNg7U1YHkNg7U1YHkNg7U1YHlNf7U1YHkNg7V1XHjNh7W1WHiNj7Y1SHgNm7Y1SHgNm7[1QHeNo7Z1RHfNn7Y1SHgNm7Y1SHgNm7Y1SHgNm7X1THhNm7W1SHiNm7U1YEiNj22m7T1VHlNj7S1WHmNi7S1WHmNi7Q1YHoNg7P1ZHPOf7m0]HTOc7k0]HUOc7k0]HUOc7k0]HUOc7k0]HUOc7l0\\HTOd7l0\\HTOd7l0\\HTOd7l0\\HTOe7l0ZHTOf7l0ZHTOf7l0ZHTOf7l0ZHTOf7k0[HUOe7k0[HUOe7k0[HUOf7j0ZHVOf7j0ZHVOf7j0ZHWOe7i0[HWOe7h0\\HXOd7h0\\HXOd7h0\\HXOd7h0\\HXOe7g0[HYOe7f0\\HZOd7f0\\HZOd7f0\\HZOb7g0_HYO`7h0`HXO^7i0cHWO\\7i0eHWOY7k0gHUOW7l0jHTOU7l0lHTOR7m0oHSOP7n0PIROn6o0SIROk6n0VIROh6o0YIQOf6P1ZIPOd6Q1]IoNa6R1`InN_6S1aImN]6T1dIlN[6T1fIlNaLN_9X1PJ", "size": [480, 640]}, "area": 32199.0, "iscrowd": 0, "image_id": 10421, "bbox": [0.0, 0.0, 640.0, 394.0], "category_id": 139, "id": 10012744}, {"segmentation": {"counts": "h:X4g:1002NO1O100001OO11hKYEU4i:0001OO1N21ON2001O2N2NO1001O00000000000000O1000000000000O100000000O1000000O100000000000000O10000000000O100000000O1000000O10000O10000O1]OcKbF^4^9bKcF]4\\9dKdF\\4\\9cKeF]4Z9dKeF]4Z9eKeF[4[9gKbFZ4]9gKcFY4]9hK\\FILa4g9gKWFI1f4h9>O100O100O10jJ^Fn4a9QK[FO4P5a9PKcFo4g900RKRFj4o9UKQFk4o9UKQFk4S:O0000000000000000O10000O1O1001OO1O10000O1O1O1O1O1O1O1O11O0000O10000001OO100O11lJXFn4h9QKYFo4g9PKZFP5k900TKTFd4l9XKSF02h4k9XKSFO3i4j9WKYFi4o90000000000000000000000000O1O1IWKVFj4j9XKTFh4m95M300O11O00O1000000O100001O00O100KkJ_FU5b941O00002N00O1001O1OO11O00O100O1000000O1O1001ON21OO11O00000gJ\\FV5h9O1O002N0mJUFQ5n9O000000O1O10000O1O10000N200O10000N2NgJ^FX5b9hJ^FX5b93001ON200000000O100VGcJQ8]5mGeJS8[5jGiJT8X5kGiJU8W5iGkJW8U5gGnJY8Q5fGPKY8Q5eGQKZ8P5eGRK[8m4cGUK\\8l4cGVK\\8j4cGWK]8i4cGWK]8i4dGWKY8k4hGTKX8l4jGSKW8k4jGTKV8l4jGTKW8k4iGVKW8i4hGXKY8g4gGZKW8g4hGZKW8g4iGYKV8h4iGZKT8h4lGXKT8h4lGYKS8g4lGZKT8f4lGZKT8f4kG\\KT8d4lG\\KT8d4kG^KT8b4lG^KS8c4lG^KT8b4lG_KS8a4lG`KV8^4jGcKU8]4jGdKU8]4kGcKU8]4jGeKj0jNa6_5eHgKj0jNb6g6\\IYIe6g6[IYIj6b6UI^Il6c6SI]In6c6PI]IQ7d6nH\\IR7f6kHZIV7h6hHXIX7i6fHWI[7k6cHUI]7l6aHTI_7o6_HQIa7Q7\\HoHe7T7XHlHh7U7100O100O1O100O100O2OO01O101N100O1OOVInGj6R8VIoGg6R8400000O2YIlGMOV60jI14V8OmGm5LRJ6NT82lGj5LUJc8OcG_5IhJU9U5oFhJT9U5nFjJT9T5^1bN^1aN_1bN_1aN^1aN[1fN001N10001N10001N10001N10001N101N101O0O2O001N101O001O001O001O001O1O001O001O001O001O001O001O001O001O00O100O100O100O100O100O100O100O1O100O10O0100O100O100O100O100O100O100O100O1O100O100O100O100O100O100O100O100O100O100O1O100O100O1O1O1O1O1N2O1O1O1O1O1O1O1O1O1O1O1O1O1O100000000001O000000001O0000001O0001O0000000O100O1O100O100O2N100O100O1O100O100O100O2N100O100O1O100O100O1O2O0O100O1O100O2O0O101N1O2O0O101N1O2O0O101N1O2O0O101N1O2O0O101YLcHH^74WHmL=e2]7:XHZM>R2[7>ZHjM=]1Z7e0[HWN:n0\\7f0[HfN7>_7h0\\HSO21b7i0]H@NAg7n0YHJMSOk7R1VH5LeNo7U1SH`0KUNS8Z1QHi1o7WNoGj1S8TNkGn1V8j1kG[JX8e5kGUJW8l5mGmIU8T6<0O100O1O2O0O100O1O100O100O1O101N1O100O100O1O100O10hJgGh3X8XLhGj3V8ULjGm3V8RLjGo3U8PLkGR4U8mKkGT4T8kKlGW4S8iKmGX4S8fKmG\\4R8dKnG]4R8aKnGa4Q8_KoGb4P8]KPHf4o7YKQHh4n7WKRHk4n7TKRHm4m7RKSHo4m7QKSHP5m7nJSHS5m7mJSHT5m7jJSHW5m7iJSHX5l7gJUHY5l7fJSH[5m7dJTH]5l7bJSH_5m7`JTHa5k7_JTHb5m7\\JTHe5l7ZJSHg5o7VJRHj5o7TJQHn5P8PJPHP6Q8nIoGT6R8jInGV6S8hImGZ6T8dIlG\\6W8`IiGa6[81N101N101N1O101N101N101N1O101N101N1O2O0O101N101N1O2O0O101N101N1O2O0O101N101N1O2O0O101N1O2O0O2O0O101N1O2O0O2O0O101N1O2O0O2O0O101N1O2O0O2O0O1O2O001O001O00001O001O001O00001O0000001O0000001O0000001O000000001O0000001O0000001O000000001O0000001O0000001O0000001O000000001O0O10001O0000001N1000001O00000O101O0000001O000O101O0000001O0O1000001O00000O2O0000001O000O101O000000001N1000001O0000001N100000001O000O10000000001O0O1000000000001N100000000000001N1000000000000O2O00000000000O2O00000000000O101O000000000O10001O000000000O10001O0000000000001O0000000000000010O00000000000001O000000000000001O000001O00000001O0000000000001O000000000001O01O00000000000000N2N2O1N2O1N2O1N2N2O2M2O1N2O1N2O1N2WFTK\\9n4aFoNd5l0", "size": [480, 640]}, "area": 183847.0, "iscrowd": 0, "image_id": 10421, "bbox": [0.0, 0.0, 640.0, 350.0], "category_id": 183, "id": 10012746}, {"segmentation": {"counts": "PlZ32nc0001V\\O0M2_c0N20000O11OO10000000000000000000000000000?A009G1OO1000000000000000000O1000000000000001OJ65K002N001OO1001OO1O1O1O100O11O1O00O1O100O1O1O1N2O1M_^OgMaa0X240000O100001O00001O00001O1O002N1O2N1O3M1O2N00O13M00N2N2O1O1O12NL4O10000@b^O^N^a0b1d^OUNN0^a0k1e^OQNM012^a0m1h^OPNK2]a0n1?0000N21O003MM31O2NN2O11O001O1O1O1O2N2N1O1O1ON200O100O1O1O1O11O5KN2O1O1N200001O000000000000O100L40000O100000000000000000000000000", "size": [640, 427]}, "area": 17439.0, "iscrowd": 0, "image_id": 10428, "bbox": [171.0, 0.0, 256.0, 91.0], "category_id": 102, "id": 10012747}, {"segmentation": {"counts": "kXZ256LYc0?N1N31O1O002Lb\\OC_c0=21O000O2e\\OFnb0h0N1JROX]OP1eb0QOY]OR1eb06N3L3L300O1O0100O2O000O]NbNd@`1Z?jN^@V1c?lNZ@S1h?mNi_OIAZ1f`0oNd_O_ODo1h`0cNX_O_ONY2k`0XNW_Ok1i`0UNV_Ol1j`0d0100O001N2O1O1N2O2N2iMj^O`1Xa0_Nk^OM1CK13Q1Xa0XOo^OO;c0g`0^OP_OL?`0b`0DQ_OI?`0b`0FQ_OJ=>c`0HR_OH==b`0JU@0P`00Q@HV`07j10000005K001O01O1O1O010O1O00100O001O1O010O1O001LYQ^4", "size": [640, 427]}, "area": 3149.0, "iscrowd": 0, "image_id": 10428, "bbox": [118.0, 458.0, 81.0, 107.0], "category_id": 132, "id": 10012748}, {"segmentation": {"counts": "n11Y1_2d3QOeK5l6_NiI[2e3ROfK3k6\\NdH5U1Y2h3ROeK2g6jNjIS2j3QOeK2d6oNjIo1l3ROdK0g6POhIn1m3ROeKOf6QOiIm1l3SOeKOg6POhIn1k3TOeK0j6iNhIS2i3TOeKOP7aNfI\\2e3TOeKOo6bNhIZ2d3UOfKNS5iNgK0IU2g3TOeKNU5QOlJ=?a1k3SOeKNU5ROiJa0`0Z1m3VOfKNR5QOlJ?`0\\1l3VOfKNR5POlJ`0a0\\1k3VOeKOS5QOiJ?d0[1k3VOeK0R5TOeJ=g0Y1e3cMbKd1:1R5VOaJf3c4gM]KOn4[3DROS1SKeJ=G@K30N0f2g4Z2m4\\KVKd4S:00000001O1O0000O10000006J000WKl@f4T?YKm@00d4R?]KPAd4V?000O11O0000\\O\\KkAe4S>]KnAb4Q>`KnA`4Q>bKnA^4R>cK_AH9h4NXKI031l=>UB_4L\\Kn=6UBj4k=VKUBl4i=UKVBk4k=f0O0O100O100O10000O12N1O2N1012M4M1NO0000O2O001N100O10O11_BdIf<1kCd6P<]InCf6o;]ImCe6R<^IlCe6Q<]IkCh6QSD`0_OJb0D1e0BPOLMZ=`0VC?_OQOO02a0b0M0e0Y=^OcB=N]O91Nb0^=B_B2]OFa0193Kd0Z=PORBa0a0KEK;M<8Gd0Z=QOQB`0a01B@NNb01?;Be0[=BbBMd1IaNf0Y=EcBMd1EaNg0\\=E_BNd1GaNf0]=G[BJb2f0R;@\\BK_2h0V;ZO]BNc2a0R;DaB]Oa2P1n:AcB^OZ2U1S;]OkE7VLWOS>>jE6c:BZAMX4OhKO05f>LYA21MX41iKN41Zc0O[_d4", "size": [640, 427]}, "area": 64087.0, "iscrowd": 0, "image_id": 10428, "bbox": [0.0, 0.0, 189.0, 491.0], "category_id": 133, "id": 10012749}, {"segmentation": {"counts": "VoW41oc04S\\O2_c09N100O1B?0O1OO2M2_^OnNV`0Q1i_OPOV`0P3KH[O=N8OMO110N1001O1OO2O000O11O1O0nL^_Of2a`0RMi_Om2e`0O1000000O101O]OUMQ@T2A^N``0]OP@l14VNh`0^OO2B\\OX`0^1V@TOO>GPOd?b1c@PO1m0S?9g@jN5o0R?T1k@nNT?]3B00000O100000000001O1O0000O10000006J000WKl@f4T?YKm@00d4R?]KPAd4V?000O11O0000\\O\\KkAe4S>]KnAb4Q>`KnA`4Q>bKnA^4R>cK_AH9h4W>gKdAZ4[>gKdAZ4[>fKeA[4Z>fKeA[4[>e000O100O100O10000O12N1O2N1O2N1O2N1O0000O10000O100O1000_N^AdMl=bNgBi3_OdMj=dNeBh3BdMh=gNbBf3GcMf=jNaBa3KeMd=lN]B`30dMb=nN\\B^34cM`=QOYB\\38cM^=TOXBX3;dM]=n2dBRM[=n2fBRMZ=l2hBTMW=l2kBSMT=m2mBSMS=l2nBTMQ=l2PCTMP=k2QCUMnQDYO=h2o2aMc8>QDXO>i2n2aMU7FiFh0XOQ2k2`MT7HhFg0YOQ2k2`MS7IhFg0ZOP2k2`MS7KfFi0XOl1o2`MP7OhFf0XOk1P3`Mo62fFd0WOQOIi2U3eMX7LaFe0YOo1d2jM`7F`Fb0\\On1Y2UNh7_O]F]O\\OR15m1P2_NW8QOVFi0Cg1f1iNa8hNSFj0Fe1[1TOl8^NPFl0Hc1Q1]OQ9]NQFe0HaN0R3k0E\\9UNmEe0L`NOR3a0Ni9dMjE[OK21NOc11b147Y:UMhEBN`1MU5`:eIfEEN\\8]:nGfEEM]8^:iGiEJI]8\\:gGoEKF^8[;O00000000000000000000000000000000000SHcDW7TbM\\AjNL_3g>hM]AgN1^3a>oMcAQ2`>lM`AT2`>hMeAW2[>gMgAY2Y>gMgAY2Y>gMgAY2Y>gMgAY2Y>gMgAY2Y>gMgAY2Z>fMfAZ2Y>gMgAY2W>iMiAW2V>jMjAV2X>hMhAX2X>hMhAX2W>iMiAW2", "size": [640, 427]}, "area": 67583.0, "iscrowd": 0, "image_id": 10428, "bbox": [0.0, 330.0, 427.0, 310.0], "category_id": 165, "id": 10012751}, {"segmentation": {"counts": "Yio42fc0d0oN:;1O001O000009G;E4L2N1O000O10000000000000000001O000000000000001O000000O10O0100O01O10000KK^\\O6ac050000LCe\\O=[c0Cd\\O>[c0400004L1O0L`\\OI_c07501O00001O0KY\\O0hc00Y\\OOlc0000kbP2", "size": [640, 427]}, "area": 796.0, "iscrowd": 0, "image_id": 10428, "bbox": [255.0, 396.0, 68.0, 43.0], "category_id": 167, "id": 10012752}, {"segmentation": {"counts": "_jc11nc01O2N1N2O1O1O1O2N1O1N2O1O1O1O2N1O1O1O1N2O2N1O1O1O1O1O2N1N2O1O1O1O2N1O1O1O1N2O1O2N1O1MZNk]Og1Ub021O01O0>B1O1O2N101N1O1O000001N100O10000O101O0O10000O101O0O100O1O1N3N1O1N2O1O1jMZNPBh1o=[Ng@O;h1h>_Nm@M5e1n>`Nk@01a1T?aNi@O0b1V?aNi@NOb1X?bNg@NNa1Z?dNf@LJf1_?_Nf@LCl1o>PNXA96[2`>^MZA76[2_>_M[A66[2]>aMbA00_2]>bMcAO0`2\\>aMdAO1_2Z>cMfANO_2[>cMfANO_2Z>eMfAL0_2P>PNoAA1_2o=QNPBA0_2d=\\N\\BTO0`2d=]N[BSO1`2d=]N[BSO1`2d=^NZBRO2`2e=^NYBQO2a2e=^NYBQO2a2e=_NXBPO4a2c=`NXBoN5a2d=`NVBoN6a2d=RMPBW17UO5b2d=QMYBQ1M\\O6b2e=PM^Bm0FA7b2e=oL`Bm0DB7c2d=lLdBo0]OE;`2[>aNeA_1\\>`NdA`1]>_NcAa1^>]NcAc1^>[NdAe1\\>ZMWA=>Y2n>eMSA[2m>dMTA\\2m>cMSA]2m>bMTA^2m>`MTAa2l>]MUAc2k>\\MVAd2k>ZMVAf2j>XMXAh2i>mLaAS3g?O01O00000000001O00000001O01O0000000000001O000001O0001O0000000nJiL[IW3\\6RMdIo2Y6SMgIm2X6TMhIl2X6TMhIl2W6UMiIk2W6VMiIi2W6WMiIj2V6WMiIi2V6XMjIh2V6YMiIg2W6]MeIc2Z6`MQEXO\\4X3c6bMmDYO_4U3c6jM\\IW2b6kM]IU2c6mM[IS2d6oMVEiNl3X3n6PNSEkN74T3P3a7SNREjN7`0k2c2l7\\NWEVOi2_2n7@PH`0P8AoG?P8BPH>P8BPH>o7CQH=o7CQH>m7CSH=m7CSH=m7CSH=m7CTHm7ASH?n7@RH`0n7@RH`0o7_OQHa0P8^OPHc0P8\\OPHd0P8\\OPHd0P8\\OQHc0o7]OQHc0P8\\OPHd0o7]OQHd0n7[OSHe0m7[OSHe0m7[OSHe0m7ZOTHf0l7ZOTHf0m7XOTHi0k7WOUHi0l7hNTEVNQ3R3k7bN`EVNf2W3k7UNUIk1k6SNWIm1i6SNWIm1i6RNXIo1h6oMYIQ2g6oMYIQ2h6mMYIS2h6lMXIT2h6lMXIT2j6iMWIX2j6fMVIZ2k6eMVIP2V7mMkHi1a7UN_Ha1l7XNlCZOY4S2W8`NPHV1[8hNfGm0g8oN\\Gf0P9UOTG`0X9[OlF9e>DmSQ2", "size": [640, 427]}, "area": 24870.0, "iscrowd": 0, "image_id": 10428, "bbox": [82.0, 329.0, 240.0, 300.0], "category_id": 183, "id": 10012753}, {"segmentation": {"counts": "^]h55i>3O1O1N;E3M2O3M2VBXOX=h0gB\\OV=h0dB\\OZ=U1eB^NX=b1hB^NY=`1hBaNW=d11O001O00001O0O101O00N2L4KYNnBe1S=122101O0000001O00O1O10O1O2L3010O1oB]NcCcA=]>CcA=]>CcA=]>CbA>`>1O1N10101M12N000N2001O1OO10O1001O001O003C_A4g>10M2KWA2l>Ne\\b1", "size": [480, 640]}, "area": 5635.0, "iscrowd": 0, "image_id": 10430, "bbox": [393.0, 184.0, 139.0, 75.0], "category_id": 96, "id": 10012754}, {"segmentation": {"counts": "0Z3f;1O000000000000000000001O1ON200000000001O000000001O00O100001O00001O001O1O001O001O00001O00001O1O1O0000001O0000001O00001O000000000000O10000O100O100000000001O0000000000O1001O00000iDZLT;f3lDZLT;g3kDYLU;i30O1001O001O1O2NO11O00001ONPETLP;l3200001O0000000000001O0000000000O100O100O10000O10000O100000000O100000000000000001O00O11O001O00jLlD`2T;`MlD`2T;`MmD`2R;aMmD_2S;aMmDK0R2S;SNnDJOS2S;PNQEMMR2R;QNQENLR2k;aMbDOC80g1R`5oMlnJ?ZABl=?PBT1LkNa0F_OKY;`0jDg2o:YMPEh2P;XMoDi2Q;VMoDk2Q;TMPEl2P;TMoDn2P;QMPEP3P;PMoDQ3Q;?000001O000000001O0000001O00000000001O0000001O00001O0000001O000000001O00001O0000001O0000000000001O001O00001O00001O1O001O00001O0000001O00001O1O001O00_NdE^N\\:b1dE_N[:a1eE_N[:[1eEYM0]1Z:Z1fEYM0]1Z:Z1gEVM2^1X:]1eEVM2d0O0Z:V2gETMOc00_O0c0Z:W2jETML51K123c0U:X2iESMM1e0b0f9Z2eFeM[9\\2hF_MY9`2iF`MV9_2gFeMY9\\2gFTMmN<\\:V2o1I71O001O00:iCZMG8e0Mj9c2gEeMM`0V:k1mEeMM`0V:k1mEeMLa0W:k1lEcMNc0U:k1lEbM0b0T:l1lEaMNDNo0X:m1kEaMNe0W:k1iEhNV:X1jEhNV:X1jEhNV:X1jEiNU:W1kEiNU:W1jEjNV:Q3O00001O001O00001O00001O0000001O00001O00001O000000001O00000000001O0000001O00001O001O001O000000001O000000O100001O1O1O00001ON21O1ON200O1O12NN22N1O1O001O1O00002N00001O00000000001O000000001O1O00001O0000001O00001O0000001O0000001O0000001O00001O000000001O000000001O0000001O0000001O00O1O100001O001O0000M30000000000000000000000O100000000001O3MJ600;E2N1O0000O1000000000000000000001O0000O100O11O0000000VGlIh8V60N2N23M1O1O001O00O1001OK50UGoIg8V6OO11O1O0000000000000000001OO10000000000O100000000K55K1O00001O00000000000000O11O00000000O1000000O10000O100O10000O10000O10000O10000O1000000001O1O001OMWGnIj8R620000001O00L4000000000000001ON2O100000000003M2N00O11O00O100000000O1000000O1000000HQG_Jo8R5WGnJKJO10OP9W5YGmJJLP9W5XGjJn8V5>0000N200001O00001O0000000000000000", "size": [480, 640]}, "area": 98825.0, "iscrowd": 0, "image_id": 10430, "bbox": [0.0, 0.0, 640.0, 203.0], "category_id": 106, "id": 10012755}, {"segmentation": {"counts": "e8[6e8fI]GW6c8iI]GW6e811O00000000000000O10000O11O000000000000000000000000000000O1000000000000O10000N2O100001O2N00000000000000O100N22N0000000000000000000000001O00O100O100N2O100001O00000000000000O1001OO11O0000O10000O1O1O1002N1O1O0000002NO12N00O1000000000000O11O00O11O0000O100McIbG^6]83000000O10000001OO100N20000O1M300000000000000000000000000000000O100000000O1000000O100O100O11O001O001O0000O10000O1000000O1000000O100002N001O00O100O10000000000O1000000O11O001O1O1O0000O10000000000O11OO10000O11O1BnGaI2000O0R8]6`0M100O1O1O1O1O10O1002N00O1O1002N00N2OO2L4LSGTJk8o5UGPJi8R6202O0O1O1O10000O1O10000O1O100O3M2N2N2N2O2L2000O0100O1O01O02O0O00002O0O00104KN33MO0M40lJWFP5m9ON3003MN0114K00N21RKPFk4T:O0ON24K20L3100O1O5LM]KhEd4W:33MN\\KhEd4W:33LO]KgEd4W:LmEaKV:\\4kEdKQ:^4PFbKm9`4;N2N10000O1O100O1O100O1O002O000O2OO02N011N0010O01O1O200N01O11M3O0O1O1O1O1O1O10000N200O2OO0101N00100ONbLdD^3Z;dLeD\\3[;50O1O100O11OO11O000N2K6O010ON1HjDaL13[;V3hDhL];T3eDkL];R39nLUDn2l;RMTDn2k;SMVDk2P<0000O1O10000O0101O00M3N2O1N2O10O02N010O100`MbC]2_f0Da00010O02M21O001O00000001O01O000001O1O0O2O2M100001M20O200OO101O00001O00000O20NO100O10100000000000000N22N00O101N100001O1O002N1O00000001O00000O1NjN[BU1e=4O01O001\\OYBLi=2\\B_OK6l=9]BFd=MWB35OP>LTBOR>0cdo0", "size": [480, 640]}, "area": 84422.0, "iscrowd": 0, "image_id": 10430, "bbox": [0.0, 235.0, 572.0, 245.0], "category_id": 113, "id": 10012756}, {"segmentation": {"counts": "Z3T3m;N1000000000000O1000001O1ON20O1000000010O2N6J4L01O00O1000YMdD]O4Q2W;`NUE_1k:_NWEb1h:[N_DCj0R2h:YN_DEk0P2f:ZN`DFj0P2g:XN^Eh1c:WN]Eh1d:WN^Ef1e:VN_Ef1jNXNg;0aEe1gN[N20P=f1RCZNm<[1oBnN5Gkg;h1nCYNQ<[200000010O000001O000000000LlC[MV?1O0000010O01O010O00001O01O01O00N2L5J]AJf>2QkP1NZfnN0h>6L5HEdA?Y>7LO310OK50VOnAe0X>OfA]OV>d0jA\\OW>c0iA]OX>b0hA^OX>b0hA]OY>e0000O1001OO12N01OO1000000000O0101O00O1OL46J2N1O101N1O100001O001O0O020O1O00000O101OO10O0100O0010O01000O101O0O2O000O101O0O100000N2N3M3M2O2NNF_A;a>02000010O01K401O1O0000000001NO2O01O10000O112N1OO1N200O0O3N1O1O1O0O100000O0100000OIYOWBf0i=[OQBO10Og0o=\\OQBa0T>60ZOmA=\\>O1O1JaAH1O]>4bANe>16NWo4", "size": [480, 640]}, "area": 22291.0, "iscrowd": 0, "image_id": 10430, "bbox": [0.0, 106.0, 629.0, 119.0], "category_id": 135, "id": 10012757}, {"segmentation": {"counts": "cT^3112000Ob>VOoAk0P>3O100O1O1O10000O1O10000O1O100O1O1O1O1O100N20000O100O1O100O100O1O1O100O1O100O10000O100O1O1000000N200O1O1O1O100O1O1N200O100O1O1000000000000O11OImMaCS2_0WA02OX>0cA323NJ1000U>f0jAZOV>h000002NhAZOW>g0NYOkAg0U>OlAZOS>g04O2M02O00O011N10fA]OT>g0kAYOl=1[Bg0f=ZOWBg0j=ZOSBg0o=XOQBg0o=5O13MM3M3J62N2N2NN200N2O11MXBlNi=R1XBnNg=T1XBlNg=T1lF", "size": [480, 640]}, "area": 1167.0, "iscrowd": 0, "image_id": 10430, "bbox": [598.0, 294.0, 42.0, 43.0], "category_id": 142, "id": 10012759}, {"segmentation": {"counts": "^6W2h<1YCjMdWOoAk0n=VORBj0m=500O2L4M20O1O1O2O000O2O1N2O0O1O1O2L3H8J6M4N1N2N3N1000RiY11gQfNO]K3lJOa9NbK9]4H]K=d4B]K>b4BPG0l3>T5CoFOS20VO>e7FRGMR20VO>FA`64cHLR21oN0aN>;C>OYOOP7h0oHEOC80g14[NLd01RO`05_OJ9OG10O1002O1?l6c3UInKM6m0KSOZ2m6h1UIVLa0GC2I_2i6Q2gIcKEMK_2i6R2dIiKCY2i6R2WIYK200T3g6Q50O1000000O2O?VHfHo6\\7mHWJLkNa0F_OK\\4]7gKjKd0SMU1I`N8DE2a70gKd0TMT1HcN8DV70gKd0UMS1GeNk7DZKc0VMS1G^NJLP81YK1hL9`04^Oc09mNP81SK1nL28:@d0b8oNiJ0gM6UO?f8ZO_J1gMOkN0=d0T<]OUEa0ZN^Oa<1UEa0m:_OTE0YN=k>ElfP1MWYoN000J0\\A0d>0\\A0d>1YA2g>MZA2d0OY=1QBOc00_O0l=4RBL51K123m=NQBM1e0m=;03K2NM50UBmNh10WN0a;d1iEbNiNLW;j1PFYNiNMX;h1oEcNQ:^1nEbNS:]1mEcNS:^1mEaN]:M\\DG8e0R1G\\:JgDMc15f9NgDMc15f9NgDLd16f9MeDNe15g9LdD0e13g9McDNDNS25h9NbDNi14f9LmF3S9MnF2R9NnF2R9NnFOVM0l;1P3ORQS5", "size": [480, 640]}, "area": 7494.0, "iscrowd": 0, "image_id": 10430, "bbox": [0.0, 0.0, 292.0, 280.0], "category_id": 164, "id": 10012760}, {"segmentation": {"counts": "\\U`0110f>9CIiA=U>8MZOlAf0Q>YOoA20d0R>^OnA`0h=\\OaB5G?c=^O]B07j0\\=ZOcBi0Z=[O`Bh0`=01O0O1000000O2O001O000IdAFa>84M4Ki[29UdMOON11O0O1I8A@\\B`0c=DYB=f=GWB8i=ITBFOc0l=GTB=j=?M2N2N2N2N1001O001O00001O0QO`B>b=\\O\\BJ9OG10O1002O1\\P70^^I1O102\\AJY>8bAN[><000000000010O00000010O000000000O100000L_OhAb0V=A[CMAOOi0T=_OkBH3041KONj0U=GmB_OOQ1T=BkB^O1o0T=FlB;R=j000000000001O0000001]Ob0OO22M7mNTBNM10a0\\>01O00000001O0O10001O0O012SB^OX=b0]BZON119c==]BJb=k000O00000001O000O2N110N10000\\OZBNf=_OYB`03NMBn>00000Zfb41eY]K1M2N3M2N2O2N2O0N200010O001O001O10ON2M`AFP`70jnH0UA100h>8K5K3N2N100nA\\Oh=g0TBZO00e=f0ZBZOOON6d=b0_BEa=<`B@b=`0\\BAe=`0ZBBc=o0N2RCdNh:5jEW1]OfN]OM02T;7jEZ1EgN`:1iEZ1CgNd:1QED=j1_OVN8=i:6_E_1C\\Nn:5^EU2_:mM[EZOH1Oi2m:kMWE[ONS3j:aMWEf2i:YMUEe2o:h0N2O1NN200N2O11O1OO1OiJ", "size": [480, 640]}, "area": 10650.0, "iscrowd": 0, "image_id": 10430, "bbox": [34.0, 166.0, 606.0, 134.0], "category_id": 169, "id": 10012761}, {"segmentation": {"counts": "XZf3X1d=40000000O10O10000000000000000000O1000O1000000000000000O100000O10000000000O010O100O1000000000O1000000000f0ZO^X33_gL?AO2O00000000001O00000O1F;AVX4OdgKe000000000001O0O101N101N101N101N1O2N2NOaAC^>:WOFVC;kb05N011N1NbAB^>=32jAAi=a0RB@n=b0lA]O120Oo=h0QBYO4Oc=h0YBYO22c=l0[BUOf=R1N2000001O00N2O2E\\BWOe=g0\\BYOe=;VBG9Mc=9fBG\\=5eBL\\=4dBK^=NPB0d01W>0]P=", "size": [480, 640]}, "area": 1732.0, "iscrowd": 0, "image_id": 10432, "bbox": [541.0, 86.0, 71.0, 55.0], "category_id": 100, "id": 10012763}, {"segmentation": {"counts": "o5Z1[3R3d2iKYJ3T4h3c1TLZJ4S4h3c1SL[J5R4h3c1RL\\J6Q4h3Q2WLoMi3R2VLnMj3R2VLnMm2ZLTMh5OnMi2aLUMa53mMo1^MkMe46mMh1T4XNkKe1Y4\\NfKa1]4_NbKa1^4aNaK]1`4dN_KZ1d4gN[KV1g4kNXKU1h4mNWKQ1i4ROUKn0h4WOVKj0i4XOUKh0l4YORKg0o4[OnJf0R5[OlJe0U5]OhJc0X5AdJ>^5B`JnGDS8;lGEV8:iGGX89fGG\\89bGH_88_GHc89[GGf89XGGj89TGHm88RGGQ97nFIV94jFKc9I]F6d9J\\F5e9K[F3g9MXF3i9MWF1k9OUFNn91SFKQ:4PFKQ:3RFNl9OWF3g9LZF5e9K[F7^2lMD1d1k1ZL:W2SNENg1e1]L;Q2ZNGHj1c1^L=j1`NIDm1_1_L?e1fNK^OP2]1`L`0^1nNOUOS2^1^La0Z1TO1oNV2\\1_Lb0T1\\O2hNZ2[1^Lb0P1D5_N]2[1^Lc0j0J8ZN_2Y1^Le0e0M>UN_2Y1]Lf0e0M?TN_2Y1]Lf0d0N`0SN_2Y1\\Lh0c0Mb0RN_2Y1[Li0c0Mc0QN_2Y1[Li0b0Nd0PN_2Y1[Li0`00f0nM_2Z1ZLh0`01g0mM_2Z1ZLh0`01g0mM_2[1YLg0a01g0mM_2\\1XLf0b01g0mM_2]1WLd0d02f0mM_2]1VLe0e01f0mM_2Z4mLiMd0mM_2Y4nLkMb0lM`2Y4nLkMb0lM`2[4lLjMc0kMa2\\4iLkMf0iMa2]4fLmMh0fMb2^4dLnMi0dMc2_4aLoMl0bMc2_4_LRNm0_Md2`4]LRNn0_Me2_4[LUNo0\\Mf2_4YLWNP1[Mg2^4XLYNP1YMh2^4VL\\NQ1VMi2W8WMiGi2X8VMhGj2X8VMhGj2W8VMiGk2W8UMiGk2W8UMhGl2W8UMiGk2W8UMiGk2W8UMhGl2W8TMjGl2V8TMjGl2U8UMmGi2S8WMnGQOXO[3j8cM^HZ2a7fMaHY2_7gMcHW2]7hMeHW2Z7iMgHW2Y7iMiHU2V7kMlHT2T7lMnHR2Q7nMQIQ2\\3oLVNQ1^NP2\\3QMTNo0cNm1Y3VMQNl0iNm1V3XMPNj0mNl1S3\\MmMg0SOl1o2`MlMc0WOl1l2dMjM`0\\Ok1i2gMjM<@l1e2kMhM9Ek1Y2\\MYKb0g27Ij1X2WNoMNKj1W2XNlMOOg1V2YNkMO1g1T2[NiMN6e1R2kNWKfNi1j0o0d1R2jNXKhNf1i0S1c1P2jNYMCk0_1l1lN[MEl0\\1j1mN[MFm0\\1i1lN[MHn0Z1h1lN[MJn0Y1h1jN\\MMl0Y1i1hN\\MOl0X1i1gN\\M1l0W1i1fN\\M3k0W1i1dN_M4i0W1i1cN_M6h0W1j1aN_M8g0W1j1`N`M9f0W1k1]NaMd0V1k1[NbM?c0V1l1YNaMb0c0U1l1WNcMd0a0U1m1UNbMg0a0T1m1TNcMh0`0T1Q5lNoJU1Q5kNoJU1P5kNPKV1P5jNoJW1P5iNPKX1P5hNoJY1P5gNRKX1n4hNRKX1eNnMQ4i0\\MX1cNRNn3f0aMV1aNXNj3a0hMU1^N^Nf3=oMR1[NdNc3:TNP1YNgNb39XNm0UNkNc37[Nl0RNlNd38[Nk0RNkNd3:\\Ni0QNkNd3<\\Nh0QNkNc3=^Nf0oMlNd3>^Ne0nMlNe3?_Nc0lMnNe3?`Nb0kMnNf3`0aN`0iMPOf3`0cN>gMQOg3a0cN=fMQOh3b0dN;dMSOh3b0dN;dMROi3c0cN;dMROi3c0dN:bMSOl3b0bN;aMTOm3a0bN;_MUOP4`0aN;ZMYOV4<`N;[MXOU4=aN:\\MVOT4`0`N:^MSOS4c0_N:_MQOS4d0_N;_MPOR4c0aN=h3AXL`0h3^OZLb0f3]O\\Lb0d3]O_La0a3^OcL?]3@eL?[3@hL>X3AjL>W3@kL?U3@lL`0T3_OnL`0R3@oL?Q3_OQMa0o2^OSMa0m2^OTMb0l2^OTMb0l2]OUMc0d80000000000000O1nM\\OhEd0X:F]E;c:E\\Ef:BYE?f:BXE`0h:@hDJWOi0P<_OhDn0W;SOiDm0V;UOiDk0V;WOiDi0V;YOhDh0V;[OiDe0V;]OhDd0Z;[OdDf0^;YO`Dh0b;WO\\Dj0g;TOWDm0k;SOQDo0Q=23J41N2O1O1O1O1N101O1N2O001O001O001O0O2N100O100O0100O0N300001N2NR_g1", "size": [480, 640]}, "area": 51708.0, "iscrowd": 0, "image_id": 10432, "bbox": [0.0, 64.0, 521.0, 416.0], "category_id": 104, "id": 10012764}, {"segmentation": {"counts": "\\hc82n>0O1O3DMeA5\\>JbA9^>F`A>^>20O1000001O00N101FDoA=o=DQB=j=GUB;i=FWB;i=CXB=j=BUB?k=@TBb0l=]OTBd0l=7100000001@QBMo=0UBOk=LZB3j=GYB9W>01N10000M[AKe>45O000O101O1O0Oke2", "size": [480, 640]}, "area": 775.0, "iscrowd": 0, "image_id": 10432, "bbox": [588.0, 109.0, 46.0, 38.0], "category_id": 114, "id": 10012765}, {"segmentation": {"counts": "a\\W81o>2N3M3M3ZBF`<;^CFb<0O101O010O001O001O00100N2O100N2O01NLEdA<]>120L6L01003M0100000N2O100O10O11OO2OO10N3N120M0110OZOjAa0\\>0O0000002OO00000O20ON201B`A80Gd>8\\AHd>8\\AHd>8\\AHf>66J_Z`0", "size": [480, 640]}, "area": 1079.0, "iscrowd": 0, "image_id": 10432, "bbox": [541.0, 62.0, 64.0, 31.0], "category_id": 121, "id": 10012767}, {"segmentation": {"counts": "[YT81k>6M10001O0O2N12NN3O001N1O2O0O100000000N2D]OZBd0b=]OVB1OO5a0g=`000O1O12MMPOXBP1h=4O10O01NjNZBR11oNd=T1\\BlNf=:YB:2\\Oi=5VB>R>\\OmA120O51NY>MgA41MZ>OeA23M`>1^`d0", "size": [480, 640]}, "area": 868.0, "iscrowd": 0, "image_id": 10432, "bbox": [555.0, 102.0, 41.0, 45.0], "category_id": 142, "id": 10012768}, {"segmentation": {"counts": "bc^82n>001O001N101O001N2O1O1O1O1O2N10101M4K8I000000000O10000000000O10001O0O2O001O001O001N2O1O1N2O2N1XCcNh;O`C`1d0dNj;c1PDaNo;c1iCcNU0PU50PkJ1O1O1O2N4L1O00001O1O2NN2O1O1O1O1O1O100O1O100O10000O100000000000000000000000000O1O10Pc[1:RncNFb>`0L1O00001O000000001O0oA]Oe=Q1N2N1O1gBPO`NOO3M4LVW;", "size": [480, 640]}, "area": 9935.0, "iscrowd": 0, "image_id": 10432, "bbox": [267.0, 0.0, 349.0, 83.0], "category_id": 156, "id": 10012770}, {"segmentation": {"counts": "Paa63m>3M001O0XAKe>5[ALd>7100001O00000000000000000000000000001O5K000000000000000000001O001O001OO1000000N2000000O100N21O00002N1O1O00000000N23MO11OO1O11O00O1O1O100001O1O1O1O1O00001ON2N23MO100001O1O0000000000N2N2O12NO1001OO1O1O11ON2O1O100004L2N00N2O11bAAY>b01001O2N00000000O1O100000000001O1O1O000000000000O1O100O100O1N2N200000[CA_N0o;?^EFbNKP[EMcNFQ;F6K5K5K4M3M2N3M2N2O2M2N2O0O2O1O1O1O1N2O1O004L3N1N2N1O2VFlMc6V2VISNg6n1SIZNj6h1oH`Nm6b1mHfNP7[1iHnNS7S1hHUOU7l0eH]OV7e0cHDZ7=`HJ]78]HMb74]HMc73\\HNc73\\HNc73\\HNd72[HOe71YH1g7OXH2h7NXH2h7NXH2h7NXH2h7NXH2g7M[H3e7K]H5c7K]H5c7L\\H5d7K[H6d7LXH6h7KUH8j7ITH8m7GQH_2`N`LS1Q1>]2`NbLb0DeM_10POZ2Y3@cLQ1T1SM^OR2h2KeLe0a1\\M_Oj1Y26gLP1U1nL0k1R2dNkL>NU2U1mL4i1m1dNSM?HU2T1mL9h1h1dNXM`0DV2S1lL?f1a1fN^M`0AV2Q1lLd0e1\\1fNdM`0]OW2o0mLh0d1V1gNjM?ZOX2Z3_NAiNPN>VOX2\\3^N^OkNRN>VOX2\\3\\N[OnNUN=UOX2^3ZNXOPOWN=UOW2_3ZNSORO[N=TOU2a3YNoNTO_N=ROU2c3VNoNUO^N?QOU2e3SNl0H_KU2h3PNj0J_KU2l3kMg0O]KV2]4ZM7?]KW2n9gMSFY2n9fMSFY2n9fMRFZ2o9dMSF[2n9dMRF\\2o9^MVFb2U;O0010O01OO0O2oD\\Mc9g2[FaM\\9a2dFfMU9[2iFmMo8U2oFSNj8m1VGXNe8i1YG[Nc8f1]G^N_8c1_GaN]8a1bGbNZ8_1eGeNW8]1hGgNS8[1kGiNP8Y1QHiNl7X1THjNi7V1XHmNd7T1]HmN`7T1`HnN]7R1dHPOY7Q1hHQOT7P1lHROQ7n0PITOn6l0QIXOk6h0UI[Oh6f0WI]Og6c0WIAf6?ZIXMBW1Q7a1\\ImL2a1_6b1_IlL6b1Y6a1`InL:a1S6a1cInL>^1o5c1eIlL`0_1j5e1hIjLa0`1f5e1jIiLd0`1a5g1mIgLf0_1]5j1mIeLj0_1X5m1mKRNR4n1QLoMo3Q2SLmMm3S2ULlMj3T2XLjMh3V2[LgMe3Y2]LeMc3[2_LdM`3\\2cLaM]3^2PKiL@g0`5_2\\JbM3MY6h1cI_N4H]6c1_IiN4_Oe6b1UISO6WOh6d1QIZO6nNm6e1lHA8dNP7h1hHI7[NU7i1dHOl8OUG4j8IVG:i8EWG>h8@WGc0h8]OWGf0h8WOXGl0h8ROXGP1g8oNXGS1i8jNXGX1g8gNYGZ1g8eNXG^1h8_NXGc1h8\\NWGg1i8VNWGl1i8QNYGQ2f8mMZGU2g8gMZG\\2e8aM\\Gb2d8YM^Gi2b8TM_Go2`8nLbGS3_8hLcG[3\\8bLeG`3m92N0O2O001O1O0O2O001O0012NGZLZEb3f:eLWEX3h:oLYEi2f:_M\\EY2c:kM\\EQ2d:SN\\Ei1e:YN\\Ed1d:_N\\E]1e:fN[EV1e:mN\\EP1d:SO[Ej0f:XO[Ec0g:@XEXIl1R;GmD8Q;LmD3R;1mDMR;5nDJQ;8PEFn:=SEAm:`0SE_Ol:c0UE[Ok:f0UEVOm:l0SEQOo:o0SEoNm:R1SEnNk:T1UEkNk:V1VEiNh:Y1YEeNg:\\1YEcNf:_1[E^Nf:c1[E[Nd:g1Z11N2O1N2O0O10000O1000000000000000TN\\C\\1ceE1e0N[OC3OK0n9a0oE_O1d0e0J]OBM22N20Q:\\1_FAe9`0YFAg9?XFBHQOe9]1_FcNDP1X:=kEOU:2gE1Y:e1K2N00O100O100O100O1N2K5O100O10000O1O1O100O1O12N1O1O00000kEXMh9h2mEXM37o9a2nEdMR:\\2nEeMQ:j201O001O1O00O10000O100001O000000001O000000N2jN_FoMU:a0mE^Oj02Z9N]F0:1k;O10lW11ShN2OO1O00000000N7\\O?SO^OfDn0`:1VEmN0U1c:`1^EZM^:j2M202L3jFRMm7Q3kGUMU8l2^GlLD`0n8f2XGbMh8`2RGdMn8\\300000000000000000O11O0000YL`GT1BGn8TOaGU1L\\Oi8WO_G[1H^Oi9XOkEl0>Kh9WOkEn0?Ig9XOkEm0?Kg9UOmEn0?Jl;UObCb0dTNJX<2oCHYc8Q3]G]Mc8b33O1N2001O000000000000000000OgGfKd7Z4YHiKg7Z4UHhKj7X4UHjKj7Y4lG_K2:R8Z4lGiKS8h4O00O11O00001O0000000000000000SKPH`4a8VKPHR4h8F9XL^F_3j90O10N4fLTFn2T:01O1M3N2OdNUMZHj2`7dMYH[2f7jMXHU2f7QNVHn1Z7dMjGa0m0h1Y7mNdHlNTOh1U8]OgH^NTO:1j1T8@gHfNVOGOo1S8DkHbNYOh1m7JeHYNXO26i1n7NcHVNFl1g7NTI2l6NTI2l6NTI2l6NUI1k6NVI1k6OUI2j6NWI1i6OXI0h60YINh6OiG[Nb1d1d6LfI2Z6", "size": [426, 640]}, "area": 54366.0, "iscrowd": 0, "image_id": 10434, "bbox": [109.0, 0.0, 531.0, 168.0], "category_id": 96, "id": 10012773}, {"segmentation": {"counts": "fhT24V=>C2MN2O2N10010O0000000000001O0000000001O001O1O01O0000000O100000000000001O2N1O2N1O2M200O2N1OO1O1O001O100O1O0102N1O1Nhi?;lU@20000O12N00N3N10000O10000O10000010O0O2LXCDi<;PX6DUhId0GO00000000000000000000000000]C]O_kXG@j8?WGAh8?YGAg8=[GAg8>ZGCe8;]GEd89]GHb83\\EJT23a82bGNm:00001M2N2N3M2BFkC@VO_Dm0];WO`Dj0^;[O^De0a;c0N1O1OZNcDb1\\;^NfDa1b;00000010OO1001O00000010N2O1O1N1001O0000001O001O000001N3M3mDVNa:m1\\EVNa:m1\\EVNa:m1[EWNb:k1\\EXN`:\\2N010O01hMfE^1Z:aNnEX1R:gNVFR1k9lN\\Fo0c9PO_Fo0a9POaFo0`9oNcFo0]9QOdFn0\\9ROfFl0g0kNd68fHo0`0lNj66fHo04iNfN7kNB2?h7MbIk0eNjNOO0;6HKNOO1d0OLk7KbIX3^6iLbIV3_6iLcIU3]6kLdIT3\\6lLfIR3[6mLfIR3Z6oLfIP3Z6QMgIm2Z6jLTH2b1S3Z6iLWH4_1R3b6PM^In2c6RM]Im2g6QMXIn2i6RMXIl2i6UMVIj2k6XMSIg2m6\\MRIb2o6`MoH_2R7aMnH^2S7cMmH[2S7fMmHY2U7eMmHY2T7ZM\\G4g1a2m8OaN\\MZHb2g7^MYHa2g7`MYH_2g7aM[H]2e7dM[H[2e7fM[HY2e7hM\\HV2d7kM\\HT2e7kM\\HT2d7mM]HQ2c7PN]Ho1c7RN]Hm1c7TN^Hj1b7WN^Hh1b7YN^Hf1c7ZN^Hd1b7]N^Hb1b7_N^H`1b7aN_H]1a7dN_H[1a7fN_HY1a7hN`HV1`7kN`HT1a7lN^HT1b7mN]HS1c7nN]HQ1k6]NTHc0P1P1l6_NRHb0Q1o0m6`NQHc0P1m0o6bNoGb0Q1l0P7dNnGa0Q1j0Q7gNlG`0R1i0Q7jNkG?R1g0S7lNiG>S1f0T7nNgG=T1e0U7oNfG>S1c0W7QOdG=T1b0X7SOcGZ1Ai92Sk3NgVL1O1O1O10N13M101N2N5L4K2N2O0O1O2O4aCSOXf4@ZKe0a4ZO`Kk0[4UOeKm0Y4ROhKn0X4ROhKn0X4QOiKo0W4QOiKo0W4POjKP1V4nNjKT1V4kNjKV1V4hNkKY1U4fNjK\\1V4bNkK_1U4`N]K0RM`1c7]N]KQ2f4kM\\KT2m7001]EkMo9V2mEoMQ:S2jEPNV:Q2fERN[:^20001O000010N10000001O01ZMcE]2]:aMhE\\2X:cMkEZ2V:eMmEY2d:N3L3O1M3O2M2NO1O100O1O1O1N2M3N3QEiMg:Y2VEhM00f:a2ZE^Mb:h2^EXM[:k2eEUM[:m2010N110O001O0O1010O01N101O_EYM_:j2O100O01O000O10000001O000000O02OO1O100O100000000000O101O0000000000009G4kEjLn9Y301O00O1000000001O001O00000cFdLl8\\3RGfLn8_3fFhLZ9d300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002N2N2NfLZLRMd3m2^LTM`3l2bLSM]3m2cLUM[3j2fLWMY3i2gLWMY3h2hLYMW3g2hL[MW3f2hLZMX3f2hL[MW3f2hL[MW3f2gL[MY3f2fLWJOb2[3X3eLUJ2b2Y3Y3eLTJ4a2X3\\3dLRJ5a2W3]3eLPJ6a2V3_3eLoI6a2U3`3fLmI7a2T3b3fLiI:d2P3c3ZM\\Lf2d3[MZLf2f3[MYLe2g3\\MWLe2i3\\MVLd2j3^MSLc2m3^MRLb2o3^MoKc2Q4_MkKc2U4\\LeIP1m1l2`4VMWKQ3i4PMPKV3P5TM`JR3`5_MiIg2W6V200001O0000000000", "size": [426, 640]}, "area": 59480.0, "iscrowd": 0, "image_id": 10434, "bbox": [0.0, 101.0, 640.0, 325.0], "category_id": 149, "id": 10012776}, {"segmentation": {"counts": "]fk72mW4ZNXKGPOb1_1>Y4YNXKGPOb1]1`0[4WNXKGPOc1[1>_4XNVKd194c4XNTKe172g4ZNRKc153\\5iM_JU23EQO\\Na7o1\\IFR7:lHXOUOkNP8m1iHXO[OhNm7P2eHYOCcNm7P2^H]OT8c0jG^OX8a0fG@[8`0dG@]8?bGB_8FoF\\Oc0n0`8FmFZOb0Q1b8GlFVOa0S1d8IkFQO`0W1g8IjFmN>Z1i8a0jFAV9Y21O001O01O01O0000O001O1O1O1O2N1O1O20O2N100OoN_L\\H_3e7aL[H_3e7aL[H^3f7bL[H\\3f7dLZH\\3f7dLZH[3h7dLYHZ3h7ULiHk3\\8N1O\\H]Lc5c3\\JeL^5Y3bJoLW5P3iJWMQ5i2nJYMR5f2mJ\\MR5d2mJ_MR5a2mJ`MS5_2mJcMR5]2mJdMT5Z2mJfMS5Z2lJhMS5W2mJjMS5V2lJlMR5T2nJmMQ5S2PKmMo4T2PKnMo4Q2QKPNn4Q2QKQNm4o1SKRNl4o1TKQNk4o1VKRNh4o1oJ_LjNb1W6n1mJcLlN_1V6n1lJeLPO]1R6o1kJgLSOZ1Q6o1iJkLWOU1o5Q2gJmLZOS1n5o1fJQM]Oo0l5Q2dJSMBj0i5S2cJUMGg0d5U2bJWMLb0]5[2dJWMO>\\5eNTJb3>^M3;Y5_2_JYM88W5c2\\JWM=8U5P4dJWL[5\\O^JV3OfMb5TOmJ\\3_OPMi5^OUKU3RO]Mh5^OXKS3QO_Mf5^O[KQ3oNcMd5]O_Km2nNfM\\5ChKe2mNhMZ5CkKc2lNkMW5CoK_2kNnMU5CRL^2hNPNU5BUL\\2gNSNR5AYLZ2fNUNW5ZOUL_2eNWNV5YOWL^2dNZNS5XO[L\\2cN\\NQ5YO]LY2cN^No4YO_LY2bN_Nn4WObLX2aNaNl4WOeLV2`NcNk4VOgLU2_NfNh4UOkLl0TNYO:f0g4TOmLh0WN\\O6h0e4TOoLc0[N@2j0c4RORM?^NCNl0a4ROUM9bNHHl0b4SOUM4fNKDm0a4TOWMNjNO_Oo0`4SOYMJmN2[OP1`4SOYMGQO4WOQ1_4TO[MATO9TOP1^4UO\\M]OWOR1_:nNTEO=S1^:oNlEQ1T:mNnES1U;001O000000OPOmNkES1R:POPFn0P:SOoEl0Q:UOPFd0nNZOS;1oEe0V:\\OiEd0W:\\OiEd0W:]OhEc0X:]OiEb0X:^OfEb0[:_OeE`0[:@eE`0[:@hE=Y:BfE?Z:BfE=Z:CgEY:ChE;X:EiE:W:FjE9V:HiE6Y:JiE0[:0fEI`:8Z1O01O000010O000O2O1O1O001O00eDO]90cF1]9MdF5X;001O001O1O1O0010O00000000101N2M2NVTU11ikjN3N00001N101O1O0O3N00O1O10O0100O10O010O0105FmB1fiY1", "size": [427, 640]}, "area": 264767.0, "iscrowd": 0, "image_id": 10440, "bbox": [0.0, 0.0, 640.0, 427.0], "category_id": 157, "id": 10012779}, {"segmentation": {"counts": "0c1g;000000000000G9N2N2N2POQDe0o;YOTD6L1QB=@kg30QXL8UCEf<=ZCDj<6UCLP=46K3Mlh00SWO0000000VD4V:LeE;Y:E_Ec0a:]OWEk0i:UOPER1P;nNdD1NV1^;iNaD6MS1b;=000O1001O00001O000000000000000003M1O00002OO000000000001O000000000kNZDf0i;POVDN6R1o;1O1N10N1010O3N1]n2jNcRM6J6Rd1C[\\N000i^e20RaZM3mBMT=5nB3e<901O0M3O@nCKo;4e0N]eX3", "size": [426, 640]}, "area": 4051.0, "iscrowd": 0, "image_id": 10442, "bbox": [0.0, 0.0, 388.0, 199.0], "category_id": 92, "id": 10012780}, {"segmentation": {"counts": "RoW21Y=000`D4b9LYF8h9HSF>l9BoEc0Q:]OiEi0W:WOdEn0\\:ROaEP1`:PO^ER1b:nN]ET1b:lN\\EV1d:jNZE8]Oe0Y;SOXE8Bd0V;TOWE7Fd0S;UOUE8Jb0Q;VOSE:M?P;WOQE<0mD\\OX;d0jDUO[;k0b0001O00001O0000001OO1K5L41O00001O001O00001O4L4L1O1O1O1O1O1OHZDROD2h;j0d000O1N200O100N2N200O100O100001O001O1ON2N2O100O1000000001O1O1O1_C]OO1OO92V;U1hDmNW;U1fDnN0Io:[1mDXOR;`1000000000000000000000000000001O00000000000000000000001O00000000001O00001O0000000000O100O1O1O11O1O00N21O1O0000O11O1O00000000O1N2O1O100000kDoMQ;Q2nDQNQ;o1oDQNQ;o1nDRNR;n1nDRNR;V1SEXOKBR;T1VEYOHCR;T1]EROAJR;S1aEUO_:k0gEoNY:P1Q100001O001O1OCUD]Oi;a0[D^Od;b0]D]Oc;b0_D]Oa;c0`D\\O`;c0bD[O_;e0c00000000000001O001O001O001O1O1O2N1O2N3M1O1O2N001O1O001hDdN`:]1^EdNb:^1TEbNJ2R;P20000000000000000000000000002N1O1O001O2N00000000001O00000000000000N2001O000000001O0000001O0000000000001O000000001O00000000001O1O001O001O1OM3O1A\\EWNe:i1[EWNe:i1[ETNh:l1XESNi:l1YESNg:k1[ESNg:l1EYB1ONkB1P=4N3L6L5O1O21KYnd1_OZR[N001nBOj<1UC1h<1WCOj<0WC1g<0XC3d9cXB200N2N2O1O10001O00000000000000000000001O000002N1O1O001O2N00000000001O00000000000001M2001O000000010O0000001O0O1001O000001O000000001O01OO1000001O1O001O001O1OM3O1O101L3O100N32M1OO100000000000000000000000CXC8nfJ_OY5a0kJ[OU5e0oJXOP5i0SKSOm4m0WKPOh4P1\\KmNc4S1aKjN^4V1fKfNZ4Z1jKcNU4]1QL\\NP4d1PL[NQ4e1_LjMb3V2i300000000000000001O00000000001O4LO1O1O11O00MSEiMm:W23N2001O1^G\\N\\5f1[JcNc5[1]JiNa5Z1ZJjNd5V1YJoNe5o0[JUOc5i0\\J\\Ob5f0ZJ^Od5c0ZJF^5:aJK[56cJOY51fJg1c3ZN[Lk1a3XN[Li1e3YNXLi1g3WNfK]2Y4cMfK^2Z4bMeK`2Z4`MeKb2Z4^MeKc2[4]MeKd2Z4[MgKe2Y4YMiKg2W4YMiKg2W4YMiKY1;dLl3S2iKP1m0bL\\3^2gKk0S6TOnIi0U6WOkIg0W6YOiIf0X6ZOiIf07VMe4T2TKi0OdMa4c1`Km0EhMi4[1cKo0[OmMQ5T1XLl1f3TN\\Ll1b3UN^Lk1a3UN`Lj1`3VNaLj1^3UNcLl1\\3UNdLk1[3UNeLWNnN\\2^4]OdLYNnNT2b4CaLZNkNECe1Z5<[LYNfNGMU1X5k0XLXNaNH7f0W5Z1TLXN[NH>6_5j1kKWNUNJd0Lb5S2hKWNoMJk0Cc5\\2fKfNZ5Z1iJcNW5]1lJnMfM3^7o1nJkMeM5^7P2PKfMdM:\\7P2ZKoMg4Q2UKRNl4n1QKkM]MKa2Lb2^2]MPNG6f2j1aMTNYOd0R3X1bMZNlNl0a3k0_M^NaNT1P4>\\McNZNW1Z46YMhNSN[1c4MWMc1i2]NTMf1l2ZNTMf1l2ZNTMg1k2YNTMh1l2XNTMh1l2XNSMi1m2WNSMi1m2WNSMe1Q3[NnL_1Y3aNgLY1_3gN`LT1f3lNZLn0l3ROTLh0R4XOmKc0Y4]OVKhMSOh2j5@QKPNoN]2S6CmJn0V5ROjJk0Y5UOhJk0W5UOiJU1m4kNSK_1c4aN^Kh1X4XNhKR2n3nMSL[2c3eM]L_2_3aMbL^2^3bMbL_2]3aMcL_2]3bMcL]2]3cMcL^2\\3bMeL]2[3cMeL^2Z3bMfLQNkNh3_4WNgLmMnNk3[4XNgLjMROn3V4XNiLfMUOQ4R4YNiLcMYOP1Ic1U4JaMdNfNj0[OYN]4Y2cMeNmNZOP5Q2TLfNaNXOe5S2jKfN^NZOf5P2mKgNTN@o5i1nKhNnMDR6d1QLHP48SLDn3e2e2\\2nMdMS2_2iMbMW2b2dM^M]2f2^MZMc2j2XMVMi2n2RMRMo2R3lLnLU3T3hLmLW3U3gLkLY3W3eLhL\\3Z3bLgL]3[3aLeL_3]3_LcLa3`3\\L`Ld3b3ZL^Lf3c60kL^LbLb3X3dLhL\\3R3jLnLV3l2PMTMP3g2UMYMl2_2[MaMg2R2dMnM]2VM_LT4[1fNi2o0_MQOb2g0eMYO[2?mMAT28RNHo1=kMCU2c0eM]O\\2h0\\L\\L0l2d3m0RL]L9f2e3S1hK[Lc0b2f3j1ZLVNf3j1ZLVNg3i1YLWNh3h1XLXNj3f1VLZNl3e1SL[No3c1QL]NR4`1nK`Nb4hNdJ>j0k0h4^NbJe0f0m0Q5TNfJc09Y1Z5iMaJm04Z1d5_M[JU11\\1m5TMVJ^1M^1R7`NnH`1T7]NmHc1U7UNQIk1R7lMTIT2Q90000000000001O0000000000000000000000000000001O00000000000000000000000000000000001O000000000000000000000000000000001O000000000000000000000000001O000000000000000000001O0000O1", "size": [426, 640]}, "area": 174508.0, "iscrowd": 0, "image_id": 10442, "bbox": [0.0, 51.0, 640.0, 375.0], "category_id": 145, "id": 10012784}, {"segmentation": {"counts": "m^l02U=3M3M4L3B>^Ob0L5M2mKiNPLZ1P4gNhIAk0j1]5fNgI@j0m1jNTNf5`0dJ@j0n1gNeN]5OoJ_Ol0n1cNUOV5KmJSOZ1m1^N[OZ51^JkNi1d3h3nMXLS2g3mMXLT2h3lMXLU2g3kMXLW2g3iMYLX2f3hMYLZ2f3fMZLY2g3gMWLZ2k3aMVL`2l3oLaL]2YNfLW5d0fLg2S4^MdKd2^4bMQJkNd0d3]5gMhIfNj0b3`5nM`I`No0a3c5SNYI^NS1]3f5ZNYJe1i5[NWJc1k5]NTJb1n5^NQJa1Q6_NoI_1>iLS4h1_K]1BiMo4;nK`3R4[LTLd3l3RL^Ln3b3kKeLU4[3cKnL]4Q3ZKcJN^2h4o2WK[Mc0VM_3^8^LeGa3[8\\LiGc3W8ZLnGd3S8YLPHf3P8WLTHh3l7ULXHX3_OoLV9g2VGVMk8a2_G^Ma8X2kGeMV8Q2UHmMl7k1Q2L4M3L4M3L4M3M3L4M7H1N8HSP4GRPL4L4L3M41N2O1NREGo88mFLT92iF2X9o11O1O1N2J6J6J6K5JeG\\O\\4>cKK[4i0oJ[Oo4Z1ZJjNd5T1[JQOc5m0]JWOb5g0\\J^Ob5`0^JD`5:aJOW5OjJ6R5ERK`0j4[OZK]2o2^MUMf2h2UM\\Mm2c2nLaMT3^2fLUMm3k2oKXMS4g2kKZMW4e2gK\\MZ4d2dK]M^4b2`K`Ma4_2^K[K^Ok1T5j2\\K[KCj1Q5k2ZK[KHi1d3]NnL_4D\\KLg1Y3YOdLe36\\KNe1P3i4oLeI2a1l2f5UMYJh2k5XMTJg2m5ZMiHDc0P3f6]MaHHj0m2HVMa55gIMP1k2@dM]5EmI1V1j2VOhMe50`KP2bNWNm5IlKV3S4iLnKX3P4hLQLW3o3iLRLW3n3hLSLX3l3hLTLY3k3hLULW3k3iLULDaNX2]5SNRLG_NP2d5ZNoKF[NFF_1S6ZOoK@VNG1P1l5MPL[OQNH:`0o5;jK]OjMH`01X6j0aK\\OdMJg0HX6R1_K]O_MIV8i0^JLb54aJYOXMNX8h0cJUOWM3V8h0fJPOVM7U8i0hJkNUMf2b7_NPHlNL06f2o7_NPHkNJQ3Y8VNlGiNKm2[8]NhGh1Z8YNfGgNMe2^8fNdGeNNa2`8lNaGdNOY2f8TO[GcNOQ2l8]OVGbNNm1n8CSGg0m8YOTGf0l8[OTGc0m8]OSGb0n8_ORG?o8BQGP8_ORHc0m7ZOUHg0k7VOWHk0i7[MVHV1?lN7R1S7gN^HV19TOm07n6b0VHYOT:c0mE@R:Lc6h3kIZLY6T4SIoKm6W50QOgHmKX7W4PI]KP7g4XImJh6W5d03MTK]HT4_7nKZH[4b7k0L4L4L2M2N2N2N2N2N3M2NN2J6J6K5J6J7F;El0VO8G9H7H9M35J6K5VG\\Lb7i3TH\\Ll7j3jGZLW8g1`G`0`8AaG>_8V21O2N3M2N8fKPGb10>\\9^OfFa0b9TOlF`0]9UOgFi0b9mNaFQ1h9dN]FY1l:N2O1I7H8HWkS1", "size": [426, 640]}, "area": 48503.0, "iscrowd": 0, "image_id": 10442, "bbox": [68.0, 0.0, 485.0, 425.0], "category_id": 183, "id": 10012785}, {"segmentation": {"counts": "X4V;^401O00000000000000000000000O10000000000000000000001O000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000001O00000000_NUEYNk:d1XE\\Nh:a1\\E^Nd:a1^E^Nb:a1_E_Na:_1bE`N^:_1dE`N\\:_1eEaN[:]1hEbNX:]1jEbNV:]1kEcNU:[1nEdNQ:\\1PFdNP:[1RFdNn9Z1UFeNk9Z1VFfNj9Y1XFfNh9X1[FgNe9Y1[FgNe9Y1\\FgNc9Y1^FfNb9Z1^FfNb9Z1_FeNa9[1`FdN`9\\1cFaN]9_1eF_N[9a1gF]NY9c1jFZNV9f1lFXNT9h1nFVNR9j1QGSNo8m1SGQNm8o1UGoMk8Q2XGlMh8T2ZGjMf8V2\\200000000000000000000000000000000000000000000000000000000000000000000O10000O100O10000O10000O100O10000O100O10000O10000O100O10000O100O100O100O100O1O100O100[OZB[Og=e0]BWOc=h0aBTO`=k0dBQO]=o0fBnNZ=Q1e000O1O100O100O100O100000000000000000000000000000000000000000000001O0000000O1000000000000000000SBTOR=l0mBUOS=l0kBVOT=l0iBVOV=m0eBVOZ=l0cBUO]=m0`BUO_=m0]BVOb=_1O001O1O1O001O001O001O001O00001O001O001O001O001O001O00001O001O001O001O001O0000001O0WEbM\\8^2]GiMc8W2VGPNj8P2PGVNP9k1hF\\NX9d1cFaN]9_1aFcN_9]1^FfNb9Z1[FiNe9W1YFkNg9V1UFmNk9S1RFPOn9P1PFROP:n0iEYOk6S4mHULX2Z6", "size": [500, 375]}, "area": 149232.0, "iscrowd": 0, "image_id": 10444, "bbox": [0.0, 21.0, 375.0, 473.0], "category_id": 183, "id": 10012786}, {"segmentation": {"counts": "_[S15h:2N3N115J10O100M3N2M3N1N3OeQd02Tn[O3J6M3O10010O011ON3N10001O01O01O0N2O2M2O1N3N1OZPV3", "size": [349, 500]}, "area": 446.0, "iscrowd": 0, "image_id": 10445, "bbox": [103.0, 220.0, 97.0, 72.0], "category_id": 105, "id": 10012787}, {"segmentation": {"counts": "kl:2k:0N114K1O1O100O1001O000000001O00000000O1O1O1000000001O000000001OO100001OO11OO10000O11O00O100000000O1O1O1001O00O1001O1O0000000000O100O10000O100NBhE;V:DmEgNYNYNY1P3>gNXN[NY1m2`0hNUN^NY1k2a0hNUN^NZ1j2`0iNTN`N[1g2a0iNSNaN\\1f2`0jNQNcN_1c2`0jNoMdNa1b2a0gLcMQ2:gNb1a2a0gLcMQ29gNd1a2c0gNhMjNd1_2b0iNjMjNb1]2d0iNiM`NLEe1S3f0hNhMaNNDc1R3h0iNfMaN1Bb1T3g0iNeMaN4A`1U3g0iNdMbN5@`1U3g0iNdM`N8A\\1W3h0hNcM\\NZ2k24iNaM[N]2l22iN`M[N_2l21VO1i00VO0k00iN_MSNf2T3KiNi4AXK;h4GZK5g4MZKOg43[KHf4:[KBf4`0[K\\Og4d0[KVOi4k0XKoNl4R1UKgNP5Z1QK_NT5b1mJXNW5h1kJQNZ5P2gJiM^5X2cJbMb5^2^1001O1O1O1O001O1O1O2N1O1O2N1O1O2O0O1O2N1O1O2N1O1OeNkHPOS7T1jHlNU7U1kHkNT7V1lHkNR7V1nHjNQ7V1PIiNP7X1PIgNP7Z1PIeNP7[1QIdNP7\\1PIcNP7_1oH`NQ7b1nH\\NS7e1mHXNU7h1lHUNV7j1lHRNW7n1jHoMX7Q2iHlMY7T2hHiMZ7W2gHfM[7Z2d000001O000001O0000000001O0000000000000000001O01O00000000O100O101O0O100O100O1N_MhGa2W8`MiGa2U84O\\MlGa2R86O1O1O1O1O2M2N2N2N2M3N2N2M3N2N2M3N2N1O2N2N2O1N2NSM\\Ie1[2UMi1U1mKg1Y2UMh1T1QLg1U2WMh1R1ULg1R2XMh1P1WLi1o1YMh1n0[Li1l1ZMh1l0^Li1i1]Mh1h0aLl1f1]Mh1h0bLk1d1aMh1g0aLh1f1dMf1g0aLf1g1dMh1j0^Lb1i1eMi1l0ZL`1k1fMj1m3UNSLl1m3[L]KY11nNg0]3l3\\L^KS13SOc0^3m3\\L^Kn06VOa0`3k3[LaKi07[O>`3k3\\LaKe09]O5aAO]>2bAN^>;0N2ON111OO11OO100001O00000O1O1000000000N3OaAA]>?cAA]>a00O11OO1O100O1001M2O0101O00000000001O001O000N03O0000000O00101M110O1O10010OO10000000O11O1O001O00000000000000O11O0000O10000001O00O10000O1000000000010OO0102NN2001O01OK^OkAc0T>^OlAb0n=]OTBi0k=WOUBi0l=5O10000001O00MQOUBo0k=3O100O12N003M00001O002ON1N1N3000001OO2O1O3M000FPBDQ>:QBDQ>;8\\AHe>73O00fCKi92iCN^20j90iC4Y2Ln91hC4Y2Ko9OjC61Nl1O[:6fCNl1M^:>bEB]:?bEB^:?aEA_:?aEB_:=`EE^:IiC`0i1Ga:9_EGa:9_EG]:IkC`0h1G]:JjC?i1G]:=bED^:`EB`:>_EC`:?_EAa:JkC?d1Gb:IjC`0c1Hd:GiCa0c1Hc:GkC=0Ba1;i:LlCI\\1;j:IaE7_:IaE7_:GcE9_:EcE9a<100N20000O10000000000O10000000000000000O10000000000000000O1000000O1000000O100000000000000O11OO1M\\OjAd0V>]OiAc0W>]OiAc0X>2O1O100000000O11OO100O100000WOlAf0W>[OiAa0X>^OhAb0\\>O1O00001O00001O00001O00XOCmB=n3O1DLjA7S>JdA020N6]>:01O101M10010N1O11M22NN21O002M2O10O00nAWOn=i0PBXOP>h0QBWOo=i0oAYOR>i0010O010001N0QBSOl=Q100OPOTBj01VOn=j0SBUOl=l05O00001OO20O0000N20O10O2N0011OO001UBQOe=P1ZBPOe=R1ZBnNf=Q1ZBPO=0gd0nA\\OU>`0mA_OO0V>?9O0O011O0O11O000000000M30000O100O2D^ORB10a0n=DQB=m=;[BROX=Q1fBSOV=n0cBnN1:W=]1O0N5L0oBVNlN1N2O0O3OO01OO1O2O0O1cC`M\\<^2dCbM\\<^2dCbMZAcA?]>AcA>`>O01^BBbgBC;OmT=b0PCRO09R=e0VCZOk\\OiA00`0\\>2N011O1O110NO11O2O3MO12N100OO1L42M00WOkAe0Y>11L1101O]OfAa0]>00O001O2M100I_A0`>0bAN^>19O010O1LVA1k>O30ZPV2", "size": [480, 640]}, "area": 7871.0, "iscrowd": 0, "image_id": 10449, "bbox": [304.0, 236.0, 186.0, 108.0], "category_id": 134, "id": 10012793}, {"segmentation": {"counts": "m2f1Z=0O11O1N200O01N1002N1O000000N2O0O3N3iBWN01P=j1PCWNP=h1QCXNm^2R;nMnDR2R;oMmDQ2Q;PNPEP2P;oMoDT2l:_MgD?=Q2l:SNgD^O6_2U;SNeD]O5a2V;VNfDXO0b2[;P100ON3O1O0O1O2N0100O1O11OO100000O021N2OO0003M0000O1O1001O01OOO2101NO010NgL]DY3c;kN^DoNb;S1]DlM0o0b;T1cDlN];S1gDQNHa0a;]1hDmMF13d0`;[1REdNn:]1]DoMb0d0R;_1mDbNS;[1oDdNQ;[1QEeNm:\\O^Dm1g0fNk:^O_Dk1f0gNj:_1UEbNk:]1UEcNj:_1UE`Nl:a1iDmMNd0V;^1mDnMIOMf0\\;_1lDmMKNLg0];^1lDPNHa0^;a1hDPNJ=^;e1fDfNY;\\1gDcNY;^1gDaNY;`1dDcMNl0^;d21O001OO1010N02N10O100O2N011O10O0O2OO1O21N0O10O011O0NOeLaD[30eL[;b3O010J_LlD`3O^LR;j3nDVLP;l3201OO1002N01OO11N2M22NPESLn:h0REY2OPMm:i0UEX2l:YMRE22JNb2o:aMREH0NO20N259\\2d:dMQEK42713MB00[2o:jMREK40825Y2]:hM^FY2U;00O1O101O[CiMa<[20000O10O002M^CgMeb06M3O002O00O10000001O000010N20O04L1jAZOP>Q1JO11N010000001ON12O2N0010OYBlNO0_=_1M3M30N010O00ZC^Nn;b1QD_No;c1nC_NR<`1mCaNT<^1kCcNU<\\1jCfNV<[1hCfNW<\\1gCfNU<\\1lCdNT<]1jCdNW<\\1fCgNR000N20000O11O0000O1O100000010O1O10OO20O00O101aEPOk6Q1UIoNm6n0mHSOiL1[:j0kHWOgL1`:LbE4NL000;Z30c7OeGF_M0`00_O=l:KgGNjMKC=k:JdG5jM5b:EdG9aM@5d0c:DeG:cM^O021b0g:DfG8cM9i:_OeGS1[8mNeGR1\\8nNeGQ1[8nNfGS1X8nNgGQ1[8oNeGQ1\\8nNcGT1\\8lNeGR1U5gN^K9]OP1T5iN^K7^OQ1S5iNbHMe29FR1Q5jNbHNe26IP1P5nN_H2d2OOP1m4\\OTK@\\MNc2S1n4@UK\\O]MOa2S1n4AQN=o1InM4S24gMKY29cMI[2QO_HV1U5I[2QO`HU1U2kNi0o0e48_JkNk0k0i49\\JmNk0i0i4:ZJjNPN5l2f0k4:YJSOj0c0n49UJZOj0?P57UJ\\Ol0:o4;UJ[Ol0;o49UJ]Ok0:Y5YOQH>m1Oj09ZMVOk72UH?m10j0?X5_OoI2i0`0W5VOPH0o1:k0AVMj0R8YOoGKT2a0i0\\7BdH>\\7BfH=Z7BbHBRMl0\\:BaHc0_7]ObHb0QMoN[:>dHf0]7ZObHe0_7\\O`Hd0a7[ObHb0^7XOfEHl2P1^7XOhHg0Y7TOaEMY3n0W7ROPIk0d:N1NlN[ORDd0l;]OVD?lN^Om<3XD?j;CVD;j;FVD:i;GWD9g;IXD8f;I\\D6b;M]D3c;M]D3_;1aDO_;1bDN];3QD_OH`0]:AkFa0nNBI<[:GjF;POEJ;Z:HjFEbN?`0JBH0c0O\\O_:`1o0c6bNnF5m0<`1m0c6lNnG9^1i0d6oNnG8^1k0c6lNoG9^1m0`6mNPH6a1m0^6nNPH5b1m0_6mNoG7`1n0c5cNeH:75b1k0d5fNcH:75b1k0X5fN^H1`0:84b1k0X5ROlH1:3a1k0X5ROlH0;2b1n0T5ROlHO?Ob1R1Q5QOmHO`0Ie1Y1^MZN^7f0mHOb0Cj1a1g4lNlH1e3o0QL[N_7c0mH3c3o0b3nNiH3f3o0d3jNiH2g3U1^3jNkH0h3U1^3kNhH2j3S1^3kNgH4j3Q1^3lNhH3k3P1]3mNhH3k3P1]3mNhH3l3o0\\3oNhH0m3Q1Y3QOjHNf3^OULb1Q7_NPIf03LY3]OhL4G^1W7_NmHe06KW3@fL5I[1V7bNmHb0:JT3CfL4H]1S7eNnH=>KS3BeLi1l6ROmHSO`0`0Q3D_LM2j1R7RO^IEl2GcLb1S7RO^IDm2HbLb1Q7TOaIAm2HaLc1Q7TOcI@j2h1b3hNdI@j2i1a3gNeI_Ok2k1^3hNfI\\Ol2j1`LiMP7P1eI\\Ol2i1b3jNeI[Oi2k1b3jNdI[Ol2k1g0", "size": [480, 640]}, "area": 50948.0, "iscrowd": 0, "image_id": 10449, "bbox": [0.0, 85.0, 640.0, 263.0], "category_id": 142, "id": 10012794}, {"segmentation": {"counts": "e9b1e1^OT9b0lF^OT9b0lF^OS9c0nF]OP9d0PG[OQ9e0oF]Oo8c0QG]Oo8c0QG\\OQ9c0oF]OQ9b0PG]OZOTOd8^1RH_OYOSOd8_1SH^OXOTOe8^1SH_OWOSOf8^1SH_OVOTOg8\\1THAnNoN_O4_9\\1THAnNQO]O2a9\\1TH@kNPO^O00213b9[1SHAjN_OT9o0SHBgN@U9n0UHCdN@W9m0THDdN@X9l0UHCcNAX9l0UHDbN@Y9l0THEeN]OV9n0VHEdN]OV9n0VHDfN]OT9o0VHDfN]OT9o0VHCfN_OT9m0WHDeN_OT9m0WHDfN^OS9m0WHGfN[OR9n0YHGeN[OQ9P1YHFfNYOS9o0WHGhNmN_O9b9R1XHIfNlN@9b9Q1YHJiNTOn8o0\\HMfNTOm8o0_HMcNTOl8P1cHO]NQOP9o0eHN\\NSOo8o0dHO]NROP9n0cHO^NSOn8n0eHO]NSOn8o0dHN]NTOo8o0bHO^NROo8o0dHO]NROP9n0cH0]NROP9n0dH0[NROR9m0bH2\\NQOS9l0`H3]NROT9j0`H3\\NSOT9k0_H2]NSOW9H\\Fi0Q2<\\NSO^9`0UH`0PNfN2O0;i9?VHa0oMhN0M2;m99PF\\OS2a1mM_N3;m98UHQ1mMhNn96WHQ1jMjNo95XHP1hMlNP:4XH`1f7nMRFb0W2a1g7aNYH_1h7`NWHa1i7_NWHa1i7_NVHb1j7^NVHb1j7]NWHc1i7`NTH`1l7dNPH\\1o7gNoGY1Q8hNnGX1S8lNiGS1W8nNhGR1X8POfGP1Z8POfGP1[8oNeGQ1[8oNeGQ1[8oNdGR1\\8mNeGS1[8mNeGS1[8mNeGS1\\8mNcGS1\\8nNdGR1]8mNcGS1\\8oNcGQ1]8nNdGR1]8mNcGS1\\8nNeGQ1^8mNaGS1`8kNaGU1h8aNYG_1g8bNXG^1h8aNYG_1g8aNYG_1g8aNYG_1e8cN[G]1b8lMiEf0f1^1]8jNbGV1^8jNbGV1W8POjGP1V8POjGP1V8PNSFj0g1V1]8iNcGW1c8cN]G]1c8cN]G]1b8cN_G]1[8lMRFf0c1^1[8jNdGV1\\8jNdGV1\\8jNdGV1\\8iNeGW1o7UNZFe0g1U1P8VOoGk0T8ROlGn0Y8mNgGS1[8kNeGU1[8kNeGU1[8lNdGT1\\8lNdGT1\\8kNeGU1Z8lNfGT1V8nMSFn0h1S1T8TOiGm0V8TOUFhNc1T2Q8]OoGc0m7ASH?j7DWH;c7QNjFc1c1l0PBTOk=n0TBROl=R1O1N100O2IlN_BU1a=501N1O1O2O00XOdBL\\=OjB0V=1iBOW=1kBMU=NcBA<9W=F^B=?IZ=LVB01OO0`01^=NYB0I1^cP3", "size": [480, 640]}, "area": 33414.0, "iscrowd": 0, "image_id": 10449, "bbox": [0.0, 295.0, 434.0, 185.0], "category_id": 148, "id": 10012795}, {"segmentation": {"counts": "c4R5b1cL^O_Oc3n3oLcL^O_Oc3n3oLcL^O_Oc3m3PMeL]O]Ob3n3RMeL[O^Od3l3QMfL]O\\Ob3n3QMfL]O\\Oc3m3PMgL\\O]Od3m3oLfL]O]Od3m3nLgL]OZOh3P4jLfL_OYOg3P4kLgL^OXOh3Q4jLgL_OWOg3R4jLgL_OVOh3S4hLhLAnNoN_Oh4k4hLhLAnNQO]Oe4n4iLgL@kNPO^O0021g4n4gLgLAjNU4@jJ01i4^1nLBgNX4BiJg4]1QMCdNX4EhJe4]1QMDdNX4EiJe4[1SMCcNa4X4lKUMDbN^4[4nKRMEeN\\4W4oKUMEdN\\4W4oKUMDfN]4T4oKVMDfN]4T4oKVMCfN_4T4mKWMDeN^4U4nKVMDfN]4T4nKVMGfNZ4S4oKXMGeN[4Q4PLYMFfNX4T4PLVMGhNmN_OX5c4SLWMIfNlN@Y5b4QLYMJiNU4m3nK]MMfNV4k3mKaMMcNW4JfJ^3W1WNO]NU4AcJ1:k3n0XNN\\Nf4\\3\\KWNO]Nf4\\3ZKWNO^Ni4X3XK[NO]Ni4X3YKZNN]Ng4\\3\\KUNO^Nf4[3[KXNO]Nf4\\3ZKWN0]Ng4[3YKYN0[Ng4]3XKWN2\\Nf4^3WKUN3]Nh4^3TKVN3\\Ni4^3UKUN2]Ni4a3RJRLi0Q2<\\Nh4i3kJjM`0PNfN2O0P6NPJS4j0nMa0oMhN0M2o5ORJU4c0iK\\OS2a1mM_N3P6NSJT4`0PNQ1mMd4R4ZJSNQ1jMi4P4VJWNP1hMk4Q4UJWN`7f1nGRLb0W2a7g1aHYNa7f1^HYNd7f1\\HZNe7e1[HZNf7f1ZHZNf7f1YH[Ng7e1\\HXNe7g1_HUNa7j1bHTN^7l1cHSN^7m1fHoMZ7P2gHoMY7Q2iHmMW7S2iHmMW7T2hHlMX7T2hHlMX7T2hHkMY7U2fHlM[7S2eHmM[7S2eHmMX7[NhGh3P1lMX7]NgGW2?eNc0g0X7]NfGS2c0iN>g0Y7a0]HfN^25h0o0W3lNQL4i0Q1V3jNQL5i0Q1U3kNRL4i0R1S3iNWL3c0@lLd1\\6iNTL2b0@mLi1^6XNdI6_29b0Z1^3WN`I5a2:a0Z1b3XN[I0b2=b0[1\\6dN]IBTM01j1_9cN\\IFUMg1]9eN[IGXMc1^9eNXIKZM_1_9fNWIKZM_1^9gNXII[M^1^9jNWIH[M^1]9kNXIHYM]1`9kNWIHYM\\1a9lNVIIXM[1b9lNWIGXM^1`9lNWIFXM_1a9kNWIFYM^1`9mNVIEYM_1a9lNVIEYM_1a9mNUI]1j6dNVI[1l6cNUI^1j6bNWI]OXMo1a9bNeH_O^Nn1m8bNbHDaNk1l8`N_HJeNf1l8`N[HNhNc1m8_NYH0jNa1m8`NXHOkNa1m8`NXHOkNa1m8`NXHOkNa1m8`NXHOjNb1n8`NWHNjNb1Q9_NRH2mN`1o8_NQH4PO]1o8_NPH5QO\\1P9_NQH2nN_1R9_NhH_OQNR2V9aNUI_1k6bNoH\\ObMS2_9bNRI_1f5mMjHf0^1^1i5kMhG0o0f0^1_1l5PNfHa0^1^1l5UNjGHa0e0h1^1m5VNeGF13d0d0g1]1n5aNZH2h1]1o5lMeGb0d06g1\\1S6]NWH6e1^1R6^NXH5f1]1P6`NZH4d1]1P6aN[H3e1]1o5`N\\H4R1]OcNo1P8_N\\H5k0EeNg1U8_N[Hc09_OSO_1Z8^NYHo0Kb1m7TMfGNd0_1@b1U8RMgGIOMf0h1]O`1X8PMgGKNLg0j1\\O^1X8QMjGHa0m1\\O[1Y8nLlGJ=o1^OS1OnL\\84bHl1SOP10PM\\84`Hn1ROh01XMc82YHo1SOf01YMd8O[GNl0R5P9O100000010OONTFRKm9m43hNPF\\L0?0MP:U3YFkLLBL8o9X3[FlL1Jd9Y3`FaLA1O2<3c9Y3bFbL@O2185d9X3dFbL10]O2o9\\3cFcL0O^O2P:[3cFdL11\\9Z3]GdLe8[3_11O12N01O1NN30]DeLa;]3N20aLbD\\3a;O0101McLaD]3_;cLaD\\3`;111O00001O10OO20N20O00bLaDZ3`;eLaDZ3b;10WO^D`M0:0Fb;Y2jDmMHH_;[2jDfMB1n;Y2d0101N1O011OaMcC]2_a:@gE]2h0dMQO?_:C`EN1]2o0cMRO?^:W2_FZMSOa0]:U2`FZMTO`0]:T2aF[MQOb0_:S2aF[MnNb0_:U2cFmM\\9T2cFmMoN[O]:h2cFQNY9R2fFoMY9R2fFoMROUO20o9i2PFXMk0n0UOROo9h2PG\\N_8kNcF06m2`0TMYOU1^9QOfFf2`0SM\\OZ1^9oNcFd2?UM_OO0Z1_9P2PGXNP9i1oFWNo8k1PGVNc8^NSGa3;QNc8V2\\GiMb8Z2]GhMa8Y2`GeM`8\\2`GdM`8\\2`GdM`8\\2`GdM`8\\2`GdM`8\\2`GdM`8Y2cGeM_8[2aGdM`8\\2`GdM`8[2aG^Mf8b2ZG^Mg8`2[GaMd8S2jFeL10a0W1e8T2oFdL=Y1g8m1dGRMROe0\\9UOcFl2R1XMSOc0d9n1ZGXMnN1:f0]9P2PHmMR8S2nGmMP8S2UHhMl7X2THYMVN`1V;JiD7X;GiDFBBf;h0iDEBBe;h0jDiN@8263M\\;S1REeNC;OKY;Y1XE^NA=2GQ;c1fEdN[OGm:h1iE_N]OGk:l1iEVNj:k1U1KPCZNP=f1QCYNoWG2cNWO@5e:b0YG0dNYO^O021c:f0ZG0aNZO\\:f0TG0^90cFO]91dFO\\90eFO[90gFNZ92gFMZ93eFL]9F_D3U27\\9BbDNL4Y2;Y9AgD4o1X:BhE?W:BhE?W:AiE?V:BjE?U:BkEl002N00002NLSBUOm=j0510N2O0003cMXOXDLR2l0f9ZOYFg0b9SO]D:P2c0`9C_F?^9B`Fa0_9@_Fa0a9@_F`0`9@_Fb0`9_O^Fb0b9_O^Fa0a9@^F`0b9A]F?c9B\\F=e9DYF>f9CZFEJ];8O1O3M0_ADO0]>9cAH\\>?O001O000000001O00O10000O1O1000000000000O10000001O001O000SB^O\\=c0bB^O^=d0`B]O_=d0^BYOI3i=d0^B_Oa=b0^B^Ob=d0XBWO13i=Q1O002NNYBkNg=U12O1O11O00001OO1001OO1001O0000001ON200O100KWBSOi=m05O100N2O100O100O1O10000000000NiA[OW>e02O1N2O1000000000000002N0000001O0000001hA[OS>k0N002N1oAROn=n0RBSOm=m0SBUOk=P10O10000001O0000O11OO1O1O1O1C=O1000000000000000000000000000000001O1O1O1O1O001OO1O1L41OO1001ON2O10000M32N00001O00O100O1N2002NO12NM`AEa>;21O0000O1004LO100001O1OO11OO100000000001O00O1000000001OO11O00001OO100N2001O00001O1O00O1001O1O2N000000000000O11O001O001iAZOR>l0mAUOm=o00O11O0SBQOi=S100000O11O0VBmNg=V1000O11O0YBiNe=Y1000000000O100O100O11O00001O00001ON2O1FZBXOh=g0\\BVOd=k0[BUOe=f0WBZO6Oc=e0ZB[Oo=e060000O100O1001OO1O1001O00001OO100N2000000O1001OO100000000O11OO100001O0000O11O00O11O1O00001O1O001O1O3M1O1O1O00O12N1O002N002N1O2N2NN2002NO100O1O10000O100O1", "size": [480, 640]}, "area": 8549.0, "iscrowd": 0, "image_id": 10449, "bbox": [288.0, 0.0, 352.0, 42.0], "category_id": 157, "id": 10012797}, {"segmentation": {"counts": "`al3130?0b=9[BLBLj=:bB1[=4YBA1O2<3EW=`0dB@O2185FV=b0dB10]O24W=>hB0O^O24W=?hB11@V=Y1hBiNW=`102NO1N3L4OM30\\NfBb1\\=O1N20OFbBTO^=l0cBkN020N^=U1:0O1O20N10010N2N110OO11O00O1O010100O01O00010OO102M2O1O1N3M2O1NjAZOV>g01N11O00010OO11O0001M20000O1O1_OcA>b>O0N2E\\A201h>NYA1hV]4", "size": [480, 640]}, "area": 2504.0, "iscrowd": 0, "image_id": 10449, "bbox": [265.0, 323.0, 74.0, 59.0], "category_id": 162, "id": 10012798}, {"segmentation": {"counts": "jg`61111dA13N00M2V>4jA=R>9O2L4N1O1O1M3JhNbBZ1^=4McNdB\\1\\=4O1O1O100J]NlBO0e1S=600O1N21NO30OO1L401N11O0O2O001O4L0O1001O0M302IQNYCo1g<50O100001O0YCiMeYd8", "size": [480, 640]}, "area": 13133.0, "iscrowd": 0, "image_id": 10449, "bbox": [445.0, 92.0, 195.0, 108.0], "category_id": 163, "id": 10012799}, {"segmentation": {"counts": "0m2S<00O11O1O1O1O00O1002N1O000000N2O1N2O1001OO1001OO10000001OO100N2001O3M1PDTMj;R3O2VDlLd;T3\\DlLd;Y3O001O00O1O11OO10000O100O1001O1O00M3001O001ON[DiLe;W32O11O0000O1O1BWD[M23h;b2=0000O1000000O1001OO11O001O000000001O1O1O2N0000O1O1M32N0000N21O1OO100000000O1O11O00001O00O11O000000O1MiC]MWN10O1N2O1O100001O1O1O00O1N2001O1O100000001OO0102L1ONaDdL\\;]360N01O2ON2O0100ON41N0N210O01N2O0O2M2002M003MNcLbD^3^;LcDfLO0`;X3600O0O213J12OO1L5O1N020OO2O001O4L0001O00ON300KUDUMk;k2501OO11O00001OO100N2001O00010000O0O1010M301M1O11O1O0000O0M5K4N3M2M4jMYCo1o0O9G0001O000N2MYAMW\\18^RO000_AGk>0O6J00O20j`i7", "size": [480, 640]}, "area": 130.0, "iscrowd": 0, "image_id": 10449, "bbox": [88.0, 308.0, 19.0, 26.0], "category_id": 178, "id": 10012801}, {"segmentation": {"counts": "bfV1a0\\>4L4L4N1O1Om0RO201N100O101N100000B>F:2N1Oe0[O0000000001O00000C^C\\Nb\\MBd2>]MAc2b0[MfMbNAS4i2\\MfMiNWOl3S3[MgMQOmNd3[3]MhMWOdN\\3e3]MgM_O[NT3m3^MiMFPNm2W4^MiMQ4V2QLiMo3X2PLiMo3W2RLiMm3W2TLiMk3W2ULjMj3V2WLjMh3V2YLjMf3V2ZLkMe3U2\\LkMc3U2^LkMa3U2_LlM`3U2`LkM_3T2cLlM\\3T2dLmM[3T2eLlMZ3T2gLkMY3U2hLkMW3U2iLlMV3T2kLlMT3T2mLlMR3T2nLmMQ3S2PMmMo2S2RMmMm2R2TMoMk2R2UMnMj2Q2XMoMg2j1oJULY2R2g2i1QKTLY2S2e2i1RKPLO0\\2W2b2j1dMWN[2i1fMVNZ2i1hMWNW2i1iMXNV2h1kMXNT2b1SN^Nl1b1TN_Nk1a1VN_Ni1a1XN_Ng1`1ZNaNe1_1\\NaNc1a1\\N_Nc1b1]N^Nb1`1`NaN_1_1bNaN]1_1dNaN[1d1`N\\N`1e1`N[N_1e1bN[N]1f1bN[N]1e1dN[N[1e1fN[NY1e1gN\\NX1d1iN\\NV1e1jN[NU1e1kN\\NT1e1lN[NS1e1nN[NQ1f1nN[NQ1f1oNZNP1f1QOZNn0f1RO[Nm0c1VO\\Nj0d1WO\\Nh0d1XO]Ng0c1ZO]Ne0c1\\O]Nc0c1^O]Na0e1]O\\Nb0d1_O\\N`0d1A\\N>e1A\\N>d1C\\NP5>gNSOZLc0i4;lNTO[Ld0`0UO`2S1e0TO[Lh09VOd2o0h0TO[Ln0NTOl2k0k0SO[LU1DROT3f0m0TO[L[1YOPO\\3b0Q1ROZLc1oNnNc3>T1QO[La2_2^NW1QOZLa2]2_NY1POZLc2Z2^N\\1POZLc2X2]N_1oNYLT1PO0n1cNTO[1e3oNYLi0ZO;a1bNWO\\1e3nNYL`0Ce0U1bN[O[1d3oNYL5MP1f0dNBV1b3QOZLK5\\18dNl00]26kMW1hNdNR1N[27kMY1cNfNW1I[29kMY1^NhN\\1F[29jM[1\\NiN^1C]29gM^1YNjNa1@_28gM`1TNkNf1]O_28fMf1nMhNl1ZO`29dMS3KdLa29dMS3JeLb29bMT3KcLc29^LX4i0eKi24]LX4a0lKR3L^LX46UL\\3D^LV4N^Ld3\\O^LW4DfLn3TO^LV4_OjLS4PO^LV4_OjLS4QO^LU4]OkLU4PO_LT4[OmLV4oN_LU4YOmLX4oN_LT4WOnLZ4nN_LT4WOnLZ4oN_LS4UOoL\\4nN_LS4TOPM^4mN^LS4ROQM`4lN_LS4nNSMc4kN^LR4nNTMd4jN_LR4jNVMg4iN^LR4iNVMi4hN_LQ4fNYMl4fN^LT6b3lI^LT6b3mI^LR6b3nI^LR6b3nI_LQ6a3PJ_Lo5a3QJ_Lo5a3RJ_Lm5a3SJ_Lm5a3TJ_Lk5b3TJ^Ll5b3UJ^Lj5b3VJ_Li5a3XJ^Lh5b3XJ_Lg5`3[J_Le5a3[J`Ld5^3^JcLa5]3`JbL`5^3`JcL_5[3dJdL\\5\\3dJeL[5Z3gJfLX5[3gJeLY5[3hJeLW5Z3jJfLV5[3jJeLU5[3kJeLU5[3dIYKT1\\1W5\\3dIXKU1]1V5[3fIWKU1]1U5`3jJaLU5_3kJaLU5_3lJaLS5_3mJbLR5^3oJaLQ5`3nJaLQ5_3PK`LP5`3PKaLo4_3RKaLm4_3SKaLm4_3TKaLk4_3UKaLk4`3UK`Lj4`3VK`Lj4`3VKaLi4_3XKaLg4_3YKaLg4^3[KbLd4]3]KcLc4]3^KcLa4[3aKfL^4Y3dKfL\\4Z3dKgL[4Y3fKfLZ4Z3fKgLY4Y3WJVK\\1`1]4Z3VJWK]1`1\\4Z3VJWK]1`1\\4Z3VJWK^1^1\\4[3VJXK]1^1\\4_3fK`LZ4d3bK]L]4c3dK]L[4c3eK]L[4c3fK]LY4c3gK]LY4d3gK\\LX4d3hK]LW4c3jK\\LV4e3iK\\LV4e3jKZLV4c3]JlJ]1b1U4b3nK^LR4a3PL_Lo3`3RLaLm3]3VLbLj3X3\\LiLc3V3_LiLa3W3_LjL`3U3bLkL]3V3bLjL^3V3cLjL\\3V3dLjL\\3V3eLjLZ3V3fLkLY3U3gLkLY3V3gLjLX3U3iLkLW3V3iLjLV3V3jLjLV3V3kLjLT3V3PMgLo2Y3ZM^Lf2", "size": [446, 640]}, "area": 140959.0, "iscrowd": 0, "image_id": 10463, "bbox": [0.0, 98.0, 640.0, 348.0], "category_id": 117, "id": 10012805}, {"segmentation": {"counts": "a\\h013260HOV=0jB93NoG:_O?F;E;C=I8O01O00@mLTFT3l9RMjER3V:;0000XObLaFJ063^3\\9oLcFQ3]9PMbFP3^9QMaFP3^9PMaFQ3_9oLaFV3Z9o0H00000000000000000000001O00000000001O0000000000000000001O00000000O100N20000N200O11O00O11O0000N2M3JgFeK[9Z45000000O1N2001O0000O1O1_OhFYL[9e3gF[LY9d3a0bNkE`NMZO0>Y:d1UFWNBK6MJ20NZ:Q2[FPN\\:R2bElM`:S2f0O1000000000000L4N2L400O10000000000O11O0000001O002N2VDUN];m1_DaNU;T20001O0000O100001O00000000O100", "size": [446, 640]}, "area": 15322.0, "iscrowd": 0, "image_id": 10463, "bbox": [505.0, 0.0, 135.0, 158.0], "category_id": 161, "id": 10012807}, {"segmentation": {"counts": "acY21j=4O5K8H1OEfBI18W=M?2N002N2N3M5K4L8H6J6J8H7I7I7I7I5K7I7I5K4L6J4L1O1O00002N0000001O00000000000000000000001O00000000000000000000000000001O00000000000000O100O100O1O100N2O11O2N1O001O3M00001O000SFTLh9S4N003M0000O11OO100O11O0000000000000000001OO1001O0000000000000000O11OO1I\\FULc9k3^FTLb9l3^FPLO0d9Q4600O10000J6000000O1002N1ON200005K1O001O000000001O001O001O1O0000N200000000002N00001O0000000000O11OO1000000O10000000000001O00000000000000000000001O0000000000001O0000BgFXLX9g3`0O^F[Lm8e3UGYLk8f3g0O1O100O1O1M3L4L4K5N200O1O1O1O1O1O1O1O1O1O1O1O1O100O1O10000O100O100O100O100O100O100O10000000000000000001O001O1O1O001O1O1O001O1O1O1O2N2N2N2N2N2N2N2N3M4L4L3M4L4L3M4L=C1O1O001O1O00001O001WG[KW8e4iG\\KV8d4jG\\KV8e4iG\\KV8d4jG\\KV8e4iG\\KV8d4lGZKT8g4lGYKS8g4b01O001O001O00KSGZKl8f4TGZKl8f46O11O0000001OO1000000UOXG`Lh8\\3]GdLb8n2lGRMT8e2VH[Mi7U2fHlMZ7i1QIWNo6^1\\IcNc6P1jIPOV6i0RJVOn5j0RJVOn5k0QJUOo5k0QJUOo5;nFET30n5;TG[OR3:j5;aJE_5;aJF^5:bJFe5DgF063^39R6FnI:S6EmI;T6DmI;S6DnI[1b:SOYEBK6MJ20N[1P;ZOQE\\1R;bNlD`1S;d01010000000nDYMm:g2REZMn:g2QEZMj:k2UEVMh:l2XEUMc:T314K100000001O0O110O1OMdEdL\\:\\34N1hM_EmN5n1_:lNkE1D0e:]OYE4?9JOf:@RF:_O4i;D_D;a;@dD>_U9k0hFWN6c0O9i8W1SGiM6i004_8c1[G]M6o010Z8h1fG\\N0JX8l1eG_N2DW8o1dGcN4\\OW8R2cGfN5WOV8k3jGSLT8R4jGmKT8U4nGiKP8Y4oGhKP8Y4PHgKn7[4RHeKl7]4SHdKk7^4UHbKj7_4UHbKi7`4WH_Kh7c4WH^Kg7d4YH\\Kf7e4ZH[Kd7g4[HZKc7h4]HXKa7i4_HXK]6CXJQ6f5RJVJQ6h5RJSJR6l5oIQJT6m5oInIW5LoJT6MlIV50nJR6n5nISJQ6m5oITJo5m5RJRJm5o5SJRJi5R6VJoIe5U6[JlI`5X6aJhIY5]6gJdIV5^6jJcIU5]6lJcIR5^6nJcIP5^6PKcIn4^6RKcIl4^6UKbIi4_6WKbIg4_6YKbIe4_6\\KaIb4a6]K`Ia4a6_K_I`4b6`K_I^4b6cK^I[4c6eK^IY4c6gK^IX4b6hK_IV4b6jK_IT4b6lK_IS4a6nK_IQ4a6oK`Io3a6QL`In3`6RLaIl3a6SL`Il3`6TLaIj3`6VLaIi3_6XL`Ig3a6YL`If3`6ZLaId3`6\\LaIc3_6]LbIa3_6_LbI`3^6`LcI^3^6bLcI]3]6dLcI[3]6eLdIZ3]6eLdIZ3\\6fLeIY3[6gLfIX3Z6hLgIW3Y6iLhIV3X6jLhIV3X6jLiIV3V6jLkIU3U6kLlIU3S6kLnIU3Q6kLPJU3o5kLRJT3n5lLSJT3m5kLTJU3k5kLVJU3i5kLXJT3h5lLaJl2^5TMjJe2U5[MkJf2T5ZMlJg2S5YMmJi2Q5WMoJk2o4UMQKm2m4SMSKo2k4PMVKR3h4nLXKT3g4kLYKW3e4iL[KZ3b4fL^K^3^4bLbKa3Z4`LfKd3S4_LmKe3P3XLkJ7S2d3n2^LeJNCIf2o3S3]LlJEl1S4_4mK]KV4hMjK_61dKb4`4\\K\\Kg4f4YKUKj4n4UKlJn4W5QKeJR5[5nJbJU5^5jJaJW5_5iJaJW5_5jJ_JX5`5hJ_JY5QOfJn51QKZ5POeJo52oJZ5ROeJn51oJ[5SOdJn51oJ\\5ROdJo50mJ]5TOcJo50lJ_5TObJo5OmJ_5VO`Jm51lJa5WO^Jl50mJc5e5]J[Jd5YO[Jh50oJf5[OZJd50PKh5]OYJi6g5f02N101N1QITJk5m5UJWJg5j5YJYJb5h5^J]J\\5e5dJ^JX5b5iJaJR5a5mJdJm4]5TKfJd0UO]2V6nLiJ>VOa2R6RMmJ4VOg2o5TMRKKTOo2j5WMYK_OROW3g5ZM]KUOPO_3d5\\M^La2c3`M^L^2c3aM_L\\2b3eM_LX2c3hM]LQ1RMQOa6NmJPO0m1dNTOa6OaJZO;_1dNXOa6OWJCf0R1cN]Oa6NlIMQ1c0eNE[6KfI6\\15eNo0V57VLgNeNT1T56XLaNhNX1Q56YL]NiN]1n45\\LZNiN`1l45]LVNkNd1h45`LRNkNh1f45jLgMcNS2d44QNKo15QNKP2oNVOn0l0SOSOe0V1ZOkN<^1EbN2g1MYNJP27PN@Y2`0gM^OZ2b0fM]O\\2c0dM\\O\\2d0dM[O]2f0cMXO_2g0bMWO_2j0`MVOa2j0_MTOb2l0^MSOd2m0\\MPOf2P1[MnNg2R1XMlNj2U1VMiNl2V1UMgNm2Z1l4O0100O0010O010O0100O010O010O10O01O010O010O10O010O0100O010O010O1O010O010O010O10O010O0100O0010O0100O010O010O010O10O01O010O10O010O0100O010O010O010O1O010O010O10O010O0100O010O0010O0100O010b0]Ol0UO`G", "size": [446, 640]}, "area": 61598.0, "iscrowd": 0, "image_id": 10463, "bbox": [169.0, 75.0, 471.0, 365.0], "category_id": 183, "id": 10012809}]} \ No newline at end of file diff --git a/src/taming-transformers/data/coco_annotations_100/annotations/stuff_val2017.json b/src/taming-transformers/data/coco_annotations_100/annotations/stuff_val2017.json new file mode 100644 index 0000000000000000000000000000000000000000..02769c6c0b86a75fb2079eab476fbee18d5be549 --- /dev/null +++ b/src/taming-transformers/data/coco_annotations_100/annotations/stuff_val2017.json @@ -0,0 +1 @@ +{"info": {"description": "COCO 2017 Stuff Dataset", "url": "http://cocodataset.org", "version": "1.0", "year": 2017, "contributor": "H. Caesar, J. Uijlings, M. Maire, T.-Y. Lin, P. Dollar and V. Ferrari", "date_created": "2017-08-31 00:00:00.0"}, "images": [{"license": 1, "file_name": "000000017627.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017627.jpg", "height": 480, "width": 640, "date_captured": "2013-11-16 15:13:53", "flickr_url": "http://farm5.staticflickr.com/4145/4977243989_c2efb1b911_z.jpg", "id": 17627}, {"license": 3, "file_name": "000000016228.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016228.jpg", "height": 440, "width": 640, "date_captured": "2013-11-19 00:09:53", "flickr_url": "http://farm4.staticflickr.com/3737/10031812195_372ae7538f_z.jpg", "id": 16228}, {"license": 2, "file_name": "000000011813.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011813.jpg", "height": 500, "width": 333, "date_captured": "2013-11-24 04:49:37", "flickr_url": "http://farm4.staticflickr.com/3545/3411897599_c3ae826bbb_z.jpg", "id": 11813}, {"license": 3, "file_name": "000000015079.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015079.jpg", "height": 424, "width": 640, "date_captured": "2013-11-20 14:57:40", "flickr_url": "http://farm8.staticflickr.com/7064/6970424809_69d949181f_z.jpg", "id": 15079}, {"license": 3, "file_name": "000000011197.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011197.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 03:59:36", "flickr_url": "http://farm8.staticflickr.com/7002/6732385791_cd9fcb9572_z.jpg", "id": 11197}, {"license": 3, "file_name": "000000016010.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016010.jpg", "height": 471, "width": 640, "date_captured": "2013-11-18 21:20:54", "flickr_url": "http://farm2.staticflickr.com/1134/950664990_8070cd6e3a_z.jpg", "id": 16010}, {"license": 3, "file_name": "000000018150.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018150.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 03:12:35", "flickr_url": "http://farm8.staticflickr.com/7155/6476497205_c725257677_z.jpg", "id": 18150}, {"license": 3, "file_name": "000000011760.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011760.jpg", "height": 425, "width": 640, "date_captured": "2013-11-18 18:15:02", "flickr_url": "http://farm3.staticflickr.com/2477/5856512283_9abe8e859f_z.jpg", "id": 11760}, {"license": 3, "file_name": "000000015278.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015278.jpg", "height": 480, "width": 640, "date_captured": "2013-11-19 23:14:33", "flickr_url": "http://farm4.staticflickr.com/3633/3291104715_bdec9818d3_z.jpg", "id": 15278}, {"license": 6, "file_name": "000000011051.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011051.jpg", "height": 536, "width": 640, "date_captured": "2013-11-18 05:42:28", "flickr_url": "http://farm4.staticflickr.com/3155/3281278459_15063a4662_z.jpg", "id": 11051}, {"license": 3, "file_name": "000000016958.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016958.jpg", "height": 428, "width": 640, "date_captured": "2013-11-21 20:49:33", "flickr_url": "http://farm8.staticflickr.com/7108/7435713066_78b44aae33_z.jpg", "id": 16958}, {"license": 2, "file_name": "000000010977.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010977.jpg", "height": 375, "width": 500, "date_captured": "2013-11-15 02:16:38", "flickr_url": "http://farm9.staticflickr.com/8060/8241415983_02d80c2fca_z.jpg", "id": 10977}, {"license": 1, "file_name": "000000017436.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017436.jpg", "height": 640, "width": 481, "date_captured": "2013-11-15 14:11:51", "flickr_url": "http://farm4.staticflickr.com/3265/2922590857_cc7c32cfaa_z.jpg", "id": 17436}, {"license": 4, "file_name": "000000013659.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013659.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 06:35:46", "flickr_url": "http://farm7.staticflickr.com/6144/5987177856_785814a990_z.jpg", "id": 13659}, {"license": 1, "file_name": "000000020059.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000020059.jpg", "height": 427, "width": 640, "date_captured": "2013-11-18 21:44:47", "flickr_url": "http://farm1.staticflickr.com/177/393601030_4451879068_z.jpg", "id": 20059}, {"license": 3, "file_name": "000000012576.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012576.jpg", "height": 640, "width": 480, "date_captured": "2013-11-21 01:24:50", "flickr_url": "http://farm3.staticflickr.com/2813/9012011605_cbb7999e2b_z.jpg", "id": 12576}, {"license": 4, "file_name": "000000014439.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014439.jpg", "height": 404, "width": 640, "date_captured": "2013-11-22 17:25:30", "flickr_url": "http://farm4.staticflickr.com/3544/3506151605_2a3530b2f9_z.jpg", "id": 14439}, {"license": 3, "file_name": "000000018575.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018575.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 01:42:34", "flickr_url": "http://farm4.staticflickr.com/3252/2464830020_ecf3bcf1c3_z.jpg", "id": 18575}, {"license": 2, "file_name": "000000013546.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013546.jpg", "height": 425, "width": 640, "date_captured": "2013-11-20 06:39:19", "flickr_url": "http://farm3.staticflickr.com/2689/4091707765_2f3bf944a7_z.jpg", "id": 13546}, {"license": 3, "file_name": "000000013923.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013923.jpg", "height": 427, "width": 640, "date_captured": "2013-11-21 21:17:47", "flickr_url": "http://farm9.staticflickr.com/8550/8973469217_ddac383dc5_z.jpg", "id": 13923}, {"license": 1, "file_name": "000000017379.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017379.jpg", "height": 640, "width": 478, "date_captured": "2013-11-15 01:16:56", "flickr_url": "http://farm6.staticflickr.com/5123/5316824279_9f0a0584c7_z.jpg", "id": 17379}, {"license": 1, "file_name": "000000010363.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010363.jpg", "height": 361, "width": 640, "date_captured": "2013-11-15 07:08:52", "flickr_url": "http://farm4.staticflickr.com/3027/2477308902_443e5baf08_z.jpg", "id": 10363}, {"license": 2, "file_name": "000000017178.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017178.jpg", "height": 427, "width": 640, "date_captured": "2013-11-15 08:30:55", "flickr_url": "http://farm4.staticflickr.com/3354/3626704406_be9d80e909_z.jpg", "id": 17178}, {"license": 1, "file_name": "000000015338.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015338.jpg", "height": 424, "width": 640, "date_captured": "2013-11-16 17:43:06", "flickr_url": "http://farm9.staticflickr.com/8526/8519097250_f635a04651_z.jpg", "id": 15338}, {"license": 3, "file_name": "000000011122.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011122.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 09:24:02", "flickr_url": "http://farm4.staticflickr.com/3278/3105013044_2f108fed95_z.jpg", "id": 11122}, {"license": 5, "file_name": "000000010707.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010707.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 23:35:53", "flickr_url": "http://farm1.staticflickr.com/147/434840964_a9c5bc3b58_z.jpg", "id": 10707}, {"license": 4, "file_name": "000000012120.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012120.jpg", "height": 428, "width": 640, "date_captured": "2013-11-23 03:42:48", "flickr_url": "http://farm4.staticflickr.com/3492/3179857331_fdd8bbd30f_z.jpg", "id": 12120}, {"license": 1, "file_name": "000000018193.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018193.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 13:24:37", "flickr_url": "http://farm1.staticflickr.com/242/516677812_f03351fffd_z.jpg", "id": 18193}, {"license": 3, "file_name": "000000019109.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019109.jpg", "height": 428, "width": 640, "date_captured": "2013-11-17 02:08:36", "flickr_url": "http://farm8.staticflickr.com/7223/7017616831_24cd0b6131_z.jpg", "id": 19109}, {"license": 4, "file_name": "000000013291.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013291.jpg", "height": 335, "width": 500, "date_captured": "2013-11-18 16:17:44", "flickr_url": "http://farm4.staticflickr.com/3394/3491087208_8efdfeb6d4_z.jpg", "id": 13291}, {"license": 1, "file_name": "000000017714.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017714.jpg", "height": 480, "width": 640, "date_captured": "2013-11-24 14:14:00", "flickr_url": "http://farm7.staticflickr.com/6133/5943387737_ffd52a7f27_z.jpg", "id": 17714}, {"license": 4, "file_name": "000000012062.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012062.jpg", "height": 427, "width": 640, "date_captured": "2013-11-16 20:16:30", "flickr_url": "http://farm4.staticflickr.com/3775/9086068242_2064357878_z.jpg", "id": 12062}, {"license": 4, "file_name": "000000015517.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015517.jpg", "height": 480, "width": 640, "date_captured": "2013-11-16 23:41:40", "flickr_url": "http://farm9.staticflickr.com/8184/8407007011_9456edeb6d_z.jpg", "id": 15517}, {"license": 1, "file_name": "000000010764.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010764.jpg", "height": 424, "width": 640, "date_captured": "2013-11-19 19:23:45", "flickr_url": "http://farm3.staticflickr.com/2714/5810596234_b5090d75f6_z.jpg", "id": 10764}, {"license": 4, "file_name": "000000015272.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015272.jpg", "height": 640, "width": 424, "date_captured": "2013-11-16 12:18:43", "flickr_url": "http://farm9.staticflickr.com/8386/8584364941_15ab4eb0e4_z.jpg", "id": 15272}, {"license": 3, "file_name": "000000010583.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010583.jpg", "height": 612, "width": 612, "date_captured": "2013-11-20 14:18:50", "flickr_url": "http://farm9.staticflickr.com/8497/8288720209_c13ea818f8_z.jpg", "id": 10583}, {"license": 4, "file_name": "000000017029.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017029.jpg", "height": 640, "width": 640, "date_captured": "2013-11-18 14:33:10", "flickr_url": "http://farm8.staticflickr.com/7304/8746020648_f1e2075b86_z.jpg", "id": 17029}, {"license": 2, "file_name": "000000012748.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012748.jpg", "height": 640, "width": 480, "date_captured": "2013-11-19 01:51:12", "flickr_url": "http://farm8.staticflickr.com/7295/9090127695_6dc690f776_z.jpg", "id": 12748}, {"license": 1, "file_name": "000000015597.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015597.jpg", "height": 640, "width": 433, "date_captured": "2013-11-20 01:36:59", "flickr_url": "http://farm7.staticflickr.com/6128/5960989557_660cd5f173_z.jpg", "id": 15597}, {"license": 4, "file_name": "000000013348.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013348.jpg", "height": 427, "width": 640, "date_captured": "2013-11-16 14:52:33", "flickr_url": "http://farm9.staticflickr.com/8286/7733450942_0da3e941b4_z.jpg", "id": 13348}, {"license": 3, "file_name": "000000011699.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011699.jpg", "height": 640, "width": 480, "date_captured": "2013-11-18 10:35:30", "flickr_url": "http://farm7.staticflickr.com/6010/5946492599_6248b4620e_z.jpg", "id": 11699}, {"license": 1, "file_name": "000000010995.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010995.jpg", "height": 480, "width": 640, "date_captured": "2013-11-20 21:22:47", "flickr_url": "http://farm4.staticflickr.com/3438/3815505319_1c077a82b6_z.jpg", "id": 10995}, {"license": 1, "file_name": "000000015497.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015497.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 00:19:02", "flickr_url": "http://farm3.staticflickr.com/2197/2269556612_b210991e62_z.jpg", "id": 15497}, {"license": 2, "file_name": "000000017115.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017115.jpg", "height": 640, "width": 443, "date_captured": "2013-11-18 18:09:41", "flickr_url": "http://farm6.staticflickr.com/5189/5672755536_fd276c33d6_z.jpg", "id": 17115}, {"license": 6, "file_name": "000000019742.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019742.jpg", "height": 374, "width": 500, "date_captured": "2013-11-24 03:31:54", "flickr_url": "http://farm1.staticflickr.com/70/194348221_493851f79b_z.jpg", "id": 19742}, {"license": 4, "file_name": "000000011149.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011149.jpg", "height": 375, "width": 500, "date_captured": "2013-11-15 04:15:40", "flickr_url": "http://farm4.staticflickr.com/3625/3323418866_ea5017538d_z.jpg", "id": 11149}, {"license": 2, "file_name": "000000017207.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017207.jpg", "height": 480, "width": 640, "date_captured": "2013-11-15 10:53:00", "flickr_url": "http://farm6.staticflickr.com/5131/5537426848_a4508fe44f_z.jpg", "id": 17207}, {"license": 6, "file_name": "000000018737.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018737.jpg", "height": 427, "width": 640, "date_captured": "2013-11-15 18:31:53", "flickr_url": "http://farm5.staticflickr.com/4026/4511471485_c1791c0767_z.jpg", "id": 18737}, {"license": 1, "file_name": "000000015751.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015751.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 05:52:45", "flickr_url": "http://farm8.staticflickr.com/7351/9419515091_a211b75ce5_z.jpg", "id": 15751}, {"license": 1, "file_name": "000000014888.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014888.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 18:50:25", "flickr_url": "http://farm9.staticflickr.com/8380/8634330041_a47c2cdaeb_z.jpg", "id": 14888}, {"license": 3, "file_name": "000000020333.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000020333.jpg", "height": 640, "width": 427, "date_captured": "2013-11-18 04:03:40", "flickr_url": "http://farm5.staticflickr.com/4027/4697218785_7f0414cdf8_z.jpg", "id": 20333}, {"license": 4, "file_name": "000000012280.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012280.jpg", "height": 640, "width": 480, "date_captured": "2013-11-18 07:29:51", "flickr_url": "http://farm9.staticflickr.com/8516/8544258219_95e49e415e_z.jpg", "id": 12280}, {"license": 5, "file_name": "000000010092.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000010092.jpg", "height": 426, "width": 640, "date_captured": "2013-11-21 00:20:22", "flickr_url": "http://farm9.staticflickr.com/8276/8710590452_08a7a8f59c_z.jpg", "id": 10092}, {"license": 1, "file_name": "000000019221.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019221.jpg", "height": 478, "width": 640, "date_captured": "2013-11-19 22:51:01", "flickr_url": "http://farm7.staticflickr.com/6156/6237638989_9d2c007615_z.jpg", "id": 19221}, {"license": 1, "file_name": "000000018770.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018770.jpg", "height": 428, "width": 640, "date_captured": "2013-11-18 02:44:01", "flickr_url": "http://farm9.staticflickr.com/8020/7499130232_34bd20c007_z.jpg", "id": 18770}, {"license": 3, "file_name": "000000012639.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012639.jpg", "height": 640, "width": 480, "date_captured": "2013-11-22 21:09:08", "flickr_url": "http://farm5.staticflickr.com/4102/4795012771_81c0b6b502_z.jpg", "id": 12639}, {"license": 3, "file_name": "000000012670.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012670.jpg", "height": 428, "width": 640, "date_captured": "2013-11-24 01:39:03", "flickr_url": "http://farm5.staticflickr.com/4144/5072551441_fd302a2c44_z.jpg", "id": 12670}, {"license": 3, "file_name": "000000014038.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014038.jpg", "height": 427, "width": 640, "date_captured": "2013-11-24 11:18:00", "flickr_url": "http://farm9.staticflickr.com/8507/8561635383_4bc0c679dd_z.jpg", "id": 14038}, {"license": 4, "file_name": "000000020247.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000020247.jpg", "height": 457, "width": 640, "date_captured": "2013-11-18 14:33:42", "flickr_url": "http://farm8.staticflickr.com/7027/6473127891_50c1ca2c03_z.jpg", "id": 20247}, {"license": 3, "file_name": "000000015956.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015956.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 23:12:04", "flickr_url": "http://farm5.staticflickr.com/4057/5078510649_c131c12862_z.jpg", "id": 15956}, {"license": 3, "file_name": "000000011615.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011615.jpg", "height": 640, "width": 480, "date_captured": "2013-11-17 07:15:52", "flickr_url": "http://farm1.staticflickr.com/47/151953288_f6b6a50f78_z.jpg", "id": 11615}, {"license": 3, "file_name": "000000014380.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014380.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 09:54:28", "flickr_url": "http://farm6.staticflickr.com/5463/8750190611_325720f243_z.jpg", "id": 14380}, {"license": 1, "file_name": "000000018519.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018519.jpg", "height": 640, "width": 515, "date_captured": "2013-11-20 01:22:59", "flickr_url": "http://farm8.staticflickr.com/7199/6892325386_145a03efa0_z.jpg", "id": 18519}, {"license": 4, "file_name": "000000019924.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019924.jpg", "height": 500, "width": 458, "date_captured": "2013-11-18 01:01:49", "flickr_url": "http://farm4.staticflickr.com/3407/3642510664_1c89fbc90a_z.jpg", "id": 19924}, {"license": 3, "file_name": "000000016598.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016598.jpg", "height": 640, "width": 478, "date_captured": "2013-11-18 03:39:49", "flickr_url": "http://farm6.staticflickr.com/5091/5391571396_41823477da_z.jpg", "id": 16598}, {"license": 5, "file_name": "000000013774.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013774.jpg", "height": 480, "width": 640, "date_captured": "2013-11-18 18:22:53", "flickr_url": "http://farm8.staticflickr.com/7167/6837122127_de8b1f8d77_z.jpg", "id": 13774}, {"license": 5, "file_name": "000000018491.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018491.jpg", "height": 427, "width": 640, "date_captured": "2013-11-19 17:54:54", "flickr_url": "http://farm3.staticflickr.com/2134/5814907667_496ae24446_z.jpg", "id": 18491}, {"license": 4, "file_name": "000000012667.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000012667.jpg", "height": 480, "width": 640, "date_captured": "2013-11-15 15:06:56", "flickr_url": "http://farm1.staticflickr.com/197/499050773_995cd1e9bb_z.jpg", "id": 12667}, {"license": 3, "file_name": "000000013201.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013201.jpg", "height": 640, "width": 427, "date_captured": "2013-11-19 21:57:52", "flickr_url": "http://farm9.staticflickr.com/8391/8577059857_69c575151f_z.jpg", "id": 13201}, {"license": 1, "file_name": "000000017959.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017959.jpg", "height": 427, "width": 640, "date_captured": "2013-11-22 18:46:36", "flickr_url": "http://farm4.staticflickr.com/3031/2389030002_e3a04076c3_z.jpg", "id": 17959}, {"license": 1, "file_name": "000000017899.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017899.jpg", "height": 640, "width": 480, "date_captured": "2013-11-14 15:45:58", "flickr_url": "http://farm8.staticflickr.com/7031/6746562893_cbf91d331c_z.jpg", "id": 17899}, {"license": 4, "file_name": "000000015746.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015746.jpg", "height": 640, "width": 427, "date_captured": "2013-11-16 21:36:18", "flickr_url": "http://farm4.staticflickr.com/3643/3517907686_509f46055f_z.jpg", "id": 15746}, {"license": 4, "file_name": "000000014473.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014473.jpg", "height": 427, "width": 640, "date_captured": "2013-11-17 11:06:09", "flickr_url": "http://farm9.staticflickr.com/8401/8607706408_e00725a54d_z.jpg", "id": 14473}, {"license": 1, "file_name": "000000014831.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014831.jpg", "height": 640, "width": 480, "date_captured": "2013-11-17 19:58:56", "flickr_url": "http://farm9.staticflickr.com/8113/8656986875_366dec25c9_z.jpg", "id": 14831}, {"license": 1, "file_name": "000000016502.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016502.jpg", "height": 500, "width": 375, "date_captured": "2013-11-16 18:53:28", "flickr_url": "http://farm1.staticflickr.com/153/388880244_55dd5edd8e_z.jpg", "id": 16502}, {"license": 3, "file_name": "000000015254.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015254.jpg", "height": 427, "width": 640, "date_captured": "2013-11-20 01:29:32", "flickr_url": "http://farm1.staticflickr.com/140/385285808_120242fcc0_z.jpg", "id": 15254}, {"license": 1, "file_name": "000000015660.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015660.jpg", "height": 348, "width": 640, "date_captured": "2013-11-22 08:41:16", "flickr_url": "http://farm4.staticflickr.com/3356/3414127711_6772851b0d_z.jpg", "id": 15660}, {"license": 5, "file_name": "000000011511.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000011511.jpg", "height": 464, "width": 640, "date_captured": "2013-11-16 13:42:03", "flickr_url": "http://farm8.staticflickr.com/7124/7556029168_519acfdf09_z.jpg", "id": 11511}, {"license": 3, "file_name": "000000017905.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017905.jpg", "height": 640, "width": 480, "date_captured": "2013-11-16 18:01:33", "flickr_url": "http://farm1.staticflickr.com/44/173771776_53b9c22bb6_z.jpg", "id": 17905}, {"license": 1, "file_name": "000000013597.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013597.jpg", "height": 425, "width": 640, "date_captured": "2013-11-19 20:18:39", "flickr_url": "http://farm5.staticflickr.com/4040/4474734743_bc5e8973c7_z.jpg", "id": 13597}, {"license": 3, "file_name": "000000020107.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000020107.jpg", "height": 500, "width": 333, "date_captured": "2013-11-16 23:28:30", "flickr_url": "http://farm2.staticflickr.com/1311/968078473_4a7d696ec6_z.jpg", "id": 20107}, {"license": 1, "file_name": "000000018833.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018833.jpg", "height": 426, "width": 640, "date_captured": "2013-11-17 16:35:54", "flickr_url": "http://farm1.staticflickr.com/92/217798870_1d648607b4_z.jpg", "id": 18833}, {"license": 1, "file_name": "000000016439.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016439.jpg", "height": 480, "width": 640, "date_captured": "2013-11-22 19:14:13", "flickr_url": "http://farm1.staticflickr.com/52/171945415_f37fb5d1b2_z.jpg", "id": 16439}, {"license": 3, "file_name": "000000016451.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016451.jpg", "height": 612, "width": 612, "date_captured": "2013-11-20 20:12:37", "flickr_url": "http://farm8.staticflickr.com/7460/9050893513_1fb9508000_z.jpg", "id": 16451}, {"license": 5, "file_name": "000000019432.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019432.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 04:39:45", "flickr_url": "http://farm6.staticflickr.com/5131/5533564723_6f1633b85e_z.jpg", "id": 19432}, {"license": 3, "file_name": "000000019786.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019786.jpg", "height": 375, "width": 500, "date_captured": "2013-11-22 00:20:10", "flickr_url": "http://farm1.staticflickr.com/115/317277248_05f5ac031e_z.jpg", "id": 19786}, {"license": 1, "file_name": "000000017031.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017031.jpg", "height": 334, "width": 500, "date_captured": "2013-11-16 22:09:32", "flickr_url": "http://farm4.staticflickr.com/3431/3811840964_b913f6f140_z.jpg", "id": 17031}, {"license": 5, "file_name": "000000018837.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018837.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 18:58:56", "flickr_url": "http://farm9.staticflickr.com/8219/8372455764_124e052754_z.jpg", "id": 18837}, {"license": 3, "file_name": "000000014007.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014007.jpg", "height": 426, "width": 640, "date_captured": "2013-11-24 11:03:51", "flickr_url": "http://farm8.staticflickr.com/7161/6701691801_dc2cee1aa9_z.jpg", "id": 14007}, {"license": 1, "file_name": "000000018380.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000018380.jpg", "height": 426, "width": 640, "date_captured": "2013-11-25 14:13:45", "flickr_url": "http://farm6.staticflickr.com/5474/9701242334_0797348359_z.jpg", "id": 18380}, {"license": 3, "file_name": "000000016249.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000016249.jpg", "height": 365, "width": 500, "date_captured": "2013-11-14 12:26:50", "flickr_url": "http://farm4.staticflickr.com/3168/2931904036_1c5828e037_z.jpg", "id": 16249}, {"license": 4, "file_name": "000000013004.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013004.jpg", "height": 500, "width": 375, "date_captured": "2013-11-19 21:30:33", "flickr_url": "http://farm5.staticflickr.com/4049/4208826429_3432119060_z.jpg", "id": 13004}, {"license": 4, "file_name": "000000019402.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019402.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 04:31:37", "flickr_url": "http://farm5.staticflickr.com/4135/5435897535_a9b3e0a053_z.jpg", "id": 19402}, {"license": 3, "file_name": "000000013177.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013177.jpg", "height": 427, "width": 640, "date_captured": "2013-11-15 20:03:10", "flickr_url": "http://farm8.staticflickr.com/7127/7607618094_78c23b097e_z.jpg", "id": 13177}, {"license": 3, "file_name": "000000014226.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000014226.jpg", "height": 480, "width": 640, "date_captured": "2013-11-17 04:22:03", "flickr_url": "http://farm1.staticflickr.com/6/6710769_d74169f5b7_z.jpg", "id": 14226}, {"license": 2, "file_name": "000000015440.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015440.jpg", "height": 640, "width": 404, "date_captured": "2013-11-17 09:50:00", "flickr_url": "http://farm4.staticflickr.com/3261/2870016347_39ffc0ca45_z.jpg", "id": 15440}, {"license": 4, "file_name": "000000017182.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000017182.jpg", "height": 428, "width": 640, "date_captured": "2013-11-19 22:30:23", "flickr_url": "http://farm4.staticflickr.com/3020/2906486794_80400b009e_z.jpg", "id": 17182}, {"license": 6, "file_name": "000000019042.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000019042.jpg", "height": 371, "width": 640, "date_captured": "2013-11-17 01:03:41", "flickr_url": "http://farm8.staticflickr.com/7289/9652593344_4469e9a6f1_z.jpg", "id": 19042}, {"license": 2, "file_name": "000000013729.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000013729.jpg", "height": 480, "width": 640, "date_captured": "2013-11-21 20:10:40", "flickr_url": "http://farm2.staticflickr.com/1009/559099100_98414a0e66_z.jpg", "id": 13729}, {"license": 2, "file_name": "000000015335.jpg", "coco_url": "http://images.cocodataset.org/val2017/000000015335.jpg", "height": 480, "width": 640, "date_captured": "2013-11-25 14:00:10", "flickr_url": "http://farm6.staticflickr.com/5533/10257288534_c916fafd78_z.jpg", "id": 15335}], "licenses": [{"url": "http://creativecommons.org/licenses/by-nc-sa/2.0/", "id": 1, "name": "Attribution-NonCommercial-ShareAlike License"}, {"url": "http://creativecommons.org/licenses/by-nc/2.0/", "id": 2, "name": "Attribution-NonCommercial License"}, {"url": "http://creativecommons.org/licenses/by-nc-nd/2.0/", "id": 3, "name": "Attribution-NonCommercial-NoDerivs License"}, {"url": "http://creativecommons.org/licenses/by/2.0/", "id": 4, "name": "Attribution License"}, {"url": "http://creativecommons.org/licenses/by-sa/2.0/", "id": 5, "name": "Attribution-ShareAlike License"}, {"url": "http://creativecommons.org/licenses/by-nd/2.0/", "id": 6, "name": "Attribution-NoDerivs License"}, {"url": "http://flickr.com/commons/usage/", "id": 7, "name": "No known copyright restrictions"}, {"url": "http://www.usa.gov/copyright.shtml", "id": 8, "name": "United States Government Work"}], "categories": [{"supercategory": "textile", "id": 92, "name": "banner"}, {"supercategory": "textile", "id": 93, "name": "blanket"}, {"supercategory": "plant", "id": 94, "name": "branch"}, {"supercategory": "building", "id": 95, "name": "bridge"}, {"supercategory": "building", "id": 96, "name": "building-other"}, {"supercategory": "plant", "id": 97, "name": "bush"}, {"supercategory": "furniture-stuff", "id": 98, "name": "cabinet"}, {"supercategory": "structural", "id": 99, "name": "cage"}, {"supercategory": "raw-material", "id": 100, "name": "cardboard"}, {"supercategory": "floor", "id": 101, "name": "carpet"}, {"supercategory": "ceiling", "id": 102, "name": "ceiling-other"}, {"supercategory": "ceiling", "id": 103, "name": "ceiling-tile"}, {"supercategory": "textile", "id": 104, "name": "cloth"}, {"supercategory": "textile", "id": 105, "name": "clothes"}, {"supercategory": "sky", "id": 106, "name": "clouds"}, {"supercategory": "furniture-stuff", "id": 107, "name": "counter"}, {"supercategory": "furniture-stuff", "id": 108, "name": "cupboard"}, {"supercategory": "textile", "id": 109, "name": "curtain"}, {"supercategory": "furniture-stuff", "id": 110, "name": "desk-stuff"}, {"supercategory": "ground", "id": 111, "name": "dirt"}, {"supercategory": "furniture-stuff", "id": 112, "name": "door-stuff"}, {"supercategory": "structural", "id": 113, "name": "fence"}, {"supercategory": "floor", "id": 114, "name": "floor-marble"}, {"supercategory": "floor", "id": 115, "name": "floor-other"}, {"supercategory": "floor", "id": 116, "name": "floor-stone"}, {"supercategory": "floor", "id": 117, "name": "floor-tile"}, {"supercategory": "floor", "id": 118, "name": "floor-wood"}, {"supercategory": "plant", "id": 119, "name": "flower"}, {"supercategory": "water", "id": 120, "name": "fog"}, {"supercategory": "food-stuff", "id": 121, "name": "food-other"}, {"supercategory": "food-stuff", "id": 122, "name": "fruit"}, {"supercategory": "furniture-stuff", "id": 123, "name": "furniture-other"}, {"supercategory": "plant", "id": 124, "name": "grass"}, {"supercategory": "ground", "id": 125, "name": "gravel"}, {"supercategory": "ground", "id": 126, "name": "ground-other"}, {"supercategory": "solid", "id": 127, "name": "hill"}, {"supercategory": "building", "id": 128, "name": "house"}, {"supercategory": "plant", "id": 129, "name": "leaves"}, {"supercategory": "furniture-stuff", "id": 130, "name": "light"}, {"supercategory": "textile", "id": 131, "name": "mat"}, {"supercategory": "raw-material", "id": 132, "name": "metal"}, {"supercategory": "furniture-stuff", "id": 133, "name": "mirror-stuff"}, {"supercategory": "plant", "id": 134, "name": "moss"}, {"supercategory": "solid", "id": 135, "name": "mountain"}, {"supercategory": "ground", "id": 136, "name": "mud"}, {"supercategory": "textile", "id": 137, "name": "napkin"}, {"supercategory": "structural", "id": 138, "name": "net"}, {"supercategory": "raw-material", "id": 139, "name": "paper"}, {"supercategory": "ground", "id": 140, "name": "pavement"}, {"supercategory": "textile", "id": 141, "name": "pillow"}, {"supercategory": "plant", "id": 142, "name": "plant-other"}, {"supercategory": "raw-material", "id": 143, "name": "plastic"}, {"supercategory": "ground", "id": 144, "name": "platform"}, {"supercategory": "ground", "id": 145, "name": "playingfield"}, {"supercategory": "structural", "id": 146, "name": "railing"}, {"supercategory": "ground", "id": 147, "name": "railroad"}, {"supercategory": "water", "id": 148, "name": "river"}, {"supercategory": "ground", "id": 149, "name": "road"}, {"supercategory": "solid", "id": 150, "name": "rock"}, {"supercategory": "building", "id": 151, "name": "roof"}, {"supercategory": "textile", "id": 152, "name": "rug"}, {"supercategory": "food-stuff", "id": 153, "name": "salad"}, {"supercategory": "ground", "id": 154, "name": "sand"}, {"supercategory": "water", "id": 155, "name": "sea"}, {"supercategory": "furniture-stuff", "id": 156, "name": "shelf"}, {"supercategory": "sky", "id": 157, "name": "sky-other"}, {"supercategory": "building", "id": 158, "name": "skyscraper"}, {"supercategory": "ground", "id": 159, "name": "snow"}, {"supercategory": "solid", "id": 160, "name": "solid-other"}, {"supercategory": "furniture-stuff", "id": 161, "name": "stairs"}, {"supercategory": "solid", "id": 162, "name": "stone"}, {"supercategory": "plant", "id": 163, "name": "straw"}, {"supercategory": "structural", "id": 164, "name": "structural-other"}, {"supercategory": "furniture-stuff", "id": 165, "name": "table"}, {"supercategory": "building", "id": 166, "name": "tent"}, {"supercategory": "textile", "id": 167, "name": "textile-other"}, {"supercategory": "textile", "id": 168, "name": "towel"}, {"supercategory": "plant", "id": 169, "name": "tree"}, {"supercategory": "food-stuff", "id": 170, "name": "vegetable"}, {"supercategory": "wall", "id": 171, "name": "wall-brick"}, {"supercategory": "wall", "id": 172, "name": "wall-concrete"}, {"supercategory": "wall", "id": 173, "name": "wall-other"}, {"supercategory": "wall", "id": 174, "name": "wall-panel"}, {"supercategory": "wall", "id": 175, "name": "wall-stone"}, {"supercategory": "wall", "id": 176, "name": "wall-tile"}, {"supercategory": "wall", "id": 177, "name": "wall-wood"}, {"supercategory": "water", "id": 178, "name": "water-other"}, {"supercategory": "water", "id": 179, "name": "waterdrops"}, {"supercategory": "window", "id": 180, "name": "window-blind"}, {"supercategory": "window", "id": 181, "name": "window-other"}, {"supercategory": "solid", "id": 182, "name": "wood"}, {"supercategory": "other", "id": 183, "name": "other"}], "annotations": [{"segmentation": {"counts": "m:Z1R`2j0^OZ2kMlK;e0Jb04kNk1i10]2TNaLHP2Q1TOR1[2SN@h0WNS1Z2SNFd0QNX1Y2TNIa0PNY1W2VNGc0[NP1o1YNO?RNY1n1XN07hKNZ2f1V6[NaGNY2j1V6UNbG1X2k1U6SNeG1V2k1W6RNdG2W20cMh1j8WNcI0dMj1[;0013M4M11M4L2N2N1O4L3nDnMf:R2ZERNb:o1]ETN`:l1`ETNR1DoN0V9X2iFTNm07P8f1RGSNo07n7T2PHoMo7Q2WHlMf7U2\\HgMe7X2\\HlMVO@i7d2QITNnNCf7X2]ISOY6m0fIYOlNSNS7h2nIBj5P1dIVOA_M`6l6I1O4L6J5PJfHf5h7`JVHn4Z8IV7BiH=Y7CgH=Y7ChHl0h6TOXIm0g6SOYIm0g6SOYIo0e6QOZIR1d6nN\\IR1d6nN\\IQ1e6oN[IP1f6POZIP1f6POZIP1f6POZIP1f6POZIP1XObMj6^1nIP1YO_Mk6a1lIS1kN\\M5:l6W1TJl1j5TNVJP2f5PNZJQ2f5nMZJT2d5lM\\J\\2\\5dMcJ`2Z5`MfJ`2Z5`MgJ`2X5`MgJb2X5^MiJb2V5^MiJd2V5\\MjJd2V5\\MjJf2T5ZMlJf2T5ZMlJJkN^1Z6hNkJGPOc1Q6fNoJAUOk1k5dNPK@ZOg1g5iNPKiNkN0OIR1>mNU1X6KPKbNTO1HMo0>N8X5j0nLmNkM;T5h0dNUO]1k0dNPO`1P1_NPOb1P1^NQOa1o0bNmN_1S1dNkN[1U1eNkN[1U1eNkN[1U1eNjN\\1V1dNaNQK5[6Z1eN`NQK1^6_1aN`Nd10[I^1n4eNg1M[I^1h;bNXD^1h;bNXD^1k;O0LUDiNk;V1VDjNj;U1WDkNi;U1WDkNj;S1XDlNh;T1XDlNh;S1ZDlNl;l0\\a2TOi_M1000000O100O1gN7`D:T;T1N2M3N2N2N2M3N2N2M3N2N2M3N2N2N2I7]Oc0]Oc0^Ob0001O0dKlGb3Y8XLiGg3Y8SLkGm3i80O1000000N2O1001OO11O1ON2O1O1O1001O1O1RLiFg3`9M2N1O1O00H800000000000000000000FTLVGl3j8TLUGm3k8TLTGl3k8XLPGj3n8:O100L4O100001O000000000000002N1O0000O1N2000000001O1O3M3M00000000000000000000000000N2O1N2N2N200000000000000001O000VLVGT3j8lLYG_11YOf8XO[G]10ZOe8YO^GY10\\Ob8[OaGg0=MR8\\OcGJX1h0T7_OkI?U6AnIT3BjK]5=nLnNnM?T5b0PMmNRNfEVOc:i0]EWOc:i0]EWOc:i0]EWOc:h0^EXOb:h0_EWOa:i0^EXOb:h0_EWOa:i0_EWOa:i0_EWOa:i0_EWOb:h0^EXOZ:IUEo0a0WOT:LWE01o0e0TOR:3XEk0i0mNQ:_1m000010O0O10000000dN[DKOU1g;lNdDP1l;N100000O1000000O100001OO101O0VDnN\\;R1dDoNZ;R1eDROY;b1M02cNaDk0`;oNcDS1^;iNeDW1g;0003SOUD5eb0B@<`0D^O=c0CTOUOTK\\1h5_OUOd0l0\\OSOe0m0[OQOg0o0YOQOf0P1ZOoNg0Q1YOnNh0R1ZOmNe0S1[OkNg0U1XOlNh0T1XOlNh0T1XOkNi0U1VO[NZOQLa1d5UOYN_OmK_1j5ROVN`1j1`NSNc1m1]N^M\\OnLZ2d5[NXM\\2h2dMXM\\2h2cMYM]2g2dMXM\\2h2dMYM[2g2eMZMZ2f2fMZMZ2f2fMYM[2g2eMYM[2g2eMYMZ2h2fMXMZ2h2fMXMZ2h2fMWM[2i2eMWM[2i2eMVM\\2j2dMVM\\2j2cMWM]2i2cMVM^2j2aMWM_2i2aMVM`2j2_MVJUOm2\\3m2_MVJUOm2\\3m2_MVJUOl2]3n2^MUJVOl2]3o2]MUJVOl2]3o2]MUJVOk2^3P3`MPM`2P3`MoLa2Q3`MnL`2R3`MmLa2S3_MlLb2T3^MlLb2T3^MkLc2U3]MjLd2V3\\MjLd2V3\\MiLe2W3[MhLf2X3ZMhLf2X3ZMgLg2Y3YMfLh2Z3XMfLg2[3YMdLh2\\3XMcLi2]3WMbLj2^3VMbLj2^3VMcLi2]3WM_Lm2a3SM_Lm2a3SM^Ln2b3RM]Lo2c3QM\\LP3d3PM]Lo2c3QM^Ln2b3RM^Ln2b3RM^Ln2b3RM_Lm2a3lLTJ[O\\2h3`3eLTJ@0N43Z2h3^3gLUJ_O70W2i3]3hLVJ^Oi2i3Q3iLTMV3l2jLTMV3l2iLUMW3k2iLVMV3j2jLWMU3i2kLWMU3i2kLXMT3h2lLXMT3h2kLZMT3f2lLZMT3f2kL[MU3e2kL\\MT3d2lL\\MT3d2lL\\MT3d2lL]MS3c2lL\\MV3d2jLZMX3f2gL[MY3e2gLZMZ3f2fL[MY3e2fL]MY3c2gLVJDT3d3f2hLUJEU3c3f2hLUJEV3b3e2iLTJFW3a3e2iLTJGU3a3g2mLXMT3h2lLYMS3g2mL`Ml2`2TMaMk2_2UMaMk2_2UMaMk2_2UMbMj2^2VMbMj2^2QMTJG\\3Z3`2mLTJF01a3Z3Z2nLmMQ3S2lLmMW3S2hLTNR3l1iL]N6PL]2^:ON200`0@1O002N2N00O1O10000000^NlDn0T;SOiDo0Z;cNfD5:P1i;N4L1O2N8H3M001O1O1O1O002N00O14L4L1O005Ked]3", "size": [426, 640]}, "area": 21217.0, "iscrowd": 0, "image_id": 10092, "bbox": [96.0, 57.0, 280.0, 353.0], "category_id": 167, "id": 20000608}, {"segmentation": {"counts": "c0T1i5Y2WMgMi2[2UMeMk2[2UMeMj2[2XMdMh2\\2XMdMh2[2YMeMg2[2YMeMg2Z2[MeMd2\\2\\MdMd2\\2\\MdMd2\\2\\MdMd2[2^MdMb2[2_MeMa2[2_MeM`2[2bMcM_2]2aMbM`2]2aMaMa2]2bMaM\\2WOYJX3\\3_M\\2ZOXJX3[3]M]2g2dMXM[2i2eMWM[2j2dMVM[2l2dMTMY2n2iMRMV2n2jMRMU2P3jMQMT2P3lMQMS2o2nMoLR2R3nMlLS2U3mMkLX2P3iMmLZ2BYJ\\3]3PM\\2DWJ[3^3PM\\2DWJ[3^3QM[2CXJ[3_3PMZ2EWJZ3`3QMY2EWJY3a3SM[2m2fMRM[21RJ]2c3bM_2HTJe2]3cMl2\\2TMdMR3N\\Ik1c3VNa4g0_KZOc4c0]K]Oi4=WKCl4:UKEi4=WKEo43QKNn4J]GNe3;k4FaGNf3=i4BbG1e3>h4@eG1c3>j4_OdG2c3`0Q5_OPKa0l8O100010O3M4M1N2N1O4LO20O0001O0000000000010O001O00010OhCSOSRNc0T3\\OmLc0S3]OmLe0Q3[OoL0eK5^7JmLNSLMP75mLMk33VLGP48a40001N11OM4O00010O01O00005SGNY40hKd0d3^OYHG41Z3k0X44eKK[4:[JlNkNk0j6;XJXO`N>X7:kHSO;g1i6WOjHXOFC3o1]7VOiHY2W7gMjHX2V7hMjHX2V7hMjHX2V7gMkHY2U7gMkHY2U7fMmHY2S7gMPIV2P7\\M[HXONM30]1f2W6TNaJXOnMP2a7hNXKl0h4SOYKm0g4SOYKn0f4RO[Kn0d4RO\\Kn0c4SO]Km0c4SO]Km0c4SO]Km0c4SO]Kl0d4SO]Kl0c4UO]Kj0d4VO\\Ki0e4XOZKg0g4YOXKi0g4WOYKi0g4WOYKg0Z4^NSIk0c2f0Z4aNRIi0d24QM_OZ7EPIh0h2IXMFQ7KmHg0l2EYMFl61oHd0n2CWMGl63oHc0n2BYMEj69nH`0n2B[MDi6o2C[MAk6=kH?o2Dh4LSHF1k0U3De41UH;W3Dc42UH:W3Fb41WH9X3Eb4P1^KoNa4S1_KlNb4T1^KkNc4T1^KkNd4T1\\KkNf4T1ZKkNh4S1YKhNn4V1SKdNS5[1_3N2OO0101N010N2N200001O0O3M2M2N3hDbNb:^1\\E[Ol9f0TFH^98aFJ^97aFHa98]FGe9o10O1O110M2000O01_OSFdMn9Z2WF`Mk9^2b0M4ZO\\EaNf:[1g00000001O1O00O100000000O10O0101OO0100O1000O01O100O100O100O2N2O1N1O100O1O100O1O010O1O1O0101OL40O0O13M02N2O00001O1O2N1O1O1N10001O1O001O001O00fNTDV1Q<00O00O2ON2N20OYOoC6R?N2N1OO10FSC7mjGI1HY37g4V1WKhNh4X1WKiNh4X1TKlNm4S1RKnNm4S1TKlNm4S1RKnNn4R1SKmNm4S1SKmNl4T1TKlNl4T1SKmNm4S1jJ_N[M>j7T1kJ_NVMa0P8n0kJWOU5i0kJWOU5i0^JDa5=_JCa5=]JEc5;_JCa5=kJWOU5i0lJVOT5j0lJVOU5i0kJWOU5i0kJWOU5i0kJWOU5i0kJWOU5i0kJWOU5i0kJWOV5h0jJXOV5h0jJXOU5i0kJWOV5g0kJYOV5f0jJZOV5f0jJZOT5h0lJXOS5i0mJWOS5i0mJ`NTMc0o7m0mJ_NUMd0o7l0PKTOo4m0QKSOP5l0PKTOP5l0PKTOP5l0PKTOo4m0QKSOo4m0QKSOo4m0QKSOo4m0QKSOo4m0QKSOn4n0RKROn4\\O[HV1g2^O^5>bJB_5=aJC_5=aJC_5=aJC_5=aJC_5>`JB`5>aJA_5?`JB`5>`JB`5>`JB`5>`JBB\\OZ3R1TMBoNOm3?TMB\\Nc0^4LVMAjMU1BcNd4g0PNBVMl10mMi4d0RN^2oLRMo4`0RNR3n1mLSNR3n1nLRNR3n1nLRNR3n1nLSNQ3m1oLSNo2o1QMPNo2Q2QMoMo2Q2QMoMP3P2PMPNo2Q2QMoMP3P2PMPNQ3o1oLQNo2f1RL^KP1l2U1PM]Oa4^N]KN124o0o2T1SMZO]4jNaKh0n2S1YMWOX4SO\\Kd0S3P1^MVOS4:_N`0^MWOQ4:aN?_MWOo3:bN?bMUOk36AMoJoNR5W1M52MN21OO10000O1iJdNW5Z1O51KWMWOkMLS1S1l3IVM1bMfN20R1a1T4HUM8gNOV4HSM9fNOX4iNeJd0]2d0eN0Z4bNjJi0W2e0dN0h4ZOdLf0dNOj4WOfLi0`NMn4oNlLT1VNLX84hGLX84hGKY85gGJZ86fGI[87eGH\\89cGF^8:bGE_8;aGD`8<`GCa8=_GAc8?]G@d8`0\\G_Oe8a0[G]Og8c0YG_Oe8a0[G@d8`0\\G@d8`0\\G_Oe8a0[G_Oe8a0[G_Oe8a0[G^Of8c0YG", "size": [426, 640]}, "area": 51377.0, "iscrowd": 0, "image_id": 10092, "bbox": [0.0, 0.0, 640.0, 394.0], "category_id": 173, "id": 20000609}, {"segmentation": {"counts": "g1i5a70000O100000000O10000000000O01O1N2ONbHYJ]7h5dHXJ[7h54O100O1M4O0O2N2O1N2N2YORHSLn7d3XH[Lo7[OPHm31gLX8^1cGC5PO\\8g0YH1[OXO[8j0ZHL[OZOR8kF:nNCl92WGY1_8gN`G_1lNSNY9b0hGh1P8jN^G\\1A_Mg8e4I]K^G_4b8`K_Ga4_8_KaG_4b8_K_G`4g8O00O11N101O000O10001O000O10001O00000O101O000000000O2O00000O10001OO_LmFNh0d1k:@`0@7J?ASWV3BWiiL5H505Hc0lCmNR;S1lDNZ:OeE2Z:a1N1OO1003M3M000000001N10M3G900N22N]Oc0]Oc0]Oc0]Oc0]Oc0]OUZY1@nffN3M2N3M3[D7c9K`EQ1_:m001SOdMjF]2T9gMiFQ2_9QN_Fe1j9_NSFc1k9`NRFa13dNc8OWGd2h8_MUGa2j8cMSG\\2;mLo7R4mGSLR8m3iGYLW8]4O100O100O10000000000000N1_Ob0_Oa0^Ob0^Ob0_O`FSNe8R2cFkM23[9R2_FoM60Z9Q2`FoM60Z9Q2`FoM60Y9R2bFmM51Y9R2bFmM51Y9R2bFmM51LNl8T2SGmM51J1m8Q2TGmM51K2j8Q2UGlM61K4h8o1WGlM61K6f8m1ZGkM52K8d8k1\\GkM52K9b8k1^GjM52K;`8i1`GjM43L<^8g1bGjM44Kj0P8X1QHjM44Li0o7Y1QHjM5`1j7f0QHjMHm1W8:hG6X8^2O1000000000000000000000mNiGSMW8m2iGSMW8m2iGSMW8c2SH]Mm7\\1ZIdNf6\\1ZIdNf6\\1ZIdNf6\\1ZIcNg6]1YIcNg6]1YIcNg6]1YIcNd6`1\\I`NZ6j1fIVNo5U2QJkMd5`2\\J`M^5f2bJZM\\5:SIR1a1dNZ5WIn0b1cNV5n2jJRMT5P3lJPMR5R3nJnLP5T3PKlLn4V3RKjLl4X3TKhLk4Y3UKgLk4Z3TKfLl4Z3TKfLl4Z3TKfLl4Z3TKfLl4Z3TKfLl4Z3TKfLl4Z3TKfLl4S2bLeMRM", "size": [426, 640]}, "area": 68723.0, "iscrowd": 0, "image_id": 10092, "bbox": [94.0, 104.0, 546.0, 322.0], "category_id": 183, "id": 20000611}, {"segmentation": {"counts": "h3V5R610000O100001O0N3O3K003N2M2N3N1J403K5ON22NM2O20N4M2O4M0lKPIh1N:Y7UNgHj0O00O11O00001OO1001OIgE[O\\:?eEA`:?aE@_:`0bE_O^:a050000J66J00000000O100000000O11O1O0000000000000000000000000000000000000000N21OO11O001O1O00000000L43MO1O100O10000000000:F5_FSO\\8n0_GVOa8j0YGVO]O1Y9i0XGXO_ONZ9k0SG@m8`0SGAl8?TG@m8`0SG@m8`0XG[Oh8g0QG_On8a0kFoNL21`0V9?iFoN1j0V9V100000001O0000000000O1000000001OO1O1N2N20000000000000000000000001O00O100O11ON22NN2000000001O001O1O1O1O1O1O002NO1K5001O00001O001ON20000O1N2IcF`N_9Z1bFfNOM01_9\\1cFeN0N^9]1bFdNc9[1_FdNa9\\16000000000000000000000000000YFdNL120NO[9]1hFmNX9a11O1O1O100000000001O0000002NM3001O001O2N001O0000001OO10000MfFWNZ9h141O0000O100000000000000000000FbFhN_9S1bFgNh9Y140000O10000001OO10000O[FmNV9d1O1O3M001O00O100O100O100O100O100fNjF`0W9\\OTG=l8@[G;f8A_G>a8_OcG?f9N1N3N1N3N1N3N1NUV_1", "size": [361, 640]}, "area": 15248.0, "iscrowd": 0, "image_id": 10363, "bbox": [70.0, 0.0, 436.0, 67.0], "category_id": 113, "id": 20000615}, {"segmentation": {"counts": "n8[2n80000000000000N200N2N2O1N2N2O1J6N2L4000000O100N2O1001O1OO1N21O00O10000000000M3N2HdL^Ha3b7_L]Hb3b7_L^H?0`2b7cM^H^O2j2`7gMdHY2\\7fMfHY2[7fMfHY2Y7hMgHX2Y7eMjH[2V7cMkH^2V7_MmH`2T7\\MoHd2Q7YMQIh2h7000000000001O001O00000000001O0000000000O1O100O10000O100000000O100O10000ZM]MfLc2Z3]MeLP1SNLX5UOeLj0gNAd4DfLg0YOVOQ44dLd0[5[OgJ`0]5@cJ=_5E_J8e5H\\J3h5NWJOl51TJKP65PJGT69lIDW6=Z26WE\\Oa:g0O001O0000000000O100O10000O10000E;00O11O00000000000000O10000GRE4Q;LoD0P`a5", "size": [361, 640]}, "area": 9618.0, "iscrowd": 0, "image_id": 10363, "bbox": [0.0, 180.0, 137.0, 181.0], "category_id": 115, "id": 20000616}, {"segmentation": {"counts": "i2o0Z:O10000O011OO20O01LSOjEP1R:230O1O0101N1M21O1ON22NM3N2002N1O4L1lEPOm9X1ZFfNZ9Z1aFeNN22M[98cFS13fNY90dF34S1MiNO4Z9LgF0004`1c9O00001N10001O7dNRFm0W:N6YO_E;e:A\\E?n:H6IkD0XUY11PkfNOd:9TEIj:;00NCXE=h:CXE=h:20000O1DFeEJ0b0Y:LgNWF[1h93O2O00_NZF_1h90001O01O0001OO1001N1O10FdNgF[1Y9mN`FS1_9<0O10O10000O010O02OO100O002O00O11O0O002N1N200O10N2L5L3L5L300O100O1O0N3N1O2M3N1O2N2MH92N1O3L3N2N2M3N2N2N2M2O2N3L3N3MaTa5", "size": [361, 640]}, "area": 3682.0, "iscrowd": 0, "image_id": 10363, "bbox": [43.0, 190.0, 94.0, 83.0], "category_id": 152, "id": 20000620}, {"segmentation": {"counts": "[1P1Y:0O0100000000001OO1BhEA06X:9hEA07W:8iEA0O05W:;mE_OM000Y:a0<000000000O11O01N0110N01002N002JXEGi:88JTP7NPPI1O1O1O2N1O1O2N1O1O1O1OO11OO10001NXoj1EZfTN2R:k0XOg0J\\N_Fd1`93000000000O2L3F:F920O0001O0O101O001O2N2N2N2N1ON200O100001O00000000001O00000000O1O1N2O1O11O1O001O1O1OO1N2NRFlNk9X11N2O11O001OO100N2HT1SOTXm00h\\RO1O3f:]8@gG>Y8BhGm9BRF?n9AQF`0o9@PFa0P:_OnEc0R:]OmEd0S:\\OlEd0U:\\OjEe0V:[OiEc0Z:]OeEb0]:^ObEa0`:22M3N2AYE:>Ek91gE7a0Hh91gE5c0Jf91gE3e0Ld91gE0h0Oa91bFO^91bFO^91bFO^91bFO^91bFO^91m000000000000000000000000000000000000000000000000000000O1000000000000000000aE0e9j00000000UO", "size": [361, 640]}, "area": 142545.0, "iscrowd": 0, "image_id": 10363, "bbox": [91.0, 0.0, 549.0, 361.0], "category_id": 183, "id": 20000622}, {"segmentation": {"counts": "j7Z;i71O100O1O1O1O100O1]JdD]3];cLiDV3X;jLoDn2R;RMTEh2l:XMZEa2g:_M_EZ2b:fMdES2]:mMiEl1X:TNnEe1S:[NSF_1m9aNYFX1h9hN^FQ1c9oNcFj0^9VOiFb0X9^OnF]G@d8`0\\G_Oe8a0\\G]Oe8c0\\G\\Od8d0\\G[Oe8e0\\GYOe8g0\\GWOe8i0[GVOf8j0[GUOe8k0\\GSOe8l0\\GSOe8m0\\GQOe8o0\\GoNe8Q1[GnNf8R1[GmNe8S1[GlNf8T1[GjNf8V1[GhNf8X1ZGgNg8Y1ZGfNf8Z1[GdNf8\\1ZGcNg8]1ZGaNg8_1YG`Nh8`1YG^Nh8b1YG]Ng8c1YG\\Nh8d1YGZNh8f1YGXNh8h1XGWNi8i1XGVNh8j1XGUNi8k1XGSNi8m1W400000000000000000000000000000000000000000000000000000000000000000000O1000000O1000000O10000O1000000O10000O1000000O1000000O10000O1000000O10000O1000000O1000000O10000O1000000O10000O1000000O1000000O10000O1000000O10000O1000000O1000000O10000O1000000O10000O1O1O1O1O1O1O1O100O1O1O1O1O1O1O1O100O1O1O1O1O1O1O1O100O100O100O100O100O100O100O100O1O100O100O100O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000``e00`_ZO00001O00001O00001O001O00001O00001O00001O00001O00001O00001O00001O001O00001O00001O00001O00001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O1O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O1O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O1O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O001O1O001O001O001O0HnL", "size": [612, 612]}, "area": 346583.0, "iscrowd": 0, "image_id": 10583, "bbox": [0.0, 1.0, 612.0, 611.0], "category_id": 183, "id": 20000623}, {"segmentation": {"counts": "lbP1Y1e=3M4L3M4L3L5L3M4L3O2N101N00000001O000000010O1O1O1O0000000001O00100O1O1O001O1O0000000000010O00000001O000000010O0PN`C`1`<`N`C`1a<_N`C`1a<_N_Ca1b<^N_Ca1b<]N_Cc1b<\\N_Cc1b<\\N^Ce1b8POP:c0fE>d0fNf9l0cE`0P1\\N\\9V1cE=R1\\NP9LVFW3j0mLP9LVFV3j0oLP9LTFU3m0oLo8MRFT3P1nLo81nEP3S1PMn8Z3RGfLn8Z3RGeLo8[3QGeLo8[3PGfLP9Z3PGeLQ9[3oFeLP9\\3oFdLR9\\3mFcLT9^3fFeL\\9]3_F\\Ll9d3g01O1O100O100O101OO01001@lDRMT;n2REkLn:V3WEeLi:[3=1O1N2O1O0010000001O00001N2O2jN]DkNe;Q1^DnNc;n0bDPO`;l0cDSO^;i0fDVO\\;e0iDXOZ;e0hDZOZ;c0hD\\OY;b0jD[OY;a0jD]OY;`0jD]OW;b0kD]OV;a0mD\\OT;c0oDWOV;f0d1N1O2N2N2M3N2N2N2M2O1O2N4LS[[5", "size": [480, 640]}, "area": 17042.0, "iscrowd": 0, "image_id": 10707, "bbox": [69.0, 186.0, 205.0, 186.0], "category_id": 93, "id": 20000624}, {"segmentation": {"counts": "dbl3120h>0WA100h>60O10000O1000000O10O10O10000O1000000O1000O01000000O10000O_i20bVM1O00Ojbj14aPUNLU:8UEK]NO62OLO;a;NmE0bNLLK1c0c;J\\DIX1U1[:^O`Ed0^:@_Ea0`:LUE3j:OTE2k:OUE1i:2VENi:3WEMh:4XELg:6XEJh:6XEJh:7WEIi:7WEIi:7WEIi:8WEGi:9WEGh::TEZNE\\1W;;mDOS;o100000000000000000000000000cNZL`Gf3W8mL[GW3[8]MWGg2_8mMTGV2c8o1]GUJY8m5oGSJg7o5aHQJY7n5nHRJQ7g5WIYJk7S4gHmKo7j2dHVMc<000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000jNM_C3^<4^CL_<<\\CDa9J8H1O1O10000000O1000000000O1000O11OO100000000000O10O100000000000000O10002N2N2N2N00bA@Z>c0O7J5QBYO[=\\1J0O1000000O10000O100000@nBROQ=l0TCPOn<>hBL;BQ=b0fBIh=7ZBGg=9[BEe=:^BCc=<]BEb=<^BCc=<]BEW=g0iBYOR=k0oBTOQ=m0nBTOP=m0QCSOnN4M000000O1L47J[R62dmI5K4K5L4KHkAFT>8U>ElA`0V>41O?A1O000000000000003Mn^?1Pa@2L3M3O1O1O11OO10000O1001ODAWB?h=DVB8000000O10000O1000000O10000O10000O1000000O10000O10000O1000000O10000O1000000O10000O10000O1000000O10000O1003MO1001O1OO[OdBH\\=E[B:a00V=0iB1V=0jB0X=NhB2[=LdB4^=JbB6_=J_B7c=G]B9d=G[B9e=GZB:f=FZB:e=HZB8f=HZB8f=JXB6h=1QBOn=b0000000O1QMQOmGo0T8QOkGo0V8QOhGP1X8ROfGn0[8ROdGn0]8ROdGl0\\8UOjGd0V8XOmD4R3=S8DSH5m7LWHOh73XHLg77WHIi78VHHj79UHGk7;SHEl7=SHCm7>RHBn7?QHAo7a0oG_OQ8b0nG^OR8c0mG]OS8c0mG]OS8d0lG\\OU8d0jG\\OV8e0mDWOj24Y8i0eGWO\\8i0cGWO^8i0aGWO_8j0hFNX94gFKY96gFIY98gFGY9:^EmNd0h0l9?^EiNg0g0j9b0^EgNi0f0l9a0QEPOV1>Z:>gEC^:6cEKb:N_E3f:F[E;k:\\OWEe0a<1O1O1O1O1O1O1O1O1O1O1O1O1N200O1O1O100O1O1O1O1L4XNTOVER1f:f13M2N2N2N3M2N1O1fNUD]Ol;a0[DYOf;d0_DYOa;f0`DZOa;d0`D\\Oa;c0_D]Ob;b0^D^Ob;b0^D^Oc;a0]D_Od;`0\\D@d;?^D@c;?]DAc;>^DBc;=]DCc;<^DDb;;_DEa;;^DFa;:`DF`;9aDG`;7aDIa;4`DLb;0`D0b;M_D3c;J^D6d;G]D9e;C]D=d;A\\D`0f;]O[Dc0g;ZOZDf0h;WOYDi0o<000000000O11O00000000000000000000000000000000001O00M3]OTOPCn0ml4Xgg2", "size": [480, 640]}, "area": 13769.0, "iscrowd": 0, "image_id": 10707, "bbox": [14.0, 352.0, 438.0, 128.0], "category_id": 118, "id": 20000626}, {"segmentation": {"counts": "hZY38g>2O00O01000O02O1O1O0O2O1F910000O101O000O2O000O2O001M2O1O2N1O2O1N2N1O2N2NY?0e@3M2nMMWE0RNO_<>ZEAWN010]j<@]1L4Lbfe4", "size": [480, 640]}, "area": 3628.0, "iscrowd": 0, "image_id": 10707, "bbox": [224.0, 282.0, 96.0, 93.0], "category_id": 121, "id": 20000627}, {"segmentation": {"counts": "kTP69^>9WN_OkDf0W;HSDNYO1e]>1O1O101N2N3N1N2N3M;F5JfN`BS1c=kN^Bb0Y>H9J[k_1JjT`N3L6N300O20OO11O01O02N1O100O00000001O0N2O1O2O0000001O00000O1O2O000O101N10000010O000001O000001O01O0000001O0000001O01O00eH", "size": [480, 640]}, "area": 2771.0, "iscrowd": 0, "image_id": 10707, "bbox": [409.0, 197.0, 231.0, 255.0], "category_id": 123, "id": 20000628}, {"segmentation": {"counts": "dVV24P>NjB2W=NgB2S>1000O01000O01001MUAOk>1K1]AOR>OPB;OEW>;ZZn6", "size": [480, 640]}, "area": 90.0, "iscrowd": 0, "image_id": 10707, "bbox": [149.0, 344.0, 16.0, 32.0], "category_id": 132, "id": 20000629}, {"segmentation": {"counts": "`VR16g>5_AGV>:fAJY>?O100O100O10000O1000000O10000O100O1000000O100000000O10000000000001O4L8H7I3M00ZR6NhmI9G6I2OO1O2N100N3N3K]AHh>1k\\Z7", "size": [480, 640]}, "area": 1194.0, "iscrowd": 0, "image_id": 10707, "bbox": [72.0, 450.0, 67.0, 30.0], "category_id": 143, "id": 20000630}, {"segmentation": {"counts": "[8e6m8^Ob0^O5K6J5K5K6J5K6J5K5K6J5K6nLgDQ2^;gMkDS2Z;hMnDP2W;kMjDT2W;kMjDT2R00000001O0000000000001OBNnA2V>0dA0b>42N0N2NRo70PQH4L0001O00000000000000000000000000001O000000@MSB3m=4lALS>a0000000O10000O1000JmA_OS>`06N3M3O001O11N010000O01010O2N1K4Njk\\6", "size": [480, 640]}, "area": 682.0, "iscrowd": 0, "image_id": 10707, "bbox": [114.0, 452.0, 88.0, 28.0], "category_id": 165, "id": 20000632}, {"segmentation": {"counts": "QVV34k>5WAHb>B:[CPNf;W3^Oj0VOe0eEoJ]9e5E00O100O100O11O0000001O00001O1O2N2N1O2N1O2N2N2N1O2N2N001O001O1O001O1O1O1O1O1O1O00001O3M00O1O1O1N2O1O1N2N2M3N2N20000O10000O10000O10000O10000O10000O100000000000000000000O1O1ZOWGUKi8_4R1O1O1N2O1O1O1O1O100O100O1O100O1O10000000000000000000000000000000000001O000000001O001O001O1O001O1O1O2N2lFRKR8P5iGTKV8n4eGUK[8n4\\GYKc8i4UG]Kk8]5O00001O001O1O001O1O001O001O1O001O001O1O001O001O00O1N2N2N2N2O1O1O1O100O1O1O1O100O10000O100O100000000eMmGiMS8^1lH\\NT7\\1ZI^Nf6]1eI]N[6a1lIZNT6d1TJVNl5h1\\JRNd5l1dJnM\\5Q2jJQNo4m1YKRNb4l1Z4N2N2O1JlB^NV=`16NjBcNm<]1TCbNO1[15\\9X1dEiNg06a9Q1hEPO=6g9k0lEUO46l9e0oE]OK5R:>nEIF0X:7mE`1n9aNlEh1P:h1L4L4L4L3MM3M3N2M3N2M3N2M3M3NYG]KU7`4jHdKV7Z4kHgKU7U4nHlKR7P4QIRLn6k1_GDf1cNk6e1fG@c1lNg6`1nG\\O^1VOc6Z1WHWOY1A`6T1^HTOU1I]6o0fHoNQ13Y6j0mHkNn0=T6c0WIhNg0g0dMYOX8S1XLB^K\\OY8o0aLE_39hLCW3;PMBn2T;EfD?Y;DaD`0^;B]Da0c;BWDb0h;ARDc0m;@lCd0Ta0YA^On5OZ2k0iGUOe50b2S1hGnN2OX50n2^1hGdN1O0Oj40]3j1hGXN0O2OgkEkJc9`5\\FaJ0OV9R6E1UGoIe8Q6[GQJc8o5\\GSJc8m5]GSJc8V6O001O0000001O000000EhGnIX8j5cGVJj8k551O003MO10000000000O100000000000000000000000000O11OO1NoFUJQ9k52O100000000000000O1000000O10000000000000000001O00N200NiF[JW9e5iF[JW9e5iF[JW9e5iF[JW9e52001OhJXGX4h8fKnGEjNn3X9^LhFCm10SNV3X9[MTIT2dM[MX9c0jIZ1X6cNbJ9TLXO0004Z9:UKDeKNL004Z9:gKCY4HWA1m>Oc\\T6", "size": [480, 640]}, "area": 41000.0, "iscrowd": 0, "image_id": 10707, "bbox": [0.0, 0.0, 221.0, 240.0], "category_id": 180, "id": 20000634}, {"segmentation": {"counts": "XX[113000d>0\\A0O13O\\>0bA0O040W:0bI0TL000O040S:;_IEZL1000O40S:=\\ID]L0000O40S:>[IC^L0000O31T:>ZIB_L000O01O01W:?ZFNm1CaM11OO01O01W:`0SF5Q2CeMH0O01W:d1SHhNeMD10W:U2`G\\NXN@1NT:W2]FUN5;YO[OS:c2PFWN5Ok9Q4OOjFVKUO0o8j4kG\\KUOIm8n4kG^KR8a4nGcKo7^4oGQLc7R4XHQLg7P4XHPLh7[4kGgKU8b54ZIfG^6j8bIUGn5T9SJkFe5]9ZJdF2OX5h9fJZF1O0Oj4T:UKnE0O2O]4c:aK_E1O0On3d:QLfE0G10f3Z;YLgD4OMOU3m;jLTD10h2m;WMbD0B1NU2S=F=VN`BX1k=gNVB0Ok0]>E1@dA9]>GeA7[>HgA7Y>IgA7b>O0O2O0000001N100000E6`AJX>1hA;Z>51O003MO0100000000O010000000O100000000O10000000O02OO1NCaA=_>2O0100000000O1000O1000000O10001O0000001O000001O01M20N0^OfAb0Z>^OfAb0Z>^OfAb0Z>^OfAb0Z>1101OhJNbK2\\4d0oFjNn3b0T5^OmFm10SNV3b0Q6j1^IdM[Ma0Z9a2cHaMZ7Y3bGTLXO0004b0R9m3lFeKNL004a0S9`4jF`KU9U51O1O10N14M;DP1QO>B:YLREg2V<^Oj0WOd0cNQB?c>D10O01O0O2O00Xgl5", "size": [480, 640]}, "area": 8050.0, "iscrowd": 0, "image_id": 10707, "bbox": [92.0, 0.0, 145.0, 215.0], "category_id": 181, "id": 20000635}, {"segmentation": {"counts": "`7`0^>o0SOb0^O5K6J5J6K6J5K6J5J6K6J5K6J5J6K5K1O1O1N2O1O1O1O1N2O1O001O1N2O1O1O1O1N2O1O1O001N2O1O1O1O1N2O1O1O1O0O3N3M3M3M3L100000O10O1000O1000O10O100bJbHZ3^7dLeHZ3[7eLiHY3W7eLlHZ3T7dLPIZ3P7dLSIZ3iNWL_7=lIZ3eN[L\\7:RJZ3aN^L\\76WJY3^NcLY72\\JZ3ZNfLY71^JW3XNiLZ70_JV3WNiLZ72aJn2YNQMV71aJb2eN\\Mk63_J`2fN^Mk62_J^2hN`Mi62_J]2hNaMi63_J[2iNbMh63_JY2jNdMh64]JV2mNfMf64]Jo1eMjMV14h63^Jf1dM^NS1Hk65^J^1dMoNo0_Oo64^JQ1fMJi0ROS74]J_2^N\\MV75\\Jb2ZNZMZ74\\Je2WNVM]76\\Jg2SNTMa75\\Ji2QNRMc76[Jk2nMoLh76[Jm2jMmLk76[JP3fMjLo77\\J^3b5cL^J_3_5aLbJ^3^5bLcJa1eMBi7mNbJ`1eMDh7mNdJ^1dMZOOkNi7>dJ\\1dMBl7RO`J[1dMKe7jNgJ[1dM2^7cNnJ[1dM:U7\\NWKY1dMc0n6UN]KX1eMe0l6SN_KX1eMe0l6SN`KV1eMh0j6RNaKV1dMi0j6RNbKU1dMi0j6SNaKS1fMj0i6SNaKS1eMk0j6RNaKS1eMk0j6RNaKb0dMQO2[2h6TNaK?iMoNMQ1O0j6AaK>dMkN220U14Jd6FcKh0eM^N1\\17B`6LcK;bMZO5o0:ZO\\62cIUO`1U1RN@0l0d0ROV6:cITO`1m0YN]1b0RNR6a0bISOa1R1TNY1l0kMm5h0aISOa1b3UO]Li5o0`ISOa1d0UNV2l7TN\\HSOc1b0UNY2j7TN]HROc1a0VN[2h7SN^HQOe1`0UN^2f7RN_HQOe1e3k5[M_HPOf1>VNc2c7PN`HPOf1=WNd2a7QN`HoNh19oN[2a6aMSJH?f0dNQ2k6`MRJG`0Q1[Nh1S7_MoKi0nLh1T7^MoKj0mLh1T7^MnKk0nLg1U7\\MmKm0oLf1W7ZMjKQ1nLf1Z7WMgKT1oLe1c:ZN^Ef1b:ZN]Ef1d:ZN\\Ef1d:ZN\\Ef1d:YN\\Eg1e:YN[Eg1e:YNZEh1f:TN\\En1d:lM_EV2c:dMWEg2i:h00O10000O10000`LVEEMm2n:hMXEQ2h:PNYEo1g:PNZEP2f:PNYEP2Y:XMjEh0MP2Y:^McEb05P2X:cM^E=9P2Z:^NgEa1Y:^NiEa1W:_NjE`1V:`NjE_1W:`NkE_1T:YNVFf1j9[NUFd1l9]NTFb1l9_NTF`1l9aNSF^1n9cNRF\\1n9fNQFY1o9hNQFW1n9kNQFT1P:nNoEQ1m8fMaGZ1Bo0k8jMbGX1Bm0j8PNbGU1Cj0i8TNcGS1Dh0f8YNeGQ1Bg0f8]NeGn0Dd0g8`NdGm0Dc0g8bNdGm0Ca0h8eNbGl0E>h8iNaGl0F:h8mN_Gl0G7i8oN_Gl0F4k8SO\\Gk0H2k8VOWGn0LLk8i1SGWNl8n30UNUGcMj8[2ZGdMe8[2]GdMb89`GKNKa87iGKFM`87QHH_OO`89WHDXO3_8:]HATO4^8:cH@oN5]8hH\\OjN5]8?mHZOfN6[8b0QIWOdN5[8d0UITO`N8Z8e0XIRO^N8Y8f0]IPOZN9W8i0aImNWN9X8j0dIlNTN9W8l0hIiNQN:U8o0lIfNnM:U8Q1oIeNlM9R8U1SJbNkM8P8W1XJ`NhM`0f7R1cJ]NgMh0_7j0lJ^NeMn0X7d0TK^NdMT1P7?^K\\NaM\\1j69eK[NaMb1c63mK[N`Mf1]60ULYN^Mf1]61VLYN\\Mf1^62VLXN\\Me1]64XLWN[Md1]65ZLVNXMe1^65[Lc0d3_O\\L`0d3@]L?c3B^L7JX8IiG8J4Y8ETH4^O;Z8BZH6VO;]8@_H8nN<_8]OeH:fN=a8ZOkH;_N?c8VOPI>WN?g8SOTIa0oM`0j8nNZIe0fMa0m8jN_Ig0^Mc0Q9eNdIa2Y6^MjIc2S6]MPJc2l5]MWJc2g5]M[Jd2b5[MaJf2\\5ZMfJg2W5XMlJh2R5XMPKi2m4VMVKk2g4UM[Kl2b4SMaKm2]4SMeKn2X4QMkKo2S4QMoKP3n3oLULQ3i3nLZLS3c3mL_LS3g71O001YJkMaNU2\\1jMhNW2U1gMoNY2n0fMVOZ2g0bM@_2:QM_J2`5m2KSMe0n2SOSMS1m2gNRM`1o2XNQMo1o2kMoL]2R3[MQMi2o2QMRMT3o2dLXM\\3h2^L^Mb3c2VLeMi3[2RLjMn3W2mKmMT4R2gKSNY4n1bKWN]4i1_K[Na4f1YK_Ng4a1UKcNk4^1oJhNP5Y1kJkNU5Z1aJkN_5[1WJiNi5\\1mIiNS6]1cIhN\\6]1ZIhNf6^1PIfNP7e401O0000001O000000001O0000001O0000001O0000010O000000001O0000001O0000001O000000", "size": [480, 640]}, "area": 146305.0, "iscrowd": 0, "image_id": 10707, "bbox": [0.0, 2.0, 640.0, 478.0], "category_id": 183, "id": 20000636}, {"segmentation": {"counts": "0_8i400001OO1000000001O00O11O000000000000001O00O1000000O100O10000000000O10VKdGh4_8O00O1MXKfGh4Z83001O1O0000M3000000001O00001O000000000000O1001OO100O10000LTKlGl4T8TKkGm4U830000001ON200000000000000O100000000O1001O000000001O000000000000001O0000001O00000000O100M3O1000000000000N2001jJoGS5S80002NO1O10000O10000NlJPHT5P8lJPHT5P8200001O0000000000000000000000001O0000000000O10000000000000000O1O10000001O00O11O000000O1001O1O001O00O10000001O0000O10000O100O1O10000O1O100000000000000O100001O000000000000001OO11O0000O1N2O1N2N2N2O1L4N2N2N2M3N2N2N2N2N2M3N2N2N2N2N2M3N2N2N2N2M3N2N2N2N2N2O1N2N2N2O1N2N2N2O1N2N2O1O1O1O1O1N2O1O1O1O1N2O1O1O1O1N2O1O1O1O1N2001O00001O00001O001OXO_GiLa8o2hGPMX8l2mGTMR8j2QHUMo7i2THVMl7h2WHUMk7i2XHTMj7j2YHRMj7l2Z1N2N2N2N2N200O100000000O100000000O100000000O1000000000000000000001O00000000000000000\\H`M`4a2_KcMcMOQ6^2]LgMUM4]6U2_L[Na3e1_L\\N`3d1aL\\N^3e1bLZN^3f1bL[N]3f1cLZN\\3g1dLXN\\3h1dLYN[3h1eLWN[3j1dLWN[3j1eLVNZ3j1cLYN]3h1^L]Na3d1[L_Ne3b1WLbNh3^1TLgNk3Z1RLhNn3Y1oKjNP4V1mKnNR4S1kKoNU4R1lJUMBm1a5o0hJYMDj1d5m0gJZMCl1e5k0gJZMAn1g5i0gJYM_OQ2j5g0fJYM]OS2l5e0fJYMZOU2P6e0cJWMZOW2R6e0aJL^58^JHb5;[JFd5=YJDf5d0RJ\\On5P4O001O00001O001O001O00001O001O00001O001O00001O001O0000O100000000000000000000O1000000O1O1O1N2N2M3M3K5N2001O00000000001O00O100O100O100O100O1O100O1O100O100O1O100O10]J^I`4b6_K^Ib4b6\\K`Id4`6[KaIe4_6YKcIg4^6WKcIi4]6UKeIk4[6TKfIl4Z6RKhIn4X6PKjIP5W6nJjIR5Z6hJhIX5Z6_JVI3a0^5T7O0000O11OO10000000000000000O10000O100O11OO1001O0000001O000000O100O10000001OO1001O00001O00O100O100O11OO10000O1001O00000000001OO10000O11O00001O0000O100000000O100001O00000000000ZJ`Hd5b701OO10000000000O100000000O100O1001O000000000000001O000000O100000000O1001O1O0000000000000000000000O100O100001O000000O10000001O00001O00N2", "size": [424, 640]}, "area": 142873.0, "iscrowd": 0, "image_id": 10764, "bbox": [0.0, 0.0, 640.0, 273.0], "category_id": 145, "id": 20000637}, {"segmentation": {"counts": "_8i4_80001OO1000000001O00O11O000000000000001O00O1000000O100O10000000000O10VKdGh4_8O00O1MXKfGh4Z83001O1O0000M3000000001O00001O000000000000O1001OO100O10000LTKlGl4T8TKkGm4U830000001ON200000000000000O100000000O1001O000000001O000000000000001O0000001O00000000O100M3O1000000000000N2001jJoGS5S80002NO1O10000O10000NlJPHT5P8lJPHT5P8200001O0000000000000000000000001O0000000000O10000000000000000O1O10000001O00O11O000000O1001O1O001O00O10000001O0000O10000O100O1O10000O1O100000000000000O100001O00000mKYHe2g7YM_Hc2a7[MfH`2Z7hLcIS3]6kLjIP3W6nLnIn2Q6QMSJm2n5PMVJn2j5PMZJn2f5QM]Jm2Q8N2N2N2N2N2N2N2N1O00001O001O00001O001O00001O00001O001O00001cNPE`0P;[OVEd0k:UO\\Ej0d:QOcEm0]:nNiEQ1X;O1O1O1O1O1O1O1O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000VOUOWEk0h:VOXEj0h:VOXEj0g:WOYEi0g:WOYEi0f:XOZEh0e:YO[Eg0e:YO[Eg0d:ZO[Eg0e:YO[Eg0d:ZO\\Ef0c:[O\\Ef0d:ZO\\Ef0c:\\O\\Ed0d:\\O[Ee0d:\\O\\Ed0c:]O\\Ed0d:^OXEd0g:^OWEc0i:_OTEb0k:@REb0m:APE`0P;BmD?R;l000O1O100O100O1O100O100O1O100O1O100O100O1O100O100O1O100O1O1O1O1N2O1O1O1O1N2O1O1O1O1N2O1O1O1O1N2O1L4L4K5K5K5L4M3N2N2O1N2N2O1N2N2O1N200001O00001O0000001O1O1O1O1O1O1O1O1O0000000000000000000000000000000000001OO1M3N2M3N2M3M3L4M3L4M3M300O100000000000000000000001O0000O11OO10000000000000000O10000O100O11OO1001O0000001O000000O100O10000001OO1001O00001O00O100O100O11OO10000O1001O00000000001OO10000O11O00001O0000O100000000O100001O00000000000ZJ`Hd5b701OO10000000000O100000000O100O1001O000000000000001O000000O100000000O1001O1O0000000000000000000000O100O100001O000000O10000001O00001O00N2", "size": [424, 640]}, "area": 86705.0, "iscrowd": 0, "image_id": 10764, "bbox": [0.0, 240.0, 640.0, 184.0], "category_id": 154, "id": 20000638}, {"segmentation": {"counts": "mnj26P=6J7SOm0I7J5J4L4L4M3L4L4M3L4L4L4M3J6L2N3M2M4M2N2N3M2N2M4M2N3M2N2N3L3N3M2N2N3L3N2eHPK\\6S5^ISK_6o4[IXKb6k4XI[Ke6g4VI_Kh6b5M4L3M3N2M3M3M2O1N2N2O1O1O1O1O1N2O1O1O1O1N2O1O1O1O1N2O1O1O1O1N2001O00001O00001O001OXO\\HlKd7l3eHSL[7i3jHWLU7g3nHXLR7f3QIYLo6e3TIXLn6f3UIWLm6g3VIULm6i3Z1N2N2N2N2N200O101O00000O100000000O10VOcLiG]3W8cLiG]3V8dLjG\\3V8dLjG[3V8fLjGZ3U8gLkGY3U8gLkGY3T8hLkGY3U8gLkGY3T8hLlGX3S8iLmGW3S8iLlGX3S8iLmGW3S8iLmGW3R8jLmGX3Q8jLnGV3R8jLnGV3Q8kLnGV3R8jLlGX3S8kLjGV3U8mLhGT3X8mLeGU3Z8nLcGS3\\8oLbGR3n2ZLhMMg3f4`NaK]M1R4_4bNcKoL8^4U4dNVL[1k3eNVLY1k3hNULW1l3hNTLW1m3jNSLU1n3kNRLS1P4lNPLS1Q4nNoKQ1R4oNmKP1U4oNlKP1U4nNmKP1T4lNPLS1R4iNRLV1o3fNTLY1n3bNWL]1i3aNZL]1h3_N[L`1g3]N\\Lb1d3[N`Lc1b3`MbJAn1o2a3ZMgJDk1P3`3XMiJDj1S3^3YMhJBm1T3\\3YMhJ@o1U3[3[MeJ]OS2X3Y3ZMeJ[OU2Y3Y3ZMcJYOW2\\3Z3XMWMf2m2WMTMf2R3VMnLi2V3TMkLj2Z3RMgLl2k6O2N1N3N1O1O2N1N3N1O2N1O1N3N1O2J5K5K6J5K6K4N2N3N1N3M2O1N101N2N2000000001O00001N10001O1N2N2N2M3M3L4L3K5N2001O00000000001O00O100O100O101N100OO1N3N1N2O2M2M4M2M3N3L301O1N2O1N2O2M2O1N2O1N5K4M3GTC0SiP2", "size": [424, 640]}, "area": 41455.0, "iscrowd": 0, "image_id": 10764, "bbox": [219.0, 81.0, 265.0, 315.0], "category_id": 183, "id": 20000639}, {"segmentation": {"counts": "Rd[3:];0`MGbI9^6GbI9^6M[I4o5LXHi0P1[Oh63QHU1d0iNZ7`2SH`Mm7U300001O1O00001O001O1O2N1O001O00001O000000O10000O100001O001O1O001O001O2N001O1O00001O001O0O101O001O00010N2O01O0000O2O001O2N001O1O001O001O00001O00001O001O001O0010O0001O1O1O00001O001O1O1O001O00000000001O00O1L400L4O1O10000O11O0000001O4dNmFTOJLO=]9`0ZG_Oh87aGHb83aGLg8K\\fl0", "size": [375, 500]}, "area": 10676.0, "iscrowd": 0, "image_id": 10977, "bbox": [293.0, 233.0, 128.0, 113.0], "category_id": 98, "id": 20000640}, {"segmentation": {"counts": "bc\\38`;6I0001O001O0001MDiD=h:H\\ENM9c:O\\EK06c:g0O0O200N3N1O0O2O00001N11O1O1N3N000O2O0001O00100O001O010O2N00100O00010O001OUOgE8Y:GhE9Y:FhE:W:FiE:W:FiE;V:EkE:V:EjE;V:EkE;T:ElEAdFmNT8S1kGoNT8X1dGnNW8]2L3M4LO1000000N21O0ZHTMXO0d0Hk00_N0^4T3[LcNB\\N=d0R3\\2cLmLLh2JVNf3T2eLU1\\3jNdLV1]3kNbLU1^3kNaLW1^3jNaLW1^3jNaLV1_3kN[LlLMY4h3lNYLZ1g3hNWLW1m0cKk1h7RN[Hn1e7QNmH^O\\OO6a0HFi79UIZO\\OO0f0GHi7CUH523i1KVNN06a8JcG6j1IRN01002i84ZIIR76oHJP76Y2O3MRgZ3NQYeL00000O1WK1iM0X23VI3o01TOJLOX20U4P1`JGZ1YOi3_1cJAc1PO3N9=kM\\11\\Og1mNO9\\NS2FEO_Od1`N;\\G_Od8?aG^O_8a0eG\\O[8c0hG[OX8e0iGZOW8e0kGYOU8h0lGWOT8h0oGVOQ8j0PHUOj7LRGn0X1SOf7ORGn0]:RObEn0_:ROaEn0_:ROaEn0^:SObEm0^:SOaEn0_:ROaEm0`:SO_En0a:4000I`EWO`:j0`ETOc:9^EM4J`:6]EN5L_:1YEO7010`:0cE0M0[;O1000000000000000fXX11YggN010O0010O010O00010O0010O00010O010O0010O0010O0001O00Vln0", "size": [375, 500]}, "area": 11437.0, "iscrowd": 0, "image_id": 10977, "bbox": [108.0, 222.0, 307.0, 104.0], "category_id": 123, "id": 20000645}, {"segmentation": {"counts": "icX12d;1O100O1O100O1NJcD6];200000000O11O0000000000001OO10000000000O100000000O1000000O1000000O1000000000000000000O10000001O000000O11O000000N2MBlD?T;20000O10000O1000000O100O100000000O100000000001O1O001O1O001O2N000EkD4U;KPE1P;OREOm:3;O1000O1000000O01000000L4OiPT3", "size": [375, 500]}, "area": 1458.0, "iscrowd": 0, "image_id": 10977, "bbox": [110.0, 322.0, 116.0, 23.0], "category_id": 131, "id": 20000646}, {"segmentation": {"counts": "[gS1120a;6G823JK5K31O2N2N2O000001O000N3NmT]4", "size": [375, 500]}, "area": 206.0, "iscrowd": 0, "image_id": 10977, "bbox": [97.0, 206.0, 17.0, 22.0], "category_id": 132, "id": 20000647}, {"segmentation": {"counts": "mUZ4_1X:O100000000N2K5O11O2B=N2M2J7O1O4L2N5KO1000000000000000\\GhMi7X2VHkMh7T2XHmMh7S2RHTNm7l1QHZNC\\OV8Z2UH^Nj7c1QHbNo7b210000000O01O11oGeLd70VH_2=kMn73SJFR62Xal0", "size": [375, 500]}, "area": 3283.0, "iscrowd": 0, "image_id": 10977, "bbox": [377.0, 103.0, 45.0, 124.0], "category_id": 133, "id": 20000648}, {"segmentation": {"counts": "kbV4292m:?H^OTEe0k:4M3O1001O00M3J6O101O3M0fEgNV:Z1iEgNT:_1K5O11O2M2O1O001O1O4L2N5J010000000000000O1CaEB_:=dEA[:?fEAZ:9mEFS:8SFCn9;h0K`]P1", "size": [375, 500]}, "area": 1584.0, "iscrowd": 0, "image_id": 10977, "bbox": [367.0, 164.0, 44.0, 56.0], "category_id": 143, "id": 20000649}, {"segmentation": {"counts": "]Zm01f;00000O2O0YE8_9H`F:_9MYF9b9m01M3L4001O1O1O1O1O101O0O2N1O1O2N1O1O1O1O2N002N0000000000000000001O0000000000000000000000000000001O00000000000000001O000000000001OOE^FcNb9\\1fF]NZ9a0_1L400000000000000000000001O0000000000000000000000000000001O00000000000001N10000000000001O00000000000000001O000000000000000000001O000000000000000000000000001O0000l0TOe0[O000O2O0000000000000000000000000000000000000000000000000000000000000000000001H7C=E;B>G9F_jB4L1N2O1_LTHU3l7jLUHV3W8N5L3M003M00000O100000000O10000000000000000000000O10000000000000000000000000000O1000000000001O00000O1000O1000000000000000O2O00000000O1000000N1L5mNeMbHc2^7k00000000O100000000000000O10000J\\HYLd7g3\\HYLd7g3\\HXLe7h3[HXLe7h3[HXLe7g3\\HYLd7g3\\HXLe7h3[HXLe7h3[HWLf7i34000000J6B>C=E;G9DB4L1O1O1kFhMi8X2VGiMj8c2O4L3M012M000000000000000000000000000001O00000000000000O10000000000001O00000000000000001O0001O0000000000O10001O000000000001O00000000O10001O0N2KQ1QNhF_OU:Lk0000jSo2", "size": [375, 500]}, "area": 7445.0, "iscrowd": 0, "image_id": 10977, "bbox": [153.0, 44.0, 87.0, 98.0], "category_id": 181, "id": 20000652}, {"segmentation": {"counts": "j`h26];8H7K5L4L3N1N2O1N3N1N2O1N100VFlNQ9T1fFVOY9e1O1N3N1O1O1O0O101O00001N10001OO1000000O100000000O1000000O100000000O1000000O103Mc0]Oc0]Oc0\\Oa\\`0@oc_O10001O00001O001N10001O001O00001N101O00001O001O000O2O001O00001O001N10001O00001O001N10001O001O00001N101O00001O001O0O101O001O00001O0O2O00001O0OL4_Ojjm0", "size": [375, 500]}, "area": 5281.0, "iscrowd": 0, "image_id": 10977, "bbox": [241.0, 214.0, 177.0, 126.0], "category_id": 183, "id": 20000653}, {"segmentation": {"counts": "dcb1N000000000000001O0000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000001O00000000000000000000000000001O00000000000000000000000000001O00000000000000000000000000001O00000000000000000000000000001O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000RN?]DAQ;`2^Ob0@`0", "size": [480, 640]}, "area": 4191.0, "iscrowd": 0, "image_id": 10995, "bbox": [107.0, 360.0, 533.0, 120.0], "category_id": 93, "id": 20000654}, {"segmentation": {"counts": "0PhQ13mfnN8H8H:F7I002N7I9GB9G:F9G:F:F9G`1`N3MOaGRJn7`60>Bc0]O9G7I6J4L9G5K8H9G7I5K6J5_Oa0I7I2TLoDf3^;F:G7H:F:G8G8HN2Mblb4", "size": [480, 640]}, "area": 75666.0, "iscrowd": 0, "image_id": 10995, "bbox": [0.0, 0.0, 326.0, 480.0], "category_id": 109, "id": 20000655}, {"segmentation": {"counts": "RYf42l>4\\ONUB5h=1QB4k=c0N2N1OO100O100O100O100O100O100O10N1C>0O100O1O100O100O100O100O100O100O01mNR1100O100O100O100O1O100O100O100O100O1O100O1O100O1O100O100O1O100O1O100O100O1O100O1O100O100O1O100O1O100O100O1O100O1O100O100O1O100O1O100O100O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1OM4[OJ[B:W8I7H6K7H8I6I6K9G7H8I5K0O1O1O104KO2M2N3N1N3005J10O001O10O01O0010O01O10O01O00100O1OO1100O1O01O01O0010O01O3M10F91O100O1O00101N1O00100O1O100O2N1O2O1N1O1O100O0010O02N010O100O10000O100O010O010O010O01001N100O100O101NO2K5N1M4O001N110O0100O10O1O0100O010O01O010002M100O01O0014K7J6I3N9G5J=D8G7JXgP15gPoNV8F00000000000000000000000000000000N2B>00000000000000000000000000000000O1SL]IZNf7U1kHkNU7U1kHkNU7U1kHkNU7U1kHkNU7U1kHkNU7U1kHkNU7U1kHkNU7U1kHkNU7T1lHlNT7T1lHlNT7T1lHlNT7T1lHlNT7T1lHlNT7S1mHmNS7S1mHmNS7S1mHmNS7S1PIjNP7V1XIkL_8R3i1M30000000000000000O100000000000lEQMW8o2aGPOh6P1TITOl6l0TITOl6l0TITOl6o0QIQOo6P1PIPOP7Q1oHoNQ7R1nHnNR7R1nHnNR7S1mHmNS7T1lHlNT7U1kHkNU7U1kHkNU7X1hHhNX7[1eHeN[7c1]H]Nc7e1[H[Ne7f1ZHZNf7i1iGQL004Z2S8\\400000000000000000000000000000000000000000000000000000000000000000L4[OlGYJY8X4WIcKm6h2`3O1O100000000000000000000000000000000000000000000001O000000000000000000O11O0000000000000000000000001O00O1O1O1000000001O000000001O0000000000O100O100O100001O001O000000001OO11O0000000000001O0000000000001OO1001O00000000001O000000000000001OO100001O00000000O11O0000001O1ON2001O1O1O00002N001O00001O001O00000000000000000000000000000000001O0000000000000000000000001O00000000000000000000", "size": [480, 640]}, "area": 52412.0, "iscrowd": 0, "image_id": 10995, "bbox": [110.0, 0.0, 530.0, 418.0], "category_id": 172, "id": 20000658}, {"segmentation": {"counts": "PhQ13m>8H8H:F7I002N7I9GB9G:F9G:F:F9G`1`N3MOaGRJn7`60>Bc0]O9G7I6J4L9G5K8H9G7I5K6J5K5K5K000000O100O100O10000O10000O1O1O100O100O100O10000O100O10000O100O100O10000O100O1000000N2000000O1O100O100O1002N00F:00000000O1001O00O100000000001O001O1O00000000O100O11OO10000000000000000O100O100O100O1001O00000000001ON2K5N2L4O1O1N200O100_GfJ\\7Z5`HhKb6X4_IPLW6Q4jImKV6T4jI[Lg5e3]J]L]5c3_JUMl4Q7ZKeFe2\\;^Oa0_O:G;E;G5I9G8G6J8HX[i5", "size": [480, 640]}, "area": 45406.0, "iscrowd": 0, "image_id": 10995, "bbox": [72.0, 0.0, 172.0, 339.0], "category_id": 181, "id": 20000659}, {"segmentation": {"counts": "bRc13k>3L3M3N2M3M3N2M3M3N2M3M3N3L3M3N2M3M3N2M3M3N2M36JO101N1O1O100O1O1O100O1O100O1O1O100O1O1O100O1O100O1O1O100O1O1O100O1O100O1O1O100O1O1O100O1O100O1O1O100O1O1O100O1O100O1O2O0O100O10000O100O100O100O100O10000O100O100O100O10000O100O2O0O100O100O10000O100O100O100O10000O100O100O100O101N10000O100O100O100O10000O10O0100O100O100O10000O100O100O100O100O100O100O100O010O100O100O100O100O100O100O100O1O100O100O100O10O0100O100O100O100O100O100O100O1O100O100O100O100O010O100O100O100O100O100O100O1O100O100O100O100O100O100O100O10O0100O100O100O1O100O100O100O100O1O100O1O100O1O100O100O1O100O00100O100O1O100O1O100O100O1O100O1O100O100O1O100O1O100O100O1O010O1O100O100O1O1O1O1O1O1O2N1O1O1O1O1O1O1O1O1O1O1O1O100O2N1O1O1O1O1O1O1O1O1O1O1O10001O000001O0000000000001O000001O000001O0000000000001O00000001O0001O0000000000001O00000001O0001O00000000001O0000000000010O0000000000001O0000000000001O0000000000001O0000000000001O00000O1000001O0000000000001O0000000000001O0000000000001O0000000000001O00000000001O0000001O0000001O0000001O0000001O0000001O0000001O0000001O0000001O0000001O0000001O0000001O0jMkIaKU6l3i2^Oc0]OnH", "size": [480, 640]}, "area": 95635.0, "iscrowd": 0, "image_id": 10995, "bbox": [108.0, 213.0, 532.0, 262.0], "category_id": 183, "id": 20000660}, {"segmentation": {"counts": "cdIE[6lG^OT8`0QH]Oo7a0WH[Oi7b0]HZOd7d0bHXO^7f0gHWOY7g0mHUOS7i0SIROn6m0[IkNe6T1gIaNY6^1jI`NV6`1kI^NV6a1mI]NS6b1PJ\\NP6d1RJYNo5f1SJYNm5f1VJXNj5h1XJUNi5j1ZJTNf5l1`JnM`5Q2jJfMV5Y2UK\\Ml4d2]KSMc4l2gKkLY4U3e4O1O1K5M3M3M3O10000O10000O100O10000O100001O1O1O1O1O1O1O1OO1N2N2N2O1O100O10000O1000000000000O100000000001O001O1O001O1O001O1O001O1O001O0000000000000000001O1O1O1O1UFaM[5`2`JjMZ5W2bJnM\\5S2_JRN`5o1\\JVNb5k1YJZNf5g1VJ]Ni5d1RJbNl5b1mIbNR6d1dIbNZ6_1bIeN\\6^1^IhN`6Y1]IjNb6W1ZInNc6U1YInNf6S1WIQOg6P1VISOi6n0SIWOk6k0QIXOn6i0UH[L2P3g7f0RHfLMg2P8d0mG?Q8U4O1O2N1O2N1O2N1O2N1nLUGUNm8d1ZGZNg8_1aG_Na8Z1eGeN\\8T1kGkNW8n0nGROS8h0SHWOn7b0YH]Oi7<]HCh72_HMe7JaH5d7@dH>a7XOeHg0_7nNiHQ1\\7aNoHf0kLQOZ:LUIQ1jLiNX:HZI\\1fLcNU>X1i0L4L5K4M3L8H9GXT2", "size": [536, 640]}, "area": 110016.0, "iscrowd": 0, "image_id": 11051, "bbox": [0.0, 0.0, 640.0, 536.0], "category_id": 172, "id": 20000662}, {"segmentation": {"counts": "`^h51g`02N2N1O2N2N2N1bAD^<>SC0l<2eB=SLm3S7dKRI?Kl3S7h3MYJPIl1l6YNTIf1k6\\NUIc1j6_NVI`1i6X4O1O1O_JZIR1e6a4O1O1O1O1001O0000001O0000001O0000001O0000001O001O2N2N2N1O2N2N2N1THRIl5P7eI^IZ6d6YIiIe6Y6WIkIh6U6VImIi6U6SIoIk6S6RIoIm6S6oHPJP7Q6nHRJP7P6lHSJR3[Nh0d7SLTJT3\\Nd0]9]OfF>[9BiF9Y9FjF6W9InF2T9MPGNQ92SGIn86WGEk8:YGAh8?\\G\\Of8b0_GYOb8g0bGTO_8l0eGoN]8o0hGlNY8T1kGgNW8W1nGdNS8\\1QH_NP8a1THZNn7d1WHWNj7i1ZHRNh7m1\\HnMe7Q2`HjMa7V2cHeM_7Z2eHaM\\7^2iH]MY7b2_3O101O0O2O000O2O001N10001N101N10001N101O0O10N2M2N3M3M2N3M2N3M3M2M4M3M2N3SEnLP8T3jGWMo7l2jGZMT8h2fG^MX8e2cG_M[8c2`GbM^8a2]GcMa8`2YGeMd8^2XGfMf8]2TGhMj8Z2RGjMl8Y2oFkMo8W2lFnMR9U2iFoMU9T2eFQNY9Q2`FVN^9c4N2M3N2N2N2N2N2N2N2N2N2N2M3N2N2N2N2N2N2N2N200O1000OUL]GCc8;cGA]8=hG_OY8?mG]OS8a0RH\\On7b0XHZOh7c0^HYOc7e0cHWO]7g0hHVOX7h0nHTOR7j0TIQOm6n0\\IjNd6U1hI`NX6_1kI_NU6a1lI]NU6b1nI\\NR6c1QJ[No5e1SJXNn5g1TJXNl5g1WJWNi5i1YJTNh5k1[JSNe5m1aJmM_5R2kJeMU5Z2VK[Mk4e2^KRMb4m2hKjLX4V3e4O1O1K5M3M3M3O10000O10000O100O10000O100001O1O1O1O1O1O1O1OO1N2N2N2O1O100O10000O1000000000000O100000000001O0O2O1O001O1O001O1O001O1O001O0000000000000000001O1O1O1XFXM^5i2]JgMW5Z2eJjMZ5W2aJoM]5R2_JRN`5o1[JWNc5j1YJZNf5g1UJ^Nj5c1RJbNl5e1iI`NV6c1dIbNZ6_1aIfN^6\\1]IiNa6X1\\IkNc6V1ZInNd6T1WIPOh6Q1UISOi6n0TIUOk6l0RIXOl6j0VHWL4S3e7g0RHbLOk2m7d0oGmLJb2V8b0jGb0T8R4O1O2N1O2N1O2N1O2oLSGSNn8g1YGWNi8a1_G]Nb8]1dGbN^8V1iGiNX8Q1nGnNT8k0QHUOP8d0WH[Ok7>[HAh76_HIe7NaH1d7EbH:b7\\OfHb0_7TOgHk0]7iNlHV1Y7\\NRIj0kLnNY:JWIV1hLfNW>V1j0K4L4L5L3L5K9G9GUT2", "size": [536, 640]}, "area": 214508.0, "iscrowd": 0, "image_id": 11051, "bbox": [7.0, 2.0, 628.0, 534.0], "category_id": 183, "id": 20000664}, {"segmentation": {"counts": "[no43k>2HLaA6`>J]A;a>21M03N1L44LODaA9_>GaA9c>1L1SMDVG`0j8DRG\\;GdFLjMN1?a;FdFd0^9@\\Fa0e9_O\\F?e9@[F`0f9^O\\DIk1f0k9@ZDKk1f0j9EXF;g9EYF9i9IUF9i9GXF7i9HXF7i9GYF9g9GYF:f9FXF;i9DVFEQNg0i;BWDGl1m0l9\\OUFf0j9XOWFj0h9SOYFP1k;O12O2M10M2000jNkN]C2P1S1c;oN]DQ1a;kN_C5m0:UO5_^O4\\@lA2N?U>_OmAc0U>^OiAe0U>30105lAQOl=U1K4M10O11M200O2GcNgBO3_1U=dNiBT1a=510N3M20H72N4J4N1OO1OO1M]NlB`1V=aNjB]1X=cNfBZ1^=31M`BfNa=X14O00102BXBAh=>YB@h=a0XB[OOKj=g0<100O2O00N200O1N211ON1B[OVBO9f0_=ZOXB3;b0[=\\OZB1>d0U=_OiBc0W=^O]BJ107f0[=B]BJ5e0_=@]BK4e0_=@\\BL6c0^=A\\BL7b0]=G\\BE2f0b=E\\BF1d0d=K\\B4d=M[B3e=>\\BoNe=Q1\\BmNe=P172N1O4L000000O10000000000000000N22XBjNb=Z10O100\\O[BLf=4ZBKg=4[BKe=5^BHb=7aBG_=9aBG_=8bBDIJe=b0]BJf=6^BEc=:`BE_=;bB@D3h==eB_OC2j=>d00000001O2N003M1O1O003M002N1O1O1OO1N21OGPBDn=c052N00HhAGY>971O1OM31O000000001O0000M3L4N2O11ON21OO1N2O100O11O1O1O2N0000002bDKm74UHKk77RHKm77kGFnL71IS;:mG0oLGT;9mG3S8LoG3Q8LRH2n7OlG6T8JnG4R8LQH1o7OQH1o7OQH1o7NQH5m7LQH3Q8MlG4V8JjDIS39T8LoG5jLGT;0TH?U;0dA@Y>i0hAXOn=i0PBWOo=ORBi00ZOk=n0100O20LQOUBo0l=1101OM31O11UDnNc9T1]FkNfN0R:W1bEkNU1N_N4`0OY:U1_EnNP19WOD[:W1XEoNW16VOC\\:e1]FiNmNBLN13i:d1]FiNlNEMNm:c1YFVOiNWOQ;`1ZE`Ne0a:Y1`EgN_:Z1_EgN`:Z1`EfN`:Y1`EhNFUO[:Y2iEQOW:S1cEYMOe1Y:[NiEa4W:_KiEa4W:_KiEb4V:^KkEa4U:_KkEa4R:_KkEg4k9_KWFc4d9?0001N1O100^M", "size": [480, 640]}, "area": 11680.0, "iscrowd": 0, "image_id": 11122, "bbox": [341.0, 0.0, 299.0, 254.0], "category_id": 96, "id": 20000665}, {"segmentation": {"counts": "hRd721Ok>Ib9X1\\FlNEMNa01^OM071IO94FO?Mf9W1gFiNWOb04^O20H0a03R:8_Ee02h;OXD0i;NXD2h;NXD2g;NZDFUOMg<7cDIa;1kBOi[6", "size": [480, 640]}, "area": 21241.0, "iscrowd": 0, "image_id": 11122, "bbox": [520.0, 120.0, 107.0, 321.0], "category_id": 97, "id": 20000666}, {"segmentation": {"counts": "Y8f4`0kLi7U3XHjLi7T3XHlLi7R3XHnLh7S3XHlLi7S3VHnLk7Q3UHoLk7R3THnLj7T3VHlLk7S3THnLo7iNbGo00c1>eNP8iNcG`1X8`N]G0M00415032]2>fNY2gNXM7f5D]J9OJM^2`0`N_OQO03h2f0XMYOg5K\\J0M065K]2?`NAoN05g2n0^3QOkI?OW1?TOAQO67a2m0j3QO`I50`1>UOi25e3SOTI10V1>Aj24aNSO_3MiJOO20n0>Lk24aNXOWNHa55^J2O2`0c0j25`N]OXNMQ5EmJO13O015a04^O0[3g0^NOXNROW5LhJ016a0N_O105Z3j0^NOWNQO060Ed00c30kK0N0f04]O006X3g0bNl0SNeNU5_OQK007W3i0_Nd1^3[MnJ5V3m0^Nc1h3\\M\\J0_3R1\\Nc1\\NaMb8l0QId1[NcM9FB6o7l0lIe1YNgM62M@J0[7Q1`Jf1UNZM0=73NJJFR7P1jJe1UN]M0<1A0b02Ol6a0kJk1UNbM1D0>O@0b05C]6n0XKX2WNiL0S12UOOD4OJ1n5o0RJQOj1[3VNkL0Q10iN1;1F22i5l0QLS4RN_K0^O15214JR5P1gJUO0L30[1i5bNhJ5H6FX4V1]KjN33Y1\\6dNbI2<1DN3_4U1bKjNY1R7fNmHO:X4m0iKgNO2\\1f7dN\\H3Lj3Y1SLlN\\1S8\\2YIbMQ7fN_G0OZ3_1SNX7l1iHSNX7m1gHQN[7o1fHQNZ7n1eHRN]7m1cHSN^7QOSG^2`1_N^7ROSG_2_1_N_7POSGa2^1WM`NW1n8oNVGc2^1_Ng7a1XH^Nj7b1VH_Ni7a1VHWN`NVO[9c2XHTNaNUOW9g2XHRNdNUOU9j2UHRNT8m1nGmM]N[Og9h2nGkMU8U2kGlMT8T2lGmMS8T2lGmMS8S2nGkMS8U2lGkMU8U2lGjMT8V2mGiMS8W2nGhMR8X2nGgMS8Y2mGgMS8Y2oGgMo7Y2THdMl7\\2UH]MSNJk9i2RHXMSN10Ml9j2VHXMl7h2V200001O000000000000000000000PEVMSO1]:j2`FUMQO4]:f2dFVMnN3_:h2_FYMQONa:i2^F_Mc9`2^FaMa9`2^F`Mb9`2^F^Md9b2\\F`Mb9`2\\FcMc9]2]FaMe9_2[FaMe9_2[F`Mf9`2ZF`Mf9`2ZF^Mh9b2lETMG;\\:a2mETMB0K029e:c2eETME42LM315g:d2cEVME23`2\\4W1SKTN5SN?o0]O8l4`2UKWLNT14gNO2MN<2;m0ZOTO2MM202010K14O=m4\\3UKYL2n0:lNi0`0iNFo0K]O?`4[3dKYMZ1oN9:i2]3eK]M^3VOl0`3cKZMb3VOk0_3dKXMe3WOh0_3eK]M`3TOm0^3cK\\Ma3WOj0^3fKZMa3UOmKHj4j3hKWMc3WOkKGk4j3iKWM^3[Ok0]3gKYM]3[Oj0^3iKiL\\OHP42j0\\3lKgL^OHP43f0c0XKY1OjMP1Nhjd1", "size": [480, 640]}, "area": 171607.0, "iscrowd": 0, "image_id": 11122, "bbox": [0.0, 88.0, 527.0, 392.0], "category_id": 113, "id": 20000667}, {"segmentation": {"counts": "0d1\\=O1MdBaN]=_12001O1O0000LcBcN_=]121O002NNbBcN]=]13001`BbN\\=c1N001O001O001O1O00000000O10000001OO11O1OO11OO1N22N1O001O0000O1000WC]NUOC1NZ0C^\\BN0Gg=8]B0MIX>7hAHY>LeA67KW>8fAG\\>61KOYA2`>N_A1OO06\\>]OPBe0Q>5M4N1001ONRORBn0l=3002OO02N102NM31N2O1OO1N21O3M2N2N1ON2iAYOW>h0M1101NM4O02O00N1NVOPBj0Q>UOPBj0j=WOXB0Nh0d=]O`Be0a=\\OZBI3j0d=AYB?e=?1OL6JbNeB_1[=bNdB]1^=3O0O0N3VN]NXFb1h9^NXFb1h9^NkE2kNc1Y;\\NkE4gNa1T:YNPG0mN2g0OE5Bb1U:XN`F0G9=JAn1j9PNQF172L5?O]Oj1R:PNlE48NM7ME51K8Of1W:RNfE88MN;J_O20O427Mc1V:TNlENO8;IDO5a0L@0OOa2Z:bMgENO71H11O36>IT2[:^MeEM071IO94FO?MW2[:aMeE20H0a03c2X:UNfEi1]:\\11000O2O00000000O100O10010O0000000O10001O000000RH", "size": [480, 640]}, "area": 6655.0, "iscrowd": 0, "image_id": 11122, "bbox": [539.0, 252.0, 101.0, 168.0], "category_id": 126, "id": 20000669}, {"segmentation": {"counts": "U2T6f4\\JoNe5Q1\\JmNf5Q1[JPOe5n0\\JSOc5n0]JROc5m0\\JTOe5k0[JTOf5m0YJTOd5n0\\JPOg5o0XJROk5eLfIo00c1>h0m5fLfIc3U6]L`I0M00415032]2>j05cL\\O7f5D]J9OJM^2`0`N_OQO0Y2b0`N^OYOg5K\\J0M065K]2?`NAoN0\\2`0gNBlNM31Ng54YJ?OW1?TOAQO6Z2JfMb0T1@TONLo51RJ50`1>UO1Q16TOZO\\O:@;1[OOU57lJ10V1>A1U13BEiNHM0JY5MiJOO20n0>L2V12C@FOeNa55^J2O2`0c01X1_OjM?_3CnLQ5EmJO13O015a04^O0b0n1Jg1ESLW5LhJ016a0N_O105b0P2Hi1EQL060Ed00c30kK0N0f04]O006`0R2Ga2FeKU5_OQK007>T2GX3o4\\JnJ5>W2DY3Z5\\J\\J0g0[2CZ3MaJi5U2[JZ3JdJ9FB6V5V2UKZ3IhJ62M@J0b4\\2hKZ3F[J0=73NJJFY4[2RLY3F^J0<1A0b02OS4k1TL`3EcJ1D0>O@0b05Cd3V2bLP4FiI0S12UOOD4OJ1T3\\2WMn3ElI0Q10iN1;1F22P3X2WMg5E_H0^O15214JY2\\2kM^6EhG5H6F^1]2bNP7EdF2<1DN3e1Y2eNe7FPFO:_1P2lNZ8E^E3LQ1]2VOi8e0WG[OR9FbD0Oa0]2IX96hFJY95gFLX94gFMZ92gFMZ92fFN[90fF0Z9OgF1Z9MhF2X9LjF4Q<00000000001OO10O11O01O0001O0000O11O0000000000000000010O00O1001O0000000000O110OO11O00O110OO10000001O0000O11O00001O001OO1011N11L5M3M1N110O000O2O00N2O1O2M2O1N2O10001O00000O11O00000000000O1001O01O0000000001O000000000001O00O1000000000001OO20O000000000000000001OO100000001O0000000001O000000000000001O01N02O01O000000O1O1OF^A8b>G_A9a>G_A;0E`>8bAH^>9_AG00a>=00000O1001N2O1O01OO101OOdA@[>?dAB[>?eAA\\>a00O100N21NO22OOO003N000001O1N1@bA=_>CaA003MO100M310OO2N2NObAB^>>N44ML4M11\\OfAb0^>M012OOO2N1100O1O1O2M3M]OhA>OA]>?O202L311OO1O0KgAA[>?32MN320N10N2J^OjAe0U>26KO03M1OO12O10N011O03K02JFfA:[>5002N4L2N]AG_>9`AH`>;100N22\\AE_>=12O1M1000ON0027H3N1000000O11O00010N001MF_A;_>4OBdA:]>EeA9a>1N1O4NN1N4L3L3M^Q70cnH2TANi>6N4ZAF_>;aAG[>;eAE\\>:dAF]>>N22NO1O10100N10M4O100J6N012L5Lnb=0l\\B7J7M3N20O1OO2O000O11M12O01O2M100AbA;`>DaAN12NN0001O1O3M0K5005J100O2N11O1O2N1O1N1N42NN1ON2]OeAa0^>N12M02LbAC_>;41O1O0O1O10O100001O2N0O1M33L2O0001OO1000001ON2N3eA\\O\\>c0O000eA^OX>d020N02N1O02K52K4N00000000bHA;`0CC<;]O@^I8S79_ON<6UO]OSJ>l60kL_OTN5SN?o0]Oe4?SNBWLNT14gNO2MN<2;m0ZOTO2MM202010K14Oj4`0oNBYL2n0:lNi0`0iNFo0K]Ol43nN1YMZ1oN9f4]NQO1]M^3b3`LTOOZMb3b3_LSO0XMe3d3[LRO2]M`3`3aLROO\\Ma3a3`LTO0ZMa3_3`LXOOWMc3e3ZLSO5WM^3j3\\LnN6YM]3i3\\LPO7iL\\OHP4`4\\LnN:gL^OHP4a4XLULFY1OjMP1KYOIU48`MC[NR58]Kc0EoNMj4>iKDN4_OO0l4e0\\KP5A[J0OXi]1", "size": [480, 640]}, "area": 20345.0, "iscrowd": 0, "image_id": 11122, "bbox": [0.0, 65.0, 543.0, 415.0], "category_id": 132, "id": 20000670}, {"segmentation": {"counts": "nZU62o>OO1000000O1M3O1NJZA6e>3O100O11O0000001O000000O1000000O1O1O12NO100000000O11ON2O11OO1O11O00000000JCgA?Y>400N21ON2001O00O11OM3O11O0000O10000000000O100000000O10000000000000000000000001O000000O1001ONTOQBk0o=UOPBl0P>200000000O1K5I700001O00001O001OM3001O1O00001O1O00000000O10000O11O00001O1O00000000\\OjNUC1H0OW1S=iNVC^1h0L4B>O1O001O00001O00LiA_OW>a0iA^OX>c02002NO1L45OH8Mgke5", "size": [480, 640]}, "area": 372.0, "iscrowd": 0, "image_id": 11122, "bbox": [231.0, 0.0, 21.0, 23.0], "category_id": 157, "id": 20000672}, {"segmentation": {"counts": "d1a0^>0N@eA`0\\>3O1000O0O11K]OiAc0Y>21N102OM^OgAc0W>4bCYOVN31NQj:^OSE@c1j1Z9kNdFT1]9kNcFU1]9lN^FX1c9gN^FX1c9gN]FY1c9gN^FX1b9hN_FW1a9iN^FX1b9hN]FY1b9hN^FX1b9hN_FW1a9iNaFV1^9kN^F[OeNj1n:iN]F[1b9fN^F\\OiN0L30[1n:VOcF\\O^N33Y1n:WOdF_O^NY1n:XOdF^O[NO2\\1P;WObF]OaN\\1l:XOkFf0T9\\OjFg0W9WOjFh0W9WOiFg0Y9XOiFh0W9XOgFh0Z9XOfFh0Z9XOgFf0Y9[OgFe0Y9\\OfF\\OUNW1T;UOREDg1X1V9QOVEGc1W1Z9jNjD1Z2V1l8hNWGP1cMVOW;KXGl0eMUOe=i0^BUOb=l0:JmA[OW>c031O1O10N002O1O1O0O10201M1I_AJd>1\\A10Mj>2Ta6OXPI1^>O`A4_>L`A3^>1aAN`>811O00N22L3ON200O100NFFRB;m=EnA0K029o=GPB42LM315P>JoA23OO[OhA`0O@\\>`021OO12N10L3O1O10010O010O2D^A5k>Lof;NSYD1RA0i>4O000YAKe>8O2NO\\OH_B1C8l=H]BNH108l=J[BNH009l=J[BOHO06n=ORBI34MM19j=h01O2N0N]BSOZ=l0dBXOZ=g0cB[Oa=c0_B\\Ob=d0\\BZOh=h0TBXOn=m02M2M3N4M0O110N1002O0O3nAXOd=l0WBZOf=g0XBZOi=IWBT1j=0O1oNkNXDT1g;mNUD0TOT1gOC1N4T1`0_:CaDJLO?0B0O4U1>]:]O^D<0F0O>0C8U16_:7hD[OC8Q1HPOO0`0c;4^D\\O54I5Q1HPOb0c;2]D[O6?j08b:O]D\\O5?k05d:4aDFk08d:4\\DTO0`0P18e:g0YEZOg:h0XEWOi:h0[EUOoN[Oe;`1ZEXOf:h0VE[Ok:e0PEaN[Oj0d;UO\\D_1>bNFl0Z;TOeDa1<_NDm0Z;TOgD]1:dNAM1n0_;TOdD]1=dN@k0T;ROQE7KZ1?Cd:mNUE3G]1`0De:lNQEg1=[Ob:ROnDb1`0\\Ob:SOoD_1?]Od:n0\\ESOc:n0\\EPOb:POmDQ2?PO@nNR;1nDR20mM=U1f:P1mDkMOAa0m:\\2bEeM_:X2cEhM^:W2dEhM\\:U2gEjMZ:W2gEdM\\:]2cEeM[:\\2dEdM\\:\\2_EWMAa0n:X2aElM^:T2dEjM\\:U2bEPN\\:P2fEnMZ:T2dEkM]:V2cEjM\\:U2fEiM[:R2SE\\Me0?Z:U2hElMX:Y2cEgM]:X2cEgM_:[2^EfMb:Z2]EfMd:X2]EkMa:V2^EiMc:X2]EgMc:X2]EiMc:W2^EiMa:W2_EjM`:Y2[EjMd:T2^ElMb:n1TE]M:d0c:P2bEQN]:o1cERN\\:P2bEPN^:T2^EkMc:W2[ETMG`0o:\\2ZESMH8OJ1Mo:n2\\E\\Ml:d2TE]Mk:c2SEYMS;g2oDRME0^;n2a0001OO10000M3M36J1O000000000000001OO1O1MPDUMQ^Og;i0[DIN^Og;i0ZDIMCg;e0ZDIMYOF:Rb:3RD]OT1i0j:K[E5eNVOm;f0^E4dNWOm;d0bE9[:FgE;W:FaEc0]:]OeEa0[:_OiE=W:AmE=S:CnEd0a1S;]NoDc1R;QNVD107f0g1V;QNVD5e0k1T;QNWD4e0k1T;PNXD6c0i1V;QNWD7b0e1_;TNmC2f0m1Z;QNQD1d0P2_;PN`DP2a;oM_DQ2R\\;k22O1OM31N1O11O1O01N1000M3L6LO202NO12OO1N2O10O011O10010M1000002FgDiLX;Y3gDhLZ;U3hDjLZ;n2cDnL71IO^;Q3lDoLW;Q3;2N3OJ52N3M000O02N1M1PMTDS3g;3M2011O100NZDkLe;U3300001OMZDlLf;U32001OM31O1OO1O1001O1O1O2N3MO1000000000000O1000000L[DmLe;S3[DmLe;S3[DmLe;S3[DnLd;R3\\DnLd;o2\\DnLj;h2\\DZMf;a2?0000O1O100", "size": [480, 640]}, "area": 43201.0, "iscrowd": 0, "image_id": 11122, "bbox": [0.0, 0.0, 640.0, 185.0], "category_id": 169, "id": 20000673}, {"segmentation": {"counts": "o[e31n>;DRG@P9?QG@n8b0RG\\Oo8e0PGZOm8j0SGUOn8l0QGTOo8m0d0UOaE10j0\\:=O1N101O1N1O2O1N2G\\NXF1OO0e1d9=nFnM_8Q2`GPN\\8T2cGmM]8S2bGnM[8U2eGkM\\8T2cGnMY8U2fGkMZ8V2fGjMX8X2gGhMZ8X2fGhMZ8MZGW2;mM_8S2aGlM^87ZGD1d16`N`8:]GW12_Na84hGY1FbNf81hGLZO10Y17hNf9NTF00X15iNn9X1QFhNP:Y1nEfNT:\\1iEdNW:^11OO001`FfNb8[1[GhNf8V1YGlNe8V1ZGkNf8U1YGlNg8R1[GnNb8FkFb00GP12T85\\HMd73ZHOd73ZHOf71oG:R8ElGZ8CfG=]8@bGa0^8_ObGa0^8_OcG`0]8@XGBGn0Q9@WGCIl0P9AVGDKj02TO`8PM@o74PK;QMAQ83oJ9QMEn75PK5RMFn76PK3T5NlJ1T5OmJ3P5MoJ4Q5LoJ4R5LmJ4d4DkH8a24d4DiH:b22f4DeH=e20e4EbH>h2Lg4F_H`0j2Jg4YKBg4>YK@i4`0VKAj4`0UK_Ol4a0TK@j4N_H6g2MZMC42n61TI<`2;^4XORI>[2>c4SOSI?V2c0f4nNTI?Q2g0m4iNRIa0l1k0Q5eNRI`0k1l0S5eNRI?j1m0T5dNRI?i1n0U5cNRI`0g1o0V5bNRI?h1o0V5bNRI?g1o0X5bNQI?f1o0Z5bNPI`0d1o0\\5aNPI`0d1R1Z5^NQI`0d1V1X5ZNTIa0b1[1XNRNj62\\Ia0a1_1S5PN\\Ia0a1_1S5QN[I`0a1`1T5PN[Ia0_1a1U5nM\\Ia0_1a1V5mM[Ib0^1b1V5nM[I`0^1c1W5mM[Ia0\\1c1Y5lM[Ia0\\1c1Y5lM[Ia0[1c1\\5kMYIc0Y1c1^5jMYIc0X1d1_5iMYIc0X1c1a5iMWId0W1d1b5hMWIe0U1h0gNZOl6ZOYIc0T1e0kN_Og6YOZIc0S1a0ROBa6ZOZIc0R1>WOFZ6[O]Ib0P19^OIY6YOZId0o06CLS6[O[Ic0n03HOn5\\O\\Ic0l01L1k5[O]Ic0k0O14f5YO_Ic0j0N45c5ZO_Ic0i0L:5fNXOg63`Ie0g0J`04bN[O03`6OhId0e0Je0=m4UOiId0e0Gj0?g4VOkIc0c0Go0?b4WO\\J414V1?]4YO_K67`0Z4ZO^K6;>W4\\O]K5`0=R4_O]K4d0;o3AlILW16R1;j3DmIKV16V1:e3GmIJV4>m1GmIKX4=k1GmILY4=i1GmIM\\4:h1GdN7\\1GiIOk4;]6O22MO21N00O2N1O20OO21N100O1O01O001O0100OO[JKZJN\\5692GO63JN44KMKGlJ?Y5KHHmJ?[5JFGoJ`0[5IE?:CD=;DD>:@He02\\OIh07XOHj0VKiNm4>Ml03UOMj03VOMi04ZOJe06[OJf0eLgNP2e0Y1c0gLjNo1d0V1e0jLiNo1b0W1e0iLkNo1`0X1e0iLlNn1>[1e0eLPOo1;[1f0`LVOT24\\1f0ZL]OY2M]1f0TLD^2F^1f0mKLd2^O_1f0gK3i2WO`1e0bK;m2PO`1d2_N\\M`1f2^N[Mb1_O_KL0o2l2hMi1WO^K0NS3h2gMU2[2fMhMZ2Y2cMhM^2Y2^MiMb2Z2ZMgMf2[2VMgMj2[2SMeMo2]2lLgMS3Z2iLgMZ3Y2cLhM^3Z2]LiMc3Y2YLkMe3[2RLZMnNTOQ5g3jKTMXOTOT5h3\\KUMBROR5o3UKoLKROo4U4nJjL6oNl4d5VK[Jg4g5[K_J]4a5dK`J\\4^5eKcJ[4[5eKfJ^4V5cKiJ_4U5bKkJb4P5_KPKa4o4`KQKa4m4`KTKb4h4_KYK`4f4`K[Ka4b0VK_2:oL`4?nKl1CeM`4;dLl0\\OiNR46YMMUOKe34GK:3HN7OK25KN52H18OE4;JD9=`5O11N10O100O1000L3L6J7I6J6J6J4M00M3M3M3L4M3M3M6I8I:FUV5;XiJ?H8I7O1O1N2O1O1N3N1O1N4M1YH", "size": [375, 500]}, "area": 24970.0, "iscrowd": 0, "image_id": 11149, "bbox": [0.0, 0.0, 500.0, 314.0], "category_id": 129, "id": 20000676}, {"segmentation": {"counts": "iXP4163T;OkD2R;2mDNS;2lDOS;2mDNS;2mDNS;3kDNU;2kDOS;;O12N001O1O01O01O00O1000001N01000001O0000001O001N4M6J001Ldg00_XO0iiW1", "size": [375, 500]}, "area": 552.0, "iscrowd": 0, "image_id": 11149, "bbox": [350.0, 95.0, 41.0, 22.0], "category_id": 139, "id": 20000677}, {"segmentation": {"counts": "Z8]3[8O1O1O1O1O1O2N1O1O1O1O1O1O1O00000000O1000000M3N2N2N2N2O1M3N2O100001O000000001O00000000000000000000001O3M2N6J8H5K4L4L4L4L3M3M2N2N2N2N2N2N3M2N2N3M1O1O1O2N1O1O1O1O1O2N1O1O00001O001O00`JXO1h00[OMd03@I`08CE<;I@7a0K\\O5d0MZO3g0NWO2i00UO0k02SONn03POMP14oNLR14mNLV13hNM\\1OdN1`1L_N4d1J[N6i1GVN9n1DQN\\2DaM<`2E^M;c2F[M:e2HYM8h2IVM7k2JSM6n2JQM6P3KnL5S3LkL4V3MhL3Y3NdL3]3MaL4`3M]L4d3MYL4h3MUL4l3MQL4P4MmK4T4MiK4X4MeK4\\4MaK4`4M[K6f4MRK7o4NgJ6Y50^J3b54oI4Q6i21O0000000000000000000000000000001O0000000000000000O100O100O100O10000O100O100O100O10000O1O100O10000O100O100O100O100O100O1@RKWJn4j5[KkIf4Q6PKoI^5R631O002N3M2N1O2N2N1O=C00000000N2N2N2N2N20000001O001O00001O001O00001O00001O001O00001O001O000000O100O1O1O1O100O1O\\KZIY4e6]K[I72\\4f6cK[I\\4e6_K`Ia4k60001O1O0000O10000N_KnHa4R7_KnHa4R7_KnHa4R7_KnHa4Q7`KPI_4P7aKPI_4P74003M00000000O11OO100000000N200O11O1^KnH42o3]71001OO11OO100001O00O1O1003M3M5oKXHi3k7000001O0000000000O10000O100001O001OO100001O2N000ZLQHd3o7\\LRH03]3U8O1O1O0000000000001O1O1O1O00003MO13MO12N00O1O1O11OO12N1O1O1O000000001O1OO1O11O1O1O1O1O002N002NO11O001O1O003M002N1O0000O100000000000000000000001O00000000O12NO1001O3M0000001O00007I1O1O00O10000001O1O00000000N2O11O000000001OO11O00O100O10000O11O2N1O1O1OO1LSN_Fl1f901O00001O0000000000000000O10000O100O10000O100O1M300000000000000001O00002N00", "size": [375, 500]}, "area": 51784.0, "iscrowd": 0, "image_id": 11149, "bbox": [0.0, 173.0, 500.0, 202.0], "category_id": 140, "id": 20000678}, {"segmentation": {"counts": "eiR18^;1EJUE6k:HWE9GK4MLOb:0^E1003<3HZ:P1nEkNb9W1WFnNi9Q1]FjNc9g1N000000O11O1O000VFYNd9g1[FYNf9h1XFYNh9j1100O10000000000O10000001O1O001O1O001O1O1O001O1O1O001O1O001O1O1O1O1O1O1O1O1O1O1O2N00O100001OO100O1000000O12N002N1O0000O11O1O0000O1TOPGQOP9dE:Y:c001O03M001N010000O001O1N2FcNZF]1f9cNZF]1f9eNVF^1h9dNUF^1n9`NQF`1n952ON11O0^NQF\\1o9`NRF00`1Q:aNoE_1T:00aNlE\\1W:002ON2N2O00O2O0OIhElN02Y:k0hEUO2OW:k0hESON150T:n0<_O`EDK3g::`0N3GfDO_;NaD2he7NfZHOc:6YEJF0[:]1K4M2O00O101OO110N2O00M3[OlETO93U1M[7i0YIWOg69WGNX2L^61\\GLZ;1eD0c;OTG0S60oH0RO1i91iENM0\\9:iFLMKMO[9>hFKNHO1Y9:jFONFO0Y9V1hFjNO0[9T1eFmN0OY9W1]FhN30N39NX9e1gF\\NY9e1fF[NY9f1gF[NX9c1`FZN83Y9b1_F[N81Z9e1^FZNm9f18JO1O00001N2N2O10ONZNTFh1f98N1N2EoMlFV2S9jMkFX2U9410N2O1O100002N01O02N0000O100M`MoFa2m8510O100J7L30001O00O10000N23MO1O1001O001O00000000000000O100O1O11O1O001O00O100O1000000O1O12N001O1O00001O00O1000000O1H_GXMc8f28N2O1GPGhMS9V2oFhMS9W2mFiMT9V2700001OkNeFOZ9JnF1W9NhF2Z9LhF4Y9TO]Fb0:;`9AaF>`9_ObF1EEN5k95bFOKGIOk9:bFM3H[9;cFJS:6nEFU::d00YEFP:=jEJR:7lEMR:4lEMS:8iEIV:l0DfN[F[1d9fN[FZ1e9gNRFb1m9401O00O1M3N2M3M3K5N2L4O1M3MTGUOR7i0mH[OR7b0oHFk65WINi60UI4k6KRI9n6EQI;R7DlH>U7[OVGN0Oa1m0X7ROPIR1h85J4M6I3O2L6H5M4K4L5N3M2O000O1O1^O[MdG07h2Q8`MmGj1MnML>Y8NiGi17kM\\8c2=O1O1TOoFQOR9h0XGVOg8c0cGZO]8`0lG]OT8a0PH^Oo7`0VH]Oj7b0ZH[Of7c0^HYOd7e0h1N2N2N2N2N2O1N2N2N2N2N2N200000000000000000000000000000000000000000000000000000000Z2[LmMV3LC0O100OOCZMmGd2U8]MiGc2X8]MgGb2Z8_MfG_2\\8aMcG^2_8bMaG^2_8>N10001O001O00001O001O000010O0001O0010O0001O010O00O1O2O0O2N2N^OkLdHT3\\7oLcHP3\\7SMcHk2]7XMaHg2`7YMaHe2_7]M`Hb2a7^M`Ha2a7_M_H_2b7aM^H^2c7cM[H]2f7dMYH[2h7eMWH\\2j7dMSH]2n7cMPH^2R8c0010mLjGd2V8ZMmGe2S8ZMnGf2R8YMPHf2o7ZMSHe2l7[MUHf2i7ZMXHf2g7ZMZHf2e7ZM[Hf2e7ZM[Hf2f7YMZHg2f7YM[He2f7[MZHe2f7[MZHe2f7YM\\Hg2e7VM^Hh2c7VM_Hj2W801O0O10001O0O^OZMUHf2e7`M[H_2f7aM[HY2i7hMWHT2m7lMSHo1R8QNoGj1V8UNjGk1V8UNjGj1W8VNiGi1X8WNiGg1Y8XNgGh1Y8XNgGg1Z8YNfGf1[8ZNfGd1[8\\NeGd1\\8[NdGd1]8\\NdGb1]8^NcGb1]8^NcGa1_8^NaGa1`8_NaG_1`8aN`G_1`8aN`G^1b8aN^G^1c8bN^G\\1c8dN]G\\1c8dN]G[1d8eN]GY1d8gN\\GX1e8iNZGW1f8iNZGV1g8jNZGT1i0hN[64lHT1e0lN_60lHS1a0ROc6LkHQ1?XOe6GmHo0:_Oi6BmHo06Cm6^OmHn03Io6ZOnHk02MP7XOnHj001R7UOnHj0N5R7QOPIi0L;R7mNRIf0Ka0Q7iNTIf0Ie0Q7fNUId0Hk0Q7aNWIc0GP1P7nNiH05W1P7KnH8Q7GoHRLCk3T1QK[Om4\\1oITOn5\\3N2M3M3M3M2N3A?O1N2O1iNkIjLW6o2SJmLm5m2]JoLd5k2eJPM]5n2gJoLU5T3PKgLm4]3WK_Le4d3_KXL^4k3c13M3M3N`MiHf0U7VOSIh0k6UO\\Ij0a6SOgIj0W6ROQJl0m5QOZJm0d5POdJm0Z5POmJn0Q5nNWKP1m4gNYKZ1m4YNZKg1[70000000O100O10000O100O100L4TOl0H8H8L4O1N2O1O1N2O1O1N2O^4bKbK", "size": [375, 500]}, "area": 75732.0, "iscrowd": 0, "image_id": 11149, "bbox": [0.0, 2.0, 500.0, 349.0], "category_id": 183, "id": 20000681}, {"segmentation": {"counts": "0[2P;000000001OO11O00O1000000O100MPEjMQ;V220000000000NmDmMR;S232N1OO1LmDPNS;P2nDnMS;S2lDmMT;S22O1001O0jDmMT;S2lDnMS;U20M300001O00001O1O0000001O1OO1O12N00N2O1O1001OO1O11O00O11O000000000kDmMR;U21O100N21O001O00000000000000003M:F2NO11OO10000L[EaMf:_23001ON21O1O000000O12NOYEdMa:a2200O11O1O00O1000000O11O00M31O5K00O1000_EYMO0]:l2hEVMNNl9n2SFVMOM\\10R7m2cGVMOMV17W7f2bG\\MW1OV7Q3cGfLR1<[7P3dGeLa0OE?V8m2cGeL1O:7J8X8P3cGbL1O86L:W8o2dGfL81M:W8U3eGlL10Y8h3gGVL[8k3cGUL^8\\40O12NN21OO10000O1O1001O001O001O000000O100O1000000O10000001O001O1O1OIcG`K]8_4dG^K_8b4bG\\K_8d4400O1O1N2dMiGDW8gGBY8>gGAZ8TOVG>`0>Z8TOVG>`0>Z8SOXGh2g8TM_Gj2a8VM`Gi2`8UMbGm1D\\Nj8GbGm1E[Ni8HcGl10PN]84cGl10PN]84dGm1MoM_84eGg1K[N`8MfGh1LYN^8MnG@I2i:NVX26biM2nBHo97ZF533KU1\\9YOgFCF]1]9VOiF_OJ[1]9VOiF_1V9aNjF`1V9_NjFa1U9`NkFa1T9_NlFa1U9^NkFc1S9^NmFb1S9^NmFc1R9]NnFd1Q9\\NoFd1JYMU9T1PG]OKf1T9mNQG]O;V1AYNP9T1TG]O;U1BZNo8T1UG\\O:Z1a8ZOUG[O;Z1b8ZOSG\\O;[1a8YOTG\\O;\\1`8XOUG]O:[1a8XOUGB4Z1d8TOXGHNQ1m8WOUGj1m8TNSGl1m8TNSGl1]8XMgGk0LP2Z8UMTHO4j2XORM`85THO6h2h7YMkG=;R2YO\\Ma85gGl0Mj1JVMb84gGl0Mj1KUMa85eGn0Oh1_8ZMbGn0Og1`8[MaGn0Oh1_8[MaGm00h1_8[MaGm00h1_8[MaGm00h1_8\\M`Gl01g1`8gNdGW1Z8iNfGW1Z8iNfGW1Z8TN[Hm1d7RN]Hn1c7QN^HS2^7lMcHS2^7lMdHHlNi1`8_NdHHlN>74Y8FeHGkN32^O=R1Q8FfHFjNC1OO9f0i0j7FgHDPOFg0n0c7HfHA5g0U7HgHZO:n0o6H^J6c5J]J6c5J]J2g5K\\JLm53UJJm55QJMP63nIOR61nIKQMCY9OlFa0[2MZ:0000000001O000O1000000000000000001OO1NDUCDCb8[OdG`0ITO?]1DD_8[OfG?9a0EC\\8]OgG0KM<8AA02O88:b8DcGNk1KRN9i8MmII\\M:f8MnIG_M;c8N_J2a5M`J3`5M`J4_5M`J3`5M`J3`5M`J3`5McI2lMc0o7JcIH[N?R8LaGUOi0060UO>7c0S8JbGUOe02[OO12d0M\\O10`08`0V8NSH_OMCBh077X81jGROG;0B:o0K1[81_GoN33N0O>;?I3[80dGQOMa03]O0Q1O0^82aGG2UO0Y2]8LaG:_8F`G;`8X20O10000O1000000bK_GR4a8jKdGNKR4`8oKlGR4S8jKRHU4ClKg8[41O001O3N0O1O2NO1101O00001O00N2O1]OjK`G2e2;[5:mG\\Oi24WM^OT8a1lG_Na2g0h5j0WJYOj5i0TJUOn5m0PJSOP6m0PJSOP6m0PJPOS6o0nIQOR6m0PJSOP6m0RJQOn5o0RJQOn5o0QJTOm5l0RJSOP6l0QJTOo5l0QJTOo5l0QJTOo5n0oISOP6m0QJQOP6P1oIPOQ6P1oIoNR6Q1`G[N\\2c0U6T1lIkNT6U1lIjNU6V1lIhNU6Y1kIgNT6Y1mIeNT6Z1oIdNQ6\\1hIoNT6n0mIUOR6j0oIUOR6k0nIUOR6l0oIROQ6o0nIQOR6o0mIROS6l0oI`NcM=_8U1lI[NdM11>`8V1kI[NeM00=b8X1iI[NhM=_8X1oIgNR6X1nIhNS6Y1nIfNQ6Z1nIgNR6X1QJ^N[M4d8\\1WJ_NUM1e8`1R3MZDaNf;_1300O1001O1O001O1OO1O100000000O1000000O100NkDdN_:`1ZEcNf:^1UEcNn:]1QEeNJJo:c1REfNNHP;b1QEkNP;R1QEoNP;Q1mDROS;c1000000lDlMQ;T2PEkMP;X201O00O11OO1MoDkMR;U2200MlDnMU;R2200000000000000N21O1O00O13M2N00N200001ON21O00O1001OO1N2001OMiDRNW;n13O11O0000000000MfDTN[;k1300", "size": [427, 640]}, "area": 55456.0, "iscrowd": 0, "image_id": 11197, "bbox": [0.0, 0.0, 640.0, 171.0], "category_id": 96, "id": 20000682}, {"segmentation": {"counts": "jbi01Y=102L20000O1O100N2N101N104OM2O002N00M4N12MO2O20O2N0001N1O2O00O2@WC[CBf<=ZCCf<=ZCCf<>YCBg]D4c;L]D6a;CmD;n:AaEMf:3ZEMf:1\\EOd:1\\EOd:1\\EOe:0[E0e:0[E0e:0[E0f:OZE1P<4L03M2N1OTFLb63\\IMiL0l92PIO\\M2c90eFMi16iMNi9OeFM>747i8FdFL32^O=R1Oi8GcFKC1OO9f0i0Hi8HaF1Fg0n0Al8F]FW1g0SOl8GVF\\1n0mNl8^1RGcNn8]1RGcNn8]1nFlNm8T1jFWOT9j0iFYOV9d0lF^Oj2mNg2c1aJYOAnN^1D00gN0T86cHITO?]1DK3mNKKOW88dH9a0EKOnNNR86UHKM<8AA02O88:3ZO7U8KSHk1KRN9n0h7h1nG\\M:k0h7i1lG_M;h0i7Z2WHfMh7[2XHeMh7[2YHdMh7[2XHfMg7Z2YHeMh7[2XHbMk7a1THlMc0ARO7e01h7DUGe02[OO12d0M\\O10`08f0Oi7:^GMCBh07a0Kj77oFG;0B:o0Ke9J\\E33N0O>;?Ig9O]EMa03]O0Q1Og9ORF2UO0Q=N6OVPo2", "size": [427, 640]}, "area": 21474.0, "iscrowd": 0, "image_id": 11197, "bbox": [186.0, 0.0, 226.0, 295.0], "category_id": 132, "id": 20000686}, {"segmentation": {"counts": "e4e0i4c2L]M5b2K^M5b2K]M6c2J]M5d2KTM_KHf4T3KRMbKIc4U3LnLdKM`4U3LlLfKO_4T3KkLhK0^4U3X50O11O001O00000000000000000000O10000000000N2A?00YM[LUI5e09>W3h5hLfI1b0W3h5hLfI1b0W3h5hLfI1b0W3h5hLfI1b0W3h5iLeI0c0W3h5iLeI0c0W3h5iLeI0c0W3i3`LjL9jN0c0W3e3fLlL3lN1b0V3f3fLkL4mN0b0V3f3fLkL4mN0b0V3j3bLgL8mN0b0V3i3bLiL8lN0b0V3j3aLhL9lN0b0V3i3bLiL8lN0:^3Q4[LgL5nNP5[4lJgLT6V3oIkLP6U3PJkLP6V3PJiLP6W3PJiLP6W3oIjLQ6V3oIjLQ6W3nIiLR6W3mIjLS6X3kIhLU6W3lIjLS6V3mIjLS6X3jIiLV6W3iIjLW6V3iIjLW6V3iIjLW6V3iIjLW6V3iIkLV6U3jIlLU6T3kImLT6R3mIPMQ6P3oIPMQ6o2PJQMP6R3mInLS6Q3nIoLR6Q3oInLQ6R3oInLQ6R3oInLQ6R3oInLQ6S3nImLR6S3nImLR6R3oInLQ6R3oInLQ6S3nImLR6S3nIlLS6T3nIkLR6U3nIjLS6W3lIhLU6X3kIhLU6Y3jIgLV6Y3jIgLV6X3kIhLU6X3kIhLU6X3kIhLU6X3kIhLU6U3nIkLR6T3PJkLP6U3PJlLo5S3RJmLn5S3RJmLn5S3RJmLn5S3RJnLm5R3SJnLm5R3SJnLm5R3SJnLm5S3oIUKIh1X6S3oIUKIh1X6S3jIVKOO0g1W6T3iIWK0N0g1W6Z3iIoJ0g1W6Z3iIoJ0g1W6Z3iIoJ0g1W6[3hInJ1h1V6]3jIbLW6^3iIbLW6^3iIbLW6^3iIbLW6^3jIaLV6_3jI`LW6`3iI`LW6`3iI^LY6b3gI^LY6b3gI^LY6b3gI^LY6b3gI]LZ6c3fI]LZ6c3fI]LZ6c3fI]LZ6c3gI\\LY6d3gI\\LY6d3gI\\LY6d3gI\\LY6d3gI\\LY6d3gI\\LY6a3jI`LU6Z3hITK4a1T6Z3SJfLm5Z3SJfLm5Y3TJgLl5[3RJeLn5Y3TJgLl5Z3SJfLm5Y3UJfLk5Z3UJfLk5Z3UJfLk5Y3VJgLj5X3WJhLi5X3WJhLi5Y3VJgLj5Y3VJgLj5Z3UJfLk5Z3UJfLk5[3TJeLl5[3TJeLl5[3TJeLl5[3UJdLk5[3VJeLj5[3VJeLj5Z3WJfLi5Z3WJfLi5Z3WJfLi5Z3WJfLi5Y3XJgLh5Y3XJgLh5Y3XJgLh5Y3YJfLg5[3XJeLh5[3XJeLh5\\3WJdLi5]3VJcLj5^3UJbLk5^3UJbLk5h3kIXLU6h3lIWLT6i3lIWLT6i3lIWLT6j3kIVLU6j3kIVLU6j3kIVLU6j3kIVLU6j3kIVLU6i3lIWLT6g3oIXLQ6h3oIXLQ6h3oIXLQ6h3QJVLo5j3TJTLk5l3fIlJ>V1l5n3fIlJ`0T1j5P4fImJa0R1h5Q4gImJa0R1h5U4fIhJ`0S1j5W4VJiKj5W4VJiKj5W4VJiKj5W4VJiKj5W4VJiKj5X4UJhKk5X4UJhKk5X4UJiKFlNm5\\5\\JiKBkN20P6\\5\\JPLc5P4]JSL`5m3`JVL]5k3bJUL^5k3bJTL_5k3bJUL^5k3bJUL^5k3bJUL^5k3cJTL]5l3cJSL^5m3bJSL^5l3cJTL]5j3eJVL[5j3eJVL[5[3SJZK0O0Ob0\\1\\5Y3`J[K4\\1\\5W3XKiLh4V3YKkLf4U3ZKlLe4U3ZKlLe4T3ZKnLe4R3[KnLe4Q3\\KoLd4R3[KnLe4S3ZKlLg4T3YKlLg4W3VKiLj4T3YKlLg4T3YKlLg4T3XKlLi4T3WKlLi4W3TKiLl4U3TJYKP1c1k4T3WKlLi4Q3VJ\\KR1c1g4Q3VJ]KT1c1d4P3YJ\\KT1c1c4Q3`KPM_4o2bKPM_4Q3_KPMa4P3_KoLb4Q3^KoLb4Q3^KnLc4Q3^KoLb4S3\\KlLe4T3[KlLe4T3[KlLe4U3ZKkLf4U3dJZK5_1Y5[3\\JVKG0d0_1W5^3]JVK;_1U5`3ZJRK?L_Ob1g5i3hJeJAd1f5h3iJZLU5h3kJXLT5i3lJWLT5i3lJVLS5l3mJTLR5m3mJTLQ5n3oJQLQ5U4jJkKV5W4hJiKU5[4jJeKV5\\4iJbK[1cNU2e5^LUJ4f1?ZN05n2j5bLQJKf1d0[N14n2k5aLPJLf1d0\\NK0A4a3m5`LnIOe1b0ZN^O393G0`3S6`L^Ka0YN_O465IM_3U6bL\\Ka0aNC2KM^3T6cL\\K`0fN@6[3j5eL[K;_Oo2R7fLgG7Y1Q3Q7hLgG1]1V3c800N2N200O100O001O1O1000000N2M300O0O2O1O1N200O1O1O1O1O10YNaMbH]2`7jMmFHY1]2l7oMRHP2P8RNfGBWO[2Y9oMRGGJOKZ2[9oMdFH412NKZ2Z9PNeFF182INW2]9QN^FG202:2GOU2a9QNZFK0N4?LC4T2e9UNZF91`1g9XNUF:0[O1S2i9Z1100O1N2O010N2O1O2N1N201N1O1O1O2N1O1O2O0N201O0NG\\MoEc2]:]MZE_2h:aMXE_2j:N201MlMjMVIU2g6PNYIP2h6oMYIn1j6QNUIP2m6nMSIR2n6mMRIQ2Q7nMoHR2U9O002N100N^MSNjGM_10RNm1_8UNdG76Ge10RNm1_8WNaGb0m1ZOSNk1a8TO[Ik0f6XOXIf0i6]OTIb0m6_ORI?P7AoH?R7AoH=R7CnHe201OO10GXCOR=01O000000000000O1O11O0000000000001O00000000000O1N2O11O1O0001O1O2N0000hR20XmM000000000O1000000XR\\<800O11O0000001O00000XObCc0h3NO10O100000O10000O10O1O1O1O2O1N1N`mi2", "size": [427, 640]}, "area": 533.0, "iscrowd": 0, "image_id": 11197, "bbox": [370.0, 149.0, 54.0, 20.0], "category_id": 143, "id": 20000688}, {"segmentation": {"counts": "Z5R1Y<000O10001OO1000O11O2N2N1O001O0O1_OiCMW<1bCIm<4XCKh<1mX6OYZI004h<:10O0000001[OBPD7K7UcJAa5<^JDc5;]JEc5=[JCe5>[JCd5=ZJEf5;ZHRNm1d1i5:ZHRNm1d1j59YHSNk1f1o56PJKS63kIOW6NhI3Y6LeI6[6IeI8[6IcI8]6HbI9^6HaI9^6GaI:_6G_I:a6F_I:a6G]I:c6GZICiNXOm7U1YIBlNWOm7W1TICQOTOl7Z1QIBUOmNP8b1iHAYOfNT8i1bHAn7`0PH@Q8a0mG@S8a0kG_OV8a0iG_OX8d0dG]O\\8c0cG]O^8b0bG_O^8a0aG_O`8a0`G^Oa8b0]G_Od8a0[G_Oc8c0]G]Oa8f0_GYO_8j0_GWOa8j0^GVOb8l0\\GTOe8l0ZGTOg8l0QGdM1c1n8d210000O10000O100O10000O10000O1O100O1O100O100000000O1000O1N2O11O1O000O10000O100O100O100O1O2O0O10000O1000L[LbFe3^9[LbFe3^9[LbFe3^940000000O1000000O100O10001N10000O10000O102N2N0000000000000000O1O1O1L^L]Fd3c911000001O0000001O0000]FiLU9T3jFmLV9S3iFnLW9R3iFnLW9R3iFnLV9S3iFoLW9P3iFPMW9P3iFPMW9b300000001O00O101N100000000001O0O1000000001O000]OlFoLU9P3c000000000000000000000000001O00002N2N2N1OO11O0000O1001O000000010OQFVM^9[300000000000000000000000000000000O2N1000O10001O0^O^F[Mb9e2^F[Mb9e2^F[Mb9e2^F[Mb9e2_FYMb9g2^FYMb9g2_FXMa9h2kFlLU9T3a0000O11O01O0000000000001O00000XFkLZ9V3^FSM`9]3O1O00000000O1000001O000000O4O0N2M3N2O0N10000000000001O00O1dI", "size": [427, 640]}, "area": 51902.0, "iscrowd": 0, "image_id": 11197, "bbox": [0.0, 165.0, 640.0, 262.0], "category_id": 149, "id": 20000689}, {"segmentation": {"counts": "[2Z2Q;00000001OO110O0O1000M3M2O2ONnMlDS2T;3O1OK5M3M3M1WNcDd1a;05K4N00McNZD[1h;fNVDZ1l;eNTDZ1m;2O1001O0dNSD[1l;eNUDZ1n;0_DfNn:^1PEeNn:[1REgNl:[1REgNm:Z1oDjNo:l1MaNnDQ1g:nN\\EZOO2NY1h:ZO[EZO001[1d:[OgEd0Y:\\OgEh0U:XOkEg0W:XOiEi0W:WOhEh0X:YOfEi0Y:U12K30N3N1O10010N1O3OM2O011M20000O1O1`MXE]2j:O1O2OO03N12O0O002N00M3O12NN2O4N9H0NO11]NlDl0T;UOlDj0U;VOkDj0U;WOjDi0R;mNeD;9i0GlNW;>REi0n:^OkDa0W;i0N30M30O00001N21M0QNlDj1X;11O011O10O1N1000000O110O1L2213K00O1000SNeDO0i1`;\\NbDNN[1_;dNeDOM\\1_;eNdDOMV1e;iNdDW1h;iNnCR1We2c9XM^Fi2o9WMcEa2d:O6N2N0000O1N202N00O1O0100002N010O000bMUE\\2m:1O00100O1N3NI41110011OO0OO2XEcMd:[2YEdM11f:[2YEeM00g:[2YEhMg:^2O021NO03\\E[M40P:k2kEUM11T:R3MnLmER3S:4O1N10011O_NYF\\Og9d0YF\\Oh9c0XF\\Oj9c0VF]Oi9d0WF[Oi9f0WFYOj9g0VFYOj9g0VFXOk9h0UFWOl9i0TFXOj9i0VFWOj9i0VFXOi9h0WFXOi9U2OMRFlLm9S34cMlEg1X:RNkEn1V:mMkEW2T:hMnEJJY2Y:hMPFNH[2W:fMVF\\2f9eM[F]2d9`M_Fa2U:00001O]M[E`2e:aMZE_2i:010dEaMj9_2VFaMi9a2SF^MG1W:`2RFdMl9^2SFcMi9JnEe27bMk9c2oEaMP:m2MhLRFY3n93O00O11O1O00O11M21L4N1O004L3N01M20O101M021O00O1010OO1N20100LiLRFW3n93O11O01O0000000MeLUF\\3j94O0TN", "size": [427, 640]}, "area": 24243.0, "iscrowd": 0, "image_id": 11197, "bbox": [0.0, 29.0, 640.0, 148.0], "category_id": 169, "id": 20000690}, {"segmentation": {"counts": "hW24U=3L3N2N2N5J5K5L3N1001O1OK4SDnN`;T1]DQO_;R1]DRO`;o0^DUO^;^1M3M3O1O1N2O1O101O000001O000VNoDZ1R;eNPEY1P;fNSEX1o:fNSEX1P;_NYE^1^;ROSD6\\:ZOiG8kMN\\:LdE01Nj13m80VE001k<:01OO101O]X`0Mfg_O00O2O0000UUP1HRkoN1jB;fVJ@j5a0WJ]Oi5d0XJZOh5g0YJWOg5k0YJSOg5n0ZJPOf5Q1[JmNe5T1\\JjNd5X1\\JfNd5[1]JcNc5^1^J`Nb5a1_J]Na5d1`JZN`5h1_JWNa5j1`JTN`5m1aJQN_5P2bJnM^5T2cJiM]5X2]31O1O1O2N1O1O1O3M3MiNaDVOOZO^;_1gDSOc;l0aDoNa;P1cDkNX2F[6]1bGhNR21Y6V1iGeNl1;X6o0dJWOY5h0eJ]OY5c0dJCY5=cJG]5:`JH`58^JJb56]JKc55\\JLd55ZJLf54YJMg53ZJKg56ZJGg59[JEe5;]JCc5>_J_Oa5a0aJ]O_5c0cJ[O]5f0dJWO]5i0eJUO[5n0eJoN[5T1dJjN\\5X1dJfN\\5]1j33M1O1O2N1O1O2N2N4L3M3M3]D^MR;e2gDbMV;P3L5gEnLj8Y3gFUMS9Z4J6J6J5K4L1O2N1O00[LSHg0m7XOWHe0i7cNdGQOf0Z2f7^NmGUO`0Z2d7_NPHTO?[2a7`NSHQO?^2^7`NUHPO>V2nNkM_8o0WHmNf0n1gNUN\\8P1XHkNk0j1cNYN[8R1XHjNo0f1_N[N\\8U1UJ:V6FoIOSMlNQ9U1SJGQ69VJ@j5`0_JUOc5k0Q40000001O001O001O1O3M2N1O1O1O1O1O1YEnNn7_1^GjN`8S2`FSN]9P2^FTN`9S2WFQNg9a3K9G:F1O0000O100Ob1_N1O`0_O100KmDmLS;R3PElLP;S38O0O100O2O=PNTDa0n;^ORDb0o;TORD\\O03O[1;cNX;b0lDABOOf0?XOU;`0UE_OZO10`0<@V;?ZE@TO2M:`0EU;>aEBjN:a[;V1eDWN050=\\;W1dDWN0000000=\\;m0dDkN0K0N22N0000;^;n0hDgNJ06OJ100041IO1_;W1mDiNDO;0E30O1N22b;Q1lDmNO2ANO061`;R1^EnNP;R1W10000000000000000000000O100O100O100O1O100000000O10000O1O10PPm0XOhPSO`0@0000000000000000001O00001O00001O0]BZOf==YBDm=6SBIm=9QBHn=9QBGQ12g;;oCB]O7c<:kCA_O8f<8jC_O_OGO`1GZ5h2TITM4\\14FW1SO]5_4VIeLY1kNa5T1TIf3S1WKi5Q1XIn3g0PKR6Q1[IT4;kJZ6P1_IX41hJ`6o0cI]4A`J23k6n0gI_OHY4a6XLjIUONa4X6YLkJe3U5[LQK^3P5bLTKZ3l4fLYKU3g4jL_KQ3a4oLfKi2T8M7I6I7_MfD`1`;RNkDHOd1a0kA10OP>0PB010T>0[B2T=NlB2T=NmB1i=O100000O10O100000f\\;4jbDMSBb0a=;J5M30001N11O00^MiNoE1=5ZOT1X:fN_E00082`0T5o0PKc4LkI050=U5P1PKb4KlI0000000=V5T1oJT4K`J0K0N22N0000;X5U1nJcNJY56dJJ06OJ100041IO1Y5b1oJ]NH11Z5;fJDO;0E30O1N22\\5`1PKd32jJO2ANO061[5`1oJ`N@Q5T1oJk4_1fJa3a6_L_Ia3b6]L_Ic3a6]L_Ic3a6\\LaIc3`6\\L`Id3`6\\L`Id3`6[LbId3_6[LaIe3_6ZLcIe3]6[LcIe3^6YLcIg3]6YLbIg3`6WL`Ij3`6VL_Ij3c6TL]Im3c6SL]Il3e6SLZIn3f6QLZIo3h6PLYIn3h6QLYIo3h6PLYIo3g6PLZIP4g6nKZIR4f6mKYIVOSOk4f7mKXIYOQOj4g7lKZIYOoNk4h7jKZIZ4d6eK^I[4b6cK_I]4a6bKkIS4V6kKlIV4R6iKoIU4T6iKmIW4S6hKnIW4T6gKmIX4a0cKU34[LZ4=gKV3M^L\\4;lKS3GcL]49nKT3CdL_47oKU3AeL`45oKW5P4iJQLW5m3jJTLV5l3iJULW5k3hJYLU5g3kJYLU5h3iJXLX5h3gJYLY5g3gJXLZ5i3dJXL\\5h3cJXL^5i3aJULa5k3_JSLc5n3[JoKi5R4TJlKP6T4oIkKS6V4jIlKV6T4fIPLZ6Q4cIQL]6P4`IQLa6Q4PIYKZO00i0f7P4\\H_K1m0c7`5000HZHaIO000h7\\6XHeIo7[6QHfIn7Y6SHeIO3k7W6YHjIf7U6_HgIa7X6<1OO10000N2nNiGlKW8R4lGlKT8_3hGVL69R8a3jGSL6:Q8a3lGTL59o7b3oGQL7:j7d3QHPL;6e7d3XHSL3:e7c3YHRL65c7i3YHmK39XOI]8P4VIQLQ7o3nHQLS7o3PInKP7R4g100O100O12N3M0000000000000000001O00001O00001O0oEhKj9Y4UFhKj9Y4VFfKj9\\4TFeKk9\\4TFdKQ12d7^4RH_K]O7`8]4nG^K_O8d8Z4lG]K_OZCCh<9YCFj<8WCHk<5UCKn<1SCOoa=01O00000O20O000001NZGFX39_L2`3N]L5d3H^L8g3@\\L`0j80O10000000MTBBl=>30OO2NhBl0Q:>kEBY:>cEC]:?_EBb:?QEMo:j1001O0O110JoDiLS;k0RF\\On:c0SE\\On:c0SE]Om:b0TE]On:b0RE^On:a0SE^On:a0SE_Om:a0SE_O];0dDOo<000004LW^i1", "size": [464, 640]}, "area": 61552.0, "iscrowd": 0, "image_id": 11511, "bbox": [136.0, 0.0, 377.0, 379.0], "category_id": 132, "id": 20000693}, {"segmentation": {"counts": "k5e8k5000000000000000000000000000000000000000000SHWJS7i5lHXJT7h5kHYJU7g5iH[JW7h5eHYJ[7P6[HQJe7]6000001O0000000000000aJ]IQ3c6nL`IP3`6oLdIn2\\6QMhIl2X6SMlIj2U6TMoIi2Q6VMRJh2Q5UKRKR21f2m4ZKPKo17d2i4_KnJk1>c2d4dKkJi1e0`2`4hKjJg1i0_2]4lKhJd1o0]2Y4QLfJa1U1[2T4WLeJ]1[1Y2o3\\LdJ[1`1W2l3`LbJX1f1U2h3dLaJV1k1S2d3hL`JT1P2Q2`3lL_JS1R2P2_3nL]JR1U2P2]3PM]JP1W2o1\\3RM\\Jo0Y2n1[3TM[Jn0Z2n1[3UMZJl0]2n1Y3oNgLQ1[3mNfLR1[3mNeLS1\\3kNfLT1Z3lNfLT1[3kNfLT1[3jNfLV1[3iNfLV1[3iNeLW1[3iNfLV1Z3iNgLW1Y3iNhLV1X3jNhLV1X3jNiLU1W3jNjLV1V3jNkLU1U3kNkLU1U3jNmLU1S3kNmLU1S3kNnLT1Q3mNoLS1Q3lNQMS1o2mNQMS1n2nNSMQ1o2mNQMS1P3kNRMT1n2lNRMT1n2lNSMS1m2lNTMT1l2lNTMT1k2mNUMS1k2mNUMS1k2lNVMT1j2lNVMT1j2lNVMT1i2mNXMR1f2oN[MQ1c2QO]Mo0T2jLgJ18V2m2o0S2nLQKR2m2P1R2mLRKS2l2P1b2PO^MP1b2PO^MP1b2oN`MP1`2PO`MP1b2nN^MR1b2nN^MR1c2lN^MT1b2lN^MT1c2kN]MU1c2kN]MU1c2jN_MU1a2kN_MU1a2kN_MU1a2jN`MV1`2jN`MV1_2kNaMU1_2kNaMU1_2jNbMV1^2jNcMU1]2kNcMU1\\2lNdMT1\\2kNeMU1Z2lNfMT1Z2lNfMT1Y2lNhMT1W2mNiMS1n1VOSNi0m1WOSNi0m1VOTNj0k1WOUNi0k1WOUNi0j1XOVNh0j1WOWNi0i1WOWNi0h1XOYNg0g1XOZNh0f1XOZNh0f1XOZNh0f1XOZNh0f1WO[Ni0e1WO[Ni0e1WO[Ni0e1WO\\Nh0d1WO]Ni0c1WO]Ni0c1WO_Ng0c1VO_Ni0a1VOaNi0_1ROgNm0_1mNbNR1d1hN]NW1e1fN^NX1g1dNYN[1n1]NTNb1T2VNmMi1[2oMfMP2`2jMaMU2f2_MkH2a4]2^7O1O1O1O1O2N1O1O1O1O1O2NnH[NZ1d1gN_NV1`1jNjNm0U1SOTOe0k0[O_O<`0DF88HN31L32LN34LL45KK84FK;6DH>9AXOeN\\Kj1^5@VOn0k0QOUOo0l0POSOQ1n0nNROQ1o0oNQOQ1o0oNQOQ1o0oNQOP1P1POoNQ1P1POPOP1P1POPOP1P1POPOo0Q1QOnNP1R1POnNP1R1POnNP1R1POoNn0R1ROnNn0R1ROPOl0o0UOROj0n0VOSOh0n0XOROh0n0XOQOi0o0WOQOh0P1XOPOh0P1XOPOh0P1XOPOh0o0YOPOg0Q1YOoNg0Q1YOoNg0Q1YOoNh0P1XOPOh0P1XOPOi0o0WOROh0n0XOPOk0o0UOoNm0P1TOoNn0P1ROnNP1R1POmNf0cKmM_5]1nN:`KTNV6b1ZN5o1KPN2S2OmMOT22lMOR22nMOP22PNNo13PN0m11SN0k11WNXOeKZOT6_1XNPOlKYOBM0OZ6l1ZNhN]K]O?0P6l1WNaNb2`1_MYNXKI20V7o1aMQNXK1^7o1n41O1O1O1O1O1N2O1O1N2O1O1N2O1O1N2O1L4F:G9F:C=I700O10000001O000lKlEl3V:nKjE11Q4[:01oKcEm3a:O0000001O00001O001O0000O1OkNaE[N^:LhE<0HW:EXF7F4R:]OfF3^O`0k9ZORGJXOl0e9[OSHe0n7ZORHf0n7ZORHf0o7YOQHg0o7YOQHg0o7YOQHg0m7oNcE9a2g0l7QObE8b2g0m7POaE9b2g0m7[OSHe0n7ZORHf0n7ZORHf0l:000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000001O00000000000000000000000000000000SNSO\\D5d1h0S:G]E9c:7mDIS;g0]DYOc;j100O10000kIXMb0h2^OYM`0h2@YM?g2@[M?e2]OWMfJ5l5d2XOWMmJ1O5j5d2ZO^MjJOl5b2ZOiMe0W2ZOjMg0U2YOkMh0T2XOlMh0T2XOlMi0S2WOmMi0S2VOoMi0Q2WOnMj0R2VOnMj0R2UOoMj0R2UOoMl0P2SOQNl0P2RORNm0o1TOPNl0P2^MZMPM2e0i0j4l1`MZMgLN6;a0h0l4e1eMbMiL6`0k0k4^1lM`NiL8[5W1lM6T2JjM9U2GlM8T2HkM9U2PMfJb2U3>V2nLeJe2T3=[2CeM=\\2BcM=^2DbM>Z2DfM=Y2CgM>YOoL;d2>dMB\\2>dMB\\2>dMB[2?eMA[2`0dMA[2>fMCX2=iMD[M^NS3n1BDZM^NU3m1BDYM`NU3l1BCXMbNW3j1BEjLmNd3]1C]1>bNB^1>aNC_1=aNC^1?`NBa1=_NC\\1gLgKi3k2Aa0_1^ObNa0_1_OaNa0`1]OaNb0`1^O`Nb0`1]OaNb0a1\\O`Nd0a1[O_Ne0c1XO^Ng0d1XO\\Nh0e1\\MPKo0\\3e1e1YMXKi0U3n1d1VMaKb0m2X2c1SMeK?k2^2a1PMiK67L3O0OdYX2", "size": [464, 640]}, "area": 1326.0, "iscrowd": 0, "image_id": 11511, "bbox": [439.0, 195.0, 41.0, 47.0], "category_id": 150, "id": 20000695}, {"segmentation": {"counts": "mkX43\\>2O0TOl002NN200O1OiDVOj8k0SGZOj8f0UG_Og8a0XGAg8?XGBh8>WGBj8=VGDj8:WGGi89VGHj88UGLh84XGLh85VGKk85TGLl84TGKm86QGKo85PGKQ96nFHT98lFFV9;hFB\\9?aF_Oc9a0\\F^Of9c0WF_Oi9a0SFCm9>PFDP:=mEDT:>]ElNZO00i0Y;=iDRO1m0V;m1000HgDTMO000[;i2eDXMb;h2^DYMa;f2`DXMO3^;d2fD]MY;b2lDZMT;e2<1OO10000N2nNVD_Oi;`0ZD^Of;MVDH69d;OXDE6:c;OZDF59a;0]DC7:\\;2_DB;6W;2fDE3:W;1gDD65U;7gD_O39XOIo;>dECc:=\\ECe:=^E@b:`0g100O100O5NjZj3", "size": [464, 640]}, "area": 3674.0, "iscrowd": 0, "image_id": 11511, "bbox": [302.0, 0.0, 68.0, 119.0], "category_id": 175, "id": 20000696}, {"segmentation": {"counts": "^b07d=g0YOg0XOh0D<00O1O1O1O100O1O1O1O100O1O1O100O001hElLQ9U3lFmLT9T3iFmLY9T3bFnL_9Z3WFgLj9a3lE`LU:m32N1O1O1O2N3M3MhN]L[GO[Ob3Y9cLXG1]OZ3Y9iLUG4@P3Y2bLc4>_I6DX15ZOT2mN`4`0^IP24`Nm1TO]4`0^Ij1>_Nf1[OZ4R3UJaM`1AW4l2_J`MY1HU4d2hJbMR1MT4^2oJcMl03S4W2TKeMh08Q4R2ZKdMc0?P4l1`KcM?e0n3g1fKbM;j0n3b1iKbM9P1k3]1oKaM5V1i3[1RL]M4\\1h3X1TLZM3a1g3W1ULWM3f1e3U1WLSM4l1c3S1WLPM5Q2a3Q1YLmL6S2`3R1YLjL6U2b3R1WLhL7W2b3R1VLeL9Y2c3S1RLcL;[2e3Q1hMPO[2o0cMRO_2]1oLcNS3\\1lLeNT3Z1kLgNV3Y1iLhNX3W1gLiNZ3W1dLkN\\3U1cLkN_3S1aLnNa3o0_LQOd3l0[LVOh3f0XLZOk3eMlIa2Y2Km3^MQJc2R2O_4M`K5b4ZN[I4S2c1g4jMeI=d1i1n4[MlIf0U1Q2]6iMcIW2c6cM]I^2h6\\MXId2l6XMSIj2P7RMPIn2Y91O0O2O0VJaMC_2n2U2eMbKo0f1^Nb0o2V2CRM_Mh0n2V2HlL[Mn0n2U2NeLUMU1n2V24]LoL]1m2V2=nKlLl1g2V2Z1jMfNV2Z1iMgNW2Z1hMfNX2\\1fMdN[2[1eMfNZ2[1dMfN]2Y1cMgN]2Z1bMfN_2Y1aMgNa2W1^MjNe2S1[MmNf2Q1[MoNf2P1YMROg2m0YMSOh2l0XMTOi2k0WMUOj2i0VMXOl2`NmK^OW1R2d3cM\\K9P1T2V4oLnJk0l0V2Y4jLoJm0h0[2k5bMVJ^2S6YMmIg2]6nLcIS3f6cL[I]3l8000O101O000O10000O1aM\\LRJd3m5_LQJb3m5_LSJa3m5_LRJb3m5_LSJa3m5_LSJa3l5`LTJ`3l5`LSJa3l5`LTJa3k5_LUJc3g5_LXJc3f5^LZJc3f5\\LZJe3j5VLVJk3n5PLQJR4V82N1eIkKY2V4dMnKY2T4eMPLX2Q4fMSLW2n3gMVLU2m3gMXLnLHY4Q4hNZLeLNa4i3hNZMV1g2iN_MP1c2oNaMm0`2ROeMi0]2TOiMg0X2XOmMb0U2^OoM=R2CTN6m1IYN0i10\\N_MkL`1k4o0`NSMPMk1a4R1XOlNi0U1TOkNn0U1QOkNP1U1oNkNR1U1mNkNU1T1jNkNX1U1gNkNZ1U1nLQMXOj1k3U1gL[MYO_1R4V1`LeMWOV1[4U1WLoMWOn0c4S1TL[NmNc0P5S1PLo0R4QOdKX1]4iNPKh1Q5k30O10000O1000000O10O1000O1000000O1000O01000000O100001O0O2O001O001O001O0O3N1N2N2N3M2N2N2N3M2N2N2N3M2N2N2N3M2N2N2N2M3N1O1N3N1O1N3N1O1N3N1G9G9G:C2nNaK>_4c03kNdK<[4h0c1RO`Nm0d1lN`NT1^7001N1000001O1OkNoBl0P=POVCo0iRLlNYOd1h0TNR2O:R1]1QOaM0QNl1f0oMT208T1\\1lNgM2mMo1f0lMS229S1[1lNiM2kMj1l0RNn127S1\\1kNkM2jM_1W1]Nb138U1X1iNoM1nM2Ke0U1VOd128W1W1hNPN1eNh08UOe138X1T1fNTN1cNj0c3UOcNZ1S1fNTN0cNm0b3SOdNZ1S1fNUNO`41XLZ1S1eNVN0_41XLY1T1fNa50\\IY1T1gNU9W1k42N1O01N11O1OO1001O1O0_]OeN]b0[1b]OgN]b0\\121O3M2NO1010ON22NO1002d]O]NWb0f101O00O1O100Nh]O\\NXb0c1i]O]NWb0d13N12N00O100002N2NO11ON22N1O2NO2O0001O00O12NO1O1O100OoAaNQLIY=e1gFlNX9S1iFmNW9S1iFmNW9T1hFlNX9U1gFkNY9T1hFlNX9S1iFmNW9S1iFmNW9R1jFoNU9P1lFPOT9P1lFPOT9o0mFQOS9o0mFQOS9n0nFROS9m0mFSOS9l0nFUOQ9j0PGVOP9j0PGVOP9i0QGWOo8i0QGWOo8h0RGXOn8d0VG\\Oj8d0VG]Oi8b0XG^Oh8b0XG^Oh8b0XG^Oh8a0YG_Og8a0YG_Og8`0ZG@f8`0ZG@f8`0ZGAe8?[GAf8=[GCe8=[GCe8=[GCe8=[GCe8<\\GDd8<\\GEc8;]GEc8;]GEc8;]GEc8;]GFb89_GGa89_GGa89_GGa89_GGa89_GGa89_GGb88^GHb88^GHb88^GIa87_GIa87_GIa87_GIa87_GIa87_GCVKB[=k0_GCVKB[=k0_GCYK^OY=o0^GCg8=YGCg8=YGCg8=YGCg8=YGCg8=YGCh8=WGCi8=WGCi8=WGBj8>VGBj8>VGBj8>VGBj8?UGAk8?UGAk8?UGAk8?UGAk8`0TG@l8`0TGAk8?UGAk8`0TG@l8`0TG@l8`0TG@l8`0TG@l8a0SG_On8?SGBl8>TGBl8>TGBl8=UGCk8:XGFh8:XGFh89YGGg89YGGg8;WGFh800000000000000000000000000000m\\O]OH0ob0c0Y]OEab0m00001O00000000000000001O0000000000JY]OoNkb0n05J6O10000O10000000000000000002N3M3M3M00001O00001O000000000000000000001O0000000000001O000000000000001O00000000001O0000000000001O0000000000001O00000000001O000000000000001O0000O1N200O1N20cJlNnGT1R8nNlGR1U8nNjGR1S8lNgB3T5Q1V8UOgGk0Y8WOeGh0\\8ZObGf0^8\\O`Gd0`8_OeD_Oc0R1h:@_DBj0n0g:^O\\D1e0a0o:@XD1i0?o:AVD3i0RCYNk2\\1P:NmBnN8Gl2`1l9KQCdNOO`01d2c1j9DSChNn3d1o8CUG>j8BVG>k8AUG?k8@VG`0j8@VG`0j8@VG`0j8@VG`0j8@VG`0j8@VGa0i8_OWGa0i8_OWGa0i8_OWGa0i8_OWGb0h8nNUCHS4Z1h8kNZCIn3[1i8kN`CDg3`1j8kNbCBe3d1h8iNmGW1S8hNnGX1S8hNlGX1T8hNlGX1T8iNkGW1U8iNkGW1U8iNkGW1lMZNb7?bJW1kM[Nc7?aJV1lK`NS1Mo1Ng2?[NV1kKjNj0DY2Mg2?[NV1jKROb0_Oa2Jh2?[NV1jKZO9XOk2Hg2?\\NW1hKD0POT3Fh2`0[NV1hKMGjN]3Dh2?\\NZ1cKa0X3fMi2VGBj8>UGCk8=UGCk8>SGCm8=RGDn80003M1O00001O0O100O1O2OYF", "size": [640, 480]}, "area": 224221.0, "iscrowd": 0, "image_id": 11615, "bbox": [25.0, 0.0, 455.0, 640.0], "category_id": 132, "id": 20000699}, {"segmentation": {"counts": "`?`4[?bKf@`4X?_Kh@10`4X?5000000000ZKj@b4X?2O1O100M31OO12N1O000000002N0000O1N20000M300O100004L00O1O12N002N000000O1O1N22N1O00O11O1OO1001O1O0^Kf@^4Z?aKh@^4[?21O3M2NO1001ON22NO1002dK]@W4f?01O00O1OgNZ@ZNf?a1_@_N_?hN\\@l1a0]NHl0Z?lN]@e1m0\\N_OQ1X?a0oA]OP>?WB_Ok=WDCh;?UDCi;?VDBj;?SDCm;=RDDo;9QDIQ<7cCiNgMR1d>8bCjNfMP1e>;aCO_<2`CN_<5^CLb<6\\CJe<7YCIj<3UCOj<1WCOi<0XC0i1RPA5K204M1N20ON300O2N1O2N003M000O11O0000O100JVOS]Om0ib07O100O1001O2N4L00O10000O1O1O1O100MlNY]OU1fb03004L000000001O0000000000O1O1M300N2O1O1O1O1O1O1O1N2N2N2N2N2M3N2O1O1N2M3M3N2N2M3N2O1O18H002NO12NO100O1MeMa^O[2^a04N200N^Mf^Ob2Za02N2N\\Mj^ON11O]2Xa0bMn^O^2Za00I7000000002N00N2O1O1O1JYMQ_Oi2m`0YMS_Og2n`0XMQ_Oi2o`04O1000000DPMd_O1Ln2^`0UMe_OMKo2^`0XMe_Ok2n?mLZ@8Gl2o?mLP@OO`01d2k?mLT@n3k?40000O1000000000000000000@mKSAS4j>RLTAn3k>YLo@g3P?\\Lm@e3R?e0O11O001O0000001O000000O11O00MYKn@f4S?ZKl@f4S?4K5I7O10000001OO11O00N200GgJkAY5U>iJgAY5Y>gJfAZ5Z>fJeA[5[>50000000000000000O100O1O100", "size": [640, 480]}, "area": 33426.0, "iscrowd": 0, "image_id": 11615, "bbox": [0.0, 458.0, 480.0, 182.0], "category_id": 169, "id": 20000700}, {"segmentation": {"counts": "V]e5h0Xc01O00001O0010O0001O1O1O001O100O000000O1O1O1O101O000001O00000001O0000000001O0001O00006J00000001O00010O1O1O1O1O0000000001O2L4L5M2OSn]2", "size": [640, 480]}, "area": 1639.0, "iscrowd": 0, "image_id": 11615, "bbox": [290.0, 166.0, 65.0, 37.0], "category_id": 183, "id": 20000701}, {"segmentation": {"counts": "0X8h;001O001O0000001OXOh00000001O000000000000001O00000000000000O1O100O100O1000000001O0000001O0000001O1O1O1O001O00001O0000N2M3N2M3N2M3N2M3N2N2O10000000000O1M3L4M3L4M3L4M3L4M3M3L4M3L4O10000000000000000000000000000000000000000000000O1M3001O1O0000O100O100O100iN^AoLc>P3lAbLT>\\3Y1O1N2O1N2O1O1N2O1N2O1N2N2N2M3N2N2M3N2M3O100O100O10000O100O100O10000O100O10000O100O100O10000O1000000001O000000001O00000000001O000000001O0000001O2N1O2N1O1O2N1O2N1O1O2N1O1O2N1O2N1O1O8HN2M300O1O1O1O1O1O1O1O1O100O1O1O100O1000000O1000000O1000000O100000000O100000000000000000000000000000000000000000000001O1O1O1O1O1O1O1O1O1O1O1O001O1O1O1O1O1O1O2N1O1O1O1O1O1O1O2N2N2N2N2N2N3M2N3M5K4L4L4L1O1O1O1O1O1O1O001O1O1O1O1O1O001O1O0000000000001O00001O0000001O00001O00001O1O1O001O1O1O1O001O1O1O001O1O1O1O1O1O2N1O1O2N1O1O2N1O1O2N1O1O2N1O1O2N1O1O2N1O1O2N1O1O00N2O1O1O1O1N200000000004L001O0000001O001O2N0000O1O10000N2O1O1O1O1O1O1O1O1O1O1O1O1O1O1O100O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O100O1O1O1O1O1O1O1O1KnA[JS>c5600001O00O1O100O1O1O1O1O1", "size": [640, 480]}, "area": 80310.0, "iscrowd": 0, "image_id": 11699, "bbox": [0.0, 0.0, 480.0, 267.0], "category_id": 102, "id": 20000702}, {"segmentation": {"counts": "X8n6R=O2N1100OO1lIoBS5W=lJlBl4[=QKjBf4_a0fL6K5J7I6J6K6I6J6L5O001O00001O00001O0O100000O100O100O100O1O100O100O100O100O00100O100O100O100N2K5K5K5K5K5KJ6G9J7H7_Oof:LjYE10O10O10000O1000000O10000O1000O010O1O1O00100O010000O1000000O10000O100000O1O1O1O10oi\\13mUcN2N3L3N3M2M4L3M3M4L4L4K6K4L4O1Y1hN1N2N2O1N2M2MUXR5", "size": [640, 480]}, "area": 3893.0, "iscrowd": 0, "image_id": 11699, "bbox": [0.0, 184.0, 220.0, 302.0], "category_id": 105, "id": 20000703}, {"segmentation": {"counts": "Q_g64lc02U\\OKgc0;L6J3M4K8I4L3M5K4L2b]O^NZb0b1f]OcNUb0]1k]OgNPb0Z1P^OkNja0V1V^OnNea0g1[^OkM^a0V2b^OoMWa0S2i^ORNV?I\\Bj2`=\\MYBi2c=]MUBf2nNhLh>g0TBc2SOjLe>m4[AYK_>g4aA\\K\\>d4dA_KY>a4gA`KX>U5O000VBYJ[=g5dBaJW=]5iBhJ\\=o4_BeJK?d=j4aBgJJd0c=m4]BXK_=g4aB[K^=e4aB[K`=d4aB[K`=d4`B\\Kb=b4]B_Ke=]52N1O2N1O2N1O2N3M1O1O3M1O1O001O1O1O002N2NL47I2N1O1O1O1OO11O001O000000003M=C1O0000000000000000001O00000`Kc@]4]?bKd@^4^?12N000000001O00001OO11O00002N001O1O000000003MO11O1O2N3M1O2N2N001O001O1O1O1O002NO10000", "size": [640, 480]}, "area": 19204.0, "iscrowd": 0, "image_id": 11699, "bbox": [344.0, 414.0, 136.0, 226.0], "category_id": 117, "id": 20000704}, {"segmentation": {"counts": "Ymm52ic07I8H8H7G:G8H9G8G:F9D=Cd3lA\\LV>e3gA[LZ>h3bAXL^>l3^ATLa>f400000000000000O100000000000000O1004L2VKj@f4\\?L6J3M4L7I4L3M5K4L2bL^_OZ3b`0fLc_OU3]`0kLg_OQ3Y`0oLl_Ol2T`0TMP@h2d`0XMn^Ob2Ra0^MS_O]2m`0cMX_OX2\\a0L4L1QNR^Oj1oa0UNU^Og1ka0YN[^Oa1ea0_N^^O^1ba0bNa^O[1_a0eNb^OZ1Sb0O000TO[]O=eb0Bc]O7]b0Ih]O2Yb0I[]OK?8Vb0M[]OJd05[b0Kj]O0Vb00n0O01O00Oo\\k1", "size": [640, 480]}, "area": 7641.0, "iscrowd": 0, "image_id": 11699, "bbox": [303.0, 470.0, 81.0, 170.0], "category_id": 132, "id": 20000705}, {"segmentation": {"counts": "gTl31kc04K5L5K4L4K5L5K4L4K5L5L3O10001O01O00010O00000001IKP^OfNPb0j0e^OQO_a0`0T1I6K4I`al4", "size": [640, 480]}, "area": 1168.0, "iscrowd": 0, "image_id": 11699, "bbox": [198.0, 347.0, 31.0, 67.0], "category_id": 144, "id": 20000706}, {"segmentation": {"counts": "^a0b2ic0eM000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000cILnH4S76bHJ^7a0WH_Oi7l0lGTOT8W1aGiN`8a1UG_Nk8l1jFTNV9W2_FiMa9c2SF]MQ:j2dEVMa:P3TEPMQ;V3dDjLa;\\3SDeLT<_3aCaLfj3TAVLX?S4=C=C=C`0@`0@a0_O`0@a0_O;E1O000000000000000000000000000000001O0000000000000000000000000000WhR3", "size": [640, 480]}, "area": 4837.0, "iscrowd": 0, "image_id": 11699, "bbox": [0.0, 426.0, 321.0, 214.0], "category_id": 167, "id": 20000707}, {"segmentation": {"counts": "QWT43ic04M3L4M4K4L[Ok\\Og0Rc06K4M37I3M1I7O22MM4K4Kaal4", "size": [640, 480]}, "area": 356.0, "iscrowd": 0, "image_id": 11699, "bbox": [211.0, 321.0, 18.0, 37.0], "category_id": 172, "id": 20000708}, {"segmentation": {"counts": "f_`64jc04L4MO010O2N2N101N1O2O000101N2N1O2N2N1O2O1N2N3M3M3M3M3M4M2Mk0UO1O1O1O1O1O100O1O1O1O1O3M;E3N2M2O1N2O1N3N2M3N1N3N1N3N1N3N3M1N2O3mLPLoER4n9QLQFP4m9RLRFn3m9ULPFm3n9ULQFl3m9WLPFk3m9XLRFh3n9YLQFi3m9YLPFj3n9WLPFf3T:\\LiEl3P:ULoEm3S:PLkER4T:PLiER4W:nKgET4X:mKfEU4Y:mKeER4\\:oKbES4^:nK_ES4a:nK]ET4c:lK[EU4g:kKVEV4j:kKUEU4k:mKRET4m:nKQEV4k:lKREc4a:_K\\Ec4c:^K[Ec4c:aKYEa4f:aKXE`4g:bKWE_4h:dKTE^4k:dKSE]4l:hKoDY4P;kKkDW4T;nKgDS4X;RLcDP4[;[2O1O1gD\\GU;e8jD\\GU;g803M100O1O1O2N1O1O2N002N1O1O3M1O2N2N1O100O1O4L002N2N3M4L2JlE]FW:_98N0010O01N2N2O1N1O3M001O1`J", "size": [640, 480]}, "area": 25339.0, "iscrowd": 0, "image_id": 11699, "bbox": [333.0, 176.0, 147.0, 349.0], "category_id": 181, "id": 20000709}, {"segmentation": {"counts": "gS1R4l?2K5J6K5lI`KbLf4]3]K[Li4c3\\KTLj4a2DVJb0j5_OPJf0P6ZOjIl0V6TOdIR1]6nN\\IX1d6hNWI]1i6cNQIc1o6^NjHh1V7XNfHl1Z7TNfHl1Z7UNeHk1[7UNeHk1\\7UNcHk1]7UNcHk1]7UNcHk1]7VNbHj1^7VNbHj1^7VNbHj1^7WN`Hj1`7VN`Hj1_7WNaHi1^7WNcHi1]7WNcHh1]7XNdHh1\\7XNdHh1[7XNfHh1Z7WNgHi1Y7WNgHi1Y7VNhHj1X7VNhHj1Y7TNhHl1X7TNhHl1X7SNiHm1W7RNjHn1W7QNiHo1W7PNjHP2V7PNjHP2V7oMjHR2W7mMiHS2X7kMiHU2X7jMhHV2Y7hMhHX2X7gMiHY2X7fMhHZ2X7eMiH[2W7eMiH[2X7_MmHa2S7ZMRIf2n6VMVIj2h6SM]Im2`6QMeIo2Y6nLlIR3Q6lLiI_3U6^LbIP4[6nK_I]4_6`KZIl4c6SKkHc5S7f3N2O10000000000O1M3L4M3LYIXI>e6E[I;a6I_I7^6KcI5Y6OgI1V62jINS65mIKo58QJIl5:TJFh5>XJBg5>ZJBf5>ZJBf5>ZJBf5=[JCe5=[JCe5=[JCe5=[JCe5<\\JDd5<\\JDd5<\\JDd5;]JEc5;\\JFd5:\\JFd59\\JHd58[JIe57ZJJf56YJKg54ZJLf54YJMg53YJMg52ZJNf52ZJNf52ZJNf51[JOd52\\JNa55_JKa54`JLa53_JMb52^JNb52^JNb51_JO`53_JMa53^JNa53^JNb52]JOb52]JOc51]JO\\4mHgL[>X3TBZLl=d3Y1O1N2O0O2O1OmHnKZNP4h1PLXNo3i1RLVNl3l1ULSNj3n1WLQNg3Q2XLPNf3R2ZLnMd3T2[LmMb3W2]LiMa3Y2`LfM^3\\2cLcMZ3`2gL_MW3c2jL\\MS3g2nLXMQ3i2PMVMP3j2QMUMn2l2SMSMm2n2SMQMl2P3UMoLk2R3VMlLj2U3VMjLi2X3WMgLi2Z3WMeLh2\\3YMcLg2^3YMaLf2a3YM_Lg2b3WM_Li2a3UMaLj2a3TM`Ll2a3QMaLn2Y:0000O100O100O1000ZIUMWLj2j3VMVLj2j3WMULi2m3VMRLj2o3UMQLk2b:1O000000001O00000000001O000000001O000jBRMZ9n2eFUMY9m2dFUMX2MQ1o2dLXMU2MW1l2bLYMQ20]1i2_LZMn12b1e2]L\\Ml13g1c2ZL]Mi14m1`2VL`Mh14R2]2SLbMe17W2Y2PLdMc17]2V2mKgM`17c2S2jKkM\\16j2Q2fKmMZ17o2m1cKQNX16U3k1_KTNV14[3i1aKRNn09a3f1kLhL^Og1f3c1nLdLWOl1k3a1QMbLmNQ2R4i1iLTLPOV2W4c1PMULcN]2\\4\\1WMVLVNb2c4U1]MXLkMf2h4R1aMVLaMl2n4m0KiN5V1OhN0W12]NWIRNg6`34mMjI^NR6d37aMo0^2SOXMV1g2mNoL[1P3gNdLd1[3`710O1O1O100O1000000O1000000O1000000O100000000O100000000000000000dIlLlKT3T4WMaKi2`4aMUK_2k4lMjJT2V5XN^Jh1b5cNSJ]1n5mNgIS1Y6XO\\Ih0d6CQI=S7JbH6c70RH0S86bGJc8=QGCV9a0_F_Oh9e0mE\\OZ:g0[EZOl:i0iDXO`;i0UDXOVo;EPD;n;JkCHN?V<`02OO00110N3NO20O00000001O1O003JgCVOYU5h2oNjLlK?T5g2oNkLmK>S5h2PO^Mm0d2SO\\Ml0e2SOgLnKa0n4h2TOgLnKa0n4h2UO]MUL4^3_2=^MRL;[3W2d0]MoKe0V3n1k0^MlKl0T3e1Q1ZOkNf0U1^OfNc0Z1AaN`0`1C[N>e1EWN_1S2jL\\Mj1`0\\1S2lL[Mj1`0[1T2mLYMk1d0V1R2PMXMn1d0R1U2PMVMo1d0Q1W2PMSMQ2g0m0W2RMQMR2g0l0Y2RMnLT2j0h0Y2TMlLU2k0f0[2SMiLZ2j0c0^2h0cMVO^2j0bMUO_2n0\\MSOe2o0WMROj2P1SMPOn2R1oLnNR3T1mLjNT3X1hLiNY3Z1bLgN_3[1`LcN`3c51O001O001O00O1N2N2N2O1N2N2N2N2M3N2M3N2000000O1000000O10000O10000001O2N1O2N1O2N1O1O2N1O2N1O2N00O1000000O1000000O10000O1000000O1000000O10000O1000nKVMeMj2R2_MnMa2j1gMVN\\2c1hM]N^2\\1cMdNb2U1_MlNg2m0ZMSOk2g0WMXOk2e0VM[Ol2b0UM^Ol2?WM@k2=VMCl2:UMFm27UMHl26TMKn21UMNm2OTM1m2MTM3n2JSM6o2GRM9P3CRM=P3@QM`0R3\\OPMc0R3ZOoLf0S3WOnLi0U3ROnLm0T3POlLQ1V3lNmLR1V3jNiLX1Y3dNhL]1[3_NgL`1[3]NdLe1^3XNcLh1`3TNaLl1a3PNaLP2b3lM_LT2c3iM^LW2d3fM]LZ2f3bM[L^2g3^M[Lb2h3TM_Ll2c3bLnL]3_6000O1O100N21O0000000000001O0000O11O0000O1N2O1O1001O00000000O11O0000", "size": [425, 640]}, "area": 131385.0, "iscrowd": 0, "image_id": 11760, "bbox": [0.0, 0.0, 640.0, 324.0], "category_id": 169, "id": 20000713}, {"segmentation": {"counts": "cf>2T=6K5J6K5J7I6K5J6K5J6J7J6I8I6I8J5K6I6K6J5K6J5K6J6I6K6J5K6J6J6J6I7J6J6J6K5J6K5K5J7YJjHo4h700O10000O101O0O10000O101O0O10000OL5L4K4gMhJ_L]5_3RKnKS5P4]K^Kh4`4gKmJ^4R5n1M2O2N1N3N1O2N1N3N1O1N3N1O22M3N2M4M4K6K4K6K4K6J5]JWJ]3n5PL_JP4f5^KgJ\\4e5RKgJe4S7G9010O001O1O1O1O1O1O001O1O1O100O1O001B>\\Od0\\Oa0_Oa0L4M3M3M3M3M3M3M3M6L3O2N1N3N1O2N1O2N1N3N1O2N1O2N1N5G?A?Ad]FCc9<^FDb9:_FG`99aFG_97cFI]95dFL\\93eFM[91gFOY90gF1Y9MiF3V9LlF4U9JlF6T9HnF8R9GoF9S9EmF;U9CkF=X9@hF`0[9]OeFc0V<0O10000jL\\O\\Gd0c8_O[Ga0d8A[G?d8DZGl:5\\FWOgN[1m:^OZFR1g9mNWFU1i9jNUFY1k9gNSF[1m9eNQF]1o9cNoE_1Q:aNmEa1S:_NjEd1V:\\NhEf1X:ZNfEh1[:WNcEk1\\:VNbEl1Y:YNeEi1a:QN]EQ2c:oM[ES2e:mMYEU2g:kMWEW2i:iMUEY2k:gMSE[2m:eMQE]2o:T1O100000000000000O10000N2M3N2N2O1001O00000VK\\Ed4d:YK_Eg4i:N001O000000000000000000O10000O1000000000000O100O1003MO1O1O12N]Oc0M31O000^O5ZKgEMMl4\\:9N20O17J`0@0O100NoLaF1a9LcFXMLb2d93`FYMI03d2f92]FZMOd2e90]F\\MOc2d91]F\\MOc2c9cMZFU2;8[9dM\\FP2:<[9bM`Fn16?Z9^MhFP2Mc0R:ZOnEf0V:WOhEj0\\:ROcEo0`:nN`ER1c:lN[EU1c:mN]ES1d:kN]EU1d:kN\\ET1e:kN[Ee0EYNP;R1[Ea0EPN1=o:Q1]Ea0H]Nk:R1^E`0H]Nl:Q1\\E`0L]Nk:P1YE`0O`Nk:m0mDiN1W1j0TO[:i0jDlN1R1P1XOU:j0jDlN0Q1T1XOS:i0gDnNN04P1U1YOQ:j0hDnNMO4o0X1ZOP:k0eDoN2l0Y1[OP:P1gDDY1]OQ:P2QERN3Ml:P2mD^N2AR;P2iDeN0]OX;l1gDhN2\\OX;j1fDlN0[O[;g1eDoNMnNM=a;C_DP26SOL]Oa;`1cDSOJ_Ob;T1bD^N2d1\\;OdDZN0g1\\;0kD1U;1iDOV;1mDMS;4nDJQ;9oDEP;>oDAQ;?lDDS;b0Dj7NdG>b0Dj7NdG=c0Ei7NcG>d0Dh7OdG=d0Dh7OcG>e0Ch7OcG>e0Ch7NcG`0e0Bh7NcG`0e0Ai7OaGa0f0@i7O`Gb0g0_Oi7O`Ga0h0_Oi70^Gb0i0^Oi70]Gc0j0]Oi7O^Gd0i0]Oi7O^Gd0i0]Oi7O^Gd0i0]Oi7O]Ge0=lMD`1a80^Gd0:QNE[1c80^Gd06WNGU1e80]Gd06[NFQ1g8O^Ge05]NDP1h8N_Ge05^NCo0i8N^Gg05[NEP1h8N_Gf04[NFQ1g8N_Gf04ZNGR1f8N^Gg04YNIR1e8N^Gg05XNHR1f8N]Gi05VNIT1d8M^Gi05UNJU1c8M^Gi05TNKV1a8N_Gh05SNLW1`8N_Gh05RNLY1`8M^Gi06PNL[1`8LXG`N3Y29oML]1`8JYGP1;hML_1`8IXGQ1=eMKb1`8HXGQ1a0`MGh1`8GXGQ1k0YOm7FWGR1k0YOn7X2QHiMo7W2PHjMP8U2PHlMP8T2oGmMQ8S2oGmMQ8S2nGnMR8R2nGnMS8Q2lGQNT8n1kGSNV8l1jGTNV8l1iGUNX8j1hGVNY8i1fGXN[8g1dGZN]8e1cG[N^8d1aG]N`8b1`G^Na8a1_G_Nb8_1^GbNc8]1]GcNe8[1[GeNf8Z1YGgNh8X1XGhNi8W1WGiNj8aNfFj1`0Ek8`NeFk1`0Fk8^NeFl1`0Fm8^NcFj1`0Hn8P1RGPOo8o0QGQOT9j0lFVOX9f0hFZO]9a0bF@b9;_FEb9:^FGa99_FG`9:`FF_9;aFE^9KS8iM^G[2a0LQ8iM]GZ2d0Mb4[MQNZ3_M\\O^4\\MRNV3bM^OZ4`M`K1b1P3fN_OT4ROPKhNS1e2]OnL@L3i2k4NlK?CQMBJ3i2i44jK:ETMH`2f4=aK2MTMKb2OoL01\\4Q7fK_IOl2V4f3iKUMo3]7I6K3M6H;gMbCc0S=mNgCJT=0^1ImZe2", "size": [500, 333]}, "area": 48387.0, "iscrowd": 0, "image_id": 11813, "bbox": [0.0, 50.0, 158.0, 450.0], "category_id": 123, "id": 20000716}, {"segmentation": {"counts": "eSd34_?4d@LR?4l@I03U?3k@OT?2l@OS?1m@OT?8O101OO101N1O101N10O110O0nBEk:;QEEPN1n<[OZAf0f>ZOXA00f0h>221XAXOb>h0]A[Oa>f0^A[Oa>n0N2NkNeAR1a>N0UO]Ad0c>XO`Aj0^>UOcAl0b>001OO1O11O003M0O2HQOfAT1R>jNoA^1P>bNPB^1P>3000O10000O100001O001O001O1O0000000000]NVB\\1T>L1001O00O1O11O1O00N20gF", "size": [500, 333]}, "area": 2986.0, "iscrowd": 0, "image_id": 11813, "bbox": [237.0, 286.0, 96.0, 204.0], "category_id": 132, "id": 20000717}, {"segmentation": {"counts": "YZo16]?5L1N2O0O2O000000000cLBdG?Z8CeG;[8IQE1b16Z9[1`DhNS1M\\:Y2[EfMc:a2XE`Mg:k2mDWMR;f34L3M100O000000O1O100O101OO1K56J00000000000000O2O0000001O001O0O101O0N2M4M2N2O10O20O00O1TD^Lf;b3WDaLi;g3N001M2O1O1000000000000O010000O101O1O0000001bMZDaN0X2g;WO^Df0b;[O_Db0b;^OaD?_;AcD`0Z;^N\\D`0>_OHi0`;UO]Da0;@Kh0];WO_D`09AKg0\\;ZObD5>IEj0Y;XOfD3Z=BgBN3M2Ih@N[?0eR_1", "size": [500, 333]}, "area": 10454.0, "iscrowd": 0, "image_id": 11813, "bbox": [129.0, 216.0, 107.0, 139.0], "category_id": 143, "id": 20000718}, {"segmentation": {"counts": "_ab32a?3K5N1N01NMHm@:R?4O110_ADi=;XBGe=9ZBLb=4YB4d=LVB=g=l0L4L3M3MN12O1N2O000000ZNlBn0S=oNoBT1n0000000000000000000eGUIm7k6oGZIP8g6mG\\IR8d6lG_IS8R7O1O000000001O00", "size": [500, 333]}, "area": 48456.0, "iscrowd": 0, "image_id": 11813, "bbox": [0.0, 0.0, 333.0, 241.0], "category_id": 173, "id": 20000720}, {"segmentation": {"counts": "[>8e<2hENP:`0jE_On9i0RFXOe9Q1[FoN\\9Z1dFfN[9[1dFfN\\9Z1dFfN\\9Z1dFfN\\9Z1dFfN\\9Y1eFfN\\9Z1dFfN\\9Z1dFfN\\9Z1dFfN\\9Z1cFgN]9Y1cFgN]9X1dFhN[9Y1eFgN[9Y1eFgN[9Y1eFfN\\9Z1dFfN\\9Z1dFfN\\9Z1cFgN]9X1dFhN\\9X1dFhN\\9X1dFhN\\9X1dFhN\\9X1dFhN\\9X1dFgN]9Y1cFgN]9X1cFiN\\9X1dFhN\\9X1dFhN\\9X1dFhN\\9X1dFhN\\9X1dFhN\\9X1dFhN\\9W1eFiN[9W1dFkN[9U1eFkN[9U1dFlN\\9T1cFmN]9S1aFoN_9Q1`FPO_9P1`FRO`9n0^FTOb9l0]FUOc9k0[FWOe9i0ZFWOg9i0WFYOi9g0UF[Ok9d0UF]Ok9c0SF_Om9a0RF@n9`0PFBP:>nEDR:gNBY1>gNBY1=hNCX1=hNCY1Q2CnM=R2CnM=R2CmM>S2BmM>S2ClM=T2ClM=T2CkM>U2CjM=V2CjM=W2BiM>W2CfM?Z2AfM?Z2AfM?Z2BeM>[2BfM=[2BeM>[2Y5000000001O00000000001O00000000001O00000000001O1O001O1O1O001O1O001O1O1O001O1O1O001O1O001O1O1O001O1O1O001O1O001O1O1O001O1O1O001O1O2N1QJbLo1_3mMfLQ2\\3kMhLS2Y3iMmLT2T3fMSMX2o2aMXM]2i2]M^Ma2c2YMdMe2^2TMgMl2Z2nLlMQ3U2iLPNW3R2bLTN]3m1]LWNd3j1VL[Nj3c5000000000000000001OO10000000000000000001O2NO1O100000000N2O11O00001OO100hJoJW2P5eMUKZ2k4cMYK\\2g4aM]KdM\\Oe4W5fM_KdM\\Od4U5fM`KgM]Ob4R5fMaKiMZOe4T5`MbKVNYO\\4k4_M[K`N1Q4GWKi4T2XLlM^Oh4Z4\\MXLlM@f4X4]MYLmM@e4W4^MYLmMAe4U4^MZLmMBd4T4^M[LnMAd4T4^MZLoMBc4T4]M[LPNBc4R4]M\\LPNCa4R4_M[LQN_O\\4_OcKO0h4P2[LS3nNmJ0Og4Q2lKb3]O^Jj4Q2XKgN0ZOM0c0U4\\4ZNcK`M7U4V4nMPLnMIP4[4nMPLRNEV4U4dMSKUNS11EX4S4bMUKUNS11EW4T4bMUKVNR11EW4T4bMUKVNR11EW4T4bMUKVNR11EW4T4aMVKWNR10EW4S4bMVKWNR10EW4S4bMVKWNo0X5j3`LXKXNa0e5W4SLXKXN4i0J_O?Q4Z4_MWKROW=F00000000000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000H8H8J6N2M3M3N2M3M3N2M3M3N2M3M3O1O1O1O100O1O1O1O1XN`NeG`1Z8iN]GX1b8QOUGP1k8h1O1O1O1O1O1O1O1O1O100O100O1O100O100O100O100O1O100O100O100CaKmG`4S8<000000000000001O3M3M2N2N000000000000O1000000000000O100000000000000O1000000000000000000001O000000000000000000001O00000000000000001O0000000000000000G`KhG_4Y8cKdG]4]8cKcG\\4_8dK`G[4b8dK]G\\4d8cK]G\\4d8cK]G\\4c8dK]G\\4j8O1O1O001O1O0000O1000000000000DhKeGX4[8hKdGY4[8gKfGY4f80000000000000O100000000K5L4N2O1O1O1O1O1N2O1O1O1O1O10000O1ROnJcIR5]6nJcIR5^6nJaIR5_6nJaIR5\\70O1000000XOnJWIR5j6nJTIS5m6mJRIS5n6oJPIQ5Q7oJnHQ5S7PKkHP5V7PKiHP5X7a02N1O2N1O2N1O2N1O2N0000O1O100O1O100O1O100O1O100O1O100O100000000000000O1000000000000O100000000000000O100000000000000O100000000N2N2N2N2M3O100001O00000EjHaJW7]5jHcJV7[5lHeJT7Y5nHgJR7W5PIiJQ7U5PIkJP7S5RImJn6Q5TIoJl6o4VIQKj6m4XISKi6k4XIUKh6i4ZIWKg6f4[IZKe6e4\\I[Kd6d4]I\\Kc6c4^I]Kb6b4_I^Ka6`4aI`K_6_4bIaK_6]4bIcK^6\\4cIdK]6[4dIeK\\6Z4eIfK\\6X4eIhK[6W4fIiKZ6V4gIjKY6U4hIkKX6T4iIlKX6R4iInKW6Q4jIoKV6P4kIPLU6n3mIRLT6l3mITLS6k3nIULR6j3oIVLQ6i3PJWLQ6g3PJYLP6f3QJZLo5e3RJ[Ln5d3SJ\\Lm5c3TJ]Lm5a3TJ_Ll5`3UJ`Lk5_3VJaLj5^3WJbLi5\\3YJdLg5[3ZJeLf5Z3[JfLd5Z3]JfLc5Y3^JgLb5X3_JhLa5W3`JiL`5V3aJjL_5U3bJkLh5j2YJVMn5b2SJ^Mm5b2SJ^Mo5_2RJaMn5_2RJaMo5]2RJcMQ6Y2PJgMW6R2iInMX6P2iIPNU6R2kInMT6R2mInMS6Q2nIoMR6Q2nIoMR6P2oIPNQ6o1PJQNn5Q2RJoMn5P2SJPNl5Q2TJoMl5P2UJPNi5Q2XJoMh5Q2XJoMc5U2^JkM_5X2aJhM^5X2cJhM]5W2dJiMZ5Y2fJgMZ5X2gJhMZ5W2fJiMZ5V2gJjMZ5T2gJlMY5T2gJlMW5KSHV2g2oMW5JRHW2g2oMZ5P2gJPNV5R2kJnMV5Q2jJoMW5o1jJQNV5o1jJQNV5n1kJRNU5m1lJSNU5l1kJTNU5k1lJUNS5l1mJTNR5l1oJTNo4m1RKSNm4n1SKRNm4m1TKSNk4n1UKRNj4n1WKRNj4l1WKTNh4m1XKSNh4l1YKTNh4k1XKUNh4j1YKVNg4i1ZKWNf4i1YKXNg4g1ZKYNg4f1YKZNh4e1XK[Ng4e1ZK[Ng4d1YK\\Ng4c1ZK]Nf4c1ZK]Ne4d1[K\\Ne4c1\\K]Nc4d1]K\\Nc4d1]K\\Na4e1`K[N`4e1`K[N`4e1`K[N_4e1bK[N^4e1bK[N^4d1cK\\N\\4e1dK[N\\4e1dK[N\\4d1eK\\N[4d1eK\\NZ4e1fK[NZ4d1gK\\NY4d1gK\\NY4c1hK]NV4e1jK[NV4e1jK[NV4d1kK\\NU4d1kK\\NV4c1jK]NV4b1kK^NT4c1lK]NT4c1lK]NT4b1mK^NS4b1mK^NT4`1mK`NS4`1mK`NS4`1mK`NS4_1nKaNS4^1mKbNS4^1mKbNS4]1nKcNR4]1nKcNS4[1nKeNR4[1nKeNR4[1nKeNR4Z1oKfNQ4Z1oKfNR4Y1nKgNR4X1oKhNQ4X1oKhNQ4X1oKhNR4V1oKjNQ4V1oKjNQ4U1PLkNP4U1PLkNQ4T1oKlNQ4S1PLmNP4S1PLmNP4S1PLmNQ4Q1PLoNP4Q1PLoNP4P1QLPOo3P1QLPOP4o0PLQOP4o0PLQOP4o0PLQOP4o0PLQOQ4n0oKROQ4n0oKROQ4o0nKQOR4o0nKQOS4n0mKROS4n0mKROS4n0mKROS4n0mKROS4o0lKQOU4n0kKROU4n0kKROU4n0kKROU4n0kKROV4n0iKROW4n0iKROW4n0iKROW4n0iKROX4m0hKSOX4m0hKSOX4n0gKROY4n0gKROY4n0gKROY4n0gKROY4n0gKROY4n0gKROY4o0fKQOZ4o0fKQOZ4o0fKQOZ4o0fKQOZ4o0fKQOZ4P1eKPO[4P1eKPO[4P1eKPO[4P1eKPO[4P1eKPO[4P1eKPOY4HQHY1e3oNZ4S1fKmN[4R1eKnN[4R1eKnN\\4Q1dKoN[4R1eKnN[4S1dKmN\\4S1dKmN\\4S1dKmN\\4S1dKmN\\4S1dKmN\\4T1cKlN]4T1cKlN]4T1cKlN]4T1cKlN]4T1cKlN^4S1bKmN]4U1bKkN^4U1bKkN^4U1bKkN^4U1bKkN^4U1bKkN^4U1bKkN^4U1bKkN^4U1bKkN^4U1bKkN^4U1bKkN_4T1aKlNa4R1_KnN`4S1`KmN_4T1aKlN_4T1aKlN_4T1aKlN_4T1aKlN_4T1aKlN]4V1cKjN\\4W1dKiN]4V1cKjN]4V1cKjN]4V1cKjN^4U1bKkN]4V1cKjN]4V1cKjN^4U1bKkN^4U1bKkN^4U1bKkN^4U1bKkN^4U1bKkN_4T1aKlN`4S1`KmNj4i0VKWOl4HbGm0b3[On4e0RK[On4e0RK[On4e0RK[Oo4d0QK\\Oo4d0QK\\Oo4c0RK]On4c0RK]Oo4b0QK^On4c0RK]Og4IgGO0k0b3]Og4IgG0Oj0c3]Og4IgGm0b3ZOg4j0YKVOg4j0YKVOc4n0]KROi4h0WKXOk4f0UKZOj4g0VKYOj4g0VKYOj4g0VKYOj4g0VKYOj4g0VKYOj4i0TKWOm4i0RKWOn4k0gJ^OZ5c0YJHg59lI3U6N]I>c6DoHh0", "size": [427, 640]}, "area": 63697.0, "iscrowd": 0, "image_id": 12062, "bbox": [0.0, 232.0, 640.0, 195.0], "category_id": 167, "id": 20000723}, {"segmentation": {"counts": "Q8c2g:c2^M0O1O100O100O1O100O100O1O100O100O1O100O100O1O100O100O1O100O1O100O100O1O100O100O1O100O1O100O1O1O100O1O1O1O100O1O1O100N2O1O1N2O1N2O1O1NN3I7J5M4O1N1O3N1N2N2O2M2N2O1N3N1000001O01O0001O01OXNlHZMU7e2TIRMm6m2\\IjLd6V3i100O001O1O001O1O00100O010O10O01O10O0100O010O10O01O100O101BWFWMj9i2=O010O0SNeEj0\\:TOeEl0\\:SOcEn0]:QOdEo0]:PObER1]:nNcEU1[:jNeEY1X:fNhE]1W:bNiE_1V:aNiE`1X:^NiEb1_:VN`Ek1`:UN`Ek1_:UNaEl1^:UNbEk1^:UNbEk1]:UNcEl1]:TNcEl1\\:UNcEk1]:UNdEk1\\:UNcEl1\\:UNdEk1\\:UNdEk1[:UNeEl1Z:UNfEk1Z:UNeEl1Z:TNgEk1Z:UNhEi1W:XNjEg1U:YNmEf1S:ZNnEe1Q:]NPFa1P:`NPF_1o9cNQF\\1n9fNQFY1o9iNPFW1o9kNoEW1P:jNoEV1P:lNoET1P:lNPFU1o9lNQFT1n9lNSFT1m9lNTFS1k9mNXFQ1g9PO[Fn0d9RO^Fm0a9@UF?j9a1O100N2M3N2M3M3N2M4M2M3M3N2M3N2NQOZG]Me8e3O1O2N1O1OBcGPL\\8S4hGgKX8[4hGdKV8`4iG_KU8d4jG[KU8i4iGWKU8k4jGVKT8k4lGUKS8l4mGUKQ8l4nGVKP8k4PHVKo7j4QHVKn7k4RHVKl7j4UHWKi7j4WHVKh7k4XHUKg7l4YHTKf7m4ZHSKe7n4ZHSKe7n4[HRKe7n4[HQKe7P5[HPKd7P5]HPKb7Q5^HoJa7R5_HnJ`7S5`HmJ_7T5`HmJ_7`5O010O1O1O1O1O1O_NjHoLU7R3iHPMV7P3iHQMX7n2hHQMY7o2gHmL]7T3cHiL_7W3aHiL_7W3bHhL^7Y3aHgL`7X3aHgL_7Y3bHfL_7Z3`HeLa7[3`HdLa7[3`HdLa7\\3_HcLa7^3_HaLb7`3]H_Lc7c3]H[Ld7e3\\H[Ld7f3[HZLd7h3\\HWLd7i3\\HWLc7k3\\HTLe7l3\\HSLd7n3[HRLd7k40UO\\HoKc7m40O1XO\\HiKc7Y4^HeKb7\\4^HcKa7^4aH`K_7a4aH]K`7d4`H[K_7f4cHXK]7j4bHUK^7l4?3N1N3N1O2M2O2N1O2NO100O1O100O00100O1O100O1O100O1O100000000O10000000O100000O100000000000000O1000000000000O010000000000000O100M3N2N2N2N2000000000O2O0_MoJhLQ5W3PKiLP5U3RKkLo4R3SKnLm4P3UKPMk4o2VKQMj4m2XKSMi4j2YKVMg4h2[KXMe4f2]KZMc4e2^K[Mb4c2`K]Ma4`2aK`M_4_2bKaM^4^2cKbM]4]2dKcM]4[2dKeM\\4Y2fKgMZ4X2gKhMY4W2hKiMX4V2iKjMX4T2iKlMW4S2jKmMV4R2kKnMU4Q2lKoMU4o1lKQNT4n1mKRNS4m1nKSNR4l1oKTNQ4k1PLUNQ4i1PLWNP4g1RLYNn3f1SLZNm3e1TL[Nm3c1TL]Nl3b1UL^Nk3a1VL_Nj3`1WL`Ni3_1XLaNi3]1XLcNh3\\1YLdNg3[1ZLeNf3Z1[LfNe3Y1\\LgNd3X1]LhNc3V1_LjNa3U1`LkN`3T1aLlN_3S1bLmN^3R1cLnN]3Q1dLoN[3Q1fLoNZ3P1gLPOY3o0hLQOX3n0iLROW3m0jLSOV3m0jLSOV3l0kLTOU3l0kLTOU3k0lLUOT3j0mLVOR3k0nLUOR3j0oLVOQ3j0oLVOQ3i0PMWOP3h0QMXOo2h0QMXOo2g0RMYOn2f0SM[Ol2e0TM[Ol2d0UM\\Oj2e0VM[Oj2d0WM\\Oi2c0XM]Oh2c0XM]Oh2b0YM^Og2b0YM^Og2a0ZM_Of2`0[M@e2`0[M@e2?\\MAc2`0]M@c2?^MBa2=`MC`2=`MC`2i1BWN>i1AXN?i1@WN`0i1@WN`0i1_OXNa0i1^OWNc0h1\\OYNd0g1\\OYNd0h1[OXNe0h1ZOYNf0g1ZOYNf0h1YOXNh0g1WOZNi0f1WOZNi0g1VOYNj0g1UOZNk0f1UOZNk0f1TO[Nm0e1RO[Nn0e1RO[Nn0e1QO\\No0d1QO\\No0d1QO\\No0e1oN\\NR1c1nN]NR1c1mN^NS1b1mN^NS1c1lN]NT1c1kN^NU1b1kN^NV1a1jN_NV1b1hN_NX1a1hN_NX1a1hN_NX1a1gN`NY1a1fN_N[1`1dNaN]1^1cNbN]1^1cNbN^1^1`NcNa1\\1_NdNb1[1^NeNb1[1]NfNd1Y1\\NgNe1Y1YNhNg1X1YNhNh1W1XNiNi1V1WNjNj1V1UNjNk1V1UNjNl1U1TNkNm1T1SNlNn1T1RNkNn1U1RNkNo1T1QNlNP2S1PNmNP2T1oMlNR2S1nMmNS2R1nMmNS2R1mMnNS2S1lMmNU2R1kMnNV2Q1jMoNW2P1jMoNV2R1iMnNX2Q1hMoNY2P1gMPOY2P1gMPOZ2o0fMQO[2n0fMQO[2n0eMRO[2n0eMRO\\2m0dMSO]2l0cMTO^2k0bMUO^2k0cMTO^2k0bMUO_2j0aMVOa25WLeLX1V3b21\\LfLR1Y3c2N_LgLo0Z3d2JbLjLj0\\3e2EgLmLd0^3f2_OmLQM=`3h2XORMVM6b3i2ROYMYMNe3j2lNjNS1X1fNmNZ1T1`NQO`1P1ZNUOf1m0SNXOm1i0mM\\OS2e0gMAX2i500000001O00000000001O00000000000000000000000000000000000000000000000000YIgL\\3Y3`LlL_3T3^LPMa3P3\\LSM\\M]OR6_3bLVM[M]OQ6]3bLWM^M^On5[3cLWM`MXOS6a3[LQMSN@W5_3hL_L\\N9j4X3eL`MbM^Of5R3hL_McMAc5P3iL`MdMAb5o2jL`MdMBa5n2kL`MdMC`5m2kLaMeMB_5n2lL`MeMB_5n2kLaMfMA_5n2kL`MgMD\\5l2mL`MhMWOg5Y3aLXMU4h2kKiLd4W3[LaLiLM0c0X5o2aMoLWM7X5j2TM\\MeMIW5k2PMaMhMDX5k2lL^LkMS11DX5k2lL^LkMS11EW5j2lL_LlMR11EW5j2lL_LlMR11EW5j2lL^LmMS10EW5j2kL_LnMR10EW5j2kL_LnMR10EY5h2iLaLnMi0a6a2cKgLlM;o6a2aKTM`MNo01XO?V5Q2]NkMUL=`5Z1[NeNULXO5`0\\5V1WOaNh1R1dK", "size": [427, 640]}, "area": 119289.0, "iscrowd": 0, "image_id": 12062, "bbox": [0.0, 59.0, 640.0, 363.0], "category_id": 183, "id": 20000724}, {"segmentation": {"counts": "f_6114Q=MoBO0:k<50001O00O4L002O00O02OO10000000000000000`CGm;:PDHo;;nCGP<:FP<WLcM_1\\3Z2QOWLbM_1^3Z2POXL_M`1a3X2POXL^M`1c3X2oNWL]Mc1d3U2SOTLYMh1d3T2ROTLZMh1e3T2ROSLXMc11VNe3T4ROSLWMc1o3Z2iNSLXMc1P4Z2iNPNX1P2gNQNY1o1gNPNZ1P2fNoM[1Q2eNnM\\1R2dNmM]1S2cNlM^1T2bNlM^1T2bNkMdMPN[3U4QOkMbMRN]3S4QOkM`MUN^3o3ROlM_MWN_3m3QOmM^MYN`3j3QOnM^MYNa3i3POnM^M[Nb3g3POnM\\M^Nc3d3QOmM[MaNd3b3QOcNo0]1POdNP1\\1POdNP1\\1POdNP1\\1POdNP1\\1POdNP1\\1POeNo0[1QOeNo0[1QOmMaM^N^3e3TOeMdMeNX3f3TO`MjMiNR3g3TO_MlMiNP3h3TOVMYMjNe06o2j3SOVMZMhNf07m2k3SOVMZMgNh06l2m3ROVM[MdNj07j2o3QOVMZNhNg2S4nNUM\\NeNh2V4lNUMY2j2hMVMX2j2hMVMX2k2fMUM[2k2eMUM[2k2eMWMY2h2hMXMX2h2RKjKd2^1Z2j2fMVM\\McNk4W4iMVM\\McNk4V4jMZMV2f2jMWM\\MbNj4X4hMVM\\2i2eMWM[2g2gMYMY2g2gMYMY2g2gMYMY2g2gMZMX2f2hMYMY2g2QKkKd2]1\\2h2PKkKd2]1\\2h2PKkKd2]1\\2j2dMVM\\2j2dMWM[2j2dMUM]2k2cMUM]2n2`MRM`2o2_MQMa2P3mKfK?\\1b3f2RKPLf07e0T1b3e2SKQLc08g0V1`3b2VKmK1M>b0j0T1_3`2ZKTL52LGV1g1[3]2]KTL234CQ1k1Z3Z3RMhLl2V3UMlLj2S3WMnLh2P3\\MoLc2g2hMYMW2d2kM^MT2b2lM_MS2a2mM_MS2a2mM`MR2a2mM_MS2b2lM^MT2b2lM^MT2c2kM]MU2Q3]MoLc2R2hKlKOl0`1V1i2R2hKlK3j0Z1X1k2W2mK`LW1Y1l2W2QL]LR1\\1m2P2iKoK`0=j0d1m2Q2gKPLm0O?P2m2X2eLhK=P2n2X2fLgKlC@02L0X<`0jC^OO5OMX<`0jCFNJXP<_OVD>j;AXD>h;AZD>f;A^D<_P9BPG>P9BPG>P9BPG>P9BPG>P9BPG>P9BPG>P9BPG?o8AQG?o8BPG>Q9BnF?oNfNP:k0QGa0P9_OoFa0Q9@nF`0R9AmF?S9BlF>T9BkF?U9AkF?U9BiF`0V9@iFa0W9@fFb0Z9_OeFa0[9@cF`0^9@aFa0_9@_Fb0`9_O]Fb0d9AXF`0h9CRF`0n9`1O00000000000000\\NVFFj99XF]OQ:c0oEZOT:e0mEZOT:?fEdN7`0NAV:X1RFWO]:i0`EYOa:f0`EYOa:b0QEoN=?c:a0cE^O_:a0aE^O`:a0`E@`:`0hEWOY:h0kEUOU:l0oEoNQ:Q1U16J1O1OO1O1O100000001O00mDkNo9U1PFmNo9S1PFPOn9P1QFSOm9m0RFUO1Hi8S1UGVOG2T9h0UG]O\\OO_9e0SG:m8FQGlN]OU1b9OPGlN@T1a90ZG0f81YGOh81WGOi83UGMk86\\FdN?V1T9[G[O[O7Z9?ZG\\OZO5\\9?kFgN2g0F2]9a0gFjN5b1R9FjFfN4d1Q9HZG8e8JYG7g8JPG?o8BWG6j8KVG5i8KXG4h8KZG4f8G`G8`8GbG8^8FcG<\\8DdG;]8EcG;]8EcG;]8EbG<^8DbG=]8DbG<^8EaG;_8GhFdN`0f1h8MjF_N3d1S9MjF_N3e1R9MkF^N2e1S9NjF^NNh1X9JkFZN1k1T9LRG3o8NPG1Q9OPGOQ9MSG2n8JVG5k8JVG7j8GXGUO_O:X9a0YGSOC;S9b0ZGQOGPICo6?PI_OQ7d0]GaNo0j0e7h0WG`NT1i0d7T1\\HlNd7T1\\HlNd7T1\\HlNd7T1\\HlNd7T1\\HlNd7T1\\HlNd7T1\\HlNd7T1\\HlNd7T1[HmNe7S1ZHnNf7R1ZHnNg7Q1XHPOh7Q1WHoNi7Q1WHoNi7R1VHnNj7S1UHnNj7U1RHlNn7W1PHhNP8Y1oGeNWOlNj8_2PHdNR8\\1oGcNQ8[1QHeNo7T1YHkNg7P1^HoNc7o0`HPO`7o0aHQO_7n0cHQO]7n0eHQO[7n0fHROZ7n0gHQOY7n0hHROX7n0hHROX7n0hHROX7n0hHROX7n0hHROW7o0iHQOY7m0gHSOZ7l0fHSO[7n0dHRO]7m0cHSO]7n0aHSO_7m0`HTO`7l0`HTO`7m0^HTOb7m0\\HTOd7l0[HTOe7n0XHTOg7n0VHROk7k0YHUOe7l0\\HTOa7o0^HROb7n0^HROa7P1]HRO\\6", "size": [428, 640]}, "area": 54333.0, "iscrowd": 0, "image_id": 12120, "bbox": [0.0, 17.0, 640.0, 172.0], "category_id": 173, "id": 20000728}, {"segmentation": {"counts": "[n15R=6I7XOLPD;o;b0O101N2N1O2N3M8HOO2O0O2O1N101OJiDXNW;h1mDUNR;k170001O100O1O1O1O100iN]De0ZDDg;;WDGi;n0100O001O1O1O0[OUDIl;1ZDNg;K`D5`;HcD6^;IdD6];HeD7\\;GfD7[;GhD8WOCO<3EL5:LE2<0AOa03\\ONc05ZOLf06WOKi08SOIm0[601N2YOaC?a<]ObCb0e\\c0Bd\\O>\\c0Bd\\O>]c0Af\\O@`0lNTAZLf?f3:001O0000001O000000001O0000001O0000001O0000001O0000001O0000001O000000001O0000001O0000001O0000001O0e@gKo>Y4l@mKS?a4O1VA[KW>f4bAbK\\>Q50001OO1J66J1O000000000000002N0000000000000000000000001OO1001O002N002N2N00000000000000000000001O1O0000000000000000000000000000000000O100001O0000000000000000000000O100O100N2O1O100000000000000D<4L8H000000000000000000000000000000000000000000LeAcJ[>]5eAcJ[>]5eAcJ[>]540000000000000000000000000000001O2N1O001O00000000001O000000000000001O1O000000O100N200O1O1000000000000001O1O1O00000000O100000000O1000000O10000000000@iAWKW>i4`0O100O100000000O100000000002N00CSAfKn>Y4SAgKm>Y4SA]KO7o>\\4ZA^Kf>b4<00O1O1001O1OL4N20000000000O11O002NO11O000000O1000000O1H_@PLb?g3^@YL0K33^?i3n@ULQ?j3c000N2O100001O0000002NN2M32N00O15K00N21O2N4L001O00O1L400000000000000000000@Q@oLo?P3R@PMn?n2U@QMk?o2U@QMk?n2W@oLk?P3]@hLd?X3b0O100O1O100O100O1002N00001W_OlLd`0X30000\\_OfLb`0\\30000000000000M3O100O1O1O100000000LX_OoLi`0o25N2N2N2N2O100O100O100O100O1O100O1000000000000Hb^OnM^a0R2b^OnM^a0R2c^OjM`a0V2`^OhMba0X23000000NZ^OjMfa0R26JU^OTNna0j150000O1000000000000001O0000001OO1001O000000Ln]OYNSb0f14O100L41ON2O11O002N1O1O1O1O001O1O00000000000000001O1O1O002NO1001O00000000000000", "size": [640, 480]}, "area": 66282.0, "iscrowd": 0, "image_id": 12280, "bbox": [0.0, 0.0, 480.0, 186.0], "category_id": 102, "id": 20000731}, {"segmentation": {"counts": "fdQ67ic04MO00O1O1O20OdG6ZI`1aL^NY9V1hEZNg0`0o1c1RNcN_9V1_FdNa1Z2YNmMe9X1`F_Nd1Y2]NlM[9i1XFWNj0_OkN4g0f2MgM^9o1PFYNm0F^Om2HXMm9m2hFRM[Ol3l9POmFSMYOk3l9[OPFWMd0R3[9R1PFkJNa4R:[5nLUFoKk9n3XFSLg9k3^FRLb9j3nFaK\\9^4dFbKQ9i4oFWKR9h4nFYKQ9g4PGXKQ9g4oFYKQ9g4oFYKQ9g4oFYKR9f4hF^L@jL5Km7m6YHTICZ4l7a2aHWIBW4m7R2THoI0d0h7S5VJkI_N>Ae0j7S5WJiI]N`0Cb0j7U5XJhI\\N?Cc0i7V5QKZJXM>CoNQ8Y6WKVJWMa0@QOR8X6WKVJYM>_OSOR8V6ZKWJVM`0]OTOS8T6[KXJUM`0\\OTOU8T6XK[JVM`0b7T5ZK[JUM?a7V5[KZJUMFA?n7`5^KZJSMDEb0i7`5TM\\Jl2d5TM[JjJBP8S6WMZJiJCP8S6YMXJfJGo7n5RHPJ[5:dJHo7l5cM_J]2_5dMbJ\\2\\5fMdJZ2Z5fMgJ[2W5fMjJZ2U5dMnJ\\2R5dMnJ[2R5gMfJZJJo7`5gMfJZJH0Mo7d5iMfJYJG0On7d5jMeJYJGO0m7d5Z62O0O110O01000000000000HiAgJW>Y5iAgJV>Z5kAbJX>^5hA`JZ>`53000000NbAbJ^>Z56J]AlJg>Q541000O10000000O1000010N10000O20N102OO01O00NNVAQKl>m44O10OM32M01002N1O3M2JnJ[AT5b>7N2O010O10O0cJaAY5`>fJ`AZ5`>fJ`AZ5`>fJ`AZ5`>fJ`AZ5c>00001O1O1O002M01001O00000001OLcJeA]5\\>30RN", "size": [640, 480]}, "area": 66579.0, "iscrowd": 0, "image_id": 12280, "bbox": [309.0, 48.0, 171.0, 503.0], "category_id": 112, "id": 20000732}, {"segmentation": {"counts": "n8R;n80000000O100001O0000000000001oDRGn:n8RERGn:P901O00O100002N0000N200000000O10000000000NQESGo:m8QESGo:m8QESGo:m82O11O00O1001OO11O000000N2JmD^GT;`8nD_GS;^8lD`G02U;^8800O100000000000000000000000000000000000000N21O00001O000000002N000000O1O100O1000000001O0000O11OO10000000000000000000000000000LbDfG^;[8aDeG_;[8aDeG_;\\8`DdG`;\\821O001O0000000000J6O100001ON21O1O6J00000hFdGl6\\8lHmGS7S8eHVHZ7j7^H_HoNTOP8]8iHgHWOlNP8]8aHoH_OeNo7]8YHVIH]No7^8PH]I0VNP8^8gGdI9nMP8j:PHWEo7j:PHVEP8j:PHVEP8j:PHVEP8j:oGWEQ8i:nGXER8i:lGXET8h:lGXET8l:gGUEY8Y;000000000O100^OdG`E\\8`:kGYEU8h:QHQEo7o:a000001O\\MRGVJn8j5SGUJm8l5RGnH0hN0l0n8]7TGmH5Eg8^7UGlH3Hg8\\7\\GeHM0g8[7cG]HG>`8U7ZHjGWOY1X8m6PIVIn6j6QIXIn6h6QIXIP7h6oHXIR7h6nHXIR7h6mHXIT7h6lHWIU7h6mHWIS7i6mHVIT7j6mHTIT7l6lHVIR7l6mHUIQ7i6QIXIn6Q7jHPIT7T7hHmHW7S7jHlHV7T7jHlHV7T7kHlHT7T7mHkHS7U7nHjHR7S7fG\\GZ1_1P7T7VIjHj6U7YIiHg6U7]IhHd6V7`IhH`6X7aIfH`6[7aIcH_6]7cI`H^6a7cI]H]6c7eIZH\\6g7eIWH[6i7gG^GK0l1f0c6m7eGaGg1a0d6Z8\\IcGe6_8[I_Ge6b8\\I[Ge6e8]IYGc6e8aIXG`6h8aIWG_6i8cITG^6l8dIRG\\6o8Z200001O000000000000O10000O10VEPGd:P9[EQGe:Q9ZEnFf:V9000001O000000000000000000000000O1000000000000000000000000MXEmFi:P9XEPGO0i:P9XEPGj:P9300001O00001ON2000VEPGL0f:P9^ERGb:n8^ESGa:n8]ETGb:U901O00001O0000001O00001O1O0000000000O100000000KkLmFgKR9Z4RGbKn8_4QGaKP9^4PGbKP9]4QGcKP9[4QGeKn8[4TGdKk8^4TGbKl8V1jHnL^Nk1h8mMXGo1c1RNcNR2c8lMWGa1Z2YNmMY2d8lMSGd1Y2]NlMS2Q9`MoFj0_OkN4g0f2MgMW2V9WMRGm0F^Om2HXMe2U:PNjE[Ol3e2W6TNlEYOk3c2d6YMnEd0R3R2[8YMbCNa4i2d<00000001OE;1O001O00001O001O00000000O10000O10000O10000O11O00001O1O001O1O1O1O1OO10000000000000000O10000000000O100000000000000O1000000O1N2O1N200O10000000000000000O100000000000000001OO1000000000000O100001OO10000O11O002N001O00N21O0000O1O1N2O1O1O1O1O1KbLg_O_3W`06O1001O001O0\\Lh_O`3Y`0_Lg_Oa3Y`0_Lg_Oa3Y`0_Lg_Oa3Y`0_Lg_Oa3\\`00000000000000O10000000000001OLaLg_O_3Z`0300", "size": [640, 480]}, "area": 126347.0, "iscrowd": 0, "image_id": 12280, "bbox": [0.0, 263.0, 480.0, 377.0], "category_id": 117, "id": 20000733}, {"segmentation": {"counts": "ooP48hc06J3M1O0O2O001N1l\\O[OK0Pc0f0T]O^Oib0o0N2N1O01M201oNT]Ol0mb0SOS]Om0Pc01O00010O0003M0VOo\\Oe0Wc0O4Ed\\OJ_c03a\\OL\\c08d\\OH\\c08e\\OG[c09e\\OF\\c08jgb0Gjd\\OO70Xc02`\\ON0g0Qc07N1O1000001N100O2ON1100Y]OmNL0cb0S1a]OoN^b0R1b]OoN]b0R1a]OPO^b0Y1O2O0OUOV^OBla0j2ZAWMg>i2VAZMg>j2n@_L1d0U?o2g@]L3e0V?R3j@mLW?U3g@kLY?o3NFo@gKQ?Y4;F:6I3FhKg@X4Q?hKo@0K33l3[?`Lc@[3`?f0M9EG:M40001N10^@eK_?[4a@eK_?[4a@eKa?Z4^@iK]?`4KN7SOk0O006G4OO30N302L001mLX_Ol2h`0QM[_OP3m`0M<[O9000010O000000JT1d^OjL5K\\?1]@S3OoM[?POe@Q3_Of@n2m0RM^>W3V1O101N12N3L5N1N2M3Q@VLb?m3Y@SLh?S41N2M201N1gLn_OO0n1T`0oMP@2N54h0o?QOP@1M67d0m?UOP@0L69b0n?WOm_OJJL2`0:a0Y`0POa_O0ML1a08d0Z`0oNa_ON5>0d0]`0nNP@>Ae0a`0lNm_O`0Cb0c`0mNk_O?Cc0[a0@g^O>CoNfa0?i^Oa0@QOga0>k^O>_OSOha0=j^O`0]OTOia0o_OP2:cMf?>o_OP2:cMf?T3Y@mLe?V3Z@jLe?[3V@fLk?f3100000001O000fLo_OS25eMl?1P@G0c2;^Me?8R@D0e2``0gMf_OX2]`0eMd_O[2_`0aMb_O^2_`0aMb_O^2^`0bMc_O]2^`0aMd_O_2\\`0_Me_OZ1FEXa09j^OFXa08g^OI`a0O`^O3fa0E[^Oa0^b08H3M1O0010O001O2O0O2O02O1N101N10O001O1O2N2O1N1N3N2M3N2M3N1N3N2M3N2M3N1N3N2M3N2M3N1Nh]d14Sb[N4M2M2N3O0000O1O8Ijf=J]YBk1m_OkMU1:n>U2m_OaMl0:V?`2b@aM]?f2n_OPM2O5i0SAOi>2m@:P?Gf@e0W?\\O_@m0a?TOU@T1l?mNk_O[1U`0X10O1O100O1O1O1001O001O001O001O0000000000000000001O001O001O1k_OWLQ`0l301O001O1O1O1O1O001O1O1O1O001O1O001O1O00]Oc0N2O1O1O1N2O1YOb_O[M0:_`0X2S@^Mn?g1`_OVN0O20R13]?Me@0kN0O0k12Rb0Nfld2", "size": [640, 480]}, "area": 13576.0, "iscrowd": 0, "image_id": 12576, "bbox": [172.0, 0.0, 172.0, 140.0], "category_id": 112, "id": 20000739}, {"segmentation": {"counts": "fjo68gc07Z\\OB_c0?M4N1N2L4N201N1N200O10001O00000NnNV]OR1ib03O2N100O10001O0O10000O1010O3M2N0001NJ[]OnNjb0R111000000010O002M100O3N1SOo\\O11b0Tc0]Om\\Oe0Yc0OOO0O2O011O0N2N>DiPV1", "size": [640, 480]}, "area": 1937.0, "iscrowd": 0, "image_id": 12576, "bbox": [358.0, 62.0, 61.0, 47.0], "category_id": 119, "id": 20000740}, {"segmentation": {"counts": "coZ85jc03M3O1M3N3N1M3N2N2N2N5K5K2N3N1OkN\\]Ok00QOib0o051O0O1OO1O100N21O1N0100000000000000O0100000001O00001OO12M10O100002N00OWL", "size": [640, 480]}, "area": 1691.0, "iscrowd": 0, "image_id": 12576, "bbox": [427.0, 113.0, 53.0, 48.0], "category_id": 165, "id": 20000741}, {"segmentation": {"counts": "0k4U?003MM32N1OO11O00O1002N1O1O1[APKX>T5`ARK^>X5aAaJ]>a50N2001O1O2N2N1O2N001O1O2N1O1O2N1O1O1O2N00O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O1O100O1O1000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000O10000000000000000000000\\NRAVNn>i1TAVNl>j1UAUNk>l1VARNj>o1UAQNk>o1WAoMk>P2UAoMm>P2SAoMP?n1QAQNP?jNh@R37TN[?nN]@a29`Nd?kNT@^2:eNj?mNk_OY29jN\\`0h0e_OWOm`0oNi^OU1:KXa0PO^^Ol0:3ca0E^^O:ia0QOm]O2O5b2SA]Mm>b2UA]Mk>c2VA\\Mj>c2XA\\Mh>c2YA]Mg>c2ZA\\Mf>c2[A]Me>b2]A]Mc>b2^A^Mb>b2_A]Ma>b2`A^M`>a2bA^M^>b2cA]M]>b2dA^M\\>a2fA]M[>b2fA^MZ>b2gA]MY>b2hA^MX>a2jA^MV>a2kA_MU>a2lA^MT>`2nA`MR>m0o@MP1VOQ>l0UAGm0\\On=k0]AAg0Dl=i0eA\\Oa0Jj=i0lAUO<2h=g0TBoN79e=f0\\BjN0`0d=e0oC[OQ\\DBd;>]DAc;>^DBb;=`DAa;?_DAa;>`DB`;=bDC];=cDC];PECo:>PEBP;?X4001O1O1O1O001O1O1O1m^OBb>>n@6n>Ki@`0T?Ab@j0\\?WO[@Q1e?POQ@X1P`0\\1000O1O100O1O1O1001O001O001O001O0000000000000000001O001O001O4L001O001O1O1O1O1O001O1O1O1O001O1O001O1O00]Oc0N2O1O1O1N2O1O1O1O1O1O1O1O1O1O1O1O1O1000000001O00000000001O000000001O00000000001O00000000001O000000001O00000000001O000000001O00000000001O00000000001O000000001O00000000001OWOo_OcMQ`0b1k@]NU?P1^APOb>P1_AoNa>Q1_AoNa>Q1`AoN_>Q1aAoN_>Q1cAoN[>Q1kAlNR>T1nAnNP>R1PBPOn=P1RBROl=n0TBTOj=l0VBVOh=j0XBXOf=h0ZBZOd=f0\\B\\Ob=d0^B^O`=b0`B@^=`0aBE[=;eBKU=5kBNR=2nB0P=0PC3m4XClNmMS1h>1\\ChNPNX1b>0hC3Un1AT>X2R@jMS1:a>X2SATNk>o1RAQNm>n1[AiMf>X2VAnMh>S2]@ZMe0b0o>Z2SAcMm>]2QAdMU6Ak1k2PHdMU6Bj1k2QHaMV6Hd1h2UH_MU6AVI7c8h2PHdMV6Gj1d2TH`MR6Ni1c2SH`MT6Og1`2WHRMYO303k69b1`2]HSMXONN000k6c0^1\\2HgM5Y2KaMn;DPDRBnMi0d1U=`0mAoMn0a1U=?hAUNd0EHg1l=m;BTD>l;BTD>k;CUD=k;CUD=j;DWD;i;FVD:j;HPBcNg1e1YWYVZ2N100001N1O101Kf^OaM\\a0^23L`^OgMaa0W26M23NN1N2O11O01O0000O101O00O11O0_MmMUCS2kc2RB[O1UNQ>h2eARO;VNo=i4SBVKo=h4RBXKn=f4TBYKm=f4TBZKl=d4WB[Kj=c4WB]Ki=a4YB_Kg=`4ZB`Kg=]4[BcKe=[4]BeKc=Z4^BgKa=W4aBiK^=W4cBiK]=U4eBkKZ=U4X1O101N2N2O1N2N2O1N2N2O1N2N2N102N2O0O1UOh_OnMY`0i1S1K4O3N002O00Z_ORNZ?n1b@XN\\?h1`@_N]?a1`@lNV?U1f@nNZ?R1c@QO]?o0_@\\N@8Q`0^1V@^NO1k?b1o_O`N=Jd?\\2a@`M`?]2f@`MZ?^2l@^MS?b2U110O010O011N010O101N100O100O100O01O1000\\Nh^OUONT1[a0CR_O[ODMNe0]a01b_OFf`0:Z_OEUOEYa0f0b_OCWOGVa0g0c_OBWOGVa0g0c_OBWOGVa0h0c^OZOb0O^O:7ETa0Q1g^OoNN00g07YOTa0V2l^OjMSa0n0o^OOMSOTa0l0R_O1ISOVa0j0R_O4HROVa0i0R_O6GQOWa0e0Z_O_O_O?L^OZa0c0]_O^O_OOK123KM\\a0`0j_O^OoN025IL]a0`0i_O_O^O3i`0=`@C_?=b@B^?>b@C^?=c@B[?`0l^O^OM0a10e?Z1[1000l_OhN_=Y1_BoN[=R1a@eNe1;i=P1b@eNd1:l@F0V1U1iNZOc0KCi>6o@CNX1R1lN\\Ob0FFo>2n@BO62j0m0UO]OU1g>SOQAG5l0IPOc06FU1h>QORAG5R19SOEV1k>mNRAF7o09SO[O37Y1^?bNo@6h0NjN[1fa0cNT^O24]1ha0hNW^OX1ka0hNS^OY1ka0iNT^OW1ma0>1N2O\\ORNS_OR2i`0RNT_OP2i`0RNY_Om1e`0UN[_Om1d`0QN]_Oo1d`0PN^_Ol1e`0RN[_Oo1V>nMgC2TNn1U>`NVC@iNP2P>gNhA0l0V1^=POaAK3XO3TAWNl0g1P>1YASNg0n1o=M\\B2c=N^B1b=O`BUNeNi1k>1cBOa=N^B3b=M]B3c=YNQA_1]17g=JYB5h=KWB5j=KUB5k=KUB5l=OoA1Q>0oAOR>2kANY>0fA1Y>1dAO]>2aAO`>1_AOa>3h@TN=j1i>5h@RN?i1i>=TADk>i0h@XOX?j0f@VOZ?h20O1O1010N1O11N20O0001O002NO1O1O2OO01N2O100O1O10O101O001N110O3M1O1O2N000O2O0O1001N10O10010N10001N4jMW@Ni?2X@Of?QNZ@c079JS1k?bNo@EYOi1h?aNcA[1^>dNiAV1V>iNlAV1T>iNmAW1S>iNnAV1S>hNoAg0`>YOaA4R?Lb2N00100O100OR\\1GSdN5L4L3M5L2bP:]OPPF2N2N2N1nNMW^O5ia05k]OMUb0=_]OEab0m001OOZOfNh^OZ1l`0gNb^O1Ob0Of0_a0hNc^O0Oo1]a0UNb^OLOo1_a0WNb^Ol1^a0Z17XN]OB5a0k1e8hLmF^1nHBR7n1AQ6[:UHgES1:_6Z:UIRFh6R:UIZF^6e9jIVFT6j9hI[FW6f9nHXEe0Q1^6m9WIPE0Q1h6o9VITENo0R2_O^O^OZN000]13VOm:DRE2Q1m1DXN]OB5a0b:BZGa1\\N_NYO2Z3:f7FZG`1aNaN_27f7F]G0PO0_O2b24b7J[GOl34i4MYGNk3;_=01O0J\\\\O0gc0MZ\\O0hc00W\\O1QXi8", "size": [640, 480]}, "area": 5407.0, "iscrowd": 0, "image_id": 12639, "bbox": [0.0, 280.0, 30.0, 360.0], "category_id": 132, "id": 20000748}, {"segmentation": {"counts": "0Q8o;O1003M1OO10000O11O00O10000000000O1001O0000kM_DjKb;o3fDPLZ;o3jDnJEOa;Q5mDmJD3^;o4PElJC4^;o4QEkJC5\\;Z4SDVK0?o0LB5\\;Y4fDWK<0N>Q;[4hFdKX9Y4RDZKf2=X9Y4RDZKg2=V9Y4SDZKh2m3oAQL`1;_NFk=Q4eC]L[i=c3WBnK90<5ZO:j=g3`BjK20C12j0h=i3WBcK1k0h=R5000001O00000000De4>0000N2O11O1OO11O000000O1YOQA]Lo>_3VA`Lj>_3XAVLKLn>l3[AVLn>i3TAVLl>j3UAULk>j3WATLj>m3d0001O1OO11O0000001O00001O000000O100O1O1O1000000000000000000000000O11O1O00001O00O11OO11O000000000000000000000000O1O100O100O11OO100001O000000000000O1O100001O1O0000O10000N200O1001O1O00001O1O1O00001OO1000000O100000000000[@SLF0]?l3n@VLCN_?l3o@ULBO62a16];d3YCXLG5S1KkN6S=b3WCYLG5R19Qj500000000000000000000000", "size": [640, 480]}, "area": 69895.0, "iscrowd": 0, "image_id": 12639, "bbox": [0.0, 0.0, 480.0, 260.0], "category_id": 169, "id": 20000749}, {"segmentation": {"counts": "eU>^1l0fNc`0`1Y_OeNR:4WK]1bJeNQ:1YK_1cJbNR:0XKd1bJ_NS:NXKi1`J\\NW:LVKm1^J[No94_Kb2]4aM`Kc2\\4aM`Kd2^4]M^Kg2`4[M\\Kj2b4WMZKm2e4SMXKQ3f4QMWKS3g4oLVKS3i4nLTKV3j4lLSKV3m4iLRKX3n4hLPK[3o4fLoJ[3R5dLmJ^3R5bLlJ`3T5UKgF11l0S4P4U5PKkF02n0j1NROW4V8lJWGn0`12POU4l8gKSH7kNW4R9aKQHe0Fn0T7^6jHnGb0`0AS1S7_6lHkGh0d1b1UNI124^NZ8ASH3H>b1e1WND074\\NX8CTH2I6XNn7NlGL1i0f1Z1]NXONb07VNk7a0lG5h1Z1^NTONf08SNg7f0kG4k1W1`NQOOi07SNc7i0kG3m1W1aNmNOm07QNa7k0kG4m1U1dNiNNQ1c8nNkF5Q2R1eNfNNU1a84lH0hNbNNY1_85lHOiN_NN]1]8`NhFU1U2>kNZNNb1\\8_NiFU1S2?lNWNNf1Z8]NjFX1R2>nNSNNi1Z8[NiF\\1R2;5NP7XNlF_1P2:4N_7H^H93O_7IgHNJ9`7HiIkNhN\\1`7IhIkNiN[1_7JhIkNiNZ1`7KgIkNiNZ1a7JfIlNiNZ1e7FbIoNjNZ1f7F_IQOkNY1\\7iNVFd0c3ZOkNX1\\7lNUFc0c3YOlNX1\\7lNUFc0c3YOlNW1]7mNUFb0b3[OkNV1^7lNVFc0`3\\OlNU1^7mNVFa0`3]OlNT1_7nNXF>]3@lNT1_7POXF:]3BlNS1a7QOVF9\\3DnNQ1c7^NRF=0?]3EnNQ1j7kNkE>]3FnNP1k7lNkE=\\3GnNP1k7nNjE9]3JnNn0l7QOhEEM9`34oNm0m7QOgEB0;[38POi0R8PObEA4=X3;oNg0S8QOiEMS3>POd0U8QOfEMU3?POb0W8ROcELW3a0nNa0Z8QO`EMX3b0mN?]8RO]ELY3d0mN>_8TOWEI^3f0lNXNCc8OUI?WNAd81TI?XN@d81TI?XN_Od8I_E]Oe3]1WN]Oe8HaE]Oc3^1WN\\Of8IbE[Oa3a1VN[Oa8:XI_OaLLf1;b89XI^OhLH^1?c8;XI[OkLIZ1a0a8=YIYOnLC_OKl1g0]8d0ZIVOoLDe1=P8j0]ISOQMFf18i7R1`IoNSMFi13_7^1fIfNUMFm11n6m1PJ\\NP:d1PF[NQ:e1PFYNQ:g1oEXNR:h1oEWNQ:h1PFWNR:h1oEVNR:j1R402N6J5K3L3N2N2N2M4M2M3N3L9Hg^OEV?1e@6Y4Fk6;QIJl68PIMn64nH1o61lH5R7LiH:T7H^Hg0`7ZOUHS1g7oNWHT1g7mNVHW1g7kNWHX1f7kNWHX1g7iNVHZ1h7hNVHY1j7hNTHZ1j7hNTHZ1k7gNRH\\1l7fNRH\\1m7eNQH]1m7eNPH^1n7cNQH^1o7bNPH`1n7aNPHb1n7_NQH?[LSOc;>QH?cLnNZ;d0QH?kLiNR;i0RH?RMcNk:n0RH?YM^Nd:T1PG`1cNWM[:[1mFa1oNoLR:a1kFd1c:\\NYEg1h:YNTEj1n:UNnDo1R;VNeDm1b:eL\\Dh1c0f1k:GfDPK[:XNXEi68SKc:P5WESKj:R70O00100O1iIUEW3l:gLaEm2a:oLmEe2U:hKSE7U1e3i9QLUE8_1[3^9ZLUE8j1V2lMaMV;NVE6o1V2iMfMS;KVE4U2V2gMiMn:LXEOZ2W2eMlMi:LZEL_2W2cMoMe:LZEIf2U2`MUN`:K]EEl2T2\\MZN[:LZIb1`L`NV:M_I\\1_LfNS:KdIX1^LkNi7GiG1N4W4R1^LPO_76UG`0j0k@IU?a2O1O100O100O1FJj@VLk>P4]AmKb>P4eAmKZ>o3nAnKQ>o3VBnKi=o3U1N2Mf@kLQ>R3ZAfMg>i3001O001O001O001Ob0oNc@[L^?b3f@\\L[?a3i@]LX?`3l@^LU?_3o@_LR?^3RA`Lo>]3UAaLl>\\3n0M3N2M3mN]_OeNf`0Z1d_OZN_`0e1o0O2N3fNP^O>Sb0_O`^ONca0OZ1M3M3M3MWZ7", "size": [640, 480]}, "area": 58167.0, "iscrowd": 0, "image_id": 12639, "bbox": [22.0, 125.0, 446.0, 431.0], "category_id": 183, "id": 20000750}, {"segmentation": {"counts": "o0V9W1^JH`59aJG^5;aJE^5bJA]5b0bJ^O\\5e0cJ[O[5g0eJYOZ5h0fJXOY5h0hJXOW5j0hJUOW5m0iJSOV5Q1gJoNW5V1fJiN[5X1dJhN[5Z1dJfN[5\\1dJdNZ5^1fJaNZ5`0_GFU3J[5=bGiNO60b0R32\\58eGnN52Hf0R31]53dGUO;OBi0R30\\54ZHLZ20[54\\HUOVOc0S33[55\\HUOXOb0Q34Z56cHGR23Z57dHFR23Y57fHFQ23Y56fHHQ22X57gHGQ22W57hHIP20W57jHIo1OW58lHHm10W58lHHm10V51UI0d1OW50WI1a1NX50YI2_1NW50[I2^1NV50]I3\\1MW5O_I3Z1MW5OaI4X1MW5NbI5W1LW51aI[OZNf0n2OV50eI0U10U51fIOU1OU53fINU1OT54gINT1NT55gINU1MU54eI0V1LV53dI1V1KT57fINV1KS57gIOV1JR58hINV1JQO]OQ4j0iKNV1KoN_OP4e0RLNo0NmNCo3;\\L4h0MhNIU43^L7e0MfNLV40_L7e0MgNKT42^L9f0JhNLR42`L8f0JgNMS41aL7e0JhNOP41aL8g0HhNOP41bL7f0IhNOQ40aL8f0IgN0R4NbL9e0IgN1Q4MdL8d0IhN2P4MdL8d0IhN3o3LeL8d0IhN3P4KeL7d0KfN4Q4JaLCkMd0m2JgN6l3LdL8j0FfN6m3KbL:k0EgN5k3McL_OlMg0P3HfN6j3MfL4j0IgN5e3^OdJa0U22l0IhN5b3@eJ`0U22l0IiN4`37kLKm0JhN5a34jLMm0JhN5a33kLNl0JgN6c31fL[OQNc0o2JiN6`33fL]OPN?R3KhN7_32fL4R1CiN7[3]OkJd0P25Q1CiN7Z3^OlJc0o16R1AjN9X3^OlJa0Q27Q1AjN9W34oL2P1AjN9W34oL1Q1BiN:aN[OU4f0bM2P1BhN=\\NXOJ2_4d0cM2R1CRNGVOi0G]O[4=eMNlM^OW3:oMS1kNoN[43mM5Q1FlMe1U3_NoM4R1HiMg1T3^NPN2U1IeMj1U3[NQN1V1J_MP2Y3UNRN1V1J^MQ2Z3TNQN2W1I\\MS2[3RNSN2V1I]MS2Y3SNRN2X1G]MU2X3SNRN3X1E]MV2X3SNSN1Y1E]MW2W3RNSN3Y1D\\MY2W3PNTN2Z1EZMZ2X3oMSN4Z1C[MZ2X3oMSN3[1C[M[2V3PNTN2[1CZM]2V3nMTN3\\1BZM^2T3nMUN4\\1_O[M`2T3mMUN6Z1]O]Ma2S3XMRLc0R2:Z1ZO_Ma2S3XMRLc0Q2=Y1VOaMc2U3kMPN=Y1POfMh2R3kMoM>Y2i1DUMTLd0o1?W2i1EVMTLb0o1a0W2g1GkMQN?W2g1HjMPN`0W2g1IiMoM`0X2h1IhMoM`0W2h1KgMnMa0W2i1HPMVLf0k1a0W2i1HQMVLd0j1b0X2j1IgMnM?`1iN]MR3U3fMmM?b1iN[MS3V3eMmM>c1kNYMQ3X3fMkM>e1lNVMQ3Z3eMkM=f1mNTMQ3\\3eMiM=h1nNPMR3\\3eMlM;i1nNnLS3\\3dMmM;j1oNkLR3a3aMjM>k1POhLR3c3_MkM=l1ROfLQ3d3`MiM>m1ROdLQ3f3^MjM>m1TObLo2h3_MhM?n1SOaLP3i3^MgM?P2VO\\Lm2n3]MfMa0P2VO[Ll2l3`MiM=Q2a26QMiM?Q2_27RMgM?S2^27RMgM`0R2^27QMgMa0S2]24^LTLc0e1b0T2\\23aLSL`0f1c0U2\\22TMiM`0V2[21TMkM`0U2\\20SMkMa0V2[20QMmMc0T2\\2ORMkMa0X2\\2MTMjM`0Z2\\2KUMjM?\\2[2KVMhM`0]2Y2LWMgM`0]2Y2KXMhM>^2Y2KYMeM?a2X2JYMeM?a2X2IZMeM>c2W2I[McM>e2W2H[McM>e2V2H]McMh2T2H]M`M?i2S2H^M^M>l2T2E`M^M:o2U2DbM[M6U3W2BbMYM1[3]2\\OcMWM0^3\\2\\OdMUMOa3\\2[OeMSM0b3[2[OeMRM2b3X2]OfMQM1c3Y2ZOnLlKh0W11c3Y2ZOgMTM0b3X2[OhMSM0b3X2[OhMPM3e3T2\\OiMnL4f3S2\\OiMnL3g3T2[OhMnL5g3S2YOPMlKh0T15g3R2ZOkMnL4h3Q2ZOkMmL4j3P2ZOkMlL7i3m1[OmMkL8i3k1\\OlMlL9h3j1]OlMkL;h3i1[OTMlKg0P1=i3g1\\OnMlL;h3g1\\OnMkLW1d0l3g1nNgMVMb0m3g1lNfMXMb0n3i1iNfMWMa0Q4i1hNfMWM`0R4j1gNfMVM?U4k1dNgMVM?V4j1cNiMUM=Y4i1cNjMTM=Y4i1cNjMSM=[4h1cNkMRM=[4f1eNmMoL=]4d1eNPNmL=^4b1eNRNlL<`4a1eNSNkL<`4_1gNUNiL;a4c0aJUOV4NhL9b4c0aJUOV4NeL[JYOn3^OhKd0j07V5<[J\\Om3]OhKd0i07Y58\\J_Om32^L6[54]JEg3]OiKd0h05^50]JJd3^OhKc0h06e5FZJ2c33]L7k5\\OWJ;a32\\L8o5VOVJ`0_32]L6n6IeL1]L6n6IbL\\OjKe0f06n6IaL]OkKd0b0[O_Ok0b7JbL4\\LXO@i0c7KaL5ZLXOBh0c7L_L4]LXO@i0d7K_LDmK2a0F_Oi0c7L_LDnLGPOh0c7N_LClLc0h6J[LDlL`0m6KWLEkL>Q7MTLDlL;V7OmKGmL5]72fKIlL6_70dKKkL7b7NbKKkL8c7MaKLmL7c7K`KMnL8h5\\O]IOe1>W20oL7h5_OSK9V21nL8h5@SK7W21nL7i5BRK6U22PM6i5BRK6U22lLA[Oe0b6CRKHZN;j33nL;l5_ORKH[N;h33PM:k5ATK2P25PM8l5BSK2o16QM6m5BRK3P26PM5n5CRK2o17PMM[ODd66QK3P25QMNZODd66QK4P23QMN\\ODb68PK4m1@`Lb0e0M^OD`6:oJ3n1@`Lb0e0LX6OeJ3m15WM@[ONn6:dJ2m15VM@a6:[J1n15VM@a6;ZJ1l1@bLc0h0B_6:[J1l1@bLc0h0B_6:[J1k1AcLb0h0B_6:\\J0k15[MA^6;[J0k14\\MB]6;[JOl14\\MB]6<[JMi1AgLd0h0B]6=ZJLi1BhLc0i0B[6<\\JNg1AhLe0i0@\\6<]JMe1;bM\\O\\6<]JMd1=bM[O\\6<]JMd1_JK]1c0jMTOZ6>_JL[1c0lMTOY6;nH^Ob1`0Z1e0lMROZ6;cJMV1g0YMoN92e6:dJNU1V1^MbNi69eJOR1]1[M[Nn69eJOQ1b1ZMTNP7;eJOP1g1[MkMP7?fJNj0D^MY2S7UNeJOg0V2`4kMiJNf0]2]4fMmJLf0b2Y4bMQKKf0h2U4]MUKJg0m2P4YMZKIc0U3o3RM^KJ>Z3R4lL`KJ;^3T4hLbKI6d3W4dLbKH2j3[4^LcKINm3^4ZLdKILo3`4XL]K01k3a4UL]K10m3b4RL^K2Mn3e4QL]K1LQ4f4oK\\K1MR4f4PLZKNNT4h4nKYKNNW4h4jK[KOKY4j4gK[K1I[4k4cK]K2F]4m4aKaKJaNBP1U5n4_KfKD^Oo4l4]KQMf4n2ZKQMg4o2YKoLi4Q3VKnLl4R3UKkLm4U3PKlLS5S3jJnLX5R3hJlLZ5T3fJjL\\5V3dJiL]5W3cJgL]5[3cJcL]5_3cJ_L]5c3cJ[L]5g3cJWL]5k3cJSL]5o3cJoK]5S4cJlK\\5V4dJhK\\5Z4dJeK\\5\\4eJbKY5a4gJ^KX5d4hJZKX5h4hJWKW5k4iJTKW5m4jJQKU5Q5kJnJV5R5kJlJU5U5lJiJV5V5kJaI^Og0h5h5kJVI^O0NO3Q1h5i5YKVJh4j5XKUJi4k5WKTJj4l5WKQJk4o5UKPJl4P6TKoIm4Q6SKnIn4R6RKmIo4S6QKlIQ5S6PKkIQ5U6oJkIQ5U6oJjIY5o5gJQJY5o5fJQJ[5o5eJQJ\\5n5cJSJ]5m5cJRJ^5n5aJSJ_5m5aJRJa5m5^JTJb5l5^JSJc5m5]JSJc5m5]JSJc5m5^JQJc5o5]JQJd5n5\\JQJf5n5ZJRJf5n5[JQJe5o5[JPJe5Q6[JoIe5Q6ZJoIg5Q6YJoIg5Q6XJoIh5R6WJoIi5Q6VJPJj5P6VJoIk5Q6UJoIk5Q6UJnIl5R6TJnIl5R6TJnIl5R6TJoIl5P6TJQJk5o5UJRJj5n5VJRJj5n5VJSJj5l5VJUJi5k5WJVJh5j5XJVJg5k5YJVJf5j5[JVJd5j5\\JWJb5j5_JUJb5j5^JWJa5i5_JXJ`5h5`JYJ_5g5aJYJ`5f5`J[J_5e5aJ\\J^5d5bJ]J^5b5bJ^J^5b5cJ^J\\5b5dJ_JZ5b5fJ_JZ5`5fJ`JZ5`5fJaJY5_5gJbJY5]5gJdJX5\\5hJfJX5X5hJkJW5S5jJoJV5n4kJRKV5l4jJTKW5k4jJTKX5j4iJVKW5i4iJWKW5i4jJWKV5h4kJWKU5i4kJWKV5h4kJWKU5i4lJVKT5j4lJVKT5j4mJUKT5j4mJTKT5l4mJSKS5m4PKPK`NSO]6m5UKnJ]NVO0O\\6m5XKRKh4n4ZKQKd4P5\\KPKd4P5\\KPKd4P5\\KQKb4P5^KPKb4P5^KQK`4P5aKoJ_4Q5aKoJ_4Q5aKPK_4o4aKQK_4o4bKPK_4o4aKQK_4o4bKPK^4P5bKPK^4P5cKPK\\4P5fKnJ[4Q5fKnJZ4R5jKkJU4U5TLbJn3\\5RLfJk3[5ULbJn3^5RLbJn3^5RLbJP4\\5PLeJn3\\5QLeJn3\\5RLdJo3[5QLeJo3[5QLeJP4Z5PLfJP4Z5PLfJP4Z5QLfJm3[5SLeJm3[5SLeJm3[5TLdJm3[5SLeJm3[5oKWJjM>X6Z5lK[JkM2M4H5O30O01N101O000O101O001O0O101O01O010O1O1O01O0O11O01O00001O00001TB[OZ=g0aBXOJ2P=0\\Ci0G]Ol0O1O100O1O100O100O100O100O1O100O10000O100O100O1O100O1O100O1O100O10000O100O1000000O100O1O100O100O10000O10000O1000000001O0000001O00000000O100O1N2N2O1O1N2SOcCUO_E`A;b>001N110N101O1O0001O0001O0001O01O01O00010O00010O0001O01O0001O01O000000001O01OO2O0O1O2O01O01O0001O0I7O101O0O100O010O1004HeABa>8igh4", "size": [480, 640]}, "area": 14917.0, "iscrowd": 0, "image_id": 12667, "bbox": [53.0, 0.0, 261.0, 125.0], "category_id": 132, "id": 20000752}, {"segmentation": {"counts": "nfm62m>1N2N2O1O1N2O1O1N2N2O1O1N2N2O1N2N2O1N2O1O1N2N2O1O1N2N2O1N2O1N2N2O1N2O1N2O1N2N2O1N2O1O1N2N2O1O1N2M3O1O1M3N2001OO1N23MO1O100E\\MXDOKd2l;dMSD_2k;S9nNnDd0o1?Q9oNoDb0o1a0R9BmF?S9AlF`0T9@kF`0V9@jF`0V9_OjFa0T9iNQEf0k1a0T9jNQEd0j1b0W9AhF?Y9AfF?[9AeF>\\9BcF>^9BbF=_9C`F=^9EbF;^9EbF;a9B_F>b9A_F=c9C\\F>d9A]F>d9B[F?e9AZF?g9@YFa0d9B\\F=e9B[F?e9AZF?g9@ZF`0f9_OZFa0d9kNgDc0e1b0d9mNfD`0f1c0e9@[F`0e9_O]F`0d9_O\\Fa0e9\\O^Fc0c9^O[Fa0f9@YF`0g9AXF?i9AVF`0j9@VF`0i9AWF>j9BTF?m9ASF?l9BSF>n9BQF>P:BPF>o9CQFR:AnE?S:AlE>U:DjE:X:GfE6_:IaE1e:0YE0h:0WEOk:1TE0l:0SE2l:NTE1k:WOnCh0W11k:0VE0j:0VE0j:0SE3m:MRE4n:LRE3o:LQE5m:SOoCh0T15m:MRE4n:LQE4P;KPE7n:JQE8n:GSE9m:FSE;k:mNTDg0P1=l:EUE;k:ETEW1d0i:^OWEb0i:]OXEb0j:_OTEa0m:_OSE`0n:@QE?P;BoD?P;CnD=S;CmD=S;ClD=U;CkD=U;CjD=V;DiD=V;DiDl;AUD;n;FRD5SkCNZODl<=jCN\\ODg`CB]13M5K4L5K2N1O2MYic02fV\\O4L6J5K6J5K5K5K5K5K5K5K5K6J5K5K01N1O1O010MnCXMShB@Z=`0c000O1001O1OO1O1O1N2N2N20000K\\AMe>3\\ALe>3\\ALd>44O10000000001MTA0n>0Pk7", "size": [480, 640]}, "area": 53973.0, "iscrowd": 0, "image_id": 12667, "bbox": [0.0, 80.0, 623.0, 306.0], "category_id": 143, "id": 20000754}, {"segmentation": {"counts": "0o0Q>00000000O10000000000O10000O1000000O10000O10000O100000000000000O1000000O1000000O100O11O00O100000000O10000000000O100000000O100000000O1000000O100000000O100000000O1000000O1000000O1000000000000000000O100O1000000O10000O10000O1KU`g7", "size": [480, 640]}, "area": 2173.0, "iscrowd": 0, "image_id": 12667, "bbox": [0.0, 0.0, 112.0, 31.0], "category_id": 172, "id": 20000755}, {"segmentation": {"counts": "Q[U46e>9G:F9F:G9G9G9G9G9G9G9G7H7J6J6L3N3M3M2N3M3N1N3M3M2N2N2N3M2N2O1N3M2N2N2N3M2N2OO000000000001O01O001O1O1O001O1O1O1M3L4L4L4L4L4L4L3M4L4L4L4L4L4L5K4L5L3O2N2O0O2N1O2N1O2N2N1O2N1O2N2N1O2N1O2N101N2N1O2N1O2N2N3M3M3M2N3M3M3N1O2N2N2N1O2M3O1O010O1O10O01O100O00100O1O3M3M2N1O00001O001O00001O001O00001O001O001O0O101O001O00001N101O0N2O2M2OV\\j2", "size": [480, 640]}, "area": 14715.0, "iscrowd": 0, "image_id": 12667, "bbox": [284.0, 49.0, 163.0, 241.0], "category_id": 183, "id": 20000756}, {"segmentation": {"counts": "0n0^<00000000001O002NIkCXOTbFB]9>dFBh7LUHb05Bd7LlFMX1e09Bk7JiGc0>Ci7LeGa0d0Ch7MgF868\\1Ch7`1ZH`Nf7_1[HaNe7]1]HcNc7[1_HeN`7[1aHeN_7X1dHhN\\7V1fHjNY7T1jHlNS7U1oHkNn6U1UIkNQ7m0QISOV7d0mH[O`75cHK_:0000000000000000000000000000000000000003M2NWh30iWL2N2N1O00000000000000000000000001O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000L]=0eB101N1ecl1O]\\SN2N0000000aNLfE4Y:4`EL`:;YEEg:b0RE^On:8^DO=IU;5cD71D[;4hD=F_Ob9OVH2hNf0S9HdG_O]Oh0o8;RGkN1j0V9d0SG[OP9d0nF\\OV9=nFBU99nFFV93mFMV9MnF2U9ImF7W9BmF=V9]OmFc0o:O001O001O001O1O001O001O001O001O000000000000O100000000M31O1O1O1O2N001O1O1O1O1O001O1O1O1O001OjXf14WZYNNZIT;=dDH:LR;;dDG0000000001O0000001O001O001O001N00O3O0O1N2O100O100O1O10000O10000O10O10000000000000000000000000001O0O10001O001O001O001O1O010O1O1O1O1O1O1O1O2N2N1O1O1O2N0000F:0001O0O6POaC40?j\\9BeF=[9CfFJk3V7hKkH`0Oh3W7^11O001O1O1O1O2N2N2N2N1OO100O100O100N2O1O1N2O1O1N2O1O1O1O1OWJQIW5n6fJYIW5e6hJ`IS3@eNo6UNhIS3ZOmL2_1k6^NoIT3SORM3Z1j6]NUJU3oNUM2X1P8a1nGYM2T1Q8b1lG]M3o0R8b1lG`M2m0T8a1jGdM2i0U8b1iGgM2e0W8b1gGjM2c0Y8`1fGoM1?e8V1ZG]N1;e8X1ZG^N19f8X1YGaN1\\O1;f8f1YGeN0TON536g8k1XG\\O2cNg8P2WGC2WNh8U2VGIm87PGOi8`2I3M3M3M3L4N2N2N2N2N2N2O1O2M2O1O1O1O1O100O100O100O100O100O100O100O10000O10000O10000000000eNQKYJo4e5UKYJk4f5WKYJi4f5YKYJg4f5ZKZJf4e5[K[Je4e5[K[Je4d5\\K\\Jd4c5]K]Jc4b5^K^Jb4b5^K^Jb4a5_K_Ja4`5`K`J`4_5aKaJ_4_5aKaJ_4^5bKcJ]4\\5dKdJ\\4S5nKlJR4o4X2N2N2N2NWJYKQ3W4YJTLi2El2Q4kJoK\\21f2o3QNQLm1n3VNSLg1m3\\NSLa1l3cNSL[1l3iNTLT1k3oNULo0j3UOVL?S4DmKO0kKR4Y4nKA0oK3:n3Z4oKRO4^LM8o3\\4oKiN5eLK:P4[4PLaN3`Ml3R4RLXN1jMl3R4RLPN1QNm3R4RLPOn3f3WL_Ii3P4RLmL`2YOXO^3YNQMO7`2]OXOT3XN^M1O^2CXOk2YNgM2I]2HWOb2\\NQNOD^2LVOZ2^NYNO_O\\21WOQ2`NbNNZOl1bN]NZ2b0d3UO^KNfNf12cN^2>[3\\O[KMlNe13aNe2:P3DXKMQOb16aNj25g2KUKMUO`19aNk24a2ORKNYO]1<_Nm25[22oJN^OZ1S4dN`1NbK]1R3dNj2[1[McNc2]1HcNmM]1R2cNoM]1P2cNQN]1o600000000000TJhNDX1:hNHX19iNEW1Hh4W1lJG\\1S2bNWM?Hg4W1lJHY1n1kNYM;Kd4W1lJGX1P2mNUM=Mb4W1kJIV1l1VOTM71b4]2nK;7XMSONV4_2^L5mN_M_1Nh3_2iK6e0[MoNOl3`2^LOQ1bMW3`2eKKY1eMR3a2bKJW1jMPNJW5b2aKHY1PNV3Y2_KF[1SNV3X2^KDY1jMFOZ2c2fLEX1hMM3P2a2iLDY1iM22i1a2kLDi0hMiN130m11`1f2iLAk0hMQONK2U21X1j2gL]OP1gMXO0m12Q1m2gLZOS1fMk138\\5mMaJ[5_5dJaJ]5^5dJbJV50gI^5R1cJW5OgI^5R1bJX50fI^5R1bJX50fI]5R1dJX5OfI]5R1cJY50eI]5R1cJm20WN0jM\\5S1dJk21XNOjMV40jLW5ROnLNkMR45mL_7QO\\HQ46nL^7QO\\Ho37QM]7PO\\Hn38RM\\7PO\\Hm2LPN>3i0PO^5j2`IPN88j0nNi20cNg2fMQN3oNd1Y3kMjMa0jNe1^3iMiM`0iNg1`3gMkM?cNk1e3cMkM?`Nn1g3aMjMa0^Nn1k3^MiMb0\\NP2g4bLPM\\1YNQ2o4\\LgLc1ZNQ2W5TL_Lk1ZNQ2T7QNlHn1T7RNlHn1T7U2O100O10000O10000O11O001O1O1O1O1O001O1O1O1OERJXIP6e6RJ[IP6b5lIUK6XOn5`5PJUK4[Oj5_5VJSK3]Of5^5[JRK1_Od5]5_JRKNA]5MWJ^5b0QKMCY5_5nJkJKFV5^5QKjJLGR5]5VKiJJIP5]5YKhJIJm4]5]KfJIMh4]5aKcJP44SLX5V5oJcJQ5]5VK\\Ji4c1eJa1j0eLa4l1eJ]1=WL19l4U2fJZ1:]L8Nh4]2fJV18cL?Cb4f2gJSO:KKoNj5U2QJoNl0[OVOEk5l3`KlKdN:l5S2SJROc1oNY4R4aKQL_4o1TJSOV1ROe4R4VKPLk4S4nJQLQ5R4iJQLW5R4dJQL[5S4^JPLc5c1UJWO2ZOh5`1VJQ1i5POXJn0i5ROVJo0i5ROWJm0i5\\30O01O0010O01O`J^JV3c5fLdJW3[5fLkJX3T5eLRKX3o4dLXKXOQOR3f5cM_KYOlNQ3g5`MfK\\OcNS3l5XMhKD\\NR3Q6PMlKKTNS3U6iLoK0mMV3Y6`LSL7eMW3T9dLmF[3W9bLjF\\3Z9`LhF^3d9O2\\NSFVO^:h0eEeNLNc:[1dEcNMLe:_1aEaNLLh:`1`E_Nm:_1a0N3M3N2M3N2M3N3L4L4Doj4GbUK2N3N2M3M3N2M3ZOf0L4M3M2M4Mg0XO4M2G`McEb2V:dMhE`2U:`MkE`2V:_MjE`2W:91O2O0O100ZMeE[2j9`MdF4CZ2k9jMYFMLX2l9ZNTFd1n9\\NRFc1S:YNmEe1[:UNdEk1c:oM]Eo1e0hM[96PFQ2d0kM^92nEQ2d0oMa9MkET2b0PNh9Q2UFPNl9Q2QFPNP:Q2mEPNS:Q2kEPNV:Q2gEPNZ:Q2cEPN^:_20OkNWMjGi2U8WMmGg2S8ZMmGe2S8[MoGc2Q8^MoGa2R8^MPH`2P8aMQH]2a4`MaM2oM]2k3gMSKMS30PNZ2d3RNRKH[3KPNZ2_3bNcNTOoMY2Y3gNiNPObM4QOT2`4lNnNnNRM>Bf1]4nNPOQOfLc0O\\1Z4\\NGFgKi09]O2l0V4WOLh0iLO[3WOOi0gLOY3XO2i0fLMX3XO5i0fLMT3[O5i0hLKS3[O7i0hLKo2]O:f0jLKl2^O=e0SMA_2K`0a0S2_OQNU5YOV16gI`0R5ZO[1OgIg0m4ZOm1e0RN[OP2d0oM\\OS2c0lM]OV2b0hM_OY2a0eM@]2?aMBc2;ZMFl25SMKU3OiL1]3KaL5d3HZL8\\80O100N2O03M3L5Kgf0", "size": [428, 640]}, "area": 120237.0, "iscrowd": 0, "image_id": 12670, "bbox": [0.0, 40.0, 638.0, 388.0], "category_id": 183, "id": 20000763}, {"segmentation": {"counts": "PTh22nc02N2N2N3M2N2N2N2N1O2N1O2N2N2N3M2N2N2N2N2N2N2N2N1O1O000000O1000[^O`Nj`0`1U_ObNBNl`0a1a_OaN@2n`0\\1b_OcNZON24Qa0\\1a_OcN[ON43o`0]1__OdN^OO11Qa0^1[_O]NCe0Ra0P1U_OXOj`0i0S_OXOn`0g0R_OZOn`0e0R_O[Oo`0k100000000000000000001O7I4U_OiLe`0]3L1O5K2N4L1O2N1O00001O001O00001O2N2^@nKR?U4i@oKU?S4h@PLV?_4N2N2N1O2N1O00000000001O0000000000000[AoJ[>Q5`AoJM2d>o4_ARKb>n4]ARKd>o4ZAQKg>S51O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O100O100O100O100O1O100O100O100O1O100O100O100O1000000000000001O000000000000001O0000000000001O1O2N1O1O2N1O1O2N1O1O2N1O1O2N1O1O2N1O1O2N1OL]AlJb>S5`AnJ^>R581OO10000000000O10000[OVASLk>k3XATLh>j3[AULe>h3^AULFFk>S4bAULc>h3aARLd>l3_AQLc>m3i0O1N2N2N2N2M3N2M3O1N2N2N2N2N2M3N2M3O1Lk^O[MWa0e22O11O1O1O001O001O001O1O000000N2M3O1N2N2O1N2N2N2dN]^O9ea0E]^O:da0C_^O;ca0Ba^O;aa0Ca^O;aa0Ca^O;aa0Cb^O;_a0Cc^O;_a0Be^O;]a0Ce^O<\\a0Ah^O\\b0O1O2I_\\OJec036Mi^_1", "size": [640, 480]}, "area": 29638.0, "iscrowd": 0, "image_id": 12748, "bbox": [141.0, 0.0, 263.0, 173.0], "category_id": 102, "id": 20000764}, {"segmentation": {"counts": "]`Z45gc01Z\\ONbc0Nd\\O2ec00O100O1000O0100O10000O100O010O01000O010O10O10O010O10O010O1O00bC4j4KZK3d4M]K3c4M]K3c4L^K4a4L`K4`4KaK5^4KcK5]4JdK6\\4IeK7Z4IgK7Y4HhK8W4IiK7W4HjK8U4HlK8T4HlK8n;00000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000SNIQ@7n?JR@6n?JR@6m?JT@6l?JT@6l?JT@6k?KU@3TNKga01V@4k?MU@2l?NT@2k?OU@1k?NV@2j?NV@2i?OW@1i?NX@2g?OY@0h?0X@0h?0X@0g?0Z@0f?0Z@0e?1[@Oe?1[@Od?1]@Oc?1]@Oc?0^@0a?1_@Oa?0c@M\\?4X2O010O10O010O0100O010O0100O0100O010O010O010O10O010O0mno0", "size": [640, 480]}, "area": 1616.0, "iscrowd": 0, "image_id": 12748, "bbox": [221.0, 381.0, 207.0, 259.0], "category_id": 105, "id": 20000765}, {"segmentation": {"counts": "ffg31nc03K5N2N2N20ON3M3N2N2O1N2N2O1?TO`\\OO05YlZ5", "size": [640, 480]}, "area": 270.0, "iscrowd": 0, "image_id": 12748, "bbox": [191.0, 338.0, 16.0, 34.0], "category_id": 112, "id": 20000766}, {"segmentation": {"counts": "QbQ25kc0b0^O6h\\OUO040K30M1^b0h1b]OWNSb0l1O2N01O000000O100000000000000000000O100001O00O1O11O1O1OFVN^^Oj1ea073M1OO1000000000000000000O100001OO1N2O1N2N21O00O13M00001OO1O1O11O0000000000001OO1001O0000001O001O0000O1000000000000000000O10000O11O00O1000000000000NiM[^OW2ea0200O100O1O1O100N2O1M300L4O1HZMT_Oh2l`0XMT_Oh2l`0XMT_Oh2l`06000000001OO1000000000000O100O100O100O1M3O100N21XOb_OlM``0l1T@fMm?T2S1I7J7H6K5J6J7J5J6K5J6JXcT4", "size": [640, 480]}, "area": 11569.0, "iscrowd": 0, "image_id": 12748, "bbox": [104.0, 533.0, 163.0, 107.0], "category_id": 116, "id": 20000767}, {"segmentation": {"counts": "\\UU371Kec0;M0O101OO1O1O02O000001O001O01M1O2O2N10000O2O0O2O000O01000O10000O100O1000O01000O02O00O0100O100O1N2OOQ]OSOmb0o002N1O2N1O1O101N0010N12NN30OJ]]OQOcb0Q1]]OoNbb0R1^]OnN`b0T151N2N2O1=D0N2O2N1O1O1O2N1N2O1N2O2M2O1N2L5M2O\\o]4", "size": [640, 480]}, "area": 2270.0, "iscrowd": 0, "image_id": 12748, "bbox": [161.0, 498.0, 91.0, 73.0], "category_id": 131, "id": 20000768}, {"segmentation": {"counts": "V[W73lc01N3M3M2O2M3M2M4N2M`0@2O2M2N2N2N2O2M2N2N2N2O2M4L:G3L5K200O1O1JWMR_Ol2l`05N2N2N2N2N2o_OeL[?]3a@hL\\?Z3a@jL[?Z3b@iL[?Z3_@kL_?k3O2N2N2N2N3N1N2N2N2O1O12Ne0UOU2lKZ^O099DG31MO0413]cQ1", "size": [640, 480]}, "area": 4889.0, "iscrowd": 0, "image_id": 12748, "bbox": [370.0, 4.0, 57.0, 162.0], "category_id": 157, "id": 20000769}, {"segmentation": {"counts": "V]Y63lc02O4M0N3N1O1O2N1O3e]O^OQa0f0i^O\\OXa0h0b^OYO_a0j0[^OXOea0l0V^OVOja0m0P^OUOQb0n0j]OSOTb0Em]Od1Sb04L4O2N100O100O2O0OnMV^OQ2ia0300O1O2N1O10000O2O0N2O1O1O1O2N1O1O1O101N22N0O2O1O001O1O001O1O>A101O000000001O0O1000001O2N8H2N3M0O10000000000000000O1UO_]O7ab0Ed]O;[b0Bi]O=Xb0@k]O?Vb0[Oo]Oe0eb0101O000001O01O0000002N1O24SOj\\Oe0_c0K001L_\\ODac0;6EY\\O3iQo0", "size": [640, 480]}, "area": 5648.0, "iscrowd": 0, "image_id": 12748, "bbox": [322.0, 103.0, 109.0, 120.0], "category_id": 169, "id": 20000770}, {"segmentation": {"counts": "0c4W7V80TDSIe:U8O0F:O100O10000O100O100O101O0O100O10000O100O101O0O100O100O10000O100O1O1N2N2N2N3M3M3M3M3L4M3M3M3M3M3M3M3M3M3M3M3M3N1N3M3N2M3N2M3N2M3N2M3M3N2M3N2M3N2MPDmHX;o7O001N2O1O001O1O1O0dEdGS9]8gFgGZ9Z8_FkGb9V8XFoGh9Q8SFSHn9n7kEWHV:i81O100O1O1O100O001O1VGlE^OBU8c:YH]EAT1d7`9jHhFP7Y9oHgF:UO\\5V:YJeF;Gj4e9iJeF>KXOiN040K30M1f4i:aKeF`0g0YOjM[4k:jKeFa0j0c3c8kKcFa0m0b3a8kKcFb0m0b3b8jKbFd0l0b3W:\\LjEc3W:\\LjEc3W:\\LjEd3X:YLiEf3Y:YLgEg3[:nKSC5c2l3`:PLbEP4^:oKcEP4W=00O10SARLh=m3WBXLf=h3YB\\Ld=c3\\B`Lb=^3^BgL_=W3bBmL[=Q3fBSMW=k2jBYMS=d2nBaMo<]2RCgMkT=^OfBl0Z=QO_BX1c=c20O100O10O010O0100O101N100O100O100O100O01O0O?A1O1N1000RJiBS5W=lJkBBNV5W=WKkB@2X5R=XKmBZON24\\5Q=VKnB[ON43X269lh=CYB:h=GYB6h=LgBBZ=?UC[NYNOc>g1lCUNUTOZELdLh0X>[OPE3hL;^>@lDP1Z;kNUAMe3R1[;QOcC9RNf0\\>POiC4iMn0_>lNbCVa0Fb^O<_a0A`^O]OHP1ha0D`^O^OFn0ha0G_^O>ca0EX^O;fAHY>Q3O1O1O0OO3K304L1O11NO2N2O1O10L31O01O0000O20OOONPAXKm>i46Ho@^KT?Z4>N1N2N2O2N2O1aLU@f2l?RM]@n2c?jLf@S3U`0O2M3L3N3N1N3Gg^OgMZa0R2l^OnMVa0Y1d^OVO7CTa0k0n_OUOS`0j0c1M3G94KH9O13MD<00O1M2M^Pb4", "size": [640, 480]}, "area": 7871.0, "iscrowd": 0, "image_id": 12748, "bbox": [167.0, 157.0, 79.0, 185.0], "category_id": 181, "id": 20000774}, {"segmentation": {"counts": "gP1:b`0T3lLT3jMV2O100O101O0O100O100O10000O100O10000O2O0O10000O100O100O10000O100O2N1N2N2N2N3M3M3M3M3L4M3M3M3M3M3M3M3M3M3M3M3M2O2M3M3N2M3N2M3N2M3N2M3M3N2M3N2M3N2MhCUI`;g7O0O2O1O1O001O1O1fEbGo8^8lFfGU9[8dFjG]9W8]FmGd9T8UFRHk9n7PFVHQ:k7hEZHY:f81O100O1O1O100O001O1O1O1O1N2O1N2O1N2O1N2O1N2N2O1N2O1N2O0O2O1NcEaG\\9^8bFgG\\9W8dFmGZ9R8eFQHZ9m7eFXHY9e7hF_HV9^7kFfHS9W7nFmHP9P7PGUIn8g6TG]Ij8`6WGdIg8Y6ZGjIe8S6[GRJc8k5^GYJ`8d5aG_J_8]5aGgJ`8T5ZGUKh8f4RGdKo8W4kFRLW9i3cFaL]9[3^FmLd9n2VF\\Mk9\\62O1N01N101N101N2O0O2O001N101N101N101N101O0O7Ja0^Ob0_O9F2O1N2O1N2O1O1L4L4L3O2M3N2N2M3N2N2M3N2N2M3N2M3N2N2M3N2N2M3N2N2M3N2M3N1O2M3N2N2M3M3L4L4L4L4L4M3L4L4L4L4LjI_LSL^3f3kLVLDRJ]3c9XMSL@[JW3`9]MnKBbJo2a9bMeKDkJh2a9gM\\KGSKa2a9jMUKKZKY2b9oMlJMcKR2b9SNdJ1iKl1c9VN[J4SLd1c9ZNSJ8ZL]1c9^NkI;bLU1d9bNcI>jLn0d9gNZIa0RMW1T9[NcIb0ZMT1Q9]NbI`0]MT1o8_NbI=^MV1n8_NbI;aMX1j8`NbI9cMY1i8aNbI5fM[OJ8l8;aI3iM[OH9l8bN\\4h1PL[NWOdN0h26gNb4d1oKZNYOcN0h20mNh4_1nKXNZOdN0b5g4dMmKWN[OdN1a5g4eMlKUN]OdN0c5f4fMkKTN^OdN1b5e4gMlKRN^OeN1c5e4gMjKRN@dN1c5d4iMjKSOCT3c4jMhKSODT3c4kMgKQOGT3b4lMfKPOGU3b4mMeKnNJU3a4nMdKmNKU3a4nMcKmNLV3a4nMbKlNMV3a4oM`KlNNV3b4oM^KkN1V3a4PN]KjN1W3b4c1_K]Nb4b1^K^Nb4b1]K_Nc4`1^K`Nb4`1]KaNc4^1^KbNb4^1]KcNc4]1]KcNc4\\1^KdNc4[1\\KfNd4Y1]KgNc4Y1\\KhNd4X1\\KhNd4W1]KiNc4W1\\KjNd4U1]KkNd4T1[KmNf4R1ZKnNh4o0XKROi4m0WKSOj4k0WKUOk4i0TKXOm4f0TKZOm4e0RK\\OP5b0PK^OQ5`0PK@Q5?nJBT5;mJET5:kJGV58jJHX55hJLY53gJMZ51gJO[5hNcJVK1S6]5eNbJYK1R6^5cNbJZK0T6`5_N`J^K0S6a5PK^JR12jM0T6a5mJcJP1MoMNU6d5gJiJo0EVNNT6e5dJnJm0_O[NNU6f5_JmJS1_OZNNT6h5[JaJnNHk11iNNT6i5VJWJA2W10oNNS6j5]KZJ\\ONUONR6l5^KYJVOL[OOR6n5iIRJ<78JBOQ6Q6cIQJe070HGOR6T6\\IPJl2LhM0P6X6VImIR3KiM0o5[6PIlIX3IiM0P6^6jHkIY2G^NOa01n5a6dHjIa2GXNMe01o5Q7VKRIGMS5P7XKTImMKo00m5P7YKVI^OKY5n6[KXIZOJ[5n6\\KYIVOI_5m6]K[IROHa5l6_K]InNFd5l6`K_IiNFg5j6bK^IhNHf5j6bK\\IiNJ90S3i6mM[IhNLe5h6eKYIgNOe5g6iMYIW2f6jMYIX2e6hM\\IaJ5_7_6PNbIR2]6nMbIT2]6mMaIU2^6lM`IV2_6jMaIW2_6iM_IY2`6d5OYKaIoK^6S4bIlK]6V4cIiK\\6Y4dIfK\\6Z4eIeKZ6]4fIbKY6`4fI`KY6b4gI]KX6d4iI[KW6f4iIYKW6h4iIWKW6i4jIVKU6l4kISKU6n4kIQKU6P5kIQINAW6^7lIPINAV6`7lInHNBV6a7kIlH0CU6a7lIkHNEV6a7kIiH0FU6b7iIiH2ET6k9mIUFS6k9lIVFT6j9lIVFT6i9mIWFS6i9mIWFS6h9mIYFS6g9mIYFS6f9nIZFQ6\\7kIoH3FR6f9nIZFR6e9oI[FQ6e9oI[FQ6X7kISI4FQ6V7kIUI4EQ6U7kIWI4DQ6T7lIWI4EP6S7lIYI3EP6S7lIXI5Eo5a9PJ`FP6_9QJaFo5_9PJbFP6^9PJbFP6Q7mIUI3KP6P7RJPIN0P6P7RJoHN2P6Z9PJfFo5Z9QJgFo5Y9QJgFP6X9oIiFQ6V9PJjFP6^7lIQH3b0Q6]7mIoG3d0P6]7nInG1f0R6]7lIkG3h0Q6_7kIhG4i0Q6Q9nIPGR6f0kIW54SJQ6d0mIY51TJS6a0mIZ51UJR6`0oIZ5NWJS6>PJ[5MWJS6=nI^5OVJU69lIb5OUJV67jIe50UJX63hIi50TJY61gIh4NiI2_1[6MdIl41gI0`1]6JbIP52eINb1_6GaIR52ZL_6aN^IW52YLa6^N]IY52ZLc6ZN[I\\52\\Lc6VN[I_51\\Lf6QN[Ib5OZJOInAh13^NR>JkA2`0IC:U>JhAYO[1`0iN[EBe:>T10000000000001OK6I7N2N]ij1", "size": [427, 640]}, "area": 11505.0, "iscrowd": 0, "image_id": 13177, "bbox": [151.0, 0.0, 348.0, 66.0], "category_id": 113, "id": 20000779}, {"segmentation": {"counts": "Pj[2111T=5M2N2M4M2N3M2N2N2O1N2O1N102M2lJnNnMR1S2POiMR1W2oNgMR1Z2nNcMT1_2lN^MV1c2iNZMY1h2gNUMZ1k2gNRM[1eKbNW73RMa1l2aNPMb1o2_NoLb1Q3`NkLa1W3_NgLb1Y3_NdLc1\\3_NaLb1_3_N^Lc1b3_N[Lb1d3`NYLb1g3_NWLb1h3aNUL`1k3aNRLa1n3aNoK`1Q4aNlK[1PMnMV7h0hKZ1]4hN_KV1d4lNZKP1k4ROQKP1o4QOoJR1o4oNnJT1Q5nNlJT1T5lNiJU1X5mNeJT1[5mNbJT1_5mN_JT1a5nN[JT1e5mNYJT1g5mNVJX1XN]M]7\\1XJ[1g5gNVJZ1j5iNSJY1l5hNQJZ1o5gNnI[1Q6hN`Ie1`6\\NQIR2o6V2O1O0O1000O01G90000000000000O11O0QIfI01j6Y6VIfI11h6[6WIfIi6^60000000KXIgIh6Y6XIfIi6Z6WIfIi6X6YIgIh6Y6XIgIh6Y6XIgIl69VI[5m6]J`Ia5V7O2N1O2M2N3M3N1O2M2O2N101O001N20OO10_GWK^8k4001O000O101O0O101O000O0jNaGRMLMb8m2jGQMG1_8l2oGnLF2IGa8Z3aHlLb7U3`HhLa7W3aHhL^7Y3Y110O01O010O10O01O10O01O001N2O001O001O1O001O1O001N101O1O001O1O001N101O1N101O0O2O1O0O2001N2O1N2O1O1N2O0O10000O100O1O1N2O0O100O010ON31N2O2M3N2N2M2O2M3H8ZOf0[Oe0E;N2O1O0O2O1O1N2O1O1O1N2O1O0O2O1O1N2O1O1N2O1O1O0O2O1O1N2O1O1N2O1Oa\\l2", "size": [427, 640]}, "area": 25959.0, "iscrowd": 0, "image_id": 13177, "bbox": [181.0, 147.0, 237.0, 211.0], "category_id": 115, "id": 20000780}, {"segmentation": {"counts": "XnQ3334j<8TCBX<4SD36i;OUD2k;f02O000O10O10000000N2001O1O0RDhNh;_10OXD`Ne;0ZD01_1OaNc;0]D11`1O_Nb;0`Dc1d;00O1000K_N`Da1`;_N_Dc1`;]N`Dd1];^NbDc1^;]NbDd1];\\NcDd1\\;600000M30O001O10000O101OO200O1O002N001WN_Df1c;00001O0O10000O10001O0O1@UN`Ek1^:XNaEh1]:\\N_EIGk1e:bNaEb1a:^N\\Ec1g:[NXEe1k:=0O1O001O001O001O001O10O01O001O001O001O001O00100O001O001O001O001O001O001O001O1O0000001O0000001O0000010O0O11O00O2O01OO101O0000001O0000001O000000001O0000001O0000001O000000001O0000001O0000TDcNj;_11N100000001O0000010O01O00NTDfNl;W1VDiNj;V16000001O0O10001N10001O0O2O001O001O0O2O001O0O2O0O2O0O2O1N101N1O2M2N3O001O010O010O010O0010O010O10O10O10O010O0O2O010NXS7JnlH2jBNP=71O05L2QCDiKJo7o0]HTOZOE05532K6=JKQ8m0\\H^O@EOK7;KMQ8l0[H@_OD1O260MR8k0YHZ1ClMT8k0VHP2g7TNVHn1g7UNVHm1h7m1M2N3M3N1N3M3M2N3M3M3M3M4LnJ^I`3`6^LcIc3Z6XL_IlN8m4V6YLPJh3m5ZLSJh3j5YLVJh3i5WLXJj3g5ULZJl3e5RL]JP4a5oK`JR4_5nKaJS4]5oKbJR4]5mKdJT4[5iKoInNf0[5Y5fKkJ[4T5_KRKb4m4^KSKc4l4]KTKe4i4\\KWKe4h4ZKYKg4f4YKZKh4e4YKZKh4e4XK[Kj4c4UK^Kl4a4TK_Km4_4UK`Kl4_4SKbKo4\\4QKdKP5[4PKeKQ5Z4kJeJXOR1n5X4jJkKW5T4kJjKW5R4lJmKU5P4nJoKS5o3nJQLS5l3oJTLS5i3nJWLS5f3oJZLR5d3PK[LQ5b3QK^LP5`3PKaLR5[3QKdLP5Z3PKgLQ5V3QKjLP5T3RKkLP5Q3RKoLa1\\OKc3eNQMU1H6T3hNSMc08f0c2hNUM`0:l0[2fN[M=:R1V2bN`M<9W1Q2^NgM;7\\1m1XNnM;5b1g1UNTN94g1c1PNZN93k1]1oM_N63P2Y1kMdN56Q2P1lMjN28U2i0iMPO28X2b0hMVO17[2>eM[O08^27dMANCiMJl4m0eKeN0236k0X:QOgE22m0d;10000O10000000000N2001O1O0POjCk0\\f<@\\C2N9n<0005K3JkB0X=000nbc07h\\\\O3IIYC8g<60000O1O1N2O1001OO1MZOaCf0^<4J6000000O1001O00O1001OO10000LoNmCR1S<32N1O1O000000001O00O11OO1001O00001O000000O1N200O11O0000O1000000WNoNTF2j3CWL;j3DWL;i3FXL8h3IXL6i3IYL6f3KZL4e3M]L1c30]LOc32^LJd36]LHd39]LDd3<]LAe3`0\\L]Oe3d0[LZOf3f0\\LVOf3k0[LROf3o0ZLQOd3P1^LoNa3R1_LnN`3R1bLlN^3U1bLkN]3V1dLiN[3W1fLiNY3X1hLgNW3Z1iLfNV3Z1lLeNR3]1nLcNQ3]1QMbNn2_1SM`Nk2b1UM^Nj2b1XM]Ng2d1YM\\Ne2e1]MYNc2h1]MXNb2i1_MVN_2k1bMUN]2l1cMTN\\2m1dMSNZ2n1gMRNX2o1iMPNV2P2kMPNS2R2mMnMR2S2nMmMQ2S2QNlMPNgM^3c4bNfMoMiM\\3b4fNdMnMkM]3`4eNeMlMmM`2MVN`4_1eMjMoM]2N]N\\4]1gMhMQN[2KdN\\4Y1hMfMSN\\2HhN[4W1jMdMTN[2FnNZ4T1ZNL[MTOX4S1]NGZMYOW4Q1_NX1_1jNaNW1]1jNcNW1Z1lNeNU1Y1lNhNT1U1nNkNS1S1nNmNS1P1POoN]MdMn2[3FROXMmMl2n2NUOSMRNn2g20WOoLWNo2a24=G@;c0C[O>e0CXO?h0BPOe0P1\\OZNZ1e1gNfMm1Z2TN[MV2e2kMYMV2g2jMYMW2f2jMYMV2g2kMWMV2i2kMVMU2j2lMUMU2j2lMTMU2l2lMSMT2m2mMRMS2n2nMQMR2o2oMoLS2P3mMPMS2P3nMoLR2Q3oMmLR2T3nMkLS2T3nMkLR2U3oMiLR2W3oMhLQ2X3PNgLQ2X3PNfLQ2Z3PNeLP2[3PNeLP2[3QNdLP2[3QNcLP2]3QNbLo1^3RNaLn1_3SN_Ln1a3SN^Ln1a3SN^Lm1b3TN\\Lm1d3TN[Ll1e3TN[Lm1d3TNZLm1f3l30001O000000001O001O001O001O010001N100O101N100O101N100O101N100O2O0O100O2O0O10001N100O101N100O100O10O010O0100O010O10O010O10O10O0100O010O010O10O0100O010O010O10O01000O010O0100N101O1N101O0O2O1O0O2O1O0O2O001N2O001N2O001N101O1N1O2M3N1N3M2N3M3M2N3M3M2N3M3M3N2M4L3M3M3M4M2O1N2O1O2N1O1O1O2M2O1O1O1O2N1O1N2O2N1O1O1O1O2M2O1O1O2M2N2M3N2M4M2M3N2M3N3L3N2M3N3L3M3N3L6K5J6K5J6K5J6K5J6K5J7J5J6K5J6K5J6K5J6K5J6Kmf9", "size": [427, 640]}, "area": 153862.0, "iscrowd": 0, "image_id": 13177, "bbox": [0.0, 3.0, 616.0, 419.0], "category_id": 183, "id": 20000784}, {"segmentation": {"counts": "m4h5W>1O2O0NVJnAi5S>2O1O1O100O1N21O001OO11O1O1N1000001O00O100001O0000MUJQBk5b=`0GeIjB^6U=dIiB]6T=9O1O1O11O0000O1O1O1O101O00000000000000aIQCm5P=QJQCo5P=oIQCQ6`=N2O002N2N3M00O100O10000O1O1O00101O0000000000ODhIoB5Jm5U=SJmB01l5Q=TJlB15i5P=`JQC`5o<_JSC_5mb4ZBXKf=c4eBWK[=d4S1K5K4O011O1O1O1O2N1O00BVLg@j3Y?>RDbK[8^4eGcK[8[4gGeKX8[4iGfKU8Z4lGfKT8Y4mGhKR8W4oGiKR8U4oGkKR8S4oGmKQ8R4PHnKR8o3oGQLT8k3mGULV8g3kGYLX8c3iG]LY8`3hGaLZ8\\3fGjLW8R3jGUMQ8i2oGWMR8h2mGXMU8f2kG[MV8d2jG[MY8b2gG^M[8a2cGaM^8^2aGbMa8\\2_GdMc8[2\\GeMf8Y2[GfMg8Y2ZGeMh8Y2YGgMi8W2WGhMk8W2VGgMl8W2UGhMn8V2RGiMP9U2RGiMQ9U2oFjMS9T2nFkMP8FSE\\2o2lMm7KTEW2P3kMm70UES2o2iMo75REP2U?RNl@k1U?UNl@i1V?WNk@g1T?[Nl@c1U?]Nm@`1U?`Nm@]1S?dNRAU1o>kNVAn0m>ROXAe0k>\\OYA=j>B\\A6f>K^ANd>3aADb>c4[A\\KN5l>Y4VAlKo>P4l@TLW?Z40O2N1O1YOf@fL\\?W3f@hL[?V3g@lLW?R3l@lLV?Q3k@mLX?Q3i@oLX?5a@P28kMX?3a@Q29kMX?2_@S29kMY?1_@R29lMZ?1]@R2:lM[?1\\@o14Z@P1`1jNX>5X@P1a1kNW>5X@n0d1lNT>6X@3L6k1AQ>5Y@3M3l1Dn=6_@LJ7k1Fm=6o@2W1Fj=8PA0X1Hg=7TAOV1Jf=5VA0U1Je=6WANV1Lb=5ZANUa0On^O0Ra0OQ_OOo`00gQ7OkoH0T\\O0ic00V\\O0hc07L3M1N4M2N2N2O12O0O1O100O1N01O10O01O0mN4T^OKma06Q^OKoa06P^OKoa06o]OKQb05n]OMQb04n]OLRb05l]OLTb05j]OMUb03k]OMTb0Q1L3M3N3K4O2N1O1O100O1O0001O01O003M2O0O2N1O1O2O0O2N1O101N2N1O1O1O1\\NoLXBR3g=PMVBR3h=QMVBP3h=SMVBm2i=UMVBl2h=WMVBj2h=YMVBg2P=hLdBc0:f2Q=iLbBd0;d2R=jL`Bd0=c2S=jL]Be0?a2T=lLZBe0a0`2T=lLYBf0b0_2U=lLVBg0d0^2U=mLUBf0e0^2U=nLSBf0f0]2W=UNhBl1X=TNgBm1X=TN\\BbNG[3m=SN\\BX2c=hM^BX2c=fM^BZ2b=eM_B\\2`=eM_B[2a=fM]B[2c=dM^B]2a=dM^B\\2b=dM^B\\2b=eM]B[2c=eM]B\\2b=dM^B\\2b=dM^B\\2b=dM^B\\2a=eM_B[2a=fM^BZ2a=gM_BY2a=gM^BY2b=hM^BX2a=iM`BV2_=kMaBT2`=lM`BT2_=mMbBR2_=mMaBS2_=mMaBS2_=mMaBR2`=nM`BR2`=nM`BR2`=nM`BR2a=mM_BS2d=jM\\BU2d=lM\\BP2h=PNXBP2i=oMVBR2i=oMWBR2g=oMYBQ2f=PNZBQ2e=PNZBo1f=RNYBP2e=QN\\Bm1d=TN[Bm1e=SN[Bm1d=TN\\Bl1c=VN[Bk1d=WN[Bi1d=XNZBj1f=VNZBj1f=X2O10001N101N101BcIUC_6k<=N0O1O2N1O100O100000iKUCY1kUCWO5:e<`0VCUO;6_]^_c3SA_Lk>a3UAdLf>\\3[AdLd>\\3\\AdLd>]3\\AbLd>^3\\AbLd>^3\\AbLd>_3ZAbLf>^3ZAaLg>_3YAaLg>e2l@fM;Fi>c2UA_M2Ni>b2\\A[MI4k>`2^A\\MF5k>^2aA^MA5n>\\2cAaMZO6R?Y2eAWN[>h1gAWNY>h1iAWNW>h1kAWNU>h1mAWNS>h1oAVNR>i1PBTNR>k1PBTNP>l1PBTNP>k1RBTNn=n1QBQNo=P2QBPNn=R2PBnMP>S2PBkMQ>V2oAZMUOLm>l2lAWMc>j2]ATMd>n2[AQMe>P3ZAoLg>S3XAkLi>V3P12N1O2N1O2N1O2N1O1O2N1O2N1O2N1O2N1O2N1O1O2N1O1O2N1O1O2N1O2N0000N2N200O1001OO1001O00001O001O00000000O1000000N2O100O11O000000O1M3O10000001O2N1O001O001OO100K\\@lK0Od?S470000O1001O00EV@XL06i?`3>00O1000000001O001O001O0000Ek_OkLU`0S3n_OkLS`0T3o_OjLR`0S3Q@mLo?S3R@jLP`0U3Q@jLP`0V3=1O0000000000O1N2LW_OPMj`0o2400O1001O1O001O1O1O1O2NO1N21O0000O11O00O100O1O1O100O1H800O1O1O1O100ZOi^O`NLC\\a0l1k^O\\NZa0c1i^OXNZa0e1b0N2QOj]O3Wb0Kk]O4Vb0KV^OIka06W^OHja08W^OGia08X^OHha07Z^OHfa08Z^OHfa08[^OGea08\\^OGea09\\^OEea0;[^ODfa0;[^OCga0;\\^OCea09S1N2N2O1O1N2OQXj01RTUO0jc08K2N2N002N002N2N1O00000000O100O1000000000000000000000000002N2N2N1O000000002N00O1001O1O1O1O00001O2N1O001OO1O11O001O1O0g]OmNea0U1W^OPOfa0R1T^OTOja0Q1o]OSOoa0a1N2N2N1O2N1O001O1O4^^OaM[a0b2000001O00001O1O1O00O1000000001O00", "size": [640, 427]}, "area": 38645.0, "iscrowd": 0, "image_id": 13201, "bbox": [0.0, 0.0, 427.0, 157.0], "category_id": 169, "id": 20000789}, {"segmentation": {"counts": "TWj11nc09G7I2N2N2QC@\\6a0^IJ[68_I3Z6O`IW=VT<]OeBf3i0\\La0?Rf^OBXa0=V100010O0000010O00010O000010O01O01O100O010O1O100O;FjcR2", "size": [640, 427]}, "area": 36044.0, "iscrowd": 0, "image_id": 13201, "bbox": [93.0, 87.0, 227.0, 436.0], "category_id": 183, "id": 20000790}, {"segmentation": {"counts": "V4;T:1OO10000002N001000N1O1010O1ON21O1O2OO01O0000000100O00000000000O110O1N20O10O1OO1O1000001O001N1N12O1O1O1O1O0OS^a4", "size": [335, 500]}, "area": 665.0, "iscrowd": 0, "image_id": 13291, "bbox": [0.0, 134.0, 55.0, 22.0], "category_id": 106, "id": 20000791}, {"segmentation": {"counts": "f5i4e51000000001O000000O100O1O100O11OO100000000O1002N003M00O1001ON2000000001O001O000000O11OO100000000001O0000000000000eL_Jh1a5QNmJh1S5QN\\Kg1d4RNnKc1R4VNgLX1[3_NaMl0R6O00000000000000000000000000000000O100O1O100O1O1O1O1bNjNaIX1]6nN]IT1b6QOXIQ1f6SOWIn0h6YOaHWOQOS1]6^NeJiH@W7a0kH]OS7e0nHYOR7h0Y12mNVO_Hk0^7[O]Hh0`7]O[He0c7_OZHa0f7CUH?i7FSH:l7JPH8;mNP7o0`H6VOY6W1YIZO0\\O=5Z6T1YI\\O1ZO:9[6P2[IgM8<\\6m1\\IgM5?_6i1]IhM2b0`6f1^IiMOc0c6d1^IhNb67\\I@29b67\\I@2:a66]I@2GOKb6n0]IA2C5J]6P1^ICOA:JZ6Q1]IEN^O=LZ6o0[I5>kNY6JWJOROn0OYOa00T6OYJISOo0OWOe0OP6SJ^OWOn04SOk01f5b0UJ9>TO]5d0UJ7U7KjH4W7MhH2X70hHNY72mHIQ78bHZOBM1=j7=^HIFFm7a0\\H9d7HYH:g7GWH9k7GRH;n7FoG<=eNU7[2kHjMQ7V2mHoMQ7o1oHRNR7l1nHUNR7k1mHVNT7h1kH[NU7_1oHbNS7\\1lHeNV7Z1hHgNZ7W1bHnN^7R1]HROi7g10001O0O1O2eH[Mk6d2UI]Mj6d2TI]Ml6c2TI^Ml6b2SI_Ml6b2RI`M5LV6d2eI`M4OV6a2eI`M50U6a2eI_M51V6`2dI`M52W6^2cI`M53X6^2bI_M54Z6\\2aI`M44\\6i2cIXM^6g2`IZMb6d2]I]Md6c2ZI_Mg6S32RMYIQ2i6mMXIR2i6mMXIS2i6lMVI]OMe2o6mMVIR2l6mMSIS2R7iMmH2Mc1[7WNhH8M_1i77XHQNj7n1YHmMj7R2:`NhGi0X8WOhG72AW88hGM=Gl7cFA^9?cF_O^9a0bF]O`9h01O0M^FZOc9f0]FYOd9g020O100eF6P8KnG9=QOh6g0jH;;XOb6=QI>:ZOa69TI`08WOe69QId06UOh68QIf03TOS6\\O]Jb2]ORNU6ISJn2l5k0O0O2O1N101N200O010O100O1000000000000000ROVJWMk5f2YJXMg5e2_JUMd5j2`JoLd5R3]JhLg5X3h00000010O0005WMmHl1X7iMnHX2e7O1O1O100O1O100O10O10O101N101N2O0O2O1N101O0O2O1N101N2O1O1O1O1N2O2N1OO0100000000O10000000O01000000O3N1O2N2N2M3N2N1O1O1N101O1O1N2O001OO1O000000000000000000O1000000000000000O01000O10000O10000O10O10O1000O10O1000O01000O01000O010000O01000O0100000O0100002M3N3M2N2N2M10O2O1N1Of0[Of1", "size": [335, 500]}, "area": 38520.0, "iscrowd": 0, "image_id": 13291, "bbox": [42.0, 66.0, 457.0, 234.0], "category_id": 183, "id": 20000796}, {"segmentation": {"counts": "Phk01Z=0O1L1lBOT=7M3NO000L40001O000000001O000MkB0U=OlB1`cf50hiYJ0N1O100jBNS=5N210L33NO0M301N11OO1010O00O101O01O00013L01O1O1O1O1O1M3O[O\\Cd0d0]O[;c0dD^O[;c0cD@[;a0cDA\\;a0aDB[;a0cDA^;>`DE];=aDEo:l0nDVOo:m0PEROP;P1nDPOS;f1N00O10000000000000^EiMP:\\2kEdMU:b2aE^M10^:l2MO100000000000000TOdEiN\\:W1eEhN[:i0dEkN2;Z:g0hEhN4`0T:0dEM6A5a0Q:1dEMi0Mg96aEAN0OJl09TOGe:e0^E_O8La04P:a0YE[OXj3S7lK_H;1KKn3f7cLZHk3f7hKZHe4f7SK[HM2o4d7nJYH051OQ5S80000000O100O100O1O100O1000000O1000000001OO11OO100000000000000001O1O2N1O1WKiG\\4Y8[KgG22c4X8ZKgG21d4`81001OO1O11O2N1O0000001O0000001O[O`K`HOAOMY4P8mKaHJB04R4i7ULnHk3R7WLlHi3T7WLlHi3T7WLQHGg0S4X7ZLgHf3Y7]LdHc3\\7]LdHc3\\7]LdHc3\\7]LdHc3\\7]LdHc3\\7]LdHc3\\7]LdHc3\\7]LdHc3]7\\LcHd3]7\\LcHd3]7\\LcHd3]7\\LbHe3^7[LbHe3^7[LbHe3^7[LbHe3^7\\LaHd3_7\\LaHd3_7`LZHc3f7]LTH\\ONX4n7\\LTH\\ONX4n7\\LTH\\ONX4n7\\LTH]OMW4o7\\LSHj3m7VLSHj3m7VLSHj3n7VLQHj3o7VLQHj3o7VLPHk3P8ULPHk3P8ULPHk3P8WLnGi3R8h00000000000000000000lJnGo4Y8N1O2N1O1O00O100000000002N00001O1OO10000O11O0000000000001O1O0000K[KdGe4\\851O0000001O0000001O002N1O2N1O2N1O2N1O1O000fKUGT4Q900000000000000000000000000000000000000000000000J60000000000000000000000000000O1O1N2N2N^K\\Ga4j8_KUG\\4k8dKUG\\4k8dKVG[4j8eKVG01W4P90000000O100000000001O0000000000L4^OeKfG0051V4Y8eKeG1140W4Z8eKdG1130X4[8dKdG1130X4[8dKdG114OW4\\8hKdGa4\\870000000000000000000000000000N2N2M31O00000000000000000000001O0000000000000000000000000000000000000000O100000000000000000000O11O000000001O00000000001O000000001O00000RKgGj4Y8VKhGi4]8000M31O1SKcGj4`8O0000000000O10000GWKPHi4P8YKnGg4R890000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000oJkGl4U8SKmGl4S8TKlGm4T8SKmGl4S8TKnGk4R8TKoGl4Q8TKPHk4P8UKPHk4P8UKQHj4X80000000003MO1O1O100N200001O00O11O00O1001OO1O100001O1O1O000000O1000000001O001O0YKaGb4a8\\K`Gc4`8]K`Gc4`8]K`Gc4`8\\KaGd4c80000000000000000000001OO100001OO1000000000000000000000000000000001OO1001O00000000000000000000002N1O3M1O00N2003MO11O2N2N1O001OKmKQGT4i8:002NL4O10000001O3ML400", "size": [427, 640]}, "area": 101610.0, "iscrowd": 0, "image_id": 13348, "bbox": [0.0, 232.0, 640.0, 195.0], "category_id": 140, "id": 20000799}, {"segmentation": {"counts": "ln[42V=6kBIn<9RCGl<;TCFi<ZCCg<`0O1O12N00O1000000000001OL[CAk<:UCFQ=0oB10Ocbi0", "size": [427, 640]}, "area": 855.0, "iscrowd": 0, "image_id": 13348, "bbox": [525.0, 247.0, 54.0, 32.0], "category_id": 161, "id": 20000801}, {"segmentation": {"counts": "l]i622OT=5O1QCJL2f<5\\CJN1c<6_CKM0d<5_CKM0c<7^COa<2_CN`<=210L33L11L303L201M2OMEVCTOMe7JRI9YOKg71kH4AGe7:eHOFGe7?`HKJHd7b0]HFOIc7f0YHA4Jb7j0UH\\O3BnN8j8o0PHWO6EoN5k8T1kGSO9EQO4k8Y1fGnN=3m7T1aGiNa03P8X1ZGeNf0_O[O8h8f1SGcNd0DA3j8]2eG_MA4k8\\2dG`MA4l8[2cGaMA6l8W2cGcMA7l8U2cGdMA7m8U2aGdMB7o8S2_GfMC6o8S2^GgME4n8T2\\GiMH0o8V2XGjMJOo8V2WGkMKNo8V2VGlMKNP9V2TGlMLNR9T2RGnMLMT9U2oFnMf9Q2ZFoMh9o1XFQNi9o1VFQNk9n1UFRNl9m1TFSNn9l1QFTNP:k1PFUNQ:k1nEUNT:i1lEWNU:h1jEYNW:g1kEVNW:h1g0O10cEUNY9j1fFXN[9g1dFYN]9f1cFYN_9f1`F[Nb9d1\\F\\Nf9c1ZF]NUON^:d1\\FeNc9[1gE\\N;b0i9P1lE_N:a0k9P1iEbN:>n9o0hEbN=O[:]1o00cDaNm:^1QEdNQ;Z1nDgNS;Y1jDjNV;U1iDlNX;T1eDnN[;R1dDnN];R1cDmN^;T1aDlN_;T1`DlNa;T1_DlNa;U1^DjNc;V1]DjNc;^11O100000000000000000000000000O100000000001O1O1O2N1O1O2N1O1O0000O1O100O100O100O1O1O1O1O1O1O1O1000000001O000O1000000000000000000000000000001O000000000000000000000000000000001O0000000000000`DZN[;f1bD_N\\;i1O2N1O0000O100O10000O100O100O100O10000O100O1001O1O1O1O1N2O1O0FPNYEQ2f:RNWEn1i:TNUEl1k:;O0001O010O1O1O1001N101O001N1O2N1O1O0000000000000000000000000000000000000000O10000000000000000000000000000000000000000O1N2N2N2N2N2O1N2N2N2N2001O00001O00001O0lD`N]:a1_E`Nc:`1^EaN`:_1aE`N_:`1bE_N^:a1bEUN4I[:R2e00000000000000000000000000000000000000000O1M3N2O100000000001O0000000000000000000000001O00000000000000O10000000000000000000000O100000000000000001O000000001O00000000001O00000000001O00O100000000O1000000O1000000000000000000000000000000000000O10000000000000000000000000001O0000001O0000001O0000001O0000001O000O101O0000001O000000001O0000001O000O101O0O10001N100O101O0O10001N100O101O0O10001N101N2O1N2N2N2N2N2N2O1N2N3M2N2N2N3M2ORdn0", "size": [427, 640]}, "area": 32373.0, "iscrowd": 0, "image_id": 13348, "bbox": [0.0, 142.0, 566.0, 166.0], "category_id": 183, "id": 20000803}, {"segmentation": {"counts": "ce415000^<7^C8YC0O0O12NN21O1O01O00000N20000000000000000000000O1O10O11O00O1000M24A<000O02OO20N1000001OO1001O000002N5nEgL0Oh9Z3XFkLf9]3O000000O10000000001N3iLWFKOj2Z:KfEZM[:e2fE[MZ:d2iEZMW:h2gEXMY:j1jE^No:?WEYOF1k;>jDAW;b0iD^OX;a0h0000000000000C^CMOOmb_20V]`M3eYHFf7;ZHEg7:YHFbML50f9`0bHDcML41g9?bHDcML41g9`0`HM`73^HOb72WG^O35lN3j99VGB11RO3h99UGC@:@F54f9:PGNUO60\\O77b9;`F_O1>G5O]O66b9?\\FDNo0MiN84`9b0[FEMm00hN83`9e0XFE1o07fN`9k2aFTM_9l2aFSM`9n2_FRM`9o2aFPM`9o2<100000001O0ZFmLU9T3hFlLX9W3hFiLo83fFX3;eLo8`3PG`LQ9a3nF_LR9a3nF_LR9a3nF_LR98eFo29iLR95eFL0V39iLR95eFL0V39iLR95eFL0V39iLR95iFQ35jLR95iFQ34lLR9NfF34S34kL^9T3cFmLc9l2]FTMc9l2]FTMc9l2]FUMa9l2_FUM`9k2`FUMGLg9o2bFWM]9j2bFVM_9j2aFVM_9j2aFVM^9k2bFUM^9k2bFTM_9l2aFUM^9k2bFUM]9l2cFSM^9m2bFSM^9m2bFSM^9m2aFTM`9k2`FUMa9j2_FUMc9j2]FVMd9i2\\FWMd9i2\\FWMd9i2\\FXMc9g2^FYMb9g2^FYMb9g2]F[Mb9e2^FZMc9f2]FZMb9g2^FSML0f9m2`000000001O000000000000000000000O10gETMT:P30010N2O101OO1003M001OM32N01XMoET2R:iMRFKKO43LH0011O]1Q:nNTFDK41O4O?N\\OV1S:ROmEI63KL0042b0NYO07f0Q:AQFMHL0042b0NYO07f0S:_OoEOKL12m0d0Z9]OnE0JM12[16n8ImE11OU15^9J]E1U1ObN1Z;0YF0g90i101OmD0Qli2", "size": [425, 640]}, "area": 19250.0, "iscrowd": 0, "image_id": 13546, "bbox": [11.0, 0.0, 413.0, 193.0], "category_id": 123, "id": 20000804}, {"segmentation": {"counts": "S4`5i700O1O101O00O1001NO3L22O2QKbHo3^7PLcHP4a7jKaHU4i7bKWH^4Z800O100O11O00O101O000000000O8fKQGl3X9N>DOO000001OO10001O01OO12NN2N200N2N200O10000000000O10O11O00O10O11N1D<0O10O0101OO100000O1000000000002N5bLSF0OT3n9lLWFQ3R:O000O10O1000O1001OO0011JPMPFQ3o9PMQFP3n9SMPFn2Q:PMoEo2T9TMTG_3o7gLiGF1^4W8kKhGY4X8gKhGY4X8<0O11OO10000O10000001O00001ON2001OO1001O0000001O1O0000000000000000000000000000K5L4N2M31OO12NgK`Gh3c8mKgGS4g80000000000000000OC>J6000O1O11OO10O100000000000O1O1100O0000O10000O100O11O0000O11O0001N10000000001O00000O1000001O2N1N100001OO10016H5M0O0O1001O1O1O0SOPL^HS4b7mKWHZ4i7fKoGc4P8]KoGc4R8]KnGc4R8]KnGc4R8]KnGc4R8]KnGc4R8]KnGc4R8]KnGc4\\80F]KnGc4R8]KnGc4R8]KnGc4\\800O100001OO100000O100000001OO1N2K5N2O1hKRGT4R9ONlKPGT4Q9lKoFU4P920NbMSLdKo3Y4RLgKn3Y4RLgKn3Y4RLgKm3Z4SLfKn3Y4RLgKn3Y4RLgKn3Y4RLgKm3Z4SLfKl3[4TLeKl3[4ULdKl3[4SLfKl3[4ULdKk3]4TLcKl3]4TLjKe3V4[LQL^3o3bL^II`2d3R4gLnKY3S4fLmKZ3S4gL]IC]2f3V4iLjKW3V4iL`Ka3`4_L\\Ke3d4[L]Kd3c4\\L\\Ke3d4[L\\Kf3c4ZL]Kf3c4ZL^Ke3b4[L^Ke3b4[L_Kd3a4]L^Kc3b4]L^Kc3b4]L^Kc3b4]L^Kc3b4]LeI@a1R4j4^LeIBKO_1R4P5]LfIHZ1j3P5^LfIH[1i3P5`LcIG]1i3P5oLoJR3S5kLmJW3R5jLmJV3S5jLlJW3T5iLkJX3U5jLiJV3W5iLiJX3W5iLhJPOeNU4e6iLhJW3W5iLjJW3U5kLjJU3W5iLjJW3V5aLSK^3l4bLUK^3k4bLUK^3k4^LZKX3TN\\Lg65WK\\3XNYLI0P73PKc3^5ZLbJg3^5ZL`Jh3`70O0100WLjF_3`9O11OO10000OK6M4OO10O1000O11OO100000001N0110OO101O1O0^L[F`3g9N11000001N11O00O100000N21N10001O01O00001OO10O1M301O1O1N01OO2OM5I3\\FaLc9`33O11OO1000O2M200^F\\L^9e3bF[L]9g3bFZL]9f3cFYL^9j3OO2OO1012M001OM32N00N2dMWLSI43LH0011O]1h3d5YLQI4O>W1U3i5YLnH0042>X1S3i5[LmH0042>Z1Q3g5`LmH12>[1n2h5cLkH12>[1m2i5lLkH7]1j2j5oLiH7]1h2l5QMgH7\\1i2m5PMgH7\\1j2l5oLhH7\\1i2m5QMfH6_1]OaNY3Y7hMaJo1`5QNaJn1_5RNbJm1^5RNdJm1\\5SNdJm1\\5SNdJn1[5RNdJn1\\5SNdJm1[5TNZJWO^Nd2Y7SNXJ[2h5eMWJ]2h5cMXJ^2g5_MiHTO`1\\3h5`MhHTO`1\\3i5_MgHUO`1\\3i5_MhHTO_1^3h5]M\\Jb2e5^M[Ja2f5_MZJa2g5]MZJc2f5]MZJc2g5^MWJb2i5]MXJc2n5YMQJf2R6YMmIe2Y6WMfIi2Z6WMfIi2X6YMhIh2Y6WMeIj2Z6WMeIk2Y6VMgIj2Y6VMgIj2Z6kLZHJN0^1[3[6gL\\HNK0^1[3\\6eL\\HOK1]1Y3]6gL\\HO\\1Z3X6gLRJY3m5gLTJZ3h5hLYJW3h5hLYJX3f5hL[JW3l71O:HO9F1O0000PNhLoIX3c5gLkH2b1W3_5PMhHL`1\\3h5SMRJS3n5mLRJS3i5YLiHf0^1R3f5YLlHg0^1P3d5XLnHk0^1m2d5XLnHj0_1n2o4XLRJ0@k0`1m2m4ZLPJm0S1^2W5fLeIm0T1\\2X5hLcIl0U1\\2X5hLdIk0T1]2X5iLdIg0V1`2V5iLeIf0U1a2U5jLgId0S1b2X5jLeIb0T1c2X5lLdI?T1e2Y5nLbI`0P1d2\\5nLdI=m0h2_5lLdI:n0?oNk0^6]NeI9m0>VOf0X6fNdI5m0`0XOe0V6gNeI2m0b0[Oc0T6iNdI2k0b0_Ob0S6jNcIOl0JhN?h0n0R6iNbIOn0IgN?j0b0UOQOQ71ZI3P1IfN`0k0dJNYOEhNO[7>cJN\\OGaNO`71O10O1O011N0100001O0O10O10O100O2N1O1O11O01N1001O00O1000O011O0O1000O1O1000000O100O10O10O02O00N3N10000001O000000O100O011OO02OO_L", "size": [425, 640]}, "area": 75417.0, "iscrowd": 0, "image_id": 13546, "bbox": [0.0, 15.0, 640.0, 292.0], "category_id": 124, "id": 20000805}, {"segmentation": {"counts": "UcV11X=001O=C1O00000000000000001OO1000000K5Ioc`0NZ\\_OO11O0K5Em0JSOm3U5hLPLSOkN>m0Q4X4\\LQLEHm3Y4_LVK\\O18`0o3W4]LWK]O27`0o3W4]LWK]O27`0o3W4]LWK]O27`0n3X4^LVK]O36?P4W4]LWK]O36?P4W4]LWK]O45>Q4W4]LWK]O71d0d2o4oL\\J=e0c2P5nL]J?c0d2o4mL^J>d0d2o4oL\\J=e0d2o4PM[JQ6BoI?P6ZOmITM3l3f5nN[JTMOo3e5jNgJV1Y5hNiJX1W5dNmJ\\1S5UN[Kl1e4TN[Kl1e4TN[Kl1e4UNZKk1f4UNZKk1f4UNZKk1f4TN[Kl1e4TN[Kl1e4TN[Kl1e4SN\\Km1d4RN]Kn1c4RN]Kc1n4]NRKb1o4^NQKb1o4^NQKb1o4\\NSKd1m4\\NSKd1m4\\NSKc1n4\\NSKc1n4\\NSKc1W4_LRKR2d0_1Y4_LSKR2e0^1X4`LSKQ2f0`1S4_LcJ0d0R2e0^1d3bL_K18o1d0`1d3aLYKMK6d0k1d0b1c3cLVKJN007e0k1b0b1e3QMiK[1c0f1a2ZLUMh0FX1f0d1_2\\LSMj0HV1g0c1Y2_L]LOi0j0JU1h0b1V2bL_LM0Od0m0OX1d0\\1^1_LTN4VO1a0l03U1d0Y1Z1lLRN1Cn0=n0c0V1[1lLoMi136c0T1[1CRN[Oc0P1HfL5OlN01W3c0UOc0n0HgLSO7c0W3OoNa0k0JkLQO4d0X30oNa0i0JVMDT30oN?h0MUMDT30QOZ2@]J2Y3>]2@WJ2\\3>]2CTJO_3>^2EPJMb3>^2BSJ0_3>c3B[LMcKa0R8B[LMcKa0R8CZL?f3AYL`0g3@XLa0h3_ORLLlKi0R8[ORLg0m3ZOULd0k3\\OULd0k3[OVLe0j3ZOXLe0h3XO[Lh0S8000001O[KYOhLg0X3ZOhLe0X3[OhLe0Y2[OPJ0d3h0Z2]OoILe3h0\\2_OlIIh3h0[2DhIEn3f0Z2HeICP4e0X2NdI^OV4b0V24^I\\O\\4`0S2d0lM]OV2b0jM]OS2f0mMZOT2e0lM[OS2b0RN]Om1?aIkNb4g0n18^ITOh4d0i19_ISOh4d0i19_ISOh4d0i19`IQOh4f0h19\\NGd19\\NGd19\\NGd13_IZOl4d0e12_IZOl4d0e12_IWO00g40[Kg0_62_IWO00a40`K30d0_63aIUOa4U1m1GVN9j1GVN9j1FWN:h1GXN9i1FVN;i1GUN:k1FWN8i1HVN9k1FUN:k1FVN9j1GUN:j1GUN:k1FUN:k1FTN;l1ETN;m1DRN=n1CoM`0Q2@kMd0U2\\OiMf0W2ZOiMf0X2YOgMh0Y2XOgMh0Y2XOgMh0Y2XOgMh0Y2XOfMi0Z2WOfMi0Z2WOeMj0Z2WOfMi0Z2WOcMl0]2TOdMk0[2VOcMl0]2UOaMl0_2TO_Mn0a2SO[MP1e2POXMS1h2lNXMU1h2kNXMU1h2kNWMV1i2kNVMU1j2jNWMV1i2jNVMW1i2jNWMV1i2jNWMV1h2kNWMV1i2gNdISOd3V2h2gNdISOc3W2j2dNWM^1i2cNTM_1l2aNSM`1m2`NPMc1P3]NPMc1P3]NoLd1Q3\\NoLd1Q3\\NnLe1R3[NlLg1T3ZNjLg1V3YNjLg1U3ZNiLh1X3VNiLj1V3XNhLi1Y3VNfLk1Y3VNfLk1", "size": [425, 640]}, "area": 103887.0, "iscrowd": 0, "image_id": 13546, "bbox": [0.0, 16.0, 640.0, 409.0], "category_id": 140, "id": 20000807}, {"segmentation": {"counts": "n2U1T<01O000001O01N10010M2^OiCF000M[<3lCLl`T8", "size": [425, 640]}, "area": 428.0, "iscrowd": 0, "image_id": 13546, "bbox": [0.0, 94.0, 13.0, 38.0], "category_id": 149, "id": 20000808}, {"segmentation": {"counts": "0i0f1Fe8O001O1O1OE`CM`<1dCL]<4<001O1O001O004L4L2N1OO1O100000000O11O0000O10000O1001O1O2N7I6J1O000000000000001O000000O1O100000000001O000000000000000SDTO];l0^DPON5c;k0_DPOK016d;l0[DoN0106d;]1N2N1O2N3M5K1O2N2N2N2N2N1O2N2N2N2N2N1O2N2N2N2N1O2N2N2N2N2N1O2N2N2N2N2N1O2N2N3M3M3M3M1OK5O10000O1O100O100000000O10000O100O1O1O1O11O00O1001O00O10000O11O000000O1O1000000O100O10000O11O00N2O10000001O000000O100O10000O100", "size": [425, 640]}, "area": 20207.0, "iscrowd": 0, "image_id": 13546, "bbox": [0.0, 0.0, 640.0, 138.0], "category_id": 169, "id": 20000809}, {"segmentation": {"counts": "agk22li:8SE82Bk:V1TEkNl:U1SEmNl:i1O000000000000O100O2gMREO091`1_;OONaDZN_;f1aDZN_;f1aDZN^;g1201OO10100O2N10XNcDb1^;\\NcDd1^;[NcDd1a;00\\N]Dd1c;YO^DGc;9\\DHc;F\\ENk;GWC;fgf<2100000001O001O3L102GQC1U=O101O00She4", "size": [425, 640]}, "area": 2517.0, "iscrowd": 0, "image_id": 13546, "bbox": [221.0, 0.0, 58.0, 85.0], "category_id": 171, "id": 20000810}, {"segmentation": {"counts": "\\h[61X=000M0mB0b<2jC1V<0cCMK6a<0`CJN007b<>nN[O^Eh0a:XO]Ej0^:XOgDOi0j0^:YOiDM0Od0m0g9SO^F4VO1a0l0f9ZO]F1Cn0P:POZFi1f9m0]NQM`HOlN01W3c8jL^G7c0W3n7eL]G4d0X3o7nLPHT3o7lLQHT3o7nLnGS3Q8oLcG_O3c3\\8nL^G@3NLe3f8jLZGb3e8a000O1000000\\G]Kb8e41O0000000^K]G]4d8cK\\G]4h8000000000000NXGcKh8]4XGcKi8\\42O1O1JSGlKQ9T422N0O1O2L3N20000N3N101O00M4N10010O02N00O20O000L5J^KbGb4Z8\\KiGh4W8XKiGh4W8XKiGh4W8YKgGh4Y840000JSKPHl4Q8TKoGl4Q8TKlG00g40[KT8NlG00a40`K30Q80kGa4b8300O1000O2N12NO1001OO1O100O100O1M3L4N200O1000000O100O100M31ON3N1N3L3M20100O2OO10O10000ON]L_Fd3a9\\L_Fc3a913M2O1M300O100O1N3N100N111N1O1OeH", "size": [425, 640]}, "area": 18783.0, "iscrowd": 0, "image_id": 13546, "bbox": [490.0, 234.0, 150.0, 174.0], "category_id": 172, "id": 20000811}, {"segmentation": {"counts": "i0f1e;NO20N9H3SOSD9b3n:IbE2B5l;JUD3n;LTD1hgc21jd\\M7UCGX00000000000000O10002N2MgQ70XnH2N2N30O0001O000010O00UCO^O100000000000000000O1000000000000000000000000`NJmE6P:MgEKTO8T;NgEKUO7S;OlDN;0F3S;?PEBMOR;c0jDB4KQ;V1oDiNQ;X1oDhNP;Y1PEgNl:X1mDeN63m:U1REfN15l:T1_EoN]:o0fE[Oi8BaGR1H\\Oe8FaGa07IX8H_G9>0S8J]G4a02S8KZGC_O4V1>R8KgGA87^89hHFZ7:eHF[7;dHEb76]HJi71VHOj72UHNl72SHNm73RHMn74QHLP84oGKR86mGJT86kGJU87jGIV88iGHX88gGG[89dGF_89Y2000]FMo53oI3n5KRJ6n5JPJ9o5GoI;Q6ERIEdNh0[8BPIFdNk0a0UO_6:[JGdNk0VJJc55]JMb52^JOb51]J1b5N^J4a5K_J6a5J_J7`5H`J9`5F`J<_5D`J=`5BaJ?^5@bJa0^5_OaJc0^5\\OcJe0\\5ZOdJg0\\5YOcJi0\\5VOdJk0\\5TOeJm0Z5SOeJn0[5QOeJQ1Z5nNfJT1Y5lNgJT1Y5kNgJW1X5hNhJY1X5gNhJZ1W5eNiJ\\1W5cNiJ_1V5aNiJ`1W5_NjJb1U5]NkJe1T5[NlJe1T5ZNlJh1S5WNmJj1S5VNmJk1R5TNnJm1R5RNoJo1P5QNoJP2Q5oMoJS2P5lMQKU2n4kMQKV2o4iMRKX2m4hMRKY2n4gMQK[2n4dMSK\\2m4dMRK^2m4aMTK_2l4aMSKa2l4^MTKd2k4\\MUKd2k4[MUKg2j4YMVKg2j4XMVKj2i4VMVKk2j4UMVKl2i4SMWKn2i4RMWKo2h4PMXKR3g4nLXKS3h4lLYKU3f4kLYKV3g4iLZKX3e4hLZKY3f4gLZKZ3e4eL[K\\3e4dLZK^3e4aL\\K`3c4`L\\Ka3d4^L]Kc3b4]L]Kd3c4[L]Kg3b4YL^Kg3b4YL]Ki3b4VL_Kj3a4VL^Kl3a4SL_Ko3`4QL`Ko3`4PL`KR4_4nKaKR4_4mKaKU4^4kKaKV4_4iKbKX4]4hKbKY4^4gKbKZ4]4eKcK]4\\4cKcK^4]4aKdK`4[4`KdKa4\\4^KeKc4Z4]KeKd4[4[KeKg4Z4YKfKg4Z4YKeKi4Z4VKgKk4X4UKgKl4Y4SKhKn4W4RKhKo4X4QKhKP5W4oJjKQ5V4oJiKS5V4mJjKS5V4lJjKV5U4jJkKW5T4iJlKW5T4iJkKY5T4fJmKZ5S4fJmK[5R4eJmK\\5S4cJnK^5Q4bJoK^5Q4bJnK`5Q4_JPLb5o3^JQLb5o3^JPLd5o3[JRLe5n3[JRLf5m3ZJRLg5n3XJSLi5l3WJTLi5l3WJSLk5l3UJTLl5k3SJULn5k3RJULo5j3QJVLo5j3PJVLR6i3nIWLR6i3nIWLS6h3lIXLU6h3kIXLV6g3jIYLW6f3hIZLY6f3gIZLZ6e3fI[LZ6e3eI[L]6d3cI\\L]6d3cI\\L^6c3aI]L`6c3`I]La6b3_I^Lb6a3^I^Lc6b3\\I_Le6`3[I_Lf6a3ZI_Lg6Q50O2O001N2O001N101O0O2O001N2O001N101N101O1N101O0O2O001O0O2O1O001O0O2O001O001N2O001O0O2O001O001N2O001O001N101O001O1N101O001O0O2O001O1O0O2O001O0O2O001O1O0O2O001O001N101O1O001N101O001O010001N101N2O0O2O0O2O001N101N101N101N101O0O2O0O2O0O2O0O2O1O0O2O0O2O0O2O0O2O001N101N101N101N101O0O2O0O2O1N101N101O0O2O0O2O0O2O0O2O001N101N101N101O0O2O1N101N101N101O0O2O0O2O0O2O0O2O001N101N101N101N2O001N101N101N101NSJWJ[4i5dKWJ^4h5aKXJ`4g5`KZJa4e5^K[Jc4d5]K\\Je4c5ZK^Jf4a5ZK_Jh4`5WKaJi4^5WKbJk4]5TKcJm4]5RKdJo4Z5QKfJQ5Y5nJgJS5X5mJiJT5V5kJjJV5U5jJlJW5S5hJmJY5R5gJnJ[5Q5dJPK\\5P5cJPK_5n4aJRK`5n4_JSKb5k4^JUKc5k4\\JVKe5h4[JXKf5h4YJXKi5f4WJ[Ki5e4VJ[Kl5d4SJ\\Kn5c4RJ^Ko5a4PJ_KQ6`4oI`KS6_4lIbKT6]4lIcKV6\\4iIeKX6Y4hIgKY6Y4fIgK\\6X4cIiK]6V4cIjK_6U4`IkKa6T4_ImKb6R4]InKd6Q4\\IPLe6o3ZIQLg6n3YIRLi6m3VITLj6l3UITLm6j3SIVLn6j3QIWLP7g3PIYLQ7g3nHZLS7d3mH\\LT7d3kH\\LW7b3iH_LW7a3hH_LZ7`3dHaL]7^3cHcL^7\\3aHdLa7Z3_HfLb7Z3]HgLd7W3\\HiLe7W3ZHjLg7T3YHlLh7T3WHlLk7S3THnLl7Q3THoLn7P3QHPMP8o2PHRMQ8m2nGSMS8l2mGUMT8h2mGXMT8g2lGYMV8e2jG\\MV8b2kG^MW8`2iG`MX8_2hGbMY8\\2gGdMZ8Z2gGgMZ8W2fGiM[8V2eGjM]8S2dGnM]8P2cGPN^8o1bGQN`8l1aGUN_8j1aGVNa8i1^GXNb8g1^GYNd8f1[GZNf8e1ZG\\Ng8c1XG]Ni8b1WG^Nk8`1UGaNk8_1TGaNn8]1RGdNn8\\1QGeNP9Y1PGhNP9X1oFiNR9U1nFkNS9T1mFmNT9R1kFoNU9P1kFQOV9n0iFROX9m0hFTOY9k0fFVO[9MhFXOMl0[9_OUGD@m0]9]OTGE_Oo0]9\\OTGABT1[9YOSGADW1Y9XOSG^OF[1Y9TORG^OG^1\\9POmF_OIb1]9kN\\GV1g8gNWG[1l8aNTG_1P9^NoFc1[:1O1O001O1O1O1O001O1O1O001O1O1O001O1O1O1O001O1O1O001O1O1O1O001O1O1O001O1O1O001O1O1O1O001O1O1O001O1O1O001O1O1O1O001O1O1O1O2N2EgLbFZ3\\9hLcFZ3Y9hLgFZ3V9hLiFY3U9iLjFY3S9hLmFY3Q9hLoFZ3n8gLRG[3k8fLUG[3i8fLWG\\3e8fL[G\\3b8eL^G\\3`8eL`G]3]8dLcG^3Z8cLfG^3X8cLhG_3U8bLkG`3R8aLnG`3o7bLQH`3l7aLTHa3i7`LWHa3g7`LYHb3d7_L\\Hc3a7^L_Hd3^7]LbHd3\\7]LdHe3X7]LhHe3U7\\LkHf3R7[LnHf3o6\\LQIf3k6\\LUIf3g6\\LYIf3b6]L^Id3_6^LaId3[6^LeId3V6_LjIb3S6`LmIb3o5`LQJb3j5aLVJa3g5`LYJa3d5aL\\Ja3`5aL`Ja3]5`LcJb3Y5`LgJa3V5aLjJa3S5`LmJb3o4`LQK", "size": [425, 640]}, "area": 161062.0, "iscrowd": 0, "image_id": 13597, "bbox": [0.0, 0.0, 640.0, 425.0], "category_id": 123, "id": 20000815}, {"segmentation": {"counts": "n;8V1P1^9APFP3`7XMWH_3T7`LkH^3X7aLhH]3[7bLeH]3^7aLbH]3a7bL_H\\3d7cL\\H\\3g7bLYH\\3j7cLVH[3n7cLRH\\3P8cLPH[3S8eLlGY3X8eLhGY3[8fLeGY3]8fLcGX3`8gL`GW3d8gL\\GX3f8gLZGW3i8hLWGV3m8hLSGW3o8hLQGV3R9iLnFU3U9kLjFT3X9kLhFS3\\9kLdFS3_9lLaFS3a9lL_FR3d9mL\\FQ3o9O1N2N200O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O100O1O10mFQNl6n1SI\\Ne6c1[IfN]6Z1bInNW6Q1iIXOo5g0PJCh5=WJKb54^JNa51_J0a50^J2a5M_J4a5K_J7`5I`J8_5GaJ:_5EaJ=^5CaJ>_5AbJ`0]5_OcJb0]5^ObJd0]5[OdJe0\\5ZOdJh0[5XOdJj0[5UOeJl0[5SOfJn0Y5ROfJo0Z5POfJR1Y5mNgJT1Y5lNgJU1X5jNhJW1X5hNhJZ1W5fNiJ[1V5dNjJ]1V5bNjJ`1U5`NjJa1V5^NkJc1T5\\NlJe1T5[NlJf1S5YNmJh1S5WNmJk1R5UNnJl1Q5SNoJn1Q5QNPKP2o4PNPKQ2P5nMPKT2o4lMQKT2o4kMQKW2n4iMRKW2n4hMRKZ2m4fMRK\\2m4cMTK]2l4cMSK_2l4`MUK`2k4`MTKb2k4^MTKc2l4\\MUKe2j4[MUKf2k4YMVKh2i4XMVKj2i4UMWKl2i4TMWKm2h4RMXKo2h4QMXKP3g4oLYKR3g4nLXKT3g4lLYKT3g4kLYKW3f4iLZKX3e4gL[KZ3e4fL[K[3d4dL\\K]3d4cL[K_3d4`L]K`3c4`L\\Kb3c4^L]Kb3c4]L]Ke3b4[L]Kg3b4XL_Kh3a4XL^Kj3a4UL`Kk3`4UL_Km3`4RL`Ko3`4QL`KP4_4PL`KQ4`4nKaKS4^4mKaKU4^4jKbKW4^4iKbKX4]4gKcKZ4]4fKcK[4\\4dKdK]4\\4cKcK_4\\4aKdK_4\\4`KdKb4[4^KeKc4Z4\\KfKe4Z4[KeKg4Z4XKgKh4Y4XKfKj4Y4UKhKk4X4UKgKm4X4SKhKm4X4RKhKP5W4PKiKQ5V4oJjKQ5V4nJjKT5U4lJkKT5U4lJjKV5U4iJlKW5T4iJlKX5S4hJlKY5T4gJlKZ5S4eJnK\\5Q4dJnK]5R4cJnK^5Q4aJPL_5P4aJoKa5P4_JPLa5P4^JQLc5n3]JQLd5o3\\JQLe5n3ZJSLg5l3YJSLh5m3XJSLi5l3VJULj5k3VJTLl5k3TJULl5k3SJULo5j3QJVLo5j3QJVLP6i3PJVLR6i3mIXLS6h3mIXLT6g3lIXLU6h3jIYLW6f3iIZLW6f3iIYLY6f3fI[LZ6e3fI[L[6d3eI[L]6d3bI]L^6c3bI]L_6b3aI]L`6c3_I^Lb6a3^I_Lb6a3^I^Ld6S50O2O1O0O2O001N101O0O2O1O0O2O001N101O0O2O1N101O0O2O001N2O001O0O2O001O001N2O001O001N101O001N2O001O001N101O001O1N101O001O0O2O001O1O0O2O001O001N101O1O0O2O001O001N101O1O001N101O001O0O2O1O001O0101N101N101O0O2O0O2O0O2O0O2O001N2O0O2O0O2O0O2O001N101N101N101N101O0O2O0O2O0O2O1N101O0O2O0O2O0O2O0O2O001N101N101N101N101O0O2O0O2O1N101N101O0O2O0O2O0O2O0O2O001N101N101N101N101O1N101N101N101N101O0O2O0O2O0O2O0O2O001N10QJWJ^4g5bKYJ_4g5`KYJb4e5^K\\Jc4c5\\K]Je4b5[K_Jf4`5YK`Jh4`5WK`Jk4^5UKcJk4]5TKcJn4[5RKeJo4[5PKfJQ5X5oJhJR5X5mJiJT5U5lJkJU5U5jJkJX5T5gJmJY5R5gJnJ[5Q5dJoJ]5P5cJQK^5n4aJRK`5m4`JSKb5l4]JUKc5j4]JVKe5i4ZJXKf5h4YJXKi5f4WJZKk5e4TJ\\Kl5c4TJ]Kn5b4QJ^KP6a4PJ`KQ6_4nIaKS6^4mIcKT6\\4kIdKV6\\4iIdKY6Z4gIgKY6Y4fIgK\\6W4dIiK]6W4bIjK_6T4aIlK`6T4_IlKc6R4]IoKc6Q4\\IoKf6P4YIQLg6n3YIRLi6m3VISLk6l3UIULl6j3SIVLn6i3RIWLP7h3oHYLQ7g3nHYLT7e3lH\\LU7c3jH]LW7b3iH^LY7a3fH`LZ7_3eHbL]7]3bHcL_7\\3aHeL`7Z3_HfLb7Z3]HfLe7X3[HiLe7W3ZHiLh7U3XHlLh7T3WHlLk7R3UHnLl7R3SHoLn7o2RHQMo7o2PHQMR8m2nGTMR8k2nGUMT8i2lGXMT8f2mGZMU8d2kG\\MV8c2jG^MW8_2jGaMX8]2hGcMY8\\2gGeMZ8X2gGhMZ8W2fGiM\\8U2dGlM\\8S2dGmM^8P2cGQN]8n1cGRN_8l1aGTN`8k1`GVNa8h1_GXNb8h1]GXNe8f1[G[Ne8e1ZG[Nh8c1XG^Nh8b1WG^Nk8`1UG`Nl8_1TGbNm8]1RGdNn8[1RGfNo8Y1PGgNQ9X1oFiNR9V1mFkNT9S1lFnNT9Q1lFPOU9o0jFQOW9n0iFSOX9l0gFUOY9j0gFWOZ9BSGCBk0\\9@TGD@m0]9]OTGCAQ1[9\\OTG@CU1Z9YOSG@EW1Z9XOQG]OH\\1Z9SOoF^OI`1[9oN^GR1e8jN[GW1h8fNWGZ1m8bNSG_1Q9]NnFd1[:1O001O1O1O001O1O1O1O001O1O1O001O1O1O1O001O1O1O001O1O1O001O1O1O1O001O1O1O001O1O1O001O1O1O1O001O1O1O001N2O1O001O1O1O1O1O1O2N2EgLbFZ3\\9gLdF[3X9hLgFZ3V9hLiFY3U9hLkFZ3R9gLnFZ3P9gLPG[3m8fLSG\\3j8eLVG\\3h8eLXG]3d8eL\\G]3a8dL_G]3_8dLaG^3\\8cLdG_3Y8bLgG_3W8bLiG`3T8aLlGa3Q8`LoGa3n7aLRHa3k7`LUHb3h7_LXHb3f7_LZHc3c7^L]Hd3`7]L`He3]7\\LcHe3[7\\LeHf3W7\\LiHf3T7[LlHg3Q7ZLoHg3n6[LRIg3j6[LVIg3f6[LZIg3a6\\L_Ie3^6]LbIe3Z6]LfIe3U6^LkIc3R6_LnIc3n5_LRJc3i5`LWJb3f5_LZJb3c5`L]Jb3_5`LaJb3\\5_LdJc3X5_LhJb3U5`LkJb3R5_LnJc3n4_LRK", "size": [425, 640]}, "area": 110089.0, "iscrowd": 0, "image_id": 13597, "bbox": [0.0, 0.0, 640.0, 420.0], "category_id": 183, "id": 20000816}, {"segmentation": {"counts": "a=_1a=000O100001O000000001O001O001O0gN_Bf0NYO07i=?XBZOO7j=>WBZO42g=d0=N2O1O2NbA@\\>`0dA@\\>?eAA[>?dAB\\>a000001O001N9HcJLeHNY1OT67aHKTNNa<:WEMe:9WEH]NJVXDAM2N=j;2\\DK_OK2GOa0O_OV:0000000000000000000000011N3M2N2M2O000O020NK6O2O000000B`A<`>D`AK2N0KZA0W`?2dn@0O0SAOj>3YN7XDHb;e0SCG?G^]=CWCCm<>RCAn1?4L4L4L3M10O01O000000000fA^OV>o0GRORBk0Q>00001O0000001O00001O0000dEbNHJKW1k:IYEWO:3CGNW1j:WOWEM2N=2@P1j:TOcE_OK2GOa0O_O>0n0l:TOPF@TO0b0n1[:aNfF^1Y9cNgF\\1Z9cNgF]1X9`NTEEe1k1W9`NTEEd1k1Z9^NSEGc1k1Z9]NUEGa1l1[9\\NjFd1V9[NkFe1V9ZNiFf1X9YNiFg1YOTNj84mGh1VOTNQO0l93dGMfNg0I=m0SOQ9IcG2eNf0J;h0nNXO8_;LfDc0M9e0[Oi:IaDf035?@l:c0hDK;Cl:b0kDJ8El:`0PEI4Gl:?REI2Hl:>UEINIn:5oNRkNn;n1fIZN>e1C[N>c1C]N=^1HbN8Z1LgN4U1OkN1Q13POMk07UOIh0:YOFe0;[ODd0>\\OBc0?^O_Oa0c0_O\\Oa0e0_OZO`0h0AVO?a0L^O2>FXI@17X6c0f0@QIF27U6b0k0@TIMQ6b0l0ARIOQ6>o0BQI1o5a53\\1_OSIb0]5Mb1@RIe0[5IU27kMGW29iMFY29hMDZ2ZOnAOOe0Y>0000]OhA?W>@jA`0Z>103M6I7J6J3LN3M2O2N2N3L3N2N2N3M2M3N2N2N2N2MTjW4", "size": [480, 640]}, "area": 20896.0, "iscrowd": 0, "image_id": 13659, "bbox": [0.0, 100.0, 350.0, 380.0], "category_id": 110, "id": 20000819}, {"segmentation": {"counts": "gYS32l>4L3L5OOO3M101N1O1001O0O2O001O001N101N1N3MUIKoN3S10kNMW15i62N1O0000O11OJ6OGOeA1Z>1eAO\\>0dA0[>2dAN\\>2dAN\\>2cAO]>1cAOf>100O100`^g0MeaXOd0[OO2O1N1O000O]D@h85^D4f2G\\M0V;8hDL15n1b0Z9AiDLh1j0d9SOeD3b1o0S:QOiET1V:kNkEU1U:kNaELmNY1b;kN]E0QOV1`;kN\\E2TOS1`;kNYE5WOP1`;kNVE8ZOn0_;jNTE;]Ok0_;jNRE=_Oj0^;iNPE`0Bg0^;iNmDc0Ee0^;hNiDf0Ic0];gNgDi0L`0];hNcDk00>\\;hNaDl03=[;1eD0Z;0fD0Z;0fD1Y;OgD2X;NhD2X;NhD3W;MiD4V;LjD5V;JjD6V;JjD7U;IkD8T;HlD9S;GmD;Q;EoD=o:CQE?m:ASE`0l:@TEb0j:^OVEd0h:\\OXEf0f:ZOZEh0d:XO\\Ej0c:UO]El0b:TO^En0`:RO`EP1^:PObER1\\:oNcES1[:mNeEU1T:ZMiEa13V1X:jNhEX1V:hNjE[1T:dNlEa1P:^NPFg1l9XNTFl1h9TNXFQ2c9oM]FR2b9nM^FR2b9nM^FQ2c9oM]FQ2c9oM]FQ2c9oM]FQ2c9oM]FQ2b9PN^FP2b9PN^FP2c9nM^FR2c9lM^FT2R9`LUG[1KT2a9jM_FV2\\9`LaFX13Y2\\2cLV4M[IU12]2\\2aL_M1_6NVJ?@R3[2_LbM2]6NoJc3Q1]LdM2\\6OmJc3R1[LgM3Z60kJc3S1YLjM4W6n0gIm2W2QLlM4V6j0lISOGf3Z2XLoM5T6e0[Jk2P2`Ld3b0bJk2k1cLc3:jJS3c1cL]5]3cJcL\\5^3dJbL\\5^3dJbL\\5^3dJbL\\5^3dJbL\\5^3dJbL[5_3eJaL[5_3eJaL[5_3eJaL[5`3dJ`L\\5`3dJ`L\\5`3dJ`L\\5`3dJ`L[5b3cJ_L]5a3`JbL`5^3^JdLb5\\3[JgLe5Z3WJiLi5W3UJkLk5U3RJnLn5R3oIYLkMe0U8S3nIXLoMe0S8T3jIWLVNe0P8T3gIXL[Nd0n7T3eIXL_Nd0l7T3cIXLbNe0k7m1mG_NS2Dm5k1WH^Nm1Gm5f1]H_Ng1Kl5a1eH`N`1Ok5\\1mH`NZ14i5W1UIaNR19i5R1[IaNn0=g5P1`I_Nj0a0f5o0dI\\Ng0e0e5m0YLSOg3k0ZLVOf3i0[LWOe3g0]LYOc3f0^LZOc3c0_L]Oa3b0_L_Oa3?aLA_3=cLC]31N2^ONmA2M1V>9hAGY>a002M1O1O2O1N1O10O0HRB_Om=2dBLY>01NQl11mSN10000\\`h4", "size": [480, 640]}, "area": 334.0, "iscrowd": 0, "image_id": 13659, "bbox": [288.0, 274.0, 26.0, 37.0], "category_id": 123, "id": 20000821}, {"segmentation": {"counts": "0Y6g81OO11OO11OO100O100001O00O100001O0000000000001O0000000000000000001OL\\GkIe8m5[GSJ020Mf8l5aGTJb8l59O1L4000000N2000000O1O10;XOZF_KT:l3lElK1N0:c:[3hEaLe:Q3^EjLBOb;f2W1]ON2N110O10PT51S]J3`>:M4000N2OKBfA=Z>CfA=Y>6N1O1010Ob0F>B2N0O10O10N200000O01000O100000000O8I8D4AcA0\\P7`0l]I40O20OO10O20OO1O10000000[OhAb0X>_OgA?[>@fAb0X>^OhAc0W>]OjAb0V>^OkAa0Z>01O000000N@dA`0\\>@dA`0\\>@dA`0\\>2O11OO10000O1000_OWef0M][YO0O6K2RNKmD5YNKd<2RE9m:GSE9m:HRE8m:IQE9o:GQE9o:GRE5Q;KoD5g:5XELg:5YEKg:4ZELf:3[EMe:3[EMe:3[EMe:3[EMe:3YEA]N;[<3XE0h:0XE0i:NXE2i:LXE4i:KVE6k:C[E=d<2N000001O0000004L00O10010O1O1OF:JfQ\\10_ncN2M3N1N3N2M3N1M4L4L3N3M3MKVBXOh=g0]BXO_=i0=N2O2N1O2O0O2N1O2O000O2O_OCaB;S>N1000000O101O0O2O001O0O2O001O0010]X]29YgbM0^AFh<7cD4cNFj<7bD6];MaD3^;McD4[;MeD3\\;LcD5\\;LdD4^;JbD6^;KaD5b;J\\D6`;KbD6^;a0kC_OWMYAOVmP24baoM3L4M4M2O000cA_O[>b000101N10000O10000000000OM401O1O1O10O1O00000000000000000001O000001O000000O10000O11OO1010O00000000000000000000000001L301O2N1O1O1O2N1O1O1O2N1O7I6^C\\N\\;j1]DXNb;l1YDVNh;i1UDZNj;g1TD[Nk;g1QD\\Nn;e1oC^NPf0b;d0SDdN=h0b;c0dD[Od;ZOTD?=5^=N5DdAMi>NQ\\R5", "size": [480, 640]}, "area": 5976.0, "iscrowd": 0, "image_id": 13659, "bbox": [0.0, 197.0, 293.0, 270.0], "category_id": 143, "id": 20000824}, {"segmentation": {"counts": "Y6Z1g=OO0_BiN\\=]1O3OOO3N8G;F0001OWClM02a8000000000000KGcA9_>32N1N104LM3O10000000001O000O1011N22M01N2N1O2M3L30Qgb00mX]O3M1N3FIhA8X>HgA:X>GfA:\\>DbA?`>O2O2M2O2M2O2M2OXSU4OhljK00000O100000001cM7`EJ\\:`0]EA_:i0YEYOb:R1WEoNh:\\1lDfNT;R2SDoMl;KoCa2Q0[A020M0b>7^ALb>9O1L4000001M1100000O1O100O100O11OPD_Oa9a0^FE^9:mE[O^N0`0`0Q;5QF]OaNO6b0V;2SF]OaN04b0X;1RFFdN:Y;1QFHeN7Z;1SFI_N7^;OTFb0m9]OSFc0m9]OSFc0m9]OoEg0Q:YOoEg0P:ZOPFf0o9[OPFf0Q:YOoEg0Q:YOoEg0R:XOnEh0R:XOoEg0R:XOoEg0Q:YOQFd0Q:[OoEe0R:ZOnEe0S:[OmEe0T:ZOlEg0T:XOlEg0V:WOkEh0W:WOiEh0Z:VOfEj0[:UOeEk0\\:TOdEm0]:QOcEn0_:QOaEo0a:oN_ET1`:jN`EU1V<0XBkNf=W102N001N1`BiNW=X1hBlNT=`101OlNmB;S=DoB;Q=DRC:nb>N1O0000O1O1O1O1O1O1O100N2O1O1O1O1O2O0O1O100O1O1O1O100O001O010O0100O2O1N101KnAXOS>f05N1N6CaA0c>M]A2j>N1NVfi6", "size": [480, 640]}, "area": 4591.0, "iscrowd": 0, "image_id": 13659, "bbox": [34.0, 178.0, 141.0, 136.0], "category_id": 167, "id": 20000826}, {"segmentation": {"counts": "P^g0;l4Fl4g0_JYOlK1N0g9V1nIUOo5W1cIlNjLBO0\\9S2ZIbNf6P2gHRNX7Y2fFoLd1h0f7f2PHZMP8W3^GjLb8]3WGbLj8^3hFPMX9P3fFRMZ9n2dFUM[9j2fFVMZ9j2eFWM[9i2eFWM[9V41O11O001O001O001O1O00_MiFlL0^AE^>>cAC]>=cAC\\>>dACk=2UBM0e00]Oh=S101O000000NYBkNg=U1YBkNg=U1YBkNg=U12LWBPOj=P1WBPOh=P1XBoNi=Q1WBoNi=Q1WBoNi=Q130000000000000000000000000000O1000000000000000000000000000RBQOk=o0UBPOl=P1TBZOb=R10001O2N1OO1GaBkNe=P184LM300000000000cEnNl6R1TIFT6:lIEU6;kIFT6:lIEU6;kIEU6;kIoNhL<]9e0X4000000000bFROj4n0VKROj4n0VKSOi4m0[KoNe4Q1e400000000000`FQOo4o0QKROn4k0fFQO\\45n4j0fFQO\\45n4j0fFQO[46o4i0fFQO[46o4i0RKWOo4i0PKXOP5h0PKXOP5h0oJYOQ5g0oJYOQ5g0nJZOR5f0nJ[OQ5e0jJ@V5`0kJ_OU5a0kJ_OU5a0kJCQ5=oJCQ5=oJBR5>mJCS5=mJDR56K0M4AGkA05a0i=`0L1000N22TBmNg=X1XBjNa=]1N008GM400N2000O0oNcNaD]1^;lNVDX1i;iNhCC0o1X00O1O11O00001O1O001O000000002aC_M41P2P:g1[E`N:0[:c1TEFl:Q2SEYLm:d3900000000000000000000O2O000000O1000O1000000000000ORE^L`:b3`E^L`:h1VEL;\\N_:g1[EI6aN^:e1`EF3eN]:d1eEBNkN]:b1iE@JnN]:a1mE]OFSO]:_1PF[ODWO[:\\1TF\\O@YO\\:Z1VF[O_O[O[:Y1WF\\O]O\\O\\:X1XFZO\\O_O\\:W1XFYO]OAZ:V1ZFXO[O\\OFOd:]1[FWOGZOn9_1\\FUOa:k0_EUOa:k0`ESOa:m0_EROb:n0^EROb:n0_EPOb:P1^EoNc:Q1^EnNb:R1^EmNc:S1]ElNc:V1_EdNYOKg:a1iF_NW9b1gF_NY9a1gF_NY9b1eF_N[9a1eF^N\\9c1P2001O001G8L50O000010O00000O21N00O10B_C]Na[7AeH?\\7AcH?]7AcH?^7@bH`0^7@bH`0_7_ObH`0^7AaH?`7@`H`0`7@`H`0a7_O_Ha0a7_O_Ha0b7^O^Hb0n5]NYIR1i0`0m5fNTIi0o0a0l5nNnHa0V1a0k5VOiH8\\1POfM`1T8_OcH1c1oNgMa1R8CbHLe1QOfM`1R8G`HIg1POgMa1Q8H`HFh1g0e5G`HBl1h0a5IbH^Om1j0_5LaHZOP2l0]5LbHWOQ2n0[5OaHTOS2o0Y50cHPOT2R1V52cHlNW2S1U53cHiNY2S1S5U1mJkNR5V1nJkNP5W1oJiNQ5W1oJjNo4W1QKiNn4X1RKiNj1nMlNZ3ZOhNj1PNjNW3\\OkNi1SNeNP3DnNf1XN`Ni2LoNd1\\N\\Nc21ROc1`NVN\\29UO0VNaNUO0jNkMIf1X2?UO0jNkMIe1Z2>TO2iNkMId1\\2=SO4hNjMJd1\\2>RO4hNjMJd1]2>PO4iNjMJc1^2a0mN2kNjMJc1_2b0jN1mNjMJc1_2d0hNOoNiMKc1`2f0dNNQOiMKc1a2g0aNMSOiMLb1`2i0`NKUOjMKMSO[1^3R1_NLUOiMLI\\O[1T3X1^NKUOjMb0m0l1]1]NLUOjMg0g0h1c1\\NLUOjMm0a0c1h1[NMUOiMR1?]1l1[NLVOiMR1`0\\1k1\\NLVOjMP1a0^1h1\\NMVOjMP1b0]1g1]NMVOjMo0c0_1e1\\NNVOjMo0c0_1e1\\NNVOjMe0NXNf0b3c1[NOVOjMe0m0j1Z1[NOVOjMe0m0k1`0aLmNi1l1VOjMe0m0k1e3^MmLT2\\O`0k3XMiLX2[Oa0o3TMgL[2WOc0V4[LdKLo0V3VOd0o4ULkKX3SOe0S5RLjKY3ROf0T5QLjKY3POh0W5nKiK[3nNh0Y5mKiK[3lNj0`4nKmKMg0\\3jNj0a4\\L`K]OV1]3gNl0b4dLgL`2fNm0a4dLjLn6U3SIkLm6T3SImLm6S3SImLm6S3RIoLm6Q3TInLl6R3XIkLg6U3YImLe6S3[InLd6R3\\IoLc6R3]InLb6R3^IPM`6P3YIaKUO`1a7o2YIdKTO^1b7n2ZI[Me6f2YI]Me6d2ZI`Mb6a2\\IfM8gMS5d4dJkM2cMY5c4cJQNM^M_5b4cJRNJ_Mb5`4bJSNJ_Mc5_4bJSNI`Md5^4aJUNG`Mg5a4[JQNIcMk5d4TJaNk5[5O1O1O1OmN\\JkHc5T7cJhH\\5W7eJjHZ5U7hJiHY5V7iJiHW5U7kJkHU5T7mJkHS5T7nJlHR5R7QKmHo4R7RKnHn4Q7TKmHm4Q7UKQIi4n6XKUIe4i6^KWIa4h6`KYI_4e6cK\\I\\4c6eK_IY4`6iK`IV4^6lKcIS4\\6nKdIR4Z6QL]IgN_OW5S7SLoHWOLf4S7RMmHm2R7VMlHj2n4gJUMk7i2[HQMg7n2]HnLd7Q3`HjLX2\\Nb2i4ZKgLT2bNa2e4aKeLm1gNb2c4eKbLj1lN`2a4jKULPO_Oa20e2Z4QLQLiNFj1f0\\3b3YLjKbNNe1k0_3\\3aLdK\\N5_1P1d3X3iLgKCS1c3V3jLgK[OHlN[1o4V3jLgKWOLPOW1o4V3jLgKSO0TOT1n4U3kLgKPO3WOQ1n4U3kLgKmN6ZOn0n4U3kLfKkN:\\Ol0m4T3lLfKhN=_Oi0m4T3lLfKfN?Ah0l4T3lLeKdNb0De0l4T3lLeKaNe0Gc0k4S3mLfK]Ng0Ka0j4X3hL`K`Nj0N>j4^3bL[KbNl02a2k0XNoN\\Oi2i1QN`N4BfN0d0_2k0UNSO@c2f1WN`N1HYO[2k0nMkNDO5k2c1[N_Ni0W2YOeMA0S2d1^N\\Nf0Y26dMjM3l2b1R1e0jNhM4a1T1e0[NhMeM2l2`1U1e0kNjM0_1V1e0mNmML]1X1d0oNnMI\\1Z1d0oNPNG[1[1d0POPNEZ1]1e0oNQNDX1_1g0W2XOiMh0oNQNBT1a1j0X2UOiMj0X2TOjMl0V2SOkMk0W2SOjMl0X2ROjMk0Y2UOgMi0[2WOeMi0\\2VOdMi0^2VOaMj0b2UO]Mj0f2jN\\HKn4Z1i2`NbH6e4Y1[O_NA8S1Y1Y3gNfLZ1Z3gNdLR1d3nN[LS1e3nNYLR1h3nNWLS1i3nNVLR1j3oNTLR1l3nNSLS1HaNI==V1H]NJ==Z1FYNM>;]1EWNN=;_1EUNO<;b1DSNO=;d1CnM3>9g1BkM5`06h1DfM6e03h1EbM9h0Oj1E^McKEU3H^1b0_KCjNQOR4f0j1h0WK@ROUOg3?T2o0oJ]OXO[Oj2LVM9o5T1fJ\\OWOGR24RNAT6Y1_J[OUOP39XLX6]1WJ[OUOT3[IZOJV39lLb6d0[IZOKj2j0QMP6k0ZIZON]2[1WM]5S1XIZO1o1S9gNlFYO2e1]9RO`FZO4W1h9@RFYO6l0KfNg9U1XFXO42@Nc0J`9n0XFYO23F_Oj09U9m0WFXO34i0Hn8n0PFYO73j0Hn8d1WFfNF_Ok08Y9b1TFhNGEf03^9_1TFkNHDe02`9]1RFnNIEc02a9[1QFPOKCc06^9U1QFK=UO^9Q3[FSMb9g3WFiKe9W4_FiK^9V4fFjKV9V4nFkKn8T4VGmKe8S4_GoK[8Q4hGQLS8o3QHQLl7n3XHoKg7Q4_HgKc7Y4dH]K_7c4`1N1L4M3MkEjKf9T4UFSLl9i3QF]Lo9a3lEfLT:S4001O0000000000XIYKW3g4aLaK_3_4XLiKi3W4oKQLQ4o3gKYLY4g3^KaLd4^3TKjLl4V3kJSMU5m2cJZM^5f2YJcMg5]2QJjMP6V2hIRNX6n1_I[Na6e1WI\\NP7o0oH]O[7b0hHSOa7m0\\HlNn7S1RHdNX8\\1hG[Na8d1`GRNk8m1UG\\Mb9c2_FeLY:Z3gE`L`:^3bEcL]:\\3dEeL\\:X3fEiLZ:T3hElLY:R3hEoLW:o2kERMU:l2lETMU:i2mEXMS:e2oE\\MP:c2QF]McoM]:o0QET1c0mM\\:U3eEkL[:T3fElLZ:T3fElLZ:S3gEmLY:R3hEnLZ:o2gEQMX:o2iEQMX:n2m0O1O2N1O100bMlCF0U2Vb03O0O100O1O1O1O1O1O1O1O1O1L4MUA1nan0", "size": [480, 640]}, "area": 60941.0, "iscrowd": 0, "image_id": 13729, "bbox": [0.0, 267.0, 575.0, 213.0], "category_id": 101, "id": 20000832}, {"segmentation": {"counts": "j`g42m>6K5M3M3MN2N3M7IeW`4", "size": [480, 640]}, "area": 107.0, "iscrowd": 0, "image_id": 13729, "bbox": [323.0, 121.0, 9.0, 23.0], "category_id": 105, "id": 20000833}, {"segmentation": {"counts": "Q]\\81n>3N1O0KN\\A2c>0\\A1c>601O1O001O01O1OHDlAEkA;S>HlA8T>HlA8T>IkA6V>JjA2MKY>3jA1NLX>3hAKO72IW>6gAJ063JW>5fA3_>7000000001O0001M1N3M32M4MO12N003M00M4OEbA4f>O1O010OO1001O0000M3O11O0O101O000O1O1M4N1OVT1", "size": [480, 640]}, "area": 809.0, "iscrowd": 0, "image_id": 13729, "bbox": [572.0, 268.0, 65.0, 29.0], "category_id": 121, "id": 20000834}, {"segmentation": {"counts": "0W2n2oNg5Q1YJoNg5Q1YJoNg5Q1YJoNg5Q1YJoNg5Q1XJPOh5P1XJPOh5P1XJPOh5P1XJPOh5P1XJPOh5P1XJbNWMAa8n1WJ`NZMA_8o1WJ_N[MB^8o1WJ^N\\MC]8o1WJ\\N^ME[8o1VJ\\N`MEZ8o1VJ[NaMEZ8P2UJZNbMFb8g1lIbNcMGi8JjFb1l2jNbMIi8KiFb1R3bN^M1j8]1^J_NXL0\\9`1P4001O00000001O000000000003J[NkBj1oO1O2M2OVQ8;XnG:L2M2N33M0O10O1001O0O103K7KT]f1CPbYN0YC8hc0^7^OeKl1_LTN=c0]7\\OTH0`3o1cLRN:d0_7[OUH1[3P2gLPN9e0e7[OYKQ2iLPN8d0`7ZOYH1T3R2lLoM5e0j7YOUKS2lLPN4e0U;[1gDPN3f0V;Z1fDQN2g0X;X1fDQN4f0[7ZOjHOe2R2oLPN7e0S7AZLk1[LoM8e0S7AZLR2cL^NQ7@^LQ2bL^NP7A^LQ2bL^NP7@aLQ2^L_NJ[On65kLU3VLdLQ77jLT3ULdLR77lLS3QLgLS76oLW3o2hLUMU3k2kLYMP3g2QM]Mk2c2TMaMi2_2WMeMd2\\2[MhMb2X2^M19OG28NG38NH37MH57KI57KI66JI86HJ86HJ94IL73IM73IN71I07OI17NJ36LJ47KI6`71O001O001O1O0WbQ1HQ]nNP1I8K4F;H7K500O2O0O100O[N^Cm0c1O2N1O1O1O1O001O1O1]AE^>a0G_OkAd0V>]OiAc0W>]OiAc0W>]OiAc0W>]OiAc0W>7MK4O1[OgAc0\\>N100_OcA?`>N200O00000001^AC_>=aAD]>=cAC]>=cAC]>`00000000000000KcAG]>NcA80H0O^>0bA100020N0O^>0bA1000O10O100]>OcA100000O10O1cee6", "size": [480, 640]}, "area": 699.0, "iscrowd": 0, "image_id": 13729, "bbox": [139.0, 49.0, 46.0, 28.0], "category_id": 130, "id": 20000836}, {"segmentation": {"counts": "_\\m7140dT5;_YK=mAYOl=h0TBXOl=i0SBXOk=j0TBVOk=Q1O0^OPOSCR1kcCB@2MMn<;jCF\\O1P=3jCLUO2[>LiA1W>OjA0dWm0", "size": [480, 640]}, "area": 1083.0, "iscrowd": 0, "image_id": 13729, "bbox": [540.0, 232.0, 38.0, 62.0], "category_id": 139, "id": 20000837}, {"segmentation": {"counts": "PgZ71o>00000O2cMN`C100T22YNND0j;RDh[l7", "size": [480, 640]}, "area": 5472.0, "iscrowd": 0, "image_id": 13729, "bbox": [0.0, 267.0, 101.0, 213.0], "category_id": 167, "id": 20000839}, {"segmentation": {"counts": "W2n2R<00000000O1000000000fDWM^:h2aEZM^:f2aE[M_:e2`E\\M`:d2^E^Mb:a2^E`Mb:`2]EaMc:_2\\EbM\\8LQIb2bNcM]83TG@b1l2jNbM`82TG@b1R3bN^Mh83fHU3[7lLdHT3\\7lLdHS3]7mLdHR3\\7nLdHR3\\7nLdHR3\\7nLdHR3\\7nLdHR3\\7oLcHQ3]7oLcHQ3]7oLcHR3\\7nLdHR3\\7nLdHR3\\7nLdHR3\\7nLgHo2Y7nLRG_Oj1^3T7RMTG_Om1Z3o6WMWIg2i6YMWI^2R7bMnHm1c7SN]Hm1c7SN]Hm1c7SN]Hm1c7SN]Hm1c7SN]Hm1c7SN]Hm1c7SN^Hl1b7TN]Hm1c7SN]Hm1c7SN]Hm1c7SN]Hm1c7SNjFFh0W2^8SNiFJb0W2e8RNXF]O:;8FGd2_9XNXFRO0`0B1O001Oc0]O1O2N1O2N1O2N1O2N1O2N1O2N1O2N1O2N1OO1002N2N2N2N3M2NK5F:]Oc0_Oa0]Oc0@`0K50000000000O100000000000000O10000000000O1O1O1O10000000000001O00O11O00000000001O1XBiNe=Y10000000000000000000000000O100O1000000000000000000000000000000000000O1O100000000O1000000000000000000O10000001O1O00001O000000O100O10000000000MWBoNi=i0;JSKH^K8W43iKMl3>TLBY3Q1gLoNX3R1hLnNU3U1kLkNR3Y1mLgNP3\\1PMdNP3]1oLcNR3W1SMhNn2S1WMmNi2X1RMiNm2V1TMjNl2=cH\\Oc47k2:eH\\Ob49j25kHA[4>f2JWIGS4b0b2BhNb0i73M001O0000000000000000N21O1O00N200H80000O1O100000000O100000000000000000000001O000000O1000000000000000000000000000000000000000`KA_J?^5H^J8^5MaJ3]51aJO\\55cJKZ59eJGY59iJGY55iJKU56lJJV5@kF5R4;m2EgJHo2c0Q2L04F1?OWO7m0IkN2N9GNeAGK0Q11k;>SCA10P13k;`0TC^Ol0ORO7mj<:kCOS<0iC7TOHh;;fC_Oc0<3N^;7fDFN:T;1iDG69o:0jDH95n:3TD^Oc09=ODIg:d0VEEa0JR;a0]DEb0FT;e0iC[O?:m=GR=JaB`02O1N3N1N2O1N2O001N2O1N100O10000N2WGLc28YMi0e1[OYNc1a0gN^Oe1\\KWMS3R2ERNUNl33ULeNP3S3eM]M\\4CgNo2oL\\Mj8c2YG[Mg8e2ZGYMg8f2[GXMf8g2]GWMc8i2^GUMc8j2`GSMa8m2aGQM_8n2cGQM]8n2eGQM[8o2fGPMV8S3lGlLP8W3RHhLj7\\3j12N3M3N2M3M2O2M3M3M3N2M3M3K5aNcKVHb4f7gKPH^4k7lKkGY4P8QLfGU4U8]1O1O1O2N1N3O001N101O1O0O2O2N2N2N3L3N3M[OiHcIU7[6YI]Ic6a6aIcIX6]6jInIj5P6YJPJZOZOS6f6eJhI_OBk5e6hJbIDIc5e6kJ^IEN^5d6nJZIH2Z5c6lK]IU4`6mK_IU4_6lKaIV4\\6kKcIW4[6jKeIX4W6[2N4L3M3N2N3L3N2N2M3YK^Fk3c9RL_Fn3c9nK_FQ4c9lK_FT4^3^K_2;UJV4Z3aKb28TJV4\\3aKTMOd47lJZ4\\3_KWM1_44oJ[4]3`KVM3\\4ORK^4\\4cKa0MSK`4`4bKg0^4\\OaKkMOL`4kMaKP4OUN;GU4SNcK`1Mb00O?KQ4SNdKa6>[Kn3TNfKZ6c0aKg3SNiKY4JhLX1k0T3TNkKZ46hK]1h1c2UNlK[4`2_Mc1UNoK]4d1ZKfNS2g3UNQL^4^1^KiNn1j3TNPLa4X1bKnNh1k3RNQLe4R1cKYO_1f3WNQLg4k0eKGV1]3]NRL_50PKj0k0n3b4fJfJe1>g3c5bLTJ_3j5lLlIV3R6oLhIS3W6PMfIR3X6PMfIQ3X6n2N3M3mLTGKQ92oFLU92kFMX92hFK]92cFoN=gNS9X2`FgNl0jNh8]2]F^NZ1oN]8`2YFWNb;g1_DnMm;P2SDfMZ30]OgA`0X>AhA=Y>ChA\\5NZJd1nNVNY19`5LZJd1iN]NZ14`3@fL;Gc1eNeNZ1O\\3IlLOId1aNkN[1JV34RMCLa1`NUOX1DX38QM^OO]1_NAU1]O[3;PMYO1Z1_NLQ1WO_3=mLVO5]3ROQMl3?kLRO7i3fNhLV4`0kLoN9S5l2nKkLVO2l4S3oKhLDH@SOU4\\4hLgL2]OoNAX4[4gLeLa0SO^3X4RLcLY6]3gIaL[6^3gI_L[6a3eI]L]6c3dIZL^6e3cIZL^6f3cIWL_6i3bITL`6k3eIoK]6Q4gIiK[6W4W2O10@`0J6J6J6J7I6J6O11O1O001O100O1O1O1O1O1O11O0O2mGXJk6i5PI[JP7f5kH_JT7a5iHbJn5F_Ji5^OeJl5HgJh6R5_InJb6k4dIUK\\6d4kI\\KU6]4RJcKn5Z4UJfKl5W4VJhKk5V4WJjKi5S4ZJmKf5Q4\\JoKe5n3]JRLc5l3_JTLa5j3aJVL_5g3cJZLOlNd3h4_L\\LKmNh3d4_L_LFoNl3_4aLbL@QOP4Y4dLeLZOUOR4R4hLiLTOVOV4k3kLoLlNXOZ4W2_JhN_2JdNYOb4o1^JjN`20\\NXOj4g1^JlNa27RNYOS5]1]JoNc2P:@RF`0o9\\OSFe0S<1O100O1O1O1O100O1O1O1O100O1O1O100O1O1O1O100O1O1O1O1`J\\OdLd0Z3^OeLc0Z3^OeLc0Z3^OeLc0Y3_OgLa0n2JQM7n2JQM7o2IPM8P3HoL9Q3jN^H`0a4f0R3iNbH6a4R1_3dNiL]1\\8100O1O1O1O100O1O1O1hKWNXKj1T4lNjKT1T4oNjKR1T4POkKQ1P4TOoKm0m3XOQLi0l3ZOSLg0l3[ORLf0m3XOULi0k3UOVLl0j3jN`LV1l3nMcLS2T81O1O1O1O1O1O1O1O1O1O100O1O1O1O1O1O1O1O1O1O1O100O100O100O1O100O100O100O100O100O100O100O100O100O010O100O100O100O100O10000000000WMdLnI\\3i5nLVJR3j5oLUJQ3k5oLUJQ3k5oLUJQ3k5oLUJQ3k5oLUJQ3k5oLUJQ3k5oLUJQ3l5nLTJR3l5eL]J[3d80000000000000000000001O0000^D", "size": [480, 640]}, "area": 90814.0, "iscrowd": 0, "image_id": 13729, "bbox": [78.0, 54.0, 562.0, 425.0], "category_id": 183, "id": 20000842}, {"segmentation": {"counts": "g:Y4g:0000000000000000000000000O100MgK_EY4a:3O1N20000001OO1000000001O00002N1O2N1O001O0000000000000000000000000000000000O1O10000O100001O00O100001OO100000000000000000000002NO10000001O0hKZEV4f:jKZEV4i:OO1002N1O00O1000000000000O1001O00O100O100O1000000NiK[EW4e:200O11O0000O100000000000000000000O100000000000000000000000L]EiKf:i3a0OO00000000O10O010O10000ODkDnLV;R3jDeL12OMW;b2iDTNd;j1eDnM\\;o1\\DdM71IO0O00f;1YDT20mM>NE010c;1YD00Q2l<1OL310O1000O01NQCSNP=l10BPCeN05P=T1SCgNM4Q=S1oBfN81H1S=W1b0O1O2N2OO10O2O0O1O10000O10O10O10O010001N100O1SOoAl0P>TOPBj0T>02N0O2O000N2N20000O10O1O001O010NN0_OgAc0Y>O300O1000000O10000O1000O010OONBdA`00@Z>d0NOhA^OX>b04N010O01001OO0100000001O2@`AN2H[A3g>KZA3j>0o^c2Oo`\\M3WAKc>;N2N3O000O11O0O11O001O00O1001O00O120ObABX>e0N3M00100N10001O01OO3N0RBPOm=o0SBQOm=Q10O100000N3BnNbB15R1S=YOhBj0X=`0N2N101O001O0O1000O12N1N2O10OUCPNeO2O0000O1001O01N02OO100O11O001N011O0O010000000000O20N100O1000000dD^L:0d:0REb31_L50j:d3SE[LN1P;c3RE]LM0Q;e3oD_L0KP;n31N1001O00O100000000002N00N20PETLm:l3RETLO030f:U4YEkKd:X410O0O11O00O020O0O10O02OO102NN201iEfKf9[4nEeK00N5S:X4mEdK08U:`4N2001OO100000000001O00O12N0000O1003M00M30VKmEg4S:YKmEg4V:000N20000003MNZKjEf4V:21O000000O100000000001O", "size": [480, 640]}, "area": 44745.0, "iscrowd": 0, "image_id": 13774, "bbox": [0.0, 317.0, 640.0, 163.0], "category_id": 154, "id": 20000843}, {"segmentation": {"counts": "Z9]1c=00000000000000000000000000O100M]BiNc=W13O1N20000001OO1000000001O00002N1O2N1O001O01O0000000000000000000000000000000O1O10001N100001O00O100001OO01001OO100000000001O00O3ON10000001O0\\BfNb=Z1^BfNb=]1OO1002N1O00O1000000000000O1001O00O10O0100O101O000N]BgNc=Y1200O11O0O11N10001O000000000000000O100000000000000000000000_FjNiK1\\9V1]JYOc5i0\\JVOd5j0\\JVOd5j0\\JVOd5j0\\JVOd5j0\\JVOd5j0[JWOe5i0[JWOd5i0\\JXOe5g0[JYOe5f0\\JZOd5f0\\JZOd5f0\\JZOd5e0PJjNnLb0R9d0PJjNeL12OMc0\\9c0VIjNTNP1f86TISOnMh0n85QIkNdM71IO0O00R1\\93eFjNT20mM>NE010o0Z95gFhN00Q2R2Y7[OhHd0X7\\OdHh0\\7WOeHi0\\7VOcHk0\\7VOdHj0\\7VOdHj0\\7UOdHl0\\7TObHeNSNW2[9UOaHm0_7QOSHfNeN05Z2S9oNQHjNgNM4[2T9nNoGgNfN81H1]2Y9lNnGf1R8ZNmGg1T8XNkGi1V8WNhGj1X8WNgGi1Y8VNhGj1X8VNgGk1Y8VNfGj1Z8VNeGk1[8UNdGl1\\8TNdGl1\\8TNdGl1\\8TNcGm1]8SNcGm1]8RNdGn1\\8RNcGo1]8QNcGo1]8PNcGQ2]8oMcGQ2]8oMcGQ2]8PNaGQ2^8PNbGP2^8PNaGQ2_8oMdFgNl0Y3_8QNeFfNj0[3a8QN_Go1a8SN]Gm1d8RN[Go1d8SN[Gm1e8SN[Gm1f8RNXGP2h8PNVGR2j8nMVGR2k8mMUGS2k8mMTGT2l8lMTGT2l8kMUGU2j8kMVGV2i8jMXGV2h8iMXGX2h8hMXGX2g8gMWG]2h8`MgFiNc0g3f8`MYGc2g8]MYGc2h8\\MWGe2j8ZMVGf2j8ZMVGf2j8ZMVGf2j8ZMUGg2k8YMUGg2l8XMTGh2k8YMTGh2l8XMTGh2m8WMSGi2m8VMSGk2m8UMSGk2m8TMRGn2o8QLcFi00VO`00@n3^9RLcFi0c0U3j8RLdFf0a0ZO^On3b9gLPG\\3Q9dLmF]3S9bLnF^3S9aLlF`3T9_LmFa3S9_LmFa3S9`LlF`3T9_LlFb3T9^LlFb3T9^LlFb3T9^LlFb3T9^LlFb3T9_LkFa3U9aL[F[Oa5D]J=c5C]J=a5E`J:`5F`J:`5F_J;a5E_J;a5E_J;b5D^Ja5E_J^OTLi0]9UOdFb0k3_OTLO030a0]9\\OdFc0T4_OkK>]9@dFd0W4LU5@dFe0W4JY55gJKY54hJLX55gJKY55gJKY54gJMY54gJKY55gJKY54hJLX54gJMY52iJMW53hJNX52hJNX54fJLZ52hJNX52iJLX54iJ@eK00Ng9a0fJ_OdK0j9c0`4N2001OO100000000001O00O12N0000O1003M00M30dA_OY>a0gA_OY>d0000N20000003MNhA\\OY>c021N11OO11N1000O1001O01\\F", "size": [480, 640]}, "area": 66820.0, "iscrowd": 0, "image_id": 13774, "bbox": [0.0, 298.0, 640.0, 182.0], "category_id": 155, "id": 20000844}, {"segmentation": {"counts": "0Z9f500000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000001O000000000000000000O1001OO100000000001O00O11O00000000000000000000000000000000000000000000000000O10000001O00000000000000O11O00001O00000000000000000000000000000000000000000000000000000000O11O000000000000000000N21O00001OO10000000000000000001O1O0000000000000000000000000000000000O10000O100001OO1001O00001O000000O1O10000O1O100001O1O000000001OO1001O0000001_JcF]5^9bJcF]5i6gJdKLdM\\5c6oJlKP5S4QKnKn4Q4SKoKm4Q4TKoKk4P4VKPLj4o3XKPLh4P4XKPLh4P4XKPLh4P4XKPLh4P4WKQLi4o3WKQLi4o3WKQLi4o3VKRLj4P4SKQLm4P4QKQLo4P4oJQLQ5P4mJQLS5n60N20000001O000000001O000000000000L4K5L4O100O1000000O1HWJYGi5d8;00O10000001O1TJUGa5l8YJZGf5P9000001O003M3M1O5K0000000000000000000000O11O000000000000000000001O00O10000000000000000000000000000000000LeJbF\\5^9dJbF\\5^9300000000000000000000000000001O0000001O1O000000000000000000000000000000000000000000000000000000000000NdJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`9dJ`F\\5`920000000000000000000000000000000000000000000000000000000000001O00000000O11OO11O000000000000O100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001OO1000000000000000000001OO1000000000000000000000000000000000000000000000000001OO100O100N2000000001O00O1001_JbF^5`90M30_JdF^5\\9bJdF^5\\9bJdF^5\\9bJdF^5`9O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00O11OO11O0000O1001O00", "size": [480, 640]}, "area": 193810.0, "iscrowd": 0, "image_id": 13774, "bbox": [0.0, 0.0, 640.0, 310.0], "category_id": 157, "id": 20000845}, {"segmentation": {"counts": "kj^35f>6N2N100O2N1000000000O100O3M2N2NaR8LPmGd0K5L12MVCVOf;i0YDYOf;S1nCoNQh03L3M3L=DkSn4", "size": [480, 640]}, "area": 1722.0, "iscrowd": 0, "image_id": 13774, "bbox": [236.0, 210.0, 66.0, 158.0], "category_id": 183, "id": 20000846}, {"segmentation": {"counts": "idX13W=001N20O0100N110000O10001N10001N2OUgj6", "size": [427, 640]}, "area": 87.0, "iscrowd": 0, "image_id": 13923, "bbox": [97.0, 199.0, 18.0, 10.0], "category_id": 93, "id": 20000847}, {"segmentation": {"counts": "ecW1130S=2kBOT=5O001O001O001O1O00001O001O001OO11O00001O00001O001O001O00001O1OO11O0000001OO1001O00N2O1N200000000001OO1001OO100001O1O1O00001O00001O00O11O000000O1000000O11O1O0000000000000000000000O1000000000000000000000000001OO1O100000000001OO1001O00O1001O0000O10000000000O11O000000000000000000000000000000000000000000000000000000000000O100001O000000000000000000000000O1000000000000000000000000000YC_Od^GDJ;I6f0]OZ8=THKQO6b0@[8?VHFnN;k9O\\G@kN`0j9OjG1V8OjG1V8OkG0T81lGNV82jGMV83jGMQ89nG^OPNL03W:4c:L_E2`:0aENR:FXEdfg<22O0105J01O001O1O001O001O001O001O00001O001OSMKdH5X7OiH0S73nHMU70lHOT70mH0S70nHOR70oH0Q70oH0Q70PIOP71PIOP71PIOP71PIOo62QINo62QINo62QINU7LlH3V7KjH5V:000000000001O000000000000001O0000000000001O00000000000000000000000000001O00_jm2", "size": [427, 640]}, "area": 13562.0, "iscrowd": 0, "image_id": 13923, "bbox": [0.0, 313.0, 414.0, 114.0], "category_id": 118, "id": 20000850}, {"segmentation": {"counts": "S9b1h;0100000000000M3L]N_Dd1`;4O1O10000O1O2O2N0ObNhD_O0O1W1W;XOQEh0o:YOQEe0P;[OPEe0P;[OQEe0m:XOiDF:Q1n:XOiDF9`0FNX;MiDC<>F1V;LhDG;;H1V;MgDH:8MEH:[;0fDFO0>9L1Y;FRE7G3n;MTD0m;MVD2m;KVD0`U17liNHn<>M6J`0A3jCiNPcDFN2];9`DLL1`;8`DHO1c;W11OO20O0000O100mDZNa:g1^EYNc:f1]E[Nb:f1]EYNd:g1[EZNe:m1TESNj:2PE10j1Q;SNVEj0I6[;IiDVOL10h0`;LfD\\OJh0b;H^D_O61Jg0];NTEMl:6REIm:7nDOR;1nDOU;NlD1\\;EfD;S;GVE5j:1RENQ;FRE?l:EVE5o;13Mbce3Co\\ZLNROe0800000000002O0O1O1O000006JM]O]Ce06[OQ<3iCb06[OQ<2jCc04]OQj0]1l8iNTGW1l8iNSGX1m8hNRGZ1m8fNSGZ1g8mNWGT1i8lNVGV1i8jNWGV1j8iNUGX1l8kNoF7H^O]9^OZFe0><0A^92aF>1@^93bF;0Ac90_F>MAd92aF95\\O[9;cFNg:2\\EFk:9R11O12M10002N3L6K4Kali2", "size": [427, 640]}, "area": 5419.0, "iscrowd": 0, "image_id": 13923, "bbox": [333.0, 154.0, 91.0, 130.0], "category_id": 156, "id": 20000854}, {"segmentation": {"counts": "n7U1ViDXOF:`;?iDXOF9`0F^:h0]EYOC<>Fa:f0\\EXOG;;Hc:d0[EYOH:8MEHm:h0]EYOFO0>9Ld:f0SEE7Gg:Z1YEhN0EY:c1dEkN2FX:`1cEmN0KX:IoEY2`:1O`MaENHT2h:lMfEQ2Z:oMlEk1T:UN\\F[1d9fN_FOiNV1g:kNcFT1]9lNiFO`N50`0h:\\OjFOfNa0b:_ORGa0l:01O1LWCDj<1UC6R=O1O2Lkn\\1OXQcN1O100\\CNl;5kCNF1^7Ci:3QF;VOBi:3PF^:EaEJVO;V;MjE5U:LkE5T:Kf1000O11O00000000000002N1O1O2N000000000001O000000000000000O1O10000000000O100000000000010BTCeNB[1>eNB[1>eNB[1>eNB[1>eNB[1=fNCZ1=eND[1kNBU1>kNBiJ@W6n0POBU1>kNCfJ_O\\6n0nNCfJ@[6m0oNFQ1:oNFQ1:oNFQ1:oNFQ1:oNFQ1:oNFQ1]OeIj0Z5IQ1]OeIj0Z5IR1\\OdIk0Z5IR1\\OdIk0Y5JU16jNJW16iNJW16iNJW16iNJW16iNJW16iNIX17gNJY16gNJY16gNJY16gNIZ17fNIZ17fNIY18gNHX19iNFW1:jNDV1=jNCU1>lNAT1?lNAT1?lNAT1?lN@U1`0kN@U1`0kN@U1`0kN@U1`0kN@V1?iNAX1?hNAX1?gNBY1>hNAX1?gNBY1>dNE]1:dND]1eNCZ1>eNCZ1=fNDY1a0Ka0_8a0aGoNO`0`8b0`GnN0a0_8b0`GmNE^OM22V1d2SOT3[1_Ji0GcMe0><0k4T4hJkK>1i4U4jJkK;0l4X4eJjK>Mm4X4fJmK9MP5W4gJoKN8U5e1[J^Ob0hNF:^5]1bJ]O97V5;fJZO5;U59hJ[O4n6UO_Ij0b6QOcIn0]6nNgIR1Z6iNkIV1V6eNoIZ1R6PNTH1n1o1n5PNdJo1\\5PNfJo1`5hMdJW2Y8O1O1O1O00N2O1O1O1N2O1O1O1O1N2O1O1N2N2N2N2N2N2N2O1N2N2N2N2N2N2N21O001OSKkLDU3KcMO\\2MkM1T2KQN4o1IVN5j1G\\N7d1EbN:]1EdN=Z1BgN>Y1AhN?m0PLUMa3n1`0i0TLWM[3Q2b0f0VLWMW3T2d0d0L[O4c0O[O3c0N\\O4<4BM<6BL;6DL97EJ99EI99DJ99EH9:FH7;FG8\\K=`4_O`Kj0Z4SOgKU1T4gNlK`1Q4\\NoKg1h74L4M3L3M4M3N2M2O1N101O0O2OO001O1O0010O03M3M2N3N1N3M2N3M2N3N1N3M2N2N3J5L4L5K4LaFVOd6f0VIJe60VI`0d6\\OVIT1d6hNXId1e6WN]Ik1c6QN^IS2j83M4L3M4M2M4L3N3N1N2O0O10000O100O10000001O0000oK", "size": [427, 640]}, "area": 110700.0, "iscrowd": 0, "image_id": 13923, "bbox": [0.0, 0.0, 640.0, 427.0], "category_id": 172, "id": 20000856}, {"segmentation": {"counts": "Qkh1150XhE@W:?iE\\O]:d0cE\\O]:g0`EZO_:n0WETOi:e0YEDc:0B2^8e2bGTM61;3_O3^8e2hHRMoN0M2\\8l2XISMh6l2YITMg6m2XISMh6m2XISMh6k2YIVMg6i2ZIWMf6h2PHXMg00Y7i2mGXMj00Y7i2bGVM22c0OE1DL]8S3eGRMd00D2S8U3XHkLD0T8V3VHmL]O4]8o2mGeLIj0Z8a2lGgMT8Y2lGgMT8Y2lGgMT8Z2fGbL0T1Z8`2eG`M[8`2eG`M[8h300000001O001O1O1O000000000000000000MgGTKZ8k4fGUKZ8k4fGUKZ8i4fGVK01Z8g4701AfGkKZ8Z3aHeL`7h2TIWMl6i2TIVMm6k2RIUMn6k2RIUMR7g2oHXMP7i2PIWMn6k2RIUMn6k2RIVMm6j2SIVMm6j2TIUMk6l2UITMk6l2UITMk6l2UITMk6l2VITMi6l2j110001O0O100000000000000LRMkEn2U:4O10001O00000NkLnEU3Q:3O1O10000000000001gLQFT3S:1_FjLk8V3e0[NnEA0XOU:W1kE[O8WOW:S1kE]Oh:`0[E@e:`0[E@e:`0\\E_Od:a0\\E_Od:a0\\E^Of:a0ZE^Og:a0^EZOc:d0^E^Oa:a0_EAa:`0\\EAg:=XECg:GhD>a0KU;0lDOU;0kD0V;OjDE^OM22k;7efP3", "size": [427, 640]}, "area": 22608.0, "iscrowd": 0, "image_id": 13923, "bbox": [167.0, 39.0, 241.0, 171.0], "category_id": 181, "id": 20000859}, {"segmentation": {"counts": "e_6;l<4N2M3N2O0100000O2O001O001N101O001N101lCZOa;X10000O1000001N10001O1N3N1O1O1O1N2O1O2N9F9H7I00000O1000000O100000000O1000000O1000000O10000O10000O10000O10000O3N8H6I1000O0BeFnL[9Q3`00O01O10O01O10O01O10O01O10O01O10O01O10O01O010O2N101N1O2O0O2N101N1O2O0O2OO01O100O1O100O00100O1O100O1O101N1O101N1O2O0O2N101N1O2O0O1O2M\\D]Nd;b1\\D^Nf;`13O2O0O2N1O1O3M4L5L3L4L5J5J6Kdd>V1UZA8J5L1N2O0O2O1N2O1N101N2O1N2O001O1O1O1O001O1O1O1O1O0^EiMo9Y2QFiMl9=QFm03hNi9;[Fg0LPOf9=aF=IYOb93YFM4`02B^91\\FX16hN\\90]FZ17gNZ9N`F\\16gNX9MbF]16gNV9LdFc00_O73S9KeFf02YO68Q9IgFg03VO6;n8GjFi03RO7?j8FlFl01nN9b0h8DmFo02iN:e0e8CoFR10dN=h0c8AQG_1=oNa8CRG^1=PO`8BRG_1?oN\\7d0UH0BW1`1bNc2`4mKbK61;3_OX1_1bNe2`4RM`KoN0MV1^1jNn10TM`4S1fLKjNn10TM_4U1fL\\3kN^K`4T1fLJjNQ20QM`4T1eLKkNQ20oL^4W1gLIkNQ20oL]4W1iL^3kNZK[4MhKh0R1;jNT21kL\\4KhK;KIV1R1jNT21kLc4CaKc0OER1W1jNT21iLd4BaKd00DQ1Q5jNUKm45ZKAR1U5hNTKm4KSKLh1\\1VNR10`N1[On4KTKHj1`1SNk09eNI\\Om4LSM]3PNcL6g0J\\Om4MSM]3oMgL6a0K^Om4MSMX1nMa00dN260@n4FQK1Q2^1nM`00hN211AS5GlL_1PNZ11mM0CS5FlLe1oMT10nM3BW7[4eHRL4DV7a1gHk0OnM5FU7a1jH_12oLT7a1nH]1NRMT7a1QIZ1KUMS7a1VId0AQN8IQ7b1YIS1F[MQ7b1\\IP1C^MQ7a1`In0@`MP7b1cI0k6o0nHQO]1g1]NXN=1l6l0oHRO]1j1[NVN=2m6i0PITO\\1l1YNTN?3m6e0RIVOZ1P2XNQN?4Q:k1aEPN>5Q:l1PFUNo9l1QFTN\\52]Nk1_1POaNP1l0CSO?l0ATO`0l0@SO`0m0@ROb0m0^OSOb0m0^OSOc0l0^OSOb0m0^OROd0m0\\OSOd0m0\\OSOe0l0[OSOf0m0[OROf0m0ZOSOf0m0ZOROh0m0XOSOh0m0YOQOi0n0WOROi0o0VOnMYNSNc2n3TOnM\\NRN`2P4UOkM_NSN]2Q4TOkMaN\\ML;`2^4SOjMoNfMo1_4ROjMPOfMo1`4ROiMoNgMP2_4QOiMPOgMP2`4POhMQOhMo1`4POgMROiMn1`4POgMROiMn1`4QOeMROkMn1_4POeMSOlMm1_4POeMSOlMm1`4oNcMUOmMl1`4POaMUOoMk1`4POaM[OiMe1f4POaM]OgMc1h4POaM\\2_2eM`M\\2_2dM`M]2`2cM`M]2`2cM`M]2`2dM_M\\2a2dM_M\\2a2dM^M]2b2cM_M\\2a2dM_M]2`2dM_M\\2b2XL[Kc0T2T3a2YLaK=n1Z3a2YLdK:k1]3a2YLeK:i1]3b2YLeK:j1\\3a2ZLeK:j1]3`2XLgK;i1]3`2XLgKAEN2N2N2A?M3M3O1O1O1O1N2N2N2M3N2N2N2M3N2002N1O2N1O1O2N1O2N2N4L5K2N1O0000001O00001O00000001O1N2O1NhIaJ^O4V4Z5YLgJ@0V4W5YLmJ_OLY4V5WLQK_OH[4U5XKhJ>>MD_4U5TKmJ==O_Ob4X5nJPK><0\\Oe4Y5iJSK?;_5V5]JmJb5T5WJSK4QOS5Y7gJjH[5a72O1N2O0O2N2O1N2N3N1N2jHoIQ7R6nHoIQ7V6N10O0011N2O1N2O1O1O1O1O1O1O100O1O1O100O1O1O100O1O1O1SJTI[5l6`JWIa5l6VJ[Ii5S7O1M201O1O2N001OO21N011N2N2N2O1N3M2N3M1O2N3N1N2N2O1N2N2N2OYMaKdL]4]3cKPJ0^2\\4c3kK\\LS4e3oKYLP4h3QLWLn3j3SLVLk3k3WLSLh3n3YLQLg3o3ZLPLe3Q4\\LnKc3S4^LlKa3U4`LjK`3V4aLhK_3Y4aLcI]OR2Q4\\4eLcKZ3^4hL`KX3`4jL]KV3d4kL[KU3e4mLYKT3f4mLXKP3YNSL`6o0UKm2o4UMlJm2U5TMkJj2hNSLJ0V6U1VKg2kNbLe5h0_Ke2mNcLd5j0\\Kc2QOcLc5k0ZKb2SOdLc5l0WKa2VOcLc5m0UK`2YOcLb5n0SK_2\\OdL`5n0RK^2@bL_5Q1oJ^2BcL]5Q1nJ\\2FcL\\5S1kJZ2IeL[5R1jJZ2LgLV5Q1kJY2OhLT5P1kJY21hLS5R1gJX26hLQ5R1dJU2JPLb0k0n4X5VKkJg4S5nJoIH1On0[5l4dJTJO09a1R5\\4RKeKm4[4SKgKk4Y4UKhKj4X4VKjKh4U4YKmKBWNQ5l5^KPL`4o3`KSL_4m3aKUL]4j3dKVL\\4i3eKXLZ4h3gKYLW4g3iKZLV4f3jK[LU4e3kK[LU4e3jK\\LV4^3QLaLo3Y3YKeJ=0ENN03T2d4Y3fKXMZ4i2eKVM\\4i2eKWM[4h2fKXMZ4h2fKXMZ4g2gKYMY4g2gKYMY4f2hKYMY4f2hKZMX4f2hKZMX4f2hKZMX4d2jK\\MV4d2jK[MW4e2jK[MU4a2oK`MP4_2PLbMP4Y2XKTKj0c2n3Y2eKWN[4i1eKWN[4i1eKWN[4h1fKWN[4i1eKWN[4h1fKXNZ4g1gKYNY4f1hKZNX4f1hKYNY4g1gKYNY4g1gKYNY4g1fKZNZ4e1gKQNc4P2]KiMi4X2UKhMl4Y2TKgMk4Z2TKfMl4\\5000000000000000000000001OO1_Oa0000000000000000000000000000000_Oa000000000000000000000000000000000000000000000000000000000", "size": [426, 640]}, "area": 102772.0, "iscrowd": 0, "image_id": 14007, "bbox": [0.0, 0.0, 640.0, 289.0], "category_id": 102, "id": 20000862}, {"segmentation": {"counts": "XkU43W=0O1PFOf61[IOd61]IOc61]IOb61^I0a61_IOa60`I0_61aIO^61cIO]61cIO\\61eIO[60fI0Y61gIOX61iIOW61iIOV61kIOU61kIOT61mIOS61mIOT6OmI1T6MmI3e90000000000000000000jKNTK2m40PK0[5N\\J2b5MgF0h33`5OaJ1_5OaJ1^5OcJ1]5OcJ1\\5OeJ1Z5OgJ1Y5OgJ1X5OiJ1V5OkJ1U5OkJ1T5OmJ1S5NnJ2Q5OoJ1P5OQK1o4NRK2m4OSK1m4NTK2k4OUK1j4OVK2j4MWK3h4NXK2g4NZK2f4M[K3d4N\\K2d4M]K3b4M_K3`4N`K2`4MaK3^4McK3]4McK3\\4MeK3Z4NfK2Z4MgK3X4MiK3V4NjK2V4MkK3T4MmK3R4NnK2P4OQL1m30TL0k31ULOi32XLNf33[LMc35]LKb35_LK_37aLI_36bLJ_34bLLc3O]L1e3L\\L4]8000000000000000000000000000000000O100000000kJLTM4l2LTM4k2MUM3k2NTM2k2OUM1k20TM0k21UMOk21UMOk22TMNl22TMNl22TMNl23SMMm23SMMm24RMLo23QMMo23QMMo24PMLP34PMLQ33oLMQ34nLLR34nLLR34nLLS34lLLT34lLLT35kLKU35kLKV34jLLV35iLKW35iLKX34hLLX35gLKY35gLKZ35eLK[35eLK\\34dLL\\35cLK]35cLK^34bLL^35aLK_35aLK`35_LKa35_LKa35_LKb35\\LLd34\\LLe33[LMe34ZLLf34ZLLg33YLMg34XLLi33WLMi34VLLk33ULMk33ULMk34TLLm33SLMm33SLMn33QLMo33QLMo34PLLQ43oKMQ43oKMR43mKMS43mKMS43mKMT43kKMU43kKMV43iKMW43iKMX42hKNX43gKMY43gKMZ42fKNZ43eKM\\42dKN\\43cKM^42bKN^42bKN_42`KN`42`KNa41_KOb41]KOc41]KOd40\\K0d41[KOf40ZK0g40XK0h40XK0i4OWK1i40VK0k4OUK1l4NTK2l4ORK2o4MQK3o4NPK2Q5MoJ3R5LnJ4S5LlJ4U5KkJ5V5JjJ6V5KiJ5X5JhJ6Z5IeJ7W9000ULIcJ7]5IcJ7]5IcJ7X900000000000000000000000000000000000000000000000000000000000000000O1000000000000000000000000HH^C8c\\9WOfEH1On0S1T9lNlEO09a1k0c8YO^Gf0b8ZO`Ge0_8[ObGf0\\8ZOfGe0X8\\OjGBWNn0o9AmG=R8CPHk<`0A`0_O`0A?@?A100O100O100O100O1O100O100O100O100O1O100O100O100O100O1O100O100O100PNhLmIY3Q6VMbIj2]6XMaIi2^6YM`Ih2_6ZM`If2^6]M`Id2_6^M`Ib2_6`M_Ia2`6bM^I^2a6dM]I]2a6fM]IZ2c6hM\\IX2c6jM[IW2d6kM[IU2b6oM\\IR2a6RNTI]NIb3b6]LdIi1G`N3Z3`6dL]IS23Z1^6TOaIm0]6TOdIl0Z6UOfIl0X6VOhIj0i5DWJ=f5FYJ;d5G]J9b5G^J:a5G^J:a5F`J:_5FaJ;]5GbJ:\\5GeJ9Y5IfJ8W5JiJ7U5JlJ6R5LmJ5Q5LPK4m4ORK2l4OTK2m4LTK4m4KRK6o4HQK9Q5DPKT5_OlJb0U5]OkJc0V5[OjJf0X5WOhJj0[5SOeJm0`5mN`JT1d5hN\\JX1e5fN[J[1f5cNZJ^1f5bNZJ^1f5aNZJ`1f5_NZJb1g5[N[Je1e5YN\\Jh1d5WN\\Jj1e5SN]Jl1d5RN]Jo1c5PN]JQ2c5mM_JS2a5kM`JV2`5iMaJW2^5kM`JV2`5jM_JW2`5iLYJ@6g3a5fL^JA0j3a5eLbJ@Kl3c5cLeJ_OHn3b5eK[J>>NCP4d5bK`J<<0_OS4g5]KbJ=;2[OT4j5YKdJ>:3WOW4`6aK_J3RO]4a6XKeJ4oNd4j7VKYHk4R8100O100O1O100O1O100O100001O00001O001O00001O00001O001O00001O0O101O00001O001O00001O00001O001O00001O00001O001O00001O00001O00001O001O00001O00001O001O00001O00001N101O00001O00001O001O00001O00001O00001O001O00001O00001O001O00001O00001O001O00001O00001O00001O2N2M4M3M2N3M3M2N3M2N3M3M2N3M3M2N3M3M2N3M2N3M3M2N3M3M2N3M3M2N3M2N3M3M2N3M3M2N3M3M2N3M2N3M3Mbde0", "size": [426, 640]}, "area": 40916.0, "iscrowd": 0, "image_id": 14007, "bbox": [301.0, 154.0, 286.0, 268.0], "category_id": 183, "id": 20000866}, {"segmentation": {"counts": "_Q53m:D^Ol8d1^GoNE]Om8e1]GBc8?\\GAd8b0XG_Oh8f0RG[On8a2000000000000000O11O0000000000000000000000O100EoFVL01Q9c3QGYL03N1Q9]1oF2g0`NYO1Q9i0SG]O21L:S1[OnN3n8=oFG811OM;V1@f74YGM2NDO<2M>T1@e74[GLe00YO>X:DcGNiM6khW10dWhN2c2KR62XG?d0]Oe03`70VGd0b0YOf06b7MlFj0e0E2AD5h8m0dGJ@XON3o8j0cGR1\\8mNcGV1V8POjGn0m7hMiGW18R1l7kMjGT11Z1R8cMnGR4R8oKdGJO21W4[8nKcGK11OU4^8ZMbGf1^8YNfHc0Z7]OfHb0[7^OeHb0\\7mM`G^1T1k0Y7TOgHl0[7ROeHo0\\7oNdHP1^7oNbHP1b7mN^HS1b7mN^HR1d7mN\\HR1e7nN[HR1d7oN\\HP1e7PO[HQ1d7oN\\HP1e7PO[HP1e7PO[Ho0f7QOZHP1mNlM[8]1hHj0X7WOhHi0S7\\OnHc0Q7^OoHb0P7_OPIa0P7_OPIa0k6iMRHg1S1a0j6hMRHh1T1`0j6hMQHi1U1?j6hMQHi1U1?j6CVI=j6CVI=j6CVI=j6CVI>kNhMk7j1ZIa0f6_OZI`0g6@YIa0g6]OZIc0i6ZOWIe0l6YOTIh0n6UORIl0o6ROQIn0R7oNnHQ1T7mNlHS1T7mNlHS1T7mNlHS1T7mNlHQ1V7oNjHQ1W7nNiHR1W7nNiHQ1X7oNhHR1W7nNiHR1W7nNiHQ1X7oNhHR1W7nNiHR1W7nNiHR1W7nNiHR1W7nNiHR1W7nNiHT1U7lNkHT1U7lNkHT1U7lNkHU1T7kNlHU1d6bMdHY1h0V1c6dMbHV1k0X1a6cMcHU1l0X1a6dMbHT1m0X1`6gMaHQ1o0U1c6kM]HP1P1U1c6lM\\Ho0Q1U1c6nM[Hl0R1X1a6mM\\Hk0S1Y1`6mM\\Hj0T1X1a6PNYHh0g0f1Q7mNYHh1g7n10O1eLXHT1g7kN\\HnMLP3i7QOaHn0_7ROcHm0]7QOeHm0\\7ROgHl0Y7SOiHm0V7UOiHi0Z7VOeHk0`7PO_HP1a7QO^Hn0c7RO]Hn0c7SO\\Hn0c7oMSH49l1e7kMZH70n1f7kM[H7Nn1g7fMPHA;m0Ll1i7gMoG_O>n0Il1l7dM_Ha0Dk1n7fM[H`0Ek1Q8dMZHc0Ci1U8bMXHf0Bh1V8aMYHf3i7XLWHh3i7YLVHh3i7YLVHf3k7ZLUHf3k7ZLRHj3m7VLgGD9V4HjKU8`0QHg3IjK32l7=WHQ4k7nKTHU4j7lKUHQ4n7PLQHn3n7ULQHj3o7XLQHh3m7\\LQHd3o7l0OMRHiJP8n4RHTKR8l4oGSKR8m4oGRKP8o4PHQKo7P551N1H85J8kKgGc21bLV8o0gG=1>3WNT8j0oG55f0KZNQ8k0THWOJ;7X1KZNS8i0QHYOK=6^O3U1[8EaGWOOa0f0GXO4GCl8i0nGI9^OmN4<7d8d2S71lHOT73_HYM8e2Z76cHJ]77_HTM0e2`7<_HDb7R30YJ^He5d70N200M3O11Oh0XO1O00000000000000000000000000001O001O1O1cKdGi3o804L0000001O00001O001O001O1O1O3M1O2N3M001O002N6JO10000N2O1O1O1O1O1N2O10000000000001O000000000000001O1O1O000000001O00O10SN]F2d9J`F5_9HeF8\\9fN[FD2c0:R1X9fN_FB2e07S1Y9dNgF81i0EiNb96kF6Nd0MoNY97nF5M=3WOR97PG2L:8]Ok87SG1J4?Dc87VG0IMe0L]8NaFOg08FHl03V8N`G6n0Lb7N`G6n0Lb7N`G6n0Lc7M_G6o0Mc7L^G7P1Lb7M^G7P1Lc7L]G8P1Ld7L[G8Q1Ld7L[G8Q1Lg84YGLg83ZGMf83ZGMf83ZGMf83ZGMf83QGK[N2d:3RGMXNOf:4SG4m8KUG4k8LUG4k8IYG6o:O1O001O1JlB3X=N1O]fY1", "size": [427, 640]}, "area": 28078.0, "iscrowd": 0, "image_id": 14038, "bbox": [263.0, 237.0, 276.0, 190.0], "category_id": 118, "id": 20000871}, {"segmentation": {"counts": "Zh?:8Gai<3O1N4M2N2N3M2N2O0O0O10000001O001O0]OhC3YhGDW8f<43M0000O1001O1O000M3DSC9Q=N2O0O2O1O0O102Na[h4", "size": [427, 640]}, "area": 284.0, "iscrowd": 0, "image_id": 14038, "bbox": [250.0, 253.0, 24.0, 20.0], "category_id": 139, "id": 20000875}, {"segmentation": {"counts": "Vbg32P=;UOJ]D7a;J`D6^O3[;KWEf0e:\\O[Ef0^OmNS;=`Ei0^:XOaEi0^:WObEj0]:VOcEj0^:UObEk0^:UObEk0^:UObEk0^:VOaEj0^:WObEi0^:WOcEh0]:XOcEh0]:YOaEh0_:XO`Ei0`:WO_Ej0a:WO]Ej0c:VO]Ej0c:WOZEk0f:VOXEj0i:WOUEj0k:VOTEk0l:WOQEj0o:WOPEi0P;i000000000000000000000000000000001O000000000000O10000NPEiMP;S2PEmMT;Q2lDoMV;P2300001O00O1O11O0000001O003M1O001O1mDiMP;W2PEiMP;Y2000000000000000000000000000000000001N0100000001O002N4L3oMgDh10VN];j13JaD\\Nc;b15N3M3M3M2iNlCS1Xl:D^Ol8d1^GoNE]O;Fm7o1RHB1QO[7^1cHA2Ci6o0QI_O64W6b0]I[O8e9LkEe00YO>7e9d1mEiM6l0c9k2I1O001O0000000cF\\LS9d3mF\\LS9d3mF]LR9c3nF^LQ9b3oF^LQ9c3nF]LR9c3nF]LR9c3mF^LS9m300000N200O100GlF[LT9c3QGYLP9f3QGZLo8e3RG\\Lm8Z3]GhLa8S3cGoL\\8Q3dGRMY8o2fGRMY8n2gGTMW8l2iGUMV8k2jGUMV8k2jGUMV8T3`GmL`8Z3YGfLg8\\3WGdLi8]3VGcLj8o3000000000003M5K2N3M00000000O100000000000000000000O12bG[KR8P5O001O1O1O3M1O001Oe0[Oe0[Ob0^O:FcH[J^7[5dHfJc7P5^HQKj7f4VH[KHLW8c4nGfKZ8R4aGPLi8T4:F:O1K5E;H8G9F:G9E;FWKZNkI2c2KdMc1P6_NfI?d0]Oe03QOb1Q6^NdId0b0YOf06RO^1T6_NXIj0e0E2AD56G^Oe1i6AoIJ@XON3;\\1Z6^OmIR1DBa6[OjIV1AA`6_OoIn0^OFZ6RNnIW18V3h5gKnIT11^3n5_KRJW6m5jIiIJO21[6W6jIgIK11O[62bIR6V700O001N2M2N300_ObHkJ1O]7V5cHhJ8NT7Y5QIgJP7X5PIiJQ7V5nHiJS7X5kHkJT7U5lHkJT7U5lHlJS7T5mHlJS7T5lHnJS7R5mHmJT7S5lHmJFJ\\7Y5nHoJR75iHX45aKT74lHY40bKW70mH\\4McKX7NkHj1;WODQOCN=2i7g1fHUO9ROR7i1eHUO9QOS7j1dHUO9POT7j1dHVO8POT7j1dHVOc8j0]GUOd8k0\\GUOd8k0\\GUOd8k0\\GUOd8k0\\GUOd8k0\\GUOd8k0\\GUOd8k0\\GUOd8k0\\GUOe8j0[GVOk8]OXFE2o0m0Ml8ZO^Fg0V1_O^8G^Fi0c;SO_Dl0P<10O00001O5KO4M7GH82O1O1000000O1O100O1O2O0O010O1O1O1O1O1O1O2O0O1MeNUD\\1j;30000000000000O10000000000000000O10O1O1O1O100000000000000O11TOdDF\\;9l0O100O13NM101001O0000001O00001O00003MN2O1O1O1000000000000001O001O1O2N1OG9KXCGh<9XCDk<<20000000000O11O000000000000O1000000000000000O1000000000000000000000000000000TGDi4f7IUKIUM>f7IUKIUM=g7JTKIUM=g7JTKIUM=g7JTKIUM=g7JTKIUM=g7JTKIUM=g7JTKIUM=g7JTKIUM=g7JTKIUM=g7KSKHVM=g7KSKHVM=g7KiGCR30QMZ1S8TOjGBR30oL\\1U8ROjGBR30nL]1V8CVHQ1FPNO[1U8U2jGoMV8c30O100000000000000[OiGgK0O0N010NX8o2mGkMT9R2T100000000O1000000O12NO11O000000N2001O1O0000000000000000000000000000001O1O00001O0000002N3M1O001O0O1O00O0100OiLPFX3o921OO100O1O12OO01LQFjLo9V341N010O0_FjLENP9Z3YGgLH2l8Z3XGlLFO]8JnG^3JZMU8YOnGa4P8cKkGe4l7?0OO2N3NO01O1O2NlNU10O1O1O1O1L_K]Gb4b83O2O20O1O00O2N1O100O2N1O1O1O2N1O1O1O1O2NcMSH^Ol7`0WH@h7?ZHAf7=\\HDb7;`HE_7:cHG[78gHIW76kHKS73PI4h6KcInNSO[OZ7f1eInNRO\\OMWOY7^2kInNoN^OV7e1lIkNPO]OU7h1lIfMPOf01LR7h1oIdMoN4K868i6YOTI_2U1aMPO2GN3>49i6o1QKhMUNE44f6^2RKiMTNB:3a6a2SKiMgNCW6c2WKfMiMGf00X6b2[I`M[1;Z6U2[H`MZ1<[6S2\\HaMY1<[6S2\\HaMZ1;Z6T2\\HaMZ1:[6U2ZHbMZ19]6P2^HgMU18^6k1cHmMP17]6h1gHQNl06^6i1fHnMP17[6k1bJUN^5k1bJRNXMLW8R2dJnM_5R2m2M3N20000O1N2O1N2N2O^E]N^9a1bFfNY9Y1gFlNU9R1mFoNR9P1nFQOR9m0PGSOP9l0QGTOo8j0RGWOn8h0SGXOm8f0UGZOk8f0UGZOR5BXMc1WMlN_5BZMf1SMhNb5B\\Mj1oLcNc5E^Ml1kL_Nf5E`MZ2\\LRNQ6FcMX2\\LRNR5BbK6Q3m2_McMi1@_M4Y3j2SMnMR23l0P2oLPNQ23P1n1lLSNn13d1_1YLaNf1;Q2[1PL_Ne1>\\2Q3^MbLbNdNo3j4XMhLQOVNg3T5UMgLTOUNh3V5oLgLYOSNg3[5iLeL_OQNh3b5PL`J0Q28mMh3]8XLbGk3\\8ULdGm3Z8SLfGk3\\8ULdGk3\\8ULdGm3[8RLdGP4[8PLeGo3`8mK`GS4l8O10O6KO101N10NaKXG^4i8cKWG\\4i8dKWG[4j8eKWGZ4i8gKVGX4k8hKUGX4k8iKUGU4l8kKTGU4l8kKUGS4[2kKR43bIR4\\2lKFOV23hKR4S2oKoMMP20U23iKP4e1cL=\\OT21jKP4d1dL=]OT2OkKP4d1eL:_OV2MlKn3d1fL9AU2LnKm3d1gL8UOTN:Q4NoKl3c1gL<^OR2T4cM_L7UOUN9P4T4cM^L8BT2P4dM_L8@T2Q4dM_L8AS2P4eM_L7BT2o3eM_L6DT2f3mMfLNEU2[3WNPM_OSO_Nd0j3Y3XNQM]OTO_Nc0l3X3XNQM^NTO9g0Q3T3YNPMZN[O9b0S3S3ZNPMYN^O6a0W3Q3[NoLVNB8=W3R3[NoLUNE7;X3Q3\\NoLTNG79Y3Q3[NPMTNG79Z3P3\\NoLRNL55]34ZLe1Q2WNSNK64\\32`Le1j1[NSNL71\\31eLd1d1_NTNL7O\\3^OYL4?T2_1aNUNL8L\\3_O\\LLa0\\2X1bNWNL9J[3_OZMY2k0bNWNM9H[3@ZMY2k0bNWNM;EY28YM[OQ1Y2k0aNWN0:Cg1BPNj0KWOS1Y2j0`NXN18EQ17jN0GZOT1Y2i0aNYN17D9o0CCk0X1i0`NZN25FG_16QOk0X1j0_NYN34T2LZM9Hc0X2k0_NYNg3S1dKGV2m0_NXNe3W1hKAU2P1\\3^O_JBU2P1\\3^O_JBU2P1[3_O`J@V2Q1Z3_O`J@V2P1[3@`J_OU2Q1[3@`J^OV2Q1[3A_J_OU2", "size": [427, 640]}, "area": 81815.0, "iscrowd": 0, "image_id": 14038, "bbox": [0.0, 0.0, 640.0, 427.0], "category_id": 172, "id": 20000879}, {"segmentation": {"counts": "cX]2j0T1DQOCN1a:k0]FLc94]FLc94]FLb95^FKb95^FKb95]FLc94]FMb93^FMb93^FMb93^FNa92_FNa92_FO`91`FO`91`FO`91`FO`93^FMb9c0nE]OR:n1010O00000O10003L8IF9100002N2N2N2N2N1O2NOkEmLU:R320O10O1000000000001O00000000000001O00000O3N6J0000000000000O102N1O1O2N002N0000000000O11N2O0003J6K6J200O10O0101N004LN12G94M5IO02O1O4L3M2M4M2O0O100000O2O0000X1hN2[NZEa0f:_OXFEg9:e100O2O00>B[PY4", "size": [427, 640]}, "area": 11429.0, "iscrowd": 0, "image_id": 14038, "bbox": [185.0, 125.0, 126.0, 120.0], "category_id": 174, "id": 20000880}, {"segmentation": {"counts": "od76U=b0^Ob0^Ob0^Ob0^Ob0^Ob0^Ob0^O9GO100O10000O1006J7I7I7I7I7I7I7I7I5K4L5K4kNYI^Kk6V4TIRK1h0o6l3WIZKKj0R7h3\\IWLh6e3XI[Ll6a3TI_LP7e3`HaK3j0a7g3^HYLf7d3YH\\Lk7a3TH_LQ8[44L1O12M2N2O2M2N3N1N3M010O1O100O1O1O00WNaHfM_7X2eHgMZ7X2gHhMY7W2hHiMX7m1RISNn6h1WIXNi6h1WIXNh6j1WIVNi6j1WIVNi6j1VIWNj6i1VIWNj6i1VIWNj6W2hHiMX7Y2fHgMZ7[2dHeM\\7\\2aHfM_7S400000000000000000000000O1000000O10000O10000O010O100O100O10000O1000000:Fe0[Of0ZO=C:F:F:F:F:F:F:E;F9F;F:E;F:E;F:E;F:EhY5J_fJT1lN00000000000jMlNWF1e1S1T8mNTF8b1k0Z8YOhGg0W8YOjGg0V8WOlGi0T8WOlGi0T8VOmGj0S8VOmGj0S8VOmGj0S8VOmGj0S8VOmGj0S8VOmGj0S8UOnGk0R8UOnGk0R8UOnGk0Q8VOoGj0Q8VOoGj0Q8VOoGj0Q8VOoGj0Q8VOoGj0Q8VOoGj0Q8VOoGj0Q8VOoGj0R8UOnGk0R8UOnGk0R8UOnGk0S8TOmGl0S8TOmGl0T8UOiGl0W8WOfGi0Z8YOdGg0\\8\\OaGd0_8^O_Gb0a8A\\G?d8CZG=g8BYG>g8BYG>g8BYG>g8BYG>f8CZG=f8CZG=f8CZG=e8D[G=d8C\\G=c8D]Gg8@YG`0j8]OVGc0l8\\OSGd0n8[ORGe0o8ZOQGf0Q9XOoFh0R9WOnFi0T9UOlFk0U9TOkFl0V9SOjFm0X9QOhFo0Y9POgFP1Z9oNfFQ1\\9mNdFS1]9lNcFT1^9kNbFn0Q;[OQY1GlgN3kBLn<:O2M2N3M21N2N001O001O1O1O1O2N1O1O1O2M3NYWb0>Yh]On0RO?A1O00000000001O000001O001O010O001O001O00001O001O1O1003M00000O1000O1O2N2N2N3L3N3@`0M2N3M3M2N3M2N3M2N3M___1a1P_`N001O001O1O0O2O010O001O10O0O1K501O0O11O01O01O001\\DaNZ;i10ObMUN\\Il1`6WN`Ii1^6YNbIh1[6[NeId1S1TNe1:XMb1aNSNa15c28\\M`1_NTNUO11Oo18n26_M]1^NZNUOMm0MVO2c0:U45RNDSOKPN70Lj00VO2e07S48TNClN:YNAg0:L0j0Ff1m0ZNSOC6f0:ZN@e0=LNd0Ll1h0[NROE4e0;[N@b0?ML>3Q2d0\\NoN^OOZO6^1?`N[Oa0a0KL:7X2?ZNoN^O0]O3]1a0`NZO?c0LJ4?]28ZNPO@N^O3[1b0aNYO=e0MIMe0d23YNkNjNOi02]O2[1d0aNXO41Lg08FHl0j2MZNjNjN0h01^O3Z1d0bNWO3o05o0b2ZOZNhNjN1h01_O2Y1e0cNWO1o06o0a2\\OZNfNkN1i00_O2X1g0cNVO0o07o0`2]O[NjNDM^O1Y1g0cNUO1P15P1`2ZN`M>k0ZOlNOi02_O0X16`N63A1P15P1_2[NeM9g0^OlNOj01^O1Y1g0bNVO1P15P1_2ZNjM6b0BlN0i01^O0[1f0aNWO1P15P1^2[NoM1>FlN0i01^O0:NANh0i0XOYO3n04Q1^2[NVNJ8LkN1j00]O1;N_O0h0f0YOZO3n04R1]2ZNDFgM0i01]O118`0VO]O3n03j0H]NW2c04XOfM0i02\\O0>18OTO;2C3n03j0KZNT2f0^NVOo02]N0i02\\O0>18;TOC2O3n03k0MVNR2i0XN\\OU1L]N0i02\\O0>18;TOC2O3n03l0V2nNjMD[1D^N0i02\\O0>18;TOC2O3n02n0V2lNeMK`1]O_N0i02\\O0>18;TOC2O4m01o0S2HXO\\N^N1j01\\O0>18;TOC2O4m0NS1S2G[OXN^N2j01\\O0>18;TOC2O5U3o1cN[OWN_N2j01\\O0>18;TOC2N7V3l1`N_OZN\\N2j01]OO=28;TOC2N8U3j1[NG`NUN2j01]OO=28;TOC2N9U3f1TN3gNlM2j01]OO=28;TOC2N:T3d1gMc0UO]M2j01]OO=28;TOC2N;S3a1iMf0TO\\M2j01]OO=28;TOC2N:T3`1jMh0RO\\M2j01]OO=280ZONJ02N:T3_1jMj0RO[M2j02\\ON>O;3WONJ02N9U3^1kMl0PO[M2j02\\ON>O;3WONJ02N9U3]1lMm0oN[M2j02\\ON>O;3XOMI12N8V3\\1lMP1nNZM2j02\\ONa11eNOFN8V3[1mMQ1mNZM2j02\\ONZ2NiMW3Z1mMT1lNYM2j02\\ONf2U3fNnMU1kNYM2j02\\ONe2V3eNnMX1jNXM2j02\\ONe2V3dNoMY1iNXM2j02\\OMe2X3bNPN[1gNXM2j02\\OMe2X3kNgMU1RO\\NOc1Y3SO`Mm0XO[1X3lM\\Mi0\\OZ1Y3QNWMe0^O\\1[3bNdLZ4]3dKfLZ4[3k20O100O1000000\\OhLUGX3k8oLmFR3S9nLmFR3S9nLmFR3S9nLmFR3S9nLmFR3S9nLlFS3T9mLlFS3T9mLlFS3T9mLlFS3T9mLlFS3U9lLjFU3V9jLkFV3a9^L_Fb3e9000O10000\\F_L_9f300NWLbFj3]9VLdFi3\\9XLcFh3]9XLdFg3\\9YLdFg3\\9ZLcFf3]9ZLdFe3\\9\\LcFd3]9\\LdFc3\\9^LcFb3]9^LcFb3]9^LdFa3\\9`LcF`3]9`LcF`3]9aLcF^3\\9cLdF]3\\9dLdF[3\\9:0000000_LdFS3\\9mLeFP3]9PMdFm2^9SMcFk2^9VMbFg2`9YMaFf2_9ZMbFe2^9[McFd2]9\\MeFb2[9^MgF`2Y9`MkF\\2U9dMoFX2Q9hMSGT2m8lMVGQ2j8oMYGn1g8mM]FKn0V2e8nMaGR2_8nMaGR2_8nMaGR2_8mMbGS2^8mMbGS2]8nMcGR2]8mMdGS2\\8mMdGS2\\8nMcGR2]8oMbGQ2^8QN`Go1`8SN]Gn1c8RN]Gn1c8RN]Gn1c8RN\\Go1d8QN\\Go1d8QN\\Go1d8QN[GP2e8PNbHi0RN", "size": [427, 640]}, "area": 52693.0, "iscrowd": 0, "image_id": 14038, "bbox": [18.0, 39.0, 622.0, 388.0], "category_id": 183, "id": 20000881}, {"segmentation": {"counts": "a^W4=c>2N00000000000000000000000000000_N4^C^O1>a<O^ma3", "size": [480, 640]}, "area": 4536.0, "iscrowd": 0, "image_id": 14226, "bbox": [288.0, 415.0, 108.0, 65.0], "category_id": 105, "id": 20000882}, {"segmentation": {"counts": "glj69g>000000000000000000000000000000000000000000000000000000000000000000IZA4i>0001O001O001O001O00001OQRk1", "size": [480, 640]}, "area": 357.0, "iscrowd": 0, "image_id": 14226, "bbox": [466.0, 471.0, 47.0, 9.0], "category_id": 110, "id": 20000883}, {"segmentation": {"counts": "\\Ti55a>;0=B01O00001O001O00001O001O00001O001O00001O001O001O00001O001O00001O001O00001O001O00001O001O00001O001O0000000000000000000000000000000000000000S\\b1O^U]NIV>8jAIT>8kAJT>7fAF0102Y>b0O12M101N1O2O000000001O0002NO10000000O100N22N8HO100O100O100OO2F\\k=", "size": [480, 640]}, "area": 1701.0, "iscrowd": 0, "image_id": 14226, "bbox": [394.0, 214.0, 216.0, 266.0], "category_id": 115, "id": 20000884}, {"segmentation": {"counts": "g[W14k>103L3OO00001O00000000000000000000000000000000000000000000000000002N001O2N1O1O1OSXS6:eglIOO05JRn00kQO4K5K5N200001OZOAlB>o20001O001O001O001O00001O1O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "size": [480, 640]}, "area": 1209.0, "iscrowd": 0, "image_id": 14226, "bbox": [500.0, 471.0, 140.0, 9.0], "category_id": 165, "id": 20000887}, {"segmentation": {"counts": "k>5k>000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000mNMYC3g<0VC0k<1SCOn<3oBMR=5kBKW=6fBJ[=8bBH_=:^BFd=:ZBFg=RBBP>?mAAT>?kAAV>d02N1O1O2N1O1O2EcAO^>OcA1^>NeAO_o>0W_A001O2N1O1O1O1O00000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000000001O1O0KXA2l>ORmS5OoRlJ1N1[M6SFKn9>hEB\\:d0YE^Ok:g0kDYOZ;3eC5f0Ij;O_C`1P=0O1100OO10001O0ZOZNRDf1i;_NWDb1c;cN]D]1_;hN`DX1_;jN`DW1_;iNaDW1_;jN`DV1`;jN`DV1a;jN]DX1b;hNQDe1o;f001O0001O01O000010O00O2N11O1O10O00001N100O2N1000001O00001O02NO2O0000001O00001O0000001O00001O0N2F;M200O101N100010O0001O01O0010O01O10O01O010O1O0010O01O10Of0[OT1kN3fH", "size": [480, 640]}, "area": 11476.0, "iscrowd": 0, "image_id": 14226, "bbox": [0.0, 219.0, 640.0, 261.0], "category_id": 167, "id": 20000888}, {"segmentation": {"counts": "T:Q1o=1O001O0O2O1N10jNXBU1j=OO2O0O2O1N101N1O2N101N2O0O2O0O2O0O2O1N101O0O2N1LRNVCo1hcGBX8TMdG[34CU8SMgGY36DR8RMhGZ37Fn7QMkGX38Hk7QMlGW3;If7j0BTO`0l0_OTOc0k0XOgMnJ^1k5k0VOhMnJ\\1n5l0SOXOo0g0oNYOS18YJXNd4^1V19YOEi0;WOCk0=TOCn0oNCR1j00000000001O0000000000001O0000000000001O0000M3O10000O10000O100O10000O10000O10000O100O10000O10000O10000O10000O100O10000O1000000000000000000000000001O0000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000001O0000000000000000000000000bG^O^2b0^MBb2>YMHf28VMLj24QM1o2OlL7S3IiL;W3EdL`0\\3@_Le0a3[O[Lj0d3WOVLn0j3TOoKQ1Q4POjKU1U4lNeKY1[4hN_K]1a4dNZK`1f4aNTKc1m4^NmJf1T5[NgJi1Y5YN`Jk1a5VNYJn1h5SNSJS2k5nMoIW2Q6jMiI\\2V6eMeI_2[6bM_Id2`6^MYIg2g6ZMTIj2l6WMnHn2R7SMhHR3X7oLcHV3\\7kL^HZ3b7gLXH^3h7cLSHa3m7aLlGd3T8d1000bKiHS1W7gNRIU1o6eN[IW1e6fNaIU1a6iNdIV1Z6iNkIS1U6lNoIj0X6TOnI`0Z6_OkI5]6JgIL`62fIBb6=cIXOd6g0aImNg6Q1aIaNg6^1^3O1N2O1O1N2O1O1O1O100O100O10000O100O10000O100O10000O100O100", "size": [480, 640]}, "area": 52611.0, "iscrowd": 0, "image_id": 14226, "bbox": [0.0, 0.0, 640.0, 480.0], "category_id": 173, "id": 20000889}, {"segmentation": {"counts": "U;f3[;O001O001O1O001O001O001O1O001O001O001O1O001O001O001O1O001O001O001O1O001O001O001O1O001O001O001O001O1O001O001O001O1O001O001O001kNeCC\\<=fC@ZZHBe7?[HAe7`0ZH@e7a0[H_Od7b0\\H^Oc7d0\\H\\Oc7e0]H[Oc7f0\\HZOc7g0\\HZOc7g0]HYOb7i0]HWOb7j0^HVOb7k0]HUOb7l0^HTOa7m0`HRO_7P1`HPO_7Q1aHoN_7R1aHmN^7T1bHlN]7U1cHkN\\7W1cHiN]7W1dHhN[7Z1dHfN[7[1eHeNZ7\\1gHcNX7_1gHaNY7_1gHaNX7a1gH_NX7b1iH]NV7d1jH\\NU7f1jHZNV7f1kHYNT7i1kHWNm47RJc1Q1VNm4l9DTF:l9ISF6l9oNRF[O2d1l9POXFYOLe1m9POUF@N_1l9PORFI1U1m9oNSF00P1l9kNWF9Mj0l9jNXF`0Ld0m9f0RFYOm9i0SFUOm9m0SFROl9Q31O01O001O01O01O0O2O00001N101O0O101O0O2M2O1O2M2O2N1O1N3N1O2M2O2M2N2N3M2OoJ]Gh3`8]100O2O0O2OlJdGd3[8]LeGc3[8]LeGd3Y8]LgGc3X8^LhGc3W8c1O10kJjGa3T8`LlG`3T8`LlGa3R8`LnG`3R8`LnG`3Q8aLoG`3o7aLQH_3o7aLRH_3l7bLTH^3l7cLSH]3V7ZMjHg2l6bMTI^2c6kM]IV2Z6RNfIn1_4jJPM`3bNe1[4RKhL`3mN_1X4XKbL]3VO[1V4^K]LZ3]OY1R4dKZLV3DV1P4kKTLS3KR1o3;RLEj3>VLBh3`0XLAe3a0[L_Ob3d0^L\\O`3f0`L[O]3g0cLYOZ3j0gLVOW3k0iLUOV3l0jLTOU3n0jLSOT3n0lLROS3o0mLROQ3o0oLQOP3P1QMoNn2R1RMoNl2R1TMnNk2S1UMnNj2R1VMnNi2S1WMmNh2U1WMlNg2U1ZMjNe2W1[MjNd2V1\\MjNd2V1\\MjNc2W1]MjNb2V1^MjNb2V1_MjN_2W1aMiN_2W1aMjN^2V1bMjN^2V1bMjN]2W1cMjN\\2V1dMjN\\2V1eMjNY2W1gMiNY2W1gMiNY2W1gMjNX2V1hMjNW2W1iMjNV2V1jMjNV2V1kMiNT2X1lMiNS2V1nMjNR2V1nMkNQ2U1oMkNP2V1PNjNP2V1PNkNo1U1RNjNn1V1RNkNm1U1SNkNm1U1SNkNm1U1SN[JOS3n1a2SN\\JJjN3X4P2b2TNZJI\\3R2Z2UNZJH]3S2Y2UNlJMT2n1o2VNlJKX2n1l2WNkJJ[2o1j2WNkJG_2R2e2WNQOi1o0XNQJGS4Q2l1XNQJGT4P2k1YNPJHU4o1k1YNPJHV4n1j1ZNPJGW4o1i1ZNoIHX4o1h1YNPJHY4n1g1[NoIGZ4n1g1[NoIG[4j1i1_NmIFZ4j1j1`NlIFZ4j1i1aNVIGc0M50`3j1b2gNiI_OO0B0T4i1c2aNnIGIOB0U4h1b2[NUJNBOB0U4h1g3YNbHOB0U4g1g3[NbHNB1U4e1g3\\NaHOC0U4d1h3\\NaH0B0V4c1f3^NbHOB0V4c1f3^NbHOBOW4c1f3`N_HODNX4b1d3bN`HNR4`1^3bN`HNCN[4`1c3dN_HNS4^1_3cN]H0T4]1`3bN]H1S4[1a3dNQHN44Y4Z1c3eNnGM73Y4Y1d3iNVHMV4Z1d3iNVHLX4Z1W4eNiKZ1o801OoKiNYJV1h5kNXJT1h5mNWJS1j5mNUJR1n5mNRJR1P6mNoIS1R6lNoIR1T6mNkIS1Q:OoLoNVHP1i7POXHP1g7QOZHm0f7SO[Hm0e7SO[Hm0m:O001O00001OXDTOlM3U;i0QG^Oo8a0SG]Om8c0SG]Om8c0TG\\Om8c0SG^Ol8c0SG]Om8c0TG\\Ol8d0TG\\Ol8d0UG\\Oj8d0VG\\Oj8d0WG[Oi8e0WG[Oi8e0XG[Og8e0YG[Og8e0YG[Og8e0ZGZOf8f0ZG[Oe8e0\\GZOd8f0\\GZOd8f0]GYOc8g0]GZOb8f0_GYOa8g0_GYOa8g0_GYOa8g0`GYO_8g0aGYO_8g0bGXO^8h0bGXO^8h0cGXO\\8h0dGXO\\8i0cGWO]8i0dGVO\\8j0dGWO[8i0fGVOZ8j0fGVOZ8j0gGUOY8k0gGVOX8j0iGUOW8k0iGUOW8k0iGUOW8k0jGUOU8k0kGUOU8k0lGTOT8l0lGTOT8l0mGTOR8l0nGTOR8l0Q3000nDTOP8l0R300000000001O000000000000000000000000000[ESOW7m0jHSOU7m0lHSOS7m0nHSOQ7m0oHTOP7l0QITOn6l0SITOl6l0TIUOk6k0VIUOi6k0XIUOg6k0YIVOf6k0ZIUOe6k0\\IUOc6k0^IUOa6k0_IVO`6j0aIVO^6j0cIVO\\6j0dIWO[6i0fIWOY6i0hIWOW6i0jIWOU6i0kIVOV6j0kIROX6n0WOROZKn0]1SOTM0_1m0a1YOfLKh1l0g1_OULFT2k0l1DfKA^2k0Q2IVK]Oi2j0V2NfJZOS3h0\\23WJUO]3h0a28gIQOh3g0f2W1YMiNm2Q1SMoNR3l0nLTOW3h0hLYOU3i0kLWOP3n0PMROl2R1TMnNg2X1XMhNc2]1]McN_2a1aM_NZ2g1eMYNV2l1jMTNR2P2nMPNm1V2RNjMi1[2WNeMe1_2[NaM`1d2`N\\M[1j2dNVMX1n2hNRMS1S3mNmLn0Y3QOgLk0]3UOcLf0b3ZO^La0g3_OYL=l3BTL9Q4GoK4V4LlKNY41hKI]47dKCa4=`K^Oe4a0\\KYOi4g0XKSOm4m0TKnNP5R1QKhNU5W1mJcNW5]1jJ]N[5c1fJWN`5h1aJSNc5m1^JmMg5S2ZJgMl5X2UJcMo5]2RJ]MS6c2oIVMV6j2kIQMZ6n2gIlL^6T3cIfLb6Z3_IaLf6^3[I\\Lj6d3WIVLn6j3TIPLQ7o3P200000jGkLb4T3XKUMe4k2UK_Mg4a2VKeMh4Z2VKkMg4U2XKPNi0VNf0j3`NTN`0XNQ1d3]NZN6ZN^1[3[N`NK\\Nk1T3YNdNB_NU2m2WNjNXO`Nc2e2TNPOnNbNn2^2SNUOcNdN[3W2PN[OYNfNh3n1nM_1S2aNlM`1T2`NjMa1W2_NhMb1Y2]NfMd1Z2\\NdMf1\\2ZNcMg1^2XNaMi1_2WN`Mk1_2UN`Ml1a2SN_Mm1a2SN^Mn1b2RN^Mo1a2QN^MQ2b2nM^MR2b2nM^MS2a2mM^MT2c2kM]MV2b2jM]MX2b2hM^MX2c2gM]MZ2b2fM]M[2c2eM]M\\2b2dM]M^2c2aM]M_2c2aM]M`2b2`M]Ma2g2[MYMf2k3ULTLl3Q5oJoJR5U6iIoH", "size": [480, 640]}, "area": 154124.0, "iscrowd": 0, "image_id": 14226, "bbox": [0.0, 17.0, 640.0, 458.0], "category_id": 183, "id": 20000890}, {"segmentation": {"counts": "]ci0131Q=5MJPC110OOo<551SDKa:6]EIkN11Oc;9\\DGR16nNJa;?WE0h:2WENj:1cDC:a;?aDTON=a;X1K62MhN]NhFc1W9eNaF\\1a9]NbFe1[9RNmE5m0h1U9^NnF]1S9cNlF]1Q9fNoFZ1Q9hNnFW1P9nNnFQ1S9POlFn0T9VOiFj0X9nNoFR1Q9lNRGS1o8nNoFR1R9oNmFP1T9kNmEEm0a1V9hNQGX1P9hNoFX1T9gNlFW1lN_NW:5jEMR1c1R9aNmEKR1b1R9aNSG[1S9dNkF_1U9_NjFc1W9\\NiFe1e9\\NjEd1X:]NdEc1`:]N\\Ee1e:]NZEa1g:^NYEc1c:aN]E^1]:fNeEZ1[:fNeEZ1Y:hNgEY1R:[NaE>;X1V:ZN_E>:Y1V:ZN_E>:Y1W:hNjEX1X:gNiEX1W:ZN^E9=[1V:\\N_E6;`1U:YNbE59d1T:WNdE1:f1U:XNbE0;h1P;2M00O3N1OM[NbDb1_;5001OO100001O00O1O10N110000002N00004LI7002N2NL]NbDa1_;42O1O1NM400N1101O001O1OO11O001O001O0bN\\DU1e;gN\\D[1h;2O1VDaNo;Z1J7H_NcDb1[;`NgD^1Y;cNbDO1\\1];eNbD_1];eNbD\\1];dNcD\\10]N\\;6dD`1Z;92N000O0O11N2O12N001O1O0000009G3M00000O2O0000001O0001OO10001O000000000000000000000gNRDU1n;kNTDS1m;lNSDU1l;kNTDU1l;kNTDU1l;jNUDV1k;jNUDU1l;kNTDU1Q<0000OLlNRDU1n;kNRDU1n;lNQDT1o;lNQDT1o;lNQDU1n;40O10000000000000000000000O1000000000000000000000000000000000000000000NoCjNQlMCI06e7n0^HT19SNA62[O`7X1dHT1KeM9]1U7HhH\\11mNW7HgH]1OlNZ7GfHa1LiN^7EjHkNIS4\\7RMlHjNKS4X7SMWIj2i6XMVIg2j6YMUIi2j6UMWIkN]On3\\7WM]IoNXO_3[7cMhIZ2W6fMhIjNnN]3[7hMkIjNjN\\3[7iMQJU2n5kMVJQ2j5kLeHQ1d1Q2g5nLeHQ1h1m1d5QMdHR1h1n1c5PMgHP1f1o1h5RNWJn1h5SNUKoNaMi1Z7WO_Kh0b4WO]Kj0c4VO^Ki0b4WO\\Kk0d4UN`H21h0j2Q1l4nNXKo0b4YN`HOOi0S39Q5LPKOU50jJL[55fJH\\5ZO`Gk0U3ZOoL6`8=QKXO\\L0g8g0j3]OaC:]O10000O10000O100001O00000O1000000[ETOk8l0TGVOk8k0SGWOl8i0SGZOl8e0SG\\Ol8e0SG]Ol8c0UG\\Ok8d0UG\\Ok8e0TG[Ol8e0UGZOk8f0UG[Oj8e0VGZOk8f0VGYOj8g0VGYOj8g0WGXOi8i0VGWOj8i0VGWOj8i0UG]Of8c0XGDc8<]GEb8;]GGc88\\GJc87[GLc84]GLc84^GL`85`GL_84aGK`85`GK`85`GK_87aGH_88aGH_88aGI^87cGH]88cGH^87bGJnNPOU9V1nGInNQOR9X1oGMiNROQ9Q1VH9j7GUH:k7FUH:k7FUH:k7FUH:k7FUH;j7FVH9j7GUH:k7FVH9j7GVH:i7FWH;g7FXH]NPNo7c1eI>\\6AdI>\\6ChI_NXNg1o7KTJNk52VJMk52VJKl55TJJm56VJHi58WJ^NmMR1n7>`J@_5a0`J@\\5c0dJ^O]5`0cJA[5`0eJ@[5`0eJAZ5?fJBZ5=fJCY5?fJAY5`0gJ_OZ5a0fJ_O[5kNTHc1a2B]5MTH[O_2j0Y5MXHlNN116`2=_MKk7f0ZHkNN0N1a2c0_MJk7f0^HlNZ2g0]M[O0N20M1l7S1VKPOPMLf8T1\\JoNk5n0VJROi5n0WJQOg5R1ZJoNf5o0[JoNf5Q1[3O2NM300O0011O01L3002N0O1000000001O000000000NlNmCT1S;e7i3mGlK>:e7j3nGkK>:d7l3]HULd7l3[HULd7k3nGjK9=g7j3PHkK6;j7k3oGlK59l7l3oGlK1:P8k3nGlK0;Q8g4O00002N1OMTHiJj7W55001OO100001O00O1O100O10000002N00004LI7002N2NLSHlJk7U551O1O1OL400N2001O001O1OO11O001O001O0UHiJb7X5ZHiJh7[52O17IJ6IUHmJl7Q5VHQKh7o4YHlJO1f7S5[HlJk7Q5YHnJg7R5YHnJg7S5XHmJh7R592N0000O1O1N2O12N001O1O0000002N0000O1O100N2O12N00N21O1O1O00000000O1001O00O1O1001O1OO1N21O1O1O0000002N00M3O11O0000O1002NO11O1O00O1O10000O11O001O00001O00O11OO1O100O10000O100000000O1000000O1001OO11OO10000O11O00000000000000N2N21O1OO11O00001O000000O1O11O00000000000000001OO11O0000001O00O1001OO1001O00O100O100001ON21O000000O1001O00O1000000O11O0000000000000000000000001O00000000000000000000000000001O000000000000001OO1000000001O000000001O00O1000000O11O00000000O100O100000000001OO10000O11ON2001O00O1O1000000000000O1O100N2001O3MO1000000000000O11O0000O1000000O1N2O11O1O2N000000001O001OO1N2N200O1O12NO12N1O00001OO1O11OO11O1O00O10000O11O1OO11OO100001O000000N2N2001O002N002NO100O1001O00000000001ON20000000000O100002NM^G^Ka8b44001O000000O10[G\\Kc8f401O00O100N200O1N21O000000000000000000O10000O1N200001O1OM3N2N21O000000001O00N2001O0000O1001O0000O1O100O1O12N001O00000000000000O1O100000000O11O1O00N2MmFmKT9S421O1O002NO1001O00000000000000O1N200001OO1001O", "size": [427, 640]}, "area": 100491.0, "iscrowd": 0, "image_id": 14380, "bbox": [0.0, 0.0, 640.0, 181.0], "category_id": 106, "id": 20000893}, {"segmentation": {"counts": "og[21Z=0hB0U=0jB200o<9M35K0O01O1OO20O001OO101N11OO11ON2N3OiR2d;B[D?d;BZD?f;@\\D`0d;@[D`0e;_O\\Db0c;_O]D`0c;@]Da0DZOl;4aDa0B]Ol;2bDa0B^Ok;2bDe0^;[OcDd0^;\\OaDf0];ZOcDf0];[OcDd0^;\\OaDd0_;\\OaDe0^;[OcDd0];\\OcDd0^;[ObDLCh0i;\\OeDKBi0i;\\OgDd0Z;[OdDg0\\;YOdDi0Z;WOfDh0[;XOfDg0[;XOeDh0[;XOeDj0Y;VOiDh0W;XOiDh0X;WOhDk0V;UOjDk0k;0000SOdCm0ZDA[;3oD=EA[;2PE>DB[;ORE`0^O\\O14_;1QEa0@_O_;0QEj0o:VOQEl0m:TOTEk0m:TOSEl0m:TOTEk0l:VOSEj0^OPO];6VEk0j:TOWEl0j:TOUEk0l:TOUEl0k:UOTEl0k:UOUEi0l:XOSEg0n:YOREf0P;ZOPEe0P;[OPEe0P;[OPEf0o:ZOREe0n:[OREe0o:ZOREf0m:ZOSEf0m:ZOSEf0m:VOWEk0h:XOWEg0i:XOVEi0j:WOVEi0j:WOVEj0i:WOXEf0i:ZOWEf0i:\\OmDMEe0a;]OjDNEd0b;_OhDMFe0a;_OhDMEe0c;^OhDMEe0c;]OjDi0W;UOjDl0U;UOlDh0U;XOkDi0T;WOlDi0T;VOmDi0U;VOlDj0GROR;3XEk0FUOo:1ZEj0GUOo:0[Ek0FWOm:N^Ej0]OSO2006R;O^Ei0_OSOOO15T;2ZEU1AdNS;7mDI=^1f:kN[EGB[1S;POYEED[1S;QOZEo0g:PO[En0e:RO[En0e:TOYEl0g:TOYEl0g:UOXEk0h:TOYEl0h:SOXEm0h:SOXEm0h:TOWEl0i:TOWEHFk0S;_O^Ea0c:_O\\Ea0d:@[E`0e:AZE?f:A[E>e:B[E>f:@[E`0e:@[E`0e:@\\E?d:A]E>c:B^E=b:C]E>d:A\\E?d:A]E>c:B^E=b:C^E=b:C^E=b:C^E=b:CZEB^O00k0X;CZEB^Om0X;@WEf0j:XOWEh0i:XOYEf0g:YOZEg0f:YOZEg0f:YOZEg0f:YOZEg0f:YO[Ef0e:ZO[Ef0e:ZO\\Ee0d:[O\\Ee0d:[O\\Ee0d:[O\\EK[Oc0Y;B]EJ]Oa0V;E]EJ]Oa0V;E]EK\\O`0W;E]EK^O>U;BeEKRO04c0cg74RI_OVO>h72SI_OWO=f74SI_OWO=f74TI_OUO>h71TI@TO`0f71VI_OUO?f71UIATO?h7OSIBUO?f71UI@\\NCh0k0h70TIC[NBi0k0i7OSIFTOf7NTIDXO=d7NTIEWO>e7NSIEWO>g7KRIGWO>g7KRIGYO=c7MTIHWO;c7OVIFWO:`7UOfGl0c1EYO:\\7UOhGl0c1EYO;[74XID]O9Z73ZIC\\OP7OdIC\\O>P7OeIC[O=P70eIC[O=P70eIC\\OZ7MdIFQO=\\7LcIGQO=[7NdIDQO>[7NdIDPO?\\7MdIDPO?\\7MdIEPO=\\7NeIDoN>\\7NgIBlNa0]7MhIBjNa0]7OjI_OiNDAa0k7=mI\\OhNEAa0i7?nI[OiNDB`0g7a0nI\\OjN^O\\O14d0i7`0nI\\OkN@_Od0h7`0nI\\OTO4n6`0nI\\OVO2l6c0mI\\OVO1l6d0nI[OVO1l6]OSHU1k1^OUO0o6b0mI]OTO^OPOa0n7e0nI]OUONm6e0mI^OVOMm6e0nI]OTOOQ7b0iI@VONQ7@PHm0j1DVONU7@mGh0i1JSOO^76`IJQO1_75`IJPO2`74aIJnN2a74aIJnN2b74_IJPO1a75_IKoN0b75_IKoN0b75_ILoNNb76_ILoNNb76_ILoNNb76[I0TOIa78]INQOIc78\\INROJb78\\INROJb78\\INSOIa79]IOoNId78]IOoNId78_IEVNEe0`0f77^IDWNEd0a0g76_ICVNFe0`0f77`IBVNEe0b0e77`IBVNEe0b0e77_IDRO5_77^IETO3^78_IFPO3a78^IERO2`79^IERO2`79]IFRO2a78]IGROGROO_8c0\\IHSOFUOL\\8f0]IGROGUOL]8e0[IISOFWOJ\\8g0YIJSO]OSO2006O[8h0[IIRO_OSOOO150\\8h0^IF]OAT70`Gi0o1WOQN=n9CRFi0Q2EoMBk90UFi0S2CmMDk90UFj0S2Ch7CUFj0S2Ef7=ZHCf7=\\HAd7?\\HAd7?]H@c7`0\\HAe7?ZHAf7?ZHAf7DVFh0U2Ce7EVFh0U2CPNF_9g0cHJ^75cHJ]76dHI\\78dHG]78cHI\\77dHI\\77cHJ]76cHJ]76cHK\\75dHL[75dHL[74eHK\\75dHK\\75dHL[74eHM[72eHNZ73fHMX76gHJX77hHEjM^O00^9m0hHEjM^O`9m0eHBa7>^HC`7@\\Fm0T2E^7=aHD_7=`HC`7=`HC`7=`HC`7=`HD_7[IDc6<]IDc6=\\ICd6=\\ICf6;[IEc6<]ICd6=\\IDb6=^ICg68YIHn6\\ObFd0_21Q7NoH3P7MPI2Q7NoH2Q7NoH3P7MoH4Q7MmH4S7LnH3R7MnH5Q7JoH4S7LmH6Q7JoH6Q7JPI5P7LoH5P7KoH7P7IPI7o6JRI6m6JSI6l6KTI5m6JTI6k6KSI6m6JTI1eMYOW9e0TI5n6LRIMU7;h2EkC]OZoIBQ6>oIBQ6>PJAP6`0oI@Q6`0oI@Q6`0oI@Q6`0PJ_OP6a0PJ_OP6a0PJ_OP6a0PJ_OP6b0PJ]OP6c0PJ]OP6c0QJ\\Oo5d0QJ\\Oo5d0QJ\\Oo5d0QJ\\Oo5d0RJ[On5f0QJZOo5f0QJZOo5f0RJYOn5g0RJYOn5G`G`0b2In5G`G`0b2In5DcGc0`2Hn5_OhGh0Z2I^68bIG^69bIG^69bIG^69bIG^69cIF]6:cIF^69bIG^6:bIE^6;bIE^6;bIE^6;bIE^6;cID\\6=dIC\\6=dIC\\6>dIA\\6?dIA\\6?dIA]6>dIA[6`0eI@\\6?dIA\\6`0cI@]6b0bI]O^6e0`I[O_6i0^IWOb6k0]ITOb6o0\\IQOb6T1[IlN", "size": [427, 640]}, "area": 23505.0, "iscrowd": 0, "image_id": 14380, "bbox": [113.0, 227.0, 527.0, 200.0], "category_id": 147, "id": 20000900}, {"segmentation": {"counts": "Wbb01X=5nBLf[CCe<=YCGd<`01O000O100O11O001O1O00_O\\C=b4^OZ<1cCa02_O[ZCBe<;_CE`<<`CCe<9;K10000O2OOOf_i0OZ`VO3N20O010000kBMQ=70O010O10O001NO21O3OM^OGRD001O1OWCBd]CBd<=[CDe<<[CDe<<[CDe\\CAdV<1O0000O10O10010O0000000000O02N100O3N1O01O00O11O000O1HPDLP<4PDLP<4QDKP<4:GeC001T^;0^nDO^C0011OX<1gCO011OX<1gCO0103S<0mC3U\\D@N013e;>ZDC0Of;i00000000000001WOYDc0f;^O[Da0e;_O\\D`0d;_O^D`0b;_O_Da0a;]ObD6J2n;LUD3g;O[D1c;1]DNb;4_DFK0c;=bDCa;?;O3GjCNXS;BoD>d;O00001OO01001O01O01OO11OO3N1N1HgC3[>;\\58VJ^O=:]58VJ^O<<]56WJ^O<<]56WJ]O=>[55XJ]O==\\56VJ^O><\\56VJ^O><\\56WJ^O<<]56WJ^O;=^55WJ^O<<]56WJ^O;=^55WJ^O;=^55WJ^O;=^5BPI0W10<>]5BPI0V12<<^5CPIFM2W1:=;`5CPIEM4T19==b5AWIKg0:=NhNCl6:XIMDEo0d0`0LT6MjH1a06a0LT6LkH2a05`0LU6MjH2a05`0LU6MjH3?5c0JT6NiH4a03b0KT6MjH5`035_OVO<[7OhH3b020JWO2_72dH1f0IROLl0:XOM`76`HOj0HROLj0=YOHc7o0YIPOROKh0`0ZOFb7o0[IoN0>RODc7m0_IhNlN001R1h0nNBe7l0hJDcM^Of7l0ZHkN]2k0cM^Of7j0kJI_MYOi7o0gJIcMTOf7R1gJK_55aJL^54bJM]53cJM]53cJM]53cJM]53cJL^54bJJ`55bJJ^55eJI[5JTHBe2a0W5MTHAh2c0Q5JYHBh2d0n4I\\H_OH0P3g0l4I]H@j2g0h4HfK7Y4HjK6V4InK5Q4KQL3o3MSL2l3MdHET3[J^OD4mN0T7?ZJ]OD5nNOT7>[J]OD6mNOT7b0WJYO]Oa0XODT7b0WJ[O[O?[OCS7`0\\J]OUO`0\\OCS7`0\\J]OUO?]ODR7a0[J\\OWO>]ODQ7c0ZJ[OXO>[OFS7a0ZJ[OXO>ZOGT7?[J\\OWO1[OJN;U7>[J[OXO2^O;P78[JZOWO3B7l6<[JZOWO3C6k6=\\JYOVO4C6k6=[JYOXO5@6m6<[JYOXO5@KGNV7h0]JYOVO6@LGLV7i0\\JZOWO5@MGJV7j0\\JYOXO6_O6m6:]JZOWO6AOP7?ZJ^OSOT1_6\\O`JAdNCOe0OKn67dJH^NC1NL<43m68dJIWN@N013g02E8j6:dJJUNC0Oh01_O0K8U7;dJ5fNYO_O<3JT7AGX7;hH\\O;e0KIOF:6_OL02Z7U1hNdN0W7j0UI9W1fN^N5W7l0TI9a1hN\\5m0VI:P9FPG:P9FQG^OD3[9>UG[OB7X9?WGYO@FH`0a9a0ZGXO[OGJ`0a9a0]GVOWOIL?`9b0`GSOWO;Y9NcF1P1BUO?X9NjFEE1_1;S8ObHO_70aH0`70aH0^70bH0^7OcH1]7OdH0\\7OcH3]7MdH2\\7NeH1[70dH0\\71dHN\\74bHM]72cHO]71cHO]71bH0^70cHO]71cHO]7L_FIU2;\\7MgH3Y7LgH5Y7KgH4Z7LfH4Z7LfH3[7MeH3[7NeH2Z7NdH3@Io54aJGiM:f1Mo53aJFjM;<0?Ni61gJKeML:o0FBc7HWK_1i4bNTK`1l4aNQKb1n4`NoJ`1R5cNkJ]1NRNi2a0VMc1LoMm2>UMj1GkMS3;VMl1BlMX38TMS2]OhM^35SMW2[OgMa32TMW2XOkMc3NRLFFd2b0kMe3KQLIEc2c0lMf3InKKI`2`0oMi3FmKLI`2?QNj3CoKKHa2Hg0f0]Oc1QO]Ob0WNg0L9m0\\Od1SOYOf4SOXLd1QOXOh4TOWLe1QOUOi4VOVLg1oNROl4WOULh1oNoNm4YOTLk0lNiN1R1Q5ZORLj0POgNMT1R5\\OPL1hNA>IHX1S5]OoKLPOWOf04WO\\1U5]OmKL:YOeN\\1V5_OkKLk0d0[3@jKLk0c0\\3AiKLj0d0]3_OkKLh0e0]3_OkKLh0e0]3_OlKKf0g0^3^OmKKd0g0_3^OmKKd0f0`3_OlKKd0f0`3_OlKKc0g0a3^OlKKc0g0a3^OkKLd0f0a3^OkKLc0g0b3]OlKLc0d0b3@jKMe0b0a3AjKNe0`0a3BjKNf0?`3CjKMh0?^3DkKLh0?]3EkKLh0>^3FjKKi0?]3FmKIe0a0^3FmKIe0a0^3FnKGe0c0]3FnKGe0c0]3FnKFf0c0]3GmKFf0c0]3GmKGe0b0^3GmKGf0a0]3HkJPO`0h0W1`0^3HiJTO`0c0Z1a0]3HgJXO`0?\\1`0^3IeJ[O>=_1?^3IeJ]O<;a1?^3IcJH50j1?^3I`JL8Kj1`0^3J^J6NBV2>^3J^J7N@V2>_3K]J7M@X2>^3K^J6KCX2<_3K_J5JDX2<_3KcJMGSOOh0Y2=^3KcJEN7R28]3LdJ\\O5`0j17^3McJYO8c0g17^3MdJVO:e0d18^3MeJTO:g0c18^3MfJQOcIS1g1^Ng4<\\ISO\\1Gi4=SJYOGc0]1Fj4>XJSOBi0[1El4?jJKEm4`0eJK>Fl4?fJK6XO_N>e6?fJKKDiN2f6?eJLANTOGf6?cJNXO8^O\\Oh2_OR1o0`MNTOl15iM^OB5FJU1H`5f0jJ\\OXO4`0J^5g0iJ[OYO3`0L^5f0iJ\\OXO0d0M[5g0iJ\\OWOOg0NY5f0jJ]OVONh0OX5g0iJ\\OWOLi02W5f0iJ\\OWOJk04U5f0iJ\\OWOHm06S5f0iJ[OXOHm07R5f0jJ\\OUOEN1;8h5f0iJ\\OWOCN774k5f0iJ\\OMM\\O1n5f0hJ\\ON1ZOJR6i0fJ]ON6TOCX6j0fJ]ON?jN[Ob6i0gJ\\OMa0iNZOc6i0gJ\\OMb0hNYOd6i0gJ\\OMc0gNXOV2HT2Q1RM\\ONc0eNXOS20T2i0VM\\ONd0dNWOP25W2d0UM^O0c0cNVOR14ZO6l3?UM_OOk0DWOUO4S4;UM_OOk0A7[3_OVM]O0l0\\O;^3\\OUM^O2j0cNU1U4cNWM]O1k0cNU1U4cNVM_O2h0cNV1U4cNWM^OYOHIP1BW1U4cNWM^OUO1Hg0GX1T4bNXM^OTO4Fe0JW1T4bNXM]OUO6Bg0LT1U4bNXM^OSO7Bf0OR1T4cNXM^ObNA>g0Df00Q1T4bNYMAoNh1C6T4bNYMAoNg1D6T4bNXMBPOf1D6T4aNYMCoNg1C^O`0]Ne3k0YMBPOh1BTOm0dNX3n0YMBPOh1BnN\\5HQLBROP3o4_MnKBROm2R5aMmKBPOk2U5cMkKBPOi2W5eMhKCROd2Y5iMfKBROb2Z5kMeKCQO_2]5nMbKCRO]2]5PNaKCSO\\2\\5RN_KCVOZ2[5SN_KCWON]Oi1k5fNbKBYOG_OT2c5cNeKALm1]4bNgKALP2Z4_NjKAMQ2W4^NlKAMT2T4[NoK@9k1g3eNPL@a0d1^3lNQL@e0b1X3nNSL@j0^1R3ROTL@o0@dMg1X5YOUL@o0@dMi1V5WOXL_Oo0@cMk1U5VOXL@R1[1e2bNmJ2\\11R1\\1d2`NoJ3[11R1MeMm0m4RORK2Z12R1MlMg0e4WOTK3Y13Q1LRNc0_4[OUK3Y13Q1LVNa0Y4^OVK3Y12R1LYN?U4BUKDO8]17P1L^Nb3@fK0T15P1MeN>`3@gK0T16o0LgN>^3@hK0T16o0LhN?[3_OjK0T16o0LiN?Y3@jKOU15P1MiN?W3ChKLX15P1MjN`0T3BjKLX14Q1NjN?S3DiKKW16S12eN8X3FhKKW15T12fN6X3DkKNS17T11gN5W3EkKNT17R11iN4V3FkKNT17?B^NNGa0X1=k2\\OVL0R17oELP:4PFLP:5nELR:6lEJT:e0XE@h:U12N100N20000O100iNnDK1Nc03_:MUEOKOd03i:M^E2b:N_E2a;NaQg4", "size": [404, 640]}, "area": 644.0, "iscrowd": 0, "image_id": 14439, "bbox": [236.0, 15.0, 21.0, 55.0], "category_id": 132, "id": 20000909}, {"segmentation": {"counts": "nZ6120^<0aC3[O00001N10000O1O11N2OOO2O1NkCER<<32J42OO11O00O11O000O1O1CQD4QlDBT;>a0O1O1000000O12N3M3M6J1OO10000M3O1K51OO11O00O11O000000001O00O1O1O1O1O10000OWDE[;;cDH\\;7dDNX;1iD0V;0jD2T;OkD1U;0jD1U;0jD0V;1iDOW;1hD0X;0iDNX;4fDJ\\;7dDH\\;9bDH^;:`DF`;g0000O11OO14L00M3001O1O00O1000000000000O10000O1N2N2K50000000000000000000000000000000XDYOc;g0\\D\\Ob;d0^D^O`;k003M000000N20000O11O000000\\OcD1];OjDEE1a;:d0O10000O100O100001O1O2NO100000000KlCIU<83O1000000001O00001O00001O1O2N3M00000000000000001O000000O1O1O1BoC7_Oc06kNI26f8JYG6=Lh05jNI26e8j5BQJb0R6]OiIf0Y6[OaIg0U5mMkJ_1Ih0Y5kMoJ`1Bh0^5hMQKc1[Oh0`5hMVKc1SOi0d5fMZK9PO_3F`L:_31WLOi31WLOi32VLNk31ULNm30TL0P4DXLX5e0aJ[O_5e0aJZO`5f0_JZOb5g0\\JZOe5e0ZJ[Og5e0XJ[Oi5f0TJ\\OT6gICZ6e0\\I[Oe6e0ZI[O_6ZOlGZ1e1\\O\\6^OnG?5Ga1;Z6BWHK;4U1>W6CSH3g0Go0c0U6AQH>j20U5NVHCd2>V50XK0c4^OUHb0X30b46^KIc48\\KHd49[KFf4h0lJWOV5h0jJXO]5GUH6^22_5F\\K9f4KTK6P5HnJ7Y5CgJ[;NdD2Q;9oDGf:d0ZE\\Oh2@m4X1[HXOe2CP5V1ZHXOb2FS5g1jJ\\NU5e1hJ^NX5b1_HoMQ2c0_5_1_HnMo1f0j4T2WIWMk1h0n4Q2WIXMg1k0P5n1YIXMb1n0T5k1ZIXM^1P1X5i1YIXM[1S1Z5f1[IXMW1U1]5d1\\IXMS1W1`5b1]IXMo0Z1c5^1^IYMk0\\1f5]1^I[Me0[1l5[1_IeM7T1Y6W1`IJ_67aII_67aIJ]66dIJ\\66dIJ\\66dIK[65eIWO6oMV6j2dIRO=RNP6k2cIoNc0TNj5m2cIjNk0UNd5P3aIfNR1XN]5R3aIdNg7[1YHcNi7]1WHaNl7YOSHX11^Om7ZOSHW10]OP8[OQHW1O]OQ8\\OPHW1OEi7SOZHW1MNb7jNbHW1L7i7SN\\He1K`0S8_OmGi0k7WOUHk0j7TOVHl0k7SOUHm0l7ROTHn0l7ROTHn0m7QOTHn0m7QOWHj0k7bNRHZO7P2g7bNVH^O7l1d7aNZHB6i1a7aN\\HF7e1^7`N_HK7a1Z7`NdHN6]1X7dNbHO:Y1T7hNbHOn0e0_6]OdHMo0d0]6^OeHNP1b0Z6AfHMR1`0W6DgHLT1>T6FjHKT1VIFb1JW5a0WIEd1HT5c0YIE_9;aFD_9d9B_F<`9DaF=]9CdF=[9CfF=Y9ChF=W9CjF>T9BmF>R9BoF>P9BQG?m8ATG?k8AVG?i8AXG`0f8@[G?e8FWG8j8IVG6j8JWG4j8LWG3V8^OlFMHb0W1=g7WOWGMK?X1Z;000O10O1000000FVn6", "size": [404, 640]}, "area": 46783.0, "iscrowd": 0, "image_id": 14439, "bbox": [25.0, 39.0, 597.0, 301.0], "category_id": 183, "id": 20000914}, {"segmentation": {"counts": "m0n3]9000000000010O000000000001O000001O0cLdFk2]9nLcFJ1X3\\9lLlFT3e9000001O000001N10000O100O101O00000001O0010O01O1O0000O101N1O1O11OO100O2O0O10000000iN[FhNe9V1`FhN_9X1bFgN^9?\\FWO7XOIo0e9?]FZO86\\9XOZFJ0S12E86f95RFE95d96TFE85d96TFD97a96VFC:6`97VFC:ZODh0l9;VFC>B@4m9e0VFCL[Ob08_O5n9d0UFCa0D\\O5n9c0VFBi0_OTO;o9FoEf09Gl0LW93XFGf04W9LhG3Z8IhG7f:0L400fMDWF8N0YO5`:JiEKI<2MOMM6R:;PFOMG4IN5h9T2YFgMO5g9W2XFeM04h9W2XFeM04h9X2WFdM14h9c2XF]Mh9c2XF^Mg9S3000000000001O00000000000O2O00000O1000001N1000000000001O000O1000000N3O00000000000O2O0001OO1000001N1000000O1O101N1O100O1O1O1O2OMRGiKm8W44001O0O1001O001O001O0VOmF\\MS9d2nF[MS9d2mFnLO2T9Q3mFmLO2T9Q3mFmLO2T9Q3oFkLN4R9Q3PGkLN4R9g2mFUMn9l0VFCL80RO17l9l0ZF^OND0O`:m0iEoNZ;P1a0O1O10000000002OhFTOkL1P9k0YITOXN=_8?RHTOQO5MO1>8]OG01?P9>^Gn0IYNH;R9?[Gn0JXNI?AGT10lNEQ9j0PG[O??@GT10lNEQ9h0QG^O?=_OHU1IS8d0jF^O`06@D29_:?_EYOY<`0>1M10O10XF^Og6a0cG_O25fN00LOO]9a0VGDE7n01jNH\\9k0AW8OnFa0j0@X80mF`0k0AY8OiFb0NiNM120c0e0[OZO[9e0eF\\O1W1OROe0<[O[O:Oe8h0QG`00SOb0E^Ok01XO1N<2m7\\2UHlNLjNo7[2kGTO3cNS8Y2hGVO3bNU8X2eG[O2_NY8U4dGmK\\8a41O000010O000000000O1000001O01OO1001O000001O0000000000000O110O0000000000000002OO000001O1O1O0010O0001O1O0000000001O0001O001O1O4YKZGb4g80001OO100O2N1O10000000001O000O1000001O00000000001O0001O000010O00100O1N2O1O1O2M200N2O101O000O1O1O1O2O0O1O1N2O2M2O1O1O1O1O2N100O100O1O2O0fHUJOLQ7Z6N1O1O2OO00100001NO1000000001O1O1N1XI_If6d6O1N101ON21O3M00O10N103M5K103L4L3I5O1O10000O10]H]J^7j5N1O1O00iM", "size": [427, 640]}, "area": 88911.0, "iscrowd": 0, "image_id": 14473, "bbox": [0.0, 29.0, 640.0, 278.0], "category_id": 124, "id": 20000915}, {"segmentation": {"counts": "Rlg11:1d<0XC4g<801O1O1O0000O100O10000O100000000O100000000002N00001O1O001O00000000O1O1000000001O@WC00036V=JcUh03VjWO5O2N3M3M3M00O1O10000001O000000000000000000O10000O11O0000000000000000001O001O001OO1001O1O00000000000000N200O100O1000000O100001O0000001O1O0000000000000000001O0000000000000000000001O100O00001O01O0001O000O2O001N101N10001N1O100001O1O001O001O1N2O00000O100001O000000000O101O01O1O1O00000000000O2O01O00000000000010O00001O01O001O0O10001O0010O001O1O1O0010O0100O01O01OO2M2O2O00001O001O01O001O1O00O1000O1001O001O100O1O010N2M3Mbfa2", "size": [427, 640]}, "area": 4149.0, "iscrowd": 0, "image_id": 14473, "bbox": [134.0, 0.0, 310.0, 36.0], "category_id": 127, "id": 20000916}, {"segmentation": {"counts": "kai01X=5M1UOJ_D7XOIT<2dD8k9GcEOJ0S12E8k91`FGE9j9OaFIE8j9OaFID9j9NcFIC:i9MdFIC:ZODZ::iFHC>B@e98]OG01?8V96VHIYNH;1`9M3kD^O_9c0QF_OVO1i:`0XE]OH0`0`0`:`0nDQOb0?Q9AiGS1UO\\OP9LcGg0]O]Oo8MdGf0\\O^Oo8@bF:R1h0]O_Om8_OdF;R1g0]O_OQ9KaGg0]O^OQ9LbGf0\\O_OR9LTGAGT13_Oj8^OmF>?AGT10lNEd0W9]OnF??@GT10lNEd0U9^OQG?=_OHU1IGP9VORG`06@D29T2j8jMnFP4i8=2N00O10aNUG^Nj8LVG25fN00LOOT1j8_O[GE7n01jNHS1e8ZOcGG2Q15NY8WO`GH4S13OX8UOcGG4T12OW8VOXHk0AOW8VOYHj0@0X8UOXHk0AOY8SOXHNiNM120c0e0[OZOP1P9POQG1W1OROe0<[O[O:O9T9]OTH0SOb0E^Ok01XO1N`:_OaEb0_:]OaEc0`:]OVEn0i:ROSER1m:nNoDV1h:l0]Ob0O2O1N2O1O3L7J1O1OdMSFZ1j9]NcFc1Y9TNSGm1f8eMdF2S1Y2h901O01O0REeM73Y:h2N0010O01OL4N20001O000`MaET2_:jMlEn1S:RNnE1Bc1`:]NYF_1i9`NYF^1g9bN[F[1f9fNZFZ1e9fN[FZ1e9gNZFY1f9iNYFV1h9kNVFV1i9lNUFT1k9nNSFS1l9oNRFQ1n9QOQFo0n9SOPFo0_O_N\\:c0QFT1o9POlER1S:SOfEo0Z:P11O1O2K4O1O100O101O0002N00N201O00000000001O000000001O000001O0001O01O001O00010O0000000001O01O00000001O00000000001VNVEQ1j:mNXES1h:kN[ET1e:jN^EV1a:hNaEW1`:gN`E[1a:^NfEb1Y:\\NlEa1T:_NVFW1j9hNWFX1i9hNWFX1i9hNXFW1n:N20kNkNUFS1l9mNTFS1l9ROkER1U:PObEV1`:jN_EV1a:kN[EX1e:lNSEX1m:c000001O00000001O1N2O4L2N1O1O0YE^Me:d2000000O100000aN]E7b:GaE8_:]OcEXO0[1]:fN_E9e0Q1m9dNcF\\1]9dNcF]1e:0I6K6UOWN[Fb1f9^N[F`1e9cN]FX1d9lNXFT1g9POUFP1k9@eE`0\\:C^E?b:U10010O1O000001N1O1O1O1O1O2O000001OO110O0001O1TEcMh:e2LO01O1O000001N1K5O10000O2N100O10001O00000001O01O01O001O1O10O01O5K002O0O;E00000001O000O1000001O00000O101N100O1O1O1O2N1O1001O00100O00000010O0O1O100O1O2O00000000001O01O1O1OO1010O002N0001O000O1O1O1O2O00000000001O000001O01O000O\\EjMU:V2jEjMW:V2gElMY:X2aEjM`:`20001O001O100O1O1O0001O01O00001O010O0000000001O000O1O1O2N1O1IaE`Ma:^27K5O2N10000000001O0001O0001O000001O0001O0O1O1000O10000O101O0O100O10000O10O0101QEiMh:W2WElMf:^2O1O1O001O002N1O1O000000000000000000O0100O2N100O1O101N1I6O12N3N010O1O3MO11O00O1N101000000000100VFkL[9W3`FmL^9`3100000O2K4011NO2O1O001O1000GiF\\LX9a3:^LYF^3l9M3N1O2ON30N4NO0O2O2M21N4MO12M3N1N0000000O10000001O00000]F", "size": [427, 640]}, "area": 51714.0, "iscrowd": 0, "image_id": 14473, "bbox": [0.0, 205.0, 640.0, 208.0], "category_id": 147, "id": 20000918}, {"segmentation": {"counts": "RnW41Z=1O1O00001O0000001O00001O001O001O00001O00000000000000000000O1000000O100001O0000000000001O000000000000000000O1001O0000000000001O000000001O001O0000001O001O0000000000001O001O001O00001O001O00001O001O0000000000000000O1001O000000000000000000000000000000O1000000O11O0000000000O10000N2N2O1O1O1O100O1O10000O1000000002N1O1O1O1O1O1O001O001O1O1O001O00001O001O00001O000000001O00001OO11O0000001O00001O001O001O001O001O001O00000000001OO100O1J600O100O1O1O1O1O1O1O10000000000001O00001O001O0000001O0000O100O10000O1O1O1O1O1O1L400001O001OO10000000000001O1O001O1O1O1O00001O001O2N1O1O001O00001O2N2N1O0000000000001O1O001O001O001O000000O10000O100001O00", "size": [427, 640]}, "area": 5651.0, "iscrowd": 0, "image_id": 14473, "bbox": [326.0, 0.0, 314.0, 35.0], "category_id": 157, "id": 20000919}, {"segmentation": {"counts": "n]R32Y=0oB0f<3UC0k<8O1M3O1O1O011O0001N1001O00O11OO1001OO02OO11N11O0000000000000000001O001O001OO1001000OO1001O00001O0N3O0O101N101O000O2O00010O00001000O000001O000000000001O0001O000000O11O000000O101O01O00O101O0000000O02O000O100O10001N1O101OO2O1O0O2O001O1N2O0O10000000000001O00000O100010N2O1O000001O000010O00000001OO10000O2O00001O0001O1OO01000001O10O001O1O10O01N101O1O000O2OO1N3N2O00O11O000001N101O1O00O10001OO100O10001O000O2N00O3N010000000001O1M5MO3EH^C9a<;N1O1O0O2O1O0O1N2M4M21O10O01O1O1O001N10001O00100N3N3N0O0000001O00001O001O0O20O01O00000000000002N01OO110O100O001O00001N2O0O13M4L1O1O1O100L4N1O2M3MYR_1", "size": [427, 640]}, "area": 6558.0, "iscrowd": 0, "image_id": 14473, "bbox": [236.0, 17.0, 291.0, 48.0], "category_id": 164, "id": 20000920}, {"segmentation": {"counts": "0m0^<0000000000001O0000000000000000001O0UDROY;o0`DQOJ1f;n0^DZOa;X1000001O000000O10000O100O100000000001O001O001O1O0000O100O1O1O11OO100O100O1000000000000001OO1000000O100O1O100N2O1O1O1O100002N001O001QDkNf;_1N2N1O000000000000000000000000000000O1000000O1000000O10000000000000000O1000000N2000000000000O2kNUDh0l;TOXDk0T<10N2O1O000O0100O10O1O010O1O100O001O1O100O102N000O2O10O010O001O000O2N0100000001O@[OlC0036b0n;IlC7T<`00000000000000002N001O1O1O1O1O1O001O1O1O0\\D`N];a1`DaNON^;b1cDcN\\;g1O1O001O3M1O2N1O0000001O1O000000000000O1000000O100O10000O1O10000O1WOTEQOn:m0UEROk:KiD>NH`0LT;;\\DGc0KU;;[DEc<8;L4Jjl`20YS_M1O1O1O001O1O1nBJm<:0000000001N2O3MO1GYCMg<3:O00000O1000O01Ndj00]UO2N1O2N2O1N1O2O000O2O001O1O201N00O1O1O100O0010O0100O10O010O0001O001O00001O01OO11O010O0001OO11O0O100O22M4L100O100O1eC_Ok;a0SDAl;?SDCm;=PDIJDP`5^6oJWI^O`0_5Y6QKZI^O=b5Z6oJ[I]O:e5[6nJ\\I[O:g5[6mJ\\IZO9j5^6iJZI[O8m5d6bJVI_O6o5d6bJkI_5U6aJjI`5V6_JkIa5U6_JjIb5V6]J]IAFS6m6\\JZIEGP6o6[JYIHEn5R7TJiHHOO`09El5S8VJkGk5T8WJjGj5U8a0O1N2O1N2O1O10000000eI^HX5c7]JiHa5\\8O2N1O2N3M2N1O8H>B1O00000000O1000000O100000000O11UKmE150NV4S:iKPF0O`0J@31M[3W:dLXF2BNO90G;W3d:iLTE1M00O=U3b:kLTE0?V3]:jLhEV3S;N0000000000000000000000lNmLjEOOT3V:SMdE`3[:cL\\EF5g3_:eL`E\\3`:eL^E\\3b:dL]E]3c:`00000000000000000001ON2L4M\\LTFZ2e9lLkEn0`0V2e9mM[FS2e9mM[FS2e9mM[FS2e9mM[FS2e9mM\\FR2d9nM\\FR2d9nM\\FR2c9oM\\FR2d9nM\\FR2d9nM]FQ2c9oM]FQ2h9kMWFU2o9eMPF\\2Q:cMmE_2T:`MlE`2T:bMhE`2X:cMdE^2\\:eMaE[2_:S1001OO1000000O11O00000000001O000000O1000000000000000000O1000000O100O15`K]EY4f:O000000000000O1000000000000FgKmEY4R:jKlEV4Q:hKiE53S4T:QLkEo3T:?00LXKQFg4o9YKRFf4n961UKmEg4Y:M00N2O11O001O00001O4nLlEP1W:gNoEY1T:cNnE\\1U:YNZEXOd0_2S:WNSFi1o9TNRFl1T:kMPFT2V:dMlE\\2\\;00000001O00001O00O100O1WLfMbH8a0T2k6hMVHa0m0h1l6hMQHg0S1`1i6lMTHe0ElNI6S1]2[7lMTHf0DSOm0[2X7oMWHg0AnNQ1[2W7PNWHS1c0l0U7SNWHQ1d0l0T7TNXHP1c0m0S7UNZHn0c0m0o5_MYIOD0?i02l0c0m0n5cMSI28c04k0d0l0m5fMnH49b08h0e0k0k5VNUI9:g0f0j0j5XNVI79g0h0i0i5ZNTI7;e0j0i0g5]NPI7?c0i0j0i5_O^IGh0k0i5_O_IF2a1[6jLVIP23SNO[5h6cJTIn7l6300000000000000000000000000000000O1O1O1O1O1N2O1O1O1O1O1O1O1O1O1O1O1O1O1O1N2O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O100O1O1O1O1O1O1OhGeJm6Z5jHeKa6[4TIfLV6Y3`IWM[6j5M3M4L3M3M3M3M3M3M4L3M3M3M3M3M4L3M3M4L3]MSFMQ:KTF4o9JPF6T:EnE:U:ClE1N10O0100O100000001O1O00010O3M2jAVOl01UOOoB1O00000000O2O00000O100000000O20O1O00O11O000001O01O0000gNTE^Nl:W1]EkNc:U1_EjN`:U1`ElN`:T1aEkN_:U1aEkN_:U1bEjN^:W1bEVN@No:l1aEVNA_OO:P;Q2aEUNGEi:U2bEUNIAf:Y2bEUNIBe:U2oDlMc0_CVM0h0R;X3J1O10O0000000010OO1000001N11O0001O0000O2O00000O01000O1000000O100000O0100000O010O15SEjKe:Z4O00000O100000O2O3M2N2N2N2N3CmDgLU;V3nDhLT;S3jDgL53R;U3REjLn:U3?H\\DTMd;k2^DUMa;i2aDXM^;g2>00M300O1L4N2001O0OSOjC[NOb0Vn4c2UOSMkK;S5_2ROnMm0o1ROUNn0h1QO`Nl0\\1TOcNP1Z1POfNS1W1lNjNX1R1hNnN[1o0eNTO[1i0eNVO_1g0aNWOe1e0[N[Oh1b0XN^Ok1?UNAn1_1f0V1Y1QL^MO:j01ZO:e2c0W1j1eL[NQ2KZ1i1_LoLAd1d2D[1j1`LgNR2_O^1j1_LjNQ2\\O`1k1^LlNo1YOc1k1^LnNm1WOf1i1^LSOi1TOj1h1]LVOg1ROm1g1\\LYOf1oNo1g1\\L\\Ob1mNT2e1ZL@`1kNX2c1VLG_1fN]2a1SLL^1cNc2]1PL2Z1aNh2[1oK5W1`Nk2Z1mK:U1\\NP3X1lK=R1[NS3f4jLZKW3g4hLXKY3i4eLWK]3j4`LVKb3j4\\LVKf3k4WLUKk3k4SLUKP4k4mKUKV4j4hKVKY4l4dKTK^4UOPKT5>iKd4POQKX55kKk4kNRK[5NmKQ5fNSK^5HnKW5bNRKV7`501O000000O12N1O000000", "size": [424, 640]}, "area": 61323.0, "iscrowd": 0, "image_id": 15079, "bbox": [0.0, 128.0, 640.0, 296.0], "category_id": 143, "id": 20000927}, {"segmentation": {"counts": "ZP82V=0O1O1O2OO02N100O1O100O100O2N100O1O10O01O100000O1000O10O001000O100O01000O100O102M2OD;001O010O001O010O01O10O0100O010O100O1O100O100O10O0100O001000O100O010O1O10000O01000O10000000O0100O10000O010O100O100O10O0100O10000O010O100000000O01000000000O0100000O10O010000000O10O10NZCBf<>2000O01O1O1O0010O1O0010O1O100000O10O10000OWCFf<:YCGf<9ZCIOMc<;]CKad8C_G<^8DfG;W8FmG8P8ISH7i7JZH5c7KaH4\\7MhH1U70nHOo61UIJl67WIE_MBW9j0^ID`6=cI@\\6`0hIAS6`0PJ_Om5b0WJ^Od5b0`JZO`5g0cJUO]5l0_31O001O1O001O1O3M2N2N3M2N3M2N3M2N3M2N3M2N2N3M2N3M2N3M2N3M2N3M2N2N3M2N3M2N3M1OO11O00001O001O001O1O001O001O1O001O001O1O001O1O0000001O00001O0000001O00001O001O001O0000000000000000000000O100001O00000000O10000000000O10000000000000000O10000001O1O1O1O2N2N2N4L2N1O2N1O1O1O2N2N2N2N3M3M1O2N2N1O1O2N00001O00001O1O1O001O00", "size": [424, 640]}, "area": 49874.0, "iscrowd": 0, "image_id": 15079, "bbox": [0.0, 0.0, 640.0, 178.0], "category_id": 173, "id": 20000929}, {"segmentation": {"counts": "dof06k<;EjKAW4`0iK_OX4a0gK^OZ4b0gK\\OZ4e0eK[O[4f0eKXO\\4h0dKXO\\4i0dKUO]4l0bKTO^4l0cKRO^4o0bKoN`4Q1_KoNa4R1_KlNb4U1^KjNb4W1^KgNc4Z1\\KfNd4[1\\KcNe4^1[K`Nf4a1ZK^Nf4c1ZK[Nh4e1WK[Ni4f1WKXNj4i1VKVNj4k1VKSNk4P5500O1QMoJgMQ5Z2oJeMR5W510000O10000O10001N10000O10000mNhJUJY5j5hJVJY5h5iJWJW5h5jJWJW5h5kJWJV5f5mJYJS5f5nJYJT5n4dJjJ:7R5P5oJ\\J1c0P5S5cKlJ_4T5aKkJ_4V5aKiJ`4X5dKaJ]4`5e1101N1O100O2O0O1O2OO00001O010O00001O001O00001O0O2O001O001N101O000O2O001O001N101O00001N101O001O1N101O1O001N2O1M2O2M3N1N3M3N2M4M2M4L3N3L3NaNkKnIR4U6QLiIk3Y6XLeIf3]6]LaI_3b6cL]IZ3e6iL[IQ3g6SMYIg2j6[MWI`2k6cMUIW2m6lMSIo1P7UNnHf1U7]NkH]1X7fNgHU1[7oNdHm0^7WO`Hd0c7_O]H;e7IZH2i72UHIn7:QH^OU8e0kGROZ8R1eGfNa8^1]G[Nh8h1WGPNn8T2RGcMT9`2i04L3L4M3M4K4M3M4L3L4M3M4K10O2O1N3N1O2M2O1N3N1N3N1O2M2O2M2O2N1N2O2M2O2M2010O2O0O100O1O101N100O2O0O100O2O0O1O101N100O101N100O2O0O1O101N100O101N100O2O0O1O101N100O101N100O101N1O101N100O101N100O101N1O10O0N3M2N3M2O2M2N3M2N2N3M2N3M2O2M2N3M2N3M2N2N3M2N3N1N3M2N3M2N3M2N2N3N1N3M2N3M2N3M2N3M2O1N3M2N3M2M4J5K6J5L`c4", "size": [424, 640]}, "area": 110265.0, "iscrowd": 0, "image_id": 15079, "bbox": [55.0, 8.0, 573.0, 377.0], "category_id": 183, "id": 20000930}, {"segmentation": {"counts": "0d:d1S10O12NN2M3K5L4K6K4L5J5L5J6K5J6K6J4K7J4K6K4K7J4L5J5L4K5L4K5L4L4K6K4K5L4L4K5L4K5[OWIdJm6X5UIiJl6S5XIlJi6S5[IiJf6T5_IhJc6T5aIkJ`6Q5eImJ\\6o4R1fLhG^1[8bNfGZ1]8eNdGX1_8hNbGR1c8mN_Gl0h8SOXGk0j8UOWGg0l8YOUGc0n8\\OSG;V9EkF9V9FkF9V9GjF7X9IhFLEiNf9[1eFKd95\\FJe96[FIf97ZFGh9:WFSOGHU:U1UFQOHHT:W1VFnNJET:]1RFlN]:V1cEgN^:Z1cEcN^:]1cEaN^:_1dE]Nd02_8a1RH`NQ8`1kG`NZ8_1bGaNb8_1[G`Ni8`1SG`NQ9`1kF`NY9`1cFaNa9^1[FbNh9^1UFbNP:[1nEeNV:X1kEfNX:X1o0M2O2N200000001N100O10000O1000000O1A?0001O00000000000000000000000000000000001O000000000000000000000000000000001O0000000000000000000000000000000000000000001O0000000000001O001O1O2N1O1O1O2N1O1Oajk3b0mTTL000000000000000000000000000000000O100000000001O00000000000000000000O10000000000000000000000000000001O]C^O]m1BmMc0T2^OiMd0W2\\OfMg0Z2YOcMi0^2WOYMR1g2nNXMS1h2mNWMT1i2lNUMU1l2kNiLSOkLU2\\6hNhLa1X3_NgLa1Z3_NeLb0iL^Ob60ZKRO[O^1oN^O\\62ZKROhN2H[11]OT64ZKTOgN2HV19^On56YKWOeN3ER1e0[Oh5:WKXOeN^1c0mNa5=VK[OcNX1l0nN[5?SK@cNP1V1nNT5b0SKAaNl0^1oNn4d0SKC]Nd0k1TOe4e0SKh0=bN`4f0SKd0b0eN[4h0RK?h0hNV4i0RKYEAh:?XEAh:?XE@i:`0WE_Oj:a0VE^Ok:b0UE^Ok:b0UE^Ok:b0UE^Ok:b0UE^Ok:b0UE^Ok:b0UE^Ok:b0UE^Ok:b0UE^Ok:b0UE]Ol:c0TE]Ol:c0TE]Ol:d0SE\\Om:d0SE\\On:c0RE]On:c0RE]On:c0RE]On:c0RE]On:c0RE\\Oo:d0QE\\Oo:d0QE\\Oo:d0QE\\Oo:d0QE\\Oo:d0QE\\Oo:d0QE\\Oo:d0QE\\Oo:d0QE\\Oo:d0QE[OP;e0PE[OP;f0oDZOQ;f0oDZOQ;f0oDZOQ;f0oDZOQ;f0oDZOQ;f0oDZOQ;f0oDZOQ;f0oDYOR;g0nDYOR;g0nDYOR;g0nDYOR;g0nDYOR;g0nDYOR;g0nDYOR;g0nDYOR;g0nDYOR;g0nDYOR;g0nDYOR;g0nDXOS;h0mDXOS;h0mDXOS;h0mDXOS;i0lDWOT;i0lDWOT;i0lDWOT;i0lDWOU;h0kDXOU;h0kDXOU;h0kDXOU;i0jDWOV;i0jDWOV;j0iDVOW;k0hDUOX;m0fDSOZ;n0eDRO[;o0dDQO\\;P1cDPO];R1aDnN_;S1`DmN`;T1_DlNa;_100000000000000000O100000000000000000000000000000001O00000000000000000000000000000000ZIZNg1f1YNZNg1f1YNZNg1f1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nj1e1VN[Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nk1b1UN^Nk1b1VN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1n4000000000000001O001O00001O0XIYNl1h1SNXNm1h1SNXNm1i1RNWNn1i1RNWNn1j1QNVNo1j1QNVNo1k1PNUNP2k1PNUNP2k1PNUNP2l1oMTNQ2l1oMTNQ2m1nMSNR2m1mMTNR2n1lMSNT2m1lMSNT2n1jMSNV2m1iMUNU2m1jMTNU2l1jMVNU2j1jMXNU2i1jMXNT2S2aMPN]2k2hLVMW3_3SLcLl3g3iK[LU4Q4ZKVLe4T4fJYLX5R4RJZLm5c5N2Ob0^Oh0XOi0TOQIUM\\4P2\\K`N[5`0iJEo5[OSJn2Q72M2XHYMj4i2lJIj29SMd0Q2]OmMl0j1WOSNQ1f1POWNY1b1hN\\N]1`1dN^N^1a1bN]Na1a1aN]Na1b1_N]Nc1b1^N[Ne1d1[N\\Ng1b1ZN\\Nh1c1YN\\Nh1b1YN^Nh1a1YN^Nh1a1XN_Ni1`1XN_Ni1`1WN`Nk1]1\\N]Ne1b1[N]Ng1c1XN]Ni1d1UN\\Nl1d1SN\\Nn1h1lMYNT2h1kMXNV2g1jMYNV2f1kMZNU2f1kMYNV2f1kMZNU2f1jM[NV2e1jM[NV2d1kM\\NU2d1kM\\NU2d1kM\\NU2c1kM^NU2b1kM]NW2c1hM]NX2e1fM[NZ2g1dMYN\\2h1cMXN]2j1`MWN`2k1^MUNb2m1\\MSNd2n1[MQNf2P2YMPNg2P2YMPNg2P2XMQNi2n1WMRNi2o1VMQNj2o1VMQNj2o1VMQNj2P2TMPNm2P2SMPNm2P2SMPNm2P2SMPNm2Q2RMoMn2Q2RMoMn2Q2RMoMo2Q2QMnMo2Q2RMnMo2R2QMnMo2Q2RMoMn2P2SMPNm2P2SMPNm2o1TMQNl2n1UMRNk2n1UMRNk2n1UMQNm2n1SMRNm2n1SMRNm2n1SMRNm2n1SMRNm2o1RMQNn2o1RMQNn2o1RMQNn2o1RMPNo2P2QMPNo2P2QMPNo2P2QMPNP3P2oLPNQ3P2oLQNP3o1PMQNP3o1PMQNP3o1PMQNP3o1PMQNP3o1PMQNP3o1PMQNP3o1PMRNo2n1QMRNo2m1RMSNn2l1SMTNm2l1SMTNm2l1SMTNm2l1SMTNl2>bI:b3XOl2>bI:b3YOk2=cI;a3XOl2=cI<`3WOm2=cI=_3VOn2=cI=_3VOn2=cI>^3UOo2=cI?]3TOP3=cI`0\\3TOP3hJK]3Cj1c0hJL`3_Of1e0jJNh1@kNM^4f0nJOf1BoNHZ4g0RK0a1GTOBT4g0WK2^1JWO^Oo3f0\\K4Z1N[OXOk3f0`K6W10@SOd3h0fK6R15DnN_3g0lK7n09HhNZ3h0PL9j0=LcNU3g0VL:e0a01^NP3g0ZLkNZ2P6XMWKX4e4hK]KY4`4gKbK[4`0mJg1h0jM^4?jJc1h0PN`4n3aKTL`4i3`K[L`4`3aKcL`4W3aKkLb46cJc0l0BY4LkJ]KBg4DnIVN]1X2f4DmInM^1c2d4_OnIhM`1m2b4[OnIcMa1U3b4YO\\Ko0_4RO]KS1b4nNYKW1f4iNVKZ1j4gNRK^1m4cNnJa1R5_NjJd1W5]NdJe1]5ZNaJi1`5TN_Jn1c5nM]JV2c5gM\\J\\2d5aM\\Jc2d5ZM[Jk2d5QM\\JT3c5iL\\JZ3d5cL\\Jb3c5[L[Jl3`0_JX4a1XKU4NiJl4n0VK^4HeJU5k0QKS5T5iJlJW5X5fJgJY5^5cJbJ_5_5]JbJe5`5VJaJm5`5nIaJS6a5iI`J^6]5]IdJf6]5UIdJQ7Z5kHfJ\\7a53M7I6J8G9H4L5K2N0O10001O00000OmG", "size": [427, 640]}, "area": 54209.0, "iscrowd": 0, "image_id": 15254, "bbox": [0.0, 0.0, 640.0, 426.0], "category_id": 143, "id": 20000933}, {"segmentation": {"counts": "cU1b0d<6K5K5J7J5J6K5K4K5L4K5L4K5L4L4K5L4K5L4K6K4L4K5L4K5L4K5L4L4K5L4K5L4L4K5L4K5L4O1O1O1O1O1N2O1O1O1O100O10000O1000000O10000O2oN^IWKb6e4dIYK\\6c4kI[KT6a4RJ]Kn5`4XJ]Kh5_4_J^Ka5^4eJ`K[5\\4lJaKT5[4RKcKn4Y4WKfKi4W4[KhKe4T4`KkK`4Q4eKnK[4n3jKQLV4k3oKTLQ4h3ULVLk3g3YLXLg3d3^L[Lb3a3cL^L]3^3gLbLY3Z3kLfLU3V3oLjLQ3S3RMmLn2o2VMQMj2k2ZMUMf2g2^MYMb2c2bM]M^2`2eM`M[2`2eM`M[2_2fMaMZ2^2gMbMY2]2hMcMX2\\2iMdMW2\\2iMdMW2[2jMeMV2Z2kMfMU2Y2lMgMT2Y2lMgMT2X2mMhMS2W2nMiMS2U2nMkMR2U2nMkMR2T2oMlMQ2S2PNmMP2R2QNnMo1R2QNnMo1Q2RNoMn1P2SNPNm1o1TNQNl1o1TNQNl1o1TNQNl1o1TNQNl1o1TNQNl1o1TNQNl1o1TNQNl1o1TNQNl1o1TNQNl1n1UNRNk1n1UNRNk1n1UNRNk1n1UNRNk1n1UNRNk1n1UNRNk1n1UNRNk1n1UNRNk1n1UNRNk1m1VNSNj1m1VNSNj1m1VNSNj1m1VNSNj1m1VNSNj1m1VNSNj1m1VNSNj1m1VNSNj1m1VNSNj1l1WNTNi1l1WNTNi1l1WNTNi1l1WNTNi1l1WNTNj1k1VNUNj1k1VNUNj1k1VNUNj1k1VNUNj1j1WNWNh1i1XNWNh1i1XNWNh1i1XNWNh1i1XNWNh1i1XNWNh1i1XNWNh1i1XNWNh1i1XNWNh1i1XNWNh1i1XNWNh1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNg1h1YNXNh1g1XNYNh1g1XNYNh1g1XNYNh1g1XNYNh1g1XNYNh1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1YNZNg1f1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Nh1e1XN[Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1c1VN]Nj1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nk1d1UN\\Nl1c1TN]Nl1c1TN]Nl1c1TN]Nl1c1TN]Nl1c1TN]Nl1c1TN]Nl1c1TN]Nl1c1TN]Nl1c1TN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN^Nk1b1UN[NVK1e6d1UN[NVK1e6d1UN[NVK1e6d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1d1WN\\Ni1e1VN[Nj1e1VN[Nj1f1UNZNk1f1UNZNk1f1UNZNl1f1SNZNm1f1SNZNm1g1RNYNn1g1SNXNm1i1RNWNn1i1RNWNn1j1QNVNo1j1QNVNo1k1PNUNP2k1PNUNP2k1PNUNP2l1oMTNP2m1PNSNP2n1nMSNR2m1mMTNS2m1lMSNS2n1lMSNT2n1jMSNV2m1jMTNU2m1iMUNU2l1jMVNU2j1kMWNT2j1jMXNU2`2RMcMk2X3[LiLd3c3oK_LP4l3dKVL[4T4QKWLm4U4]JXLa5j5O1O4Ki0XOi0VOj0TOgHaMf4a1SKoNe51^J4[6jNhI_3n62M2XHYMj4i2lJIj29SMd0Q2]OmMl0j1WOSNQ1f1POWNY1b1hN\\N]1`1cN_N_1`1bN]Na1a1aN]Na1b1_N]Nc1b1^N[Ne1d1[N\\Nf1c1[N[Nh1c1XN]Ni1a1YN^Nh1a1XN_Ni1`1XN_Ni1`1WN`Nj1_1VNaNl1\\1\\N]Ne1b1ZN^Nh1b1WN^Nj1c1TN]Nm1f1oMZNR2h1kMXNU2h1kMXNU2h1jMYNV2f1kMZNU2f1kMYNV2f1kMZNU2f1kMZNU2f1kMZNV2d1jM]NV2c1jM]NV2c1jM]NV2b1kM^NU2b1kM]NV2d1iM\\NW2f1fM[NZ2g1dMYN\\2i1bMWN^2k1`MUNa2k1^MUNb2m1[MTNe2m1ZMRNg2o1XMQNh2o1XMQNh2o1XMQNh2o1XMQNh2P2VMQNj2o1VMQNj2o1VMQNj2P2UMoMm2P2SMPNm2P2SMPNm2P2SMPNm2Q2RMoMn2Q2RMoMn2Q2RMoMn2R2QMnMo2Q2RMnMo2R2QMnMo2Q2RMoMn2P2SMPNn2o1RMQNn2n1SMRNm2m1TMSNl2m1TMSNl2m1TMRNm2n1SMRNm2n1SMRNm2n1SMRNm2n1SMRNm2o1RMQNn2o1RMQNo2n1QMRNo2n1QMQNP3o1PMQNP3o1PMQNP3o1PMQNP3P2oLPNQ3P2oLQNP3o1PMQNP3o1PMQNP3o1PMQNQ3n1oLRNQ3n1oLRNQ3n1oLRNP3o1PMRNo2n1QMRNo2m1RMSNn2l1SMTNm2l1SMTNm2l1SMTNm2l1SMTNm2l1SMTNm2l1SMUNl2l1SMTNm2m1RMSNn2n1RMQNn2o1RMQNn2P2QMPNn2R2QMnMo2S2PMnMo2S2PMmMP3T2oLlMQ3U2nLkMR3V2mLjMS3V2mLjMS3W2lLiMT3X2kLhMU3Y2jLhMU3Y2jLgMV3Z2iLfMW3[2hLeMX3[2hLeMW3]2hLcMX3^2gLbMY3_2fLbMY3_2fLaMZ3a2dL_M\\3g2^LYMb3m2XLSMh3S3RLmLn3Y3lKgLT4_3fKaLZ4e3`K\\L_4i3\\KWLd4o3VKQLj4U4PKkKo4[4lJeKT5`4gJ`KY5d4cJ\\K]5i4^JWKb5m4ZJTKe5Q5VJoJj5U5RJkJn5Z5mIfJS6^5iIbJW6c5dI]J\\6g5`IYJ`6l5[IUJd6Y60kKbI]1]6cNiIX1W6gNoIT1Q6lNTJo0l5POZJk0f5UO_Jf0a5YOeJc0Z5]OkJ>U5BPK9P5FVK5j4K[K0e4OaKL_44fKGZ48lKDS48TAG`>>O3M00000O2O00000O01OG^OVBa0k=@TB?l=DRB;n=KmA4R>>H8O100OO100O12N01O01O001cBjNE1V=X1TClNi5J5eAEm=>RBCh=c0UB@g=e0VB]Oe=h0YBZOc=U1K6I6K4nBSNkik01O00001O001O00001O00001O001O00O1N2N2N2N2N2N2N2N2N2N2N2N2N2M3N200000000001O000000001O000000001JXBROh=m0600O1MnAWOS>i03O0001O0001O0O1O10010N1001O1O101N1O1O3M1O01O000000001O0N2N2N2O2N1N200O100010O00001O01O00000002OO01O1O002NO2O0NfA^OZ>a03M300O001O1O1O001O11O0O10O11N10O11O0O2O001O1N012N0O2O001O1N1000000O10O10ON300O010O02OO0100O103L5L4K5L0O100O100O100O100O100O1O100O100O100O100O100O100O100O100OM4HgBfN[=Z16O001O001O01M4L4L4M3L4L4L4M2M4L3M3N2M3M3N1nC^Mf;b2\\D^Ma;d2_D]M_;d2aD]M];d2cD]M];Y2cD]M59X;Z2nDfMS;Y2lDhMT;W2mDiMT;V2lDjMT;V2kDkMU;U2kDkMV;T2jDlMV;S2kDmMU;S2lDlMU;S2kDmMU;S2kDmMV;R2jDnMV;c1ZD_Na0NV;b1^D]NOoA01000WQg0", "size": [480, 640]}, "area": 17533.0, "iscrowd": 0, "image_id": 15278, "bbox": [34.0, 290.0, 557.0, 190.0], "category_id": 170, "id": 20000938}, {"segmentation": {"counts": "n5U2l1dAO0;[>701O0000000001O2N1O1O2M2O1N2O1O05K7^AAU>e010O1O000L3L5L2M2N3N2M2N3M2O2M2N3M3N1N3OO3M3M3M3M3M3M4L3M3M3O1O1O1O100O1O2N1O1O1O100O1O1O1O2N1O100O1O1O1O1O1O101O01O001O01O010O010OdEGR6:lIIS66fIFVL7T1Id7;QKHTL6U1Jd77TK3iLDDOE6g85TK5kLH^O1c81TK9hL9o7_OXK?bL4DRO_8:[Kc0VLSO8R1T8YO^Ki0YLOX8WO_Km0VLMZ8VO`KT2`4lM_KU2`4kM`KU2a4kM^KU2b4kM^KV2a4kM_KS2c4lM_KS2`4nM`KT2^4kMcKV2[4kMfKT2Z4kMgKV2W4kMjKU2U4jMlKW2R4jMnKV2R4iMPLV2o3jMRLV2n3jMRLU2n3kMTLT2l3lMULS2j3mM[Lo1e3QN^Ll1a3TNcLi1]3WNfLP1\\KYOn7GkLa0dKFa7InL4mK1T7KSMGULIgAO0147V>NjA1V>0iA0X>0hA0X>0gA0Z>0eA0\\>0dAO]>1bAO_>81O1O1O100O1O1O1O1N2O2M2OmZU1", "size": [480, 640]}, "area": 5558.0, "iscrowd": 0, "image_id": 15335, "bbox": [395.0, 163.0, 165.0, 253.0], "category_id": 105, "id": 20000940}, {"segmentation": {"counts": "Rc[23V?NG7L3N1100O01M3L3M4L3M2N2N1O2N1O2N1OUOdB4Z=LhB3W=MlB2R=NQC0n<1SCOk<1XCMg<3\\CLb<4`CK_<5dCH\\<8V1001O000O10000000001O000000000000001O000000000000001O0000000000001O000000000000001O000000000001O01O000000000000010O0000000000001O0000000000001O3M3M3N2M3MO1L4L4M3M3M3M3M3M2N2Nff;O^YD000000001O0000001O0000010O00000010O0000010O001O0010O010O1^OOTB0k=3SBNm=3RBLm=9PBGm=OjA?4CQ>d0kA[OT>j0O1N101O0O2ERObBi0`=[O^Bd0d=\\O\\Bb0f=_OXB`0i=AVB>>ZOm0hA0\\>0`A0c>1YAOi>32N000000000001O00000000000O10000000000000001O0001O1MVANj>0VA0fU_1", "size": [480, 640]}, "area": 4010.0, "iscrowd": 0, "image_id": 15335, "bbox": [161.0, 106.0, 379.0, 94.0], "category_id": 123, "id": 20000941}, {"segmentation": {"counts": "^o71m>3M5dAJg=:UBJg=:VBLd=6WB6OZO]=j1D7oBmMi<_2F7IC9F9G4M3L4M3N2O2M[k11fTN001O1N3K4N2N2N0]OBUB1;?_=G^B9c=H\\B8d=I[B6e=KZB6f=JZB5_=B\\B=42_=3aBL^=6bBJ]=8bBG]=;bBF]=bBB^=?aB@b=n04K3N1N7J00000000000000O1O1O1O100O1O10nNTBP1l=POUBo0n=0O11O001OO100O11OO1O10001N100NVOWBG1g0i=^O]Bb0b=]ObB`0^=@dBLE>f=GiB9W=FiBP=BPC>P=B_B36;[=B]B669]=0_B2`=g0000mNeBa0[=_OfBa0Y=_OgBb0X=^OhBc0X=\\OiBd0V=[OkBf0T=XOoBh0P=XOQCh0n5SBNQ>1oAOR>5hAKZ>6bAL_>:0O2N2N2N2O2N100001N014[AFZ>;HEUB>h=DUB=g=KUB4l=MPB6o=>0O101O0O101O0O100O2O2N000000O1000000001O2N3MO1001O2N00001O00O10000O100O100O1O2O1N1O2N2O1O1N2O0O2OLTBUOk=k0WBTOh=l0YBTOe=m0]DTO`9l0^FWOa9i0[EVOJ6j:d0\\EXOSOi0a;N]EZOoNk0c;K^E?a:A`E9e:E]E3k:LVEMQ;MjC^OW1b0R;MjC@U1a0S;KdCDa1`0m:HXE6j:IVE7l:HTE6n:JSE4o:LQE2Q;NnD2R;NoD0S;0lDOV;1iDOX;1gDJ\\N2o<4gDKZ;3gDL\\;1_Qg0O\\PYO3^O`00000001OZBCh<=SCGo<:hBKY=n0HeNlBZ1S=iNkBV1U=jNmBU1R=kNQCT1lPSXa=001O002N0010N1NgN^OYD`0g;BYD;i;GVD7j;JWD5i;KXD3h;MZD1g;OZDOf;1\\DMe;3XDOh;1UD4j;LZD0e;1^DLb;3bDK];5g10O010O10O01001OO1O5K10O100001O4NM100000001O000000000010O01O001O10O01O00010O1O0010O01O1O2O0O00100O1O2O0O010O01O00001N1fBN`;9]DJb;6\\DMb;5[DMe;5VDOi;2TD1k;0RD2n;0nC3QY=ChBk=01O01O000O2O00001O001O1O001O1O0O2N2H8A?K4B?M4I6^Oc0VOWMoDI3Q3m:WMnDJOMOV3S;e0N201OJ5F;D01000O0100O01000O010000O001L4L4K5L3K6J6BTObBR1]=90O0100O10000O010O100O100O10000O100O100O10000O10000O100000000O1000000O100000001N101O1O001O1O001O002N1N3N1O2N5K0000000000001`CaM]<_2cCdMZFZAJg>4[]e5", "size": [480, 640]}, "area": 14525.0, "iscrowd": 0, "image_id": 15335, "bbox": [23.0, 370.0, 229.0, 110.0], "category_id": 137, "id": 20000943}, {"segmentation": {"counts": "djR71m>3O1O002N1O001O001N2O00011M110N101O001O1O3M1O001OO04NO00O3N1O1O1O3M003M1O4L2O2M1O000O10000000000000000000000000000000000001O00O11O002N1O1O002N1O1O1O2N2N1O1O1O1O1O1O1O1O2N002N2N1O2N001O1O1O00002N001O2N001O001O2N1O002N1OQbe0", "size": [480, 640]}, "area": 3040.0, "iscrowd": 0, "image_id": 15335, "bbox": [483.0, 432.0, 110.0, 48.0], "category_id": 139, "id": 20000944}, {"segmentation": {"counts": "aQ_32n>1O7KO000001O1O1O00100O1O1^AB_>g0gAYOj=g0TB[Ol=l01O2N1O1ZOZB0[>00000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000OQ`f0LWQYOOk>4UALh>600000000000000O100001O2N00O100N2N2O1O100O100O10000O100O1N2N2M3N2N2M3N2N2M3L4H8H8I7L4M3M3L4M3N2O1M3N2N2N2NWMPDf2o;YMTDf2T`^`D@a;`0aD]Oa;a0a1N001N10001O00001O00001O00001O001O00001O00010O0O110O02N100O002O0O1O101N2O0O1O100O1O100O1O2OO02N2N1N3N001N2O1O0O102N0O2O2N0O2O001N3N1O0O3N1O1N10000O10000OVOk0_Oa0N1O2N2O1O1O1O1O10000O1000000000000O100000000000jT6", "size": [480, 640]}, "area": 8162.0, "iscrowd": 0, "image_id": 15335, "bbox": [236.0, 384.0, 390.0, 96.0], "category_id": 165, "id": 20000945}, {"segmentation": {"counts": "0e4[:1OM3O1N2O100001O0000000000000000nKaEc3_:[LdEd3\\:ZLiE4Jn2]:mLmE1Jo2Y:oLQFOLl2S:UMSFJ6OZOe2]:bM]GS2c8lMdGJmMR2_:TNPHb1P8^NWH[1i7eNcHo0]7QOgHKkLl0^:ZOlHd0T7]OSI;m6FYI3g6OZIOe61jELQ32U75dEMU3OW7g0eEPOi2<`7k0dESO^24l7`1oG]No7m1mGPNP8Z2kGcMS8c2mGYMQ8l2o100000000001O00N2O1N2^OmCUNUPCBP=>oBCQ==oBCQ==oBCQ==oBCQ==oBRO36n00001O00001O0000001O2N000000O1000000001O2N3MO1001O2N00001O00O10000O100O100O1O100O1O1O10000O100O10WCiNi;W1WDkNg;U1YDlNf;S1[DoNc;Q1]DoNDOV;R1VEPOB0W;P1WESO^ON[;o0VEWO[OK_;n0VEZOVOJd;l0VEKi:5UEMk:3TENl:2nDiN^OW1d;0kDlN@U1e;OgDhNDa1e;HcD=];CbD=_;D`D<`;D`D=_;DaD<^;EbD:^;FbD;];FcD9];HcD7];JcD5J\\Na;`1eD6Z;KdD6\\;LaD5_;f10O1AcD[M];]2oD^MR;`2h0M3L4K5K5L4O1O1O1O1O1O1O1O1O1N2N2N2N2O1001O00000000000000000000000000001O1O1O1O1O1O1O1O1O1O1O001O1O1O2N1O2N00HTC]NkL4B>N2K5_Oa0XOeBAI3b=bBB^=?^BEa=;`BD`=n0000001O0000001O00001O00001OO1O1N2O1N2N2M3M3O100O10000O100O100001OAkAIM:f>IelV1", "size": [480, 640]}, "area": 34477.0, "iscrowd": 0, "image_id": 15335, "bbox": [0.0, 0.0, 557.0, 158.0], "category_id": 172, "id": 20000946}, {"segmentation": {"counts": "e>;k:j2XEhM`4_8aKaG^4`8aKaG]4`8cKaG\\4_8eKaG[4_8dKbG\\4]8dKdG]4Z8dKfG\\4Z8cKgG]4X8cKiG]4W8cKiG]4V8cKkG]4T8cKmG]4S8cKmG]4R8cKoG]4P8cKQH]4o7cKQH]4n7cKSH]4m7bKTH^4k7cKUH]4j7cKWH]4i7cKWH]4h7dKXH\\4h7cKYH]4f7dKZH\\4f7dKZH\\4f7cK[H]4d7dK\\H\\4d7cK]H]4c7cK]H]4b7dK^H]4a7bK`H^4`7bK`H_4H_K`62hIa4D^Kd62hIb4A\\Kh61hIl3lN_La0Eh63kIe3VO_L3Jh67oI]3^O_LHMh6;RJU3H`LZO0h6`0VJl21aLmN5g6b0\\Je2`0iLP5g0`J\\2c0mL\\4LkIQ1V1S2[7YNeHe1\\7\\NdHc1]7\\NdHb1]7_NcH`1^7`NbH^1`7bN`H]1`7dN`HZ1b7fN^HX1c7hN^HW1c7iN]HU1d7lN\\HS1e7mN[HR1f7nNZHQ1f7POZHP1f7POZHo0f7ROZHm0g7SOYHm0f7TOZHk0g7UOYHk0g7UOYHj0g7WOYHi0g7WOYHh0g7YOYHg0g7YOYHf0h7ZOXHf0g7[OYHd0h7\\OXHd0h7\\OXHc0i7]OWHc0h7^OXHa0i7_OWHa0i7_OWH`0j7@VH`0i7AWH>j7BVH>j7BVH>j7BVH>j7BVH>i7CWH=i7CWH=i7DVHT8CiG?W8AhG`0X8BeG?[8BcG?]8C`G>`8C]G?c8CZG>f8n20000000000000001O000O101O0000001O0000001O01O0010O01O0010O01O0010O100O100O1000000000000000000000001O2M4M2M4M2M4M2M4M2M4LiNnGcKP8[4RIhJj6V5]IiJ`6U5cIlJZ6S5hIPKU6m4oIUKm5j4XJUKf5i4_JWK]5g4hJZKU5d4lJ_KQ5`4PKdKl4Z4VKjKg4T4ZKnKd4Q4]KPLc4m3_KULj2SO]Lg4j0WL^4g3cK[L[4e3eK\\L[4b3fK`LX4`3hKaLX4^3hKgKPN3V6U4kKhKQN2S6V4lKhKTN1o5V4mKiKWNOk5W4oKkKWNNi5V4PLlKZNMd5W4RLlK]NK`5X4TLmK^NJ]5Y4ULmKaNGZ5[4VLnKP5R4PKnKP5R4PKoKo4Q4QKoKo4Q4QKoKo4Q4QKoKo4Q4QKoKo4Q4QKoKo4Q4QKoKP5P4PKPLP5P4PKQLo4o3QKQL_4D\\I[4U2QL`4DZI[4V2QLa4EWIZ4X2QLb4FTIY4Z2QLc4FRIY4[2QLd4GoHX4]2QLe4HlHW4_2RLe4GkHW4`2RLf4HhHV4b2RLY1CA4cLW4c2RLU1FG]4TOmKR1HLZ4ROnKc06=k3POoK>:d0f3nNPLa06c0i3lNRLb02d0k3jNSLe0Md0o3gNTLh0Id0Q4dNVLj0Fd0T4aNVLn0Bc0X4^NVLU5i3kJWLV5i3hJYLX5g3gJYLZ5g3eJYL]5f3bJZL_5f3`JZLa5e3_J[Lb5e3]J[Ld5e3[J[Lf5e3YJ\\Lg5d3QJkKUNa0k7d3aHmKg01lN>n7b3^HWL`0KSO1BC2f5c2^KlMXO^OB4g5`2bKQNTO[O@5j5[2fKYNnNVO@6m5V2jKaNhNSO]O8Q6o1oKiNbNPO[O9T6j1SLkNcNPOTO;W6i1SLhNhNTOkN]Nn0o1fND<\\NP1m1fNG:\\NR1i1fNK8\\NS1f1gNN6\\NT1c1hN15[NU1`1hN53[NV1^1hN81ZNX1[1iN;OYNZ1Y1iN>MYNZ1W1jNa0LXNZ1U1lNc0JXN[1R1mNg0GWN\\1P1oNi0EWN\\1n0QOk0CVN^1l0QOn0AVN^1j0SOQ1^OUN]1j0VOR1]OTNY1l0\\OP1[OTNT1n0Co0YOSNo0Q1Jm0VORNk0S12k0SOQNh0V16j0ROPNc0Y1=g0POPN>[1d0g0mNnM:^1k0d0kNnM6_1R1c0iNmM0c1X1b0gNjMMf1_1`0dNjMHi1e1>cNiMDk1k1=`NhM@m1S2;]NhM[OP2Y2:[NfM[Om1^2=WNfMZOj1b2b0SNcM[Oh1f2e0oMcMZOe1j2i0lMbMYOb1l2P1jM^MYO_1o2U1WL]MMOl0\\1R3[1QL^M0Kl0Y1T3a1nK^M1Il0T1W3h1iK]M4Gk0Q1Z3o1cK\\M7Dk0P1Z3T2`K\\M:@k0o0[3X2]K[M=^Oj0n0\\3]2YKZM`0[Oj0m0X3f2QK^Mm0oNi0m0R3^4VLdJg0m0m2g4\\L\\Jf0l0k2n4^LVJg0j0i2T5`LRJf0i0i2X5aLoIe0h0i2]5aLkIe0g0h2b5cLgId0g0g2e5eLdIc0f0g2j5eLaIb0d0i2m5eL_Ia0c0i2Q6fL\\I`0b0j2T6fLZI?a0k2W6fLXI??k2[6fLVI>?k2]6gLTI=>l2`6gLRI<=m2c6gLPI;n:ASE?m:@TE`0l:_OUEa0k:^OVEb0j:]OWEc0i:]OWEc0i:]OWEc0i:\\OXEd0h:\\OXEe0g:[OYEe0g:[OYEe0g:[OYEd0h:\\OXEc0i:]OWEc0i:\\OXEc0i:]OWEd0h:\\OXEf0f:ZOZEf0f:ZOZEe0g:[OYEe0g:[OYEd0h:\\OXEd0h:\\OXEc0i:]OWEc0h:_OWE`0j:@VE`0j:@VE?k:AUE?k:AUE>l:BTE>k:CUE`HNGDX10`6?hGC>:1FX1Mb6b0eGC0G0919:^OH:c1Gh6^1bGWO6[OL:d1F_6`2kG`M21N:a1F`NNT8a2lGaMO>g1@^6f2kGkMf1_O_6X3bIhL]6Y3i100O10O100000000O2O0WGRMX7o2RHfMn7_2PH^MQ8l35K5G9OL02MO110O2O000001O0O11NPLVGE0n37SLh8a1QG^N01:i1MWNR83XH\\1Nh0b7QN`HW1N?DUNk78RHD`0_1O=IVNf74QOl6;SIL7=jNXOW12h6=PICRONa135NY6a0aL_O_3g0[LXOe3l0XLTOh3l0Y41O2O000O2O0O1O1HmNZDT1i2mNl5Y1mHgN[N1l02SOM0O_8[1WIhNYNO0Nk05UOOa8U1VIgNZN6OJ24NM0i0b8?PIjN^NM0`1a8JQI=o6BSI=m6CSI=m6CSI=l6CUI=k6DTI]2W3bMjL^2U3dMiL]2W3j3O100000000O100002NM300000dG^LR7a3kH^LnN1a18h4Y3hJ_LmN5^1:h4U3iJdL`07g4[3`JbL@CM1l0a0V5^3[J_LDH;1FN_Og3a8YL_G0k0f3h7ZLXHf3e80N200O10000000000000000000YLcFc3b9O1O00000000000000O11OO10000O1O1O1O100000000001O00000000000000O11OEYLSGi3j8ZLQGONh3P9<000000LkKUGU4j8mKUGS4k85LfKZGZ4f8gKYGY4c8fK^G1OY4d870000001OO1O100O10000_OiKoGY4Q8gKoGY4Q8gKoGY4Q8gKoGY4Q8?0000005KK500000000001O000000000000000000O11O1O000000O100001OO100", "size": [424, 640]}, "area": 96795.0, "iscrowd": 0, "image_id": 15338, "bbox": [0.0, 238.0, 640.0, 186.0], "category_id": 140, "id": 20000951}, {"segmentation": {"counts": "_8a0g<00O1000000000000000000000O10000N@\\C`0d<@\\C`0d<1100_O[C?e\\EBd:?[EAe:`0ZE@f:`0ZE@f:a0YE_Og:o1BO100000000O11O2NO1O100000XEcMe:`200eEaMm9f2iE`MT:a2lE_MS:m2N001O00O10000000000000000", "size": [424, 640]}, "area": 15919.0, "iscrowd": 0, "image_id": 15338, "bbox": [29.0, 0.0, 611.0, 102.0], "category_id": 157, "id": 20000953}, {"segmentation": {"counts": "foj0110h[OW8h0QG7=jNXO>[9a0gFRONa13\\O[9j26I4M000017H9G3NO0H8C=O1DUFZMk9_1UF[N1l02SOM0l9f1VFYNO0Nk05UOk9g1PFZN6OJ24NM0f:b1\\E^NM0];b162O000O11O001N2O01OO2OO2O`N\\D30K0c05]ON4c;M\\DO4b00^Oi;0_D?HA[<<:N2L3O2N1O_Pm0O_bROO30L15O]<5^CN1N3O10T<N_Og39[LW5U2kJiME0k0f3^OZLZ5i1WKWN1f3^OZL\\5Z1_L\\2m3VM^Ll2c3fLjLZ3a610000000000000000000YLcFc3b9O13L00001O1O1O000O110N2OO10O1O3MO12O0000O12N01O01O00001O1O1O0O200DiKcGZ4Y8iKbGONZ4^8=O2N2N3IQKoGT5k7nJTHS5k75LfJZH[5e7fJZH[5k0eJg5O_I1O[5d0cJ]O1O2c6a5PJ]J]O6c6]5jI\\JD=b6V5kI]JB=d6V5jIlJW6S5jIlJU6T5lIlJS6U5mIlJR6T5nIlJQ6T5PJlJP6T5PJlJP6T5PJlJ_5NPJW5b0kJ^5NPJX5a0jJ_5NPJY5`0iJ`5NPJY5`0iJ`5g5_JYJa5U7BO105KK5000O11O2NO2N100000]J^H`5e700jJ\\Hh4k7nJ[Ho4f7QKZHn4R8N0O20O1N100000O100001OO10kL", "size": [424, 640]}, "area": 39402.0, "iscrowd": 0, "image_id": 15338, "bbox": [65.0, 0.0, 575.0, 308.0], "category_id": 169, "id": 20000954}, {"segmentation": {"counts": "0k5]700001O00000000000000001O000000000000XLoHY1Q7fNPIZ1P7fNQIY1o6gNQIZ1n6eNTIZ1l6fNTIZ1l6fNTIZ1l6eNVI2FnNT7P1VImN1EE>T7o0XImNOFE?S7;QIkN:c0NGDa0R7PO[J5ROJC>:1Fc0e8TOjGHC0G0919:^OH:Q1_8TOfHHWO6[OL:V1l:hNjD21N:a1a:`NUEO>c1a:]N`Eb1R;1000O010000000000001M2B?ZOj0NXTd7", "size": [424, 640]}, "area": 6428.0, "iscrowd": 0, "image_id": 15338, "bbox": [0.0, 0.0, 50.0, 211.0], "category_id": 172, "id": 20000955}, {"segmentation": {"counts": "k5;m<`0@01O00000000000000001O0000000000000000001O000001O0001O2N2N3M4FX`>Mn_A4M2N2N2N2M3N2N2O100O1000000O100004K9H9G]=1TB=D=O1O100O1O1000000000O1000000000000000000O100000000000000000001N100000000000000000000O1000000000024K5J5K6J1O00O100O2O00000000000000000000000000000000000000001O01O000FUC7kC=C=C=C=O10000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000001O1O1O1N3N1N2O2M2O1O1N3N1N2C=B?A>B>A[lZ1", "size": [424, 640]}, "area": 15438.0, "iscrowd": 0, "image_id": 15338, "bbox": [0.0, 172.0, 536.0, 100.0], "category_id": 183, "id": 20000956}, {"segmentation": {"counts": "0m6S=00000000000000000000000000O1L400N200O100O10000000000O10000000000CmBlIT=S6=LVBQJk=n54001O00O100000000O100001OLRBVJn=g57GkAfJV>X5mAeJU>[5kAcJW>]5hAdJX>\\5iAcJW>]56O100000000001OO11O3M1O1O0000001O000000O10000O1N2001O001O1O001O001O001O000000O100O1O100O1003M2NO1000gA[JW>h5O00001O4mAXJ1N]=[6000A?00cNUBeLk=Z3fBVLZ=i3VChKjX4iAmKW>n4000000000000000002N0000001O0000001O0000001O000000001O0000001O00U1kNa0_OO1N2O1O1N200O1O1O1O1001O0000000000000000N2N2J6NQCSIoc=o4dBaJK?a=n4kBdJB:c=R5TCfJnR56O1N200O10000O11O1OO10000O11SARKf>n4YATKf>n4XARKh>V5M1O3M0000001O0000O1000000O10nAiJBKe=\\5fBlJDMb=X5fBoJGJb=Y5_B[Ka=b50000000000000000000000000001O?AO100001O2N000000001O0000000000O1O1000000000000001O1O000000000000", "size": [640, 404]}, "area": 68724.0, "iscrowd": 0, "image_id": 15440, "bbox": [0.0, 0.0, 404.0, 244.0], "category_id": 96, "id": 20000957}, {"segmentation": {"counts": "VdY52mc03GL^\\O8bc0310N2N1O101O0N4N0f\\O]OWc0h0i\\OAhb0l00000LlN\\]OT1`b09N10O10OLb]OgN`b0X1TOQOn^OP1o`0TOP_Om0Ra0POm^OP1Ra0ROn^Oo0o`0TOP_Om0o`0SOQ_On0n`0SOQ_Om0o`0SOo^OP1T`0dNb_OJ>b0JT1T`0aNb_OK?`0OQ1m?kNf_OB:a06P1j?VOh_OL>m0k?XOd_OMa0k0j?0W@0g?1Z@Ng?1Y@Og?2X@Mi?3W@Mj?2T@0h?4V@Oi?2R@2o?MQ@2P`0NP@2P`0Nn_O4R`0n1X@[LS?e3c@eLV?Hd@X4\\?6O2M200O10000O11O1OO101ON1N4`Ke@W4]?hKe@T4`?jK`@T4j?M1O3M00000O20O000O1000000O2OaLV@BKS3n?XMZ@DMP3j?XM]@GJP3k?QMi@o2T`000000000000000000000O1001O011=AO100001O2M100000001O0000000000O3M1000000000000001O1O000000000000PI", "size": [640, 404]}, "area": 11975.0, "iscrowd": 0, "image_id": 15440, "bbox": [271.0, 159.0, 133.0, 153.0], "category_id": 97, "id": 20000958}, {"segmentation": {"counts": "VXa11kc00V\\O2010M01nb00R]O42LN60N0L40M0OO00^b0g0b]OE0Noa0f1O0000001OO1O020OO10000O11O00011N00O02OO11ON21O0000O01000O11O001O00O11O000O10O2O001O0000O100O02O0O13MO11ON120O10O000O1O201M4M2N2N1O001O00N22N1O0000000000000_Nc]O_1_b0000001O000000000000O11O0000000001O001N100000001O00O101OOaNc]O]1`b00O1O2N1O03M01O11O00O12ON010O1003MO12M11O1OO10000O012ON3NM31OO12N0000O10000000O1M32NO13M000000000O11O01N010001OO10000O11O1OO100N21O1O000000O1O12M02O01OO11OO1001N1O1O1O11OO010N3O02N1OO1O20M21O02NO11O3M0O11NO^]OfNcb0Y121OO1000O2N2OO12NO01L400O0024\\Nb]O\\1ab00000O11ON21O001OO12N00O1N^]OfNbb0Z12000000001O1O00O1O100001OO100000O1001O00O1K52NN24L2NO1N2001O2N000000000000000000000001O00O100002N1O1NOa]OcN_b0]13O0O11O000N1O22O0N00101O1O0000]]OfN`b0Z1`]OfN`b0]10002N1O00002NO1O10000O11\\@", "size": [640, 404]}, "area": 16199.0, "iscrowd": 0, "image_id": 15440, "bbox": [78.0, 478.0, 326.0, 72.0], "category_id": 124, "id": 20000959}, {"segmentation": {"counts": "fSX22oc010OT\\O1fc051N100O00000O10000O1000jBN^62aHN^J0g00WO0P=2bH0`JOf0OWO10Oo<2cH7WKOSoJL^0jB0dM070Vc00c\\O070Vc00c\\O0hc00cho3", "size": [640, 404]}, "area": 13504.0, "iscrowd": 0, "image_id": 15440, "bbox": [115.0, 213.0, 84.0, 284.0], "category_id": 132, "id": 20000960}, {"segmentation": {"counts": "[i^11kc05K5N2O1N2O1O100O1O1O01OO1O11O00000O100O1O1O2N11O1N101O00000000001N1000000000O10000O1000O10O2O0010OO10O100O11O0000000000O11O1O0000O2N11OO1000O10000001OO11O1O000000O10000000000000000000000O10000000000000001O001O000000001N10O100000000010O00O2N0100000000O20N1000O1O1000O20N20N01000O1001O2NM31OO03N0000O102N0000O1000000O100001O000O11O02M100001OO10000O11O1OO100N2100O0O1O10O0003NO1001OO02OO1001O0000000000O10O20O00O10001ON210O00000000O011OND`\\O<`c021OO1000O2O10N12M02OO1000O11M22N000O11NO30O001N012N01N1NE_\\O:bc03O00O11O10M30O0O1O100001OO1000000000O10000000000O1001OO11O0000O100000000O12NO10000O101O00O0100020OO1ONI[\\O7ec020O020O000O01010OO1O0100000000G\\\\O4fc0LZ\\O5hc0O102O0N1NT\\O0hR5", "size": [640, 404]}, "area": 4824.0, "iscrowd": 0, "image_id": 15440, "bbox": [74.0, 542.0, 322.0, 24.0], "category_id": 140, "id": 20000961}, {"segmentation": {"counts": "m6S=m60000000000000000000000000O1L400N200O100O10000000000O10000000000CmBlIT=S6=LVBQJk=n54001O00O100000000O100001OLRBVJn=g57GkAfJV>X5mAeJU>[5kAcJW>]5hAdJX>\\5iAcJW>]56O100000000001OO11O3M1O1O0000001O000[M]JmFc5o8bJPG]5m8hJRGX5m8jJRGV5R8^JXF=e1T5P8_JaE2010M01?>o1P5a7bJQF42LN60N0L40M0OO000`0]2o4a7XKRFE0`0\\2d4S7RMlHn2T7SMkHn2T7SMkHn2T7RMlHn2T7RMlHo2S7QMmHo2S7QMmHP3Q7QMoHo2R7PMnHQ3P7PMPIP3P7oLQIQ3o6oLQIQ3n6oLSIP3o6nLRIR3n6mLSIR3n6mLSIR3P7mLoHS3Q7nLnHQ3R7PMnHP3S7PMlHS3P7nLPIT3o6kLQIT3n6nLRIR3o6mLQIS3eM[JX9b2SIV3l6kLSIU3l6lLTIT3l6lLTIU3k6kLUIY3hMXJ1N\\8b2kIi3V6VLjIj3V6ULkIP5Q5oJoJU5m4kJSKW5j4iJWKX5fMXHm6_2]K`5b4`J^K`5b4`J^Ka5a4^J`Kb5_4_JaKa5_4_JaKa5_4`J`K_5a4`J`K`5`4`J`K`5`4`J`K_5a4aJ_K_5a4aJ_K_5Y4PH_Ib2X2^5X3PH^J0g00WO01b2[2^5V3RH`JOf0OWO10c2]2\\5U3YHWK`2d1W5U3ZHUK`2f1V5T3\\HRKE]Oi2]2V5S3]HSK`2j1S5S3`HoJ^2n1R5S3_HnJa2o1P5S3oKmLQ4d2PHoJ\\4]2d3b1PHQL101=NE1Ob4[2]3?RHZMNb0`0ZO`4[2P3AYHaN0BG081KOM020e5\\2Y2_OEa07lMXHHMc0_8i1JeMgG?`8m1MnM8R2HgM?Y2AcMc0]2a8OO11O1O000000O10000000000000000000000O1000000000000000000000000000000O100mLbMcA0?7BMo1Z2_;cNPCVOBLo1[2k6bMkJb0_La01ROL:m1o1a6nMZJGYM=M44`00RON8OBl1^2b6PN]I6XNBOP11L1TOMW`0Di_O;V`0Gi_O9W`0Hi_O7V`0Kj_O4U`0Oj_OOV`03j_OLU`06k_OIT`09l_OFS`0V3i@`MV?f30O100O1O1O2N1^NX@jNi?f21O1O1O2N1O1VNP@CP`0;P@FQ`08o_OIR`05n_OLS`02m_OOU`0Nk_O3V`0k11O1lMh_O>Y`0@g_Oa0Z`0]Of_Od0\\`0YOd_Oh0]`0VOc_Ok0^`0SOb_On0_`0POa_OQ1``0lNa_OU1``0fNc_O[1_`0^Nd_Od1]`0VNh_Oj1Y`0PNl_OP2U`0jMo_OW2m`000000000000000000002N0000001O0001O01O0000001O0000000O2J5L40001O00Rbh2", "size": [640, 404]}, "area": 15074.0, "iscrowd": 0, "image_id": 15440, "bbox": [114.0, 116.0, 148.0, 145.0], "category_id": 183, "id": 20000964}, {"segmentation": {"counts": "01o>000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000`BY2g9V5ZL7I", "size": [480, 640]}, "area": 2689.0, "iscrowd": 0, "image_id": 15497, "bbox": [0.0, 0.0, 640.0, 252.0], "category_id": 123, "id": 20000965}, {"segmentation": {"counts": "l\\X421Ok>30000000000000000O100000000O100O1O100O100000000O100O100O100O1O100O100M300O100O100O100O10000O100O100O100CYO`Bh0a=XO^Bh0b=XO^Bh0c=XO[Bi0e=XOZBh0e=ZOZBf0f=[OXBf0g=\\OXBd0h=:O10000O100O100O10000O100O100O10000O100O10000O1001O1O1O001O1O001O1O001O1O001O001O001O001O001O001OoKUOnIj0P6]OkIc0T6DgI;X6LbI4]62_IM`6:ZIFd6b0WI]Oh6i0SIWOl6P1oHoNP7W1kHiNT7^1gHaNW7g1cHYN\\7m1`HRN_7U2\\HjMc7]2UHeMj7a2oGaMo7g2iG[MV8i2eGYMZ8k2aGWM^8l2^GVMa8m2[GUMc8o2YGSMf8Q3UGQMj8R3RGPMm8b4O1N2M3M3M3M3L4M3M3O13M3M2N3M3M3M3M3M3M3M2N3M3M3M3M3M3M3M3M2N3M3M3M3M3M3M3M2N3M3M3M3M3M3M3M2N3M3M3M3M3M3M3M2N3M3M3M3M3M3M3M2N3M2N3M2N3M2N3M3M2N3M2N3M2N3M2N3M3M2N3M2N3M2N3M3M2N3M0000000000000000000000Qme1", "size": [480, 640]}, "area": 16078.0, "iscrowd": 0, "image_id": 15497, "bbox": [290.0, 263.0, 234.0, 217.0], "category_id": 167, "id": 20000966}, {"segmentation": {"counts": "1a2^:^OdEo<0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000000000000000001O00000000000000oBOS;1lDOU;1jDOW;1l10000000000000000000000000000000000000000000000000000000000000000000000000dL3eGMg;000RL1kHOo65SIKm63UIMj63WIMh63YIMf62\\INd61]IOb61_IO`62`IN_62bIN^61cIO\\62dIN[62fINY62hINX61iIOV62kGNB0b82oGN]O0c83RHMYO0e82THNVO0e83WHMRO0h81XHOoN0i81ZHNlN1j81[HNjN1k81oIOQ60PJ0P60PJ0P60PJ0P60PJ0h4OQH1W30h4OaL1^30bL0^30bL0]31cLO]31cLO\\31eLO[31eLOZ31gLOX31iLOW31iLOV31kLOU31kLOT31mLOS30nL0Q31oLOQ30PM0o20dHOl21`40dHOl21`4OeH0k21i90`B0V8O]L1]K0`=0`B0`=0`B0`=0`B1_=OaB1_=OaB1_=OaB1_=OaB1^=0bB0^=0bB0^=0bB0^=0bB0^=0bB0^=0bB0]=1cBO]=1bB0^=0bB0^=0bB0]=0dB0\\=0dB0\\=0dB0[=1eBO[=1eBOo7MfL4[KOo7MjI0;6kMMo7NlIO9:hMIR8OnIO6S70aHM[3BSN1SO=o6c0PLoNjM1[O:l6c0SLSObM0C7i6c0WLWOYMNK5e6d0[L[OPMK53a6d0_L_OfLJ<2`6c0aLCgMJh5a0fLIlKHQ1N^6>jL6iL\\O^6;oL4dLA]69TM2_LF^65YMO[LL]62]MNWL0]62nNNT10lN0U10jN0X1NhN2S80jAM_=3aBM_=3aBM_=3aBM_=3aBM^=4bBL^=4aBM_=3aBM_=3aBN^=2bBN^=2bBN^=2cBM]=3cBM]=3cBM]=3cBM]=3cBM\\=4dBM[=3eBM[=3fBLZ=4fBLZ=4fBLZ=4fBLZOOn=5hBLZOOn=5hBOW=1iBOW=1jBNV=2jBOT=2lBNT=2lBOS=1mBOS=1mBOS=1mB0R=0oBOQ=1oB0P=0PC0P=0PC1oGT4`3oL_MdNZO6G[4]3lL_MfN]O0Hb4Y3iL^MjNAGHk4V3dL^MnNDAHQ5S3aL^MPOHZOGZ5P3]L]MTOKSOH`5m2YL]MXOOkNHg5j2WL[M\\O2cNIo5g2SL[M_O5\\NIV6d2oK[ME6SNL]6`2WNdMYKKe6_2TNdMTKNl6[2RNmMR2P2PNlMU2Q2lMmMW2Q2kMlMY2Q2hMlM\\2R2\\5M2N3M2N3M3M2N3M2N3M2N3M2N3M3M2N3M2N3M2N3M3M2N3M000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000]AS5S9T4YLg3YLlB", "size": [480, 640]}, "area": 284100.0, "iscrowd": 0, "image_id": 15497, "bbox": [0.0, 1.0, 640.0, 479.0], "category_id": 183, "id": 20000967}, {"segmentation": {"counts": "S5_1a=00000000O100001O0000O11OYOdBJ\\=1bB_O2?]=0iB1W=NkB1Z=JfB6[=@^B18?Z=@nB>k=CaA9c>0000L]AJe>35000O10001N1O0L5J6M3OO20O010001OO1O12M101O00010L3O10008HZQ7NfnH2N200N2M4M2N1100002NN20000O11O0000O101OiACm=8lAKS>5lALT>3mAKU>5jALV>5iAKW>6iAIW>8hAIW>`01O0001O0001N100000\\C^Ok:b0kC^Oc06b;jd9A]F?c9A]F?c9A]F?c9A\\F`0d9_O^FPOcN^1o:B`F>`9AbETO5_1Y:]O_EYO5\\1[:\\O^E^O1V1b:\\O]EAMT1f:ZO]EEIS1j:XO]EGGQ1l:XO]Ec1c:]N\\Ee1c:ZN^Eg1a:YN_Eh1`:XN_Ei1a:VN`Ek1_:UN_Em1a:RN`En1`:RN_EP2`:QN^EP2b:QN]EP2b:QNZER2f:nMZES2e:nMYET2f:lMZET2f:mMYES2g:mMYES2g:S101O00O11O1O1O000000cL^E\\2b:dM_EZ2b:fM^EZ2b:bMcE]2]:_MgE`2Z:_MgEb2X:^MhEa2Y:\\MiEe2W:ZMjEf2V:ZMkEd2V:ZMmEe2S:XMQFg2o9XMRFh2n9XMQFi2o9VMRFj2n9VMRFi2o9XMnEh2T:XMlEg2U:YMkEg2U:YMjEh2V:XMiEi2W:WMeEm2[:SMeEk2]:UMdEj2\\:VMeEh2\\:YMcEg2]:ZMcEe2]:\\McEc2]:]McEc2]:^MbEa2_:_MbE`2^:aMdE\\2\\:eMdEZ2\\:gMdEY2[:hMdEX2\\:iMeEU2[:kMfET2Z:lMgES2Y:mMgES2Y:mMhEQ2Y:oMgEQ2Y:oMiEo1W:QNlEk1U:TNmEk1S:TNnEl1R:UNmEk1S:PNPEFn0Y2R:oMSEEo0Z2n9mM[FS2e9lM\\FU2c9lM]FR2d9mM^FR2b9mM`FQ2a9mMaFS2`9lMaFS2V;1O0O2O01O10002NO000022MO010L30001O00010O1O2N1O000001O001ON200O100O100000100O000O2M21O]O^MlD_2R;bMoD]2^:bM]E16\\2]:eMlDO3O32N1:Z2c:kMQE3NF13=X2b:mMQE==f1T:gM^EM7T17V1S:lMfEn0;R1m9RNgEm0o0l9UNdEl0?P1m9_OSFa0m9_OSFb0l9]OUFc0k9\\OVFd0j9_OQFd0n9[OSFe0m9VOeE`N?Z2l9VOXFj0h9WOWFi0i9VOXFj0h9TOZFl0f9TOZFl0f9TOZFk0g9UOXFl0h9TOXFl0h9TOXFl0h9VOUFk0k9WOSFi0m9XORFh0n9YOdE[N91HV2\\:CPF;Q:FnE:R:GnE7U:HkE6W:JhE5Z:JgE5Y:KhE4Y:KgE5Z:JeE7]:GfE7Y:JfE7Y:IgE8Y:HgE7Z:HfE8[:GeE9\\:GcE9]:HbE8`:F`E;_:F_Eb:P201O00010O01O1O001O2O02M3TEkKh:X4N1O1M2O1M3N21ON2J510O1O10000001O3M1N_FaKd8^4\\GdKb8\\4\\GgKb8Z4]GjKa8U4_GkKa8U4`GnK\\8S4bGmK_8T4`GmK_8T4`GkKa8U4^GjKd8U4\\GlKc8U4\\GmKd8R4\\GmKd8T4\\GlKd8T4\\GlKd8U4[GkKe8U4[GjKg8V4XGhKk8W4UGiKk8X4TGgKm8Y4TGfKm8Z4RGfKo8Y4QGgKo8Y4QGgKo8Y4QGgKo8Y4QGgKm8[4SGfKk8[4UGeKk8[4UGWKC;X9_4WGbKg8_4YGaKf8`4ZG`Ke8a4[G_Ke8b4YG_Kg8a4XG`Kh8`4WGaKi8`4UGbKf8b4YG`Ke8a4YGaKg8c4TG^Kk8\\5000O1N03OO10000HWGYJi8f5XGZJh8f59000000O1000000M300000000O100000000O11OO1001OO11O0000000000000000000000006J2N000mFXJn8Q6LO100001OO11O0000LVGRJj8n54O100O100O11O0000001O0000001O2NO100000000000000O1001O00O100000000000000O1O100O1I7O10000O100000000001O00000000000QG[Jc8k5VGVJj8k5UGUJk8P601O00000000002N00O12N000YGnI`8R6`GmIa8S6_GoI_8Q6aGlIb8U6]GkIc8Y60M\\GjId8V6\\GiIe8V63001O1O00N2LXGoIi8Q6WGoIi8P64001O001OO1N2N2N2N21ON22N00000000000000000000001O000000001O0PGTJl8l5UGSJk8m5UGSJk8Q60O11O00N23MN22N2NM300N2N200O100O10000L400O1001O00SOiF_K07W9Z4iF_K000JY9g4k0ASFjKn9U4VFgKk9X4WFgKi9Y4?O100O100O1O100O100O100O100O100O1O100O1O100O100O10000O100O100O1JjDbLV;X3jDhL0OW;Y3iDhL0NX;Z3hDgL1NX;Z3hDhL0NX;Z3hDfLOO];[36000000O100000000O1000000005K000000000000000000O11O00000000000000001O00000000000000000000O1000000000000000000000000N20000000000O100N200K[DmLg;S33NVDoLi;Q3300O11O2N001OO11O1WDjLf;V3ZDkLe;X301O1O2N0_DcL_;_300000001OO100000000_OaDaM_;W2aD]M1MO?_;P2bDeMON4>Z;P2bDcM2N2?Z;o1cDdM1M3`0K@00Z;_2gDdM0N3Q1i:\\1TEeM1M3R1h:\\1TEeM9n0c:\\1TEgM8n0d:[1TEgM7n0f:[1SEfM8o0e:Z1UEfM6P1e:Z1REdM>Q1a:]1^EdNb:[1`EdN`:Z1bEfN^:Z1bEeN_:[1aEeN_:", "size": [480, 640]}, "area": 89857.0, "iscrowd": 0, "image_id": 15517, "bbox": [0.0, 0.0, 640.0, 206.0], "category_id": 106, "id": 20000969}, {"segmentation": {"counts": "odS91g>0]A1MO_>1eAON4^>LcA2N2^>MdA1M3_>LdA0N3^>MdA1M3_>LdA9Z>GgA8Z>HfA7[>IdA8[>JdA6\\>GbA>`>O02M20000dM", "size": [480, 640]}, "area": 215.0, "iscrowd": 0, "image_id": 15517, "bbox": [622.0, 76.0, 18.0, 20.0], "category_id": 132, "id": 20000970}, {"segmentation": {"counts": "i^7114l0Ml<8iBHA5_=9mBOR=3lBNU=2iBOW=2hBNX=4`B\\O1b0_=k01O001O0000001O0000001O000000001O00001O000000001O00001O00001O1O001O4L0000O10000000000000000001O0000001O001O0000001O001O00001O0000001O001O0000001O00001O00001O001O001O00001O001O000K5K^AJe>2ZANZbf7", "size": [480, 640]}, "area": 3064.0, "iscrowd": 0, "image_id": 15517, "bbox": [15.0, 433.0, 99.0, 47.0], "category_id": 140, "id": 20000971}, {"segmentation": {"counts": "`8V11lN5\\2`1_Nk68iGX1[1aNl67jGV1Z1dNk66lGW1X1cNl66mGU1W1fNl65mGT1X1gNk65nGU1U1fNm65nGT1V1gNm63oGU1T1hNl64QHS1S1iNm63QHR1S1kNl63RHQ1R1lNl63RHQ1R1lNl63SHP1P1nNm61UHQ1JPNAOl0o0g7PO^Gk0e0U1FPND;i0a0XOTOg82XGc0f0\\1\\OoM50I?g02ZOAS9b0bG^1ZOoM7h08Em82dF@00f0U2@dN;Cn82cFBd0V2ZOmM1f0`0AQ9I^FM0003k0S3GSMY9HUFOl00WOP3a0QM\\O1P:NRF0l0o2Q:QMPFo2o9QMRFn2n9RMSFn2l9RMTFn2Q;N6J10O0000010O000dNZM^Ff2[9[M_EOV1f2S9\\MdE32KX1f2m8mMSGS2m8mMSGS2m8mMSGT2l8lMUGS2j8nMVGR2j8nMVGR2k8mMUGS2j8nMVGS2h8nMYGQ2g8oMYGQ2g8oMYGR2f8oMYGQ2g8oMZGP2g8oMYGR2h8lMXGU2h8jMXGV2i8iMWGX2i8gMXG\\2d8dM\\G\\2f8bMZG^2e8cM[G\\2e8eM\\GZ2d8fM\\GZ2d8fM\\GZ2d8gM[GY2e8gM[GY2e8gM\\GX2e8gM[GY2e8gM[GY2f8fM[GY2d8hM\\GY2c8gM^GX2a8iM_GW2a8iM`GV2`8jM`GW2_8iMbGV2^8jMcGV2\\8jMdGV2\\8kMcGU2]8kMcGU2]8kMbGW2]8iMcGW2]8iMcGX2\\8hMcGY2]8gMcGY2]8gMcGZ2[8gMeGY2[8fMfGZ2Z8fMfGZ2Z8fMfG[2Y8eMgG[2Y8eMgG\\2W8eMiG[2R8RM^Fd0`1Z2R8RM]Fe0a1Y2R8RM]Fe0a1Z2Q8QM]Ff0b1Y2Q8iMnGX2Q8iMoGX2P8hMPHX2P8hMPHX2P8hMPHY2o7hMPHX2P8hMoGZ2o7gMQHY2o7hMPHY2n7iMQHW2k7mLhFm0\\1V2e7UN[Hl1d7TN\\Hl1d7TN\\Hm1c7SN\\Hn1f7PNZHP2POlLW8S1hHQ2lNiLJ5b8Q1hHR2hNgLN:b8m0hHb2W7_MiHa2]7YMcHg2^7XMaHi2_7XM`Hh2`7XM_Hi2a7WM_Hi2b7VM]Hk2c7UM]Hk2c7UM]Hk2c7UM\\Hl2d7UM[Hk2f7YMTHh2l7hMdGX2\\8V20000000000000000000000000000O100000lI[Gm5l801O0000001O0000001O0000001O000cMmFmNS91mFdN8S1k87oFeN:Q1f89SGeN9P1c8EkG[OFl0^8DSH_O@l0]8_OYHEZOl0n7XNjGW1o0D[Ol0l7YNiGX1Q1B[Ol0h7]NkGV1R1A^Oi0e7`NjGV1U1@\\Oj0d7aNjGV1V1^O_Oi0a7cNiGW1W1]OAg0_7eNjGV1W1]OEc0Z7jNjGU1X1^OFZOjNT1^8oNjGU1X1_OI]76cH[O0?]76cH[O1>[78gHWONa0[77jHUOLd0[76jJJV56jJJV56jJJV56jJJV56jJJV56jJJW55gJMY53fJNZ52eJO[51jJJV57iJIW58gJIY57fJJZ57aJM_53_JOa51_JOa51_JCYLHX9e0^JC[LHW9e0^JC[LHW9e0_J_OWLE28X9d0^J\\OZLGO028W9e0^J]OaLNQ9f0]J[OcLOQ9e0[J]OfLLo8g0\\J\\OdLNP9f0[J]OdLNQ9e0[J]OeLMP9f0ZJ]OfLLR9g0ZJZOfLMQ9i0YJWOjLNn8l0WJTO`6l0j30000000000001O00000001O00000001O000000O100O1O1O1000001O01O0000000000001O000000000001O01O00000000001O1N2O1GQO_BP1`=800[EgNc71`ER1m2nNb7NdET1i2oNi7Q1VHPOk7o0UHSOi7m0VHUOPNITOO01a9R1XImNWM96IK366Y9g0YIYO^MN04W9f0]IVO\\M1M4Z9e0]IWO\\M1J4^9c0\\IYOUME5l0Z96\\I\\OWMBOk0^97\\I]OVMBOj0`97XI@YM;_95WIa0i6_OWIa0i6_OWIa0i6_OVIb0j6_OUIa0k6_ObHPO\\Na1R9_O_HTOYNIJe1^9^O]HVO[N`1X9ZOZHmNWN;5^1[9ZOTHA^NV1^9YO`FXOU1Y2[8UO\\Gl0d8[OTGf0l8FfF0aJoFo4Q9lJTGT5m8gJWGY5^7gJmIY5S6iJYHM]1Z5Y6PKfIP5Z6PKfIP5Z6PKWHF]1Z5\\6PKWHF]1Z5\\6RKdIn4\\6RKdIn4\\6RKdIn4\\6RKdIn4]6QKcIo4\\6RKdIn4\\6RKdIn4]6QKcIo4]6QKcIo4^6PKbIP5^6PKbIP5]6QKdIn4\\6RKdIn4[6SKeIm4Z6TKfIl4Z6TKfIl4[6SKeIm4[6SKeIm4[6SKeIm4[6_KYIa4f6bKXI^4g6cKYI]4e6eK[I[4g6cKYI]4g6cKYI]4g6cKYI]4g6cKYI]4i6aKWI_4i6aKXI^4i6aKWI_4j6`KVI`4k6^KVIb4k6]KUIc4k6]KUIc4j6^KVIb4j6^KVIb4i6_KWIa4j6^KVIb4j6^KVIb4j6^KVIb4i6_KWIa4i6_KWIa4i6_KWIa4i6_KWIa4]6kJhHd0k0a4V6hJlH70`0n0a4U6UKnH;l0`4W6SLiIm3W6SLjIl3X6RLhIn3W6TLhIl3X6TLhIl3Y6SLgIm3Y6SLgIm3Z6RLfIn3Y6SLgIm3Z6RLfIn3Y6SLgIm3Y6SLgIm3Y6SLgIm3Z6VKhH:n0`4Z6QKlH`0j0_4W6RKPI`0i0^4X6QKoHb0h0]4Y6QKnHh0d0W4^6QKRId0`0[4`6nJQIg0?[4a6kJdHNd6B\\I>d6A^I>b6B^I>b6C]I>b6C^Io0i0X7gNiG?P1o0]8QOcGn0^8ROcGm0\\8TOdGl0[8UOeGk0^8POeGo0Z8ROfGn0U8dNaE?Z2m0U8WOkGi0V8VOjGj0U8WOkGi0S8YOmGg0S8YOmGg0S8YOlGh0T8WOmGi0S8WOmGi0S8WOmGk0S8ROnGn0eMcNY:=RHV1o7iNQHW1P8[NdE91HV2e1Z8gNdGZ1]8eNcG[1^8eN`G\\1c6XNUI<6]1e6XNUI:5_1f6XNTI:5^1g6XNTI;4]1h6YNSI:5]1h6ZNRI87^1g6\\NPI97Z1i6]NQI87Z1h6^NQI88Y1g6`NQI77Y1h6aNPI68Y1h6bNoH59Y1h6cNoH39W1RN[Ng8;oH28V1m6jNiH0;Y1h6gNnHNY1f6lNZKV1d4jN]KU1c4kN]KU1c4kN]KU1c4lN]KT1b4lN^KT1b4mN]KS1c4nN\\KR1d4nN\\KR1d4oN[KP1f4ROYKm0g4TO[Ki0e4WO^K[OkKY1g8]OaK?a4A`K=a4C`K:b4D`K<`4CaK<`4AcK?]4_OeKa0[4@dK>^4@dK>^4\\OgKe0Y4[OgKd0Z4[OgKe0Y4ZOhKf0X4ZOhKf0X4ZOhKg0W4YOiKg0W4ZOhKf0X4]OeKc0[4^OcK>b4C]K=c4C]K;e4D\\K;e4FZK:f4FZK;e4E\\K9e4G\\K8d4H]K7c4I]K6d4J[K6f4I[K6f4KYK5g4JZK6f4JZK6f4J[K5e4K[K5e4L[K3e4NZK2f4N[K1e4O[K2d4O\\K0d41[KOe41[KOe41[KOe41[KOe4O]K1c4N^K2b4N^K2WKCY9:aK5_4JbK6^4IcK7]4HdK8\\4HeK6\\4JdK5]4KcK4^4LcK2^4JfK5[4JfK4\\4LhKOY40\\500000PWY5", "size": [480, 640]}, "area": 20233.0, "iscrowd": 0, "image_id": 15517, "bbox": [0.0, 0.0, 279.0, 201.0], "category_id": 157, "id": 20000973}, {"segmentation": {"counts": "]O2JZA1gPS20S^mM8G4M2N4L1O0O2O1O3M0O3N2N5K2WBjNe=Y14K1nN]Bf0T>J6J8DVA3RXf6", "size": [480, 640]}, "area": 1348.0, "iscrowd": 0, "image_id": 15517, "bbox": [0.0, 395.0, 183.0, 56.0], "category_id": 167, "id": 20000974}, {"segmentation": {"counts": "b6n1R=1O00O10O1000010OO11N11O00O103QCoMiUCc0]=\\OdB9OZOg=2[B40?i=[OXB23b0l=\\OWBa0T>00001O0013L002NO11O000N_AEa>:`AF`>:`AF`>:`AFa>84O10000NYAKg>070ngT10_WkN0UB2j=OgAO60J5X>LgA00O0118X>]3WB3l=KkAN;5_>Mn]R3MWamL0kB0WO0n=5dB1Z=0VBJ:7[=JXB72I:7[=:bBH]=9bBJ[=6^B_OON24O0O2O001O001N2O1O1O001O1N2O0000001O0O2O1jAZOQ>k0O1O1O1O002N6J001O0000000010O000001O000000001O0000001O01O000001O0000001O0000000010O000001O00001O001O1O001O1O01N10000O10000O1000O100000000000000000000000O10001O00001O1N2O00000000001O000O10`NSOmDm0S;SOmDl0T;TOmDk0S;VOlDi0U;WOkDi0U;WOkDi0T;XOlDg0U;ZOjDf0V;ZOjDe0W;[OjDd0V;\\OVE8j:HhEEX:d000010O000001O00000O2O0000001N100ZDTOX9k0gFWOY9h0fFZOZ9e0PF3P:]O]D2^1g0U:WO]D2X1n0[:oN]D2X1P1\\:gNbD8S1Q1]:eN`D9T1S1c:lN]EU1c:jN^EW1a:iN_EW1a:iN_EW1a:iN^EX1b:hN^EY1a:hN^EX1b:hN]EY1c:gN]EY1c:gN]EZ1b:fN^EZ1^:^N\\D8U1[1^:^N]D7U1[1^:^N]D8T1[1^:]N^D8S1\\1_:\\N^D8S1\\1_:\\N^D8S1]1^:[N_D8S1]1^:[N_D8OJm0d1e:ZN_D?k0W1f:ZN_D?k0X1e:YN`D?j0Y1f:XN`D?j0Y1f:XN`D?k0X1e:YN`D?k0X1e:YN`D?k0Y1d:XNaD?k0Y1d:XNaD`0j0X1e:XNaD`0j0X1e:XNaD`0j0Z1b:WNcD`0k0\\1_:TNfD`0l0\\1]:TNgD`0l0\\1]:TNgD`0l0\\1]:TNgD`0l0]1\\:SNhDa0k0\\1]:SNhDa0k0]1\\:RNiDa0k0]1\\:RNiDa0k0]1\\:RNiDa0l0]1Z:RNjDa0l0]1Z:RNjDa0l0]1Z:RNjDa0l0\\1[:SNiDb0k0Z1]:TNhDb0k0Y1^:UNgDb0k0Y1^:UNgDb0k0X1_:VNfDb0k0X1_:VNfDb0l0W1^:WNfDb0l0W1^:WNfDb0l0W1^:WNfDc0k0V1_:WNfDc0k0V1_:WNfDc0k0V1_:WNfDc0k0V1_:WNfDc0k0W1^:VNgDc0l0V1]:WNgDc0l0V1]:WNgD219k0^1]:WNgDd0k0U1^:WNgDc0l0W1\\:VNhDc0k0X1]:UNhDc0k0X1]:UNhD0O?l0\\1]:UNhDc0k0X1]:UNkDa0g0Z1^:UNkDa0g0[1]:TNlDa0g0[1]:TNlDa0g0[1]:TNlDa0g0[1]:TNlDa0g0[1]:mNcET1\\:mNeEQ1[:oNeEQ1[:oNeEQ1[:oNfEP1Z:POfEP1Z:POfEQ1Y:oNgEQ1Y:oNgEQ1\\:lNdET1^:jNbEV1`:hN`EY1_:gNaEY1_:gNbEX1]:iNcEW1]:iNcEW1]:iNcEX1\\:hNdEX1\\:hNdEX1\\:hNdEX1\\:hNdEX1\\:hNeEX1Z:iNeEW1[:iNeEW1[:iNeEW1[:iNeEW1[:iNeEX1Z:hNfEX1Z:hNfEX1Z:hNgEW1Y:iNgEW1l9VOTFj0l9VOTFk0k9UOUFk0k9UOUFk0k9UOUFk0k9UOUFk0k9UOUFl0j9TOWFk0i9UOWFk0i9UOWFk0i9UOWFk0i9VOUFl0j9TOVFl0j9TOUFm0k9SOTFn0m9QORFP1n9PORFQ1m9oNSFQ1m9oNSFQ1m9oNSFQ1m9oNTFP1l9POTFQ1k9oNUFQ1k9oNUFQ1k9oNUFQ1k9POTFP1l9POTFP1l9POUFP1j9POVFP1j9POVFP1j9POVFP1j9POVFQ1i9oNWFR1h9nNXFS1g9mNYFT1f9lN[FT1d9lN\\FU1c9kN]FU1c9kN]FT1d9mN[FS1e9mN[FS1e9lN]FR1d9TNbE9k0b1c9TNjE3d0h1b9UNPFL`0n1`9VN[Gi1e8WN[Gi1f8VNZGi1g8WNQFI?P2`9WNoELa0l1`9XNmENc0j1`9XNkE0e0h1`9XNiE3f0e1a9XNiE3f0e1a9XNiE3f0e1a9XNiE4f0b1b9ZNhE4f0b1b9ZNhE4f0b1b9ZNhE5e0a1c9ZNhE5e0`1d9[NgE5f0^1d9]NfE6e0]1i9VNdE>c0[1j9UNeE`0a0Z1^:fNbEZ1e9fN`E0l0X1e9hN_E0l0W1f9iN]E1m0V1f9iN\\E2n0T1g9jN[E2n0T1g9jNZE3P1Q1g9lNYE3a1?W9^OXE3i16P9GWE3P2Mk80UE3a=M_B3a=M_B3a=M_B3a=N^B2b=N^B2b=O]B2b=O]B1c=O]B1c=O^B0b=O_B1a=O_B1a=N`B2`=L_B7a=d0000^O\\BHd=8\\BHd=8\\BHd=8\\BHd=8\\BHd=8\\BHd=8\\BHd=8\\BHd=7]BIc=7]B\\OP>d0PB[OQ>d0PB\\O:0V=d0_B]O64[=>_B_O28^=Q10O100000000001O000000_O_BCa=6_B@0:a=6`B_OO;a=7`B]OOm=HSBJ0>m=HSBJ0>m=HSBI1?l=HTBH0`0l=HTBH0`0l=HTBH0`0l=HTBH0`0l=ISBG1`0l=ISBG1`0l=ISBG1`0k=JXB6h=JXB6h=JXB6h=JXB6h=JXB6h=JXB6h=JXB6h=JXB6h=JXB7g=IYB7g=JXB6h=JXB6h=JXB6h=JXB6h=JXB6i=IWB7i=IWB7i=IWB7i=HXB8i=HVB8j=HVB8j=HVB8j=HVB8j=HVB8j=HVB8j=HVB8j=IUB7k=IUB8j=HVB8j=GWB9i=GWB9i=GWB9j=ARB04?o=AQB?o=AQB?o=AQB?o=AQB?o=AQB?o=AQB?P>@PB`0P>@PB`0P>AoA?Q>BnA>R>CmA=S>DlA801O0000000000000000000000000000000001O01O0M3000\\OQB7o=JTB2l=NWBOj=4VBHj=?SB]Om=f01ZOnAg0o=[OQBe0k=:O2O00VOWB=i=CWB=i=CWB>h=>O01N100000000O100000000000000WOVBdHB^7U8AjG`0W8_OiGa0X8^OhGb0Z8\\OfGd0[8[OeGe0]8YObGh0`8VO`Gj0a8UO_Gk0a8UO_Gk0`8VO`Gj0_8WO`Gj0`8VO`Gj0_8_JRGc4?n0_8^JSGc4?o0`8\\JPGf4?o0c8RO\\Gn0`8WO_Gi0_8ZO`Gf0^8]OaGc0\\8@cGa0[8@fG`0X8BhG>W8BjG>T8DkG=U8BlG>S8ClG>S8BmG?R8BnG>Q8CnG>R8AoG?P8]OfGkJ9i5R8ZOgGkJ7l5R8XOTHh0k7XOUHi0j7WOWHi0i7VOWHk0h7UOYHk0f7UOZHl0f7TOYHm0f7SO[Hm0c7TO]Hm0c7SO]Hm0b7TO]Hm0a7UO_Hk0a7TO_Hm0`7TO`Hl0_7UOaHk0^7UOcHk0\\7VOdHj0V7\\OiHe0V7\\OjHd0V7[OkHe0S7]OmHc0P7@PI`0o6@RI`0m6ASI?l6BTI>l6BTI>k6CUI=k6CUI=j6CWI=h6DXI=XBT1W2fNaMIP>=YBS1U2gNdMHP>9XBU1o1kNgMEV>8UBW1m1lNjMC\\>3oAb1e1hNPNBU?k1dBcNg=`1TB`Nm=a1PB`NR>`1kA`NW>a1gA_N[>a1bA_N`>a1_A^Nd>b1T@SNj0;U?m1h@TNZ?k1e@TN^?l1_@TNd?k1[@TNh?l1U@UNl?k1R@UNQ`0k1m_OTNV`0k1h_OVNZ`06]_Oh07QO_`06`_Oc0OWOd`05__Oc0JXOi`05^_Ob0HYOk`05^_Ob0DYOPa05]_Oa0BYOSa06]_O>_O\\OVa05]_O<]O@Wa04]_O:\\OAYa05[_O8\\OC[a05Z_O6[OD]a06X_O4[OG^a05X_O2YOJ`a04X_O0XOL3CXa0a0]_ONXOO1EZa0>^_Od0c`0]O\\_OIXO;]a0L\\_O`0e`0AY_OEYO?_a0LW_O?j`0BS_O?n`0AQ_O?Qa0Am^O?Ta0Ak^ONAKga07e^OODJia06b^OOGIja07^^O0HIla06[^O1IHoa06W^O1KHPb07T^OCI83NRb06Q^OCJ95LSb07n]OBJ<5KUb06k]OBK>5IWb07i]O01HXb08f]ON5GYb0:`]OM:GYb0<[]OLWc078L4000000M3L_dS2Lg[lM5L2M1O1O1O1O1O1O101O0000000000000O100000001O000000O10O100000O100000000O100000000O1000000O10O1001O1N2O1O00O10O010O010O010O1O01KFd\\O9\\c0Ja\\O7^c050001O001O010O0010O1O10O01000O1000000O10000O10O10000000O10000000000O10O10000000000000000O1Ie\\OI[c07f\\OHZc07h\\OGYc07To3", "size": [640, 433]}, "area": 14027.0, "iscrowd": 0, "image_id": 15597, "bbox": [9.0, 177.0, 417.0, 286.0], "category_id": 183, "id": 20000979}, {"segmentation": {"counts": "djP21e:0]E3a:6O0_EG`:?L1dEAQ:0SFd0i9@TF`0j9DUF:n9:1FQFBR:J@n3S1aMoNgN>J@n3S1aMiNkM0o0d0G@n3S1`MhNPOe0B@n3S1fN]O\\M@n3S1VMkNC`0YOBn3T1TMmNDJdN`0f0En3T1RMPOG7YOEn3T1PMQOJ6XOEn3T1nLQON6VOEn3U1kLTOO2XOEn3U1iLXOVO^O5>OGm3U1gL\\OVOZO7>OGm3U1eL^OXOYO6=0Gm3U1cL@[OWO4=0Ho3T1^LD_OUO0<4Gn3U1]LEATOO;5Gn3U1SLNMkN_OL8?;Gn3V1oK01iN]OL=;8Jn3Z1iKNFcNO065IK<<8Jo3W3]KlL0FO00:?16Lo3d3]KULO;`005Lo3g3]K\\L?15Lo3T4mKnK5Nn3U4kKnK6No3U4jKmK7No3U4jKmK7No3T4kKnK6No3T4kKnK5OP4m3^KkK>94OP4n3PLSL0OP4P4oKPL10P4Q4nKoK20P4R4mKnK21Q4R4kKmK51P4R4eKdKK9`01P4R4cKhKI50Gd0:P4T4`KQLMAc0:P4T4^KSLO_Ob0;Q4T4\\KSL1^Ob0;Q4g4^KnJa0;Q4g4^KnJa0;Q4g4^KnJ`0o15^50aJ0_51bJN^52cJM\\53gJJZ56jJEW5;mJ@S5a0d200O010000O10O1000000O010000000O0100000O1000O01000000O01000O100000O0100000O010000O10O1000O1000O01000000O01000O10O1000O1000O10O10000O010N2N2O0O2N2N2N2O0O2N2N2NQf\\12mYcN3N2N20N1L401MZn03bQO5LJfE0W:0lEOR:1<00010O0100O1000000001O010000O101OjjW11TUhN1N2O8H01O00d]:", "size": [348, 640]}, "area": 6017.0, "iscrowd": 0, "image_id": 15660, "bbox": [88.0, 27.0, 521.0, 316.0], "category_id": 183, "id": 20000983}, {"segmentation": {"counts": "TQW12nc0017G4L6J1IAl\\O`0Uc050O1O2O00N2012MO2N00N22OOO3O1M110N101O3N0O011N3M2OO1O1NHoNe]OR1[b0mNe]OT1Yb0nNe]OT1Zb0nNb]OT1^b08O03M1N0N23N0O1M5L2O2O00003M00N120N10O1O02O018G1O1O1N2N201N2L4O100L4M3O000K500N2M3L4N2O1O100O1Jn^]5", "size": [640, 427]}, "area": 3005.0, "iscrowd": 0, "image_id": 15746, "bbox": [62.0, 254.0, 87.0, 61.0], "category_id": 97, "id": 20000984}, {"segmentation": {"counts": "T4\\2fa0N0000000O1O100000000O10011nNW^OIja05Z^OHga06h^O]OVa0c0T1M3001OO100001\\OSOS^On0ja0UOU^Ok0BQOVb07U^Og0FVOQb03Z^Of0GVOna03\\^Oh0EYOka00W^OH1^1ea0kNZ^OIN^1fa0jN\\^OHMa1ea0f010OO0hNZ^OPO6P1]a01h^OH[a09j^OAWa0?i^O@Xa0`0h^O_OZa0>h^OBYa0=g^OBYa0`0f^OQO_Oha0BX^O>ha0BX^O>ga0EW^O;ha0DZ^O;ha0CY^O0nA2a4o0aKoNl=8cFi0`9YO_Fg0_9[O`Ff0_9[OaFf0jKmNX=`0lFc0kKROT=b0kF;lKnN16MJV=h0PGo0o8QOQGP1m8QOZGh0e8YO[Ge0g8[OYGf0f8ZOZGf0e8[O[Gd0f8\\OZGa0i8_OWG`0i8AXG?g8AXGWOfKR1P=GeGTOWKn0W=NbGTOWKm0X=OcG2\\8NeG1[8OfGO[81fGOY81hG0V80jG0V80jG0V80mGOR80jG3V8NjG2V8NjG2W8MjG2V8NjG2X8LgG5Y8KeG7[8IeG7\\8HdG8]8GcG8_8GbG<\\8BfGa0W8]OiGb0Y8]OjGc0oJlNQ==oBDU5R1o7mNlB2_5o0h7ROYHm0g7SOYHl0]=1O001000LS]OTOnb0j0R]OUO01nb0h0V]OXOjb0c0R]O\\O023Olb0b0U]O]OO1mb0`0>NM4L3N3L221O00000P]OTOlb0T1M0OO110O0O1000000O2POR]O;0E0007fc0O2O1JW\\O0mco00W\\PO1cc0O\\\\O2dc051OO20O01N1O11NLHb\\O9]c0Hc\\O7]c061O010H_\\OO_c0Na\\ON0O0012_c0Ob\\OO42fc00i]O0_`0Na_O4Tb03K3O2KDd\\O<\\c0Ec\\O;^c0Ea\\O;_c031O00cNBW_O?i`0AS^O0l0?Qa0BQ^O0m0?Ra0AQ^O0m0?d`0@d^O5ILOOo0?a`0G_^OK10O41NON0Ol0`0f`0?Y_OAh`0>X_OBg`0?X_OBh`0=Z_OBg`0=Y_OCg`0=Z_OBf`0>Z_OBf`0>Y_OCg`0d`0B\\^O<0D20T1>``0HZ^OK1O[17a`0KS^ON00c16Yb0L0OX\\m0OhcRO3E0`\\O5d9K[F3`9631AEnFO39^93_ONnFE1:b93_O=`0D@<`0D^O>b0B^O>b0A_O?a0B]O?c0A]O?c0B\\O>c0D\\OP6U9gMiF[2W9bMlF^2S9cMmF]2R9cMmF_2S9aMmF_2T9cMiF]2W9bMjF^2V9bMlF\\2T9cMmF]2S9fMiF[2U9dM_FXL=T6T9lIaFd3N\\LT6W9`JcGP1UOa4X9^JeGP1QOd4Z9[JgGP1oNe4Y9ZJlGo0kNg4V9\\JQHl0iNh4X9ZJPHm0jNg4V9\\JRHj0jNi4T9]JSHj0fNk4Y9YJQHl0eNl4Z9XJQHl0gNj4Y9YJPHk0gNn4Y9WJPHl0fNm4Z9WJPHm0eNl4^9TJmGP1dNm4_9RJnGQ1hNh4X9YJPHn0fNl4[9UJnGQ1eNk4\\9UJoGP1dNl4]9TJoGo0cNo4^9QJPHP1bNo4]9QJRHP1cNeNDV6g9UJTHo0bNl4[9UJSHm0bNo4[9TJTHl0]NT5_9QJUHf0SNoN;X6]9SJVHd0SNQO:X6\\9UJUHc0eNV5U9VJWHg0SNlN;Y6\\9PJWHo0\\NR5]9nIVHR1`Nm4X9SJWHP1aNn4Y9QJTHP1WNgNeNf4AdJV97dH>fNf4BdJT98dH=hNd4BgJm8jNf4d9eJbGf0jNc4m;]KRDd4n;\\KQDd4Q<\\KoCb4R<^KnCb4S<^KkCc4U<]KlCa4V<^KhCd4X<\\KiCc4X<[KiCd4ZKPDXHPl3k;nJhCJOX14fNK`5Z<`JgC39;G92YOMb5S=cJnBK0h00m4R=[JSC0N]6j0lIROH0Oe;0gD]65^Jb;b5]D_Jb;`5`D`Ja;a5^D^Jb;c5[DbIBk0UbJk;]5UDcJl;YOfCL2k59SKo;VOgCK1m58RKU`9B`F=a9C_F=a9C_F;d9D[F?b9B]F`0b9@^F`0c9_O]F`0d9@\\F?e9A[F?e9AZFa0d9@\\F`0d9@]F?d9BZEYMIU3m:CXE\\MHQ3o:EWEiM]O_2^;GUE]1oNlKg;h2WEc1i:]NWEe1g:[NZEe1d:\\N[Eg1d:XN\\Ei1c:WN]Ej1`:\\KbDj2o0k1]:[KdDW22XNn0U4\\:\\KdDU25YNk0BQO_4];hMjDTNg0FVOY4[;lMhDVNf0GVOV4\\;mMgDWNh0EYOS4X;QNhDnMH1^1o3o9SNlDmMIN^1o3o9UNkDnMHMa1n3l9WNjFi1U9YNkFa1gMXL_;X2iF`1Z9`N^EgMPO6P1`3c:bN^ESNH^3k:^N^EYNAZ3Q;]N^EYN@[3Q;]N_EXN_O]3Q;\\N]EYNBY3S;_NZEXNBY3U;^N[EXNQO_OZ2c;6oC`M>Z2c;6oC`M>]2`;2UD_M;^2a;2SDbM;\\2c;3PDbM<[2e;0SDdM8[2f;0RDfM7[2g;NRDjM4W2l;JcC[Mg1mBmLnN\\1V>g1lBmLnNZ1X>i1iBnLoNY1Y>h1hB[NX=f1hBYNY=f1hBZNX=f1iBVMmNg0[>S2hBUMROd0U>X2hBoLnN16MJf0\\>\\2[C^Mj^c0NO300OO203MO102M13LNDa\\O=_c0Ca\\O<`c0D`\\O<_c03O100b\\O@\\c0b00O021M10011N00O1O10_Oc\\O`0^c0L411M10O1_\\OF[c0_c0O1N20000002M20M2O12L03O1O0O15JN4N1O0O2002\\\\ODac0=O01L1G_\\O;^c0Fb\\O:^c060_Oa\\O;cc0O13L0NDb\\O<_c011N22OM22^\\OD\\c0b0L]Oh\\Ob0Xc031M0^Og\\O?[c06M00N3O2O0O1N2O01OO1O11O00O11ON21O01M22OOhkk2FbTTM1N6KM3NN9LN3M21M102[\\OF`c0>LCc\\O=^c01102N03M000O01Lb\\OH[c07h\\OGYc0:8O\\\\OF_c09a\\OH`c0752M00O210M14L20N02M4NOO302LJl\\O@Vc0b04ON1000K80L310NO1000000N12N4ML50N1ON31O2M002O0001ON^Of\\Oc0Yc011O2O0001O0O02N011O10O20L4F_\\OKfc03Z\\OMjc01Xh80jWG5U\\OJdc0:O0OO21O012L2OJ62N3MO1N13N00004LOUC", "size": [640, 427]}, "area": 3971.0, "iscrowd": 0, "image_id": 15746, "bbox": [0.0, 404.0, 427.0, 43.0], "category_id": 140, "id": 20000988}, {"segmentation": {"counts": "0_1ab0000000001OO1001O000000O1001O00O100O10000O11O00N_]OeNab0[1_]OeNab0[1_]OeNab0[121O0000N20000000000000000O1000000000000000000O10000000000000000000000000000O1000000000000000000000000000000000000O1000000000000000000000000000000O10000000000000000000000O1000000000000O1O100000000000000000000000000000000GT]O^Olb0`0W]O_Oib0`0=[ACdM0Qa0c0SAAo>=l@_OQN023Qa0>l@CQNOUa0T]OCJOnb0Y2iARNV>P2gARNX>o1gARNX>o1gAmM]>T2bAhMb>Y2]AdMf>]2YA_Mk>b2RA`Mn>a2n@`LMo0U?b2m@aMS?f30001O00001O000UBVK`bc00O10000000000O2O000000000O100N2M4M6L3M1O00O100O1O1000J7M4M2N2M4M2O1O2N1O0000O100000O100000000O1O102O0gM_NQBb1m=`NSBa1j=aNUB`1g=dNYBY1e=lNXBT1g=POUBR1h=TOUBk0k=YOSBe0n=^OPB`0P>DnA?n=DoA?n=DPB?l=DRBkNeAT1\\>kNeAU1[>hNhAW1Y>dNlA\\1U>_NoA`1S>ZNRBf1o=WNSBh1o=VNRBi1P>TNRBl1P>QNRBm1P>PNRBNXNk1g?UNYBj1o?O2OO0O00O2M26K2O1O001O1O1O0001N10001N100O2N100O2O00001O1O1O2N1M4J7J6I5K22O3M3M101O01O001O0O3L5L1N2N2N2O100000000O1000001O0O100Nhi_1", "size": [640, 427]}, "area": 48215.0, "iscrowd": 0, "image_id": 15746, "bbox": [72.0, 198.0, 278.0, 377.0], "category_id": 183, "id": 20000992}, {"segmentation": {"counts": "0\\fb0>^f]O4M3N2M3N2N2O1N101N1O2O001O001O01O01O001O000101N3N1N0010O0100O010O00010O010O01O010O00010O0001O00001O001O0000001O0000010O0000E]OnCb0P_LE`3:_LIa36^LM`32aLO_30`L2_3MaL5^3KaL7_3GbL;\\3EcL=\\3BdL?]3_OcLc0\\3]ObLe0^3[OaLf0_3YOaLh0_3YO_Li0`3XO^Li0b3XO\\Li0d3XOZLi0f3YOWLi0h3XOVLi0j3XOULh0k3ZOTLe0l3\\OTLc0l3^OTLa0l3@TL?l3CRL=n3DRL;n3FRL9n3IQL7n3JRL5n3KRL5n3LRL3n3MTL1l30TLOl31VLMj33WLLi35WLTOdL2U7l0jLSOV3o0jLoNV3T1hLkNY3V1fLiNZ3Y1fLeNZ3^1dLaN\\3a1cL^N^3c1T43M2O1N3M2N2O1NO1N3L31O2N100O2]E]OZ8k201N1O2N2O0O2O05L6I4\\Mc2G9Fhm]4", "size": [427, 640]}, "area": 261716.0, "iscrowd": 0, "image_id": 15751, "bbox": [0.0, 0.0, 640.0, 427.0], "category_id": 151, "id": 20000993}, {"segmentation": {"counts": "\\fb0>j<4M3N2M3N2N2O0O2O0O2N101O001O0010O01O00001O02O1N2N2OO01O010O10O010O0010O0010O0010O01O01O00001O00001O0010O000001O0000001O0000E^OmCb0PUIBk6>UIBb6HnFf0`2Bb6JkFd0d2Ab6MhFb0f2Ab6g0^IXOb6i0^IWOb6h0_IUOd6k0\\IROg6n0k200O01000O100000O01000000O1000O10O1000000O0100000O1000O10O1000000O01000O100000FVOSDi0n;XOPDi0Q[3AeL`0\\3_OcLb0]3]ObLf0]3ZObLg0^3YOaLh0_3YO_Lh0a3YO]Li0b3XO\\Li0d3XOZLi0f3YOWLh0i3YOULh0k3YOTLg0l3[OSLe0l3\\OTLc0l3^OTLa0l3@TL?l3CRL=n3DRL;n3FRL9n3IQL6o3KQL4o3LQL4o3LSL2m3OSL0m30TLOl32ULLk34VLKj36VLPOhL6Q7l0jLSOV3o0jLoNV3T1hLkNY3V1fLiNZ3Y1fLeNZ3^1dLaN\\3a1cL^N^3c1T43M2O1N3M2N2O1NM3N3N11O2N100O2]E]OZ8k201N1O2N2O0O22M6K4K3ZMg2Eh0XOXm]4", "size": [427, 640]}, "area": 11336.0, "iscrowd": 0, "image_id": 15751, "bbox": [44.0, 232.0, 255.0, 195.0], "category_id": 183, "id": 20000994}, {"segmentation": {"counts": "fgf77h>2N2O000O2N1O2M3L3L501N2N00001O1O10N11N2K401O000000NXBlNh=T1XBlNh=T1XBlNh=T1XBlNh=S1YBmNg=R140O10LWBQOi=n043N1N1000001N11N0100000M33M0OSOXBc0i=ZOfB9[Zm0", "size": [480, 640]}, "area": 1585.0, "iscrowd": 0, "image_id": 15956, "bbox": [526.0, 160.0, 52.0, 44.0], "category_id": 98, "id": 20000995}, {"segmentation": {"counts": "bej621Ok>9J0000000J6L4001O000000O11O2NL4O1hNBnC>j;KUD5A[Oh;a0gD4[OCl;;fDf0Z;[OeDg0Y;YOfDi0Y;XO^D^OA\\1Q<^1O000000O10000XMQD_2P<]MTDb2VU=g0oBXOU=CgBl09^OT=a0nB^OR=GcBg0>@R=?PC_OP=e0d0O1NkAYOU>g02010N11O01O0000NjAZOW>e0iA\\OX>b03I:M1O004L1OYS:", "size": [480, 640]}, "area": 7384.0, "iscrowd": 0, "image_id": 15956, "bbox": [466.0, 181.0, 152.0, 95.0], "category_id": 110, "id": 20000996}, {"segmentation": {"counts": "hh63c>f0aAYOl=Y1H2POgNgCa1XO10[KXGR3i8jL[GU3f8hL\\GX3e8gL[GY3f8eL[G[3g8cLYG]3h8bLXG^3i8aLWG_3j8_LWGa3j8^LVGb3k8]LUGc3l8\\LTGd3n8ZLRGf3o8SLXGl3i8gKcGY4b900000XMiKgJW4W5UL_Jk3a5^LVJb3k5dLnI\\3R6hLjIX3W6jLfIV3Z6nLbIR3_6QM]Io2i6oLSIQ3j6VMRIj2o6YMmHg2S7\\MkHc2W7_MeHa2Z7dMbH\\2^7hM^HX2`7nM\\HR2h7nMTHR2k7b21O001O001OMQITHP7l72O12N001O00001O2NO1001O1OITIVHP7j73000000000000000000000000000000000\\IUHS6k7gI]HW6V802N1O001O000000O1000000000000000000001O0000001OO1001O00O100O1UOdIRI\\6m6eIUIY6g6eIaH4e0X6j6nITIR6h6TJVIl5j6UJdH@4OKc6]7n0O1O1O1000000000000O11O1O3MO1002cHcHS7\\7nHdHR7`7jHaHU7e701O1O2N00000000N21O00O12N1OO1O1O1O1O1O100001O001O00M33MO1OPIYHi6i7UIXHMOj6j7WI\\Hh6d7WI^Hh6b7XI^Hh6b7WI_Hi6a7WI`Hh6`7XI`Hh6m7O00001O1O001O00001OM]IiGc6U8_IkGa6n7^ISH4N^6l7?N200O1O1L42N1ON21O001O0000001O4L000000003M0000O1N21O00001O00O11O00O11ON200001OO11O001O000000", "size": [480, 640]}, "area": 134004.0, "iscrowd": 0, "image_id": 15956, "bbox": [0.0, 234.0, 640.0, 246.0], "category_id": 114, "id": 20000998}, {"segmentation": {"counts": "eUm18a>JbA41N20001O000000O10000N20O102NM300O1O1000000000000O1002N00O11N0MfAB[><5GaAMc>1m_m6", "size": [480, 640]}, "area": 614.0, "iscrowd": 0, "image_id": 15956, "bbox": [130.0, 232.0, 37.0, 25.0], "category_id": 132, "id": 20000999}, {"segmentation": {"counts": "jcY74i>4O1O0O2HIeA8[>62OO1N102M2O010L33M00O0011N200O0O2L4O1N2M2O8HTid1", "size": [480, 640]}, "area": 487.0, "iscrowd": 0, "image_id": 15956, "bbox": [498.0, 174.0, 29.0, 26.0], "category_id": 143, "id": 20001000}, {"segmentation": {"counts": "TXZ67e>5^AIT>e0K4K6QOUOcCo0\\R0L;POl0L1HcNmB]1R=dNmB]1S=cNmB]1S=cNmB]1S=8000000000000000000O1000000000000K500O11O5K0000000000000000000000001O0O3WNjB29T1Q=kNUC7EGM?YbS4", "size": [480, 640]}, "area": 2659.0, "iscrowd": 0, "image_id": 15956, "bbox": [313.0, 83.0, 47.0, 67.0], "category_id": 181, "id": 20001004}, {"segmentation": {"counts": "kWd09d>4N3M3M100O2O001O000O10000000O2O00000O2O2M3N2L8IhRm0MllRO1lA4S>MiA7Oo0hL3M3O10N2O10000O1FPDcMQ<\\2:O2N10002N1TN_CW1W=N2M101O0000001O0000001O0000UEgNP8Y1mGlNP8[1fGkNX8V1dGoNY8S1cGSOZ8n0bGZORNQOR:g1iG@U8T1TGSOg8o0UGTOk8m0RGUOn8l0mFWOS9m0eFTN@9k9f1]FSNL5h9k1TFQN:3a9f2dF[MY9c2lFZMU9c2PGZMQ9d2SGXMn8g2UGWMl8g2VGWMl8g2VGXMj8g2XGXMi8f2YGXMi8f2YGmLhN7P:j2^GVMc8h2^GWMc8h2^GXMc8e2_G[Mb8c2`G[Mb8c2`G\\Ma8b2aG]M`8`2cG^M_8`2cG_M^8`2R2O1O100O10O010hEdMk7[2THfMl7\\2QHeMP8]2lGeMS8_2gGcMY8a2aGaM_8b2]G_Md8d2WG]Mi8g2RGZMn8j2mFXMR9R3cFoL]9T3[FQMe9U41O0O1DmEiKU:W4:01aNdE^MN8^:f1oFUNQ9j1WGnMk8P2S201O1O010O001O10O01O1O001O010O0000001O0000001O0000001OO0100000000O10O100000O100000O0100O100OTEXNb8h1]GYNc8f1]G[Nb8f1]G[Nc8d1]G]Nc8c1\\G^Nd8d1YG]Ng8f1UG[Nk8h1QGYNo8j1mFWNS9k1jFWNU9k1hFUNY9m1dFTN\\9n1aFRN`9P2[FmMkNJj:Z2VFoMTOCg:`2oEQNW:Q2YE]Ng:m2100O1N2F:[NaDFb;9hD[O[;d0iDUO[;k0iDmN[;R1hDhN\\;W1gDcN];]1eD]N_;e1n03L1O1O001O1O1O001O1O1N101O1O1O1N101O_O`CcN`cD@`;=bDBe;5^DIi;0YDNi;OZDOi;MZD1h;L\\D1h;KXD5P_Ob0I6001nFdK^7]4^HfKb7[4[HgKe7Z4ZHfKg7Z4WHgKi7[4UHfKj7[4UHeKk7\\4THdKl7]4RHdKn7]4QHcKP8]4oGcKQ8^4nGbKR8`4lG`KT8a4eGeK[8\\4XGPLi8S53oLoFMT9LYGKj8MdGJ_8YNcFT1[1:T8^NfFP1d19i7aNjFn0f1=b7`NnFj0i1b0Q8WOVHf0n7QO[Hk0h7nN`Hn0m:L4L4L4L3M4L4L4Lkje05oTZO2M2O2N2O1N2O00000O1001O000O2O000O2O3L3N3Hl^j1", "size": [480, 640]}, "area": 26304.0, "iscrowd": 0, "image_id": 15956, "bbox": [43.0, 83.0, 472.0, 254.0], "category_id": 183, "id": 20001005}, {"segmentation": {"counts": "0b3U;00O1O1O10000KiDgLZ;U3gDkL\\;U3300O1001O001O1O1O001O1O001OO11O002N0lDdLm:]3REdLm:c300PE]Ll:f3100001O1XEVLa:j3[EVL13b:Q4N2N2N1O001O0000001O0000O1O1O100@dEeL\\:[3eE]L1L[:h3fEWLb:h3_EXLa:g38001O1O001ON22NHUE_L0O01k:_3:_OlDZMY;g2fDUM^;i2fDTM[;m27MZDUMf;k230000O100000000001O00O12WDSMd;P301O1OO^DoL`;T301O2N00O10bDjL[;Y3000O1002N2N0hDdLU;_303M000mD^LQ;d30001O1O001O001O00O11O00KTE]Ln:d3QE\\Lo:a35LmDeLR;[35001O002N001kD`LQ;c301O1O001O2N00002N1OM32N00N200M3N21OMPE^LQ;b320000001O002N2N0000002N1O1O1OO100K51O1O000000O11O000000O11O00000000O1DSEnLm:Q3TEoLl:Q3TElLo:T3PEiLONR;Y3oDfL30n:Z3oDfLW;W3hDiL\\;R371O1O001O002N2N0000001dDfLY;\\301OO13M0000JjDkLV;o2jDQM2LV;P3kDRM[;o261ON2N200001O00001O0000003MO12N2_DjL];X302NO10000000000N2001O1O00O11OO13MOhDgLT;Z3jDgLV;^3jDaLR;d3N3M000000O1N2002NM3001O001OO100O100O100O11O00002nD[Ln:e3RE\\Lm:g30O1000000O1O10000O11O2NM3N2InDeLO000S;Y3mDhLY;V3jDiLV;X3iDhLW;W351O00O11OO1000bDjL[;V3eDkLZ;U3fDlLY;Z3O0hDdL0OS;d3N003MO1O11O1OO11O1O1OO100M31O002N3M2VESLf:Q4ZEPLa:V4M000000000000O11OO1000000UOaE\\Ma:c2aElLN3f:m2`EnLL1h:o2^EmL0Od:S3f000N21O00O11OO100001O2N2N1OO11O2N000dDhLY;]3NInDiLR;W37001ON20000O1001O00_OdDgM\\;X2cDfMOG^;b2eDeMNI];c2dDcM0K[;b2eDbM2JZ;d2dD_MMN5OZ;e2a0O100O11nC\\Mo;g2O0RDYMl;j2O1fDUMf:l2TEUMGOU;m2lDSM16S;m2kDUMT;m2jDSM0IS;a301O5K000000N200001O1OO1002N2N000VEVL3O_:n3aERLM0`:n3bEWL\\:j3bEWL^:Q4000O1001OO11O001OO1001O00001O1O1O1OO1000000O1000000O10000FdESL11[:k3eESL03[:b3gE[L42V:_3PFeLP:W3cEeL;NE4]:Y3eEcL72H1\\:R3gEkL]ECb:?\\EAd:`0\\E^Oe:b0\\E]O^OlNT;i1^E[Ob:f0^EZOa:f0`EXOa:j0^EVOa:k0_ETOa:l0aEPOa:Q1^EQO`:P1`EPO_:Q1aEnN_:S1aEkN`:W1bEeN^:\\1cEbN]:^1eE`N[:`1fE_NZ:d1eE[NZ:g1eEWN\\:i1fEUNZ:m1fEPN[:R2eEkM\\:U2S11O3M1O1O2N0000O1O1O10000O1O1000000O100O11O002N2N1O1O00001O1]D]MP;S32002N1O1O1O001O1O1O00O100O1O1O10000O11OO1MeDjL[;U3fDlLY;S3hDnLW;R3jDlLW;T36001OO1K`DQM0O`;P3`DPMc;P3200VOcDoMK0h0Kn9n1iESNC0LOk00VO2a:j1XGWNUN03N^:g1ZG[NVN6i:JVES1n1ZOR9e0mF]OUN^On:o0lFDVN^OR;j0gFIVN_OW;b0cF8`9B_F`0f9[OYFg0f9ROcD0e1P1j9mN^FR1c9nN\\FQ1e;0O2UMmNPHS1d7mNmE5[2P1i7mNiE7MHU2W1V8lNfE:a1B_N04\\1W:hNbEL1a0]1\\1P9oNdEUOQ1P2[9RO^FS1b9ROSFT1m9k10000000001O2N000000O12N000000O100000000", "size": [471, 640]}, "area": 70015.0, "iscrowd": 0, "image_id": 16010, "bbox": [0.0, 0.0, 640.0, 145.0], "category_id": 106, "id": 20001006}, {"segmentation": {"counts": "T7g0g0^5]6bJcI^5]6cJbI]5^6aJeI^5[6cJcI^5]6cJoHZO>S6c6cJnHZO`0S6a6dJnHYOa0T6a6gJ_IX5a6hJ`IW5`6iJaIV5_6jJdIS5\\6lJdIU5\\6kJcIV5Y6nJgIR5X6PKkIl4U6TKiIn4W6RKeIR5[6oJ[IQOJR6k6mJSIZO0j5m6b1000000000000O11O00000YHSI00a7n6^HRI10a7Q7^HPIa7S700000000000O100000000O1000000O10000O100001O00O100000000000000001OO100001O001OO100001O00000000O100000gHoHH2m6o6[IoHG5l6l6[IQII4k6k6\\I^Ia6b6_I\\Ic6d6]I^Ia6b6_IaI^6_6bI`I_6`6aI`I_6`6aI`I_6`6aI`I_6`6aI`I_6_6bIaI^6_6bIaI^6_6bIaI^6^6cIbI]6^6cIaI^6`6bI]I`6c6UIPI>7^6i6TIPI`02_6P7bInH_6R7c00000000000001O00000000000000000000000000000000000000O1O1002N00000000N22N000000000000000000O11O00O100001O00O10000000000000000000000000000001O00O11O0000000000000000001O000000000000001O000000000000001O000000001O000000000000000000000000000bHiH\\7W7dHjH[7Y7000O1000dHgHZ7[70000000M300000000001O0000O100000000O100000000O100000000NaHlH_7P7aHRIa7n6`HQI`7o6`HPIa7Q720000N2O]HRI_7n6^HWI`7P700000001O001O00001O0000001oIhHa4X7^KiHb4X7[KiHnNO^5X7cKlHkNNb5V7bKlHkNOd5V7_KQId4o6YKPIPOId5W7XKQISOLe5S7WK[Ij4f6UKYIl4g6TKUIP5k6PKSIXODb5Y7VKRIVOIc5V7RKeHZOf0d5e6QKZIU5f6kJdH[Ob0k5j6mJUIT5k6kJTIW5m6hJRIY5n6gJPI[5P7fJnH[5S7eJiH^5W7bJeHb5[7^JeHb5[7_JdH^OMk5_7dJgH@2e5X7jJdH@8e5T7mJ`H]O9l5W7jJVIk4k6SKVIm4j6SKjHZOHi5^7lJjHZOLh5[7mJSIR5m6nJmH^ODb5_7oJlHDC\\5b7oJjH]5V7cJjH]5V7cJjH]5V7cJjH]5W7bJiH^5W7bJiHEE^5b7mJiHBI`5^7mJiH_OLf5[7kJnH[5S7dJkH^5U7bJlH]5U7bJlH]5T7dJlH[5T7eJlH[5T7fJoHV5Q7lJoHR5Q7mJ[H^Oc0d5R7nJ]H_O>c5U7mJSIR5m6nJcH@3c5[7lJdH@Oe5]7iJPIY5P7gJiHBBj5e7dJfHBHj5b7cJmH^5T7aJjHEAf5e7fJfHDHf5b7fJnH[5R7eJdHCIk5c7bJdHe5\\7\\JbHe5^7\\JbHc5^7^JaHb5_7_J`Ha5`7_JaH`5_7]JeHb5[7]JfHc5Z7^JeHb5[7^JeHb5[7SJXH6=g5[7SJXHM082R6g7hIYHd6g7\\IYHd6g7[IZHU12S4d7hJZHS14U4b7hJZHR18S4^7kJZHQ1>o3^7oKfHo3Z7PLoHh3Q7nKVH]Ol0c4o6nK\\IQ4d6nK^IQ4b6nK`IQ4`6nKbIQ4^6nKcIR4]6mKcIT4]6kKdIU4\\6jK_I\\4a6cK\\Ia4a6UKSH9U1GmNn4j7_KTIk4l6UKRIm4k6VKSIl4o6QKQIP5o6PKQIP5o6PKQIP5o6PKQIP5o6PKSIn4n6QKVIk4j6UKmIT4S6lKmIT4S6lKmIT4S6lKmIT4S6lKmIT4S6lKnIS4R6mKhIY4X6gKQIP5o6PKoHR5Q7nJoHR5Q7nJoH9VOP4k7gKRI4TOV4j7fKVIOQO[4i7fK\\IGmNc4g7fKgIZ4Y6fKgIZ4Y6fKeI\\4[6dKQIH_Oe4a7bKoH3VO\\4k7aKoHR5Q7nJnHS5R7mJnHS5R7mJnHS5R7mJnHS5R7mJnHS5R7mJnHS5Q7nJoHR5Q7nJnHS5R7mJnHS5R7mJnHS5R7mJnHS5R7mJnHS5R7mJnHS5S7lJmHT5S7lJlHU5T7kJlHU5S7lJmHT5S7lJnHS5R7mJPIQ5P7nJRIQ5n6oJTIo4l6QKVI8nNo3l7iKXI5nNQ4j7jKYI2POS4g7kK[INPOW4f7jK\\IHSO^4a7jKmIV4S6jKkIX4U6hKiIZ4W6eKjI[4V6eKiI\\4W6dKiI\\4W6dKoHIIc4X7dKQIJDb4[7dKSIJ@b4]7eKTIo4l6RKUIl4k6UKVIi4j6YKjHACT5c7\\KlHA_OQ5e7]KQIBXOo4g7`KTI@TOn4h7cK^H7GV4k7cK_HX5b7gJ_HX5a7hJ`HW5`7iJ`HW5`7iJ`HW5`7hJbHW5^7hJcHX5]7iJbHW5^7gJRHC`0f5^7gJRHC`0f5]7hJeHX5[7hJeHX5[7jJcHV5]7jJcHV5\\7mJbHS5]7mJdHS5]7mJbHS5^7mJbHS5^7mJcHR5]7lJeHT5[7nJcHR5]7nJcHR5]7lJeHT5[7lJTH_O?e5]7nJcHR5]7lJTH_O?e5]7lJeHT5[7jJgHV5[7hJeHX5\\7fJeHZ5[7fJeHZ5[7eJfH[5Z7fJeHZ5[7gJdHY5\\7hJdHW5\\7kJbHU5^7kJbHU5^7kJbHU5\\7mJdHS5\\7mJdHS5\\7mJSH_O?d5]7PKdHo4]7PKcHP5]7PKcHP5]7PKcHP5]7PKcHP5]7PKcHP5]7PKcHP5]7PKdHo4\\7QKdHo4\\7QKdHo4\\7^JSHa0a0Q5\\7^JSHa0a0Q5\\7^JSHa0a0Q5^7nJcHR5]7nJcHR5\\7oJdHQ5]7nJcHR5]7nJcHR5]7oJbHQ5^7oJbHQ5]7oJdHQ5[7PKeHP5[7PKdHQ5\\7oJeHP5[7PKeHP5[7PKeHP5Z7QKfHo4Z7QKfHo4[7PKeHP5[7PKeHP5[7PKeHP5[7PKeHP5[7PKeHP5[7PKeHP5[7PKeHP5[7PKeHP5[7nJSH@b0b5\\7dJRHOf0]5X7bJTH0e0^5Y7_JSH0g0a5Y8000001OO1001O0000000000000000O11O000000000000000000000bMlFYOT9g0lFYOT9g0lFYOT9g0lFYOT9g0lFYOT9g0mFXOT9g0lFYOT9e0PGYOP9g0RGjM55l8l1RGlM5YOHe0Y9[O`Fn01`0>UO>NP9MYF:JYO22NN0Oh0b09^OPO9S:JWF7[17^OGf;6ZDIk;3UDL^=MN2002NYb87`]G6J4L1O3gBd0YOjN`;d0lDY1n:jNhDb1S;R1kD`LQ;`3oD_L9=Q:V3oEQMj9o2nE]L3g0LCf9Y3[F^L2R10mN11V9f3fFYL1T10mN07l8IYGh3K[MOnN16l8IWGj3LZM0XOm8DVGa5i8`JVGa5i8`JUGb5k85O10000O1000000000000O100O11OO10000O100O1001OO1001O0000", "size": [471, 640]}, "area": 130319.0, "iscrowd": 0, "image_id": 16010, "bbox": [0.0, 221.0, 640.0, 250.0], "category_id": 124, "id": 20001007}, {"segmentation": {"counts": "b3b3U;0O1O1O10000K\\LTEf3i:[LWEh3i:300O1001O0L5N2O1O001O1O001OO11O002N0eLkDS3W;lLjDT3\\;00iLdDS3_;1`DlL00Z;U3eDkL10Z;X3eDiL[;Y31jLdDo2\\;mLdD13P3c;N2N2N1N101O00000O2O0000O001O10OAZMoDf2Q;[MgD1Le2^;\\MaDm2];TMcDl2\\;7101O1O001ON22NHkLiD0O01U3U;;^OaLeEc3]:\\L_Eh3_:\\L^Ee3c:8LoK`EQ4`:4OO10O101O00000001N10O12lK^Eo3e:01O1OOSLZEk3i:01O2N00O10WLUEf3n:00O01002M3N0_LmD_3U;0kD`LV;]3jDcLV;_30aLjD]3X;0001O1O001O010O00O11O00KgLjD[3W;dLiD\\3T;5L`LRE_3n:5001O002N001^LmD^3V;01O1O0O2N3N02N02N1OM32L22L200M3N21OMcLkD^3U;200000O20O02M3N0001O02M2O1O1OO100K51O1O000000O11O000001N11N11O00000O1DfL[EZ3d:gL\\EY3d:gLYE\\3g:cLVEON_3l:bLSE30[3m:bLSEe3i:ZLWEj3d:71O1O001O002O1N0000001ULUEh3m:01OO22M0000JZL[Ef3_:ZLaE2Lg3_:ZLcEl3^:61ON2N200001O00001O000000aEjK`:S4`EnK^:V42N2kK^EP4e:02NYERLd:Q40000000M30N2001O1O01N11OO04MOVLYEf3h:XLYEh3l:XLSEd3R;M4M000000O0O2002NM30NlDaLU;Z3kDhLW;X3jDgLW;X3iDgLW;[320O10N10iDfLS;Z3jDkLS;]31O00002_LjD^3U;bLlD]3W;1N10001O0O1O101O0O20O2NM4M2IYLZEO000h3d:XL]En3a:UL^El3b:SL^Em3a:51O01N11OO1000kKaES4^:mKcER4]:nKdEQ4b:0OoK]E0Ol3k:N003MO2N11O10N11O100OO101L31O002O2M2XLQEd3S;\\LnD_3X;M01O001O00000O11OO1000001TO`L]Fb3b9`LmEN3g3l9_LoEL1i3n9]LnE0Oe3R:g0O0N21O00O11OO100001O2N2N1OO1oE_Km9`4SF`KM0P:_4RFcKn9]4RFcKn9NQF\\40gKT:W4lEiKm92RFU41iKm9^4SFbKm9d41ON201O0O1001O00_OZKQGf4n8YKPGOGh4X9[KoFNIg4Y9ZKmF0Kb4O[KY93lF2J`4^9^KeFMN5O`4_9>23N0O11iJaFT5b9O0mJ^FR5d9O1`K[Fl3f9nK[FGO[4g9fKYF16Y4g9eK[FZ4g9dKYF0IY4[:01O5K000000N200001O1OO1011N2N000oK]E3Of3g:ZLYEM0g3g:[L^Ec3c:[L^Ee3j:O10O1001OO11O010OO10O2O00001O1O1O1OO101O000O1000000O10000F]LZE11b3d:^LZE03b3[:`LbE42]3X:iLlEW3P:\\LlE;NE4d3R:^LjE72H1c3k9`LRFUO>Z3d5aLeI:JYO22NN0Oh0b09^OPOf3f6]LdI7[17^OT3Y8iLgGW3]8eLcG[3o9NM20O3N4K1O1O10000O11OO1MeDjL[;U3fDlLY;S3hDnLW;R3jDlLW;T360VJkL2V3MkL2T3FmLgJ1b5m2ZJQM0O]53dJ3d5j2[JPM`5=4c2LaMbJIR5f2^2fN]O]OUN^Oc3e4[L\\Ka2n0[ODVN^Oc3d4[L[K9=e1>MIVN_Oc3d4eLmKc11O8g1j3_LYK3g0LCd156`0h1h3_LZK2R10mN11Y194il0NUSO2N7H1O1O1O000O2N11ON@mA`0S>@mA`0S>2002N002NO11O0001M22N00N20_OlA?V>0NAlA?T>2N200O100O11O1O101N000000000_OlA?V>1O0000000000001O000000000O1000000001O00O1000O11O00000000000000000000000N^OoAb0h=^O]Bf0a=\\O^Be0a=\\O\\Bg0b=80000010N1001O00000001OO11OO10O11O0000000001O00000000000000001O2POYBl0m=TO]B2I3i=MXa;Na_D1F1iA1V>0gA3X>7M4N3C_OYBN1d0a=]O_Bl0a=500000000000000000G_B\\Oa=d0_BZOc=f0]BYOd=f0]BYOd=f0]BXOe=h05O10O10O2OO1000000000O100O1[OPBd0Q>O01O10O100O1001OO1001O000nG", "size": [471, 640]}, "area": 3894.0, "iscrowd": 0, "image_id": 16010, "bbox": [441.0, 257.0, 199.0, 38.0], "category_id": 178, "id": 20001009}, {"segmentation": {"counts": "f`Q42d>0O2dAOQ>3lANT>1lAOU>610jAKl=6SBMm=>1M3M3NoAFi=;SBHi=LVBb01]Og=0XBb0R>O1N101N2O2M3K4O101OdAMQ>4PB4i=KUB9Q>I8a0@H9LkAIQ>8mALQ>8PBDo=:VBEg=:^BDa==<000000000oAEf=:XBIg=8TBHQ>962N1O10O0103N0M\\ORBa0n=ARB>l=GSB6m=KUB1l=0SBOl=3SBF2No=:PBHP>?1MQBCk=:TBHm=`01FQBGT>96O1O1O10O1L3O11O000GgA3^k1OPcN105K6I4M9^OWOeBl0X=;N2N2N2NO11ON2L4N2H9L4N2O00100001O2N4Lg0YO00000000MUCZNk3iALdmh2", "size": [471, 640]}, "area": 4312.0, "iscrowd": 0, "image_id": 16010, "bbox": [281.0, 260.0, 166.0, 65.0], "category_id": 183, "id": 20001010}, {"segmentation": {"counts": "\\h^2270T=2kBNR=6jBNS==O1000O1000001O0O10O100000O101O1OO11BhB006]=IhB2`=Noo58joI8H00000000000O1000000000000L@PC`0n<6G90000000000O11OO1001O0000000001O0:oNTCb0\\=E4L00O1001O000000000000000000001O00001NkXl4", "size": [440, 640]}, "area": 1327.0, "iscrowd": 0, "image_id": 16228, "bbox": [183.0, 101.0, 93.0, 42.0], "category_id": 96, "id": 20001011}, {"segmentation": {"counts": "f^a4a0g1Bf9f1lDaNR;S2O1O13L3N2QN`DG5d1];\\N^D3?[1W;bNTET1l:lNTET1g;oNaCk0^K]P33ZbL3Z=L_j`7", "size": [440, 640]}, "area": 255.0, "iscrowd": 0, "image_id": 16228, "bbox": [48.0, 205.0, 31.0, 31.0], "category_id": 123, "id": 20001013}, {"segmentation": {"counts": "g]T71f=1N2O1N2N202N000003M3K\\o5NhPJ2M100O100NL`B4_=31O0000000000NJbB6]=3001O00002N0000O12NNKaB5_=21O1O00O1O101O0O1O1O1O1O1M300000000O12NN200001O00O12NYDAU:?kEBT:>lEBS:?lEBS:?mEAT:>lEBT:>hEFW:;dEJ\\:E^D?Q11c:O[E3d:NZE4g:KPE=P;EdDf0\\;ZOaDi0_;WO^Dl0b;e0001O[DPNa;Q2_DoMa;T200000004LVNVEc0Q;XOPEg0Q;YOoDg0Q;YOoDf0R;YOoDg0Q;YOoDg0R;WOoDh0S4", "size": [440, 640]}, "area": 2042.0, "iscrowd": 0, "image_id": 16228, "bbox": [531.0, 217.0, 109.0, 75.0], "category_id": 124, "id": 20001014}, {"segmentation": {"counts": "\\_d4115X=KkB?P=BmBi0l<01NVCZOfR=CPC;ml0V6[4]IiJ=k0W6\\4PJcKQ6\\4PJaKS6_4mIaKS6^4nIbKR6^4mIcKS6\\4mIeKS6[4mIdKT6[4lIhKR6X4nIfKT6Z4lIfKT6Y4lIhKT6X4kIjKT6V4nIhKR6W4PJgKQ6Y4PJhKn5X4SJgKm5Y4SJgKm5Y4SJfKn5Z4RJeKo5Z4RJgKm5Y4SJgKm5Z4RJeKo5[4QJeKQOZOl6P5TIPKn0h0n5W4UJhKl5X4TJiKk5V4aIRK5h0[6V4`IRK4i0\\6T4aISK2j0]6S4aISK0l0_6P4bITKNm0`6o3ZITKO06o0`6l3\\IUKN14n0c6l3\\IUKL23n0e6j3]IVKK4On0i6g3^IWKJ\\1h6]3^IXKI[1i6\\3_IYKH[1i6]3]I[KFZ1m6_5L000000001O", "size": [440, 640]}, "area": 74266.0, "iscrowd": 0, "image_id": 16228, "bbox": [0.0, 0.0, 640.0, 234.0], "category_id": 169, "id": 20001020}, {"segmentation": {"counts": "`V3d1Sb;]OcDc0_;POkDk0DnNb;2nD5]O?5ZOa;0oD5^O=R=M4N2O000O010O1N1O2N2M4Mbn2c0iPM9I7H4fCSOc;a10000O1001\\NZDT1h;eNaDW1Rj;UOZD8O2K1^Kc:EeEn0^O@LCl:1iEi1W:XNhEh1W:YNiEg1OUN`95aFS1ZOWOc0Ca95aFc1L[Nb9c0RFQ1:^Nd9[1mEB>TOd9\\2oE^M;9e9_2YFcMf9_2WFdMh9_2SFcMl9V3O0O2O001N1I8L301O0O101O001O0O2O001O001N101O001O000O2O001O001N101O001O0O2O001O000O2O001O001N101O001O0O2O001O001N10001O001N101O001O0O2O001O001N10001O000O100000O10O1000000000O0100000000000O100000000000000O1000000O100O100O100O1O100O100O100O101N1O100O100O100000000000000O100000000000000000000000000O1000000000000000000TN\\61VIi1b0TNX63VIf1g0UNS65VId1j0VNo56YI`1m0XNj58YI]1R1YNe5:YI[1V1YNa5;ZIZ1Y1YN\\5>[IZ1Y1WN\\5?[IZ1[1VNY5`0]IY1\\1UNV5b0_IY1^1RNS5e0_IZ1`1nMQ5h0_IZ1b1lMo4i0`I[1d1iMk4m0aIZ1f1gMi4o0aI[1m8eNTGZ1l8fNTGZ1k8gNUGY1^1gMU5P1]IZ1\\1gMW5o0]IZ1[1iMW5n0]IY1[1kMV5m0`IW1Y1nMV5k0aIX1W1oMW5i0bIX1V1PNX5h0bIX1T1SNY5f0\\I]1Z1oMX5h0nHg1h1cMY5g3fJZLZ5f3eJ[L[5f3bJ[L_5e3_J\\Lb5d3]J\\Ld5Q1QIe0Y1ZNh5b0^IU1g0ZNl5`0_IU1c0\\No5?^IU1a0\\NS6>]IV1>]NW6<[IX1<[N[6d8B\\GNS9IPE5n1NU97kFFW9;S2GhB2W=80HiBOV=2jBNV=2kBLU=5kBKT=7kBIU=6mBIR=8nBHaX3", "size": [440, 640]}, "area": 64040.0, "iscrowd": 0, "image_id": 16228, "bbox": [7.0, 130.0, 626.0, 223.0], "category_id": 183, "id": 20001021}, {"segmentation": {"counts": "k7=o:100001N01001N02O01O00000N2M5KjX\\5", "size": [365, 500]}, "area": 185.0, "iscrowd": 0, "image_id": 16249, "bbox": [0.0, 250.0, 16.0, 14.0], "category_id": 125, "id": 20001022}, {"segmentation": {"counts": "0k7=T3100001N01001N02O01O00000N2M5Kkb44S]K2O1N2O0O2O10O0101N3N3L3N3A[OnEh0l9_OPFe0g2TOT4`1eKeNW4b1aKcN[4c1]KcN_4d1YKaNb4f1YK]Nc4k1XKUNe4R2VKnMh4Y2TKgMj4`2PK`MP5e2kJ\\MU5g2hJXMX5l2dJfLFEe5h3cJbLl5g1dICSL:fNk08_NQ55SLa0eNi09cNP5MULf0bNi0oNe4XO^LR1_Nf0a0SOT68[Ic09aNEe0d67_Ia05H[6H`I?1M_6E`I8\\O`1c6XOdIPO?4YOf1d6UOfIQOd0m1f5ROfIQOb0o1h5oNhIRO:U2m5iNjIRODi2a6UNmIR2S6nMbIPO2R3\\6mMbISO2P3[6lMdIUO1n2Z6nMfIUONm2\\6mMiIVOJl2]6nMjIWOHj2^6nMlIYOEi2^6nMnIZOBh2_6nMRJYO_Oh2_6oMSJXO_Oh2^6oMVJUO^Om2[6nM`JQ2_5oMbJQ2^5nMdJ]1ROUNZ6>eJZ1UOWNU6>gJY1SOmMJ;[6`0iJU1SOQNK8Y6a0jJT1TOSNK6V6d0lJP1UOVNJ5T6e0oJn0TOYNJ1S6h0PK`1nNeMS6k0QK_1Y5aNhJ_1W5aNiJ`1W5^NkJc1T5\\NlJd1T5\\NlJj0bNUOb60mJj0eNSO^61nJl0iNoNY64nJm0POiNR69oJm0XObNh5`0QKn0XOaNh5`0RKl0YOcNe5`0SKl0o5ROSJm0n5QOTJn0n5nNVJP1l5mNVJR1l5jNWJT1l5iNVJV1R8N1O1O1O2N4K4M3M4L3M;Eo\\;4bbDgGBY8=hGCY8;iGCX8=hGCX8m3NYLm0GZ1?]MC`0n3J[Lm0F`1;XMEc0P4D]Lo0Bh18QMIe0Q4@^LQ1_Oo16jLKh0S4WOcLV1YOV22dLOj0Q5X4oJhKR5W4mJjKS5S4mJmJ0Q1T5R4lJoKV5S55K5hJ`JY4f5_K\\Ja4W62N10O01O1N1O2O1N101N2O1N101000O10000O10001O1N2O2N1O1O1O2ZK[J`3ARLn59gJd3YOTLQ62lJi3ROVLY7h3fHZLZ7l33M0001O0000O101N1N2000000000000000001O0O100000000000000000001O000000000000000001O0001O01I6N2N2N3M2N2N2M4L3M3O101N1O1O1O00100O00jNfI[MY6h2jISMU6o2oIkLQ6X3RJcLm5d3PJYLo5o3jIPLV6R4jImKU6T4mIjKR6\\3iIRM7_OQ6a3jIlL7An5f3lIfL8Bk5k3oI_La6d3b03M4L6J5K^LXIg10QNg69ZIe11QNc6;\\Ih1OkMd6>^I]2a6dMbIY2LcL^6U1iIU2IfL]6V1nIP2DkL_6T1PJn1AnL_6T1SJb1@aM]6n0VJ]1_ObM\\6S1UJY1_OdM]6S1TJX1@dM\\6T1UJW1@dM[6n0_ITOg0Y2_OeM[6m0_IVOh0X2\\OeM_6T1VJV1[OfM`6S1VJV1YOhM_6M^IT1j0W1YOhM_6T1YJS1WOjM_6T1[JQ1VOjM_6V1\\Jo0TOlM_6V1^Jn0ROlM`6V1_JT1`5mNaJf0POXN_6S1aJc0ROYN^6S1aJb0ROZN^6T1aJ`0SO[N\\6U1aJ?UO[NZ6V1bJ=VO\\NY6V1bJ2M_6F_I;02a6D_I804a6E`I5N8b6D`I2N52_N`6[1`ION9g6I[ILNJZ1e6ZO`IQO`09[O]1e6YOaIQO>7]O`1c6XOdIQO?M^Ol1_6UOfIQOd0n1e5QOgIROa0o1h5nNiISO9T2n5iNjISOCh2b6UNmIS2R6mMcIQO1R3\\6lMcITO1o2\\6mMcIUO1m2[6nMfIVOMm2\\6mMiIVOJl2]6mMkIXOGj2^6mMmIZODh2_6nMoIZO@i2_6mMSJYO_Oi2^6nMTJXO_Oi2]6nM_JR2a5nM`JQ2_5oMbJ_1QOTN\\6=dJ\\1SOVNY6=fJZ1UOWNU6?fJX1TOmMJ;[6`0iJU1SORNJ8Y6`0kJT1TOTNJ6V6c0mJP1UOWNI4U6e0oJo0SOXNK0T6i0oJ`1nNeMS6k0QK_1Y5aNhJ`1V5_NkJb1U5]NlJc1T5\\NlJe1S5[NmJj0cNUO`6OoJk0eNSO\\61oJl0jNnNX65nJm0WObNk5?PKn0WObNh5`0QKm0YOcNf5?SKl0YOcNe5`0SKl0o5QOTJn0m5POUJo0m5mNWJQ1k5lNWJS1k5jNWJT1R8O2N1O1O1O3M3L5L3M3M7Ibh;MVWDPH_OQ8?TH]Ol7c0WHYOk7e0ZHWOg7g0]HVOc7i0bHROX43]Mi0_NQOT49[Me0dNmNm3OlJa0a2a0P4LoK0Q48jKFU4SOB2O0010Mo2l:aMeE`2Y:aMgE_2V:eMiE[2W:dMjE\\2U:dMlE\\2T:dMlE\\2S:cMoE^2o9bMRF^2l9cMUF]2j9eMUF[2j9cMaE\\Of0Q3h9cM[F]2d9bM^F_2`9aMaF_2]9aMeF_2Z9`MjF^2V9aMlF^2W9^MkFa2lN[Mn91XGS3f8kL[GY3b8eL_G[3a8dL`G\\3a8bL`G^3a8`L`G`3a8`L^G`3c8aL[G_3e8aL[G_3f8aLZG^3g8`LZG`3S:0O10000O1O1O1000000001O00000000000000001O00O1N2000000001O00O10000001O0000000000O1O1@^LaEc3^:_LYEN1d3f:?O11OO11OO10000002NN2O11O1OAjKPFZ4P:fKnE\\4Q:eKlE^4R:dKlE^4T:700O1O11ON2000000000000HTK\\FQ42XLHG04j9MZFn39QLM3`9NWFQ4h0QLP9U4RGhKh81]FZ4a:3ON003M2O01000O100O1LYEoKg:Q4ZEoKe:P47O0O100O@XLjEg3X:YLgEg3W:\\LhEc3W:d01N0100010O0000000hMgEIY:1oEJT:3PFIS:2SFHR:1UFLn9M[FLj91[FIm90WFAZ::hEC\\:7jE]Oa:a>20O0000000000O2O000000000O101N1K5004L0001N1000000O10001N10000000N3N2M3_OcA70H01_>OaA010O30M00e>0\\A10OYR60b\\J0TA023X4Ok59kEE00S45Q6;jIKS66PF_Oh3>X66hIJW67iIIW66jIJW65jIKU64lILS65mIKS64nIMQ63PJLP63QJMm55SJKn54SJKm54TJMk53UJMW5FUG=e3MU5JSG9i3MR5OPG4o3Mo4i0QKVOP5j0PKUOQ5j0QKROjKIU9U1QKQOS5n0nJPOiKKY9U1PKnNR5R1oJkNfK0[9T1oJmNR5T1]401N10000O10002N1O1NPC@c;?WDGi;8XDHh;8XDHg;8ZDHh;6XDJg;7YDJf;5\\DJd;6\\DJd;4^DLb;3_DMa;2`DN`;2`DN`;OcD2\\;L_C@U1c0];LfD3\\;LdD3_;KbD3`;L^D4iNAi<;^D2n;DTD?00bAA[>>fABZ>>fABZ>>fABZ>>fACY>=gACY>?eAA[>?eAA[>b0000000WD^OS9c0hFBW9>_F\\OnM00;b;:^FNa90bF0[93fFL[93eFM[93fFLZ94fFLZ94fFLY95gFLY93gFM_9MaF3d9H\\F8e9D^FlDAV;?mCjNj0g0Y;?mCkNj0g0W;a0iD_OW;a0iD\\O[;b0fD@X;`0hD@X;?iDBX2_O`5P1XH@X2HY5g0`HAX2GX5g0bHBU2GY5g0bHBU2HY5d0cHDT2HY5d0cHES2G^5?`HJR2Gb5:]HOR2Ga59]H0R2Ga58_H0P2Ha58_H0P2I`56aH1P2H_56bH2o1H_56bH2o1I^54dH3n1I^54dH3n1I]54fH4m1G]54hH4k1HnMLo58XJ3l1IZMLEk0R6]OTK3l1b2`2[MdK3l1c2^2ZMgK3k1c2^2YMhK4j1d2\\2YMjK3k1c2Y2[MmK2j1e2W2YMPL1i1e2Y2XMoK3h1e2Y2WMPL4h1d2X2XMPL4h1d2X2WMQL5g1d2X2WMQL5g1d2X2VMRL6f1d2X2VMSL5f1d2W2VMTL6e1d2W2UMUL7d1d2W2UMUL7d1d2X2SMUL:b1c2Y2SMUL:c1b2X2SMVL;b1b2X2nL[L`0]1d2[4[MfKf2X4ZMhKf2X4[MgKe2Y4[MgKe2Y4[MgKe2Y4[MgKe2Y4[MhKd2Y4[MgKe2Y4[MgKe2Y4[MgKe2Y4\\MgKc2Y4]MgKc2Y4]MgKc2Y4]MgKc2Y4]MhKb2Y4^MfKb2Z4_MeKa2[4`MdK`2\\4`MeK^2\\4bMdK^2\\4bMdK^2\\4bMeK]2\\4bMfK\\2Z4dMhKZ2X4fMiKY2W4gMiKY2W4fMjKZ2V4fMjKZ2V4fMjKZ2V4fMjKZ2W4eMiK[2W4eMiK[2W4eMiK[2W4eMiK[2W4eMiK[2W4eMiKZ2X4fMhKZ2X4fMhKZ2Y4eMgK[2Y4eMgK[2Y4eMgK[2Y4eMgK[2Y4fMfKZ2Z4fMfKZ2Z4eMgK[2Z4eMeK[2[4eMeK[2[4eMeK[2[4eMeK[2[4fMdKZ2\\4fMdKZ2\\4gMcKY2]4gMcKY2^4gMaKX2`4jM^KV2b4lM\\KT2d4lM\\KT2d4mM[KS2e4mM[KS2e4mM[KS2f4lMZKT2f4lMZKT2f4mMYKS2g4mMYKS2g4mMYKS2g4mMYKS2g4mMYKS2g4mMYKS2h4lMXKT2h4lMXKT2h4lMXKS2i4mMWKS2i4mMWKS2i4mMWKS2i4lMXKT2i4kMWKU2i4kMWKU2i4kMWKU2i4kMWKU2i4kMWKU2i4lMVKT2j4lMVKT2j4lMVKS2l4kMUKU2k4lMTKT2l4lMTKT2l4lMTKT2l4lMTKT2l4mMSKS2m4mMSKS2m4nMRKR2o4mMQKS2o4mMQKS2o4mMQKS2o4nMPKR2P5nMPKR2P5nMPKR2P5nMPKR2Q5mMoJS2Q5mMoJS2Q5mMoJS2Q5mMoJS2Q5mMoJS2Q5mMoJS2Q5mMoJR2R5nMnJS2R5kMoJU2Q5kMoJU2Q5kMoJU2Q5jMPKV2o4kMQKU2n4lMRKS2n4oMQKR2m4oMSKP2m4QNSKo1l4RNTKn1k4SNUKm1j4TNVKl1i4UNWKk1h4VNXKj1g4XNXKh1g4YNYKg1f4[NYKe1f4]NYKc1f4^NZKb1d4aN[K_1d4bN\\K]1d4dN\\K\\1c4eN]K[1b4eN_K[1`4gN_KY1`4hN`KX1_4iNaKW1^4iNcKW1\\4jNdKV1[4kNeKU1Z4lNfKT1Y4mNgKS1X4nNhKR1W4oNiKQ1V4POjKP1T4ROlKn0S4SOmKm0R4SOoKm0P4TOPLl0o3UOQLk0n3UOSLk0l3VOTLj0k3WOULi0j3XOVLh0i3YOWLg0h3ZOXLf0V3ZMRJQ2h2e0R3^MUJn1i2d0Q3`MTJl1l2d0o2aMTJl1m2c0o2bMQJm1P3a0o2bMPJn1Q3`0P3bMmIo1S3?P3bMlIe1OYNU3a2o2BPJkMQ3c2Q3_OPJiMKOT3i2S3[O]Me0d2ZO\\Mf0e2XO\\Mh0d2WO]Mi0c2VO^Mj0b2VO^Mj0b2VO^Mj0b2VO^Mj0b2VO^Mk0a2TO`Ml0`2TO`Ml0`2SOaMn0^2QOcMn0^2TO`Mm0_2RObMl0a2SO_Ml0b2QOaMl0SLZM]6g1cMo0_2PObMP1_2mNcMS1]2iNaIaNS4f2\\2gNiMY1W2fNjMZ1X2dNhM^1U2cNkM]1U2bNlM^1T2bNlM^1T2aNmM_1S2`NnMa1Q2^NPNb1P2_NoMa1Q2^NPNd1P2YNQNg1n1YNSNh1l1WNUNi1k1UNWNl1h1RNZNn1f1PNTJSOB2O0010Mf3m2d2oMVJEV3\\2d2nMWJFU3\\2d2kM[JHQ3]2d2kMZJIR3\\2c2kM[JJR3[2c2kM[JJR3Z2c2lMZJLS3X2c2kMZJNS3W2c2iM[J1R3U2d2iM\\J1P3V2d2hMZJ]O\\Of0f3U2e2fMYJ8R3R2e2eMXJ;S3P2d2eMYJPIh0e3nNW3:TIi0d3mNX38VIk0b3mNX3KWI]O0k1a3mNX3G\\I@Kl1a3mNX3AcIEDm1a3nNW3_OfIEB01d1`3XOW3_OgIDDM5a1Z3^OU3AjIBO^1S3@S3@lIANo0AYOS4LiK4i67mI@Mo0CQON1_;?hE?g:AYE>h:CXE=g:CXE=i:CWE>h:BXE=i:CWE=i:CWE=i:DSE?m:AoDe0o:[OQEc0Q;]OoDb0R;_OmDb0R;]OkD^OTOV1o;ZOPE@QOg0OAU<4mDEmNO0g01_OV<0SEMfNc02]Oj=f0XBXOj=h0700O1O11ON2000000000hN]OSDc0m;@nCJRO>0Hd4J\\K0Y86dHJSO>1F]46i3NeH8UOA_4:f3NfH6i3O^3KiH0UOGh4>Y3LiH0o35X3KiH0o35W3LjHMQ47U3LeHE]O9h46U3MaHIB4h46U3LfHG\\O6j47T3KfHI[O6k46T3KgHHYO8l45S3LhH3U41S3LhH3U41S3LhH3U41S3LgH4V40S3LgH4V40S3KhH6T4OT3JiH7S4KY3LeH9R4I\\3LcH;S4@a32gH6Y3N1L3J6J6L4M3K5J6J6K5O1O10000000000kN_NkDa1T;`NRDMa0c1];_NmC6c0\\1Q1^Nd81fE8d0Y1R1`Nb8OhE9c0X1R1cNa8;\\FR1S1dN`8:\\FT1d0]NSOj1JROQ7n1oHQN8o0HROQ7n1SImM2U1KoNP7o1VIhM1Z1IoNP7o1VIhM1Y1JPOo6o1VIhM1Y1JkNE]OZ7g2VIhM1X1KgNIBU7g2VIhM2W1ImNG\\OX7g2WIiM1W1HmNI[OX7h2VIiM2V1GoNHYOZ7i2TIjM3T1HPOU7R2PIjM3T1HPOU7R2PIjM3T1HPOU7R2PIjM3T1HoNV7S2oHjM3d0]OWO;8V7T2nHiM4c09@f6R2nHkM4b09@e6T2mHjM5a0;@c6U2nHiM3b0>_Oa6V2PIiMNc0b0]O`6W2QIhMLd0d0^O^6V2SIhMId0g0\\O_6X2RIjM\\O]O5V1T9c1\\GZOd8f0]GZOb8f0_GYOa8g0_GYOa8g0_GYOa8g0_GYOa8g0_GYOa8g0_GYOa8g0_GYOa8g0_GZO`8f0`GZO`8f0`GZO`8f0_GYM^Oi1S9n0iGQOW8o0iGYNQOYO1IU9e2jGUNSOZO5Hn8i2jGeMQOK4N^9b2]GcMUOI4L^9h2]G]MSONo9e2nF\\MVOLm9h2mF[MWOLn9h2k1000002N001O1O1N2O1O1O1O4L4L8H1O3M2N2N3M2N3NO05K5J7J3L6J2O3M2G`AMc>1]AOg>LZA3i>12MiSj0", "size": [480, 640]}, "area": 22936.0, "iscrowd": 0, "image_id": 16439, "bbox": [405.0, 49.0, 179.0, 264.0], "category_id": 130, "id": 20001028}, {"segmentation": {"counts": "dUa0190H010^>0aA10O30M001^>3bAM10O2^>>O000O1001OO2O000001OO1010O0]OeA00?_>0OBbA1O0O100O100O101N10000O100O2O0O0100O010O001000O0100O010001N013M00000O100O100O10000O2O0N2O1O100M3NkNYBU1f=30001ON20EoNeBS1[=900O100O11ON2000000O100000O1O001OOO31N1002NN120N01O1O101UObB1_=NcB1\\=OeB0\\=OeB@L:b=D^B;5GL9a=E`B1NN026OL:h=DVB0419:W>O0O100G[A6h>O2KVA2j>NWA0m>0\\`S7", "size": [480, 640]}, "area": 3571.0, "iscrowd": 0, "image_id": 16439, "bbox": [36.0, 268.0, 118.0, 62.0], "category_id": 139, "id": 20001029}, {"segmentation": {"counts": "h\\o01o>1JO[A2c>8K6EAnA`0P>CmA?R>8MUOQBk0n=4NQOSBo0m=2NoNUBQ1k=2O1O10kNXBR1h=nNXBR1k=000O10000001OO10000O10000O10000O1M300O100O100O1000000O1N2O10000O11O1O00000000000000000000000000001O000000001O0000O1M30000000000000000000000006J`0@8UOlA:d>I00001O0000001O00001O0000Q\\k6", "size": [480, 640]}, "area": 3760.0, "iscrowd": 0, "image_id": 16439, "bbox": [66.0, 430.0, 105.0, 50.0], "category_id": 143, "id": 20001030}, {"segmentation": {"counts": "0f9Z5O11O0000000000O10000000000O100O1K5004L0000O10XNeFZLL^1_9U2nFhMR9T2SGkMl8U2TGlMl8S2UGcL]OOOU1_9X2\\GhMc8X2_GgMa8X2`GhM`8X2aGgM_8Y2aGgM_8X2bGhM_8W2bGhM_8V2bGjM_8U2aGkM`8S2aGmM_8R2bGnM^8R2bGnM^8Q2dGnM\\8R2dGnM[8R2fGnMZ8R2gGmMZ8Q2gGoMX8R2hGnMX8Q2iGoMW8P2jGPNV8P2kGoMV8o1kGQNT8o1mGQNl7QOkFm2Z1RNi7QOhF02m2^1TNf7R2YHQNf7P2UHUNi7m1THVNl7j1THVNk7k1UHUNk7l1THTNm7k1THTNl7l1THTNk7m1UHSNk7m1UHSNk7m1VHRNj7o1UHQNi7Q2WHoMj7P2WHoMi7Q2WHoMi7R2VHnMV7kNPHX3j0mMU7oNnGT3n0lMS7UOjGP3S1kMQ7k2oHUMQ7k2oHUMQ7l2oHSMQ7m2oHSMQ7m2oHSMQ7m2QIQMo6o2RIPMn6Q3PIPMo6Q3RInLn6R3QIoLP7P3PIkKhNR1X8S3PIkKhNR1X8T3RIlLn6T3RIlLn6T3QImLo6S3QImLQ7R3nHnLS7Q3mHoLT7P3mHoLT7P3kHQMU7o2kHQMU7P3jHPMU7Q3jHPMX7n2hHRMW7o2iHQMW7o2hHRMX7o2gHQMY7o2gHQMY7o2fHRMZ7n2cHUM]7l2bHTM^7l2aHUM_7k2aHUM_7k2`HVMa7i2_HWMc7h2[HYMf7f2ZHZMf7f2ZHZMg7e2YH[Mg7e2XH\\Mh7e2UH]Mj7d2UH]Mk7c2UH]Mj7d2VH\\Mk7c2TH^Mj7e2VHZMj7f2WHYMi7g2WHYMi7g2WHYMh7h2XHXMh7i2WHWMi7i2UHYMk7g2PH^MP8c2dGgKN00k1]8_2bGjM^8\\4N200O1002NN21OO10000001O00O10000O100N200N20XIjGf6X801O0000001nMZHhLf7X3jHXLV7h3RIPLm6R4RInKn6R4SImKm6S4SImKm6S4SImKn6R4RInKn6R4RInKR7n3nHRLV7k3jHTLW7k3iHULW7k3iHULW7k3iHULW7k3jHTLV7m3iHSLW7m3iHSLW7m3iHSLW7m3iHSLV7n3kHQLU7P4jHPLGLo5T4ZJPLTOLEk0R6Z3VKhNZ4X1fKiNX4X1hKhNX4X1hKiNV4Y1jKfNT4\\1lKfNR4Z1nKeNT4Z1lKfNT4[1lKdNT4\\1lKdNT4\\1lKdNT4\\1lKdNT4\\1lKdNT4]1lKbNT4^1lKbNT4^1lKbNT4^1lKbNU4]1kKcNU4^1kKaNU4_1kKaNU4nLbJV4Y1nN]4S1dKnN[4Q1eKoN[4R1dKnN\\4R1dKnNm3kLnJW4U1nNe3SMWKn3T1oN^3ZM^Kh3T1mNV3dMeK_3U1mNn2lMnKV3T1nNg2SNULo2T1nN_2[N]Lg2U1mNV2dNeL_2U1mNo1kNlLY2T1lNh1TORMQ2V1kN`1R4aNmKW1[4iNeKP1c4oN]Ki0k4WOUKg0m4ZOQKh0n4XORKi0m4WOSKi0m4XORKh0n4ZOPKf0P5\\OnJd0S5\\OlJd0T5\\OlJd0T5\\OlJd0T5\\OlJd0T5\\OlJd0U5[OkJe0U5[OkJe0U5[OkJe0U5[OkJe0U5[OkJe0V5ZOjJf0V5ZOiJg0W5YOiJg0W5YOiJg0W5YOiJg0X5XOhJh0X5XOhJh0X5XOhJh0X5XOhJh0X5XOhJh0X5XOhJh0X5XOhJh0Y5WOgJi0Y5WOgJi0Y5WOgJi0Y5WOgJi0Y5WOgJi0Y5WOgJi0Z5VOfJj0Z5VOeJk0[5UOeJk0[5UOeJk0[5UOeJk0[5UOeJk0[5UOeJk0\\5TOdJl0\\5TOdJl0\\5TOdJl0\\5TOdJl0\\5TOdJl0]5SOcJm0]5SOcJm0]5SOcJm0]5SOcJm0]5SOcJm0]5SOcJm0^5ROaJo0_5QOaJo0_5QOaJo0_5QOaJo0`5PO`JP1`5PO`JP1`5PO`JP1`5PO`JP1`5PO`JP1`5PO`JP1a5oN_JQ1a5oN_JQ1a5oN^JR1b5nN^JR1b5nN^JR1b5nN^JR1b5nN^JR1c5mN]JS1c5mN]JS1c5mN]JS1d5eMaGU1k2V1k5eNUJ[1m5cNSJ]1l5dNTJ\\1l5dNTJ\\1l5dNTJ\\1l5dNTJ\\1l5dNTJ\\1m5cNSJ]1k5eNUJ[1l5dNTJ\\1k5eNUJ[1l5dNTJ\\1j5fNVJZ1l5dNSJ]1n5bNSJ]1m5cNSJ]1l5dNTJ\\1i5gNWJY1g5eM^GR1k2Y1g5iNYJW1g5iNXJX1h5hNYJW1g5iNXJX1i5gNWJY1i5gNWJY1i5gNWJY1i5gNWJY1i5gNWJY1j5fNVJZ1j5fNVJZ1j5fNVJZ1j5fNVJZ1j5fNVJZ1j5fNVJZ1k5eNUJ[1k5eNTJ\\1l5dNTJ\\1l5dNTJ\\1l5dNTJ\\1l5dNTJ\\1l5dNTJ\\1l5dNTJ\\1m5cNSJ]1m5cNSJ]1m5cNSJ]1m5cNSJ]1m5cNSJ]1n5bNRJ^1n5bNRJ^1n5bNRJ^1n5bNRJ^1n5bNRJ^1n5bNRJ^1o5aNQJ_1o5aNQJ_1o5aNQJ_1o5aNQJ_1o5aNQJ_1o5aNQJ_1P6`NPJ`1P6`NPJ`1P6`NPJ`1P6`NPJ`1Q6_NoIa1Q6_NoIa1Q6_NoIa1l0cM^1l0fMa1k0eM^1j0gMa1j0fM_1i0hM`1i0gM`1h0gMa1h0jM_1e0iMa1a0SNd1X:BhE>X:BhE>X:AiE?W:AiE?W:ZOPFf0P:ZOPFf0o9\\OPFd0P:\\OPFd0P:ZOSFe0m9[ORFf0n9ZO^F:b9FfF3Y9NfF2l5WO`Kf0cN5k5_OWHDP3h0^MXOC9R1:m6NoJ7]MEh06k6OPK6\\MFi05j60QK7UMVON?S12j62PKP1VNnNj62PKP1WNmNk61nJR1WNmNj62oJQ1WNmNk61nJR1XNkNg67QKn0XNkNk63mJR1XNkNk62nJT1VNjNl62nJT1VNjNl62nJT1VNjNl62nJT1VNjNm61mJU1VNjNm61mJU1YNgNi65nJT1_N_Nf6j7MeHX1[2eNQN8o6LdHW1\\2iNmM2V7LbHY1[2lNhM1Y7LdHW1[2lNhM1W7NfHU1[2lNhM1U70hHS1[2lNhM1T71iHR1[2lNhM2S70jHR1Z2mNiM1S70jHR1Z2mNiM2Q70lHQ1Z2lNjM3P70lHQ1Z2lNjM3o61mHP1Z2lNjM3k6]OdHd0=P1Z2lNjM3k6^OdHb0=Q1Z2lNjM3d0]Om4i0[Jk0[2kNiM4c0MTO@o4i0VKl0Y2kNkM4b0LTOBn4h0TKo0^2fNjM5a0NSOBo4f0SKQ1`2eNiM3b01QOBo4g0lJU1i2`NiMNc04mNFP5h2gMaMhMLd07kNER5g2gMbMhMId0g0l3o1hMbMjM\\O]O5V1^1[3_1XNcMZOo0\\2_1ZNcMZOl0]2a1YNdMYOk0^2a1YNdMYOk0_2`1XNeMYOl0^2_1YNeMYOl0^2_1YNeMYOl0^2_1YNeMYOl0^2_1YNeMYOl06aNIn2h0eMZOk0OjNJi2m0bMZOk0LnNIh2Q1_MZOk0GTOHg2W1YMYM^Oi1^1H[OLc2Z1`MQOb0BDL_2a1[MYNQOYO1I`1U1II^2g1XMUNSOZO5H]1R1IAh2V2jLeMQOK4NP2f0[OCi2Y2gLcMUOI4LQ2f0\\O]On2e2`L]MSONb21]AOg>LZA3i>12MiSj0", "size": [480, 640]}, "area": 148979.0, "iscrowd": 0, "image_id": 16439, "bbox": [0.0, 0.0, 640.0, 480.0], "category_id": 172, "id": 20001031}, {"segmentation": {"counts": "Pco17h>6J100O101N1O100O1O100O2O0O1O100O100O1O2O0O100O1O100O101N1O100O100O1O2O0O100O1O100O101N1O100O100O1O2O0O100O100O1O101N100O100O11O0001@\\NbCd1Vc]OA]b0`0b]OA^b0>36LO00001L3F;JmVa7", "size": [612, 612]}, "area": 450.0, "iscrowd": 0, "image_id": 16451, "bbox": [184.0, 243.0, 24.0, 25.0], "category_id": 132, "id": 20001033}, {"segmentation": {"counts": "c6a2=R4_4V2eJgIe0L8V4^4W2eJfIo1S4\\3W2iJaIl1X4[3X2RMhMn2X2RMhMn2X2RMhMn2X2SMgMm2Z2RMfMn2Z2`JdINKW2W4[3[2^JhIW2l3[3j2dLVM\\3k2cLUM]3k2dLUM[3l2dLTM\\3l2eLSM[3m2eLSM[3m2eLSM[3m2fLRMZ3n2fLSMY3m2hLQMY3o2gLQMY3o2gLQMY3n2iLQMW3o2iLQMW3o2iLRMV3n2kLPMV3P3jLPMV3P3kLoLU3P3lLPMT3o2mLQMS3n2oLQMQ3o2oLQMQ3o2PMPMP3P3PMoLQ3Q3QMmLo2S3RMlLn2T3TMkLk2U3VMiLk2W3WMgLi2Y3XMfLh2Z3ZMdLf2\\3[MbLf2^3\\MXLl2h3UMjKX3V4jL^K`3b4aL[Ka3e4aLWKa3i4aLXJkLPO00OIO1g6n6cLTJZ4l5hKmIdLWOd7l6kKcIcL@O1c7l6nK]IcLFL1c7k6QLZIhLJW7m6SLTIhLOU7l6iLRIX3o6^4O100001OO11O00O1001ON200000000O1001O000000000000000000001O1O1O00000000001O00000000000PJUIGk6SO_Ji0`5UOfJh0Z5VOkJg0U5WOPKf0P5XOVKd0j4ZO[Kc0e4[O`Kb0`4\\OdKb0\\4[OiKc0U4SKRIY4k2c0S4^OoKa0Q4^OQLa0n3@SL?o3^OSLa0l3_OVL`0k3_OVL`0j3_OXL`0h3_OZL`0f3_O\\L`0d3@]L?c3@_L?a3@aL?_3AbL>^3AdL>\\3BeL=[3CfLT4RAkKk>W40O11ON200M3O1O100000000000000000000000000000000000000000000000000000000000000O1001OO1000000000000000000001O0000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O11OO11OO100000000001OO11O00O100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O11O0000O100001O00O1000000", "size": [612, 612]}, "area": 78785.0, "iscrowd": 0, "image_id": 16451, "bbox": [0.0, 0.0, 612.0, 136.0], "category_id": 157, "id": 20001036}, {"segmentation": {"counts": "Ro^13Pc05Q]OJfb0=K3FGi]O:Sb0=00001O01O0001O01O00010O001O010O1O2O0O00100O100O00100O1O3NO03M100O2O0O2N1O1O10O01000\\Nb^Oa1`a0001N3N0O1O4M1O1O1O000012M01O0O2O1N2O2N00mMR_OQ2Pa0001N10001N203L20N0O10O100O10000000001OO10001O0O001NoJVNlHj1m6`NPI`1Z<000000001OO10O11OiJjM`IV2`6jM`I1kJR2e;mM`I0nJQ2b;oMfIP2Z6PNfIP2f;2NoMR_Oo1m`0QNT_OP2o`010O1O00N2N2N2O1O1O1O1O2N002N001O1010M201O1O000000001N100001OO10WJhMfJY2X5iMgJV2Y5lMfJT2Z5mMeJR2]5kMeJU2Z5lMREKc5W2\\5XN\\Jh1d5PNdJP2\\5QNcJo1]5RNbJn1^5SNaJm1_5SNaJm1_5TN_Jm1a5oMcJQ2]5oMdJP2\\5oMeJQ2[5oMeJQ2\\5nMdJR2[5oMdJR2\\5nMeJQ2[5oMeJQ2[5oMeJQ2[5oMeJR2Z5nMmEJWO1`4O_KV2m:oMmEKVO1d4X2X6kMbELJ1HOd4Z2X6jMbELJ0H1e4X2W6kMbELJ0H0g4X2U6lMbELI1H0i4V2T6iMTE1h02o3V2U6hMSE0h02P4W2X6gMgE3Q4V2X6gMgE2Q4Y2W6eMgE3S4V2W6gMfE2T4X2n6gMSIX2P7fMPI[2l;O20N1O1lJeM_IZ2c6nMaDH[4Y2X7lMPIS2k6SNPIQ2SG_@YOe0T1g>Ce@YOd0W1d>@i@XOe0S1e>Ef@XOg0o0e>Id@XOi0j0e>Ob@WOk0b0i>7]@VOl06R?d0R@VO^a0j0b^OVO^a0j0b^OVO^a0j0>0000O1000000001O001O00O1N2101N3M1V_OnN`?R1_@PO`?P1^@ROb?n0]@TOb?l0^@TOb?l0^@UOa?k0_@UOa?k0`@UO_?k0a@VO^?i0c@WO]?i0c@XO\\?h0d@XOP2IS:o0mCYOm1KU:l0nCYOk1OU:h0PDZO_OEd1;l:f0QDZO[OJe1d:N`DYOPO=j1>e:LaDYOPO>i1>f:JaDYOPOb0g1h:EcDZOoNe0e1=h:DdDYOoNi0c1;i:CeDYOoNj0b1;j:AeDYOoNm0`1A=D7I7I5`MSNcCQ2]ZNjBChNS2^>_NdBl1\\=XN`Bi1_=\\N[Be1d=aNWB_1i=fNQB[1o=iNlAY1S>lNhAT1X>lNgAU1Y>kNgAU1Y>kNfAW1Q7VM0d1mHW1S7WMNb1nHX1T7XMKa1PIX1U7XMJ`1QIY1T7XMJ`45bKJ^40[KUI8j6]41]KSI8j6[43lKLT45lKJT46mKHU47kKIT1ZIW1m6eMIT1ZIW1n6cMIV1ZIV1m6aMlNJkJ_1\\OV1o6\\MgN9jJU1AU1oZEdM[Om1\\;4aESNROe1a;W2_DdMf;]2YD^Ml;b2UDYMo;g2SDRMROeA1[>OfA0[>IlA5U>ERB5S>DTB3U>GRBOW>KPBKY>NWB_O]4", "size": [612, 612]}, "area": 40340.0, "iscrowd": 0, "image_id": 16451, "bbox": [152.0, 123.0, 460.0, 427.0], "category_id": 183, "id": 20001039}, {"segmentation": {"counts": "kfP11^?0d@2\\?3O1NJg@5Y?Kf@6Z?20000001O0000000000001O00O11O000000O100000000001OO11OO1000000000000O1000000O1NGi@9V?3O10000001OOEk@9V?Fj@:V?Fj@:X?0O10000000000000000001O000000000000O10000O11OO10000000000O11OO10000000000000000O100000000O1000000000000O100000000O100O10000O1O10000O100O100000000000000000000O1000000000000000000000000O10000O11O000YOXAb0h>^OXAb0m>00000000000000000O10000000000000000000000O10000O100000000001OO100000000O100000000O11O00000000000000O1000000000000001O000000000000O100000000O11OO100000000O1000000O1001O00O10000000000000000000000O100000000000000000000O11OO100000000O100000000O1000000000000O1O11O1O000000O10000O10000000000001O000000O11OO1000000", "size": [500, 375]}, "area": 6374.0, "iscrowd": 0, "image_id": 16502, "bbox": [66.0, 466.0, 309.0, 34.0], "category_id": 124, "id": 20001040}, {"segmentation": {"counts": "n;f3m;100O10000O1O1N200O1O1O1O1O1O100O100O10000O10000O1000000000000O100O100O100O100O100O1O100O100O1O100O100O100O100O1O100O100O100O1O100O01KVE^Kl:b43O0OQE`Kn:`4RE_Kn:b420O1O1O2O0O1O1O1O1O1O2N1O002N1O1O1O001O1O1O1O101N011N00100O1O100O10O0100O1O01NmEcJR:]52001000001N0oEaJo9`5PF`JP:`5PF`JP:b51N101O00O100O1O1000001O000000000000O2O000O11OO10000000000O11OO101O000000O100001N2O1O0000O0010dJlEX5R:hJPFX5V:000O1N1100000000O100O2O000O1O2O000O100O101O0000001O00001O000O101O0000001O00001O00001O0O101O0O110O00VE[Ke:e4[E[Kf:i4001O001O001O00001N101O1O0000001O000000001N10000O1000001O0001OO10001O000O101O001O1N11N10000000000000O1000000000000001O000000000000O1000001O0O110N101O001O2M101O2N0O2O100O1N100000000000000000O1O10O01O1O1O10000000000000O11OO100000001N100000000O10001O0000000O1O11O10OO1O1O00100O001O10000000001O01O000O11OO2O0000[E", "size": [500, 375]}, "area": 55624.0, "iscrowd": 0, "image_id": 16502, "bbox": [0.0, 309.0, 375.0, 191.0], "category_id": 150, "id": 20001041}, {"segmentation": {"counts": "0n;f3O100O10000O1O1N200O1O1O1O1O1O100O100O10000O10000O1000000000000O100O100O100O100O100O1O100O100O1O100O100O100O100O1O100O100O100O1O100O1000000O100O100O1^MTK[Jm4a5YK\\Jh4b5[K]Je4a5^K]Jc4b5^K]Jc4a5`K]Ja4a5bK]J_4b5bK]J_4a5bK_J_4`5bK_J_4`5aK`J`4^5aKbJ`4^5_KbJb4]5^KcJc4]5\\KcJe4\\5\\KcJe4\\5[KdJf4\\5ZKcJg4^5XKaJi4`5VKnHAm0Z5V6UKfHHR1T5X6iKgIW4Z6hKeIY4[6gKeIY4[6hKcIY4\\6hKcIY4^6fKbIZ4^6fKaI[4_6eK`I\\4`6dK`I\\4a6dK]I]4c6cK]I]4c6cK\\I^4d6cK[I]4f6bKYI_4g6bKWI_4i6aKWI_4i6aKVI`4j6aKTI`4l6`KSIa4m6_KSIa4m6`KRI`4n6`KRI`4n6`KQIa4o6bKnH^4R7hKhHX4X7kK_H[4b7k100000000001O0cIhH^4X7bKhH^4Y7bKfH^4Z7cKeH]4[7dKdH\\4]7cKcH]4]7cKcH]4]7cKcH]4^7bKbH^4^7bKbH^4^7bKbH^4_7aKbH^4^7bKbH^4^7cKaH]4`7bK`H^4`7bK`H^4`7bK`H^4a7aK_H_4a7aK_H_4a7aK_H_4a7aK_H_4a7bK^H^4b7bK^H^4b7bK^H^4b7cK]H]4c7cK^H\\4b7eK]H[4c7eK]H[4d7eK[H[4e7gKXHZ4h7gKWHY4j7iKSHW4m7h10000M300000iIYHcNMh5k7dK^H\\4b7dK\\H^4d7i11O001RJSHS4n7jKTHV4m7fKVHZ4k7cKWH]4j7_KYHa4h7\\KZHd4g7YK[Hg4g7PK`HP5a7iJfHV5[7dJjH\\5\\7ZJhHf5c801O00000000001O0000001O00001O0000001O0000001O00001O00001O00001O00001O00001O001O001O001O00001O001O1O0000001O000000001O0000000000001O00000000001O0000001O001O1O00O1000000000000000000000000000000000000000000000000001O00001O001O001O2N001O2N001O1O1O1O000000000000000000O1O100O1O1O1O1000000000000000000000000001O000000000000001O000000000000001OO1O1O1O100O1O1O10000000000001O000000001O0000", "size": [500, 375]}, "area": 120799.0, "iscrowd": 0, "image_id": 16502, "bbox": [0.0, 0.0, 375.0, 382.0], "category_id": 157, "id": 20001042}, {"segmentation": {"counts": "QlT11_?6L3M2O2M3M2O1N2O000O11O001O01O10O200O_AAn=?kAHT>l010O000O110O000001O0001O010O001O00001O00001O003M6J3UB]N`=k101O000000O2M2B>100O1O01O000010O0001O00001O000010O000000001O00001O00100O2N102M2N1O1L2100E[BfNf=Z1\\B`Ni=_1^BbNZ=^1dBdN\\=j11N1N3M3L4L4M3L4M3K6G8I:H9Hool2", "size": [500, 375]}, "area": 4621.0, "iscrowd": 0, "image_id": 16502, "bbox": [75.0, 238.0, 109.0, 77.0], "category_id": 183, "id": 20001043}, {"segmentation": {"counts": "Wa0Z2ea020N02N2N1O1N2F_MS_Oc2d`0:[_OSMd`0g2c_OYM[`0b2l_OcMn?W2Y@iMP=LYB7S2n1kNoMiib0CU]O=kb0DT]O20N02N2N1O1N2F_MS_Oc2d`0a0O1N7J1YMdLYB7S2V3d;gMVBkN\\1\\3amKB\\Ni41XKf5W7YJiHf5X7ZJmHa5T7^JlHb5T7^JlHa5V7]JkHc5^71000O1000O10O10O1000O10O100000O2O00001N11O01O001O000010O01O00001O0010O0001O001O001O01N1O1O100O11O01ZMaJ]M_5c2aJ]M_5c2bJZM`5e2bJYM_5g2bJWM_5i2bJWM]5i2dJUM^5i2dJVM\\5j2dJUM]5k2dJVMZ5j2gJWMW5h2kJWMU5i2lJTMV5l2kJQMBmMc5R5kJPMY5n2iJQMW5o2jJoLW5Q3jJnLV5R3kJmLU5R3oJjLR5V3oJiLR5V3mJkLS5U3mJkLS5T3nJlLR5T3mJlLT5T3lJlLT5T3lJlLT5S3lJoLT5P3lJPMT5P3lJPMT5P3kJPMV5o2kJQMU5o2kJQMU5o2jJQMX5n2hJPMZ5P3fJnL\\5Q3eJmL]5S3bJkLa5U3_JbLk5]3UJbLl5]3TJcLm5]3SJcLm5]3SJbLn5^3QJcLP6\\3PJcLQ6^3nIaLS6_3lIbLT6_3kI`LV6`3jI`LV6a3hI_LY6a3gI^LZ6c3eI\\L]6c3bI]L_6d3`IZLb6f3^IYLc6h3[IXLf6h3ZIVLh6k3WITLj6j2dI_LAg0l6l1cJ\\M`Nf0o6?PLkNQMe0Q7KbLA[Ld0T7HdLDXLb0V7JcLDVLa0X7JdLDTL`0Z7HiLFkKb0]7D`HFY44jKa0_7BmLMcK?b7ClLNaK?d7CkLO`K=f7ClLO^Kf;J[DHOk0f;e0O10000000000O1001O00000H[DiNh;T1;fNmCR11nNU<0jC627ec;FkDc0U;]OjDd0S;^OmDc0U;[OkDe0U;ZOlDf0T;ZOkDg0U;XOlDh0T;WOmDi0T;UOmDk0S;TOmDm0T;QOmDo0S;POnDP1g;000O100O100O100O100O10000004L=C6J:F5K0000_d10a[Nb0_O4K8H2OO00001O_OROdDn0\\;SOcDm0];TOcDk0];VObDj0];WOcDi0];XOcDg0];YOcDg0];ZObDf0^;ZOcDe0\\;\\OdDd0\\;\\OdDd0\\;]OdDb0\\;^OdDb0\\;^OeDa0Z;AeD?[;AfD>Z;BfD>V;FjD:U;HkD7T;JlD6S;LmD3R;NnD2R;OnD0Q;1oDOP;3oDMP;4REJm:8TEFj:=WEAf:c0[E[O]:ERET1`0WO]:o0cEQO\\:Q1dEnN[:U1cEkN]:W1aEiN^:Z1`EfN_:]1`EbN_:c1]E]Nb:i1YEWNg:W2O1O1O1O1O1N2N2O1M3M3M3M3O11O00001OO100001O0000000000O1000000O1O1OdMWFW1j9aN^F^1b9[NeFe1[9TNlFl1T9mMTGR2S:0N2L4L4L4L4L4L4L43M1O003M001O00O100000000001O2N1O00001O1O00N200000000001O001O1O001OO1001OO1001O00000000O10000", "size": [428, 640]}, "area": 25528.0, "iscrowd": 0, "image_id": 16958, "bbox": [0.0, 320.0, 640.0, 108.0], "category_id": 101, "id": 20001048}, {"segmentation": {"counts": "`S^4110X=3O00001O00000000001O00000000001O000000001O0000000000001O0000001O000000001O00000000001O00000000001O00000000001O000000001O00000000001O00000000001O000000001O000000001O0000001O00000000001O000000001O000000001O00000000001O000000001O000000001O0000001O000000001O00000000001O000000O100000000O1000000O1000000O1000000O1000000O1000000O100000000O10000O1000000O100000000O100000000O1000000O1000000O100000000O100000000O1000000O10000O100000000O1000000O1000000O1000000O1000000O1000000O10Phj0", "size": [428, 640]}, "area": 3889.0, "iscrowd": 0, "image_id": 16958, "bbox": [340.0, 0.0, 236.0, 29.0], "category_id": 102, "id": 20001049}, {"segmentation": {"counts": "Rmi06S=3KHSC018l<5N200N2O1001O5K00000000O100000000001OO1^ODSD=l;GQD9n;GiCL5=QR<2mCORfe<7O10OO1O12NN1102N0O1000O10O100000O0100O010000O010001O1NO21O3M1O002M2O001N2O1O1O1N102NZ_W4", "size": [428, 640]}, "area": 3105.0, "iscrowd": 0, "image_id": 16958, "bbox": [61.0, 355.0, 254.0, 73.0], "category_id": 114, "id": 20001050}, {"segmentation": {"counts": "eRb18:Ibl<001O5LOO11O0000000O2OO1N21O0O2O1O00O1O10O10O1000O1000O10000O1O1L32O00000O5L9D5M1Niic5", "size": [428, 640]}, "area": 1732.0, "iscrowd": 0, "image_id": 16958, "bbox": [119.0, 331.0, 90.0, 41.0], "category_id": 115, "id": 20001051}, {"segmentation": {"counts": "PR3110X=4N0O10001O00001O00000000f0ZOa0_O;E7I6J5K3SEbMN0f:n2ZERMZ:U3K1SFmLHM0110]9d3cFjLR9m3mFhKh8i4RJSKd20bJ[5Z2iJS3S6RLoIn3\\6fKdIZ4f6\\KZId4j6WKWIi4R7nJnHR5h7O2ML40000001O000001O000O1O1O1O100000000000000001O00001OM3L4N2O1000000O100O1N2O1002N001O1OO100M31OO1O1000000ON32N0O100001ON32MM3NnIjHR6V721O00001O00000TOiHcKW7[4lHdK`3^OIj4jLhK]3OXOV4_MjKY3=kNS1bNWNYO;2MW3R1YN?Y1\\N>d1jM0i1[N=W2XM^O[2[N=g2fLPOm2YN=[5CeJ=[5CeJ=\\5BdJ>\\5BdJ>\\5BdJ>\\5BdJ>\\5BdJ=]5CcJ=]5CcJ=]5CcJ=]5CcJ=^5BbJ>^5BbJ>\\5DdJ<[5EeJ:_5CaJ=_5CaJ=_5CaJ=_5D`J<`5D`J_OaLR6Q3_Ja0a5_O_Ja0a5_O_J=_OaLT6R3]J=e5C[J=e5C[JV6BhI`0Y6_ObIe0_6[O_Ig0a6ZO]Ig0d6ZOXIh0h6n21O1O3gIWIK9:Ce4]8QKnG[4b801O1O00gGiKZO3k7U4fHjLEjNh6m6SIUIX6_7A_H\\J1MQ7V6O1[IgIU6Z6jIfIV6[6hIfIW6\\6`IcI1O04^6h6O00000O1000000OO200OJ6O13MO21O002O0O2OO0O2M3000O1XIlIW6d601OO1O12NN2002N000000O1000001O0O10000_L^IjL3W3`6NeI1\\6MeI3[6MeI2\\6MfI2Z6NfI2Z6NgI2X6MiI4V6LkI1W6OiI0X6OiINZ6[MPKGH0WO<_Ol0`6POjN;X1DiN=W1@mN?S1AlN?U1AkN?U1@lN=V1FeN8a1GZN9k1GUN4P2LQNNT22c500000001KcS3OalL11OPXQ4", "size": [428, 640]}, "area": 60518.0, "iscrowd": 0, "image_id": 16958, "bbox": [7.0, 16.0, 323.0, 380.0], "category_id": 123, "id": 20001052}, {"segmentation": {"counts": "TUZ15Z=8B4M@XCb0f<300O1O010O001O00N3MZC^OfUFB:n0_9ImE_OOJL07P1n9a0kE_N7R1k9e0kEYN050o0S:T2O0O10000O10000OPMRFd2n9[MUFd2j9\\MVFc2k9\\MWFd2h9\\MXFd2g9]MZFb2f9]M[Fb2f9^M[FY1GaN0Q1m9UO\\FW1MDg9UO]FR1FfN9R1U9oNnF6Oo04LP9oNkF72l04MP9POjF72l04MQ9POhF74l02MR9POhF74l02MS9POeF77k02MT9POdF77l00MV9PObF78l01LU9QObF79k00N^9UOcFl00O]9UOdFl0NO^9UOdFk0O0]9UOeFk0K2Z:OcEoNFR1g:1XEmN20NW1h:\\1O01O001O001O1N101O001O001O001oNQECo:=SEAn:=SEhNM005ON1MO040m:W1[EjNHO[;V1e0O2O001O001O0O2O01O00000TEoN\\9U1aFROX9Q1^EhNR11nN6b:T1^EeN627`0U:o0_EiN0F3a0]:d1_E]Na:W200O1000000O100VOVMRGj2m8WMSGi2l8YMRGh2n8XMRGh2m8YMSGg2n8YMPGc2]O[Mc92PGa1^OhN3JOK`93oF\\1^O^N48LH0061M011_94oFX1@bNN132NM]:8SFT1FdNO0L1Z:9TFP1c:QO]Eo0d:QOZEQ1d:PO\\EP1d:PO\\EP1c:RO\\Eo0e:oNZER1h:mNWES1i:mNWES1g:oNYEQ1g:POWEQ1o0aN]80^F<6S1h0aNoN61N\\9LiF:2T1j0QOZ8AnF7MY1f0SO_8]OPG5K[1I`N210O8k0R9UOQG5Ij1LPOY9RORG4Hn2V9nLSG4Fn2W9nLSG4Eo2X9lLTG6Cn2Y9lLUG5AP3Y9lLVG5@o2Z9lLWG4_OP3Z9kLXGS2_OmM7l0g9m0RF[N\\2VORMe4Y1fMjNoMb0HBjI@X6a0gIZO^6f0bIXO`6h0aIVO`6k0aIQOa6o0n21O1O3nCPOK9:C^:d2XEgMU:h201O1O001O1O1O1nEmL1Mb9e3O1jFXLf8i3YGWLg8j3WGWLi8j3nFUL1O04P9V4O00000000000000N200O1O1O1O10000001O001O0000O1O1N2N2N2O1N2N2B_FPMb9m2`0@nEeMS:[2nEdMR:\\2oEcMQ:]2QFaMo9_2RF_Mo9a2RF^Mn9b2WFYMi9g2>O10000000XJYMVK3_5d2ZOaMe0_2ZObMf0^2ZObMf0^2YOdMf0\\2ZOdMf0\\2ZOeMe0\\2YOeMg0\\2XOeMg0]2WOcMi0^2cKVM_2=n1_2_KYMIb1]OH0WO<_OW3h2^LTM?001OoH[K[5e4dJ\\K]5c4bJ_K^5`4bJbKX5c4gJ^Kb3X6]LjIV3b6jL_Ij2l6VMZI7B\\N\\9\\1^2O10000O2O00000O10001O0O1000000O2O0000000O101O000O11O01O00000000010O000000000010O00000001O000001O01O0000001O01O00000001O0001O0001O0000000010O00000000010O00000001O0001O0001O0000010O000000010O00000001O01O000000O10001O000O1000000cGDi3=YKc0e4]OlIR2T6oMWIe2i6[MTIh2k6YMUIh2j6XMUIj2j6VMRIQ3k6oLQIiNFY4X7PMoHV3P7jLoHW3Q7iLoHW3Q7iLnHY3P7hLPIX3P7hLPIX3P7iLjHeN1d4U7gLjHeN0f4T7fLlH\\3T7^101O000O2O000O2O00001N10001O000O2O001ZIbI\\6^6dIfIX6Z6hIfIW6\\6hIdIX6\\6gIeIY6g600O1000000O10001O000O1000001O0O1000001N10000O2O00001O0O10001O0O2O00001N101O001N2O1oJ^HV4d7_KeHa4R8010O11OO001OL23K5J6H8L4K5O1O1O1O100O1O1O100000000000000O_LgHQ1Y7mNkHQ1U7oNkHQ1U7oNkHQ1U7oNkHQ1U7nNlHR1T7nNmHQ1S7oNmHQ1S7oNmHQ1S7oNmHQ1S7oNnHP1R7oNoHQ1Q7oNnHR1R7d2O10000000000001O1O1XLQIQ1P7bN\\I^1f6YNaIg1`6QNhIn1Y6kMmIU2T6cMSJ]2o5ZMYJe2h5SM_Jm2b5kLeJU3i701O0000001O0000001O00", "size": [428, 640]}, "area": 90111.0, "iscrowd": 0, "image_id": 16958, "bbox": [0.0, 0.0, 640.0, 386.0], "category_id": 172, "id": 20001056}, {"segmentation": {"counts": "X;=o<00001O00000O2O00001O0bCAo;?iC@O0N1Y1O01O010O1O010OO10010N1001O01O00000O2O00gE", "size": [428, 640]}, "area": 3506.0, "iscrowd": 0, "image_id": 16958, "bbox": [0.0, 288.0, 640.0, 127.0], "category_id": 177, "id": 20001057}, {"segmentation": {"counts": "\\S:1m02_;N[D8c;IYD^O1000001O000000001O0001N3N1O1_OXD\\Oj;`0[D]Oo;6i0Im[1f1kXNYNe7h1UH]Nl7c1nGcNQ8^1iGgNX8Y1bGmN]8T1]GQOc8P1WGUOj8l0oFZOP9g0jF^OV9c0dFC\\9V2010O01O01O01O]Od0SOl0H801O0O101O001O0O101O00001N10001O00001N10X1hN1OaC@R<`0mCCR<;oCEQ<;nCGR<8nCHR<8nCIQ<7nCJS<4nCLR<4nCMR<2nCNR<2mC0SS<@nC`0R<@mCb0S<]OmCc0S<]OmCd0S<[OmCe0\\<2O001O001N101O0O2O001O0O2O001O010O0010O01O010O010O0001O001O00001N101O0O101O001N101O001N101O0O101O00UM]OnHa0S7_OmHa0S7@lH`0S7BmHXOYOC0V79fIh0@POB0X78eIi0@POCNX7:dIj0_OPOCMZ78eIl0]OPOCL[78dIn0\\OoNDL\\77dIo0ZOPODJ_76cIS1XOmNEKa74aIV1WOmNEJc73aIX1SOmNHIe70`I\\1POnNIFh70_I^1kNCg7nN]IW3c6hL]IY3d6fL[IZ3f6fLYI[3h6cLWI^3j6bLUI^3m6aLRI`3n6_LQIb3Q7]LnHd3R7\\LmHe3T7YLkHi3U7WLjHi3X7VLgHl3X7SLgHS4V7lKiHb4j6^KTIj4g6TKYIW5]6iJbI]5Z6bJdI`5\\6`JcIa5S71N200O10nNfHRLZ7o3QIfKm6[4WIZKYO3`7d4]IYKc6g4Q10O2O0000@_GVL_8k3bGTL^8k3dGTL\\8l3eGTLZ8l3fGTLZ8l3gGSLY8l3hGULW8k3jGTLV8l3jGTLV8l3jGULU8k3kGULU8j3mGVLR8j3nGVLR8j3nGVLR8j3oGVLP8i3QHWLo7e3gGoK:=n7c3WH]Li7c3XH]Lg7b3ZH^Lf7a3\\H^Ld7a3]H`Lb7_3`H`L`7`3`HaL_7^3cHaL^7]3cHeL[7Z3gHgLW7V3mHkLQ7R3SIoLk6j2]IUMc6j2^IVMc6h2`IVM`6i2cIUM]6k2dIUM[6j2hITMX6k2mIQMT6m2PJPMP6o2W200O2N1O1O2N1N2N2N3L3M4L3M3M4L3M4L3L5@`0L4_OnC0j;D`Dd0o;10VO`Ci0^ULaAk3_>VL`Ak3^>ULcAj3T>SL]A2NO9l3[>TL^A0I6=g3\\>TL]A:IG6n3a>VL]A;N^ONU4d>RL`AjKfAo4U>QKmAR5n=oJRBo4o=PKSBo4m=UKPBj4P>XKnAf4T>[KkAd4V>]KiAc4W>d0O00O2OO2O01N0101ON211K3L4N2M4O000O10001O0000O1O0100000IlJbAS5^>nJ`AT5`>7OO1O0002AfJVBZ5k=gJRBZ5_:eJ[E0U33nLX5b:mJ[EJ0Kj25YMZ5a:mJ\\EKi2c5j7mJVHR5j7nJVHR5k7lJVHU5i7kJWHT5k7kJUHU5k7kJUHU5l7kJSHU5m7kJSHT5o7lJQHS5P8kJPHP2YM`0h:^MPHn1\\Mf0d:YMRHl1]Mn0`:UMRHi1bMS1]:TMoGh1eMdNB[O2\\2b:iMWHm1eM`NC[O3`2Z:hMZHn1gM^NLn1P:eM]Ho1kMYNIS2P:`M_HU2hMVNJV2P:_M]HU2hMWNKV2P:_MZHV2iMWNLT2o\\P1QAUOh>l0XA[O`>f0`AAY>?gAEQ>?oAEj=>XBDa=>`BEQ=g0oB]OlTi6dM_Mm1gK`0k6bM_Mm1fK`0l6cM_Ml1eKQNiNZ2R8jM`Mk1eKPNjN[2R8hM`Mm1iK;g6iM`Ml1iKPNoMmM^1M`Nm70SHd1V4>QNoMkM`1m7_NQHd1W4=VN_Oe54TL=WNoMcM]1S87SL=YN\\Od58RL;[N_Ob55SL=kKoM\\2d1c5\\NQHa1U4b0VNBeM[Nm70SHb1T4a0WNFc5HVLb0WNEgMXNi7b1XL?[NEcM]Nj7^1XL`0[NEbM_Nj7\\1XLb0\\NG_5FULb0\\NFb5HRLb0WMoMRO18h1\\7EoKcNRLP2Y1oMQO3NL0m1f7@oKg0TLlMX11QO3NLH14o1i7\\OQLh0\\MoMjNNN35MI04o1i7\\OnKj0aMoMeNL046OLn1i7ZOnKk0bM[NgND1l1h7ZOnKk0`M]NhNC1m1g7YOPLk0^M]NjNk1f7oNSLh0]M_NhNi1j7POQLh0^M^NgNj1k7oNPLh0`M^NeNl1j7nNQLh0`MP1_6XNQLh0`MP1b6UNnKj0bMP1`6VNnKj0\\MkMmNU3i7VNnKj0[MnMlNS3j7UNoKj0[MX1f6nMPLi0XMZ1i6mMnKj0YMZ1h6lMoKj0YMZ1h6lMnKl0XM[1j6gMnKn0XM[1j6gMoKn0VM[1k6gMoKn0VM[1k6gMoKn0VM[1k6gMnKo0UM\\1l6fMPLl0UM^1k6fMoKn0SM_1m6cMQLm0RM`1n6bMQLm0PMb1P7_MRLn0nLmMUOa3m7bMQLo0RM_1m6bMQLn0TM_1l6bMPLo0UM^1n6`MlKS1UM^1n6`MnKQ1UM]1n6bMmKQ1UM]1n6bMmKQ1UM]1c6`L`HT1h3o0VM\\1Z6eLbHN3T1k3m0YMY1S6]NeL9ZMW1R6`NdL9ZMW1R6`NdL9[MW1P6`NfL8[MU1Q6cNcL9\\MT1Q6cNcL:ZMT1S6bNcL9[MU1R6bNbL;WMlMlNW3[7eN\\LTNWLT2V1X1W6dNXLPN[LS2X1X1U6hNULmM^LT2X1U1V6mNQL0jMS1T6POoKMlMT1U6ROlKJnMT1W6VOhKEQNU1W6YOeKCSNU1W6[OYJ[M[N0T1R22Y1U6]OWJ\\MCm17T1o5FSJYMHn15S1P6IPJVMKo14Q1R6MlISMNo14R1Q6OiIQM2m14U1P60gImL6n12W1P60eIkL8o14nMhNNOn2Y7=cIlL6n17mMlNm2S7=^IQM;h1c0nM[NM1e2X7h0WIVMa0b1f0kM_Ne2S7i0PI[Mh0\\1o0`0Y5j0iH`Mo0V1o0?Z5o1gIcMn0?Z5o1gIbMP1>Y5Q2fIaMT1:W5U2eIaMU19V5U2fIcMR19X5T2eIcMT18X5U2dIcMT18X5U2cIdMU18W5T2_IiMZ13W5T2\\ImM[10Y5T2ZInMZ10\\5R2ZInMT1^MZNc2W7Q2[InMT1_MYNb2X7Q2[IoMT1^MWNb2[7Q2ZIoMT14b5m1ZIoMT14b5m1ZInMV15_5m1[InMV13a5P2XImMY11_5R2XInMY1O_5S2XIjM]14Z5R2YIjM]15Y5P2[IlM\\13Y5Q2[IlM\\14X5P2\\IlM\\13Y5Q2[IlM\\13Y5Q2[IlM[14Z5Q2ZIlM\\1OPNaMY7d4[ImM[1NQN`MZ7e4[IlM[1N]5V2WInM\\1J^5X2UIPNZ1Ja5V2UIPNY1Kb5U2UIPNY1Kb5U2UIPNf0?T6a1VIPNg0=T6c1UIQNe0=V6b1SITNf0:W6a1UITNe09W6c1TITNe09W6c1TISNe0:X6c1TISNc0:Y6c1TISNe08W6e1TIRNf09V6e1SISNg08V6e1SISNg08V6f1PITNj06V6f1oHUNm03T6h1nHUNo03S6h1mHVNo03dNRM]7d4PIYNn08n5`1RIYNQ1;h5[1YIYNR1=a5Z1^IXNR1>_5Z1aIVNU1;Z5_1bITNV1=W5`1aIUNX1:W5a1aIUNX1:W5a1aIUNX1:W5b1`ITNY1:W5a1bITNW1:X5c1`ISNY19W5c1aITNW1;W5a1bITNW1;W5a1cISNY18U5f1`ISN\\17S5e1aITN^15R5g1`ITN_15P5g1`IUN`14RNQMl6e4cIUN`17m4", "size": [640, 640]}, "area": 105393.0, "iscrowd": 0, "image_id": 17029, "bbox": [0.0, 0.0, 640.0, 419.0], "category_id": 97, "id": 20001059}, {"segmentation": {"counts": "[6o0f0Di4Q2V4[NQGCj4_ObJ`2d9\\NRGEg4_OdJ`2a9]NSGEm4l1P4aNRGHj4g1T4`NQGJj4h1S4_NRGJk4g1S4_NRGJk4h1R4^NTGIh4k1S4]NUGGi4k1S4^NUGFg4n1dJ\\M^9P1VGFf4R2T4XNVGFg4P2T4ZNUGFg4o1U4[NTGEh4Q2Q4\\NWGBj4o1Q4^NVGAk4R2n3]NWGAl4Q2n3[NXGDk4P2m3]NWGCl4P2m3_NTGVOBJL0]50cJ`2_9aNRGQO]5MQJb2`9aNPGPO`5_2b3aNoFnN_5`2d3aNRM_1m2aNRMb1l2^NTMb1k2_NUMa1k2_NVM_1l2cNQM\\1P3dNoL]1Q3hM]F?^6XOdIa2`9hM`F=\\6n1V3eM_F<[6o1V3dM_F>[6n1W3cM]FNO9]6U2X3dM[FI6=X6DbI^2e9gMfFIG6^6KaI_2g9dMiFN^ONg6`2R3dMjFLV6a2P3dMdM\\2\\2fMaMX2c2hM\\MX2c2jM\\MGhH]2P:iMZMV2h2hMYMV2i2iMWMW2j2hMWMR2^:1O1O0Z^OjMba0[2OO100N20MhM^^OW2ca0300O021N01O1O001N10000O1002NO20OO1M4O0M3M31O00O100001n]OTNoa0n101O02NON31O0O10N200O23K2jIRNXJn1d5VN^Jh1^5[NcJd1Y5`NhJ^1X5cN[EB[O2Q5h1[6fNVEC[O3R5b1^6iNTEL\\4^1]6jNREIb4\\1\\6kNPEJe4[1[6jNQEKd4[1\\6hNRELb4\\1\\6hNPENe4Y1[6iNQEMd4Z1[6iNoDOf4[1X6fNREOf4[1X6fNQE0g4V1oJXNY;b0PE1h4U1\\6lNjDOj4U1]6kNiD0j4T1^6mNaD]OOOOc0T5S1]6nNaD\\OOf0S5P1]6RO_DOS5o0_6KbI2`6O]I3c6M^I3`6O_IOb62_IO^6LhI5hJ\\N[;`1mI7R6IoI7Q6IPJ7n5KQJ5Q6IoI6Q6KkD^Nm4g1V6MmD]Nm4e1U60mD[NP5c1S62mD[NP5c1R6;oICQ6_NnDi1o4IR6]NREi1k4J]66bIHa61_DaNP5_1b6N_DaNP5a1a6E^DPOT5\\1_6C^DPOT5\\1^6D^DPOV5Z1]6F`DlNT5]1]6]O[DVO00a5[1U6^O[DWO1N`5\\1T6_O\\DVO00`5Z1T6AWJ>j5AXJ>h5BXJ>h5BXJ>i5BVJ>j5CUJ\\N\\2P2hL[M`2V32eMlM]1?\\N\\2V2UO=4cMmM]1`0\\N[2W2TO<7aMjMa1?ZN\\2X2VO;7_MiMc1?ZN\\2Y2UO;8^MhMd1?ZN\\2Y2VO:7^MhMf1?ZN[2V2YO<5^MhMe1`0[NZ2V2XO=6]MgMf1a0[NZ2S2ZOXM\\MT3h2_MhMh1`0YNZ2R2^O>0_MhMh1`0YN[2R2[O?1_MhMh1a0XNZ2S2[O?O`MlMf1`0XNZ2S2\\O>O`MkMe1b0ZNX2T2YO?1_MkMe1b0TNSOAV3h2ZO>0_MlMf1a0oMe2^2mN>2^MkMh1>lMl2a2hN=3]MlMi1>hMo2d2dN>2]MnMi1?eMm2d2SL\\M`2V32\\MoMj1`0cMl2f2RLZMb2W30VMWNP2Y49`Mc00QMZNS2V48_Mf00oL[NT2V48_Md00PMZNU2W46bMc0LSM[NT2W46bMc0LSMZNT2Z45`Md0KTM[NS2Y47_Mc0MSMZNU2Y45_Md0MSM[NT2Z43_Mf0LSM[NT2Z4OnJbMa2W3KUM[NT2[4NbMk0HSM[NT2\\4MaMl0HSM[NT2[4NbMk0GTM\\NS2[4NaMl0HSM\\NR2\\4OnJaM^2Z3LTM\\NR2]4NlJcM_2Y3LTM\\NP2b42VMj0LSM\\NR2g4KRMP1KRM]NS2k4FmLU1KRM\\NT2Q5_OfL^1MnL[NW2Q5^OgL]1NkL\\NZ2o4^OXJoM]2^31iL[N]2o4@dLZ13gL[N_2l4CdLX16dLZNb2k4CeLW1T1WOW2C_L[1X1TOZ2@_L[1V1VO[2_O`LZ1S1YO\\2^OaLiMjM\\3Z1bLb0m2h3\\OgLT1oNcLa0m2k3[OdLV1mNcLiN1i1k2m3[OdLV1lNhLb0i2l3ZOdLW1mNgLc0g2m3[OcLW1mNgLb0j0dN`0[5d0ZJlMW2`3oNfL`0g0iNb0U5g0fLZ1mNPMjNAT1j0^Oc0R5g0eL[1mNUMN2Bi0i4g0jLZ1mNTMNOFk0a4m0oLS1mNVMKLLn0[4o0QMQ1mNVMKH1Q1S4T1SMm0oNVMHD9U1l3U1SMl0QOVMG_O=Z1h3U1SMl0ROUME@`0Y1e3X1RMk0TOSMF@`0Z1d3X1RMk0UOQMF_Oc0\\1`3Y1RMk0VOoLF@c0^1^3X1RMl0XOlL_1o0W2Y1RMl0YOjL`1P1U2Z1TMj0XOjL`1Q1U2[1RMk0ZOgLa1Q1S2_1RMh0ZOhLa1Q1S2_1QMi0\\OfL^OOk0R1Z3`1nLl0@cL[O0m0Q1Z3a1mLk0B_L]O4k0i0UNTOS5f2kLm0FZL\\O6l0h0UNSOT5h2fLP1m0\\LUOi0_3j1`LP1k0^LWOg0]3l1aLo0l0\\LWOi0[3m1aLo0i0_L[Od0[3o1aLn0h0`L\\Ob0]3o1_Lo0g0aL]O3SNKZ5b2`LUMTNf3`2fL@3SNGZ5f2aLj0a0gLA2UNDX5j2bLh0c0[L]M8Q27TNDZ5j2aLh0e0cL]O5h3b2TLf0h0aL]O8f3`2SLj0j0^L]O8f3`2TLi0h0`L^O7g3_2SLj0h0`L^O7f3_2ULj0g0_L_O8e3_2SLl0i0]L_O8e3_2SLl0j0\\L_O8d3`2RLm0k0ZL@9b3b2VLg0T3hLe0`2YLg0R3hLf0a2XLg0R3hLh0a2TLg0U3hLh0_2RLj0W3eLh0a2oKl0Z3aLo0[2fKV1[3^LT1Y2_KZ1^3[LX1W2]K[1\\3]LW1Y2\\KZ1^3[LW1[2[KZ1^3[LX1Z2ZK[1_3YLX1\\2YK[1`3XLW1^2XKZ1T:fNlEZ1S:gNPFV1P:jNPFV1P:jNlEcMXNc3l;jNlEZ1T:fNlEZ1T:fNkE[1U:fNjEZ1U:gNkEY1R:iNnEX1n9mNoEU1n9lNTFT1i9POWFo0f9TOXFn0f9UO[Fi0f9VO[FnL\\Nh3X;[O_Fe0b9ZO^Ff0b9[O^Fd0b9\\O^Fd0b9\\O]Fe0c9[O]Fe0d9[O[Fe0e9]OYFc0g9]OYFc0g9_OWFa0i9_OXF`0h9@XF`0h9\\LfDn2`1h0j9[LeDm2b1g0V:XLXDh2b1P1^:iNcEW1]:jNbEV1^:lN`ET1_:nN`ER1`:oN^ER1b:oN]EQ1c:PO\\EP1d:PO[EQ1e:POZEP1f:POZEP1h:nNXER1h:nNXER1g:oNXER1g:oNXER1h:oNWEQ1i:oNWEQ1h:QOXEn0i:ROVEn0i:SOWEm0j:ROVEn0k:QOVEn0j:SOUEm0S4WL^1k2_Jn0S4YL\\1j2`Jm0T4YL]1i2_Jn0T4YL]1i2_Jn0R4[L^1i2^Jm0Q4]La1e2_Jn0m3cLa1_2bJn0l3dLb1_2bJl0j3gLd1]2aJm0j3fLg1\\2_Jn0h3hLh1\\2_Jl0f3kLj1Z2aJj0f3jLk1\\2_Ji0g3jLj1]2_Ji0h3hLk1_2[Jj0k3fLi1a2[Jj0m3cLj1b2bIQM;k3Y4bLk1a2bIXM2f3b4`Lj1c2[IPM187f3d4^Lg1e2^I\\M7a3d4^Lg1f2\\I]M7`3g4\\Lf1Y3\\I]L2o3m4YLg1[3YI^L2n3n4YLf1d7\\NZHd1f7\\NZHe1e7\\N[Hb1f7^N`H]1_7dN`H\\1`7cNaH]1_7cNaH\\1`7dNaH\\1^7eNcHY1]7iNbHV1^7kNaHU1_7kNaHU1_7mN`HW1[7kNcHU1]7kNcHW1[7jNdHW1[7iNeHX1Z7iNdHZ1Z7gNeH[1Y7eNgHZ1Z7gNeHX1\\7hNcHX1^7jN_HX1`7c512NN21O1OO10000O13M1O1O2N1O1O00000000O1O11OO1001OO1001O0000O1O1O1000000000000000000O10000000^IaCc5_eMXAX2j>fMXAX2j>fMXAX2i>fMZAX2g>gM[AW2g>gMYAY2g>fM[AY2e>gM[AY2f>eM\\AZ2d>fM\\AZ2d>fM]AY2d>eM]A[2c>eM^AZ2b>eM_A[2b>dM_A[2c>cM]A]2f>^M]Aa2f>[M[Ae2g>WM\\Ah2f>UM[Ak2g>RMZAn2h>oLXAR3j?1O1O1M3M3N2O1O1N2O1O1N2O1O1O1N2O1O1N2O1O1O1001O0000000000000000O1000000O1000000O10000O1N2O1O1N2O1N2O1N2F:M3M3L4O1O1O1O1O100O1O1hNhJgCY5Wbc00O100O100O100O0100O01000O01000OYOAn]O`0la0GS^O9ha0LW^O5fa0MZ^O4_a02a^ON`a01Z^O6fa0JW^O9ia0FW^O:ja0FV^O9la0EU^O;ka0EU^O:la0EU^O;ka0EU^O:la0EU^O;ka0EU^O;ka0DV^O;ka0EU^O;ka0EU^O;ka0DV^Od4UA]Km>d4o@^KR?f42M31O1O1O1O1O001O1O001O1O002N001O001OO100001O2N1O002N2N001O001O1O001O002N001O001O000aB_J_b3QBZLP>e3SBXLn=g3UBVLl=j3WBSLi=m3YBPLh=o3[BnKf=R4\\BkKe=T4_BiKa=W4aBfK`=Z4bBcK_=\\4_BfKb=Z4R100O1000000O10000O100O1O1O100O1O1O1O100O1N2J6N2M3N2N2N2Ha_OlLb`0R3b_OkL_`0R39M3N2M3M3N200O10000O100O10000O100O100Gc^OoM]a0P2d^OoM]a0P2d^OPN\\a0o1e^OPN\\a0o1e^OQN[a0n1f^ORNZa0m1h^OQNYa0n1h^ORNXa0m1i^OSNWa0k1k^OUNUa0j1l^OVNTa0i1m^OWNSa0h1n^OXNRa0g1o^OYNQa0f1Q_OYNo`0f1R_OZNn`0e1S_O[Nm`0d1T_O\\Nl`0c1U_O]Nk`0b1V_O^Nj`0a1W_O_Ni`0`1l0N2O1O1O1O1O1O1O1O1O1O1O1O1O1N2O1MQ]OTOPc0f0P]O]OSc0b06M3001OO1001O00O11OO1002N0000000000000000Bf\\O6Zc0Jf\\O5\\c0If\\O5]c0Id\\O5Z_c4", "size": [640, 640]}, "area": 43343.0, "iscrowd": 0, "image_id": 17029, "bbox": [0.0, 0.0, 405.0, 243.0], "category_id": 169, "id": 20001066}, {"segmentation": {"counts": "QPa91oc00O2O00001O1U\\OLhc04X\\OLhc07O001O001O001O2N1O000000O1N2001O00003M000000000000002N00000000O100001O1O2N001O3MO10000Eh\\OLZc0Lj\\ONN3Z_n1", "size": [640, 640]}, "area": 705.0, "iscrowd": 0, "image_id": 17029, "bbox": [488.0, 0.0, 53.0, 24.0], "category_id": 171, "id": 20001067}, {"segmentation": {"counts": "R2`0kb0e00001O003M2N1O0001O1N2O2K6M4LOVOo\\Of0Qc0[OP]O>Vc0Bj\\O;Yc0Eh\\O6]c0If\\O1]c0OjZe0:SeZO4L4K4M4K4L5J5L5N2N1O2O0O2O0O2O0O2O1N101N1O100O1000001N1000000O10001O0O10000O10001O0O2O1O001N2O1O001N2O1O1O0O100001O1O1O1O1O1N2O1O1O2N1O1O1N2O1O1O1O1O1O2N1N2O1O1O1O1O1O1N2O2N1O1O1O1O1O1O1O1O1O1O2N1OW_O]OV>b0iAAV>>iADW>;hAGX>8hAJW>5hANW>1hA1X>NiA3V>LjA6V>HkA8U>GlA8U>DnA=R>_ORB`0o=\\OTBe0l=WOXBh0i=TOZBm0^`0N101N10O001O001O1O001O1O001O10O01O001O010O001O001O1O001O001O1O001O1O00001O001O001O00001O001O00001O001O001O001O001N100L5K4M4M2M4M3M3M4L5K4M4K4L5L4L3L5L4L3M4K5L3M4L5K5K5K5TCQK_:S5PEjK_:[4WE^LV:f3cE`LY:d3bE`L\\:d3]EbL_:b3[EcLi0fMZ8l5gFbLl0fMZ8k5dFdLP1cMY8i8eGYGY8h8eG[GX8g8gG[GV8g8iGYGW8h8gGZGW8g8iGYGW8g8hG[GV8g8iGYGW8g8iGZGU8g8jGZGV8f8jG[GT8g8jGZGV8g8iGZGU8i8iGWGW8l8dGWGV7WOYIf9]OTGX7[OWId9]OTGZ7[OVId9]ORG\\7]OTId9]OoF`7@PIc9]OmFd7BlHc:T7`EiH`:X7bEeH]:\\7gEaHV:b7lE[HS:g7mEXHR:i7lEYHT:h7P12O001N2O1O0O2O1O001N10000010O1O1O1O101N1N2J6N1N3N2N2N1IdCiH_a0W6bN[1f0PH7a0>X6`NW1l0PH6b0=`>^On@5c0=]>_OPA3e0=Z>AQA2g0CSA1h0;T>ETA0i0;P>R1RBlNm=U1TBkNj=V1WBiNg=Y1XBiNg=W1XBYMUO\\1b>\\1XBYMWO[1`>\\1XBZMYOZ1^>\\1WB\\M\\OW1]>\\1WB^M\\OW1\\>[1WB`M]OU1[>[1WBaM^OU1Z>Y1XBcM^OT1Z>Y1VBeMAQ1X>Z1WBgM@o0Y>Z1VBhMBm0X>[1UBiMCl0X>Z1TBlMDh0Z>:bAZO?EFe0Z>]1PBPNF`0\\>`0_AWO>JH=\\>b0^AVO>LI9]>d1hAUNM3\\>k0[ARO;3NN]>m0ZARO952H]>Q1YAPO794D]>T1WAoN6;8^O]>X1UAnN5?:XO]>[1UAlN3c0_1RAkN2e0?oN^>a1RAiN0i0k?>V@gNNm0l?O1O1O1O1O1O1O1O1M3G\\NfGf1Y88M3N2O100O1N20000O1O1N200M3O1O100O1000000O100O10000001O000000O100O100O100N2O1O1O1N200O1N2O10000001O001O1O00000000O1000000O1M3J600O100O100O100N20000O10000001O002N1O1O001O001O1OO100001OO100O100O1O1N20000001O00001O00001O00", "size": [334, 500]}, "area": 11500.0, "iscrowd": 0, "image_id": 17031, "bbox": [375.0, 219.0, 125.0, 115.0], "category_id": 160, "id": 20001069}, {"segmentation": {"counts": "0gbj02cgUO2O1N3N1O1O2N100O2O0O101N1O101N100O2O0O101N1O100O2O0O101N100O2N100O2O0O101O0O101O0O101O0O1000O01000O^KgN1Y1MiN2W1LlN4T1JoN5P1ISO6n0GUO9k0EWO;h0C[O^I]Og6b0[IXOi6g0YIUOj6k0WIPOn6o0SImNP7R1RIiNR7W1oHeNU7Y1mHcNV7]1kH_NX7`1l000O101N3N9G4K01O001O00001O00001O000010O00010O001O01O01O010O00010O0010O00010O01O01O01O1O1N2O1N2O1O1N2O1N2O1O1N2O1N2O001N2O1Noe4KUZK4cF2U81UG3KF08o82PGd0o8>O1O1O1O1O1O1O1O1M3G\\NfGf1Y88M3N2O100O1N20000O1O1N200M3O1O100O1000000O100O10000001O000000O100O100O100N2O1O1O1N200O1N2O10000001O001O1O00000000O1000000O1M3J600O100O100O100N20000O10000001O002N1O1O001O001O1OO100001OO100O100O1O1N20000001O00001O00001O00", "size": [334, 500]}, "area": 124212.0, "iscrowd": 0, "image_id": 17031, "bbox": [0.0, 0.0, 500.0, 332.0], "category_id": 169, "id": 20001070}, {"segmentation": {"counts": "gbj01[:3N1N2O2N1O1O2O0O101N100O2N100O2O0O100O2O0O1O2O0O101N100O2O0O1O2O0O101N10001N10001N10001N01000O0100O^KhN0X1NjN1W1LlN4S1KoN5Q1HRO7n0GUO9k0EWO;h0C[Of4FYK9f4JXK6g4MWK3g42WKMh46UKKi4:UKEj4>UKAj4c0RK^Ol4g0QKYOo4i0oJWOP4dIZLX7CTOi3QJaLn6CQOb3^JhLc6DoN]3gJlL]6FkN^3kJiLS=X3nBfLR=Z3PCdLP=\\3QCcLo<^3QC`LP=`3RC^LnU4]J]Ln4Dd0n3^JaLg4Fk0h3_JdL`4IP1c3_JgL\\4KS1]3aJkLV4KZ1Z3`JmLQ4HdJWOk6S4`JRMk3Gi1W3\\JTMf3Im1R3]JXMa3JQ2n2]J[M]3HYKjNl6R4^J_MY3G^KgNk6S4]JbMU3H`2e2[JgMP3Fe2b2[JkMk2Fj2_2ZJoMg2Fm2[2ZJSNd2ER3X2YJWN`2BX3W2WJ[N[2@_3U2UJ^NX2@b3R2UJbNS2Af3m1VJeNP2Ai3j1VJiNk1@o3g1UJlNh1_O[MeMc6P4YJPOc1^OaMdMa6n3ZJTO_1CW4Y1YJWO[1C\\4V1XJ[OW1B`4S1XJ^OS1Cd4o0WJCo0Aj4l0UJGc0IX5`0SJL5OWOTLa6Q4QJ0H8FhK`6P4PJg4S6YKlIh4T6XKjIk4U6UKiIl4X6TKfIl4GSGc6Q4dIn4IQGc6Q4bIo4a6QK^IP5b6PK\\IR5d6nJZIT5f6S401OO1N200O10000O1001O0000MWIoBi6Q=WInBj6R=2001OO11VIoBc6Q=[IQCe6U=0000000000000O1002NO11O0000VLbIRJ>_LY5Y9dJRJ4eLX5T9mJSJJiLZ5o8VKSJ@mL[5j8`KUJSORM]5d8iKVJjNVM]5^8TLVJPN[M;1OOS5W8PM^J`M[M:4HLO210]5j7`MfK`2n3nMPLR2l3SNSLm1l3VNQLk1m3YNQLg1n3[NQLe1n3^NPLb1o3aNoK_1o3dNoK]1P4fNnKZ1Q4hNnKX1Q4kNlKV1R4nNbK`KeMd5h6nN]KcKjM`5h6POYK[KkM63_5h6ROYKYKkM83]5g6UOZKVKlM83]5f6WOZK^KPN[5e6YOYK^KQNY5d6\\OZKT1e4nN[KQ1d4QO[Ko0d4SO[Km0c4VO\\Kj0c4XO\\Kh0c4ZOZKh0e4ZOYKg0e4\\OYKe0f4_OWKa0h4ERKm2SBhLn=X3[B^Lf=a3dBUL]=j3mBkKU=U4[1O100O100O100O100O100O100O100O100O100O1O100O11O1O1O1O1O1O2N1O1O1iHmK_NT4`1nK^NS4`1PL^NQ4a1QL]NP4b1RL\\No3b1TL\\Nm3c1UL[Nl3d1VLZNk3d1XLZNi3e1YLYNh3e1[LYNf3f1\\LXNe3g1]LWNd3g1_LWNb3h1_LWNb3h1^LXNc3f1^LZNc3e1\\L\\Ne3c1[L]Nf3a1TLVHZOY6d4_1QLYHVOO0\\6j4Z1nKZHYO3OY6k4Y1mKoNS4Q1mKoNS4P1nKPOR4P1nK\\HWOb6k4R1PLnNQ4Q1nKPOR4R1jKPOV4Q1iKoNW4S1gKmNY4U1eKkN\\4V1bKjN^4\\800001O0000000000000000000000000000000000O100O1O1O100O1O1O1O100O1O1O100O1O1O10UB`KV<_4jCbKV<]4kCdKT<[4lCfKTfN`Bi047UO:X?]OhA0UOc0T?ZOlAJUOm0X?oNgALVOU1la010000O100O10000O10000O100O10000O100O100hNbNn_O^1^?ZO]@g0P?0l@0f>b0VA^Oj>g0PAZOP?j0l@VOU?n0e@SO[?i20000O11OO100001OO100001O7fK[@k3m?00000002N4L3M3M4UMm_Oa1V`0oMZ@n1Pa0L3M3M4L3M2N1O1O1ORMmNoBS1Q=[ObBd0^=IVB6k=OoA1P>4mAKS>9dAL]>7QA7o>]20000O11O00O1O12N002N00]1cN2N3M2N2N3M2N2N1OO100O10000O100O1fLdMPE\\2b:QN_Eo1Y:YNhC]O`0[2b;^NoCB3P2i;cNTDIGd1UZ3ka3aZMPCf2P=ZMPCf2o<\\MQCc2o<\\MRCd2n<\\MQCe2n<\\MQCe2e\\1a2[01O0000O1001O0^M_@e0a?nNl@R1Qa000000000000000000000000000000000000000000O10000O10000O10000O10000O10000O100O10000O10000O1L400mLYNlCh1i;cNWD]1k:UNhBj0]2Q1l:\\OZBfN00j2n1l:[O]BgNf2o1m:YO^BhNf2n1k:ZO[Eg0e:YOZEh0_:PNgBW1l2h0\\:RNcBO0Z1S3c0W:SNgB3OW1S3c0W:DlE:T:EnE:R:FoE9Q:WNfB]1Z300000O1O1O1004L1O001O001O1O001O001O001O1O001O001O1O001O001O1O001O001O1O001O001O0000oKQOQEo0`:A_E?]:EcE;Y:HhE8U:KkE5Q:NPF2l92TFNh95YFKc99]FG\\9`0dF@]9?cFA^9>XFLh90fBcNc3O]L\\1Z=KfBmN1Md3[1e9KhBjNO0d3\\1e9IiBjNg3]1a9HhBkNh3\\1_9GfBmNQ4\\1Z9FgF;X9FhF:X9FhF:X9FhF:X9FhF:X9FhF:W9GiF9X9FhF:X9EjF:V9FiF;W9EiF;W9EjF:V9GiF9X9FhF:X9FhF:X9FiF9V9GjF:", "size": [640, 443]}, "area": 53639.0, "iscrowd": 0, "image_id": 17115, "bbox": [0.0, 416.0, 443.0, 224.0], "category_id": 124, "id": 20001073}, {"segmentation": {"counts": "jj91mc04X\\OO\\c04a\\OMTc0f0O00001O0n\\OUOnb0o001O01OO110O000ONT]OROlb0n0T]OROlb0n07TOm\\ONOd0\\c0N3NOO1001O00O11O000000000M4N11O02IZOo\\Og0ob0YOo\\Ok0Qc0UOo\\Ok0Qc0200000001NO6M:[Oh\\OMYc00_\\>7]cA9H8XOi0K41OO10O021M3N00010N010001;K`]OaNWb0a16J6J6]O\\]O^OYn9k0[dF4L4L5K3M4L5M21aNg]OU1bb00M27K3L6I7I7L4J5M4JTo9NgPFb0D=D2N1O00O10000000001O001OT]OoNib0Q1V]OPOjb0T1O0000O1O10O101O00O1000011L3ROR]ON000O1b0Zc011O00001O001O0000O10000M_Og\\O`0Zc03I]OQ]Oc0lb0BR]O=nb0DQ]O=ob0CQ]O=ob0CQ]O=ob0Co\\O?Qc0800O1000000O100OWOS]Oa0mb0]OU]O0N^c0Bd\\O=_c0000NFb\\O7[c0He\\ON0:^b0Fe^O8[a0Ie^O7Za0Jf^ONlN5\\b00j^O0Ta02P_OIo`09[12M2O1`\\OC]c0?11O0001O0001O001O0d\\O^O\\c0d04J6J6J`en0V1[YQOK401N011OSNoNP_O0i1Q1V?ROi@n0W?SOi@LYNo0l`0VOn@i0S?XOl@g0T?[Oj@g0U?YOj@j0T?VOl@j0S?XOl@j0Q?WOo@j0P?XOo@h0o>ZOm@i0S?XO]_O@Z1[1W?VO^_O@\\1Y1V?ZOj@g0T?ZOl@f0T?YOl@g0U?ZOj@e0X?ZOh@g0_?QOa@o0a?oN`@P1b?nN_@Q1c?kN`@S1c?kN]@T1f?jNY@V1Za0Oobd0kNe][Oh0]Oc0J6I7H7J5J6K5J6K5K5K;E8D^Li_Oc3O]Lo?0U@1Md3n?]LR@O0d3n?^LQ@g3o?YLQ@h3k?ULU@Q4k?110000000000000O2OO10010O000001N0cA", "size": [640, 443]}, "area": 10984.0, "iscrowd": 0, "image_id": 17115, "bbox": [15.0, 438.0, 428.0, 158.0], "category_id": 136, "id": 20001074}, {"segmentation": {"counts": "mW[4112jc02V\\OMfc0612M3N1O0O100N120HBj\\O=Yc0Dg\\O;Yc07OO11e\\O\\OWc0h0K4O1P]OUOjb0l0U]OUOkb0P1O1O01000O10000O100O3N00L4O1K410O2M1O200001m\\OTOPc0l0P]OVOmb0o0001MU]OSOhb0j0W]OVON0kb0S1O000V]OlNhb0V100001O0O1lNW]OP1lb020O0O1001O010O101NmNU]OR1nb0N01O0003L8I6K5J6J6L[kj0l0]SUO;D;L5OO11O00O10i]OZNSb0j11O1N1O101O002O0L4`Nb]OZ1`b0eNa]O\\1ab0000O02O000001O1M3O00O20aX[1", "size": [640, 443]}, "area": 3809.0, "iscrowd": 0, "image_id": 17115, "bbox": [222.0, 484.0, 151.0, 61.0], "category_id": 150, "id": 20001075}, {"segmentation": {"counts": "_`11nc05K5L4K5K5K9F:G9C=A`0D;E;E6J7I6I7J6I8I6J4L3M2N3L4L4M3O1O1N4M3M3M3L4L4M4L3L4M3M3L5L3L5L3M4K5M2mNkHWEX7\\:UIaEn6R:_IkEc6l9fIQF]6m9fIPF\\6o9eIoE^6n9dIPF^6n9cIQF_6n9aIPFb6n9`IPFe6k9R2^H_FQOTOe3i:kLXFWOTOo3j:cLWFUOTOX4P;UKmDc0T1GTOc4l:PKYE9k0LUOk4X>0O2O0O2O001N2O1O1N2O0OO2O1N1O2N2O001O00aN\\KdCd4k7QKmJS1TMk3n7aKcIg1YNh2T8oKmHf1kN[2W8^LWHe1]Ol1\\8nL_Gd10_1`8n0\\GQOd8V6OiD[GT;e8mD]GQ;a8PEcGl:]8UEeGh:[8YEgGe:Z8YEjGb:Z8\\EhGa:n8M4L3M4M2NX1hN6J6J6J6YH`Db6bX4N2N2N2O1N2N2N2Naef06UZYO;F9G:E;F9F;C=@?@>J5N3L4M2N3M3L3N3M2N3L4M2N3M2M3N2N2M3N2N2N2M3N2N2N2M3N4L6J5J6K9G`0_Oa0@`0@?A8G8I7I7I7H9H7I7`GcFb4QOaKd:ZOhFT5oNWK`:ROnFg5kNmJUbC@0120\\<`0eC_O`c;B^D=b;C_D;^;IcD6\\;KeD4[;LgD2Y;NiD1X;MfD5Z;KhD3Y;LhD4W;LjD3W;LkD2V;MkD2V;MQEKP;5TEFn:9REFn:;cD1@En;OlD@Se15fZN4O3L10001N03M3O3L3L4N\\Z82aeG4L5K4L2N00000O20OO6KM5L1N5K6J4M^=Oo_20nbY2", "size": [427, 640]}, "area": 1880.0, "iscrowd": 0, "image_id": 17178, "bbox": [11.0, 210.0, 445.0, 80.0], "category_id": 124, "id": 20001079}, {"segmentation": {"counts": "W;T2T;mMnDS2R;mMmDT2S;lMmDT2R;mMnDS2R;3O1001OO10000M3N200O1O1AfMmEZ2P:iMPFW2l9bMlE85HK^2T:oMmEV2R:lMmET2T:a00000N20000000000IiLZFW3c9jLXFO20OW3g9jLXF01Y3c9;00O11OO100O100001OO11OO1001O00O12N00O11OO100O11O00N200000000000XL_Ff3c901ZL\\Fc3f901O0000O100O10000001OO1O10000N200O100O100O1002NN20000000000O1O1MTLfFm3T9SLlF02o3m8QLQG0120n3n8SLQGR4o8nKQGR4o85001O001O00O1O100000000O12NO100O11O000000O1000000O10000N2O1O1N2M^K\\Gc4d821O00O11OO10000O11O00O10000N2O11O0000O1001OO1O11O00O11O00N2001O001O1O000000001ONYK`Gg4_8ZKbGe4_8ZKaGf4_8ZKaGf4^8[KaGf4_83002N000XK_Gf4c80O10000N21OO11OO1O1001OO100M3NSKfGm4W8SKiGP5U84O1000000O100N20000001OO100O100001O0000O100O11OO100O100001OO1L4K5L\\J_Hf5a7200O100O11O0000O10000O100001O00000000O10000O11OO1O1O100000000O10000001O00001O000000O1O1O1MPJkHP6U73O1O100O1L4N200;E1O1ODSJYIn5d6>1O1O0kIWIh5j6SJYIn5R70O1N2N2FlIXIY6f6lI\\Io5W6kI\\JU6d5lIZJU6h5kIVJU6k5lIRJU6n5nImIT6S6b0O100O100O10000O100O100O1007I2N2N3M2N2N4Lc0]O5K5K3M00DoEWOO4S1OROe0l90RFYOM0R13ROg0l9MSFXOQ15lNk0P:FZG_OfNl0o9E[G`0h8\\O[Gd0e8\\O[Gd0d8]O]Ga0e8@XGa0h8]OmE_OZ1U1j8XO[Gh0d8[OZGd0h8[OXG2dN^OO>U:2XG1hNLP:3XGOjNNo93VGOkNJIIW:=UGOnNEGN00V:OiE9`15POBB0Y:7PGP8R1QICnNSO8J3>e7R1iH`NWOO4S1OROe08X7U1hHaNYOM0R13ROg08T7W1iH`NXOQ15lNk0;o6Y1gHF_OfNl0:n6Z1gHF`0UOf6V1fHHd0SOlN@N000c7e1oHHd0[O]6l0PIJa0[O_6l0QIFa0^O^6l0oH[N_OZ1U1^O]6o0kHHh0ZO\\6m0oHGd0^O\\6l0oHF2dN^OO>j0T7m0nHF1hNLg0S7k0PIFOjNNe0S7l0PIDOkNJIIm0]7l0PICOnNEGN00m0]7k0bHWN9`15POBB0m0^7m0iH_O<;k68bHSN1Z1a0eN^Ob1b7>`HUOe0lNYO`1c7g1PIiL_Oc1k0]Nf5W3lIhLB3Ob1a0[NJ2V6U3oIjL@k1?TNa6W3aIgNNRNM1U6W3mIiN`0oMb5X3nIhLBo1`7Z1oHgNP7X1QIiNLoMd6X3_IkNLmMe6Y3]IkNNlMe6X3[IiLET2:kMf6W3]IiLDS2:mMe6Y3ZIhLFT20VNo6n2RIgL6e2h6c0RIjL4e2i6b0SIgL4X1KjN0O3S1k6U2RIhL0[1=F0nNR6j4nIXL0nNR6k4nIVL0ROo5h4QJWL1oNn5j4QJWL`6i3aIVL_6j3`IWL`6i3eIRL[6Q4aIPL_6l3fIRLKUOo5i4VJRLKVOn5h4WJRLLUOm5i4WJRL[6n3dISL\\6m3eIRL[6n3eIRL[6f3SI_Ke0l0X6c3nI]LR6a3PJ_LP6`3QJ`Lo5a3PJ_LP6`3RJaLl5^3UJcLj5_3TJaLl5]3WJbLi5^3WJaLj5_3VJaLj5]3XJbLi5^3WJbLi5^3VJbLk5`3UJ^Lk5c3WJdKmNa0l6k3\\JTLe5l3\\JSLd5m3RIdKW1=h5T4XJkKh5U4WJkKj5V4WJhKi5Z4UJdKm5[4UJ\\KS6g4iIYKX6g4V100O1O11O1O0000O11O1O2N002NO1000000000000001OO1O1O1N2L^G_Kb8a441O1O0\\G[Kb8g40M31O00L\\GaKd8_4\\G`K10`8`4bGaK^8^4dGaK\\8`4aGcK3MK1T8a4lG^K92l7d4oGYKN2T8f4lGYKNO11U8g4jG^K0JW8d5^O8HH8000000O100O10000O1001O1O1OO10000O100O10000O100O10000O100O100001O00001O00001O00001O001O00001O2N1O2N1O001OO1O100O11OO11O0000N21O1O00001O1O0aHVJ]7l501OO11O001O00000000N2J6M3O100O100O10000O1000000003M00000000000000000000000000001O00000000001O0000000000001O00000000001O00O100O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O100O100O100O100O1O100O100O100O100O100O100O100O100O1000000O10000000000O100000000O100000000O100000000O100000000O1000000O1O1O1N2O1O1O1O1O1O1O1IkFWLV9f3oFWLR9g3PGXLQ9i381OM3O11OM31O1OM3O11O1O1O1O00O1O100O100O100O1O100O10000O10000O10000O1000000O1", "size": [427, 640]}, "area": 87008.0, "iscrowd": 0, "image_id": 17178, "bbox": [0.0, 0.0, 640.0, 222.0], "category_id": 169, "id": 20001082}, {"segmentation": {"counts": "enZ33Q=8M2O1O01N2O1O1O1N2000O10001O1O001O100O001N3N2N2O0O7I4LM3C>O001O0000000101N=C1O00BkCCX<<;10001^CDSm;L5K5Kk>=^@P1PO=C:G:L4L3kNSMjGP3S8UMgGn2X8VMbGn2[8TMbGo2\\8TMaGn2^8SMbGm2\\8UMdGk2Z8WMeGj2Z8WMfGi2Y8YMeGh2[8XMeGh2[8XMeGh2\\8WMcGj2]8VMcGj2]8WMbGi2^8WMaGj2_8VMaGj2]8aLZGd09k2W8^MhGc2U8`MkG`2T8bMjG_2V8aMjG`2T8jLfG85o2U8iLfG85o2T8jLgG74P3U8aMjG_2V8aMiG`2V8aMjG_2V8aMiG`2W8`MiG`2W8`MhGa2[8[MfGe2Z8jLeGM0Z3[8hLgGMN[3[8hLgGh3Y8WLiGh3W8XLjGg3V8ZLiGf3W8[LhGe3X8\\LgGe3X8[LiGf3U8[LjGf3U8ZLkGh3S8XLmGi3R8XLmGj3Q8VLoGk3P8VLPHk3o7TLQHn3m7RLSHo3l7RLSHP4k7PLUHQ4j7j0N101N2N1OmJ]H`4a7^KaHc4^7\\KbHg4\\7XKcHl4\\7b0O2N1O2N1O2O1N1N3N1N3M2N3M3M2N3M2N3M2N3M3M2N5K8H8H5K1O100O100O100O100O1O100O100O100O100O100O100O100O100O1000000O10000000000O100000000O100000000O100000000O100000000O1000000O1O1O1N2O1O1O1O1O1O1O1O1O1O1O1O1O100O1O1O1O1O100O1O100O100O1O100O100O100O1O100O10000O10000O10000O1000000O1", "size": [427, 640]}, "area": 54706.0, "iscrowd": 0, "image_id": 17178, "bbox": [256.0, 108.0, 384.0, 319.0], "category_id": 183, "id": 20001083}, {"segmentation": {"counts": "Ydf11Y=3_FMg54WJMi54bFKb31l56TJJl5;oIER6TOX;3aDM:0i;NXD2h;I]D7\\<1O00N2N20an1N]PN=^DJ[;8cDNh:c0VE_Oi:b0TE@l:a0SE_Om:b0PE@P;^10001O0000000000000O100000O1000000000000000000000000000000001O000000000000000000000000000000oNlDmN30Na0S;a0ZE^Oa;F[fW1", "size": [428, 640]}, "area": 117739.0, "iscrowd": 0, "image_id": 17182, "bbox": [0.0, 0.0, 545.0, 276.0], "category_id": 123, "id": 20001087}, {"segmentation": {"counts": "b8j4a81O1001O000000002N00001OO11OM3M30000NSKeGm4[8200001O00O100000000O10000000000O10000000000O10000000000000000000000000000O1000000000000O10000000000O1000000000000000000O100000000000000O10000000000000000O1000000000000000000O100000000000000O10000000000000000O100000000000ULQHY2n7fMUHX2l7hMUHV2l7jMUHaNKb3P8mMWHS2i7mM\\Hn1d7SN]Hj1d7VN\\Hi1e7WN[Hi1e7WN[Hi1d7XN]Hg1c7YN]Hf1d7ZN]He1c7[N]H`1h7aNYH[OBR1T8CZHeNMINR1E\\Oa8T1oGbN`08ZODn8b1WG`Ne0Nj8c1aF^Nf:c1a0000000O1N2O10O100000N2NUDcNk;]120000N20O1000000000O100000000000O10O100O1O1O1nNQDg0o;WOVDe0k;ZOZD`0i;]O]D`0[TOZ1a4\\3bKSKM:0W1a4P4]KjJ2V1a4P4XKoJ7Q1a4i4`KVK`4j4`KVK`4j4^KXKb4h4\\KZKd4f4\\KZKd4g6000000000dIZKQ4g4kJfK@J_5`4PKhK_ON\\5Z4eJYLM_O]5X4fJZLJ@`5V4fJ[LI_Oa5V4fJ\\LF@d5T4fJZMZ5f2fJZMZ5f2fJ[MX5f2hJZMX5f2hJZMX5f2hJZMX5f2hJZMX5f2hJZMX5f2hJZMX5f2hJZMX5f2gJ[MZ5d2fJ\\MY5e2gJ[MY5e2gJZMX5h2hJXMX5h2hJXMW5`NZJb3?nMW5aN\\J^3=QNW5`N]JDN_3>]NW5`N_J]O0g3:\\NW5`NhJT31\\NW5`NiJS30]NW5`NhJT31\\NW5`NhJT31\\NW5_NiJU30\\NW5_NiJU30\\NW5_NkJ?^OTO6n1:0W5_NnJ4Ma1NLV5`NTKOIc1MNW5lMYJ118OIl0?E_O_OV2`0Nh5nMfJm0cL[18Kg2mMjN;YNQ47fMe2oM_N`5lNaLe2PNSNj5XOVLe2Z5ZMfJf2Z5ZMfJe2[5[MeJe2\\5YMeJf2\\5YMeJg2[5XMfJa1mMSO^7\\OeJ2kM@01195O2ILn0]7\\OeJ3FBWNa0`7GdJJd0MWM0P`P1", "size": [428, 640]}, "area": 51935.0, "iscrowd": 0, "image_id": 17182, "bbox": [0.0, 0.0, 563.0, 428.0], "category_id": 172, "id": 20001088}, {"segmentation": {"counts": "^\\V42Z=1N100MMlB4S=30000000000O1000001O000000HoB5Q=JPC6S=00000000000PCNe<3:1O000000000000001O0000O01000000000O1000000000oV`3", "size": [428, 640]}, "area": 421.0, "iscrowd": 0, "image_id": 17182, "bbox": [321.0, 220.0, 50.0, 20.0], "category_id": 177, "id": 20001089}, {"segmentation": {"counts": "]b]24V=5L5J6K5J6K5J6J5L4M0O10O0100O100O100O010O1O10000O10O100000000000000O10000000O1000O1000000000000O1000000000000\\NaD[1_;81c0]OO1O1O10O01O1O100O1000O1000000000000O10000000001O000001O00000000001O00NnMjDR2V;nMjDR2U;oMkDQ2U;30mMkDP2T;PNlDP2T;40000O1001O00001ONkMmDU2R;lMnDT2Q;nMoDQ2Q;oMoDQ2Q;oMoDQ2Q;VNlEf0U:SOnD?c1O00000000O100000O101O0000O1O1O100O1000O100000000000000000O10000O1O0HgAJ[e42[iK2N1O004K2PBDZ=<[BD11c=c\\BBd=`0ZBAe=a0YB@f=b0ZB]Oe=g0XBZOf=OUBc06^O8OkO[=1hBO]>0dnQ9", "size": [480, 640]}, "area": 435.0, "iscrowd": 0, "image_id": 17207, "bbox": [0.0, 182.0, 21.0, 56.0], "category_id": 105, "id": 20001092}, {"segmentation": {"counts": "]Z51j>1XA0h>5MJZA7e>200000000O1001O4H4OL6O1O2M2O00O2O000000000000000000000000000000O01000001Ln^c8", "size": [480, 640]}, "area": 372.0, "iscrowd": 0, "image_id": 17207, "bbox": [11.0, 164.0, 41.0, 12.0], "category_id": 132, "id": 20001093}, {"segmentation": {"counts": "_9a5_90000000000000O10000000000kM`JiJa5W5_JfJd5Z5\\JdJf5\\5ZJcJg5]5XJdJh5\\5XJaJk5_5UJ_Jm5a5SJ]Jo5c5QJ\\JP6d5PJ[JQ6e5oIoH0R1R6m5oIQI0n0U6[6lIcIU6]6kI[IN[OW6Z7kI[IOYOW6[7lI[INYOV6\\7lI[IOXOU6]7lIoHLZA8b>8K4L5Ko0QOa0_O000000000000000000O100000000000000000000O100000000000000000000000000UNPDe0Q`e020O11KiA_OX>8PBHQ>0oZk6g0ndTIO000O1000O10O1000001N1000O1O00100O10O100000000O1000000O10O1000O01O1G@QBa0g=?01G9000O102N8H1N5L2N1O004K2MgA]OY>8gA1\\>GdA414a>H_A9a>G_A9c>05K1OQ`[1", "size": [480, 640]}, "area": 2013.0, "iscrowd": 0, "image_id": 17207, "bbox": [0.0, 61.0, 547.0, 122.0], "category_id": 169, "id": 20001096}, {"segmentation": {"counts": "[7T2a;UNbEj1^:cNVE[1k:[O`Dd0`;^10TM_DY2b;fM^DZ2d;dM]D[2e;cM[D]2g;aMZD^2h;aMXD^2n;^MQDa2o;`MRD9Nc1QZ3[AlK11Oh0f>Y3ZAoK10Oc0O\\Oi>T4nAQLV>S4i0N1N4M22N1OO0114KO1O0010ZK", "size": [640, 478]}, "area": 133574.0, "iscrowd": 0, "image_id": 17379, "bbox": [0.0, 103.0, 478.0, 377.0], "category_id": 133, "id": 20001099}, {"segmentation": {"counts": "Ra0n2Ra0000000O1N2O1O0O2O1O1O1O1N2O1O001O1O1N2O10O10O10000O2OO010O10O10O010002MO2000O011N10O10O1000O0100O3N000O3N0O10000O10O11N100OO200O01TOS^OEka00Q^OZO00011O;a0aa0_OS^Od0n0FPa0;S_OCl`0=U_OCk`0V_OBj`0>V_OAj`0`0U_OAk`0?U_OAk`0?U_OAk`0?T_OAm`0a0`^O\\OI7fa0=`^O_OH5ha0`0Y^O@L0la0a0V^O0ja01T^O0la0R10O10O10O10O10000000O1000O1000000O100000O1000O100000000O11O0O01001OO11O0RNQ^Ok1Rb00O1001OO10000000001N10000000001O0O1000000O101O0O10000000001O0O10001O001O001N101O0O2O001O00001O001O010M`Md^O`2\\a03N101O001O0O3N3e_OTM\\?n2`@TM_?P3\\@RM`?U3[@mLd?W3V@lLi?X3R@jLn?d30000O100000000000000000000001ON2001ON2001O001O1O000000O11O0000O1000000O100000000O1000000O1000000000000O10000000000O10000O100000000000000O100000000O11O00O1O100O1000000O1O1O11OO1000000M30000001O00N2000000001O00N21OO11O00N_Ke@a4[?200O12NO12N00000000000000O10000O11OO1O100O11O00O1001O0000N20000NZKj@f4V?21O0000O11O0000000000000000O100N21O00O1O11ON2O1000000O1O100O10000000000O100000000O1000000OfLeAQ1[>nNgAQ1Y>oNhAP1X>oNjAP1V>POkAo0U>POmAo0T>POmAo0Q>ROPBn0P>ROQBm0o=ROSBm0m=SOTBl0l=SOVBl0k=ROWBm0i=SOXBl0h=SOZBl0e=UO[Bk0e=TO]Bk0b=VO^Bj0b=VO_Bi0a=WO_Bi0a=WO`Bh0_=YOaBg0_=YObBf0]=[OcBe0]=[OdBd0\\=\\OdBd0[=]OfBb0Z=^OfBb0Z=^OgBa0X=@gBa0Z=^OhB`0X=@gBa0Y=_OgBa0X=@iB?W=AiB?W=AiB?W=AjB>V=BjB>V=BjB>V=BkB=U=CkB=U=CkB=T=DmB;S=EmB;S=EmB;S=EnB:R=FnB:Q=GoB9Q=GPC8P=HPC8P=HPC8Q=GoB9P=HPC8P=HPC8on\\O\\O04Rc0`0n\\O\\O10Tc0d0k\\O\\O10Tc0d0k\\O\\OWc0e0201O00O20O03M1ONk\\OYOUc0g021_^OYOg?f0Y@[Oh?e0T@Ed?jNg_O9OB_1U1Y?YOi@k0S?UOm@g0W?XOj@j0U?iNY_O:b1m0U?iNY_O008b1S1Q?eN]_O007c1S1S?fNZ_O7b1Q1Y?oNh@S1U?lNl@T1T?lNk@U1V?gNW_OOc1U1NkNi=1f@O`1Y1NfNcN1m`0Y1_@oN]?W1]@lNa?S1a@nN\\?S1e@lN\\?X2`_OhM_`0Z2`_OfM_`0m220OO2ON30N11N02lLZ_Ol2h`0oLX_O10Q3n`0PMR_Oj2Ta0N2OO?BO00000LY_OoLf`0R3[_OmLg`0R3Y_OmLg`0T322N0O1000aMY_Oe1g`0TNZ_O_O4\\2c`0hMZ_O51W2f`0aM]_O5NJO0NX2Qa0lM[_OU2e`0jMa_OQ2a`0lM__OU2Wa0N2N101OM30020L021O00002NN2N20O001N20000b^OlMn`0V2S_OjMo`0R2S_OmMm`0S2?10000O400IVN^^Oa1_a0RNa^O0062h1ca0XN]^Og1ba0YN^^Oh1^a0ZN`^OG0R2ba0TN^^OJ0R2ba0TNb^Oj1`a0VN_^Oi1aa0RN]^OO5o1la0M1O3NO0n]OXNna0f1P^O\\Nna0l1O1O12N1O1O0010M31ON23SNo]Od1Qb0[NP^Od1Sb0YNP^Od1Wb0OXF_NT1N]FZ1^8iN\\1V1bNmN_1Q1^NROe1k0\\NUOd1i0[NZOd1f0RNnNQHg0b9?YNoNTHX1MjNj1IR5U1W1mNnGT2OjMX12f5P1h0ROaHm2YKWAh4l>412NO10\\OTKTBl4g=[KXBd4b=eKZB\\4a=lK\\BT4^=UL_Bk3\\=]LaBc3Y=g1YI\\IJg61`IhIOa5f6c0PJVOW6g0kImNb6Q1_IoN_63aJJb55_JId56\\JIe59YJGf5;YJEh5:XJFh5;WJEj5:VJAo5>RJCg5XK\\HU5m1Cg5[KYHP5R2Fc5`0^J@c5?]JBd5?XIUKA\\4V7?XIXKXO@Oj4_7=[I[KRO\\O1U5b73^Ig0`6WOdIh0\\6XOdIj0[OTJX6Q5]JQ1TOnIHLf6U5^JT1ROmI`6o4]Jc1kNYIh6S5\\Jc1j5\\NVJh1f5YNZJi1a5XN`Jk1]5SN^ImJV12jNl6h0UIh4R5hKlJiNQ7`0UIP5k4hKnJhNW77WI4Ce4P5]LoJdN1NQ72_I2Gm4i4]LoJdN1O0OP8R5oLeLPKYNQ8R5oLeLPKZNQ8o4RMZKnJF0X1P8h3UMTKTKP1h7l3UMRKWK0Di0Q8U4SMPKgKd0V7Z4mGRKU6d0n1U4XNlKi1R4YNmKg1S4YNkKi1V4VNiKk1X4TNXKeI=W8\\4WNbKk1V4gGaK`69i11gGI0a30YL21N0_656Tb0Dg]O<00[b0Q1ONg]O]NXb0c1g]O]N[b0c11Ie]OgNZb0Z17O03M3ON00O11OO1d]O`NWb0a1i]O_N1ORb0f1m]O[NTb05o]OY1na0dNY^OY1ia0dNZ^OZ1Xb0N0OL61N^OeNP^O03e1ka0`NS^Ob1ka077M0O1YOl]OASb0=P^OCna0=T^O]OLBQb0o0W^O_Oia0a0Z^OTOEMYb0k0U^OUOoa0l0b01O12ON02ON021N1P]OSOmb0o010011NOROR]Oi0Rc0VOo\\Oi0Qc0WOo\\O6OK1;Rc0Eo\\OOkc01N1112Mfj?", "size": [640, 481]}, "area": 32087.0, "iscrowd": 0, "image_id": 17436, "bbox": [74.0, 17.0, 381.0, 488.0], "category_id": 96, "id": 20001103}, {"segmentation": {"counts": "e>`4`?00000000001O000O100001O000000001O1L5N1L4O1VOU@[Ml?]2`@_Ma?^1S@jNf0FW?`1dAaNZ>`1fA`NY>a1gA_NW>b1jA_NV>`1jA`NW>_1jAaNW>]1iAcNW>]1iAdNW>[1iAeNY>Y1gAhNX>X1hAfN]N_Ol?j1gAgN]N_Om?i1gAgN\\NAl?h1hAgN\\N@m?i1gAfN]NAl?i1gAfN]>Y1cAgN^>X1bAiN\\N@P`0f1dAjN\\N@o?g1fAhN[NAo?g1fAhN[NAo?g1nA_NTNJn?g1VBaNd=]1eB_NV=b1d201O^O\\Nh^Od1o`0dNR_O\\1l`0gNi^ODNj1Ua0gNk^O_1Ua0f0000000O11OZ@oM\\=R2dBnM[=S2eBmM[=S2eBmM\\=R2dBnM\\=R2dBnM[=S2eBmM[=R2fBnM[=Q2eBoM[=Q2eBoM\\=P2dBPN\\=P2dBPN^=n1bBRN];_OkD_2HRN[;CkD[2JRNY;GkDW2LRNX;IkDU2LTNW;IlDS2MTNV;KlDQ2NSNW;LkDQ2NSNV;LmDQ2MTNU;KnDQ2MTNU;KnDQ2MTNU;KnDQ2MSNU;MnDP2MSNU;MnDP2MSNU;MnDo1NTNc9ZOnD3MMS1c0`0o1OTNb9HnE4b0P2NTN`9JPF2ODXO]2Y1SN_9LnD^O0310e0?;FoNc2c1kM^9;eE_O;f2b0`M^9;fE^O;f2a0aM^9o2TGQ2]O`M`9>SGS2]O`M_9>SGR2^O`M_9?RGQ2_O`M`9>QGR2_O`M`9=oDoNm1T3D_M_9f0oDfN0Og1V3K_M_9n0eFc1L`M^9n0cE`N8Q3h0aM]9n0cEjNOf2Q1bMo9=oD\\O1e2Q1bMo9=nD]O2d2Q1bMo9>mD]O2S2FbM\\1`0P:=kD^O4m1g1XNZ9?\\DPO2KOc0a0i1j1ZNW9a1oD5j1ZNX9`1mD7k1YNX9`1nD5k1[NW9`1mD6l1ZNW9`1lD7m1YNW9`1lD6n1ZNV9`1lD5o1[NU9`1lD5n1\\NV9_1lD4o1]NU9_1mD2o1_NT9_1lD3e1gMTNh0Z;^1mD2e1kMRNe0\\;P4jF]KhMd0];m3mFaKdMb0^;m3oFcKaMa0^;k3SGeK^M?_;m3SG_Ll8a3YG[Lf8f3`GTL`8l3eGnKZ8T4lGfKV8X4PHbKn7a4VHZKj7f4f3VKn@j4R?VKn@j4R?210MTKRAk4m>VKQAl4n>TKRAm4c>RKcAe5k=[JoA04e5m=[JoA10g5Q>XJoA10g5Q>XJoAl5P>20001O101N1UCRJe;l5[DTJe;l5U1PJTBR6j=30aKWBf2g=ZMZBm2`=oLjBl2T=RMnBP3Q=oLhCaNjNe3c1[LT:_1cEU29_LW9MZE19OB_1U1[2?\\LT92fEY1k0U2;lLh8FRFY1g0Y2?iLh8DQF[1j0V2=kLg8FeEG:b1m0U2>mLe8EfEG008b1S1R29QMf8CfEH007m0IGZ1f3E\\LZ9DgEF7m0KDV1Z4YOkKg9GoE>MGV1X4UOmKh9FoE`0MEW1Y4TOmKh9EPF=0GU1\\4QOiKl9HjEBOf0:Jk0Q1kNo16WMS:GhEBOd0>Gk0S1fNcN1]4[:jLTFPOj0U1oNP3R:jLWFnNn0R1lNU3o9kLXFlNl0V1nNR3m9lL[FiNk0Z1lNQ3P:XLdE]O1=[3IPMW4n9VLPF]OG3\\32oLV4Q:VLUJk3k5TLWJk3j5TLUJm3k5QLWJo3i5QLXJn3i5QLVJQ4i5oKXJP4i5PLUJP4l5QLSJo3l5SLTJl3l5VLRJi3o5VLRJj3o5ULRJj3o5UL`J^3^5cLaJ^3]5cLbEBm4k3b5bLaEBn4l3a5eL[J^OXKm3]:dL\\J@VKl3^:dL]J@TKl3_:dL^J]3b5cLaJ[3`5dL`J\\3`5cLaJ]3_5cLaJ]3_5bLbJ^3^5bLbJ^3^5aLcJ^3^5bLbJ^3^5bLbJ^3^5cLaJ]3^5dLbJ\\3^5eL`J\\3^5gL`JZ3b5dL^J\\3\\5ULjE=j4^3^5SLeE00Q5_3Z5VLeE7T5a3W5VLgE:o4b3Z5RLhE=o4`3Y5TLhE9Q5d3V5RLjE;o4c3W5RLjE:R5b3Z5^LdJd3\\5]LjJ\\3W5cLiJ]3X5bLiJ]3Z5aLeJ^3]5`LeJ_3_5^L`Jb3_5_LcJ_3P;O00001O2N2N2N2N1O000000O10000Z_OhLd`0Z3O2N2M3M11000000001OO11O0001O1O1O1O1N100O1000000000O1000000000000O1015aL]_O1NQ3Qa0L0O00O1001O00000000000000N21O1N1000^Ob000000000000O11OO1001O000000O11nNQMQAo2m>TMi@@O\\3W?VMe@\\O1f3]?g0a@cK`?\\4`@dK`?\\4111OO2N0101O001eK^@W4a?hK`@W4a?hK_@X4g?hKZ@1Nn3h?QLZ@1O0Ok3P`0TLP@m3o?SLR@l3Q`00O2OO10000000N3N011N0110O1N020N020O1XLY@T3Z`0001OO11OO1O11OO1O1000010O0000O0:G8JO0OO100O11O00O10O10O1001O1O001dNXM^Ah2^>]MaAb2]>bMd@\\3[?e000O12NOdK`@Y4b?fK^@Z4d?0JgKe@Y4[?6003M3M000000000gK]@V4b?jK^@1OP4h?oKY@Q4m?N000N21N20N110O1OM40O01YOoK^AP4`>SL`Al3_>VL[ALBo3Q?YL]Ai3a>ZLTAEMV4n>XLRAk30fKm>m431O10OO010N2SAoJl>R50nJUAn4n>10011N0M120]OoJgA1;R5l=a02O11O1O00O02O1OO13M0OO210N2O000O1[JgAb5]>O000O11O0001ON20001O00001_B", "size": [640, 481]}, "area": 65716.0, "iscrowd": 0, "image_id": 17436, "bbox": [0.0, 301.0, 481.0, 320.0], "category_id": 97, "id": 20001104}, {"segmentation": {"counts": "k0a7_<00000]Og0I30L400O10000N2N2M3O1O1001OO100N2O1001O1O00001J6O1O1O1VDkGg;X8OO1001O1O2N001O1O1O1O1O1O002N1O001O2N1OOlDYGQ;m8N5K1O0VEmFg:V90001O1O1O001O1O1O1O4L0000001O3M2N000000O1O1000000O1000000O10000000000000000O10000000000NdE`F\\:`92000000001O001O1O001O1OO1O11OO100O100O10000O1000000O10000001OO1000000O10000000000O1000000000000O1001O00O11O0000000000001OO11OO10000001OO1001O00O1000000001O0000O11O001O001O00001O001O00O100001O1O00O11O00000000O11O0000000000000000O100N22NJfEhFX:Z9fEcF00Z:]9gEbF\\:^9gEbFV:^9hEdFX:\\9fEeF[:[9fEeFY:[9fEfFZ:Z9fEfFZ:Z8gEeHY:Z7hEfHX:X7jEfGL;16X:h7mEfGK:43V:l7oEoGO2S:n7RFmGN1Q:P8UFkGN2n9i7bETH41U1OU9l7d12N00N200O1O10000MlCYHUo5_O2N1O001O001O1O`0@000000001O000000000000000000000000HkBeIU=Y6:O1O10000000000O1002dBeIo<]6kBcIN4T=e6lBVIR=l6000001RCSIgj4\\BVKj=NeAi4T?0001O1N20OO2N2O100O4K1001O0102M20OeKb@Q2NJi?3[@Ke?3_@Kb?3`@L`?3b@L^?3d@L\\?4d@L]?2c@O^?0b@0^?0b@0_?Oa@1_?Nb@2^?Nb@2^?Nb@2^?]No_O23MMS1c0`0o?_OP@b0P`0^OP@ODXO^`0F\\_O0310e0?;FoNRa0f0V_O;Ua0Fj^O;Va0Eh^O`a0P1102ON02O1O00OnMY^Om1ma0RNR^O0Og1Wb0O1mNl]O8Tb0HV^OOja0OW^O1ia0NX^O2ia0MX^O2ha0MX^O4ja0]Oj]O2KOc0a0ib000O11OO1O1000000001OO10Tfl0@\\ZSO2L21OM3L5M4N1N2O1N2\\O[OZ]O1=f0Xb0C[]OG3e0bb0b002O0N3ON21O01N20`]OfNYb0[1b]OeN10_b0`1b]O`NWb0g1N2N010OWNm]Oe1Sb0[Nl]Of1Wb00O012N0O100O010O1d^OVNb`0j1W_OWN_O4Xa0g1l^OVN51Sa0j1e^OYN5NJO0NTa0U2P_OWNRa0h1m^O^Nn`0d1o^O\\NSa0Y200O001L030O3OM20N21OO1_NRMPBn2o=SMRBl2l=VMf@L;1a0m2]>XMf@K:43MLk2Q?]Mn@O2MMe2S?cMk@N1LOb2U?hMg@N2MO\\2n>WMPA41U1OSO3]2m>S241M0N110O1O013MLbARKo=0cAo41QK0062R>NhA0OV57lJQ>1hAR57mJU>Q5mAmJG0\\>X5jAhJJ0]>W5iAmJW>S5iAlJY>Q5bAmJO5^>]5M1O3L102NN101O12M2O1O0010M31ON23nATJi=l5VBUJj=m5SBVJk=P602UBnIc=X601O2N0JbIiB]6W=fIhBT6\\=mIdBS6[=mIdBW6\\=70NSC_I]nJ^AP5c>62O21L00O2O0N300O20O01O1O01M11NWAmJg>U54M2O001O00O3]AnJF0[>U5iATKT>m4jAWK0Dn=T5PBgKg=SOYBU6b=602O01O1O^BeI`=^6HbIjB`6R=`IkB21N0_6R=cInBe6S=303nBVIh5l;^6nC]I<0g;d6o01O1O2N1N0111^IkBU6W=eIiBN4Z6_=fI\\BZ6d=00O110jI[Bn5c=QJcBl5\\=SJiBk5g=0TBWJ_=h5^B_J_=c5^B`Ja=Q6M1OL70M_O_BVJ03j=f5[BXJg=f5:4M0O1O01NBUJhBl5X=WJdBh5]=YJdBh5Z=XJfBf5[=\\J\\BK2k5d=WJ]Bl5d=SJ_Bm5_=YJ[Bf5e=<1L200O1000O1O3M0]BgI`=[6_BfI`=Z6`BfI_=[6bBfIO0X=_6iBaIW=]6jBdIW=[6jBdIV=_6gBaIY=c60O10001O000O01O2O1N100O1jBXIU=j6N1O1N200O101NO6QImB00g6^=I000000QI", "size": [640, 481]}, "area": 73082.0, "iscrowd": 0, "image_id": 17436, "bbox": [0.0, 203.0, 481.0, 319.0], "category_id": 169, "id": 20001107}, {"segmentation": {"counts": "WZ>1fc0BO3M2N01O000\\Mk_O]1V`0bNm_O[1T`0dNo_Oi0IcNZ`0b0Q@g0GeNY`0d0o_Og0IdNY`0g0h_Oh00^N[`0i2f_OSM_`0k2c_OQM``0n2;N6J2O2M0ROe^OWO[a0i0g^OUOYa0k0S_OiNm`0W1V_OeNk`0[1V_OdNj`0\\1V_OdNi`0]1X_OaNTa0T1m^OkNha0`0Y^O_Oka0=U^OBna0`>4NO2OaAA\\>b01OOMeAB^><6M0M4N2MY]`0Oab_O5[A1b>331O011N1O001O00001O0010O01O0000N2000_AC`><`ADS20X:O3KUh38[iKGo=>gAB21m22X8`0hGBU8?kGBS8?bF[O\\N0W16Vd0QB[Oo=c0SB^Ol=a0VB^Oj=>[BBd=<^BD`=>aBB\\=`0`02kABMLc=f0]B@f=o0L3^BkNW=X1hBgNZ=Y1fBfNZ=[1cBeN_=\\13L4M3M2N3M2O2O1O1OL4O1O100N200O11mNTBP1n=0000000O1O11OQOPOSCOh0Q1T1XA1f>5O1LG`A:`>3O11O00O100O1O100O100O1O1O1O1O1O100JYORBh0n=XOQBi0o=XOoAi0R>2001OO10000000000O100O1N2N2InN_BS1a=mN]B0NS1e=mN\\BV1d=3000000O100O100000000O1MdNbB\\1]=400N2O100O10000O100O1O100O100N2O1IUNXCl1h>B=B>C=C>B=C=C>B7I1O2N1O1O1O1N3N1PFkKS9V4hFnKX9S4gFmKY9_4[FaKe9m400000000000000O100000000000000001O3M2N1O1O1O2N00000000002N0000O1000000O100000000O100000000O10000O1M3N2M3O1O1O1O1O100O100O1000000000000O1000000000000O1000000JcJiF]5]90N2001O000000O10aJaF]5a90000000000000001O001OO1001O001O001O00000000000000001O0000001O00M3H8H^JmFg5S930000000000001O0000001O1O1O1O001O000000000000000000000000000000000000000000001OO11OO100000000000000L4001O001O001O000000O100O100O1O100O1O1O1O1N2O10000O1000000O1InIaGQ6k8L2N001O003M2N2N1O1O1O000000O1000000O1M3N2000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000001O1O2N000000O1O1O1O1J600O1000000O10000O10000O10000005K1OO10000O100K5J6GiIdG\\6_8fI`GV6e8lIZGn5f8RJ[Gm5e8SJ]Gk5c8TJ^Gl5e8QJ[Go5k8000000000000000000000000IQGZJ1Nn8g5SGYJQ9f55O1LgF`JZ9`53O11O00O100O1O2OO010HcJnF[5S9eJlF[5X943M1O1O100J\\FoJd9R5\\FmJe9S5\\FkJe9V52001K301O10000000O10O01N2N4GWFVKm9g4SFWK0Nm9k4SFVKP:j43000000O10O0O2O1O1000O1MoEWKQ:h4400N2O100O101O7H100O1O2O0O100N2ONLZESLd:P4\\EoKc:S4^EjKO0c:W44000O0100O100O100O13NKXEPLj:l3VERL02k:j3XEVLj:h3UEWLo:f3REYLP;e36MgD^LZ;`3400O100001OO1O100000O1000001ON2L400M3M3000000N2N2O11O00O100^ORDQNo;m1SDSNm;m1UDQNk;m1WDjMJN10n;W2YDiMQ01O1L`AEb>5di2KjeM000n@7H6K3N1N3M2OO02N0O10000O11O00O20WOnAa0S>_OnA?[>N3L3M3M3LRj5", "size": [480, 640]}, "area": 83153.0, "iscrowd": 0, "image_id": 17627, "bbox": [40.0, 271.0, 587.0, 209.0], "category_id": 149, "id": 20001111}, {"segmentation": {"counts": "Pd52n>1O:F9G1O00001O000WC]OU;c0kDKg:5YE8Z:IfEc0m9]OSFP1`9PO`F^1R9bNnF]1S9dNkF[1W9eNiF[1W9eNiF\\1V9dNjF[1W9fNiFZ1V9fNjFY1W9gNiF[1U9eNkF^1R9bNnF^1R9cNnF]1Q9cNoF]1Q9cNoF]1Q9cNoF]1Q9dNnF\\1R9dNnF\\1R9dNoF\\1P9dNPG[1Q9fNnFZ1R9fNnFZ1R9fNnF[1Q9eNPGV1dNnM]:l0oFV1T9kNkFU1U9kNkFW1S9iNmFX1R9hNnFV1T9kNlFT1T9lNlFS1U9mNkFS1U9mNkFS1U9nNjFS1U9mNlFR1T9nNlFR1T9nNlFR1T9nNlFR1T9oNkFQ1U9oNkFQ1U9oNlFP1T9POlFQ1S9POlFP1T9POlFP1T9POlFP1T9POmFn0T9SOkFm0U9SOkFl0V9TOjFl0fNQN^:S1lFn0T9ROlFn0T9SOlFm0S9SOmFm0S9SOmFm0S9SOmFn0R9SOmFm0S9SOnFl0R9TOnFl0R9TOnFl0R9TOnFl0R9UOmFk0S9UOmFk0S9UOnFj0R9VOnFk0Q9VOnFj0R9VOnFj0R9VOnFj0R9VOoFi0Q9XOnFh0R9XOnFh0R9XOnFi0Q9WOoFi0Q9WOoFi0Q9XOoFg0Q9YOoFg0Q9YOoFg0Q9YOoFg0Q9ZOnFg0Q9YOPGf0P9ZOPGf0P9ZOPGf0P9[OoFe0Q9[OoFe0Q9[OoFf0P9ZOQGe0o8[OQGe0hNQNS:[1TGh0l8XOTGj0iNmMk9Y1\\Gn0f8RO[Gm0e8TOZGl0f8TOZGm0e8SO[Gm0e8SO[Gm0e8TOZGHlNIj9?[GFPOIc9a0]GFSOAe9i0XGEWO_Oa9l0XGD\\O^OZ9o0YGBA[OW9S1YG@EXOS9X1XG_Oo9a0QF_Oo9b0PF^OP:b0QF]Oo9c0QF]Oo9c0QF^On9c0RF\\On9d0RF\\On9d0RF\\On9d0SF\\Ol9d0TF\\Ol9e0TFZOl9f0TFZOl9f0TFZOl9f0UFZOj9g0UFYOk9g0UFXOl9l0QFfN\\:a1]ERNP;S2l08H7jE^M`7h2[HXMd7o2S26J7I6`DZMZ:g3O2N6J8H3M00M300GUFXK1NO0k9i4:O1N200001O00O1O100O100O10000O10fE_KU:b4jE^KV:f400000001O0000000000001OO1MkE[KU:f421O0000N2001O00000000N2000000001O00001OcNjEPNV:o1kETMONR:k3oEXLn9j3nEXLR:h3mEZLR:f3iERLK<[:e3gE\\LZ:T410000001O3M2gEZKT:h411O002PFVKf9l4WFTKj9Q50001O00O100000000000000000000O10000000000000000000000000000O11O00O100000000000000O100000000000000000000000000000000O100000000000000O10000000000O1000000000000000000000000000000000000000000000000O100001O0000O100000000000000001OO1O1001OO10000N2H800009G0000001O1O2NM3O1000000002NN2O1O1000000O10000O1N2O10000M30000O100000000000000000000000000000000O100000000000000000000000000000000000000O10000000000000000000000O1000000000000000000O10000000000000000000000000000O1000000000000000000000000000000O1000000000000000000000000O10000000000000000000000O100000000000000000000000000000000001O002N0000002N001O002N1OO100O1O1001O1O001O0000001O0dE`KX:e4O2N1O1O2N1O2N001O1O1O2N001O003M001O", "size": [480, 640]}, "area": 82826.0, "iscrowd": 0, "image_id": 17627, "bbox": [12.0, 0.0, 628.0, 170.0], "category_id": 157, "id": 20001112}, {"segmentation": {"counts": "nX=;d>>CXOjAT1j==C6FZNmBg1S=300M3O1KQNWCQ2i<30000001OO100001OLmMZCT2f<3002N1ON200O100001O000000000000001O000000O100O10iMYCV2hIe0O2O1O0ObT<2a\\CN_>OcA1NO09[>901N20O110O00O1O100O100O10000O10YOlAb0U>]OkAc0Y>00001O01O0000000000001N01M^OhAc0X>12O0000N2001O00000000N2000O1002OO0N201OcN^O\\Db0\\O\\O`;3WDONY1d4KMHN6a=8eBH00\\=3iBHN5Z=3VCLlV3i1EgMUM`0V3i1FfMTMa0V3i1GeMTMa0U3j1HdMSMb0U3j1IbMSMe0S3i1L`MQMg0S3i1M_MQMg0R3j1N^MPMh0R3j11[MmLk0R3j1j1VNVNi1k1XNTNh1m1WNSNi1m1WNSNi1m1WNSNi1m1WNSNi1n1WNQNi1o1WNQNi1o1WNQNi1o1WNQNi1P2VNPNj1P2VNPNj1P2WNPNg1Q2YNoMg1Q2YNoMg1R2XNnMh1R2XNnMh1R2YNmMi1Q2WNoMl1o1SNQNo1m1QNSNP2l1PNTNQ2k1oMVNQ2i1PNVNQ2j1nMWNR2h1nMXNR2h1nMYNQ2g1oMYNQ2h1oMXNP2h1PNXNQ2g1oM[No1e1QN^Nl1c1SN`Nj1`1VNcNg1]1ZNfNa1[1_NhN^1X1bNkN[1V1dNmNY1S1gNPOU1Q1lNPOR1P1nNoNS1R1lNmNU1S1kNmNU1S1kNlNU1U1kNjNV1W1jNhNV1X1jNgNSOSKf1V6WOfNQOWKh1S6WOeNROYKf1R6XOeNROYKc1V6[O`NROcKX1o5F^NROdKT1Q6J[NROdKQ1T6MXNROeKP1T6MWNCUK?e6NVNm0k1TOTNCVK;g62SNj0o1UO]JlNY2j0bL5h65\\JQOV2f0gL1h68[JTOS2g0iLJi6XJ\\Oo1>UMEe6`0VJAm1:XMEe6`0UJFj15\\MEe6`0TJe0m0VOZNDf6a0SJm0e0nNbNDg6a0QJU1>fNjNDg6a0QJ\\17dML?l5b0PJ\\1a1RN_4b0QJ]1^1QNb4a0PJ`1\\1nMe4c0nI`1\\1mMf4c0nIb1Z1kMh4d0nIa1Y1kMi4d0nIc1W1iMl4c0mIe1V1hMm4d0lIf1U1eMP5e0kIf1U1eMP5e0lIb1W1cMmMEQ7V1jI_1[1eMnMCm6Y1iI]1_1gMV5f0mHn1o1\\M[5?YH_2a2oL]5f3gJYL`5]3gJ^L`5W2eGdNg;V1[DSN`M2M10O100O1O1O1YNVCg04UOf<1^C`0P>G9F]AMg>5J7J5N2G:H7I8M2O1O2NlNeBd0Y=XOkBj0T=UOmBm0T=nNmBT1_=1N1O2O0HgNhBZ1V=iNiBW1V=jNiBW1U=lNjBT1T==N2O1N01O1O2O020O0\\NnBZ1]=O1O01O0O1O1000001O00000000001O01O000001O00000000001O00000000001O001O010O001O001O001OO100O100O100O100O1O2N1O2M2O2N10MfNaBY1]=jNbBV1\\=lNeBR1[=POdBP1X=UOhBj0V=XOjBf0X=[OhB87^On<2mBLN94;m<^OTCNK46c0m10000O10000iNmB`0U=@lB>U=BkB=V=CjB;X=EhB:Z=EfB;[=CfBa0W=\\OkBc0W=[OkBc0W=[OjBc0X=YOlBf0U=UOPCj0d=L7FZ[a0Hbd^Og0E7M2O1N2N2O1LeNaB]1^=3000M3M3000000O10000000000O13M3M000000000000O1O1N2N200001O01O00000000000001O7H1O_NdB`1[=aNeB_1Z=bNfB^1Z=bNfB^1Z=401ON2M3cNbBU1a=4100lN^Bj0b=:00000000000O100002N2N1O2M3N0000000000000001O00000000000000000000000000001O0000000000000000000000000000001O0O2O1O00O1000000000000000000000000001O001O1O1O1O1O1N100000000000000000000O1TOYB?g=BYB=g=DYB;g=FYB9g=HYB7h=;6O1O101N1O1I7O0003M3M0O17I2N4L2M4LdT5LakJ=B3N0O1O1O1N2O2M3N1O1O10000000O10000O100000000O10000000000000000O10000000000M301JaH", "size": [480, 640]}, "area": 52731.0, "iscrowd": 0, "image_id": 17627, "bbox": [1.0, 1.0, 639.0, 473.0], "category_id": 183, "id": 20001114}, {"segmentation": {"counts": "0di]11YebN5J7I6K6I6J7I6K6I6J6K6I6J7J5J7I6J7J5J6J7Je1ZN3N2N2O1O2M2O1O1^Ob0[Oe0[Oe0[Oe0ZOf0[Oe0[Oe0[Oe0I700eLfDP3Z;lLmDQ3e;L00000000000000000000000000000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000O1000FWM]Di2c;XM\\Dh2d;\\MXDd2h;:0000000000000000000000001O00000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000O1000000000000000000000001O008H00000000000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000I^MPDb2P<610O100000000000000000000000000000000000000000000000000000000000O1000000000000000000000O1000000000000000000000000000000000001O1O1O2N1O2N1O1O2N1O1O2N1O2N1O;E>B?A>B>B>B?A>B>B?@?B:F4L4L4L4L4L3K6I7I7J6I7I7I7RMbFOe9_OgG@`8N[cP1", "size": [480, 640]}, "area": 138637.0, "iscrowd": 0, "image_id": 17714, "bbox": [0.0, 0.0, 640.0, 480.0], "category_id": 117, "id": 20001115}, {"segmentation": {"counts": "gVP22j>7H9L0001O00000000000000000000000000000000001O00000000000000000000000000000000001O00000000000000000000000000000000001O000JbAJk>O0000i]c27Pb\\M0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000002NUba2", "size": [480, 640]}, "area": 1648.0, "iscrowd": 0, "image_id": 17714, "bbox": [136.0, 462.0, 329.0, 18.0], "category_id": 165, "id": 20001116}, {"segmentation": {"counts": "di]11m>5J7I6K6I6J7I6K6I6J6K6I6J7J5J7I6J7J5J6J7Je1ZN3N2N2O1O1N2O1O1^OaJaGa5j7SKVHn4U7i1[Oe0ZOg0ZOe0[Oe0[Oe0I70000000000000000000000000001O0000000O100000000000000000000000001O0000000000000O100000000000000000001O0000000000000000000O10000000000000001O00000000000000000000000O10000000001O00000000000000000000000000000O10001O00000000000000000000000000000000001N10000000000000000000000000000000001O00000O1000000000000000000000000000000000000000000O10000000000000000000000000000000000000000O10000000000000000000000000000000001O00000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000O10000000000000000000000000000000000000000O1000000000000000000000000000001O000000000000000000000O100000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000O100000000000000000000000O100000000000000000000000000000000000000000000000000000000001N2O2N1O1O2N1O1O2N1O2N1O1O2N5K>B>B?A>B>B>B>B?A>B>B>B5K4L4L4L4L4K5I7I7I7J6I7I6YMoE6X:WOTGIS9EYRQ1", "size": [480, 640]}, "area": 165478.0, "iscrowd": 0, "image_id": 17714, "bbox": [97.0, 82.0, 472.0, 390.0], "category_id": 183, "id": 20001117}, {"segmentation": {"counts": "\\3X8j;aH^J=a5C`J<`5CaJ<`5DaJ<^5CcJ=]5CdJ;]5DdJ<\\5DeJ;[5DfJ^:C`Ea0]:_OaEg0[:ZObEk0[:UOdEo0Y:ROdES1Y:nNeEW1W:iNgE\\1V:eNgE`1V:`NiEd1T:]NiEi1S:WNlEm1Q:UNlEo1Q:TNjER2R:QNjES2S:PNiET2T:oMgEV2V:lMgEY2U:jMgEZ2V:iMeE\\2X:gMdE]2Y:eMdE`2X:aMeEb2Z:_MdEf2X:\\MeEi2W:XMfEm2W:TMgEQ3U:QMhES3U:nLhEX3T:iLjE[3S:gLjE]3S:dLjEa3S:`LkEe3Q:]LlEg3Q:ZLlEk3Q:VLmEn3P:TLmEn3R:SLlEo3S:RLjER4T:PLiER4V:oKhES4W:nKfEV4X:j2O1O1O2N1O1O2N1O1O1OM3L4M3L4M3N200O100O100O100O100O100O100O100O100O100O100O100O100O1O100O100O100O100O100O100O100O100O100O100000000001O000000001O000000001O000000001O000000001O000000001O000000001O000000001O000000001O000000001O000000001O000000001O000000001O000000001O000000001O00hNZESHNP1h:l6`ESHHm0h:P7dEnH\\:Q7eEoH[:P7fEPIZ:P7gEoHY:P7hEPIX:n3aEnM9SNV:h3iEaMLRN5e0V:g3jEVM7^NIe0V:g3kEdLf0ROXOc0W:f3lEQLX1FgNb0U:g3WFdKo03eNb0U:e3YFeKm05fN`0T:5fEa28dLX16fN`0T:HTFm2JeLW16hN`0b;;_DnN_OY1a0hNW12SNNh03YON07W<1iEb0fNTO[11fN2ZOM55g>>iA]O[11eN4FMi>7cAGY11eN1\\?OcC0W`001O_WX2", "size": [640, 480]}, "area": 60213.0, "iscrowd": 0, "image_id": 17899, "bbox": [0.0, 0.0, 364.0, 322.0], "category_id": 112, "id": 20001119}, {"segmentation": {"counts": "SbV91lc03U\\O0dc07GIe\\O;Vc09L5K4L41OPK", "size": [640, 480]}, "area": 198.0, "iscrowd": 0, "image_id": 17899, "bbox": [471.0, 161.0, 9.0, 40.0], "category_id": 115, "id": 20001120}, {"segmentation": {"counts": "d;\\1eb0O00O11eN_]OT1bb0lNi]Oh0Wb0XOU^O=ka0C`^O2`a0NXe00Q\\O0oc00Pd00P\\O0Q\\O0Yi\\69WVcI8d^OLi>5k@7U?JY@f0g?[Oe_OX1\\`0SOW_Oo0g`0SOX_Om0Ua0hNj^OX16RNg`0f0S_OW16TNg`0e0S_OW12SNN3l`0d0S_O[11QNl`0d0S_O[11QNj`0f0U_OY11RNj`0n26Ko^OTMo`0n2010O001O00001Io^O\\MRa0d2n^OZMUa0e2l^OZMTa0f2301O001O01O01O010O00001O010O00010O4Lf^ObMca0n1\\^ORNRb0`1n]OaNRb0^1n]ObNSb0^1j]OdNWb0[1i]OgNOJUb0_1k]OiNVb0V1j]OkNVb0_11O100O1Lg]O_NZb0`14O001O102M002O2M3M10O0O1X]OjNdb0Z100O11O0N\\]OhNdb0X1200000103L01O00WO\\]O7gb0DZ]O>eb0\\O`]Od0nb0100O0N22M10000Mg\\O^OZc0>g\\OCOO\\c0QOF\\]OK30:?Rb0Ka]OG10:`0Ra02c^O@1N1c050k`0\\OQ_O1Nj0ON1WO10Nd0j`0KV_OT2j`0a0000O1000000O10000O1000000O1ER_OdMn`0[2T_OdMl`0Y2[_ObMf`0]2]_OaMc`0\\2__OeMa`0[2__OdMb`0[2__OeMa`0Z2`_OfM``0X2b_OgM_`0Y2a_OgM_`0o1o^OUNia0c1>E;UO^]OL1Djb04U]O00K29dc0Gd_Z1", "size": [640, 480]}, "area": 2772.0, "iscrowd": 0, "image_id": 17899, "bbox": [375.0, 0.0, 37.0, 101.0], "category_id": 172, "id": 20001129}, {"segmentation": {"counts": "mlm6?Tc0>_Ob0`^OXOd?i0d_ON\\`0k10O100O100O100O10000000000000000C[_OYML3i`0a2`0UOk^OWNK30:Za0W1P_O\\NG10:[a07W_O^O@1N1c05k`00a^OL1Nj0ON1WO10Noa00_Ym1", "size": [640, 480]}, "area": 2218.0, "iscrowd": 0, "image_id": 17899, "bbox": [355.0, 0.0, 27.0, 105.0], "category_id": 174, "id": 20001130}, {"segmentation": {"counts": "fbg71nc02L7K3K210O1O1N200F^OR]Of0fb0>E:VObNh^O1De1Ra0ZNR_O000K29l1j`0eNm^Oc1Sa0e00003M5K4L00000000000000000000000000000000001OO1000000N21O00000000001O2N3M2N001O000000001O00001OO11O001O1O00O13M1O0h_O[LU`0i3ON23M1O0000Lo_OZLP`0e36O1O1", "size": [640, 480]}, "area": 7885.0, "iscrowd": 0, "image_id": 17899, "bbox": [396.0, 0.0, 84.0, 126.0], "category_id": 181, "id": 20001131}, {"segmentation": {"counts": "U>b0`9f5VJ]Kg4d4WKWOn0j0QOWOo0j0cLiIT1]5X2k0dLSJh0S5d2k0bL^J?g4n2l0cLhJ3]4Z3l0bLoJKV4b3l0bLPKKT4c3m0aLQKIS4e3m0bLQKGS4g3m0`LSKGP4h3n0aLSKEP4j3n0_LTKFn3j3o0`LUKCm3m3o0_LUKBm3n3o0_LWKAj3P4P1^LWK@k3P4o0`LXK]Oj3S4o0^LYK^Oh3S4P1_LZK[Og3V4P1]L[K\\Oe3V4Q1^LX1b3iN]LW1b3jN]LW1c3jN\\LV1d3jN\\LV1c3lN[LU1e3kN[LU1d3mNZLT1f3lNZLT1e3nNZLR1f3nNYLS1f3oNYLQ1g3oNYLQ1f3QOXLP1h3POXLQ1f3QOXLP1h3POXLP1k1n0TNROk1o0TNROk1P1TNPOk1Q1UNoNk1R1SNoNl1R1TNnNk1d900O1O1O100O1O1O101N1O1ON^Nh]Ob1Xb0^Nh]Oa1Yb0_Ng]O`1Zb0`Nf]O_1[b0aNe]O_1[b0aNe]O^1\\b0bNd]O]1]b0dNb]O[1_b0eNa]O[1_b0eNa]OZ1`b0fN`]OY1ab0gN_]OX1bb0hN^]OX1bb0hN^]OW1cb02100hN\\]OS1eb0mN[]OR1fb0nNZ]OQ1gb0oNY]OQ1gb0oNY]OP1hb0POX]Oo0ib03100O1O1OcFoNMQ12QOMn04ROLm04UOKj06WOIi06YOIf07\\OHc09]OGb0:_OEa0:@F?;@F?:AG?9@H`07AI?7@J`05@L`04_OMa02@N`01@0`0O@2`0LA5?JB6>HC9:AF`0:^OGc09\\OGe09YOIg07WOLh04WOMi03UO0j00TO2l0NRO5m0KQOoHBP7=RIBn6>SIAm6?TI@l6?VI@j6`0WI_Oi6a0XI^Oh6a0ZI_Oe6a0\\I^Od6b0]I]Oc6b0^I^Ob6b0_I]Oa6b0aI]O_6c0bI]O]6b0eI]O[6c0fI\\OZ6d0gI[OY6e0hIZOX6f0_FQM[2X2V7g0[FYM\\2o1Y7m0RF\\Mb2g1[7R1jE_Mg2_1_7S2`HnM`7R2_HoMa7Q2_HoMa7Q2^HPNb7Q2]HPNb7P2]HQNc7o1\\HRNd7n1\\HRNd7n1[HSNe7n1ZHRNf7n1YHTNf7l1YHUNg7k1YHUNg7k1XHVNh7k1WHUNi7k1VHVNj7j1VHVNj7j1UHXNj7h1UHYNk7g1UHYNk7h1SHYNm7g1SHYNm7g1RH\\Nl7d1SH^Nl7b1TH_Nk7b1SH`Nl7`1THaNk7_1THcNl7\\1SHgNk7Y1UHhNj7X1UHjNj7W1UHjNj7V1UH_OW7a0hHAW7?iHAW7?hHCW7=iHCW7>gHDX7eJeA11OO[5d>OO100MeJaA[5_>3O13M00O10cJ`AZ5b>10000O11O0iJ]AL0S5l>mJWAm4P?N00O11O001OO100N20SKPAj4R?100O1001O1O000000001ON2N21O00N200001O1OO1N21QKQAk4R?00ZNm@_NT?_1o@_No>a1UA]Nk>b1XA\\Ng>d1[A[Nd>d1^A\\Nk>Z1VAfNZ`0Ig_O7_`0Ac_O?d`0XO^_Oh0h`0POY_OQ1m`0bNZ_O^1da0000000000O10000O1O1O1O1O1oN`Nb_O`1X`0mN^_OV1[`0XO[_Ok0`?ZNQAU1YOd0h?X21OO1O1001O0gLW@[2h?eMY@[2e?gM\\@X2a?hMd@V2\\?nL]@h08Y2[?mL_@l04W2]?mL_@l05V2`?dMZ@^O7l2^?dM]@_OMO7m2_?fM^@[O8o2Y?gMm@Y2S?bM]@_Oa0o2R?bMRA^2l>dMRA^2l>cMWA[2f>fM[A[2e>eMYA]2g>dMZAZ2k>aMUA_2Q?\\Mm@e2X?WMg@i2`?SM^@l2[`0000N21O1O4iMQ_OU1Ra0dNS_O[1ja0O1O001O1O1O1O001O1O1O001OcM^N]Ba1R`0O`NlNU@S1k?]Oe_Oc0\\`0]Od_Ob0\\`0_Oc_Oa0\\`0Ac_O?]`0Ba_O?_`0B`_O>``0C__O=b`0C]_O=``0G^_O:e`0EY_O;i`0DV_Oe0_@H]NIo`0l0Y@WOkN1g`0X1\\@lN`?a1S@aNk?`1S@aNm?`1Q@aNo?a1n_O`NR`0a1l_OaNS`0`1j_OcNU`0`1g_OaNY`0c1a_O_N^`0b21OO11OO1PMgLYEY3[8cLUG6_NMQ1Z3Z9fLmFNTN6a0NT1W3Y9hLlF4RNOf0LS1Y3k8YMWGNeNEY1T3f8`MXGNZNMc1e2j8aMYGN[NM_1d2l8cMXGk0Kb1m8dMWGl0J`1n8eMhFROUOm1R1\\1P9gMgFZOnNd1Z1[1R8SMPGe0f0^16k0S8XMkFi0IfNc0`2e0i0S8^MgFj0?Q1f0g0T8\\OfFXM6g2o0e0S8c2mG]MS8d2lG\\MT8e2kG[MU8e2kG[MT8g2kGYMT8h2lGXMU8g2kGYMU8h2jGXMU8i2kGWMU8i2kGWMU8i2kGWMU8j2jGVMV8j2jGVMV8j2jGVMV8a3RG`Ln8YMRJn57[IaL3]5e0UOc4kNgJcL2\\5d0VOc4gLfJg09[3>WOS5]KVJd0311:KUO:X5>WOR6]KVI90I0O83HM1b01^O:Z5Y5nLYOJgLj2gNcL3e3W5TMXOHiLl2XOIh4cMWOE^KB\\1]3KcLiN`2[5YNWOElLo29cLZNo1Z5jNWOElLo2h0gMmMlNM4_5e0SOElLo2h7\\M\\KElLo2g7]M]KDlLo2h7\\M\\KElLo2i7[M[KFlLo2j7ZMZKGlLo2j7ZMYKHmLn2j7ZMYKIlLm2k7ZMYKJkLl2m7YMYKLhLk2o7ZMXKMgLi2T8WMUK2fLf2W8VMSK6dLd2\\8SMPK:cLc2_8QMnJ>fL\\2\\8VMnJ?dL\\2^8UMnJ`0bL\\2_8UMoJ?aL]2`8TMoJ>cL]2^8UMoJ>dLZ2_8XMmJ=dL^2]8UMoJ2VOS:4[EU20SN2S1^1hNVO`0X;FjDA\\O>4JMX1[1dN^NLk07YO4n;2aFI`MeJeA11OO[5d>OO100MeJaA[5_>3O13M00O10cJ`AZ5b>10000O11O0iJ]AL0S5l>mJWAm4P?N00O11O001OO1]KUKQJk4k5ZKRJh4k5[KUJHcKj4T:cKZJ^4c5eK]J[4_5jK_JW4\\5nKdJR4X5SLhJl3T5XLjFi0M]NZ1a4l7]LbFe1_1n1m7@PH`0m7EQH;m7IQH7n7JSH5l7MQH5o7KoG7P8KPH4P8LPH4o7NnG4R8gNQGZMm0o3Q8bNYG^Mf0P4Q8\\NaG\\M_O]Oo0j4P8XNkG]M>Z4g7SNTH_M5_4f7mM_H_MJf4g7gMXJZMiLk4o8mMiGgMV1\\4P7oMaG`Nl0a3c7QNWGPOm0n2k7;oGGQ8=kGCT8b0[GjJJe4k8T6mNUEPIl:j6]ESIc:g6eEVI\\:i6gEUIY:j6jESIW:k6lETIT:k6PFQIQ:n6a1N200O100O100000000000000000[KnH\\LR7b3ZITLf6k3]ISLc6k3`ITL`6k3`IVL`6Y3mHnHd0j3_6R3\\IjH6T4_6k2\\JTMd5f2bJQJYN[2U7^3gJWJUN[2V7kMPIP4i1lKRNX2V7iMVIo3^1PL[NV2R7iMVIW4W1nJZNh08Y2S7fMVIa4o0fJbNl04W2X7aMUIl4g0`JhNl05V2[7]MSIW5b0PKjN^O7l2`8l2XHhJSO_OMO7m2a8Q3THeJXO[O8o2\\8R3RHeJHY2W8P3RHbJWO_Oa0o2V8P3RHbJL^2R8V3jG^J2^2U8\\3^GWJ`0[2R8`3YGVJf0[2R8`3VGUJf0]2T8W4mGgKS8Y4mGgKT8Y4jGhKV8Y4iGgKX8[4fGdKZ8_4cGaK^8f4ZGZKf8i4UGYKk8j4SGUKn8n7001O00001O001O001hJmFAT9>nF@S9?SG[On8c0ZGVOg8i0^GROc8l0cGoN^8P1gGkN]8nLeFj2U11Z8PMcFm2i1^Oh7aM_FQ3S2TOc7eM[FV3S2UOf7`MXF[3S2TOi7]MTFm2LTMW2b2m7XMQFR33kLo1l2R8QMmEX3b2Gm79SHGm7:RHFn7;RHDn7UHAj7`0YH]Oh7b0ZH\\Oe7e0[H[Oe4\\MTKY37[OY2XMPM6_NMQ1Z3W1[OX2[MhLNTN6a0NT1W3Y1ZOU2^MgL4RNOf0LS1Y3Y1ZOg1oMRMNeNEY1T3Y1ZOb1VNSMNZNMc1e2^1ZOa1WNTMN[NM_1d2a1ZO`1YNSMk0Kb1c1YO_1[NRMl0J`1e1YO^1\\NcLROUOm1R1\\1g1ZO^1]NbLZOnNd1Z1[1h1ZO?iMkLe0f0^16k0i1ZO?nMfLi0IfNc0`2e0i0j1ZO>TNbLj0?Q1f0g0j1[O?1aLXM6g2o0e0k1[O=X3hM]Mk1[O=Y3gM\\Mj1]O?X3fM[Mg1cLVMk2]3W3fM[Md1cLXMo2]3U3fMYMd1Ee0S3gMXMc1Fg0Q3fMYMc1Fg0R3eMXMd1Ff0S3fMWMd1Ff0S3fMWMd1Ff0S3fMWMc1Gg0S3eMVMe1Ff0T3eMVMd1Gg0S3eMVMd1Gg0j3mL`L\\2Fg0c7XO^Hg0c7ZO\\Hf0d7oMYEOR3R2U8eLiDd0311Go2o2S9eLiC90I0O83HM10R3Z3P:iLWFX3X=00000000000SFdLV3\\3iLQM\\IC10Y9\\3lLkLjIJ0c0Z9h2fLdLPJ20o0Y9[2gLlMX3T2hLlM]MhN\\2[37nM]MgNcL3d5X3:PN_MXOi1h2e0eLUJ\\1]3KcLiN`4[3[1SNbM9cLZNo3Z3l1SNbMh06U1X2SNbMi1UO4Y3SNbMk1SO1\\3TNaMk1SO2[3SNbMi1cLiL`2\\3Z3RNcMi1UO6W3QNdMj1TO5X3QNdMi1UO6X3PNcMj1UO6Y3oMbMl1TO6[3lMaMP2RO4_3jM_MQ2SO8]3fM_MQ2UO;\\3bM_MS2UO>Z3^MaMT2UO`0Z3_M\\MQ2ZO`0[3]M\\MR2ZOa0[3[M\\MS2ZOa0[3[M\\MT2YOa0Z3]M\\MQ2[Ob0Y3^MYMQ2_Oa0W3^M]MP2[Ob0W3^M_MP2ZOb0W3]M`MQ2YOb0W3\\MaMS2WO`0X3_M`MQ2XO`0Y3]M`MT2VO?[3\\M_MV2UO>\\3ZLTJn0\\3Y2UO`0]3UM`M[2SOa0]3RMaM^2QOa0[3SMdM\\2QOc0Y3PMgM]2POe0U3PMkMZ2QOf0g2SLgJ27k0Z3Z2QOf0e2YLoJh0[3Y2QOf0e2XLkJn0_3U2POe0f2XLjJQ1^3R2ROe0e2bMYNj1QOd0f2cMXNi1ROd0e2dMYNi1QOc0f2cMaK`NQ2[3Gb0g2bMbKaNP2Y3Id0e2bMaKbNQ2W3Jf0b2aMdKcNYOOX100W3Y1f0b2bM^KbN_O50In02VO`3OmKZ2Q4kMPLU20SN2S1^1hNVO`0Y4b1ATNXLA\\O>4JMX1[1dN^NLk07YO4o4o1@SNPNI`M^2[AaMe>Y2cA^M^O]Om>P3oA^MZ>[2QB`Mo=[2ZB^Mj=b2j12a_OgMR?[2e@`NR4fNR6l2bEPOQ4WNZ6R5`IRK^6R5]IQK`6T5lEjJm24V7f5fH\\JW6HbGV6m1RJ\\61dG]7?cHg78gG\\7:^Hn79fG`73YHV8:dGd7NTH\\8;eGg7BUHh88bGb8]8`1O200O100O0100O1O1O1O100kNbGgF_8R9oGcFU8g7]GoHj0ROl7n7k2N2O1O1\\OYDmHi;m6i0I6J6]JkBU4]=gKnBj3Y=TLiBP4S=mKoBY4nN3N3Miac0Y3nZ\\OY1gN1O0000000001O000000000O100000000000000000000000000000000000001O00000000000000000000004L1O0_N^@dNc?Z1_@dNb?L]@33Ob?L^@220a?M`@O31_?Mb@O12^?Nd@L14]?Ne@K05]?Mg@JO7_?If@LO8`?Dg@1K9b?_Oi@3IgFAm2U4oK\\L6_OY1PMA^3P4oL\\LFEh2c0UM[O^3Q4oL\\LFEe2h0WMUO_3S4oLZLGEa2m0o0T3jLZLEEi1NaNT1V3P3kLXLEFj1N\\NX1Y3m2kLWLGFh1NYN^1[3h2kLXLHDS2`1Y1d2oLULFFn1g1[1_2RMRLEHg1OQNj1b3_2PMPLEIg1l1d1[2QMoKEIf1k1f1^2oLmKEJe1k1h1_2nLlKEIe1l1h1`2mLkKFIe1k1i1a2lLkKGIb1k1l1b2iLlKHGc1k1l1a2mLjKDJ`1n1o1^2mLjK[1l1i1\\2jLhKX1Q2n1X2jLgKU1S2Q2V2jLgKU1S2Q2W2jLeKV1S2P2Y2iLeKHJQ1X2^2Z2hLdKJKn0X2_2Y2jLcKIMn0U2`2\\2hLcKJLm0U2a2]2gLbKKNl0S2a2]2iLbKJNk0R2c2_2gLaKK1h0h1m2f2aLaKI2i0_1T3m2[LcKH0i0Y1[3T3TLcKHOk0T1^3Z3PLcKGNk0R1a3d2[KkLa0BGMl0n0e3e2ZKoL=BHKm0k0g3f2ZKSM:@HKn0h0j3g2YKWM6@IIo0e0l3i2XKZM3@IHP1a0P4j2XK]MO@IHo0>T4j2XKaMK_OJHP19W4l2WKeMEALFP15[4l2WKjM@_OOEP12]4m2WKnMYOQOJ?8DQ1M`4o2VKQNVOA4AP1N`4o2VKTNRO@7@Q1M_4P3VKTNRO_O9_Oj6n2kIjNZOYNQ1M^4Q3VKiN[OYNR1M\\4Q3WKjN[OWNR1N\\4R3VK]NTOlN7HS1M[4S3WK[NTOmN8Gi6Q3kI[NUOmN6HS1MZ4T3WKTNUOmN068GS1NX4T3XKTNVOjNON1;6Hh6R3kITNWOhN2:5GS1NW4V3WKSNXOgN4;2Hg6S3kITN^OQO0Hg6T3jISN@QOOHf6U3jIRNAQOOHf6U3jISNAPOOHj2Ng0X3nLRNBPOOHe23l0S3nLRNBPO0G[2=U1k2nLQNBPOOHP2g0a1a2mLPNCPOOHe1R1l1V2mLQNBPO0GV1a1Z2h1mLQNCnN0HV1`1[2i1lLRNBnN1GV1_1[2k1kLQNCnN1GU1`1\\2k1jLQNDmN1GT1`1]2k1jLQNDmN1GT1`1]2l1jLPNCmN2GT1`1]2m1jLoMCmN2GS1`1^2n1jLmMCnN2GS1`1^2n1jLnMBnN3FQ1a1`2n1jLlMBoN3FQ1a1`2o1jLkMBoN2FR1a1`2o1kLjMAPO3FP1`1b2Q2jLiM_OQO5EP1`1b2R2iLhM@RO5DP1_1b2T2iLgM^OSO7CQ1_1`2T2kLYNDSNR1_1_2V2kLWNDUNR1]1_2X2kLVNCUNU1[1]2[2jLUNEUNT1Z1]2\\2kLTNDVNU1Y1\\2^2kLSNDUNV1Y1[2`2kLQNDWNV1W1[2b2kLPNDVNW1W1Z2c2kLPNDVNY1T1Y2g2jLoMCWNZ1R1Y2i2jLmMDWNZ1R1X2k2jLkMDYNW1R1\\2j2jLkMCXNV1T1]2j2iLjMDXNU1V1]2i2jLiMCYNS1W1`2g2kLhMCYNQ1Y1a2g2kLgMBZNo0Z1d2f2jLfMDYNi0`1i2b2jLdMDZNd0e1n2]2kLdMCZN>k1S3X2kLcMDZN9o1Y3U2jLaMD\\N3S2_3Q2iLaME[NMX2e3m1hL`MFl0b3f1gL^MGl0a3g1gL]MHl0a3h1gL[MIl0`3j1fL[MIk0a3k1fLYMIm0`3l1eLWMKQ1\\3i1iLVMKP1\\3k1hLUMLn0^3n1eLUMLn0^3n1fLSMLl0K]Mc3e4eLSMMj0K^Mc3f4eLQMMl0`3T2bLQMMj0b3V2aLoLMk0b3W2`LnLNk0b3X2_LnLOi0b3Z2_LlLOk0a3Y2`LmLNj0b3Z2`LkLNj0c3\\2^LkLOh0c3^2^LiLOi0c3_2]LiLO75WN`3j4\\LgLO76RNe3Q5ULgL05V4U3iKfL14W4W3hKeL0aNOX1X4c3hKdL1`N2V1V4g3gKbL1`N4W1S4g3hKcL1]N7W1P4j3hKaL1\\N;W1l3l3hKbL0ZN>W1j3m3iKaLOZN`0W1h3o3hKaLd0_Od3P4hKaLd0^Oe3R4gK^Lf0_Oc3S4gK]Lg0@b3S4hK[Lh0A`3U4gKXLl0D[3T4jKVLl0FZ3U4iKTLo0GW3U4kKRLo0IV3U4kKPLR1JS3W4jKnKU1JQ3X4kKlKU1LP3X4kKkKW1Ln2Z4kKiKW1Lo2[4jKhKY1Lm2]4jKfKY1Mm2]4jKfKZ1Ll2^4jKfK[1Jl2a4iKdK\\1Jk2b4iKcK^1Ij2e4hKaK_1Ii2f4hKaK`1Hh2g4iK`K`1Hg2i4hK^Kd1M^2e4oK]Kd14V2_4WL\\Kd18Q2]4ZL[Kf17P2^4[LZKf17o1`4ZLXKi17m1a4[LWKi16m1c4[LVKi16l1e4ZLUKj16l1e4[LSKk17j1g4ZLRKm16i1h4[LQKl17i1h4\\LPKl17h1j4[LnJn18g1j4\\LmJn18f1k4\\LmJo17e1m4\\LkJo18e1m4]LjJo18d1o4\\LhJQ29c1o4]LgJQ29b1P5]LgJR28a1R5]LeJR28b1S5]LcJR2:a1T5\\LbJS2:a1U5\\L`JS2;a1V5[L_JS2k3m5[NfIhM=m3n5\\NTJe1l5]NRJc1o5]NmIf1S6SLbIR29k1V6\\NgIf1Z6PL`IU21n1_6nK`I]6a6cI_I50k5b6oI_I32m5_6QJ_IO5o5]6QJ_IM6k1HY2d6oKiIn5W6SJhIg1DX2e6PLhIh1CW2f6QLfIh1DW2f6QLgIl5Z6TJfIk5[6UJdIk5\\6UJeIj5\\6VJcIj5^6UJcIj5^6VJbI[1Hi2f6mKaI[1Fj2j6jK`Ii5a6WJ^Ii5c6VJ]Ij5d6VJ[Ij5f6VJZIi5g6VJ[Ih5f6XJ[If5f6[JYId5g6^JYI`5h6`JYI^5h6cJWI\\5j6eJVIY5k6gJVIW5k6jJUIT5l6mJSIR5m6oJTIo4m6RKSIl4m6VKRIi4o6WKPIi4Q7XKnHg4R7[KmHd4T7\\KkHd4V7]KiHb4W7_KhHa4Y7^KhHa4Y7_KgH`4Y7`KgH`4Z7`KfH_4[7`KfH_4Z7bKeH^4\\7aKeH^4[7bKeH^4\\7bKdH]4]7bKdH]4\\7dKcH\\4^7cKcH\\4^7dKbH[4^7eKbH[4_7eKaHZ4`7eKaHZ4`7eK`H[4b7dK^H[4c7dK]H\\4e7cK[H4Fi3P8RL[H3Fk3P8RLYH1Im3P8PLXH1Io3P8PLWHMLS4o7nKUHMNU4n7mK`HS4b7lK]HT4d7kK\\HU4e7kKZHU4h7jKWHV4j7jKUHV4`80]OjKPHW4P8jKoGV4R8jKmGV4S8iKnGW4R8iKnGW4R8iKnGW4R8iKnGW4R8iKnGW4R8iKnGW4R8iKmGX4T8hKkGX4U8hKkGX4U8hKkGX4U8hKkGX4U8hKkGX4U8hKkGX4U8hKkGX4U8hKjGY4d8000CgKhGY4X8gKhGY4X8gKhGY4e80CgKjGW4V8iKjGW4g8N0000O1AjKiGV4g8OO1", "size": [427, 640]}, "area": 155224.0, "iscrowd": 0, "image_id": 17959, "bbox": [0.0, 0.0, 640.0, 323.0], "category_id": 157, "id": 20001141}, {"segmentation": {"counts": "h^n11W=2M4N1O2L4M2N3M3M3M3N3L3L4N1K6N1N3M3N2M3O1N2O100010N1O10001N10001O3M2N3_OWD[Oj;c0WDXONIo;l0XDVOJNn;l0YDTOJ0m;l0>M3DaCIbM2N3M31OO1001O2N1O1O1O1N2O1O1N2O1O1O1O1O100O1O2Mc[Q10]dnN001O1N2O1O1M3N2N2N3M2O2N11N1000000000O10001O0014K5K5J7JQj03lUO3K5L4M2M4L4M3M0O10O100000010M1J7I8H\\Q:KonE1N2O1J6K5O110N11O001N1000001OO1000001N10000000O100000000000010OO1O100000O1000O1000001O00010OO2O1ON110000000K@]C0Oa0b<600O2OOO21OMXOcCh0]g<01O0000N201N12N0O101O1OO1O11O@CdC11O32L;ZkS;QOlD`01>U;QOjDa01=];BcD:b;E_Di0S;VOmDl0Q;UOnDn0o:ROQEP1m:POSEQ1N_Nk:?XEX1g:fNYE\\1f:eNXE\\1i:bNUEa1l:^NTEc1l:[NTEn00^On:BREm00DS;YOmDP12IU;3lD1T;JmD9V;BiDa0Y;[OgDh0Z;SOfDP1];kNbDX1`;dN_D_1c;4M2M3M3M4M2M3M3M3M3N2M3M3O1N3M2N2O1N2N2N2N2O1N3M1OO2M2N2N2O1N30O1O1O100O1O1O1O0101O0J7J6I7J5O2O1N2N1O2O1N2N1O2O1J9gNY100O100O10O10O100O10000O10000O010O100O1O1O1OO101N1O100cEO^72aH5X7LgH5Y7KfH6Y7KcH8]7IaHg0Q7YOmHk0P7VOPI[1^6fNaIX1b6iN\\IR1i6oNWIl0m6UORIg0S7YOoH?V7BiH:[7GeH4`7L_H0iNZOVO1c8f0^IKkNDg7b0]IFnNJf7`0[IBROOc7`0ZI^OUOMmNMe8j0YIVOBOV7k0lJUOT5l0kJTOU5m0e30O1O100O1O100O2N100O1O100ON2N3L3M3NkLXOlId0V6_OhI>[6CdI:^6HbI5_6M`I0b63\\IJg67YIFh6jJi0EiNb5>hJj0EhNe5=eJk0FhNg5VJV1K\\NQ6=SJ[1HXNW6YL_3i0TOZOnLe3f4SM\\NXOPMb3c4WM^NWOQM_3a4[M^NVOSM\\3^4_M`NUOUMX3Z4eMaNROXMV3W4hMbNROYMS3W4jMlLPOJ3VOn2V4nMfLVONNXOk2U4QNaLYO3KWOY2g4bNkK_O7FTO\\2j4_NfKD<@RO9[Oj1b5gNbKI`0]OnN=^Od1c5iN\\KNe0XOkN`0Aa1c5hNYK2i0UOfNh2Y5QNVK4k0SOcNh0HW1e5hNUK7k0RO`Nn2`5iMSK8n0PO]NQ3c5fMRK:m0PO[NS3f5cMPK;P1oNZNR3g5cMoJ=P13ZNh0h5gNlJ`0R11ZNh0h5fNlJa0o0kN^N0OT10i0h5gNjJc0n0kNbNNNT3h5_MjJe0l0lNdNLNT3i5^MgJg0l0nNfNINU3h5]MgJh0j0oNiNHNT3h5\\MfJj0i0QOkNP1N>h5gNeJk0h0ROmNBNY12?g5gNdJm0f0TOoNANV17>b5jNbJn0f0VOQO^ONT1;>^5kNbJo0e0XORO\\ONR1`0;[5PO^JP1e0YOTO[ONn0e0:X5SO\\JQ1c0\\OVOWONn0h09W5TOXJT1b0]OYOTONl0i0:X5TOVJU1a0^OZOTONi0j0;Y5UORJV1a0@\\OQONf0l0=Y5UOPJW1?C^OnNNc0n0`0X5UOmIX1?D@mNN>Q1c0V5VOlIX1>FAjNN=T1c0U5WOjIY1T3A\\41VJ0YN`0S3@_40UJOXNb0R3Aa4NUJd0W1@e4LRJf0X1^Of4LQJg0X1^Og4KPJi0Y1[Oh4LlIk0X9UOgFm0Y9SOeFo0Z9QOeFP1[9QObFR1^9mNaFT1j1kN`41eIV1c1lNWM2\\7MhIV1e1kNWM3\\7KhIX1d1jNWM4]7KfIY1g1fNVM5_7KdIZ1c9gN\\FZ1c9fN]FZ1d9fN[F\\1c9dN\\F^1d9aN\\F`1c9aN\\F`1c9aN\\F`1d9_N[Fd1c9]N\\Fd1c9\\N]Fe1c9[N\\Ff1c9[N\\Ff1d9YN[Fi1d9XN[Fi1d9WN\\Fj1d9VN[Fj1e9VNZFl1f9TNYFl1g9UNXFl1g9TNYFm1g9SNWFn1i9RNWFo1h9RNWFn1j9RNUFo1j9QNVFP2j9PNTFQ2l9oMTFR2k9oMTFQ2m9oMRFQ2n9oMQFR2P:nMoER2R:mMnES2S:mMlES2T:nMkER2V:mMiET2X:lMgET2Y:lMgET2Z:lMeEh1MYN_:ObEi13SN\\:4aEi1k:WNTEi1m:VNSEj1m:WNREi1o:WNoDj1R;UNnDk1R;71N2O001O1O02O001N101O0O2O001N2OhMRER2m:oMSER2l:70fMTEU2j:lMVET2j:kMWE50d1i:WNWE23f1f:YNWEM7j1b:XNcEh1^:XNbEg1^:YNbEh1Y1VN[72\\Gg1W1aNV7HbGh1W1aNV7GdGg1Y1_NT7JcGg1\\1[NR7MbGh1_:YNaEf1`:ZN_Eg1a:XN`Eg1a:YN_E[1l:eNTE\\1l:dNSE]1m:bNSE^1n:bNQE_1o:aNPE`1P;_NRE`1n:`NRE_1o:aNRE^1n:cNRE\\1m:fNREZ1n:fNSEX1X1iNj70nFV1Q1POR8KlFU1HfNR1:[8KlFT1DiNV17[8MkFX1m0hNX81kFU1m0cNhN1b98iFT1k0cNiN3d97hFQ1k0QOW80mFo0k0nNjNG_91O10O01O100O1O10O01O1O100O1O100O1O10O02N00101N00100O1O010O1O1O100O1O010O1O100O001O100O1O100O1O10O01O1O100O1O010O0000010O1O2OO000100O1O0001O3N2O1N02N002N0001O00000O100000002N2N2N4L00O11N101O00O010O100O0100000O0100000G91O03N0O10O001O001N1O1N3M2N3O0O2OO10O1000O_OiA;Y>ChA<^>01N010O2O000O10000O1000O10O101OO010O1N11000O10O02N01000000000O2O1O0O01000O10O01000000O0100O1000N20O02O00O10fBJi;7WDJh;6YDJd;9ZDN`;2`DLa;5]DNa;4_DKa;7[DJe;7fC=YN4L3M4L3MO12GYA5j>OM36JRS]4", "size": [480, 640]}, "area": 18260.0, "iscrowd": 0, "image_id": 18150, "bbox": [0.0, 396.0, 338.0, 84.0], "category_id": 100, "id": 20001146}, {"segmentation": {"counts": "\\4Y9g50000OR1oNS1mNS1mNS1mNS1mNS1mNS1mNS1mN;E0000001O01O2N2O0O1O001O01O00000O2N100O1M3N2O10000O1000000000Ufo12hYPN3N2M1O100O1O1O2O0O11O001O001O02O1N2O3L00O20O010O01N101N101N101O000O2O001OYk9KiTFNXA3g>301N01001O0O1000000O1000O010001OO010O1N20O10O100O00100000O1000O01000O10O10O100O0100000O01000000OO200O0100000O01OO20O000010O0O200N3McVl4", "size": [480, 640]}, "area": 3650.0, "iscrowd": 0, "image_id": 18150, "bbox": [0.0, 140.0, 306.0, 304.0], "category_id": 105, "id": 20001147}, {"segmentation": {"counts": "Poo33m>5K8H8H5K5K;E001O001O1O001O06Jc^U1", "size": [480, 640]}, "area": 16566.0, "iscrowd": 0, "image_id": 18150, "bbox": [273.0, 0.0, 287.0, 183.0], "category_id": 109, "id": 20001148}, {"segmentation": {"counts": "Smi4220h>7WAK`>>L10000000000000000000002N001O00O100001OO11N10000000000O011OO100O01000O01000O100000O10000]OZOlBf0T=\\OiBe0h<^ORCOLl0T=POhB08[1Q=eNoB\\1P=dNoB^1Y=1O0002O1N2N>AoNUOPDj0S=01O001GjAFV>9kACZ><5M4I7MPYa3", "size": [480, 640]}, "area": 1708.0, "iscrowd": 0, "image_id": 18150, "bbox": [328.0, 122.0, 70.0, 63.0], "category_id": 112, "id": 20001149}, {"segmentation": {"counts": "cgo32j>6I7J7L0O001O10O0EkAHO1U>8;2O1N1O2N2O1N2N2N2O1N3M3M4WBoN^=0aBT1e=2M2O1N3M3N2M3C>J7L4L4L6I5L1O0N30O01O10O0\\OgDbMW;]2h0M1O2N2N2N2N200O10MmMYCS2g<23N000O10000O100O100O100O3N0O2O0O01000O2OO02O0O100O100O10O02OO010O10O10O0100O010O100O10WE_NS8`1mGaNS8_1mGaNS8_1lGbNT8]1lGdNU8[1kGeNV8Z1iGgNX8W1hGjNY8U1fGkN\\8T1dGlN\\8T1cGmN]8S1bGnN_8Q1aGoN_8Q1`GPO`8P1_GQO`8P1_GQOa8o0_GQOa8n0eFM[93TF>l9BSF?e9YNaEX1i0`0e9YN^E[1k0>g9GXF:e9IZF8`9N_F3_9O`F2_9O`F3a9J_F7b9H]F9d9F[F;f9DXF>i9AVF`0k9_OTFb0m9]OQFf0o9YOPFh0Q:WOmEl0R:TOmEn0R:QOmEQ1S:oNeE_N2d2X:mNdEbN2c2Y:m1O1O1O1OO10002N1O2N1O2N1N3]L]Ee2d:oLgEP3\\:kLhES3Z:hLjEV3Q;01N1O1O001O1O2N2O001VMQDb2WN2O1O1O100O100O10000O100O100O100O100O100O100O100O10000O100O100O100O100O100O100O100O100O100O1O100O100O100O100O1O100O100O100O1O100O100O100O100O1O100O100O100O1O100O1O1L4L4L4M3L4L4L4L4M3L4L4M3O1N2O1O1N2O1N2O1O1N2O1N2O1O100O10000O1000000O10000O10000O10000O10000O10000O1000000O10000O10000O10000O10000O10000O1001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O3M2N3M2N3M3M2N3M2N3M2N3M2PDQNk:R2nDQNS;R2eDRN\\;P2^DSNc;P2UDTNl;_2100O10000O100O10000O1O1O1O100O1O1O100000000000000000000000000O10000000000O10000O100000000O100000003M5K8H8G6K5K;ET1kNU1lNT1lNT1lNT1mNS1lNT1mNS1lN;F1O0O100O101N100O101N100O101N100O10001N100O100O100O100O100O100O100O100O100O1O100O100O100O100O1O100O100O100O1O100O100O100O100O1O100O100O100O1O100O1O1L4L4L4M3L4L4L4L4M2M3M4M200O2O000O2O0O10001N100O2O00010O01O1O010O1O10O01O10O01O1O010O1O010O1O010O1O00100O1O010O1O010O1O00100O00100O001O10O01O2O1N1O2O1N1O2N2O0O2N2O0O2N2O0O2N2N101N2N101N2N101N2N1O2O1N1O2O1N10100O00100O010O10O0100O010O10O02N2O2M2O2M3N1N3N1N3N1N3N2UGlJd7V5UHoJk7T5nGoJT8R5eGRKh0B_6_5bHRKP1A]6R6fInIX6Q6kIoIT6P6mIQJQ6i2dH7^1oLn5i2dH8_1PMk5g2gH9`1PMh5f2hH9d1PMb5f2kH:o8EQG:P9FQG9o8FRG:l1PMQ5e2SI:m1SMn4b2VI:m1VMk4`2XI9n1YMh4]2[I9n1\\Md4\\2^I8n1^Mb4Y2aI8o1aM]4W2dI7Q2cMX4W2gI5S2eMT4U2jI6S2fMQ4T2lI6S2hMo3Q2oI7R2jMl3P2RJ6R2lMj3m1UJ7R2mMg3l1WJ7R2oMe3i1ZJ8Q2RNa3g1^J7Q2TN_3d1aJ8P2VN]3b1cJ8P2XN[3`1eJ8P2ZNX3^1iJ8P2[NU3]1kJ8P2]NS3Z1nJ8P2`NP3X1QK7o1dNl2U1VK7n1fNj2S1XK7n1hNh2Q1ZK7n1jNe2P1]K6Q2iN`2P1`K6S2jN[2P1bK6U2jNW2P1dK6X2iNQ2R1gK4[2jNl1R1iK4^2jNf1R1lK4T3VNn0f1nK4Q4[MNb2QL3c8L^G3c8M]G3c8M]G3b8N^G2b8N^G2Y4`MXO^2_L2U4gMXOX2cL1Q4mMZOS2dL0o3RN[Oo1eLNo3TN]Oo1cLMo3SN_OQ2cLKl3UNBQ2aLJk3VNEQ2_LIj3VNIR2\\LHj3jMiKH00Q4h2[LFi3kM9`2mKEh3mM;_2lKDg3oM=_2jKAi3PN=a2iK_Oh3RN?`2hK_Of3SNb0_2gK^Oe3UNd0_2eK]Od3VNf0V5YOkJg0V5VOlJj0T5TOnJk0T5ROoJm0Q5ROQKhLoNl3Q6YO\\Ke0e4YOSJhLR1m3m4XOjISM\\1c3j4DWK:k4DWK:j4EYK8h4]LfIW3e1:f4^LnIo2^1`0e4bLhJQ2g0Y1c4eLjJb1R1e1U4iLlJ\\1V1g1o3mLnJU1Z1i1i3RMPKo0_1i1Y5PNRKg1S5RNPKm1T5lMQKS2S5eMQKZ2l8N1O2O1N1O]O[NnCc1QZ54QK]OF?X56QKYOIb0T56SKWOJc0S57RKUOLe0P57TKSOMg0m48UKPOOh0k4:UKmN1j0h4;VKjN4j0f4>SKhN8k0c4?TKeN:l0a4a0TKaN=o0^4a0TK_N?P1\\4c0TK\\Na0R1Y4d0UKXNd0U1V4d0UKVNg0U1o3k0YKoMi0W1j3m0]KjMl0X1k0^N\\Ob2mNgMn0Y1h0^N\\Oc2mNeMQ1Z1f0^N[Od2nN\\M_N2d2`1c0^N[Oe2oNYMcN0c2c1`0_NZOf2R2kNcN_NYOh2U2hNbN`NXOi2W2gN`N`NXOj2Y2eN_NaNXOj2X2gN_N_NXOk2Y2fN_N_NWOm2Y2eN_N^NWOP3X2bNaN^NWOQ3W2bN_N[NoL2Z2T3V2_NPLcNg1L2T3V2^NlKSO_1[O>W3U2[NjK\\O^1ROc0X3S2\\NhKA^1kNf0[3aNcLe2e1cLH`1dNf0^3VNlLP3m2RNjLh0_3QNmLT3l2RNhLh0a3mMPMV3j2TNeLi0Z4S1QOTNeLh0[4S1ROTNcLi0[4R1TOTNaLi0\\4R1UOSN`Lj0\\4R1VOSN^Lk0\\4Q1WOTN]Lj0]4Q1XOUNZLj0_4o0XOWNYLi0`4P1XOWNWLi0b4o0WOXNWLh0d4VNZKb2k3`NVLh0n4g0lNaNVLg0P5g0kNbNTLg0R5f0jNcNTLf0T5g0hNbNTLg0U5f0gNcNTLf0]5`0_NjNTLe0_55bJVNm3o0RLe0a53gJTNf3T1RLc0d53hNYOdKb0f54gNYOdK`0h55gNXOcKa0i55eNXOdK`0j57dNQOiKe0g58aNnNmKi0e57_NnNmKj0j52ZNSOmKk0j51ZNROmKm0i50\\NhNULW1a50\\O0d0O]O1c0N^O1d0N\\O2d0M]O3d0L\\O3e0L\\O4e0K[O5e0J\\O5e0K[O5f0I[O7e0I[O8d0G]O9c0F^O;`0F@:`0DB==BD>1N00001O4VAIc>;O3K200001O00001O00O11O0000000O11O001N101N1O11N100O101O0O11OO2N10001O2N2ON2O2N1O1O2NO01001OMOdAD\\>9bAE_>:4O100L4O1Om_]1", "size": [480, 640]}, "area": 839.0, "iscrowd": 0, "image_id": 18193, "bbox": [480.0, 445.0, 62.0, 24.0], "category_id": 94, "id": 20001154}, {"segmentation": {"counts": "hkk233Od>7001O1O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O1N2N2N2OMaAG_>2jU`2", "size": [480, 640]}, "area": 1933.0, "iscrowd": 0, "image_id": 18193, "bbox": [195.0, 465.0, 273.0, 15.0], "category_id": 105, "id": 20001155}, {"segmentation": {"counts": "l[f43k>9G:F6J101N101O1N2O001O00100O100O2N1O100O1000O0106J5J101O000O2O000O2O000O2O000O2O001N0100N1N3M3M201000O10000O01000O1dC]N[;c1_DcNa;^1]DcNb;^1^DbNb;_1\\DbNd;_1ZDbNe;_1[DaNe;a1XD`Nh;`1WDbNh;_1WDaNi;`1UDaNk;`1TD`Nl;a1RD`Nn;a1PD`NPQ<@PD`0R<]OnCe0P<\\OPDd0P<\\OPDd0P<\\OPDd0P<\\OPDd0P<\\OPDd0P<\\OoCd0R<\\OnCd0R<\\OnCc0S<]OmCc0S<]OmCc0R<^OnCa0S<^OnCb0SHoA7T>DQB9]>M2O2N2Mcim2", "size": [480, 640]}, "area": 6858.0, "iscrowd": 0, "image_id": 18193, "bbox": [320.0, 341.0, 119.0, 97.0], "category_id": 121, "id": 20001156}, {"segmentation": {"counts": "0e<[200000000KfMcC[2X<9O1M3M3HUMUDQ3k;2N2\\KoLWMS3e2RMbJGQ1Y3[4SMXJDoN0J2`2Z3^4RMRJ3^1n2_4oLSJ4R1^OSNd3g6nLQJ1R1Z3l4cLUJ4b0e3Y5XL]I@H2>b0T1d3X5ZL\\IJ28Z1d3W5TMZIYO_1c3V5PNkJo1U5hKYIV2b1R2X5oMgJQ2[5mMeJS2Z5lMhJT2W5mMiJS2U5nMlJR2T5nMmJQ2n4iK_IW2b1P2a4nKPJMJX2c1n1c4QLkII0V2c1Q2a4aN_K_1`4bN`K^1_4gNoIPMY1Z4i4fNmITMT1X4o4kNoIlLh0[4Y5jNnInLf0X4]5kNkIPMb0X4c5VOYJk0g5]OkIi0U6Q41O00000000001OO1005K1O0K5K4M400000O10000O1000000O1000000O01O1O10O2O002M4M3M1O3L10004ROVG^Kj8b4WG\\Kj8d4^GSKc8i0XGc2d0N200000000001O001O0000000011N13M:FlNIeBI0Ob0?h<1XC0f<1XC1g\\1N00001O4VAIc>;O3K200001O00001O00O11O0000000O11O001N101N1O11N100O101O0O11OO2N10001O2N2ON2O2N1O1O2NO01001OMOdAD\\>ZF8[OOD_Oe:;\\F8YO;Z:^O]F9WO9[:_O]F:ROTOKT1e:@]F7oNb0d:YO[Fg1d9]NYFc1g9^NXFb1h9_NXF`1h9`NYF_1g9bNXF^1h9cNSFROYO[2d:eNPF`1o9bNgElNHg2_:`NbEj1^:XN`Eh1_:]10000O1001O00O100O10000001O00001O001O1O1O00001O1O1O0iK[E10m3f:QLZE02o3d:QL\\E1Ol3j:ULUEk3j:61O001O2N2SLoDg3S;WLnD1Od3Y;000001O2NO1O100O100M[LjDf3U;3000000O11O0000000000001O001O001O1O001O00001O1O1O000000", "size": [480, 640]}, "area": 158233.0, "iscrowd": 0, "image_id": 18193, "bbox": [0.0, 0.0, 640.0, 480.0], "category_id": 154, "id": 20001157}, {"segmentation": {"counts": "mfj77i>2L103NOaAFc0On<<]BGc0OA2S=:hBDd01@2oZF8[OOD_Oe:;\\F8YO;Z:^O]F9WO9[:_O]F:ROTOKT1e:@]F7oNb0d:YO[Fg1d9]NYFc1g9^NXFb1h9_NXF`1h9`NYF_1g9bNXF^1h9cNSFROYO[2d:eNPF`1o9bNgElNHg2_:`NbEj1^:XN`Eh1_:]10000O1001O00O100O10000001O00001O001O1O1O00001O1O1O0iK[E10m3f:QLZE02o3d:QL\\E1Ol3j:ULUEk3j:61O001O2N2SLoDg3S;WLnD1Od3Y;000001O2NO1O100O100M[LjDf3U;3000000O11O0000000000001O001O001O1O001O00001O1O1O000000", "size": [480, 640]}, "area": 11965.0, "iscrowd": 0, "image_id": 18193, "bbox": [534.0, 335.0, 106.0, 145.0], "category_id": 162, "id": 20001158}, {"segmentation": {"counts": "e<[2e<0000000KfMcC[2X<9O1M3M3HUMUDQ3k;2N2\\KoLWMS3e2RMbJGQ1Y3[4SMXJDoN0J2`2Z3^4RMRJ3^1n2_4oLSJ4R1^OSNd3g6nLQJ1R1Z3l4cLUJ4b0e3Y5XL]I@H2>b0T1d3X5ZL\\IJ28Z1d3W5TMZIYO_1c3V5PNkJo1U5hKYIV2b1R2X5oMgJQ2[5mMeJS2Z5lMhJT2W5PL[I]1^1c2U5kKiI\\1S1i2T5jKoIX1n0m2n4iK_I1j0V1h0P3a4nKPJMJ0S1Q1`0U3c4QLkII0OX1k0;]3a4YLZK55b3`4YL`K10f3_4YLgK0XN^OY1Z4i4VLlKNQNFT1X4o4SLRL1mMCh0[4Y5PLXLNfMJf0X4]5nK]LM^M0b0X4c5jKcL7fMP4g5hKiL;RMS4U6aKoLQ5R3nJSMm4m2SKYMg4g2XK_Mc4a2]KdM^4\\2bKiMY4W2fKnMV4S2iKQNS4n1nKWNm3i1SL[Ni3j1QL[Nk3a6L5F8H7J5O2N2N2N2N2N2N1O2N2N2N2N2N2N2M2N3M3N2O1N2001N2OO11ON2N22QHWNa2g1_MZNa2e1_McN[2[1`MlN`2R1_MoNb2P1]MROd2l0\\MUOd2j0\\MWOd2h0\\MYOd2f0]MXOf2f0ZMXOi2g0WMXOk2g0TMYOn2f0SMWOQ3g0nLYOT3f0mLXOU3g0kLXOW3g0iLWO[3g0dLYO^3f0`L[Ob3d0_LYOd3f0\\LYOg3e0XL[Oj3d0VLZOm3e0SLZOo3e0QLZOR4d0lK]OV4b0iK]O[4a0eK^O]4a0bK_Oa4?^K@f4>YKCh46J7J001O000000O1001O0000001OO10001N2O011OOO10000001OO11N100O11O0000000000N021O1N11OM_OgAa0Z>21O0O0110O1O0000000002M2O1O01M30O000000000O100001O1OO3N5K4K2N2NdQ>O]nA9G1N023L10O1000001N02OO2O0O001O1O2O1O00000010O01OO10000001O000000N2N2N2@GWB;i=HRB:m==LSOTBn0`=?0000000000000000000000000A`B^O`=`0cB]O_==iB\\O\\=`0d0N200000000001O001O000000001O004L;NoNlA0Ob0\\>00N1000000000O11N1000000000001Nil24TSM00000O10000000000001N3O0N2O2N]AEb><1O1N1O020O00[AGc>;0O20O0O2N0N3O1N1O1100O03N0000O100O100000O1O1\\O]OlBb0T=_OkBa0i0m`7b0f^H0RB^O\\=S101OO11O000000001O0O02O01OO10007H6K2M2N1N30O01O00000000O110O0O1000011O01N00O11O000000O2O0001O00O10000009G7Hb]P3", "size": [480, 640]}, "area": 5676.0, "iscrowd": 0, "image_id": 18193, "bbox": [89.0, 0.0, 345.0, 146.0], "category_id": 182, "id": 20001160}, {"segmentation": {"counts": "U[=7b>M3M3L4M3M3M3N2O100O4M1N2O0O3M100O100O2N100O100O100O1O01O0010O100O1O100O100O10000000000000000000O11O00000000000000000000O10000000001O2N2N2N2N2N2N2N2N2N2N2N4L5L4K5K4L\\O`DCd;MiD2S;BXEb0g;VOaCl0\\<4MNO34J4M2L`J", "size": [426, 640]}, "area": 3416.0, "iscrowd": 0, "image_id": 18380, "bbox": [507.0, 96.0, 133.0, 106.0], "category_id": 98, "id": 20001162}, {"segmentation": {"counts": "cX3K3L10001OO10000l\\X3", "size": [426, 640]}, "area": 3353.0, "iscrowd": 0, "image_id": 18380, "bbox": [323.0, 10.0, 66.0, 129.0], "category_id": 112, "id": 20001164}, {"segmentation": {"counts": "0l2^:0000000000O10000000000O10000000000O1000000O10000000000000000XO`EfN`:Z1aEdN`:Z1cEeN]:X1hEfNX:W1lEhNT:V1PFhNP:V1SFiNm9W1UFgNP:T1PFkNU:Q1jEPO[:k0eEUOb:LiD?e0En:8REHP;6PEJT;1mDO[;IeD6X<0001O001O5J`U11\\]NONOl<>N1O003M4L2NObCYO[[GMlNEm;7f0JO0l;POm1e7jMVI9UOm1e7QNWH]O?e0Em1e7]NcHFHm1e7_NaHDJm1e7cN\\HAOl1e7kNTHYO6m1f7FZH9g7GYH9g7HXH8h7HXH8h7IWH7i7NQH3o7d200000jJRH0ONOk4_8N1O0O4M4L2NOdKWGZ4o8M102M2aLQG`2P9SM_Gi2b8UMgGd2Y8WMRHb2^9NO001O0O2O1O001O001O0O2O001O001O0O2O001O001NIlEZMT:d2oE\\M[71nJa2jM]MX7;eJV2VN_MT7b0_Jl1aNaMP7k0WJb1lNdMk6S1PJY1WOaMj6^1fIQ1Q7YOeHg0[7A]H>d7JSH7m71kGNV8c20O1O100O100O100O1O100O100O100O10000O100000000000000001O1O001O1O1O1O00@fGQLY8j3PHRLP8j3WHTLh7g3`HVL`7f3fHYLY7b3mH]LS7_3RIaLm6]3VIbLj6]3YIbLf6]3\\IcLc6\\3_IeL_6Z3cIgL[6X3gIhLX6W3kIgLU6X3o1O1O1O100000000000000000000000000000000001O1O1O2N1O1O2N1O3M4L4L4L6J4L2NO100O1O100O1O100mNYGbMh8`2ZG\\Mf8e2ZGZMf8f2ZGZMf8e2\\GZMd8d1nFkN?Ac8b1YGcN6Ja8`1`GbNONa8M[Gg06^OOM`8N\\Gf05_OOM`8OZGg06^O0K`85VGd08[O2L`89QGa0=YO4L^89SGa0;[O3K_87UGc09_O0Fb87XGb06^O:BX8>\\Ga0O_Oe9OaF=KDd9OaF<2TO[O2X:>[FPF\\EAg:?[E\\Oh:d0XEYOk:g0UEXOl:h0TEXOl:h0TEWOm:i0SEWOm:i0TEUOm:k0SEUOm:k0SEUOm:k0SETOn:l0RETOn:l0RESO3NT:S1eEoN5OW:^1WEcNc0OV:^1PFbNP:^1PFbNP:]1RFbNn9`1PFaNo9\\1TFdNl9Y1WFhNh9V1[FjNd9T1^FlNb9R1`FnN`9Q1aFQO]9o0eFPOZ9o0kFnNT9R1b100OjD_Oe9a0[FE_9:bFF^9:cFE]9:dFE]9;aFH^90cE]Oo0c0^9OjF2V9MmF1S9MPGNT9HVG7k84P2E\\COe<1:0000000000000000000QCHl<`0K3M2N00000000000000005K1O0000000000N2M30_CYO_0000000000M3O1000000O1O100O0100000000000001O1O00000O1WD[On:d0QE_Om:a0lD\\OA9_;;mDOQ;4aD6`;k0O0000000000000000000O02O0000000YN`Dd1a;[N_De1c;0000000000000O1M3[OZNdEh1X:VNZE86e1[:SN`Eb2[::J5J6K5YGcL\\7k3THbLb7c3RHhLk7^4mGjJP8X501ON25K3M2N", "size": [426, 640]}, "area": 49117.0, "iscrowd": 0, "image_id": 18380, "bbox": [0.0, 0.0, 640.0, 273.0], "category_id": 172, "id": 20001168}, {"segmentation": {"counts": "_e0o4S88I7H8I7I7I7J6I7J6J6O1O1N2O1O1O1O1O1O1N2O1O1O1O1O1N2O1O10000000000O1000000000000000O100000O10000000000000000000000O10000001O001O001O001O001O001O001O1O001O001O0hKXJn0i5SOWJk0i5WOXJf0i5[OXJb0h5@YJ=h5CZJ:f5H[J5f5L[J1e53ZJJg59XJDh5`0WJ]Oj5f0UJWOc5lL^JQ4NPOb5RM`JQ4MjNa5XMaJR4McN`5^McJm6Z5WIeJi6Y5ZIiJc6W5_IiJ_6V5dIkJY6U5iIlJT6S5oImJo5S5SJnJi5R5[JmJc5S5_JnJ^5Q5eJPKX5o4kJQKS5o4d1O10eNjJbJU5a5lJ\\JT5e5oJWJP5l5PKRJo4Q6QKmIo4U6QKiIn4Z6RKdIn4^6QKaIn4b6RK\\In4f6RKXIm4k6RKTIn4n6RKPIn4R7RKkHn4X7RKfHn4\\7QKbH1Jf4f7YK]H0Og4e7ZKYHN4h4e7YKaHg4a7YK]Hg4b7XK`Hh4Q8001O1O001O1O1O1O00@gGPLX8k3QHQLo7k3XHSLg7h3aHUL_7g3gHXLX7c3nH\\LR7`3SI`Ll6^3WIaLi6^3ZIaLe6^3]IcLa6\\3aIeL]6Z3eIfLZ6Y3hIhLV6W3mIiLQ6V3RJjLl5U3XJjLf5U3^JjL`5U3dJRMR5n2PKQMo4o2TKPMj4P3YKnLf4R3\\K[MU4e2nKZMP4f2SLYMk3g2WLXMh3h2ZLXMd3h2^LXM`3h2bLWM]3i2eLWMY3i2iLWMU3i2mLVMLDOV37VMeMCP13T1T39VM_MHo0N[1T39VMZMLNM2L_2U39XMYMHG62Eg2V37PMgMJTOa01_Oo2W36gLgNe0U1e2`2VMbMl2]2QMeMP3[2mLgMT3Y2iLiMY3U2fLlM\\3S2aLoMb3o1[LSNi3e54L4L8H8HK5OPIgKQ5Y4TKhKf4W4^KlK\\4S4gKRLR4n3PLlKT4S4b2O100OdJoKa1Q4_NUL[1k3dNZLX1f3hNXLZ1h3eNWL]1i3cNUL`1j3_NULc1k3]NSLe1m3ZNRLh1n3XNPLj1P4UNoKm1Q4SNmKo1S4PNlKR2T4nMkKS2U4a300001O001N101O00K5L4MTHTL`6k3^IYLa6f3`IZL`6^3VHaL]10\\6[3\\HcL\\10W6X3bHgLU9U3oFjLR9R3QGnLP9m2TGSMm8g2XGYMi8\\2`GeMa8W2bGiM_8T2cGlMa10P4Q2aJoM]8n1RGQNG1X9k1cGXN^8g1c100O100OeGYNU5g1hJ[NY5e1eJ\\N\\5c1\\HXN_16V6b1ZHXN_17X6`1XH[N^16[6_1VH\\N^13_6`1TH]N[10g6b1oG]NX1Nn6d1kG^NT:b1lE]NP10\\7a1fG`Nk00`7[1kGdNd01b7X1mGhN>1f7U1nGkN:0i7S1PHlN61k7Q1QHoNIMVO3Q9P1QHQOC2YOLT9Q1RHPO^O8XOGY9P1VHoNUO`0f8a0XHnNnNb0k8`0cGVO^OKJb0V9<`GHUO4\\94`GGXO0Y98`GHZOMV9;`GHZOOT98bGJZOOS97bGK[O0Q95cGL\\O1o83dGM]O1n84aGMA1l85^GLE1l85[GLH2k84YGLK2k8d1SG_Nk8a1TG_Nm8b1QG]NQ9l22O1N101O10000O10000000000000000BkFgLU9V3oFiLQ9T3RGlLn8R3TGmLm8P3VGPMj8m2YGSMg8j2\\GVMd8i2]GWMc8i2^GVMb8i2_GWMa8i2_GWMa8h2`GXM`8h2`GXM`8h2`GXM`8g2aGYM_8g2bGWM_8h2bGXM^8h2bGXM^8g2cGYM]8g2fGVMZ8i2T100_Oa0N2N2N2N21O1O001O001O1O001O1O3M5K5K2N1O001O001O001O001O002N2N1O2N2N2O1N2N1O2`FfLl8\\3PGiLm8Y3lFnLR9f3O2N1O2N2N1O2N2N1O2N2NcN]GTNb8i1dGVNZ8g1lGXNR8f1SHXNl7f1YHYNe7e1_HZN`7d1cH]N[7`1iHaNU7\\1nHmMXOIi7X2RIkM[OLa7V2XIjM\\OM]7W2ZIjM[OL]7Z2YIgM]OMZOOi7]2aIeMg7[2d1O1000000001O1ZHbM^4^2_KgM_4Z2]KnM^4R2`KRN^4o1_KTN`4l1kKfMX4[2nJaMo5`2lI^MZ6d2U22N2mHXM`3k2kIUMh10[4h2eLXMZ3e2QJ[Mj11S4\\2ZJcMe12o3Y2RJeM^O0d22k3V2XJoMo1Lg3S2^JnMn1Ob3R2cJkMn13^3P2mMQNQ2o1QNPNn1o1TNRNj1l1YNUNe1j1]NVNb1j1`NVN^1j1oKRN:4f3j1oKSN<2e3k1nKTN?O^MNQ6o1RLTN`04\\3h1TLTNa04Z3h1ULTNc04V3h1WLTNd05S3g1XLTNg05P3h1YLRNi06l2h1]LRNf06l2h1`LQNe07i2i1cLPN]N5Y12e3i1fLPNQN?f1Gb3k1fLQNgMg0S2\\O^3l1hLmNLWOZ3m1iLmNNUOX3n1mLZNgMOV2IT3o1QMUNhM2U2IP3Q2\\KlMQ12`N8S2Jo2Q2ZKoM_166Mo2o1ZKPN`146Oo2l2gLUM0i2o2hLRM=0j2o2iLRM;1j2n2kLRM92j2n2lLQM82k2n2lLRM63l2l2mLjL[NKj1a0l2k2oLeLdNK_1f0m2l2nL`LkNNW1i0n2j2PM\\LPO0P1l0n2i2jM[LUOn0P3i2]OYMa0i2kMYLPOR1T3g2iMZLoNS1V3f2fM[LoNT1Y3e2bM[LPOT1]3h2ZMXLTOh0YOQOW4k3jKmK_1b0lNj04bNe3U4oKmKX1e0dNm0l4`2\\KnK?NFP1B:Q5i2SLQLWOe064d4V3RLQLiN?3^On0`0X4a3YLZL0Ik3l3[LSLa5m3^JQLe5n3\\JPLf5o3ZJRLf5o3YJQLg5o3XJRLh5n3XJRLh5n3WJSLi5m3WJSLi5n3UJSLk5m3UJSLk5m3]IkLc6n40O10000000000000000000000000\\MWJgMi5Z2XJdMh5^2WJaMh5b2XJ\\Mh5f2XJXMh5i2XJVMh5l2XJRMh5P3XJnLh5Z500000000001O2N2N2N2N2N2N2N2N7I8H7I8HlK\\Jj0\\5oNnJX1h4dN]K]1a4cN_K_1_4aNaKa1]4_NcKb1\\4]NeKe1Y4[NgKg1W4ZNhKh1V4XNfKm1Y4SNoJ]M5n4j4X3N2N1O2_O`GTLb8l3^GRL`8Q4`GnK_8T4bGjK\\8Z4dGdK[8d0RH`2DjLX8c0WHg2@eLW8h0VHe2DaLU8m0THd2n7`MnGd2n7`MoGb2o7aMmGb2P8]1O1N2G9DhJoNhMc0`7>VJAZN1`7?cI2mN_O`7?RIc0^OnN`7`0_HT11\\N`7[3`HeL`7[3`HeL`7[3`HeL`7[3`HeL`7[3`HeL`7[3`HeL`7[3`HeL`7Z3aHfL_7Z3aHfL_7Z3aHfL_7Z3aHfL_7Z3aHfL_7Z3aHfL_7R2aImLPOQ1_7o1lIQNT6k1TJQNl5l1XJRNi5g1^JYNb5`1eJ_N\\5a1dJ_N\\5a1dJ`N[5`1eJ`N[5`1eJ`N[5`1dJbN[5^1eJbN[5^1eJbN[5^1eJbN[5^1eJbN[5^1eJbN[5`1cJ`N]5a1bJ_N^5c1`J]N`5d1^J]Nb5e1\\J[Nd5f1ZJ[Nf5g1XJYNh5g1XJYNh5h1VJYNj5h1UJXNk5h1TJYNl5h1SJXNm5i1RJWNn5j1PJWNP6i1PJWNP6j1gHTNJ2_7X3aHhL_7X3aHhL_7X3aHhL_7X3`HiL`7W3`HiL`7W3`HiL`7W3`HiL`7W3`HiL`7W3`HiL`7W3`HiL`7W3`HiL`7W3`HiL`7W3`HiL`7W3`HiL`7a400000001O00O1001O0000000000000000000000O1000000000000O10000000000001O000000001O000000000000O100O1001O]NaHZM_7d2eHZM[7d2fH]MZ7a2hH_MX7_2jHaMV7]2lHcMT7V2SIjMm6d1eI\\N[6d1dI]N\\6c1]IRMSO[1`7b1]IVMPOi08XO[7i2[InM_7R2`HkMd7a1eGQNf0:j7a1fGRN?;o7b1eGQN`04P8k1cGnMd0Lm7U2bGmMf9R2j000001O00001O00001O0lGjMS5V2\\HjMj17j5P2YHlMj15n5_2VJ\\Mk5e2]2001O001O001O001O0]FSM_O2m8m2cGRM\\O5o8l2cGQMZO6Q9l2cGZM[8i2cGXMJAR8Z3RHVMLKe7Q3dHPME0e7S3jHcLE:`7V3\\IjLc6X3[IhLe6[3XIfLg6\\3VIeLj6]3TIcLl6_3PIbLQ7n3\\HULd7k3n0ROn0N2O1N2O1N2O1N2N2O1@mEfMU:Y2?O1OYHaMd4_2YKdMg4[2WKgMj4X2TKkMl4T2RKoMn4Q2PKQNP5n1nJSNT5l1jJYNT5g1iJ\\NW5c1gJ`NY5_1iJ_NX5`1kJ]NV5c1mJXNU5g1nJWNR5h1QKVNo4l1RKoMP5V2mJgMT5^2j26J5K1O000000001O00000000000SGWMX7i2WHlMe7T2jGaNR8`3L4L4L4L4L4L2N000000000000001O00000000000000O10000000000000000O100000000O10000001OO11OO1001O0000000000000000000000000000O10000000000000000000000000000001O00001O001O001O1O00O1O1O10000O10000O1000000000000O100000000001O00000000O1000000000000000000000000000000000000000000000000O1000000O10000000000O100O10000001O00000000000000000000000000000000000000000000000000000000001O0000O10000000000000000000000O1O100O1MSHgJn7Y5RHgJn7X53001O00O1001O00O100000000001O00O1O11O1OO100001OO1001O000000000000O1001O00O100001OO1O11O0000O11O000000000000000000", "size": [427, 640]}, "area": 97071.0, "iscrowd": 0, "image_id": 18491, "bbox": [0.0, 0.0, 640.0, 194.0], "category_id": 99, "id": 20001170}, {"segmentation": {"counts": "j5a7j501O00O100000000000000000000000000000000000000001O00000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000001VIXJo5i5[IVJ8=[6X601O00001O001OZOeI\\J[6a5mIYJT6e5PJXJQ6f5SJWJn5h5UJVJk5i5l0O100000000000000000000001O2N3M6J9G1O001O001O^O]I\\Jc6d5`IZJ_6h5`IWJ`6i5aIWJ^6l5`ISJ`6Q6]IoIb6c5_I`JNLc6c5cI`JIMc6a5hI_JGOa6b5kI\\JD1b6c5lIYJD1b6f5k000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000000000O100O1001O00001O0000000000000000000000000000000000000000000000000000000000000000000000000000001O00O1001O000000000000000000000mI]J^4b5^KfJ_4Z5\\KPK_4P5_KWK\\4i4bK^KY4b4fKdKU4\\4iKjKS4V4lKoKP4P4oKSLP4m3nKVLQ4j3nKXLQ4h3mK[LR4e3mK\\LS4d3mK]LR4c3mK_LR4b3lK`LS4`3mKaLR4_3mKcLR4]3kKfLU4Z3fKlLY4U3dKnL[4R3cKQM\\4o2bKTM]4l2bKUM^4k2aKVM_4j2`KWM`4i2_KXMa4g2`KYM`4g2`KYM`4f2aK[M^4e2bK[M^4f2aKZM_4f2aKZM_4f2aKZM_4f2bKYM^4g2bKYM^4g2bKXM_4h2aKZKNl0a4j3aKXK1l0_4l3`KVK3n0]4l3aKSK5P1Z4m3bKPK7FFm0a4]4cKmJL]O9c3`5hKjI90Ae0_4]5bLRJoN`0_4Z5dLYJlN=`4T5gLbJiN:`4k4oLmJ`N8a4c4UMXKZN4a4d4TMZKZN1c4d4RM_KYNMe4c4RMbKXNKf4a4RMeKYNJe4f4lL`K`NMa4h4iL\\KfNN_4k4eLWKmNO]4o4`LRKTO0[4P5bKVJf0k0^O0Y4Q5`KTJc00Ak041W4R5SLVJ_Og072V4[5iKnIId0:3S4]5gKmILb0<5o3_5eKkI0??7k3`6YL`Ie3_6]LaIb3]6aLdI\\OSOi3V5TLfLk0POUOVOl3V5WL]Lk0^Om2V4YLYLm0@i2X4[LULn0Bg2Y4]LSLl0Dg2Z4_LnKl0Ge2[4bLjKk0Jc2\\4PM[K?8a2\\4WMUK:>_2d4gLVKl05]2f4dLWKo03]2g4aLWKT11[2h4_LXKX1OY2j4\\LXK]1MW2l4YLYKa1JV2m4WL[Kc1HV2n4UL\\Ke1EV2o4VL[Ke1EU2Q5ULZKf1FT2P5WLYKf1FS2R5VLXKg1FS2S5VLVKh1FR2T5VLWKg1DT2o4YL\\JLP1d0_OM6Z3m4^L_K9AN2[3n4_L^K6FNO\\3l4bL_K2INL^3l4bL_K0MOH^3l4dL_KJ31D`3j4fL^KD;4\\Oc3i4hLPMDVNd3l4gLoLCTNg3m4fLQMARNi3m4gLgMZ3X2hLfMY3Y2kLcMV3[2oL`MS3`2mL_MT3a2mL]MT3a2nL^MS3a2oL]MR3b2oL]MR3e2mLYMT3i2jLWMV3l2hLSMX3o2fLQMZ3Q3eLnL[3U3cLjL]3X3aLhL_3[3_LdLa3^3^LaLb3a3]L^Lc3e3ZL[Lf3g3YLXLg3k3WLVLg3l3XL[L`3g3^L^L]3d3bL\\L]3d3dL\\L[3d3eL]LZ3c3gL]LX3c3iL]LV3b3kL^LU3b3lL]LT3j2_LRK>S2S3k2cLnJ:W2S3k2gLjJ7m0ANb3[4jLfJ4o0BO`3\\4nLbJ0R1EN]3^4RM^J0Q1C2[3_4oMZKiN5X3a4oMYKkN4W3d4nMVKmN5U3e4oMTKnN6S3f4PNRKnN8R3f4PNRKoN7Q3g4QNQKnN7R3h4QNoJoN8P3i4RNnJnN9P3i4RNmJPO9n2i4TNmJnN:n2i4UNlJmN:o2j4TNkJoN:m2k4UNjJnN;m2k4VNhJoNZFEY;f0gDZOn:Q1REoNi:V1WEjNh:W1XEiNf:Y1ZEgNe:Y1\\EgNc:Z1]EfNa:\\1_EdN`:]1`EcN]:?dFAX9b0iF^OR9e0PG[Ok8i0VGXOe8k0\\GUO_8n0cGRO[8P1eGPOY8R1gGnNW8T1iGlNU8V1kGiNT8Y1mGfNQ8\\1QHbNm7a1l1;Eb0^O3M3WF_Me8c2ZG]Mg8c2XG]Mi8k2nFUMT9k2jFUMW9j2iFVMY9h2gFXMZ9g2fFYM^9c2bF]Mf9[2ZFeMh9Y2XFgMi9o1`FPNa9_1PGaNQ9l0aGTO_8:SHFi:000000000000000O10000000000hNQ1TDoNi;[1L9H4H7I70O100000000000000O102N1O2N2N1N3N1N101O1N101N2O1O0@dDPOl<00000000000000000000O10000000\\P82]oG8H:I7I7J6I6K5J3M3N2M2O2O1N2N2O1N1M4J6M3M3M3N1O1O1O10000000000[NUMjHk2T7XMkHh2S7ZMnHe2P7]MPIc2n6_MRI`2m6aMTI`0bNm0S8jN[I7eNn0^7]OmICgNo0]7WO]HTO`1c0iNQ1Z7WO_HSO`1b0jNHIf0^7LcIZOUO9G_O7`09m6GPIh1BXNd09k6EPI]28nMj6CoHKHj1b0iNZOROW7=WID^O6a0b1_O^6CeHF`0U1`0@^65UI7?C^64UI7=E`62UI6=G`61[IO7Oa6NfIEKn6ZOYHNNb0m05l6UOfGNOn0?LP13n5V1PIhNT11j5Z1oHfNY10f5\\1nHfN]1Mc5_1nHfN`1Ja5b1lHfNc1H_5d1mHeNe1F]5g1nHbNf1FZ5k1oH_Ng1FX5m1RI\\Ng1FV5P2RI[Ng1Eg4]OjIe2IXNg1Ee4]2eIoLNP1g1De4\\2mIoM;_OM5k5[2PJRN6AN2k5X2UJTN0FNNl5V2ZJVNJINLl5S2_JXNEMOHk5Q2eJZN\\O31Cn5m1iJ\\NSO;4\\Oo5l1mJMSOUNP6l1QK0mNTNR6i1TK5hNQNT6i1WKk0i4XOWKe0i4^OXK=j4FUK7k4LSK3m40RKNS51jJN\\5OcJOc5OZJ0l5MSJ2R6KlI5T6NjI1V61hIOX63gILY67eIH[6:cIF^6<`IC`6?_I@a6b0^I]Ob6f0[IZOe6h0ZIWOf6l0XIUOf6hN[I?NP1_6oMYJo0VOW1\\6YMSK^1`NY1^8bNdG^1_8^NaGc1b8YN_Gg1d8UN]Gj1g8RNYGo1j8mMWGQ2m8lMTGS2P9iMPGW2T9dMnFn0AOe9oNkFP1B0g9lNgFS1ENi9kNhFP1A4c:I`E5`:JbE5_:IcE6^:HdE6^:IbE7^:HdE7]:HcE8^:FdE9]:FcE9^:GcE8^:FcE:^:EbE;^:EcE9_:EbE;_:@fE?[:YOmEf0\\;01N2O1O1O1O1N2O1O1O2M2O1O1O1Ndcj2", "size": [427, 640]}, "area": 30776.0, "iscrowd": 0, "image_id": 18491, "bbox": [0.0, 27.0, 422.0, 286.0], "category_id": 183, "id": 20001172}, {"segmentation": {"counts": "_g`43oc01D:O2I5K1m\\O\\Oh?OV@1T3d0PM\\Od?4YC`0VM\\O_?5ZC>ZM\\O\\?7ZC;\\M^OX?8[C9_M_OV?8YC:bM^OU?9WC8gM_OQ?9[C4eMCo>9[C4\\=LbB5_=JbB4`=L_B4b=L]B3e=L[B4f=LZB2h=MkALlM7Z`0MhA2jMO``0NgA`0[>^OfA`0n`0OnmP5", "size": [640, 515]}, "area": 574.0, "iscrowd": 0, "image_id": 18519, "bbox": [231.0, 240.0, 26.0, 141.0], "category_id": 105, "id": 20001173}, {"segmentation": {"counts": "^3[3j0SNe=k1\\BTNe=k1ZBVNe=k1[BUNe=k1ZBVNe=k1[BUNf=j1YBWNh=h1WBYNh=h1XBXNh=h1YBVNh=j1XBVNg=k1XBVNg=k1YBUNf=l1ZBSNf=m1[BRNg=m1XBTNh=VObAP2e0kNj=SOfAn1?POl=POhA@HZ2f0UOl=oNjAk19WOP>gNkAR21[O_O]Nb>5PBR2N@S>XNVBV2WOjM=i1Q??PA@o>a0QA_Oo>a0QA_Oo>a0PA@P?`0QA_On>b0QA_Oo>a0QA_Oo>a0QA_Oo>a0QA^OP?b0PAWOCcN^?V2m@YOE^Na?Y2h@[OG[Na?[2g@[OZ?e0e@]OZ?d0e@\\O\\?b0f@[OT?[Nj@Z23YOU?^Nf@U2:]Oo>`Nf@P2>@l>`Nd@Q2a0_Ok>f0VAYOk>g0UAYOk>g0UAYOk>g0UAYOk>g0VAXOj>g0WAYOj>f0VAZOi>f0XAYOi>f0XAZOi>d0XA]Og>bNd@h1f0Fn>8[AAf>>eAVO]>i0cAVO`>UOS@_1]1\\Od>d0[A]Ob>f0^AYOc>f0^AYOc>UOP@_1]1[Og>e0YA[Og>d0ZA[Og>e0XA[Oi>e0WAZOk>f0TAZOl>f0TAYOm>h0RAWOo>i0RAUOo>k0QAUOo>k0QATOP?m0n@TOR?m0l@SOU?n0i@SOX?m0Z@_Og?b0X@^Oh?c0V@]Ol?d0R@[Oo?e0P@[OQ`0f0n_OZOS`0f0l_OZOT`0f0k_O[OU`0e0k_O[OU`0e0k_OZOV`0f0j_OYOW`0k0e_OUO[`0n0b_OQO_`0P1`_OoNa`0Q1__OnNa`0T1]_OmNc`0R1^_OnNc`0Q1^_OmNc`0R1^_OmNb`0S1k_OYN[OJo`0m1Q101N11O000O2O1X^O`Nm`0a1R_OfNi`0Y1W_OgNi`0Y1W_OgNj`0X1V_OhNj`0W1W_OiNi`0S1[_OmNe`0n0`_ORO``0l0b_OTO^`0i0e_OWO[`0h0f_OXO[`0g0e_OYO[`0g0e_OYO[`0h0o^OaNc0g0^`0k0a_OUO_`0j0c_OUO]`0k0c_OUO\\`0l0d_OTO\\`0l0d_OTO\\`0l0d_OTO\\`0l0d_OTO\\`0l0d_OTO\\`0l0e_OSO[`0n0d_ORO\\`0n0c_OSO\\`0l0f_OTOZ`0l0f_OTOZ`0m0e_OSO[`0m0e_OSO[`0m0e_OSO[`0m0e_OSO[`0l0f_OTOZ`0k0g_OUOY`0k0g_OUOY`0k0g_OUOY`0j0h_OVOX`0j0h_OVOW`0j0j_OVOT`0l0l_OTOT`0l0l_OSOU`0n0j_OROZ`0j0S@iNn?V1Y1dNf]O]1Yb0dNf]O\\1Zb05O1000O1O1`Ne]O[1ab0O01O0O1000100O010d^OfNP`0Kn^O\\1g0TO^`0m0^_OVOb`0j0]_OWOc`0i0]_OWOc`0i0]_OWOb`0j0^_OVOb`0j0^_OUOd`0j0\\_OVOd`0j0\\_OVOc`0k0]_OUOc`0k0]_OUOb`0l0^_OTOb`0l0^_OTOb`0l0^_OTOc`0k0]_OUOd`0i0]_OWOeb02N4L6K1O1O000oMoNSAQ1i>\\On@a0U?Hb@6`?6T@Go?b0h_O\\OY`0f0f_OWO]`0i0c_OTO``0P1\\_OmNg`0R1Z_OiNk`0Y1S_OfNn`0Z1R_OfNn`0Z1R_OfNn`0Z1R_OfNn`0\\1R_ObNn`0`1g^OYN26Wa0b1e^OZN60Va0g1b^O[Nka0f1S^O[Nla0m1O1000000000O1000N2O100002N1O1N1O1MQ^OTNoa0m12000O1e^ORNc`0o1\\_O[N[`0e1e_O^NX`0b1i_O^NX`0_1h_ObNZ`0\\1f_OdNZ`0\\1e_OfNZ`0Z1d_OhN\\`0V1d_OlN]`0S1b_OoN^`0o0b_ORO_`0l0a_OVO_`0h0b_OXO_`0f0a_OWO^OZOTa0]1__OXOd`0h0\\_OWOe`0j0Z_OVOf`0j0Z_OUOg`0j0Z_OVOf`0j0Z_OVOe`0k0[_OUOe`0k0[_OTOf`0l0Z_OTOe`0m0[_OSOd`0o0[_OQOc`0Q1]_OoNa`0S1__OmN^`0V1b_OjN]`0X1a_OiN^`0X1b_OhN^`0X1b_OhN]`0Y1c_OhNC\\Od`0l1i_OlNX`0S1i_OmNV`0T1j_OkNX`0]OX_O`1`0SOX`0\\OY_Oa1?SOX`0\\OY_Oa1?ROY`0\\OY_Ob1>ROY`0\\OY_Ob1>ROY`0[OZ_O=Lg0`0@Z`0\\O[_O8LH11No0?D\\`0[OY_O:2GKo0?E``0E\\_Oe04F_`0E^_Oe03E``0Ab_Oj0NE``0@c_Ok0MEa`0_Ob_Ol0LEd`0\\Oa_Oo0LEYa0d^OB\\a0=e^OC[a0=e^OC[a0=e^OC\\a0;e^OE[a09g^OGYa0;e^OE[a0;e^OE[a0i^OBVa0>j^OBVa0>h^OEWa0;i^OEWa0;i^OFVa09m^OESa0;m^OFSa09k^OIUa07k^OHWa07i^OIWa08h^OHXa08h^OHXa08g^OIZa06g^OH\\a06d^OJ_a03a^ONaa0O_^O1da0L]^O3ba0N^^O1da0O\\^O0ea0O[^O2ca0N^^O2ba0N^^O2aa0O_^O1aa0O_^O0ca00\\^O0da00\\^O0ea0N\\^O2ca0O]^O1ca00\\^O0ea0O[^O1ea0M\\^O4ba0N^^O3`a0N`^O2`a0N`^O2Qa0A_^OOL>d02Pa0?o^O@Pa0b0P_O_Oo`0a0R_O^Om`0c0R_O^On`0b0R_O^On`0b0R_O]Oo`0c0Q_O]Oo`0d0o^O]OPa0c0R_O\\On`0d0R_O\\O_`0^OZ_OX16ZO_`0EU_OP1=[O\\`0KR_Ol0d0VOZ`0Z1U11O100000010N1_^O\\Ng`0d1T_OjNb`0V1^_OiNc`0W1]_OjNc`0U1\\_OlNe`0S1Z_OnNf`0BT_Oo07_Oe`0BT_Oo07_Of`0@T_OQ17^Og`0_OR_OS17^Oi`0]OP_OT19^Oh`0\\OQ_OT18@g`0[OR_OU18^ORa0b0o^O]OQa0b0P_O^OPa0a0R_O^On`0c0Q_O]On`0d0T_OZOk`0g0S_O[Ol`0g0S_OYOm`0g0S_OYOm`0g0S_OYOm`0g0R_OZOn`0f0R_OZOm`0h0R_OXOl`0i0U_OWOj`0k0V_OTOj`0l0V_OTOh`0n0X_OROh`0n0W_OROc`0_OQ_O_1=RO``0AR_O]1?QO_`0W1b_OhN^`0X1d_OfN\\`0Z1b_OhN^`0X1b_OhN^`0Y1a_OgN_`0Y1b_OfN^`0Z1c_OeN]`0[1d_OdN\\`0\\1c_OeN[`0\\1f_OdNZ`0]1d_OdN[`0]1e_OaN]`0_1c_ObN\\`0^1c_ObN^`0^1a_OeN]`0Z1c_OgN]`0Y1b_OhN^`0V1c_OkN]`0T1d_OlN\\`0T1c_OlN^`0T1b_OlN^`0T1c_OlN\\`0T1d_OjN^`0V1b_OhNa`0V1`_OmN]`0S1c_OmN\\`0S1e_OmN[`0S1e_OmN]`0P1f_OoNW`0S1j_OlNV`0S1l_OlNS`0U1n_OiNQ`0Z1n_OfNQ`0[1o_OeNQ`0]1X_OUNa0=P`0D`_Oo1?]NR`0F]_Om1`0^NR`0G\\_Ol1b0]NR`0j1o_OUNQ`0k1o_OVNP`0j1Q@TNP`0l1n_OVNR`0i1P@VNo?k1R@UNl?l1R@VNn?j1R@VNP`0h1P@VNS`0i1n_OWNR`0g1n_O[NP`0e1Q@[No?c1S@]Nm?b1T@^Nl?b1S@_Nl?a1U@_Nk?a1T@`Nl?`1U@_Nk?a1U@_Nk?a1U@_Nk?b1T@^Nl?b1S@_Nl?c1S@]Nm?e1Q@[No?g1o_OYNQ`0g1o_OYNP`0h1P@XNk?@f_OX2?XNj?n1V@RNj?n1V@RNj?n1V@RNj?m1W@SNh?m1Y@SNg?l1Z@SNg?m1Y@SNg?m1Y@SNh?l1X@TNh?l1Y@SNg?m1Y@SNh?k1Y@UNg?k1X@VNf?l1Z@TNe?m1[@SNe?m1[@SNd?o1[@QNe?o1[@QNe?n1\\@RN_?@n_O`2b0PN_?T2b@lM]?V2`@lM`?T2`@lM_?U2b@jM]?V2c@kM]?V2b@jM^?W2a@iM`?U2a@kM_?U2a@kM_?W2_@hMb?X2^@iM`?X2_@iMa?W2_@iMb?V2^@jMb?U2`@jM`?W2_@iMa?W2^@jMb?V2_@iMa?W2_@iM`?X2`@hM`?X2`@hM`?X2`@hM`?X2_@iMa?W2`@hM`?X2`@gM`?Z2a@eM_?[2a@eM_?[2a@fM]?[2e@bM\\?^2c@dM[?\\2e@eM[?[2e@eMZ?\\2f@dM[?[2d@fM\\?Z2d@fM]?Y2c@gM\\?Z2f@cM[?]2d@dM\\?\\2d@dM[?]2e@cM[?]2e@cM[?]2e@cM[?]2e@cM[?]2e@cMZ?^2f@bMY?_2g@aMW?a2i@_MQ<", "size": [640, 515]}, "area": 41058.0, "iscrowd": 0, "image_id": 18519, "bbox": [0.0, 102.0, 515.0, 187.0], "category_id": 124, "id": 20001174}, {"segmentation": {"counts": "W2h0Zc0N1N11OO10000001O00000001O00O1O0001O10L]Ok\\Ob0Sc0^Ok\\Og0Sc040000000000010O01O1N10SOP]Ok0ob0UOQ]Ok0ob0UOQ]Ok0ob0TOR]Ol0Qc01O1V]ORO`b0R1[]OoNeb0V101O010O2Z]OfNcb0[13JO4O1000N111M003N03MNZ]OkNgb0U1201O0O1O01O1000N5K7K3XOg\\Oa0]c0K7D\\\\O30Ogc00fid8", "size": [640, 515]}, "area": 2118.0, "iscrowd": 0, "image_id": 18519, "bbox": [0.0, 62.0, 72.0, 50.0], "category_id": 128, "id": 20001175}, {"segmentation": {"counts": "i6j0^1Jf?7Y@Ig?6Z@Jf?6Z@Ig?6Z@Jf?6Z@Ig?6Z@Jf?5[@Ke?5[@Ke?6Y@Kg?5Y@Kg?4Z@Lf?4Z@Lf?4Y@Mf?4Y@Mg?2Z@Mg?2Z@Nf?1[@0b?2]@1a?N`@3_?Ie@_O]Ng0l`0Ik@9S?WOU_O=i1T?Bm@=S?Ao@?Q?_OQAa0o>^ORAb0m>]OVAb0j>]OWAc0g>_OXAb0g>_OYAa0b>D^A<_>GaA9^>HbA8]>IcA7]>IcA7]>IcA7]>IcA7]>JbA6]>KcA5]>KcA5\\>LdA4^>JbA6a>G_A8b>H^A7d>OUA1k>:j@FW?9j@EW?;j@DW?:j@FV?:j@GU?9k@FW?9i@GW?9i@GW?9i@HU?8l@HT?8l@HS?9m@HP?:PAFP?:PAFP?;o@EQ?;o@EQ?;j@oNfNf0_`0;i@ROgNd0_`0:i@0V?Oi@3W?@PAf0P?ZOPAf0n>[OTAd0n>ZORAf0n>YOSAg0n>XORAh0o>WOQAi0o>VOSAi0m>WOSAi0m>WOSAi0m>WOSAh0R?TOn@m09hNl<8kBP19hNm<7TBIGX1OhNb00d=7SBJHW1OiNCOM1L1a0NZ>5SBMFV1_OkN8OG?:D]>1UBLF_1FbNF?5Jd>KSBNE]1HI_>mNSBNF]1B^NOZ1e>ZO`A[OJa09T1G\\N1[1e>7bAf1^>n1O11O00001O1QKgAU4Y>jKnAP4R>PLnAP4R>PLnAU20gNR>TOnA[2:QNg=EoAZ2;PNb=JSBR2YOcM[19U=7WBg1R1kMf<`0XBH]OZ1L\\NZ`0e0]@CAZ1S`0TO\\@@D[1P`0UO\\@^OH[1l?WO\\@]OKZ1j?cNd_Oc0g0^ON[1j?VOQAi0n>YORAf0n>ZORAf0n>ZORAf0n>ZORAf0n>ZORAf0n>ZORAf0n>ZORAf0n>[OQAe0P?ZOo@g0Q?XOPAi0m>YORA2lNBS`0a@3_?Lb@5\\?Le@3[?Me@4Z?Lf@6W?Ki@5W?Kh@6X?Jh@6X?Jh@6U?Mk@3P?2PAMR?2m@OS?1m@OW?Mi@3V?Nj@3W?Kh@5Y?Kf@5[?Kd@6\\?Jc@6`?J\\@8f?]Ok^O2^1a0h?[Ol^O6Y1?l?YOm^O:T1=P`0WOm^OR@Ek?;T@Hj?9U@Hj?8U@Kj?5U@Lj?4V@Mh?4W@Nh?2X@0f?0Y@2f?NZ@3f?LY@7e?I[@7d?J[@4eNYOo`0c0]@3fNYOm`0c0^@4f?L[@0bN^OPa0c0`@MbN@m`0c0b@LbNBj`0b0e@KcNBg`0c0g@Jb?6^@Kb?4^@Lb?4]@Mc?4[@Me?2\\@Nd?2\\@Nd?2\\@Nd?2\\@Ne?0\\@0c?2[@Oe?1[@Of?0[_O@9`0T1^OV=c0]ABGO0>e1_OSNOR?e0\\ADD02:i1^OSN01Ol>`1TAmNN7m1^OTN4l>g2iBcMS=f2cB^MZ=a2gBbMV=_2hBfMT=Z2kBhMU=X2iBiMW=BiAj1P1dNX=]OVBd1b0POX=\\OUB`1g0UOT=[OVBf1`0nNZ=[OWBh1?lNZ=[OXBi1?kNX=]OYBMXOa1W1UOX=]OYBH^Of1Q1TOX=_OXBEBg1o0]NhN`0_>GfBZ1d0oB1k0\\OgMO`>c0nB2k0[O\\`13b?_Oo^O<`15g?JX@7i?HW@8j?GT@G_Nb0aa0CP@`0S`0]Om_Oc0ha00001O001O00001O00ZN@l_O`0R`0Cl_O>n?]Od^O8^1:n?KQ@6n?JS@6k?KV@4j?MU@3k?LV@4i?LX@4h?LX@4g?NX@2h?NX@2g?0X@0f?0\\@0c?2\\@Oc?]Om^Ob0_11d?]On^O?`14b?]On^O?a13f?LZ@4g?LX@4h?KY@5g?KY@5g?_Og^O8a19P`0Dm_O>W`0^Oj_Oa0ka0000000000000000O11O00O101RN[Oe^O8_1J_7R7SHUI=I`7R7SHUI=I`7R7SHTI>J_7R7THSI>J^7S7THSI=J`7S7SHSI=J`7S7SHSI=J`7S7THRI3g7W7kGeH>4g7X7jGeH>3h7X7jGgH;2k7W7jGgH;2k7Y7gGfH>1k7Y7gGfH=2l7Y7fGeH>2l7Z7eGdH?2l7Z7eGcH?4l7Z7cGcHa03l7Z7cGcH`04m7Z7bGbHa03n7\\7`GbHa02o7\\7_GbHb03o7\\7]GaHe03n7\\7\\GbHf02n7]7ZGaHh03n7]7WGbHk01n7]7WGbHk01n7^7VGaHk02o7]7VGaHk01P8_7UG_Hj03Q8_7TG]Hk04R8_7SG]Hj05S8_7UGYHg08U8_7SGZHg08V8W8kGhGV8Y8hGhGX8X8gGhGZ8X8eGiG[8W8dGiG]8V8dGjG\\8U8dGkG]8T8cGmG]8S8bGmG_8S8`GnG`8S8^GmGc8S8\\GnGd8R8[GnGf8S8XGnGh8R8VGoGk8Q8TGPHl8Q8RGoGo8Q8PGPHP9P8oFPHR9Q8kFQHU9o7jFQHW9o7hFRHX9o7fFQH[9o7dFQH]9Y9_GaEa7^:bHcE[7\\:]HnEb7Q:_HQF_7o9\\HVFd7i9XH]Fg7b9YH`Ff7_9YHdFf7\\9YHeFg7Z9[HfFd7Y9\\HhFd7W9[HkFe7T9[HnFd7Q9`HlF`7S9_HoFa7P9^HRGb7m8_HSGa7l8_HVG`7i8`HXG`7g8`HZG`7e8aH\\G^7c8UHTF4Z1g7a8TH[F1U1j7b8SHmGm7T8RHlGn7U8QHlGn7S:0001O001O00001O00001O001O00001O00002N2N2N2N1O000000O100000000O100000000O100N2O1O1O1O1N2O1]KVHoLk7Q3UHoLk7Q3VHmLk7S3lHULU7k3nHQLS7n3RImKo6S4PImKQ7T4nHkKS7U4lHkKU7U4kHjKV7U4jHkKW7U4iHkKW7V4hHiKY7W4fHiK[7W4eHhK\\7X4cHgK_7X4bHgK_7Y4`HgKa7Y4_HfKb7Z4]HYIWOb1]8U5]HXIXO`1\\8X5]HXIWO^1]8Z5]HTITO^O2R2^8\\5]HRIUO@0o1`8`5[HPIVOBMm1c8a5[HoHWOBKl1d8c5[HnH[O^1Z8d5[HoHZO\\1\\8d5[HPIZO[1[8f5YHPI]OX1[8h5WHQI^OV1\\8i5VHQI_OU1[8j5VHQI@S1[8k5VHRI_OR1\\8l5UHRI@Q1[8m5UHRIBn0Z8P6SHSIFj0W8S6SHSIJC]Of0g8g6oGPI99h7j6]G_H0>m07kNWOh8i7ZG`H2:Q16kNXO1Ob8j7^GcHN7V15kN]Ob8Q9^HnG^7[8YHhGd7W8]HlG`7U8_HoG]7Q8cHPH\\7Q8cHoG]7Q8cHoG]7P8eHoG[7l7lHRHT7U8hHeFUOi0S8c8jHaFTOk0R8d8lH^FTOm0P8j6lGQJW1UOm6e6RHVJQ1TOm6d6UHWJo0]NhN`0T8j6YHWJT1mNc6l6[HoIAbNf1b0^6m6[HdHIk0e1@Y6P7fH^IU1_OW6S7dH[IY1@T6U7cHYI\\1\\OjMMX8^7cHWI^1\\OgMOX8^7cHWI^1[OT6^7]HXIP:h6PFXIP:h6PFXIP:h6PFXIP:h6PFXIP:h6PFXIP:h6PFXIP:h6PFXIP:h6PFXIP:h6PFXIP:h6PFXIP:h6PFYIo9f6QFdHVOc0h:j6RFbHWOc0g:k6WFUIi9k6XFTIh9l6XFTIh9l6XFTIh9l6XFTIh9l6XFTIh9l6XFTIh9l6YFSIg9m6YFSIg9m6YFSIg9m6YFSIg9m6YFSIg9k6[FUIe9l6ZFTIf9k6[FUIe9m6WFTIj9l6UFTIl9l6QFbHSOb0m:l6oEWIQ:i6oEWIQ:h6PFXIP:h6PFXIP:i6PFVIP:h6RFXIn9f6UFYIk9j6RFVIn9j6RFVIn9j6SFUIm9k6SFUIm9l6RFTIn9l6QFUIo9k6RFTIn9k6SFVIl9j6UFVIj9j6WFUIi9k6WFUIi9j6XFVIh9j6XFVIh9j6XFVIh9j6XFVIh9k6WFUIi9j6XFVIh9j6XFVIh9j6XFWIg9j6XFVIh9j6XFVIh9j6YFUIg9i6[FWIe9j6ZFVIf9k6YFUIg9k6YFUIg9k6XFUIi9k6TFWIm9i6SFVIn9j6RFVIn9j6RFVIn9j6RFVIn9j6RFVIn9j6RFVIn9j6RFVIn9j6RFVIn9j6RFVIn9j6QFWIo9i6RFVIn9j6RFVIn9j6QFWIo9i6QFXIn9h6RFWIo9i6QFWIo9i6RFWIm9i6SFWIm9i6SFWIm9h6TFXIl9h6TFXIl9h6TFXIl9h6TFYIk9g6UFXIl9h6TFYIk9g6UFYIk9g6UFYIk9g6UFYIk9g6UFYIk9g6UFYIk9g6UFYIk9g6UFYIk9g6VFXIj9h6VFXIj9h6WFWIi9i6WFWIi9i6WFWIi9i6WFWIi9i6VFXIj9h6VFXIj9h6VFXIj9h6UFYIk9g6UFYIk9f6VFZIj9g6UFYIk9g6UFYIk9g6UFYIk9g6UFYIk9g6TFYIm9g6SFXIn9h6QFXIP:h6PFWIQ:i6PFUIQ:k6nEUIS:k6mEVIR:j6nEVIR:j6nEVIR:j6nEVIR:i6oEWIQ:i6oEWIQ:i6oEWIQ:j6nEVIR:i6oEWIQ:j6nEVIR:j6nEVIR:j6nEVIR:j6nEWIQ:i6oEXIP:h6PFXIP:h6PFXIP:g6QFYIo9g6QFYIo9g6QFYIo9g6QFYIo9g6QFYIo9g6QFYIo9g6QFYIo9g6QFYIo9g6QFYIo9g6RFXIn9h6RFXIn9", "size": [640, 515]}, "area": 172206.0, "iscrowd": 0, "image_id": 18519, "bbox": [0.0, 235.0, 515.0, 405.0], "category_id": 140, "id": 20001177}, {"segmentation": {"counts": "WRP13lc04L1N3O001O001O0O101O0O10O101N1N3O0000001N2N2O1O1OS_^4No`aK0O2N3M4L4L4MO02O1OO010O10O2O0O2OO10105JOO102O4G^\\OLb\\W10YWiN2N1O1N1O100N5L4M2N001O000O100O100O01N1Ke\\OE]c0;5O0O3H[\\O1jc000O100O100OQX10PhN1O0O2O1N1O1N2\\\\OH_c0`0M3L4MO11O0001O0O2O2N2N0000000Dc\\OLfc03400O2O0OfmU1", "size": [640, 515]}, "area": 1412.0, "iscrowd": 0, "image_id": 18519, "bbox": [51.0, 162.0, 403.0, 59.0], "category_id": 162, "id": 20001178}, {"segmentation": {"counts": "0W2h0XNj?j1T@XNj?i1T@YNk?g1V@WNk?i1T@XNl?h1T@WNm?i1S@XNl?h1T@YNk?g1V@WNk?i1U@WNk?i1U@WNk?i1U@VNl?j1T@UNm?l1R@SNo?m1Q@RNP`0m1Q@TNn?k1R@VN0BX?W2h@YNNEV?R2k@[NMF@Hd?W2o@\\NKIU?g1]@oMb0e0EI\\?`1]@PNg0g0_OK\\?\\1YAjNUO1`?U1[AEe>;[ADf><[ABf>?YAAg>?ZA@f>`0[A_Oe>`0\\A@d>`0_@RNk0]1f>a0_@RNk0]1f>a0_@RNk0\\1g>b0]@SNl0Z1h>f0YAXOh>h0YAVNROh0e?R1]AQNoNd0O@f?k1aAeNjN^Of?m1aAcNkN_Od?n1aAcNkN]Of?Q2_AaNg>_1[AnMfN?o?d1\\A\\Nd>g1VA\\Nj>`1ZA`Nf>_1[AaNe>_1[AbNd>^1ZAcNg>\\1ZAdNf>]1WAfNh>X1XAjNmNZOc?m1^AROb>m0aARO^>m0`ARNkNS1d?k0aAYOmNiN\\?n1gA]OY>d0fAYO]>g0bAZO^>f0aA[OoNfN]?n1eA_O[>`0fA@Z>`0fA@Z>`0dAB\\>a0_AB`>c0[A]Oe>f0c@hMa0d1l>f0o@_OQ?c0c@dM30Oj1[?d0e@A[?b2000001O00001O00001O0000000000000000O1001O00O100001O000000O100O11O001O0000000000001O0000000000O100000000000000O10000000000000000000000O1N200004L1OKi@aKW?_4j@`KV?`45O10000000d@aKW?e4O0000O100001O001O0i@[KS?i40000000O1001O00O100O100001O1O^1bN4L00O10000O1_N]BeLc=W3jB`LV=`3SCWLm\\4WAiK8LH11Nc>]4[AgK:2GKd>a4eAjKZ>U4fAlKZ>T4aAQL_>o3`ARL`>o3_AQLa>P4\\AQLe>e40000000O100000000001O000000001O0000000000O10000000000001O001O00O100O1O1O1O1O100O10000O10000O100O100001O6JO1O11OO1O1N200O100000000O100ASAjKn>U4YAeKg>Y4_AbKb>^4`0O1O10000001OO11O00001O1O0l@dKd>\\4\\AdKd>]4ZAdKf>^4XAbKh>`4VA`Kj>a4TAaKk>_4TAbKl>i40000000O1O1O100000000O1N2O100N200Ik@cKU?\\4m@cKS?]480000000000000000N200O10000000000000000000000001O00O1002NN200O1N2O100I\\@RLd?n3^@PLb?o3`@oKa?Q4700000000O1O1002N1O1OO1000000O1000000000000O1000000O1KR@XLn?g36000000O10000001O00001O00N2O100O10000Kh_OaLY`0^35O100O1O100001O000000O1001O0000000000O10000000000O10000O100O100O11O001OO10000O100000000O1O1N2", "size": [640, 515]}, "area": 72020.0, "iscrowd": 0, "image_id": 18519, "bbox": [0.0, 0.0, 515.0, 205.0], "category_id": 169, "id": 20001179}, {"segmentation": {"counts": "fj]2a0_c00O1000000O1000000O01000000O2O000O1000000000000000001OO1000000O1000000O0100000O1000000O1000000O1000000O1000000O10O10O100bM\\O`Ad0]>_ObAb0\\>AcA?Z>DfAGfA:W>JhA6U>MjA4S>0lA0o=5QBKn=7PBJP>7oAIQ>7oAIQ>8mAIS>7mAIS>8lAHS>:kAFV>:jAFV>;hAEY>;fAFZ>;dAE]>=_ACa>>]ABd>?ZABf>?XAAi>?VABj>?UA@k>b0SA_Om>b0QA^OP?c0n@^OR?c0l@]OU?c0j@^OV?c0h@]OX?d0g@]OY?d0e@\\O\\?d0b@^O^?c0`@]Od?`0[@Ag?lNd_O\\1d0HW`00g_O1Y`0Oe_O2]`0Na_O3_`0M`_O3a`0N]_O2e`0MZ_O3g`0NW_O3i`0MV_O3l`0NP_O3Qa00k^O0Wa0\\10Om_O^Mj>a2VAaMj>]2UAfMj>Z2TAiMl>U2TAlMl>S2SAPNl>o1TARNm>l1RAWNm>h1SAYNl>g1SA[Nm>d1SA^Nk>b1TA`Nl>_1TAbNl>]1SAfNk>Z1UAgNk>X1TAkNj>U1VAlNj>T1TAnNk>U1RAmNm>T1PAnNo>T1o@mNQ?R3N101O0O101O0O101O001N10001N10001O0O3N2N2M3N1OO100000000O10000000000O10001M2O2N1O2N1N3N1O2N1O2Oh0WO4L5K5K4L2N2N3M2N2O1N3L3N2N3M1O2N2N1O2M3N1O2O1N1O2O1N1O2O1N101N4L4nN_]O?eb0VOb]Oi0kb0O2N100O2N1O100O1O1O102M3M4L4M\\eS3", "size": [640, 515]}, "area": 16792.0, "iscrowd": 0, "image_id": 18519, "bbox": [124.0, 225.0, 231.0, 175.0], "category_id": 183, "id": 20001180}, {"segmentation": {"counts": "0[4a1S9;FORD0m80RG4l8KTG8i8HVG<0000000000000000000000000000000000000000000000001O00000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000000000000000O10000O10000O100O10000O10000O1N3O0O1O1O1O1O1O1O1001O000000000000000000001OO100001O00000000000000000000000000000000001O0000000000000000000000000000000000001O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000000000000000000000000000000D6", "size": [480, 640]}, "area": 15670.0, "iscrowd": 0, "image_id": 18575, "bbox": [0.0, 0.0, 640.0, 480.0], "category_id": 165, "id": 20001181}, {"segmentation": {"counts": "[4a1^=:GORD1l8OSG5k8JUG9h8FXG>f8AYGb0e8^O[Ge0c8WO_Gm0Fe1g3W6ULk30000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000001O00000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O0000000000000000000000000000000000O1L5K4K5O100001O0000000000000000000000O1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000001O00000000000000000000000000000000000000000000000000gAHj=8nA0R>?000000000000000000000000000000000000000000000000000000000000000000000001O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001O00000000000001O0000000000000000000000000000000000000000000000000000000000O10000O10000O100O10000O10000O1N200O1O1O1O1O1O1O1001O000000000000000000001OO100001O00000000000000000000000000000000001O0000000000000000000000000000000001O01O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000dFV9", "size": [480, 640]}, "area": 290866.0, "iscrowd": 0, "image_id": 18575, "bbox": [0.0, 0.0, 640.0, 472.0], "category_id": 183, "id": 20001182}, {"segmentation": {"counts": "`eh51Z=4L000O100000001O000000000O100000O6JmXZ2", "size": [427, 640]}, "area": 114.0, "iscrowd": 0, "image_id": 18737, "bbox": [442.0, 368.0, 19.0, 8.0], "category_id": 149, "id": 20001183}, {"segmentation": {"counts": "h6c6i6O00001O001OM30000O11O00003MNaIXI_6h623M001O000000O1001O00N2MaIZI_6d6500N2O1NYI`Ig6`620000001O1ON21O000000001O000000O11O1O1OO1001O00O100O10000001O00O12ZI\\Ia6i6^IXI]6k60O1N20000000000001OO12NO1O12N1OO100N2O100000000001O000000O12N0000O10000O100O1000000O11O0000O11O00N25K2N0cITI[6P7N2N2NO1O1N2O10fIQIX6Q70O1O1O11O0000O11OO11O1O00N2O1001OO1O11OO1000000O1N22N0000O12N000000O11O1ON21O1O001O00O1O11OO11O000000O1001O1O1OM32N1O00O1O100O11OO11O0000O11O1OJeIYI^6g6bIYI^6f6cIZI]6f64001OO100001O000000O11OO10000000000O1001ON20000O10[I]Ib6f600000000fIYIP6g6oIZIQ6f6lI]ILMU6S704L1O00000000000000O11O1O00O11O1O>B4L4L4L4L4L4L4L4L4L1O00000000000000000000000UNRGYOn8@VGG4b0f8DYGJ2a0e8A]GNO`0d8_O`G1L`0d8]ObG3K?b8_OcG1L`0a8_OcG1M?`8@dG0L`0`8AcGOM`0`8AcGNNa0_8AcGNNa0_8AcGNNa0_8BlGCFj0^8C[HTOWOY1^8CPI=P7CPI=P7DoHa3C]L>c3B\\L?d3B[L>e3CYL>f3DXL=i3CUL>k3CTL=m3CQL>o3CoK>Q4BnK?R4BmK>R4CmK>U4@jKa0U4AjK?V4AiK`0W4@hKa0W4AhK?Y4@fKa0Y4@gK`0Y4@fKa0X4BgK>Y4BfK?V4EjK;V4FhK;X4EhK;X4EgK^4AbK?_4_ObKa0^4^ObKc0^4\\OcKd0]4[OdKe0\\4bNgH9n2U1[4^NkHj2X1Z4XNmH?k2X1V4ZNPI=o2U1a4iN`KW1`4hNaKX1_4gNbKY1^4fNcKZ1]4eNdK[1\\4dNeK\\1[4cNgK\\1Y4cNhK]1X4bNiK^1W4aNjK_1W4_NjKa1V4^NkKb1o700000O1IaNaD`1_;60000000000O1000000000000000000O100000000000000000000O1000000000000000000O1000000O100O100O1O100O100O1O100O100O1O100O100O1O100O100O1O100O100O1O100O100O1O100O100O1O12N1O2N2N1O2N2N1O2N1O2N001OXLTNRLk1n3VNQLj1P4VNTIGX2R2c4YNSIHY2n1c4]NQIHZ2k1d4_NPII[2g1f4SNdH8:O\\2e1o4YNcH5\\2b1R5ZN_H7^2^1S5\\N]H9_2Z1n4dNaH5_2W1U5`N[H;_2T1W5[OiJd0W5^OgJb0R5GmJ8T5IkJ6Z5GdJ9Z5JfJ5Z5MeJ2Y52eJNb5M]J2c50\\JOd53ZJMb59]JFh57WJHi5:UJFl5:SJFj5?SJBP6=lIET6=iIDX6=eIDW6b0fI_OZ6c0bI_Ob6?[IBf6?WIBh6a0TIAh6d0ZH9k7a21O00MdJVH]5g756J1O00M3N26J0000L4005K0000J6N28HO100I7N27I0000001O3M000000O11O1O0000000000O1001O2N00", "size": [427, 640]}, "area": 85908.0, "iscrowd": 0, "image_id": 18737, "bbox": [0.0, 209.0, 640.0, 218.0], "category_id": 154, "id": 20001184}, {"segmentation": {"counts": "0T6W7000000000000000000000000000000O100000000O1HkHYJV7f58O100O1N2O100000000001O5K3bHTJW7P601O0000O100O1000000002N000000000000000000O1000000O1000000000000000000000000000000000000O1O1N2000000001O001O00000000000000O10000O1O1O1O1N2O1000000O1001OO100001OO11OO1001[H\\Ja7i5N0aHYJZ7g5fHYJZ7m5O0000000000000000O11OO11O0000oNgHQK:d0n6Y4VIgKj6Y4VIfKk6Y4YIeKf6[4YIfKg6Z4ZIdKg6[4YIfKg6Z4YIfKg6X4[IhKe6X4[IiKd6V4\\IkKd6U4\\IjKe6V4\\IiKd6W4[IjKe6V4[IiKf6W4[IhKe6X4_IdKa6\\4cI`K]6`4dI_K\\6c4cI[K^6d4eIWK^6j4Q1001O001O1O1ON2000jGTKm7l4lG[KT8n400000000000001ON200O[HQKP7o4PISKn6m4oHXKo6i4oHYKP7g4PIZKo6g4fHkJ024n7c2fIPM[N?n7d2dI`M[6_2hI`MW6a2hI`MW6_2jIcMT6\\2mIeMR6[2nIkMl5T2VJlMi5T2VJnMi5R2WJnMi5R2XJmMh5T2WJQM[Nd0^7[2VJPM`Nc0Z7^2_JbMa5_2]JbMc5^2\\JcMd5^2^JlLRNa0_7c2eJZM[5e2dJ]M\\5d2dJ[M\\5e2eJYM\\5i2cJWM\\5P3QIbLi0?V6o2mHbLF4T19Z6S3`H`L80I5S1:\\6S3eH^LL1O5U12`6[3_HhLR1Ic6P4\\12N00O11O1O001VHmKZ6R4aIUL^6i3`I\\L_6c3_I`La6`3]IbLc6_3oHRLBa0`7\\3jHTMU7l2hHWMX7k2aHZM_7Z4OO10000000000000000000000000000000000002NM31O00O11OO1001OO1000000O100000000000000000000O100O1O1O1O1O1O1O1O1O1O1O1O1O1O100O100O100O10000O100O100O10000O100O100O100O1001O1O001O001O1O001O001O1O001O1O001O001O1O001O1O001O001O1O001O1O001O1O1O1O001O1O1O001O00L4K50000O10000O10000O10000O100O1000XHfJ_7c501O001O001O00001O1O1OO1O100N2000000O1000000O10000O10000000000000000000000000000000000001O00001O00O1O100000000000000O1O1M3J600000000000000000000000000N2001OM34L1O0000O11O00", "size": [427, 640]}, "area": 108857.0, "iscrowd": 0, "image_id": 18737, "bbox": [0.0, 0.0, 640.0, 196.0], "category_id": 157, "id": 20001185}, {"segmentation": {"counts": "T6d0g<1O00001O001OM30000O11O00003NM\\C]OeUEFVOL11d;>REGYOJ04c;;RE0n:1nD@@`0a;2kDAC`0a;NlD9P;JmD;Q;DgD]O4o0T;KiD5X;JfDWOOS11nNS;h0lD=0lNP;NPEW2P;2JgMYEY2e:gMYE0O]2g:8L10L4001OO1M3N0300N10O1CZEWNd:i1\\EVNe:i1[EYNe:e1]EZNKHd:j1cETNIb0o9R1dE[N?b0P:P1TFnNl9U1SFiNo9V1RFhNn9Y1TFeNk9\\1VFbNk9^1[FZNf9h1n0O10010OaD[NX;d1gD`NX;i11N1O22cDRNW;T2LO30O11O6]NcDi0^;SObDF4T1[;jNaD80I5S1:mNb:4oDL1O5U12SOh:L[ER1IVO];Y15M10O5ML4N1M4J4K4N3N3N3BjCBX<:?M5IPio2", "size": [427, 640]}, "area": 10016.0, "iscrowd": 0, "image_id": 18737, "bbox": [15.0, 85.0, 395.0, 117.0], "category_id": 169, "id": 20001187}, {"segmentation": {"counts": "[TZ37T=b0^O4L4L4L4L4L4K5L4L4L1O0000000O10000000O100000VGRNX6m1aHVNG5b7d1dHZNJ3b7b1`H_NNOc7a1\\HdN0Ld7_1ZHgN2Je7^1YHhN1Lf7[1YHiN1Lf7[1YHiN1Lf7[1ZHhN0Me7\\1[HgNOOe7Z1\\HhNNNf7Z1\\HhNNNe7[1^HPOCEo7[1^H_OTOVO^8[1^H3a7M`H4_7LbH3^7MbH3]7NcH2]7NbH3^7MWH>i7BWH?g7BXH?h7AXH?h7BWH>h7EUH^4BcK<^4DbK;_4EbK9_4GaK7a4I`K5a4KaK1a4OaKMa43aKJ`46[40000000000001O00000000000000001O000000000000001O00000000000000001O000000000000001O00000000001O000000001O000000001O000000001O000000001O000000001O000000000000000000O10000000000O10000000000O100000000O10000000000O1000000000000O100000000000000000000000000O100000000000000000000000000O1000000000000000000O10000000000000000O1000000000000000000O1000000000000001O1O001O1O001O1O001O001O1O001O1O001O1O010O001O1O1O1O1O001O1O1O1O1O1O1O1O001O1O1O1O1O1O1O1O1O1O1O2N1O1O1O1O1O1O1O1O1O1O1O1O1O2N1O1O1O1O1O1O2N1O1O1O1O2N1O2N1O2N1O2N1O2N1O2N1O1O2N001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O1O001O001O00001O00001O00001O00001O00001O00001O>]IlN2UM", "size": [428, 640]}, "area": 154465.0, "iscrowd": 0, "image_id": 18770, "bbox": [174.0, 1.0, 466.0, 422.0], "category_id": 183, "id": 20001192}, {"segmentation": {"counts": "`6j6`6000O100001OO100000000O1O1001O1O1O001O1O1OO10000O1O100O1O1O10000O1O100001OMTIiIk6W6UIiIk6X63001OO100N200LPImIQ7S6300M3O100N2O100001O0000O1O100000000O1000000000000M3000000001OO100O1J^HcJc7\\5_HbJb7\\5`HdJ`7[58O100000000O10000O1000000000000O100O100000000O100000000000000O100001O000000000000000000O10000000000O100000000000000001O000000001O00MoGmJQ8P56M3O1N20000O100000000O1001O00O100N2O1O100000000001O000000000000000jG[KC000P8e4[HaKe7`4THZKL0087I_7f4ZHiK7B]7V5dHlJZ7T5fHnJX7R5hHPKV7P5jHRKT7n4lHTKR7l4nHVKP7k4oHWKo6i4QIZKl6f4TI\\Kj6d4VI^Kh6b4XI`Kf6`4ZIbKd6^4\\IdKb6\\4^IfK`6Z4`IhK^6\\4^IfK`6]4]IeKa6d5N2N2N2N2N1O1O000000000000001O00000000000000001O00000000001O1O1O1O1O1O1O1O1O1O1O1O1hL_He0b7YO^Hh0c7VO]Hk0d7SO\\Hn0e7PO[HQ1f7mN[HS1f7kNZHV1g7hNYHY1h7eNXH\\1i7bNWH_1j7_NWHa1j7]NVHd1l7YNTHh1m7VNSHk1n7SNRHn1o7PNRHP2o7nMQHS2o7lMQHU2n7kMRHV2n7iMRHX2n7gMSHY2m7fMSH[2l7eMTH\\2l7cMTH^2l7aMTH`2l7_MUHa2j7_MVHb2j7]MVHd2j7[MVHf2k7XMUHi2k7VMVHj2j7UMVHl2k7RMUHo2k7PMUHQ3l7mLTHT3l7kLUHU3k7jLUHW3l7gLTHZ3l7eLTH\\3m7bLSH_3m7`LSHa3n7]LSHc3m7\\LSHe3m7ZLSHg3n7WLRHj3n7ULRHl3o7RLRHn3n7QLRHP4o7nKQHS4o7lKQHU4P8iKPHX4P8gKQHW4Q8hKoGY4R8eKnG[4S8dKmG]4_801N11O000l0TOQ2PNN1J6K5J5K5L6I6J7J5J6J7L32O1N3N1N3M2M3O2L3N2O2M2O1O2M2O2NPOcMTG[2m8hMQGV2Q9lMnFR2S9PNkFn1W9UNfFi1\\9YNcFe1^9]N`Fa1a9bN]F]1d9eN[FX1g9jNWFT1k9oNSFo0n9SOPFk0Q:XOmEg0T:[OkEb0W:@gE>[:DcE;^:H`E5b:X1101NG^MmE`2S:bMmE\\2T:eMlEY2U:iMiEV2X:kMhET2X:mMhEQ2Y:QNfEm1[:TNeEj1\\:WNcEi1]:YNbEe1_:\\NaEb1`:_N`E_1a:cN^E[1b:gN^EW1c:jN\\EV1d:lN[ES1e:nN[ER1d:oN\\EQ1c:PO]EP1b:l0000O1O01O00000000O0K]EeM`1Na7]2eHdMY7]2hHbMW7[2mHgMP7T2VGjMm12TNNb8U2_IUN^6j1dIVN[6i1gIWNX6h1kIWNT6h1oIWNP6i1QJWNn5h1SJYNl5f1UJ[Nj5c1XJ^Nl5\\1SJgNP6T1nIPOU6k0gI[O]6a0WIKl6LVGPOe1_1Y7XOWGYOX1g1d7gNWHAUOl1h8[NWHIoNn1m8VNSHMmNP2S9oMQH1iNS2e:mMXEV2\\9iMhG0iN^2`9bMbGd2_8\\M^Gf2b9100000000O10000\\OXMfFh2U9^MgFe2X9_MaFe2]9^M^Ff2a9b0N2O1N2O1N2O1M3N2N2N2N2N2N2N2M3N2N2N2N2N200N2N2N2N2M3N2N2N2M3N2N2N2M3N2N2N2M3N2N2M3M3L4M3M3M3L4M3M3M3M3L4M3M3M3L4M3M3M3L4M3M3M3M3L4M3M3M3L4M3M3M3L4M3M3M3L4M3M3M3M3N21O1O1OHgEaMW:Z2SFbMl9[2c0FYEmMk:S2600000000O100O100O11eH[No2d1oLcNm2]1oLgNQ3X1nLkNQ3T1nLnNR3Q1mLSOQ3l0oLVOP3i0oLZOP3e0PM^On2a0RM@n2?RMCm20QNHb17>2nMHd16>2mMIe14?3kMJf13?3kMJf12`04iMJh12`03gMLi11`03gMLi11`02gMNi10a01fMOi1Ob02dM0j1Nc01cM2i1Md01bM3j1Kf00aM5i1Kf00`M6j1Ih0ZOQLL]1Q1j1Ii0VOULMY1U1h1Hl0QOXLNV1Y1f1Gn0nN[LKV1`1a1GQ1hNYN`1f0Hh39WLGi39WLGj38VLHj38VLHj38VLHj38VLHk36VLJj36VLJk35ULKl34TLLl35SLKn33SLMo31QLNQ41oKOV4FPL:S4]OSLb0S4hN^LX1j700000000001O1O001O00001O000000001O00001O001O00001O00O100001O0000002NO1O11O1O1O1O2N5K1O1O00000000001O00000000000000", "size": [426, 640]}, "area": 140868.0, "iscrowd": 0, "image_id": 18833, "bbox": [0.0, 44.0, 640.0, 382.0], "category_id": 105, "id": 20001193}, {"segmentation": {"counts": "\\\\l32X=0O100O1N200O1O1O100O1O1O1N2N200O100O1O100O100O100O1O1N200N2O100O10000O10000O1O100O1O100O100O1O100O100O1O100O1O100O1O1O1O1O100O1O1O100O1O1O1O1O100001O1O1O0000O1O100O1O1O1O1N2IUNmD`1NjNT;\\1mDcNS;^1lDbNP;b1RE\\Nh:JVEm12TNNOh:R2:2N2N3M3N1N1O1N2OO1N2L6D6RNnDe1X;`NhDX1Z;KeDUO[;o0eDoN];P1dDmN^;T1bDiNb;V1^DgNg;T1XDiNP5I3XON^B6a=c030L4ON21N011O000000000O10000O200O2N0000ONiN]BW1c=30O100O100O101N100OJ7I610000O001O1O001N2O2N1O1O1O1O2M011O1O002N0OoMUORFi0k9BmE>T:AmE>T:BlE=U:CkE9nAF01_>9aAF02a>2_AM0O02m>OQ]o0OabPO0mA1DO]>0jA0I6]>JjA8V>IfA:Z>7N100000002N00O11OO100O10000000000001O000000001O0000000000E;1OO17IO1O1O100O11OO1001O000000000000001O007I1O6J5KO1M33M4L1O1O000000001O001O^O[BIe=7[BIe=6]BIc=7^BHb=7`B]OK7e=<_B^OM5d==bB[OJ7e=>eB@\\=?dBB\\=`0iA_OW>b03O11O1O0000M300O11O000000NcAB\\>>dAB\\>>eAA[>>4O11O001O0000O100N200O100001O001O0000001O001O1O000000001OO11OOUB@X=`0ZBBO1NNi=a0XB@O;e=;[BDf=1e^U1", "size": [480, 640]}, "area": 24486.0, "iscrowd": 0, "image_id": 18837, "bbox": [52.0, 0.0, 508.0, 162.0], "category_id": 96, "id": 20001198}, {"segmentation": {"counts": "n9_2a<0000O01000O1O1001O001O00N12O001O002N0000001O0O10IiCfMVC5J5L3L5L5K3O23M9F10000000000O1000000001OO1O10001O1O0N3O010O001O1O1N101O1N2@fAL0113Y>NRB1n=LTB3]>000SX6", "size": [480, 640]}, "area": 3883.0, "iscrowd": 0, "image_id": 18837, "bbox": [0.0, 278.0, 626.0, 122.0], "category_id": 97, "id": 20001199}, {"segmentation": {"counts": "]O1MeAAZ>`0fA_O[>a021NN210100O01O01M0fA^O[>a0eA_O[>a0eA_O\\>`0202N0O12N010O0001OO12N2N2N1O2M3O1N2NRVk8", "size": [480, 640]}, "area": 537.0, "iscrowd": 0, "image_id": 18837, "bbox": [0.0, 394.0, 35.0, 24.0], "category_id": 111, "id": 20001200}, {"segmentation": {"counts": "mhl83m>0000010O2N1O2N2N2N2N2N2N2N2M3N1O2N5K00000O100000O10000000000000TH", "size": [480, 640]}, "area": 723.0, "iscrowd": 0, "image_id": 18837, "bbox": [607.0, 252.0, 33.0, 34.0], "category_id": 113, "id": 20001201}, {"segmentation": {"counts": "\\ma032Og>a00O01VN_OUE`0l:@TE`0l:@TEb0i:_OXD02b0_;]OjC1c0O[O0j0e0[;[OmC19OD=a0a0h:ROgD0O:080=a0N_:`0PEAc0Ja:e1_EZNb:g1]EVNf:f1cEQNa:o1X11OO10000SN\\CC10a0;IEH7b<5QD1DCI8b<3PDO[OF00:0H8d<2QDNZOH`07UMYAMj>2VANfS[8", "size": [480, 640]}, "area": 1343.0, "iscrowd": 0, "image_id": 18837, "bbox": [38.0, 0.0, 33.0, 127.0], "category_id": 132, "id": 20001202}, {"segmentation": {"counts": "R=n1Q=1MRNTCn1lf05M3N1O1O0O10000O10000000000O10O1000O1001OO10000O12NO1002NO100N200O1O10000O8HhaU76S^jHo0PO2O01OO10000O01N200O100O01000001OO2N02N100000O10N0201O0O10000O0101OO01001H6O2O1MO13L4M3001OO100000000000000OTF", "size": [480, 640]}, "area": 5483.0, "iscrowd": 0, "image_id": 18837, "bbox": [0.0, 317.0, 640.0, 163.0], "category_id": 140, "id": 20001203}, {"segmentation": {"counts": "oYi01m>0TA0k>3O1000000O10000O10000000000O1000000O1001OO10000O12NO1002NO100N200O1O10000O1GJgA7Y>80000000000O10000000000000000000000001O1O1O1O00000000O100000000001O00001OO100O1000000O10000O10000O100O1000000000000000000000000O100000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000O1000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000O100000000001O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1EcA1^>MfZi00eeVO0K2XANf>2[AOc>1_AO_>2aAO]>2dAN[>2fANY>1iAOW>0jA0V>OjA2U>NlA2T>LnA4_>0O1000000O100000000O1000000O1000000O10000O100O1002N5K4Lge39PZL>A9H8G8I7I7H8I6I100M3N2O100K5J6I7N2M33M00003M00001O000000000000001O000000000000001O00000000006J8H7I8H8H7I5K1O00001O00000000001O000000001O00000000001O00000000001O00000000001O0000000000000000O100000000O1000000O1000000O1000000O1000000O100000000O1000000O1000000O1000000N2N2N2N2N2N2N2O1N2N2N2N2N2N2O1N2N2N2N2N2N2O1N2\\Od01O0000000000O1N200O100O10000001OO1O11O000000O100N20000O10000O1001OO100]NVL`F011W1i3V8bLaGe3]8]LaGe3_8[L`Gf3P8jLmGY3S8gLjG\\3V8dLfG`3Z8`LcGc3]8]LcGc3]8]LdGb3\\8^LcGc3\\8^LdGb3\\8^LdGb3\\8^LdGb3\\8^LdGb3\\8^LdGb3\\8^LdGb3\\8^LdGb3\\8^LcGc3", "size": [480, 640]}, "area": 23902.0, "iscrowd": 0, "image_id": 18837, "bbox": [53.0, 285.0, 587.0, 195.0], "category_id": 149, "id": 20001204}, {"segmentation": {"counts": "WZS84Q<0cF4T95gF1S94UEK;DROa0];1oD1=7d:m0nDYNFQ1\\;g0eDG[;o1000002NO11O001O00000000G9M3002N3YDfLb;^3N0000O1001O000000001OHaDoL_;P3dDnL\\;P3fDPMZ;Q3hDmLW;R3jDnLV;S3iDlLX;T3:1ODZD^Mf;_2XDZM27f;_2YDYM40L1h;f2XDZM20NOi;g2XDYMQo8SOZFf01DCI8;l0:R9YOUFd0O[OF00:0H8=l05V9]OPFf0NZOH`07Nm01Z9AhEOLg0NYO61J`07Nm0M^9FbE0Lh06J2Jl0Jb9K[En02D6Ik0Ic9MYEo01D5Go0Hc9l1[EnMM`0U1Fc9m1ZEmMN`0U1Ed9c2^F\\Mb9e2^FYMc9g2_FWMa9i2[10000MlCZMTOoQ\\12nmcN102NOcALP>6nAKQ>5oAKQ>4PBNn=3PBNm=d0O3N2N0N3I82LO1000O101O001OEnNaB03R1[=oNaB0OO2S1^=nNaB3OP1S=lNXC1EY1T=gNmB00O12NX1T=kNlBL12OW1S=lNmBK1^1lJiA<1DO5V>KjA70I65P>KjA78Om=JlA3:3j=J]B6V>007YBD\\<=`CDb<=[CCi<j01O1N2O2N1O1O1O1N3N1O1N2N2N2OF93M1O9G10000O2O00Q?0PA0Yf40TkJ8o=<6K4LN2L42M4M000O01O1O1O2O3L4MGmAI10O=T>HRBMJ7T>KUBLG007V>KSBNI7e>0001O1O001O1O1O100O00km05eX3KaiKO01QO0QBO0002b00H1Q=\\=c000000001O02NO11O001O00000000G9M3002N3VNiBe1[=N0000O1001O000000001OH^NRCc1l<`NRC`1l00000000000000^OmA7P4Dm54UF7i3LT6EWF?`33`6L[I;c6EWIc0h6\\OSIj0l6VOoHQ1P7mNlHZ1T7aNjHf1V7TNhHT2l97E;DDV3j4]LbKj0WOi2W5\\LcKS1nNb2]5\\LdKZ1hN[2c5[LeKa1aNU2h5[LfKh1[Nm1o5[LfKn1UNh1S6[LhKT2nMb1X6[LiKT6V4kIkKU6T4lIkKV6T4jIhKZ6W4fIfK]6d2dInLO9b6j2VJTLYOn0e6n2dIZN`6g1_IUNe6l1ZIgLEJU7`3UIaL5@j6Q4PIYLe0YO_6_4kHSLe8n3ZGnKj8R4[GhKf8Y4]GbKa1Fn4h4dI]K\\1NR5d4dIZKX15V5`4dIXKS1;j51[H^3`2eLV5LZH`3\\2gL[5HYHa3Y2jL_5DXHc3U2mLc5_OXHe3Q2oLi5ZOVHh3l1RMo5UOUHj3h1TMT6QOTHl3=]N`7fMSHi6n7VIRHj6P8TIPHl6R81O0000000000001O00006J8H7I8I7H7I5K1O00000000001O000000001O00000000001O000000000010O0000000001O000000001O00000000O1000000O1000000O1000001O0O1000000O1000000O1000000O1000000O1000000O100000000O2N1N2N2O1N2N2N2N2N2N2N2O1N2N2N2N2N2N2N2O1`MWHgMk7U2aHaMa7Z2lH\\MV7`2WIUMk6g2i2K5L5J5N2N2OcDcLY;[3gDPMP;o2PERMP;m2oDUMQ;i2oDYMQ;f2oD[MQ;Z30XOoDaMQ;V31000>Be0[Oe0[Oe0[O?BO001O0010O2O1O1N2O1O0O2O1O1O1N2O1O?@hg6", "size": [480, 640]}, "area": 187877.0, "iscrowd": 0, "image_id": 18837, "bbox": [17.0, 15.0, 608.0, 465.0], "category_id": 183, "id": 20001207}, {"segmentation": {"counts": "`0X1[:1O000O10000000001O00000O10N3L300O100N2N3O0000000O12M3O0M20001O2N1O00001O000O1001N1O100N3N2O0O101O01O1N3N01N13M000O000000O2O10O1001N100000000000RFlN[90VFT1=oN\\9S1bFoN^9Q1XFkN38d9Q1ZFQOf9^100000000000004MC3L1O100O101O0O2O0M22N12J220EhEYOY:h07200000O10000000L43M3NOOO22N0000000000000000O02O00O10100O0O2O2N01O01NO20000001OLbERO_:m04000000000000000O10000NRO_En0a:22M2OO11O3M001O00000000000O02O0000O100001O3YETOa:l0_ETOa:o001OO10OO04OO2M100000000O1K50O10O100000000000000000000002N00N2000000000WEXOg:h0YEXO00e:h0[EZOe:j0OM\\EWOf:i0ZEWOf:i0110KZE\\Og:b0[E^Oe:b0\\E]Od:b0]E^Oc:?:O100O2O00O11N1M31N20IjDOZR_1OTYaN1O00001bDMZ;8N1O1O1O00O100O11ON21O1OO1M3K5Nko30idK3R;9N2N2000001O0000O10000O1001O1OO6J:F]Wi1", "size": [371, 640]}, "area": 12937.0, "iscrowd": 0, "image_id": 19042, "bbox": [0.0, 0.0, 482.0, 87.0], "category_id": 95, "id": 20001208}, {"segmentation": {"counts": "`Yf23_;1J601N2OOO31N01O0N20O100O20O1O0001FlD2U;MmD1U;OkDMX;4hcY4", "size": [371, 640]}, "area": 259.0, "iscrowd": 0, "image_id": 19042, "bbox": [238.0, 60.0, 22.0, 16.0], "category_id": 96, "id": 20001209}, {"segmentation": {"counts": "hje05\\;4N0JHnD1O7Q;712M100001O00000000000000000000000O10100O1O00O1O1N2O10000N200000000000000O100O1O100000O01O101O0O0100000O100O1O1O11OO10N13N0O1000000O100O100000000N200O11O0000000O11O0O1O10O0100O1O100O10O1O02O1L31O00L5O0E`NaFb1_99000000O10O11O00000001OO100000O1001OO100O1000O10001O01O1O001O2N00001ON20000001OLYN[Fh1d940000000000000000000000001O1O001O3M001YNUFd1m9000000O2OO100001O00000mNSF`0n9^OSFb0o9VOWFj0j9UOWFj0j9TOXFk0W:11O001O0000O100O11O1O0O10^OXOPFM2l0m9XOPFN1k0n9YOQFLMn0Q:WOSFl0l9>O100000000000O10N200000000O1O11O000000002N0_NTFONY1X:O001N02N01000O1010O1iNiEP1]:03M1O00O10TOaEd0_:ZO^EO4f0^:[OeEd0Z:\\OfEe0d:01O00001O000O020N1]OREa0P;0001O00O100O1000000O11OO1O10010N00100O1O100O1O11OO100O11OO100O1000O11OO01000000000UOZEi0h:0O10000000000O100O100001OZEUOb:o000001OO0110N11O000O10ONRO`Eo0[:QOeET1[:2O1M300O100M300O1O1O100L_NUFb1k930000000O02O00O011O0000N2000000010OO0010000000001O001O0O1000000N2001O00O100000000O10000000000O10000O10000O1O10000001ONoMbFQ2^921O1OO100O1KmMjFT2U9mMiFT2W9kMiFW26iMg80TG_2`8aM^G10O41Ma2^8eMdGJMc2^8?001O0000O10000O1dGlLY8T3gGlLZ8S3eGnL\\8T3dGkLY8V3gGjLh74bHU3^7TMXHn2g7?00000000000000000000000O1O1000000001XHWLd7h3\\HYLd7g3\\HXLe7h3[HXLe7h3[HXLe7h3[HXLe7h3[HXLe7h3[HXLe7l3OK[H\\Le7d3\\H[Ld7f3400O1000000001O000000N21O001O1ONXHYLh7f33001OO10UH[Lh7i3O0000001OI7001O000UH[Lh7f3WH\\Lg7d3ZH[Lf7e3ZH[Lf7e3ZH[Lf7e3ZH[Lf7f3YHZLg7f3YHZLg7i300000000000O1O1002N00000000O100002N00O10000MZHYLf7h32NWHZLi7f3WHZLi7f320000001O1O001O1OO1001OO10000O10000O1O100O1O100O12NM31O0000001O00O11O1O001O2N1O2N00002N00000000001O0000000000000]HRLa7n3_HRLa7n3_HRLa7n3_HRLa7Q4O000000", "size": [371, 640]}, "area": 37729.0, "iscrowd": 0, "image_id": 19042, "bbox": [60.0, 0.0, 580.0, 130.0], "category_id": 97, "id": 20001210}, {"segmentation": {"counts": "j2a0R;0000O1001OO1001OO1O11O00000O1O011O000O01001O001N2O00O1O2O001O00000O10oDAn:?REAn:?REAn:b0O10O2M3OO10001O_OPE>1BP;=PECP;>oDBR;?00O0100O1O2O10O00002NHQEKP;3900MdDO_n`6", "size": [371, 640]}, "area": 1053.0, "iscrowd": 0, "image_id": 19042, "bbox": [0.0, 86.0, 64.0, 22.0], "category_id": 125, "id": 20001211}, {"segmentation": {"counts": "Q[d04_;3L1O1O2M2O10001O0O10O11O00000000N2N2FkD3\\;Nem[6", "size": [371, 640]}, "area": 257.0, "iscrowd": 0, "image_id": 19042, "bbox": [56.0, 50.0, 21.0, 16.0], "category_id": 127, "id": 20001212}, {"segmentation": {"counts": "[3Q4b7000O10100N3N01OO1O20O00000O11N11N1001N1010O001O1N11N1O10000000O1O010jKfHR4[7nKeHR4[7nKeHR4^71O0O3L11O1O1O2OOnKcHo3^7QLbHo3_7PLaHP4a7O10O101N1O1001O0O1O3N]HSL_7R4O00001N21N01O00MdHPL[7P4400000000O100001O2N000O10010O0000000000001O001O1O00N20000N2O1O1O1000000002M100010O00cLlKZOT4>lK^L1T3S4>lK^L1T3S4>mK]L0U3S4=nK]L0V3S4WLBi3>WLBi3>PLYL1Y3o3>oKZL2X3n3`0oKXL3X3n3d0SL\\Om3c0TL]Ok3e0TL[Ol3e0TL[Ok3f0ULZOj3g0VLYOj3g0VLXOk3h0ULYOj3g0VLYOj3f0WLZOi3f0WLZOi3f0WLYOj3c0ZL]Of3c0ZL]Og3>oKYLLb3iLPL^3_2T4_N]KXN011i0>_2T4_NgKSO4^2U4_NgKSONWOHW3c4]NiKUOKXOIV3d4^NgKROMZOHV3d4\\NZK[N=i0JWOI42U3d4\\NZK[N=i0DWOO4001V3e4[NiKWOBUO2_3c4UNiKWOBUO2_3c4TNiKZOATO3]3c4VNiK\\OD^2c4VNhK^OB^2g4SNhK\\NG]4_4YM]KZNb0\\4Q4ZM\\K[Nc0[4P4_MQLfN[OW3c4TNRLeN[OW3Y4XLoKl1<\\N\\O00`3T4YLlK26l1=XN]O11_3R4dLnKf1a0VN@OOa3R4YLoK7Nk1b0UNAMOc3U4eN[LgMEMI03g3T4eN[LfMMe3g3eN]LfML0Aa3V4gNjKfMd01KODb3R4iNkKeMe00Nc3c3gNjKfMY1d3n2eNSM\\1l2eNTM[1Y1\\LmNY2`NfMX1e3Y1_LoNU2`NgMX1e3X1`LPOV2HZ1X1aLoNV2HY1V1dLROS2cNdMQ1e3Z1dLROW2aNaMP1c3]1fLSOZ2^OP1_1fLSO[2]Oo0`1fLSO[2]Oo0`1fLSO[2]Oo0a1eLRO\\2VO[MZO04c3Z2fLSO5_Ne1g0PN\\O`3Z2gLUO3^Nf1e0RN\\O`3\\2eLVO2]Ng1e0j1h1]LWON\\NH1S2a0mM^Od00d2]2RMYOLZNJ1S2a0mM^O;2JNS3]2hLcM8f1NZNJ1S2a0ZNAGMT3_2oLXOO\\Nm1?ZNGk2W2lLZO2XNm1`0ZNGk2Y2jLYO2XNo1?[NFj2Z4jLcKP2=\\NFj2d4iNgK[NFl2c4iNgKZNGm2b4hNiKWN[OI;X3a4]NTK[N05h01ER3^4^NUKZN05i01CR3^4_NYK]Ng01BS3\\4aN\\KYNg03AS3\\4aN\\KXNi04WOK1X3b4bN]KWNi08SOG5W3c4dN\\L]NlNH5W3c4dN]L^NPOn2c4eNYL`NoND3W3e4eNZLaNQOj2e4eNYLbNROi2o3iLbLl1S1SNfNVOIX2>?U1oMgNYOEZ2?>V1kMhN]ODZ2>>V1UMoM6n0ARO8=^2>>W1SMTN0j0JPO7<_2?=X1QM_OK^N103?X3oLYLc2?>X3oLZLb2>?Y3nLYLc2>?Y3mLZLd2=?m3@SL`0n3^OSLb0m3_ORLa0n3_ORLa0n3_OVK\\Mj0U3Q4gMUKk0j0^1Q4fMVKl0i0^1Q4eMXKk0h0`1P4cM[Kl0e0a1P4bM\\K4IWO000O08_OI:i0k2R4]M]K_OHON01a06AK7j0k2R4]MdK_O@`06@J:j0j2Q4_McK^OB`09Ia0j2Q4_MgKOHG`0k2Q4_MfK0IEa0l2P4_MfK1HDb0l2o3`MgK0HCc0m2n3`MgKOIDb0m2n3aMgKKKFa0n2m3`MhKLKDa0P3l3`MiKJQ1f2U3aMkKHP1g2U3aMkKGQ1h2T3aMkKFR1i2T3`MfK\\O@:g1j2S3\\MTKAc00^O9h1j2S3[MkKBZO8i1k2R3[MkKBZO6k1m2n2]MlKA[O5k1m2n2]MlKA[O6j1l2UNlLg4a0PLAZO6j1n2n2YMnKNT1i2m2ZMnKMV1i2l2ZMnKMV1i2l2ZMmK0U1e2n2\\MmK1S1d2m2]MPL0R1b2l2aMRLMR1c2i2aMVLMP1b2h2ZMbKDi0?n0c2e2[MeL1f0d2e2[MeL1f0c2g2[MdL1e0d2f2\\MeL0e0d2f2\\MfLNe0f2e2\\MiLKb0i2e2[MkLK`0j2e2WMeKDU1;b0j2d2WMeKDU10iN9i1l2d2WMnLDfN0O69LS1S3Q3XMPMCcN30M92T1S3Q3VMRMGnNNo0U3T3RMPMIoN0m0U3V3oLaMNWOS3Y3lL`M3lMLY1U3a5RM_Jn2`5SM`Jm2`5SM`Jm2`5SM`Jm2`5SM`Jm2`5SM`Jm2`5SM`Jl2e3lLlL8_Om2b3mLVK0d16VOI@T3^4oLWK0d14WOJ_OR3_4QMWK0c13XOJ_OR3]4SMZKNa12YOL_OQ3]4]MjLEZOM_OQ3\\4^MkLCZOO_OP3\\4^MlLAZO1^OP3\\4^MmL@YO2^OP3\\4^MnL^OYO3^OQ3Z4_MlMCiMn2[4^MlMFhMm2\\4\\MlMFiMn2[4lL[K=a2IiMm2\\4lL[K=a2JhMm2^4ZMjMIhMm2_4YMiMJhMm2_4XMjMKgMm2`4WMjMKfMn2b4mLUK3b24gMm2e4nLfM3fMo2c4oLgM2fMP3b4nLhM2fMP3c4lLgM5fMo2c4jLiM8cMn2^7QMbHo2_7PMaHP3`7oL`HQ3a7kLbHU3n70000000SLjLbK10Of3V3b0YMZOg2g0XMYOh2h0XMWOh2i0XMWOh2i0XMWOh2h0YMXOg2g0YMZOg2f0YMZOg2g0XMYOh2g0XMYOh2g0XMYOh2h0WMXOi2h0VMYOj2h0UMXOk2i0TMWOl2j0SMVOm2k0RMUOn2k0PMWOP3j0nLWOR3k0lLUOT3l0jLUOV3d40000000000001O001mGhLi7a302N1O00000000000000000TH\\Li7d3WH\\Li7d3VH]Lj7f3VHYLh7g3XHYLh7i301O000000000000000000000000O1O1000000001XHWLd7h3\\HYLd7g3\\HXLe7h3[HXLe7h3[HXLe7h3[HXLe7h3[HXLe7h3[HXLe7l3OK[H\\Le7d3\\H[Ld7f3400O1000000001O000000N21O001O1ONXHYLh7f33001OO10UH[Lh7i3O0000001OI7001O000UH[Lh7f3WH\\Lg7d3ZH[Lf7e3ZH[Lf7e3ZH[Lf7e3ZH[Lf7f3YHZLg7f3YHZLg7i300000000000O1O1002N00000000O100002N00O10000MZHYLf7h32NWHZLi7f3WHZLi7f320000001O1O001O1OO1001OO10000O10000O1O100O1O100O12NM31O0000001eM\\LeLd3Z3_LdL`3]3aLbL`3\\3aLdL`3Z3aLfL_3Z3aLfL`3Y3`LgLb3V3_LjLb3U3^LkLd3S3\\LmLd3S3\\LmLd3S3\\LmLf3Q3ZLoLf3Q3ZLoLf3Q3ZLoLf3Q3ZLoLf3R3YLnLg3R3YLnLh3Q3XLoLh3R3WLnLi3R3WLnLi3R3VLoLj3Q3VLoLj3Q3VLoLj3Q3ULPMk3iMRLU53RMk3iMRLU54QMj3jMRLV52QMl3iMRLX50oLQ4P3oKPMQ4Y50000", "size": [371, 640]}, "area": 127558.0, "iscrowd": 0, "image_id": 19042, "bbox": [0.0, 101.0, 640.0, 270.0], "category_id": 148, "id": 20001213}, {"segmentation": {"counts": "nZa22_;3N101L300O10000001O00O10000000FiD8Y;O2M4N\\_5Ne`J1N3O0O1O1000000O10000000O1000000O100000001O00002NViY1OkVfN1O0O100O100000OO3N2OO10000000001ON21N1000O1010O1O1O1Ll^\\2", "size": [371, 640]}, "area": 505.0, "iscrowd": 0, "image_id": 19042, "bbox": [224.0, 183.0, 204.0, 178.0], "category_id": 150, "id": 20001214}, {"segmentation": {"counts": "\\7W4\\7000001O1O2N0000001O000000O11O00O1001O001O000000O11O0000000000O1O100O100001O002NO1O1O1O100O10000O100001O00000000O1O10iKgHT4]7O00001O1O001O00MPLdHo3\\7400000000O100001O2N000000001O0000000000001O001O1O00N20000N2O1O1O1000000002N00001O000O0H`H^La7b3_H^La7b3`H]L`7b3aH]La7b3^H^La7b3aHZLM2b7d3aHZLc7d3ZH\\L30d7c381OO01O0O2O0O10000000O02O000ZHYL`7g3_HZL`7h3_HXLa7l31O02O0O1O10000000O10000L401KZHYLh74XHL0_30aLh74ZHY3k7eLUH^3o73MLRHbLo7^3QHbLo7^3QHbLP8]331O000O1RH`Li7`3VHaLj7_3VH`Lk7d32N1fLPHP3P8oLPHQ3Q8nLoGR3Q8nLoGR3Q8iLoG02Y3Q8fLoGZ3U8O2N10NiLhGW3X8iLhGW3W83O10001O00000000LkGjLU8S3kGlL00X8Q2hGmN0QO10Y8Q2fGlN2SOO0Y8Q2fGPN0j04UOV8Q2gGoMOj0b8m0_G_N0JOk0a8l0aG^N1e0^8n0aGXN011i0^8n0kGSOT8m0lGSONWOh7d1\\HUOKXOj7d1ZHROMZOi7b1mG[N=i0JWOI4S8a1mG[N=i0DWOO4001Lo7e1_HWOBUO25m7_1_HWOBUO25m7^1_HZOATO33m7`1_H\\ODTOm7`1^H^OBTOQ8]1^H\\NGS1i7c0SHZNb0R1[7d0RH[Nc0Q1Z7i0gHfN[OMm7^1hHeN[OMc7BeHl1<\\N\\O006^7CbH26l1=XN]O115\\7NdHf1a0VN@OO7\\7CeH7Nk1b0UNAMO9_7o1QIgMEMI03=^7o1QIfMM;Q7o1SIfML0A7`7Q2`HfMd01KOD8\\7S2aHeMe00N9m6Q2`HfMY1:X6o1iIRNV6o1jIQNV6o1`HfMX1;Y6n1_HgMX1;Y6P2gIPNY6Q2fIoMZ6Q2aHdMQ1;^6U2_HaMP1:b6Y2\\IgMd6Z2[IfMe6Z2[IfMe6Z2[IfMe6Z2TI[MZO04:_74]He1g0PN\\O7a73\\Hf1e0RN\\O7d70[Hg1e0aNQ7DZHH1S2a0mM^Od0i7BWHJ1S2a0mM^O;2Jg71WHJ1S2a0ZNAGf72ZHm1?ZNa7IoGm1`0ZNb7GoGo1?[Nb7DQHP2=\\Nl7c1UH[Nl7e1THZNm7e1UHWN[OIa8e1_G[N05h01j7`1^GZN05i01g7a1cG]Ng01d7d1fGYNg03c7d1fGXNi04WOKR8j1nGWNi08SOGV8k1nH]NlNHV8k1oH^NQ7c1kH`NoNDT8l1nHaNR7_1mHbNS7^1lHbNU7^1jHcNV7]1jHcNV7]1jHcNV7^1iHbNX7]1iHbNW7^1iHaNX7_1hH`NY7`1hH^NY7`1jH_NV7NgGW10bNY13R73fGW1Z1fNP73gGR1OhN[13o62hGS1NhN[13o62iGR1[1lNl62iGR1[1lNl62hGT1[1jNm61iGU1Y1kNo6NiGW1Y1iNo6OhGW1[1iNn60gGW1T:0TGjNdNNd8X1gHkNeNNb8X1gHQOW7P1hHROQ7FgGZ1W1POP7DiG01Z1W1SOo6DhG00Z1Y1ROP7FgGY1Y1POP7T1QIkNP7n0kGgNS10iN:Y8o0TIiNbN00O_8X1PIlNaNN]8V1RIhNfN0Y8S1cGoN\\1OhNOY8S1dGnN[10hNOY8S1fGlN01<120COX8U1lGkN7120CNY8V1kGlN506Oo7W1fGjN53i8U1oFiN82e8KnF[14iN5LG7OIo8_1UGfN4MI84H_8^1`GeN2c0_8i0_GdN1e0^8i0aGaNOh0`8g0aGaNNh0a8l0]G[N2j0`8l0^GZN1k0a8Q1^GoNa8R2O10000O1JoLkGP3m7oLSH422K_2o7\\MSH62NL`2o7^MPH57KIc2P8gMXHDIe2o7gM\\HY2c7hM]HY2b7gM_HX2b7gM]HZ2b7fM_HZ2b7ZMQH8=^2a7[MRH7<_2c7YMQH1038_OI:m88[G_OHON01a06AK7n88bG_O@`06@J:m89aG^OB`09Id89eGOHGc8:dG0IEd8;cG1HDd8cGKKFc8>cGLKDc8`0cGJR97oFHQ98oFGR99nFFT99hF\\O@:i96UFAc00^O9j95lFBZO8k96kFBZO6k9:jFA[O5k9:jFA[O6i99mFAZO6k97kFNT93kFMV93jFMV93iF0T91lF1P91PG0l83TGMj84WGMf8LdFDi0?b8NfG1Z8OfG1[8NfG1Y80gG0Y80hGNY82jGKV84lGKT81fFDU1;V81eFDU10iN9]93nGDfN0O69Lg8;]HCcN30M92i89^HGnNNg87\\HIoN0g84mHNR7OnH3lMLZ;7O10000000000TNH]H8a7JfF0d16d7LgF0d14d7MhF0c13c7OkFNa12e7:ZHEe7<[HCf7=[HAf7?[H@e7`0\\H^Od7c0f1O2O0@PE=P;BQE=R;11O0O2O2FiD3\\;O01001N1NZl20WhL10OV;?MO10O000O1O0101O00001O0O2O1O1O1O0N3N3N1N[_g10e`XN3N1N1O10000O100000000000000001O00001O000O10000O10010N3N00_i0", "size": [371, 640]}, "area": 38965.0, "iscrowd": 0, "image_id": 19042, "bbox": [0.0, 227.0, 637.0, 144.0], "category_id": 162, "id": 20001215}, {"segmentation": {"counts": "0`0X1b0a7^O`Ha0`7_O`Ha0`7_O`Ha0`7^OaHb0_7^OaHb0_7^OaHb0_7^OaHb0_7^OaHb0_7^ObHa0^7_ObHa0^7_ObHa0^7_ObHa0^7^OcHb0]7^OaHd0_7]O]He0d7[O\\Hd0e7\\OZHe0f7[OZHe0f7[OXHg0h7YOVHh0k7YOTHg0l7YOTHg0l7YOTHg0l7YOTHg0l7YOSHg0n7YOTHe0l7ZOWHd0i7]OWHb0i7\\OYHe0f7[OZHe0f7[O[He0d7[O^Hc0b7]O_Hb0a7^O_Hb0a7^O_Hb0a7^O`Ha0`7_O`Ha0`7_O`Ha0`7^OaHa0`7_O`Ha0`7@^Hb0a7^O^Hd0a7\\O_Hc0b7]O\\He0d7\\OZHe0f7\\OYHd0mNmNh8?ZHh0e7XO[Hh0e7YOZHh0e7XO\\Hg0d7YO]He0d7ZO_Hd0a7\\O_Hd0a7]O]Hd0c7\\O`Hb0_7^OeH?Z7AiHU7AmH>S7AnH?R7AnH?R7AnH>S7AoHX200000000000000O1001OO1001O2N0000O10000001O00O1O1001O1O000dT:KakE3M000000001O001O00O1O12NN200O1N200000000000000L43M3M00N22N0000000000000000O11O00O1001O00O100001O00O10000000000000000000000000000O10000NkDFU;:kEFU9:jFHU98kFHU98kFIT9:iFIT94QFIh03W92SFKf04WOIm98VFLe05U98kFHU90UFKf05U9OVFLe05U9OVFLe06T9NWFLe05U9NWFMc06V9MWFLe06T9OVFKf07S9NWFKf07S9NWFKe08T9MVFLf07T9MVFLf08S9LWFLg09P9KYFLj0MTO7h91YFKk0MTO8g91YFJo08e8L\\FNP13f8O[FMn07e8M]FKn08e83ZGOf8O^GMd84[GLe86XGKh85XGKh85XGLg84YGLg84YGLg84XGMh83SGOP91PGNQ91PGNQ92nFNS92mFMT93lFLU94kFLU94kFLU94kFLU94kFLU94kFLU94kFLU94kFLU94kFJW96iFJW96kFHU98kFHU98iFJW96iFIX97hFHY98gFIX97hFIX97hFAXO6P:9hFAXO004P:;hFAZO4n9;lFGR98kFBWO81KONe9=TGBWOb0d9LUG6k8IVG8i8HRGD\\Od0c9HoFF^Oa0d9InFG]O`0e9ImFH^O?e9IjF`0W9@hFa0X9_OhFb0W9^OhFd0EQO\\900000000000000000000000000000000000000O1N2N2OQKkGi4T8XKoGe4P8\\KSHa4l7`KWH]4g7eK\\HX4e7gK^HV4b7iKbHT4^7lKeHQ4[7oKhHn3X7RLkHk3U7TLnHj3R7VLoHi3Q7VLPIj3P7ULRIj3o6RLQI5mNd3U9;M3N2M3M3O100O10000000000O1000000001O2N1O2N1O2N1O2N1OGoKXGP4g8RLYGm3f8ULYGk3f8WLYGi3g8WLYGi3f8XLZGh3e8YL[Gg3d8[L[Ge3d8b0O1O10000O1000000000000O1O1O10000000000001O00000000001O1O00000000000dKaGk3_8TLaGm3_8QLaGQ4_8lKbGV4^8kK_GW4a8:00O100000000000000O100000000000000O10000O1^OTKdHl4f6XKZI1Jh4j6`KUIJNg4l6gKnHE4d4m6Z1N2GgI_IY6_6;00000000001O2lJ]I[3e6`L_I_3c6XKWIl0:l3h6mK^IR4e6fK`IZ4f6[KbIb4j7J1O1O1O001O2N1O00\\OfKUH[4k7fKSH[4m7eKRH\\4n7dKQH]4o7dKPH\\4P8dKPH\\4P8dKPH\\4d7dKXH12\\4e7fKWHN3]4f7PLYHQ4f7QLXHP4g7QLVHR4j7nKTHT4k7nKTHR4k7oKUHQ4k7oKUHQ4k7h0000000000000O1O1O100000000000000000000O1N2N2O1N2K5M3N2O10000O11fJkH[4U7eKmHXOOj4T7SLnHn3S7RLlHn3V7S1LQJlHn5S76O[JnHR5R7\\KnHV4S7Q10000000SKmHa3T7_LmH_3U7_LPI\\3R7eLmHY3U7hLiHW3X7kLfHT3Y7mLgHdNO\\4Z7jLmHY3T7eLmH[3T7bLoH]3S7`LnH`3S7^LnHb3S7iKaH8=o3S7gKiH16W4R7eKcI[4g701O0000O10000O10000O100O1O100O1XO^K\\H1Ka4h7aK[HNLb4i7aKZHMMb4i7bKYHMLb4k7bKWHMMb4k7bKWHMMb4l7bKUHg4j7>O100O1CeJhH\\5W7fJhHZ5W7hJgHY5X7iJgHW5Y7iJgHW5Y7jJfHV5Z7>00000000001O1O2N2N0hJ`Hd4_7e0O10000000000001O1O2N8H00I7O100O1001O001O1O1ZJ]Ha5g70000000001O1O2N6JK5O1O1O10000000000NaJWH_5g7cJYH]5f75000000002N2N000000001O1O2N00001O0000N2N21O2N1O1O1O1O2NF:O1O1O10000000XKZHj3f7WL\\Hf3d7Q11O1O2N8H000000001O1O2N6JRO_KQIa4l6cKSI]4l6gKQIY4n6iKQIW4n6lKPIT4P7mKoHS4Q7nKnHR4R7SLgHo3Y7R1000000000000001OO100O10000001ZJgHW5Y7iJhHV5Y7iJhHV5X7?1WJeH_5c71O1O1O1O100N2N2J6O1O1000000001O1O4nIgHi5_7O001O1O003M4\\JXH\\5i732N3M002N1O2N2N1O2N2N2N001RKcGk4]8WKcGg4^8300`NZKfI3Ec4d6\\K_I8N[4c6^KXI=O[4i6XKSIi5m6`JfId4Z6\\KfId4[6ZKgII\\O`4n6fKfIK\\O^4Q7dKcIO[O]4R7dKeINYO]4U7bKaI2ZO\\4V7`KaI5YOZ4V7aKaIm4a6QK_Io4b6oJ^Ih0ZO\\3T8cLoG[3Q8\\LZHb3f7_LYHa3f7`L[H_3e7bL[H]3e7dLZH\\3f7eLZHZ3g7fLXHZ3h7fLZHX3g7hL^HR3b7oL]HQ3d7oL[HQ3e7PMUHU3m7iLSHW3n7iLPHX3R8gLlGZ3U8fLiG[3Y8cLhG\\3Y8dL`G]O000Q4a8h01O1O1O1O1O1O1O1O", "size": [428, 640]}, "area": 155718.0, "iscrowd": 0, "image_id": 19109, "bbox": [0.0, 0.0, 640.0, 325.0], "category_id": 96, "id": 20001218}, {"segmentation": {"counts": "`lW71X=31O00L4TCJc<6[CKbBlMcEU2]:oM]ES2e:92N2N2N1O2N2N1OO100O10000O100O100O100O100O100O1O1O1O10000000000000000000000000000a0_O1O00O100000000000000O100IQNQEo1n:TNPEl1P;VNnDj1Q;900O100O100O100O1O100O100O100O100O1O1O1O1O1O1O1O1O1O1O1O1O1O14L4L5K4L4L1O1O1O1O1O1O1O1O1O1O1O1O1OO100O100O100O100O100O10000O100O100O100O100O1O1K500000000000000000000O100O1O100O1O100O100M]M]Ec2a:^MaEa2f:O1O1O001O1O1O1O001O1O1OO100O100O1O100O1O100O11O1O1O00000ZOSEZNOa0n:S1YEkNg:Q1aEkN_:P1dEQO]:m0eEjN\\OM0000R;[1eEeN_:\\1h000N2N11O1N200O00O102N3M2LlCnNURF`1NSNR:=RF\\1Z:cNhE[1Y:hNhES1Y:nNfES1Y:lNgET1Z:hNjEW1W:kNhET1X:lNhEk0DPO^:2QFn0BoN]:M_EOb0R1]OjN66]:0VFo0@PO[:L]E1h0T1@oNZ:MZFQ1AQOU;L]D06i09ZO`;c0e0O1[O[Cb0ig6j0TIkN4=f6h0TInN5:g6i0RIoN5:h6g0SIPOBHBa0i7LiGG>Ml08_ON^OBB4R1[9lNgF28d0DWO0V1\\9nNhF18m0D3[9POjFO7P1CO\\9SOjFN7Q1CL^9UOgFM9S1BJ^9VOgFM:S1@I`9WOfFM:X2P9kMfFM:W2Q9mMdFL:X1A^Ob9_OaF52P1KcN2?`9]O_F:1;No00_N5;_9^2]FUM78^9d2g0000O10001N100O3N2N2M3N3M2N4L3M2N1O2N3M1O1O000O2O0010O2N1O1O1O2N1O2N2N3M2N1O0O2O001N101N1O2O0[MoEn1S:VNlEe1U:PNkEN0P2W:oMjE30l1X:lMgE=128e0T:]OeEK4ALU1\\:AcEF6FKR1m9oNYFe0JA4KMn0m9WORF`00^O30Ni0n98RFlN160a0P:>oEiN0:2;R:d0kEdN1`025T:i0kETO1OW:o0dETO6IY:j1d000000000O14L3M4L3M4L2N2N2N2M3L3M3NlLQFo2l9RMWFl2g9UM\\Fi2b9WMbFg2[9[MhFc2X9\\MkFb2T9^MoF^2R9bMQG[2o8eMTGW2m8hMWGU2i8jMYGk0SO3e9ROYGi0VO2a9TOZGi0UOSOI`08Ba91[Gh0QOZOL7];IfD=NG1OY;6eDOO25BW;d0dD9a;l0K5K5M2O2M3N0000O100O010O100O101O2M2O2M2N3N1N3M2N3M1000000000000001O000000000000a0AN1O1O1O1O2M2O1O1O1O2N1O1G[DiNf;V1]DgNd;W1TOgNXFX1h9hNYFV1g9kNZFS1g9mN[FQ1e9oN\\Fo0e9QO\\Fn0d9SO\\Fk0e9UO\\Fj0d9VOcEN6j0X:XO`E18f0W:ZO_E49`0Y:]O[E6<;Z:_OYE9<7[:AVE;?2\\:EQE=b0M]:GnD?e0H^:d0`E\\O`:e0`EYO`:j0^EUOc:l0ZEUOg:m0TEUOm:l0oDVOR;a11O1O1O001O1O1N2005K4L5J5L4L1N2]O\\M\\Fe2m8_MSG1Jb2P9fMoFJNb2Q9lMiFE4`2Q9[1M3FiK]GX4`8c:UOnE2_O?5KL=b:WOmE4@=5MK9c:ZOkE5B;6c0^:mNiE7C:5a0_:nNiE8D85bD_O^;c0bD[O^;g0cDVO^;k0cDiNf;c1TO\\N^E1Ke1d:]N_ENLf1e:]N^EMMf1e:^N]ELMg1f:^N[EMMf1g:^N[EMMf1h:^NYEk1f:>O101N1O101N101O001O0101O0O100O1O2OL[M`Ed2_:_M`E`2_:cM`E\\2b:62^M\\EX2g:gMZEV2h:iMZET2g:kMZET2f:mM[EP2g:PNYEo1h:PNYEo1g:RNVEP2k:PNRER2n:70SNREZ1a:XNgEa0HU1W:fNnE8KP1V:bNkEN1c0Nk0V:eNjEl01[DEc;;\\DGc;S1N2O0017IO2M3N1O2N21VN_Db1b;]N^Dc1c;31O1OO6L2M1000O1N1O2N2N0YN]De1d;[N]Dc1c;_N\\D`1e;aN[D\\1f;fNZDl0b:UORF2FP1W:POkE8Nh0V:POfE>Nh0\\:kN`E02`0N>`:ZOTFS1k9mNUFS1l9lNUFI\\Oo0a:TOTFDZO81o0b:TOSFEZO90o0b:SOVFNYOn0d:QORF3YOm0e:oNRF5YOk0e:PORF_1o9^NRF9XON0?c;0`DO_;GlD0\\;1eD0X;1gDNY;3hDKY;6gDIY;8fDG[;:eDD];;cDD^;=i00O100O02O001O001N1000000O100O100O1Nd4", "size": [428, 640]}, "area": 50867.0, "iscrowd": 0, "image_id": 19109, "bbox": [0.0, 175.0, 639.0, 221.0], "category_id": 183, "id": 20001224}, {"segmentation": {"counts": "]6a8]600000O100000000000000O1000000000000000000O100000000000000000000O1000000000000000000O100000000000000000000O1000000000000000000000000000000O10000O1000000000000O100O1O1O10lIQJY3n5\\LcJ_3]5VLSKe3l4WL_Kc3`4]LfK^3Z4`LmK[3S4cLULW3k3hL[LS3d3lLdLn2\\3QMlLh2T3VMTMd2l2ZM\\M`2d2_McM[2]2cMhMZ2X2eMkMY2V2dMnMZ2R2eMQNY2o1eMTNZ2l1eMWNY2j1eMYNY2g1eM]NY2c1fM_NY2a1fMbNX2^1fMfNX2Z1gMiNW2V1iMlNV2T1hMPOV2P1iMROV2m0jMUOU2k0iMXOV2h0iMZOV2f0iM]OU2b0kM@T2?kMDT27N101O001N101PB\\Od=P1O1O0O2O0O100O1000000O100000001O002N3M3M5K1N1000000001O0000000001N100O3N5J7J2M100O101N10000O100000001O2N5K8H00000000000000001O0000000ZEYMT9h2iF\\MNES8^3`GnL:HU8Z3_GPMJA09d8W3aGQMEE37e8T3ZGiMMVOh8g4UG\\Kj8\\500O100000000O1000000000000000000010OO101O0000001N011O0_GjIZ8W6eGiI[8W6dGiI]8X6bGhI^8X6bGhI^8\\600TKeIU1[6kNeIU1[6kNeIU1[6kNeIU1[6kNeIU1[6jNfIV1Z6jNfIV1Z6iNgIV1Z6iNgIW1Y6iNgIW1Y6hNhIX1X6gNiIY1W6gNiIY1V6gNkIY1U6fNlIZ1T6fNlIZ1T6eNmI\\1R6cNoI]1Q6cNoI]1Q6bNPJ]1Q6bNPJ^1P6bNPJ]1Q6bNPJ^1P6aNQJ_1o5`NRJ`1n5^NTJb1l5]NUJc1k5[NWJe1i5ZNXJf1h5XNZJh1g5VNZJi1h5TNZJl1f5SN[Jm1f5PN\\JP2e5nM\\JR2f5jM\\JV2f5gM[JY2g5dMZJ\\2h5`MZJ`2h5]MYJc2i5YMYJf2j5WMWJi2k5SMWJm2k5PMVJP3l5lLVJT3k5jLVJV3l5fLVJY3l5eLUJ[3l5bLVJ^3l5_LUJa3l5]LUJc3m5YLUJg3l5ULWJj3k5QLYJo3i5lKZJT4g5hK\\JX4f5bK^J^4c5^K`Jc4m70000O100001OO100000000O100000000000000O10000O10000O100000000O1000000000000O1001O000000O1001OO100000000000000O100000000000000000000000000O1001O00000000000000O100000000000000", "size": [478, 640]}, "area": 87361.0, "iscrowd": 0, "image_id": 19221, "bbox": [0.0, 139.0, 640.0, 339.0], "category_id": 123, "id": 20001225}, {"segmentation": {"counts": "]Xn33k>1\\ENl4ObG6K0c3Ok4KSG20O=91Ma30n40]G64K^32P52VG5:J]30R53UG5;I[32R5g0bGZOX31U5g0ZGA^3LU5`1iJbNV5`1fJbNZ5_1eJaN[5a1bJ`N^5a1aJ_N^5c1aJ]N_5d1`J\\Nb5b1]J_Nb5c1]J]Nc5d1\\J[Nf5d1ZJYNj5g1TJXNo5i0VGcNNg0l2LR6f0[G]Oc2MS6e0[G^Oa2MU6d0[G_O^2NX6c0ZG^O^20W6c0[G]O]20Y6`0\\GAZ2O[6?[GBY2O^6?YGBX2Mb6`0WGCV2Kf6`0UGEU2Ii6`0TGGQ2Hn6?QGKP2EP7?PGMP2BS7?lF2P2]OW7`0hF5o1[O[7`0eFOV2@W7b0`FNZ2@W7a0_FOZ2_OY7`0_F0W2A[7`0\\F0X2@]7?ZF3X2]O_7a0XF2Z2\\O_7a0XF3X2[Ob7b0UF3Z2ZOb7c0SF4Z2YOd7d0oE4^2VOe7g0iE5b2TOf7i1ZHUNh7j1YHUNi7i1WHWNj7i1f2O100O1O1O1O1O1O2M2N2N2O1N2N2N2Nj_7oNYaH1OO1O^mR4", "size": [478, 640]}, "area": 4637.0, "iscrowd": 0, "image_id": 19221, "bbox": [270.0, 178.0, 89.0, 203.0], "category_id": 170, "id": 20001226}, {"segmentation": {"counts": "0]6a8000000O100000000000000O1000000000000000000O100000000000000000000O1000000000000000000O100000000000000000000O1000000000000000000000000000000O10000O1000000000000O100O1O1O100O100O1O1000000O10000000000001O0000001O0000000000O10000O1000000O1O100O10000000000001O001O2N2N00O1O1N2O1O1N2O1O1N2O1O1O100O1O1O1O100O1O1O1O100O1O1O1O100O1O1O100O1O1O1O100O100O100O100O100O100O100O100O100O100O100O100O100O100O100O100O100O100O100O100O100O100O100O10000O1000jEkKc9T4]FnKb9R4\\FQLc9o3\\FQLe9o3ZFRLf9m3YFTLh9l3WFTLj9l3UFULk9j3TFYLk9g3TFZLl9f3SF]Lk9c3TF^Ll9a3TFaLk9_3TFaLm9_3RFcLm9]3RFdLn9[3RFfLn9Z3QFhLn9X3QFTL2a0@`0F;I6I7I8I6I8I8G8H8I7H5L3L4M3L3N3M3L4M2N3L4M3M2M4M2N2M3N2N3M2M3N2N2M3N2N1N2O2N1N3N1O2M2O2M2O1O2M2O2N1N3N1O1N3N1O2N101N1O1O3M2O2M2N2N3M2O2M2N2N3M2O2M2N2N3N1N3M2N2N2O1N101N101N101N101N101N2O1N2O1N2O1N2O1N2O1N2O1N100O100O100O100O100O101N100O100O100O100O100OnFoJY8Q5fGRKX8n4gGUKX8i4gG\\KV8d4iG_KU8a4jGbKT8]4kGgKS8Y4lGiKR8X4mGkKQ8U4mGnKR8Q4nGQLQ8o3nGTLP8l3nGWLQ8h3oG[Ln7f3QH\\Ln7d3QH_Lm7a3RHaLm7^3SHeLk7[3THgLk7Y3THjLj7V3UHlLi7T3WHoLg7Q3XHQMg7o2XHTMf7k2ZHWMe7R5O1N2O1O1O1O1O[IeHi5X7SJmHn5R7QJoHP6P7nIRIS6m6kIUIV6j6hIXIY6g6eI[I\\6d6cI]I^6a6aIaI`6^6^IdIc6[6[IgIf6X6XIjIi6U6VIlIk6S6SIoIn6o5QISJP7m61O1O1O1O2N1O2N1kLfHdN[7Y1hHfNZ7W1gHiNZ7T1hHlNZ7P1iHoNX7o0iHQOX7l0kHSOW7i0kHWOV7f0mHYOU7d0lH\\OU7a0mH_OU7=nHBS7j3ZNkMW1YNa0h3]NoMP1XNe0e3`NRNk0WNg0g3_NRNi0UNj0i3]NSNh0SNl0j3]NRNf0SNo0k3\\NRNd0QNR1m3[NRNb0PNT1n3[NQNa0PNU1o3[NPN?RNV1o3[NnM?RNW1P4[NmM>SNW1P4\\NlM=TNW1P4\\NlM=SNX1Q4\\NkM=SNW1R4]NjMPIFP7`6j3QIPK1g0>?`6j3RIoJO4O>?f0a6h3WITKJ=>h0`6g3YIRKK3LL2ON0b0Y1^6g3YIQKL00Oc0Y1X6g3YIQK4O:[1X6e3ZIPKn0[1h5d3dJ]L[5c3eJ]L[5c3hJZLX5f3hJ[LW5e3lJYLS5g3QKVLn4j3UKULi4l3XKSLg4k3[KVLd4g3_K[L_4e3aK\\L^4a3eK`LZ4_3hKaLW4]3kKeLS4[3mKfLR4Y3oKhLP4X3PLjLn3U3SLlLl3T3TLmLk3S3ULnLj3R3VLPMh3P3YLPMf3P3ZLg0OYO1g0O", "size": [480, 640]}, "area": 44335.0, "iscrowd": 0, "image_id": 19402, "bbox": [0.0, 0.0, 640.0, 400.0], "category_id": 173, "id": 20001230}, {"segmentation": {"counts": "k31b8`2kNR5^Lb3O1O1O1O100O1O1O1O1O100O1O1O1O1O100O1O1O1O1O100O1O1O1O1O1O100O1O1O1O1O100O1O1O1O1O100O1O1O100O10000O10000O100O10000O10000O10000O100O10000O10000O10000O100O10000O10000O10000O10000O100O10000O10000O10000O100O10000O10000O10000O100O10000O10000O10000O100O10000O10000O100001O00001O001O001O001O001O001O001O001O001O00001O001O001O001O001O001O010O001O00001O001O001O001O001O001O001O001O00001O001O001O001O001O001O001O001O001O00001O001O001O001O001O001O001O001O001O1O001O1O1O1O1O001O1O1O1O1O001O1O1O1O001O1O1O1O1O001O1O1O1O1O001O1O1O00N2M3N2N2N2M3N2N2M3N2N2N2M3N2N2N2M3N2N2N2M3N2N2M3N2N2N2N2M3N2N2N2N2M3N2N2N2M3N2N2N2N2M3N2N2N2M3N2N2N2N2M3N2N2000000000000000000000000000000O10000000000000O1000000O1000000O1000000O1000000O1000000O1000000O100002N000000000000TIIoN7R1ImN7U1IiN7X1IgN7Z1JdN6^1J`N6a1J^N6d1JZN6g1JXN5j1LTN4n1LPN4Q2LnM4T2LjM4W2LfLNlK6_7MbLMPL6`7M\\LMVL6_7MXLNZL5_7NTLM^L5`7NnKMdL5_7NkKMgL5`7NeKNlL4`7b0mJ[OdM3`78TKD^M4`7JeH7m0LoN3W94`GJZO2Z98SGEE3]904@?S:oN]F>02D?o9QO]F=12E`0l9QO^F=12E`0l9RO]F<2NJc0g9TO\\F;3LLe0e9TO[F<4JMf0d9TO[F<4JMe0e9UOZFNCH00b0>Mg0d9UOZFLMJ7>Ne0f9WO]FFa0>\\Oe0\\OmNX:;hG3cNh0e9VOgG2cN=C[OR:7gG1cN7^;IcDFJ08a0[;IcDEd0b0i:IcDEd0b0i:ImEFd::Q200000000000QBEY=;gBFX=:hBGW=9iBI_OLa=;PC0_OH0MR=;_C=a```a03dBAnNMP=c0SD\\OR0iADj=001O1O001O1PF@^5?_JEa5;\\JHd57YJLh53UJ1k5NSJ5m5KoI9Q6FlI>T6BiIa0W6_OfId0Z6\\OhIb0X6^OjI`0V6@lI>T6BnIa0WB^O\\=b0dB^O\\=b0a0O10000000000000000O1000000000hB@P<`0PD@P<`0PD@P<`0PD@P<`0PD@PTDBl;>TDCk;>TDBl;>TDBl;>UDAk;?UDCi;=WDEg1Mm6>\\GI_1MU7:\\GI[11Y76SG5^1H_73jF5P2HV73bFNg2Og64XF1V3Kb6j0`IVO`6g0cIYO]6=YFXO[3;\\6ZVJIWLGc9a0c4001O1O1O0RF^O^5c0]JAc5f0QJ_Oo5j0gIWOY6R1aFaNa2=n6^1RIbNn6^1RIbNn6Z1VIfNj6S1]ImNc6m0cISOkLCY9T1RJBn58XJHh55[JKe51_JOa5NbJ2^5McJ3]5LdJ4\\5KeJ5[5KeJ6Z5IgJ7Y5HhJ7Y5HhJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ:V5FjJ8X5HhJ8X5HhJ8X5HhJ8X5HhJ8X5HhJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ9W5GiJ:V5FlJ7U5InJ5Q5KRK2n4OTKNl42XKKg45VKMk43lJ6T5JeJ>Z5BbJa0_5_O`JM[LNU95fJA[L:o85dJC]L9n84eJC^L8m85fJB]L8n87WKIi48_K_Oa4b0eGFnNIjVDBj;>VDBj;>VDBj;=WDCi;=WDCi;=WDCi;=WDCi;=WDCi;]DCc;?YDBh;`0SDAo;b0jC]O[<]1UDhN\\:Q1jEPOV:h0PFZOP:?oETO^N`0c;7SFOm9OUF1k9MWF3i9KYF5g9I[F7e9H\\F8d9H\\F8d9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I[F7e9I\\F6d9J\\F6d9J\\F6d9J\\F6d9J\\F6d9J\\F6d9K[F5e9K[F5e9KZF6f9JYF7g9IYF7g9IYF7g9IYF7g9IYFOo91QFHV:8Y200000000000000000000001O00003M2kE[OmK1h9g0XJZOoKNi9k0XF[Ob3NX6h0RJWOo5?[JAe5>\\JAe5?[JAe5?[J_Og5a0YJ^Oh5b0XJ^Oh5b0[40000000000000WF_OS5a0lJ@T5`0lJ@T5`0kJAU5>lJBT5>jJDV533I[97SFM?32J\\9", "size": [480, 640]}, "area": 19711.0, "iscrowd": 0, "image_id": 19432, "bbox": [0.0, 0.0, 640.0, 178.0], "category_id": 123, "id": 20001232}, {"segmentation": {"counts": "[6e8[6000000000000000000000000000001O0000O10000001OO1N21O00000000002N0000000000000000000000000000O100N2O1N2M300000PNnIRKR6k4RJTKn5h4XJVKh5g4\\JXKd5e4`JZK`5c4dJ\\K`5]4eJaK`5W4dJhKb5o3bJPLd5g3`JXLe5`3^J`Lg5X3\\JhLi5P3ZJPMj5j2XJVMm5b2WJ]Mn5[2UJeMm5V2VJjMl5Q2WJoMk5l1XJTNj5g1YJYNi5b1ZJ^Ni5]1YJcNi5X1ZJhNh5S1[JmNg5n0\\JROf5i0]JWOe5d0^J\\Oe5>^JBd59_JGc55_JKc50`J0b5KbJ4`5GcJ9_5BdJ>_5\\OdJd0b5SOaJm0i5gNYJY1g900000000000000000001O00B`N\\C`1cfLi0`0j0^5\\NSJGR3l1]M1]5lNoLX1cML^5nNiL[1hMG_5QOcL[1nMD_5SO]L^1SN_O`5VOWL_1YNZO_5ZORL`1_NVO_5]OlKa1dNRO`5_OhKb1gNoNa5AcKc1lNlNa5AaKf1mNiNb5A_Ki1nNfNc5AXJaNg0[3^OcNe5@SJiNc0W3D`Nh5^OPJPO=V3J\\Nj5]OnIWO7R30[Nm59lI_16XNP6W4oIiKS6U4mIkKU6T4jIlKW6T4gImKZ6R4fInKZ6S4eImK[6S4eImK[6T4dIlK\\6T4cImK]6T4bIlK^6[6000000000000001O3M3M3M3M0000000000O100000000000000O1000000000000O1000000N2000000000000N2O1NeG_I[8a6eG_I[8a6200O1O100000000000000001O001O001O1O000000NeG_I[8a6eG_I[8a6eG_I[8a620000001O000000N21O00O100000000001O1O1O0000001O1fG[IW8g601O000000001O00KkG^IV8a6lG_IS8a6mG]IU8c6kG]IU8a6iG_I[8a62000000000000O100000000O1001O001O000000O1NbGbI^8^62O1N2N2N20000O1001O00O11O1O2N1O1fIjIh3Z6QLlIl3U6QLnIn3R6QLPJn3P6RLPJn3P6QLQJo3P6PLPJP4Q6nKPJR4P6nKPJR4P6nKQJQ4o5oKQJQ4o5oKPJR4P6nKPJR4P6nKPJR4P6nKoIS4Q6nKnIR4R6nKnIR4Q6PLnIP4R6PLmIQ4S6PLlIP4T6RLiIo3X6RLeIo3[6SLaIo3^6Z20000001OO100000000000000000000001O00O1001O00O100000000000000001OO10000000000001O0000001OO100000000001O001O0000001O1O0000001O1O001O00001O1O0000001O1O001O0000001O1O0000001OAUHjIj7W6UHiIk7X6UHhIj7W6XHhIh7X6XHhIh7X6XHiIg7W6YHjIf7W6ZHhIf7W6\\HhId7Y6[HgIe7Y6[HhId7X6]HhIb7X6^HhIb7W6`HiI_7X6aHgIOIT7`6mHgINKT7]6oHhILMT7[6PIiIJNU7Y6RIVJn6j5RIVJn6j5SIUJm6o600000O1O1O100N2O100O100001O001O0000001O1O0000001OBhHUIW7k6iHUIW7k6jHUIU7k6lHTIT7l6lHTIT7l6lHUIS7k6mHVIR7j6oHUIQ7k6PITIP7l6PITIP7l6PIUIo6_7O00001O00001O1O0000001O1O001O00001O1O0000001O1O00001O00001OBZIcHe6]7[IcHe6]7\\IbHd6^7\\IbHd6^7\\IcHc6]7^IcHa6n701O00001O1O0000001O1O00001O001O001O0000001O1O001O00001O1O0000001O1O00001O001O001O0000001O1O00001O001O001O00001O1O00001O001O001O0000001O1O0000RO\\J`Hd5P7jJRIV5n6eJWI[5i6dJXI\\5h6_J\\Ib5d6[JUHOW1g5n72K5N2L4N2K5O1K5N2L4`NYIYI0Z1i6g64UNYIkILX1P7l4XIUKi6k4SITKR7l4lHTKV7W64N2L4N2K5N2L4KoGXIT8g63K5O1LfGcIY8]6dGiIY8_601O1O000000000000000000", "size": [480, 640]}, "area": 146721.0, "iscrowd": 0, "image_id": 19432, "bbox": [0.0, 192.0, 640.0, 288.0], "category_id": 145, "id": 20001233}, {"segmentation": {"counts": "g4d1\\=000001O00000000O100N20[NgBc1[=01O00N3N12N1N101O0aNmBQ1c=O0N1N30O00000000002M1O1O1N2L40000000000O11O00000O010N100O2M30003M7I7I5K6J6J[ZP15\\eoN7J6K4N3M3L4M3M3M3M3M2N^OcBDZ==iBBT=>oB_OQ=b0VCUOk8O1O1O1N1O2N2N2N2N2O0O2N2O1N2N2N2O0O2N2N2N2N2N2N2O2M2N1O00000001O000N5L1N_BeN`=\\1`BdN^=^111N1O101UOiNlCEG]1Y^=BbB>^=CbB<^=DbB<^=EaB;_=EaB;_=EbB:^=GbB8^=HbB8^=IaB7_=IaB7_=JaB5V>0O01N10010O1N1000001O1O001O0001OO2O1O0000BLPB4Q>LoA3Q>MPB3o=MQB3o=NQB1o=0PB0P>0PB1n=0SBNo=1RBNm=4RBLo=4PBLP>4PBLP>4>1O01OVjS3MXgkLO[>;0000N200MCcA=\\>DdA<[>EeA;[>EdA<\\>DdA<\\>DdA<\\>DdA8`>12M4N2LaBNjN0Y=0mC2gN4`>8N3K5M2K5N2L4K5O1K5O1K5mJ", "size": [480, 640]}, "area": 11606.0, "iscrowd": 0, "image_id": 19432, "bbox": [0.0, 126.0, 640.0, 92.0], "category_id": 172, "id": 20001234}, {"segmentation": {"counts": "nmi04n7MjN?l0EnNg0g0_OoMFkKT1n5ZOTNBkK_1h5SOYN@kKh1c5lN_N\\OkKS2]5fNdNXOkK\\2Y5`N`NAPLZ2W5YN`NIPLY2W5RNhNU3P1nLoNX3i0kLVO[3b0hL]O]3=eLBa36bLId3O_L0d3K_L4d3G_L9c3B`LKQNUMb5k2`LJSN[M`5f2`LHWNaM]5b2^LF\\NgMY5^2_LD]NnMW5Y2_LD^NSNV5T2_LG[NVNY5n1_LJYNXN[5i1_LMVN[N_5b1^L2SN[Nc5^1]L6QNZNf5\\1[L:nMZNj5W1[L>lMYNm5T1ZLc0hMXNR6P1YLg0fMXNT6l0YLl0cMVNY6h0WLR1_MUNb6`0RL[1\\MTNm65iKf1ZMUNm:k1REUNo:k1QESNQ;m1oDRNS;n1kDRNV;n1n00000000000000BSNiCm1W[GS2S1]Mb7`0[GT2S1ZMc7b0ZGT2U1XMa7d0ZGT2W1VM_7f0ZGT2Y1TM]7i0YGS2\\1RM[7k0YGS2_1oLX7n0YGS2a1mLU7Q1ZGR2d1iLS7U1YGR2^:nMbER2^:nMbER2^:nMbES2]:mMcES2]:mMcES2]:mMcES2]:mMdES2[:nMdEU2X:lMhES2Y:mMgEQ2[:oMeEP2\\:PNdEn1^:RNcEl1^:TNbEj1`:VN`ES1OYNb:d0`Ej0=YNBJ[:T1fEHb1^Og8j0gEGZ1Io8?hEGQ13V96iEEj0`0[9KlEZOk0P1\\9FjEQOi0_1`9AfEiNi0j1e9]OZFi0i9ROTFR1P:fNoEb1R:UNnET2R:cMSFa2V;00000000000000000001O00000000000O10000000000000000000000000000000000000000000000000VD\\MX;d2bDbM^;^2\\DhMd;j200001O0O2E:]OQDTNQB=G:eLXDj2o;000L4I7J6J6J6M3L4M3O1O1O100O1O1O1000000000000000000000000000000000000000000000TMYE_1g:aNYE_1g:]10000000UMYE`1d:a1M3N2M4LH8G9G9G9G9G9G9GVDnMX;i1gDkNP;k0oDHi:DPEmN5T2b:eNgEn1P:iMQFf2h9PMbFP3^9gLkFY3^:0DmLkDS3j:YMUEg2[:iMeEW2V:nMjER2V:nMjER2V:nMjER2U:oMkEQ2U:oMkEQ2U:oMkEQ2U:oMkEQ2U:oMkEQ2T:PNlEP2T:PNlEP2T:PNlEP2T:PNlEP2T:PNlEP2T:PNlEP2T:PNlEP2T:PNlEP2T:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:QNkEo1U:^100000000000000000mNT1_N`1XOh001O00001O001O01OM5L5J6_O^BGR>6J7H7J6L5N2N2N2N2O1001O0000000000000000000000000000000000000000010O000000000000000000dEiNo6W1hHROX7n0^H\\Ob7d0THFl7:jG0V80aG9_8HVGb0j8_OkFk0U9UObFn0d9SOQFQ1U:oNaEY1a:c11O001O3fL]EQ2e:dMdE\\2_:XM`ER3m::F:F:O10000000000000001O0000000000000O1000000000000000000000000000000000002N4L4L3M1O1O001OI7G9H8G9H8G9H8G:gNiC_Oc1N100O100O10L3L5L3M4L3M4K4M4L3Mo_g0", "size": [375, 500]}, "area": 10525.0, "iscrowd": 0, "image_id": 19786, "bbox": [0.0, 266.0, 435.0, 109.0], "category_id": 118, "id": 20001241}, {"segmentation": {"counts": "e2g0`0g3b5YL^Jh3`5YL`Jg3`5YL`Jh3_5XLaJh3_5XLaJh3_5XLaJi3]5XLcJh3]5XLcJh3]5XLcJh3]5XLcJi3\\5WLdJOFl25]LT5h0RK]OC1ML8b31\\LU5g0`KZOAc3H]L1Om4d0\\Lg3b3RLfLn3Z3hKoLY4W51N2L31O101N1O2N101dKiHR4a7]O\\HnLi7j2[HVMf7f2]HYMf7d2[HTMR8g2nGUMU8j2`0MN4NVMVGg2m81N10000O2M2N2O2N1N2N3M2O1O12N0O3M101O1O1O002N2O0N11N1O11O2N1UMZGc2o80O01O2MOaMTGU2_9H8H5K4L4L4K6K4L4L4L4K5MSECc:f04L5J5M0O01O0001O000001O00MeDJ[;37MnUV22jiiM1iD1S;1lDOR;3kD0V;9O000000010O000001O00017M4L4Kc`[1L\\_dN2O1M200011N01O001O00001O010O05I]D0odc0", "size": [375, 500]}, "area": 9589.0, "iscrowd": 0, "image_id": 19786, "bbox": [0.0, 82.0, 447.0, 218.0], "category_id": 123, "id": 20001242}, {"segmentation": {"counts": "VeY1:\\;2N1O1O1NEkD8T;HnD8P;HQE8n:HSE8l:HVE7h:JYE6f:J\\E4d:L]E2d:N]E0d:0^ELc:5?0000000O100000000O100000000O1aFI_77`HK_75aHL^74cHMDa0_5AnJNCR1n4oN`K3^O`1`4\\NSL4]OQ2P4iMeL5QOHUOj2e4ZMTM3SOJSOZ3U4iLeM3ROOPOd4j2ZKeNMjN6g01UOR6n0jI82mN1g047Y6M\\IjN<:Lg03j0IVNg5U1cJTOKe03n0FjNS5?[KQOKg01n0HAh6_O`IP1I6S6gNUJS1Il0`5lMgJY1Ha1n4RM[K]1HW2Z1hLd0]O[Nd1Hl2c0eLl0fNjNi1H_3NRLV2?mM_3MQLV2a0lM_3NoKV2b0eMg35fKV2\\6iMoI<`N`0JTOh70mI;dN8n7]O]I:h7FWH:k2B>4fL:n2C94iL8Q3B66hL7o7IPH7Q8InG6T8JkG6V8IjG6X8JgG6Z8JdG7]8IbG7^8J`G6b8J]G6d8J[G5g8KYG4h8LWG4j8LUG4l8LSG4n8KSG4n8LQG4o8MPG2R9NnF1S9OmFOU91jFOW91hFNZ92eFM]93aFN`92WF6j9IVF7j9JUF6l9JTF5m9KRF5o9KPF5Q:KnE6R:JmE8R:HmE;Q:EoE7BG\\:3QF4X:KhE5Y:KfE5[:KdE5]:KbE6^:JbE4_:M^E3a::63M3M2D=QYV3", "size": [375, 500]}, "area": 4520.0, "iscrowd": 0, "image_id": 19786, "bbox": [113.0, 0.0, 107.0, 375.0], "category_id": 132, "id": 20001243}, {"segmentation": {"counts": "gTR32e;3N3L3N4K01O001O02O001N01N101N1O101N1O2O0O2O000O2O1N10_Zi02kdVOd0O200000O10O1O010H]OZEd0[:a0O2O1O001O10O01O1O010O1O001O100O001O1N1O2N2N101N1O2N101N1O2N1\\OXNXGj1g8WNWGj1i8WNVGi1j8c0N101O001O00001O0010O100O100O1O01N1O2N10O\\GPMb8P330@RMVHm2l7WMoGj2Q8YMlGg2T8`0N00000000000000YOmGkMR8U2VHcMj7]2^H`M^OG00k7i2oH\\MQ7d2Q1000000O100hMWGb1i8^NYG`1g8`N[G^1e8aN^G]1b8cN`G[1`8eNbGY1^8gNeGV1[8iNhGU1X8mNhGQ1X8POhGn0Y8UOdGk0\\8XOaGh0_8YO`Gg0`8ZO`Ge0`8\\O`Gc0`8]OaGb0_8^ObGa0^8_OcG>_8BaG;b8E^G1l8OTGNo8OTGOn8IZG6g8G\\G:c8E^G;b8E^G;b8E^Ga8B_Gc0\\8^OdGb0[8^OfGa0Z8^OhGa0X8_OiG?X8AkG:W8EoG5S8IQH3Q8KXHLVa3", "size": [375, 500]}, "area": 8882.0, "iscrowd": 0, "image_id": 19786, "bbox": [268.0, 0.0, 223.0, 123.0], "category_id": 172, "id": 20001244}, {"segmentation": {"counts": "YVj07Y;?H8H5K4L4L4L5K4L4L4L4L4L5K4L5K4L001N1N2N2]LSM[Nn2e1TMWNn2i1UMSNm2l1VMPNk2P2XMlMi2V2WMgMj2Z2XMbMi2`2XM]Mh2d2ZMXMh2g2[MUMf2j2]MSMd2m2_MoLb2P3bMlL_2T3dMgL^2X3fMaL_2^3dM\\L_2c3fMUL^2k3fMnK]2R4gMgK\\2X4b20O001O001N10PK`Ik4_6UKbIj4^6VKdIi4[6WKfIi4X6XKjIf4V6ZKkIf4T6ZKmIe4S6[KnIe4Q6[KQJc4n5^KSJb4l5^KUJa4k5_KVJa4i5_KXJa4g5_KZJ`4e5aK]J^4b5bK_J]4a5cK`J]4_5cKbJ\\4^5dKcJ\\4[5eKfJZ4Z5fKhJY4W5gKjJX4V5hKkJX4T5hKmJX4Q5iKPKV4P5jKQKV4n4jKTKU4k4kKVKU4j4jKWKU4j4jKWKV4i4iKXK_4`4`KaKQ5n3nJTLa5\\3`JcL]6`2cI`MT8i0lGWOe9XO[Fh0[:ORJlNY1U1fNA^6f0ZOe0[Of0YOf0[Of0XIhLd3m3fKdLj3o3bKQL_4o3aKPL_4Q4aKoKW4Y4iKfKl3f4SLZKc3Q5]LnJX3^5hLaJn2j0mLk25ZLc2X1ZMZ24^LW2d1eMm14^LW2h1cMj16]LW2e6iMZIW2g6iMXIW2i6iMVIW2k6hMVIW2k6iMTIW2m6iMRIW2n6jMQIV2P7jMoHV2R7jMmHU2U7kMjHU2W7kMiHT2X7lMgHT2\\2iM`13SLT2]2PNZ1LXLT2e2PNm0K^LU2o2mMfNVMdIm2]6VM\\Im2e6WMSIl2^7>^3bL0000000000000000000000000000000000000000000000000000000000000000hGMl43nJ5P5KRK5l4KVK5h4KZK5d4K]K6a4JaK5^4KdK5Z4K^I0n04c5L]I:j0Ih5M]I8P1Jb5N\\I7W1J\\5O\\I5]1LU5O\\I4b1NQ5OZI2i1Ol43VILR21g46RIIZ21c4:nHEa22_4TK2l3_Oo0?XK1h3@n0`0\\KOf3Al0a0`KNc3Bk0`0eKUOC?n3Ki0`0iKSOBc0k3Jj0?QLGU3Jj0>RLIS3Ik0?QLHU3Hk0`0nKJV3Ii0>PLI_3FR2DmM=R2EmM;R2FnM:P2InM8Q2IoM7o1LPN4o1MPN4o1NPN2n10RN0m12QNOn12RNNn13QNMn14QNMo14PNLP24oMMP25oMKQ25oMKP27nMJR26nMJR27mMIR29lMHT28lMHS2:lMFT2:kMGU2:jMFU2;kMEU2hMBX2>gMCX2?gMAY2?gMAY2`0eMAZ2`0fM@Z2a0eM_OZ2b0eM_O[2b0dM^O\\2b0dM^O[2d0cM]O]2c0cM]O\\2e0cM[O]2e0bM\\O^2e0aM[O^2f0aM[O_2f0`MZO_2g0aMYO_2h0_MYOa2g0_MYO`2i0_MWOa2i0^MXOa2j0^MVOb2j0^MVOa2l0]MUOc2k0]MUOc2l0\\MTOc2m0\\MTOd2m0[MSOd2n0[MSOe2n0ZMROf2n0ZMROe2P1YMQOg2o0YMQOf2Q1YMoNg2R1WMoNi2Q1WMoNh2S1WMmNh2T1WMmNe2X1ZMhNc2[1]MeN`2_1^MbN^2b1bM^N\\2e1bM\\N]2e1cM[N\\2g1cMYN\\2h1cMYN\\2i1cMWN\\2j1dMVN[2b7O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1N2O1O1O1O100000000O100000000000000000000000000O100000000000000000000000000O100000000000000000000000000O100000000000000000000000000O1000000001O00001O001O00001O00001O001O00001O00001O001O00001O001O00001O00001O001O00001O00001O1O2N2N2N2N2N2N2N2N2N2N2N2N2N2N2N2N1O0000001O0000001O000000001O000000001O0000001O000000001O000000001O0000001O000000001O0SH`Mf2`2YMjM^2V2aMTNV2m1iM\\Nn1d1QNfNf1Z1YNPO^1P1aNYOW1g0hNZOX1g0fN[OY1e0gN[OY1e0fN]OY1c0fN^OZ1b0eN@Z1a0dN@\\1`0cNB\\1>dNB\\1>cND\\1=bND^1R2ClM>T2CjM?U2BiM?W2BgM`0X2AgM?Y2AfMa0Y2@eMa0[2@cMb0\\2_ObMd0\\2]OcMf0Z2[OdMi0Y2XOeMl0X2TOgMo0W2ROgMR1V2oNhMT1V2mNiMV1T2kNjMY1S2hNkM\\1R2dNmM`1P2aNlMe1Q2\\NjMk1S2VNiMo1U2RNfMU2W2lMdM[2Y2eMcMb2Z2_MaMh2\\2YM_Mm2_2TM\\MS3a2nL[MX3b2iLYM^3d2cLWMc3g2]LUMj3h2WLSMP4j2QLQMV4l2\\4M2N3EVCaM02mgMCY2>fMBY2?gMAY2`0eMA[2?eMAZ2a0eM_O[2a0dM@[2b0dM^O\\2b0cM_O]2b0bM^O]2c0cM]O]2d0aM]O^2d0bM\\O^2e0aM[O_2e0`M\\O_2f0`MZO`2f0`MZO_2h0_MYOa2g0_MYOa2h0^MXOa2i0^MXOb2i0]MWOb2j0^MVOb2k0\\MVOd2j0\\MVOc2l0[MUOe2k0[MUOd2m0[MSOe2n0YMSOg2m0YMSOf2o0YMQOg2o0XMROg2P1XMPOh2P1XMPOg2R1WMoNi2Q1WMoNi2R1VMnNi2S1VMnNj2S1UMmNj2T1UMmNk2T1TMlNl2T1TMlNk2V1SMkNm2U1SMkNl2W1SMiNm2W1RMjNn2W1QMiNn2X1RMhNm2Z1QMgNk2]1UMbNi2b1VM^Ng2e1XM\\Nd2i1[MWNc2k1\\MVNc2l1\\MTNc2m1]MSNb2o1\\MRNc2o1]MQNb2Q2]MoMb2R2]MoMb2b7O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1O1N2O1O1O1O100000000O10000000000000000kNfAP1Z>nNhAR1]>000000O100000000000000000001O00000O100000000000000000000000000O1000000000001O0000000000000O10000000I8O00001O001O00001O0O101O001O00001O00001O001O00001O001O00001O00001O001O00001O00001O1O2N2N2N2N2N2N2N2N2N2N2N2N2N2N2N2N1O0000001O0000001O000000001O000000001O0000001O000000001O000000001O0000001O000000001ZHSMc2m2\\M]M[2c2dMgMS2Y2lMQNk1P2TNXNd1h1[NbN\\1^1cNlNT1T1kNROP1n0oNSOQ1n0mNTOR1l0nNTOR1l0mNVOR1j0mNWOS1i0lNYOS1h0kNYOU1g0jN[OU1e0kN[OU1e0jN]OU1d0iN]OW1c0hN_OW1a0hN@X1`0gNBX1>hNBX1?fNCY1=fNDZ1B5K001O00TOZLSHf3d7oLQHP3R8YMbGg2b8o0k0UO001O1O1OeN_LXH0N`3`7kMVHU2k7e11O1O1O001O2N3Mb0^O3M3M2N3M2N3M3M2N1O001O001O001O]OfLUGZ3h8f0M3M3M3M3N2O1O1O1D<00O10`KWH^3h7`L\\H_3d7]LaHb3_7ZLfHe3Y7XLlHg3T7VLPIi3o6RLWIn3i7mK\\GS4`8SL^Gm3_8XL^Gi3^8d0M3L4M3N2N2N2N2N2;E3M2N2N2N2N2N1O2N1OoM^K^I0g1`4k4aK[I4h1Z4m4bK[I6h1V4n4cKYI:h1R4o4dKYI=f1n3Q5VLkJl3U5VLfJm3Z5VLaJl3_5ULRJ\\O^Oa4`6TLmIC]O[4e6SLjI_4V6aKeId4[6\\KaIh4`6WK_Ij4a6UK_Il4a6TK^Im4b6SK\\Io4d6QK[IP5e6PKZIQ5f6oJYIR5g6i01O003M00M3000000O1O1001O1O0000L_I\\I01`6c6bI]I^6c6bI]I^6c65000000000000001OO10000000000000[I\\Ic6f6000O1O1001O0000000000O1001O000000002N00O10000002NN21O0000O11O000000000000O11OO10000O100001O0000O1O1N21O000000M3000000001O1O0000O100000000000000000000000000000000000000O11O000QKaIR3_6SL^Jk3b5RLcJl3]5QLiJl3W5\\KaI`0^1R4U5hKSKV4S7N2N1O1O1O001O001O1O2N1OQOUL^Hk3`7ZL]Hf3a7_L\\Ha3a7eLTHc3k7o0O1O1O1N2O1O1O1O1N2O1O11O1O1O001O0000000000001O0000000000000000001O000000000000000000001O000000000000000jK]Hd2d7PMhHo2X7gLQIZ3o6_LXIa3h6]LYId3g6YL\\Ig3d6VL^Ik3b6SL`Im3`6PLbIQ4l70O100O1O100L4H8I7I7M3N2O10000000000003M;E4L4L3M1O1O2N1O1O001O00gNcLeH\\3[7fLdHY3[7jLdHU3\\7nLbHQ3^7QM`Ho2`7SM_Hl2`7XMYHl2g7\\10000O1N21O1O1OcNbJnJ]5Q5dJPK[5P5eJRKY5m4hJTKW5l4iJeIN_1V5l4oJhIKY1S5o4RKgIL]1o4l4VKeILa1l4j4]KfID`1l4j4dKXKY4h4gK[KV4e4kK]KR4d4nK]KP4b4RL`Kk3`4ULcKh3]4YLdKe3\\4\\LdKc3\\4^LfK_3Z4bLfK]3Z4cLgK\\3Y4eLgKZ3Y4gLgKX3Z4hLeKX3\\4hLbKY3^4gLaKZ3^4hLaKX3_4iL_KX3a4iL]KX3c4hL]KX3b4jL\\KW3d4iL[KX3f4hLYKX3g4hLXKY3h4hLfJi3Z5WL_JP4`5RLYJT4g5h11O0000002N0000000000000000O100001OO1O100001O001OO100000000001O00001OO11O0000O11O0000O1001OO12N00O1001OO100O10000000000000000001O00O1001O00O11O1OO11O0000000000001O0000000000O100O1O1000000KUIjIk6V6UIgI01k6X6UIgIn6Y6RIgIn6Y6200001O00N22N00000000O11O00O1001O1O2N1O0000O1001O0000N21OO1001OO10000", "size": [427, 640]}, "area": 121041.0, "iscrowd": 0, "image_id": 20059, "bbox": [0.0, 201.0, 640.0, 226.0], "category_id": 124, "id": 20001250}, {"segmentation": {"counts": "0i3b900O10000001O000000O1001O0000ORKZL9f3CYLaK3m6BUI;l6HUI5j6KXI2i6NWI2i6NYI0g60XI1h6NXIlNkNC03m7^1WIlNoNZONI3c0i7_1VIeNmNZO724>c7`1UIdN[O]ON?a7`1ZI]NMNk6g1UI\\N5Gg6m1VIZN4Ei6R2QIZN]8d1cG^N]8e1aGYN`8g1^G\\Na8d1_G\\Na8b1aG^N_8a1cG]N^8f1]G\\Nc8c1_G\\Na8d1_G\\Na8e1]G\\Nc8c1cFoMb0=k8e1_FoMi0:i8n1VGRNk8n1TGUNj8j1WGTNk8R2nFoMR9Q2mFPNS9P2lFRNS9n1lFSNT9n1kFRNU9R2gFnMY9Q2hFQNV9o1gFSNZ9R2^FRNa9n2NN2O11OO100O1N21O001ON]F\\Lc9d320[F\\Lc9d3]F\\Lc9d3]F\\Lc9f30O10000O100O1O1001O001OO1O1O10000003M000[F\\Lc9f303M00001O00001O00O1001OO10000O100O100O100003MM3O1001OO10000001OO1000000O1000000000000000000000\\F\\La9f31O100002N2N0000O1001OO12N00O1O100O1000000O1O1M300001OO100O100O100001O1O2N002N1O2N00O1001O00O11OO10000000000M3O10000001O00O11O00001OO1O11OO100001O1OO11O001O00O1N21O001OO100O12N002NO1002NN2000000000000O100001OO10000N^F[Lb9e3200O1000000O11O001O1O1O1O1O1O1OO10000O100000jH\\Le4d3[K`LfMHh6h3aKeL^4[3aKfL_4Z3aKfL_4Z3nJYLjNh6\\3gIeL1FELOa0d6W3gIfL21@2g6[3bIaL0BF01Y1g6g2^IaLLS1f6m4000000000000000^OXIaJh6^5_IUJI2h6h5cISJE5h6h5hIUJX6g5h000^NeHfL2XOY7c3aHcLf0OGFR7d3oI]LaNOQ8d3d100000000000000000000000000000fF\\Lm8W4J0000000000000000000000000000000000000000000000000000000000000000O1@`0000000000000000000000000000000000000000000000000000000000000000000`0@00000000001O0000000000000000000000000000000000000000000000001O0000O100000000001O0000O1001O00O1001O00O1001OO100000000001O00O11OO11O001O2N001O1OO11O001ONUGdKk8[4VGeKj8\\4UGdKk8\\42001OO1O1O1N2O100000000000000000000000000O1001O00O1000000O10000000000O100O1K5M3K5N200O100O14L1OO11OO11O0000O100000000O1000000O1001OO1001OO1O11O000000O11O00O1O1O1001O001O0000O100001O1O1O001OO1O11O1O000000O100O1001O1O00000000000000000000001O1O1O0000001OO11O00000000O11O0000", "size": [427, 640]}, "area": 81246.0, "iscrowd": 0, "image_id": 20059, "bbox": [0.0, 0.0, 640.0, 294.0], "category_id": 169, "id": 20001251}, {"segmentation": {"counts": "i3Z3Q:O010000010N1O11O0O1001O0N2O0O2M2O22NN3OO01O2OO1000000000O101]OfESNY:i1nEUNR:i1RFUNo9i1RFTNQ:k1QFoMR:c1cE]NW;d180001ON21O00O100001oN]D8d;G^D]OOe0b;NhDOY;OiDOP1Dd8;^F1MCC:5CK8T:HmE0O3b08N:AI\\:BWF2JNC^1c;eN\\D\\1f;3O1000000O11OO10001OOjN\\NRF03d1j9_NjENI3c0`1d9\\NjE724>[1b9hNoEN?Y1_9_O\\Fc0d9BVF?j9BRFa0n9Y1PFoLP:Q3PFoLo9R3RFmLo9R3QFnLo9S3QFlLo9T3QFmLm9T3TFkLl9U3TFkLl9U3500000O1O12MO200001O0000002NO11O2NN2O20OO100O1N210OO2ONiLPFW3P:K7nLiEo2X:QMhEn2Y:RMgEm2\\:O001O1O001O00001O2N1O2OO1O0010O10003M000^MYE`2i:03M00001O00001O00O1001OO10000O100O100O100003MM3O1001OO10000001OO1000000O1000000000001O00000000^MZE`2g:1O100011N2N01O2M3N2O1M300N2M3MLhEXMW:h2jEUMW:l2iETMW:m2hERMY:n2gERMY:n211O1M3000O2OO101N100O100001O1O2OO021NO2K30O1001N1O0110N2O0000LeEVM01Z:i2hEWMX:i2hEWMU:l2410000001O00O110OO101OO1O11OO100eERMY:P31O1N002O010O00O1N21O0O2OO2O0O12N0020M10O3NN20002NN21O000O011O01OO10000NQMhEo2X:111N010000O011O010O1O1N2N2M300OO1000M2100000DbEkM^:U2fEfM[:Y2LTAP1Z>9M2N2O1N2_IbNkN_1U1_N_H1Z6a1Z1_NdNb1R1^NmH2n5a1R1kNnNV1P1lNPOT1m0oNSOQ1k0QOUOo0h0TOXOl0e0WOZOj0", "size": [500, 333]}, "area": 956.0, "iscrowd": 0, "image_id": 20107, "bbox": [311.0, 219.0, 22.0, 281.0], "category_id": 111, "id": 20001254}, {"segmentation": {"counts": "i9k5i90O1000000000000000000O1O100O100O10000000000O10000O100O1O1N2000000O10000001OO100000000000000001O001O4L1O4L1ON21O1O001OO1O100001O0000N21O0000000000OdJ[Fk4d9UK_Fi4b9UKbFh4_9VKgFe4Z9YKgFg4Z9PKWF0e0P5l91000000000000O10000004L5K2N1O1O00001O00000000005K3M3M1O000000001O0000003M7I2N1O00001O000000001O3M2N2N1O2N1OO1001O00001O2N3M1O5K00000000000iNhCROX<1fDN`=01O001O1O001O001O1O001O001O1O001O001O1O001O0000001O0000001O1Fj@4ZgY2", "size": [500, 333]}, "area": 25139.0, "iscrowd": 0, "image_id": 20107, "bbox": [0.0, 301.0, 182.0, 199.0], "category_id": 118, "id": 20001255}, {"segmentation": {"counts": "0l1h=00O1ZO]B[Oc=d0^B[Oc=f0\\BZOd=f0\\BYOe=g0[B[OMC`=R1dBA[=8_BWO7a0Z=7mBKQ=5nB_OGMZ=d0oB]OI0W=b0QC^OH0W=a0RC^OI0U=b0RCXOO6oTO[Bc0`>00O1O1O10XH", "size": [500, 333]}, "area": 1130.0, "iscrowd": 0, "image_id": 20107, "bbox": [309.0, 231.0, 24.0, 101.0], "category_id": 132, "id": 20001257}, {"segmentation": {"counts": "Yk`031NT?2QA5l>NQA9d>NZA4b>`0M4M1101O00000003M4eAeNU>f1G0HZNbBf15ZNk<1QCe11`NjO00[OgNQCX1og0hAWOY>h0:O100000002N2M30OO4L01M2010N0010oN_OoB`0Q=FRBKb0`0[=L`B7`=J^B7W=_OaB;OA2e0_=_O]B?O_O4c0a=;_BDb=>ZBCg=T11N200O1O100N2000000O1O100N2O100O1O1O1O1O1O1N200O100O10000O1000000O1O1O1O1N2N2O1O1O100O1O100O1O1O1O1M300O10000O1O100O100O1N2O1Oa`W3", "size": [500, 333]}, "area": 4379.0, "iscrowd": 0, "image_id": 20107, "bbox": [0.0, 0.0, 121.0, 108.0], "category_id": 142, "id": 20001259}, {"segmentation": {"counts": "_Sl31c?001O0_@O^?4O1N2nMIkC1D8`Z1bE\\BFD>Q>KbB3_=IjB1W=Iajm0", "size": [500, 333]}, "area": 42646.0, "iscrowd": 0, "image_id": 20107, "bbox": [0.0, 0.0, 272.0, 313.0], "category_id": 173, "id": 20001261}, {"segmentation": {"counts": "Z[k16X?;F:EAA9oAZO[>g0hAkNc>T1`A_Nk>`1XASNR?m1RAeMY?[2U101O1O010OXO_MS@`2n?cMn_O]2R`0fMe_Oa2Z`0dMb_O[2]`0d0O20L3M4L4K5L3M4K6K5K4L3L4M5K3L4N2O1O1O1O1O3M2O2M3M3M201N2N3N1N3M3N2M2N3M3N1N3M3NSW_11kh`N0X\\OOac0:c\\OFH050kb0=S]O1ib0d0O1O1N2O1N2O1N2O1O1N2O1N2O1N2O1N2O1O1N2O1N2O1N2O1O1N2O1N2O1N2O1O1N2O1N21O1O1O1O1O1O1O1O1O1O1O001O000000000000000000000000O1000000000000000000000000000000000000000000000000O1O1O100O1O100O1O1O100O1O1O100O1O100O1O1O100O1O100O1N2O1O1O1N2RM^M]Dc2b;lMoCU2PW7]:mHcES7^:lHcES7_:lH`ET7a:lH^ET7d:kH[EU7f:lHWEU7i:mHTET7l:PIoDQ7Q;o00000001O001O00001O000000001O", "size": [640, 427]}, "area": 52652.0, "iscrowd": 0, "image_id": 20333, "bbox": [0.0, 231.0, 427.0, 409.0], "category_id": 111, "id": 20001266}, {"segmentation": {"counts": "0Q9o:00000000000000000000000000000000a0_O000000000000000000000000000000000000000000000000000000001O0000000jEbFj9_9SFdFl9j9N0000001O0000001O00001O0000]OYFmFg9R9\\FhFJIk9^9d01O1OQOcE[H]:e7mEQHS:o7oEoGQ:P8RFoGm9Q8TFoGk9P8WFnGj9R8VFmGk9S8UFlGl9T8UFjGl9V8UFiGk9X8TFhGl9X8UFgGk9Z8TFfGl9[8YF^Gh9_8\\F`Gd9`8n01OO10000O100O10000O100eMaD\\KNYOa;X5iDZKIZO_;Y5PEWKDWOc;`5nDUKDWO^;a5REUKc;h4aDUKa;i4bDVK^;g4fDWK[;f4iDYKW;e4lDZKT;c4PE\\KP;a4SE^Kn:`4UE_Kk:^4YEbKf:[4^EeKa:W4dEhK\\:U4hEiKY:T4kEjKV:S4nEmKQ:P4SFnKn9o3VFoKk9m3ZFQLg9l3]FRLd9l3_FRLb9n3^FQLc9n3X3O1O100O1O1O100O1O100O1O1O100O1O1O100O100O10000O10000O10000O10000O10000O10000O10000000000000000001O0000000000001O000000000000001O000000000000001O000000001O001O001O001O001O001O001O1O001O001O001O001O001O001O001O001O001O1O1O1O2N1O2N1O1O2N1O1O2N1O1O1O1O2N1O1O1O1O1O1[BeKc;]4YDkKa;V4VDTKoNj0jW7]:mHcES7^:lHcES7_:lH`ET7a:lH^ET7d:kH[EU7f:lHWEU7i:mHTET7l:PIoDQ7Q;o00000001O001O00001O000000001O", "size": [640, 427]}, "area": 101797.0, "iscrowd": 0, "image_id": 20333, "bbox": [0.0, 0.0, 427.0, 423.0], "category_id": 129, "id": 20001267}, {"segmentation": {"counts": "b_<3oc0O10T\\OOfc03W\\ON0Oec090000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000000000000000000000O10000000000000000000000000000000000000000000000000000000000000000O100000000000000000000000000000000000000000000O1O1N2O1N2O1O1N2O100OZOm\\Oa0Zc0Cf\\OH050L\\c02Rao3", "size": [640, 427]}, "area": 2586.0, "iscrowd": 0, "image_id": 20333, "bbox": [19.0, 612.0, 203.0, 28.0], "category_id": 132, "id": 20001268}, {"segmentation": {"counts": "]V17bb0X1B?M3N1N3M3M3M2N3M3M2N3M3N2M2O2M3N1N3N2M10000O100O100O10000O100O100O100O01000O100O100O10000O100O100ORMk_OS2U`0jMP@T2P`0iMT@V2k?kMW@S2i?PNV@n1i?VNV@h1j?[NU@c1j?aNT@^1l?eNS@Y1l?iNU@U1j?lNX@R1g?POY@o0f?RO\\@l0c?VO^@h0a?YO`@f0_?[Oa@e0]?^Ob@b0]?_Ob@b0]?@b@?^?_Oe@a0Z?^Og@c0X?\\Oj@d0U?ZOn@f0P?ZORAf0m>ZOSAg0l>Gg@9X?Ld@4[?Md@4[?Nd@2[?Oe@1b;kMPHU2]L1b;mMmGU2`LNb;PNbG\\2lLDb;SNTGd2YMZOb;UNhFT2fMVNOa1b;XN\\F]2aN[MAP2b;[NnEf2WOoNj:^NbEo2BdNk:`NVEX3NXNk:dNiD`3;lMl:[3REfLm:\\3REdLm:^3REbLm:`3QEaLo:_3QEaLn:a3QE_LR6hMZNk5bK^LQ6oMWNe5gK\\Lo5WNUN]5lK\\Lm5\\NSNY5oK\\Lk5_NTNV5QLZLi5dNUNR5RLZLg5gNRNS5WLVLd5kNPNZ4^LmJMo1b5mNoMZ4dLiJKP2`5POkM[4kLeJJP2]5TOiMZ4RMaJGR2[5WOgMZ4XM\\JFS2Y5ZOcM[4`MUJFV2T5^OaMZ4gMPJDY2Q5A_MY4nMjID\\2k4F^MW4TNeIE^2f4J[MW4hNPLj3MYMV4nNmKf31WMV4SOiKc35TMX4`NWI6\\2S49SMY4]NXI;W2Q4=TMX4ZNYI`0R2o3a0TMk2bNiK:k0n3c0TMh2kNgK1o0P4c0QMf2UOeKIR1P4e0oLc2_O`KDX1m3g0mL_2J\\K]O_1k3g0mL\\22XKXOe1i3h0jLZ2:UKUOi1f3j0hLW2a0SKkNT2k3c0gLU2h0QK_N_2Q4=gLP2n0\\N[2EeLm1T1]NV2HdLn1R1\\NY2IcLl1l0bNa2CaLn1l0_Nb2F_Lm1n0\\Nc2J]Lk1o0[Nc2M[Lj1Q1YNd2NYLl1Q1VNe21WL\\2c0bMU35VLZ2d0aMU37ULZ2e0_MV39RLZ2g0]MV3`I]6Q1VI`5;`I`6m0XIc56bIb6i0ZIe51eIe6d0\\Ig5MfIh6a0]Ii5IhIj6=_Il5DhIn6:`In5@jIP76bIP8^6oGdIQ8\\6mGeIS8[6lGgIT8Y6jGiIU8W6jGkIV8U6YGfHZOV1]9U6UGlHYOP1c9T6oFaJQ9m5^FVJc9S8001O001O001O001O001O001O00001O001O001O0O2O1O001O001O1O001O001O001O1N1O2N101N2N101N1O2N101N2N100O2N1O2O0O2N100O2N1O2O0O2M2O2N1N3N1RMUEfLm:X3`ETKoNb0b;Y4iEfJTOf0V;b4_FZKb9j2WD\\N[2fN`9l2[DXNX2hN_9P3]DRNY2jN\\9S3`DlMX2nNZ9T3cDiM]>U2hAdM]>X2jAaMZ>\\2lA\\MY>a2nAWMU>f2f1M3L4M2N3L4L4L3M4K5L4L3M4L7I?AXaT1", "size": [640, 427]}, "area": 110540.0, "iscrowd": 0, "image_id": 20333, "bbox": [1.0, 107.0, 367.0, 523.0], "category_id": 183, "id": 20001269}]} \ No newline at end of file diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010005.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010005.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0d01d232c81b26c9aa248aa57c7efa0a99df3174 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010005.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010008.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010008.jpg new file mode 100644 index 0000000000000000000000000000000000000000..008094db744379178cd6c926280f3e8d7b1c8c23 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010008.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010012.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010012.jpg new file mode 100644 index 0000000000000000000000000000000000000000..67387d63b8049d1cb2c92061922e5caf2ddbe801 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010012.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010014.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010014.jpg new file mode 100644 index 0000000000000000000000000000000000000000..10fc29c73a293ff8f285097ee22647ac4120ce3c Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010014.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010015.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010015.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3f65ed88daf660f12ab4a517b5d94700a5fafbc8 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010015.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010023.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010023.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fcac786c55af86715c1e3952b3af603cefc68ba4 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010023.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010024.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010024.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99300eccfc423be6022bf506c3072e892c165d3f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010024.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010037.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010037.jpg new file mode 100644 index 0000000000000000000000000000000000000000..689e9f544084c9c40eebd03c598a43fdb854e906 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010037.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010039.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010039.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e1f866df32bb473d2b634fc0c1c05590a26d86ef Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010039.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010040.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010040.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4a1f1cea8ee8534102acf12a12f4ae1c78c48cbc Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010040.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010041.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010041.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eb3443116ee4e5962690f64cdb782e22a2674f86 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010041.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010046.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010046.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7aa89ea79433c3217e5db6c18301a2c865601c2c Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010046.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010056.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010056.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e6445455ff5a84fa8b50bb03813799ed854a65a1 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010056.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010058.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010058.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c5950601f0fb68c31419565dd3e94b26e47a6c9f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010058.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010069.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010069.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9c0d6a0a9ec6c9ff7050e0c9892d3f922d438f85 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010069.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010073.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010073.jpg new file mode 100644 index 0000000000000000000000000000000000000000..de4b4a372a09f5523e51aa4ec68991ed850e6b3e Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010073.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010077.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010077.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e28cadef3d056117246cfc32eb856e9323ef1db3 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010077.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010082.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010082.jpg new file mode 100644 index 0000000000000000000000000000000000000000..359d1b70e5ac7c198c8b7194251e65aa3a1d9005 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010082.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010083.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010083.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b2e653dba8b3e0e6e1e3fe06839fdc4c1ee534e5 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010083.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010084.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010084.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dba1752e7996493f25c29efd4edeb317e47d69fe Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010084.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010094.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010094.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a7e9e1a8e4a4814a84bf4fafd223f1d411c79ef4 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010094.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010097.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010097.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f7dd764632d057170fb433a5af7d8c90aa4edd36 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010097.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010104.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010104.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6e57d05be3d920af265d9949f0d05fae2ee2fa7b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010104.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010107.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010107.jpg new file mode 100644 index 0000000000000000000000000000000000000000..92fe1dfe8c81eac02013081fc6efb0a5340c5280 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010107.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010108.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010108.jpg new file mode 100644 index 0000000000000000000000000000000000000000..98d5e91ea96b2d018d7e6cb650169ff5b8023d01 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010108.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010114.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010114.jpg new file mode 100644 index 0000000000000000000000000000000000000000..af644b98c1aee7d176c30a720657beafbcca3bbd Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010114.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010115.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010115.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fc53bea050e5e6f019d6d2f2b5fbbf89abe43885 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010115.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010123.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010123.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8eeba46f0882d234be75f2c954f750438563f3d6 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010123.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010125.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010125.jpg new file mode 100644 index 0000000000000000000000000000000000000000..54a2d88e7e5ce36f1de86726593f1743e327d0e0 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010125.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010130.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010130.jpg new file mode 100644 index 0000000000000000000000000000000000000000..812165fd9a14e7dfeb89c1791741de382e2e68b0 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010130.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010136.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010136.jpg new file mode 100644 index 0000000000000000000000000000000000000000..63cad9040f944094d59532a535e4d53aa8f947ac Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010136.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010138.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010138.jpg new file mode 100644 index 0000000000000000000000000000000000000000..95d92a7a65365f79035749daa63f837390af6165 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010138.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010142.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010142.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e33d5d5f26d2ea9793d3f545456cb9ccd6854de Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010142.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010145.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010145.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f97492871a92bb37a6ca5680515d04a71bcf5077 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010145.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010149.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010149.jpg new file mode 100644 index 0000000000000000000000000000000000000000..521b9aefa2b48f28ca501d7deaa6689ad17c341f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010149.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010161.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010161.jpg new file mode 100644 index 0000000000000000000000000000000000000000..63b016eeca2823bcbe638839815627714c06f875 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010161.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010166.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010166.jpg new file mode 100644 index 0000000000000000000000000000000000000000..04ac245e2292d3f5218098a87c988b205a1e92f3 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010166.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010175.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010175.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a243e6d6dbc8563930f29f69382608ae72588857 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010175.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010176.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010176.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a01a7b41cff3f986cf93bbcfce4ee726bab326f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010176.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010179.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010179.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d54cff8341fe5a4d3438171874f96a982133e263 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010179.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010192.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010192.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4b147369ad45172bf535a9712e4df8bf90e89a93 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010192.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010196.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010196.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ca2428c2531d24c3cc949bc931d394f76e60c610 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010196.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010205.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010205.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c0a37eaf8802cbc0985b9454119d1f24a60d7b68 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010205.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010211.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010211.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4e36020afd10bd08616ef326e52d25868bb7410b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010211.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010216.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010216.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e3fa8130f5fa58b24d6265d3cf4643f1ed716f0a Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010216.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010217.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010217.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c286e654c7a98da75a71a6f107722d9586bf072e Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010217.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010219.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010219.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b5fc7dae66b6378deeceb62c454e2e0aab90290e Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010219.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010222.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010222.jpg new file mode 100644 index 0000000000000000000000000000000000000000..21fb0b19f04aa6f026b29b573aaa484772cd3984 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010222.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010229.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010229.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6d240643a59949d4587d66c98a5b2de9b71f01ad Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010229.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010230.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010230.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc015805511907ff7268f1e8bc3b92e4ac4f123f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010230.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010232.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010232.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f2b4bb8c500433ae27cbec4ea020dfc1374b78b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010232.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010239.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010239.jpg new file mode 100644 index 0000000000000000000000000000000000000000..89ab497d180f2e0652f2cf0a27ee4195a33d2afb Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010239.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010241.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010241.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ade270b2af4061e1d151d8f42411ed1647e0d7ee Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010241.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010243.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010243.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e1de0ab8fecfd1ee7ef7eebc3aea1718bbb94e6c Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010243.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010244.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010244.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dd63205f6f70eac8b81c9a0ce8e65cb4ea25ec34 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010244.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010245.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010245.jpg new file mode 100644 index 0000000000000000000000000000000000000000..66c44a1e95ae77401c1f894b37417d74e71e4d18 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010245.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010248.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010248.jpg new file mode 100644 index 0000000000000000000000000000000000000000..beb9a8e3374b94e5d028135f856483a0dd180a74 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010248.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010249.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010249.jpg new file mode 100644 index 0000000000000000000000000000000000000000..538c32912eb2c35bc8ff14623103021811c72909 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010249.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010256.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010256.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d20e4bfb259d5167256083f20ca952018c02900d Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010256.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010263.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010263.jpg new file mode 100644 index 0000000000000000000000000000000000000000..14f8ea3baa01b1b7adb22660264f13182138488f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010263.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010265.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010265.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ac6c8309c7bb805a706c2cc4609264d6bdc1dc3c Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010265.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010275.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010275.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3103a3adefc2d7e2f7d0227a44ef13c1cf9c9fb6 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010275.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010276.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010276.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3565e1c6e48fe235cdc1086d94a62cd9329c56cd Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010276.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010281.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010281.jpg new file mode 100644 index 0000000000000000000000000000000000000000..25185cba897ecbf7205696f229c2001b48a1ab97 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010281.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010290.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010290.jpg new file mode 100644 index 0000000000000000000000000000000000000000..67eb933911f2e5f6ec802f7084d4833b527701ed Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010290.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010303.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010303.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e17cb7157c4914050b32c0db202552d4eebad998 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010303.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010309.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010309.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2e16e69a939cf383a676a8ca83ac608b421da816 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010309.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010313.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010313.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ebd1b1da721c38a59d1ba033206ca6cc43657ca6 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010313.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010318.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010318.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b93f06d19d20e1bb1824a98a793e5d2b5a26ca9a Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010318.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010319.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010319.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5004052107bee859fdea69d5ce90d61411598df0 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010319.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010321.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010321.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c06ca6d4ddd349e621e700db9556132602ac964a Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010321.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010324.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010324.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e8e7a69c4405582646b72b7551aea77ed0dbc0c0 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010324.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010327.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010327.jpg new file mode 100644 index 0000000000000000000000000000000000000000..96f34d95e22b9b4b51c44f7639571b0ce645b2ae Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010327.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010337.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010337.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff3094913ec7f40989247191b884f817f127fd32 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010337.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010342.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010342.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9242ff36e5f2cdadb826c6b28201fa2a2041515b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010342.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010343.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010343.jpg new file mode 100644 index 0000000000000000000000000000000000000000..49bec9bf618e8eb1c8799c0bf7cb9f9914a06b43 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010343.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010346.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010346.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ad3318a388c5c92d7da25821d7db37984a39357b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010346.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010358.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010358.jpg new file mode 100644 index 0000000000000000000000000000000000000000..294af8cc94a39920ab8c5faabcbf82a0df6d57fa Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010358.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010369.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010369.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b83a0bcf3bce46dd169d7e1488bf2eabe909ded8 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010369.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010386.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010386.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9a7efcb5bb1a8a26ab133e419b3e65f3750d0e47 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010386.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010388.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010388.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aab8c87a31c42305e8f42ad56165c529d26ef048 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010388.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010393.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010393.jpg new file mode 100644 index 0000000000000000000000000000000000000000..98485b9ca79f6f7fe92bb8520907628035d07511 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010393.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010395.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010395.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b9b393aeba4bc975598cfe07cf0692e847819a53 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010395.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010400.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010400.jpg new file mode 100644 index 0000000000000000000000000000000000000000..000394595fa46b1e3ca6e112eb5369695af42cda Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010400.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010403.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010403.jpg new file mode 100644 index 0000000000000000000000000000000000000000..15651186e1de44ea6ab710fdb09d7f42a95e7165 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010403.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010405.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010405.jpg new file mode 100644 index 0000000000000000000000000000000000000000..26cf47b485f66c5ec5526dc5b01e3e4deb4f0830 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010405.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010407.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010407.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69f1861a2613d2d52645ebca6c752689877dbf71 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010407.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010414.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010414.jpg new file mode 100644 index 0000000000000000000000000000000000000000..955dd0cd6174579495170111de6efb41d6e7c12e Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010414.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010420.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010420.jpg new file mode 100644 index 0000000000000000000000000000000000000000..928302c30fef1b76a5cfc9d5511f8db86da401a2 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010420.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010421.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010421.jpg new file mode 100644 index 0000000000000000000000000000000000000000..45cbe7767672356caa9d5e0f8eff71bdeea0a872 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010421.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010428.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010428.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6f55f2d1a4f549ad4ebf42b278be45cb7cc0b972 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010428.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010430.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010430.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69de3a1c04e4ddce054762fd4c9f4bee8967894b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010430.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010432.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010432.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aa3af3238f92b5dd762f75ed14c974a3ec204d5b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010432.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010434.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010434.jpg new file mode 100644 index 0000000000000000000000000000000000000000..41e5f3f55c63ac002052923a03ce5e21d9127100 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010434.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010440.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010440.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bb2949c47f074877924270d53ced182f1ebca372 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010440.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010442.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010442.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b77845478799b0f56f6101f661f5e956e94fc667 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010442.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010444.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010444.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5de15163f43e3e15339fa38d262ef9d5f6084b2 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010444.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010445.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010445.jpg new file mode 100644 index 0000000000000000000000000000000000000000..89d64af18dee567da468d76180f2d15b77c32a50 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010445.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010449.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010449.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff9f4b25060b7197c09995be8cccd07f65f2b65b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010449.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/train2017/000000010463.jpg b/src/taming-transformers/data/coco_annotations_100/train2017/000000010463.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8111ec0ffae2246d512353ebb24b1903e8a03907 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/train2017/000000010463.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000010092.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000010092.jpg new file mode 100644 index 0000000000000000000000000000000000000000..54b98d5a019517fbf152416297690acebb310729 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000010092.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000010363.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000010363.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99016f07a5354b8818d7d8bf59a2ad02be5b3e5f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000010363.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000010583.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000010583.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aac4bf20f29ffdf5a19e2f26847229c3f3f17d52 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000010583.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000010707.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000010707.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f7c74e04d327843d02c514aad3a9e4b6ce0e0d54 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000010707.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000010764.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000010764.jpg new file mode 100644 index 0000000000000000000000000000000000000000..39327f0ece01500863c596aae58a7c69ed5630ca Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000010764.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000010977.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000010977.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e88481e26df33eb9fb807b563efccd5a9017c2dd Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000010977.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000010995.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000010995.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ef1db3e31f659fc08b915b3c8b768d57e0d99016 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000010995.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000011051.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000011051.jpg new file mode 100644 index 0000000000000000000000000000000000000000..71a14e1b6d823eb34d8051d3dd1b7226c7834386 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000011051.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000011122.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000011122.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9541405d88ae703a4bc013a0dfdc973576aa852f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000011122.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000011149.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000011149.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3de5f53a2d09ccb139c9c789cca5666cb83d15a8 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000011149.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000011197.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000011197.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3843d44902b0fc485d82956f2a7d5e0fe1ac6378 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000011197.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000011511.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000011511.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bbaf351478612d1724fbc0adb1c1dd11cb169e8a Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000011511.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000011615.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000011615.jpg new file mode 100644 index 0000000000000000000000000000000000000000..66ec4adf86de0db93dd6f297fa33ec181de3fe65 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000011615.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000011699.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000011699.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e65936fb180daaf152b432ed867c3c71b35da3c0 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000011699.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000011760.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000011760.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b16a5edf837d317f41da591af22be52efc684c06 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000011760.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000011813.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000011813.jpg new file mode 100644 index 0000000000000000000000000000000000000000..987783aa0d15e367663ffb6f4568d464367b62fb Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000011813.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000012062.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000012062.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3c9de73569c928fc4937df914ea99ab5c45de0cc Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000012062.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000012120.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000012120.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a938ab298d0daf9c774c23b9ef96dc788981b153 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000012120.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000012280.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000012280.jpg new file mode 100644 index 0000000000000000000000000000000000000000..48127a519bdad9c8273f7b33c2a734fa3ed9069a Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000012280.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000012576.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000012576.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d4b1a5b32e7eeaeb973fe7b3640c18699371abd5 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000012576.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000012639.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000012639.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b2ed15cf8ae0de8fee4af45155f16c54d16fc21a Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000012639.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000012667.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000012667.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0cf4956c5de3dc464c05be5f2a6617c7fedd89c6 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000012667.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000012670.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000012670.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b3e2e423bda5d9a4253008ba76ef6f28bdf8fd91 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000012670.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000012748.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000012748.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8b5f4c5805f8d09b9e0f7d64fad5a4b938b6c5ea Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000012748.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013004.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013004.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6cb5573cd4041c13a94d3002bbf3acc5f314eea8 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013004.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013177.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013177.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5b0b54aae527c605bac5a871ce0080af9cbf2fa6 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013177.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013201.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013201.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b5ff17f37f01c14626504eecf1212177f12699c4 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013201.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013291.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013291.jpg new file mode 100644 index 0000000000000000000000000000000000000000..19c4fffa6f0d45d1e2e15cc9b5e07c4fe6b5461c Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013291.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013348.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013348.jpg new file mode 100644 index 0000000000000000000000000000000000000000..03bbb9404dcc1a2d900cd7f17447da3ca0e00999 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013348.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013546.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013546.jpg new file mode 100644 index 0000000000000000000000000000000000000000..389684fac4ad79ea89ad8a22227e7c2816d449b5 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013546.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013597.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013597.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9a2687cfecd4c10db9008441ba70b0c194342ca0 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013597.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013659.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013659.jpg new file mode 100644 index 0000000000000000000000000000000000000000..123d95f88c816368b3bc15473ffbe963a4f3b6cc Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013659.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013729.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013729.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dd2bc4d99425885b19cd8b523c72f4c2d628249d Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013729.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013774.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013774.jpg new file mode 100644 index 0000000000000000000000000000000000000000..de140d83b64e10d0d36debc7babf5c32284abba3 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013774.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000013923.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000013923.jpg new file mode 100644 index 0000000000000000000000000000000000000000..05e3f7cb0d95d30b50354566e509773f27a997c0 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000013923.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000014007.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000014007.jpg new file mode 100644 index 0000000000000000000000000000000000000000..86961634015e26e5b973f99622c8f67b51d26cc4 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000014007.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000014038.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000014038.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eb0cc770c4d2d712b00c05c4311d5103f806a0db Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000014038.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000014226.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000014226.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4ae7f4274ae00565d6f690481ced3d69108cc695 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000014226.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000014380.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000014380.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a85ece8fb086dbaf6c23955d4464a2584180ace9 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000014380.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000014439.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000014439.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0abbdab06eb5950b93908cc91adfa640e8a3ac78 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000014439.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000014473.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000014473.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b7192f3ffa82a95b621f28f8f8e7907f8a3bfd42 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000014473.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000014831.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000014831.jpg new file mode 100644 index 0000000000000000000000000000000000000000..27eda37bbc9458a05c116665f46520066edaaa18 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000014831.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000014888.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000014888.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a609cdf68a8a96a14e3f789fe8aff5e2435ef69d Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000014888.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015079.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015079.jpg new file mode 100644 index 0000000000000000000000000000000000000000..24be72cb39b6fb3cf87e44290b17fd1c06dadb97 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015079.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015254.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015254.jpg new file mode 100644 index 0000000000000000000000000000000000000000..717ba8a59e510c173ef8204bf39a3f3bda2d51fc Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015254.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015272.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015272.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6cc3919689a4a1a0b6d0b2072462cdf10c0a6275 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015272.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015278.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015278.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1e69377f5405635ecec17ad38965af01a46cd125 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015278.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015335.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015335.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1231ff8d13cd839bccb4f22ac4873905ce1ea6fc Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015335.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015338.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015338.jpg new file mode 100644 index 0000000000000000000000000000000000000000..765870ebd5be099ecb72987d789b5f09b953e62d Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015338.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015440.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015440.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4362ec1868889f76db5170bb63c359cf35b212cf Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015440.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015497.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015497.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c2ab1aa89a8de9466ef10d3505aef0d3f47cf93f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015497.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015517.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015517.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7b6751b450ac3c2c61b16c14e8932bf5403976da Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015517.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015597.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015597.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a23272707413a3e14c85d45ca479b7b583ee763f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015597.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015660.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015660.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69fc83c0ec773b0f0a1b7fce53e4fa995d4d93d1 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015660.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015746.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015746.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0fca66897b583029f4575579eb6e7e958abec02a Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015746.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015751.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015751.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5c629a8f6fd0c2efe51cf397b19fd704ae3b642b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015751.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000015956.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000015956.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f4cb09c4b01a3633e7fd1ea680a7112b41b28abf Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000015956.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000016010.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000016010.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aa3f083f485b4d927ee46d6e334d9a1201417c29 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000016010.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000016228.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000016228.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d5a5a3fb41c8954f8e7446907bee94a92688263b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000016228.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000016249.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000016249.jpg new file mode 100644 index 0000000000000000000000000000000000000000..021626a393f4f9c559d8ed3962bfa63610a28211 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000016249.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000016439.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000016439.jpg new file mode 100644 index 0000000000000000000000000000000000000000..01c59d78539e5655c104bbbe262c2fb2ea885826 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000016439.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000016451.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000016451.jpg new file mode 100644 index 0000000000000000000000000000000000000000..806a9f64cd14df8e06d04591ef61efc964244064 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000016451.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000016502.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000016502.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ef4f855a3f2f2e5c837a27809c1683a5f0fb72f4 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000016502.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000016598.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000016598.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e401f9ab0b53ec29014f2d0021e0e30485b0ee4f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000016598.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000016958.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000016958.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e637589a07ee4ae6f6b8a272c27ab37dafcf63fc Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000016958.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017029.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017029.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3e2351f293cbf6d4a0fc525f00869728e623a460 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017029.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017031.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017031.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7d091e99ba05b6337b23f74748ad065f933a3a90 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017031.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017115.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017115.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3d6ec777845dcbb040dcaef38bb3f2a0a662c71b Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017115.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017178.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017178.jpg new file mode 100644 index 0000000000000000000000000000000000000000..50016b522cd4a7c2ee7a623a1b5f45c740923f64 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017178.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017182.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017182.jpg new file mode 100644 index 0000000000000000000000000000000000000000..28949d2c6fd22d26f20bfda1be582dba639dc15d Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017182.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017207.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017207.jpg new file mode 100644 index 0000000000000000000000000000000000000000..494b48c99e0ceb33a28e9f99d566525eaed310ea Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017207.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017379.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017379.jpg new file mode 100644 index 0000000000000000000000000000000000000000..04ee678f82c95de44eb73f02679ef30b6cdd9b37 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017379.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017436.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017436.jpg new file mode 100644 index 0000000000000000000000000000000000000000..12dca6f0a16afea687045ae1cb5a00d1ff42e5d3 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017436.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017627.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017627.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3e11df1e5c49f05ce98fc9edd1b676478c3926d6 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017627.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017714.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017714.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1ebfff93d709153d1fb1070b685e57aa37db6a1 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017714.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017899.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017899.jpg new file mode 100644 index 0000000000000000000000000000000000000000..618db3bd347e76aaddbbef0d4e5d0a2b3e53e48e Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017899.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017905.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017905.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6e87a525486a5f075875b3ebaf6d5d843f35cbe8 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017905.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000017959.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000017959.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fba6776922c689b538e424495987aaa7e9dbf4ee Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000017959.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018150.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018150.jpg new file mode 100644 index 0000000000000000000000000000000000000000..547b5561169bcb86931c6e40577583deabd6e6dc Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018150.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018193.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018193.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4446aefee75836676db3e7cf2a8ae0035b17b5bf Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018193.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018380.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018380.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b349df1b1320f95115176401eab6bcd16df9bb4e Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018380.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018491.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018491.jpg new file mode 100644 index 0000000000000000000000000000000000000000..40bb5d796159b0310b313ea1610c53b2082394d2 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018491.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018519.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018519.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e6a485a9bd2f0e246d839f7a2d320a990b44fe06 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018519.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018575.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018575.jpg new file mode 100644 index 0000000000000000000000000000000000000000..618984af87601ec3a6bbf5bced7746ccc8de4e62 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018575.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018737.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018737.jpg new file mode 100644 index 0000000000000000000000000000000000000000..340c394ff1398a1496c81855ff1128bbf8071842 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018737.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018770.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018770.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d2472e57ae9e388fbb488c93d2e9deb1233f4ccc Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018770.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018833.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018833.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6408447eb6cfaa8bcb2aea7885b5f6f52aa1f106 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018833.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000018837.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000018837.jpg new file mode 100644 index 0000000000000000000000000000000000000000..51b7b34992cb507620356020b070f61ad5a685c1 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000018837.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000019042.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000019042.jpg new file mode 100644 index 0000000000000000000000000000000000000000..440d74b0cda8a8c5a2badf2c4f10d8615d0edbaf Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000019042.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000019109.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000019109.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1e20cdde8aeb8d81354488f4687e899a02fb6d11 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000019109.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000019221.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000019221.jpg new file mode 100644 index 0000000000000000000000000000000000000000..64afe2e38c4904f56c6d0a8ea2906ea37cabae4f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000019221.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000019402.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000019402.jpg new file mode 100644 index 0000000000000000000000000000000000000000..82010ce5c61a061f02c41246aef5a4e8a0b7d12f Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000019402.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000019432.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000019432.jpg new file mode 100644 index 0000000000000000000000000000000000000000..efdcc7fcda44e16d19cd4efbcbc7a7a8f73dcd70 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000019432.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000019742.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000019742.jpg new file mode 100644 index 0000000000000000000000000000000000000000..62ef3c4ca3fae28dd50cb8a854b71484451b6453 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000019742.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000019786.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000019786.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5e174abcec3729cf870dbd6f8256c955ed7005e7 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000019786.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000019924.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000019924.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1675bd91f592a61444018a8567f78acc2f5b5880 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000019924.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000020059.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000020059.jpg new file mode 100644 index 0000000000000000000000000000000000000000..32f2ab6412b14c646c02cbd341b1babc51d1300d Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000020059.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000020107.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000020107.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ced9d7c1f0e4e629ca9076cc9c0eeefb766b6026 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000020107.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000020247.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000020247.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6e0e39f8955b28df574159bfc1cac1e9c1ec9425 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000020247.jpg differ diff --git a/src/taming-transformers/data/coco_annotations_100/val2017/000000020333.jpg b/src/taming-transformers/data/coco_annotations_100/val2017/000000020333.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b7a73cca502f3ab4a6367a29feb131fbce939b3 Binary files /dev/null and b/src/taming-transformers/data/coco_annotations_100/val2017/000000020333.jpg differ diff --git a/src/taming-transformers/data/coco_examples.txt b/src/taming-transformers/data/coco_examples.txt new file mode 100644 index 0000000000000000000000000000000000000000..030bd0f6c1d11fbd18f065f1748a34145dbfa881 --- /dev/null +++ b/src/taming-transformers/data/coco_examples.txt @@ -0,0 +1,35 @@ +000000064898.jpg +000000166563.jpg +000000231169.jpg +000000098392.jpg +000000154358.jpg +000000452122.jpg +000000323895.jpg +000000175387.jpg +000000491464.jpg +000000403385.jpg +000000303653.jpg +000000205834.jpg +000000299355.jpg +000000569273.jpg +000000185599.jpg +000000119445.jpg +000000057672.jpg +000000110638.jpg +000000517069.jpg +000000052507.jpg +000000255824.jpg +000000348045.jpg +000000361180.jpg +000000335529.jpg +000000356347.jpg +000000237928.jpg +000000348481.jpg +000000406997.jpg +000000128658.jpg +000000018380.jpg +000000166259.jpg +000000256775.jpg +000000350405.jpg +000000299720.jpg +000000522393.jpg diff --git a/src/taming-transformers/data/coco_images/000000018380.jpg b/src/taming-transformers/data/coco_images/000000018380.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b349df1b1320f95115176401eab6bcd16df9bb4e Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000018380.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000052507.jpg b/src/taming-transformers/data/coco_images/000000052507.jpg new file mode 100644 index 0000000000000000000000000000000000000000..882e148214a920408bba45f6a34234c2c84ab2b9 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000052507.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000057672.jpg b/src/taming-transformers/data/coco_images/000000057672.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d94f20de16e23e372eb4d622424fe6c5e23290ab Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000057672.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000064898.jpg b/src/taming-transformers/data/coco_images/000000064898.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c11b4c8f0ccaea43a19ca6d67d6f5d6b1e971cf2 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000064898.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000098392.jpg b/src/taming-transformers/data/coco_images/000000098392.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a6f23d06a01f0a2757bd8105c3bdfe51ec2908e Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000098392.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000110638.jpg b/src/taming-transformers/data/coco_images/000000110638.jpg new file mode 100644 index 0000000000000000000000000000000000000000..785492c1cba1c4870900f476b915a33603e882df Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000110638.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000119445.jpg b/src/taming-transformers/data/coco_images/000000119445.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d0ce218223773ed16ad7643ee42397c6a7793970 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000119445.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000128658.jpg b/src/taming-transformers/data/coco_images/000000128658.jpg new file mode 100644 index 0000000000000000000000000000000000000000..359d7accd382281ba93e3f979c62eb04c08fa771 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000128658.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000154358.jpg b/src/taming-transformers/data/coco_images/000000154358.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e8b00fa50fee12a90d82c5f0d67d1df7c76c3fc9 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000154358.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000166259.jpg b/src/taming-transformers/data/coco_images/000000166259.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fff26119bb2e2aa79daa51a04ffe794f834941fc Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000166259.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000166563.jpg b/src/taming-transformers/data/coco_images/000000166563.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3248c20732dfefb32b106714197fc3f5a0e95d85 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000166563.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000175387.jpg b/src/taming-transformers/data/coco_images/000000175387.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cf579f03cbb257e38fa619daf11d5ad739dd02aa Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000175387.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000185599.jpg b/src/taming-transformers/data/coco_images/000000185599.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5ceab0d6c5560a80821478e0ae77259d7e752d8 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000185599.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000205834.jpg b/src/taming-transformers/data/coco_images/000000205834.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f8e688831e1569bc986a378f10a9866f6d0ca2a8 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000205834.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000231169.jpg b/src/taming-transformers/data/coco_images/000000231169.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b67352bdec35320aa6567898ee5199fc4c4a305e Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000231169.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000237928.jpg b/src/taming-transformers/data/coco_images/000000237928.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9a49e5364b0afc102cb5b530f6f1f0c314ff1bdc Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000237928.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000255824.jpg b/src/taming-transformers/data/coco_images/000000255824.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e201a7b08d0bc9190e9836219ed4f1cf490c02cd Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000255824.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000256775.jpg b/src/taming-transformers/data/coco_images/000000256775.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d5f2aaf05c4f3ce1415682f7ae2e36e1aa5a4881 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000256775.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000299355.jpg b/src/taming-transformers/data/coco_images/000000299355.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f4cb23a4f413ef4da992220130356c5fa44d1d2 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000299355.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000299720.jpg b/src/taming-transformers/data/coco_images/000000299720.jpg new file mode 100644 index 0000000000000000000000000000000000000000..60f20b9a5c030508d3e29ee622aef3bd26f49fa0 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000299720.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000303653.jpg b/src/taming-transformers/data/coco_images/000000303653.jpg new file mode 100644 index 0000000000000000000000000000000000000000..31ea042c0107f91f5978510c726d0f91c9ec5c85 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000303653.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000323895.jpg b/src/taming-transformers/data/coco_images/000000323895.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1b6819075412c0b2262a60c7f0a70da29804aeca Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000323895.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000335529.jpg b/src/taming-transformers/data/coco_images/000000335529.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8347b065277be324040c5f3391c1dc43220ce096 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000335529.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000348045.jpg b/src/taming-transformers/data/coco_images/000000348045.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff993b67a98591ea0e09beeb1ab85847c492caac Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000348045.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000348481.jpg b/src/taming-transformers/data/coco_images/000000348481.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a2cb75cc0c0629480e1fdfdfe3d56a92f260e47f Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000348481.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000350405.jpg b/src/taming-transformers/data/coco_images/000000350405.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc70b638edbaa99d573f33882382e538dbb79c66 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000350405.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000356347.jpg b/src/taming-transformers/data/coco_images/000000356347.jpg new file mode 100644 index 0000000000000000000000000000000000000000..400fbfc928af368a176a6cbce993493738e8af94 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000356347.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000361180.jpg b/src/taming-transformers/data/coco_images/000000361180.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c50d671a72c770bdb56c18c3568bc0eaf55b58c4 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000361180.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000403385.jpg b/src/taming-transformers/data/coco_images/000000403385.jpg new file mode 100644 index 0000000000000000000000000000000000000000..39573bfa168ce1ba05c8d3fa6d541b310211fcf7 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000403385.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000406997.jpg b/src/taming-transformers/data/coco_images/000000406997.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4ea81fbaa2cce050a248f5327ba68c0973c5cbec Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000406997.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000452122.jpg b/src/taming-transformers/data/coco_images/000000452122.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2e2271f5326f4172e3c58993b4e2f31c6c1d4f4e Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000452122.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000491464.jpg b/src/taming-transformers/data/coco_images/000000491464.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1d7d455607ace3d584fa1f62d7c5a4d6337801b9 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000491464.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000517069.jpg b/src/taming-transformers/data/coco_images/000000517069.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a00451f49820132c366142019974bc174a5a43b9 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000517069.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000522393.jpg b/src/taming-transformers/data/coco_images/000000522393.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1a5875b5d660b82711f25215476bf4fff549b716 Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000522393.jpg differ diff --git a/src/taming-transformers/data/coco_images/000000569273.jpg b/src/taming-transformers/data/coco_images/000000569273.jpg new file mode 100644 index 0000000000000000000000000000000000000000..00327f1cd0b06c41ef0ad0b66efe8df2ba6ea25f Binary files /dev/null and b/src/taming-transformers/data/coco_images/000000569273.jpg differ diff --git a/src/taming-transformers/data/coco_segmentations/000000018380.png b/src/taming-transformers/data/coco_segmentations/000000018380.png new file mode 100644 index 0000000000000000000000000000000000000000..4a49387c7eb4c7706862e736381f2445a6ab62ca Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000018380.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000052507.png b/src/taming-transformers/data/coco_segmentations/000000052507.png new file mode 100644 index 0000000000000000000000000000000000000000..7062352ec59e4417be73521ec4978b542dac234d Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000052507.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000057672.png b/src/taming-transformers/data/coco_segmentations/000000057672.png new file mode 100644 index 0000000000000000000000000000000000000000..4ae78b24ca42cb72fa250d3a77c5358cc6730f4d Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000057672.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000064898.png b/src/taming-transformers/data/coco_segmentations/000000064898.png new file mode 100644 index 0000000000000000000000000000000000000000..654462abd6d0006d95ad9a9e595973dc119c0a6a Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000064898.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000098392.png b/src/taming-transformers/data/coco_segmentations/000000098392.png new file mode 100644 index 0000000000000000000000000000000000000000..c4f7e1ef28990e51d4ac6884f875fc325b046529 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000098392.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000110638.png b/src/taming-transformers/data/coco_segmentations/000000110638.png new file mode 100644 index 0000000000000000000000000000000000000000..4f4144b8f5909e6d7dd4c052c2cb026ceaa6101a Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000110638.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000119445.png b/src/taming-transformers/data/coco_segmentations/000000119445.png new file mode 100644 index 0000000000000000000000000000000000000000..ab63053b4e6884424bf83208fabf438ae63d1f60 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000119445.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000128658.png b/src/taming-transformers/data/coco_segmentations/000000128658.png new file mode 100644 index 0000000000000000000000000000000000000000..8b9cd9690ecb50e90eda455c6b8be04b66563b98 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000128658.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000154358.png b/src/taming-transformers/data/coco_segmentations/000000154358.png new file mode 100644 index 0000000000000000000000000000000000000000..e97dd364d4d44cbed993c7e69a0eb92a216fe14e Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000154358.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000166259.png b/src/taming-transformers/data/coco_segmentations/000000166259.png new file mode 100644 index 0000000000000000000000000000000000000000..eae767fc5a6aabf4e3adbfb0d21993da5fda4b97 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000166259.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000166563.png b/src/taming-transformers/data/coco_segmentations/000000166563.png new file mode 100644 index 0000000000000000000000000000000000000000..23cb9aa0971cc9365bc8802793ab9558328d3728 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000166563.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000175387.png b/src/taming-transformers/data/coco_segmentations/000000175387.png new file mode 100644 index 0000000000000000000000000000000000000000..5084cf28fb0094960011174e98094e4c2970e517 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000175387.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000185599.png b/src/taming-transformers/data/coco_segmentations/000000185599.png new file mode 100644 index 0000000000000000000000000000000000000000..cedf7656ff5020b7725036eebefb6b21c8dcfcc7 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000185599.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000205834.png b/src/taming-transformers/data/coco_segmentations/000000205834.png new file mode 100644 index 0000000000000000000000000000000000000000..511a7ec0ed28bb424224b9609debcdb4c33da4f4 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000205834.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000231169.png b/src/taming-transformers/data/coco_segmentations/000000231169.png new file mode 100644 index 0000000000000000000000000000000000000000..4754ce883f16720cc7854b6ec769ab48decda33c Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000231169.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000237928.png b/src/taming-transformers/data/coco_segmentations/000000237928.png new file mode 100644 index 0000000000000000000000000000000000000000..44bc25768927db32a9dc65cae1730adc2bc48e73 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000237928.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000255824.png b/src/taming-transformers/data/coco_segmentations/000000255824.png new file mode 100644 index 0000000000000000000000000000000000000000..1a304f5b844c2ba8ff2948bd7679c7472610e2e9 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000255824.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000256775.png b/src/taming-transformers/data/coco_segmentations/000000256775.png new file mode 100644 index 0000000000000000000000000000000000000000..a04c7d159dd8f34d0a5e2c02ae0a40e3f2df0b88 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000256775.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000299355.png b/src/taming-transformers/data/coco_segmentations/000000299355.png new file mode 100644 index 0000000000000000000000000000000000000000..34721a5fc18f893a74e4a5a739d3b63067eec812 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000299355.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000299720.png b/src/taming-transformers/data/coco_segmentations/000000299720.png new file mode 100644 index 0000000000000000000000000000000000000000..bf19c93a62d818521247036d3689bd04ef8c4f41 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000299720.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000303653.png b/src/taming-transformers/data/coco_segmentations/000000303653.png new file mode 100644 index 0000000000000000000000000000000000000000..91ea8823ec01f82e6b7092fac3f95b34d07103df Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000303653.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000323895.png b/src/taming-transformers/data/coco_segmentations/000000323895.png new file mode 100644 index 0000000000000000000000000000000000000000..925e3aca5344b0bc4cd2ac576e898bc18db9104f Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000323895.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000335529.png b/src/taming-transformers/data/coco_segmentations/000000335529.png new file mode 100644 index 0000000000000000000000000000000000000000..c8097938938379a507fbb8b77a059ed40295e91e Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000335529.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000348045.png b/src/taming-transformers/data/coco_segmentations/000000348045.png new file mode 100644 index 0000000000000000000000000000000000000000..0ee1fe9cabf72256ac3642e835b4812bde5b5fde Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000348045.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000348481.png b/src/taming-transformers/data/coco_segmentations/000000348481.png new file mode 100644 index 0000000000000000000000000000000000000000..c98372b490fdb3e780b6da1c3949af1449320b61 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000348481.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000350405.png b/src/taming-transformers/data/coco_segmentations/000000350405.png new file mode 100644 index 0000000000000000000000000000000000000000..86194603110e4fa381ac0f9b8edfbd6944dc86f9 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000350405.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000356347.png b/src/taming-transformers/data/coco_segmentations/000000356347.png new file mode 100644 index 0000000000000000000000000000000000000000..d1bebe56be4cce5571d175a5a587fdaeffa17b30 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000356347.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000361180.png b/src/taming-transformers/data/coco_segmentations/000000361180.png new file mode 100644 index 0000000000000000000000000000000000000000..6287aba7667e416ac52c8278fb569e9df5f4502a Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000361180.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000403385.png b/src/taming-transformers/data/coco_segmentations/000000403385.png new file mode 100644 index 0000000000000000000000000000000000000000..2e3aaddf6c6c52dcb80e3bc1ff4d856c3e156b3f Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000403385.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000406997.png b/src/taming-transformers/data/coco_segmentations/000000406997.png new file mode 100644 index 0000000000000000000000000000000000000000..2af15a30992d3101ff81b2a11d1dc7b3066bde5a Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000406997.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000452122.png b/src/taming-transformers/data/coco_segmentations/000000452122.png new file mode 100644 index 0000000000000000000000000000000000000000..511c0cafde9cc244e98d4681e05bb6b4917f27f3 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000452122.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000491464.png b/src/taming-transformers/data/coco_segmentations/000000491464.png new file mode 100644 index 0000000000000000000000000000000000000000..b9423744a767acc760103481eae048c3f7511cff Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000491464.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000517069.png b/src/taming-transformers/data/coco_segmentations/000000517069.png new file mode 100644 index 0000000000000000000000000000000000000000..0659c86904b53d12d5952895cc4b42f95d48e7d6 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000517069.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000522393.png b/src/taming-transformers/data/coco_segmentations/000000522393.png new file mode 100644 index 0000000000000000000000000000000000000000..02c0ceb748020ff95680b8d58f82723ec474798b Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000522393.png differ diff --git a/src/taming-transformers/data/coco_segmentations/000000569273.png b/src/taming-transformers/data/coco_segmentations/000000569273.png new file mode 100644 index 0000000000000000000000000000000000000000..ba0a48151c3c75bcde7a62257347f9e2e481f615 Binary files /dev/null and b/src/taming-transformers/data/coco_segmentations/000000569273.png differ diff --git a/src/taming-transformers/data/drin_depth/n01795545/ILSVRC2012_val_00023344.png b/src/taming-transformers/data/drin_depth/n01795545/ILSVRC2012_val_00023344.png new file mode 100644 index 0000000000000000000000000000000000000000..16850a3143d997a6f7df1e10ce6c98862ffb3cfd Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n01795545/ILSVRC2012_val_00023344.png differ diff --git a/src/taming-transformers/data/drin_depth/n01819313/ILSVRC2012_val_00003068.png b/src/taming-transformers/data/drin_depth/n01819313/ILSVRC2012_val_00003068.png new file mode 100644 index 0000000000000000000000000000000000000000..7da56a672753ac01ab941ede9a8df65cffcb1b98 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n01819313/ILSVRC2012_val_00003068.png differ diff --git a/src/taming-transformers/data/drin_depth/n01820546/ILSVRC2012_val_00034784.png b/src/taming-transformers/data/drin_depth/n01820546/ILSVRC2012_val_00034784.png new file mode 100644 index 0000000000000000000000000000000000000000..c4fe9aef2553974fefaa2e4a3474625aec10f3c9 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n01820546/ILSVRC2012_val_00034784.png differ diff --git a/src/taming-transformers/data/drin_depth/n01820546/ILSVRC2012_val_00047491.png b/src/taming-transformers/data/drin_depth/n01820546/ILSVRC2012_val_00047491.png new file mode 100644 index 0000000000000000000000000000000000000000..20e83c3a52985206b9bdaa190d7f2fbd20725de9 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n01820546/ILSVRC2012_val_00047491.png differ diff --git a/src/taming-transformers/data/drin_depth/n01828970/ILSVRC2012_val_00001336.png b/src/taming-transformers/data/drin_depth/n01828970/ILSVRC2012_val_00001336.png new file mode 100644 index 0000000000000000000000000000000000000000..df10b308fa4a61a16ff343613e1e285c52c49de6 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n01828970/ILSVRC2012_val_00001336.png differ diff --git a/src/taming-transformers/data/drin_depth/n01828970/ILSVRC2012_val_00008236.png b/src/taming-transformers/data/drin_depth/n01828970/ILSVRC2012_val_00008236.png new file mode 100644 index 0000000000000000000000000000000000000000..6287a49b92a1c5ef3e51eb1a755fb87388183c43 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n01828970/ILSVRC2012_val_00008236.png differ diff --git a/src/taming-transformers/data/drin_depth/n01828970/ILSVRC2012_val_00046802.png b/src/taming-transformers/data/drin_depth/n01828970/ILSVRC2012_val_00046802.png new file mode 100644 index 0000000000000000000000000000000000000000..c4b046001aec2bc84cc5e42a427216d64488af92 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n01828970/ILSVRC2012_val_00046802.png differ diff --git a/src/taming-transformers/data/drin_depth/n01843065/ILSVRC2012_val_00022439.png b/src/taming-transformers/data/drin_depth/n01843065/ILSVRC2012_val_00022439.png new file mode 100644 index 0000000000000000000000000000000000000000..633185b69a7391cd30a78f1863dfec7b1219cd64 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n01843065/ILSVRC2012_val_00022439.png differ diff --git a/src/taming-transformers/data/drin_depth/n01847000/ILSVRC2012_val_00022364.png b/src/taming-transformers/data/drin_depth/n01847000/ILSVRC2012_val_00022364.png new file mode 100644 index 0000000000000000000000000000000000000000..22f95bd68d203955f754623e1c73973d4dea5e38 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n01847000/ILSVRC2012_val_00022364.png differ diff --git a/src/taming-transformers/data/drin_depth/n02085782/ILSVRC2012_val_00012298.png b/src/taming-transformers/data/drin_depth/n02085782/ILSVRC2012_val_00012298.png new file mode 100644 index 0000000000000000000000000000000000000000..e96a7cf5b096f5a1a8ee6d3a7bdbddfe041dd9f9 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02085782/ILSVRC2012_val_00012298.png differ diff --git a/src/taming-transformers/data/drin_depth/n02086646/ILSVRC2012_val_00011473.png b/src/taming-transformers/data/drin_depth/n02086646/ILSVRC2012_val_00011473.png new file mode 100644 index 0000000000000000000000000000000000000000..6811ae8000fdda1a84e2703e9ff74f897e4cdce4 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02086646/ILSVRC2012_val_00011473.png differ diff --git a/src/taming-transformers/data/drin_depth/n02088466/ILSVRC2012_val_00013651.png b/src/taming-transformers/data/drin_depth/n02088466/ILSVRC2012_val_00013651.png new file mode 100644 index 0000000000000000000000000000000000000000..dcfdfdfa1eb5bb6383307e887df90b306c4ef100 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02088466/ILSVRC2012_val_00013651.png differ diff --git a/src/taming-transformers/data/drin_depth/n02089973/ILSVRC2012_val_00000028.png b/src/taming-transformers/data/drin_depth/n02089973/ILSVRC2012_val_00000028.png new file mode 100644 index 0000000000000000000000000000000000000000..2e2aea97296bc551bae39a526481d6e17e4ed6de Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02089973/ILSVRC2012_val_00000028.png differ diff --git a/src/taming-transformers/data/drin_depth/n02093256/ILSVRC2012_val_00046547.png b/src/taming-transformers/data/drin_depth/n02093256/ILSVRC2012_val_00046547.png new file mode 100644 index 0000000000000000000000000000000000000000..0eca5fa4412dd36bc3c20e0cd2b548938fd123d7 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02093256/ILSVRC2012_val_00046547.png differ diff --git a/src/taming-transformers/data/drin_depth/n02096294/ILSVRC2012_val_00042133.png b/src/taming-transformers/data/drin_depth/n02096294/ILSVRC2012_val_00042133.png new file mode 100644 index 0000000000000000000000000000000000000000..38aedd8449b7a7b1538528955d3b0d958702b221 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02096294/ILSVRC2012_val_00042133.png differ diff --git a/src/taming-transformers/data/drin_depth/n02099601/ILSVRC2012_val_00005697.png b/src/taming-transformers/data/drin_depth/n02099601/ILSVRC2012_val_00005697.png new file mode 100644 index 0000000000000000000000000000000000000000..7a7dfb117e269c48b8da278dd2a55ace374fcce9 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02099601/ILSVRC2012_val_00005697.png differ diff --git a/src/taming-transformers/data/drin_depth/n02099712/ILSVRC2012_val_00023471.png b/src/taming-transformers/data/drin_depth/n02099712/ILSVRC2012_val_00023471.png new file mode 100644 index 0000000000000000000000000000000000000000..5169c340902711f7957b977bbdd6da25f1aa9f15 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02099712/ILSVRC2012_val_00023471.png differ diff --git a/src/taming-transformers/data/drin_depth/n02100877/ILSVRC2012_val_00039863.png b/src/taming-transformers/data/drin_depth/n02100877/ILSVRC2012_val_00039863.png new file mode 100644 index 0000000000000000000000000000000000000000..9ae67afaea45980e2c1f3c69920999a53b6b0a1a Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02100877/ILSVRC2012_val_00039863.png differ diff --git a/src/taming-transformers/data/drin_depth/n02101006/ILSVRC2012_val_00032333.png b/src/taming-transformers/data/drin_depth/n02101006/ILSVRC2012_val_00032333.png new file mode 100644 index 0000000000000000000000000000000000000000..0dfb99ace6cbb3751022ed8504bdab22334d95a8 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02101006/ILSVRC2012_val_00032333.png differ diff --git a/src/taming-transformers/data/drin_depth/n02101006/ILSVRC2012_val_00047325.png b/src/taming-transformers/data/drin_depth/n02101006/ILSVRC2012_val_00047325.png new file mode 100644 index 0000000000000000000000000000000000000000..6d2c611d49b16196512b6c9b63ecab4c60433f75 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02101006/ILSVRC2012_val_00047325.png differ diff --git a/src/taming-transformers/data/drin_depth/n02101556/ILSVRC2012_val_00030540.png b/src/taming-transformers/data/drin_depth/n02101556/ILSVRC2012_val_00030540.png new file mode 100644 index 0000000000000000000000000000000000000000..ca4df4b7bb29ef32dd0077eae410d0a3d2007474 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02101556/ILSVRC2012_val_00030540.png differ diff --git a/src/taming-transformers/data/drin_depth/n02102318/ILSVRC2012_val_00024691.png b/src/taming-transformers/data/drin_depth/n02102318/ILSVRC2012_val_00024691.png new file mode 100644 index 0000000000000000000000000000000000000000..334f3045af2683774dc66c1fcb28b04367abc83c Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02102318/ILSVRC2012_val_00024691.png differ diff --git a/src/taming-transformers/data/drin_depth/n02105505/ILSVRC2012_val_00031252.png b/src/taming-transformers/data/drin_depth/n02105505/ILSVRC2012_val_00031252.png new file mode 100644 index 0000000000000000000000000000000000000000..f526968ec1cce1019775f8b8974c1594d496d857 Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02105505/ILSVRC2012_val_00031252.png differ diff --git a/src/taming-transformers/data/drin_depth/n02110627/ILSVRC2012_val_00008310.png b/src/taming-transformers/data/drin_depth/n02110627/ILSVRC2012_val_00008310.png new file mode 100644 index 0000000000000000000000000000000000000000..290ca590a02022d5c25543350049aebf8a0c8dcd Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02110627/ILSVRC2012_val_00008310.png differ diff --git a/src/taming-transformers/data/drin_depth/n02111889/ILSVRC2012_val_00042625.png b/src/taming-transformers/data/drin_depth/n02111889/ILSVRC2012_val_00042625.png new file mode 100644 index 0000000000000000000000000000000000000000..4859c0645d37b31673686be89d2511e8db8504fc Binary files /dev/null and b/src/taming-transformers/data/drin_depth/n02111889/ILSVRC2012_val_00042625.png differ diff --git a/src/taming-transformers/data/drin_examples.txt b/src/taming-transformers/data/drin_examples.txt new file mode 100644 index 0000000000000000000000000000000000000000..aee7b4267abe081b44d503e1854e083147b41772 --- /dev/null +++ b/src/taming-transformers/data/drin_examples.txt @@ -0,0 +1,25 @@ +n02100877/ILSVRC2012_val_00039863.JPEG +n02085782/ILSVRC2012_val_00012298.JPEG +n02102318/ILSVRC2012_val_00024691.JPEG +n02105505/ILSVRC2012_val_00031252.JPEG +n01819313/ILSVRC2012_val_00003068.JPEG +n02101006/ILSVRC2012_val_00047325.JPEG +n01828970/ILSVRC2012_val_00046802.JPEG +n01843065/ILSVRC2012_val_00022439.JPEG +n01847000/ILSVRC2012_val_00022364.JPEG +n02089973/ILSVRC2012_val_00000028.JPEG +n01828970/ILSVRC2012_val_00001336.JPEG +n02101006/ILSVRC2012_val_00032333.JPEG +n02101556/ILSVRC2012_val_00030540.JPEG +n02093256/ILSVRC2012_val_00046547.JPEG +n02086646/ILSVRC2012_val_00011473.JPEG +n02099601/ILSVRC2012_val_00005697.JPEG +n01820546/ILSVRC2012_val_00047491.JPEG +n02088466/ILSVRC2012_val_00013651.JPEG +n02111889/ILSVRC2012_val_00042625.JPEG +n02099712/ILSVRC2012_val_00023471.JPEG +n01820546/ILSVRC2012_val_00034784.JPEG +n02110627/ILSVRC2012_val_00008310.JPEG +n02096294/ILSVRC2012_val_00042133.JPEG +n01828970/ILSVRC2012_val_00008236.JPEG +n01795545/ILSVRC2012_val_00023344.JPEG diff --git a/src/taming-transformers/data/drin_images/n01795545/ILSVRC2012_val_00023344.JPEG b/src/taming-transformers/data/drin_images/n01795545/ILSVRC2012_val_00023344.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..8be40cd994ef269be64f6ab366f8eebbf0604189 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n01795545/ILSVRC2012_val_00023344.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n01819313/ILSVRC2012_val_00003068.JPEG b/src/taming-transformers/data/drin_images/n01819313/ILSVRC2012_val_00003068.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..93aa80ce279c01f794abf7e605186b4d2f1a9493 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n01819313/ILSVRC2012_val_00003068.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n01820546/ILSVRC2012_val_00034784.JPEG b/src/taming-transformers/data/drin_images/n01820546/ILSVRC2012_val_00034784.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..ee2475bfc6c6a433af0570c1586b47b3e1c2096b Binary files /dev/null and b/src/taming-transformers/data/drin_images/n01820546/ILSVRC2012_val_00034784.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n01820546/ILSVRC2012_val_00047491.JPEG b/src/taming-transformers/data/drin_images/n01820546/ILSVRC2012_val_00047491.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..52b088cad04871d592cf8f301999b80c5ce2a781 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n01820546/ILSVRC2012_val_00047491.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n01828970/ILSVRC2012_val_00001336.JPEG b/src/taming-transformers/data/drin_images/n01828970/ILSVRC2012_val_00001336.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..0545b6ca34444386a2b44564b67783484b4dcfe7 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n01828970/ILSVRC2012_val_00001336.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n01828970/ILSVRC2012_val_00008236.JPEG b/src/taming-transformers/data/drin_images/n01828970/ILSVRC2012_val_00008236.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..9245278802ec124690ba8048cd32b9ea3256cbc5 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n01828970/ILSVRC2012_val_00008236.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n01828970/ILSVRC2012_val_00046802.JPEG b/src/taming-transformers/data/drin_images/n01828970/ILSVRC2012_val_00046802.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..40fc0b7ca438775a18c4498d0abb0c048648e0c7 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n01828970/ILSVRC2012_val_00046802.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n01843065/ILSVRC2012_val_00022439.JPEG b/src/taming-transformers/data/drin_images/n01843065/ILSVRC2012_val_00022439.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..a986cbe422aa448bcf360d6dc6b8ffb60d527db5 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n01843065/ILSVRC2012_val_00022439.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n01847000/ILSVRC2012_val_00022364.JPEG b/src/taming-transformers/data/drin_images/n01847000/ILSVRC2012_val_00022364.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..8bfd129a98d33c3c8b84b1b2f6eee3a5d53e00f3 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n01847000/ILSVRC2012_val_00022364.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02085782/ILSVRC2012_val_00012298.JPEG b/src/taming-transformers/data/drin_images/n02085782/ILSVRC2012_val_00012298.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..2d6cc8b9b58081fd8dde9a13eb0b2e3fe427e0c1 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02085782/ILSVRC2012_val_00012298.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02086646/ILSVRC2012_val_00011473.JPEG b/src/taming-transformers/data/drin_images/n02086646/ILSVRC2012_val_00011473.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..bc304d73c7fa93f1905acfe6bf9ede5bb378f6dd Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02086646/ILSVRC2012_val_00011473.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02088466/ILSVRC2012_val_00013651.JPEG b/src/taming-transformers/data/drin_images/n02088466/ILSVRC2012_val_00013651.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..0a5006e5ea2fc30817f59b9a9c8ca510249d6de5 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02088466/ILSVRC2012_val_00013651.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02089973/ILSVRC2012_val_00000028.JPEG b/src/taming-transformers/data/drin_images/n02089973/ILSVRC2012_val_00000028.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..1fbcd80a848d7b3ef9395a1e755b8a56ce8eefe0 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02089973/ILSVRC2012_val_00000028.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02093256/ILSVRC2012_val_00046547.JPEG b/src/taming-transformers/data/drin_images/n02093256/ILSVRC2012_val_00046547.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..a0282b5afc31f8909ed6757e47bd537de6082dfd Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02093256/ILSVRC2012_val_00046547.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02096294/ILSVRC2012_val_00042133.JPEG b/src/taming-transformers/data/drin_images/n02096294/ILSVRC2012_val_00042133.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..ccb669dc28e6558fb7017984d8b7cf9d833e6c17 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02096294/ILSVRC2012_val_00042133.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02099601/ILSVRC2012_val_00005697.JPEG b/src/taming-transformers/data/drin_images/n02099601/ILSVRC2012_val_00005697.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..44d202e4dbe2b7b3d3382377c12f3eca02cd3569 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02099601/ILSVRC2012_val_00005697.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02099712/ILSVRC2012_val_00023471.JPEG b/src/taming-transformers/data/drin_images/n02099712/ILSVRC2012_val_00023471.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..f64b46bdf6c3f99f93de7d5f0faf4cd57dc5d690 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02099712/ILSVRC2012_val_00023471.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02100877/ILSVRC2012_val_00039863.JPEG b/src/taming-transformers/data/drin_images/n02100877/ILSVRC2012_val_00039863.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..31893dac4ca74f731cb35e4cccd538f7593596e0 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02100877/ILSVRC2012_val_00039863.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02101006/ILSVRC2012_val_00032333.JPEG b/src/taming-transformers/data/drin_images/n02101006/ILSVRC2012_val_00032333.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..0fbb7d7cdefc03002fd1816ac62f3c8ea7c4c980 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02101006/ILSVRC2012_val_00032333.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02101006/ILSVRC2012_val_00047325.JPEG b/src/taming-transformers/data/drin_images/n02101006/ILSVRC2012_val_00047325.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..515b8060385b3636662d622287166f093be21068 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02101006/ILSVRC2012_val_00047325.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02101556/ILSVRC2012_val_00030540.JPEG b/src/taming-transformers/data/drin_images/n02101556/ILSVRC2012_val_00030540.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..898b0192dc3aead1e20fb8a9ad3fbf3fe1fef37f Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02101556/ILSVRC2012_val_00030540.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02102318/ILSVRC2012_val_00024691.JPEG b/src/taming-transformers/data/drin_images/n02102318/ILSVRC2012_val_00024691.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..6c059a394019ee54f766e66fb943d328a4957b20 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02102318/ILSVRC2012_val_00024691.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02105505/ILSVRC2012_val_00031252.JPEG b/src/taming-transformers/data/drin_images/n02105505/ILSVRC2012_val_00031252.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..8c84d30ae56f3810c491ac6ac90c2be1d3f5fb91 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02105505/ILSVRC2012_val_00031252.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02110627/ILSVRC2012_val_00008310.JPEG b/src/taming-transformers/data/drin_images/n02110627/ILSVRC2012_val_00008310.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..1a0752a1650636d647f58454e4a5e67cbf81bcb3 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02110627/ILSVRC2012_val_00008310.JPEG differ diff --git a/src/taming-transformers/data/drin_images/n02111889/ILSVRC2012_val_00042625.JPEG b/src/taming-transformers/data/drin_images/n02111889/ILSVRC2012_val_00042625.JPEG new file mode 100644 index 0000000000000000000000000000000000000000..1d006eb9f065490ccc4895fba33fc5f9e9c2bc63 Binary files /dev/null and b/src/taming-transformers/data/drin_images/n02111889/ILSVRC2012_val_00042625.JPEG differ diff --git a/src/taming-transformers/data/ffhqtrain.txt b/src/taming-transformers/data/ffhqtrain.txt new file mode 100644 index 0000000000000000000000000000000000000000..59729b1e904b7d1ad22699049feb33029661d82f --- /dev/null +++ b/src/taming-transformers/data/ffhqtrain.txt @@ -0,0 +1,60000 @@ +52535.png +59777.png +34697.png +02469.png +14829.png +30422.png +67376.png +33750.png +53892.png +28195.png +29092.png +52892.png +44199.png +58925.png +64331.png +34247.png +19821.png +51546.png +54387.png +09355.png +40638.png +47508.png +37287.png +37815.png +37586.png +44148.png +30275.png +49542.png +12843.png +53820.png +40411.png +51095.png +55788.png +33199.png +04083.png +03557.png +36146.png +36803.png +49914.png +09730.png +60284.png +18145.png +59598.png +28986.png +16960.png +41184.png +06653.png +45879.png +26625.png +20460.png +37634.png +25341.png +61836.png +60843.png +04638.png +09380.png +03584.png +21989.png +49175.png +55568.png +14356.png +16415.png +21576.png +25995.png +52520.png +10997.png +50881.png +16764.png +60844.png +53804.png +63305.png +25562.png +29774.png +65947.png +36260.png +33847.png +26168.png +31586.png +25423.png +27633.png +13473.png +30098.png +04337.png +46297.png +08041.png +45153.png +17463.png +06097.png +19116.png +44313.png +69680.png +53047.png +51170.png +12952.png +04056.png +46668.png +69890.png +57889.png +22130.png +35083.png +28697.png +57492.png +38531.png +03872.png +22232.png +18883.png +21357.png +21687.png +60244.png +22987.png +55705.png +59117.png +15646.png +67692.png +52587.png +52456.png +08461.png +34961.png +02420.png +36689.png +16341.png +66524.png +32318.png +57991.png +67679.png +01911.png +20660.png +48625.png +21900.png +47505.png +63299.png +34464.png +26388.png +51854.png +31311.png +69621.png +20803.png +21391.png +56788.png +00250.png +61010.png +27029.png +30810.png +24078.png +18905.png +49148.png +19461.png +35706.png +63627.png +27947.png +21652.png +16875.png +20534.png +04474.png +20535.png +57561.png +46448.png +38624.png +67007.png +25358.png +28305.png +23822.png +43910.png +20700.png +38890.png +31623.png +53657.png +60124.png +64627.png +32896.png +69387.png +17486.png +48711.png +19970.png +29882.png +13363.png +36552.png +31589.png +04040.png +05536.png +65326.png +29699.png +04884.png +64998.png +59344.png +24038.png +38203.png +48152.png +48885.png +09349.png +39783.png +05636.png +34402.png +29625.png +66760.png +66597.png +33160.png +52762.png +00151.png +67803.png +01408.png +37447.png +29529.png +53809.png +68260.png +37944.png +61284.png +32497.png +23103.png +65183.png +60290.png +54304.png +60080.png +54616.png +23360.png +29525.png +41568.png +05711.png +08848.png +44903.png +41145.png +67348.png +57224.png +41609.png +18507.png +21496.png +59036.png +40188.png +29577.png +05212.png +61058.png +24684.png +53059.png +56698.png +37483.png +19772.png +39757.png +13897.png +41177.png +01392.png +26986.png +64915.png +43519.png +03478.png +54628.png +39744.png +51364.png +61183.png +09559.png +42797.png +15951.png +56550.png +05707.png +67448.png +37380.png +55386.png +59176.png +58044.png +56013.png +37122.png +08195.png +45014.png +05745.png +60382.png +68319.png +56560.png +20394.png +03237.png +39178.png +62465.png +01866.png +08513.png +31446.png +36118.png +69921.png +55445.png +10281.png +49258.png +29044.png +02639.png +15494.png +51642.png +38274.png +62907.png +24182.png +55150.png +22675.png +09207.png +34312.png +57009.png +06598.png +11338.png +46147.png +02113.png +46091.png +69552.png +09117.png +68434.png +20289.png +28363.png +55877.png +43784.png +68390.png +22917.png +16518.png +68357.png +67361.png +25367.png +55525.png +33872.png +47747.png +18206.png +50114.png +02224.png +66247.png +13615.png +12836.png +21375.png +30518.png +04615.png +12601.png +17517.png +69197.png +65074.png +69247.png +36326.png +69800.png +02315.png +28701.png +01488.png +30097.png +39918.png +44528.png +04117.png +67057.png +59975.png +20094.png +39576.png +22919.png +68018.png +25651.png +59933.png +39812.png +62214.png +42890.png +38571.png +68547.png +17625.png +50038.png +39970.png +25791.png +01376.png +49956.png +15521.png +06905.png +55981.png +07131.png +45746.png +33458.png +03599.png +65493.png +00690.png +21791.png +66942.png +03697.png +19474.png +51181.png +33464.png +63350.png +58489.png +11401.png +63991.png +59545.png +49954.png +37778.png +69814.png +14821.png +41111.png +14842.png +04154.png +30027.png +58166.png +38674.png +54540.png +58827.png +21237.png +16017.png +21575.png +43057.png +36496.png +38730.png +61489.png +39388.png +51820.png +57870.png +31710.png +02204.png +07506.png +68322.png +12939.png +61819.png +36695.png +15207.png +52122.png +60910.png +57109.png +12335.png +42726.png +69080.png +32217.png +23655.png +15776.png +34654.png +09870.png +01797.png +51123.png +24970.png +55676.png +61881.png +61913.png +69054.png +45782.png +65845.png +35948.png +51916.png +65622.png +38710.png +01739.png +47967.png +49530.png +58540.png +33041.png +27157.png +62696.png +38765.png +35405.png +09630.png +51187.png +05913.png +41858.png +24787.png +25963.png +10858.png +14846.png +00569.png +63066.png +10804.png +34469.png +26896.png +25745.png +59121.png +52505.png +43458.png +60233.png +15817.png +23651.png +37496.png +17720.png +00664.png +54237.png +62535.png +57006.png +13916.png +43619.png +14234.png +16622.png +62399.png +40589.png +49857.png +13040.png +63737.png +11968.png +04759.png +28935.png +37636.png +65276.png +08155.png +02762.png +62241.png +06288.png +31416.png +55158.png +69039.png +67438.png +28354.png +13847.png +62631.png +56467.png +38277.png +49958.png +51205.png +14012.png +40015.png +69162.png +04881.png +24323.png +47427.png +18361.png +18048.png +24539.png +32357.png +58329.png +02141.png +12409.png +21263.png +47606.png +29924.png +36259.png +37388.png +27922.png +68179.png +59746.png +42173.png +60496.png +03616.png +56110.png +12905.png +18619.png +07837.png +25646.png +17930.png +20791.png +14636.png +51143.png +35119.png +42341.png +27863.png +63988.png +44129.png +50692.png +58535.png +07871.png +44726.png +37861.png +63112.png +12539.png +34537.png +25236.png +10510.png +55833.png +68722.png +43381.png +03983.png +39042.png +49437.png +16636.png +48522.png +62247.png +68840.png +62226.png +67945.png +24335.png +38414.png +11412.png +38145.png +53530.png +21998.png +07144.png +57498.png +14985.png +44117.png +29966.png +53020.png +61650.png +10991.png +04972.png +50475.png +64583.png +23009.png +06915.png +03564.png +46684.png +32645.png +14693.png +47882.png +21243.png +19867.png +31042.png +60756.png +54190.png +38544.png +28665.png +22516.png +29808.png +14789.png +59747.png +13046.png +26967.png +43720.png +63718.png +16985.png +05593.png +64688.png +29551.png +60678.png +52039.png +47921.png +38578.png +22269.png +35779.png +50458.png +07388.png +29185.png +28231.png +48307.png +67286.png +29450.png +59076.png +49565.png +12152.png +08537.png +11211.png +34243.png +11895.png +03378.png +65091.png +33662.png +52250.png +27172.png +67324.png +27659.png +37458.png +29850.png +43514.png +11844.png +07071.png +14893.png +58967.png +13459.png +12822.png +67632.png +29941.png +24196.png +01326.png +44229.png +03986.png +64141.png +52983.png +67175.png +04200.png +64571.png +30674.png +02925.png +68564.png +64516.png +25443.png +05321.png +36734.png +52378.png +69083.png +23813.png +69539.png +24159.png +00799.png +46830.png +56568.png +25022.png +19350.png +37888.png +36575.png +07358.png +38413.png +08944.png +07737.png +02386.png +25489.png +56364.png +05808.png +41755.png +64326.png +30454.png +45647.png +13690.png +46817.png +08280.png +04028.png +01466.png +60206.png +00079.png +53104.png +35322.png +41265.png +66929.png +68653.png +60625.png +29917.png +00257.png +48405.png +54038.png +04381.png +36663.png +61800.png +32455.png +12398.png +41585.png +69440.png +20767.png +69323.png +59114.png +26503.png +57149.png +56885.png +63495.png +33816.png +20667.png +11273.png +55526.png +06243.png +58174.png +53988.png +05122.png +27661.png +46420.png +45525.png +41277.png +05726.png +31205.png +00272.png +49387.png +66806.png +56082.png +44666.png +27081.png +68343.png +39925.png +60740.png +24795.png +64250.png +63217.png +01980.png +67349.png +61998.png +64373.png +07341.png +35103.png +20788.png +38140.png +60672.png +24997.png +03474.png +22690.png +12691.png +39707.png +57537.png +23174.png +20341.png +62332.png +32185.png +16318.png +15101.png +50423.png +18054.png +61885.png +57769.png +23200.png +31391.png +38359.png +36568.png +26979.png +16581.png +35708.png +53080.png +67554.png +24072.png +62183.png +68068.png +23532.png +52857.png +20264.png +04784.png +32350.png +64254.png +57461.png +36137.png +23121.png +28327.png +29694.png +57614.png +33645.png +62710.png +58543.png +01619.png +33622.png +45025.png +22039.png +35925.png +51389.png +65537.png +22555.png +66117.png +09130.png +44532.png +23406.png +49091.png +42585.png +43838.png +11351.png +19750.png +63165.png +26385.png +63158.png +32569.png +47242.png +07033.png +26962.png +14272.png +06274.png +29649.png +41514.png +14257.png +24256.png +34722.png +13436.png +42091.png +22864.png +48986.png +04493.png +33682.png +22393.png +42344.png +59115.png +28872.png +46465.png +25501.png +17223.png +47500.png +15780.png +01953.png +18786.png +13240.png +05368.png +35360.png +31905.png +27353.png +19420.png +33573.png +18453.png +50581.png +62599.png +54408.png +21220.png +54600.png +21542.png +25667.png +17044.png +02061.png +63464.png +17595.png +63086.png +05652.png +32984.png +23691.png +09464.png +66673.png +65548.png +25973.png +51135.png +68984.png +20979.png +55609.png +68268.png +05320.png +62074.png +42746.png +05688.png +45569.png +22477.png +28623.png +44151.png +62110.png +54213.png +23932.png +28265.png +54451.png +04661.png +46288.png +15413.png +34094.png +63989.png +26238.png +33452.png +30492.png +53076.png +27728.png +12312.png +32483.png +14928.png +02632.png +21400.png +68493.png +27206.png +27784.png +66594.png +20391.png +07462.png +52886.png +51796.png +25414.png +59738.png +41691.png +13851.png +47818.png +37852.png +02130.png +66926.png +15275.png +36347.png +07806.png +34566.png +21663.png +47859.png +46024.png +14292.png +44704.png +65265.png +62275.png +65255.png +63871.png +65875.png +04037.png +04304.png +17378.png +02584.png +32273.png +66311.png +43725.png +56249.png +01060.png +09034.png +12961.png +68816.png +24248.png +61797.png +53254.png +14161.png +23699.png +24632.png +53141.png +18679.png +52021.png +24546.png +21194.png +48887.png +26335.png +47726.png +54380.png +27407.png +47377.png +30217.png +30980.png +24617.png +33087.png +48052.png +07019.png +25559.png +39281.png +09556.png +20245.png +26598.png +17246.png +20590.png +56047.png +14568.png +53882.png +25688.png +33569.png +53932.png +61577.png +44644.png +35491.png +33202.png +23410.png +18079.png +40681.png +57207.png +31522.png +44472.png +33132.png +61048.png +63251.png +34465.png +65270.png +10414.png +51571.png +01350.png +48902.png +00875.png +66700.png +12589.png +13376.png +33281.png +68378.png +63788.png +60911.png +43567.png +28225.png +64180.png +08156.png +16766.png +48977.png +33249.png +42166.png +52729.png +54113.png +29438.png +32624.png +51379.png +07485.png +49870.png +46259.png +14205.png +20397.png +35817.png +27424.png +17759.png +65651.png +69123.png +13079.png +43104.png +60814.png +38547.png +43913.png +08026.png +06674.png +48189.png +62877.png +17676.png +25820.png +40052.png +27936.png +13969.png +36667.png +69188.png +50562.png +61380.png +20336.png +48210.png +27938.png +62501.png +02793.png +52922.png +16251.png +13877.png +47225.png +45188.png +15684.png +17578.png +08262.png +07869.png +33463.png +01711.png +59974.png +27650.png +34966.png +16704.png +04570.png +31578.png +25105.png +46867.png +00883.png +51589.png +21137.png +33865.png +69079.png +14874.png +43938.png +39882.png +27351.png +40469.png +50266.png +61084.png +15625.png +69435.png +69215.png +58218.png +36678.png +29856.png +03250.png +47375.png +58228.png +30678.png +27592.png +03969.png +41381.png +66994.png +29904.png +26824.png +40921.png +17449.png +27952.png +16859.png +45322.png +06474.png +34717.png +09172.png +27613.png +54547.png +47353.png +21562.png +20891.png +56892.png +41174.png +51232.png +64102.png +47153.png +32899.png +35977.png +43125.png +56655.png +15862.png +54845.png +52696.png +55280.png +41241.png +45251.png +36987.png +63505.png +58420.png +32822.png +20549.png +21673.png +07991.png +33438.png +20634.png +20481.png +16290.png +46945.png +29653.png +35204.png +23232.png +44145.png +39136.png +49378.png +52407.png +05966.png +50224.png +45270.png +22196.png +27709.png +37305.png +31316.png +48895.png +63153.png +11963.png +33124.png +04839.png +69731.png +56379.png +18108.png +54187.png +34905.png +67831.png +02637.png +68645.png +57014.png +14223.png +21466.png +14343.png +43691.png +64875.png +51704.png +61632.png +15322.png +37121.png +05089.png +03472.png +61011.png +13486.png +14555.png +21743.png +43248.png +31685.png +29477.png +11840.png +07650.png +60811.png +52326.png +34642.png +52575.png +05416.png +50162.png +64142.png +55587.png +57246.png +62904.png +29693.png +45941.png +04088.png +11699.png +39870.png +65817.png +67078.png +69149.png +08907.png +38079.png +19615.png +69932.png +04866.png +55549.png +48606.png +38223.png +55013.png +27093.png +39335.png +45687.png +61267.png +25421.png +63145.png +28524.png +11198.png +65531.png +45413.png +37607.png +48528.png +30498.png +43009.png +08089.png +21255.png +11891.png +33454.png +52441.png +58295.png +15148.png +12554.png +67809.png +22632.png +42938.png +61485.png +45109.png +11225.png +29892.png +40394.png +34494.png +64536.png +46510.png +04956.png +01188.png +61990.png +32219.png +26788.png +59662.png +23033.png +47271.png +16174.png +29532.png +35289.png +57047.png +46784.png +48555.png +54312.png +46791.png +60692.png +14000.png +65724.png +60241.png +03954.png +56145.png +23476.png +00732.png +61796.png +04614.png +10145.png +25118.png +36672.png +59208.png +55236.png +16767.png +56418.png +62772.png +53562.png +45098.png +35835.png +17491.png +12447.png +66646.png +09628.png +53810.png +61687.png +68950.png +17310.png +66356.png +61961.png +09518.png +14800.png +59141.png +49887.png +68141.png +04656.png +63181.png +08594.png +47658.png +64283.png +19370.png +03391.png +00745.png +69712.png +24204.png +36302.png +66236.png +13411.png +20193.png +37544.png +58327.png +00849.png +48389.png +16548.png +06234.png +53035.png +36057.png +16984.png +64224.png +44361.png +25363.png +31936.png +29526.png +61401.png +15612.png +64454.png +50711.png +69829.png +23125.png +27942.png +12352.png +69924.png +51408.png +30742.png +27128.png +36589.png +02162.png +58214.png +12234.png +57708.png +22028.png +69096.png +03913.png +19477.png +56524.png +13675.png +03385.png +02010.png +04164.png +63460.png +40179.png +50961.png +63248.png +26673.png +36722.png +56024.png +37582.png +00947.png +66497.png +02440.png +43305.png +69394.png +55057.png +24655.png +35385.png +44742.png +64033.png +36240.png +42345.png +49049.png +19113.png +42702.png +18025.png +68027.png +00467.png +15495.png +08271.png +29690.png +63529.png +44663.png +67755.png +68031.png +03311.png +59489.png +67493.png +00180.png +41626.png +35062.png +60333.png +48968.png +26468.png +54115.png +44748.png +49119.png +38207.png +12640.png +49473.png +63603.png +20182.png +54838.png +04467.png +61880.png +45575.png +28843.png +02717.png +02783.png +62702.png +42920.png +55507.png +69885.png +17257.png +27546.png +08475.png +42131.png +00857.png +26084.png +36524.png +28128.png +45107.png +39348.png +68424.png +39567.png +47131.png +29890.png +40235.png +34359.png +03309.png +53647.png +07848.png +33195.png +16218.png +60004.png +13955.png +15296.png +34549.png +07773.png +33535.png +36701.png +05455.png +03410.png +63085.png +20425.png +44625.png +38107.png +16674.png +32932.png +39353.png +01042.png +22837.png +15093.png +02778.png +38180.png +52082.png +44863.png +15436.png +08171.png +22397.png +22115.png +32618.png +08885.png +44196.png +19401.png +09538.png +14979.png +16640.png +27143.png +15025.png +68792.png +23210.png +09204.png +28998.png +41753.png +53031.png +50613.png +31903.png +66391.png +14677.png +67173.png +16949.png +52476.png +16916.png +50968.png +67056.png +07416.png +49219.png +15604.png +62194.png +38293.png +30619.png +12646.png +16715.png +16181.png +59223.png +16201.png +38516.png +24980.png +67412.png +24180.png +52188.png +41909.png +02322.png +33337.png +34329.png +17116.png +26476.png +54076.png +11700.png +41120.png +34811.png +12388.png +47238.png +61745.png +52192.png +03086.png +24070.png +44207.png +40392.png +30135.png +66696.png +21323.png +02569.png +34784.png +58597.png +28082.png +45094.png +23190.png +02692.png +32127.png +47721.png +22248.png +59454.png +44394.png +14148.png +01954.png +67953.png +03488.png +39526.png +17459.png +10536.png +46883.png +55942.png +12408.png +35666.png +54449.png +53149.png +11375.png +14828.png +64182.png +15595.png +42717.png +50972.png +07977.png +39449.png +16992.png +20023.png +59513.png +66682.png +64028.png +36717.png +47644.png +17622.png +28137.png +49103.png +19236.png +00192.png +63203.png +33839.png +65359.png +06379.png +52636.png +58536.png +18641.png +42533.png +36217.png +45611.png +22939.png +63545.png +45173.png +11829.png +36415.png +54215.png +24255.png +47535.png +12558.png +52325.png +41577.png +11107.png +19483.png +52264.png +14509.png +42913.png +12605.png +03319.png +12384.png +37291.png +28499.png +16131.png +46369.png +69900.png +35644.png +11939.png +69366.png +23653.png +02848.png +08578.png +27612.png +50750.png +56510.png +57327.png +19264.png +02203.png +34143.png +13537.png +54080.png +00626.png +23246.png +25768.png +19408.png +66848.png +45397.png +15414.png +31053.png +11816.png +03197.png +69589.png +21965.png +25074.png +23140.png +38916.png +20086.png +19330.png +10118.png +24713.png +23151.png +66578.png +06218.png +59233.png +29988.png +69133.png +48604.png +02851.png +46438.png +61900.png +12347.png +43153.png +43621.png +66121.png +19597.png +46457.png +43260.png +62831.png +37118.png +38941.png +11186.png +37505.png +50006.png +53726.png +67409.png +23114.png +56567.png +68105.png +68581.png +46975.png +66353.png +52446.png +53410.png +16608.png +04423.png +02314.png +43279.png +48792.png +65137.png +02877.png +69248.png +13719.png +26139.png +35074.png +53681.png +48705.png +10458.png +11594.png +14155.png +64655.png +11978.png +30427.png +00390.png +17129.png +15540.png +19673.png +31804.png +63246.png +39340.png +57055.png +52177.png +00265.png +63583.png +53054.png +44340.png +58144.png +21611.png +06424.png +46761.png +34442.png +65149.png +60732.png +41431.png +19674.png +12089.png +33549.png +11094.png +38295.png +40059.png +20556.png +36413.png +23572.png +26067.png +36452.png +57934.png +14349.png +00197.png +61879.png +38428.png +48816.png +07574.png +07325.png +14092.png +38045.png +03702.png +17657.png +03103.png +37179.png +42947.png +55740.png +07092.png +45641.png +35280.png +13791.png +35585.png +23618.png +51371.png +33321.png +56135.png +43192.png +23693.png +56158.png +63666.png +26360.png +60396.png +48524.png +18015.png +16849.png +44111.png +13996.png +01729.png +03337.png +45718.png +05856.png +42256.png +24354.png +50760.png +30104.png +31062.png +14224.png +34688.png +13578.png +42246.png +25978.png +61480.png +53592.png +31537.png +50090.png +10553.png +32100.png +07064.png +50963.png +20177.png +63135.png +68292.png +01274.png +49714.png +34145.png +31756.png +55615.png +50550.png +55044.png +33129.png +26571.png +34217.png +28234.png +21893.png +08523.png +03985.png +50461.png +60759.png +35007.png +59015.png +46659.png +53007.png +28722.png +39410.png +66438.png +57308.png +61748.png +03647.png +14803.png +03165.png +45756.png +07648.png +09672.png +32309.png +00519.png +68375.png +44450.png +02488.png +54362.png +19390.png +29720.png +15525.png +19604.png +43345.png +58273.png +58865.png +30835.png +57592.png +29249.png +55841.png +59484.png +56897.png +38057.png +15917.png +56204.png +08077.png +25181.png +46460.png +40560.png +08664.png +42135.png +03809.png +59471.png +19195.png +45918.png +03300.png +65361.png +20809.png +42996.png +25289.png +01859.png +29278.png +17734.png +61450.png +34271.png +45139.png +20902.png +00522.png +33389.png +02089.png +58891.png +28272.png +33455.png +21208.png +37332.png +27570.png +29151.png +37921.png +11897.png +58257.png +16156.png +35559.png +02890.png +67577.png +38068.png +33225.png +34927.png +11029.png +04452.png +02524.png +37409.png +02867.png +36080.png +01691.png +10213.png +61685.png +03181.png +02693.png +66685.png +46760.png +25822.png +41030.png +43158.png +25910.png +65347.png +56083.png +16157.png +21042.png +38628.png +67161.png +56325.png +67653.png +16077.png +45854.png +56780.png +29507.png +18799.png +58424.png +51010.png +35222.png +42128.png +36752.png +64644.png +40122.png +56884.png +23565.png +41764.png +67367.png +48249.png +00006.png +03579.png +15319.png +31459.png +02379.png +39643.png +02937.png +42468.png +02365.png +68833.png +54428.png +12683.png +37068.png +68284.png +31796.png +53262.png +35960.png +00084.png +58631.png +12202.png +22104.png +19124.png +50761.png +38777.png +50478.png +69869.png +49052.png +05356.png +65065.png +27105.png +42780.png +56766.png +22213.png +67516.png +66264.png +31665.png +03409.png +10748.png +04907.png +61396.png +61021.png +47175.png +10492.png +51398.png +68463.png +33509.png +38268.png +51278.png +18254.png +63469.png +12302.png +24542.png +49551.png +12697.png +09885.png +29261.png +61059.png +16793.png +12547.png +46758.png +17406.png +49723.png +51006.png +33883.png +08374.png +36485.png +51631.png +63348.png +66621.png +14341.png +54166.png +04322.png +64341.png +57031.png +61484.png +33603.png +24218.png +05242.png +63687.png +39039.png +54199.png +41981.png +59340.png +42601.png +60812.png +40085.png +37470.png +24127.png +05430.png +50735.png +53305.png +41233.png +22743.png +21997.png +25557.png +31946.png +57355.png +38564.png +17829.png +12536.png +21764.png +53292.png +06735.png +05200.png +45927.png +67875.png +63906.png +25214.png +60014.png +51137.png +66201.png +63275.png +34433.png +30396.png +52103.png +01227.png +67805.png +25967.png +58694.png +24562.png +15213.png +22252.png +41978.png +33808.png +68300.png +01433.png +23743.png +45533.png +12912.png +04130.png +42315.png +37664.png +17344.png +21643.png +13342.png +00177.png +49776.png +47545.png +40983.png +60736.png +52879.png +14256.png +20893.png +32933.png +45466.png +16385.png +31081.png +31204.png +53033.png +39871.png +38729.png +54720.png +09604.png +19283.png +26913.png +21806.png +38308.png +19521.png +09723.png +39484.png +45531.png +50467.png +50167.png +20085.png +64654.png +59253.png +27110.png +54929.png +51238.png +12967.png +58019.png +18993.png +15133.png +09437.png +00539.png +45930.png +61775.png +63683.png +42408.png +43745.png +67335.png +46932.png +58190.png +62761.png +59901.png +46154.png +17114.png +27338.png +11177.png +21360.png +10824.png +52295.png +52546.png +09925.png +43695.png +26024.png +26998.png +07202.png +01303.png +51217.png +08222.png +35120.png +51930.png +05990.png +03326.png +42397.png +36439.png +53233.png +21422.png +37166.png +48158.png +22309.png +68210.png +09798.png +24544.png +33205.png +19939.png +13329.png +19817.png +43157.png +45729.png +46858.png +69764.png +07082.png +00313.png +36443.png +40368.png +33724.png +54990.png +26078.png +55200.png +03884.png +66011.png +34478.png +64952.png +18937.png +45281.png +24352.png +59863.png +19100.png +63370.png +53706.png +24211.png +45568.png +37726.png +26577.png +63402.png +14587.png +34394.png +20706.png +21012.png +29312.png +50559.png +68165.png +12783.png +05529.png +08495.png +65715.png +14956.png +18246.png +26006.png +40035.png +52022.png +64491.png +41552.png +02738.png +13529.png +42045.png +04796.png +65051.png +69537.png +30485.png +33725.png +47282.png +54723.png +64166.png +06245.png +59942.png +11334.png +56161.png +37889.png +09435.png +10196.png +18576.png +43121.png +37123.png +27964.png +19657.png +16956.png +62056.png +22736.png +43932.png +06367.png +52178.png +67587.png +62523.png +55014.png +46116.png +07418.png +41463.png +16814.png +30905.png +37916.png +36074.png +00853.png +55620.png +25180.png +55258.png +52621.png +37090.png +10671.png +31944.png +68981.png +13485.png +18382.png +28648.png +25516.png +10372.png +06145.png +45600.png +07448.png +52251.png +37142.png +69584.png +57044.png +64305.png +20139.png +27203.png +55290.png +57281.png +61569.png +11087.png +39014.png +42811.png +54711.png +35244.png +45421.png +23540.png +36941.png +37196.png +37576.png +01520.png +38641.png +36569.png +30645.png +35427.png +17933.png +04184.png +65466.png +65690.png +09439.png +20806.png +37862.png +42198.png +58459.png +09208.png +26663.png +20802.png +38247.png +30434.png +09442.png +49030.png +36395.png +08770.png +40755.png +44619.png +38302.png +48131.png +30838.png +42139.png +32908.png +52872.png +22780.png +06453.png +37937.png +45502.png +22176.png +22823.png +46660.png +01032.png +10594.png +26729.png +41281.png +37720.png +68050.png +12321.png +64550.png +10001.png +43575.png +31832.png +06806.png +25710.png +45242.png +20485.png +11865.png +06103.png +33767.png +59193.png +11850.png +00262.png +00149.png +00840.png +03170.png +35318.png +46935.png +63826.png +36307.png +35725.png +48669.png +08247.png +15270.png +65723.png +34031.png +04616.png +10881.png +27638.png +35651.png +22202.png +39756.png +05676.png +51279.png +47112.png +63750.png +13630.png +55074.png +07223.png +03211.png +30588.png +25234.png +68560.png +29215.png +07288.png +51291.png +45399.png +34944.png +59845.png +33489.png +52867.png +38894.png +17955.png +25295.png +08223.png +29341.png +06800.png +59459.png +33384.png +57419.png +61504.png +66591.png +20604.png +56691.png +42813.png +63537.png +10150.png +11649.png +44276.png +26730.png +05783.png +41019.png +58149.png +42870.png +05732.png +63173.png +16657.png +20017.png +06870.png +31350.png +24484.png +69457.png +02416.png +53432.png +04030.png +31880.png +63944.png +35057.png +62575.png +69071.png +67084.png +03073.png +04660.png +22020.png +42202.png +65285.png +34545.png +40344.png +53198.png +55288.png +11678.png +61012.png +58595.png +36310.png +00418.png +08328.png +59576.png +34522.png +47826.png +16140.png +02878.png +18609.png +43993.png +63998.png +10583.png +65180.png +22089.png +29543.png +55467.png +30708.png +52365.png +37575.png +28733.png +24077.png +66305.png +30804.png +22893.png +38420.png +47995.png +11654.png +13987.png +16289.png +59447.png +36535.png +41655.png +50913.png +16159.png +11837.png +56737.png +03671.png +47372.png +33575.png +30975.png +63059.png +39062.png +24482.png +13361.png +35141.png +03425.png +09886.png +09599.png +66985.png +06745.png +44473.png +55315.png +23518.png +36044.png +42248.png +00430.png +66783.png +65784.png +41262.png +26731.png +60076.png +59895.png +13285.png +63585.png +31613.png +00475.png +08653.png +48896.png +55252.png +58821.png +30504.png +50914.png +04676.png +12915.png +57789.png +03657.png +46087.png +68015.png +63720.png +44092.png +10844.png +00763.png +36018.png +48700.png +41354.png +29251.png +20898.png +36446.png +02648.png +37912.png +12426.png +52989.png +30631.png +17179.png +25433.png +51064.png +17050.png +23351.png +10012.png +09560.png +03822.png +10695.png +12250.png +14763.png +54515.png +37672.png +27615.png +25991.png +08957.png +38598.png +67329.png +20943.png +31401.png +60912.png +16090.png +49620.png +59719.png +46486.png +64408.png +56569.png +44306.png +43255.png +29083.png +06731.png +10504.png +33686.png +60893.png +66417.png +06216.png +46754.png +52237.png +06924.png +43642.png +09142.png +27989.png +58129.png +55448.png +40705.png +38757.png +39071.png +56678.png +48747.png +18549.png +41352.png +31244.png +50210.png +50082.png +69343.png +26232.png +58537.png +32150.png +48245.png +52096.png +28403.png +59049.png +37180.png +44786.png +31157.png +62422.png +51296.png +62817.png +08719.png +06289.png +41515.png +01432.png +67571.png +36596.png +09191.png +40861.png +22392.png +15486.png +59677.png +53340.png +54092.png +28908.png +16046.png +08959.png +65711.png +18034.png +25258.png +45945.png +30347.png +67700.png +61140.png +19752.png +48053.png +40870.png +53066.png +42823.png +00245.png +18913.png +39369.png +63910.png +39795.png +60568.png +30846.png +39540.png +41340.png +16725.png +27941.png +54988.png +64119.png +34155.png +67992.png +20011.png +13683.png +08308.png +07476.png +04288.png +26696.png +19452.png +52716.png +18039.png +31358.png +26077.png +63978.png +55217.png +04507.png +39302.png +60904.png +01962.png +44485.png +47617.png +05373.png +25941.png +09381.png +55926.png +60494.png +47327.png +26646.png +44343.png +05102.png +50132.png +01513.png +62694.png +40671.png +31901.png +29500.png +69121.png +45905.png +20389.png +63602.png +60151.png +61107.png +58511.png +03459.png +50762.png +30141.png +61027.png +14168.png +67699.png +65150.png +00148.png +53461.png +39574.png +18969.png +08970.png +27419.png +58944.png +12200.png +55243.png +11129.png +31681.png +04458.png +40470.png +17227.png +30798.png +56085.png +44592.png +18459.png +07731.png +47098.png +09120.png +41203.png +10207.png +29754.png +17281.png +37111.png +09719.png +62986.png +14289.png +57451.png +66944.png +57446.png +59461.png +27146.png +56183.png +65032.png +28004.png +23979.png +47063.png +55310.png +52824.png +02640.png +20575.png +07193.png +60817.png +33780.png +23598.png +27996.png +06634.png +31421.png +54160.png +49094.png +61817.png +63236.png +06970.png +11534.png +25226.png +24053.png +60842.png +32942.png +39958.png +56080.png +36911.png +09635.png +18172.png +08947.png +13409.png +49978.png +07239.png +11380.png +02184.png +68902.png +27125.png +19329.png +11893.png +52452.png +34598.png +47652.png +29459.png +45650.png +15703.png +16125.png +41077.png +42146.png +39154.png +02438.png +53808.png +50483.png +04914.png +26544.png +37733.png +61627.png +34970.png +29088.png +40290.png +20542.png +45638.png +13873.png +39058.png +58588.png +66030.png +69352.png +19813.png +67214.png +52223.png +06358.png +06623.png +32677.png +18849.png +11973.png +56544.png +21587.png +10472.png +49607.png +28961.png +24832.png +17699.png +14331.png +46229.png +02332.png +15811.png +63890.png +13552.png +03428.png +62149.png +29552.png +16542.png +53746.png +56702.png +39634.png +19616.png +41715.png +42109.png +39900.png +35396.png +29239.png +22515.png +07548.png +40161.png +53774.png +33451.png +27859.png +60925.png +33862.png +19331.png +29320.png +38260.png +46458.png +02247.png +25512.png +14716.png +20004.png +00807.png +34400.png +68211.png +42475.png +44597.png +48102.png +67427.png +36581.png +13565.png +41856.png +53250.png +36519.png +64764.png +47612.png +10589.png +31826.png +48838.png +28659.png +59320.png +31907.png +46149.png +24469.png +40387.png +41907.png +31378.png +02374.png +50546.png +64398.png +09461.png +03846.png +48927.png +55250.png +05076.png +55067.png +33185.png +05502.png +19275.png +55778.png +35870.png +54043.png +47898.png +62350.png +08186.png +45627.png +31800.png +00913.png +24712.png +01896.png +17292.png +43474.png +36202.png +54371.png +60614.png +36383.png +48293.png +42473.png +63347.png +48707.png +69515.png +55784.png +33825.png +21177.png +32369.png +30211.png +10777.png +29020.png +39289.png +49678.png +16836.png +57488.png +55129.png +50484.png +59186.png +00373.png +45912.png +49117.png +67529.png +07017.png +34255.png +40840.png +36269.png +50926.png +26834.png +41425.png +22878.png +36882.png +46718.png +01531.png +58186.png +11615.png +48689.png +43641.png +39234.png +26556.png +42954.png +00743.png +40430.png +45304.png +58226.png +04617.png +50299.png +14703.png +49294.png +68212.png +67440.png +13063.png +68585.png +46074.png +05734.png +52396.png +24206.png +21390.png +36772.png +64589.png +07271.png +30867.png +51085.png +51799.png +49455.png +10043.png +11161.png +29035.png +63415.png +61230.png +64403.png +06411.png +46933.png +16072.png +27161.png +36801.png +07461.png +02228.png +47913.png +12230.png +23953.png +69276.png +18395.png +37200.png +31556.png +63073.png +13326.png +45100.png +42279.png +43452.png +20527.png +47931.png +63779.png +03650.png +43869.png +08125.png +10679.png +43264.png +44198.png +06238.png +36287.png +14375.png +12575.png +29822.png +43716.png +19592.png +34265.png +39383.png +66826.png +18570.png +29854.png +37163.png +00964.png +45010.png +36048.png +22628.png +10385.png +32071.png +62800.png +35992.png +42501.png +17051.png +23556.png +02910.png +03667.png +31858.png +00594.png +57558.png +33588.png +68690.png +47391.png +22009.png +51326.png +23193.png +69088.png +03262.png +68047.png +50813.png +31093.png +19885.png +20884.png +20461.png +57296.png +28987.png +59667.png +63303.png +68672.png +42956.png +03060.png +28298.png +21766.png +32171.png +34509.png +48670.png +02235.png +42311.png +41576.png +39217.png +17017.png +35658.png +59097.png +08799.png +21519.png +10072.png +17339.png +62307.png +23705.png +48339.png +17716.png +22890.png +45341.png +42694.png +37078.png +46915.png +69362.png +03442.png +22918.png +42558.png +43361.png +60561.png +22585.png +36467.png +06765.png +65291.png +60300.png +55058.png +02618.png +36190.png +37175.png +15237.png +66600.png +23713.png +41396.png +60304.png +26243.png +07520.png +17348.png +51576.png +15036.png +32117.png +31893.png +01013.png +34967.png +20249.png +34352.png +18007.png +28710.png +11579.png +44074.png +39028.png +53028.png +43493.png +38174.png +56468.png +00168.png +68132.png +64953.png +11983.png +04819.png +58401.png +63512.png +20276.png +65950.png +44030.png +28553.png +41493.png +47574.png +51881.png +38769.png +22223.png +20184.png +33506.png +44346.png +03029.png +61051.png +03441.png +33440.png +11147.png +46603.png +28118.png +07342.png +28488.png +65182.png +36448.png +24223.png +13204.png +54917.png +06205.png +38690.png +65620.png +39364.png +65929.png +02385.png +63684.png +50883.png +68975.png +24962.png +52940.png +31620.png +61115.png +19954.png +36629.png +61712.png +44711.png +19561.png +41844.png +67356.png +66991.png +04988.png +05592.png +11395.png +46188.png +54872.png +41163.png +01545.png +57974.png +10064.png +28471.png +05620.png +44301.png +67982.png +05902.png +29735.png +13035.png +22774.png +68374.png +36392.png +57556.png +25318.png +55885.png +02016.png +62001.png +38719.png +24985.png +26642.png +03192.png +55416.png +67734.png +08398.png +39792.png +18131.png +67240.png +47055.png +10217.png +41332.png +33978.png +09131.png +57626.png +54681.png +28216.png +07423.png +24480.png +35116.png +16432.png +24029.png +54979.png +66807.png +16237.png +36144.png +69681.png +51147.png +28664.png +56238.png +68568.png +08281.png +57057.png +36012.png +40809.png +39603.png +64945.png +67793.png +65507.png +14020.png +63955.png +44667.png +26412.png +14706.png +48934.png +38365.png +31748.png +20459.png +69669.png +08977.png +11804.png +31814.png +30339.png +57155.png +08676.png +23826.png +24293.png +52413.png +15140.png +68694.png +08906.png +46642.png +42284.png +38209.png +64880.png +36743.png +41207.png +60343.png +50253.png +46274.png +08151.png +68836.png +37659.png +46382.png +30443.png +58468.png +58336.png +53369.png +08296.png +23021.png +69629.png +56840.png +55050.png +05178.png +69830.png +37355.png +62065.png +44045.png +09537.png +36014.png +52508.png +34650.png +44247.png +68439.png +30473.png +66162.png +30256.png +46250.png +03645.png +43132.png +33288.png +59952.png +15758.png +05507.png +21399.png +32615.png +39747.png +09861.png +26366.png +60010.png +42331.png +40471.png +03638.png +21290.png +34331.png +55844.png +25803.png +60194.png +00532.png +23682.png +35520.png +31935.png +61378.png +60924.png +46052.png +15945.png +33023.png +63408.png +18293.png +30613.png +27005.png +23137.png +34833.png +51786.png +36254.png +50984.png +69556.png +62334.png +10193.png +45475.png +41097.png +52293.png +45247.png +05691.png +27773.png +21310.png +29002.png +16908.png +20698.png +45194.png +14801.png +23746.png +12541.png +16666.png +40247.png +63982.png +16488.png +02698.png +49255.png +07243.png +02381.png +35433.png +37834.png +07006.png +44516.png +10029.png +04629.png +61676.png +12676.png +06181.png +21480.png +34534.png +13367.png +32635.png +36962.png +42155.png +02978.png +60509.png +38621.png +27107.png +41581.png +15735.png +12616.png +64115.png +17302.png +20520.png +02568.png +07382.png +38526.png +56233.png +53415.png +17743.png +30144.png +43521.png +57135.png +24898.png +37207.png +06468.png +29894.png +10680.png +57415.png +47212.png +06549.png +39729.png +10587.png +29590.png +10922.png +61155.png +68991.png +51656.png +22912.png +27109.png +27458.png +18406.png +03644.png +61190.png +50187.png +04455.png +36246.png +49521.png +32613.png +65200.png +35089.png +23238.png +58436.png +57225.png +56954.png +60338.png +22040.png +60532.png +44381.png +18278.png +45583.png +13815.png +20477.png +44115.png +36157.png +63274.png +43312.png +68046.png +11626.png +55720.png +17255.png +21392.png +60995.png +46881.png +05806.png +08836.png +14646.png +24251.png +04147.png +62266.png +30882.png +63431.png +47935.png +22343.png +47700.png +23674.png +50011.png +65750.png +53434.png +08044.png +63521.png +69285.png +04494.png +09847.png +06666.png +17874.png +14744.png +45106.png +60439.png +53308.png +43569.png +28671.png +33085.png +50358.png +43912.png +26873.png +68965.png +25384.png +58173.png +03375.png +53175.png +19865.png +35680.png +04389.png +46053.png +25150.png +01547.png +39533.png +21746.png +64461.png +10040.png +03324.png +25968.png +64961.png +02223.png +35781.png +54154.png +50249.png +19706.png +14557.png +63987.png +06049.png +44016.png +48630.png +08651.png +63536.png +62249.png +05114.png +37392.png +16279.png +19361.png +44204.png +38745.png +10077.png +28442.png +61245.png +46950.png +25958.png +44003.png +68571.png +09360.png +02628.png +14663.png +59448.png +46130.png +45965.png +43970.png +38018.png +23999.png +65623.png +08945.png +44589.png +63543.png +11690.png +65939.png +59445.png +29104.png +11218.png +37997.png +28673.png +62533.png +51594.png +51627.png +04234.png +52379.png +17709.png +18445.png +37783.png +49766.png +13408.png +58596.png +57701.png +04905.png +04777.png +14478.png +47857.png +38649.png +52372.png +39200.png +47286.png +30346.png +50804.png +35679.png +10412.png +13580.png +23467.png +07990.png +07772.png +10027.png +48060.png +13062.png +23430.png +51486.png +11149.png +38144.png +42840.png +49851.png +30807.png +17445.png +64018.png +07499.png +67714.png +42222.png +28688.png +30394.png +11229.png +50953.png +31441.png +13939.png +34986.png +39140.png +40190.png +46135.png +16990.png +14625.png +46096.png +37769.png +44456.png +21599.png +00693.png +08385.png +43524.png +33164.png +06686.png +39652.png +32375.png +34061.png +65635.png +24443.png +45375.png +28211.png +01289.png +57848.png +06144.png +48588.png +65898.png +59533.png +22849.png +26469.png +34387.png +13041.png +01261.png +40767.png +37514.png +44816.png +12660.png +58672.png +05310.png +60360.png +26976.png +09546.png +60680.png +68359.png +16931.png +31169.png +64176.png +49311.png +40920.png +50740.png +22615.png +46773.png +35988.png +39297.png +67881.png +27516.png +62428.png +47757.png +62305.png +32534.png +29096.png +51300.png +18358.png +35531.png +05849.png +58246.png +40359.png +14773.png +32983.png +16194.png +31508.png +12040.png +32731.png +29397.png +42361.png +00628.png +40296.png +66246.png +41541.png +45692.png +08318.png +20130.png +28989.png +21650.png +29502.png +34212.png +49487.png +00815.png +50646.png +48127.png +49864.png +21398.png +34404.png +64671.png +43076.png +35575.png +18936.png +13926.png +60610.png +26623.png +34894.png +44392.png +31876.png +67029.png +06950.png +13286.png +64844.png +56896.png +00595.png +54417.png +24177.png +30841.png +26603.png +53407.png +64759.png +44636.png +27970.png +68420.png +45743.png +41591.png +19897.png +26115.png +49975.png +53571.png +33278.png +28990.png +66841.png +53423.png +53762.png +16516.png +34292.png +52063.png +53338.png +46675.png +65931.png +31210.png +54309.png +26517.png +07350.png +27327.png +66111.png +41327.png +54338.png +19269.png +10447.png +22138.png +63405.png +31669.png +58275.png +09138.png +04255.png +56576.png +00571.png +02221.png +30371.png +59983.png +42334.png +47297.png +25411.png +10082.png +48964.png +43543.png +51249.png +37899.png +12023.png +03972.png +65181.png +03527.png +61003.png +47007.png +50529.png +54915.png +08024.png +69410.png +18352.png +02801.png +67922.png +09379.png +62652.png +68468.png +59082.png +15715.png +10570.png +50411.png +01856.png +35758.png +10203.png +48507.png +14337.png +06436.png +58806.png +19438.png +14909.png +01389.png +22570.png +15907.png +61026.png +36193.png +52074.png +28361.png +67369.png +16872.png +16771.png +27756.png +35686.png +27284.png +48971.png +43707.png +11671.png +18846.png +55659.png +29652.png +09550.png +16513.png +33936.png +52209.png +05372.png +30735.png +58922.png +28928.png +35635.png +15739.png +53603.png +51889.png +11894.png +01648.png +62365.png +36813.png +09638.png +08706.png +09364.png +66873.png +08554.png +47073.png +05949.png +54046.png +64947.png +05897.png +66256.png +49441.png +64394.png +14132.png +07125.png +44304.png +06520.png +17589.png +38066.png +20282.png +22657.png +49502.png +48230.png +61842.png +49302.png +21005.png +24715.png +07570.png +26894.png +25031.png +47788.png +39460.png +01391.png +56838.png +37532.png +54340.png +38165.png +17634.png +41529.png +04581.png +59821.png +10334.png +66570.png +48073.png +36345.png +21884.png +29271.png +59908.png +52461.png +63466.png +54971.png +26009.png +38613.png +34493.png +23548.png +49260.png +17876.png +56692.png +37686.png +10713.png +57894.png +01934.png +09310.png +57937.png +51049.png +67373.png +63685.png +22418.png +19929.png +26718.png +30342.png +33175.png +56320.png +64818.png +20989.png +59183.png +61862.png +39808.png +61049.png +37750.png +41408.png +63912.png +29648.png +08567.png +33029.png +50512.png +64081.png +39920.png +37645.png +29617.png +36546.png +51180.png +02326.png +40652.png +14537.png +51494.png +32289.png +67179.png +09103.png +20696.png +20597.png +56721.png +52398.png +53016.png +21212.png +03027.png +13670.png +66487.png +20415.png +57548.png +65138.png +09949.png +60898.png +04742.png +38748.png +38055.png +03876.png +67754.png +55274.png +68181.png +25096.png +37425.png +26318.png +35196.png +48765.png +46996.png +37150.png +35509.png +64098.png +18856.png +18851.png +31663.png +06416.png +10809.png +48501.png +06858.png +59441.png +20188.png +26447.png +44522.png +29220.png +51243.png +55903.png +10503.png +36975.png +60041.png +00126.png +13259.png +50322.png +17244.png +59312.png +03929.png +13269.png +49197.png +52548.png +07985.png +55686.png +23599.png +62807.png +56951.png +23250.png +54941.png +00859.png +19898.png +46548.png +16331.png +38162.png +32768.png +64894.png +55420.png +07381.png +51822.png +48719.png +10546.png +36233.png +36550.png +28285.png +12773.png +07472.png +51711.png +50469.png +15741.png +56718.png +04719.png +65590.png +04006.png +32916.png +48878.png +57527.png +62722.png +31570.png +63317.png +55485.png +36620.png +18964.png +64825.png +09023.png +52920.png +57375.png +51800.png +45678.png +36177.png +15433.png +07970.png +19154.png +18862.png +23747.png +48903.png +67115.png +65986.png +29297.png +28010.png +38492.png +08587.png +19968.png +36683.png +55515.png +21859.png +57964.png +21441.png +20762.png +37176.png +37049.png +04415.png +24518.png +66050.png +44775.png +11263.png +02707.png +55953.png +68592.png +54008.png +49381.png +41848.png +20981.png +39544.png +14735.png +59957.png +52530.png +31745.png +54506.png +35161.png +31457.png +66197.png +13845.png +68784.png +61661.png +59379.png +68497.png +44448.png +33479.png +18157.png +02913.png +13800.png +54310.png +28511.png +29679.png +45210.png +28651.png +16431.png +01211.png +16972.png +42528.png +16506.png +25551.png +47438.png +64044.png +66737.png +43475.png +06738.png +44878.png +32716.png +03706.png +45089.png +05943.png +08993.png +36191.png +39558.png +09539.png +67518.png +61127.png +39487.png +62242.png +62764.png +28175.png +53767.png +40934.png +29547.png +47139.png +04481.png +44767.png +12188.png +13737.png +20874.png +47738.png +17110.png +08172.png +40976.png +54007.png +01938.png +54361.png +38859.png +15984.png +57443.png +62438.png +25221.png +57042.png +20975.png +67532.png +65099.png +33259.png +22532.png +55745.png +22804.png +31529.png +34190.png +61895.png +34741.png +10554.png +02808.png +01714.png +08471.png +37713.png +46263.png +45514.png +41263.png +65878.png +11230.png +18701.png +41973.png +69202.png +69735.png +09736.png +16169.png +63380.png +27827.png +17267.png +06729.png +20906.png +00078.png +58725.png +21574.png +23874.png +04718.png +44420.png +39589.png +53223.png +53477.png +61088.png +07353.png +65309.png +27792.png +69818.png +59190.png +07305.png +41256.png +44380.png +00770.png +06388.png +22303.png +32606.png +22254.png +64872.png +43717.png +51455.png +60582.png +46618.png +54625.png +43175.png +32370.png +52420.png +33466.png +68508.png +67208.png +14246.png +07098.png +28130.png +01333.png +39501.png +08288.png +50597.png +19844.png +31951.png +36111.png +41761.png +32858.png +09787.png +08871.png +51189.png +29730.png +29533.png +30088.png +68565.png +11452.png +36297.png +60886.png +05909.png +20729.png +17814.png +50022.png +04112.png +55889.png +22810.png +01448.png +57112.png +60965.png +39577.png +45358.png +63605.png +20429.png +60864.png +13960.png +48757.png +06072.png +49471.png +29221.png +39974.png +53190.png +64993.png +36348.png +57567.png +54052.png +10011.png +46704.png +01750.png +11343.png +61395.png +65553.png +44432.png +62540.png +67045.png +66471.png +48929.png +67396.png +25872.png +35989.png +42161.png +58344.png +24034.png +02030.png +33711.png +67904.png +51000.png +21671.png +03924.png +43739.png +14047.png +30879.png +54698.png +15779.png +63141.png +40034.png +45123.png +33432.png +29775.png +29545.png +35888.png +19430.png +65098.png +51639.png +05476.png +59805.png +33191.png +61740.png +45903.png +65777.png +27708.png +37265.png +14377.png +36156.png +09977.png +58462.png +11207.png +13437.png +45362.png +47288.png +68791.png +10264.png +31787.png +34773.png +01601.png +06657.png +36009.png +25616.png +14044.png +51001.png +60989.png +23570.png +05924.png +05166.png +46586.png +44542.png +07680.png +04227.png +28261.png +31879.png +66627.png +07486.png +15769.png +60735.png +63772.png +69195.png +23373.png +53840.png +05656.png +21364.png +32789.png +12995.png +10976.png +39026.png +44405.png +48140.png +02323.png +09797.png +54483.png +46157.png +26057.png +34228.png +29203.png +37831.png +56907.png +37936.png +54056.png +36416.png +68538.png +33209.png +63205.png +10360.png +09383.png +35299.png +28030.png +12436.png +45219.png +26778.png +00769.png +62815.png +62929.png +63487.png +26224.png +24449.png +63919.png +45586.png +12543.png +29707.png +28491.png +07274.png +29032.png +41326.png +63859.png +02430.png +32649.png +31638.png +06768.png +05559.png +43843.png +66495.png +57289.png +35384.png +00426.png +27373.png +36610.png +31353.png +39170.png +01055.png +30758.png +66936.png +14446.png +08737.png +10218.png +24410.png +61542.png +26863.png +11470.png +64518.png +52926.png +65908.png +49579.png +64904.png +16354.png +51646.png +26943.png +42110.png +16388.png +55326.png +52377.png +63480.png +57021.png +45521.png +00420.png +30828.png +08167.png +12286.png +69820.png +04770.png +63819.png +67807.png +12658.png +28493.png +05188.png +32139.png +60058.png +48654.png +49681.png +08334.png +33355.png +54862.png +21920.png +46331.png +53943.png +62186.png +00432.png +40406.png +21988.png +68125.png +65791.png +25742.png +25328.png +18765.png +00424.png +06797.png +10194.png +31562.png +11744.png +41494.png +46299.png +47626.png +52281.png +68002.png +09216.png +35302.png +28774.png +52955.png +17813.png +40117.png +56931.png +55356.png +08237.png +36106.png +17566.png +19287.png +49906.png +55696.png +11653.png +27700.png +48815.png +33119.png +34693.png +36231.png +34019.png +35381.png +35723.png +58232.png +08745.png +37398.png +12625.png +04278.png +59207.png +15327.png +19102.png +37223.png +16452.png +68085.png +67230.png +32335.png +28387.png +36483.png +50495.png +13905.png +09095.png +05443.png +41330.png +58544.png +38563.png +47349.png +22295.png +01052.png +26997.png +66222.png +39212.png +45199.png +09363.png +62123.png +09177.png +18214.png +54145.png +33880.png +29192.png +37226.png +62142.png +38968.png +36252.png +28690.png +01576.png +26188.png +62992.png +01388.png +19746.png +45222.png +43109.png +39805.png +25080.png +14750.png +25203.png +49040.png +39458.png +46402.png +42333.png +57716.png +37089.png +05624.png +55022.png +67639.png +32411.png +26928.png +26676.png +07354.png +49365.png +46849.png +58009.png +07525.png +13157.png +32680.png +45117.png +54400.png +56566.png +41756.png +18979.png +13471.png +48709.png +31837.png +59456.png +25193.png +24956.png +43385.png +50857.png +38883.png +13870.png +09924.png +46102.png +26212.png +43090.png +64276.png +23836.png +49350.png +49269.png +00419.png +00282.png +45079.png +00312.png +14815.png +51310.png +48304.png +60311.png +52549.png +09677.png +63424.png +19050.png +50402.png +54610.png +53749.png +27648.png +67154.png +41686.png +08101.png +53848.png +41379.png +48392.png +38797.png +51873.png +48043.png +67857.png +50977.png +44968.png +66532.png +51811.png +05127.png +47502.png +10235.png +23069.png +42076.png +52354.png +66516.png +21312.png +39719.png +44037.png +22909.png +17422.png +10386.png +32077.png +65825.png +69178.png +66734.png +16283.png +13888.png +16111.png +21134.png +01337.png +25276.png +17080.png +66788.png +65029.png +67884.png +19769.png +50810.png +58917.png +26995.png +61589.png +51580.png +11701.png +05486.png +66394.png +48021.png +00380.png +68878.png +36808.png +55832.png +41289.png +03238.png +27983.png +26497.png +68624.png +64645.png +06462.png +37093.png +41841.png +34002.png +44386.png +11329.png +00182.png +10995.png +28226.png +52247.png +50217.png +61781.png +12382.png +00637.png +66893.png +50878.png +28389.png +54431.png +02371.png +17068.png +01436.png +53587.png +46318.png +42384.png +54687.png +39907.png +57608.png +43469.png +59856.png +43453.png +03252.png +11000.png +06298.png +64335.png +21588.png +47785.png +15577.png +28937.png +51491.png +16315.png +07561.png +35950.png +01010.png +25858.png +10865.png +05843.png +27042.png +07800.png +60355.png +60492.png +13341.png +26400.png +24661.png +12578.png +14972.png +29764.png +22331.png +30085.png +24041.png +65810.png +37126.png +06406.png +11378.png +26950.png +08728.png +20864.png +23924.png +09952.png +38392.png +33821.png +21329.png +63080.png +39923.png +60800.png +01319.png +64776.png +34511.png +11063.png +27026.png +60964.png +07135.png +56271.png +18286.png +52331.png +69379.png +07757.png +36782.png +16825.png +26798.png +21664.png +25471.png +29394.png +17170.png +68324.png +49799.png +44890.png +49525.png +25569.png +05809.png +18059.png +21361.png +50455.png +20881.png +35181.png +62626.png +33167.png +32735.png +15865.png +67415.png +38109.png +36632.png +67072.png +56853.png +62180.png +34957.png +40764.png +33320.png +50879.png +29325.png +66297.png +27130.png +55793.png +50108.png +57342.png +65787.png +67137.png +69205.png +41010.png +00090.png +46284.png +45157.png +11764.png +48572.png +46383.png +38438.png +50734.png +20834.png +13633.png +11555.png +16113.png +25897.png +13833.png +29722.png +61860.png +38292.png +60166.png +59682.png +44249.png +30590.png +54295.png +66763.png +18398.png +69442.png +56531.png +52394.png +04297.png +55795.png +13223.png +68438.png +65781.png +50076.png +61789.png +25331.png +13994.png +36553.png +04924.png +67528.png +49347.png +64581.png +32277.png +13861.png +33146.png +40990.png +49240.png +17855.png +50988.png +04806.png +67655.png +48226.png +04822.png +01793.png +67097.png +07198.png +18057.png +34520.png +19728.png +26102.png +52882.png +39307.png +44507.png +40056.png +35802.png +36774.png +37698.png +16713.png +12993.png +61221.png +65147.png +68067.png +64358.png +63593.png +23819.png +40689.png +16932.png +23358.png +22070.png +15030.png +69293.png +39669.png +36369.png +24064.png +56573.png +52207.png +57221.png +40360.png +57595.png +52531.png +21024.png +40715.png +57766.png +66332.png +53049.png +14368.png +10446.png +54543.png +01020.png +15215.png +22386.png +57173.png +68063.png +55174.png +41664.png +47554.png +55226.png +06071.png +51935.png +28494.png +24355.png +19185.png +22578.png +46121.png +65749.png +54823.png +04138.png +15085.png +26143.png +43928.png +33702.png +23997.png +60337.png +37627.png +51052.png +36350.png +28220.png +63306.png +36930.png +28458.png +48493.png +03007.png +58619.png +18041.png +00686.png +29702.png +08053.png +25553.png +24331.png +49753.png +20953.png +61984.png +50093.png +12586.png +05524.png +02974.png +09063.png +16740.png +04606.png +31251.png +54570.png +48549.png +57755.png +48089.png +13318.png +02964.png +64243.png +67746.png +68842.png +52537.png +10608.png +18554.png +11491.png +26837.png +41739.png +24380.png +18022.png +32123.png +54830.png +03055.png +42452.png +17167.png +18210.png +20135.png +21651.png +45513.png +04264.png +23108.png +47163.png +68133.png +61981.png +49467.png +57741.png +27977.png +32894.png +31142.png +57172.png +18282.png +68593.png +35476.png +37506.png +09525.png +22797.png +45870.png +27323.png +63641.png +50833.png +54535.png +11718.png +12498.png +46584.png +22933.png +11727.png +54564.png +32181.png +58753.png +22638.png +13402.png +33035.png +41826.png +50535.png +23329.png +61271.png +41590.png +10421.png +14041.png +57245.png +65481.png +34745.png +05765.png +16845.png +51966.png +65087.png +36584.png +31592.png +24209.png +13917.png +58225.png +57182.png +04497.png +18291.png +51366.png +54335.png +25829.png +17262.png +26344.png +23335.png +38805.png +33433.png +29975.png +36783.png +65829.png +18261.png +43800.png +36199.png +35148.png +37806.png +60078.png +41732.png +52543.png +47619.png +14045.png +60676.png +55514.png +50263.png +31389.png +21125.png +44067.png +32167.png +09283.png +33617.png +38937.png +27924.png +36293.png +42644.png +50403.png +49855.png +52847.png +17538.png +19666.png +60695.png +51717.png +13488.png +32105.png +56355.png +53532.png +44523.png +25884.png +46968.png +56222.png +01768.png +54168.png +21843.png +39612.png +07814.png +07756.png +14308.png +30830.png +62295.png +66672.png +14983.png +14732.png +60916.png +46790.png +50270.png +63271.png +13684.png +38636.png +21019.png +43658.png +03489.png +02138.png +37976.png +33487.png +27750.png +27760.png +04321.png +00553.png +18768.png +59424.png +62614.png +23755.png +62645.png +28973.png +03160.png +68161.png +52551.png +68552.png +01360.png +15112.png +60642.png +45476.png +13986.png +12849.png +08790.png +56711.png +65712.png +60216.png +40211.png +61274.png +39730.png +47312.png +30892.png +13704.png +26303.png +58127.png +07273.png +55393.png +33097.png +32189.png +28969.png +02510.png +45752.png +52875.png +08477.png +02579.png +16923.png +59058.png +22051.png +01351.png +48981.png +65295.png +40773.png +68947.png +52282.png +57944.png +52445.png +09521.png +44210.png +25356.png +22788.png +06132.png +01664.png +02064.png +43307.png +49775.png +69415.png +02831.png +68510.png +62960.png +30471.png +11528.png +11497.png +26397.png +20684.png +32266.png +22696.png +14429.png +18663.png +48521.png +03121.png +15038.png +13497.png +12046.png +11226.png +27147.png +65152.png +23969.png +68147.png +04243.png +38011.png +50493.png +62442.png +66633.png +63726.png +36560.png +36994.png +23407.png +19800.png +49134.png +63920.png +69328.png +53799.png +12688.png +14951.png +60130.png +65072.png +06596.png +54480.png +05232.png +50065.png +19953.png +26012.png +36970.png +03856.png +64262.png +07362.png +46223.png +13094.png +33457.png +17588.png +15449.png +38939.png +49585.png +24371.png +56139.png +46860.png +59366.png +57640.png +53553.png +11786.png +34651.png +18613.png +18671.png +09233.png +18492.png +68935.png +18454.png +52801.png +03859.png +38990.png +03843.png +64099.png +67469.png +31916.png +21301.png +11703.png +69420.png +05478.png +21023.png +67868.png +66871.png +45974.png +53466.png +24809.png +33856.png +56659.png +19626.png +05150.png +25472.png +64165.png +00412.png +12634.png +45338.png +29093.png +00001.png +22456.png +35819.png +33772.png +62366.png +03267.png +22523.png +10021.png +50860.png +36746.png +48694.png +15053.png +58458.png +16589.png +66941.png +24464.png +29573.png +32938.png +28607.png +12707.png +60006.png +19302.png +53521.png +58302.png +64666.png +30829.png +34755.png +33246.png +32430.png +68304.png +13356.png +24228.png +01949.png +11873.png +01944.png +39653.png +60880.png +25702.png +21252.png +44216.png +40254.png +64743.png +38349.png +11242.png +59944.png +54716.png +39054.png +05983.png +58939.png +10953.png +37138.png +60521.png +01444.png +48593.png +57206.png +31765.png +42035.png +46407.png +56652.png +44679.png +20897.png +38319.png +51008.png +34290.png +08278.png +18813.png +38670.png +30786.png +40102.png +11100.png +42986.png +32092.png +18072.png +31294.png +30470.png +59481.png +10481.png +59179.png +59535.png +48949.png +37924.png +47914.png +28747.png +51653.png +42874.png +53160.png +44888.png +09567.png +40539.png +46925.png +43922.png +12113.png +07958.png +12927.png +34480.png +63597.png +53728.png +62302.png +27372.png +29100.png +69540.png +47351.png +65019.png +46666.png +39005.png +15790.png +34643.png +27366.png +00284.png +09367.png +35485.png +01021.png +22648.png +21182.png +51999.png +29079.png +08755.png +64456.png +66623.png +27418.png +43201.png +19132.png +26887.png +24621.png +26897.png +34086.png +53956.png +31713.png +37552.png +11118.png +35717.png +62664.png +66526.png +61653.png +43426.png +48376.png +67538.png +22239.png +61358.png +28366.png +14003.png +35506.png +42873.png +63199.png +06102.png +29371.png +02740.png +24700.png +15245.png +65654.png +27871.png +01723.png +38545.png +33932.png +34280.png +46296.png +54350.png +68815.png +55477.png +07810.png +16197.png +66735.png +48155.png +52816.png +21138.png +68099.png +10956.png +59268.png +25391.png +10098.png +56758.png +17643.png +25432.png +55905.png +30218.png +44118.png +25993.png +19149.png +27968.png +00550.png +28215.png +32835.png +19317.png +15499.png +54101.png +38258.png +51850.png +49399.png +57621.png +23220.png +39879.png +65874.png +29067.png +15634.png +22711.png +37816.png +20147.png +42423.png +57542.png +60266.png +51489.png +66899.png +36984.png +64806.png +36949.png +61420.png +61449.png +12170.png +38163.png +44922.png +68054.png +37116.png +08143.png +55261.png +64307.png +67817.png +46421.png +42969.png +14779.png +50885.png +20595.png +61564.png +28208.png +46897.png +44022.png +56182.png +33077.png +18228.png +65088.png +69984.png +59612.png +30537.png +33279.png +32073.png +44384.png +35801.png +42740.png +63816.png +43196.png +14912.png +48340.png +68782.png +11869.png +02387.png +35282.png +64910.png +57054.png +01094.png +39433.png +36586.png +42946.png +33350.png +27196.png +18248.png +44076.png +14742.png +07788.png +02275.png +11929.png +31304.png +03707.png +68329.png +03898.png +16233.png +23139.png +08483.png +36370.png +68277.png +61844.png +45353.png +20136.png +25924.png +65846.png +22679.png +42190.png +52991.png +45034.png +56813.png +59887.png +15987.png +17604.png +23107.png +38435.png +48951.png +48214.png +03583.png +19889.png +07998.png +17966.png +50871.png +57286.png +68534.png +44424.png +60542.png +66068.png +04812.png +54857.png +34195.png +17764.png +62516.png +32682.png +15147.png +64377.png +61680.png +66027.png +40954.png +38816.png +00780.png +41589.png +14787.png +56179.png +68009.png +08336.png +18265.png +23763.png +59227.png +61335.png +05525.png +49725.png +54643.png +36463.png +60050.png +31704.png +04522.png +42778.png +36686.png +56953.png +49946.png +51878.png +62790.png +32650.png +15429.png +26407.png +25756.png +00827.png +17328.png +39000.png +56431.png +00781.png +30766.png +49358.png +33253.png +49199.png +65789.png +10291.png +40045.png +60138.png +00821.png +38129.png +02766.png +58502.png +42939.png +60731.png +33442.png +23343.png +37543.png +64381.png +40629.png +60949.png +15250.png +35502.png +69949.png +29050.png +20852.png +13938.png +42041.png +13550.png +28222.png +12569.png +19640.png +10306.png +42867.png +39055.png +69241.png +37055.png +25435.png +21675.png +67694.png +36899.png +24836.png +27100.png +69213.png +37260.png +25969.png +29990.png +18122.png +16662.png +13543.png +59920.png +27671.png +56976.png +37714.png +58326.png +05929.png +35990.png +04708.png +30724.png +19238.png +28036.png +05743.png +68183.png +26518.png +01997.png +41497.png +63194.png +24246.png +11996.png +54343.png +12712.png +36167.png +19407.png +61367.png +19893.png +60577.png +32653.png +45255.png +00935.png +65478.png +35043.png +18637.png +19070.png +44506.png +57853.png +46647.png +18019.png +69019.png +18232.png +69189.png +52375.png +43876.png +62726.png +02928.png +15468.png +60314.png +49010.png +18386.png +53693.png +28103.png +27213.png +31114.png +66969.png +02014.png +50708.png +14522.png +65433.png +31691.png +65379.png +23106.png +41521.png +12268.png +52525.png +36920.png +16534.png +47493.png +27515.png +66706.png +30501.png +34576.png +45406.png +13892.png +06801.png +61711.png +16212.png +31143.png +31887.png +19894.png +34632.png +05800.png +29448.png +38270.png +34816.png +52563.png +45978.png +43562.png +55697.png +64985.png +29589.png +31237.png +35125.png +53101.png +25532.png +36061.png +59750.png +00387.png +48284.png +11985.png +47476.png +10732.png +07470.png +42187.png +17159.png +60347.png +12130.png +33245.png +35344.png +15054.png +09014.png +18520.png +42963.png +35890.png +39997.png +28052.png +57686.png +51938.png +57675.png +37508.png +48505.png +61303.png +54966.png +67851.png +69483.png +04730.png +07153.png +55267.png +00142.png +14387.png +05217.png +19784.png +66098.png +26411.png +66101.png +52967.png +41847.png +15291.png +60155.png +62695.png +25054.png +44591.png +36212.png +29294.png +37368.png +14976.png +21440.png +18721.png +43823.png +01591.png +68632.png +24590.png +27336.png +18209.png +30719.png +14727.png +51101.png +37188.png +47150.png +15049.png +59310.png +09740.png +48858.png +50382.png +56195.png +28650.png +53092.png +42715.png +20664.png +07393.png +24178.png +58608.png +33420.png +15401.png +06207.png +00638.png +39032.png +31288.png +65177.png +39977.png +08826.png +69778.png +23933.png +05978.png +28138.png +14067.png +04648.png +61090.png +36931.png +63509.png +62900.png +25246.png +65921.png +13866.png +53073.png +21112.png +22433.png +32347.png +50207.png +03138.png +49290.png +12469.png +33541.png +26969.png +05994.png +66158.png +18985.png +48098.png +17662.png +67139.png +35818.png +42269.png +62795.png +62692.png +59101.png +53123.png +45534.png +35267.png +67912.png +17111.png +56986.png +46049.png +37032.png +44055.png +31351.png +43114.png +07169.png +45904.png +54856.png +30579.png +58647.png +52254.png +42724.png +44054.png +34132.png +21530.png +64158.png +42905.png +40134.png +30447.png +40446.png +54139.png +14174.png +01764.png +49055.png +03783.png +07000.png +68910.png +60988.png +42485.png +41839.png +17142.png +55960.png +08097.png +59037.png +01439.png +51655.png +69895.png +20412.png +60781.png +64220.png +56851.png +45734.png +25759.png +03944.png +69047.png +46422.png +00496.png +20665.png +42250.png +24887.png +34071.png +20129.png +56406.png +59242.png +14297.png +13869.png +63785.png +27730.png +27881.png +05319.png +41086.png +38581.png +37950.png +15783.png +35469.png +38124.png +42763.png +18058.png +58655.png +38985.png +46115.png +39188.png +04282.png +40298.png +45245.png +58785.png +62303.png +21596.png +16446.png +66662.png +58388.png +52037.png +40895.png +57082.png +30635.png +34349.png +23911.png +51414.png +29449.png +65284.png +03838.png +44963.png +04331.png +55893.png +22136.png +32742.png +24456.png +21934.png +52901.png +23697.png +28269.png +20299.png +49794.png +39045.png +20038.png +40772.png +33277.png +40630.png +40749.png +33289.png +64502.png +68920.png +46898.png +00654.png +60697.png +60234.png +57035.png +58483.png +19751.png +32298.png +42436.png +51616.png +47809.png +05930.png +24867.png +49580.png +42744.png +12192.png +24459.png +10564.png +26357.png +09454.png +30113.png +06387.png +26911.png +21463.png +13608.png +65443.png +48213.png +04751.png +22267.png +32342.png +26599.png +20796.png +63584.png +54877.png +19870.png +53403.png +08786.png +58066.png +59884.png +60349.png +13652.png +29133.png +25807.png +09057.png +03963.png +18972.png +07419.png +42982.png +11312.png +06849.png +69685.png +32130.png +06275.png +25268.png +66767.png +36707.png +33987.png +43563.png +67813.png +25757.png +23334.png +00264.png +33963.png +16665.png +03314.png +59608.png +22793.png +69221.png +00337.png +19947.png +41988.png +04860.png +53116.png +29879.png +17149.png +33971.png +27879.png +16930.png +37577.png +15969.png +20250.png +40858.png +21831.png +13668.png +31845.png +05354.png +69852.png +33859.png +54650.png +56411.png +34313.png +04710.png +48270.png +57452.png +17576.png +19621.png +13347.png +65323.png +31393.png +17465.png +47547.png +64069.png +39743.png +17575.png +32467.png +40228.png +60042.png +58580.png +11479.png +07162.png +63609.png +02068.png +10627.png +54654.png +56236.png +31084.png +05799.png +36531.png +47708.png +24885.png +08767.png +00381.png +03413.png +24864.png +64799.png +13738.png +27247.png +24442.png +37675.png +22337.png +20800.png +35338.png +42129.png +21415.png +39406.png +44809.png +64877.png +68186.png +66094.png +65545.png +07925.png +07844.png +67406.png +09825.png +53721.png +66492.png +19273.png +41318.png +04025.png +10036.png +07808.png +11088.png +01566.png +30712.png +22870.png +13867.png +41006.png +06446.png +42571.png +15236.png +34421.png +11630.png +16034.png +32326.png +28807.png +06995.png +06708.png +61846.png +68240.png +24888.png +37751.png +13660.png +08445.png +02189.png +04931.png +19866.png +28178.png +00222.png +25746.png +00951.png +49843.png +51892.png +42240.png +52411.png +61543.png +36248.png +34524.png +45897.png +12764.png +20643.png +65228.png +51907.png +38126.png +04599.png +54044.png +37160.png +61186.png +37676.png +07880.png +65792.png +21497.png +40354.png +52156.png +50201.png +09937.png +33836.png +66017.png +30272.png +11125.png +31771.png +43263.png +21526.png +04626.png +25568.png +31981.png +46166.png +20204.png +18661.png +41928.png +44026.png +42503.png +38911.png +46798.png +24267.png +45566.png +69624.png +41995.png +03445.png +55808.png +48583.png +30578.png +13491.png +17349.png +33581.png +18727.png +15930.png +20332.png +28279.png +28342.png +15803.png +18748.png +61833.png +13296.png +06368.png +46545.png +06580.png +27949.png +05805.png +07807.png +39770.png +30477.png +28831.png +40936.png +68725.png +08769.png +48110.png +64460.png +15541.png +44144.png +61592.png +00511.png +16816.png +44939.png +37555.png +49220.png +61720.png +39947.png +03893.png +08161.png +62660.png +05344.png +61374.png +06655.png +36423.png +50875.png +06346.png +44107.png +32841.png +33515.png +12595.png +42594.png +64178.png +20058.png +30212.png +45791.png +58902.png +63633.png +18790.png +65887.png +20923.png +43428.png +00259.png +58698.png +12116.png +61158.png +28095.png +64107.png +65304.png +20110.png +43348.png +02098.png +54791.png +25849.png +04070.png +04582.png +65121.png +22149.png +12367.png +22644.png +12151.png +48097.png +17959.png +53605.png +15661.png +18854.png +47615.png +68963.png +52443.png +63033.png +21999.png +37383.png +25016.png +22300.png +02852.png +30681.png +06544.png +68379.png +34779.png +45909.png +38867.png +55948.png +54105.png +49777.png +46923.png +03695.png +61247.png +26355.png +09030.png +43964.png +19194.png +64817.png +22952.png +08866.png +03862.png +56537.png +69993.png +44942.png +47797.png +54896.png +64147.png +40101.png +17527.png +69665.png +43871.png +58058.png +21088.png +67678.png +49936.png +38487.png +46772.png +10836.png +63414.png +06631.png +03264.png +22348.png +56498.png +40626.png +56502.png +69422.png +01440.png +60139.png +48175.png +43195.png +68908.png +20115.png +12199.png +31965.png +45993.png +34496.png +01197.png +45208.png +17496.png +17698.png +03744.png +11031.png +17485.png +32364.png +15759.png +67234.png +12306.png +54298.png +43516.png +37240.png +67713.png +33010.png +45924.png +09162.png +37893.png +31433.png +15797.png +20468.png +66558.png +51503.png +55253.png +13180.png +62063.png +64383.png +57699.png +53829.png +09002.png +35565.png +55216.png +69590.png +03129.png +38440.png +29303.png +24166.png +59970.png +01836.png +24854.png +05626.png +03960.png +05298.png +57176.png +65316.png +35347.png +33895.png +16143.png +39371.png +61755.png +08211.png +25319.png +67456.png +33153.png +42120.png +68709.png +28139.png +59818.png +21356.png +53873.png +05860.png +03649.png +37600.png +69277.png +31063.png +43304.png +62808.png +64008.png +49566.png +68198.png +19341.png +64014.png +20342.png +66076.png +21401.png +40184.png +39877.png +29346.png +22722.png +43671.png +48685.png +30045.png +12545.png +51921.png +27361.png +34164.png +12860.png +44363.png +46167.png +09405.png +01156.png +47219.png +51784.png +46868.png +23886.png +18321.png +00705.png +59130.png +30642.png +13029.png +68983.png +43819.png +49985.png +15683.png +62968.png +69011.png +56879.png +04071.png +10241.png +15640.png +17028.png +18946.png +15183.png +27119.png +55137.png +51248.png +02849.png +26113.png +27305.png +56707.png +62078.png +19172.png +42332.png +55974.png +35336.png +10827.png +06235.png +13983.png +17536.png +41190.png +40023.png +47772.png +35728.png +47744.png +04155.png +43363.png +24531.png +64430.png +49925.png +02300.png +05438.png +12626.png +65348.png +00640.png +29138.png +11628.png +47419.png +63332.png +50418.png +07077.png +47969.png +50153.png +35603.png +31835.png +55349.png +10243.png +54911.png +06077.png +05030.png +18040.png +42770.png +58265.png +22762.png +05413.png +08874.png +40633.png +68423.png +58860.png +65549.png +21946.png +69097.png +05709.png +42225.png +35993.png +44457.png +59136.png +24896.png +13072.png +24241.png +13631.png +29779.png +08913.png +05467.png +08685.png +60217.png +58529.png +01628.png +12523.png +42326.png +35711.png +61708.png +19137.png +24006.png +65202.png +16298.png +11047.png +52230.png +68697.png +65574.png +69368.png +20116.png +11853.png +53204.png +61295.png +51226.png +47497.png +67916.png +19681.png +14723.png +25431.png +08750.png +24874.png +59014.png +37954.png +55837.png +33667.png +05196.png +09109.png +02961.png +57287.png +61025.png +49763.png +13627.png +66436.png +10370.png +16303.png +54250.png +60730.png +38141.png +24572.png +04959.png +60077.png +02603.png +12494.png +44064.png +00901.png +43116.png +40107.png +04129.png +00919.png +19115.png +13093.png +62612.png +48615.png +68862.png +32084.png +14837.png +45380.png +37601.png +68857.png +43072.png +10812.png +48029.png +37923.png +15465.png +06348.png +60190.png +66681.png +15377.png +46871.png +01708.png +63722.png +39209.png +33737.png +47947.png +67715.png +29907.png +20172.png +30195.png +61756.png +44112.png +14181.png +17701.png +41820.png +18176.png +39230.png +38565.png +56809.png +43172.png +46662.png +24405.png +46705.png +16213.png +29323.png +68382.png +17457.png +02759.png +36426.png +62346.png +12039.png +30888.png +29767.png +25292.png +00818.png +46406.png +51277.png +01209.png +01229.png +21459.png +69208.png +03791.png +04385.png +53436.png +28297.png +01177.png +15738.png +41270.png +17475.png +49861.png +43847.png +11746.png +20132.png +25202.png +33763.png +54086.png +13198.png +29071.png +40067.png +25476.png +08381.png +46393.png +27762.png +19599.png +30633.png +49962.png +40564.png +30286.png +13256.png +02542.png +69345.png +34609.png +51199.png +11527.png +05775.png +40959.png +16049.png +21915.png +42551.png +64489.png +35796.png +41524.png +15544.png +30995.png +56661.png +38032.png +04074.png +15944.png +06626.png +34041.png +69064.png +57586.png +46042.png +06159.png +01009.png +22361.png +34527.png +62339.png +63794.png +20823.png +64122.png +59358.png +63861.png +02520.png +36019.png +48740.png +08259.png +27183.png +22019.png +37043.png +08640.png +43777.png +37237.png +42399.png +02498.png +02481.png +03845.png +29673.png +59797.png +57241.png +28675.png +12176.png +66751.png +69704.png +48646.png +42486.png +60969.png +42496.png +32836.png +07625.png +65204.png +39359.png +14448.png +56545.png +66130.png +00314.png +11788.png +60503.png +09323.png +47489.png +42082.png +20217.png +58231.png +09743.png +28934.png +14974.png +34729.png +62505.png +62979.png +25775.png +47293.png +34984.png +53394.png +58716.png +42147.png +48264.png +19567.png +66408.png +24741.png +27561.png +31409.png +62154.png +08484.png +52220.png +45168.png +39166.png +16202.png +61909.png +41022.png +38948.png +03894.png +34877.png +42388.png +02185.png +37276.png +00825.png +00289.png +31993.png +18018.png +51950.png +22268.png +50707.png +64088.png +40292.png +40874.png +63949.png +13718.png +01282.png +25448.png +65444.png +15062.png +28180.png +01755.png +46731.png +09154.png +66099.png +51640.png +64211.png +55460.png +45651.png +52533.png +64963.png +42907.png +02881.png +24775.png +48279.png +36047.png +24574.png +11946.png +56620.png +53517.png +50342.png +34358.png +65905.png +64325.png +52388.png +07103.png +48149.png +06678.png +63576.png +21014.png +66160.png +15826.png +52029.png +49380.png +56019.png +62324.png +24947.png +13975.png +13432.png +68960.png +37721.png +45859.png +34535.png +47065.png +37784.png +32094.png +34895.png +69425.png +44899.png +43704.png +66611.png +62739.png +63284.png +17558.png +14668.png +31033.png +54439.png +67895.png +34092.png +53474.png +49801.png +20797.png +11538.png +58441.png +48893.png +32909.png +28960.png +31175.png +41618.png +38251.png +53981.png +35263.png +54466.png +64846.png +38903.png +40116.png +42854.png +54529.png +34662.png +67379.png +02812.png +19083.png +18180.png +44514.png +28306.png +40501.png +16602.png +49760.png +36090.png +46997.png +09081.png +36453.png +52947.png +58020.png +29001.png +46796.png +34299.png +44147.png +55422.png +47299.png +33088.png +26562.png +19286.png +03807.png +49400.png +46536.png +66066.png +04489.png +37252.png +42001.png +35733.png +42560.png +11509.png +57412.png +18627.png +41504.png +64893.png +47356.png +62134.png +31579.png +01190.png +41274.png +61430.png +66453.png +58061.png +12886.png +47670.png +67720.png +47335.png +24798.png +48579.png +51368.png +08163.png +15956.png +19995.png +44203.png +34605.png +46717.png +63382.png +21567.png +61283.png +22096.png +64197.png +32777.png +50463.png +67806.png +63999.png +12239.png +56797.png +56365.png +25886.png +24803.png +50337.png +21612.png +43822.png +12997.png +05842.png +41328.png +22368.png +68863.png +11612.png +61518.png +46082.png +38255.png +24136.png +30314.png +56398.png +04244.png +62313.png +04709.png +39749.png +13564.png +18177.png +00848.png +16493.png +66590.png +48017.png +33390.png +12493.png +06965.png +13358.png +47108.png +22123.png +63392.png +20744.png +26922.png +31399.png +14659.png +61130.png +48672.png +48921.png +37693.png +55385.png +55041.png +40673.png +30241.png +24244.png +06621.png +44773.png +31186.png +04236.png +69645.png +28706.png +40941.png +05289.png +16093.png +17317.png +13435.png +64735.png +56546.png +18804.png +25361.png +39425.png +26487.png +57500.png +66216.png +12525.png +22505.png +53075.png +60551.png +39057.png +02509.png +46927.png +05935.png +37070.png +56622.png +35939.png +54633.png +56309.png +02503.png +11909.png +11811.png +48529.png +45796.png +15672.png +27530.png +34129.png +08286.png +44977.png +60257.png +67815.png +43406.png +49750.png +00942.png +07293.png +65450.png +28759.png +12651.png +48809.png +15788.png +32883.png +45239.png +32378.png +28465.png +63209.png +06509.png +37801.png +39311.png +09573.png +23721.png +40328.png +12780.png +52076.png +66913.png +66105.png +55436.png +04402.png +38393.png +38589.png +46673.png +42051.png +10066.png +10184.png +41105.png +41822.png +28435.png +28958.png +35609.png +02370.png +39984.png +30714.png +63315.png +63262.png +56552.png +17189.png +13450.png +36757.png +48016.png +17875.png +26378.png +55962.png +30287.png +05494.png +69609.png +16003.png +56744.png +60558.png +02062.png +24825.png +68749.png +57709.png +44293.png +32275.png +45621.png +38210.png +48603.png +15947.png +13412.png +11307.png +55850.png +17095.png +69640.png +28035.png +47571.png +55495.png +27131.png +46323.png +23076.png +01812.png +25259.png +37006.png +31255.png +67513.png +51029.png +69954.png +31203.png +64971.png +57985.png +48034.png +15445.png +46198.png +16726.png +46989.png +62567.png +05021.png +64043.png +60846.png +66325.png +40597.png +59753.png +47543.png +11966.png +32538.png +61471.png +01127.png +45919.png +55602.png +44205.png +46690.png +43551.png +13857.png +11427.png +45607.png +57774.png +52571.png +69948.png +30426.png +01246.png +03241.png +32532.png +46672.png +48545.png +63937.png +28797.png +60237.png +19333.png +61268.png +07616.png +22256.png +51390.png +49528.png +16834.png +63712.png +31793.png +23269.png +61343.png +18292.png +12945.png +11122.png +43771.png +34550.png +58793.png +67085.png +55465.png +52491.png +64981.png +03226.png +26114.png +45373.png +36224.png +01101.png +47773.png +02059.png +40997.png +65853.png +18485.png +32222.png +31629.png +24525.png +69723.png +39859.png +33028.png +63450.png +64950.png +61624.png +45956.png +52013.png +12555.png +48388.png +55112.png +22749.png +48786.png +44810.png +63864.png +17151.png +22789.png +67271.png +60029.png +31250.png +55921.png +42857.png +03617.png +41697.png +18097.png +30239.png +03439.png +36238.png +16638.png +00789.png +00113.png +51367.png +50787.png +57918.png +37275.png +12769.png +67740.png +59401.png +68770.png +69287.png +24876.png +44372.png +25017.png +58031.png +25792.png +57320.png +34295.png +28835.png +61535.png +35894.png +21279.png +39462.png +53831.png +61255.png +64063.png +11428.png +08383.png +58387.png +33647.png +33403.png +49520.png +66129.png +23054.png +57303.png +30711.png +40499.png +34305.png +02929.png +60966.png +33089.png +62687.png +10944.png +08502.png +43386.png +27591.png +27589.png +38653.png +18416.png +29973.png +51490.png +12619.png +32144.png +47041.png +32426.png +05755.png +20740.png +45555.png +14572.png +56773.png +37168.png +63632.png +07876.png +53494.png +21585.png +26361.png +29021.png +45163.png +07994.png +14454.png +22388.png +51758.png +43560.png +57462.png +36924.png +15791.png +17241.png +28725.png +28765.png +16585.png +35582.png +19832.png +43990.png +20716.png +18493.png +18322.png +34615.png +25024.png +10598.png +22474.png +56553.png +24409.png +28554.png +09347.png +64685.png +07438.png +05814.png +52073.png +00133.png +53925.png +05390.png +24578.png +21160.png +12681.png +58545.png +33877.png +16914.png +18734.png +45554.png +32257.png +11171.png +39046.png +51115.png +42602.png +19804.png +04682.png +31693.png +10579.png +31192.png +52235.png +59177.png +10046.png +51744.png +50616.png +22229.png +32374.png +65857.png +53449.png +15980.png +32199.png +09145.png +05651.png +26460.png +62176.png +05134.png +44750.png +58829.png +00955.png +65333.png +40546.png +12879.png +00845.png +58195.png +69225.png +13812.png +22375.png +02803.png +60270.png +04079.png +62588.png +29668.png +54367.png +18446.png +23356.png +36338.png +11405.png +51614.png +16705.png +46353.png +30262.png +36638.png +14623.png +59494.png +11964.png +67991.png +16368.png +12334.png +22360.png +47792.png +02855.png +51526.png +10006.png +50099.png +46472.png +38216.png +31448.png +61960.png +23943.png +38127.png +41555.png +03820.png +38214.png +54045.png +49687.png +55193.png +18104.png +63399.png +64513.png +29350.png +21000.png +29954.png +53655.png +13536.png +04683.png +69396.png +43261.png +63976.png +29503.png +23670.png +00841.png +25905.png +59917.png +33829.png +66186.png +07667.png +39556.png +49642.png +69607.png +15045.png +11986.png +10590.png +50884.png +08133.png +26686.png +16478.png +23382.png +63860.png +03844.png +24742.png +51021.png +60402.png +63658.png +40918.png +11345.png +29272.png +68282.png +34057.png +12867.png +45712.png +07936.png +24149.png +39688.png +02911.png +13116.png +25008.png +11608.png +68919.png +00742.png +08901.png +01284.png +21711.png +16808.png +10854.png +68428.png +28129.png +19689.png +27283.png +20826.png +37829.png +61293.png +02482.png +64487.png +35375.png +17466.png +42733.png +67531.png +35911.png +21311.png +27707.png +31281.png +17616.png +45701.png +20653.png +64717.png +40960.png +60094.png +21976.png +38974.png +06399.png +69332.png +32796.png +11632.png +29863.png +33809.png +30881.png +59568.png +11135.png +46934.png +62919.png +12866.png +30335.png +16217.png +05578.png +31046.png +35701.png +23187.png +14359.png +30968.png +13756.png +60792.png +69859.png +49594.png +45604.png +65448.png +03883.png +33483.png +00105.png +31299.png +15981.png +50702.png +67003.png +04761.png +33692.png +36358.png +67873.png +57703.png +36455.png +02932.png +28637.png +47725.png +68036.png +59302.png +28358.png +67436.png +09038.png +53742.png +34456.png +55079.png +62016.png +67588.png +16841.png +39139.png +07911.png +46239.png +66548.png +49797.png +40498.png +07906.png +40118.png +05939.png +13416.png +09705.png +35264.png +44266.png +62125.png +42174.png +25589.png +04830.png +10721.png +48954.png +66690.png +23298.png +26993.png +16882.png +09721.png +57845.png +02194.png +57712.png +54816.png +44156.png +14486.png +48002.png +00707.png +33937.png +48610.png +01184.png +28156.png +25075.png +42058.png +13019.png +01517.png +07734.png +06973.png +38945.png +68496.png +52840.png +02786.png +32888.png +10502.png +36141.png +29987.png +12289.png +57083.png +17392.png +63105.png +36365.png +69474.png +55545.png +13539.png +60822.png +54662.png +26329.png +43672.png +34360.png +18676.png +26198.png +27769.png +37306.png +30909.png +07173.png +68194.png +65428.png +21911.png +35053.png +52358.png +21559.png +10896.png +39804.png +69475.png +68928.png +08253.png +56695.png +21774.png +07233.png +32898.png +20812.png +58986.png +64727.png +45504.png +49454.png +40729.png +28422.png +65834.png +18149.png +06064.png +00805.png +42012.png +33893.png +53509.png +66427.png +20233.png +13707.png +28836.png +06692.png +19830.png +62615.png +26682.png +46598.png +68578.png +47053.png +03930.png +30940.png +55654.png +52936.png +30372.png +14004.png +05018.png +23658.png +22882.png +66517.png +08793.png +47217.png +24096.png +21604.png +22651.png +17866.png +67067.png +42784.png +43419.png +44917.png +25045.png +58832.png +20876.png +44227.png +66856.png +34814.png +46118.png +17105.png +34532.png +28728.png +41371.png +54421.png +22140.png +20190.png +42007.png +57304.png +55039.png +37334.png +05883.png +64984.png +45817.png +26617.png +03971.png +34252.png +09822.png +17133.png +68757.png +12674.png +32939.png +39138.png +37061.png +36102.png +15649.png +23122.png +60146.png +55004.png +49385.png +21605.png +12340.png +05145.png +03755.png +21193.png +58997.png +19680.png +33325.png +39621.png +06018.png +40487.png +18645.png +05569.png +07372.png +28802.png +38430.png +65027.png +28218.png +14051.png +19713.png +14201.png +43324.png +03374.png +26726.png +50717.png +66818.png +31011.png +01474.png +41368.png +44580.png +35941.png +36786.png +63108.png +05258.png +07199.png +53417.png +60112.png +44428.png +42677.png +33891.png +39403.png +29845.png +13903.png +67985.png +20201.png +60161.png +07280.png +16083.png +12344.png +28420.png +35382.png +11071.png +37204.png +58552.png +49160.png +11564.png +46994.png +34356.png +66575.png +41156.png +62385.png +07934.png +12208.png +50449.png +14615.png +46139.png +49798.png +64681.png +27753.png +59678.png +68013.png +18330.png +14189.png +66753.png +42456.png +09818.png +65523.png +68831.png +20931.png +00819.png +49533.png +69625.png +02936.png +51893.png +22235.png +27586.png +28888.png +50575.png +20821.png +23393.png +64348.png +55504.png +55570.png +67983.png +44582.png +03034.png +65899.png +20265.png +54587.png +41501.png +49035.png +00851.png +10212.png +29057.png +54488.png +26569.png +04910.png +62390.png +42628.png +03242.png +48309.png +40143.png +38965.png +17132.png +17773.png +49433.png +27299.png +28597.png +08142.png +63134.png +43006.png +02496.png +56839.png +23487.png +59396.png +57134.png +18741.png +23981.png +65609.png +27473.png +31021.png +35770.png +15762.png +60634.png +60544.png +55946.png +20934.png +22352.png +66637.png +50798.png +24138.png +02682.png +30160.png +64419.png +31461.png +55613.png +57062.png +19282.png +50937.png +09286.png +07949.png +00416.png +52988.png +49976.png +25739.png +02779.png +57893.png +57972.png +31037.png +55273.png +61168.png +21499.png +54200.png +52766.png +45078.png +05329.png +50074.png +16751.png +35432.png +09419.png +69479.png +57581.png +54957.png +26752.png +36168.png +30128.png +23386.png +22396.png +00920.png +16660.png +69450.png +30378.png +53719.png +60327.png +59275.png +31092.png +69182.png +09733.png +11033.png +51237.png +24497.png +33785.png +35463.png +68822.png +39245.png +56540.png +43339.png +52615.png +37387.png +59565.png +52652.png +38858.png +32154.png +13338.png +37220.png +45279.png +59967.png +45884.png +22998.png +24699.png +15807.png +01738.png +00280.png +59399.png +19763.png +12243.png +01030.png +03687.png +66664.png +08612.png +39710.png +62583.png +25438.png +10160.png +32320.png +48199.png +33137.png +39267.png +09699.png +55311.png +30789.png +18381.png +36633.png +52279.png +20286.png +27329.png +67059.png +32366.png +64843.png +47061.png +34343.png +52727.png +32082.png +56293.png +53703.png +19950.png +59521.png +54813.png +34192.png +65500.png +17224.png +36800.png +31821.png +28994.png +28951.png +52817.png +32973.png +44300.png +47014.png +59946.png +19032.png +43810.png +11757.png +17736.png +12579.png +40911.png +33635.png +41861.png +26187.png +65889.png +64392.png +61216.png +51047.png +11736.png +44657.png +67589.png +50376.png +35807.png +40594.png +17878.png +68244.png +37621.png +25811.png +67288.png +64544.png +07904.png +47777.png +27027.png +56163.png +50189.png +30993.png +62037.png +45921.png +60883.png +64808.png +59472.png +31568.png +02806.png +08127.png +69792.png +55996.png +05801.png +53978.png +31954.png +68302.png +30120.png +48580.png +31767.png +52628.png +19416.png +10979.png +12908.png +21654.png +00676.png +13918.png +53480.png +45183.png +15887.png +54058.png +20348.png +65245.png +06360.png +04717.png +69487.png +49599.png +56996.png +11925.png +48530.png +61441.png +35477.png +20049.png +42327.png +47258.png +38700.png +52059.png +69164.png +35259.png +45542.png +01379.png +63500.png +07947.png +22851.png +50332.png +47492.png +11856.png +62895.png +04299.png +31178.png +14591.png +06955.png +24711.png +46516.png +34067.png +42942.png +37590.png +42945.png +37318.png +07852.png +30510.png +46333.png +00996.png +39387.png +21538.png +19406.png +40651.png +62740.png +58162.png +50236.png +60985.png +11802.png +55028.png +48067.png +06060.png +29412.png +35265.png +03916.png +39731.png +39331.png +41878.png +27667.png +27208.png +25147.png +18435.png +25758.png +59374.png +28325.png +04693.png +42688.png +25979.png +63230.png +52222.png +10002.png +03651.png +00379.png +31697.png +00554.png +40521.png +42661.png +47180.png +37041.png +44854.png +27783.png +64708.png +15388.png +29435.png +04698.png +36195.png +01205.png +08556.png +49788.png +63267.png +27540.png +38604.png +19638.png +06899.png +62747.png +12761.png +46971.png +47608.png +66970.png +16087.png +33977.png +45021.png +51281.png +31190.png +27607.png +17460.png +61428.png +34211.png +06183.png +47237.png +18848.png +45825.png +22246.png +64913.png +67101.png +46005.png +20632.png +69972.png +42758.png +24964.png +17849.png +04374.png +14113.png +44440.png +53500.png +64082.png +25023.png +34671.png +10569.png +31434.png +10798.png +31631.png +03952.png +42801.png +20861.png +23737.png +40841.png +08040.png +28922.png +03698.png +35628.png +08898.png +54126.png +15330.png +55409.png +69434.png +07465.png +47881.png +16148.png +49277.png +35534.png +62419.png +36135.png +31502.png +40550.png +57557.png +31768.png +37373.png +58073.png +40869.png +59632.png +56354.png +44671.png +14882.png +61138.png +04700.png +60500.png +05307.png +42521.png +45090.png +22541.png +58333.png +59569.png +51162.png +21406.png +64871.png +13010.png +54514.png +68474.png +24416.png +22732.png +47043.png +35474.png +14718.png +02841.png +20717.png +50368.png +05027.png +05704.png +25093.png +54805.png +60605.png +60847.png +24273.png +37488.png +49093.png +40318.png +18990.png +08063.png +62441.png +66043.png +14426.png +51083.png +66894.png +08478.png +17018.png +30848.png +69572.png +66415.png +53951.png +48575.png +57373.png +25789.png +42071.png +42104.png +37595.png +14988.png +64555.png +49587.png +04928.png +68952.png +33046.png +07584.png +16236.png +55645.png +07216.png +43916.png +43449.png +42847.png +62571.png +69111.png +33953.png +43626.png +53452.png +48448.png +16732.png +31349.png +28970.png +43252.png +51360.png +45864.png +19901.png +18247.png +48558.png +53674.png +29216.png +36791.png +66528.png +16567.png +43129.png +02997.png +00089.png +69361.png +15662.png +27340.png +19402.png +08236.png +02180.png +51319.png +23980.png +12414.png +03495.png +00895.png +24627.png +52962.png +02163.png +11330.png +01759.png +00795.png +24786.png +03772.png +60292.png +32665.png +41088.png +47978.png +45071.png +01489.png +09262.png +29666.png +10925.png +63900.png +12277.png +56442.png +55943.png +60018.png +53271.png +41642.png +26105.png +49154.png +46722.png +12179.png +45175.png +06524.png +08119.png +07705.png +11857.png +00087.png +21330.png +63420.png +42235.png +52830.png +29255.png +50758.png +25004.png +47478.png +08961.png +08916.png +50935.png +16590.png +36361.png +35311.png +66139.png +20171.png +58111.png +18327.png +41275.png +01186.png +68660.png +06916.png +27729.png +52088.png +31428.png +67757.png +03132.png +59361.png +60990.png +01643.png +65961.png +27653.png +47987.png +50572.png +01195.png +63711.png +36832.png +69093.png +09203.png +28741.png +20418.png +19328.png +25227.png +54170.png +30792.png +52803.png +44571.png +20109.png +29505.png +65128.png +66135.png +15558.png +24848.png +49650.png +60457.png +40308.png +06897.png +19799.png +55865.png +25579.png +04054.png +31039.png +61161.png +29375.png +29427.png +56607.png +49083.png +45811.png +60414.png +65080.png +04026.png +48819.png +66555.png +07893.png +18796.png +14313.png +26433.png +11062.png +14866.png +07009.png +12546.png +39850.png +11969.png +40687.png +17957.png +27502.png +42002.png +60613.png +21722.png +46511.png +37120.png +18920.png +42018.png +12035.png +57941.png +64600.png +40756.png +03254.png +31335.png +02154.png +26451.png +07044.png +14405.png +64634.png +26044.png +38158.png +14777.png +59648.png +55702.png +37538.png +02308.png +24847.png +55034.png +01232.png +32689.png +19654.png +48590.png +19876.png +43438.png +04519.png +58652.png +23926.png +43163.png +62285.png +24194.png +18308.png +41495.png +60213.png +25464.png +03887.png +31479.png +04046.png +42781.png +46086.png +28119.png +43143.png +02229.png +52262.png +16474.png +48364.png +23638.png +17815.png +39857.png +31863.png +05891.png +43259.png +16424.png +19296.png +11918.png +51953.png +56267.png +06351.png +18582.png +35113.png +49818.png +69962.png +48278.png +30585.png +35356.png +14243.png +62457.png +38503.png +30615.png +41940.png +35608.png +16782.png +28957.png +68276.png +59842.png +53225.png +14824.png +32935.png +49106.png +20243.png +27239.png +28696.png +49129.png +49970.png +00411.png +05318.png +48995.png +22056.png +61599.png +61510.png +59440.png +31520.png +68386.png +14831.png +69268.png +23931.png +67691.png +08568.png +59841.png +42435.png +03700.png +07663.png +16734.png +00065.png +34556.png +68937.png +46626.png +11682.png +49756.png +03373.png +40986.png +20396.png +12213.png +26222.png +32488.png +66156.png +04291.png +50258.png +40862.png +46841.png +24680.png +28336.png +22904.png +26352.png +07117.png +19189.png +44246.png +17839.png +40385.png +53743.png +09948.png +04258.png +53788.png +43842.png +24857.png +35270.png +52751.png +03866.png +07639.png +47494.png +69023.png +21653.png +28863.png +42799.png +40264.png +32895.png +62240.png +64598.png +12032.png +04182.png +22853.png +13020.png +57475.png +40380.png +26214.png +19744.png +57753.png +63924.png +16720.png +56155.png +36982.png +52062.png +35727.png +47542.png +65976.png +25845.png +33121.png +23560.png +63994.png +28480.png +02127.png +36490.png +36091.png +47860.png +53618.png +37710.png +27201.png +15638.png +43398.png +05226.png +59792.png +42142.png +68824.png +02236.png +05414.png +09834.png +13728.png +14714.png +11355.png +04280.png +12976.png +55084.png +07203.png +23957.png +02196.png +37754.png +48795.png +36063.png +27969.png +58384.png +59463.png +50789.png +67461.png +69594.png +52523.png +59455.png +64960.png +53518.png +15342.png +17642.png +56610.png +61356.png +21851.png +59629.png +30965.png +62417.png +36754.png +14681.png +34555.png +04653.png +17058.png +15753.png +42548.png +59748.png +19878.png +19347.png +03736.png +52695.png +16175.png +65106.png +06074.png +36635.png +36291.png +39155.png +01090.png +61409.png +52199.png +20366.png +32887.png +17015.png +03507.png +55524.png +06007.png +20571.png +26522.png +49614.png +41046.png +49135.png +41971.png +59625.png +09132.png +31531.png +33871.png +52017.png +01031.png +14333.png +41056.png +26708.png +24910.png +48166.png +25558.png +63809.png +21338.png +64819.png +03380.png +22652.png +22091.png +56878.png +64339.png +41370.png +56821.png +55439.png +07318.png +44435.png +09211.png +35219.png +00850.png +43366.png +62163.png +02282.png +51330.png +43094.png +44430.png +46150.png +14776.png +02390.png +03030.png +06196.png +32101.png +57104.png +53117.png +66220.png +07886.png +01560.png +58869.png +08070.png +23263.png +21296.png +52931.png +24516.png +00102.png +46714.png +50784.png +62222.png +56202.png +27569.png +12746.png +53830.png +24257.png +69752.png +44121.png +45294.png +05678.png +63481.png +41331.png +23680.png +17786.png +31170.png +30059.png +00921.png +20961.png +54548.png +09004.png +53514.png +01335.png +34679.png +20128.png +05874.png +43019.png +53303.png +25188.png +56562.png +47583.png +16018.png +15610.png +67549.png +17280.png +51739.png +59883.png +62779.png +68257.png +47197.png +51015.png +67320.png +67662.png +48250.png +44723.png +63625.png +44234.png +20021.png +38612.png +65460.png +27943.png +01679.png +04837.png +41875.png +21768.png +62413.png +03024.png +45795.png +17135.png +00634.png +14228.png +07348.png +28629.png +35780.png +19187.png +07191.png +21836.png +60119.png +14433.png +24521.png +25274.png +08607.png +18674.png +44817.png +34704.png +14932.png +63639.png +01310.png +27761.png +06560.png +20343.png +42431.png +03789.png +45295.png +51070.png +60293.png +46227.png +54719.png +23686.png +62492.png +61887.png +58516.png +27663.png +26548.png +59313.png +38228.png +07323.png +14552.png +67105.png +51708.png +06279.png +68110.png +15761.png +36424.png +64005.png +60100.png +52599.png +36679.png +20065.png +05915.png +32124.png +65131.png +06058.png +32035.png +64547.png +68659.png +04644.png +05937.png +24579.png +68967.png +55108.png +42834.png +43706.png +00627.png +58650.png +50588.png +18739.png +17927.png +23709.png +10582.png +09224.png +02947.png +01796.png +17434.png +47306.png +59605.png +06760.png +30460.png +64284.png +17004.png +44083.png +60467.png +07833.png +27812.png +25346.png +64111.png +49276.png +40832.png +21358.png +67169.png +15960.png +24296.png +08408.png +57923.png +27696.png +38905.png +08338.png +38952.png +47216.png +00423.png +15337.png +59475.png +07820.png +26453.png +22481.png +39924.png +61921.png +36205.png +57351.png +08785.png +56327.png +64431.png +34892.png +55634.png +37314.png +52583.png +60022.png +33556.png +14566.png +09983.png +39950.png +05459.png +48618.png +16042.png +64405.png +50116.png +15678.png +18991.png +53145.png +37109.png +15402.png +05264.png +45213.png +38172.png +24021.png +54291.png +67954.png +36024.png +07777.png +55441.png +61734.png +19545.png +22503.png +56071.png +00404.png +04875.png +62355.png +48169.png +14875.png +10350.png +18178.png +67675.png +50012.png +16245.png +45140.png +08136.png +64485.png +44133.png +26255.png +27032.png +15309.png +12735.png +33376.png +35392.png +54144.png +50323.png +06638.png +57037.png +39089.png +26436.png +03823.png +17182.png +52811.png +24080.png +06186.png +00551.png +06518.png +09245.png +20528.png +23436.png +56943.png +26509.png +01454.png +37689.png +59020.png +00714.png +21914.png +28091.png +66437.png +04566.png +51853.png +15575.png +40090.png +48476.png +00304.png +64793.png +62397.png +43882.png +49310.png +26177.png +07675.png +41201.png +61886.png +66183.png +06099.png +54835.png +10882.png +30516.png +36405.png +14171.png +03784.png +08648.png +22494.png +26331.png +67118.png +24723.png +03591.png +44783.png +30400.png +43048.png +53662.png +28355.png +66434.png +25079.png +14622.png +08558.png +04217.png +06888.png +12485.png +59945.png +18466.png +48663.png +07916.png +18583.png +55388.png +46432.png +40383.png +08145.png +51955.png +30453.png +09806.png +54577.png +57499.png +52410.png +19555.png +54128.png +17325.png +15701.png +07964.png +24063.png +57421.png +25949.png +44489.png +28281.png +60246.png +61683.png +07700.png +16763.png +39786.png +38459.png +68794.png +53392.png +68309.png +53589.png +19738.png +39502.png +30242.png +06402.png +62938.png +21423.png +31315.png +16467.png +26322.png +42696.png +20480.png +34660.png +15204.png +04886.png +19605.png +34769.png +10114.png +35720.png +28280.png +50184.png +32609.png +48192.png +14724.png +43701.png +34223.png +42391.png +43028.png +69762.png +31377.png +28399.png +65431.png +25407.png +32572.png +38470.png +55985.png +10272.png +46707.png +29544.png +12444.png +14675.png +45536.png +01853.png +31516.png +05439.png +12818.png +19084.png +26906.png +49673.png +01172.png +11461.png +49016.png +50096.png +32571.png +27705.png +56516.png +32115.png +69622.png +27513.png +28079.png +33313.png +16684.png +15379.png +43303.png +27045.png +40746.png +48367.png +27073.png +51087.png +60015.png +31323.png +23608.png +00614.png +15685.png +14039.png +44568.png +31442.png +11247.png +54691.png +06610.png +51422.png +06073.png +30647.png +47199.png +14525.png +08010.png +51186.png +13581.png +44613.png +50339.png +66775.png +57593.png +37904.png +37545.png +21029.png +49967.png +36559.png +27557.png +61509.png +25499.png +07266.png +39064.png +68801.png +31123.png +56441.png +21916.png +61226.png +65630.png +67213.png +11619.png +29635.png +59199.png +18375.png +69216.png +33516.png +30071.png +47971.png +54685.png +31422.png +68617.png +28245.png +03015.png +20883.png +43164.png +13060.png +42176.png +21536.png +47275.png +26284.png +12100.png +66385.png +32892.png +30939.png +48488.png +12322.png +18697.png +06873.png +29419.png +66032.png +30180.png +69087.png +66982.png +68146.png +48068.png +26104.png +45979.png +46134.png +36643.png +57602.png +04790.png +41416.png +35395.png +13970.png +69341.png +16011.png +59547.png +67519.png +48378.png +58895.png +47662.png +55598.png +17362.png +13112.png +69044.png +29728.png +66195.png +39802.png +03119.png +38257.png +60381.png +00668.png +18625.png +34910.png +02772.png +11086.png +68832.png +01822.png +60429.png +14712.png +45548.png +64820.png +63244.png +64470.png +37986.png +32523.png +21968.png +32928.png +57387.png +10975.png +69893.png +33030.png +59763.png +44185.png +48993.png +19323.png +45810.png +39750.png +69605.png +42536.png +12873.png +47236.png +55578.png +41720.png +43374.png +43036.png +60116.png +38803.png +08707.png +34210.png +26285.png +28141.png +55798.png +30818.png +17682.png +60089.png +49874.png +57683.png +30122.png +37592.png +56169.png +43393.png +23460.png +58481.png +21566.png +28374.png +31228.png +24395.png +38556.png +58241.png +13832.png +64968.png +60682.png +44265.png +44208.png +35741.png +41533.png +50416.png +60951.png +57164.png +68540.png +48785.png +45935.png +43901.png +55882.png +00408.png +36437.png +65212.png +61202.png +12492.png +05698.png +48107.png +06747.png +18222.png +17653.png +14252.png +15367.png +06563.png +27786.png +26227.png +60059.png +22796.png +30411.png +61063.png +44087.png +55404.png +38677.png +43347.png +62500.png +36461.png +45426.png +60141.png +19181.png +68004.png +38137.png +06587.png +39290.png +22506.png +49180.png +15197.png +42273.png +38042.png +32499.png +12309.png +65111.png +49079.png +45032.png +51285.png +26650.png +18896.png +65005.png +16149.png +03401.png +02220.png +43608.png +03365.png +67076.png +54163.png +41818.png +51141.png +06794.png +67899.png +32440.png +50948.png +57514.png +40902.png +68135.png +39671.png +33204.png +34260.png +24299.png +61805.png +61780.png +49668.png +36406.png +35537.png +28870.png +00629.png +66303.png +13937.png +05951.png +35232.png +36069.png +60711.png +15622.png +51684.png +24760.png +04253.png +57121.png +10146.png +42876.png +64897.png +15369.png +05936.png +36658.png +35668.png +64881.png +31786.png +68261.png +24363.png +16040.png +60147.png +59426.png +32604.png +09528.png +47125.png +27404.png +46844.png +17778.png +62293.png +24364.png +51393.png +69963.png +41724.png +12449.png +15642.png +55614.png +24171.png +38812.png +27412.png +57954.png +47986.png +13071.png +55463.png +09231.png +05016.png +38794.png +49451.png +66908.png +09047.png +28842.png +20379.png +23044.png +69535.png +21771.png +30936.png +21093.png +07661.png +26180.png +00560.png +46142.png +16451.png +52509.png +42244.png +62776.png +51943.png +52823.png +51778.png +42323.png +47070.png +51706.png +45223.png +42568.png +48428.png +29524.png +07043.png +62587.png +35287.png +24060.png +00488.png +03044.png +55904.png +04929.png +57346.png +32391.png +23485.png +67119.png +48605.png +63497.png +17333.png +53865.png +48260.png +00699.png +54860.png +28303.png +42648.png +16647.png +30038.png +08160.png +10529.png +14673.png +00521.png +07836.png +30228.png +33555.png +37294.png +33075.png +65335.png +02256.png +33918.png +23442.png +29022.png +64874.png +22925.png +58325.png +57177.png +56144.png +05451.png +10849.png +65691.png +31111.png +15288.png +02661.png +33578.png +17522.png +32442.png +48855.png +40250.png +04357.png +20601.png +41919.png +04121.png +69260.png +59430.png +12387.png +21629.png +66931.png +53289.png +55308.png +20083.png +09529.png +69250.png +53550.png +58081.png +13236.png +69942.png +62735.png +61029.png +47557.png +03443.png +36236.png +04815.png +06024.png +28087.png +08876.png +10900.png +12906.png +64995.png +58756.png +16464.png +59022.png +15487.png +28967.png +53924.png +30439.png +17400.png +58497.png +03614.png +61042.png +47787.png +31507.png +53760.png +05898.png +00566.png +38513.png +44972.png +34985.png +49070.png +46875.png +26206.png +23516.png +14218.png +02518.png +67869.png +13200.png +23811.png +37796.png +47307.png +07374.png +16322.png +37747.png +50457.png +47840.png +32487.png +07920.png +03588.png +16559.png +42603.png +02689.png +63887.png +23952.png +51142.png +03074.png +02945.png +05378.png +67309.png +53568.png +30544.png +62849.png +31855.png +62080.png +32386.png +17615.png +31126.png +32792.png +28277.png +69763.png +00817.png +55792.png +56054.png +40741.png +48113.png +43998.png +47746.png +08335.png +17021.png +13074.png +67974.png +07212.png +09690.png +15216.png +55320.png +26391.png +59363.png +50716.png +66429.png +38961.png +61639.png +68091.png +59244.png +68266.png +20903.png +05917.png +27609.png +23613.png +14144.png +69844.png +41956.png +24092.png +09317.png +46057.png +18713.png +00290.png +20954.png +26814.png +30393.png +42529.png +18412.png +28318.png +25770.png +15549.png +00513.png +55440.png +65235.png +66291.png +53492.png +08228.png +32801.png +41357.png +68861.png +50590.png +69623.png +18986.png +41944.png +20991.png +63607.png +54116.png +54217.png +26958.png +64245.png +37337.png +21963.png +33626.png +57256.png +23967.png +38143.png +13242.png +24023.png +37231.png +50979.png +40547.png +32623.png +68254.png +16454.png +06543.png +67413.png +66825.png +41294.png +38092.png +41966.png +42124.png +22190.png +61180.png +60142.png +18314.png +68858.png +27282.png +21569.png +67799.png +61112.png +23216.png +14480.png +13154.png +26848.png +18895.png +43654.png +56712.png +26226.png +33641.png +41821.png +55328.png +69300.png +49232.png +20288.png +55268.png +03317.png +60118.png +68415.png +25153.png +34617.png +50282.png +00291.png +36318.png +34306.png +61066.png +44855.png +39609.png +57657.png +36793.png +18568.png +26343.png +21926.png +05442.png +66669.png +56910.png +19409.png +21758.png +60108.png +21222.png +57405.png +25911.png +02654.png +20368.png +62796.png +05360.png +02790.png +69098.png +17700.png +18921.png +37988.png +45029.png +68637.png +14270.png +49880.png +44824.png +28254.png +20860.png +55548.png +58915.png +21840.png +56419.png +00790.png +60189.png +65877.png +32978.png +02691.png +35776.png +60594.png +13687.png +68381.png +57369.png +40855.png +18343.png +52389.png +48640.png +56981.png +22922.png +21795.png +57091.png +65660.png +45576.png +02403.png +21157.png +01996.png +03239.png +17601.png +10560.png +68551.png +63091.png +04477.png +27328.png +11169.png +69611.png +04169.png +19478.png +22874.png +58678.png +58022.png +28235.png +23326.png +58283.png +53061.png +24727.png +57476.png +28034.png +34173.png +62158.png +27362.png +61576.png +47650.png +36501.png +05480.png +57639.png +52485.png +51972.png +33098.png +03896.png +13045.png +53960.png +51569.png +30693.png +39239.png +08695.png +30917.png +06999.png +02273.png +54203.png +54942.png +51257.png +67867.png +23221.png +24792.png +25089.png +53896.png +01077.png +03547.png +23421.png +12742.png +05780.png +45229.png +63662.png +34648.png +56682.png +24756.png +48409.png +41737.png +20298.png +42290.png +47174.png +07482.png +43718.png +40294.png +29045.png +23767.png +10613.png +06315.png +59653.png +26900.png +36545.png +08969.png +18830.png +42632.png +26542.png +20327.png +05059.png +11416.png +43879.png +68484.png +01720.png +22812.png +16754.png +57084.png +66901.png +36884.png +46164.png +01897.png +03330.png +11843.png +21805.png +64435.png +68281.png +56130.png +28853.png +19978.png +32987.png +41140.png +14762.png +65498.png +01113.png +50343.png +31560.png +18822.png +49237.png +11935.png +50606.png +22429.png +17351.png +35117.png +15135.png +61117.png +61172.png +66530.png +30390.png +15507.png +60863.png +69200.png +55166.png +24802.png +02915.png +04293.png +51898.png +36599.png +08598.png +51672.png +02528.png +51197.png +48556.png +59779.png +50728.png +35394.png +37867.png +25350.png +29370.png +07975.png +53177.png +65248.png +03099.png +26135.png +11819.png +39327.png +27155.png +40971.png +07300.png +50058.png +48632.png +04584.png +27625.png +46904.png +00321.png +28426.png +00471.png +65765.png +69218.png +53875.png +33400.png +59173.png +22453.png +44796.png +48179.png +68130.png +50874.png +57727.png +54879.png +36625.png +25900.png +37995.png +52064.png +44787.png +04749.png +38004.png +51071.png +30999.png +27988.png +12458.png +44014.png +47451.png +15005.png +07343.png +26244.png +34012.png +63698.png +53356.png +33982.png +16033.png +63156.png +49929.png +44658.png +56972.png +25132.png +30514.png +30896.png +63813.png +24397.png +41817.png +03902.png +46863.png +19629.png +42025.png +38390.png +06332.png +66089.png +40569.png +13653.png +57888.png +14293.png +44844.png +11262.png +59924.png +01950.png +57844.png +26845.png +33638.png +45220.png +36363.png +26060.png +37209.png +33252.png +12427.png +36176.png +07331.png +26249.png +35568.png +28787.png +28622.png +37407.png +17242.png +02044.png +64835.png +31555.png +26753.png +04969.png +51926.png +01490.png +16903.png +53253.png +40575.png +19144.png +56658.png +33994.png +62671.png +65903.png +67036.png +27395.png +59487.png +51579.png +23188.png +10270.png +38062.png +44052.png +55916.png +22049.png +69675.png +01557.png +16569.png +46491.png +34472.png +56654.png +23302.png +02789.png +26589.png +49274.png +65664.png +37614.png +56923.png +43841.png +53536.png +51136.png +34364.png +04498.png +35397.png +44197.png +37466.png +14510.png +40919.png +15037.png +20277.png +29592.png +22723.png +66333.png +10228.png +35689.png +36295.png +24730.png +07296.png +25197.png +55195.png +35481.png +59087.png +65709.png +21973.png +27884.png +61974.png +47588.png +65990.png +66884.png +07738.png +08216.png +37567.png +23564.png +45799.png +67483.png +31293.png +43384.png +52974.png +06109.png +00223.png +47081.png +13645.png +12073.png +04960.png +16543.png +02347.png +18711.png +61749.png +04239.png +60806.png +10276.png +64493.png +33701.png +48328.png +57349.png +32666.png +33776.png +20313.png +47970.png +60851.png +04593.png +65871.png +21983.png +06954.png +49853.png +60390.png +54307.png +01373.png +14452.png +36171.png +06045.png +54918.png +56877.png +14755.png +39201.png +49243.png +64209.png +52761.png +11309.png +35793.png +24817.png +59997.png +56417.png +19165.png +61590.png +56152.png +63400.png +46225.png +45161.png +66589.png +32118.png +35588.png +28338.png +38573.png +47215.png +39665.png +60635.png +05173.png +08638.png +58199.png +18731.png +09219.png +43678.png +12162.png +10478.png +17387.png +07046.png +66758.png +04798.png +06876.png +55073.png +61394.png +01500.png +15282.png +24118.png +34587.png +09449.png +19828.png +05322.png +67772.png +21796.png +38029.png +06994.png +44046.png +25863.png +05170.png +14187.png +38077.png +40039.png +67497.png +56000.png +30336.png +28050.png +58796.png +64333.png +39514.png +55848.png +61249.png +16500.png +68472.png +22574.png +52923.png +54201.png +19786.png +30979.png +55093.png +30215.png +11413.png +56103.png +60019.png +06469.png +39668.png +61949.png +16039.png +34324.png +69618.png +46338.png +52428.png +06048.png +30797.png +34896.png +69376.png +46328.png +32141.png +60970.png +45425.png +33436.png +39218.png +46396.png +42666.png +46148.png +50580.png +64966.png +52440.png +54948.png +64459.png +39450.png +09675.png +46507.png +66355.png +30543.png +56916.png +16167.png +23423.png +31761.png +51619.png +06011.png +53063.png +51909.png +50851.png +33120.png +45012.png +08521.png +69171.png +33411.png +44530.png +05563.png +42973.png +35371.png +19239.png +22410.png +40479.png +14852.png +21095.png +69918.png +64223.png +32761.png +05501.png +60592.png +30785.png +26107.png +29562.png +16628.png +01877.png +62803.png +12015.png +48218.png +53497.png +16598.png +60037.png +62155.png +43055.png +58711.png +55480.png +13509.png +04171.png +45892.png +43984.png +54733.png +65923.png +08980.png +45042.png +39273.png +04553.png +63266.png +37324.png +09246.png +22160.png +44684.png +55344.png +53638.png +15838.png +57841.png +13929.png +22333.png +18478.png +63516.png +24914.png +53290.png +17654.png +19823.png +07197.png +35472.png +21510.png +69759.png +05088.png +03728.png +51060.png +67914.png +02797.png +42653.png +19073.png +40317.png +22510.png +52997.png +57445.png +05970.png +28991.png +25334.png +39180.png +02333.png +53524.png +37730.png +41164.png +47361.png +41116.png +45395.png +46587.png +26987.png +16141.png +45624.png +05649.png +21846.png +69494.png +37570.png +06998.png +14960.png +52502.png +18236.png +18167.png +67844.png +50674.png +10067.png +45256.png +06881.png +69819.png +44402.png +02111.png +30654.png +56143.png +65557.png +52718.png +35363.png +11952.png +36894.png +27961.png +27248.png +59814.png +44195.png +69384.png +45898.png +03839.png +67796.png +24033.png +54353.png +67399.png +66310.png +51308.png +21145.png +69717.png +38520.png +23294.png +06688.png +46764.png +48105.png +36947.png +37824.png +05973.png +48316.png +17989.png +39328.png +15201.png +23771.png +47235.png +00109.png +26842.png +48710.png +36669.png +39068.png +45816.png +27002.png +62560.png +29290.png +01527.png +16928.png +57395.png +52853.png +62276.png +20600.png +44244.png +49546.png +05526.png +32112.png +21355.png +22276.png +50826.png +51875.png +23311.png +20508.png +00092.png +49593.png +38889.png +28988.png +55859.png +41854.png +10049.png +13393.png +56095.png +16486.png +03010.png +64865.png +26299.png +33995.png +11481.png +06265.png +40194.png +63114.png +53390.png +60570.png +31601.png +38686.png +31320.png +16353.png +20076.png +29234.png +52019.png +65108.png +21660.png +19924.png +06650.png +68189.png +60356.png +47851.png +27986.png +47529.png +26704.png +61054.png +43515.png +37026.png +54841.png +16653.png +40807.png +35133.png +60854.png +13924.png +50714.png +31406.png +11097.png +46352.png +49085.png +50170.png +63820.png +03455.png +48295.png +46127.png +50866.png +35853.png +21950.png +14674.png +15847.png +26148.png +35003.png +61174.png +56361.png +04799.png +04469.png +54659.png +39211.png +45132.png +40554.png +01106.png +20772.png +45550.png +27150.png +48480.png +55376.png +27390.png +62893.png +27803.png +09453.png +61493.png +68369.png +56924.png +11933.png +09866.png +12174.png +54501.png +48763.png +04893.png +23396.png +29522.png +14887.png +35681.png +53894.png +45944.png +65844.png +45065.png +12142.png +66328.png +37462.png +41546.png +41665.png +42295.png +41870.png +07727.png +05811.png +13962.png +66927.png +07933.png +09841.png +69055.png +36691.png +35953.png +57649.png +06478.png +36607.png +00224.png +50554.png +60543.png +67628.png +22119.png +26800.png +01293.png +60531.png +36628.png +23039.png +24258.png +41867.png +65663.png +33765.png +16239.png +07618.png +59716.png +13484.png +17647.png +01595.png +03950.png +58991.png +55345.png +13862.png +68641.png +57262.png +66830.png +68078.png +15571.png +68177.png +31146.png +08951.png +06280.png +23507.png +27279.png +06400.png +36646.png +46048.png +14536.png +42888.png +66506.png +18275.png +36971.png +69692.png +39185.png +31749.png +59607.png +00544.png +06117.png +18873.png +52201.png +34459.png +60861.png +02643.png +17411.png +29555.png +56793.png +39043.png +04242.png +65832.png +19186.png +56605.png +44730.png +05778.png +03092.png +59803.png +46304.png +28194.png +16235.png +22041.png +46276.png +16738.png +61423.png +31937.png +48265.png +63823.png +17973.png +03661.png +38743.png +29344.png +21759.png +24921.png +31476.png +44320.png +21531.png +33418.png +69428.png +46113.png +01346.png +15265.png +07491.png +68021.png +00642.png +62079.png +59791.png +18351.png +55054.png +28433.png +02729.png +09808.png +19446.png +12429.png +60526.png +62379.png +55247.png +38935.png +10389.png +18877.png +24298.png +61205.png +29565.png +03392.png +61305.png +44264.png +35017.png +20016.png +31427.png +43134.png +50769.png +15937.png +41536.png +13898.png +29980.png +10282.png +48516.png +23218.png +17156.png +14036.png +38635.png +68677.png +36096.png +27821.png +58284.png +63229.png +14417.png +21525.png +49150.png +29117.png +49304.png +20404.png +45967.png +45693.png +01880.png +62987.png +07089.png +21047.png +63406.png +23533.png +06150.png +18464.png +56230.png +20646.png +31318.png +45954.png +60497.png +27141.png +09436.png +69372.png +20496.png +46779.png +15324.png +27632.png +39456.png +56539.png +65302.png +17066.png +20027.png +06920.png +64177.png +24750.png +29008.png +41994.png +11454.png +54062.png +08407.png +09640.png +50499.png +36515.png +31162.png +23028.png +44188.png +36220.png +62586.png +02931.png +46065.png +24524.png +37071.png +60288.png +41169.png +27855.png +32713.png +36877.png +39636.png +01100.png +41960.png +26020.png +53574.png +31147.png +00174.png +56225.png +25878.png +25942.png +34059.png +62020.png +65600.png +26956.png +39591.png +00023.png +17288.png +59160.png +00491.png +10724.png +69867.png +54602.png +30100.png +45017.png +08293.png +64021.png +14647.png +51736.png +60250.png +40327.png +01308.png +05774.png +36107.png +51072.png +29358.png +03798.png +55102.png +29723.png +29107.png +13643.png +48531.png +09458.png +40267.png +17620.png +44109.png +45996.png +18773.png +48462.png +23942.png +37255.png +55674.png +02809.png +61649.png +58145.png +39886.png +09778.png +26756.png +12143.png +06306.png +64738.png +39976.png +02494.png +05953.png +20070.png +58372.png +03710.png +04733.png +29245.png +01359.png +59673.png +35310.png +57145.png +47576.png +26751.png +00301.png +58517.png +62949.png +07682.png +30031.png +50259.png +57854.png +12570.png +59757.png +36221.png +42086.png +68074.png +35753.png +45126.png +06487.png +38810.png +02585.png +39482.png +09526.png +39179.png +36279.png +04011.png +69769.png +26564.png +23786.png +03776.png +58065.png +59325.png +34088.png +17404.png +29363.png +69793.png +21083.png +64840.png +53272.png +52179.png +29444.png +37295.png +13574.png +17982.png +03155.png +51792.png +33697.png +56214.png +51851.png +64135.png +11770.png +35847.png +54207.png +11154.png +30671.png +55499.png +02388.png +34028.png +12965.png +43161.png +62541.png +17077.png +48170.png +08628.png +00999.png +06422.png +23247.png +38166.png +24987.png +58742.png +04752.png +11531.png +47099.png +28850.png +59609.png +45821.png +09478.png +58219.png +17713.png +33985.png +55419.png +41456.png +08463.png +53154.png +14307.png +36966.png +56160.png +27564.png +68131.png +43086.png +08001.png +59522.png +40938.png +21383.png +65417.png +64090.png +09178.png +08960.png +13111.png +20352.png +29819.png +30367.png +19069.png +42720.png +41588.png +55716.png +11624.png +39966.png +45487.png +50919.png +18861.png +37925.png +28259.png +03432.png +32814.png +69278.png +28562.png +66619.png +31949.png +65483.png +48928.png +18017.png +29513.png +27403.png +32856.png +04203.png +64308.png +22338.png +19301.png +43391.png +14099.png +03043.png +19814.png +67000.png +36225.png +27724.png +33689.png +56213.png +27731.png +21256.png +57722.png +59743.png +59804.png +51034.png +19053.png +44595.png +65354.png +10871.png +02829.png +13067.png +44497.png +05644.png +44745.png +08362.png +59460.png +17035.png +38232.png +34316.png +63269.png +05992.png +32399.png +56917.png +32580.png +44851.png +21075.png +26989.png +60289.png +12726.png +26035.png +17279.png +04842.png +52655.png +10230.png +58050.png +46072.png +09090.png +19502.png +22271.png +06546.png +31494.png +58887.png +44849.png +09148.png +36630.png +29259.png +37914.png +17284.png +30558.png +26160.png +39953.png +21378.png +18396.png +65030.png +66603.png +47936.png +64498.png +09336.png +57038.png +69771.png +07480.png +68603.png +00062.png +39892.png +61452.png +15616.png +49488.png +03949.png +54744.png +39735.png +67416.png +36690.png +28923.png +38928.png +17441.png +00190.png +37961.png +25235.png +52610.png +38835.png +32626.png +14008.png +15408.png +66288.png +02103.png +45843.png +55952.png +51676.png +55601.png +28230.png +60549.png +57659.png +47784.png +26513.png +21842.png +06421.png +47756.png +15339.png +53686.png +64815.png +28409.png +30568.png +64982.png +43034.png +03440.png +49366.png +04716.png +20702.png +19560.png +26267.png +15396.png +51951.png +65702.png +28007.png +61243.png +52187.png +30983.png +19724.png +22727.png +40503.png +02472.png +28559.png +01731.png +44459.png +66040.png +60103.png +56395.png +26512.png +63708.png +16183.png +01687.png +30274.png +64734.png +15118.png +49029.png +16330.png +44001.png +31639.png +22084.png +10890.png +10390.png +28882.png +51416.png +36711.png +29599.png +24157.png +18281.png +69264.png +68574.png +64526.png +44923.png +62098.png +57299.png +15637.png +50757.png +14567.png +17835.png +16948.png +21829.png +24302.png +10775.png +16654.png +30271.png +44469.png +36286.png +11038.png +38929.png +10192.png +02540.png +46688.png +54027.png +62033.png +24677.png +05071.png +61191.png +15232.png +23380.png +08617.png +05954.png +65151.png +22702.png +01862.png +02053.png +39813.png +01727.png +06142.png +51045.png +35223.png +37393.png +41090.png +30138.png +33769.png +66643.png +60416.png +16867.png +25502.png +48248.png +04976.png +63967.png +25158.png +08566.png +24412.png +54413.png +50268.png +07301.png +28855.png +55206.png +57235.png +43518.png +17248.png +02677.png +64324.png +11798.png +15774.png +67680.png +60329.png +03574.png +35974.png +45048.png +45000.png +19305.png +67684.png +46911.png +56787.png +63316.png +20925.png +60344.png +50612.png +60835.png +61560.png +25441.png +56570.png +06204.png +17296.png +13657.png +39255.png +13822.png +67931.png +48354.png +53193.png +08369.png +66882.png +25709.png +05812.png +27162.png +00211.png +56501.png +34733.png +47456.png +25207.png +36017.png +20101.png +55381.png +50318.png +39883.png +25352.png +64519.png +50889.png +28022.png +50980.png +17904.png +52651.png +04531.png +67128.png +50346.png +28887.png +30249.png +64315.png +55187.png +05967.png +43764.png +04287.png +66444.png +32002.png +64769.png +03253.png +69295.png +13966.png +36603.png +13470.png +17842.png +40195.png +32242.png +08543.png +06175.png +68918.png +13456.png +13234.png +41144.png +22920.png +62281.png +10253.png +28878.png +48777.png +57685.png +39420.png +49900.png +05469.png +42818.png +15366.png +27643.png +26272.png +57615.png +36088.png +23376.png +50611.png +50468.png +03569.png +07790.png +20999.png +41610.png +56705.png +67906.png +56280.png +13752.png +43257.png +44007.png +66957.png +01123.png +06270.png +64965.png +23677.png +39467.png +56735.png +15150.png +69270.png +34690.png +01210.png +46820.png +10038.png +33545.png +36776.png +19888.png +46483.png +65661.png +17083.png +09346.png +36492.png +69125.png +36731.png +65254.png +13165.png +06715.png +53207.png +38774.png +49770.png +66018.png +17943.png +54970.png +47941.png +63789.png +02907.png +05991.png +20295.png +66996.png +51761.png +54890.png +09852.png +25774.png +53115.png +28571.png +38014.png +29594.png +46918.png +58526.png +40926.png +49997.png +59768.png +51607.png +42137.png +54395.png +00185.png +66918.png +49809.png +55379.png +44897.png +69813.png +54432.png +39914.png +09810.png +40231.png +25339.png +29115.png +06465.png +16021.png +06583.png +38225.png +15550.png +07065.png +51504.png +08079.png +12000.png +18220.png +61566.png +10773.png +51188.png +51020.png +46831.png +37781.png +57926.png +20896.png +11115.png +58315.png +60088.png +60626.png +47385.png +24132.png +67455.png +32980.png +12998.png +63694.png +10845.png +17363.png +28775.png +06004.png +21996.png +02153.png +39296.png +45635.png +13378.png +05349.png +43923.png +66013.png +63592.png +27673.png +60701.png +15476.png +38204.png +45713.png +48191.png +40421.png +64449.png +43723.png +54260.png +22473.png +55289.png +22751.png +38907.png +11732.png +51611.png +05297.png +41490.png +22500.png +18480.png +26171.png +48802.png +25027.png +35262.png +66459.png +28795.png +60755.png +40508.png +03231.png +50314.png +66343.png +42992.png +57959.png +65353.png +16502.png +37653.png +35734.png +05039.png +38291.png +62504.png +50650.png +19630.png +02514.png +05247.png +18532.png +21945.png +12602.png +21397.png +27115.png +62585.png +12001.png +41573.png +00091.png +23068.png +29165.png +59465.png +03925.png +13310.png +32533.png +66122.png +11698.png +49619.png +17343.png +09377.png +56891.png +50390.png +25724.png +58905.png +12930.png +57244.png +20749.png +58139.png +62556.png +52135.png +38243.png +15199.png +06372.png +29814.png +08008.png +53176.png +69651.png +36785.png +44005.png +18143.png +32419.png +30754.png +19422.png +23736.png +49934.png +08014.png +13997.png +36725.png +07978.png +39344.png +53741.png +02742.png +46885.png +35650.png +63103.png +25522.png +61043.png +26830.png +41397.png +08309.png +49156.png +39573.png +42689.png +36432.png +02317.png +03037.png +03058.png +56522.png +16961.png +19801.png +60488.png +36525.png +61893.png +56215.png +60442.png +26790.png +67645.png +20588.png +04286.png +15222.png +32915.png +48377.png +29081.png +40171.png +04424.png +29610.png +60555.png +00236.png +35839.png +28724.png +49253.png +08647.png +07573.png +04407.png +68851.png +40314.png +45755.png +12351.png +16591.png +56649.png +05000.png +47933.png +51925.png +50226.png +63123.png +31398.png +06236.png +63474.png +51828.png +19882.png +49345.png +50474.png +14438.png +30048.png +10521.png +17195.png +24424.png +16815.png +06092.png +41155.png +64921.png +05710.png +45615.png +10051.png +60427.png +37468.png +06528.png +03721.png +65469.png +33181.png +11109.png +67769.png +27967.png +59021.png +17694.png +63730.png +26523.png +16523.png +04004.png +44967.png +46306.png +69529.png +64664.png +47631.png +24897.png +28999.png +48066.png +20683.png +08966.png +30521.png +68352.png +50136.png +24679.png +58332.png +51597.png +04979.png +28512.png +45160.png +61625.png +51303.png +11157.png +08476.png +20220.png +52684.png +43757.png +40603.png +27775.png +47817.png +06774.png +12920.png +55703.png +17539.png +69755.png +18134.png +63936.png +43222.png +36760.png +59479.png +53723.png +64042.png +26937.png +38156.png +50000.png +49403.png +00240.png +52954.png +02899.png +40658.png +38658.png +16953.png +45840.png +20315.png +41578.png +30914.png +08462.png +43530.png +43405.png +03636.png +18891.png +34289.png +31287.png +31500.png +67163.png +47989.png +24523.png +66689.png +06047.png +40680.png +30288.png +46600.png +64145.png +58296.png +28074.png +60305.png +60389.png +17924.png +13570.png +25661.png +58567.png +65897.png +47011.png +36200.png +10965.png +50426.png +50331.png +27917.png +11754.png +20522.png +55096.png +62314.png +65607.png +13942.png +22800.png +59745.png +57950.png +19727.png +27913.png +31678.png +39196.png +32403.png +42605.png +34853.png +02508.png +02233.png +42282.png +66535.png +57284.png +58507.png +57254.png +62237.png +41008.png +26338.png +23441.png +26426.png +12324.png +33263.png +58059.png +13747.png +60033.png +41411.png +53318.png +03812.png +68180.png +05875.png +38012.png +04050.png +40381.png +55624.png +52975.png +50651.png +14728.png +17070.png +32710.png +23902.png +40532.png +51477.png +65676.png +57428.png +45211.png +44762.png +12596.png +31607.png +57363.png +28343.png +36517.png +54325.png +64334.png +14021.png +29716.png +23909.png +16898.png +16108.png +59294.png +53058.png +34466.png +32226.png +09065.png +37821.png +56136.png +48344.png +09176.png +41929.png +13022.png +67839.png +31875.png +13017.png +49757.png +52874.png +40506.png +44314.png +28057.png +33323.png +48623.png +07770.png +38699.png +06172.png +37732.png +28251.png +32911.png +31595.png +47359.png +66257.png +48699.png +12512.png +62039.png +50209.png +47365.png +06573.png +49940.png +13051.png +08200.png +44654.png +61297.png +19155.png +44909.png +31072.png +11041.png +51612.png +46391.png +13379.png +12330.png +04495.png +63079.png +08522.png +60212.png +54427.png +18518.png +12885.png +68953.png +23554.png +57921.png +38453.png +36060.png +04568.png +60923.png +37624.png +26484.png +33296.png +02096.png +11367.png +57214.png +16314.png +29527.png +12180.png +57632.png +21259.png +69826.png +06923.png +69181.png +30595.png +11575.png +14043.png +03056.png +39355.png +09909.png +11472.png +21931.png +66502.png +42614.png +11489.png +55046.png +59878.png +34272.png +29369.png +63090.png +34513.png +58193.png +49993.png +17290.png +66577.png +35788.png +37361.png +53242.png +61709.png +67638.png +51680.png +18197.png +29536.png +21630.png +51995.png +37485.png +18083.png +14235.png +48629.png +42851.png +37984.png +51110.png +03835.png +38732.png +57160.png +17582.png +60420.png +08662.png +18531.png +41791.png +13219.png +02837.png +02565.png +56342.png +55561.png +42612.png +63457.png +45574.png +68398.png +43204.png +24968.png +10942.png +38167.png +50309.png +18709.png +48725.png +37186.png +68631.png +69784.png +12817.png +60268.png +62182.png +41708.png +61204.png +42242.png +44519.png +00030.png +06751.png +51700.png +13475.png +68612.png +48916.png +40256.png +14209.png +30517.png +05708.png +20108.png +49872.png +45839.png +57955.png +43657.png +66022.png +26252.png +34038.png +42810.png +21035.png +20209.png +23970.png +43400.png +16449.png +61636.png +56453.png +42764.png +34583.png +47540.png +31853.png +04404.png +21174.png +35549.png +27420.png +56383.png +26606.png +35184.png +15220.png +16031.png +59380.png +66221.png +19161.png +19431.png +20446.png +19136.png +09111.png +15603.png +05005.png +06900.png +16203.png +19453.png +35460.png +47669.png +68188.png +51512.png +32081.png +32746.png +13374.png +00561.png +64765.png +45327.png +36051.png +54718.png +18126.png +62372.png +52118.png +49576.png +43066.png +07881.png +18129.png +41797.png +61468.png +36513.png +08164.png +61963.png +04300.png +34103.png +17719.png +37005.png +37298.png +06828.png +51148.png +58374.png +21238.png +01239.png +52740.png +24983.png +49039.png +62007.png +51654.png +34864.png +57915.png +22501.png +33716.png +64713.png +64301.png +43362.png +04018.png +57642.png +07087.png +32312.png +48955.png +29992.png +04215.png +12030.png +27348.png +52890.png +19118.png +32743.png +14864.png +11108.png +65866.png +39407.png +66966.png +69892.png +19989.png +68985.png +35882.png +57904.png +22631.png +56902.png +31152.png +01929.png +52966.png +05570.png +53446.png +21152.png +26190.png +15983.png +10326.png +38834.png +21822.png +41614.png +39110.png +17902.png +44907.png +33341.png +49376.png +05340.png +00371.png +49995.png +18156.png +30911.png +51038.png +22027.png +32183.png +42488.png +11532.png +50542.png +66364.png +09182.png +44804.png +25843.png +27144.png +10880.png +29564.png +12647.png +00911.png +14933.png +60748.png +54181.png +50422.png +06493.png +58357.png +29228.png +21879.png +32212.png +52489.png +22391.png +23331.png +56687.png +28936.png +05276.png +15619.png +02058.png +67542.png +25885.png +27234.png +00333.png +57264.png +26459.png +28372.png +31888.png +43558.png +29311.png +65751.png +54075.png +65627.png +23319.png +44884.png +10084.png +21418.png +08810.png +05352.png +47672.png +21876.png +44934.png +59672.png +39965.png +29144.png +26539.png +42172.png +05747.png +65164.png +55218.png +50923.png +53678.png +30959.png +34517.png +05663.png +35881.png +32293.png +27842.png +58729.png +00027.png +04975.png +42259.png +30259.png +25970.png +14458.png +44073.png +41036.png +21429.png +04327.png +51265.png +52340.png +57945.png +33292.png +35884.png +03998.png +14760.png +20692.png +03542.png +38782.png +10034.png +45268.png +20359.png +27993.png +68837.png +12034.png +34388.png +55127.png +35316.png +00828.png +09209.png +31254.png +26489.png +13274.png +09734.png +69693.png +09664.png +53620.png +03774.png +62326.png +22594.png +48599.png +56694.png +25196.png +54348.png +40353.png +06456.png +24202.png +27287.png +11455.png +60136.png +00315.png +40126.png +50508.png +54737.png +21254.png +48074.png +10542.png +61654.png +49510.png +44601.png +43631.png +54106.png +36342.png +54131.png +15196.png +26320.png +52643.png +31069.png +37167.png +33576.png +53629.png +21750.png +64642.png +31248.png +61815.png +16810.png +20790.png +07001.png +30178.png +18798.png +57301.png +25111.png +07355.png +46484.png +69413.png +59650.png +13872.png +03630.png +35760.png +52075.png +07677.png +38339.png +44990.png +06893.png +46808.png +28346.png +34954.png +17158.png +54183.png +05534.png +19327.png +27171.png +42200.png +07028.png +44211.png +66006.png +06301.png +54709.png +52603.png +37082.png +04571.png +03724.png +37092.png +41860.png +56207.png +44066.png +03335.png +43748.png +14867.png +67194.png +30854.png +49089.png +43482.png +66832.png +04146.png +13972.png +05650.png +32022.png +67557.png +63334.png +52347.png +06136.png +60548.png +02492.png +59562.png +14361.png +46441.png +01170.png +43463.png +53606.png +69443.png +61307.png +64805.png +68820.png +39413.png +32568.png +07049.png +18839.png +16044.png +49733.png +13577.png +60350.png +40583.png +61000.png +13479.png +56424.png +52941.png +55265.png +58063.png +67996.png +61892.png +10768.png +44652.png +51720.png +30661.png +27994.png +34822.png +52593.png +06872.png +22058.png +19354.png +44869.png +38150.png +32025.png +05313.png +03734.png +17414.png +66625.png +63094.png +10177.png +38193.png +47686.png +55758.png +55343.png +40459.png +35343.png +17472.png +22163.png +50990.png +09894.png +42863.png +20732.png +22442.png +03537.png +38943.png +22102.png +50135.png +05296.png +61866.png +47661.png +51745.png +59161.png +42750.png +06766.png +41884.png +03273.png +37722.png +20742.png +35440.png +28424.png +30043.png +66177.png +29026.png +08430.png +03118.png +50982.png +33990.png +18239.png +18754.png +02983.png +26316.png +25409.png +39637.png +58368.png +32936.png +37657.png +42773.png +35359.png +29631.png +30356.png +25082.png +21903.png +22323.png +45319.png +51712.png +29058.png +41271.png +27382.png +69141.png +60145.png +12391.png +60207.png +00533.png +10280.png +21235.png +26399.png +64962.png +14139.png +11024.png +02463.png +54686.png +15724.png +59382.png +50901.png +57820.png +17827.png +14149.png +61317.png +45769.png +22906.png +09596.png +61125.png +18588.png +52600.png +56733.png +54669.png +20837.png +69604.png +41951.png +25249.png +63485.png +05728.png +32408.png +63812.png +48050.png +41977.png +12420.png +31825.png +69878.png +13676.png +26660.png +31856.png +20096.png +55739.png +56210.png +55025.png +34934.png +66448.png +19248.png +24153.png +28310.png +22717.png +32834.png +26498.png +15557.png +20500.png +69917.png +10928.png +01659.png +06027.png +55956.png +21801.png +21100.png +10729.png +06441.png +42445.png +44114.png +58210.png +69235.png +42163.png +28588.png +20187.png +00954.png +12703.png +59132.png +24278.png +60996.png +29149.png +19291.png +32080.png +63725.png +13635.png +56117.png +07658.png +64012.png +50667.png +25275.png +22363.png +28405.png +39939.png +56604.png +05154.png +58602.png +55790.png +08030.png +58428.png +13689.png +33456.png +23462.png +69412.png +44461.png +34657.png +53130.png +14431.png +65225.png +33055.png +64369.png +05064.png +19585.png +37395.png +46073.png +46110.png +37302.png +14998.png +31762.png +54504.png +61675.png +65726.png +49768.png +35182.png +23785.png +39260.png +09874.png +44341.png +68648.png +64089.png +30710.png +67181.png +14597.png +54293.png +54891.png +09032.png +45013.png +69453.png +52743.png +14730.png +27791.png +64248.png +05053.png +45246.png +51572.png +60575.png +51311.png +42544.png +52641.png +59588.png +04533.png +58479.png +30162.png +39259.png +22210.png +59473.png +57072.png +41502.png +59876.png +67270.png +03626.png +07254.png +31628.png +67948.png +04364.png +09824.png +32388.png +17693.png +40794.png +67046.png +26795.png +45793.png +00031.png +13152.png +09012.png +48871.png +48353.png +13569.png +05045.png +46262.png +37303.png +29825.png +00829.png +25812.png +51813.png +46411.png +69790.png +46937.png +27972.png +63878.png +40618.png +29784.png +68798.png +05274.png +34314.png +41489.png +21416.png +16917.png +18191.png +39727.png +30046.png +04292.png +35230.png +51299.png +24238.png +11201.png +11248.png +31852.png +36045.png +18764.png +23623.png +03567.png +01137.png +46535.png +11719.png +22124.png +53669.png +16258.png +62754.png +27297.png +26935.png +64653.png +53683.png +30061.png +67617.png +67419.png +22362.png +50355.png +39381.png +16676.png +21777.png +61713.png +40012.png +33810.png +68020.png +41286.png +28061.png +66937.png +67171.png +51320.png +49386.png +58831.png +07784.png +20235.png +53690.png +37708.png +45037.png +57801.png +62231.png +66670.png +66238.png +07642.png +67514.png +63731.png +25801.png +35729.png +50504.png +34168.png +54578.png +21603.png +13390.png +41394.png +67551.png +51958.png +41954.png +58840.png +19704.png +50244.png +24637.png +54499.png +58928.png +14736.png +29116.png +25136.png +04176.png +11962.png +16296.png +07766.png +14402.png +62496.png +11803.png +47727.png +17745.png +12441.png +69503.png +41535.png +17412.png +48982.png +38324.png +49041.png +42967.png +08447.png +40808.png +27308.png +50853.png +00586.png +40220.png +25457.png +14937.png +04937.png +67635.png +05535.png +64928.png +20104.png +64198.png +15586.png +24600.png +69068.png +61433.png +15828.png +13421.png +44867.png +37028.png +13895.png +62273.png +01707.png +11516.png +65367.png +57263.png +16099.png +08244.png +26387.png +23550.png +04589.png +22790.png +35767.png +67555.png +54741.png +17199.png +63959.png +54627.png +62617.png +35127.png +66085.png +32265.png +65762.png +46079.png +45346.png +20006.png +44651.png +20334.png +18783.png +62369.png +36003.png +22372.png +15276.png +40493.png +41745.png +69155.png +42117.png +12782.png +39022.png +34937.png +46569.png +49823.png +17075.png +43607.png +68154.png +57591.png +01571.png +00768.png +00438.png +22655.png +65849.png +24584.png +57838.png +18778.png +16022.png +28860.png +46742.png +40379.png +55605.png +10728.png +13621.png +65297.png +57738.png +58713.png +12249.png +15047.png +59583.png +59773.png +46292.png +47320.png +26395.png +37434.png +20427.png +69385.png +67013.png +63285.png +08673.png +36280.png +69099.png +45519.png +07269.png +52705.png +35104.png +38353.png +22103.png +00541.png +57539.png +32586.png +57016.png +32379.png +23644.png +50586.png +08869.png +18640.png +27212.png +18403.png +21269.png +05561.png +31080.png +65474.png +67129.png +43350.png +45732.png +68625.png +50044.png +61612.png +65729.png +00442.png +69134.png +27689.png +16615.png +20707.png +13214.png +32302.png +45878.png +52757.png +57147.png +19321.png +05377.png +56643.png +67565.png +60868.png +69021.png +69816.png +10319.png +20263.png +52700.png +40266.png +42169.png +40110.png +19131.png +33003.png +68604.png +28785.png +18302.png +38993.png +62538.png +48728.png +16699.png +23603.png +47173.png +13954.png +60666.png +08357.png +05798.png +01889.png +30926.png +45646.png +04224.png +64246.png +38500.png +69364.png +37513.png +40172.png +41414.png +15307.png +60101.png +12395.png +02312.png +37446.png +53941.png +57706.png +28160.png +05035.png +24237.png +03423.png +63747.png +11871.png +22562.png +19974.png +63434.png +68914.png +44518.png +24948.png +51763.png +64429.png +51791.png +49575.png +26882.png +58342.png +21461.png +49006.png +15179.png +09502.png +28595.png +14705.png +18477.png +65124.png +20908.png +46788.png +49460.png +16395.png +02605.png +55281.png +28171.png +30012.png +27099.png +01891.png +16976.png +24259.png +12974.png +24450.png +30876.png +08779.png +14881.png +10828.png +02002.png +68654.png +29791.png +35407.png +01821.png +42879.png +63341.png +04316.png +49802.png +53897.png +69147.png +57802.png +05198.png +66831.png +54302.png +68526.png +30406.png +62475.png +22617.png +60968.png +57111.png +40214.png +18706.png +11762.png +14421.png +16800.png +61159.png +28814.png +04803.png +37038.png +17155.png +21228.png +13391.png +00776.png +48008.png +54998.png +42924.png +01294.png +65595.png +36208.png +30851.png +31153.png +13836.png +09481.png +52787.png +54585.png +37285.png +30266.png +06519.png +31989.png +15373.png +47266.png +31929.png +04456.png +48045.png +22734.png +21620.png +20251.png +61124.png +50473.png +40961.png +44178.png +07076.png +34510.png +09544.png +44347.png +48837.png +03102.png +61067.png +31462.png +16527.png +18632.png +29967.png +30626.png +65336.png +22192.png +09308.png +08111.png +66412.png +31057.png +27853.png +61448.png +43015.png +07541.png +01554.png +18087.png +56850.png +55594.png +33377.png +31264.png +59525.png +12847.png +17072.png +69007.png +57827.png +24330.png +29853.png +21074.png +00465.png +02253.png +23571.png +67207.png +01152.png +42414.png +33334.png +37773.png +50344.png +67781.png +12730.png +21793.png +33037.png +66466.png +20356.png +30937.png +36041.png +41644.png +41465.png +03601.png +65206.png +03251.png +61699.png +63096.png +62758.png +02470.png +67476.png +62109.png +06505.png +50465.png +53966.png +57580.png +57449.png +53815.png +32443.png +24341.png +60833.png +30234.png +39912.png +00252.png +27990.png +04783.png +18789.png +10887.png +33983.png +13270.png +01530.png +02197.png +52477.png +20808.png +03381.png +31885.png +16630.png +22044.png +62601.png +54397.png +49406.png +37763.png +41754.png +10496.png +68003.png +37758.png +13333.png +44784.png +40417.png +15912.png +55142.png +49081.png +56999.png +34505.png +57851.png +24819.png +61950.png +24545.png +21640.png +22961.png +37130.png +03084.png +24945.png +68106.png +40024.png +47348.png +14488.png +67562.png +20372.png +20633.png +50020.png +07403.png +02564.png +41057.png +05465.png +19984.png +34962.png +25637.png +62883.png +54594.png +25134.png +49529.png +33200.png +65262.png +11134.png +67146.png +60959.png +67421.png +69757.png +14853.png +37455.png +53826.png +15378.png +24104.png +17811.png +51845.png +11916.png +18460.png +26838.png +18572.png +27216.png +19613.png +13289.png +45690.png +04512.png +05733.png +05767.png +44281.png +46046.png +58457.png +18981.png +37876.png +57729.png +55168.png +25394.png +64091.png +17500.png +55891.png +62621.png +18784.png +69491.png +59085.png +10703.png +28749.png +29492.png +37602.png +43152.png +26354.png +28396.png +58028.png +39622.png +64593.png +64707.png +13757.png +08330.png +49146.png +02999.png +30799.png +40215.png +37172.png +55366.png +10588.png +34342.png +56472.png +24589.png +12667.png +38276.png +04665.png +37868.png +23807.png +54248.png +58165.png +07660.png +04994.png +28844.png +21103.png +51781.png +08564.png +50998.png +34439.png +25194.png +38073.png +28811.png +15159.png +09812.png +31512.png +33892.png +39595.png +44634.png +14611.png +47024.png +16970.png +65358.png +30408.png +50086.png +06031.png +44218.png +03490.png +52921.png +58518.png +43610.png +38808.png +52868.png +00069.png +05171.png +48341.png +52302.png +16457.png +57510.png +41608.png +10966.png +64130.png +48393.png +57790.png +69179.png +17714.png +68835.png +58180.png +45479.png +15353.png +44181.png +16355.png +02561.png +33551.png +00896.png +15079.png +46119.png +32233.png +03646.png +50072.png +59098.png +59787.png +41911.png +42830.png +14447.png +01850.png +24570.png +42819.png +39177.png +48803.png +33116.png +59559.png +24651.png +52002.png +16946.png +33228.png +43244.png +64481.png +10164.png +42774.png +68363.png +61171.png +18580.png +63963.png +27887.png +25120.png +20089.png +46177.png +13250.png +67282.png +02651.png +38909.png +49609.png +47640.png +07557.png +17174.png +66125.png +63839.png +42606.png +47123.png +50009.png +47381.png +41166.png +33080.png +05855.png +00176.png +58720.png +37297.png +64564.png +08708.png +13829.png +26567.png +44924.png +30185.png +14317.png +32221.png +24233.png +22829.png +52327.png +55836.png +00460.png +69882.png +39204.png +44493.png +55371.png +31470.png +41687.png +24649.png +08644.png +42458.png +11408.png +52812.png +66551.png +03723.png +34355.png +11288.png +14163.png +40468.png +15451.png +63732.png +58430.png +11989.png +04420.png +11552.png +42607.png +64537.png +45182.png +39985.png +19274.png +37851.png +17506.png +21797.png +60105.png +43337.png +07093.png +53158.png +02102.png +10843.png +19796.png +61692.png +35570.png +43682.png +09701.png +43598.png +27715.png +57479.png +53097.png +57011.png +17016.png +57768.png +47763.png +03339.png +41114.png +41631.png +25994.png +67932.png +09343.png +36592.png +42817.png +32683.png +66755.png +16597.png +10578.png +10363.png +18450.png +53838.png +53634.png +44982.png +56523.png +25663.png +62876.png +39823.png +37546.png +28753.png +13401.png +50356.png +39469.png +65310.png +37857.png +61799.png +68872.png +39067.png +05834.png +07858.png +69416.png +67840.png +43669.png +30381.png +51906.png +50119.png +17329.png +23968.png +03545.png +61545.png +00885.png +27478.png +41551.png +13914.png +58973.png +57715.png +69504.png +01143.png +30052.png +25300.png +14474.png +48613.png +03518.png +61131.png +38240.png +18853.png +50334.png +16080.png +12813.png +18875.png +20456.png +03075.png +22559.png +25805.png +02578.png +41291.png +13128.png +05517.png +39755.png +43883.png +65893.png +41276.png +41516.png +11981.png +19299.png +05336.png +65677.png +41219.png +52174.png +60401.png +22540.png +14335.png +67296.png +37428.png +66834.png +54788.png +42679.png +29898.png +19148.png +69251.png +53208.png +34531.png +04844.png +32722.png +23962.png +18954.png +63568.png +20824.png +47499.png +69931.png +20596.png +46979.png +64440.png +46588.png +62212.png +68490.png +08844.png +37144.png +51385.png +48352.png +15898.png +02631.png +22708.png +28959.png +40439.png +39375.png +56198.png +27582.png +20839.png +23391.png +12609.png +13658.png +26301.png +67752.png +43424.png +37264.png +07656.png +11285.png +05589.png +63001.png +67380.png +61251.png +18566.png +05477.png +24567.png +41443.png +50377.png +06336.png +00431.png +10935.png +04460.png +39548.png +02858.png +63069.png +10984.png +07467.png +19874.png +55437.png +52710.png +63475.png +28048.png +04163.png +54997.png +09805.png +06483.png +41278.png +52338.png +15050.png +08997.png +42188.png +61724.png +24151.png +53152.png +31528.png +01788.png +60082.png +32660.png +28856.png +39667.png +21731.png +55970.png +04149.png +28948.png +56301.png +48520.png +42348.png +48544.png +54894.png +24236.png +02018.png +63551.png +61975.png +40192.png +37066.png +52496.png +31861.png +46341.png +56074.png +33316.png +65387.png +18274.png +23984.png +59776.png +38335.png +66226.png +67574.png +24931.png +32484.png +33184.png +51829.png +07496.png +14192.png +12459.png +10214.png +69154.png +01299.png +34377.png +57957.png +33799.png +23684.png +60709.png +20929.png +58159.png +49752.png +37891.png +37749.png +19802.png +12168.png +08187.png +17777.png +33819.png +28812.png +32639.png +56640.png +55796.png +47405.png +56669.png +68731.png +09603.png +23610.png +11898.png +23368.png +12785.png +49691.png +09881.png +02132.png +55636.png +55083.png +56347.png +26738.png +54844.png +49690.png +64320.png +52068.png +15531.png +57437.png +49484.png +65266.png +17611.png +58383.png +63774.png +52147.png +59826.png +34791.png +52136.png +41226.png +07218.png +47564.png +02965.png +56066.png +31328.png +20950.png +29121.png +52565.png +07746.png +43855.png +25152.png +59290.png +58164.png +44255.png +04545.png +23308.png +34770.png +22973.png +08443.png +46839.png +08242.png +15489.png +46596.png +64587.png +33234.png +20385.png +12080.png +19962.png +30803.png +14306.png +02556.png +59381.png +23851.png +36748.png +10562.png +30556.png +33192.png +48202.png +28314.png +53200.png +07702.png +65282.png +34341.png +05080.png +09183.png +23411.png +09620.png +52359.png +67832.png +44385.png +52298.png +01886.png +62436.png +41165.png +08428.png +26144.png +20606.png +15422.png +42057.png +64382.png +32709.png +44095.png +07745.png +53484.png +10088.png +15798.png +61126.png +18945.png +48779.png +11266.png +16178.png +20406.png +01630.png +65026.png +24271.png +35140.png +13697.png +39480.png +57429.png +34194.png +20820.png +63133.png +19771.png +67174.png +65785.png +40909.png +34222.png +21388.png +37198.png +07175.png +15280.png +23352.png +64093.png +26536.png +68148.png +39504.png +42640.png +47884.png +43411.png +25417.png +55335.png +47393.png +47082.png +43266.png +02435.png +66108.png +63411.png +49128.png +45250.png +57311.png +23748.png +55464.png +11602.png +14965.png +05616.png +38370.png +24152.png +51191.png +61068.png +16698.png +36055.png +29238.png +54573.png +49073.png +23971.png +62101.png +23439.png +65368.png +54094.png +04225.png +48635.png +52795.png +34602.png +03604.png +58707.png +04416.png +21874.png +51651.png +67030.png +47398.png +49852.png +52616.png +68014.png +01398.png +04895.png +51214.png +47142.png +68734.png +20566.png +64292.png +57778.png +43060.png +58686.png +62720.png +42116.png +51111.png +05288.png +18245.png +12119.png +20794.png +31289.png +24882.png +04260.png +38691.png +60195.png +25937.png +35785.png +34435.png +13419.png +09767.png +17023.png +14840.png +02357.png +22569.png +12846.png +51915.png +55762.png +45345.png +29176.png +66287.png +53235.png +21022.png +16062.png +15249.png +61034.png +06472.png +69899.png +18235.png +54470.png +34382.png +50333.png +64857.png +46026.png +18224.png +64622.png +60313.png +29164.png +04597.png +15488.png +08752.png +39810.png +13523.png +44360.png +05781.png +59982.png +09976.png +37633.png +22298.png +59409.png +02118.png +32172.png +54424.png +52484.png +27660.png +61633.png +50097.png +12835.png +54964.png +18729.png +66132.png +50113.png +34808.png +16521.png +35834.png +51167.png +22768.png +11386.png +61035.png +01098.png +65568.png +17597.png +02126.png +04142.png +28857.png +56983.png +54982.png +01371.png +07834.png +09195.png +00498.png +56900.png +30689.png +53306.png +54559.png +24662.png +50328.png +00103.png +24346.png +49871.png +24925.png +14526.png +57762.png +24245.png +28174.png +32448.png +00619.png +61945.png +69175.png +09096.png +28479.png +01582.png +61098.png +26793.png +01039.png +09722.png +62635.png +25316.png +25484.png +60644.png +21341.png +45190.png +35471.png +67193.png +02570.png +49211.png +11523.png +19182.png +54468.png +49984.png +09887.png +64041.png +65468.png +60205.png +19643.png +67737.png +17572.png +20351.png +11442.png +56425.png +62224.png +62717.png +68253.png +18332.png +64347.png +21231.png +47910.png +11876.png +48205.png +64139.png +12996.png +42565.png +09165.png +63787.png +48662.png +12031.png +10128.png +08100.png +06201.png +17357.png +34659.png +52402.png +59885.png +24676.png +18112.png +68462.png +42877.png +05560.png +03766.png +30624.png +32884.png +57913.png +67663.png +47813.png +04443.png +67804.png +04294.png +62595.png +41780.png +66565.png +04528.png +10348.png +59474.png +69766.png +45535.png +56636.png +00931.png +09766.png +09490.png +24902.png +06338.png +36489.png +31120.png +56975.png +32550.png +41675.png +51091.png +49224.png +31648.png +02259.png +56281.png +58976.png +30354.png +51545.png +59230.png +42154.png +66860.png +25133.png +02258.png +60432.png +00251.png +58426.png +20904.png +24491.png +63143.png +39606.png +41137.png +02337.png +23323.png +54469.png +38548.png +02008.png +01837.png +49844.png +06457.png +02117.png +12698.png +45284.png +11321.png +00283.png +18669.png +42926.png +33147.png +38363.png +06991.png +57425.png +05109.png +29799.png +12731.png +64473.png +36684.png +13600.png +46829.png +45760.png +52429.png +22430.png +33423.png +66602.png +61162.png +61604.png +20353.png +36988.png +28794.png +14794.png +52009.png +66584.png +42703.png +36204.png +47847.png +23167.png +37524.png +60878.png +24440.png +25480.png +51030.png +16547.png +24950.png +30179.png +36124.png +38316.png +26090.png +60533.png +51247.png +51581.png +04771.png +63052.png +60435.png +49209.png +29478.png +65434.png +05183.png +26082.png +50870.png +56493.png +44202.png +55406.png +58681.png +17415.png +00786.png +68351.png +58910.png +08702.png +67052.png +00797.png +47807.png +53174.png +64701.png +32904.png +24602.png +32018.png +55861.png +21319.png +22856.png +56898.png +56494.png +09922.png +01732.png +27325.png +01663.png +66632.png +17478.png +21741.png +55071.png +29062.png +21937.png +22705.png +69722.png +35527.png +12904.png +46266.png +10136.png +45722.png +20899.png +34805.png +17090.png +41512.png +18738.png +66074.png +05280.png +60102.png +41506.png +65964.png +33732.png +19087.png +37129.png +40258.png +57968.png +44238.png +61512.png +36741.png +32216.png +21841.png +26825.png +06681.png +24648.png +55325.png +12898.png +11815.png +63215.png +42252.png +19753.png +68116.png +01623.png +07402.png +20185.png +41967.png +17040.png +13314.png +42762.png +47455.png +24406.png +53577.png +19910.png +18056.png +67364.png +50942.png +33940.png +05470.png +38352.png +58669.png +16656.png +39825.png +61415.png +44886.png +58249.png +25525.png +44630.png +49241.png +46208.png +48129.png +45155.png +20955.png +62284.png +44357.png +64916.png +15211.png +33057.png +62383.png +67022.png +66113.png +62622.png +09123.png +12393.png +17355.png +55296.png +32862.png +59298.png +16868.png +09962.png +10251.png +51391.png +16160.png +67608.png +49659.png +25595.png +63941.png +38151.png +46612.png +12610.png +42247.png +44071.png +33841.png +20969.png +19577.png +27508.png +32457.png +67789.png +56401.png +07516.png +28669.png +15357.png +18513.png +21124.png +33790.png +60248.png +04408.png +32679.png +45087.png +35744.png +01311.png +65628.png +68786.png +11867.png +02843.png +54619.png +19975.png +18021.png +57726.png +36627.png +60434.png +45081.png +38759.png +52486.png +29724.png +67745.png +44599.png +56713.png +08339.png +61052.png +27267.png +17918.png +16759.png +51740.png +04820.png +68353.png +44043.png +47345.png +28319.png +01833.png +62752.png +13230.png +69718.png +08645.png +32191.png +42583.png +52482.png +60258.png +66606.png +63917.png +51513.png +38910.png +35599.png +31896.png +61739.png +61870.png +21326.png +29928.png +46575.png +30176.png +12636.png +67866.png +31553.png +46040.png +65674.png +47616.png +52124.png +05735.png +62282.png +24399.png +06330.png +35480.png +28021.png +12421.png +57168.png +11734.png +27232.png +12781.png +50049.png +33408.png +22226.png +46023.png +43246.png +46785.png +14185.png +26213.png +10301.png +49315.png +45207.png +64249.png +30952.png +41283.png +32687.png +33422.png +24274.png +57416.png +65993.png +46474.png +13169.png +46184.png +38463.png +35665.png +37491.png +13027.png +50480.png +24643.png +42406.png +56339.png +19261.png +44724.png +64746.png +68461.png +23642.png +53710.png +28570.png +50976.png +05537.png +60688.png +58068.png +18527.png +21176.png +28603.png +09128.png +17630.png +19005.png +43523.png +02079.png +22013.png +05007.png +54328.png +03384.png +31324.png +51172.png +64658.png +66390.png +20638.png +37374.png +33984.png +65050.png +49485.png +40229.png +09388.png +44329.png +48872.png +63856.png +33771.png +01063.png +67278.png +37004.png +12133.png +12399.png +42929.png +48813.png +50445.png +48396.png +26196.png +24601.png +04238.png +33744.png +52927.png +25779.png +44544.png +09764.png +30526.png +33592.png +26021.png +05057.png +36274.png +32381.png +44371.png +57167.png +12968.png +05201.png +09807.png +12363.png +66581.png +04978.png +11366.png +58620.png +60559.png +54391.png +12065.png +20911.png +24220.png +65965.png +21760.png +45588.png +64551.png +50388.png +34234.png +02166.png +36075.png +42871.png +25691.png +06696.png +03531.png +32617.png +40011.png +63814.png +48686.png +62373.png +61228.png +22778.png +29263.png +69350.png +56337.png +26290.png +62381.png +15286.png +59934.png +52224.png +27121.png +62469.png +57998.png +19175.png +58389.png +04538.png +39863.png +49508.png +23135.png +09832.png +31307.png +42575.png +69880.png +16831.png +49675.png +58264.png +50775.png +47539.png +43016.png +02458.png +16280.png +31195.png +42027.png +15164.png +32966.png +49440.png +19760.png +01713.png +65650.png +67511.png +41441.png +01987.png +42591.png +01404.png +46437.png +60391.png +17002.png +13057.png +07240.png +03408.png +54861.png +15618.png +22620.png +18347.png +51540.png +69561.png +27697.png +17757.png +09043.png +08405.png +05116.png +53280.png +41242.png +24620.png +17263.png +49095.png +21198.png +29398.png +02446.png +58340.png +44449.png +48624.png +18152.png +49142.png +49372.png +49459.png +23726.png +60084.png +61779.png +53582.png +13979.png +12894.png +06091.png +53552.png +45686.png +01124.png +62345.png +19075.png +47835.png +46234.png +45818.png +60143.png +65306.png +56742.png +28008.png +06241.png +68222.png +20915.png +39598.png +09193.png +55764.png +31923.png +29139.png +34308.png +04757.png +34705.png +37248.png +18372.png +33818.png +45959.png +53345.png +49425.png +29884.png +07572.png +67739.png +39593.png +55684.png +42618.png +08805.png +16520.png +49120.png +38056.png +47121.png +14858.png +33695.png +42897.png +34440.png +54269.png +45916.png +63706.png +60629.png +18906.png +31283.png +07566.png +20639.png +67124.png +35854.png +63385.png +20111.png +32013.png +40588.png +20181.png +57298.png +43421.png +13042.png +68242.png +21016.png +00454.png +15970.png +11750.png +21709.png +51823.png +29314.png +20557.png +19424.png +19167.png +37024.png +17107.png +26590.png +16152.png +47498.png +62090.png +06259.png +19104.png +65815.png +32238.png +19601.png +56901.png +31218.png +17665.png +47269.png +21619.png +36343.png +03605.png +66496.png +44318.png +47001.png +10008.png +51764.png +18542.png +47388.png +58651.png +35999.png +45231.png +65170.png +01673.png +31232.png +39693.png +52854.png +46271.png +01181.png +50681.png +24879.png +63719.png +61994.png +35504.png +50326.png +49100.png +42471.png +68368.png +40350.png +06516.png +01277.png +57906.png +51229.png +14460.png +60047.png +53212.png +13740.png +09472.png +50005.png +45128.png +07447.png +41427.png +18227.png +26462.png +16334.png +20977.png +22294.png +56554.png +47176.png +52197.png +14621.png +45080.png +12081.png +55165.png +34001.png +68527.png +08479.png +20862.png +61385.png +35078.png +03212.png +43645.png +24086.png +35794.png +34422.png +55546.png +41018.png +13273.png +43378.png +17712.png +63733.png +36889.png +38171.png +67544.png +32563.png +37629.png +55099.png +38932.png +14670.png +19043.png +24530.png +10418.png +37040.png +37074.png +42317.png +51336.png +46774.png +43767.png +56101.png +57002.png +12588.png +49452.png +40431.png +20424.png +61703.png +23445.png +48005.png +66397.png +33497.png +52011.png +40442.png +65948.png +34027.png +55088.png +10646.png +54476.png +25948.png +64617.png +60351.png +12495.png +57939.png +25415.png +17192.png +42233.png +52405.png +33746.png +52631.png +65341.png +51748.png +27801.png +25091.png +51054.png +03308.png +37027.png +38389.png +08210.png +61417.png +17660.png +52310.png +08735.png +16595.png +39919.png +67231.png +44741.png +46111.png +33396.png +21436.png +37348.png +08261.png +56070.png +45724.png +26745.png +09297.png +08875.png +64675.png +40864.png +14098.png +18938.png +66867.png +20620.png +49957.png +35496.png +50276.png +68658.png +20748.png +32187.png +16005.png +09601.png +14836.png +64613.png +29219.png +66173.png +57813.png +69118.png +43228.png +49227.png +35924.png +69254.png +60564.png +60098.png +50805.png +60150.png +23575.png +14492.png +59849.png +60428.png +20935.png +64415.png +31431.png +48317.png +20310.png +18173.png +62315.png +61169.png +03889.png +44395.png +60512.png +13739.png +29159.png +09151.png +38226.png +34580.png +33543.png +14699.png +19443.png +27236.png +36685.png +22761.png +60879.png +30090.png +43905.png +64590.png +48425.png +67390.png +49812.png +10356.png +28767.png +46928.png +68531.png +50246.png +56895.png +30184.png +54683.png +32481.png +13309.png +55690.png +55106.png +17260.png +04942.png +26784.png +39872.png +43529.png +29414.png +24991.png +31127.png +59360.png +31696.png +13455.png +40252.png +16967.png +36740.png +05144.png +09856.png +01230.png +34389.png +52797.png +29905.png +34471.png +31369.png +14575.png +34718.png +30705.png +58656.png +42806.png +54832.png +20845.png +16975.png +55303.png +28954.png +19486.png +07236.png +69671.png +37261.png +60446.png +66386.png +69286.png +40931.png +67601.png +05595.png +59134.png +49623.png +65502.png +00101.png +57555.png +32756.png +26944.png +23541.png +18436.png +44081.png +19033.png +67609.png +59852.png +57306.png +65644.png +47642.png +07610.png +53350.png +46667.png +57524.png +15708.png +66864.png +53352.png +11469.png +36473.png +39915.png +33648.png +23465.png +30283.png +05013.png +45709.png +52750.png +58843.png +41941.png +25211.png +05683.png +33670.png +51002.png +67314.png +47420.png +21446.png +66069.png +30819.png +34200.png +61437.png +07094.png +25456.png +13162.png +65966.png +53483.png +39844.png +08351.png +19059.png +49641.png +31124.png +34920.png +02407.png +22413.png +20910.png +25737.png +30779.png +24866.png +22703.png +32174.png +39832.png +60905.png +26045.png +19528.png +55024.png +69914.png +39477.png +55241.png +56123.png +25286.png +08323.png +43356.png +68098.png +00749.png +50397.png +21498.png +37263.png +45990.png +05590.png +12007.png +17740.png +18243.png +41359.png +03370.png +09489.png +20381.png +51382.png +68323.png +39304.png +50941.png +02341.png +31920.png +27377.png +08493.png +56679.png +27046.png +05876.png +06690.png +43573.png +12196.png +46728.png +60341.png +23727.png +49560.png +47871.png +48211.png +67644.png +43722.png +22902.png +09979.png +06757.png +23890.png +00388.png +55228.png +21794.png +57297.png +45857.png +39642.png +45356.png +23527.png +42729.png +38895.png +37372.png +07262.png +32259.png +08347.png +14015.png +45549.png +45092.png +64674.png +55191.png +30599.png +28801.png +60954.png +53265.png +40666.png +68361.png +27824.png +55209.png +10449.png +34903.png +23948.png +29607.png +58286.png +14925.png +15873.png +46076.png +40825.png +07112.png +34778.png +59092.png +15132.png +21685.png +64452.png +46344.png +01661.png +20501.png +66657.png +06082.png +46541.png +15259.png +65882.png +35015.png +28177.png +36065.png +44359.png +04311.png +08306.png +37335.png +36869.png +00243.png +49121.png +25847.png +30663.png +17326.png +65833.png +37828.png +24644.png +44011.png +59554.png +09692.png +65827.png +67393.png +21475.png +61890.png +69701.png +59232.png +33158.png +34732.png +34890.png +43343.png +42767.png +45906.png +49341.png +63417.png +67546.png +41134.png +36583.png +65865.png +30866.png +31345.png +16819.png +04188.png +12056.png +69012.png +45655.png +63851.png +42223.png +45274.png +30210.png +60746.png +10884.png +47761.png +67492.png +35875.png +38451.png +55283.png +54738.png +19260.png +64625.png +28454.png +49737.png +51497.png +61100.png +08940.png +61495.png +27583.png +45911.png +48525.png +09950.png +11899.png +29380.png +53279.png +14485.png +43544.png +65891.png +59860.png +58585.png +12505.png +22514.png +09562.png +53167.png +24582.png +02538.png +05789.png +45661.png +08742.png +43663.png +16702.png +29345.png +57238.png +36312.png +63329.png +25468.png +35774.png +38620.png +13612.png +16642.png +57582.png +34420.png +45484.png +26972.png +03915.png +25508.png +25011.png +58106.png +08623.png +34682.png +55554.png +67223.png +37935.png +23012.png +18137.png +57714.png +48229.png +60245.png +37402.png +19811.png +01919.png +30853.png +62770.png +38497.png +56416.png +65371.png +41904.png +65925.png +58802.png +01717.png +03402.png +45923.png +27020.png +07078.png +50306.png +69092.png +34563.png +69059.png +02633.png +47581.png +06615.png +13840.png +09813.png +14834.png +56968.png +04672.png +35649.png +50801.png +43832.png +01414.png +15554.png +29659.png +50350.png +68084.png +34249.png +55821.png +55556.png +35846.png +53646.png +18999.png +32482.png +66919.png +00944.png +38853.png +22156.png +07821.png +16736.png +15846.png +65516.png +24494.png +32781.png +35444.png +37327.png +42467.png +02663.png +09744.png +14364.png +31841.png +51518.png +16459.png +06570.png +41542.png +58446.png +56581.png +16275.png +52210.png +52054.png +53055.png +47130.png +04281.png +52142.png +48677.png +52597.png +15202.png +13708.png +67485.png +67788.png +42493.png +17628.png +69485.png +63147.png +47086.png +66075.png +48086.png +18666.png +47673.png +06062.png +14994.png +45917.png +03224.png +09986.png +60978.png +61020.png +55018.png +57365.png +25684.png +29675.png +07357.png +53191.png +47208.png +51449.png +41419.png +42004.png +56684.png +56125.png +11927.png +33802.png +41192.png +62128.png +14743.png +49464.png +36927.png +46232.png +68665.png +26516.png +34807.png +10349.png +19366.png +64232.png +58416.png +34847.png +11132.png +41730.png +41089.png +19622.png +23573.png +38697.png +14602.png +55557.png +29493.png +54661.png +22349.png +12574.png +30998.png +19200.png +09382.png +13831.png +33745.png +30002.png +11879.png +57772.png +55146.png +20765.png +58818.png +18349.png +18747.png +61398.png +29222.png +58321.png +17590.png +55679.png +20495.png +11241.png +48735.png +60282.png +09516.png +48861.png +19806.png +08813.png +11808.png +58217.png +40732.png +07196.png +55387.png +54562.png +14396.png +64559.png +27198.png +41450.png +30437.png +07681.png +66859.png +00233.png +53585.png +69946.png +65543.png +47329.png +20388.png +01397.png +58671.png +50436.png +18147.png +27916.png +38179.png +15513.png +19829.png +45448.png +57181.png +13081.png +26456.png +21056.png +07303.png +16551.png +46903.png +41200.png +26313.png +10113.png +39520.png +28906.png +45176.png +38085.png +25167.png +07440.png +67771.png +37376.png +66879.png +50850.png +45830.png +06020.png +33948.png +44725.png +62251.png +35086.png +63098.png +44397.png +00624.png +46605.png +47531.png +53328.png +55518.png +50447.png +10340.png +58765.png +06098.png +56039.png +48084.png +53183.png +48263.png +02903.png +44760.png +22991.png +27618.png +68494.png +67402.png +66820.png +63024.png +16842.png +02140.png +12924.png +20452.png +11468.png +06113.png +16309.png +57230.png +56826.png +31802.png +25088.png +10628.png +10789.png +35722.png +64174.png +19610.png +00916.png +37343.png +64969.png +41711.png +54646.png +53903.png +26038.png +63601.png +00846.png +41175.png +24188.png +11065.png +37288.png +17277.png +62878.png +17832.png +35459.png +34151.png +55735.png +16607.png +23762.png +12613.png +14629.png +24466.png +24807.png +63186.png +34630.png +24170.png +60789.png +18929.png +59688.png +40835.png +47596.png +58788.png +01598.png +09300.png +08902.png +50141.png +13153.png +38213.png +38395.png +33760.png +00728.png +40063.png +55648.png +09838.png +32048.png +24612.png +41250.png +56800.png +00923.png +31632.png +55729.png +55976.png +43586.png +16256.png +14105.png +49665.png +36066.png +29264.png +45824.png +37018.png +33081.png +55804.png +31490.png +46853.png +42527.png +53971.png +14642.png +68969.png +46982.png +36213.png +56059.png +41202.png +53656.png +27856.png +16051.png +31285.png +25864.png +29998.png +67885.png +66601.png +27889.png +42336.png +43798.png +39127.png +02572.png +34056.png +12055.png +54977.png +13092.png +26655.png +59836.png +33804.png +28186.png +32095.png +67439.png +25108.png +30013.png +53752.png +48019.png +69843.png +24688.png +64711.png +10293.png +52963.png +45172.png +65807.png +27909.png +07853.png +09384.png +36530.png +52215.png +47316.png +19365.png +04852.png +37680.png +35018.png +03080.png +65828.png +41992.png +45736.png +50380.png +56736.png +68083.png +34901.png +14766.png +20652.png +42685.png +64986.png +59928.png +60510.png +15195.png +10410.png +16495.png +14282.png +44681.png +05955.png +23837.png +67035.png +61288.png +23701.png +46702.png +06600.png +32149.png +35251.png +21951.png +39261.png +15405.png +12118.png +29846.png +09124.png +37354.png +62341.png +11870.png +06689.png +63939.png +02173.png +43325.png +43099.png +40538.png +53551.png +60823.png +68477.png +42274.png +69373.png +48379.png +08739.png +20537.png +08394.png +27494.png +22577.png +26861.png +54382.png +16081.png +24318.png +17687.png +57086.png +12907.png +11475.png +12295.png +42107.png +38536.png +58551.png +05510.png +13584.png +44020.png +61514.png +13469.png +45577.png +66491.png +19574.png +68113.png +16344.png +35631.png +59328.png +08319.png +07776.png +48187.png +43105.png +43593.png +26039.png +35986.png +02591.png +27980.png +33563.png +49136.png +11185.png +56209.png +49195.png +01722.png +38332.png +60476.png +32714.png +07012.png +68482.png +19315.png +68783.png +36996.png +35115.png +59252.png +46032.png +03293.png +57136.png +30476.png +14600.png +29560.png +15680.png +41232.png +62122.png +29145.png +01159.png +15424.png +24133.png +63383.png +63951.png +57063.png +49250.png +45801.png +10689.png +68753.png +39692.png +19288.png +14871.png +17540.png +42094.png +64643.png +20647.png +03607.png +53708.png +15919.png +49544.png +56998.png +39848.png +69347.png +56112.png +63089.png +36952.png +65073.png +34574.png +42783.png +13426.png +44056.png +14676.png +23205.png +63282.png +52891.png +35195.png +41021.png +49207.png +51978.png +18705.png +19153.png +15829.png +06373.png +35871.png +67215.png +67530.png +50193.png +13530.png +41180.png +41864.png +21860.png +49046.png +25648.png +21857.png +31521.png +03104.png +33720.png +35449.png +06153.png +19586.png +50819.png +25548.png +49069.png +56495.png +01898.png +26610.png +53877.png +47880.png +34428.png +45244.png +52492.png +25649.png +52180.png +39675.png +02880.png +16512.png +59784.png +08038.png +22731.png +33005.png +40528.png +56317.png +45774.png +61997.png +53508.png +41936.png +43568.png +49980.png +01838.png +41893.png +47408.png +35454.png +63452.png +62836.png +00852.png +45445.png +14781.png +20482.png +54924.png +23078.png +35825.png +45952.png +01061.png +32707.png +56561.png +54060.png +09849.png +12796.png +30000.png +15074.png +55300.png +24419.png +21609.png +12122.png +07061.png +68845.png +29616.png +08081.png +26656.png +31913.png +18760.png +44694.png +07439.png +21207.png +08667.png +58011.png +36935.png +51865.png +55715.png +02796.png +27551.png +24208.png +03265.png +30831.png +45243.png +26690.png +31650.png +33550.png +52943.png +38869.png +54359.png +27777.png +24862.png +11457.png +65038.png +47406.png +32126.png +18161.png +43342.png +23369.png +63942.png +65831.png +09146.png +69738.png +04190.png +45790.png +40830.png +36762.png +16790.png +54265.png +55045.png +14477.png +69721.png +40114.png +03817.png +61419.png +06890.png +51714.png +01615.png +69999.png +43477.png +59349.png +28978.png +12950.png +04075.png +39298.png +38325.png +51843.png +67908.png +66501.png +47589.png +55361.png +52637.png +37777.png +66677.png +42133.png +56302.png +42098.png +42787.png +19508.png +17488.png +47379.png +24998.png +40204.png +55264.png +07865.png +32725.png +38374.png +15273.png +41121.png +12774.png +62188.png +48718.png +00364.png +42775.png +65219.png +02104.png +32867.png +37856.png +67808.png +17979.png +46362.png +40127.png +12194.png +67826.png +59724.png +47431.png +34463.png +56034.png +53146.png +22599.png +26532.png +33342.png +34980.png +68225.png +26486.png +23611.png +19042.png +36585.png +16366.png +52306.png +53957.png +63473.png +26162.png +46195.png +16578.png +34315.png +69472.png +24594.png +61908.png +61106.png +17909.png +35867.png +07685.png +47132.png +24656.png +58949.png +13976.png +06693.png +02715.png +28309.png +33593.png +04781.png +58062.png +68410.png +43012.png +69901.png +54301.png +04167.png +18884.png +34097.png +20560.png +52162.png +34713.png +48716.png +11868.png +64958.png +01597.png +38981.png +02615.png +28240.png +47965.png +65453.png +48482.png +29076.png +01369.png +61355.png +68853.png +02923.png +48000.png +07652.png +46613.png +16802.png +48267.png +47181.png +28452.png +16606.png +31950.png +34304.png +20098.png +10047.png +23226.png +24287.png +53805.png +66844.png +22633.png +54015.png +40276.png +34702.png +07725.png +10099.png +60513.png +45265.png +24112.png +34658.png +26719.png +57140.png +57231.png +20471.png +55462.png +24018.png +48652.png +48244.png +15675.png +49138.png +00666.png +58870.png +59986.png +47635.png +69608.png +38454.png +54871.png +13741.png +17147.png +34929.png +41422.png +08234.png +59843.png +49499.png +33149.png +24716.png +67672.png +03613.png +28163.png +15027.png +40644.png +39996.png +56086.png +01452.png +61316.png +13344.png +51394.png +69168.png +19152.png +50865.png +26792.png +43582.png +09486.png +00025.png +41272.png +04334.png +24217.png +54009.png +16004.png +05756.png +05611.png +55917.png +58237.png +22966.png +35124.png +66330.png +61507.png +35346.png +42962.png +11140.png +31615.png +33962.png +10996.png +52153.png +50949.png +24040.png +38419.png +23992.png +24294.png +19993.png +20413.png +39797.png +53321.png +15310.png +35036.png +69719.png +65332.png +27275.png +13375.png +29805.png +07750.png +00187.png +32528.png +10591.png +30362.png +07451.png +53391.png +62697.png +32308.png +12720.png +47982.png +11162.png +07518.png +68315.png +54792.png +47618.png +40208.png +65327.png +12366.png +69004.png +25575.png +10344.png +11188.png +31735.png +50016.png +57746.png +31109.png +17059.png +18469.png +03447.png +17221.png +52878.png +33437.png +67418.png +26551.png +54282.png +51255.png +50978.png +08965.png +55908.png +13864.png +57505.png +36149.png +16329.png +20010.png +63877.png +62219.png +33542.png +18283.png +28939.png +59402.png +50084.png +19127.png +60040.png +00191.png +00152.png +59044.png +66163.png +68370.png +38010.png +21786.png +20052.png +48063.png +59739.png +51775.png +36341.png +08659.png +24974.png +04628.png +39959.png +23162.png +54185.png +68288.png +64321.png +46317.png +15641.png +51347.png +46275.png +25939.png +32001.png +29852.png +43051.png +14931.png +02366.png +33959.png +24054.png +46322.png +60658.png +30278.png +52280.png +47141.png +66411.png +11234.png +45922.png +47875.png +54085.png +47027.png +47017.png +32160.png +26159.png +32803.png +65242.png +32850.png +50429.png +67690.png +25205.png +34801.png +53905.png +53179.png +41225.png +11611.png +22992.png +45097.png +54306.png +02124.png +56781.png +05120.png +37232.png +22795.png +60953.png +34529.png +06561.png +16938.png +53995.png +46783.png +27587.png +64549.png +26822.png +45273.png +22311.png +32452.png +51431.png +25483.png +69667.png +59091.png +30777.png +19071.png +06707.png +19085.png +04714.png +34899.png +33114.png +46525.png +68143.png +06133.png +45510.png +65967.png +50527.png +13808.png +35350.png +07735.png +14807.png +04271.png +63896.png +08432.png +62882.png +60973.png +28463.png +67357.png +48385.png +46700.png +16144.png +16465.png +12412.png +24654.png +01493.png +38311.png +19372.png +68676.png +14825.png +17868.png +37941.png +09815.png +26936.png +59951.png +37673.png +62912.png +17069.png +03298.png +18204.png +65167.png +40668.png +12067.png +38701.png +16884.png +05530.png +18388.png +22047.png +30895.png +34486.png +40449.png +57380.png +45297.png +13028.png +25477.png +49249.png +17707.png +15262.png +05664.png +32153.png +56247.png +31301.png +50364.png +41983.png +29861.png +31870.png +66599.png +23310.png +33354.png +54512.png +68646.png +27098.png +68591.png +67055.png +62458.png +54903.png +08771.png +26914.png +17212.png +45855.png +28419.png +62677.png +33272.png +02889.png +00813.png +36787.png +34782.png +44747.png +46888.png +08674.png +48078.png +13304.png +05637.png +65403.png +54091.png +14778.png +31362.png +11774.png +08621.png +50564.png +33244.png +19842.png +20804.png +00698.png +43820.png +61256.png +52589.png +01033.png +43664.png +35869.png +01087.png +66855.png +59795.png +45636.png +69338.png +06703.png +24934.png +61177.png +33668.png +65830.png +49644.png +45706.png +47240.png +19266.png +24232.png +23300.png +36038.png +25984.png +69371.png +35566.png +04635.png +21942.png +45438.png +37817.png +58823.png +35180.png +28621.png +35059.png +49064.png +48912.png +05906.png +68507.png +35738.png +65076.png +48660.png +17758.png +44965.png +30108.png +55794.png +30130.png +58037.png +33254.png +21067.png +65278.png +17014.png +36430.png +05886.png +01164.png +21561.png +30519.png +16185.png +47767.png +13998.png +49469.png +60799.png +31978.png +23209.png +29036.png +15727.png +07267.png +68580.png +58673.png +30740.png +05162.png +22700.png +52789.png +22317.png +04387.png +63499.png +62061.png +02703.png +50261.png +08214.png +18828.png +40580.png +67354.png +29807.png +31341.png +24498.png +38800.png +09228.png +06300.png +58356.png +27892.png +35173.png +61300.png +03938.png +69199.png +35227.png +06299.png +62791.png +28793.png +19459.png +61760.png +18417.png +14687.png +53546.png +38740.png +10473.png +38980.png +32140.png +58893.png +29262.png +55038.png +54936.png +61464.png +26626.png +49466.png +67797.png +14284.png +52730.png +23694.png +13659.png +06593.png +20956.png +10761.png +41484.png +21960.png +36249.png +68314.png +08135.png +03360.png +06791.png +33122.png +29847.png +03524.png +68647.png +45427.png +67191.png +37512.png +06162.png +44182.png +48013.png +58691.png +56356.png +64800.png +03040.png +57925.png +28977.png +11707.png +31933.png +18918.png +28792.png +31005.png +60229.png +51284.png +21698.png +59874.png +15000.png +35852.png +39774.png +01450.png +58299.png +43506.png +52427.png +02151.png +22980.png +36010.png +26337.png +42590.png +33476.png +38838.png +07128.png +06661.png +19764.png +60425.png +25953.png +68178.png +20476.png +00287.png +02752.png +28000.png +53591.png +18000.png +25925.png +23908.png +37206.png +53660.png +04782.png +25959.png +68595.png +23146.png +41157.png +34193.png +43811.png +69313.png +06853.png +38708.png +17409.png +27421.png +41038.png +55176.png +13380.png +22752.png +14070.png +15188.png +47227.png +68964.png +21116.png +09010.png +17287.png +29442.png +23841.png +49027.png +24979.png +43786.png +36207.png +08231.png +45228.png +57383.png +21990.png +53512.png +28655.png +01264.png +58805.png +18431.png +02566.png +28373.png +07161.png +67435.png +55009.png +02257.png +36555.png +37827.png +20445.png +15497.png +65052.png +06191.png +26279.png +05986.png +54390.png +24624.png +00402.png +25980.png +32874.png +69664.png +68911.png +53203.png +29940.png +10982.png +47567.png +67786.png +20507.png +27455.png +14159.png +18678.png +09359.png +55639.png +46364.png +21209.png +61235.png +49457.png +17613.png +43926.png +61386.png +20462.png +12711.png +32462.png +58366.png +13189.png +64478.png +05098.png +55994.png +26505.png +59615.png +66379.png +24965.png +49009.png +26442.png +68576.png +61465.png +03492.png +12797.png +63117.png +47888.png +42145.png +00022.png +19171.png +31590.png +61644.png +36064.png +17787.png +15060.png +55677.png +20681.png +65140.png +00854.png +15069.png +60643.png +25677.png +36417.png +36056.png +08988.png +49082.png +40585.png +38950.png +02355.png +13141.png +43818.png +29768.png +40828.png +39998.png +31014.png +69713.png +02940.png +24422.png +58665.png +35253.png +28294.png +43049.png +21601.png +24312.png +56908.png +29676.png +34113.png +13122.png +15106.png +16082.png +41464.png +68650.png +41362.png +67226.png +28301.png +58506.png +44078.png +42312.png +04664.png +14987.png +54829.png +19904.png +54672.png +07583.png +06481.png +33125.png +64173.png +17646.png +39538.png +32086.png +19841.png +57724.png +27269.png +04532.png +15114.png +59740.png +44108.png +46381.png +42519.png +66057.png +07143.png +60598.png +15203.png +61942.png +66967.png +65173.png +03368.png +08274.png +07165.png +28495.png +64541.png +30187.png +33032.png +08858.png +54670.png +50393.png +23508.png +13388.png +62005.png +50077.png +51927.png +63513.png +29777.png +42995.png +36654.png +23647.png +51273.png +14376.png +14371.png +04296.png +52045.png +23808.png +46453.png +00615.png +35762.png +00117.png +52248.png +53300.png +59497.png +16639.png +39338.png +28859.png +26286.png +68927.png +38668.png +52221.png +62414.png +33806.png +47018.png +58178.png +52702.png +56529.png +45146.png +10873.png +57056.png +01251.png +69035.png +28824.png +25139.png +67080.png +45623.png +63845.png +42125.png +27484.png +42460.png +14573.png +11551.png +08693.png +12563.png +22660.png +24158.png +48687.png +45285.png +17304.png +62861.png +44777.png +12292.png +49498.png +47200.png +48591.png +41773.png +04734.png +50476.png +37635.png +33270.png +66522.png +60536.png +07344.png +29434.png +40245.png +56422.png +01884.png +59315.png +55827.png +04237.png +04980.png +37499.png +65146.png +61457.png +55233.png +19001.png +44755.png +63109.png +47148.png +61389.png +32628.png +41912.png +18415.png +38705.png +38448.png +45581.png +55446.png +25511.png +60981.png +00071.png +02930.png +23176.png +28191.png +50156.png +17997.png +26693.png +48196.png +43528.png +32300.png +62119.png +46429.png +55651.png +68012.png +43437.png +55190.png +56586.png +21173.png +22513.png +01049.png +12245.png +04539.png +59900.png +36965.png +18712.png +19887.png +36507.png +34369.png +60454.png +56926.png +04047.png +09484.png +57344.png +09339.png +37517.png +40883.png +53842.png +32460.png +07707.png +36089.png +29664.png +37036.png +22222.png +21442.png +39077.png +39640.png +18692.png +03045.png +59634.png +02635.png +04480.png +38052.png +39174.png +31912.png +69391.png +47783.png +00042.png +11203.png +13786.png +02598.png +15617.png +44417.png +48471.png +24830.png +20959.png +67854.png +32967.png +24120.png +41146.png +66168.png +18519.png +36011.png +12141.png +19488.png +46058.png +68764.png +19276.png +18770.png +15563.png +14657.png +10070.png +44140.png +17509.png +34992.png +64303.png +42514.png +65044.png +62736.png +27869.png +19960.png +57890.png +16601.png +06607.png +58646.png +24493.png +44883.png +06808.png +05181.png +69702.png +55930.png +47340.png +00227.png +68478.png +49706.png +20951.png +68996.png +26785.png +03274.png +66960.png +25682.png +07003.png +20518.png +26474.png +34370.png +36127.png +38447.png +48780.png +22891.png +07477.png +15418.png +49921.png +00246.png +62518.png +21236.png +18716.png +00019.png +48810.png +38154.png +52125.png +36372.png +45764.png +51122.png +19856.png +00938.png +06197.png +03515.png +52004.png +40685.png +11438.png +33268.png +14886.png +21143.png +39453.png +49538.png +66014.png +63566.png +38206.png +01656.png +51939.png +51410.png +55163.png +17303.png +59017.png +35365.png +46698.png +27103.png +44914.png +21191.png +64650.png +02177.png +12224.png +49062.png +57651.png +64906.png +62910.png +36539.png +01086.png +57377.png +25495.png +11735.png +68224.png +00968.png +53664.png +14378.png +68843.png +42649.png +58003.png +09890.png +06305.png +03088.png +02835.png +25906.png +61308.png +44607.png +26189.png +64496.png +01607.png +28257.png +31117.png +16664.png +32361.png +00744.png +20093.png +63677.png +00131.png +20144.png +03717.png +58736.png +28641.png +68256.png +33898.png +26647.png +38848.png +09017.png +21297.png +03081.png +54697.png +04435.png +29059.png +40523.png +39638.png +40943.png +23914.png +66659.png +36263.png +02191.png +06370.png +13629.png +09386.png +61613.png +09608.png +66732.png +22533.png +53201.png +22709.png +29786.png +10919.png +56341.png +65575.png +47624.png +30755.png +32808.png +42422.png +58474.png +35860.png +19316.png +45831.png +35114.png +48585.png +11988.png +62199.png +37971.png +42901.png +56240.png +20165.png +64739.png +66241.png +03632.png +52046.png +18860.png +22897.png +09495.png +16377.png +04642.png +21187.png +61076.png +57629.png +37723.png +27023.png +27677.png +48359.png +06376.png +06739.png +13859.png +51560.png +47537.png +62667.png +42559.png +03110.png +24353.png +42673.png +67718.png +34908.png +51519.png +20478.png +32097.png +43902.png +15559.png +00279.png +26921.png +44309.png +12345.png +16637.png +13985.png +03841.png +26701.png +39354.png +13669.png +43476.png +49298.png +49284.png +68101.png +09816.png +51158.png +36020.png +35576.png +28779.png +51295.png +09468.png +21353.png +45987.png +62940.png +12128.png +30826.png +56940.png +55107.png +40873.png +12238.png +52115.png +69367.png +14167.png +45526.png +68905.png +03769.png +01161.png +60994.png +50027.png +60346.png +14809.png +57333.png +50657.png +32821.png +08203.png +30932.png +06918.png +00573.png +56191.png +31833.png +19176.png +19936.png +41922.png +18142.png +24852.png +08917.png +17089.png +48943.png +64357.png +36039.png +06622.png +58412.png +00804.png +53695.png +57148.png +05290.png +17544.png +60928.png +53534.png +61923.png +52827.png +31518.png +60801.png +06706.png +24615.png +14029.png +65008.png +03701.png +22121.png +58727.png +13201.png +49728.png +58015.png +21923.png +66223.png +04765.png +24981.png +23612.png +67525.png +06815.png +42609.png +21421.png +58359.png +47549.png +69480.png +05610.png +05206.png +05790.png +44836.png +59222.png +07479.png +08535.png +35308.png +36503.png +33417.png +29424.png +01540.png +18592.png +65161.png +66461.png +13695.png +50720.png +53241.png +09883.png +07151.png +25830.png +42272.png +35602.png +43023.png +32920.png +02645.png +37117.png +19931.png +36298.png +58636.png +10633.png +38734.png +10585.png +42596.png +60404.png +06015.png +43911.png +56660.png +67227.png +03183.png +43415.png +47047.png +30252.png +22306.png +03347.png +65645.png +07414.png +29468.png +48156.png +05012.png +67332.png +26927.png +65221.png +23595.png +07522.png +24930.png +46068.png +64424.png +67566.png +52998.png +26122.png +01012.png +05594.png +65946.png +41205.png +24824.png +26988.png +00971.png +39784.png +49577.png +10201.png +11363.png +01586.png +49783.png +14500.png +18479.png +69025.png +58743.png +30887.png +02454.png +34340.png +12262.png +52006.png +62619.png +02741.png +22627.png +58612.png +47042.png +35183.png +68673.png +02678.png +08426.png +45871.png +51649.png +14973.png +24510.png +31934.png +63313.png +51887.png +37628.png +23006.png +07928.png +26594.png +69467.png +56596.png +05397.png +02680.png +09532.png +09782.png +57029.png +55713.png +62374.png +13644.png +02335.png +28250.png +39539.png +32791.png +45596.png +37809.png +69726.png +09446.png +02122.png +00518.png +07312.png +23452.png +68915.png +29315.png +52208.png +05850.png +63263.png +31475.png +34231.png +68422.png +49061.png +01417.png +08553.png +28992.png +12146.png +26959.png +67042.png +05542.png +31481.png +24037.png +58946.png +29515.png +38983.png +59923.png +42711.png +24301.png +48817.png +30096.png +60745.png +46750.png +21961.png +40860.png +46623.png +54885.png +17432.png +07285.png +12913.png +43553.png +38368.png +20974.png +61500.png +65953.png +28501.png +66731.png +31918.png +01549.png +36300.png +28143.png +56436.png +23117.png +38304.png +47768.png +08677.png +00662.png +43364.png +04145.png +12858.png +21776.png +40543.png +02045.png +13088.png +16058.png +07729.png +27932.png +62485.png +04592.png +56343.png +59116.png +23673.png +60848.png +66542.png +24198.png +67362.png +28284.png +60188.png +18336.png +55489.png +15180.png +64327.png +32371.png +20850.png +28950.png +66048.png +61231.png +57110.png +16307.png +39745.png +55608.png +22498.png +39851.png +42564.png +12722.png +56469.png +27704.png +16372.png +52723.png +16098.png +47037.png +43899.png +69119.png +22650.png +30299.png +12553.png +24785.png +21508.png +29839.png +48417.png +35080.png +59714.png +65797.png +26884.png +08686.png +04680.png +44785.png +10945.png +41024.png +05768.png +14210.png +16316.png +61093.png +43635.png +68489.png +10246.png +15384.png +22094.png +45749.png +26852.png +53950.png +68586.png +66640.png +09673.png +58408.png +47165.png +43731.png +24849.png +09682.png +26999.png +04485.png +54099.png +08115.png +05488.png +33036.png +49731.png +52426.png +41713.png +17708.png +07120.png +62510.png +21468.png +02306.png +27468.png +61962.png +54972.png +13166.png +19281.png +20449.png +35868.png +24187.png +32587.png +06948.png +51682.png +62173.png +56508.png +33212.png +10483.png +40648.png +40163.png +67477.png +05249.png +60223.png +24929.png +14857.png +43765.png +34783.png +27772.png +31846.png +06846.png +19081.png +58301.png +24604.png +16869.png +48683.png +09432.png +66176.png +68075.png +68532.png +24122.png +21853.png +40910.png +32729.png +10153.png +08682.png +66583.png +59507.png +45717.png +39224.png +05104.png +11526.png +18189.png +00456.png +16624.png +36824.png +22670.png +64816.png +62955.png +12156.png +52899.png +35627.png +52664.png +66699.png +51695.png +23219.png +62028.png +57116.png +18989.png +54892.png +07456.png +20377.png +23367.png +25485.png +06087.png +52312.png +65796.png +64505.png +60765.png +28569.png +66692.png +44835.png +19485.png +68152.png +16196.png +44012.png +04492.png +47503.png +41540.png +59492.png +27058.png +43872.png +63197.png +14850.png +34724.png +30564.png +21882.png +40766.png +19435.png +45960.png +59812.png +28478.png +60600.png +05444.png +66995.png +39471.png +15537.png +24543.png +13716.png +22402.png +54937.png +41302.png +58104.png +53919.png +62389.png +41054.png +12470.png +46200.png +48419.png +41805.png +64004.png +45842.png +15814.png +04490.png +43240.png +26266.png +21818.png +25647.png +07859.png +17603.png +08856.png +62906.png +53042.png +29078.png +34501.png +04827.png +09783.png +14982.png +08287.png +56316.png +14134.png +31540.png +26420.png +27356.png +37339.png +59664.png +31959.png +28382.png +64501.png +27253.png +42159.png +37417.png +50622.png +15206.png +08048.png +39090.png +46665.png +28369.png +29602.png +49163.png +15492.png +38230.png +22307.png +06440.png +63219.png +16380.png +46405.png +45723.png +41398.png +09688.png +15066.png +56457.png +12778.png +37459.png +04741.png +26203.png +26432.png +39856.png +04731.png +37140.png +68884.png +38116.png +25674.png +67225.png +49727.png +23045.png +41081.png +61261.png +41023.png +00159.png +19501.png +39956.png +21133.png +33338.png +11618.png +09530.png +07629.png +55123.png +31886.png +26155.png +27498.png +49868.png +42099.png +41492.png +09121.png +66519.png +34333.png +17706.png +05454.png +32875.png +00892.png +54893.png +59555.png +19349.png +42928.png +60035.png +27931.png +37964.png +56313.png +12733.png +29860.png +64755.png +65558.png +00203.png +30871.png +56294.png +67980.png +39717.png +66365.png +29495.png +59623.png +36928.png +09961.png +37617.png +33115.png +05468.png +20555.png +28804.png +01977.png +17188.png +05853.png +60563.png +06393.png +22956.png +24779.png +14900.png +10807.png +32708.png +40440.png +11239.png +09016.png +48559.png +46559.png +43501.png +11114.png +00681.png +59282.png +68144.png +52030.png +47874.png +09027.png +61444.png +25062.png +26176.png +54151.png +42504.png +46088.png +46590.png +18320.png +57458.png +52756.png +16794.png +60794.png +65056.png +10079.png +46047.png +37272.png +55016.png +49924.png +35533.png +03680.png +15517.png +35765.png +66410.png +27691.png +02077.png +43548.png +43774.png +41470.png +06269.png +49337.png +43499.png +47056.png +47603.png +12559.png +06968.png +51166.png +16879.png +46563.png +40115.png +30764.png +23795.png +54018.png +53346.png +36977.png +46105.png +17608.png +19225.png +39689.png +27573.png +43075.png +10450.png +28982.png +05680.png +45503.png +49769.png +44931.png +36192.png +05641.png +65324.png +19235.png +68760.png +03753.png +67900.png +43064.png +08147.png +11984.png +59697.png +23253.png +65217.png +66340.png +59560.png +39101.png +54907.png +13433.png +44126.png +37853.png +35820.png +59585.png +34990.png +43742.png +12339.png +28789.png +30823.png +40524.png +03357.png +54827.png +05095.png +58269.png +29717.png +68145.png +43775.png +63378.png +60053.png +46445.png +59350.png +32132.png +10116.png +54316.png +20992.png +40955.png +35710.png +63272.png +37670.png +64841.png +52841.png +49654.png +60027.png +01406.png +02934.png +01057.png +32169.png +14626.png +09792.png +30743.png +49326.png +24272.png +54787.png +55978.png +33849.png +58320.png +19213.png +35660.png +62042.png +14849.png +69941.png +62181.png +51493.png +38159.png +35339.png +21464.png +14826.png +08487.png +40301.png +36502.png +47806.png +21242.png +60547.png +61189.png +04794.png +50701.png +54978.png +19934.png +20285.png +12252.png +64596.png +00528.png +22948.png +44490.png +47770.png +69091.png +01182.png +30918.png +00608.png +63554.png +68233.png +12063.png +51462.png +42017.png +29974.png +60334.png +36214.png +59875.png +27934.png +43919.png +12471.png +11323.png +08051.png +63600.png +67437.png +02688.png +02447.png +58570.png +05867.png +56619.png +65459.png +31608.png +51638.png +14822.png +20281.png +55454.png +56241.png +06295.png +54072.png +56228.png +69143.png +56830.png +08688.png +49916.png +38908.png +55173.png +54177.png +06912.png +54828.png +31414.png +14855.png +19198.png +45883.png +45708.png +47158.png +15193.png +65847.png +48004.png +09493.png +61936.png +56860.png +07611.png +05119.png +31151.png +52977.png +54138.png +39563.png +15962.png +19789.png +69108.png +01497.png +29657.png +37516.png +18509.png +48383.png +49190.png +38415.png +10277.png +36082.png +58076.png +05899.png +02240.png +35551.png +24863.png +20044.png +36305.png +67063.png +56668.png +38261.png +50204.png +12740.png +00715.png +60645.png +55691.png +04208.png +53635.png +39875.png +57585.png +23700.png +01609.png +66174.png +28531.png +42114.png +66564.png +58757.png +24051.png +27757.png +05964.png +16199.png +23477.png +25782.png +48796.png +12018.png +21419.png +00567.png +27975.png +30483.png +52680.png +08520.png +13776.png +09519.png +48257.png +12328.png +19398.png +51444.png +62004.png +58445.png +00055.png +21972.png +40180.png +12135.png +20658.png +59279.png +16724.png +47749.png +08179.png +12029.png +53954.png +63875.png +47203.png +09667.png +22257.png +62257.png +29441.png +58501.png +01631.png +64548.png +65528.png +00298.png +42020.png +34500.png +49866.png +64792.png +06680.png +40120.png +20789.png +05481.png +50329.png +46090.png +20141.png +47092.png +14164.png +35422.png +11388.png +44423.png +42281.png +12551.png +59851.png +33138.png +42028.png +48177.png +23606.png +64351.png +57997.png +10019.png +09072.png +68671.png +11577.png +60222.png +16667.png +37719.png +25877.png +67510.png +67966.png +40667.png +56706.png +39318.png +29750.png +35234.png +39583.png +47209.png +63216.png +17796.png +00605.png +67386.png +09395.png +11655.png +01553.png +12587.png +39860.png +00689.png +14879.png +60441.png +52654.png +26637.png +58259.png +62920.png +37681.png +54993.png +48037.png +40632.png +22997.png +16796.png +45186.png +24698.png +42239.png +10401.png +22191.png +45483.png +67382.png +02214.png +07580.png +11709.png +29160.png +17315.png +30333.png +12618.png +40153.png +57867.png +53902.png +59954.png +35841.png +44175.png +35766.png +16477.png +01412.png +69010.png +20013.png +38181.png +26370.png +31012.png +24056.png +27184.png +08146.png +23080.png +01384.png +24776.png +24768.png +49966.png +51735.png +24067.png +49087.png +00225.png +36745.png +53854.png +04095.png +01267.png +56444.png +09302.png +67220.png +65576.png +11142.png +55070.png +36605.png +55287.png +08819.png +26424.png +19026.png +64269.png +56506.png +66940.png +59783.png +10399.png +21230.png +29932.png +43112.png +63863.png +00452.png +58328.png +51327.png +42186.png +64561.png +30154.png +02047.png +01235.png +51270.png +25975.png +32633.png +64934.png +57105.png +47096.png +46367.png +34902.png +04303.png +03135.png +10913.png +49048.png +29053.png +11851.png +09578.png +31058.png +37910.png +65006.png +02764.png +12895.png +69574.png +39840.png +62208.png +05267.png +62165.png +00701.png +67073.png +31076.png +29099.png +23088.png +37874.png +22884.png +01523.png +01249.png +59060.png +59486.png +44720.png +57028.png +21982.png +22848.png +40083.png +11411.png +21142.png +35661.png +52973.png +17366.png +26446.png +63673.png +67462.png +65308.png +53739.png +36013.png +20487.png +65861.png +07164.png +54175.png +31695.png +45986.png +02972.png +14601.png +65570.png +58407.png +05262.png +51485.png +39001.png +57501.png +61522.png +61143.png +22357.png +18508.png +35883.png +41838.png +06361.png +13826.png +00706.png +40634.png +07490.png +30386.png +60808.png +66490.png +62794.png +63786.png +63744.png +32832.png +04344.png +62311.png +28546.png +61327.png +18857.png +16719.png +57455.png +33166.png +40775.png +67504.png +50931.png +20980.png +53457.png +23463.png +03594.png +67422.png +00260.png +43637.png +50827.png +32521.png +23998.png +66308.png +05066.png +10792.png +68127.png +00602.png +01647.png +05404.png +36925.png +46502.png +56722.png +11361.png +36942.png +61345.png +39674.png +15705.png +53081.png +55743.png +48946.png +68961.png +57736.png +40378.png +56994.png +04874.png +05504.png +59914.png +05961.png +48173.png +36203.png +36378.png +35163.png +03178.png +48880.png +52191.png +53648.png +49961.png +54049.png +04954.png +39732.png +54333.png +33358.png +35613.png +47516.png +35754.png +10351.png +08460.png +41545.png +35893.png +16356.png +60170.png +12690.png +50785.png +44598.png +64264.png +43796.png +13992.png +11058.png +48174.png +63169.png +67108.png +13679.png +55845.png +17901.png +62576.png +15800.png +06085.png +00235.png +14475.png +05824.png +18652.png +10154.png +69920.png +32136.png +27229.png +05395.png +31224.png +64855.png +65572.png +55807.png +67707.png +66829.png +52483.png +48333.png +37529.png +18521.png +53753.png +14052.png +28920.png +61434.png +38069.png +20723.png +48822.png +46475.png +65479.png +61830.png +23362.png +30524.png +69283.png +02101.png +43802.png +48410.png +20546.png +63840.png +06879.png +38355.png +38665.png +66656.png +28968.png +21324.png +05512.png +03297.png +40922.png +14530.png +69631.png +69344.png +15463.png +15254.png +05522.png +16260.png +11733.png +42307.png +33050.png +40542.png +45699.png +00793.png +54549.png +38995.png +45045.png +18287.png +63523.png +33406.png +15717.png +62375.png +40426.png +10267.png +02192.png +14238.png +06476.png +62781.png +61926.png +39037.png +08238.png +29319.png +10433.png +44123.png +46887.png +36895.png +61167.png +07915.png +44781.png +58880.png +09731.png +08833.png +65022.png +17525.png +19928.png +34809.png +38347.png +25046.png +10643.png +39257.png +28288.png +53688.png +16092.png +25533.png +55231.png +41239.png +18638.png +12515.png +48289.png +64436.png +49078.png +38584.png +62130.png +48616.png +46219.png +38191.png +12293.png +19346.png +22802.png +16925.png +29670.png +27379.png +45200.png +17074.png +53628.png +33395.png +54640.png +68269.png +51910.png +26764.png +26806.png +62337.png +05337.png +28919.png +02614.png +03483.png +58792.png +36494.png +29628.png +05895.png +65344.png +57487.png +35832.png +15789.png +41831.png +13434.png +16231.png +56756.png +62713.png +64905.png +62669.png +30987.png +48186.png +42866.png +02205.png +23118.png +25064.png +17956.png +58084.png +58553.png +53698.png +50778.png +54318.png +15223.png +46098.png +61376.png +66850.png +04128.png +09770.png +47621.png +35691.png +15251.png +06906.png +29535.png +04210.png +21445.png +15691.png +28788.png +30375.png +17976.png +47204.png +52693.png +29074.png +23978.png +22592.png +23547.png +53286.png +21720.png +31904.png +28626.png +12319.png +18888.png +21886.png +13004.png +47272.png +22387.png +05815.png +55421.png +48568.png +12821.png +16057.png +41674.png +20963.png +06883.png +40604.png +41962.png +17684.png +66319.png +33851.png +00234.png +04298.png +24889.png +22436.png +57360.png +59433.png +15666.png +20113.png +04137.png +46697.png +21455.png +48768.png +55666.png +62470.png +53275.png +60939.png +52837.png +33031.png +17019.png +50910.png +12298.png +53859.png +29029.png +15656.png +64007.png +52151.png +08254.png +29650.png +33921.png +06714.png +23290.png +20805.png +25036.png +40275.png +18268.png +00725.png +68891.png +11561.png +19385.png +21276.png +46650.png +00992.png +53910.png +05153.png +01760.png +51011.png +15419.png +24486.png +48049.png +43805.png +52229.png +13003.png +05613.png +32106.png +11200.png +11633.png +41390.png +25492.png +51593.png +35462.png +08206.png +01800.png +57033.png +16430.png +05596.png +22965.png +34886.png +28644.png +67855.png +66180.png +50722.png +53654.png +36284.png +15504.png +47136.png +17067.png +57993.png +64328.png +08488.png +67069.png +08547.png +34855.png +06442.png +19899.png +09426.png +62643.png +61135.png +37886.png +54824.png +03078.png +34965.png +21949.png +63938.png +66171.png +10790.png +30183.png +55785.png +05331.png +49584.png +11093.png +32940.png +55843.png +47611.png +06148.png +08840.png +52578.png +26671.png +28572.png +56248.png +33885.png +13118.png +64407.png +03940.png +44978.png +52640.png +47273.png +40138.png +51547.png +14811.png +48950.png +35968.png +45142.png +44901.png +40330.png +00991.png +59062.png +02901.png +14050.png +35594.png +20721.png +43797.png +26154.png +18517.png +52858.png +38875.png +38561.png +27385.png +57385.png +09158.png +10147.png +36733.png +48527.png +47988.png +22097.png +06198.png +06597.png +14782.png +06526.png +15111.png +48495.png +27622.png +58490.png +45318.png +58782.png +66911.png +20322.png +47850.png +12499.png +45374.png +54255.png +35683.png +69531.png +34085.png +00972.png +13889.png +43875.png +03655.png +01244.png +56227.png +62649.png +35203.png +43826.png +36151.png +20918.png +54259.png +13096.png +13131.png +57869.png +66191.png +32367.png +41178.png +60790.png +41211.png +04245.png +12693.png +48778.png +44230.png +34035.png +46007.png +50008.png +57951.png +04705.png +12418.png +23061.png +61821.png +01066.png +38505.png +32389.png +51441.png +22302.png +30706.png +64274.png +68702.png +65227.png +18067.png +69697.png +00782.png +29692.png +38822.png +17781.png +64680.png +13603.png +45324.png +26553.png +40390.png +49088.png +46114.png +23379.png +11502.png +40509.png +47411.png +28735.png +57045.png +30044.png +51250.png +10517.png +05993.png +13083.png +62272.png +26898.png +21875.png +60715.png +65705.png +48794.png +67392.png +38309.png +49172.png +48123.png +66766.png +29667.png +03873.png +62963.png +06318.png +58603.png +61466.png +38888.png +15458.png +59834.png +60866.png +39325.png +36713.png +21649.png +62957.png +35829.png +38231.png +19855.png +68140.png +17165.png +56475.png +45875.png +01814.png +05351.png +44794.png +41426.png +44557.png +10086.png +27533.png +49602.png +16394.png +32043.png +44971.png +42665.png +31689.png +59033.png +31577.png +26138.png +67087.png +31881.png +15936.png +08294.png +42149.png +56129.png +12763.png +10031.png +16257.png +62896.png +33659.png +11298.png +46415.png +31466.png +04872.png +39893.png +11777.png +30364.png +06675.png +29331.png +11166.png +23365.png +45797.png +28592.png +42727.png +45050.png +27055.png +24868.png +44184.png +04966.png +20622.png +16939.png +40932.png +39223.png +18141.png +65602.png +38182.png +08671.png +43317.png +17131.png +08152.png +48589.png +41363.png +23448.png +10362.png +20005.png +12088.png +08393.png +53362.png +21697.png +29162.png +28065.png +41833.png +65267.png +66210.png +34146.png +33048.png +48161.png +53939.png +42368.png +66878.png +23500.png +69657.png +40578.png +04024.png +01847.png +64078.png +50944.png +33929.png +07640.png +23993.png +61488.png +04150.png +30496.png +19854.png +56952.png +53495.png +40654.png +43131.png +57220.png +38718.png +01709.png +08626.png +59106.png +22195.png +50623.png +27751.png +43851.png +21119.png +12933.png +14861.png +57133.png +67275.png +24533.png +69052.png +18401.png +29226.png +16626.png +38469.png +43080.png +49923.png +69683.png +46913.png +53111.png +15383.png +68112.png +37969.png +21977.png +23444.png +37894.png +51817.png +39445.png +34476.png +34942.png +49482.png +18776.png +18153.png +36601.png +11446.png +38382.png +30576.png +20248.png +47945.png +56602.png +49541.png +25390.png +63210.png +05231.png +02485.png +47684.png +59225.png +35755.png +02871.png +68455.png +59741.png +35071.png +36756.png +54029.png +33265.png +00470.png +68614.png +04901.png +65879.png +54262.png +36608.png +69521.png +19513.png +13405.png +68250.png +07234.png +30258.png +08470.png +00754.png +18110.png +17505.png +33941.png +05854.png +26193.png +56476.png +29418.png +49021.png +07363.png +25025.png +11143.png +51022.png +06190.png +04148.png +50587.png +17101.png +30320.png +07230.png +00020.png +03017.png +40065.png +62356.png +25777.png +21300.png +16050.png +46336.png +26289.png +27687.png +53747.png +05760.png +15017.png +38533.png +46567.png +09448.png +02784.png +29472.png +49674.png +27142.png +14741.png +47378.png +40369.png +10424.png +45511.png +09500.png +45103.png +23927.png +45443.png +35370.png +31375.png +05631.png +13481.png +07413.png +09312.png +32730.png +44270.png +08744.png +28055.png +46278.png +45275.png +39473.png +16056.png +19812.png +69554.png +67802.png +51517.png +50790.png +52316.png +08973.png +20306.png +11931.png +58906.png +51340.png +23126.png +02125.png +41104.png +04780.png +34707.png +24630.png +21725.png +64010.png +65491.png +26621.png +02432.png +32218.png +62289.png +12725.png +13224.png +53526.png +34947.png +55625.png +14908.png +65163.png +52152.png +42647.png +02078.png +34845.png +01613.png +07874.png +68444.png +49335.png +43853.png +06584.png +44708.png +33382.png +41537.png +10190.png +23292.png +62881.png +34798.png +27767.png +25517.png +07586.png +48204.png +40365.png +14605.png +04977.png +19038.png +24585.png +00538.png +24390.png +52794.png +47026.png +60255.png +27876.png +68870.png +40609.png +38003.png +61004.png +62320.png +57097.png +35702.png +07391.png +26572.png +41668.png +26916.png +21192.png +34790.png +55742.png +52268.png +38806.png +69940.png +23404.png +11301.png +31668.png +15989.png +01000.png +11976.png +57619.png +06362.png +28404.png +56905.png +65906.png +03581.png +42359.png +22835.png +59630.png +16396.png +18646.png +66443.png +60650.png +66107.png +28862.png +69103.png +09174.png +52627.png +29361.png +34269.png +12145.png +63865.png +16153.png +38281.png +34834.png +53219.png +45753.png +29439.png +59619.png +52139.png +00497.png +24634.png +19278.png +66039.png +38050.png +40515.png +56870.png +54793.png +62657.png +03243.png +36356.png +40692.png +07387.png +23637.png +61321.png +09932.png +56776.png +13782.png +61865.png +69354.png +58781.png +65714.png +28333.png +33063.png +21004.png +01959.png +39229.png +48059.png +22231.png +34612.png +64944.png +38666.png +33931.png +65467.png +04600.png +45868.png +60714.png +17386.png +33751.png +28822.png +65398.png +49165.png +58908.png +33508.png +48645.png +39559.png +51056.png +57574.png +05218.png +68686.png +23668.png +39088.png +22241.png +59949.png +41804.png +67727.png +52839.png +64295.png +30093.png +11317.png +27838.png +20230.png +66254.png +06996.png +04923.png +26578.png +58143.png +67943.png +28049.png +35488.png +48404.png +50713.png +66663.png +39549.png +09062.png +07768.png +59756.png +30273.png +12361.png +38343.png +27823.png +13538.png +02966.png +31606.png +38452.png +31099.png +04684.png +24692.png +05155.png +17210.png +24550.png +21196.png +60283.png +48998.png +59643.png +47004.png +39822.png +24975.png +45310.png +40342.png +02815.png +52304.png +50419.png +14355.png +11032.png +38679.png +26982.png +55061.png +18424.png +23043.png +19492.png +44521.png +01813.png +22408.png +62156.png +38489.png +30304.png +21962.png +23824.png +16514.png +59893.png +36121.png +59796.png +19455.png +01737.png +34215.png +16539.png +56440.png +37908.png +69690.png +69335.png +05040.png +46734.png +55210.png +32207.png +37411.png +61863.png +35468.png +54011.png +65061.png +61978.png +42038.png +03263.png +63137.png +26314.png +05614.png +65625.png +27764.png +39645.png +13171.png +69138.png +20831.png +06949.png +45874.png +31940.png +68821.png +01671.png +66774.png +41026.png +46940.png +23416.png +53846.png +01651.png +40070.png +59888.png +09376.png +56132.png +05744.png +28755.png +08130.png +59154.png +32494.png +08139.png +61332.png +47569.png +57749.png +49819.png +46506.png +15764.png +62089.png +05521.png +39780.png +39339.png +46794.png +61014.png +40995.png +30313.png +38215.png +22972.png +59303.png +07441.png +15437.png +19798.png +25490.png +31622.png +52935.png +48500.png +38384.png +40844.png +01863.png +48655.png +09535.png +38250.png +24918.png +39975.png +38652.png +59418.png +12299.png +40490.png +41946.png +40434.png +47298.png +22653.png +35623.png +67190.png +05926.png +34483.png +49419.png +63060.png +56042.png +66865.png +12407.png +43265.png +32387.png +25650.png +51267.png +06249.png +06100.png +35051.png +32767.png +07781.png +17041.png +36727.png +37711.png +38400.png +23853.png +33307.png +15631.png +42427.png +22215.png +15155.png +00740.png +15115.png +23354.png +15129.png +54710.png +47473.png +60051.png +15508.png +52190.png +14654.png +24358.png +23437.png +52318.png +59840.png +34652.png +39775.png +11332.png +14076.png +19074.png +39599.png +44504.png +02969.png +01175.png +56984.png +54647.png +57466.png +51919.png +17922.png +03943.png +56608.png +52964.png +67782.png +51228.png +50666.png +47832.png +34943.png +18865.png +60192.png +46143.png +21641.png +27264.png +58135.png +41279.png +61482.png +65215.png +23585.png +68951.png +64751.png +45872.png +11377.png +26014.png +12670.png +56697.png +16997.png +02042.png +23357.png +59079.png +13036.png +15344.png +19562.png +30190.png +61896.png +66336.png +31176.png +16866.png +66009.png +27544.png +66845.png +43659.png +30237.png +17671.png +27447.png +11783.png +52451.png +38987.png +11456.png +21340.png +30699.png +31199.png +05773.png +57931.png +36033.png +62363.png +22151.png +40534.png +64167.png +62031.png +26375.png +44819.png +41554.png +43442.png +25772.png +65652.png +29430.png +68895.png +29172.png +57275.png +27452.png +02217.png +34911.png +34233.png +52569.png +57397.png +01948.png +38979.png +16535.png +25587.png +45076.png +66447.png +55596.png +07124.png +67488.png +51175.png +07405.png +50432.png +61841.png +33215.png +22529.png +01255.png +29041.png +08759.png +58920.png +10455.png +04010.png +22449.png +55230.png +63220.png +27734.png +56093.png +54153.png +69109.png +65694.png +66252.png +04689.png +46349.png +16273.png +37975.png +62148.png +65416.png +35943.png +58006.png +58610.png +08649.png +61214.png +50158.png +51139.png +53985.png +26747.png +64060.png +08764.png +03570.png +05692.png +24370.png +09780.png +63643.png +54070.png +22373.png +31333.png +03840.png +54821.png +39815.png +67623.png +48944.png +50240.png +27149.png +49278.png +10552.png +39992.png +33606.png +15285.png +48898.png +03203.png +25383.png +43917.png +45765.png +42974.png +21729.png +37103.png +15474.png +07057.png +11403.png +04174.png +50101.png +02630.png +10202.png +03342.png +50327.png +04926.png +17772.png +21018.png +03332.png +48715.png +50024.png +26674.png +23704.png +14559.png +01735.png +43486.png +07317.png +28770.png +08329.png +48395.png +05826.png +15560.png +10465.png +22024.png +09990.png +42318.png +69595.png +59586.png +49948.png +59090.png +15446.png +20472.png +01423.png +21701.png +07031.png +32396.png +65706.png +03869.png +01093.png +59950.png +15509.png +32211.png +48288.png +68207.png +28821.png +20378.png +38966.png +13209.png +05971.png +36567.png +69981.png +54774.png +43845.png +27763.png +45360.png +55122.png +32589.png +37906.png +44463.png +63980.png +60183.png +19091.png +05996.png +63289.png +38902.png +50996.png +49972.png +34655.png +37187.png +24249.png +41740.png +28914.png +21045.png +60211.png +54197.png +06359.png +41392.png +28073.png +04013.png +18127.png +46924.png +45608.png +09558.png +03167.png +66754.png +19981.png +22445.png +18357.png +48460.png +08506.png +37039.png +01434.png +31714.png +42409.png +03670.png +37597.png +20968.png +64698.png +26692.png +60585.png +68787.png +07697.png +34497.png +10663.png +02479.png +19095.png +00958.png +29129.png +17106.png +53600.png +06138.png +56846.png +51511.png +00670.png +14143.png +57022.png +22486.png +61122.png +13512.png +63975.png +45984.png +22407.png +24365.png +41965.png +60366.png +25850.png +06741.png +25540.png +31552.png +21924.png +31514.png +19405.png +12923.png +59599.png +11801.png +02977.png +27200.png +13634.png +44130.png +47865.png +33302.png +00021.png +50412.png +15113.png +21354.png +34337.png +05341.png +19742.png +60648.png +54016.png +67020.png +66368.png +24001.png +27436.png +60358.png +25815.png +12454.png +57832.png +08162.png +15653.png +36794.png +05499.png +40285.png +10672.png +40119.png +38314.png +51783.png +26787.png +42093.png +47333.png +02755.png +34756.png +03168.png +49617.png +23082.png +00359.png +41776.png +43078.png +19451.png +55278.png +64749.png +25882.png +54317.png +37378.png +46059.png +66119.png +21534.png +32816.png +20358.png +18961.png +38080.png +36085.png +26358.png +68421.png +25149.png +20463.png +44953.png +35587.png +23440.png +43100.png +29762.png +37855.png +22006.png +43376.png +12592.png +57323.png +15593.png +36154.png +53906.png +54622.png +40259.png +43962.png +09765.png +07710.png +13253.png +47115.png +06308.png +67245.png +64057.png +14138.png +23672.png +27525.png +64121.png +25935.png +56463.png +07539.png +23780.png +12922.png +48456.png +06405.png +65436.png +03957.png +55121.png +47981.png +48302.png +14519.png +64391.png +39342.png +65733.png +04981.png +20687.png +35656.png +59048.png +67411.png +53418.png +22381.png +31731.png +36092.png +18805.png +18217.png +67705.png +33150.png +38486.png +58632.png +45823.png +10950.png +57459.png +29926.png +00598.png +03201.png +41627.png +27538.png +49716.png +69519.png +18005.png +01285.png +35837.png +19048.png +52767.png +47838.png +43509.png +04009.png +64355.png +13149.png +08384.png +12979.png +48139.png +20092.png +44527.png +19872.png +14515.png +32428.png +11562.png +30116.png +63760.png +44139.png +66112.png +29969.png +64484.png +45004.png +33518.png +44097.png +22528.png +48350.png +17393.png +54846.png +07715.png +14225.png +13417.png +67572.png +29586.png +12171.png +21387.png +46283.png +05639.png +45442.png +39336.png +58090.png +46320.png +10531.png +18063.png +36828.png +08112.png +64306.png +61651.png +08605.png +47679.png +18090.png +30298.png +42935.png +42141.png +67001.png +24640.png +41684.png +24378.png +12793.png +09621.png +29118.png +42795.png +58307.png +18735.png +25200.png +04488.png +50067.png +67222.png +00124.png +10947.png +49164.png +21583.png +21804.png +18378.png +47551.png +00993.png +68232.png +38815.png +23016.png +20180.png +12825.png +07309.png +50391.png +67114.png +67170.png +58126.png +66489.png +38473.png +20033.png +15109.png +04903.png +50557.png +65517.png +53987.png +54783.png +31432.png +63947.png +46929.png +64531.png +07507.png +10709.png +52374.png +17185.png +32784.png +61608.png +38479.png +19121.png +40150.png +45030.png +52701.png +43167.png +23259.png +67470.png +29979.png +44698.png +52351.png +02712.png +59520.png +21223.png +56686.png +24717.png +52144.png +62596.png +27721.png +08528.png +35276.png +28904.png +57900.png +24433.png +67280.png +00677.png +23040.png +01427.png +68346.png +34552.png +01486.png +42047.png +55544.png +54065.png +41110.png +45598.png +31121.png +68335.png +01930.png +49176.png +05197.png +58464.png +61370.png +11535.png +02660.png +30146.png +45006.png +04484.png +01861.png +40166.png +08071.png +44587.png +58531.png +53565.png +19563.png +56963.png +41645.png +40956.png +64967.png +04785.png +16348.png +47685.png +52722.png +37580.png +30469.png +65046.png +06562.png +19645.png +35445.png +16996.png +68766.png +26223.png +62146.png +35714.png +00318.png +17833.png +29143.png +10094.png +46730.png +68600.png +34889.png +56944.png +37953.png +06704.png +37203.png +03435.png +28428.png +50992.png +10906.png +11269.png +30739.png +52448.png +64059.png +62377.png +30843.png +16259.png +46902.png +47062.png +57658.png +39153.png +37668.png +03276.png +35917.png +25539.png +63879.png +00082.png +32917.png +12754.png +50511.png +22784.png +24032.png +24924.png +52904.png +09447.png +11864.png +06684.png +21948.png +02737.png +65107.png +31930.png +33925.png +50479.png +12584.png +52104.png +35027.png +36330.png +47077.png +11556.png +50175.png +30220.png +25107.png +31900.png +44814.png +03942.png +41309.png +60002.png +64336.png +43614.png +49996.png +60472.png +41334.png +27009.png +66795.png +10855.png +61957.png +24917.png +46442.png +48868.png +36328.png +26777.png +46736.png +68271.png +15711.png +37849.png +02131.png +23038.png +59830.png +13982.png +13235.png +40021.png +51292.png +17112.png +34592.png +19482.png +46433.png +56681.png +24452.png +34077.png +66363.png +35975.png +66096.png +01701.png +10938.png +41811.png +04213.png +52339.png +23053.png +48534.png +40820.png +40760.png +33906.png +38495.png +28170.png +53422.png +27231.png +25285.png +41770.png +67267.png +03967.png +20503.png +41705.png +64523.png +27954.png +27718.png +01509.png +16906.png +44353.png +24923.png +59517.png +19228.png +06490.png +35334.png +13949.png +56762.png +51988.png +56109.png +37731.png +67259.png +58607.png +14539.png +54859.png +26807.png +00295.png +69212.png +37683.png +46357.png +09882.png +05817.png +48753.png +18418.png +44981.png +35235.png +11494.png +09594.png +45827.png +48195.png +06028.png +11308.png +67322.png +49395.png +08467.png +31801.png +55501.png +59977.png +61410.png +33882.png +38575.png +47480.png +01198.png +11960.png +60705.png +58450.png +55488.png +42556.png +54393.png +21832.png +44086.png +15390.png +64371.png +53598.png +33025.png +19780.png +13805.png +26234.png +40947.png +60456.png +58117.png +59660.png +40345.png +38283.png +20609.png +20149.png +06003.png +42325.png +52056.png +02619.png +45714.png +46080.png +23706.png +61520.png +09328.png +21181.png +60768.png +16284.png +61384.png +17587.png +35315.png +29324.png +67111.png +54165.png +45643.png +39131.png +37313.png +56390.png +55390.png +60621.png +45882.png +53006.png +02893.png +01478.png +28892.png +41123.png +46503.png +60095.png +16774.png +49215.png +26892.png +53442.png +55627.png +14844.png +28567.png +25696.png +28037.png +39264.png +52231.png +16292.png +27220.png +06022.png +07294.png +17605.png +57720.png +18707.png +38524.png +22767.png +41639.png +54372.png +20602.png +27169.png +56739.png +56991.png +07802.png +68644.png +20778.png +47924.png +41119.png +12633.png +08942.png +18146.png +54241.png +61737.png +55931.png +46206.png +60571.png +36833.png +35764.png +05539.png +65779.png +69363.png +47952.png +09992.png +15895.png +45557.png +06244.png +20988.png +69522.png +45496.png +40022.png +31642.png +39766.png +06017.png +58017.png +43566.png +31262.png +43759.png +54801.png +66232.png +41147.png +66809.png +28858.png +45605.png +06782.png +30082.png +63550.png +03322.png +63657.png +14320.png +14330.png +51539.png +37035.png +51290.png +37331.png +23535.png +14968.png +59307.png +17807.png +69261.png +57783.png +57259.png +53342.png +20986.png +16497.png +05946.png +29909.png +63319.png +62060.png +23678.png +19357.png +20708.png +32322.png +20509.png +20562.png +15948.png +41471.png +06588.png +32811.png +01035.png +16121.png +45453.png +11053.png +43189.png +15364.png +32548.png +08270.png +29407.png +50532.png +54047.png +26605.png +56011.png +30479.png +27698.png +54358.png +01121.png +15840.png +26888.png +33248.png +10788.png +39447.png +40857.png +66263.png +58616.png +55197.png +48935.png +17805.png +29680.png +03512.png +29335.png +32028.png +26996.png +57040.png +41945.png +20450.png +09788.png +27837.png +33092.png +08371.png +69282.png +66145.png +63868.png +30076.png +19921.png +40599.png +35374.png +16703.png +62850.png +25228.png +48058.png +52274.png +59055.png +01604.png +35499.png +65752.png +57917.png +18202.png +01487.png +65933.png +27310.png +64782.png +34736.png +57748.png +37715.png +68970.png +63498.png +00563.png +02004.png +22661.png +60637.png +27710.png +25521.png +53852.png +06517.png +24387.png +26305.png +46960.png +62312.png +54671.png +16425.png +18994.png +42893.png +49704.png +43994.png +40025.png +38320.png +62256.png +47733.png +67276.png +50413.png +29109.png +55175.png +27092.png +66350.png +25215.png +07817.png +69146.png +10910.png +15928.png +50981.png +21268.png +21669.png +30916.png +20030.png +63835.png +30087.png +65195.png +54077.png +41722.png +45311.png +55983.png +52910.png +66896.png +42102.png +49953.png +29726.png +00534.png +65766.png +08194.png +15932.png +46469.png +37267.png +43814.png +61108.png +36337.png +01138.png +47852.png +46630.png +43456.png +23035.png +13468.png +26241.png +23896.png +41455.png +06283.png +25806.png +55336.png +44248.png +44164.png +31776.png +37838.png +64169.png +16028.png +37046.png +48980.png +49340.png +63901.png +11631.png +62708.png +57474.png +22279.png +17666.png +58907.png +01064.png +00070.png +38445.png +51316.png +35092.png +08696.png +02548.png +43298.png +02995.png +66486.png +08039.png +52758.png +02305.png +02234.png +56915.png +02060.png +16281.png +62813.png +46185.png +48708.png +25271.png +22399.png +14939.png +10604.png +46568.png +45349.png +60219.png +62412.png +60651.png +11915.png +10933.png +05862.png +53245.png +30191.png +69196.png +20411.png +06312.png +01688.png +23047.png +15961.png +02112.png +03420.png +59243.png +29769.png +53607.png +54822.png +54236.png +41364.png +04560.png +13345.png +40363.png +34748.png +62511.png +19117.png +08083.png +18413.png +49479.png +39299.png +43755.png +06324.png +67561.png +52092.png +26158.png +62719.png +35377.png +06023.png +19658.png +34843.png +65084.png +46035.png +09548.png +06541.png +68485.png +51768.png +28317.png +26130.png +60784.png +01348.png +64079.png +53438.png +16035.png +61588.png +60369.png +32889.png +03847.png +19041.png +49149.png +35572.png +00760.png +66922.png +20603.png +01639.png +41075.png +43591.png +64184.png +44267.png +65688.png +52423.png +64539.png +65251.png +36387.png +56616.png +27140.png +19199.png +54303.png +04250.png +51215.png +37445.png +39332.png +32995.png +57829.png +46631.png +50970.png +61616.png +68491.png +18421.png +61659.png +38035.png +58645.png +58274.png +47873.png +38263.png +69896.png +67509.png +59478.png +38387.png +54386.png +20733.png +20916.png +44310.png +57568.png +00684.png +04089.png +29148.png +40978.png +57684.png +18868.png +27069.png +25216.png +00348.png +58306.png +06702.png +58833.png +38023.png +28640.png +56412.png +06211.png +11695.png +53572.png +60881.png +06769.png +50179.png +13505.png +49658.png +41921.png +30677.png +47950.png +39250.png +11271.png +32696.png +45263.png +65837.png +22913.png +57887.png +60462.png +05253.png +56481.png +02129.png +37588.png +18252.png +63353.png +03979.png +08516.png +55100.png +61571.png +52957.png +56635.png +41007.png +13317.png +67098.png +51529.png +59231.png +42453.png +07282.png +64482.png +26680.png +58921.png +31866.png +59960.png +59652.png +63410.png +42260.png +10172.png +08373.png +60484.png +56372.png +35964.png +38108.png +00505.png +35742.png +51980.png +14658.png +11666.png +37052.png +45357.png +04315.png +46866.png +43138.png +03467.png +53406.png +20548.png +10526.png +48729.png +05460.png +49735.png +24801.png +43352.png +69689.png +40323.png +15299.png +09957.png +09006.png +69459.png +35861.png +58263.png +34322.png +08854.png +00218.png +57188.png +48537.png +65927.png +04900.png +32007.png +09872.png +08863.png +26401.png +67795.png +65918.png +11326.png +68149.png +05689.png +28731.png +55869.png +16494.png +12207.png +67180.png +68740.png +40533.png +51806.png +20853.png +58221.png +18125.png +04472.png +59626.png +14952.png +58138.png +40713.png +47984.png +68457.png +30651.png +32669.png +69027.png +45858.png +57873.png +04249.png +60340.png +29915.png +47461.png +67559.png +30117.png +19584.png +06711.png +49876.png +07896.png +04996.png +31059.png +35149.png +34923.png +67249.png +61642.png +37002.png +00441.png +25998.png +39547.png +37277.png +50206.png +57470.png +11846.png +46566.png +26416.png +58141.png +58330.png +09555.png +63623.png +62444.png +28126.png +06114.png +58052.png +11335.png +06624.png +27428.png +15462.png +15516.png +28726.png +13061.png +15988.png +59668.png +45386.png +17360.png +29212.png +54448.png +22035.png +40167.png +58475.png +25466.png +04637.png +04064.png +40341.png +47429.png +65273.png +45848.png +25697.png +22030.png +36554.png +24285.png +65697.png +35123.png +56064.png +16381.png +07080.png +00589.png +51662.png +13288.png +28165.png +60169.png +53711.png +54968.png +62604.png +31927.png +62234.png +25726.png +42730.png +28796.png +50788.png +58125.png +24566.png +09895.png +62844.png +46356.png +21628.png +21427.png +66244.png +45083.png +13070.png +11610.png +25868.png +38221.png +42541.png +56593.png +59295.png +35873.png +00579.png +29734.png +22281.png +13170.png +38054.png +47762.png +23761.png +23164.png +51457.png +65144.png +25654.png +36134.png +50227.png +15442.png +03306.png +12068.png +46896.png +66082.png +24175.png +10149.png +28840.png +43168.png +06156.png +21136.png +26961.png +11688.png +15387.png +41517.png +31145.png +42751.png +19785.png +19722.png +12098.png +22943.png +48126.png +64483.png +28875.png +28740.png +32748.png +35928.png +50363.png +63130.png +34824.png +31506.png +15153.png +33450.png +62866.png +33271.png +58726.png +09553.png +44828.png +63697.png +52611.png +46400.png +29429.png +64856.png +38103.png +12954.png +11901.png +03926.png +20148.png +68307.png +32946.png +14920.png +24706.png +62081.png +18494.png +63113.png +24446.png +31758.png +06391.png +04034.png +30594.png +62265.png +47593.png +58582.png +57483.png +12381.png +13241.png +05866.png +68383.png +09354.png +47284.png +44563.png +69418.png +08474.png +52052.png +29548.png +49299.png +07974.png +12105.png +01869.png +59684.png +11665.png +65191.png +25766.png +08718.png +20166.png +49741.png +22820.png +44805.png +23954.png +34165.png +29798.png +45630.png +43783.png +33958.png +12573.png +64810.png +27454.png +08165.png +36823.png +18051.png +26239.png +45834.png +39957.png +59168.png +04473.png +09064.png +65802.png +14117.png +02248.png +15523.png +31818.png +62395.png +39483.png +31809.png +09107.png +17094.png +32732.png +07292.png +26276.png +63155.png +62550.png +55152.png +69198.png +48644.png +46249.png +20121.png +28323.png +46403.png +32999.png +55037.png +66079.png +52919.png +59654.png +47450.png +48136.png +60221.png +35756.png +01563.png +62202.png +43027.png +28144.png +10078.png +67363.png +36676.png +49084.png +58509.png +15301.png +13532.png +18983.png +46160.png +52098.png +25100.png +46778.png +10169.png +24304.png +13284.png +52169.png +10912.png +17947.png +18077.png +14624.png +44065.png +34670.png +29518.png +33967.png +07971.png +34264.png +33227.png +02250.png +06397.png +33135.png +29855.png +51128.png +56371.png +22693.png +14493.png +17953.png +49682.png +07503.png +00453.png +55251.png +15157.png +62637.png +41602.png +39323.png +47856.png +19421.png +46193.png +49429.png +01690.png +63252.png +18489.png +42328.png +44315.png +68607.png +51298.png +05447.png +00051.png +43921.png +42216.png +05293.png +56107.png +52321.png +13606.png +34209.png +15077.png +61145.png +45257.png +26209.png +14365.png +02232.png +31614.png +20792.png +14129.png +42789.png +19803.png +08591.png +66916.png +45020.png +36308.png +51596.png +07955.png +53396.png +34978.png +10736.png +54478.png +33482.png +61337.png +65257.png +14175.png +11972.png +41557.png +33447.png +18128.png +04861.png +41738.png +49286.png +33123.png +42490.png +20705.png +10787.png +50192.png +04399.png +47632.png +13803.png +14582.png +68879.png +42005.png +67729.png +27192.png +55911.png +37615.png +08342.png +48596.png +15657.png +62816.png +44339.png +27578.png +62107.png +28930.png +06417.png +12038.png +67658.png +59549.png +10476.png +48365.png +19467.png +58262.png +42461.png +10711.png +21405.png +38785.png +44808.png +28122.png +54243.png +12253.png +02777.png +29600.png +29310.png +62656.png +02396.png +28995.png +42394.png +60452.png +06477.png +12438.png +07950.png +46680.png +39145.png +46379.png +29612.png +55125.png +64332.png +12909.png +46155.png +54364.png +33496.png +32524.png +60546.png +36314.png +41798.png +54969.png +29576.png +34819.png +17607.png +60317.png +39990.png +01256.png +61792.png +10371.png +05724.png +67579.png +00427.png +28127.png +43606.png +13879.png +08191.png +42393.png +12557.png +15312.png +64195.png +64731.png +06120.png +22664.png +06317.png +27492.png +60597.png +07181.png +01135.png +16195.png +11404.png +23202.png +48846.png +61702.png +46795.png +23402.png +56409.png +25498.png +07369.png +62168.png +45049.png +53083.png +30148.png +35909.png +29266.png +52361.png +00669.png +48548.png +57371.png +23145.png +33419.png +50018.png +63075.png +17705.png +21414.png +23359.png +65307.png +01694.png +12154.png +06616.png +26140.png +27024.png +68799.png +50122.png +09098.png +40710.png +14373.png +51713.png +28773.png +50225.png +47891.png +27678.png +09259.png +36037.png +61366.png +09296.png +43652.png +62716.png +09551.png +45560.png +15899.png +56789.png +04126.png +69305.png +08975.png +32292.png +48464.png +45260.png +35213.png +31985.png +40272.png +27554.png +22875.png +53029.png +20061.png +25755.png +39917.png +10599.png +32076.png +00591.png +26461.png +43217.png +30541.png +06922.png +35081.png +50140.png +11567.png +28149.png +28670.png +52016.png +35063.png +58354.png +05261.png +11192.png +50319.png +47985.png +31269.png +18720.png +32673.png +17848.png +51634.png +44948.png +21257.png +30571.png +62547.png +53641.png +13562.png +10324.png +35358.png +51685.png +46988.png +15321.png +29231.png +46958.png +04005.png +12788.png +23839.png +46174.png +13359.png +31138.png +60767.png +04547.png +56564.png +36816.png +20843.png +52709.png +61299.png +13283.png +03765.png +13322.png +36276.png +11444.png +40536.png +35424.png +05111.png +50912.png +33131.png +64492.png +04419.png +23975.png +19748.png +48252.png +64579.png +19173.png +21346.png +48514.png +49814.png +53675.png +18579.png +50709.png +15971.png +64900.png +11813.png +32522.png +31819.png +06944.png +46385.png +52435.png +09781.png +18842.png +11111.png +26278.png +47006.png +62830.png +12845.png +16232.png +30589.png +35786.png +62407.png +69560.png +57178.png +44010.png +48843.png +14059.png +64570.png +41903.png +11274.png +25034.png +50275.png +00107.png +18500.png +48966.png +08815.png +34955.png +18987.png +32927.png +21864.png +58435.png +31110.png +47192.png +40486.png +12520.png +11441.png +60670.png +33370.png +25881.png +31118.png +46310.png +07037.png +42089.png +19387.png +55417.png +46309.png +16282.png +04405.png +07186.png +02754.png +03745.png +62620.png +42118.png +52227.png +38638.png +63484.png +15174.png +58626.png +05240.png +55910.png +54233.png +68898.png +29611.png +56184.png +69050.png +56465.png +28408.png +15166.png +24657.png +38837.png +09210.png +54418.png +13780.png +13340.png +52101.png +41310.png +64992.png +48692.png +51194.png +28509.png +56068.png +21314.png +11407.png +27094.png +13264.png +33393.png +56154.png +21321.png +62832.png +51212.png +33754.png +55430.png +01157.png +20559.png +46386.png +33768.png +21203.png +46974.png +54707.png +20363.png +13525.png +24460.png +58429.png +58957.png +69034.png +15271.png +63074.png +46301.png +67602.png +07716.png +31617.png +37156.png +21078.png +25050.png +45053.png +19709.png +62775.png +15771.png +10219.png +47958.png +31003.png +36570.png +55473.png +33345.png +07421.png +62215.png +14489.png +26236.png +43270.png +08705.png +64179.png +54984.png +45454.png +55626.png +21899.png +15757.png +42369.png +18099.png +23724.png +10907.png +60474.png +53666.png +57571.png +58478.png +41356.png +26065.png +29837.png +20399.png +37610.png +34950.png +57107.png +01823.png +13489.png +37321.png +44531.png +53472.png +19064.png +39492.png +27423.png +66512.png +21248.png +43043.png +31541.png +54597.png +66874.png +21736.png +60263.png +62384.png +24307.png +63821.png +03781.png +66167.png +46768.png +07528.png +16706.png +09127.png +58347.png +09498.png +39522.png +62915.png +39718.png +48134.png +50847.png +00044.png +65362.png +50290.png +27040.png +07002.png +54944.png +18373.png +35337.png +54054.png +27134.png +57436.png +43435.png +59241.png +48565.png +64105.png +49524.png +14812.png +53564.png +65757.png +04920.png +31074.png +62082.png +57787.png +17871.png +42699.png +36209.png +26640.png +22355.png +03513.png +06309.png +00647.png +43108.png +09648.png +08390.png +12987.png +66369.png +24940.png +62565.png +02567.png +07519.png +09290.png +14768.png +20728.png +52981.png +59519.png +49409.png +55327.png +18096.png +63734.png +54552.png +45288.png +60449.png +34081.png +49371.png +13323.png +57019.png +00873.png +54806.png +02905.png +45041.png +21001.png +33655.png +27902.png +19913.png +05406.png +36528.png +28768.png +06444.png +44085.png +65589.png +13249.png +16166.png +41000.png +37128.png +22695.png +38771.png +21225.png +03532.png +04858.png +15200.png +64527.png +69191.png +55219.png +22366.png +03312.png +59733.png +53918.png +22131.png +62473.png +25954.png +67244.png +62584.png +22173.png +59877.png +12814.png +66042.png +00900.png +16215.png +47520.png +05330.png +32269.png +19961.png +63676.png +49779.png +17494.png +67877.png +14123.png +57313.png +62765.png +07840.png +10459.png +25711.png +46440.png +58527.png +37558.png +06554.png +59592.png +14393.png +17180.png +51538.png +65489.png +68800.png +23825.png +35769.png +44103.png +25638.png +22674.png +62798.png +20365.png +09159.png +15128.png +16712.png +53316.png +09473.png +44596.png +45835.png +30584.png +25909.png +27699.png +31132.png +67429.png +08784.png +55961.png +05628.png +12668.png +01194.png +01612.png +43956.png +42755.png +20398.png +11739.png +27177.png +07220.png +17641.png +31988.png +23947.png +12062.png +15552.png +50173.png +02147.png +66446.png +56167.png +17803.png +16862.png +54286.png +58924.png +41765.png +12622.png +22822.png +32104.png +00171.png +11379.png +61083.png +47290.png +61446.png +15359.png +33477.png +45266.png +65856.png +15210.png +56703.png +23949.png +30808.png +37141.png +68533.png +04855.png +54812.png +04397.png +67307.png +03338.png +30475.png +05787.png +51263.png +21033.png +65455.png +25083.png +25112.png +47035.png +01923.png +18779.png +42828.png +34760.png +68064.png +46962.png +14380.png +47102.png +38817.png +23346.png +63749.png +42433.png +27068.png +07882.png +67915.png +68986.png +32527.png +04151.png +03235.png +02246.png +68076.png +42951.png +29087.png +27321.png +45261.png +37841.png +40683.png +62105.png +57747.png +26098.png +02328.png +44263.png +07395.png +32459.png +40697.png +39490.png +18262.png +17439.png +35030.png +39507.png +48327.png +02891.png +33902.png +11559.png +22036.png +59291.png +64445.png +51451.png +11607.png +56921.png +52671.png +61298.png +14263.png +35540.png +55203.png +53268.png +65505.png +40916.png +03868.png +13354.png +33992.png +13920.png +21347.png +20492.png +61810.png +57717.png +12872.png +58659.png +54231.png +07961.png +60226.png +57877.png +23530.png +13545.png +44401.png +63635.png +64704.png +48633.png +55791.png +36327.png +23387.png +66344.png +44106.png +52728.png +06531.png +60932.png +34846.png +18561.png +30653.png +65935.png +44611.png +00726.png +16045.png +43218.png +69523.png +40708.png +64400.png +30036.png +40723.png +54692.png +30554.png +29490.png +32225.png +00683.png +32578.png +05172.png +58575.png +66215.png +05418.png +50237.png +37651.png +26831.png +28536.png +32690.png +12362.png +67403.png +08946.png +28893.png +29553.png +34590.png +15933.png +58599.png +36034.png +60353.png +65648.png +14606.png +05479.png +28183.png +30229.png +10435.png +34047.png +48621.png +00977.png +02231.png +60780.png +60383.png +59683.png +40356.png +35139.png +00329.png +22522.png +47903.png +63193.png +66959.png +16788.png +51914.png +39663.png +22384.png +17504.png +12953.png +46540.png +64696.png +61693.png +34996.png +35615.png +10102.png +28337.png +22673.png +60804.png +40241.png +41449.png +21727.png +04019.png +67712.png +58813.png +05353.png +37208.png +48477.png +17483.png +59224.png +17792.png +28786.png +38186.png +44317.png +66307.png +49203.png +25802.png +43738.png +59905.png +36331.png +27944.png +60445.png +08725.png +13561.png +69233.png +48639.png +67812.png +59527.png +37798.png +05387.png +12946.png +31260.png +12011.png +20097.png +18115.png +42675.png +16206.png +23900.png +18353.png +03481.png +31747.png +05230.png +63646.png +19177.png +42550.png +64861.png +69805.png +49568.png +63309.png +35300.png +22623.png +22052.png +53071.png +62918.png +32256.png +46089.png +21837.png +29655.png +67018.png +17510.png +21226.png +62435.png +48305.png +04964.png +44702.png +63588.png +63454.png +47651.png +49952.png +26703.png +03232.png +51722.png +66230.png +52784.png +04325.png +18011.png +57406.png +60522.png +08282.png +19977.png +32574.png +04515.png +66508.png +69656.png +24333.png +33536.png +39754.png +60209.png +47693.png +00274.png +28776.png +30592.png +66756.png +24745.png +23102.png +67508.png +44653.png +41488.png +64054.png +44100.png +04496.png +42674.png +69365.png +06002.png +69430.png +48823.png +66451.png +62046.png +34334.png +29302.png +22314.png +33846.png +19847.png +59734.png +51707.png +29137.png +53476.png +36558.png +52686.png +21552.png +65753.png +67976.png +48508.png +42970.png +48025.png +51411.png +45862.png +22183.png +51234.png +54209.png +01680.png +41819.png +30957.png +47410.png +48653.png +04246.png +25529.png +07508.png +42419.png +02647.png +64530.png +46978.png +26902.png +03200.png +11635.png +25323.png +61673.png +27295.png +20532.png +03622.png +19833.png +57444.png +10859.png +22187.png +24858.png +49423.png +59620.png +10357.png +32807.png +69389.png +22692.png +18082.png +30430.png +25698.png +26563.png +15725.png +14352.png +57816.png +43035.png +66362.png +21544.png +19834.png +16717.png +24423.png +36538.png +43171.png +29758.png +41637.png +34481.png +04319.png +40925.png +28287.png +22590.png +66846.png +08909.png +38446.png +47279.png +65259.png +03348.png +02015.png +19396.png +00891.png +06033.png +41366.png +07483.png +55922.png +08028.png +33741.png +05725.png +67878.png +11831.png +23023.png +21135.png +53375.png +13649.png +65184.png +32431.png +44827.png +48422.png +52706.png +43644.png +29367.png +69811.png +40074.png +63328.png +59250.png +59921.png +61057.png +51338.png +62049.png +26582.png +02664.png +48112.png +61777.png +64104.png +10166.png +42262.png +11123.png +57215.png +33564.png +31955.png +03643.png +52320.png +11039.png +54899.png +39936.png +52965.png +08096.png +00837.png +58836.png +36594.png +19511.png +19292.png +36838.png +45669.png +47979.png +15351.png +02595.png +48690.png +14541.png +42306.png +28608.png +65207.png +69586.png +09545.png +17305.png +24928.png +54083.png +01189.png +31230.png +42525.png +03685.png +14820.png +56079.png +63754.png +51816.png +41597.png +56614.png +25144.png +59762.png +07987.png +33348.png +58409.png +32422.png +46251.png +60487.png +68723.png +14258.png +28558.png +49567.png +15589.png +32678.png +49904.png +28848.png +00285.png +01733.png +69299.png +69469.png +24571.png +24283.png +66073.png +64009.png +14140.png +46172.png +65713.png +14114.png +44821.png +42213.png +04631.png +08190.png +08118.png +11090.png +33143.png +42417.png +45428.png +42595.png +57279.png +36878.png +28154.png +46414.png +20275.png +00414.png +03831.png +11645.png +66776.png +27037.png +56880.png +54696.png +69930.png +04464.png +44718.png +01407.png +02537.png +64888.png +19009.png +15491.png +50284.png +60180.png +06371.png +50434.png +02290.png +14265.png +63389.png +32478.png +68045.png +46370.png +09056.png +09654.png +15925.png +30348.png +05327.png +36393.png +20174.png +50254.png +30478.png +54345.png +33572.png +48148.png +32912.png +07692.png +66513.png +16955.png +14038.png +28292.png +66561.png +06908.png +06869.png +54636.png +29897.png +54268.png +62610.png +50638.png +58814.png +26440.png +33000.png +35695.png +11043.png +44513.png +29447.png +02861.png +54146.png +16411.png +67048.png +58438.png +30515.png +62088.png +20645.png +40914.png +55925.png +66559.png +17321.png +17820.png +59820.png +06550.png +14506.png +07302.png +07579.png +61192.png +24343.png +62871.png +51365.png +59681.png +66971.png +34353.png +15227.png +61086.png +04132.png +44312.png +57530.png +66431.png +66810.png +69569.png +49111.png +12791.png +60589.png +07953.png +04114.png +54935.png +62094.png +25104.png +18296.png +24506.png +08248.png +13427.png +05093.png +44036.png +17612.png +57902.png +58709.png +37213.png +09785.png +35129.png +09011.png +63668.png +63591.png +13400.png +65048.png +68875.png +16728.png +42347.png +04630.png +08184.png +20564.png +65524.png +21889.png +31489.png +34320.png +26746.png +25895.png +23160.png +36431.png +50756.png +28617.png +66400.png +19739.png +50071.png +07599.png +33190.png +68372.png +10563.png +30024.png +63997.png +01118.png +20473.png +40881.png +38923.png +34040.png +35019.png +45400.png +62552.png +23622.png +03895.png +30632.png +31970.png +50897.png +52835.png +39249.png +24922.png +16797.png +21661.png +44431.png +17886.png +31040.png +65560.png +30194.png +33568.png +60857.png +28949.png +05506.png +22083.png +52732.png +62966.png +59980.png +37917.png +27453.png +29559.png +04618.png +56747.png +34735.png +48985.png +32954.png +49773.png +02410.png +44536.png +29268.png +43952.png +09549.png +32325.png +48571.png +04655.png +20047.png +23715.png +44627.png +05090.png +57907.png +14434.png +49581.png +59343.png +69386.png +64667.png +66779.png +61312.png +61022.png +27535.png +29809.png +39949.png +29732.png +27153.png +12084.png +39317.png +03686.png +67599.png +08113.png +52159.png +00876.png +61793.png +14603.png +68808.png +09326.png +38766.png +59202.png +52807.png +50766.png +61069.png +13610.png +63368.png +66624.png +17975.png +07654.png +50379.png +07287.png +15787.png +12517.png +03266.png +22924.png +18949.png +25946.png +27083.png +22945.png +41969.png +52822.png +16560.png +58482.png +18211.png +49789.png +54781.png +01961.png +55992.png +43200.png +59907.png +19905.png +55617.png +10454.png +25155.png +15410.png +22166.png +32965.png +32648.png +03223.png +62581.png +14588.png +20099.png +14692.png +23567.png +51687.png +52540.png +11592.png +40891.png +19650.png +10948.png +13007.png +16189.png +35070.png +55403.png +26030.png +14347.png +10682.png +19423.png +49364.png +68417.png +41295.png +54103.png +18699.png +38422.png +03909.png +32565.png +64601.png +08900.png +54315.png +08239.png +06344.png +19890.png +01301.png +67756.png +14711.png +17823.png +52315.png +62616.png +51968.png +28535.png +56600.png +60407.png +06940.png +43001.png +07736.png +37352.png +57502.png +46949.png +04348.png +46416.png +31834.png +60273.png +52290.png +58808.png +33973.png +01592.png +59052.png +45457.png +19106.png +17207.png +14798.png +69320.png +02168.png +16863.png +62858.png +02701.png +13839.png +56929.png +25528.png +07157.png +18620.png +28757.png +38955.png +39263.png +29443.png +16184.png +19649.png +45890.png +58128.png +54444.png +37502.png +40324.png +18114.png +16103.png +12882.png +26225.png +00753.png +48323.png +45682.png +36261.png +56946.png +50262.png +20878.png +44433.png +64720.png +24134.png +18429.png +48656.png +11930.png +04918.png +09817.png +07091.png +23295.png +47366.png +67205.png +58130.png +39009.png +48355.png +64061.png +17451.png +36521.png +59040.png +50216.png +36805.png +01858.png +01742.png +01767.png +46890.png +13428.png +27309.png +59663.png +64647.png +12700.png +38279.png +18345.png +43011.png +37811.png +02730.png +61328.png +66888.png +44673.png +04085.png +17266.png +04529.png +35388.png +29685.png +33008.png +05846.png +55089.png +59606.png +48337.png +07360.png +36790.png +40269.png +56405.png +25725.png +45212.png +21020.png +30366.png +32810.png +02056.png +64546.png +52234.png +35790.png +37017.png +54254.png +61782.png +68077.png +16393.png +43334.png +59024.png +15535.png +32594.png +23313.png +34075.png +06917.png +40742.png +44446.png +19166.png +46211.png +34744.png +10396.png +52742.png +31711.png +28472.png +69557.png +24160.png +52241.png +09775.png +59912.png +52198.png +09073.png +49259.png +36169.png +09762.png +06185.png +44793.png +35048.png +19926.png +01778.png +50146.png +22055.png +20079.png +15808.png +43710.png +61635.png +60214.png +38047.png +28084.png +10092.png +63962.png +12648.png +12840.png +61707.png +20212.png +51317.png +60535.png +45203.png +65901.png +22470.png +59810.png +19568.png +13726.png +48584.png +23450.png +16503.png +52834.png +57665.png +41153.png +03593.png +24547.png +43448.png +44445.png +29643.png +05238.png +19034.png +68312.png +55547.png +62548.png +36433.png +55610.png +30301.png +65070.png +02818.png +65488.png +34958.png +30767.png +53156.png +12049.png +54909.png +63409.png +39995.png +01091.png +21139.png +07900.png +34089.png +20539.png +61715.png +24310.png +08811.png +64000.png +09901.png +61469.png +06513.png +62445.png +29908.png +52239.png +10659.png +68874.png +08865.png +53818.png +54740.png +18882.png +30680.png +16921.png +65405.png +12263.png +67028.png +50278.png +43412.png +54851.png +03553.png +68341.png +42136.png +65280.png +69144.png +01413.png +35111.png +29923.png +18909.png +45807.png +30374.png +31573.png +14540.png +24147.png +61315.png +07759.png +69243.png +61477.png +19512.png +50689.png +00682.png +32066.png +23017.png +39656.png +05350.png +26475.png +27056.png +17768.png +64261.png +23223.png +68987.png +15648.png +35664.png +08221.png +29390.png +01196.png +54946.png +44253.png +44534.png +69617.png +45786.png +35899.png +59600.png +57191.png +05987.png +06210.png +33791.png +23222.png +63456.png +50315.png +04409.png +52896.png +44655.png +55857.png +07270.png +15615.png +62751.png +39319.png +20703.png +20319.png +22273.png +17661.png +67152.png +18053.png +04588.png +06232.png +19332.png +04032.png +02171.png +57187.png +35583.png +07954.png +03112.png +35987.png +58161.png +34258.png +43565.png +08675.png +28918.png +00847.png +09936.png +17711.png +51996.png +18687.png +40994.png +00697.png +51963.png +63834.png +43681.png +41380.png +19720.png +54886.png +45342.png +40577.png +08485.png +22301.png +05852.png +29613.png +26204.png +56783.png +35530.png +42421.png +64110.png +54344.png +53182.png +00902.png +28687.png +37836.png +09054.png +40079.png +12869.png +33934.png +44158.png +40845.png +63249.png +62169.png +47594.png +62059.png +69750.png +31721.png +44125.png +59025.png +53816.png +10545.png +56254.png +50442.png +43522.png +31302.png +19822.png +30832.png +46056.png +34467.png +46133.png +10847.png +08967.png +63990.png +40817.png +02610.png +69780.png +68049.png +20928.png +08332.png +53440.png +63805.png +51691.png +50117.png +38587.png +10619.png +03994.png +45437.png +10305.png +12747.png +51465.png +09851.png +44326.png +51222.png +11769.png +40497.png +04870.png +63968.png +29849.png +63042.png +02513.png +31854.png +39182.png +61912.png +66587.png +43947.png +51877.png +43180.png +36995.png +69058.png +33585.png +47074.png +30925.png +07555.png +26170.png +28645.png +06720.png +48847.png +15011.png +26619.png +39498.png +66462.png +13254.png +10917.png +38256.png +34759.png +17145.png +45120.png +07550.png +07935.png +15938.png +39512.png +15908.png +60525.png +43029.png +22967.png +68326.png +58968.png +22611.png +30822.png +56676.png +61330.png +41217.png +34239.png +34820.png +27441.png +62420.png +20210.png +19045.png +26054.png +27396.png +18792.png +19707.png +20504.png +63206.png +09113.png +35088.png +63483.png +12014.png +58137.png +26019.png +46236.png +30817.png +31548.png +21762.png +08801.png +66580.png +65763.png +50015.png +27865.png +00559.png +09748.png +25067.png +00779.png +17253.png +45350.png +47022.png +43884.png +55496.png +03509.png +33653.png +32014.png +60115.png +19337.png +15001.png +55178.png +48649.png +67615.png +64652.png +51084.png +34616.png +02289.png +58577.png +31539.png +62418.png +59720.png +15172.png +50041.png +52553.png +15754.png +66380.png +69691.png +33755.png +46847.png +69676.png +11796.png +23689.png +69803.png +06817.png +31276.png +16422.png +24004.png +64230.png +13193.png +18188.png +68286.png +10406.png +08918.png +63061.png +43505.png +25722.png +51601.png +39246.png +38539.png +49369.png +09462.png +36374.png +51525.png +03535.png +21058.png +21578.png +63441.png +49800.png +11437.png +43445.png +28378.png +15805.png +43945.png +27480.png +59410.png +55177.png +42987.png +45147.png +57855.png +44427.png +09227.png +16461.png +40293.png +03853.png +22322.png +57857.png +09391.png +07636.png +18026.png +40813.png +46342.png +40917.png +01193.png +60971.png +08983.png +23846.png +31543.png +28283.png +12124.png +02751.png +04607.png +28107.png +12102.png +04791.png +60545.png +43433.png +60850.png +46977.png +48904.png +34837.png +55145.png +39142.png +08989.png +33297.png +68173.png +68736.png +28367.png +14363.png +60339.png +37389.png +00613.png +36244.png +28411.png +50048.png +34263.png +24608.png +60760.png +03005.png +58018.png +61902.png +20073.png +30302.png +63295.png +16839.png +17385.png +57695.png +26428.png +40905.png +44520.png +27460.png +01921.png +46727.png +28682.png +24088.png +33421.png +67081.png +64025.png +15553.png +38132.png +62386.png +02725.png +05873.png +57382.png +24417.png +42153.png +11209.png +45240.png +31737.png +49077.png +64545.png +52283.png +41048.png +19777.png +22984.png +00620.png +67722.png +54429.png +69173.png +39084.png +59181.png +68871.png +18962.png +06396.png +12956.png +47143.png +18387.png +04014.png +63003.png +53361.png +19223.png +34235.png +49257.png +36721.png +32632.png +51349.png +20191.png +52799.png +05985.png +12581.png +33864.png +06220.png +46716.png +32621.png +39876.png +27950.png +67731.png +25460.png +51325.png +64891.png +63189.png +04521.png +64423.png +28984.png +54581.png +21541.png +53921.png +16584.png +01787.png +10439.png +11146.png +46039.png +44235.png +10129.png +61129.png +42201.png +14570.png +29326.png +37183.png +31465.png +14583.png +56584.png +28407.png +01605.png +19082.png +62225.png +59159.png +31546.png +05148.png +49346.png +66292.png +44852.png +43584.png +23052.png +22791.png +62451.png +66424.png +19659.png +69505.png +39787.png +48915.png +31456.png +19479.png +04179.png +40253.png +30534.png +10799.png +45402.png +25989.png +23903.png +36136.png +36000.png +38280.png +50371.png +61951.png +24718.png +43835.png +16877.png +57491.png +25797.png +66021.png +44217.png +65736.png +34487.png +35721.png +62753.png +62057.png +46724.png +03914.png +68696.png +69563.png +68209.png +53118.png +55375.png +29686.png +15716.png +02659.png +23418.png +61379.png +22719.png +49004.png +10665.png +54048.png +12884.png +51647.png +01270.png +60261.png +16697.png +44292.png +53933.png +39933.png +04284.png +54897.png +27495.png +62783.png +58288.png +69550.png +17031.png +33201.png +35947.png +52969.png +27641.png +26990.png +00129.png +17908.png +40892.png +20693.png +00778.png +68674.png +17254.png +13032.png +23810.png +15923.png +32921.png +43737.png +61137.png +01097.png +00956.png +11347.png +14239.png +34687.png +58801.png +68616.png +12948.png +30355.png +63985.png +54757.png +34198.png +40762.png +18195.png +22953.png +65318.png +07495.png +54981.png +53304.png +03888.png +39491.png +22844.png +44806.png +15395.png +38814.png +22618.png +33434.png +38236.png +49571.png +40660.png +60785.png +15809.png +28443.png +35275.png +25063.png +09289.png +12110.png +68589.png +57971.png +53982.png +44840.png +03571.png +02466.png +46826.png +48678.png +58204.png +50079.png +07856.png +05096.png +36450.png +22716.png +50040.png +64577.png +52225.png +48642.png +29669.png +40806.png +15723.png +54574.png +50547.png +46509.png +41061.png +44842.png +53677.png +05163.png +61630.png +21929.png +18164.png +40612.png +65300.png +13090.png +19297.png +00009.png +06484.png +69573.png +31891.png +54555.png +29488.png +55748.png +24142.png +43936.png +50361.png +44316.png +05623.png +62843.png +54923.png +65012.png +65395.png +41078.png +50066.png +07560.png +43071.png +56835.png +18346.png +37229.png +07079.png +30243.png +40716.png +63595.png +46029.png +45599.png +39004.png +41079.png +31348.png +44970.png +54205.png +34454.png +35286.png +12816.png +56812.png +46653.png +34448.png +02176.png +51556.png +60079.png +68729.png +22971.png +63213.png +22589.png +52330.png +54922.png +21742.png +33312.png +69398.png +04042.png +18329.png +57153.png +56098.png +62826.png +67145.png +09240.png +29426.png +52141.png +48682.png +42731.png +16860.png +59408.png +38543.png +68387.png +18659.png +32479.png +21090.png +50642.png +51468.png +24653.png +08348.png +69633.png +61656.png +14655.png +45947.png +09061.png +09878.png +59311.png +16594.png +34114.png +52959.png +43787.png +16646.png +54551.png +19609.png +26895.png +51913.png +21625.png +18475.png +39279.png +69077.png +67016.png +08359.png +34373.png +10464.png +17118.png +07918.png +66645.png +03106.png +10813.png +41260.png +37419.png +68164.png +50387.png +27603.png +15645.png +08625.png +66997.png +26270.png +28642.png +65411.png +35411.png +21008.png +09471.png +25461.png +65211.png +37737.png +41604.png +43483.png +00729.png +14145.png +47221.png +68976.png +52150.png +54732.png +12862.png +41636.png +29111.png +50375.png +69339.png +56190.png +07769.png +55027.png +01510.png +41767.png +25799.png +61491.png +19196.png +10441.png +02589.png +24875.png +52406.png +36626.png +50243.png +19881.png +08846.png +34274.png +35010.png +39554.png +52760.png +12460.png +28206.png +17481.png +59105.png +63636.png +51555.png +01402.png +42820.png +38298.png +41130.png +30486.png +69626.png +42668.png +13312.png +54563.png +51917.png +42704.png +13919.png +32659.png +45719.png +48825.png +54653.png +47712.png +05017.png +64781.png +62891.png +23929.png +68408.png +24628.png +09372.png +27850.png +40591.png +23191.png +69786.png +55143.png +36641.png +22537.png +13771.png +32859.png +64164.png +44429.png +41629.png +41259.png +00392.png +20724.png +59375.png +65082.png +56229.png +45731.png +68765.png +21175.png +16799.png +40695.png +37587.png +46240.png +27117.png +41650.png +47533.png +54505.png +02142.png +66261.png +56893.png +20919.png +14386.png +34983.png +27402.png +47758.png +65216.png +20015.png +25450.png +01734.png +50369.png +02082.png +38693.png +02419.png +04817.png +16900.png +43220.png +61418.png +51835.png +59503.png +09789.png +57413.png +57260.png +44838.png +62358.png +44082.png +63634.png +20020.png +17790.png +29745.png +58057.png +04831.png +24116.png +00155.png +17929.png +01747.png +18667.png +35321.png +10499.png +60839.png +29581.png +36876.png +44856.png +44194.png +57512.png +46880.png +04135.png +12808.png +47020.png +00731.png +45771.png +08847.png +50470.png +27303.png +25531.png +33276.png +47560.png +42192.png +38403.png +25913.png +12149.png +20241.png +01314.png +16496.png +40571.png +41195.png +43772.png +46136.png +27692.png +30929.png +63314.png +30538.png +69217.png +07641.png +02760.png +00791.png +30387.png +21307.png +50618.png +48956.png +62854.png +39748.png +43183.png +58095.png +17346.png +50700.png +41963.png +06194.png +28486.png +60127.png +65578.png +54865.png +66945.png +54545.png +10821.png +26372.png +33309.png +66921.png +14030.png +22162.png +62207.png +00012.png +50466.png +00111.png +54425.png +07943.png +19587.png +12288.png +36613.png +59129.png +29199.png +64097.png +29935.png +38826.png +39493.png +46719.png +07410.png +04429.png +58255.png +14022.png +08266.png +44706.png +04428.png +01614.png +11923.png +20561.png +05239.png +19271.png +23056.png +66880.png +19017.png +22962.png +29277.png +35560.png +64890.png +41033.png +50032.png +01341.png +22794.png +51075.png +18495.png +38112.png +31878.png +46589.png +57895.png +07030.png +51419.png +35320.png +57000.png +63822.png +62069.png +29843.png +51595.png +33610.png +43594.png +20526.png +38441.png +17375.png +27415.png +19684.png +35295.png +14253.png +66124.png +28239.png +60777.png +42822.png +63885.png +69876.png +51934.png +14462.png +02560.png +14946.png +59028.png +18298.png +51100.png +52259.png +08636.png +66217.png +37991.png +55581.png +43277.png +05161.png +28271.png +46889.png +05617.png +21979.png +66418.png +59705.png +67964.png +32108.png +21367.png +26557.png +00083.png +21462.png +31952.png +12169.png +08465.png +26064.png +52308.png +55692.png +43779.png +69228.png +12489.png +48856.png +64525.png +49724.png +09092.png +48784.png +19294.png +41041.png +14093.png +50888.png +62522.png +02914.png +21694.png +14793.png +42850.png +50729.png +06609.png +42130.png +10877.png +40551.png +23385.png +64032.png +35466.png +38218.png +00376.png +62067.png +39673.png +51218.png +59075.png +42497.png +23792.png +67933.png +20361.png +05544.png +44505.png +25182.png +06005.png +28332.png +64665.png +26867.png +09187.png +15281.png +59624.png +21800.png +27896.png +61139.png +02046.png +01273.png +59167.png +13967.png +09403.png +63768.png +06385.png +02336.png +28151.png +40584.png +47088.png +51324.png +36905.png +06851.png +49840.png +02313.png +25581.png +14262.png +31599.png +51827.png +29230.png +15601.png +26728.png +24522.png +55415.png +22068.png +56886.png +17166.png +47729.png +68121.png +03801.png +34376.png +26145.png +27393.png +58470.png +11342.png +06443.png +20885.png +32138.png +33293.png +42403.png +59816.png +22535.png +53764.png +07867.png +63969.png +01056.png +15393.png +19815.png +35778.png +32415.png +19437.png +28606.png +28672.png +45181.png +34586.png +34841.png +32247.png +62325.png +24189.png +48612.png +69230.png +62073.png +65451.png +32596.png +10864.png +35773.png +06753.png +61738.png +62335.png +28548.png +51124.png +44579.png +56283.png +41131.png +22270.png +61262.png +02948.png +39705.png +57070.png +63780.png +37430.png +14040.png +21656.png +52928.png +53067.png +33952.png +43601.png +53835.png +62962.png +12101.png +49076.png +22472.png +09631.png +67272.png +50485.png +16614.png +42927.png +21272.png +26568.png +05407.png +08054.png +64039.png +54093.png +31744.png +49758.png +68557.png +46838.png +03072.png +22758.png +62651.png +27219.png +38680.png +33117.png +20654.png +23383.png +45673.png +09352.png +39363.png +33607.png +29334.png +47458.png +20573.png +66327.png +62961.png +21488.png +25177.png +09404.png +58451.png +58695.png +30265.png +63756.png +40465.png +30685.png +26081.png +60398.png +27271.png +19627.png +01895.png +39489.png +48286.png +68700.png +57482.png +26609.png +03286.png +48638.png +09427.png +10500.png +57519.png +21420.png +03674.png +67449.png +27170.png +67643.png +37254.png +65256.png +51671.png +09400.png +61544.png +36514.png +66371.png +55015.png +67089.png +07365.png +18027.png +65949.png +30010.png +48666.png +10697.png +63152.png +62043.png +61991.png +31347.png +02149.png +63574.png +58752.png +21025.png +69116.png +32180.png +65422.png +36388.png +21434.png +49507.png +55077.png +24658.png +49246.png +49206.png +09712.png +25841.png +67920.png +08704.png +68573.png +01362.png +68460.png +12888.png +58790.png +32998.png +02617.png +40203.png +10014.png +09587.png +04991.png +49933.png +01849.png +08822.png +39716.png +65824.png +16555.png +02066.png +62922.png +00517.png +11451.png +22999.png +52995.png +49886.png +66953.png +04891.png +22147.png +27350.png +48848.png +58662.png +28289.png +06135.png +57981.png +33407.png +60668.png +05545.png +31652.png +35836.png +36763.png +07497.png +40233.png +46201.png +67505.png +52256.png +23990.png +31471.png +59640.png +03603.png +07749.png +23661.png +57563.png +07775.png +54747.png +36891.png +43948.png +06523.png +38074.png +58867.png +11773.png +41418.png +44958.png +55372.png +05771.png +26691.png +12496.png +63776.png +47525.png +69567.png +16328.png +33631.png +05601.png +55810.png +03658.png +45385.png +21867.png +55023.png +56674.png +67138.png +21317.png +56174.png +24382.png +51426.png +42759.png +62561.png +50186.png +06935.png +11942.png +49312.png +26127.png +50956.png +33229.png +17027.png +22616.png +33301.png +62189.png +39991.png +14053.png +56287.png +27226.png +17492.png +35497.png +48601.png +09774.png +46244.png +29304.png +19356.png +41580.png +19445.png +21944.png +28248.png +52944.png +02573.png +58410.png +67313.png +56105.png +61591.png +54736.png +02665.png +53431.png +39677.png +52297.png +28320.png +15475.png +01367.png +33795.png +05575.png +16776.png +47698.png +47012.png +39056.png +14749.png +35804.png +24961.png +63979.png +38773.png +39343.png +69124.png +36821.png +54036.png +14207.png +50133.png +12734.png +22624.png +29031.png +27735.png +41900.png +23707.png +48181.png +64282.png +33726.png +25137.png +42950.png +02427.png +50280.png +43276.png +35685.png +24721.png +31436.png +02553.png +41742.png +51256.png +01154.png +50089.png +59556.png +62304.png +29332.png +55944.png +29630.png +40415.png +10333.png +45891.png +22995.png +32067.png +12329.png +54751.png +07127.png +14269.png +19377.png +54989.png +22327.png +29953.png +37250.png +10970.png +14688.png +56837.png +39151.png +23988.png +24020.png +42014.png +19768.png +01007.png +67321.png +55097.png +02735.png +19123.png +66750.png +31469.png +02310.png +07244.png +19782.png +39534.png +58277.png +57547.png +39158.png +09659.png +50056.png +65185.png +09527.png +08681.png +50947.png +28702.png +40044.png +49225.png +58004.png +21275.png +22641.png +42364.png +50232.png +49496.png +04856.png +13239.png +39590.png +09051.png +62361.png +01700.png +67451.png +52933.png +03327.png +08166.png +06773.png +33410.png +52741.png +31134.png +03907.png +53471.png +21141.png +32924.png +08352.png +33051.png +45551.png +27489.png +43778.png +18916.png +46942.png +35441.png +38334.png +50724.png +38778.png +39167.png +32155.png +12254.png +53855.png +50748.png +09868.png +06863.png +37233.png +22786.png +66811.png +47775.png +65213.png +32971.png +17926.png +39315.png +59337.png +00903.png +31805.png +68938.png +34470.png +04470.png +53984.png +60618.png +34825.png +44241.png +00278.png +25264.png +67265.png +50047.png +38436.png +25419.png +46084.png +32750.png +14970.png +26240.png +33189.png +29598.png +32783.png +11458.png +27086.png +52506.png +40781.png +64884.png +04596.png +66741.png +35084.png +64233.png +31177.png +61626.png +45665.png +31000.png +13299.png +65592.png +56612.png +57825.png +35626.png +32202.png +36979.png +10758.png +26253.png +65556.png +16737.png +26694.png +45214.png +50574.png +19490.png +60167.png +60849.png +24703.png +23488.png +60656.png +63375.png +57292.png +58179.png +52978.png +56651.png +45787.png +53967.png +20091.png +11560.png +57285.png +32228.png +65884.png +56856.png +55132.png +28278.png +15349.png +69486.png +04044.png +25537.png +02906.png +11324.png +43694.png +36968.png +66733.png +51405.png +39511.png +04559.png +24771.png +36234.png +16682.png +20888.png +47452.png +10581.png +40073.png +41246.png +38664.png +02644.png +55292.png +65890.png +20947.png +20865.png +39898.png +02942.png +14430.png +02158.png +62129.png +45148.png +45688.png +30573.png +47190.png +33339.png +53887.png +19035.png +21335.png +03344.png +12360.png +27835.png +61322.png +58587.png +42693.png +40567.png +61674.png +33907.png +58185.png +41126.png +38212.png +53426.png +65162.png +32157.png +10487.png +03038.png +59595.png +67827.png +63106.png +13452.png +36588.png +43021.png +56791.png +03551.png +63129.png +32110.png +63445.png +68946.png +54155.png +63312.png +63057.png +02810.png +55269.png +37221.png +05046.png +27596.png +28100.png +57850.png +39169.png +24108.png +00066.png +64080.png +00231.png +01443.png +59642.png +69737.png +07824.png +39485.png +62780.png +26332.png +23242.png +30385.png +24348.png +34351.png +35505.png +51024.png +19304.png +08986.png +46846.png +48771.png +65547.png +43359.png +61691.png +49891.png +26325.png +55552.png +64798.png +35191.png +36843.png +27483.png +62679.png +32692.png +28418.png +65655.png +68606.png +49238.png +05316.png +18683.png +56448.png +55188.png +54743.png +60286.png +56205.png +41539.png +59915.png +28869.png +16297.png +40284.png +51541.png +39579.png +50644.png +49671.png +66231.png +19098.png +08879.png +66063.png +49562.png +58363.png +12709.png +66338.png +23284.png +05011.png +13535.png +15042.png +54734.png +10432.png +44782.png +00643.png +35028.png +55450.png +01650.png +25115.png +34599.png +65812.png +59579.png +39098.png +01974.png +41859.png +63015.png +63472.png +45296.png +30794.png +02302.png +48754.png +15399.png +51669.png +39764.png +08754.png +05877.png +12487.png +04868.png +27163.png +10413.png +51674.png +35688.png +68026.png +01899.png +52077.png +44604.png +33101.png +25614.png +37056.png +24148.png +37107.png +68849.png +42916.png +65325.png +05625.png +33778.png +57677.png +41603.png +47996.png +36440.png +61505.png +50975.png +10143.png +10332.png +14319.png +30290.png +23491.png +46215.png +25867.png +62460.png +16264.png +35946.png +11056.png +39228.png +34436.png +10616.png +19498.png +01083.png +36875.png +64700.png +61581.png +44616.png +03209.png +58538.png +67051.png +01644.png +50098.png +48007.png +26043.png +46878.png +69768.png +29180.png +67800.png +52821.png +08765.png +10710.png +31569.png +48931.png +44586.png +40763.png +68732.png +24111.png +09923.png +47187.png +29902.png +06051.png +62941.png +30933.png +53617.png +49550.png +41989.png +54843.png +40491.png +16468.png +01283.png +06647.png +15692.png +48224.png +28043.png +65692.png +48083.png +69865.png +11009.png +41680.png +31325.png +42183.png +36239.png +24788.png +67479.png +65419.png +17862.png +56671.png +27900.png +20871.png +44801.png +19179.png +16710.png +38585.png +26047.png +25750.png +11133.png +17836.png +46009.png +27074.png +22310.png +01199.png +37165.png +30692.png +19743.png +60264.png +55769.png +23582.png +22283.png +52645.png +47075.png +23417.png +54267.png +30042.png +14550.png +53416.png +17785.png +44603.png +39426.png +54864.png +06839.png +42144.png +04084.png +39782.png +18636.png +67725.png +62408.png +03234.png +23381.png +62909.png +45522.png +04619.png +01698.png +13944.png +29070.png +68488.png +33264.png +63403.png +29550.png +14136.png +45617.png +18930.png +34614.png +68217.png +46564.png +31635.png +04441.png +13663.png +58993.png +30778.png +59864.png +49183.png +26345.png +67742.png +04119.png +48611.png +12274.png +52024.png +44881.png +28654.png +44408.png +11999.png +55396.png +03790.png +50585.png +07083.png +44647.png +43272.png +12852.png +01749.png +38375.png +63357.png +29921.png +53630.png +21657.png +24101.png +62977.png +45844.png +34450.png +23136.png +68771.png +23426.png +11305.png +35331.png +21688.png +11311.png +00175.png +17741.png +02879.png +01973.png +40878.png +51609.png +51312.png +13798.png +32849.png +63908.png +63442.png +08862.png +54955.png +08851.png +54797.png +46006.png +29085.png +07551.png +42040.png +58109.png +53214.png +45813.png +28545.png +12304.png +69967.png +56173.png +46183.png +58239.png +27204.png +34727.png +44124.png +39013.png +00720.png +49494.png +62999.png +17523.png +15581.png +22550.png +18973.png +22489.png +41676.png +21117.png +30315.png +32658.png +14495.png +34666.png +55164.png +43756.png +63288.png +46534.png +37412.png +17710.png +55213.png +12535.png +63490.png +32156.png +23116.png +05528.png +35200.png +00536.png +00045.png +11020.png +58525.png +52226.png +50347.png +66694.png +49074.png +66666.png +07329.png +45410.png +62880.png +19773.png +37375.png +68657.png +34544.png +33597.png +31729.png +10819.png +09076.png +07306.png +45865.png +13052.png +12594.png +07601.png +02453.png +01144.png +38356.png +62403.png +30870.png +63255.png +19668.png +54826.png +29084.png +16509.png +13575.png +60328.png +04525.png +25527.png +15886.png +38282.png +50062.png +47246.png +48938.png +03684.png +64554.png +65840.png +39937.png +09025.png +29516.png +63228.png +38572.png +47481.png +10310.png +01247.png +45812.png +11141.png +64935.png +61996.png +44678.png +26109.png +41258.png +36133.png +10095.png +26593.png +38264.png +10974.png +26146.png +53639.png +05933.png +04841.png +60306.png +65686.png +28614.png +08243.png +03011.png +60181.png +41887.png +59501.png +04241.png +39063.png +28188.png +24797.png +22220.png +29931.png +61939.png +46436.png +12659.png +29848.png +24551.png +64533.png +12275.png +41734.png +13266.png +28328.png +46951.png +01363.png +18719.png +34721.png +31183.png +66407.png +62867.png +48681.png +21128.png +32804.png +49700.png +54870.png +35654.png +43130.png +40559.png +27429.png +09671.png +34880.png +39181.png +41530.png +47578.png +35557.png +37972.png +38918.png +62609.png +39240.png +25620.png +63465.png +19355.png +56801.png +03094.png +02063.png +33047.png +40125.png +42100.png +51559.png +37222.png +19715.png +13294.png +57988.png +10645.png +35976.png +18811.png +39440.png +50822.png +60173.png +12057.png +14795.png +28376.png +41034.png +05037.png +66198.png +05453.png +52143.png +00270.png +34936.png +36131.png +08401.png +36497.png +20274.png +14276.png +21082.png +26304.png +16091.png +41905.png +17231.png +60584.png +04990.png +11409.png +60560.png +19933.png +15331.png +60506.png +38831.png +25554.png +22718.png +31370.png +04323.png +52930.png +30772.png +61519.png +28800.png +15221.png +05168.png +18664.png +36956.png +27684.png +53215.png +33766.png +46488.png +20247.png +27521.png +48026.png +67219.png +61154.png +69961.png +45527.png +55712.png +31246.png +06262.png +15538.png +56588.png +39955.png +26037.png +41595.png +21839.png +28390.png +69246.png +24477.png +16095.png +35669.png +18440.png +17865.png +69904.png +31164.png +07559.png +02996.png +60581.png +13320.png +65013.png +63564.png +21332.png +60254.png +32279.png +52072.png +17390.png +12240.png +29993.png +14936.png +47566.png +41403.png +50221.png +53099.png +29322.png +17193.png +45459.png +29521.png +28932.png +22647.png +36062.png +08434.png +29698.png +31478.png +63510.png +07257.png +10841.png +63451.png +28341.png +41503.png +59567.png +12005.png +51750.png +17034.png +60609.png +45593.png +59713.png +40414.png +20538.png +54079.png +60299.png +50723.png +26414.png +03760.png +53851.png +54769.png +03228.png +59692.png +26027.png +65565.png +16346.png +13959.png +44141.png +13743.png +58316.png +00748.png +11640.png +04970.png +29504.png +36615.png +48412.png +63427.png +46451.png +34363.png +45138.png +09136.png +57664.png +44941.png +59853.png +56148.png +12750.png +31724.png +60882.png +14394.png +27907.png +30899.png +06822.png +16359.png +22746.png +41692.png +63425.png +27878.png +30318.png +25523.png +45971.png +21382.png +59174.png +39186.png +09003.png +32352.png +40900.png +47895.png +27819.png +05204.png +11881.png +04561.png +12789.png +63352.png +18120.png +05123.png +48478.png +65754.png +27488.png +60867.png +15732.png +12951.png +05968.png +03050.png +23211.png +66761.png +30395.png +21473.png +19908.png +21881.png +35612.png +06564.png +22680.png +14315.png +21221.png +16420.png +57671.png +54849.png +62041.png +34777.png +67819.png +22606.png +02895.png +32788.png +59855.png +60135.png +64199.png +36618.png +59603.png +23639.png +39441.png +04219.png +44659.png +34381.png +41009.png +07647.png +39503.png +62269.png +07523.png +13161.png +13030.png +49443.png +04175.png +50837.png +42742.png +59170.png +68195.png +66849.png +18071.png +33924.png +30248.png +08388.png +62885.png +32390.png +38618.png +05311.png +53501.png +15328.png +49543.png +15317.png +18324.png +14911.png +28868.png +60196.png +51573.png +21938.png +54299.png +33022.png +08402.png +03633.png +57146.png +21634.png +43854.png +42072.png +03572.png +42073.png +55401.png +62319.png +06532.png +61377.png +61744.png +43026.png +08154.png +02992.png +42998.png +24383.png +38830.png +09018.png +13693.png +25965.png +26221.png +00877.png +01894.png +22968.png +11406.png +60712.png +34800.png +32839.png +51361.png +49732.png +37091.png +38224.png +25311.png +48061.png +35221.png +16070.png +05878.png +63014.png +22521.png +17431.png +51994.png +25507.png +15561.png +39144.png +31813.png +48807.png +51551.png +22345.png +27645.png +67779.png +17307.png +08748.png +02976.png +11264.png +62884.png +56601.png +58131.png +04099.png +15483.png +59297.png +69653.png +42151.png +22423.png +24560.png +50050.png +60013.png +60831.png +53792.png +46560.png +10175.png +21271.png +25206.png +11511.png +31773.png +25988.png +03639.png +09097.png +36665.png +38534.png +53469.png +13278.png +19531.png +23163.png +10795.png +12656.png +57174.png +63110.png +65911.png +06167.png +10693.png +63631.png +47572.png +10654.png +20242.png +16610.png +18893.png +08087.png +69249.png +40545.png +38650.png +35879.png +47403.png +41746.png +01492.png +17970.png +20948.png +24720.png +33070.png +01791.png +33838.png +33471.png +20770.png +12464.png +52653.png +55407.png +09804.png +41406.png +35659.png +08606.png +08183.png +12220.png +46011.png +03484.png +05100.png +50524.png +31455.png +33178.png +12052.png +19967.png +00355.png +54949.png +55466.png +05822.png +32227.png +14468.png +55076.png +61451.png +43202.png +47334.png +66961.png +52384.png +01730.png +15439.png +63372.png +63253.png +67166.png +16482.png +27890.png +39635.png +29456.png +05133.png +06878.png +13598.png +68103.png +52668.png +51760.png +29747.png +59264.png +36035.png +12419.png +00997.png +40262.png +44051.png +62698.png +53128.png +66458.png +36077.png +57123.png +61759.png +27392.png +64155.png +29782.png +12491.png +25114.png +45348.png +55631.png +67039.png +22108.png +26111.png +32477.png +10057.png +59708.png +44957.png +64651.png +31995.png +01242.png +20024.png +13013.png +41613.png +47068.png +50659.png +02245.png +06408.png +60430.png +17436.png +01994.png +33694.png +63869.png +63769.png +41594.png +16978.png +63542.png +14318.png +64862.png +62405.png +11855.png +47032.png +65951.png +16926.png +02681.png +16345.png +17964.png +34179.png +36505.png +25655.png +64686.png +64801.png +47595.png +59616.png +22959.png +20613.png +66695.png +33715.png +16253.png +41654.png +24623.png +13226.png +55299.png +57952.png +01756.png +35663.png +53295.png +28312.png +66388.png +69520.png +17060.png +02005.png +06188.png +22037.png +66989.png +34637.png +29888.png +66769.png +23546.png +06141.png +15046.png +37699.png +47303.png +55947.png +18457.png +28526.png +06677.png +42983.png +24606.png +50417.png +19386.png +44061.png +37772.png +46330.png +69775.png +00604.png +31850.png +08069.png +18193.png +41661.png +45517.png +31523.png +38887.png +23899.png +50396.png +67116.png +66092.png +54323.png +54194.png +10081.png +16922.png +34763.png +56511.png +16300.png +43396.png +29126.png +32065.png +51657.png +64803.png +46192.png +20223.png +44938.png +31189.png +27529.png +24505.png +28727.png +28964.png +37460.png +44764.png +26083.png +11423.png +11374.png +03959.png +08680.png +47844.png +22787.png +11790.png +25736.png +33474.png +19676.png +31079.png +50265.png +17949.png +24243.png +14071.png +45685.png +17899.png +44574.png +00473.png +32610.png +54082.png +55510.png +63356.png +14332.png +11340.png +16499.png +10738.png +00696.png +56040.png +58684.png +26007.png +58710.png +07995.png +02714.png +47598.png +29961.png +54996.png +55575.png +25675.png +15609.png +12003.png +58379.png +06902.png +48130.png +34207.png +04992.png +66895.png +44709.png +50731.png +52866.png +63667.png +38025.png +46171.png +11486.png +40824.png +50460.png +32197.png +23522.png +30660.png +27948.png +05048.png +45416.png +04889.png +32468.png +09480.png +27363.png +52216.png +27841.png +50509.png +07712.png +09164.png +28829.png +34033.png +14406.png +04505.png +15306.png +23055.png +51523.png +38557.png +19250.png +64883.png +64672.png +39570.png +42573.png +16798.png +67984.png +06865.png +49439.png +50028.png +01183.png +24047.png +15728.png +53034.png +11953.png +40315.png +67450.png +19158.png +29094.png +61089.png +47241.png +14851.png +23681.png +19758.png +30026.png +66376.png +66605.png +13834.png +62192.png +41423.png +12373.png +21991.png +12456.png +60087.png +43414.png +69051.png +38466.png +21872.png +45632.png +04022.png +63477.png +28758.png +04134.png +50633.png +00221.png +07885.png +47876.png +08060.png +35677.png +11105.png +35194.png +19138.png +11314.png +26588.png +27078.png +13770.png +44919.png +52829.png +17052.png +61422.png +15673.png +54889.png +51358.png +33084.png +07747.png +11267.png +26126.png +29942.png +38996.png +60021.png +12980.png +36125.png +36408.png +03090.png +02933.png +53315.png +13646.png +58196.png +04329.png +59552.png +59935.png +53934.png +44857.png +35188.png +11510.png +03352.png +26909.png +62161.png +59574.png +66349.png +59993.png +22458.png +54297.png +53251.png +61233.png +14554.png +31122.png +02207.png +61212.png +34806.png +37069.png +44921.png +12285.png +14100.png +18942.png +14917.png +25151.png +66868.png +16136.png +20078.png +32091.png +15014.png +34762.png +67467.png +42296.png +04685.png +15786.png +23124.png +63170.png +40810.png +02213.png +08098.png +14589.png +55257.png +65230.png +25571.png +21265.png +43111.png +49187.png +04160.png +21683.png +58439.png +18558.png +40949.png +68464.png +03400.png +49214.png +28300.png +29751.png +12815.png +17732.png +08829.png +13806.png +00945.png +00121.png +11943.png +00053.png +40401.png +54178.png +54811.png +26438.png +26953.png +03026.png +26110.png +09899.png +57439.png +31706.png +48453.png +11600.png +40319.png +45929.png +14107.png +06070.png +23490.png +31510.png +67736.png +61714.png +13750.png +11596.png +51992.png +02864.png +69060.png +69951.png +36936.png +27598.png +34991.png +07489.png +38259.png +66240.png +46350.png +53127.png +08132.png +68790.png +48144.png +10097.png +47184.png +14422.png +11001.png +49058.png +46326.png +66439.png +03066.png +57113.png +23934.png +61541.png +43122.png +03958.png +50892.png +44275.png +44453.png +26415.png +10365.png +64607.png +36464.png +41268.png +65055.png +21606.png +00543.png +30235.png +45486.png +12396.png +57068.png +06975.png +03851.png +28500.png +60553.png +64112.png +04275.png +60860.png +05107.png +24050.png +26583.png +06426.png +02847.png +05546.png +56298.png +02968.png +58112.png +55777.png +58845.png +08551.png +45910.png +32359.png +54764.png +13107.png +26347.png +55873.png +61809.png +59323.png +35593.png +26247.png +62164.png +40480.png +60514.png +30095.png +64619.png +13262.png +61733.png +57795.png +59356.png +53964.png +34852.png +25908.png +25026.png +53976.png +29336.png +25338.png +25578.png +10751.png +44995.png +26514.png +14268.png +05323.png +21424.png +06353.png +44155.png +06767.png +64885.png +12641.png +69936.png +33332.png +07534.png +22496.png +48988.png +03461.png +20407.png +49011.png +22597.png +35296.png +46941.png +60238.png +46966.png +20349.png +62095.png +69673.png +64730.png +32355.png +21306.png +31645.png +15953.png +08224.png +29327.png +15572.png +49832.png +68492.png +56716.png +67273.png +37436.png +65818.png +49683.png +60578.png +08831.png +47373.png +60820.png +64410.png +68896.png +06303.png +54365.png +08065.png +43162.png +32143.png +69582.png +57788.png +45656.png +04534.png +07742.png +19255.png +51007.png +05425.png +01110.png +66582.png +03108.png +29886.png +26797.png +27655.png +54426.png +68695.png +69496.png +66642.png +14885.png +27015.png +16722.png +29922.png +00963.png +21294.png +39648.png +47677.png +39165.png +21190.png +48801.png +12777.png +08563.png +68596.png +61150.png +57485.png +04122.png +17614.png +15350.png +35552.png +44006.png +40069.png +37649.png +20857.png +02657.png +16779.png +54638.png +20131.png +22742.png +55103.png +18257.png +16391.png +54141.png +68092.png +49316.png +42243.png +17638.png +11955.png +44350.png +26520.png +01653.png +12477.png +59185.png +25636.png +68893.png +61593.png +56010.png +30780.png +69417.png +43592.png +38418.png +42572.png +30741.png +02178.png +22663.png +61721.png +50007.png +53414.png +54794.png +38481.png +12513.png +13490.png +42197.png +11019.png +68781.png +62352.png +23607.png +60057.png +44985.png +69990.png +57007.png +20594.png +54991.png +48789.png +22561.png +48331.png +03369.png +21132.png +00407.png +64133.png +65435.png +63848.png +36130.png +15032.png +65618.png +65372.png +12311.png +46669.png +54556.png +39772.png +07609.png +03832.png +23110.png +45546.png +26465.png +38953.png +24308.png +67586.png +59832.png +56942.png +52606.png +57637.png +46708.png +21787.png +39106.png +54119.png +05410.png +55442.png +59348.png +18953.png +60332.png +55304.png +30161.png +10556.png +07868.png +27158.png +09564.png +29224.png +64163.png +36042.png +36582.png +58370.png +19440.png +05995.png +25699.png +51041.png +63575.png +42739.png +23835.png +07514.png +16649.png +58150.png +44564.png +08656.png +44334.png +29356.png +67264.png +01038.png +08317.png +28926.png +27904.png +48438.png +12762.png +03093.png +05721.png +22289.png +47509.png +51962.png +08690.png +68221.png +00880.png +59931.png +49808.png +67107.png +01475.png +55829.png +34354.png +02311.png +23260.png +19413.png +24886.png +48581.png +58661.png +55092.png +45928.png +34926.png +39846.png +38685.png +39963.png +66978.png +51313.png +13336.png +61528.png +06793.png +10475.png +53285.png +51089.png +38842.png +29609.png +26700.png +36682.png +46884.png +68456.png +38522.png +59369.png +39895.png +45435.png +43857.png +63349.png +43395.png +39683.png +42209.png +00397.png +55964.png +44757.png +10801.png +55736.png +01914.png +00336.png +14086.png +12938.png +22365.png +00835.png +25732.png +54410.png +66286.png +54566.png +53085.png +49450.png +29701.png +14950.png +60776.png +08377.png +13773.png +46819.png +60239.png +65155.png +21833.png +60243.png +52015.png +65384.png +32655.png +03329.png +61826.png +45587.png +23936.png +54771.png +53264.png +28981.png +51401.png +22667.png +50384.png +56558.png +51225.png +06254.png +13915.png +26636.png +43531.png +56757.png +34610.png +00908.png +43766.png +21214.png +29528.png +12233.png +35937.png +00600.png +50902.png +25844.png +17761.png +09811.png +22935.png +53283.png +12673.png +24254.png +55732.png +25481.png +59578.png +21693.png +30942.png +69464.png +18031.png +34345.png +61823.png +29486.png +11686.png +14953.png +17756.png +16940.png +05394.png +17508.png +43296.png +62064.png +41182.png +23725.png +00366.png +68247.png +37830.png +41378.png +68058.png +60406.png +29405.png +45657.png +06941.png +48991.png +23524.png +08439.png +66616.png +38672.png +14178.png +21327.png +55880.png +57423.png +02939.png +00238.png +47016.png +37509.png +03984.png +67523.png +10557.png +13571.png +03739.png +34848.png +45545.png +59071.png +22116.png +56062.png +47278.png +68317.png +22199.png +45851.png +46289.png +25396.png +14978.png +49858.png +00612.png +07764.png +06268.png +61742.png +39189.png +40659.png +62835.png +35806.png +29033.png +19368.png +14770.png +29910.png +22259.png +00396.png +28155.png +54272.png +14287.png +01134.png +59273.png +50645.png +54292.png +20668.png +08050.png +53645.png +15748.png +35979.png +28132.png +64035.png +41063.png +46936.png +29725.png +03227.png +36142.png +51553.png +59254.png +10784.png +56565.png +38702.png +22688.png +30238.png +39951.png +06451.png +09889.png +01936.png +64724.png +43234.png +61461.png +28313.png +46816.png +23455.png +64557.png +48114.png +43166.png +04059.png +35896.png +68959.png +07563.png +37461.png +51356.png +31068.png +06286.png +58176.png +68025.png +35376.png +36619.png +61103.png +67761.png +67913.png +04051.png +10733.png +23143.png +46944.png +06594.png +03217.png +27039.png +67113.png +28679.png +47732.png +12638.png +49817.png +50198.png +30009.png +67968.png +42581.png +28610.png +15158.png +00059.png +67347.png +51933.png +43301.png +62623.png +69753.png +23800.png +50145.png +45679.png +63650.png +52624.png +61704.png +22346.png +25761.png +42542.png +28805.png +37973.png +32152.png +27427.png +25549.png +69426.png +30795.png +20426.png +04797.png +38570.png +19352.png +12261.png +03210.png +09619.png +44956.png +25504.png +54920.png +46797.png +28898.png +69209.png +22534.png +62785.png +53065.png +44365.png +30906.png +36737.png +30855.png +36946.png +57467.png +53511.png +41635.png +36818.png +26003.png +02415.png +23214.png +43332.png +12267.png +40904.png +36477.png +37328.png +49351.png +60275.png +52334.png +08614.png +00481.png +02539.png +52120.png +53022.png +58542.png +05190.png +36597.png +67428.png +40929.png +01957.png +45853.png +12066.png +22186.png +18086.png +42087.png +44902.png +25094.png +01222.png +01438.png +34296.png +32539.png +34391.png +47741.png +54497.png +46067.png +40619.png +02070.png +58455.png +04867.png +64126.png +12521.png +09915.png +41296.png +63830.png +43829.png +14802.png +30977.png +24603.png +42993.png +21885.png +21049.png +36606.png +62290.png +16407.png +31038.png +13167.png +36841.png +42507.png +41894.png +43600.png +54528.png +10888.png +32907.png +40410.png +36849.png +62368.png +18610.png +02711.png +54246.png +51535.png +23782.png +65135.png +17640.png +04107.png +50552.png +56786.png +01317.png +22395.png +54169.png +42626.png +65378.png +35064.png +11731.png +54836.png +61578.png +00413.png +23790.png +16681.png +28624.png +58097.png +24757.png +15668.png +68530.png +23977.png +64020.png +50462.png +42077.png +10949.png +08301.png +21232.png +01453.png +14034.png +28551.png +36108.png +32397.png +49589.png +28517.png +07011.png +17629.png +13133.png +42245.png +08412.png +48093.png +35067.png +09253.png +10753.png +67582.png +56987.png +28846.png +03682.png +29512.png +41624.png +14865.png +26651.png +17046.png +61077.png +09917.png +03928.png +53909.png +69131.png +50055.png +31023.png +19979.png +51078.png +17553.png +53777.png +55650.png +12669.png +36500.png +63752.png +19044.png +00034.png +23898.png +09026.png +38720.png +64656.png +17797.png +37007.png +41559.png +62864.png +20621.png +54731.png +05972.png +09938.png +11213.png +31386.png +59858.png +22672.png +48137.png +29810.png +32956.png +42721.png +31071.png +03577.png +07138.png +11362.png +50017.png +41959.png +51348.png +16826.png +38854.png +69566.png +48338.png +25561.png +65868.png +63195.png +01322.png +69507.png +22988.png +20439.png +61736.png +18781.png +69506.png +47896.png +51376.png +15815.png +51443.png +15731.png +53170.png +33873.png +23272.png +32038.png +57454.png +41842.png +11545.png +37473.png +63771.png +62429.png +58314.png +18730.png +24939.png +40563.png +39655.png +02641.png +34021.png +29415.png +34541.png +58965.png +58594.png +36855.png +51603.png +12075.png +62787.png +24454.png +21813.png +21856.png +53997.png +69614.png +14065.png +64606.png +36445.png +18109.png +25240.png +46549.png +43173.png +32747.png +55087.png +03529.png +68267.png +15303.png +28668.png +50081.png +66781.png +05962.png +56462.png +26376.png +04247.png +35348.png +24633.png +22697.png +16241.png +66987.png +19319.png +44761.png +31505.png +39597.png +59807.png +52859.png +20985.png +52474.png +26890.png +47519.png +13440.png +24660.png +55149.png +27088.png +11448.png +49686.png +17586.png +35361.png +29829.png +56645.png +53138.png +02724.png +63831.png +42079.png +66843.png +57278.png +04091.png +36046.png +12041.png +22612.png +62025.png +15750.png +16036.png +54951.png +49344.png +10541.png +14388.png +67759.png +12776.png +37519.png +52644.png +23024.png +21659.png +22691.png +07879.png +39368.png +53355.png +33823.png +22113.png +08768.png +30350.png +06278.png +29950.png +27014.png +03761.png +25633.png +57600.png +06392.png +67716.png +31007.png +38582.png +03665.png +06836.png +16097.png +17808.png +07606.png +09982.png +28985.png +22531.png +15916.png +39069.png +59385.png +35439.png +28561.png +11208.png +11173.png +64774.png +25962.png +07730.png +13337.png +06901.png +29073.png +06734.png +48090.png +12677.png +66120.png +31240.png +47692.png +06250.png +33054.png +32876.png +01558.png +25933.png +26504.png +52065.png +01620.png +32721.png +06576.png +18556.png +56044.png +01204.png +47789.png +53791.png +41656.png +66483.png +67981.png +63045.png +29519.png +38770.png +23901.png +58414.png +30456.png +41486.png +01872.png +39928.png +40348.png +59886.png +59083.png +11280.png +15904.png +51678.png +38008.png +56765.png +46981.png +33064.png +20441.png +53314.png +60933.png +34490.png +17690.png +46282.png +13257.png +51701.png +41148.png +66951.png +34696.png +06969.png +42736.png +14179.png +41031.png +02025.png +62100.png +31054.png +33105.png +18897.png +24035.png +45430.png +61443.png +52934.png +42177.png +23494.png +05912.png +18658.png +22461.png +67164.png +21568.png +05741.png +61533.png +35522.png +49071.png +28242.png +15566.png +12271.png +65133.png +50087.png +03398.png +02875.png +18132.png +44416.png +37087.png +48782.png +42140.png +51885.png +51254.png +46248.png +57946.png +37286.png +34924.png +60935.png +24141.png +15274.png +60410.png +02527.png +11478.png +25102.png +49322.png +33139.png +14805.png +49748.png +03067.png +55128.png +12272.png +49392.png +47591.png +32670.png +11055.png +58056.png +05538.png +44277.png +02134.png +12757.png +06907.png +16679.png +67612.png +62862.png +53544.png +14561.png +09313.png +09188.png +03773.png +09582.png +26508.png +63011.png +11003.png +02434.png +24137.png +51461.png +13993.png +34238.png +44023.png +69977.png +34861.png +24185.png +39733.png +61783.png +24201.png +45082.png +04936.png +22986.png +60495.png +22779.png +19259.png +62757.png +53046.png +04623.png +56464.png +34912.png +15823.png +43115.png +51904.png +21589.png +56290.png +15766.png +47867.png +30643.png +63522.png +38399.png +64219.png +37729.png +01811.png +57422.png +19891.png +33966.png +29744.png +62396.png +43697.png +37900.png +36487.png +24441.png +19197.png +58935.png +51437.png +63496.png +57868.png +53632.png +01171.png +07595.png +10780.png +11069.png +08899.png +33629.png +01525.png +47710.png +03677.png +50807.png +38391.png +09288.png +44994.png +50672.png +39801.png +35639.png +32990.png +42418.png +08539.png +31275.png +39632.png +46674.png +12911.png +29186.png +48101.png +43097.png +09945.png +23892.png +32400.png +31564.png +21621.png +44539.png +07984.png +43639.png +41901.png +10037.png +48631.png +02093.png +01004.png +61206.png +46081.png +00086.png +41777.png +10284.png +45431.png +65767.png +66604.png +14648.png +35971.png +18374.png +21993.png +43969.png +42722.png +44974.png +10863.png +47360.png +08029.png +56366.png +54498.png +26558.png +47417.png +58086.png +14451.png +02959.png +62859.png +22468.png +68243.png +29156.png +47428.png +40761.png +13500.png +08268.png +12172.png +42342.png +31794.png +50973.png +20598.png +12371.png +09460.png +68962.png +25388.png +50582.png +15755.png +67120.png +44594.png +01541.png +08344.png +16701.png +29241.png +21140.png +46020.png +20199.png +10981.png +46682.png +52619.png +24580.png +35815.png +29797.png +01682.png +08800.png +35910.png +59074.png +09799.png +61242.png +55711.png +35357.png +17697.png +10954.png +06852.png +29959.png +49945.png +17679.png +35973.png +33912.png +04707.png +49715.png +65809.png +63221.png +36990.png +05892.png +34455.png +42367.png +59210.png +48432.png +68682.png +63395.png +56087.png +12717.png +09494.png +29574.png +05609.png +16623.png +15687.png +49563.png +52323.png +59704.png +24099.png +10158.png +51625.png +06972.png +62246.png +39986.png +67218.png +20623.png +44547.png +21469.png +00123.png +67686.png +14122.png +69887.png +17765.png +34547.png +43005.png +61017.png +11278.png +16069.png +55876.png +61260.png +22545.png +53543.png +32704.png +49481.png +68134.png +29018.png +63918.png +05679.png +44502.png +01377.png +65801.png +40128.png +44612.png +59722.png +57219.png +66988.png +19915.png +22463.png +37956.png +08971.png +36181.png +46332.png +06582.png +23065.png +59906.png +32385.png +06884.png +43552.png +25266.png +28514.png +62517.png +26382.png +62887.png +65456.png +18628.png +59042.png +02170.png +61811.png +49755.png +02378.png +24324.png +25608.png +06251.png +19339.png +44008.png +06933.png +42686.png +46334.png +34646.png +51599.png +05466.png +60761.png +69871.png +11006.png +07521.png +35176.png +36634.png +67123.png +40008.png +06122.png +36186.png +21457.png +49994.png +13327.png +63023.png +35962.png +13507.png +54041.png +20739.png +26527.png +56096.png +21106.png +34178.png +09857.png +68995.png +65269.png +03229.png +52579.png +04764.png +20236.png +54572.png +64375.png +50459.png +53096.png +45177.png +41550.png +51155.png +24394.png +33061.png +36123.png +52592.png +50174.png +10629.png +10985.png +61567.png +21563.png +38034.png +25368.png +41209.png +18168.png +03071.png +59789.png +18422.png +33453.png +30377.png +24933.png +00995.png +15311.png +56456.png +35079.png +16593.png +46723.png +47862.png +48141.png +53716.png +50846.png +63200.png +41567.png +17746.png +08670.png +58812.png +29773.png +16030.png +15651.png +24697.png +28012.png +65885.png +27091.png +25612.png +26327.png +06413.png +20909.png +04668.png +18864.png +22682.png +01506.png +02155.png +02799.png +52792.png +14769.png +37907.png +63654.png +17190.png +25106.png +42162.png +50660.png +21956.png +04027.png +08639.png +16537.png +33387.png +54232.png +51969.png +03247.png +42143.png +27740.png +03813.png +12227.png +42672.png +50211.png +64503.png +14142.png +45940.png +08926.png +31922.png +48743.png +34325.png +22801.png +36397.png +36498.png +27679.png +64629.png +25280.png +52051.png +00286.png +60950.png +39944.png +56323.png +01306.png +52467.png +13031.png +66525.png +32255.png +60528.png +63502.png +48598.png +19480.png +31136.png +22127.png +14353.png +33704.png +03003.png +16538.png +61354.png +49637.png +62811.png +30466.png +15392.png +53922.png +67556.png +26949.png +27175.png +06248.png +55339.png +47930.png +05766.png +19675.png +13566.png +44319.png +09042.png +24123.png +54591.png +08509.png +20686.png +41032.png +15156.png +69315.png +40049.png +19918.png +36848.png +07050.png +17232.png +23687.png +16741.png +69232.png +35703.png +13276.png +35969.png +58901.png +54910.png +02108.png +12257.png +38602.png +61064.png +06021.png +33854.png +60955.png +46202.png +03190.png +26891.png +29731.png +24052.png +52119.png +08055.png +29253.png +18098.png +25066.png +45291.png +45584.png +49288.png +64990.png +20168.png +57504.png +60020.png +01669.png +05588.png +15879.png +03575.png +25119.png +22277.png +06029.png +27244.png +13364.png +26128.png +61006.png +28380.png +66392.png +56861.png +60707.png +61753.png +32133.png +32056.png +25690.png +24515.png +50635.png +38254.png +30035.png +36334.png +46706.png +21554.png +15105.png +48960.png +03836.png +36587.png +62402.png +09241.png +14838.png +34876.png +32720.png +54320.png +60737.png +50305.png +32552.png +24568.png +50773.png +56206.png +66402.png +63008.png +05959.png +57612.png +08586.png +46636.png +63653.png +36030.png +26934.png +68205.png +03947.png +23371.png +36160.png +13144.png +33416.png +28436.png +63440.png +14689.png +46295.png +03182.png +05157.png +50767.png +38084.png +40527.png +65260.png +13880.png +55781.png +26491.png +09337.png +22069.png +57384.png +58630.png +67823.png +51719.png +47687.png +17784.png +37169.png +37113.png +47604.png +61431.png +55932.png +01692.png +18463.png +57702.png +06859.png +02668.png +54927.png +14695.png +09566.png +47706.png +33964.png +51849.png +60464.png +25934.png +00582.png +15580.png +41596.png +39486.png +23506.png +46834.png +26425.png +32053.png +07809.png +48910.png +53782.png +03117.png +50301.png +31049.png +17751.png +14757.png +23935.png +16453.png +24009.png +08624.png +15258.png +12337.png +38521.png +51397.png +17265.png +62047.png +30410.png +19745.png +64256.png +68107.png +69806.png +53789.png +25987.png +26545.png +17471.png +36097.png +39519.png +29498.png +62898.png +46210.png +63154.png +60274.png +10767.png +47918.png +37059.png +11275.png +08170.png +07540.png +38709.png +23248.png +01803.png +22154.png +55159.png +67304.png +27849.png +61585.png +14326.png +04947.png +50880.png +27469.png +12701.png +47350.png +05629.png +21185.png +63407.png +23640.png +23515.png +36313.png +01022.png +00568.png +06319.png +15279.png +55803.png +01626.png +37574.png +55091.png +49313.png +02195.png +49902.png +45997.png +14729.png +12016.png +39890.png +64615.png +51501.png +28176.png +10959.png +33840.png +57092.png +35518.png +44877.png +53879.png +65463.png +26697.png +46019.png +34909.png +08830.png +41198.png +63095.png +52726.png +61686.png +34248.png +13705.png +21057.png +11206.png +63717.png +28552.png +25852.png +25583.png +67767.png +12768.png +00917.png +65349.png +05417.png +20123.png +63765.png +60251.png +64925.png +66805.png +17567.png +63381.png +21068.png +45167.png +50043.png +67112.png +44259.png +52707.png +61859.png +46593.png +12713.png +44570.png +69861.png +27097.png +08555.png +34885.png +55951.png +00160.png +20143.png +19853.png +45783.png +46574.png +09786.png +39016.png +65298.png +57737.png +53086.png +40876.png +44034.png +27590.png +56348.png +54327.png +14516.png +02620.png +07324.png +33627.png +32229.png +08579.png +16963.png +34678.png +25611.png +66242.png +62947.png +51042.png +24663.png +25938.png +13664.png +28497.png +45369.png +64034.png +52133.png +51635.png +00796.png +44305.png +52745.png +49171.png +03554.png +19338.png +41620.png +53325.png +15590.png +67389.png +05847.png +32818.png +33053.png +17834.png +61031.png +04774.png +45936.png +22112.png +47506.png +19634.png +39008.png +60603.png +19441.png +39654.png +69995.png +14203.png +67898.png +44992.png +67006.png +20725.png +66531.png +28750.png +13626.png +25138.png +20497.png +25816.png +02297.png +58586.png +53545.png +22321.png +21292.png +17907.png +07989.png +15409.png +23939.png +39436.png +11091.png +64970.png +02687.png +61237.png +27639.png +37012.png +34792.png +03246.png +06697.png +29132.png +54727.png +40149.png +50699.png +63656.png +37467.png +17843.png +20624.png +49722.png +58466.png +25382.png +22122.png +27019.png +59351.png +45328.png +60652.png +48543.png +28542.png +25355.png +05848.png +21598.png +05332.png +59829.png +40748.png +08763.png +69677.png +41696.png +22635.png +42756.png +35838.png +43535.png +29342.png +60630.png +04543.png +56297.png +25617.png +14116.png +18467.png +02085.png +52590.png +26450.png +64144.png +41888.png +11812.png +14088.png +19719.png +66990.png +49141.png +21040.png +07897.png +19637.png +61605.png +26644.png +53188.png +60200.png +38049.png +43859.png +03343.png +19625.png +33194.png +37631.png +40154.png +47607.png +26554.png +07311.png +33705.png +37403.png +42472.png +16375.png +05165.png +53993.png +03885.png +27106.png +39384.png +51400.png +09474.png +38119.png +11202.png +57523.png +52559.png +55871.png +35991.png +66271.png +11095.png +50202.png +19548.png +29184.png +39011.png +30337.png +59557.png +48772.png +28125.png +12928.png +41154.png +41666.png +07219.png +35431.png +58309.png +01840.png +67762.png +39358.png +22383.png +58948.png +18782.png +00674.png +30682.png +27666.png +39601.png +38098.png +45707.png +03130.png +58766.png +59442.png +40744.png +68458.png +43427.png +32948.png +16564.png +33242.png +58718.png +46607.png +41138.png +03219.png +27738.png +65579.png +11199.png +49285.png +59096.png +11182.png +10903.png +61105.png +56693.png +21966.png +59491.png +64291.png +03611.png +36153.png +17176.png +33652.png +09085.png +50900.png +68701.png +35731.png +03694.png +55517.png +07014.png +63401.png +35494.png +53358.png +07235.png +33510.png +15455.png +53240.png +32759.png +54538.png +26919.png +04370.png +36243.png +03970.png +25261.png +15443.png +08519.png +43747.png +40785.png +02767.png +02853.png +09657.png +56326.png +43677.png +29491.png +50374.png +12639.png +44075.png +47031.png +41261.png +16558.png +54546.png +44510.png +33091.png +61400.png +11318.png +15355.png +68430.png +29240.png +36201.png +06737.png +02733.png +40064.png +31185.png +53009.png +09465.png +66839.png +21028.png +57976.png +17537.png +25322.png +36835.png +30868.png +69906.png +55342.png +34913.png +37184.png +60588.png +05225.png +27332.png +22930.png +04367.png +56520.png +07902.png +43827.png +12672.png +48569.png +50895.png +64524.png +54357.png +68313.png +52470.png +31791.png +45249.png +49291.png +59531.png +67941.png +30946.png +09307.png +39960.png +07979.png +10640.png +01593.png +50815.png +53383.png +45899.png +60199.png +61540.png +55721.png +02087.png +37013.png +34379.png +08453.png +41643.png +24049.png +15096.png +18537.png +57473.png +36706.png +10730.png +11085.png +50335.png +30938.png +59209.png +18525.png +09609.png +18522.png +64638.png +66890.png +18344.png +60252.png +36268.png +45689.png +18803.png +36867.png +16067.png +22427.png +02157.png +20112.png +49446.png +36435.png +03922.png +53247.png +62544.png +14271.png +69073.png +35616.png +53596.png +09341.png +34774.png +54833.png +66743.png +04033.png +16384.png +14323.png +69421.png +30788.png +38562.png +31869.png +24366.png +58136.png +30863.png +62391.png +18966.png +05738.png +40230.png +36636.png +23821.png +54798.png +30173.png +67892.png +33511.png +04919.png +26351.png +31624.png +07767.png +36043.png +55939.png +18950.png +48499.png +63710.png +61562.png +20773.png +31812.png +42589.png +39107.png +08148.png +50908.png +36909.png +01910.png +47791.png +12504.png +33817.png +63088.png +08213.png +64432.png +51420.png +54135.png +45629.png +17723.png +30948.png +54759.png +61790.png +61598.png +41442.png +33002.png +08850.png +16571.png +27577.png +31827.png +12104.png +15031.png +13301.png +25763.png +32566.png +61843.png +65092.png +64070.png +23287.png +30300.png +27254.png +58667.png +43351.png +64067.png +15999.png +62342.png +32591.png +19747.png +55563.png +51424.png +00361.png +68454.png +36389.png +50920.png +45847.png +18819.png +68436.png +10140.png +16933.png +46570.png +05042.png +45282.png +25305.png +03673.png +45180.png +48884.png +11859.png +12164.png +62993.png +20059.png +63082.png +46661.png +13991.png +30053.png +63628.png +26885.png +44675.png +00398.png +12522.png +29217.png +58679.png +54834.png +57984.png +61481.png +57362.png +42712.png +26773.png +27815.png +12218.png +59988.png +37215.png +65186.png +48470.png +05571.png +50751.png +43683.png +38975.png +62387.png +04002.png +51375.png +02364.png +58260.png +05136.png +22032.png +26185.png +41043.png +01309.png +19240.png +40790.png +55539.png +22093.png +20438.png +59112.png +22105.png +08009.png +23501.png +13135.png +29579.png +11465.png +22519.png +64695.png +27179.png +62376.png +04353.png +20942.png +26001.png +50267.png +37457.png +11103.png +10505.png +30751.png +56805.png +65096.png +23456.png +08226.png +42293.png +56666.png +09292.png +57886.png +26449.png +05152.png +09974.png +15145.png +21528.png +22783.png +45485.png +11376.png +18835.png +13648.png +04938.png +61752.png +48182.png +23091.png +31982.png +66749.png +44577.png +51732.png +17448.png +52299.png +08511.png +64251.png +46864.png +54370.png +64931.png +22212.png +64712.png +45705.png +01699.png +37125.png +65958.png +43144.png +62526.png +51534.png +35052.png +43547.png +18305.png +26819.png +50297.png +14002.png +52395.png +34221.png +51605.png +16442.png +09898.png +06068.png +62939.png +42776.png +49629.png +28492.png +46879.png +34540.png +39982.png +58876.png +12934.png +57874.png +13515.png +63714.png +18199.png +53516.png +11563.png +55750.png +19618.png +65220.png +11590.png +40720.png +67845.png +23243.png +22634.png +35850.png +47414.png +56843.png +32612.png +48888.png +64171.png +29755.png +55590.png +22118.png +00017.png +66723.png +42777.png +42074.png +44799.png +48373.png +25174.png +29826.png +39711.png +68818.png +21318.png +10712.png +09879.png +50118.png +13964.png +64103.png +18216.png +15730.png +14767.png +11064.png +42083.png +12077.png +54802.png +28666.png +23027.png +16272.png +69312.png +04131.png +16563.png +63007.png +40719.png +33275.png +25790.png +22687.png +43804.png +40854.png +07097.png +69263.png +37319.png +66047.png +52160.png +16208.png +16854.png +32637.png +61313.png +22831.png +27872.png +40889.png +45248.png +11119.png +01250.png +08821.png +61940.png +62507.png +42055.png +13146.png +33226.png +50401.png +06010.png +39523.png +50925.png +19484.png +09126.png +31066.png +29112.png +26131.png +06501.png +67484.png +65616.png +45114.png +11740.png +32237.png +33140.png +55405.png +67605.png +20877.png +02376.png +13100.png +01494.png +58693.png +26903.png +36617.png +43712.png +29052.png +54051.png +69281.png +28646.png +65721.png +15860.png +19010.png +24777.png +07708.png +31258.png +01263.png +30842.png +23895.png +12004.png +20178.png +05519.png +20795.png +60460.png +23745.png +15365.png +04595.png +11830.png +00655.png +54541.png +41076.png +07025.png +47703.png +37112.png +27397.png +22157.png +24740.png +34743.png +05490.png +25376.png +26942.png +64087.png +37424.png +13365.png +22464.png +16439.png +54693.png +37155.png +31757.png +22460.png +12889.png +59913.png +47821.png +53502.png +64747.png +11027.png +62318.png +23374.png +28173.png +65666.png +68688.png +25267.png +60259.png +39807.png +26029.png +42552.png +47019.png +48608.png +51979.png +44104.png +18044.png +57758.png +11170.png +53763.png +48120.png +14959.png +59865.png +05440.png +63664.png +52463.png +44382.png +12242.png +69183.png +20331.png +40178.png +36671.png +48724.png +24495.png +09046.png +48056.png +49578.png +50506.png +69297.png +54366.png +01258.png +54253.png +56598.png +28902.png +27261.png +61254.png +04549.png +65461.png +58133.png +47400.png +33490.png +34716.png +19648.png +39306.png +31649.png +04384.png +30806.png +11875.png +11255.png +23237.png +59149.png +42639.png +20625.png +05881.png +61218.png +20170.png +06627.png +63517.png +42868.png +05423.png +39078.png +50104.png +62688.png +20875.png +69063.png +22604.png +40722.png +20913.png +08985.png +03083.png +22297.png +57350.png +25168.png +41997.png +49712.png +33900.png +42053.png +57329.png +69279.png +63587.png +24179.png +60524.png +13595.png +58918.png +47151.png +58717.png +67594.png +46518.png +03911.png +41827.png +40462.png +20090.png +67853.png +25992.png +36612.png +15965.png +30974.png +07694.png +02744.png +47962.png +01672.png +61286.png +20373.png +59966.png +19061.png +53548.png +64285.png +12853.png +40199.png +38801.png +11860.png +27242.png +68248.png +62472.png +15524.png +28090.png +12632.png +02270.png +31550.png +10261.png +31600.png +37661.png +45359.png +42230.png +61408.png +53496.png +38659.png +19820.png +31839.png +61778.png +34045.png +33174.png +28440.png +54637.png +62851.png +09520.png +38405.png +36697.png +62711.png +30147.png +19375.png +26396.png +69975.png +26886.png +30729.png +37224.png +17364.png +01828.png +18941.png +34562.png +16171.png +53707.png +12516.png +26607.png +27013.png +46521.png +20769.png +34430.png +40561.png +33580.png +45955.png +24362.png +59649.png +69788.png +47816.png +25154.png +55656.png +17735.png +04259.png +58167.png +10367.png +14177.png +51098.png +67864.png +31187.png +65748.png +24066.png +01062.png +59904.png +05004.png +48617.png +62235.png +52033.png +48472.png +19647.png +18540.png +06534.png +65888.png +12767.png +60320.png +13906.png +45675.png +11277.png +60870.png +15056.png +08220.png +14084.png +62553.png +62998.png +17635.png +06014.png +38128.png +11453.png +24951.png +13588.png +65059.png +38712.png +07908.png +68299.png +50755.png +28094.png +54006.png +24598.png +51438.png +56084.png +15992.png +17722.png +61411.png +42011.png +24986.png +58783.png +41885.png +60384.png +51673.png +35304.png +06527.png +19917.png +14007.png +34293.png +35629.png +51009.png +60719.png +67677.png +16650.png +58272.png +40777.png +65376.png +30945.png +01451.png +47382.png +55051.png +25832.png +28152.png +01514.png +21121.png +54958.png +38735.png +14563.png +51050.png +05627.png +60696.png +44672.png +27774.png +36304.png +23772.png +52953.png +19671.png +04569.png +16299.png +68096.png +25804.png +65992.png +53060.png +57326.png +01937.png +01946.png +23662.png +66586.png +16238.png +02842.png +30079.png +65165.png +08660.png +18872.png +28179.png +47548.png +39333.png +10294.png +67820.png +32406.png +15447.png +04932.png +23173.png +08150.png +40678.png +43174.png +34994.png +40726.png +33513.png +08387.png +03233.png +62903.png +13494.png +52027.png +30877.png +64411.png +54571.png +61607.png +04958.png +18175.png +06945.png +56164.png +38789.png +08672.png +38795.png +11549.png +48937.png +60062.png +56006.png +07364.png +45720.png +26804.png +47402.png +29794.png +10240.png +44926.png +41109.png +48842.png +00545.png +53561.png +30539.png +40425.png +37359.png +41890.png +43736.png +48863.png +03113.png +68903.png +38046.png +43749.png +35625.png +42054.png +36980.png +66181.png +10766.png +19631.png +17968.png +64974.png +46354.png +09482.png +07493.png +48411.png +02284.png +28192.png +38431.png +42489.png +50075.png +14907.png +28516.png +38412.png +22320.png +34286.png +13369.png +45198.png +30963.png +27893.png +49869.png +42862.png +28886.png +44812.png +14403.png +49118.png +28738.png +68698.png +15858.png +42006.png +02601.png +40093.png +36346.png +11672.png +40371.png +35876.png +64499.png +34485.png +17416.png +26500.png +37001.png +23719.png +42557.png +39981.png +66403.png +53663.png +20510.png +43861.png +14512.png +25851.png +02393.png +29796.png +39708.png +35862.png +05081.png +30451.png +54037.png +48866.png +67394.png +41029.png +04326.png +22782.png +56977.png +40279.png +39428.png +25769.png +30648.png +16991.png +49833.png +17810.png +43726.png +37542.png +66478.png +59862.png +10987.png +08246.png +42957.png +05839.png +10083.png +62484.png +18258.png +45401.png +37309.png +58775.png +02011.png +01503.png +55475.png +25113.png +15229.png +22601.png +47262.png +28123.png +69570.png +38146.png +32423.png +56446.png +05292.png +25635.png +50421.png +29097.png +22299.png +63954.png +48042.png +32843.png +09041.png +16688.png +06827.png +62981.png +40447.png +22928.png +25773.png +25491.png +52573.png +31363.png +58896.png +53912.png +52764.png +54569.png +51131.png +34317.png +65429.png +29793.png +54208.png +23596.png +34641.png +21101.png +65703.png +37905.png +22050.png +14910.png +11158.png +33717.png +08198.png +26181.png +36222.png +43991.png +10288.png +45869.png +68945.png +03349.png +53725.png +66796.png +13476.png +54765.png +45556.png +26735.png +26250.png +63320.png +34891.png +24689.png +49660.png +06539.png +60729.png +49349.png +26766.png +13745.png +44868.png +56858.png +19252.png +00378.png +62539.png +15343.png +29970.png +25446.png +03754.png +28321.png +69831.png +46435.png +55155.png +18009.png +59822.png +63232.png +65394.png +59364.png +64529.png +40850.png +20873.png +41084.png +34046.png +00727.png +68184.png +08230.png +24977.png +05513.png +41707.png +41188.png +47214.png +37236.png +00273.png +60154.png +59558.png +43713.png +37031.png +36964.png +02670.png +18285.png +35035.png +63716.png +15144.png +59039.png +69490.png +40249.png +52134.png +50214.png +24292.png +65959.png +27611.png +13623.png +41196.png +30322.png +09277.png +58113.png +01617.png +19578.png +53087.png +22484.png +19242.png +46531.png +03180.png +45867.png +69706.png +30639.png +27806.png +06926.png +63626.png +13784.png +12417.png +44336.png +00036.png +29208.png +42080.png +11885.png +41141.png +00603.png +36027.png +69267.png +67157.png +48457.png +57345.png +40747.png +10010.png +01396.png +17426.png +60336.png +45495.png +69872.png +63870.png +35021.png +55094.png +62330.png +59524.png +33067.png +48976.png +05335.png +12655.png +26706.png +33232.png +39393.png +49198.png +06214.png +28942.png +48497.png +18980.png +33822.png +60030.png +38198.png +66004.png +63291.png +32880.png +28351.png +28832.png +69381.png +06841.png +23510.png +59247.png +66159.png +13594.png +68888.png +64453.png +62053.png +16911.png +14310.png +33503.png +44212.png +01947.png +27057.png +61351.png +58883.png +50507.png +48563.png +49807.png +34582.png +46097.png +55892.png +10445.png +13480.png +14667.png +13510.png +31473.png +30270.png +27868.png +69610.png +40466.png +17473.png +34874.png +34347.png +32691.png +29563.png +66842.png +17946.png +17049.png +06137.png +62524.png +20662.png +03255.png +17215.png +66138.png +40610.png +20228.png +10497.png +33523.png +20663.png +17545.png +14558.png +02074.png +30330.png +33529.png +22247.png +29948.png +28348.png +20568.png +15340.png +37638.png +47541.png +64071.png +40104.png +10797.png +63928.png +55021.png +13396.png +16319.png +52277.png +27067.png +28080.png +21060.png +48035.png +53038.png +68005.png +17993.png +41387.png +56197.png +12716.png +51514.png +22188.png +06418.png +56242.png +10566.png +21734.png +40664.png +19376.png +32045.png +20914.png +18751.png +09906.png +16897.png +43517.png +38474.png +25385.png +07406.png +35486.png +43294.png +08095.png +20292.png +26079.png +07444.png +20811.png +18672.png +58485.png +54995.png +08424.png +26231.png +18229.png +48745.png +34865.png +38736.png +49113.png +36333.png +57872.png +49265.png +01753.png +51289.png +44738.png +58123.png +00644.png +10584.png +42374.png +66300.png +63180.png +53234.png +25918.png +28962.png +39308.png +25873.png +48523.png +38318.png +68968.png +02133.png +32271.png +08646.png +50602.png +44590.png +21216.png +32420.png +50155.png +13655.png +53914.png +42442.png +47760.png +62140.png +48667.png +16274.png +15139.png +62147.png +02148.png +66235.png +20308.png +63162.png +37942.png +67302.png +10655.png +34785.png +21682.png +36180.png +07649.png +23916.png +12167.png +38323.png +52286.png +11017.png +37818.png +29817.png +14905.png +26186.png +20035.png +13255.png +12139.png +53294.png +46638.png +53336.png +67032.png +08066.png +35833.png +58980.png +45134.png +45451.png +34122.png +61219.png +49935.png +32267.png +52568.png +42682.png +16714.png +19046.png +60586.png +12827.png +08733.png +69429.png +47104.png +45703.png +42972.png +14726.png +26659.png +57920.png +31966.png +54164.png +11806.png +61073.png +04922.png +00449.png +31070.png +31925.png +51794.png +08300.png +48361.png +37550.png +61164.png +06032.png +15269.png +14889.png +49293.png +40313.png +17991.png +19313.png +35920.png +13980.png +58198.png +25440.png +20283.png +62733.png +35574.png +17278.png +08798.png +17806.png +11625.png +22117.png +42793.png +60627.png +28352.png +22434.png +67858.png +26076.png +42444.png +50053.png +01271.png +37230.png +37440.png +30796.png +24607.png +13353.png +37258.png +52982.png +01297.png +03008.png +63177.png +54580.png +27090.png +35058.png +43785.png +57846.png +43460.png +04995.png +13483.png +06335.png +37057.png +21936.png +64833.png +66714.png +66768.png +53326.png +65870.png +15963.png +39838.png +52363.png +65685.png +08068.png +02291.png +56128.png +01067.png +55642.png +32951.png +49705.png +15143.png +57358.png +04985.png +26652.png +68259.png +42695.png +39505.png +53786.png +32601.png +14106.png +62525.png +24994.png +38269.png +34159.png +69989.png +24229.png +26749.png +29811.png +18622.png +30089.png +23156.png +41772.png +48737.png +31454.png +62050.png +40682.png +51221.png +42782.png +66298.png +58811.png +67998.png +09247.png +39203.png +39377.png +27509.png +61690.png +33526.png +24552.png +46494.png +58564.png +69139.png +45861.png +69392.png +55169.png +67657.png +49709.png +62846.png +37688.png +56344.png +34663.png +47764.png +65671.png +51802.png +19580.png +46374.png +08110.png +65346.png +33947.png +05863.png +60919.png +63136.png +59539.png +23738.png +22728.png +40398.png +62392.png +49601.png +28088.png +25255.png +51227.png +54931.png +46953.png +56276.png +27120.png +15959.png +50031.png +04199.png +12401.png +47961.png +10298.png +61634.png +25780.png +39213.png +22754.png +03797.png +64201.png +09855.png +31857.png +50693.png +50295.png +63421.png +63570.png +33187.png +51423.png +44739.png +07505.png +51380.png +45894.png +08936.png +14325.png +05009.png +50131.png +59674.png +53672.png +05285.png +63925.png +39826.png +20685.png +24270.png +04221.png +02036.png +66289.png +09298.png +30324.png +68769.png +52335.png +57541.png +25955.png +11101.png +14198.png +38755.png +33216.png +07072.png +25749.png +36138.png +59026.png +15218.png +03558.png +20253.png +57520.png +57564.png +54133.png +04504.png +42340.png +28388.png +37014.png +67378.png +53627.png +14641.png +63524.png +44308.png +54351.png +47599.png +50882.png +62632.png +36616.png +43661.png +08129.png +47530.png +44226.png +23489.png +07657.png +43054.png +08723.png +03526.png +69174.png +22139.png +03505.png +23141.png +55432.png +47929.png +19556.png +25889.png +37884.png +60316.png +44584.png +22558.png +35162.png +53547.png +61689.png +50706.png +01401.png +14990.png +61061.png +43556.png +07748.png +69670.png +16864.png +05243.png +05044.png +25320.png +09119.png +46034.png +63783.png +07481.png +19692.png +19973.png +45447.png +09269.png +62359.png +51615.png +63556.png +48889.png +10486.png +65670.png +34452.png +68466.png +42832.png +15034.png +32943.png +32472.png +05445.png +62299.png +18279.png +28953.png +69964.png +00038.png +34254.png +65599.png +16294.png +34935.png +01535.png +08730.png +50229.png +56451.png +67100.png +46473.png +53032.png +00157.png +15911.png +68334.png +20659.png +38113.png +58881.png +61565.png +68719.png +33598.png +59073.png +06656.png +60303.png +31392.png +37034.png +61785.png +10050.png +53094.png +62985.png +42191.png +58816.png +69837.png +45590.png +02607.png +63107.png +10715.png +63672.png +19403.png +62253.png +61677.png +47544.png +27933.png +58874.png +31364.png +56559.png +25013.png +17391.png +39076.png +44753.png +28062.png +44491.png +18812.png +35856.png +68298.png +21539.png +40475.png +16389.png +07632.png +08423.png +45305.png +46124.png +48201.png +12437.png +65343.png +43580.png +63318.png +05736.png +56920.png +41412.png +08525.png +40734.png +43439.png +33707.png +11519.png +09756.png +62856.png +19665.png +22369.png +00436.png +40094.png +56909.png +53689.png +67209.png +51690.png +20886.png +61338.png +00679.png +45634.png +13199.png +62944.png +47364.png +36272.png +05857.png +58969.png +46532.png +60674.png +36614.png +29260.png +58092.png +36903.png +12561.png +29541.png +51886.png +45423.png +09450.png +62019.png +32432.png +57754.png +07152.png +28166.png +00056.png +30016.png +22181.png +20736.png +68759.png +43960.png +35098.png +58261.png +15665.png +11159.png +65761.png +32252.png +47894.png +16001.png +39737.png +19824.png +29645.png +41850.png +03678.png +58771.png +30240.png +59613.png +11900.png +25580.png +47491.png +56857.png +10080.png +34664.png +58751.png +28077.png +51564.png +66964.png +41345.png +01328.png +01201.png +31699.png +47753.png +00026.png +31229.png +11414.png +13195.png +07454.png +07024.png +01718.png +40882.png +03642.png +50250.png +68007.png +07589.png +21013.png +38731.png +23729.png +51053.png +64773.png +47034.png +53090.png +44122.png +28715.png +62127.png +50103.png +49679.png +37842.png +01051.png +40062.png +67971.png +65510.png +29352.png +23563.png +55611.png +27472.png +02175.png +50444.png +08817.png +55770.png +20531.png +24107.png +31792.png +19412.png +69161.png +23861.png +38807.png +16643.png +40593.png +20921.png +33762.png +23291.png +13101.png +43103.png +42769.png +21167.png +37202.png +10103.png +11517.png +24163.png +54831.png +21163.png +35652.png +33475.png +39739.png +35913.png +37863.png +22625.png +25510.png +39694.png +60400.png +64395.png +58491.png +53433.png +00584.png +17382.png +13084.png +38480.png +27499.png +64465.png +00617.png +61575.png +63539.png +65742.png +34044.png +22938.png +46196.png +30467.png +01017.png +15998.png +67939.png +36155.png +09265.png +17342.png +28945.png +15007.png +02702.png +04859.png +06266.png +25348.png +38033.png +50010.png +35844.png +41027.png +50921.png +28400.png +41509.png +68611.png +03157.png +52584.png +34084.png +02325.png +69856.png +69601.png +29561.png +36781.png +07373.png +68575.png +32078.png +36556.png +58714.png +27464.png +26061.png +64310.png +22344.png +57606.png +62663.png +30820.png +54289.png +61931.png +02719.png +08694.png +31777.png +66421.png +24061.png +46689.png +66947.png +60215.png +52552.png +55223.png +35437.png +08589.png +16048.png +27749.png +15545.png +23447.png +17728.png +08229.png +54458.png +08827.png +39379.png +41574.png +58289.png +57681.png +57169.png +00487.png +34675.png +16352.png +55997.png +67838.png +49998.png +52181.png +16566.png +24851.png +52560.png +60744.png +20517.png +36322.png +32285.png +12662.png +28498.png +04944.png +29823.png +33546.png +21282.png +16409.png +34629.png +25914.png +53427.png +69082.png +49389.png +39278.png +41759.png +03462.png +58298.png +01652.png +15431.png +69460.png +26208.png +17609.png +24845.png +46204.png +30728.png +13211.png +07585.png +57251.png +06722.png +46965.png +29721.png +52507.png +62793.png +17073.png +50394.png +44908.png +59016.png +48085.png +56256.png +56020.png +03740.png +44722.png +27251.png +04478.png +66709.png +05033.png +46752.png +52669.png +43675.png +62868.png +37993.png +65957.png +56060.png +49229.png +45881.png +38327.png +57132.png +31883.png +26210.png +69447.png +16822.png +69827.png +35465.png +21728.png +34039.png +17882.png +68175.png +27702.png +52114.png +52085.png +48701.png +03202.png +19395.png +31609.png +28745.png +38850.png +10692.png +28866.png +09590.png +20570.png +43050.png +07889.png +36114.png +42357.png +54863.png +67038.png +06090.png +25497.png +41712.png +02417.png +02039.png +42032.png +01846.png +59341.png +65739.png +58243.png +37289.png +10489.png +34577.png +50400.png +14720.png +30840.png +39280.png +24017.png +20232.png +17581.png +05139.png +01203.png +42150.png +48275.png +68073.png +04882.png +29868.png +32280.png +68071.png +09443.png +41775.png +32113.png +31171.png +16180.png +33803.png +57821.png +69085.png +66366.png +52632.png +40148.png +29876.png +67569.png +50924.png +25932.png +66858.png +64917.png +34964.png +35951.png +50964.png +18207.png +57293.png +46165.png +08884.png +63081.png +58038.png +42779.png +68804.png +56530.png +56273.png +38494.png +57150.png +33269.png +64318.png +46583.png +36955.png +01257.png +02638.png +48658.png +51328.png +07613.png +30003.png +18898.png +39329.png +31245.png +21183.png +27506.png +64128.png +60957.png +43464.png +09842.png +59038.png +48391.png +09972.png +69148.png +02296.png +62092.png +34973.png +40717.png +32698.png +51952.png +68094.png +68229.png +44110.png +44174.png +01460.png +67248.png +49015.png +10688.png +33198.png +38651.png +39434.png +51807.png +23192.png +18267.png +13511.png +04067.png +34136.png +24507.png +65854.png +31217.png +22757.png +07487.png +41199.png +06723.png +01372.png +41011.png +10320.png +51471.png +48958.png +12048.png +60363.png +54721.png +58119.png +21217.png +49875.png +14410.png +65034.png +00986.png +19582.png +12971.png +43957.png +10061.png +65612.png +05928.png +46269.png +12959.png +53412.png +60269.png +64186.png +42848.png +12175.png +67144.png +39618.png +55398.png +31997.png +13620.png +51307.png +56882.png +51428.png +17388.png +58988.png +33590.png +18184.png +23322.png +47168.png +64977.png +31967.png +49416.png +06460.png +36551.png +00866.png +12147.png +66295.png +21038.png +30428.png +17365.png +56025.png +00990.png +00934.png +06819.png +23688.png +35814.png +57183.png +35418.png +01136.png +48570.png +08419.png +55205.png +36099.png +44262.png +36642.png +58581.png +25343.png +19493.png +68758.png +35750.png +17493.png +20760.png +30156.png +11382.png +26063.png +44069.png +64787.png +09716.png +37556.png +64376.png +48027.png +51059.png +59451.png +12983.png +20300.png +50092.png +50528.png +23973.png +44765.png +59873.png +13346.png +64565.png +02451.png +38329.png +05199.png +01331.png +36385.png +49191.png +33894.png +45472.png +10952.png +42254.png +36384.png +26985.png +03355.png +38633.png +18462.png +60308.png +02013.png +01782.png +16371.png +17487.png +28510.png +41070.png +44019.png +47638.png +59332.png +38358.png +33152.png +55459.png +09488.png +41001.png +55047.png +66622.png +14513.png +52889.png +48200.png +07160.png +23303.png +57554.png +60176.png +18752.png +18912.png +58444.png +46622.png +05558.png +51837.png +37901.png +56259.png +19393.png +52539.png +09536.png +35584.png +07666.png +53811.png +05686.png +39268.png +07545.png +46837.png +23229.png +35673.png +27003.png +44789.png +65916.png +19532.png +15635.png +52906.png +48164.png +01233.png +07842.png +37642.png +07617.png +69211.png +47128.png +01779.png +47386.png +53996.png +09406.png +05086.png +57199.png +11238.png +11705.png +47848.png +09876.png +44846.png +23183.png +07420.png +52043.png +55239.png +18878.png +38776.png +68638.png +66455.png +47522.png +35640.png +35579.png +09299.png +42979.png +38245.png +42825.png +16227.png +12310.png +55672.png +44676.png +19384.png +51219.png +32651.png +09331.png +26908.png +18523.png +60025.png +14791.png +64076.png +17311.png +07644.png +19529.png +11450.png +64160.png +68608.png +67126.png +28880.png +55237.png +63907.png +10278.png +22026.png +38455.png +64532.png +23742.png +54152.png +62411.png +55012.png +45565.png +05893.png +41886.png +50806.png +65109.png +59125.png +05802.png +06037.png +45721.png +17651.png +28133.png +16661.png +32629.png +59483.png +00120.png +40157.png +67794.png +60516.png +68955.png +07529.png +54445.png +66837.png +31388.png +18376.png +66299.png +13282.png +03076.png +31596.png +48258.png +49942.png +21922.png +57186.png +00869.png +41793.png +18249.png +31179.png +42554.png +31430.png +09658.png +41193.png +40557.png +15599.png +38006.png +53787.png +68000.png +27500.png +18834.png +30008.png +43950.png +15346.png +12009.png +17524.png +30750.png +21614.png +18340.png +61906.png +36901.png +02626.png +32010.png +68989.png +60072.png +44191.png +16071.png +02749.png +36219.png +33329.png +57163.png +68805.png +53961.png +11322.png +59696.png +07981.png +45420.png +46651.png +17468.png +49375.png +32712.png +15659.png +49937.png +45277.png +35324.png +03277.png +34284.png +31751.png +03610.png +01254.png +30670.png +13126.png +22450.png +04894.png +27290.png +14594.png +37846.png +15935.png +37766.png +50656.png +13348.png +56948.png +00912.png +16907.png +51528.png +44451.png +53771.png +22934.png +04669.png +35145.png +48776.png +30284.png +47357.png +46287.png +07116.png +31273.png +10198.png +11995.png +42900.png +25599.png +33860.png +08712.png +11541.png +52876.png +10382.png +63128.png +44206.png +36815.png +65247.png +52071.png +59502.png +10093.png +28532.png +18201.png +39561.png +51876.png +40420.png +57958.png +63438.png +02694.png +59027.png +01826.png +68306.png +60901.png +56410.png +36185.png +40312.png +02020.png +68639.png +17912.png +28244.png +69934.png +02468.png +43967.png +32495.png +62762.png +54878.png +57969.png +07386.png +11296.png +54311.png +07864.png +55153.png +36152.png +33492.png +24008.png +25662.png +15333.png +32474.png +13164.png +31503.png +43951.png +03291.png +56637.png +25257.png +15225.png +67102.png +41693.png +20302.png +18502.png +46377.png +04036.png +25546.png +14077.png +32319.png +52719.png +03814.png +60611.png +28335.png +08137.png +48503.png +09215.png +52112.png +14219.png +59009.png +16349.png +63956.png +19790.png +00472.png +11175.png +13248.png +59943.png +29318.png +56473.png +57550.png +28185.png +51618.png +35495.png +10964.png +01602.png +50640.png +25977.png +45023.png +62029.png +24336.png +63321.png +08057.png +65203.png +13855.png +08188.png +28513.png +48280.png +15515.png +45759.png +22806.png +40325.png +16968.png +31098.png +07314.png +51106.png +69929.png +23940.png +56862.png +60773.png +50069.png +00946.png +24514.png +35107.png +26059.png +56369.png +40818.png +60133.png +22207.png +63327.png +28397.png +40928.png +42709.png +53658.png +05514.png +59362.png +31969.png +09960.png +09746.png +37029.png +69787.png +44496.png +47998.png +34528.png +25535.png +14962.png +05797.png +46993.png +58706.png +41080.png +53002.png +10329.png +11023.png +22081.png +64851.png +03089.png +51012.png +56992.png +41230.png +28827.png +17054.png +06192.png +37930.png +43089.png +07596.png +51637.png +69014.png +58992.png +37959.png +51350.png +48080.png +46504.png +61291.png +30697.png +35011.png +37759.png +39256.png +13766.png +58589.png +47655.png +40482.png +32663.png +66507.png +17883.png +60096.png +09225.png +44688.png +48573.png +37652.png +15224.png +55126.png +66903.png +58191.png +59118.png +61239.png +50898.png +42050.png +55540.png +06410.png +69159.png +00410.png +16223.png +53125.png +69980.png +25020.png +38938.png +55080.png +33663.png +39762.png +03738.png +29030.png +59212.png +53017.png +03516.png +38546.png +01504.png +25172.png +05540.png +64911.png +03256.png +07801.png +26585.png +64488.png +12540.png +18276.png +17819.png +29729.png +43170.png +42026.png +57599.png +44945.png +25692.png +02455.png +05306.png +17526.png +30890.png +42687.png +12370.png +26951.png +20305.png +10237.png +55694.png +59197.png +21564.png +26157.png +63433.png +30297.png +34667.png +13172.png +18461.png +21830.png +46740.png +11759.png +49405.png +60896.png +57627.png +13038.png +65926.png +46272.png +17841.png +24334.png +00269.png +18306.png +14584.png +44221.png +03150.png +23960.png +30208.png +58282.png +08078.png +10967.png +17767.png +40248.png +55451.png +34064.png +69356.png +50034.png +34862.png +41096.png +09759.png +25279.png +49883.png +60874.png +57450.png +37139.png +61611.png +05441.png +51073.png +17274.png +15633.png +09320.png +44468.png +16809.png +67833.png +45031.png +48399.png +67187.png +56332.png +26853.png +03199.png +17139.png +15857.png +12964.png +02612.png +64902.png +32033.png +54281.png +57013.png +48841.png +11068.png +05291.png +36866.png +65319.png +58966.png +55774.png +65624.png +47233.png +07184.png +25400.png +46022.png +02032.png +69810.png +13392.png +56583.png +41282.png +43961.png +38881.png +68774.png +69242.png +55868.png +24668.png +62568.png +04729.png +19701.png +33758.png +17650.png +16408.png +09994.png +21737.png +42499.png +04611.png +63238.png +62706.png +24242.png +24436.png +03987.png +47779.png +03973.png +18841.png +17692.png +16749.png +32060.png +28649.png +55580.png +37526.png +04038.png +03941.png +10152.png +29654.png +23244.png +32041.png +32772.png +15134.png +21229.png +58350.png +24043.png +04318.png +36278.png +49825.png +33206.png +64206.png +10853.png +47376.png +49428.png +09747.png +22141.png +39347.png +43852.png +19679.png +66493.png +37214.png +22455.png +14037.png +57338.png +13789.png +27257.png +03321.png +04077.png +48731.png +11431.png +61822.png +43878.png +18586.png +21080.png +63781.png +39868.png +49332.png +66847.png +19911.png +21633.png +37835.png +17593.png +69733.png +37623.png +68481.png +62741.png +35657.png +54699.png +45376.png +52724.png +01798.png +58579.png +40804.png +26008.png +06997.png +65998.png +20720.png +05548.png +54539.png +60685.png +40657.png +65224.png +59147.png +21821.png +62354.png +60649.png +07623.png +68405.png +30900.png +25308.png +49772.png +61435.png +37880.png +03919.png +15425.png +32717.png +45230.png +69069.png +25945.png +16120.png +03870.png +59717.png +22681.png +54762.png +59687.png +15696.png +02763.png +11402.png +43140.png +69953.png +63027.png +20515.png +31701.png +35743.png +25148.png +50727.png +09645.png +29862.png +47822.png +42599.png +10183.png +12679.png +38244.png +39114.png +58010.png +56740.png +63426.png +37246.png +09637.png +59089.png +37225.png +34175.png +68598.png +08273.png +11249.png +00502.png +68062.png +45024.png +60164.png +34694.png +00606.png +54717.png +59314.png +49131.png +11693.png +14497.png +28089.png +33998.png +32906.png +66279.png +63444.png +33459.png +24915.png +02265.png +14089.png +18892.png +52778.png +61340.png +00948.png +25317.png +14016.png +23087.png +62700.png +13048.png +32079.png +45189.png +53467.png +21707.png +43285.png +56774.png +67232.png +69072.png +67526.png +67634.png +28674.png +54645.png +59765.png +04475.png +54022.png +12225.png +23955.png +28956.png +68776.png +00204.png +25186.png +02981.png +55826.png +07655.png +21030.png +42400.png +53862.png +52541.png +09104.png +41751.png +38262.png +31417.png +15362.png +31871.png +54753.png +68475.png +24003.png +43311.png +11580.png +09373.png +10522.png +33961.png +56455.png +07315.png +32838.png +44136.png +18379.png +42884.png +25730.png +59127.png +43024.png +44173.png +45492.png +03747.png +43760.png +49426.png +03468.png +69785.png +38714.png +00558.png +41399.png +54755.png +06786.png +63766.png +50441.png +66015.png +39620.png +38856.png +59094.png +63330.png +60677.png +67425.png +54914.png +68206.png +49630.png +39532.png +68633.png +63577.png +44462.png +60377.png +05673.png +31077.png +06065.png +53269.png +04898.png +17038.png +37656.png +43323.png +46905.png +39814.png +67776.png +41161.png +10735.png +22004.png +22340.png +61304.png +01024.png +21303.png +60796.png +39380.png +13733.png +03310.png +07628.png +15313.png +53837.png +24381.png +18943.png +59695.png +29487.png +01640.png +49210.png +41045.png +27209.png +36802.png +65024.png +62837.png +47094.png +12177.png +00950.png +10117.png +03257.png +17877.png +59109.png +60708.png +11553.png +11650.png +68289.png +49472.png +47253.png +69549.png +20984.png +62280.png +58151.png +47928.png +40027.png +45950.png +65544.png +47983.png +26750.png +33251.png +47483.png +26165.png +06799.png +61203.png +46156.png +64056.png +31674.png +00663.png +13935.png +60307.png +62213.png +44937.png +64633.png +13893.png +34408.png +06323.png +56603.png +51274.png +54992.png +02261.png +38338.png +18791.png +17554.png +55208.png +32261.png +21368.png +34294.png +25519.png +64940.png +29582.png +28148.png +03354.png +35307.png +22738.png +20718.png +00485.png +24408.png +30433.png +66046.png +33615.png +38205.png +06394.png +32492.png +25615.png +00368.png +44157.png +17440.png +29437.png +22351.png +53448.png +33926.png +36478.png +02515.png +13736.png +26938.png +55198.png +66250.png +42377.png +37293.png +58476.png +17204.png +13371.png +32769.png +28394.png +28723.png +19551.png +60900.png +46610.png +27860.png +39569.png +10831.png +46285.png +07170.png +20287.png +33723.png +56701.png +24357.png +30294.png +10346.png +59659.png +69017.png +53604.png +00514.png +67058.png +18859.png +33386.png +04809.png +16186.png +10681.png +13863.png +51198.png +45307.png +48104.png +52344.png +02748.png +30694.png +07782.png +16242.png +16604.png +45344.png +53523.png +53425.png +28438.png +04483.png +32997.png +47171.png +10932.png +51659.png +18186.png +54848.png +38376.png +40443.png +44015.png +37367.png +41448.png +50196.png +30126.png +04692.png +61977.png +32017.png +18571.png +52556.png +68599.png +35025.png +29433.png +37050.png +20628.png +51894.png +17618.png +41582.png +50001.png +59911.png +34374.png +16951.png +51036.png +05600.png +60179.png +19415.png +48751.png +35110.png +67685.png +22645.png +40013.png +08984.png +26175.png +65499.png +50115.png +56157.png +47415.png +60778.png +65471.png +52861.png +09470.png +44733.png +40875.png +28496.png +00169.png +67501.png +21646.png +58690.png +66209.png +08414.png +32162.png +26439.png +21372.png +43866.png +31387.png +57710.png +47630.png +00870.png +64132.png +23617.png +67534.png +37137.png +29061.png +37076.png +34032.png +15360.png +27077.png +05060.png +58892.png +32510.png +16795.png +16775.png +69884.png +32062.png +26629.png +19134.png +17099.png +10375.png +49194.png +18762.png +23832.png +65413.png +60197.png +06967.png +27360.png +63365.png +59882.png +43211.png +03095.png +13271.png +69700.png +16959.png +01538.png +46948.png +32741.png +58565.png +19230.png +20939.png +22282.png +32447.png +21848.png +45976.png +59221.png +20229.png +67563.png +12326.png +33928.png +51403.png +15040.png +69269.png +29937.png +02521.png +61511.png +23549.png +43373.png +23336.png +64117.png +05234.png +55373.png +01330.png +18473.png +66196.png +62058.png +19987.png +22880.png +30206.png +05896.png +30232.png +55340.png +20607.png +17573.png +08315.png +52433.png +36237.png +29040.png +58471.png +34142.png +25473.png +61914.png +34795.png +65415.png +28894.png +33889.png +28219.png +37561.png +32485.png +30168.png +11828.png +10924.png +30676.png +32929.png +25961.png +60726.png +62646.png +41750.png +36840.png +04194.png +30990.png +30575.png +30749.png +37379.png +67457.png +45112.png +60424.png +17022.png +03120.png +16619.png +23840.png +31026.png +43539.png +29520.png +41786.png +51846.png +26479.png +44187.png +61579.png +19436.png +68163.png +01226.png +60815.png +57152.png +34367.png +01943.png +17079.png +62070.png +39809.png +65629.png +08896.png +19685.png +65158.png +65731.png +55285.png +50783.png +64740.png +23473.png +67673.png +03679.png +03523.png +53783.png +58945.png +26725.png +65432.png +20636.png +57253.png +27471.png +61142.png +28013.png +35143.png +17822.png +39083.png +46749.png +66322.png +61110.png +06966.png +36637.png +15882.png +20294.png +17733.png +46107.png +67547.png +27984.png +02188.png +30050.png +60641.png +04767.png +00281.png +27640.png +23878.png +25788.png +17177.png +58305.png +34640.png +37310.png +46776.png +12739.png +04598.png +64942.png +36779.png +56399.png +55653.png +20469.png +38632.png +42580.png +22086.png +67458.png +04762.png +21433.png +31865.png +64510.png +00646.png +62508.png +63534.png +41587.png +07450.png +19094.png +36809.png +08032.png +00375.png +58639.png +26678.png +05920.png +56730.png +64849.png +53014.png +48783.png +17249.png +69727.png +13451.png +05871.png +02164.png +14685.png +35724.png +39488.png +59384.png +47205.png +37521.png +46973.png +43418.png +05584.png +35532.png +31587.png +67201.png +21071.png +10889.png +02121.png +25574.png +12451.png +34218.png +48216.png +61728.png +44803.png +12416.png +39874.png +02830.png +26093.png +66188.png +66574.png +02909.png +05101.png +09068.png +07492.png +40908.png +42482.png +35404.png +65880.png +28712.png +11174.png +33672.png +58292.png +50842.png +37257.png +41706.png +51103.png +34751.png +21543.png +28264.png +62834.png +63849.png +00194.png +54460.png +50903.png +06325.png +01703.png +59266.png +52725.png +65356.png +23578.png +42843.png +62347.png +53946.png +41346.png +21402.png +02397.png +32758.png +39398.png +46930.png +12580.png +58091.png +61114.png +01150.png +01163.png +14832.png +40281.png +31342.png +30874.png +39837.png +65160.png +47925.png +29436.png +65252.png +37881.png +05374.png +35178.png +59869.png +00722.png +66626.png +30966.png +16974.png +51883.png +13856.png +32957.png +69714.png +68321.png +41320.png +55641.png +42861.png +20375.png +32964.png +26237.png +60769.png +55683.png +27742.png +23306.png +09614.png +02167.png +16024.png +08353.png +15624.png +56284.png +31078.png +41339.png +39466.png +29913.png +03292.png +63373.png +24374.png +10028.png +05207.png +53575.png +05282.png +03664.png +41663.png +46616.png +19617.png +31583.png +18686.png +03663.png +13086.png +41702.png +18476.png +22509.png +54928.png +33605.png +04434.png +15837.png +41873.png +50023.png +09589.png +61534.png +69432.png +33052.png +45985.png +25685.png +48394.png +53779.png +69839.png +15073.png +47863.png +36674.png +42046.png +66259.png +20704.png +11883.png +66309.png +44272.png +59030.png +39324.png +51251.png +26560.png +27534.png +19092.png +23405.png +32254.png +48607.png +50719.png +41101.png +07600.png +23111.png +08877.png +25670.png +36708.png +42164.png +23757.png +39238.png +39049.png +25747.png +50835.png +36129.png +59054.png +68778.png +21273.png +25947.png +64520.png +16744.png +30490.png +19875.png +26123.png +24744.png +10105.png +29150.png +41690.png +42437.png +39095.png +64802.png +11588.png +01089.png +09037.png +44354.png +38991.png +08939.png +57277.png +10271.png +18259.png +00962.png +26492.png +02980.png +58825.png +15110.png +34573.png +03429.png +24349.png +22438.png +41803.png +15689.png +45994.png +42807.png +60750.png +09708.png +59802.png +15472.png +14014.png +69868.png +19831.png +25689.png +29956.png +24592.png +65730.png +03303.png +49986.png +48492.png +48374.png +08585.png +62914.png +06055.png +53468.png +68401.png +06043.png +59100.png +05164.png +63276.png +57973.png +62166.png +29748.png +58207.png +44285.png +55572.png +06855.png +41634.png +15975.png +33783.png +47437.png +18055.png +02100.png +27523.png +03313.png +32016.png +50563.png +17117.png +03977.png +20553.png +61123.png +08159.png +58561.png +15863.png +04193.png +13692.png +01286.png +08169.png +27543.png +34365.png +22216.png +26094.png +34972.png +28386.png +51469.png +33001.png +41014.png +57970.png +06577.png +35001.png +13039.png +39366.png +34396.png +36959.png +18552.png +52078.png +41042.png +69636.png +33261.png +00145.png +09826.png +35172.png +28817.png +68887.png +12502.png +67053.png +37454.png +39374.png +27768.png +30628.png +61109.png +07919.png +37009.png +62143.png +00029.png +30462.png +56258.png +42923.png +13923.png +12921.png +21783.png +37420.png +36609.png +60070.png +14079.png +32854.png +62916.png +67133.png +09394.png +68445.png +17649.png +27826.png +65209.png +16338.png +17238.png +35354.png +25224.png +46428.png +31987.png +38893.png +55874.png +22031.png +07662.png +00421.png +40123.png +60044.png +15149.png +32694.png +58978.png +26281.png +36784.png +50497.png +31484.png +40033.png +16146.png +16718.png +08534.png +46696.png +24000.png +59701.png +42208.png +03825.png +45221.png +50080.png +47892.png +22841.png +39641.png +46424.png +06101.png +54912.png +00444.png +57402.png +13751.png +56804.png +53642.png +25731.png +32959.png +14370.png +11002.png +41987.png +23064.png +37253.png +44729.png +26261.png +08903.png +57088.png +40277.png +46842.png +08808.png +07779.png +42829.png +53904.png +68635.png +68680.png +67975.png +25862.png +57005.png +66730.png +42892.png +19037.png +65613.png +29741.png +27352.png +50989.png +59047.png +23964.png +24181.png +46470.png +17844.png +32515.png +34554.png +18242.png +64022.png +24200.png +21054.png +63792.png +00061.png +50579.png +26702.png +01665.png +63486.png +33383.png +58774.png +55698.png +58364.png +14880.png +41273.png +63201.png +68048.png +14463.png +69571.png +26964.png +37563.png +66541.png +23337.png +03109.png +40525.png +14153.png +30988.png +68620.png +15629.png +61905.png +06437.png +35670.png +61438.png +22683.png +20318.png +17088.png +07231.png +59718.png +16893.png +46578.png +07397.png +29977.png +53608.png +56067.png +35020.png +60840.png +57076.png +52106.png +63459.png +44910.png +36886.png +18497.png +39969.png +63294.png +60413.png +37695.png +08365.png +47291.png +39422.png +03573.png +49442.png +02832.png +56985.png +06963.png +17828.png +61289.png +50172.png +30416.png +07571.png +23542.png +35026.png +53424.png +35931.png +04658.png +39831.png +30368.png +58395.png +00370.png +63847.png +44862.png +69370.png +46591.png +50490.png +14414.png +03143.png +55574.png +27563.png +12877.png +57374.png +10573.png +29291.png +14449.png +22359.png +16248.png +35205.png +13313.png +41098.png +43596.png +51797.png +08417.png +15706.png +34484.png +43903.png +47836.png +23534.png +11913.png +29936.png +45166.png +57975.png +20640.png +04302.png +43233.png +35732.png +28104.png +48793.png +45631.png +12203.png +25230.png +46312.png +58094.png +53157.png +01365.png +11004.png +69319.png +29615.png +54748.png +48038.png +69160.png +15892.png +68412.png +45539.png +13103.png +05036.png +56331.png +17596.png +52831.png +02761.png +24492.png +61555.png +46579.png +69222.png +33986.png +41186.png +31268.png +52158.png +45480.png +67570.png +53205.png +56306.png +36182.png +58761.png +61372.png +33380.png +48106.png +40311.png +17961.png +08809.png +08691.png +32975.png +36267.png +44059.png +32567.png +51583.png +06840.png +30812.png +06654.png +28732.png +65205.png +38725.png +40333.png +68997.png +06713.png +55055.png +42203.png +39225.png +08058.png +27552.png +07208.png +55220.png +32536.png +32602.png +22142.png +40307.png +23521.png +03301.png +34273.png +67648.png +04012.png +67903.png +04144.png +41937.png +60962.png +31971.png +43983.png +07036.png +14085.png +35187.png +45035.png +40412.png +22478.png +10311.png +13343.png +19463.png +00557.png +39821.png +47475.png +23099.png +44969.png +41429.png +22471.png +59577.png +32674.png +13628.png +23288.png +29842.png +09905.png +20784.png +32711.png +51798.png +26421.png +42613.png +34416.png +64156.png +30616.png +10848.png +46526.png +43297.png +54218.png +57503.png +68376.png +04984.png +65806.png +37157.png +49028.png +64722.png +25405.png +43326.png +59759.png +19342.png +66346.png +65210.png +07428.png +14848.png +28839.png +13591.png +47736.png +03666.png +22262.png +16029.png +24969.png +46735.png +66984.png +34997.png +14327.png +50443.png +14334.png +52253.png +05112.png +00980.png +33855.png +33954.png +26970.png +18600.png +43390.png +35216.png +22082.png +45287.png +62639.png +45477.png +34000.png +01358.png +03294.png +43699.png +31702.png +40672.png +17000.png +57118.png +18724.png +07582.png +64753.png +54012.png +21516.png +67631.png +25281.png +41799.png +59936.png +43093.png +61341.png +63185.png +21775.png +19024.png +61601.png +46815.png +64271.png +55314.png +41284.png +38178.png +12878.png +35151.png +47878.png +16043.png +29872.png +04544.png +12221.png +47556.png +44337.png +42457.png +43410.png +59045.png +53813.png +02334.png +40570.png +33896.png +38754.png +21755.png +37700.png +66234.png +07392.png +65672.png +45422.png +51562.png +05158.png +38715.png +51253.png +47374.png +65985.png +63166.png +10461.png +30340.png +06585.png +06804.png +49404.png +47490.png +32195.png +56368.png +10452.png +25135.png +11259.png +38220.png +41016.png +21579.png +61838.png +13968.png +11303.png +46894.png +56349.png +64275.png +69588.png +64811.png +09390.png +11622.png +64205.png +53114.png +17373.png +24926.png +39003.png +53450.png +25835.png +39272.png +23469.png +28602.png +47834.png +45436.png +67009.png +13601.png +31816.png +00546.png +60975.png +03871.png +48824.png +47659.png +16269.png +56328.png +69684.png +61005.png +04183.png +07455.png +51903.png +30224.png +53926.png +35409.png +45262.png +53650.png +07733.png +38373.png +33878.png +22807.png +15894.png +37547.png +22048.png +25680.png +54766.png +21939.png +23559.png +10597.png +04410.png +37965.png +35314.png +10176.png +03091.png +52929.png +34005.png +17202.png +68613.png +19635.png +41908.png +05191.png +57982.png +49738.png +41862.png +18831.png +58443.png +34177.png +51387.png +35932.png +08178.png +41787.png +38510.png +47265.png +19624.png +47849.png +33462.png +55855.png +52712.png +50431.png +25871.png +37060.png +40647.png +04950.png +65454.png +43935.png +08524.png +51149.png +32417.png +54275.png +19877.png +52670.png +55380.png +60386.png +13613.png +33718.png +16447.png +60771.png +45772.png +49514.png +27139.png +34181.png +42316.png +04437.png +47169.png +09627.png +64632.png +03696.png +14948.png +07619.png +40198.png +43444.png +07475.png +02927.png +02822.png +16188.png +25720.png +55364.png +60805.png +65017.png +06710.png +01906.png +56363.png +22582.png +15137.png +43793.png +65352.png +67132.png +22694.png +62670.png +41836.png +68117.png +42586.png +41930.png +68636.png +14906.png +17568.png +32857.png +31047.png +31698.png +61771.png +23461.png +65662.png +11795.png +22871.png +68272.png +66585.png +21740.png +30809.png +43289.png +24172.png +15835.png +15587.png +37045.png +68332.png +60123.png +44302.png +45622.png +55576.png +20894.png +29051.png +40361.png +51948.png +68772.png +65741.png +07466.png +18524.png +23863.png +05006.png +38827.png +31666.png +43833.png +32765.png +57130.png +46713.png +50753.png +67604.png +20060.png +54589.png +62170.png +19020.png +17945.png +55291.png +01743.png +67355.png +49162.png +33868.png +07645.png +62654.png +61281.png +57294.png +10215.png +19472.png +09561.png +16064.png +69922.png +31655.png +31968.png +57090.png +07967.png +32496.png +49983.png +69832.png +06660.png +02083.png +49989.png +60675.png +24773.png +54206.png +42934.png +09823.png +22265.png +33082.png +25673.png +22759.png +10302.png +48442.png +00941.png +07815.png +65972.png +64614.png +00347.png +54503.png +52913.png +38828.png +50872.png +44002.png +67033.png +17962.png +10660.png +42069.png +56414.png +39614.png +17864.png +56824.png +00422.png +40601.png +67620.png +56648.png +60607.png +59523.png +16937.png +58184.png +68365.png +49270.png +66948.png +18397.png +12937.png +41914.png +43267.png +54383.png +29047.png +46854.png +29200.png +48732.png +03289.png +55384.png +63948.png +39839.png +48487.png +00499.png +27992.png +15354.png +02593.png +11316.png +18881.png +06193.png +17138.png +18639.png +48292.png +57713.png +26846.png +40507.png +22698.png +14379.png +58930.png +49254.png +22133.png +55531.png +48054.png +68543.png +22915.png +66038.png +37890.png +49477.png +16302.png +64694.png +68810.png +63674.png +22725.png +37386.png +50818.png +00409.png +06294.png +41633.png +10963.png +26952.png +61176.png +47470.png +05487.png +58794.png +27347.png +08632.png +63047.png +37872.png +25263.png +15029.png +34202.png +61119.png +65646.png +26166.png +54474.png +62132.png +06284.png +37557.png +18574.png +63491.png +64623.png +43209.png +17160.png +10611.png +63811.png +35470.png +25658.png +23577.png +21186.png +07605.png +28375.png +21293.png +42955.png +56461.png +66248.png +08386.png +05615.png +46843.png +34003.png +31300.png +41641.png +02029.png +61925.png +69997.png +28630.png +69229.png +21034.png +16479.png +38333.png +69959.png +63396.png +21869.png +17944.png +48498.png +29252.png +06789.png +50555.png +29446.png +32090.png +57763.png +62673.png +00184.png +57839.png +48256.png +10825.png +48168.png +65737.png +50573.png +61776.png +05566.png +33015.png +69256.png +42263.png +01999.png +67106.png +69916.png +52639.png +68899.png +01047.png +05604.png +14737.png +21501.png +36640.png +27034.png +37897.png +03980.png +40653.png +10523.png +08608.png +07375.png +11070.png +18629.png +62810.png +60210.png +17345.png +01160.png +33294.png +09409.png +53287.png +44943.png +55215.png +40998.png +67064.png +05055.png +48076.png +55374.png +05684.png +15466.png +64258.png +17850.png +18767.png +41507.png +11104.png +15819.png +64187.png +20998.png +01981.png +35591.png +44606.png +35147.png +28739.png +49123.png +34712.png +55338.png +30502.png +15434.png +14765.png +40364.png +35595.png +27844.png +00675.png +28877.png +07398.png +24389.png +65732.png +24473.png +49059.png +40700.png +23479.png +69646.png +12178.png +62032.png +56102.png +61152.png +49532.png +13281.png +35878.png +68651.png +33781.png +08593.png +45652.png +37317.png +32296.png +45044.png +02602.png +12528.png +35799.png +10108.png +10383.png +67237.png +44443.png +02505.png +27930.png +02616.png +37479.png +24726.png +08382.png +49287.png +59633.png +28737.png +34948.png +53074.png +42660.png +39644.png +56533.png +13711.png +43292.png +28005.png +47313.png +23478.png +59846.png +13387.png +50091.png +31082.png +43360.png +41638.png +66773.png +63233.png +03065.png +13642.png +42206.png +34553.png +10745.png +01356.png +68566.png +32554.png +15582.png +65988.png +44094.png +52687.png +00166.png +53360.png +67682.png +39818.png +08349.png +31559.png +64287.png +35250.png +42766.png +00867.png +38411.png +47597.png +44900.png +36566.png +10708.png +43849.png +49126.png +34591.png +18512.png +12185.png +43455.png +09275.png +25990.png +59644.png +00305.png +05402.png +32853.png +65426.png +17753.png +60236.png +02327.png +67285.png +33642.png +35414.png +20987.png +46358.png +03115.png +29914.png +08019.png +42084.png +61852.png +48486.png +55202.png +48294.png +52287.png +06699.png +21586.png +36723.png +25028.png +15130.png +25269.png +14299.png +01864.png +19434.png +54973.png +66654.png +11488.png +49583.png +43215.png +04632.png +01206.png +37622.png +09921.png +69466.png +61695.png +03032.png +01721.png +49244.png +14416.png +32992.png +25793.png +69638.png +23744.png +56578.png +68230.png +14464.png +55752.png +17851.png +47025.png +54956.png +03787.png +31139.png +19404.png +09541.png +12826.png +08440.png +14101.png +29986.png +32681.png +60359.png +00048.png +40151.png +19487.png +22960.png +02998.png +03096.png +05219.png +55541.png +69498.png +28707.png +35391.png +31365.png +58496.png +41254.png +40988.png +47040.png +16265.png +10274.png +64592.png +60834.png +31453.png +57935.png +36937.png +69433.png +19432.png +59263.png +30897.png +67299.png +27496.png +46041.png +26816.png +22860.png +26854.png +64853.png +02150.png +05175.png +42218.png +31086.png +59596.png +56828.png +19879.png +63648.png +06783.png +50063.png +32328.png +23309.png +11954.png +52166.png +61930.png +26849.png +62965.png +55870.png +30886.png +15903.png +55816.png +63049.png +11928.png +54880.png +00095.png +26010.png +40302.png +07785.png +21684.png +31603.png +37667.png +05010.png +18869.png +35842.png +12255.png +41243.png +34489.png +35154.png +05025.png +40512.png +29183.png +01574.png +43617.png +05493.png +34698.png +15151.png +40924.png +30214.png +08580.png +49008.png +26957.png +56340.png +60309.png +46695.png +24675.png +40010.png +23277.png +00656.png +20304.png +53098.png +22520.png +49066.png +19380.png +39464.png +32547.png +56460.png +16417.png +32958.png +65780.png +15720.png +51031.png +25019.png +43574.png +61751.png +30321.png +66576.png +04917.png +49893.png +29095.png +64011.png +06787.png +58417.png +10466.png +45488.png +35256.png +09385.png +60301.png +24872.png +50124.png +28823.png +26666.png +01841.png +32846.png +51777.png +51488.png +15070.png +30985.png +34851.png +23339.png +51495.png +03850.png +57992.png +46770.png +61397.png +29763.png +09393.png +63803.png +41350.png +59059.png +32365.png +16485.png +07608.png +29329.png +09554.png +66772.png +68583.png +54191.png +45187.png +32840.png +08341.png +05424.png +19660.png +53010.png +28557.png +57026.png +27070.png +63817.png +54852.png +40851.png +57108.png +46246.png +01970.png +50891.png +39472.png +53691.png +30233.png +30025.png +32805.png +46946.png +26112.png +37047.png +62071.png +43127.png +09082.png +68449.png +45691.png +24764.png +40103.png +62789.png +61044.png +36235.png +63333.png +51119.png +30666.png +23922.png +06529.png +63582.png +47766.png +23702.png +53100.png +29204.png +59155.png +20267.png +25781.png +06154.png +32098.png +44224.png +12824.png +28238.png +39806.png +03619.png +28213.png +55115.png +12819.png +41044.png +26000.png +12969.png +33562.png +14891.png +23090.png +16147.png +17919.png +15845.png +32032.png +34625.png +08177.png +52129.png +47193.png +52566.png +15831.png +01029.png +21912.png +46261.png +21219.png +57989.png +66323.png +06163.png +01059.png +48262.png +39352.png +00680.png +10273.png +31310.png +35218.png +65386.png +17201.png +61587.png +52245.png +69642.png +19006.png +08601.png +43053.png +00459.png +62274.png +14524.png +35601.png +65682.png +46380.png +43459.png +61888.png +03668.png +69406.png +57331.png +52902.png +06676.png +08929.png +29317.png +54211.png +63802.png +02884.png +61725.png +52737.png +52937.png +42360.png +59010.png +56120.png +04952.png +11148.png +39942.png +13838.png +42836.png +66277.png +57020.png +57734.png +16491.png +50679.png +60937.png +05079.png +36425.png +39423.png +38402.png +12901.png +49283.png +13702.png +24685.png +55521.png +14055.png +04911.png +23251.png +58227.png +58397.png +20043.png +48914.png +68435.png +49912.png +15240.png +27207.png +35042.png +34474.png +19835.png +49125.png +49324.png +52547.png +47695.png +20069.png +25839.png +20483.png +13182.png +41625.png +17809.png +29396.png +00575.png +03927.png +63629.png +23558.png +30637.png +51754.png +54511.png +57882.png +42977.png +54882.png +08641.png +43489.png +47206.png +29101.png +10308.png +33093.png +42538.png +63458.png +48602.png +10065.png +30943.png +04647.png +38024.png +02389.png +17656.png +05905.png +04270.png +39867.png +62503.png +49143.png +41229.png +45064.png +33748.png +21523.png +17574.png +65698.png +10699.png +01939.png +60699.png +65490.png +02028.png +47839.png +13936.png +29054.png +10818.png +22398.png +65286.png +15146.png +20746.png +51301.png +67818.png +10946.png +46151.png +28207.png +46329.png +23212.png +34601.png +52356.png +05082.png +23581.png +40495.png +39631.png +38115.png +25282.png +53569.png +38988.png +61078.png +35372.png +58954.png +55819.png +01302.png +62048.png +00657.png +32662.png +55775.png +28955.png +30920.png +57723.png +45084.png +12246.png +39927.png +10374.png +16399.png +13461.png +66923.png +32333.png +10559.png +27713.png +60468.png +65261.png +15743.png +17789.png +20563.png +47049.png +13260.png +18420.png +42301.png +66993.png +45414.png +49139.png +63557.png +10260.png +18458.png +54100.png +23390.png +64294.png +21051.png +18648.png +15647.png +02286.png +18139.png +39650.png +59806.png +41478.png +19535.png +13065.png +30119.png +32099.png +38779.png +52877.png +44273.png +06927.png +17006.png +01696.png +51688.png +69881.png +47315.png +55709.png +57696.png +23630.png +48850.png +29202.png +55052.png +12663.png +50887.png +26371.png +53143.png +05748.png +23917.png +41563.png +67149.png +36380.png +01343.png +67433.png +24949.png +38724.png +02254.png +64247.png +52999.png +62613.png +52130.png +39400.png +68634.png +17925.png +64560.png +54954.png +48770.png +24743.png +26864.png +16529.png +19779.png +32362.png +14694.png +23912.png +66115.png +65404.png +21967.png +69635.png +37658.png +08409.png +69730.png +05357.png +42978.png +54688.png +02599.png +53171.png +65009.png +41460.png +06157.png +39195.png +58740.png +43999.png +54013.png +69913.png +08094.png +39286.png +32891.png +10565.png +67094.png +11524.png +00466.png +43609.png +62956.png +30370.png +66814.png +62629.png +35508.png +01583.png +52734.png +30106.png +16207.png +15562.png +68129.png +46066.png +63763.png +37243.png +32380.png +39421.png +36059.png +30913.png +53671.png +35135.png +03675.png +20730.png +66146.png +53759.png +68303.png +34728.png +25985.png +30459.png +17621.png +68017.png +40688.png +69454.png +43981.png +40047.png +31374.png +20945.png +56959.png +55369.png +29357.png +68330.png +24199.png +10112.png +07268.png +18655.png +19322.png +67999.png +54496.png +60772.png +20225.png +02372.png +42095.png +18795.png +14691.png +37979.png +52774.png +14127.png +06742.png +66468.png +16909.png +47182.png +55509.png +24474.png +63494.png +67923.png +45934.png +66511.png +18503.png +53462.png +45540.png +14569.png +08444.png +04440.png +65585.png +42268.png +05422.png +00641.png +54850.png +33736.png +65264.png +38253.png +03818.png +38884.png +06830.png +09333.png +33219.png +11291.png +11371.png +21918.png +12931.png +58493.png +03383.png +40821.png +08375.png +38105.png +54994.png +45850.png +32294.png +29140.png +53399.png +44252.png +56335.png +37793.png +21097.png +66280.png +14916.png +02218.png +38793.png +49115.png +53685.png +62221.png +11439.png +43711.png +45516.png +21066.png +58989.png +59458.png +04094.png +58764.png +68037.png +31519.png +57490.png +64086.png +58958.png +45491.png +16746.png +67339.png +46542.png +68433.png +10388.png +11926.png +64385.png +26769.png +58682.png +05130.png +16886.png +57704.png +18538.png +24575.png +31862.png +47423.png +15875.png +28946.png +59178.png +48619.png +36110.png +12600.png +24313.png +38568.png +49907.png +10941.png +18951.png +08541.png +46550.png +39803.png +19000.png +31249.png +49548.png +24815.png +54678.png +00005.png +48300.png +27717.png +58477.png +65587.png +64618.png +26058.png +01561.png +38097.png +01928.png +39605.png +53323.png +61920.png +59771.png +41673.png +48994.png +17427.png +56159.png +61201.png +16672.png +59397.png +43988.png +09610.png +17750.png +08724.png +12620.png +16441.png +26519.png +16400.png +04678.png +24431.png +09217.png +51537.png +24842.png +13774.png +51352.png +61425.png +30245.png +36536.png +14401.png +58093.png +41298.png +30495.png +15574.png +65120.png +19976.png +12519.png +28584.png +16220.png +50218.png +22161.png +66212.png +58216.png +09793.png +32582.png +06432.png +25370.png +27737.png +05888.png +50126.png +31738.png +08756.png +34184.png +49539.png +38874.png +12047.png +05555.png +62006.png +39943.png +33083.png +34013.png +01327.png +49020.png +02186.png +65272.png +27324.png +04202.png +61314.png +04864.png +57983.png +13424.png +49402.png +06862.png +29387.png +66721.png +57410.png +42510.png +24487.png +63183.png +07937.png +06334.png +14955.png +45562.png +54463.png +35168.png +69488.png +20854.png +53722.png +21749.png +03146.png +56299.png +12201.png +51174.png +46821.png +21199.png +51165.png +37792.png +35478.png +01126.png +65449.png +43461.png +01815.png +02954.png +40097.png +05737.png +17178.png +07445.png +59269.png +21613.png +02288.png +19031.png +20196.png +09411.png +21880.png +13526.png +53936.png +04605.png +59526.png +42349.png +22640.png +09330.png +01349.png +69945.png +31385.png +03448.png +10448.png +14157.png +13894.png +37755.png +43008.png +07088.png +64788.png +12397.png +24044.png +30857.png +32855.png +19725.png +47071.png +49053.png +57247.png +32026.png +06377.png +43119.png +10782.png +20270.png +58744.png +30801.png +62778.png +28092.png +24451.png +47083.png +32520.png +13267.png +49067.png +48814.png +64013.png +05685.png +18200.png +47322.png +17319.png +23395.png +33584.png +17293.png +01378.png +34134.png +58550.png +19932.png +10181.png +46633.png +48423.png +30358.png +68483.png +08429.png +13291.png +50271.png +11662.png +00165.png +11743.png +21403.png +53737.png +31626.png +01670.png +65086.png +05265.png +68892.png +21438.png +30317.png +39232.png +54308.png +10221.png +03756.png +22781.png +67852.png +17562.png +33071.png +43042.png +33104.png +56579.png +08650.png +34332.png +01366.png +03411.png +12308.png +29715.png +12848.png +11054.png +68204.png +32088.png +07982.png +58280.png +32991.png +02613.png +23769.png +42039.png +56585.png +03627.png +35787.png +69066.png +13373.png +12859.png +68226.png +68522.png +06536.png +33975.png +11571.png +55727.png +64949.png +03500.png +53972.png +26632.png +18615.png +38597.png +10039.png +66912.png +30688.png +07553.png +06423.png +33308.png +22010.png +51734.png +16332.png +24212.png +22792.png +62727.png +33012.png +49116.png +60717.png +39243.png +22073.png +35716.png +19997.png +19418.png +66552.png +47005.png +05052.png +29620.png +52018.png +35653.png +43689.png +19838.png +64585.png +39776.png +36215.png +53163.png +63127.png +46267.png +36845.png +00515.png +31088.png +17113.png +45886.png +26687.png +48082.png +56378.png +02395.png +15454.png +29816.png +15768.png +63546.png +44998.png +35451.png +54407.png +40771.png +52292.png +64741.png +02634.png +03206.png +54576.png +48071.png +43401.png +26871.png +03361.png +67810.png +65054.png +04747.png +00405.png +19388.png +47159.png +54492.png +66029.png +35313.png +10222.png +15990.png +49448.png +20498.png +17371.png +52008.png +11196.png +24329.png +05248.png +29006.png +14385.png +17309.png +61621.png +21503.png +43268.png +19770.png +42725.png +08368.png +03171.png +38219.png +02263.png +35698.png +61516.png +09869.png +44752.png +69877.png +53886.png +21465.png +04105.png +55322.png +15529.png +53644.png +05434.png +28273.png +18870.png +54136.png +02768.png +06434.png +16277.png +26535.png +14126.png +19227.png +23013.png +01139.png +24919.png +23268.png +26340.png +58012.png +01483.png +17675.png +58683.png +43422.png +52714.png +07755.png +51565.png +39443.png +64873.png +53368.png +60869.png +68059.png +15974.png +52369.png +06664.png +04093.png +39811.png +03606.png +59008.png +49811.png +12259.png +63429.png +06810.png +51120.png +58153.png +11339.png +39901.png +13662.png +51483.png +12374.png +31889.png +42350.png +43898.png +34668.png +09441.png +55297.png +39793.png +41305.png +03708.png +59287.png +17845.png +29945.png +24990.png +51014.png +47179.png +29736.png +21686.png +03534.png +25124.png +38574.png +57486.png +41947.png +31884.png +07861.png +04273.png +45141.png +37712.png +53866.png +67172.png +28522.png +12645.png +59450.png +60698.png +01521.png +21010.png +48351.png +56014.png +65942.png +00838.png +41975.png +14195.png +19690.png +62952.png +68199.png +05941.png +50234.png +05485.png +49806.png +27744.png +28783.png +47369.png +29742.png +62699.png +07576.png +25204.png +59111.png +53715.png +22159.png +65562.png +01001.png +00297.png +14411.png +63351.png +12383.png +17992.png +50540.png +42872.png +65041.png +02791.png +57916.png +18589.png +50021.png +44170.png +62421.png +65816.png +07130.png +43576.png +23169.png +18810.png +60693.png +07502.png +16323.png +52305.png +36893.png +10875.png +34882.png +28322.png +62676.png +52595.png +25060.png +32902.png +49427.png +47036.png +38507.png +51104.png +61429.png +04090.png +23389.png +58899.png +32775.png +47344.png +69860.png +64094.png +11151.png +65835.png +07513.png +36474.png +53343.png +62640.png +00752.png +41744.png +38471.png +64494.png +47330.png +66324.png +60508.png +52468.png +64455.png +18654.png +62950.png +34025.png +32338.png +35170.png +30614.png +45808.png +56471.png +37357.png +17996.png +33165.png +14048.png +68542.png +29196.png +52450.png +10567.png +05677.png +48313.png +35398.png +58852.png +41311.png +50765.png +58797.png +60322.png +05054.png +63051.png +21044.png +07993.png +04517.png +43685.png +28897.png +33827.png +07862.png +43526.png +00330.png +65710.png +06063.png +58373.png +57058.png +11245.png +36164.png +37201.png +59217.png +23092.png +33727.png +36247.png +11397.png +67552.png +22636.png +62102.png +48206.png +65994.png +35590.png +53364.png +15573.png +57590.png +18965.png +46265.png +12689.png +28678.png +45726.png +07052.png +29280.png +59602.png +53301.png +28544.png +53714.png +22174.png +47387.png +47178.png +36604.png +29171.png +17384.png +31137.png +41100.png +21426.png +01129.png +09192.png +18612.png +48738.png +43686.png +46471.png +41532.png +22286.png +07578.png +69240.png +28110.png +36401.png +16404.png +17376.png +36418.png +22319.png +35333.png +34310.png +47739.png +20610.png +38313.png +42981.png +49383.png +58611.png +47239.png +19359.png +60733.png +54030.png +46241.png +45461.png +37227.png +24681.png +21679.png +02181.png +67186.png +03592.png +35895.png +05338.png +67567.png +41572.png +19391.png +46804.png +46409.png +01572.png +50696.png +03865.png +61353.png +55131.png +57095.png +32473.png +58047.png +52408.png +48541.png +67366.png +48326.png +33266.png +03719.png +44823.png +41758.png +07972.png +35447.png +61746.png +07627.png +17585.png +59277.png +59496.png +43667.png +38654.png +44554.png +60664.png +26975.png +53129.png +64908.png +59102.png +28384.png +62602.png +34495.png +17374.png +35645.png +24583.png +43850.png +41236.png +10485.png +40856.png +51814.png +30169.png +49273.png +51268.png +43250.png +65776.png +41377.png +29506.png +65305.png +20436.png +64744.png +04187.png +49932.png +67905.png +26435.png +16304.png +55275.png +60092.png +40907.png +27435.png +28996.png +61455.png +65424.png +28364.png +37058.png +17548.png +05576.png +07426.png +45563.png +44441.png +59963.png +62573.png +43110.png +57611.png +65472.png +06223.png +32243.png +56367.png +21291.png +13102.png +14934.png +46144.png +66793.png +01789.png +08033.png +64242.png +45564.png +34338.png +64214.png +48320.png +62117.png +14109.png +36571.png +41122.png +58985.png +56945.png +69334.png +47823.png +36262.png +11753.png +44555.png +12132.png +08637.png +00489.png +22178.png +62703.png +18501.png +24036.png +39849.png +45337.png +40576.png +59309.png +50742.png +49701.png +25783.png +54825.png +02782.png +40957.png +25494.png +65002.png +18900.png +09504.png +68746.png +51261.png +17295.png +40646.png +62462.png +31201.png +58600.png +62506.png +32585.png +55984.png +52703.png +23161.png +69136.png +36227.png +49910.png +27695.png +47790.png +34656.png +00556.png +38804.png +67491.png +06579.png +60576.png +19992.png +42420.png +66321.png +16631.png +62174.png +20072.png +04888.png +52203.png +50195.png +14465.png +40776.png +44179.png +12798.png +40579.png +03085.png +06780.png +02621.png +10664.png +25786.png +48176.png +37690.png +27065.png +65494.png +51460.png +02119.png +17247.png +52646.png +50649.png +18253.png +25335.png +60032.png +32074.png +62661.png +09522.png +28883.png +00311.png +06313.png +08076.png +33385.png +05382.png +06329.png +66977.png +04392.png +53898.png +51474.png +39611.png +22448.png +66892.png +05380.png +46230.png +19184.png +47915.png +12542.png +45975.png +37075.png +23989.png +25727.png +38747.png +12549.png +49158.png +10515.png +13429.png +41210.png +32517.png +08284.png +57871.png +43457.png +00927.png +50743.png +03399.png +23893.png +38799.png +63311.png +56775.png +25277.png +43262.png +57597.png +16416.png +29193.png +40413.png +32360.png +07930.png +69113.png +10686.png +42855.png +37456.png +06645.png +54319.png +54068.png +39175.png +12883.png +15506.png +56806.png +54667.png +22834.png +01908.png +37832.png +28885.png +11272.png +22339.png +67749.png +16572.png +24686.png +44331.png +05147.png +48299.png +38535.png +21472.png +00158.png +07923.png +49901.png +17430.png +45007.png +28439.png +13973.png +36602.png +24479.png +16267.png +52127.png +37911.png +08343.png +45845.png +67824.png +62755.png +28504.png +23539.png +01099.png +14704.png +63093.png +18423.png +29010.png +07562.png +55134.png +14312.png +24437.png +51245.png +00758.png +28746.png +52783.png +30634.png +30421.png +20490.png +39940.png +54750.png +64597.png +59953.png +46920.png +24102.png +16221.png +68912.png +42505.png +40217.png +48600.png +15467.png +43954.png +48984.png +18290.png +02452.png +49676.png +54443.png +20369.png +16651.png +42587.png +07286.png +19850.png +47709.png +43306.png +24048.png +54360.png +68754.png +14275.png +49919.png +42425.png +67150.png +16806.png +30412.png +05083.png +63709.png +57863.png +32262.png +56065.png +68852.png +52594.png +05492.png +33845.png +11694.png +44541.png +15162.png +37101.png +55987.png +31464.png +33624.png +19244.png +24082.png +35851.png +20155.png +08999.png +50064.png +43169.png +42449.png +24687.png +16896.png +18102.png +34866.png +24058.png +15585.png +28291.png +49949.png +61195.png +16123.png +27720.png +67837.png +43319.png +46533.png +63280.png +58835.png +56854.png +09646.png +00363.png +09309.png +01752.png +38005.png +25330.png +40544.png +30205.png +33409.png +06146.png +32469.png +02908.png +09392.png +45794.png +25536.png +03214.png +63379.png +17230.png +49263.png +60871.png +43828.png +66084.png +27754.png +24610.png +41667.png +48415.png +17047.png +23384.png +10074.png +64745.png +62230.png +02581.png +10978.png +47683.png +12687.png +32311.png +36873.png +42597.png +01976.png +32475.png +47435.png +00803.png +28356.png +14120.png +36939.png +68043.png +38788.png +56575.png +32303.png +17985.png +44284.png +53332.png +27894.png +35831.png +01638.png +22120.png +54950.png +53557.png +15226.png +61582.png +07983.png +20420.png +29558.png +48767.png +14420.png +44474.png +35423.png +65934.png +29466.png +68934.png +33372.png +69257.png +60770.png +56615.png +42194.png +58513.png +28568.png +30102.png +37677.png +69330.png +55934.png +23142.png +19284.png +03580.png +12624.png +15123.png +68337.png +20105.png +44288.png +65803.png +48167.png +51838.png +52513.png +28683.png +30947.png +13677.png +51912.png +07855.png +05056.png +01435.png +52353.png +10313.png +29566.png +58220.png +35984.png +00041.png +65064.png +49018.png +36945.png +47325.png +48970.png +60374.png +66416.png +19055.png +10957.png +57589.png +18317.png +10339.png +43583.png +41430.png +60956.png +53344.png +34344.png +29795.png +49019.png +00516.png +65229.png +39596.png +27461.png +31867.png +21313.png +13651.png +13882.png +54735.png +05695.png +11944.png +41287.png +68556.png +07898.png +29637.png +48024.png +28193.png +39391.png +66097.png +53836.png +54613.png +18486.png +38070.png +02377.png +23020.png +30281.png +60450.png +36390.png +52524.png +11254.png +67397.png +11365.png +28751.png +64181.png +21345.png +63903.png +50105.png +56547.png +15102.png +18844.png +35562.png +52802.png +28903.png +03945.png +12887.png +66786.png +56384.png +45559.png +69325.png +14577.png +18927.png +04229.png +24509.png +56185.png +40001.png +34764.png +31860.png +16109.png +46922.png +63873.png +62839.png +03498.png +03879.png +57229.png +16444.png +13244.png +65611.png +30423.png +37177.png +54712.png +11393.png +06845.png +62897.png +06988.png +11419.png +24895.png +63547.png +19093.png +19025.png +67990.png +30586.png +27817.png +62116.png +60852.png +33431.png +62756.png +11102.png +03127.png +68520.png +05531.png +01069.png +66213.png +66266.png +53519.png +27033.png +30158.png +00574.png +06147.png +32763.png +59785.png +59172.png +15189.png +39148.png +57192.png +21680.png +16139.png +21521.png +14461.png +14346.png +19916.png +46303.png +15314.png +32323.png +48346.png +29445.png +59095.png +33186.png +15722.png +33989.png +22903.png +39402.png +38836.png +21363.png +07909.png +16924.png +23905.png +25248.png +56439.png +29421.png +35634.png +14725.png +01790.png +42960.png +62734.png +62593.png +57418.png +13846.png +52415.png +66441.png +62077.png +17632.png +31755.png +04336.png +48502.png +69765.png +24528.png +25904.png +36954.png +16904.png +15555.png +40797.png +20755.png +66470.png +02576.png +63691.png +12165.png +06331.png +03236.png +19051.png +07693.png +02026.png +49189.png +02109.png +13185.png +26966.png +59477.png +27011.png +39550.png +17744.png +39572.png +00486.png +43729.png +36165.png +60899.png +06515.png +01935.png +47713.png +59145.png +56919.png +37242.png +21309.png +34789.png +64457.png +36825.png +12718.png +13732.png +59434.png +42948.png +48142.png +58025.png +55761.png +33714.png +28085.png +60144.png +12301.png +59838.png +22008.png +66095.png +33996.png +32341.png +19892.png +17433.png +06427.png +44529.png +52260.png +05266.png +59929.png +20932.png +11420.png +69258.png +30606.png +10263.png +14455.png +61414.png +53353.png +25449.png +43052.png +37654.png +58974.png +24513.png +43420.png +56817.png +38663.png +12483.png +65321.png +04516.png +57233.png +30091.png +56577.png +06542.png +17903.png +27406.png +21026.png +44426.png +04430.png +37369.png +36529.png +64189.png +03623.png +50404.png +35085.png +34797.png +47337.png +66245.png +37599.png +02622.png +32049.png +58512.png +16633.png +15480.png +30268.png +27733.png +57987.png +10915.png +27006.png +08310.png +53847.png +63470.png +65021.png +65794.png +04073.png +64216.png +38781.png +17655.png +61872.png +21204.png +15514.png +58312.png +21180.png +49500.png +54090.png +02531.png +21814.png +31243.png +42952.png +30196.png +62954.png +60595.png +10507.png +09511.png +61933.png +38832.png +13137.png +16135.png +08455.png +21706.png +30707.png +28748.png +01296.png +50965.png +00862.png +51305.png +04940.png +58233.png +17013.png +59561.png +01470.png +25037.png +64783.png +37397.png +47932.png +40752.png +56334.png +36670.png +56046.png +66618.png +63084.png +00492.png +17606.png +40260.png +51723.png +46404.png +35415.png +14119.png +42463.png +06059.png +35199.png +42508.png +05475.png +14896.png +46678.png +18198.png +55878.png +07500.png +55317.png +32500.png +60345.png +07442.png +69333.png +37641.png +13850.png +10802.png +09137.png +47195.png +38388.png +67695.png +22654.png +29385.png +32316.png +43498.png +53120.png +06877.png +54184.png +33378.png +44058.png +14717.png +21850.png +43092.png +06601.png +43230.png +69142.png +00346.png +06750.png +15972.png +26963.png +36402.png +37572.png +49881.png +40831.png +13673.png +59265.png +08249.png +60807.png +29288.png +16246.png +47664.png +67874.png +00054.png +58897.png +48246.png +63617.png +40602.png +51499.png +17318.png +48538.png +20133.png +65962.png +47920.png +37752.png +21039.png +30833.png +55714.png +33875.png +55101.png +47803.png +19569.png +04267.png +33262.png +29646.png +05974.png +31873.png +69643.png +11722.png +05271.png +31277.png +38351.png +18205.png +54629.png +20355.png +05580.png +17216.png +63119.png +48877.png +39192.png +01295.png +59698.png +33684.png +67585.png +28286.png +08669.png +10109.png +22958.png +08011.png +03543.png +65408.png +42925.png +32575.png +42794.png +22370.png +16807.png +01754.png +01922.png +51235.png +64954.png +47754.png +13593.png +39602.png +32581.png +57883.png +13759.png +66224.png +36067.png +68705.png +52918.png +52776.png +30198.png +08990.png +05126.png +28316.png +66352.png +13778.png +04807.png +31662.png +66211.png +22926.png +05634.png +47527.png +63455.png +15041.png +25260.png +47105.png +57223.png +12868.png +10676.png +31591.png +49711.png +41806.png +62491.png +29778.png +08635.png +40232.png +52383.png +17084.png +68153.png +31646.png +13824.png +53324.png +03900.png +39066.png +52960.png +40485.png +69355.png +37164.png +00350.png +14551.png +58419.png +03114.png +30494.png +56381.png +47358.png +67666.png +19397.png +57184.png +53682.png +09955.png +61532.png +49478.png +43404.png +51409.png +23030.png +59353.png +13921.png +61525.png +07383.png +24007.png +63818.png +16629.png +56423.png +29485.png +60388.png +60889.png +05435.png +21213.png +16901.png +06818.png +68001.png +59800.png +20759.png +00802.png +51568.png +53744.png +19732.png +54446.png +15942.png +00214.png +42033.png +17275.png +41160.png +50763.png +54675.png +02511.png +49355.png +03002.png +64120.png +69933.png +14384.png +38656.png +42772.png +27594.png +08314.png +47610.png +45237.png +30548.png +01998.png +61829.png +63777.png +03810.png +52035.png +39258.png +26269.png +33643.png +34011.png +22167.png +54096.png +56708.png +01162.png +04654.png +59922.png +38461.png +18221.png +56055.png +65527.png +16966.png +18383.png +32424.png +24769.png +50427.png +44180.png +37535.png +30200.png +12134.png +23225.png +40244.png +53601.png +57878.png +38307.png +67279.png +64066.png +26576.png +47469.png +26829.png +04383.png +30950.png +61730.png +55668.png +11570.png +42339.png +10550.png +38657.png +53621.png +00730.png +53108.png +45105.png +16700.png +35240.png +44964.png +16343.png +11938.png +39580.png +51369.png +21460.png +63443.png +00691.png +31050.png +45741.png +32753.png +05131.png +16466.png +51626.png +51224.png +66817.png +24121.png +31272.png +50212.png +53968.png +11284.png +29209.png +01748.png +24453.png +36179.png +39050.png +26684.png +51093.png +06835.png +27399.png +04361.png +23363.png +04116.png +33837.png +23944.png +32327.png +57101.png +63072.png +42358.png +33721.png +09156.png +10914.png +13487.png +66141.png +38527.png +58317.png +01992.png +33314.png +58692.png +18037.png +22524.png +18809.png +58975.png +52601.png +51433.png +21691.png +48900.png +20409.png +03159.png +37030.png +51190.png +22564.png +30487.png +26543.png +19433.png +09751.png +10972.png +14895.png +30672.png +21295.png +65401.png +64299.png +63946.png +39759.png +11621.png +32102.png +62333.png +34413.png +40769.png +36332.png +49719.png +61499.png +36414.png +38768.png +26709.png +13228.png +06603.png +28711.png +59894.png +35258.png +27926.png +01924.png +27562.png +18761.png +26714.png +24439.png +26833.png +32240.png +52154.png +52860.png +42232.png +07252.png +65855.png +47459.png +15592.png +11258.png +56617.png +66720.png +68555.png +66481.png +18802.png +54457.png +56784.png +30981.png +19233.png +33425.png +16540.png +07944.png +01120.png +36206.png +25029.png +50927.png +12779.png +14748.png +40106.png +24758.png +28027.png +12043.png +04641.png +09242.png +63211.png +45798.png +62557.png +38643.png +32384.png +45116.png +38017.png +01006.png +18369.png +55560.png +11092.png +00868.png +49726.png +06189.png +07679.png +26759.png +42734.png +54283.png +42251.png +62590.png +41910.png +05087.png +17892.png +33472.png +32128.png +36376.png +29393.png +16625.png +66312.png +02383.png +20901.png +56526.png +25668.png +51751.png +02283.png +23267.png +69150.png +61082.png +47955.png +33315.png +24129.png +31381.png +19496.png +14949.png +29480.png +40819.png +07567.png +02484.png +12389.png +24100.png +52263.png +09408.png +59412.png +41374.png +15613.png +13044.png +00833.png +43590.png +53850.png +08473.png +28421.png +00093.png +15606.png +31718.png +58039.png +15320.png +57257.png +51613.png +19862.png +10939.png +19966.png +43943.png +09463.png +43082.png +62211.png +33402.png +47110.png +10156.png +25626.png +14013.png +65241.png +13952.png +05759.png +00186.png +61877.png +20307.png +11525.png +67494.png +63798.png +15889.png +47257.png +41466.png +26710.png +33897.png +49647.png +69465.png +69858.png +53870.png +07887.png +02072.png +53819.png +31173.png +11387.png +16426.png +57283.png +13971.png +04096.png +28896.png +03796.png +03965.png +36479.png +24483.png +32504.png +02642.png +15477.png +63986.png +10973.png +01882.png +55678.png +43640.png +54369.png +42314.png +49717.png +20626.png +23696.png +22809.png +11197.png +20856.png +57307.png +28819.png +56663.png +13311.png +01096.png +39221.png +44220.png +18907.png +44047.png +36860.png +20118.png +43128.png +62220.png +56965.png +57098.png +50381.png +31703.png +01526.png +35065.png +49105.png +22189.png +62424.png +01018.png +09267.png +16369.png +21211.png +01585.png +52000.png +20127.png +33310.png +31064.png +45552.png +36335.png +58229.png +34007.png +34368.png +18121.png +45143.png +45197.png +16172.png +22274.png +07701.png +06548.png +29463.png +18885.png +58776.png +66728.png +09963.png +45393.png +40142.png +55240.png +24810.png +10304.png +60486.png +69705.png +66998.png +45498.png +05914.png +50630.png +48162.png +39651.png +29098.png +64374.png +66934.png +66398.png +44608.png +43210.png +14505.png +30295.png +69358.png +56165.png +68193.png +50428.png +25056.png +56430.png +25518.png +65591.png +13268.png +45309.png +55665.png +14281.png +23868.png +06342.png +42351.png +05796.png +44057.png +37464.png +62306.png +17951.png +10612.png +59601.png +68656.png +06552.png +04394.png +55330.png +07921.png +17467.png +34128.png +64901.png +67210.png +43107.png +20156.png +64312.png +13413.png +23718.png +50095.png +15338.png +67683.png +20499.png +18746.png +09681.png +23179.png +23172.png +07304.png +05429.png +41482.png +28713.png +13265.png +36999.png +23760.png +05950.png +33392.png +53131.png +03596.png +44578.png +47397.png +59078.png +11434.png +56925.png +46599.png +30065.png +01345.png +67301.png +36317.png +13555.png +28229.png +09508.png +61071.png +56621.png +43473.png +22266.png +04577.png +04939.png +59216.png +03204.png +09028.png +12856.png +69686.png +63713.png +14873.png +63751.png +57309.png +13474.png +11752.png +16367.png +62296.png +37435.png +33531.png +56069.png +19348.png +28815.png +53277.png +37234.png +10395.png +43698.png +67689.png +69965.png +50570.png +20192.png +53520.png +14521.png +31149.png +33398.png +32184.png +01464.png +69078.png +04052.png +23498.png +64148.png +65529.png +67199.png +43545.png +05749.png +11755.png +63225.png +03049.png +46986.png +47152.png +59249.png +09803.png +02609.png +06089.png +57604.png +43587.png +17579.png +31373.png +02350.png +38567.png +30068.png +57310.png +29024.png +15061.png +12442.png +67871.png +35554.png +21788.png +45728.png +65357.png +00143.png +62009.png +23398.png +52219.png +32926.png +45022.png +45316.png +36086.png +02502.png +62157.png +14733.png +32438.png +10359.png +55412.png +51322.png +46640.png +08279.png +41358.png +68245.png +56551.png +53699.png +52409.png +35329.png +10366.png +03559.png +30618.png +64074.png +33828.png +62666.png +55583.png +17533.png +08435.png +10244.png +45571.png +40592.png +33161.png +39922.png +02846.png +43365.png +40146.png +00578.png +50298.png +11276.png +28766.png +34835.png +49393.png +69724.png +28921.png +51109.png +53229.png +54959.png +45625.png +37081.png +33944.png +64368.png +26056.png +39118.png +06013.png +64678.png +45121.png +51185.png +03434.png +58786.png +40257.png +09101.png +50817.png +33623.png +58871.png +66200.png +15885.png +04735.png +06230.png +56126.png +40963.png +53444.png +68040.png +12097.png +20221.png +31213.png +42616.png +30353.png +64239.png +67420.png +51345.png +16437.png +37022.png +53679.png +31330.png +57204.png +69031.png +06173.png +52167.png +03101.png +47137.png +52527.png +32949.png +08583.png +18605.png +13463.png +56778.png +16336.png +55182.png +44928.png +57707.png +69756.png +31536.png +30970.png +59590.png +63146.png +61458.png +09189.png +52715.png +10561.png +25678.png +40887.png +44538.png +37571.png +06784.png +67744.png +54263.png +18616.png +24391.png +05305.png +03733.png +01044.png +58201.png +37021.png +03382.png +34443.png +34133.png +11430.png +09916.png +64946.png +20734.png +52196.png +36329.png +49362.png +35526.png +62461.png +49267.png +30997.png +48698.png +11772.png +66701.png +45602.png +17754.png +01765.png +10606.png +18903.png +13818.png +02353.png +00823.png +26169.png +36422.png +05554.png +26205.png +33208.png +18042.png +31271.png +52391.png +61383.png +11766.png +58132.png +66500.png +05785.png +40827.png +03471.png +56016.png +07349.png +39555.png +34979.png +05845.png +51440.png +15891.png +57949.png +57757.png +47260.png +40649.png +24682.png +60403.png +65913.png +30507.png +36897.png +69378.png +16168.png +40164.png +15178.png +58367.png +37083.png +38456.png +06277.png +35369.png +43750.png +53244.png +00319.png +50839.png +56810.png +24303.png +25853.png +13814.png +54767.png +11515.png +42008.png +67760.png +64218.png +58304.png +54212.png +06646.png +47956.png +63721.png +31291.png +46580.png +17219.png +51459.png +28066.png +22485.png +14170.png +10781.png +36228.png +68108.png +58884.png +22230.png +64188.png +10513.png +64574.png +47002.png +40221.png +27270.png +17300.png +06425.png +39789.png +26591.png +36749.png +55765.png +04041.png +07721.png +09978.png +39241.png +29349.png +27898.png +42495.png +19428.png +37205.png +11061.png +39699.png +25728.png +52364.png +54934.png +42578.png +15745.png +19711.png +63827.png +25618.png +21890.png +14947.png +09710.png +29818.png +53823.png +49033.png +10834.png +39796.png +44670.png +31545.png +61104.png +38038.png +30303.png +17136.png +40859.png +36694.png +39244.png +53023.png +29141.png +56038.png +57361.png +67512.png +12348.png +40641.png +14324.png +30413.png +57065.png +20234.png +34004.png +44875.png +12509.png +01174.png +53224.png +07546.png +66072.png +67958.png +02870.png +26046.png +03431.png +26634.png +62658.png +07190.png +17424.png +13713.png +38364.png +63265.png +54542.png +18060.png +63670.png +06728.png +57995.png +50873.png +23812.png +41913.png +65512.png +14604.png +16673.png +38111.png +61953.png +19145.png +12729.png +49388.png +57544.png +24859.png +14202.png +39767.png +35617.png +53609.png +10122.png +67447.png +03860.png +55737.png +03141.png +34916.png +30062.png +07996.png +57508.png +36470.png +03826.png +02462.png +41317.png +50764.png +39320.png +00200.png +61002.png +62820.png +59239.png +28076.png +45704.png +60690.png +57267.png +40407.png +11637.png +41500.png +27795.png +62537.png +55508.png +21593.png +15707.png +00458.png +62847.png +27901.png +47052.png +52173.png +47407.png +62084.png +19008.png +08006.png +43184.png +11716.png +65601.png +34399.png +57963.png +67331.png +31337.png +38615.png +29113.png +43159.png +28537.png +66872.png +25307.png +45306.png +59110.png +67543.png +04110.png +04851.png +04152.png +46093.png +16612.png +09776.png +23801.png +18411.png +57566.png +54157.png +40987.png +25602.png +04674.png +24361.png +07713.png +25834.png +59808.png +51505.png +59187.png +47723.png +40075.png +18510.png +24448.png +15583.png +49971.png +50868.png +21146.png +66401.png +31774.png +22293.png +39691.png +61339.png +64552.png +62682.png +07432.png +63338.png +35198.png +08893.png +42562.png +65912.png +38760.png +44904.png +27553.png +06454.png +23649.png +08325.png +62380.png +58508.png +53940.png +26443.png +20694.png +15567.png +11878.png +64761.png +16617.png +36198.png +67521.png +54680.png +17521.png +65597.png +55486.png +47602.png +01675.png +64867.png +42958.png +41531.png +18043.png +06057.png +21895.png +33657.png +68627.png +23127.png +08235.png +07698.png +44526.png +60859.png +12988.png +32780.png +48121.png +46037.png +29206.png +57335.png +51702.png +20479.png +02362.png +66149.png +66464.png +41389.png +65883.png +32905.png +62364.png +48990.png +01740.png +42220.png +50438.png +19190.png +14469.png +66653.png +09840.png +17960.png +15952.png +61263.png +21352.png +14301.png +45418.png +64464.png +51918.png +35757.png +58758.png +62707.png +00506.png +49570.png +25284.png +53828.png +36516.png +19364.png +61290.png +11421.png +39768.png +66828.png +49667.png +09742.png +34101.png +37611.png +41437.png +43893.png +44944.png +13136.png +00406.png +06428.png +33612.png +37290.png +28636.png +36410.png +13546.png +36881.png +61679.png +60694.png +04834.png +61156.png +30360.png +52511.png +05804.png +69650.png +27999.png +29997.png +65970.png +30329.png +33255.png +50078.png +43014.png +36973.png +69296.png +44323.png +32405.png +46544.png +56377.png +44499.png +13688.png +19309.png +01904.png +06820.png +47331.png +18650.png +23770.png +08751.png +25185.png +02413.png +39463.png +12982.png +52418.png +45570.png +11874.png +60201.png +66182.png +68270.png +00884.png +45055.png +36611.png +08517.png +39285.png +26342.png +34867.png +52403.png +29408.png +09110.png +53349.png +04878.png +38305.png +68060.png +68594.png +34686.png +13206.png +64567.png +52813.png +39571.png +56872.png +31241.png +45015.png +48235.png +22963.png +22828.png +49045.png +11712.png +25506.png +68295.png +14094.png +37770.png +07020.png +54626.png +24311.png +65772.png +67791.png +41553.png +00501.png +58578.png +03923.png +05557.png +61786.png +02342.png +27976.png +08603.png +30213.png +62784.png +32029.png +21877.png +22063.png +53134.png +35945.png +47586.png +17994.png +17269.png +10899.png +31513.png +55800.png +37764.png +23281.png +47927.png +29043.png +62542.png +32449.png +08277.png +55148.png +23951.png +21328.png +07795.png +09717.png +16224.png +44952.png +13183.png +66249.png +02201.png +42319.png +12544.png +45336.png +59570.png +67607.png +46832.png +24327.png +04261.png +42265.png +65608.png +58894.png +12217.png +24031.png +16133.png +21692.png +42356.png +65047.png +51475.png +09053.png +46252.png +08092.png +46298.png +67151.png +01832.png +39778.png +30738.png +32020.png +03540.png +63056.png +07463.png +28692.png +32785.png +41461.png +10022.png +07109.png +45962.png +62984.png +08027.png +23945.png +05816.png +47095.png +21863.png +55263.png +48857.png +50669.png +42305.png +27833.png +44573.png +05830.png +62087.png +68733.png +29275.png +27921.png +64756.png +55090.png +59752.png +58000.png +65859.png +55181.png +68605.png +55707.png +58952.png +02208.png +69438.png +24995.png +39704.png +42466.png +19633.png +15231.png +11080.png +36853.png +24465.png +02037.png +02713.png +04003.png +51472.png +29296.png +19290.png +61320.png +42042.png +16434.png +63514.png +03648.png +35483.png +30958.png +53322.png +06125.png +10540.png +39738.png +43242.png +10644.png +15444.png +28262.png +61229.png +53013.png +16735.png +34219.png +38465.png +21995.png +11496.png +19449.png +05870.png +31051.png +07351.png +25128.png +58853.png +68501.png +12794.png +42940.png +18910.png +11490.png +08321.png +24106.png +20649.png +10568.png +17087.png +59978.png +23734.png +25362.png +50513.png +62103.png +37067.png +43703.png +53915.png +19312.png +36015.png +65639.png +63855.png +40088.png +10840.png +53535.png +28694.png +21337.png +46524.png +43355.png +51767.png +00712.png +19272.png +07626.png +31602.png +10015.png +47317.png +39546.png +33582.png +01867.png +59004.png +47577.png +35803.png +00985.png +38596.png +62277.png +67952.png +27925.png +35997.png +20262.png +28464.png +13775.png +38506.png +01654.png +19505.png +09459.png +03444.png +44135.png +02894.png +21873.png +38752.png +23891.png +35675.png +32847.png +09513.png +68479.png +53490.png +32502.png +07115.png +10961.png +03473.png +40300.png +21172.png +01269.png +68514.png +12095.png +50607.png +46827.png +33740.png +47973.png +19125.png +01655.png +17096.png +05186.png +57940.png +43649.png +42412.png +66033.png +12158.png +35167.png +51306.png +65596.png +20056.png +37072.png +54330.png +65189.png +14903.png +20567.png +59063.png +17128.png +63032.png +32603.png +02467.png +03358.png +36796.png +13220.png +66649.png +21161.png +32340.png +47222.png +48926.png +69770.png +43446.png +55918.png +34982.png +53110.png +55505.png +16895.png +32158.png +40400.png +03654.png +63883.png +19699.png +38170.png +00167.png +54601.png +09401.png +05837.png +01014.png +18614.png +47536.png +35034.png +16165.png +39397.png +02629.png +67452.png +65226.png +39135.png +41985.png +19456.png +59500.png +07069.png +66518.png +15702.png +08665.png +37790.png +52057.png +49759.png +36767.png +37823.png +26496.png +31957.png +48343.png +68399.png +40600.png +54668.png +10205.png +31525.png +34052.png +67233.png +29161.png +55687.png +13843.png +54221.png +64124.png +36871.png +56295.png +55493.png +58403.png +35032.png +54087.png +53026.png +08458.png +14229.png +17663.png +14612.png +59693.png +25534.png +15370.png +52622.png +50389.png +20952.png +05868.png +47154.png +02671.png +35961.png +12635.png +21616.png +10394.png +35097.png +06959.png +15065.png +26968.png +18528.png +24110.png +41300.png +50939.png +60064.png +09902.png +57515.png +08518.png +11138.png +12350.png +34600.png +65014.png +60056.png +08250.png +67674.png +27041.png +33824.png +43982.png +24097.png +49024.png +25893.png +52284.png +65156.png +40774.png +31356.png +22377.png +68028.png +55660.png +39019.png +13809.png +08355.png +03296.png +04510.png +25387.png +62203.png +12071.png +51418.png +53613.png +04365.png +47177.png +63829.png +31817.png +30373.png +54326.png +54482.png +28716.png +05214.png +25101.png +53720.png +16179.png +27852.png +64344.png +38401.png +06556.png +00928.png +43020.png +37593.png +15430.png +11096.png +07265.png +69955.png +08397.png +33467.png +32851.png +36644.png +50652.png +22168.png +10519.png +63034.png +08760.png +07114.png +68109.png +68517.png +34022.png +66726.png +58181.png +03367.png +47117.png +42404.png +26639.png +33960.png +34187.png +28359.png +01146.png +40197.png +20944.png +55348.png +68936.png +20655.png +44024.png +34386.png +48297.png +10229.png +24026.png +38959.png +09161.png +66658.png +17854.png +49261.png +35016.png +34110.png +58745.png +10717.png +53704.png +44864.png +15450.png +44712.png +50197.png +13192.png +68940.png +27531.png +18704.png +50321.png +29479.png +64217.png +40676.png +20224.png +47657.png +51464.png +30964.png +15326.png +40727.png +57249.png +13247.png +01092.png +27880.png +54593.png +65154.png +65678.png +43643.png +09946.png +41108.png +31022.png +21812.png +60944.png +06834.png +52113.png +57457.png +24176.png +69958.png +01988.png +22772.png +59391.png +02774.png +52667.png +62689.png +53470.png +33538.png +28039.png +38460.png +44233.png +00307.png +19710.png +03699.png +58393.png +34949.png +16484.png +00248.png +04965.png +25156.png +03704.png +17316.png +14056.png +44920.png +68467.png +23483.png +27047.png +19653.png +48957.png +10377.png +17565.png +42765.png +24240.png +43198.png +53529.png +55603.png +40537.png +07074.png +42625.png +28879.png +21287.png +65658.png +13519.png +33236.png +27168.png +34581.png +17122.png +06482.png +69575.png +04754.png +01757.png +46062.png +66563.png +40872.png +50260.png +68629.png +66520.png +23783.png +64899.png +53570.png +44407.png +09251.png +67696.png +58492.png +35901.png +67216.png +04276.png +28620.png +36366.png +09934.png +45156.png +66313.png +48890.png +55478.png +43223.png +61405.png +11459.png +57359.png +46699.png +34174.png +63026.png +58937.png +13765.png +06578.png +15964.png +33013.png +56734.png +09009.png +56382.png +38064.png +12823.png +48509.png +22504.png +62167.png +44063.png +03530.png +01879.png +27113.png +38790.png +60063.png +39588.png +19237.png +00661.png +57569.png +49909.png +35390.png +62115.png +57138.png +12801.png +05043.png +18439.png +01618.png +61956.png +06866.png +67698.png +69715.png +47553.png +37501.png +37385.png +63973.png +61646.png +37913.png +67160.png +01645.png +01456.png +29934.png +22316.png +43068.png +54819.png +23093.png +42882.png +28379.png +01394.png +20464.png +10770.png +67706.png +46485.png +58362.png +11768.png +02199.png +10171.png +16405.png +43318.png +15205.png +13352.png +61553.png +45750.png +65388.png +53665.png +14018.png +66866.png +19306.png +67822.png +49838.png +42236.png +54454.png +55036.png +33016.png +03164.png +54778.png +15737.png +07621.png +40623.png +06929.png +09860.png +05718.png +56913.png +05958.png +10275.png +31633.png +05516.png +44705.png +42641.png +16240.png +26085.png +03046.png +00341.png +19591.png +40169.png +38501.png +12358.png +15697.png +16772.png +06538.png +59383.png +13187.png +56749.png +50940.png +63846.png +63364.png +29746.png +15272.png +08448.png +57399.png +41355.png +06448.png +41749.png +16678.png +07435.png +43890.png +64386.png +01913.png +55723.png +17770.png +41238.png +56714.png +06155.png +30891.png +44495.png +15906.png +02709.png +33238.png +38061.png +50966.png +06575.png +34063.png +25901.png +51945.png +07695.png +58303.png +02653.png +12772.png +24834.png +58365.png +40422.png +46371.png +44621.png +31094.png +16727.png +40222.png +68185.png +20271.png +30166.png +47769.png +19632.png +24813.png +18618.png +53962.png +25590.png +18505.png +13696.png +20080.png +16786.png +36699.png +60357.png +22684.png +31727.png +62582.png +64648.png +67474.png +00965.png +65689.png +43597.png +22175.png +04279.png +40625.png +11418.png +30327.png +07340.png +62021.png +36880.png +31840.png +67846.png +12654.png +59867.png +20444.png +63366.png +27135.png +34099.png +42885.png +63138.png +67711.png +16295.png +27466.png +54768.png +67050.png +42003.png +51208.png +63872.png +66920.png +00864.png +25856.png +16075.png +38377.png +10687.png +08883.png +55347.png +20926.png +11642.png +19326.png +13700.png +18597.png +63838.png +09940.png +13989.png +03779.png +59638.png +66420.png +00178.png +66739.png +39435.png +48634.png +04058.png +60458.png +67079.png +30149.png +13731.png +12550.png +55211.png +19399.png +12012.png +16565.png +31973.png +30931.png +24884.png +67262.png +06825.png +40031.png +01511.png +21883.png +55483.png +29642.png +23752.png +59964.png +15546.png +07194.png +07105.png +65136.png +28081.png +33233.png +04793.png +01080.png +26550.png +35260.png +05980.png +14232.png +50120.png +32377.png +12916.png +22261.png +11974.png +14860.png +39524.png +47093.png +30125.png +56638.png +33317.png +50045.png +20825.png +36652.png +46464.png +53528.png +13553.png +03752.png +33712.png +38579.png +15836.png +27148.png +50338.png +44626.png +32561.png +26965.png +21086.png +63964.png +67088.png +24860.png +28432.png +52366.png +30520.png +02736.png +60417.png +58473.png +60505.png +66070.png +05375.png +13360.png +12474.png +44000.png +55749.png +39479.png +02343.png +33365.png +68626.png +68011.png +29338.png +22354.png +10069.png +48380.png +53992.png +35257.png +09280.png +16382.png +05670.png +28825.png +57274.png +40834.png +20650.png +18535.png +45961.png +14785.png +61901.png +62578.png +10107.png +38130.png +56315.png +17444.png +20491.png +08727.png +36506.png +25950.png +14180.png +68813.png +48015.png +42526.png +50320.png +24790.png +62416.png +04724.png +07401.png +40611.png +50435.png +51252.png +33938.png +31956.png +32705.png +68038.png +08438.png +04846.png +18585.png +26150.png +51487.png +22733.png +61524.png +23409.png +69158.png +36323.png +39112.png +00457.png +45314.png +36703.png +24823.png +38982.png +28884.png +09891.png +11789.png +38892.png +22043.png +54363.png +41508.png +24384.png +16351.png +44325.png +50190.png +48051.png +53795.png +58322.png +05739.png +17100.png +52240.png +15718.png +11546.png +11144.png +57234.png +34109.png +41251.png +54679.png +25894.png +68846.png +68409.png +40224.png +61402.png +27575.png +26874.png +31939.png +63679.png +16745.png +42278.png +67553.png +36025.png +30021.png +02952.png +30690.png +65968.png +64568.png +50203.png +50946.png +52314.png +42835.png +57805.png +56480.png +47974.png +42965.png +15020.png +54114.png +64757.png +63053.png +43602.png +53489.png +38514.png +56235.png +64582.png +38882.png +16957.png +03457.png +43953.png +19971.png +32107.png +31252.png +05448.png +68745.png +28680.png +18681.png +49014.png +15080.png +39506.png +64241.png +25127.png +49742.png +39628.png +16455.png +53293.png +11235.png +00308.png +44333.png +58021.png +63355.png +52480.png +50205.png +66598.png +09680.png +17752.png +11848.png +61972.png +23667.png +07058.png +13609.png +32057.png +24639.png +33494.png +59580.png +58674.png +41682.png +56324.png +54919.png +66968.png +51982.png +61561.png +30533.png +56345.png +53942.png +05751.png +12749.png +46325.png +30581.png +12019.png +61732.png +35093.png +51476.png +42582.png +56869.png +59910.png +53907.png +18565.png +03589.png +44299.png +51386.png +36846.png +08762.png +33042.png +20002.png +02105.png +23011.png +18303.png +68044.png +42036.png +40815.png +30944.png +08392.png +26291.png +20771.png +22745.png +11565.png +46845.png +01539.png +23764.png +08276.png +68762.png +29292.png +24305.png +41950.png +07021.png +53538.png +69273.png +03177.png +20474.png +31234.png +27719.png +47740.png +67951.png +39543.png +33514.png +08345.png +04001.png +11084.png +07849.png +55358.png +32313.png +63178.png +56750.png +20930.png +42930.png +55266.png +15255.png +60168.png +67894.png +56875.png +24941.png +50736.png +30244.png +51741.png +68285.png +41365.png +63630.png +63461.png +47294.png +60986.png +51729.png +52050.png +11227.png +16530.png +61663.png +36932.png +28302.png +20743.png +19941.png +51156.png +10141.png +66515.png +39376.png +40061.png +33999.png +11359.png +56497.png +43880.png +21935.png +13454.png +06850.png +39082.png +05829.png +28980.png +32404.png +17009.png +33583.png +37665.png +24942.png +38496.png +54658.png +19843.png +52089.png +27501.png +38168.png +52419.png +64202.png +08548.png +02958.png +43557.png +56252.png +30209.png +25359.png +03562.png +27602.png +55255.png +04120.png +23400.png +01844.png +64200.png +28790.png +10100.png +42914.png +65464.png +03070.png +64957.png +21448.png +53274.png +36468.png +67669.png +22208.png +10393.png +60122.png +23459.png +61857.png +06256.png +66044.png +66426.png +07676.png +11793.png +45068.png +66747.png +21109.png +38577.png +33935.png +07018.png +40418.png +38208.png +45043.png +60574.png +26075.png +24960.png +31343.png +62923.png +43273.png +12567.png +69703.png +14194.png +22777.png +11346.png +30092.png +24155.png +13410.png +66387.png +69791.png +02216.png +39199.png +63038.png +59261.png +61965.png +28467.png +57494.png +68414.png +04621.png +30041.png +42288.png +54690.png +18808.png +26881.png +67726.png +51863.png +66373.png +27408.png +36081.png +40297.png +63198.png +43636.png +59372.png +16476.png +37996.png +40139.png +63898.png +58719.png +38917.png +23816.png +27920.png +49963.png +26712.png +64864.png +22565.png +14487.png +54517.png +15091.png +59370.png +22978.png +02361.png +41240.png +13682.png +18328.png +50863.png +62022.png +27043.png +32845.png +08604.png +65369.png +52704.png +11896.png +63701.png +31460.png +14024.png +57143.png +65519.png +35541.png +58817.png +18506.png +64024.png +69016.png +61763.png +38529.png +47484.png +23484.png +10852.png +28596.png +13875.png +01816.png +44800.png +60265.png +28255.png +68400.png +11713.png +01982.png +36294.png +29308.png +50538.png +60411.png +27908.png +58188.png +27536.png +03353.png +46273.png +45493.png +20671.png +48281.png +07711.png +10322.png +25467.png +14764.png +58254.png +49632.png +17942.png +18482.png +57804.png +58036.png +06450.png +02115.png +04445.png +50670.png +55341.png +50410.png +05715.png +09201.png +41766.png +24855.png +16905.png +51272.png +32553.png +25040.png +39036.png +69172.png +58352.png +33532.png +05370.png +60231.png +17053.png +57745.png +65843.png +11877.png +19682.png +06837.png +57364.png +27796.png +23925.png +49318.png +43430.png +01848.png +20431.png +28972.png +01744.png +56078.png +44617.png +00429.png +59143.png +21540.png +62338.png +26049.png +07345.png +66792.png +03962.png +24010.png +41788.png +02985.png +57865.png +46237.png +08457.png +12566.png +39842.png +16690.png +09344.png +62563.png +10429.png +32503.png +39913.png +50439.png +27272.png +28096.png +04459.png +02090.png +29557.png +31060.png +13758.png +12854.png +14322.png +07952.png +38897.png +69937.png +07085.png +45389.png +27080.png +66556.png +13619.png +26220.png +24115.png +57697.png +44269.png +64543.png +11593.png +55753.png +45888.png +02917.png +31572.png +18003.png +66482.png +65168.png +18689.png +58172.png +48095.png +51159.png +08114.png +27315.png +39362.png +39115.png +16742.png +60365.png +69094.png +33256.png +58323.png +37837.png +56548.png +43278.png +15816.png +23880.png +39349.png +50273.png +12737.png +26294.png +19846.png +47671.png +64676.png +63606.png +61496.png +55906.png +67297.png +16708.png +59104.png +22889.png +06889.png +23593.png +15024.png +60518.png +30982.png +11646.png +44585.png +19543.png +25053.png +66567.png +12526.png +66060.png +28720.png +27630.png +14542.png +11081.png +24225.png +49201.png +63002.png +42608.png +39124.png +15022.png +55160.png +53927.png +58343.png +51294.png +23008.png +52211.png +11042.png +19959.png +29462.png +23789.png +62404.png +47656.png +33909.png +27703.png +16760.png +29131.png +08825.png +61319.png +47774.png +53443.png +47781.png +26404.png +10764.png +18498.png +20630.png +05925.png +56664.png +49653.png +67828.png +69744.png +51809.png +10666.png +64311.png +08425.png +46264.png +40003.png +07443.png +43511.png +24461.png +31125.png +60297.png +59120.png +38515.png +63544.png +02345.png +03269.png +02919.png +33616.png +51993.png +52288.png +01686.png +47155.png +52102.png +57666.png +21305.png +05361.png +42381.png +20254.png +62243.png +32170.png +57809.png +11730.png +12838.png +49272.png +00479.png +36486.png +30107.png +46992.png +61558.png +07602.png +25762.png +25201.png +51013.png +41415.png +04045.png +42545.png +27405.png +47674.png +33879.png +45069.png +28020.png +63030.png +50002.png +06648.png +24069.png +23983.png +05918.png +61570.png +01280.png +08378.png +65000.png +35959.png +64994.png +19142.png +55350.png +35693.png +35293.png +58664.png +59764.png +22605.png +49694.png +47252.png +42363.png +51133.png +41304.png +06356.png +04081.png +63897.png +35641.png +22579.png +54491.png +33305.png +17688.png +63376.png +35317.png +54799.png +10381.png +01005.png +09724.png +19662.png +60673.png +39658.png +69802.png +63889.png +62519.png +64980.png +29428.png +40669.png +09318.png +31278.png +38273.png +42802.png +29167.png +48283.png +53256.png +12770.png +25278.png +01416.png +58668.png +18174.png +28676.png +16658.png +06107.png +53015.png +57670.png +44498.png +42127.png +65126.png +25645.png +44562.png +19602.png +32205.png +63965.png +16376.png +16752.png +68610.png +31597.png +49296.png +61803.png +32556.png +43572.png +65759.png +08668.png +11708.png +54842.png +63100.png +07835.png +66883.png +40234.png +21533.png +00767.png +38426.png +39141.png +64973.png +25117.png +08868.png +54644.png +29366.png +50123.png +35813.png +56644.png +57588.png +46737.png +52826.png +55162.png +18001.png +18338.png +69734.png +36664.png +55806.png +41424.png +47649.png +28915.png +50492.png +24724.png +57411.png +55726.png +48011.png +44861.png +00787.png +65035.png +18852.png +06470.png +58267.png +38660.png +17323.png +67486.png +23698.png +38946.png +27987.png +69708.png +29949.png +65130.png +40535.png +54544.png +69822.png +00874.png +56785.png +29321.png +12074.png +68055.png +00249.png +58699.png +53329.png +11121.png +67765.png +65860.png +58054.png +22707.png +41782.png +61726.png +40040.png +25170.png +18148.png +67517.png +38978.png +60034.png +18313.png +58638.png +45388.png +27787.png +05642.png +21622.png +36778.png +07207.png +11641.png +49051.png +21052.png +02845.png +14734.png +41828.png +04946.png +25392.png +45283.png +66384.png +08923.png +06115.png +15848.png +67770.png +40404.png +56993.png +21545.png +51216.png +00179.png +27339.png +53419.png +40112.png +56231.png +52086.png +27581.png +04205.png +63913.png +05008.png +23695.png +23325.png +09729.png +60126.png +20153.png +28161.png +55377.png +23100.png +12490.png +27485.png +33427.png +56073.png +64829.png +02041.png +67994.png +12282.png +69237.png +25679.png +59532.png +26565.png +68761.png +63992.png +28135.png +62946.png +24145.png +51196.png +61113.png +56832.png +03351.png +27425.png +58563.png +68713.png +10895.png +31561.png +22982.png +11982.png +23112.png +08391.png +50191.png +26384.png +64401.png +29622.png +63882.png +40458.png +25141.png +63436.png +53221.png +49363.png +36421.png +03158.png +68667.png +02123.png +42624.png +01807.png +27741.png +07828.png +02775.png +28196.png +04913.png +44847.png +56318.png +12732.png +28813.png +07758.png +27189.png +12187.png +39517.png +35273.png +14165.png +49537.png +58886.png +12228.png +60039.png +38102.png +38117.png +54728.png +01873.png +03506.png +66881.png +48458.png +67388.png +11834.png +29108.png +10727.png +19279.png +13325.png +10916.png +55535.png +59064.png +15386.png +25983.png +11604.png +39002.png +69380.png +28111.png +57879.png +63981.png +21827.png +05189.png +56264.png +55487.png +34371.png +05697.png +48766.png +16357.png +40242.png +59171.png +36381.png +69517.png +53540.png +26529.png +69206.png +57367.png +63240.png +29198.png +63307.png +64706.png +49661.png +54034.png +20321.png +62659.png +63565.png +36856.png +64427.png +15818.png +46478.png +55658.png +24642.png +55140.png +63692.png +60593.png +04916.png +00288.png +12810.png +24455.png +43789.png +18922.png +50349.png +61091.png +57321.png +31404.png +35255.png +32638.png +11503.png +35797.png +31028.png +46957.png +60580.png +29878.png +30753.png +06111.png +10182.png +27450.png +31397.png +43897.png +42630.png +06755.png +02950.png +48185.png +35784.png +46055.png +10607.png +05129.png +29783.png +64350.png +58521.png +45639.png +25146.png +07298.png +04425.png +44746.png +51991.png +50138.png +44979.png +01054.png +12181.png +32641.png +14862.png +42619.png +44703.png +47255.png +25386.png +27072.png +52146.png +26501.png +44355.png +52242.png +17025.png +02271.png +46597.png +23454.png +62018.png +41592.png +46339.png +15059.png +37228.png +37756.png +67238.png +07205.png +55577.png +42513.png +66537.png +05065.png +12266.png +06340.png +13097.png +00504.png +05997.png +55635.png +59927.png +43958.png +44618.png +29265.png +43909.png +45016.png +03245.png +30448.png +61416.png +16418.png +25550.png +62184.png +07739.png +32051.png +12411.png +64260.png +29065.png +03544.png +32301.png +39102.png +45278.png +37416.png +07263.png +56822.png +47623.png +65996.png +44930.png +45067.png +17535.png +27899.png +43423.png +53680.png +23847.png +13884.png +15263.png +46762.png +31309.png +56798.png +06165.png +46972.png +30904.png +56719.png +51510.png +11658.png +32089.png +37727.png +16817.png +01918.png +18389.png +63013.png +60073.png +44916.png +23257.png +34189.png +06763.png +62298.png +25420.png +63257.png +40778.png +32213.png +06398.png +17061.png +01268.png +23856.png +10400.png +06943.png +66169.png +29395.png +64058.png +63261.png +16074.png +65584.png +44322.png +01920.png +50795.png +55262.png +14503.png +17534.png +50037.png +18546.png +05304.png +55032.png +09735.png +02507.png +46224.png +25262.png +67017.png +56091.png +45302.png +33500.png +21708.png +44766.png +68366.png +12533.png +39023.png +08803.png +16986.png +40890.png +17895.png +10810.png +42902.png +58618.png +46363.png +12108.png +21253.png +15570.png +48209.png +25187.png +59061.png +52382.png +28579.png +62153.png +25479.png +31314.png +29709.png +04651.png +30461.png +55068.png +17884.png +58027.png +21781.png +69324.png +25921.png +62769.png +68495.png +69321.png +19030.png +07041.png +29772.png +16561.png +34104.png +19289.png +04802.png +41630.png +07211.png +41957.png +34432.png +40635.png +04833.png +47072.png +51399.png +13764.png +58205.png +38605.png +00737.png +59276.png +28703.png +49894.png +66088.png +27873.png +13804.png +66003.png +52720.png +02301.png +54905.png +02993.png +46756.png +49536.png +47605.png +12064.png +03653.png +56768.png +67591.png +67135.png +07171.png +43416.png +64322.png +30307.png +56949.png +46828.png +21205.png +10886.png +08018.png +21626.png +59005.png +15530.png +59621.png +42592.png +54510.png +10820.png +64938.png +26506.png +60590.png +23265.png +39163.png +05142.png +59215.png +13066.png +56394.png +08620.png +22038.png +30034.png +42103.png +58121.png +43148.png +28929.png +13974.png +63552.png +42214.png +09912.png +42915.png +63836.png +04971.png +09758.png +12628.png +20259.png +68487.png +34166.png +07963.png +30442.png +50294.png +40765.png +49612.png +56400.png +62536.png +63741.png +64779.png +21379.png +13205.png +40944.png +52522.png +41872.png +63335.png +65293.png +06158.png +33343.png +59387.png +56634.png +48287.png +28252.png +51633.png +57928.png +28003.png +26711.png +47474.png +38287.png +01642.png +35604.png +53503.png +25738.png +19340.png +59330.png +25071.png +19550.png +39586.png +18890.png +69204.png +53339.png +03852.png +14532.png +33118.png +20976.png +30051.png +65366.png +43479.png +01519.png +28895.png +65496.png +20738.png +04579.png +07638.png +67182.png +13908.png +45582.png +11638.png +24105.png +10188.png +51154.png +32498.png +04106.png +62066.png +61955.png +22685.png +23130.png +41881.png +25453.png +32526.png +10539.png +27682.png +11826.png +20167.png +66770.png +54820.png +60987.png +21636.png +56609.png +18241.png +46681.png +50770.png +66686.png +11232.png +42105.png +53812.png +09248.png +57400.png +58308.png +45326.png +25087.png +47270.png +49922.png +21123.png +36940.png +27831.png +33507.png +16151.png +17680.png +15897.png +60001.png +47383.png +06694.png +17361.png +40289.png +05890.png +69115.png +11327.png +48208.png +01512.png +11022.png +64363.png +23353.png +22799.png +30737.png +11817.png +52956.png +34461.png +14082.png +43799.png +46985.png +42796.png +63360.png +06823.png +59516.png +26901.png +50698.png +01385.png +69274.png +20779.png +49497.png +00510.png +60107.png +69301.png +23282.png +27722.png +45133.png +20197.png +53667.png +18487.png +43867.png +57081.png +64649.png +36404.png +42553.png +53599.png +56099.png +60230.png +47625.png +28145.png +44330.png +24641.png +18367.png +02627.png +26875.png +39061.png +36917.png +21385.png +12465.png +28044.png +67358.png +03485.png +18297.png +00302.png +50624.png +63993.png +50959.png +35319.png +34765.png +36957.png +09800.png +31909.png +43313.png +01300.png +69910.png +34458.png +59405.png +33930.png +42498.png +50834.png +01508.png +60480.png +60178.png +68419.png +03405.png +03379.png +56485.png +02672.png +49684.png +31440.png +30880.png +65738.png +68877.png +45991.png +20697.png +20827.png +19334.png +27867.png +46634.png +24109.png +19016.png +49056.png +15652.png +11904.png +23451.png +41561.png +12232.png +44999.png +50951.png +37757.png +61407.png +52900.png +44484.png +36885.png +34281.png +03808.png +63337.png +37312.png +51160.png +08333.png +04704.png +41607.png +35131.png +68174.png +59782.png +54598.png +17109.png +43933.png +44222.png +66704.png +52246.png +26477.png +20189.png +63412.png +51287.png +33554.png +55331.png +22249.png +04590.png +13203.png +48153.png +32306.png +60633.png +48969.png +20215.png +35408.png +19518.png +60845.png +63323.png +13186.png +10208.png +47730.png +47645.png +63290.png +45999.png +47129.png +26310.png +18010.png +05916.png +12957.png +06947.png +58573.png +56402.png +26032.png +12284.png +53581.png +67843.png +48504.png +63446.png +25916.png +23347.png +45500.png +19324.png +40665.png +61609.png +05255.png +04390.png +07299.png +47842.png +11872.png +60224.png +65521.png +68748.png +04222.png +09515.png +23446.png +52711.png +35325.png +13295.png +66194.png +34438.png +59731.png +59881.png +36647.png +56421.png +00809.png +09469.png +37108.png +39979.png +24695.png +25297.png +39197.png +00189.png +67168.png +24755.png +21753.png +64752.png +32868.png +42048.png +36573.png +24984.png +59003.png +50272.png +65904.png +26274.png +15234.png +23482.png +61462.png +25930.png +25329.png +46070.png +53126.png +28415.png +43605.png +09877.png +10017.png +30449.png +50682.png +33561.png +54247.png +12630.png +62300.png +60473.png +34220.png +39444.png +08726.png +01141.png +68239.png +08046.png +63519.png +22378.png +52880.png +25324.png +45653.png +61904.png +29812.png +56053.png +67825.png +30255.png +58613.png +27493.png +45424.png +47742.png +65143.png +39105.png +14876.png +16383.png +48473.png +07320.png +11782.png +35830.png +28691.png +38593.png +12079.png +14450.png +32239.png +46916.png +02920.png +50950.png +24195.png +53291.png +36864.png +37620.png +28032.png +60838.png +51975.png +22892.png +40286.png +20586.png +11648.png +62644.png +65171.png +33713.png +39252.png +10600.png +69100.png +32166.png +02892.png +31581.png +00724.png +63171.png +14562.png +33512.png +35099.png +60661.png +68338.png +02206.png +66062.png +34043.png +41487.png +02331.png +65198.png +03019.png +19293.png +01567.png +05810.png +17413.png +32739.png +27654.png +61662.png +06683.png +34073.png +22350.png +27507.png +26016.png +49417.png +09059.png +69401.png +18763.png +06435.png +43808.png +18908.png +03486.png +54524.png +07458.png +67371.png +19718.png +34689.png +23645.png +68391.png +17541.png +43490.png +27851.png +31980.png +06242.png +21149.png +17726.png +12812.png +03406.png +65892.png +44250.png +65094.png +41106.png +18365.png +61941.png +68088.png +04640.png +49804.png +24674.png +00237.png +19642.png +13125.png +44537.png +40617.png +66440.png +51140.png +14827.png +63661.png +65745.png +39399.png +15163.png +22548.png +20781.png +57892.png +52393.png +27758.png +68622.png +31402.png +36104.png +18899.png +59679.png +40362.png +11426.png +37920.png +11729.png +48345.png +64280.png +13573.png +63302.png +37016.png +29389.png +21169.png +33006.png +46030.png +31799.png +64553.png +29128.png +50771.png +69482.png +69478.png +26611.png +66206.png +03974.png +09387.png +44565.png +26805.png +56012.png +64495.png +14407.png +42474.png +02359.png +16935.png +56763.png +44161.png +56624.png +60837.png +47449.png +59728.png +04961.png +45366.png +12283.png +18736.png +37463.png +57417.png +31360.png +06726.png +16268.png +18698.png +03307.png +31784.png +31594.png +37077.png +54507.png +52786.png +11800.png +23703.png +34093.png +12989.png +14897.png +23004.png +39661.png +45645.png +34597.png +49461.png +48875.png +07592.png +49390.png +57024.png +16105.png +51211.png +16857.png +49905.png +42800.png +39945.png +56474.png +23641.png +39853.png +58903.png +45937.png +36631.png +17749.png +09368.png +08153.png +66485.png +05314.png +65910.png +25298.png +04703.png +18530.png +08482.png +34813.png +37578.png +57575.png +22225.png +02499.png +68562.png +59730.png +08193.png +41248.png +41964.png +20814.png +22490.png +56121.png +23574.png +40201.png +48203.png +29247.png +61539.png +60152.png +34098.png +62111.png +64719.png +62340.png +68561.png +19381.png +35009.png +27333.png +06903.png +69437.png +05270.png +23264.png +47905.png +65581.png +64450.png +05273.png +30930.png +03271.png +59444.png +00599.png +37238.png +02926.png +08652.png +56156.png +20159.png +28453.png +63604.png +27342.png +23029.png +51482.png +22011.png +22067.png +19848.png +54921.png +56279.png +52275.png +00161.png +22145.png +68197.png +33335.png +32584.png +32486.png +46291.png +08185.png +50235.png +49645.png +31657.png +06719.png +57613.png +68728.png +06447.png +36916.png +14941.png +64758.png +24404.png +66778.png +50836.png +22054.png +06934.png +37530.png +15452.png +42297.png +01941.png +17403.png +25351.png +20009.png +43934.png +01016.png +67310.png +09079.png +19210.png +04687.png +63369.png +38322.png +09761.png +33939.png +69687.png +34138.png +43825.png +68942.png +20842.png +57625.png +67306.png +00597.png +40089.png +67444.png +21105.png +41949.png +06788.png +25006.png +12806.png +65768.png +13596.png +02882.png +21894.png +28769.png +04100.png +49890.png +33371.png +02865.png +46069.png +27440.png +41474.png +05505.png +04849.png +02262.png +16858.png +26485.png +28695.png +22275.png +15729.png +60706.png +63533.png +46664.png +40519.png +66956.png +26661.png +35866.png +01115.png +54590.png +06054.png +06662.png +10163.png +63308.png +47283.png +44955.png +69346.png +34453.png +55937.png +23520.png +01989.png +57731.png +31155.png +05474.png +40624.png +42013.png +49527.png +36273.png +33107.png +66915.png +35768.png +35571.png +53597.png +30962.png +10605.png +07999.png +62121.png +42891.png +04335.png +63037.png +47814.png +29227.png +08205.png +39416.png +46823.png +41685.png +69326.png +59540.png +61643.png +67989.png +62852.png +48452.png +51377.png +11228.png +46984.png +54182.png +34506.png +10892.png +39065.png +51039.png +36053.png +49746.png +04350.png +21458.png +67539.png +40037.png +50816.png +58156.png +23123.png +57493.png +57690.png +45241.png +50671.png +25865.png +09703.png +59794.png +37401.png +06957.png +42440.png +67960.png +26216.png +27416.png +00136.png +56656.png +36396.png +67336.png +45085.png +31526.png +41700.png +68685.png +53320.png +54702.png +19086.png +46064.png +64637.png +28460.png +69846.png +66887.png +24837.png +13654.png +58245.png +53890.png +30955.png +09476.png +54196.png +29542.png +25032.png +45091.png +01315.png +29743.png +28153.png +01917.png +24345.png +01418.png +09036.png +55066.png +27256.png +55065.png +20753.png +19935.png +47210.png +29880.png +63287.png +21492.png +50151.png +23754.png +14154.png +10199.png +17144.png +31131.png +65470.png +12446.png +37345.png +12804.png +51566.png +50345.png +05742.png +42396.png +60813.png +53005.png +06352.png +40030.png +54639.png +45439.png +25347.png +04136.png +31582.png +59001.png +48381.png +32947.png +07122.png +47289.png +28736.png +32817.png +31924.png +12803.png +06035.png +22126.png +67221.png +57237.png +13640.png +02519.png +24870.png +32036.png +09433.png +02239.png +61023.png +57543.png +00108.png +44442.png +20036.png +24502.png +06824.png +37426.png +15168.png +11072.png +05125.png +40451.png +40174.png +12943.png +28585.png +26717.png +50503.png +03890.png +67315.png +01260.png +49297.png +69061.png +11887.png +16378.png +45963.png +42875.png +21932.png +16586.png +46789.png +07673.png +00096.png +40838.png +29759.png +39864.png +36661.png +41321.png +60008.png +08285.png +39494.png +45681.png +29056.png +23753.png +05532.png +57673.png +59301.png +03023.png +13438.png +58888.png +69661.png +23576.png +36830.png +02780.png +33681.png +06258.png +34963.png +69502.png +38271.png +28459.png +23262.png +36352.png +43003.png +04574.png +13398.png +12977.png +29964.png +37860.png +41168.png +49960.png +51582.png +00704.png +52346.png +10989.png +36540.png +31778.png +09947.png +57208.png +50685.png +47750.png +11566.png +52100.png +60700.png +68393.png +59192.png +68577.png +21638.png +66898.png +27765.png +22403.png +21224.png +41525.png +57189.png +43896.png +09197.png +38139.png +62606.png +58534.png +11657.png +44639.png +20973.png +23060.png +53144.png +57079.png +27971.png +56956.png +59639.png +36693.png +17987.png +59415.png +12994.png +48636.png +60075.png +53713.png +56927.png +17598.png +41306.png +32037.png +64786.png +37820.png +53623.png +19590.png +56433.png +45833.png +30875.png +60279.png +30019.png +53173.png +64517.png +03933.png +07337.png +69592.png +48012.png +06854.png +59283.png +68097.png +52434.png +69340.png +22750.png +48420.png +32414.png +40081.png +33685.png +68814.png +24434.png +27178.png +05952.png +48790.png +35805.png +60622.png +35075.png +62431.png +04251.png +39536.png +29106.png +31902.png +42623.png +29049.png +15630.png +54817.png +21079.png +08469.png +10743.png +19861.png +58294.png +07598.png +20278.png +37644.png +50085.png +18181.png +68347.png +26579.png +32145.png +34049.png +19845.png +48769.png +38383.png +63929.png +51453.png +09019.png +07774.png +36705.png +35192.png +60783.png +32960.png +10857.png +05224.png +43190.png +24388.png +40935.png +36738.png +62301.png +45460.png +10462.png +02522.png +58773.png +02814.png +08464.png +34111.png +28938.png +46840.png +28591.png +50304.png +21092.png +31395.png +19852.png +39271.png +65895.png +46537.png +45392.png +01915.png +65075.png +41982.png +28818.png +39623.png +22432.png +51623.png +38184.png +21713.png +46476.png +53267.png +68294.png +03725.png +33424.png +64691.png +40711.png +34546.png +00232.png +23883.png +57434.png +14898.png +56641.png +55053.png +61682.png +36804.png +07634.png +11399.png +22932.png +66676.png +57396.png +06075.png +11756.png +29382.png +42718.png +52605.png +38148.png +07838.png +65804.png +45471.png +53413.png +57634.png +03709.png +16327.png +68169.png +22499.png +62937.png +08886.png +59518.png +26743.png +26161.png +14147.png +20154.png +20940.png +21732.png +64416.png +05491.png +37761.png +22240.png +60052.png +64628.png +03912.png +14199.png +00672.png +57562.png +28917.png +16086.png +48296.png +07249.png +37364.png +31383.png +26472.png +20126.png +21432.png +62648.png +62738.png +30713.png +55042.png +02340.png +04998.png +25110.png +65406.png +17454.png +37360.png +23915.png +20280.png +28613.png +04195.png +48647.png +38525.png +68241.png +64387.png +67702.png +26716.png +11683.png +60681.png +58932.png +43309.png +10493.png +22487.png +19670.png +51815.png +34029.png +37955.png +30312.png +48413.png +61133.png +29276.png +22221.png +59657.png +47887.png +48862.png +38886.png +39087.png +13478.png +61079.png +13614.png +38611.png +31977.png +13913.png +34715.png +64661.png +33738.png +13279.png +16162.png +59611.png +43665.png +13130.png +47776.png +17470.png +36780.png +05303.png +48727.png +01245.png +15417.png +53387.png +51974.png +25880.png +18984.png +54256.png +65303.png +43585.png +08892.png +07646.png +20054.png +08302.png +58394.png +42258.png +34206.png +50687.png +49271.png +60109.png +08812.png +41725.png +11165.png +65234.png +61118.png +27311.png +41733.png +40095.png +11888.png +42976.png +32116.png +65552.png +38537.png +51590.png +09618.png +14632.png +01662.png +57066.png +04511.png +53439.png +34536.png +30099.png +24536.png +08064.png +30143.png +49354.png +27292.png +50619.png +39356.png +56811.png +02745.png +33794.png +24665.png +67385.png +69864.png +16770.png +67140.png +48009.png +32272.png +46639.png +41342.png +35923.png +50548.png +21676.png +05582.png +21921.png +55063.png +47342.png +06316.png +25059.png +08919.png +11139.png +02854.png +65819.png +66454.png +04369.png +11500.png +51057.png +23350.png +42387.png +25237.png +32646.png +30551.png +17418.png +24573.png +61594.png +06636.png +13625.png +54641.png +51108.png +47734.png +19664.png +45762.png +19530.png +13441.png +63850.png +15924.png +11028.png +36537.png +69524.png +14696.png +24871.png +29440.png +46963.png +19667.png +42506.png +48402.png +12439.png +45676.png +05381.png +33797.png +51126.png +64677.png +10800.png +47707.png +47815.png +07870.png +33683.png +02338.png +65525.png +68035.png +23910.png +23976.png +69952.png +29223.png +00721.png +68628.png +23273.png +31214.png +29864.png +45355.png +01905.png +68385.png +26423.png +60945.png +45866.png +03590.png +32177.png +36101.png +63479.png +47220.png +10920.png +05099.png +49965.png +10538.png +27341.png +04342.png +13605.png +25451.png +67346.png +42160.png +22836.png +06053.png +39627.png +15175.png +58100.png +24481.png +25891.png +57288.png +44689.png +06880.png +01102.png +29027.png +67068.png +55256.png +10468.png +29972.png +52200.png +42411.png +18472.png +53784.png +12369.png +42804.png +51636.png +43069.png +62083.png +69020.png +26050.png +01361.png +41417.png +19107.png +51681.png +15667.png +26983.png +64462.png +55693.png +35044.png +07753.png +32047.png +50604.png +65123.png +44740.png +58768.png +40663.png +21113.png +18052.png +61479.png +51018.png +11179.png +05606.png +50539.png +30081.png +13117.png +46565.png +63886.png +04127.png +01668.png +25169.png +66270.png +31424.png +00966.png +57067.png +69140.png +62855.png +06395.png +65603.png +45467.png +66641.png +13661.png +65982.png +03464.png +58934.png +20513.png +38131.png +54631.png +51660.png +67784.png +09814.png +45368.png +42638.png +67503.png +00969.png +10287.png +30617.png +01481.png +27089.png +38684.png +20844.png +60208.png +27597.png +04541.png +49167.png +31820.png +36210.png +00930.png +02022.png +32636.png +47277.png +64887.png +30919.png +29815.png +59700.png +12728.png +35632.png +10233.png +18449.png +59889.png +36256.png +63071.png +55550.png +66954.png +52090.png +56865.png +41376.png +60875.png +44143.png +23842.png +13540.png +17032.png +21430.png +33444.png +43821.png +57213.png +09428.png +10245.png +35872.png +55731.png +58803.png +63652.png +37531.png +14660.png +18277.png +21662.png +59088.png +43508.png +17399.png +01712.png +03713.png +38722.png +18504.png +59587.png +35055.png +49908.png +36100.png +68773.png +10704.png +43388.png +40650.png +07204.png +03609.png +26026.png +11466.png +07102.png +63168.png +08269.png +38717.png +44873.png +51271.png +47127.png +00154.png +57864.png +06260.png +56226.png +47722.png +36720.png +50365.png +62453.png +31960.png +62328.png +25665.png +50993.png +17085.png +62805.png +55151.png +29866.png +24247.png +44163.png +37143.png +31753.png +69634.png +06946.png +67664.png +57414.png +26119.png +04016.png +15078.png +08934.png +41301.png +35332.png +58035.png +60380.png +30923.png +40707.png +56310.png +54607.png +19499.png +01419.png +13037.png +40020.png +09750.png +67499.png +69024.png +07307.png +05921.png +65775.png +57248.png +56815.png +48894.png +45553.png +01575.png +25622.png +12021.png +40596.png +68559.png +09084.png +03466.png +08743.png +23860.png +08354.png +52781.png +42123.png +11506.png +62608.png +64409.png +24534.png +41513.png +53563.png +47477.png +44475.png +63531.png +18006.png +07631.png +34154.png +49453.png +48595.png +65253.png +22861.png +27974.png +37370.png +28311.png +36021.png +40009.png +09212.png +41129.png +52081.png +39906.png +59985.png +16052.png +51163.png +66852.png +30497.png +31024.png +15658.png +07328.png +31182.png +30602.png +22587.png +45838.png +01528.png +19998.png +48760.png +46496.png +64323.png +66067.png +46004.png +47029.png +57094.png +18928.png +41984.png +51516.png +17847.png +57018.png +48924.png +33159.png +62448.png +29364.png +10862.png +42108.png +19717.png +44837.png +12828.png +11691.png +48714.png +57370.png +27318.png +01473.png +46027.png +52422.png +12173.png +25129.png +14211.png +61935.png +21645.png +10548.png +12212.png +00716.png +50383.png +68404.png +41698.png +62675.png +34977.png +47534.png +08045.png +42395.png +56137.png +59537.png +43744.png +26939.png +69804.png +10653.png +25920.png +47991.png +21365.png +05345.png +23275.png +45086.png +44813.png +26645.png +51506.png +34875.png +68443.png +46645.png +13243.png +13305.png +22658.png +55270.png +00872.png +07013.png +53983.png +43407.png +67590.png +61834.png +47668.png +44160.png +38780.png +38031.png +68061.png +21773.png +37718.png +51107.png +53216.png +41499.png +65465.png +29287.png +27895.png +67239.png +09133.png +31361.png +11634.png +28719.png +36761.png +61985.png +68691.png +55295.png +32206.png +38721.png +40202.png +07237.png +18526.png +03908.png +14984.png +16577.png +22769.png +13142.png +00806.png +40702.png +49170.png +16568.png +13881.png +28523.png +60091.png +26723.png +32433.png +00494.png +15568.png +14366.png +62894.png +38627.png +48065.png +00673.png +17631.png +22996.png +13558.png +43634.png +56245.png +07860.png +30557.png +47263.png +17168.png +26324.png +41434.png +14247.png +07026.png +14913.png +52721.png +68082.png +19019.png +52498.png +18419.png +27123.png +01827.png +53958.png +10544.png +37598.png +04836.png +37919.png +49462.png +63125.png +41853.png +08304.png +16988.png +50578.png +32068.png +55352.png +39021.png +38153.png +19930.png +55259.png +19110.png +06502.png +26698.png +09202.png +64342.png +49805.png +43684.png +21819.png +21637.png +47113.png +21267.png +27813.png +20163.png +20644.png +66979.png +54943.png +20252.png +39386.png +36428.png +67034.png +27085.png +23594.png +67687.png +32727.png +56534.png +44032.png +17479.png +50223.png +59335.png +30015.png +17464.png +07313.png +36714.png +44811.png +17196.png +13431.png +02788.png +57551.png +00181.png +17286.png +24943.png +46644.png +33916.png +68191.png +64231.png +61287.png +43537.png +02986.png +64595.png +61968.png +19159.png +41393.png +49831.png +23996.png +44254.png +00144.png +07588.png +06492.png +54516.png +21769.png +50109.png +41059.png +43976.png +38922.png +08928.png +42684.png +55600.png +41547.png +17936.png +64137.png +23171.png +08787.png +05696.png +20880.png +55835.png +27914.png +17762.png +30431.png +30105.png +52436.png +60111.png +54377.png +68235.png +52053.png +33574.png +65340.png +53525.png +04675.png +06705.png +53893.png +06898.png +66933.png +08496.png +48451.png +07857.png +26767.png +49830.png +04526.png +26826.png +57601.png +14804.png +19923.png +25743.png +18354.png +48223.png +02732.png +15394.png +07159.png +55872.png +07310.png +53164.png +54854.png +12759.png +09222.png +29523.png +23717.png +03482.png +12771.png +51967.png +42478.png +28377.png +39721.png +11073.png +20173.png +66902.png +34078.png +05836.png +36359.png +18826.png +38488.png +53817.png +31266.png +16827.png +26359.png +14470.png +63161.png +61460.png +01395.png +12045.png +54001.png +34869.png +08910.png +53309.png +54666.png +45529.png +14236.png +03939.png +03768.png +23057.png +55461.png +18611.png +32786.png +07811.png +21761.png +59645.png +28944.png +43226.png +44374.png +54226.png +65214.png +35417.png +10073.png +37219.png +18192.png +49622.png +43314.png +00335.png +66693.png +61037.png +44399.png +27481.png +34118.png +63824.png +60679.png +24565.png +03000.png +03331.png +66955.png +60466.png +56657.png +39150.png +03620.png +60684.png +65783.png +45482.png +20362.png +24616.png +02728.png +50596.png +65571.png +65446.png +02839.png +20970.png +21170.png +01458.png +00810.png +35206.png +55551.png +52810.png +39880.png +45543.png +06595.png +45901.png +33144.png +66452.png +54611.png +12153.png +64573.png +61788.png +02027.png +23429.png +63966.png +22927.png +06034.png +53139.png +20651.png +21270.png +22467.png +67592.png +26547.png +14814.png +54121.png +06217.png +59723.png +50351.png +36797.png +02636.png +01411.png +25078.png +16792.png +26437.png +15438.png +40206.png +57840.png +67693.png +00529.png +19209.png +66467.png +42255.png +54475.png +13957.png +29939.png +13025.png +18821.png +28243.png +12121.png +56181.png +50821.png +46016.png +66650.png +64604.png +54005.png +40912.png +04021.png +19072.png +68619.png +45742.png +66110.png +52249.png +64784.png +62261.png +30695.png +41405.png +67401.png +57806.png +62106.png +15415.png +42309.png +57085.png +23963.png +66713.png +66476.png +24230.png +25848.png +67925.png +46205.png +53908.png +30073.png +25184.png +23818.png +28913.png +17652.png +57573.png +08569.png +08267.png +62002.png +44364.png +07155.png +52850.png +01336.png +10725.png +21767.png +36759.png +25454.png +11784.png +43907.png +25603.png +33079.png +21582.png +19951.png +18140.png +55503.png +08120.png +53121.png +15663.png +25857.png +07890.png +18234.png +25369.png +23458.png +48907.png +02143.png +48942.png +26794.png +48233.png +34266.png +60583.png +28482.png +59973.png +23768.png +28461.png +20142.png +00771.png +09351.png +00746.png +60920.png +58078.png +53868.png +66635.png +67464.png +17804.png +28019.png +64490.png +41125.png +61222.png +52449.png +24982.png +28053.png +04594.png +24457.png +49504.png +63647.png +32120.png +06535.png +69580.png +16041.png +62515.png +49434.png +41942.png +11668.png +40572.png +08891.png +07366.png +38135.png +59443.png +46512.png +07290.png +17626.png +35949.png +32435.png +31242.png +68389.png +09314.png +49359.png +40843.png +44850.png +52755.png +24650.png +22923.png +59685.png +56288.png +23517.png +58339.png +29629.png +59712.png +53697.png +16193.png +09836.png +30912.png +24631.png +21852.png +20045.png +20756.png +17552.png +02476.png +26493.png +38583.png +18690.png +27369.png +04514.png +11163.png +45614.png +12342.png +20284.png +40701.png +57650.png +13287.png +03147.png +41717.png +38321.png +29606.png +43344.png +52349.png +12463.png +29656.png +64540.png +14057.png +39120.png +16374.png +68297.png +37262.png +65653.png +16317.png +68057.png +69988.png +47392.png +11049.png +08104.png +31104.png +12106.png +12562.png +29376.png +18847.png +49771.png +52588.png +45002.png +04576.png +48197.png +11920.png +53385.png +09965.png +02145.png +21452.png +25437.png +07167.png +51864.png +43322.png +52950.png +05365.png +58087.png +09809.png +30077.png +45387.png +02497.png +27008.png +08732.png +69026.png +34714.png +58931.png +42212.png +21964.png +37300.png +08897.png +06736.png +29197.png +18402.png +00924.png +29651.png +59536.png +61995.png +60421.png +69548.png +58748.png +67835.png +57525.png +53228.png +50316.png +66049.png +04509.png +60149.png +40441.png +21690.png +28172.png +01155.png +50057.png +42289.png +36512.png +01588.png +61436.png +61758.png +59879.png +68550.png +48657.png +12455.png +45932.png +34297.png +32842.png +31368.png +25402.png +27217.png +60433.png +63983.png +15518.png +13827.png +32363.png +06046.png +05020.png +45191.png +43653.png +68437.png +58987.png +15121.png +23714.png +18111.png +65329.png +05347.png +10130.png +19465.png +39294.png +00372.png +02080.png +00936.png +31658.png +63764.png +27126.png +65805.png +37096.png +56166.png +48918.png +46077.png +42261.png +21444.png +45192.png +22771.png +28033.png +04712.png +47681.png +68662.png +03188.png +55425.png +50300.png +50814.png +67665.png +10714.png +14233.png +68785.png +68548.png +24881.png +35792.png +14924.png +35159.png +04753.png +30765.png +01344.png +25212.png +08932.png +67536.png +48440.png +41083.png +12059.png +67558.png +30903.png +20269.png +65462.png +07554.png +08948.png +33761.png +31107.png +12380.png +51129.png +60689.png +41012.png +30746.png +63563.png +62353.png +57962.png +40132.png +51040.png +51355.png +51413.png +65932.png +08772.png +28662.png +28124.png +38078.png +54874.png +57835.png +64972.png +48668.png +11617.png +52020.png +12497.png +32444.png +59512.png +17394.png +51337.png +43491.png +45154.png +11597.png +69481.png +35479.png +48564.png +42426.png +20095.png +08571.png +28484.png +68263.png +54987.png +17141.png +66746.png +08687.png +39465.png +03652.png +28434.png +45702.png +67919.png +22272.png +42895.png +30559.png +55894.png +00509.png +36117.png +66777.png +44166.png +45896.png +59043.png +24367.png +57166.png +59529.png +34117.png +40111.png +20207.png +61278.png +03194.png +19840.png +59811.png +68587.png +28911.png +26641.png +27306.png +21443.png +59146.png +23881.png +60579.png +44398.png +24119.png +48382.png +27736.png +47510.png +25190.png +22415.png +40992.png +12486.png +69219.png +31504.png +55863.png +33747.png +53393.png +11112.png +60907.png +30761.png +03849.png +25321.png +15209.png +57645.png +41395.png +13251.png +56755.png +09397.png +32461.png +09416.png +15482.png +49127.png +69193.png +46983.png +20631.png +08404.png +18511.png +46787.png +28045.png +54913.png +02227.png +38640.png +49233.png +54388.png +44600.png +65534.png +47628.png +62737.png +01820.png +00772.png +49618.png +43734.png +32918.png +52430.png +30577.png +38063.png +42831.png +14533.png +10479.png +16927.png +50522.png +42241.png +28150.png +65178.png +35012.png +13910.png +17967.png +16012.png +10832.png +21835.png +55746.png +59131.png +45019.png +67640.png +18196.png +19066.png +11370.png +57781.png +46679.png +26393.png +67668.png +58877.png +64635.png +69987.png +22290.png +02241.png +42304.png +26326.png +22619.png +61946.png +52986.png +60370.png +38642.png +61072.png +43165.png +21985.png +03726.png +29813.png +56725.png +08839.png +23378.png +30023.png +51984.png +09652.png +21409.png +38169.png +08197.png +36591.png +61595.png +19612.png +39282.png +11300.png +18468.png +16837.png +01818.png +33481.png +55006.png +27409.png +58533.png +25653.png +55896.png +25741.png +69318.png +46782.png +22954.png +53043.png +31113.png +00552.png +18894.png +22557.png +14919.png +49023.png +42019.png +52976.png +67921.png +23233.png +25879.png +32464.png +10765.png +68355.png +56217.png +26390.png +68167.png +02461.png +19533.png +64679.png +55323.png +29688.png +19481.png +52157.png +26454.png +00898.png +07593.png +64976.png +16471.png +23731.png +24577.png +64051.png +50112.png +67987.png +05835.png +49845.png +62131.png +26429.png +46529.png +13231.png +38647.png +01685.png +68675.png +64293.png +07484.png +29497.png +53386.png +38449.png +34988.png +44820.png +32549.png +37655.png +09415.png +34008.png +47276.png +05969.png +07158.png +47010.png +06795.png +19729.png +36548.png +59293.png +47368.png +54025.png +67801.png +30005.png +58140.png +45202.png +45347.png +20430.png +57282.png +57372.png +52863.png +64964.png +03396.png +53380.png +12743.png +42880.png +18273.png +32542.png +07430.png +39345.png +34788.png +15747.png +56088.png +45201.png +02827.png +48512.png +31346.png +51480.png +39337.png +30033.png +34034.png +44546.png +39987.png +51374.png +30611.png +13871.png +65475.png +25097.png +61602.png +45754.png +57203.png +38121.png +07957.png +14839.png +57053.png +00002.png +24591.png +33649.png +53180.png +37422.png +61681.png +45329.png +17599.png +26765.png +34975.png +08418.png +19594.png +41025.png +29874.png +60281.png +25332.png +21234.png +39137.png +58209.png +68642.png +43743.png +38021.png +22400.png +55316.png +24269.png +06868.png +20872.png +12756.png +49616.png +08017.png +39508.png +50653.png +54713.png +57819.png +25069.png +46063.png +33600.png +03100.png +43316.png +21151.png +09540.png +69289.png +07228.png +06307.png +33706.png +29388.png +37292.png +26389.png +18708.png +14830.png +28268.png +15877.png +24903.png +26073.png +41255.png +68392.png +57391.png +46255.png +35239.png +43616.png +63022.png +40006.png +00447.png +19119.png +34323.png +16068.png +31150.png +16065.png +29901.png +46855.png +35705.png +54210.png +02611.png +57903.png +31775.png +36948.png +14901.png +28401.png +42275.png +54198.png +63748.png +55359.png +53659.png +16261.png +03087.png +49634.png +45195.png +14075.png +24496.png +63437.png +13464.png +15681.png +41938.png +29534.png +18634.png +15810.png +27723.png +20867.png +43150.png +47430.png +67880.png +30656.png +34525.png +34922.png +58177.png +00028.png +68706.png +02358.png +24826.png +20219.png +16934.png +00926.png +21344.png +25199.png +44132.png +67959.png +24191.png +69448.png +19414.png +55591.png +31610.png +14915.png +42540.png +32866.png +03556.png +19097.png +58189.png +57003.png +12044.png +21102.png +09959.png +17043.png +29665.png +27939.png +40357.png +39454.png +50004.png +17689.png +47245.png +38478.png +63202.png +33368.png +37371.png +04556.png +56296.png +28997.png +48308.png +20540.png +48821.png +26635.png +22776.png +16247.png +39698.png +52066.png +06182.png +53371.png +21495.png +05302.png +03692.png +11861.png +08356.png +53113.png +54967.png +05085.png +22060.png +43546.png +35458.png +39888.png +60721.png +47716.png +09593.png +14244.png +25296.png +55033.png +59056.png +69641.png +02675.png +13493.png +35298.png +23536.png +48697.png +27874.png +27111.png +52438.png +07436.png +09880.png +24937.png +56061.png +00700.png +59126.png +44512.png +10902.png +22385.png +21251.png +66764.png +40427.png +45312.png +40287.png +53376.png +03777.png +36729.png +60319.png +53876.png +06838.png +66572.png +24429.png +44393.png +35874.png +18119.png +31763.png +25130.png +11368.png +09234.png +48773.png +20678.png +43588.png +38549.png +12226.png +43959.png +48911.png +32559.png +10123.png +61916.png +32421.png +61175.png +18213.png +04307.png +08978.png +12338.png +43540.png +61824.png +48987.png +41617.png +04380.png +67701.png +54111.png +62730.png +29423.png +20040.png +37100.png +25717.png +50945.png +23584.png +36742.png +59000.png +52793.png +46152.png +17130.png +41428.png +53748.png +37974.png +49959.png +18371.png +19126.png +19912.png +55701.png +62641.png +66822.png +26133.png +17683.png +53487.png +56428.png +66688.png +47421.png +26980.png +52678.png +51842.png +12870.png +61097.png +46539.png +11742.png +30530.png +29168.png +05940.png +25232.png +65400.png +37612.png +13414.png +30063.png +09702.png +08828.png +48088.png +04743.png +66205.png +53181.png +55244.png +36429.png +63250.png +00300.png +53281.png +24203.png +64002.png +41410.png +11975.png +24856.png +25057.png +00037.png +34685.png +11484.png +32631.png +23873.png +45532.png +60387.png +34752.png +41640.png +57538.png +40754.png +03281.png +63612.png +28410.png +54527.png +41807.png +13362.png +47485.png +36862.png +02558.png +29368.png +07295.png +06369.png +19996.png +22437.png +01023.png +46609.png +59220.png +49104.png +68679.png +07511.png +05740.png +39461.png +30219.png +06671.png +07771.png +17674.png +07149.png +20390.png +02069.png +22206.png +62838.png +39346.png +67049.png +64848.png +40696.png +23777.png +03288.png +33486.png +43207.png +21454.png +68708.png +21380.png +10647.png +22170.png +45591.png +16756.png +12484.png +05403.png +50744.png +23739.png +18534.png +34137.png +10392.png +52550.png +14305.png +60368.png +06778.png +20237.png +55355.png +66269.png +59715.png +09801.png +33696.png +01368.png +14467.png +09718.png +48722.png +24438.png +56028.png +51286.png +58770.png +36032.png +31726.png +09579.png +12423.png +22756.png +10625.png +51552.png +11660.png +02375.png +18591.png +69739.png +18569.png +50182.png +28474.png +06252.png +65487.png +49444.png +60819.png +61531.png +63041.png +38296.png +07038.png +61716.png +63503.png +26549.png +45462.png +54676.png +54180.png +26004.png +65355.png +22581.png +61476.png +34287.png +55734.png +29583.png +34010.png +26602.png +35367.png +58067.png +11725.png +58187.png +62827.png +06433.png +60372.png +42786.png +15620.png +28576.png +06322.png +00565.png +58557.png +49506.png +27825.png +63700.png +20392.png +50083.png +01951.png +69875.png +36888.png +46182.png +09821.png +05317.png +60198.png +05355.png +54140.png +39629.png +69619.png +31571.png +07720.png +25915.png +22416.png +37694.png +51578.png +13761.png +13785.png +64345.png +48467.png +15957.png +08600.png +54729.png +04814.png +60628.png +01888.png +10574.png +34519.png +40735.png +50164.png +50222.png +23050.png +27946.png +47396.png +33488.png +23740.png +23314.png +09491.png +63614.png +38878.png +30072.png +64272.png +07424.png +54419.png +30834.png +49491.png +33870.png +28445.png +09563.png +14538.png +03999.png +03891.png +18837.png +50626.png +06225.png +13909.png +62437.png +17727.png +10223.png +08531.png +53769.png +20022.png +41892.png +64879.png +28852.png +14216.png +57830.png +41299.png +31895.png +61696.png +51870.png +41611.png +69298.png +61359.png +55969.png +24999.png +55529.png +63876.png +43193.png +06178.png +39752.png +03996.png +67625.png +44889.png +56270.png +14665.png +39121.png +57824.png +11156.png +42698.png +34881.png +12642.png +52971.png +51354.png +13795.png +16605.png +24268.png +54378.png +31872.png +49973.png +01551.png +66545.png +49837.png +11127.png +27646.png +34335.png +56056.png +53773.png +08794.png +15536.png +63115.png +56513.png +26364.png +58398.png +66789.png +03134.png +11244.png +52060.png +21792.png +25002.png +04462.png +44041.png +48717.png +20614.png +34261.png +55867.png +45036.png +69873.png +28781.png +17939.png +26799.png +30894.png +42061.png +12571.png +10498.png +02544.png +41955.png +41215.png +32418.png +54234.png +06606.png +61280.png +22596.png +35927.png +25972.png +17226.png +50830.png +53643.png +14996.png +66593.png +40347.png +47858.png +69823.png +51304.png +19927.png +46461.png +30572.png +24729.png +69801.png +35898.png +27159.png +20529.png +64955.png +31705.png +27313.png +68922.png +09999.png +29102.png +42757.png +52437.png +54974.png +22441.png +24838.png +69451.png +69292.png +29995.png +57672.png +33558.png +26427.png +14033.png +68453.png +30827.png +25173.png +51998.png +13465.png +30529.png +58034.png +61390.png +67197.png +69559.png +09571.png +07615.png +09184.png +36574.png +10656.png +33571.png +16829.png +20937.png +59506.png +31221.png +45836.png +52661.png +40699.png +15308.png +45124.png +36427.png +10444.png +61705.png +16110.png +20158.png +59205.png +04564.png +24704.png +04368.png +03477.png +32075.png +32974.png +60007.png +24275.png +02606.png +50014.png +19298.png +64556.png +54238.png +22964.png +31340.png +66282.png +18642.png +08227.png +25192.png +43648.png +26994.png +53192.png +60375.png +51280.png +12841.png +48917.png +65533.png +22071.png +27381.png +34069.png +54761.png +38616.png +67014.png +39834.png +41293.png +33014.png +28889.png +18050.png +13854.png +66348.png +16270.png +31740.png +35667.png +25475.png +69388.png +65615.png +31795.png +50312.png +49245.png +64975.png +55982.png +24011.png +64591.png +60999.png +19062.png +26309.png +43239.png +15976.png +42643.png +58700.png +38036.png +45060.png +26840.png +05779.png +65296.png +58089.png +63435.png +42838.png +37553.png +21041.png +26763.png +57001.png +37616.png +43688.png +21285.png +32358.png +68265.png +06333.png +68215.png +60876.png +36659.png +57211.png +12766.png +64641.png +10867.png +23276.png +26457.png +19265.png +64170.png +38267.png +65669.png +07804.png +56005.png +42922.png +45778.png +18270.png +63346.png +43824.png +38306.png +19565.png +20326.png +40160.png +52772.png +63270.png +58994.png +67882.png +16250.png +50281.png +44183.png +69761.png +28189.png +61016.png +59417.png +21546.png +30547.png +69375.png +64839.png +68187.png +20025.png +05309.png +64131.png +09115.png +44843.png +32686.png +46498.png +67578.png +18845.png +23155.png +57027.png +21274.png +35718.png +65334.png +53142.png +66521.png +21089.png +37583.png +10838.png +59237.png +57061.png +57587.png +21240.png +26410.png +21202.png +35297.png +40377.png +43478.png +67246.png +24512.png +21110.png +20330.png +04503.png +45902.png +24207.png +20268.png +07222.png +14709.png +51591.png +11539.png +43031.png +37235.png +67967.png +55646.png +48128.png +54561.png +04604.png +58290.png +08264.png +58955.png +05671.png +20924.png +26761.png +18092.png +65693.png +51987.png +41544.png +40738.png +65049.png +29284.png +69102.png +20380.png +25819.png +28700.png +26612.png +21631.png +24173.png +12837.png +45110.png +61618.png +38491.png +68228.png +69541.png +16362.png +27214.png +45995.png +05828.png +54906.png +27919.png +38087.png +27966.png +48459.png +10609.png +64690.png +69748.png +33060.png +45102.png +44732.png +05825.png +41694.png +40721.png +33007.png +57339.png +55363.png +26108.png +42598.png +05887.png +06921.png +31018.png +26707.png +48236.png +33033.png +02055.png +03207.png +06233.png +17935.png +44261.png +67184.png +54782.png +05259.png +17917.png +37189.png +29753.png +09398.png +02563.png +38671.png +43613.png +30032.png +48851.png +21280.png +64116.png +48468.png +64438.png +43550.png +16473.png +20345.png +12527.png +69255.png +48979.png +43149.png +65187.png +41599.png +67753.png +08721.png +23414.png +25412.png +55301.png +39448.png +56970.png +07201.png +65063.png +55302.png +64729.png +35152.png +02165.png +38190.png +69672.png +15298.png +09196.png +54902.png +48932.png +30787.png +16313.png +66283.png +53554.png +15086.png +04649.png +16573.png +01290.png +55293.png +35674.png +62108.png +25565.png +16768.png +30768.png +15994.png +41952.png +02211.png +46131.png +58627.png +43155.png +00172.png +20019.png +46315.png +10283.png +49815.png +42859.png +07830.png +20360.png +12086.png +28241.png +20966.png +28365.png +48992.png +19607.png +40906.png +02792.png +15564.png +69431.png +39659.png +64296.png +36216.png +48587.png +15856.png +49981.png +21571.png +01399.png +16350.png +58382.png +48620.png +30060.png +64314.png +27834.png +27647.png +30404.png +40937.png +10988.png +64987.png +52796.png +35694.png +32200.png +20971.png +17397.png +41974.png +66056.png +08272.png +37451.png +26455.png +28709.png +08602.png +16721.png +14771.png +39701.png +51641.png +09271.png +29661.png +07321.png +49860.png +37810.png +47911.png +35242.png +03612.png +01068.png +68980.png +62774.png +48135.png +47021.png +07408.png +68873.png +57115.png +18833.png +08561.png +28296.png +59819.png +46908.png +57680.png +51169.png +25161.png +15012.png +08510.png +11945.png +33344.png +20695.png +66661.png +44213.png +21437.png +69678.png +40540.png +58970.png +50960.png +34839.png +56199.png +60983.png +04082.png +22566.png +66729.png +06326.png +16659.png +11083.png +60927.png +29672.png +50061.png +50169.png +40522.png +55030.png +49635.png +23095.png +46126.png +32288.png +12422.png +13377.png +14546.png +01318.png +28508.png +45125.png +44368.png +07778.png +05586.png +53062.png +33699.png +61055.png +17978.png +62534.png +69501.png +13777.png +14104.png +15057.png +65679.png +36850.png +05287.png +44860.png +45289.png +30058.png +41710.png +45659.png +38341.png +27888.png +64827.png +40187.png +26870.png +44680.png +41197.png +55928.png +58033.png +26287.png +60877.png +54952.png +32501.png +40615.png +65271.png +64683.png +00978.png +13722.png +04308.png +18575.png +37182.png +35301.png +44853.png +51138.png +05880.png +17591.png +24216.png +61490.png +29267.png +32661.png +25818.png +17530.png +57216.png +65515.png +64150.png +10091.png +53155.png +11889.png +61368.png +57046.png +44687.png +57348.png +00775.png +23492.png +27490.png +27614.png +06458.png +64309.png +44053.png +08552.png +28026.png +37903.png +37946.png +57239.png +52258.png +52581.png +29958.png +25055.png +51262.png +31463.png +63016.png +06803.png +33910.png +15478.png +12900.png +30103.png +15921.png +39430.png +53990.png +27477.png +14884.png +44439.png +64236.png +27716.png +47752.png +63212.png +63387.png +51079.png +17474.png +53479.png +07453.png +29235.png +06894.png +69187.png +60086.png +36639.png +63504.png +65858.png +59324.png +27843.png +30075.png +04158.png +31788.png +68649.png +49695.png +15490.png +50219.png +37406.png +00374.png +32882.png +44048.png +39205.png +34557.png +67103.png +04508.png +15169.png +27809.png +69598.png +65756.png +38843.png +22808.png +24705.png +67814.png +42480.png +64812.png +61554.png +22542.png +49512.png +62782.png +22379.png +27064.png +25505.png +00832.png +56941.png +17950.png +59727.png +50430.png +23591.png +62823.png +39236.png +49730.png +65016.png +06076.png +54399.png +45508.png +55474.png +31928.png +28762.png +03414.png +05228.png +46955.png +00018.png +56141.png +11994.png +27049.png +40455.png +25463.png +56505.png +25931.png +26924.png +31882.png +03284.png +60703.png +61445.png +60758.png +69513.png +37274.png +30409.png +05463.png +41998.png +09706.png +22508.png +58447.png +28704.png +22854.png +43595.png +68115.png +52979.png +08841.png +58411.png +59292.png +53288.png +44421.png +64154.png +68377.png +17519.png +13208.png +32599.png +49621.png +38973.png +56350.png +11987.png +62973.png +58634.png +21700.png +34017.png +35419.png +52567.png +48301.png +43176.png +18774.png +59754.png +37774.png +28413.png +42405.png +10993.png +09058.png +41351.png +65036.png +03528.png +47831.png +39226.png +51549.png +63476.png +51496.png +53901.png +32299.png +20828.png +07888.png +36398.png +54117.png +52194.png +24555.png +57131.png +46869.png +55537.png +04968.png +43666.png +56764.png +02156.png +15726.png +63669.png +65440.png +00914.png +40042.png +21555.png +45323.png +10856.png +57831.png +06151.png +37481.png +23394.png +04310.png +10157.png +35510.png +06016.png +44609.png +58014.png +45298.png +44040.png +48741.png +14751.png +25290.png +34771.png +36289.png +24377.png +37581.png +27456.png +17078.png +18325.png +53935.png +40958.png +17429.png +46242.png +09281.png +07279.png +24812.png +21278.png +64912.png +00766.png +39408.png +46628.png +33621.png +16855.png +64365.png +61141.png +64534.png +16739.png +48303.png +52542.png +29420.png +35998.png +60240.png +56599.png +00209.png +58637.png +47087.png +09913.png +35211.png +47922.png +50188.png +11432.png +56979.png +18064.png +36465.png +59200.png +17033.png +39092.png +69649.png +59175.png +40367.png +19636.png +69606.png +22169.png +43181.png +00015.png +19216.png +34672.png +20741.png +66950.png +12327.png +38603.png +21681.png +40055.png +45254.png +37674.png +53754.png +15782.png +56049.png +67090.png +68554.png +40273.png +35041.png +01202.png +10126.png +43987.png +65848.png +34607.png +14066.png +14845.png +29857.png +34758.png +39962.png +55232.png +48845.png +10425.png +21099.png +22553.png +54588.png +34393.png +09760.png +66473.png +13503.png +08855.png +07316.png +06486.png +54222.png +62870.png +06844.png +04290.png +56239.png +31486.png +65001.png +02422.png +49377.png +11827.png +07371.png +69628.png +32579.png +42430.png +39133.png +55789.png +33843.png +59218.png +66477.png +15700.png +39385.png +47412.png +39125.png +36093.png +33495.png +12364.png +33151.png +30223.png +51694.png +61223.png +40218.png +36116.png +27668.png +20029.png +48791.png +33812.png +32249.png +43996.png +15473.png +53089.png +02820.png +53189.png +43044.png +12406.png +24614.png +33640.png +37725.png +22029.png +00339.png +10908.png +48706.png +29660.png +22404.png +15824.png +19169.png +21201.png +27258.png +09911.png +32176.png +28777.png +62141.png +12627.png +07797.png +64476.png +10749.png +35023.png +10135.png +48881.png +17812.png +02159.png +51699.png +18171.png +02487.png +05657.png +16524.png +33674.png +32270.png +21667.png +14409.png +17623.png +56729.png +61922.png +14902.png +05379.png +34508.png +30170.png +14418.png +06951.png +13188.png +10335.png +69807.png +09099.png +23001.png +14620.png +06221.png +34516.png +45933.png +11902.png +60031.png +17513.png +24581.png +57243.png +48347.png +32031.png +17837.png +06861.png +59462.png +29381.png +38238.png +35121.png +33280.png +49132.png +12925.png +29568.png +45119.png +11440.png +09140.png +12506.png +54652.png +22813.png +45800.png +45642.png +25222.png +52735.png +63297.png +30078.png +00623.png +00800.png +07938.png +03116.png +56304.png +22911.png +05103.png +02477.png +68549.png +62889.png +21159.png +13788.png +39284.png +08881.png +63853.png +57334.png +50627.png +16170.png +52416.png +10675.png +21913.png +35498.png +68237.png +06383.png +06419.png +10042.png +30523.png +65003.png +10911.png +52439.png +34357.png +62233.png +14596.png +21817.png +44894.png +04879.png +28826.png +57594.png +10138.png +06716.png +30813.png +40842.png +44543.png +10534.png +10456.png +21892.png +52659.png +33435.png +49680.png +05556.png +06364.png +32314.png +61943.png +14571.png +38880.png +20018.png +41208.png +38134.png +35553.png +27978.png +62449.png +33974.png +59326.png +07968.png +34960.png +16944.png +50749.png +27617.png +51643.png +32543.png +54147.png +19606.png +30776.png +06131.png +29644.png +38999.png +39367.png +09967.png +59968.png +00610.png +56380.png +13568.png +64943.png +20164.png +20677.png +11164.png +63618.png +52047.png +33465.png +31509.png +19112.png +06467.png +26052.png +64040.png +00801.png +08016.png +41252.png +33553.png +57760.png +67176.png +45144.png +03995.png +49896.png +09533.png +10142.png +00138.png +67862.png +54962.png +03195.png +53880.png +01995.png +22944.png +43382.png +46865.png +29572.png +30508.png +25178.png +61801.png +21572.png +00808.png +43022.png +64210.png +39269.png +17270.png +09157.png +51666.png +08454.png +16305.png +01758.png +54706.png +48427.png +15973.png +15888.png +67074.png +20619.png +47590.png +25721.png +41386.png +24059.png +11283.png +19672.png +10257.png +59229.png +55048.png +49317.png +11543.png +14631.png +14354.png +28873.png +59542.png +02825.png +39926.png +54595.png +54657.png +60572.png +45616.png +43561.png +22457.png +46552.png +26878.png +68200.png +04080.png +46641.png +24955.png +31754.png +48269.png +09844.png +04439.png +14064.png +20669.png +09357.png +58115.png +16440.png +02428.png +60418.png +41388.png +32161.png +09964.png +49353.png +49252.png +69796.png +37241.png +58963.png +04732.png +34618.png +22292.png +40867.png +63538.png +69395.png +35519.png +12881.png +20618.png +27958.png +49652.png +26724.png +11353.png +07145.png +48465.png +20211.png +22863.png +15519.png +64631.png +57522.png +41102.png +16428.png +45594.png +13181.png +02360.png +09714.png +42785.png +65520.png +67856.png +55530.png +18560.png +45603.png +10878.png +26889.png +30770.png +42484.png +52666.png +36049.png +28109.png +18304.png +50577.png +58208.png +69288.png +00981.png +50026.png +13453.png +21953.png +19469.png +05840.png +69658.png +03453.png +42371.png +19023.png +68541.png +26681.png +61193.png +08399.png +59742.png +49097.png +53310.png +08920.png +10772.png +16365.png +49193.png +69399.png +56260.png +55389.png +14032.png +15108.png +10516.png +61250.png +02001.png +35412.png +30591.png +38728.png +11281.png +29233.png +26295.png +27912.png +66045.png +10670.png +53003.png +35528.png +48726.png +48146.png +61764.png +37951.png +00570.png +13820.png +02512.png +47966.png +06669.png +09871.png +10829.png +15076.png +66051.png +51068.png +49321.png +00183.png +36364.png +57032.png +67400.png +02896.png +61373.png +51558.png +23037.png +01465.png +35045.png +61403.png +66705.png +05383.png +03921.png +19678.png +49072.png +64703.png +35752.png +68710.png +67004.png +08976.png +23152.png +06637.png +22150.png +54242.png +09170.png +65563.png +43946.png +50551.png +56543.png +62245.png +52493.png +42052.png +52681.png +28164.png +25198.png +22412.png +43369.png +50283.png +03278.png +23796.png +34291.png +18820.png +08835.png +52255.png +23531.png +12548.png +33441.png +06152.png +57728.png +68157.png +14204.png +10980.png +15955.png +62360.png +54523.png +38994.png +63807.png +51810.png +18203.png +58158.png +65636.png +11706.png +31128.png +57528.png +41266.png +34298.png +62162.png +02464.png +57978.png +11980.png +56312.png +49545.png +13671.png +16228.png +69015.png +35031.png +32168.png +45530.png +09420.png +20761.png +26495.png +36598.png +19458.png +29282.png +21565.png +22435.png +52694.png +60330.png +61580.png +54606.png +48886.png +41117.png +44610.png +28430.png +41071.png +57943.png +24253.png +36992.png +35450.png +08316.png +42788.png +54810.png +09295.png +34042.png +45149.png +11499.png +25288.png +13632.png +61864.png +49330.png +19595.png +04068.png +42064.png +48742.png +43371.png +30152.png +35190.png +62262.png +58311.png +65610.png +49282.png +09935.png +15127.png +39210.png +25253.png +37762.png +45738.png +54376.png +35782.png +13724.png +11036.png +21059.png +06231.png +42096.png +52412.png +08297.png +13790.png +03041.png +48923.png +01304.png +32451.png +39785.png +60557.png +62017.png +55941.png +49096.png +48414.png +08864.png +33913.png +53856.png +31405.png +43010.png +62908.png +67575.png +61603.png +52414.png +64822.png +30202.png +57908.png +26480.png +43187.png +60702.png +25336.png +34708.png +14169.png +38509.png +47714.png +44887.png +01375.png +60892.png +40076.png +41176.png +09958.png +59959.png +04330.png +25140.png +66342.png +16182.png +65699.png +01808.png +58964.png +38608.png +53977.png +61873.png +22061.png +69944.png +61244.png +23199.png +34523.png +15052.png +59732.png +21412.png +60074.png +47538.png +27431.png +24214.png +41459.png +50171.png +01969.png +13407.png +37015.png +15002.png +23081.png +12060.png +21744.png +09739.png +61992.png +40156.png +49762.png +31270.png +44466.png +23804.png +18491.png +69743.png +14627.png +04449.png +34945.png +67979.png +69207.png +10106.png +58721.png +34492.png +22419.png +43370.png +22530.png +23207.png +24005.png +47923.png +55901.png +56894.png +36288.png +22177.png +10508.png +25643.png +18725.png +44635.png +06779.png +46038.png +33066.png +39525.png +00013.png +43577.png +20213.png +60066.png +53333.png +41360.png +17986.png +49795.png +40899.png +34024.png +20037.png +55979.png +07400.png +55909.png +16803.png +46765.png +18756.png +69644.png +38586.png +14108.png +54522.png +33413.png +67524.png +04076.png +29386.png +47843.png +44193.png +66480.png +19600.png +03359.png +05693.png +45104.png +13159.png +05608.png +00146.png +40109.png +06790.png +18957.png +56866.png +62642.png +63745.png +38559.png +45964.png +03287.png +63394.png +01424.png +54776.png +01745.png +64978.png +42157.png +11508.png +23159.png +60423.png +31425.png +49531.png +25601.png +60455.png +59815.png +10641.png +22100.png +36140.png +48609.png +08207.png +29671.png +47501.png +60515.png +09843.png +51937.png +12209.png +18673.png +57273.png +23625.png +68797.png +06039.png +51624.png +19464.png +12992.png +51824.png +39476.png +62024.png +31972.png +45893.png +09479.png +25143.png +02023.png +65363.png +54749.png +16445.png +42805.png +58820.png +48874.png +28140.png +19797.png +33247.png +18559.png +10494.png +28227.png +00310.png +25520.png +05437.png +43013.png +69613.png +16562.png +62630.png +34479.png +25462.png +58737.png +30349.png +27225.png +27550.png +38733.png +54026.png +55853.png +02734.png +36509.png +21130.png +58213.png +02182.png +48020.png +11390.png +50341.png +24869.png +58732.png +34253.png +66475.png +24146.png +10178.png +48641.png +67023.png +34831.png +60431.png +58609.png +17691.png +59156.png +40191.png +47926.png +23986.png +30482.png +12903.png +47442.png +53622.png +67758.png +13567.png +34068.png +27474.png +00998.png +35047.png +29187.png +47886.png +21642.png +16421.png +46247.png +16211.png +68258.png +39909.png +24016.png +63296.png +06630.png +47084.png +43095.png +29636.png +25887.png +67541.png +26537.png +57222.png +37559.png +52763.png +27608.png +62777.png +20670.png +46990.png +37044.png +16370.png +50392.png +53947.png +36172.png +11627.png +15304.png +53653.png +21986.png +69850.png +54624.png +22443.png +45739.png +09457.png +27555.png +52252.png +62015.png +42683.png +27885.png +56186.png +22305.png +43333.png +19553.png +01569.png +49556.png +60131.png +28475.png +37490.png +25486.png +54586.png +57332.png +45464.png +13145.png +47990.png +51664.png +49624.png +45434.png +69716.png +47810.png +59416.png +06651.png +64193.png +58064.png +20475.png +12296.png +69252.png +13319.png +48975.png +22900.png +34125.png +52140.png +03452.png +06826.png +47575.png +27228.png +61861.png +58291.png +10707.png +20838.png +68519.png +50779.png +39862.png +09421.png +60055.png +17872.png +01857.png +55312.png +55597.png +20965.png +13961.png +50877.png +59165.png +67650.png +56507.png +11609.png +55940.png +59300.png +39884.png +05061.png +30380.png +42710.png +05551.png +17209.png +35982.png +18062.png +52673.png +61215.png +35514.png +45524.png +57435.png +42291.png +48133.png +04359.png +49749.png +43914.png +05619.png +11310.png +52744.png +46497.png +58400.png +27503.png +68238.png +51981.png +60249.png +46919.png +14619.png +13335.png +61258.png +37278.png +48336.png +35995.png +10558.png +02277.png +60716.png +29069.png +42182.png +47146.png +40718.png +21594.png +54883.png +59828.png +39521.png +38554.png +62139.png +49882.png +40770.png +05281.png +04823.png +09365.png +30389.png +56665.png +25306.png +21154.png +06977.png +04865.png +27394.png +29601.png +41925.png +29286.png +67576.png +54095.png +27075.png +55536.png +48445.png +19519.png +22280.png +50425.png +23104.png +07877.png +10630.png +58670.png +20737.png +61672.png +34588.png +01761.png +62362.png +53112.png +69462.png +21322.png +31451.png +52528.png +52182.png +43680.png +30171.png +58192.png +00555.png +64297.png +64621.png +33858.png +44707.png +40811.png +04125.png +12932.png +29091.png +26192.png +22495.png +42655.png +36109.png +23966.png +32372.png +00495.png +45301.png +33319.png +52300.png +06261.png +18437.png +12210.png +15763.png +04231.png +23648.png +22090.png +58708.png +31636.png +15900.png +57129.png +46031.png +06990.png +46658.png +24467.png +32353.png +09641.png +04124.png +36673.png +34015.png +44351.png +05523.png +55802.png +50456.png +34673.png +23031.png +66064.png +33789.png +55434.png +55588.png +28385.png +62309.png +20103.png +00468.png +44035.png +23802.png +52838.png +37410.png +54003.png +54617.png +37080.png +32034.png +64609.png +17879.png +53701.png +35900.png +41891.png +17898.png +04355.png +40489.png +22109.png +36700.png +21790.png +06176.png +02765.png +47443.png +62223.png +09819.png +58936.png +54772.png +39292.png +63867.png +32182.png +20776.png +06909.png +21283.png +48576.png +20077.png +43615.png +29604.png +64989.png +54490.png +28864.png +35944.png +14799.png +52894.png +52311.png +35800.png +57408.png +49553.png +54401.png +57125.png +52791.png +34127.png +36590.png +54042.png +51787.png +11059.png +25883.png +04667.png +01637.png +40226.png +19392.png +49625.png +47188.png +25061.png +51259.png +48384.png +35929.png +62172.png +10234.png +25817.png +27636.png +22584.png +43972.png +48372.png +09850.png +01095.png +44237.png +58863.png +39373.png +22921.png +15902.png +01008.png +46231.png +17681.png +68904.png +44409.png +23781.png +26860.png +51017.png +42646.png +30644.png +66272.png +29510.png +01065.png +35500.png +34502.png +53493.png +12970.png +64780.png +02139.png +44661.png +23372.png +45419.png +28329.png +55957.png +48360.png +22440.png +24306.png +40000.png +54063.png +09268.png +31720.png +64417.png +51762.png +50629.png +29841.png +25888.png +16632.png +29475.png +10931.png +62989.png +46025.png +28560.png +44780.png +09998.png +69979.png +30652.png +62975.png +53631.png +16818.png +50354.png +56113.png +06378.png +63242.png +22686.png +50777.png +62638.png +02504.png +03716.png +45446.png +25874.png +51574.png +18617.png +27940.png +46712.png +42844.png +23258.png +65511.png +64072.png +28056.png +10442.png +14046.png +37859.png +25659.png +69853.png +08209.png +46619.png +41548.png +57226.png +52747.png +28067.png +19920.png +01983.png +54341.png +47827.png +57994.png +34236.png +34611.png +28974.png +42021.png +56904.png +31598.png +49465.png +26638.png +52572.png +47439.png +25929.png +41768.png +67773.png +40975.png +61424.png +17423.png +18793.png +01040.png +13656.png +31844.png +29624.png +26575.png +56518.png +12706.png +62824.png +57796.png +49468.png +62327.png +46061.png +55754.png +00989.png +30293.png +27302.png +07415.png +15556.png +05716.png +30379.png +16693.png +68155.png +10189.png +24667.png +51765.png +28406.png +60392.png +09713.png +31637.png +55718.png +12323.png +62378.png +30029.png +14966.png +08994.png +64253.png +37377.png +66118.png +00960.png +58346.png +09319.png +67988.png +22662.png +54216.png +68602.png +09709.png +00046.png +14580.png +48496.png +34423.png +43541.png +65793.png +27194.png +38252.png +38337.png +27665.png +44458.png +08789.png +30186.png +68128.png +01817.png +68929.png +69032.png +06126.png +43782.png +56928.png +12623.png +54553.png +67496.png +50738.png +58355.png +18481.png +44936.png +05999.png +19400.png +01985.png +60373.png +20458.png +22204.png +69500.png +59690.png +25831.png +24781.png +61194.png +57137.png +17206.png +12197.png +46907.png +25513.png +58313.png +63905.png +41060.png +35535.png +61467.png +55271.png +26242.png +62270.png +16750.png +30488.png +65172.png +49834.png +12585.png +35972.png +43113.png +37744.png +59240.png +37742.png +02294.png +31524.png +07531.png +18515.png +46321.png +40091.png +61292.png +10327.png +44486.png +21824.png +36145.png +69968.png +23923.png +53165.png +23184.png +04301.png +20799.png +55619.png +28209.png +59707.png +40058.png +30111.png +27830.png +04061.png +15187.png +05753.png +14069.png +31261.png +00816.png +51836.png +05661.png +13712.png +49865.png +49361.png +67593.png +40982.png +06887.png +43037.png +39736.png +35563.png +68308.png +63218.png +21584.png +64073.png +31480.png +13420.png +63833.png +14345.png +09738.png +42611.png +66034.png +09791.png +59339.png +43992.png +03460.png +25944.png +53558.png +01472.png +66317.png +13011.png +62917.png +28756.png +48479.png +48840.png +13449.png +60897.png +64480.png +40655.png +52518.png +15539.png +52345.png +24428.png +17045.png +34578.png +19735.png +34418.png +55623.png +63097.png +15081.png +01288.png +09607.png +11576.png +55199.png +58013.png +64190.png +68367.png +47384.png +31327.png +42894.png +28425.png +63715.png +52907.png +27745.png +23844.png +08655.png +46744.png +11487.png +33197.png +27215.png +19795.png +21704.png +34558.png +38622.png +24666.png +42138.png +03855.png +11841.png +37216.png +43647.png +27963.png +63164.png +60984.png +55831.png +40219.png +12020.png +12276.png +09543.png +39326.png +33752.png +19963.png +02747.png +33634.png +63322.png +61812.png +49552.png +65389.png +06389.png +34915.png +02726.png +26362.png +67434.png +00592.png +65244.png +41247.png +01386.png +66253.png +08761.png +20120.png +50603.png +18997.png +39276.png +33614.png +50287.png +41863.png +41879.png +48879.png +00188.png +55862.png +10224.png +59151.png +28237.png +34407.png +65551.png +14062.png +43714.png +65190.png +01291.png +01078.png +04935.png +38648.png +63638.png +44874.png +10885.png +06776.png +34776.png +07182.png +38266.png +57529.png +35177.png +30084.png +01507.png +38767.png +44480.png +34737.png +18758.png +57849.png +04957.png +30163.png +01281.png +43497.png +29077.png +27050.png +10003.png +36315.png +01978.png +50869.png +33250.png +26330.png +29481.png +41752.png +62175.png +15185.png +18843.png +41522.png +23652.png +06530.png +33363.png +22214.png +32188.png +32700.png +36974.png +23474.png +67710.png +30569.png +63615.png +01624.png +62655.png +54442.png +17637.png +46851.png +65045.png +21164.png +17377.png +21298.png +58524.png +31445.png +03039.png +31105.png +20810.png +00671.png +33687.png +46508.png +14607.png +22607.png +00685.png +16392.png +17867.png +48899.png +23434.png +27995.png +68971.png +43660.png +29120.png +07330.png +10032.png +31643.png +42846.png +67821.png +40967.png +49031.png +01312.png +63620.png +69311.png +23195.png +68279.png +61032.png +64222.png +00747.png +14316.png +19583.png +51803.png +32573.png +58256.png +01706.png +20423.png +03098.png +39231.png +23132.png +21716.png +65125.png +30566.png +68331.png +01809.png +20689.png +49247.png +60218.png +04143.png +23865.png +02431.png +52497.png +16310.png +62879.png +62268.png +18621.png +63120.png +34706.png +67147.png +54379.png +18995.png +33945.png +42659.png +00688.png +56484.png +47172.png +64300.png +36526.png +28282.png +39722.png +41051.png +46812.png +65122.png +59284.png +10632.png +22721.png +33480.png +11652.png +50353.png +55433.png +63258.png +57656.png +54980.png +23756.png +53824.png +01176.png +36863.png +68720.png +03446.png +69971.png +39855.png +42944.png +00367.png +10266.png +35864.png +34197.png +09745.png +48860.png +20691.png +04324.png +00254.png +29537.png +28505.png +45343.png +69224.png +13034.png +59572.png +06464.png +48291.png +04433.png +22747.png +61837.png +68718.png +08075.png +59466.png +13315.png +65118.png +34050.png +30425.png +31676.png +17742.png +06952.png +68310.png +06314.png +16582.png +02346.png +56362.png +00982.png +06503.png +21520.png +10007.png +27218.png +10909.png +54465.png +40159.png +26616.png +35529.png +31236.png +18190.png +09077.png +25687.png +53857.png +67203.png +26720.png +54513.png +34203.png +48444.png +05813.png +07726.png +46805.png +37054.png +39999.png +03968.png +41895.png +45233.png +31419.png +57770.png +62927.png +16200.png +68172.png +26739.png +66103.png +62833.png +06668.png +53357.png +25406.png +67847.png +54477.png +69551.png +49640.png +29038.png +26828.png +57210.png +27101.png +20530.png +40637.png +68615.png +12503.png +30269.png +14023.png +67291.png +50641.png +15184.png +35957.png +62718.png +39582.png +07132.png +27221.png +49721.png +34157.png +49396.png +08559.png +64442.png +23036.png +28006.png +13425.png +12357.png +34883.png +24511.png +12704.png +64083.png +32215.png +50525.png +09075.png +55766.png +62829.png +22905.png +08489.png +15551.png +44039.png +32755.png +59689.png +49216.png +19256.png +67522.png +60646.png +57481.png +05717.png +26905.png +55771.png +16981.png +10299.png +39836.png +50142.png +69982.png +60444.png +29242.png +54715.png +68246.png +12919.png +24057.png +06939.png +34169.png +13127.png +53397.png +57577.png +52307.png +69591.png +57171.png +36336.png +40893.png +02836.png +30382.png +40516.png +12985.png +54032.png +69471.png +26219.png +52961.png +51509.png +47515.png +00967.png +00322.png +13422.png +08358.png +17831.png +26801.png +50039.png +57682.png +00710.png +38090.png +30745.png +27370.png +05279.png +62250.png +60312.png +60552.png +10774.png +24025.png +16142.png +26273.png +17091.png +66367.png +14240.png +69062.png +03323.png +64616.png +51965.png +21017.png +01589.png +31864.png +52895.png +35918.png +67750.png +36379.png +27903.png +67936.png +42068.png +18085.png +69308.png +46514.png +62971.png +67011.png +62988.png +19054.png +41085.png +01909.png +59195.png +43888.png +20855.png +59169.png +51548.png +49248.png +02658.png +66543.png +49329.png +46814.png +69666.png +22242.png +01719.png +04157.png +38914.png +34589.png +19374.png +13514.png +61938.png +56094.png +69647.png +34680.png +23877.png +12851.png +58734.png +56587.png +45953.png +41206.png +07789.png +63743.png +01446.png +60470.png +35429.png +32331.png +34998.png +68442.png +19506.png +59347.png +18827.png +14616.png +11917.png +46010.png +47194.png +40017.png +60271.png +11265.png +63163.png +59866.png +69070.png +28661.png +18923.png +46931.png +53041.png +46376.png +17150.png +52517.png +00217.png +14945.png +16360.png +20255.png +04690.png +02517.png +58556.png +43331.png +28353.png +36593.png +09492.png +44189.png +67850.png +37522.png +34326.png +45788.png +01228.png +25422.png +50228.png +56934.png +04500.png +45377.png +61080.png +06847.png +22497.png +33102.png +08921.png +24638.png +25631.png +63843.png +31161.png +66630.png +12511.png +60742.png +63931.png +08609.png +32931.png +41653.png +58148.png +68093.png +01238.png +33469.png +55075.png +34844.png +27160.png +24332.png +24224.png +11429.png +67962.png +46324.png +51890.png +56990.png +68838.png +62255.png +33349.png +15695.png +22770.png +47689.png +33157.png +09981.png +64584.png +06121.png +27680.png +51099.png +22426.png +61762.png +33109.png +35294.png +05630.png +22012.png +57407.png +46759.png +69974.png +46180.png +28162.png +32019.png +51897.png +51421.png +63021.png +66479.png +20688.png +29205.png +29911.png +34167.png +30839.png +69390.png +14517.png +33537.png +24535.png +22017.png +63746.png +56216.png +48241.png +26627.png +15244.png +42226.png +42270.png +22643.png +08084.png +53717.png +66294.png +42621.png +49186.png +19003.png +53150.png +02450.png +03729.png +67198.png +61743.png +46197.png +63525.png +46260.png +28446.png +59971.png +60157.png +48892.png +02844.png +13043.png +31567.png +19687.png +50360.png +27133.png +67471.png +58001.png +47855.png +49112.png +62773.png +23048.png +56966.png +59166.png +12448.png +48948.png +68957.png +45748.png +58704.png +26402.png +10726.png +35292.png +35207.png +08499.png +09342.png +53929.png +36006.png +19859.png +10618.png +08955.png +65594.png +05550.png +28070.png +35699.png +11807.png +18823.png +37515.png +63101.png +02956.png +05194.png +39113.png +26832.png +68664.png +40086.png +35517.png +00788.png +15051.png +03899.png +16761.png +00530.png +40078.png +38595.png +37482.png +02354.png +09651.png +01405.png +16652.png +66592.png +31575.png +14255.png +15015.png +06310.png +10958.png +12405.png +00961.png +37480.png +52746.png +53733.png +14514.png +61794.png +13945.png +05763.png +49848.png +66544.png +53649.png +17776.png +27312.png +51069.png +40372.png +09634.png +07577.png +46592.png +30825.png +61513.png +66134.png +58376.png +51125.png +19991.png +51686.png +58043.png +10791.png +44588.png +20339.png +38631.png +03336.png +10811.png +13849.png +39894.png +57142.png +59355.png +31334.png +56351.png +61847.png +60655.png +23413.png +22197.png +18598.png +08395.png +04986.png +68521.png +12748.png +23034.png +26398.png +36890.png +20920.png +55431.png +00010.png +65402.png +15977.png +49699.png +65345.png +34512.png +10026.png +15843.png +33604.png +66284.png +69114.png +40531.png +50661.png +43025.png +17203.png +68956.png +33443.png +44098.png +03981.png +39321.png +55564.png +40048.png +13858.png +14133.png +30802.png +02052.png +22858.png +55897.png +54150.png +07699.png +69562.png +05547.png +51862.png +49151.png +63548.png +69627.png +42085.png +13890.png +27197.png +67263.png +42465.png +36811.png +53482.png +39097.png +57388.png +31576.png +31677.png +00439.png +23871.png +50928.png +64364.png +41017.png +04141.png +13927.png +39824.png +20003.png +61614.png +11391.png +27470.png +10167.png +04854.png +03917.png +04446.png +22583.png +01804.png +29483.png +30489.png +36963.png +12666.png +32163.png +35130.png +41158.png +43674.png +67860.png +34884.png +48622.png +30436.png +01140.png +25145.png +46573.png +01213.png +04610.png +69194.png +37442.png +30182.png +01772.png +38106.png +61217.png +16994.png +41068.png +11520.png +23857.png +49918.png +58642.png +19206.png +69907.png +42761.png +65377.png +38606.png +17673.png +19191.png +69468.png +66938.png +01495.png +03731.png +27276.png +03280.png +02970.png +09005.png +40288.png +69018.png +04876.png +14006.png +54536.png +43599.png +58617.png +22251.png +29163.png +27165.png +31312.png +19571.png +31253.png +41037.png +46300.png +65540.png +44991.png +51037.png +29749.png +11726.png +42964.png +44279.png +08912.png +09975.png +50454.png +03268.png +59280.png +05772.png +44413.png +52034.png +68223.png +31803.png +22609.png +53206.png +18832.png +63344.png +44525.png +39541.png +12926.png +40849.png +02264.png +51246.png +22603.png +41337.png +35596.png +56426.png +06407.png +48282.png +20832.png +22367.png +59011.png +55313.png +43330.png +14278.png +63655.png +47424.png +06292.png +40520.png +20194.png +12643.png +44391.png +37702.png +40517.png +33591.png +03770.png +54532.png +07251.png +21845.png +41099.png +28686.png +66409.png +62825.png +45184.png +45403.png +09213.png +66595.png +17984.png +41916.png +58635.png +49649.png +51293.png +37735.png +05019.png +62888.png +18182.png +50893.png +43622.png +17337.png +54642.png +34375.png +01854.png +04351.png +05786.png +24174.png +16730.png +34058.png +47465.png +56396.png +10716.png +36719.png +67636.png +23475.png +60325.png +53404.png +59926.png +24372.png +33888.png +27672.png +16762.png +08168.png +63397.png +30127.png +22845.png +38378.png +23828.png +60872.png +21373.png +24401.png +66697.png +38614.png +55472.png +42723.png +69956.png +39411.png +19792.png +61213.png +53451.png +60379.png +58480.png +57353.png +26271.png +33177.png +39111.png +22910.png +53825.png +32910.png +25936.png +64932.png +57471.png +17172.png +16517.png +09523.png +09220.png +48018.png +59429.png +48115.png +12313.png +53018.png +51738.png +48111.png +24351.png +12155.png +11315.png +34738.png +23312.png +55532.png +58268.png +67131.png +41815.png +45066.png +62766.png +20231.png +53616.png +31627.png +58879.png +08783.png +06960.png +12792.png +11360.png +49781.png +60097.png +52204.png +35428.png +29614.png +53970.png +17547.png +50102.png +18162.png +02404.png +02272.png +13482.png +03107.png +18255.png +00147.png +59628.png +08595.png +26092.png +21825.png +31782.png +19318.png +24691.png +45766.png +03191.png +65457.png +67317.png +69040.png +01842.png +45528.png +12478.png +36309.png +49826.png +27326.png +21233.png +00523.png +18717.png +44471.png +55606.png +08678.png +62297.png +22593.png +59421.png +17990.png +56447.png +30197.png +58116.png +23189.png +16009.png +40581.png +09237.png +18651.png +12051.png +37870.png +42543.png +27524.png +58979.png +00970.png +54415.png +12576.png +35647.png +43425.png +03905.png +50654.png +06572.png +17205.png +24894.png +52193.png +43662.png +36409.png +30928.png +63259.png +55305.png +15412.png +57576.png +23730.png +40795.png +16226.png +21928.png +59084.png +33322.png +25183.png +14969.png +56842.png +34276.png +28708.png +59854.png +28590.png +28743.png +59437.png +37270.png +60081.png +54251.png +48983.png +03778.png +14296.png +35224.png +17097.png +10404.png +55534.png +23499.png +31859.png +52613.png +10937.png +09660.png +32802.png +19757.png +45773.png +29865.png +57201.png +12786.png +09371.png +00932.png +58940.png +51527.png +69439.png +57860.png +42106.png +18123.png +37153.png +28086.png +59107.png +36281.png +67626.png +68909.png +38396.png +42791.png +48145.png +29623.png +58804.png +33540.png +36232.png +58250.png +62792.png +42300.png +51884.png +17001.png +08421.png +42056.png +27897.png +07147.png +37666.png +36444.png +03325.png +43402.png +18105.png +62160.png +57578.png +49829.png +22947.png +45441.png +53168.png +48238.png +35539.png +25943.png +06496.png +31227.png +30014.png +15173.png +66114.png +18684.png +26654.png +64448.png +32324.png +05503.png +30540.png +30231.png +00635.png +30251.png +24342.png +26392.png +40548.png +62288.png +18124.png +55643.png +64268.png +09163.png +09907.png +42219.png +31605.png +18368.png +56690.png +29190.png +55671.png +12042.png +02594.png +59070.png +55196.png +18408.png +62624.png +39929.png +39676.png +16088.png +68293.png +42680.png +05075.png +24844.png +61858.png +05821.png +18647.png +44641.png +64215.png +54240.png +68291.png +19226.png +33024.png +23280.png +31743.png +53124.png +46558.png +47161.png +23631.png +57635.png +43335.png +01462.png +20835.png +07016.png +47968.png +66838.png +05286.png +19389.png +45579.png +43145.png +48688.png +08295.png +43231.png +53409.png +17546.png +52887.png +23366.png +69903.png +61181.png +08629.png +38787.png +52749.png +52591.png +37564.png +28136.png +61832.png +61257.png +05244.png +28634.png +55418.png +38931.png +09425.png +32738.png +35076.png +16263.png +41789.png +46757.png +62995.png +23032.png +29130.png +64221.png +04069.png +18581.png +54271.png +40885.png +45370.png +59124.png +42714.png +47013.png +38386.png +32955.png +51620.png +66910.png +63686.png +33148.png +58982.png +09243.png +30080.png +03660.png +58722.png +09926.png +60129.png +08736.png +26042.png +02951.png +17264.png +20419.png +32798.png +02697.png +65680.png +14534.png +19457.png +33633.png +63254.png +35704.png +37943.png +49137.png +66745.png +08252.png +51105.png +64237.png +22591.png +08964.png +14816.png +46044.png +25605.png +36399.png +51731.png +28828.png +41699.png +47156.png +37279.png +42741.png +10144.png +66644.png +69009.png +49913.png +62388.png +37518.png +45895.png +20354.png +53948.png +61101.png +58240.png +33646.png +60942.png +32297.png +08126.png +64227.png +25459.png +42229.png +40675.png +40338.png +10754.png +28847.png +44807.png +20145.png +67211.png +62748.png +26040.png +41367.png +65484.png +67125.png +10592.png +30280.png +46158.png +25809.png +12138.png +66136.png +65506.png +06633.png +45733.png +39254.png +42483.png +29082.png +20900.png +43865.png +47189.png +50165.png +40894.png +25628.png +01442.png +49266.png +44717.png +61306.png +60110.png +04209.png +41361.png +23182.png +55618.png +35013.png +06036.png +13095.png +41107.png +61828.png +44373.png +62195.png +14097.png +35903.png +54055.png +44376.png +69294.png +26230.png +01499.png +34384.png +44481.png +01028.png +21573.png +61153.png +05105.png +62279.png +02169.png +68901.png +40416.png +50130.png +14103.png +57765.png +09276.png +69089.png +06667.png +46045.png +01830.png +00040.png +46624.png +03936.png +58702.png +18256.png +30608.png +30506.png +32282.png +33401.png +37308.png +12820.png +07367.png +40304.png +67728.png +39500.png +28412.png +39219.png +46777.png +61259.png +44171.png +22876.png +60573.png +07684.png +28698.png +48547.png +35512.png +33331.png +20437.png +09287.png +27017.png +18596.png +61442.png +34259.png +32425.png +09118.png +13744.png +42432.png +01596.png +02506.png +23286.png +48087.png +47256.png +07674.png +04102.png +18004.png +41648.png +08452.png +51753.png +09725.png +05215.png +37494.png +15985.png +30673.png +20780.png +12403.png +25952.png +23131.png +68019.png +68086.png +30522.png +16096.png +51882.png +57480.png +00500.png +00394.png +64959.png +46467.png +68446.png +49859.png +33034.png +37471.png +07980.png +63971.png +40186.png +56667.png +01785.png +06212.png +11130.png +32083.png +53030.png +26483.png +37871.png +63832.png +33949.png +49513.png +04465.png +47100.png +09668.png +62151.png +51492.png +36449.png +27965.png +44072.png +30419.png +32790.png +40216.png +62210.png +34451.png +15982.png +34403.png +61684.png +50831.png +04263.png +69104.png +01556.png +52444.png +13232.png +55621.png +10816.png +45805.png +58046.png +04828.png +38530.png +52025.png +28344.png +15290.png +65312.png +60992.png +28120.png +01621.png +12991.png +35245.png +42821.png +32667.png +46468.png +67325.png +44756.png +58048.png +30151.png +21726.png +67777.png +19791.png +30172.png +32109.png +12214.png +05665.png +56237.png +42518.png +08895.png +03934.png +21184.png +06105.png +03419.png +32545.png +40613.png +62351.png +50598.png +44425.png +02384.png +35536.png +41373.png +35169.png +42615.png +51521.png +57818.png +39551.png +45204.png +17338.png +40953.png +05844.png +38857.png +54188.png +12629.png +57779.png +30474.png +16276.png +34126.png +42771.png +65023.png +36696.png +69106.png +52536.png +58875.png +21527.png +50256.png +41579.png +32343.png +31565.png +02081.png +16843.png +19524.png +67659.png +37626.png +48474.png +13418.png +32046.png +07119.png +43070.png +23666.png +68850.png +56250.png +11738.png +31682.png +49173.png +26298.png +40556.png +13946.png +38775.png +61839.png +49778.png +58369.png +15600.png +64983.png +17794.png +44743.png +24125.png +06807.png +11035.png +12443.png +27457.png +32852.png +46515.png +59918.png +54630.png +31684.png +16820.png +08255.png +52341.png +19470.png +18548.png +66869.png +69725.png +39610.png +32799.png +48551.png +17213.png +39080.png +64096.png +68925.png +38809.png +22551.png +38161.png +45863.png +03469.png +55569.png +22544.png +20416.png +50665.png +50502.png +16023.png +59735.png +45354.png +67345.png +50677.png +58947.png +51146.png +00508.png +45398.png +61802.png +19588.png +52790.png +27574.png +30361.png +49373.png +56218.png +52780.png +30910.png +61629.png +38176.png +40433.png +56292.png +19972.png +43578.png +58463.png +63828.png +28729.png +26899.png +50264.png +40295.png +01447.png +63345.png +07973.png +23708.png +31429.png +09643.png +67117.png +02921.png +46995.png +47828.png +35771.png +32159.png +68429.png +56021.png +26349.png +34674.png +07308.png +04792.png +60537.png +14125.png +52914.png +64338.png +25377.png +56574.png +17211.png +04422.png +02459.png +63340.png +23075.png +19857.png +45452.png +52554.png +59144.png +30700.png +25243.png +23987.png +29066.png +46140.png +37453.png +24946.png +60465.png +62945.png +20798.png +40555.png +53334.png +20311.png +07113.png +13899.png +50544.png +61474.png +62456.png +59510.png +15191.png +42738.png +30123.png +44905.png +50812.png +15181.png +51567.png +04466.png +27759.png +63222.png +19068.png +23660.png +19520.png +40071.png +18409.png +57767.png +50859.png +49782.png +67010.png +03328.png +18407.png +28157.png +32779.png +44988.png +00268.png +61070.png +51164.png +25247.png +10258.png +10180.png +41562.png +17551.png +01036.png +53172.png +49222.png +49511.png +23109.png +47666.png +21969.png +06463.png +09052.png +18595.png +26779.png +25116.png +27559.png +10255.png +54479.png +51373.png +14847.png +08312.png +66835.png +34149.png +14746.png +35236.png +48030.png +47620.png +18573.png +39660.png +38601.png +23397.png +43655.png +16026.png +20612.png +65863.png +37132.png +50969.png +63935.png +52924.png +23958.png +43985.png +25447.png +18978.png +13001.png +15548.png +65497.png +64226.png +04180.png +39030.png +14810.png +28018.png +69470.png +38912.png +34969.png +66347.png +34477.png +47126.png +14935.png +15246.png +69812.png +48940.png +37949.png +50823.png +58422.png +66620.png +64699.png +40923.png +22077.png +67580.png +51586.png +52170.png +65447.png +15979.png +39682.png +18631.png +01469.png +67475.png +04850.png +19576.png +58649.png +26847.png +68881.png +27743.png +58431.png +58293.png +45716.png +67141.png +45727.png +69585.png +58576.png +51447.png +54663.png +36481.png +27606.png +33756.png +67330.png +67893.png +23240.png +08998.png +29015.png +34746.png +27675.png +15849.png +50110.png +24488.png +37244.png +26946.png +27301.png +13807.png +50317.png +30491.png +31443.png +49001.png +45009.png +08199.png +37452.png +05746.png +69084.png +63659.png +13178.png +51479.png +41189.png +28593.png +06498.png +17592.png +39191.png +63810.png +61056.png +42451.png +27891.png +68897.png +62310.png +66320.png +45039.png +11599.png +64878.png +17780.png +41621.png +23178.png +38512.png +24920.png +40175.png +69957.png +67298.png +68689.png +41050.png +28784.png +18889.png +17921.png +55604.png +06056.png +55458.png +54285.png +57678.png +39994.png +36739.png +11537.png +35109.png +10162.png +17824.png +68972.png +29343.png +45325.png +29401.png +59257.png +55138.png +53780.png +44289.png +48041.png +07141.png +08542.png +44044.png +56438.png +45290.png +16214.png +57190.png +54609.png +21878.png +15261.png +33719.png +13794.png +55938.png +17098.png +10520.png +14938.png +43065.png +19277.png +15397.png +02886.png +27227.png +47944.png +51275.png +32103.png +19203.png +68371.png +30756.png +08634.png +68473.png +14863.png +45609.png +17830.png +25021.png +03097.png +61718.png +68278.png +12123.png +30625.png +39439.png +07261.png +33601.png +30094.png +32773.png +41191.png +58222.png +57328.png +32813.png +47050.png +13430.png +52131.png +21705.png +06551.png +25767.png +32450.png +01871.png +05449.png +23005.png +56001.png +53185.png +33374.png +53963.png +32085.png +00345.png +17273.png +36447.png +03786.png +56808.png +66090.png +37533.png +00526.png +42837.png +57017.png +46125.png +25712.png +64852.png +39171.png +31148.png +33311.png +08597.png +67342.png +53082.png +37106.png +03077.png +64466.png +59157.png +05527.png +67414.png +50595.png +27726.png +59248.png +11333.png +11336.png +44535.png +41316.png +50251.png +14212.png +00976.png +50936.png +14899.png +19538.png +01942.png +27389.png +43039.png +65924.png +13300.png +15021.png +46389.png +58990.png +14560.png +27459.png +13423.png +44779.png +53800.png +42918.png +12415.png +00929.png +47937.png +09683.png +34156.png +01019.png +03978.png +43221.png +60323.png +16205.png +33770.png +34594.png +21155.png +62933.png +59013.png +42121.png +40549.png +36621.png +01149.png +58504.png +04233.png +16588.png +24368.png +16229.png +39451.png +43139.png +56914.png +68926.png +58749.png +41784.png +02669.png +52313.png +23304.png +15493.png +49166.png +26134.png +69492.png +53186.png +17127.png +08878.png +32537.png +01955.png +44089.png +67681.png +64370.png +24400.png +11776.png +04832.png +47587.png +67654.png +42953.png +62749.png +11792.png +27829.png +08497.png +67255.png +46343.png +30811.png +39051.png +56825.png +47601.png +27223.png +31322.png +68465.png +57800.png +44540.png +32828.png +51381.png +51570.png +15131.png +14707.png +23067.png +25364.png +05573.png +68418.png +56262.png +18657.png +37539.png +22380.png +46926.png +27788.png +57100.png +07668.png +35005.png +18694.png +66965.png +68034.png +24953.png +07793.png +68880.png +44631.png +05723.png +68823.png +20758.png +13650.png +18562.png +15644.png +20949.png +55825.png +64175.png +01874.png +13965.png +68889.png +57430.png +29827.png +04788.png +36367.png +50373.png +33364.png +23150.png +45506.png +09221.png +64151.png +07166.png +60884.png +05648.png +25836.png +54373.png +50987.png +17668.png +57356.png +14437.png +45072.png +15389.png +53814.png +48239.png +46886.png +55242.png +08758.png +65963.png +35958.png +53874.png +24751.png +36480.png +58560.png +41308.png +23820.png +00357.png +37775.png +30655.png +29009.png +56115.png +37450.png +51789.png +39085.png +11443.png +13399.png +25389.png +63970.png +61196.png +39291.png +29404.png +54406.png +32925.png +31979.png +30580.png +66178.png +15092.png +17461.png +12736.png +02674.png +15297.png +56114.png +39961.png +17667.png +27021.png +33127.png +31894.png +35146.png +58769.png +48806.png +14001.png +25035.png +68425.png +09989.png +08088.png +46493.png +52205.png +27004.png +48839.png +14083.png +06547.png +65239.png +09749.png +12880.png +59308.png +45757.png +43450.png +37477.png +61871.png +10295.png +21450.png +02586.png +57826.png +27631.png +50565.png +16973.png +58760.png +24501.png +18130.png +05294.png +33501.png +61547.png +26677.png +37797.png +55664.png +50523.png +44298.png +61279.png +25313.png +11959.png +12944.png +39903.png +67748.png +24794.png +22637.png +18780.png +04908.png +29351.png +64152.png +50747.png +51334.png +48489.png +30399.png +10951.png +37804.png +48752.png +25753.png +07336.png +12702.png +27426.png +27304.png +40280.png +64837.png +12694.png +27634.png +43955.png +47949.png +00063.png +54604.png +02982.png +35586.png +69369.png +47486.png +53106.png +51484.png +36735.png +06380.png +49338.png +68779.png +35775.png +18047.png +07378.png +00032.png +35952.png +60362.png +27114.png +69122.png +15605.png +20869.png +10833.png +34256.png +48989.png +69998.png +24748.png +22567.png +58856.png +30446.png +18623.png +60909.png +34952.png +36098.png +48048.png +43417.png +37266.png +27151.png +21600.png +32436.png +03751.png +30030.png +41457.png +56715.png +67595.png +52012.png +32754.png +39372.png +28190.png +57570.png +33282.png +52562.png +65617.png +54579.png +51737.png +53363.png +05984.png +47274.png +37933.png +40970.png +38241.png +34216.png +51520.png +23203.png +66091.png +45391.png +54960.png +41584.png +69847.png +32000.png +11540.png +02800.png +09755.png +16198.png +45943.png +20157.png +13984.png +58998.png +18550.png +28275.png +51670.png +10678.png +14227.png +44754.png +03732.png +52717.png +03169.png +35538.png +23138.png +63961.png +54120.png +30420.png +43496.png +61878.png +31108.png +64830.png +25912.png +65279.png +33644.png +37740.png +42170.png +19002.png +58083.png +15841.png +69863.png +58120.png +19270.png +57078.png +26022.png +69407.png +58236.png +22896.png +44731.png +36923.png +49841.png +55069.png +48755.png +25744.png +37127.png +08327.png +51895.png +16675.png +32723.png +00632.png +66116.png +37174.png +55049.png +34710.png +20257.png +56723.png +37336.png +27870.png +01130.png +61546.png +26494.png +35907.png +08514.png +65684.png +06203.png +29068.png +18919.png +58842.png +36656.png +67889.png +38192.png +61907.png +27935.png +62126.png +44404.png +48533.png +24186.png +66152.png +36170.png +30553.png +56232.png +31908.png +14156.png +33599.png +32248.png +35547.png +22827.png +47942.png +54620.png +58203.png +69411.png +35261.png +30664.png +21517.png +45169.png +15756.png +10131.png +46825.png +29123.png +16347.png +35402.png +17971.png +12148.png +64352.png +27883.png +53730.png +52036.png +54244.png +59546.png +62514.png +35040.png +61350.png +07530.png +58075.png +47285.png +15859.png +17725.png +35513.png +05067.png +19566.png +43944.png +04580.png +22203.png +39396.png +60993.png +37486.png +00226.png +60440.png +40454.png +51478.png +56023.png +18414.png +00130.png +22014.png +30850.png +20140.png +54608.png +14339.png +57352.png +21195.png +14248.png +35142.png +68978.png +20066.png +65907.png +58415.png +02439.png +07206.png +38502.png +18434.png +61671.png +67978.png +06415.png +40530.png +16209.png +25917.png +32872.png +02398.png +09639.png +63293.png +09694.png +42706.png +34526.png +11530.png +63586.png +37734.png +32740.png +13885.png +68166.png +57521.png +21844.png +45063.png +35826.png +55667.png +03153.png +55135.png +69476.png +31382.png +22000.png +46311.png +33968.png +15746.png +50825.png +16124.png +67774.png +14060.png +14579.png +38970.png +07291.png +17437.png +05633.png +11493.png +56077.png +61065.png +61273.png +52814.png +43135.png +13706.png +58663.png +35822.png +16358.png +45908.png +56738.png +69797.png +58461.png +67970.png +68201.png +14796.png +18825.png +16847.png +30115.png +61470.png +37299.png +46571.png +66377.png +60023.png +06589.png +10617.png +42635.png +43900.png +08442.png +11184.png +47416.png +21009.png +37568.png +33675.png +27102.png +59390.png +09007.png +36028.png +14160.png +42286.png +06041.png +61185.png +60906.png +55484.png +62232.png +33203.png +41269.png +49174.png +26097.png +55975.png +33043.png +18179.png +40836.png +33303.png +57071.png +14425.png +11356.png +07653.png +14997.png +45145.png +32760.png +48526.png +31295.png +68358.png +41556.png +32194.png +15485.png +41020.png +47370.png +34564.png +05182.png +27828.png +09837.png +54565.png +21919.png +58404.png +00633.png +24739.png +54313.png +68855.png +62744.png +18438.png +63124.png +20102.png +35268.png +07664.png +18363.png +08036.png +14638.png +19943.png +18668.png +22883.png +43338.png +17972.png +69495.png +41980.png +68498.png +62570.png +09669.png +57859.png +56779.png +18251.png +52189.png +26096.png +32402.png +37507.png +55830.png +38879.png +55559.png +41049.png +63423.png +08427.png +29619.png +53883.png +35828.png +60184.png +57750.png +66719.png +03387.png +07023.png +25771.png +39578.png +00639.png +06730.png +51058.png +31574.png +37738.png +67790.png +64238.png +02219.png +57828.png +17906.png +57759.png +55254.png +01305.png +28339.png +47409.png +17636.png +30552.png +59464.png +60632.png +29627.png +61277.png +37197.png +28798.png +56632.png +56967.png +11578.png +43939.png +29869.png +57565.png +67316.png +62555.png +45828.png +68218.png +46419.png +18858.png +41035.png +22865.png +53037.png +05674.png +53370.png +61087.png +56389.png +16066.png +28447.png +33972.png +31736.png +45628.png +15699.png +00199.png +19325.png +30865.png +33876.png +60159.png +60276.png +60662.png +69992.png +15058.png +11425.png +26991.png +34871.png +04256.png +48072.png +29055.png +41341.png +47162.png +04072.png +33922.png +44286.png +13556.png +50938.png +50772.png +07956.png +11685.png +21286.png +25765.png +40100.png +29733.png +30752.png +30757.png +42199.png +68944.png +08956.png +50378.png +43904.png +05632.png +08804.png +37844.png +53057.png +62814.png +01340.png +54704.png +62370.png +64979.png +34818.png +00783.png +07099.png +48285.png +63796.png +24678.png +57464.png +66314.png +28983.png +45478.png +53863.png +02587.png +68426.png +44818.png +58539.png +58467.png +08807.png +10706.png +32642.png +48962.png +13638.png +58739.png +09273.png +34692.png +12896.png +48835.png +19734.png +27422.png +04633.png +28466.png +38157.png +40991.png +19108.png +54416.png +39365.png +41067.png +42385.png +54171.png +33887.png +60520.png +56319.png +59286.png +23566.png +28187.png +18594.png +41385.png +34634.png +42662.png +37181.png +16993.png +13121.png +68041.png +44876.png +02174.png +27446.png +65281.png +52683.png +02017.png +60045.png +59817.png +17512.png +27400.png +36836.png +27911.png +22005.png +14599.png +50560.png +10669.png +61406.png +38149.png +25855.png +12784.png +22741.png +57719.png +12140.png +54809.png +58469.png +50915.png +60530.png +15880.png +40826.png +30532.png +63176.png +02526.png +22217.png +17799.png +35272.png +07743.png +49688.png +54887.png +02281.png +68072.png +00011.png +68016.png +35810.png +13787.png +32055.png +22798.png +04906.png +38222.png +04873.png +29359.png +33620.png +00482.png +26615.png +56029.png +56958.png +14819.png +02552.png +66757.png +55520.png +57655.png +57051.png +12914.png +00630.png +07544.png +19836.png +28628.png +22287.png +48234.png +10052.png +60175.png +09517.png +29014.png +50325.png +56329.png +49523.png +59902.png +65773.png +52987.png +47321.png +47251.png +19895.png +26153.png +32470.png +37768.png +60408.png +58858.png +68525.png +11886.png +64302.png +21227.png +20067.png +44845.png +28830.png +59246.png +33221.png +06976.png +24055.png +42276.png +10595.png +38823.png +09873.png +31759.png +25956.png +40901.png +50608.png +20524.png +66031.png +30384.png +59485.png +20516.png +51632.png +45286.png +39176.png +04636.png +11260.png +54665.png +04354.png +61932.png +66375.png +41845.png +11787.png +31332.png +62499.png +44225.png +27294.png +54057.png +12219.png +48812.png +07004.png +56873.png +42362.png +27882.png +29013.png +49718.png +20435.png +03438.png +63227.png +52465.png +43870.png +54603.png +33533.png +43858.png +13069.png +29158.png +44375.png +26930.png +11832.png +14442.png +08797.png +15356.png +03218.png +41375.png +52808.png +02402.png +05211.png +05681.png +10428.png +38751.png +05752.png +43973.png +38942.png +57127.png +09910.png +10894.png +25073.png +59449.png +16838.png +09166.png +58780.png +04612.png +07015.png +29153.png +24558.png +17857.png +57409.png +69473.png +35687.png +31154.png +63462.png +32718.png +69928.png +43120.png +63067.png +04987.png +24816.png +14756.png +61610.png +48178.png +56052.png +22135.png +37500.png +00294.png +61128.png +46459.png +44622.png +30960.png +31563.png +65917.png +16910.png +18958.png +40477.png +37064.png +34828.png +40686.png +44915.png +51463.png +65760.png +28540.png +06892.png +52885.png +48273.png +49279.png +04403.png +63279.png +65287.png +56912.png +02038.png +23327.png +07671.png +56178.png +50157.png +17187.png +55003.png +29781.png +26802.png +65142.png +14208.png +45585.png +59322.png +19245.png +09044.png +03711.png +24139.png +22846.png +52478.png +46726.png +16592.png +58523.png +66144.png +45518.png +24611.png +24719.png +42148.png +00736.png +06670.png +67228.png +69583.png +08560.png +66372.png +20895.png +15423.png +00741.png +58060.png +34863.png +01103.png +24738.png +58072.png +42266.png +31238.png +53458.png +38682.png +37218.png +30623.png +27062.png +35745.png +15289.png +55923.png +61200.png +06857.png +05269.png +11677.png +09194.png +36196.png +63004.png +04295.png +38142.png +41483.png +45216.png +47904.png +50367.png +58331.png +32398.png +24782.png +69081.png +50994.png +48897.png +28854.png +46694.png +27906.png +32198.png +58961.png +02255.png +23342.png +05879.png +64077.png +45969.png +62120.png +05128.png +17677.png +07384.png +67995.png +16546.png +10155.png +62409.png +67200.png +41312.png +31165.png +44303.png +16061.png +41558.png +31379.png +60534.png +38044.png +09129.png +38468.png +15033.png +06772.png +23676.png +28370.png +45915.png +37791.png +65425.png +25126.png +03470.png +52031.png +47310.png +51016.png +06430.png +11016.png +67256.png +15825.png +10242.png +11529.png +69512.png +69695.png +19077.png +61765.png +41222.png +63298.png +64204.png +62680.png +00652.png +15484.png +33478.png +14358.png +67025.png +18714.png +18088.png +09325.png +22411.png +41002.png +49065.png +43465.png +65790.png +03511.png +05094.png +34406.png +22023.png +66833.png +12161.png +42747.png +15026.png +20448.png +08538.png +08774.png +61573.png +03261.png +64775.png +41132.png +35970.png +32393.png +02071.png +12353.png +43579.png +23938.png +67041.png +35241.png +22018.png +49666.png +16541.png +13140.png +04601.png +31998.png +02009.png +14213.png +03389.png +06374.png +09499.png +54933.png +17154.png +52698.png +38865.png +58377.png +62558.png +06177.png +04847.png +40291.png +24540.png +69538.png +08738.png +44798.png +56890.png +45664.png +43525.png +37812.png +35886.png +09572.png +38336.png +53541.png +48039.png +12910.png +12607.png +50904.png +26984.png +26596.png +45640.png +11462.png +49955.png +48661.png +68882.png +53420.png +52925.png +42984.png +02795.png +12094.png +52371.png +66557.png +14118.png +66999.png +43096.png +18635.png +11447.png +61151.png +69533.png +52849.png +38630.png +29348.png +55852.png +62316.png +07517.png +04825.png +38310.png +27549.png +38847.png +52206.png +17580.png +60182.png +16490.png +09155.png +16119.png +57122.png +50710.png +62218.png +03875.png +53776.png +64349.png +53566.png +02225.png +27445.png +19212.png +66771.png +41505.png +50293.png +56512.png +28146.png +04133.png +34431.png +29770.png +54224.png +65642.png +23198.png +07068.png +04377.png +38763.png +32490.png +03780.png +41518.png +29540.png +37119.png +09569.png +05900.png +26103.png +19344.png +44060.png +53513.png +08363.png +38039.png +36985.png +56127.png +63063.png +28290.png +25162.png +34928.png +27937.png +27260.png +60036.png +12082.png +34739.png +62023.png +69652.png +50239.png +64421.png +61768.png +50025.png +68839.png +19965.png +08176.png +59468.png +41150.png +05495.png +45440.png +39006.png +25567.png +06553.png +33594.png +01050.png +46959.png +03449.png +16038.png +35185.png +56187.png +42438.png +16936.png +27012.png +14294.png +05564.png +01736.png +67431.png +34879.png +42221.png +52367.png +33833.png +46335.png +17218.png +03767.png +66184.png +38591.png +08370.png +10111.png +61622.png +61197.png +38152.png +34395.png +08870.png +45267.png +08720.png +06139.png +25357.png +49873.png +17163.png +52558.png +59998.png +09642.png +57633.png +43769.png +42185.png +62357.png +24696.png +59850.png +20203.png +61439.png +10739.png +36183.png +01468.png +50781.png +55156.png +22015.png +19267.png +51096.png +59984.png +13901.png +15822.png +27779.png +05793.png +11060.png +69815.png +64951.png +42839.png +13332.png +11751.png +51983.png +51177.png +32914.png +09859.png +20938.png +14435.png +56353.png +52618.png +50796.png +53801.png +53475.png +30109.png +15284.png +31191.png +12028.png +06485.png +28705.png +24880.png +55272.png +17873.png +40636.png +49348.png +33473.png +48764.png +06390.png +55919.png +51563.png +23432.png +08710.png +44774.png +34191.png +09966.png +60687.png +48368.png +10197.png +22976.png +47565.png +17594.png +41915.png +08508.png +17121.png +42577.png +11050.png +38921.png +46258.png +52682.png +53162.png +29965.png +13225.png +33735.png +08174.png +33656.png +19150.png +56876.png +53282.png +23946.png +22312.png +03216.png +55782.png +05904.png +01991.png +54945.png +19525.png +47434.png +04417.png +38746.png +41743.png +06605.png +10460.png +40026.png +31823.png +67243.png +49708.png +54347.png +44640.png +09106.png +11294.png +60936.png +39828.png +52648.png +19677.png +01544.png +25794.png +54509.png +08411.png +36122.png +34241.png +20470.png +25838.png +22146.png +41421.png +00377.png +36362.png +23041.png +48554.png +30509.png +25664.png +25530.png +62027.png +07564.png +57484.png +07385.png +04896.png +31828.png +59833.png +24415.png +60903.png +36831.png +07195.png +57161.png +08991.png +50481.png +54473.png +45779.png +39794.png +33267.png +31267.png +32513.png +56767.png +26630.png +28506.png +51961.png +42112.png +13749.png +65351.png +57898.png +31890.png +12755.png +62574.png +30859.png +37967.png +01715.png +37685.png +29593.png +60929.png +00703.png +09970.png +22209.png +26179.png +56477.png +50583.png +04191.png +34226.png +59354.png +11991.png +52099.png +61184.png +12892.png +46015.png +50292.png +57977.png +49729.png +38742.png +55260.png +28437.png +12844.png +48696.png +31496.png +12087.png +17549.png +16287.png +06805.png +25070.png +67375.png +34761.png +01218.png +25641.png +20735.png +38840.png +54701.png +19022.png +37320.png +46792.png +07146.png +61774.png +10648.png +46466.png +06127.png +37938.png +61209.png +38924.png +61664.png +36355.png +01046.png +42515.png +14679.png +65522.png +07107.png +38963.png +64109.png +58747.png +03621.png +01629.png +16511.png +52843.png +42676.png +22649.png +08529.png +49319.png +24340.png +09152.png +37161.png +41689.png +09969.png +03824.png +55029.png +56246.png +45744.png +36542.png +36230.png +02989.png +63055.png +36119.png +32930.png +48251.png +06273.png +20583.png +21677.png +62191.png +38443.png +45299.png +52213.png +37443.png +53832.png +16616.png +66026.png +53473.png +02287.png +06980.png +04558.png +11921.png +27274.png +31822.png +66787.png +08914.png +27262.png +21532.png +51112.png +06698.png +46595.png +69310.png +03320.png +00822.png +37789.png +39024.png +44825.png +27802.png +11168.png +65328.png +41565.png +60601.png +63996.png +66932.png +38866.png +07056.png +47854.png +16958.png +14183.png +60616.png +30134.png +00860.png +30230.png +21288.png +24850.png +26510.png +66638.png +36758.png +46643.png +68640.png +66396.png +22898.png +58730.png +11212.png +32530.png +50399.png +33798.png +06746.png +56289.png +20754.png +58598.png +46094.png +07264.png +06725.png +43118.png +50180.png +19558.png +40445.png +69331.png +42302.png +52656.png +28609.png +63304.png +00987.png +60060.png +50510.png +32395.png +64999.png +07390.png +46835.png +31517.png +14251.png +11187.png +27714.png +25899.png +01480.png +38290.png +22763.png +32146.png +38360.png +36532.png +36161.png +11396.png +31501.png +04214.png +40605.png +25861.png +01636.png +46656.png +23897.png +39932.png +38202.png +64907.png +04927.png +66359.png +08265.png +56027.png +05549.png +68251.png +64939.png +04527.png +57733.png +31198.png +15055.png +61915.png +41047.png +11025.png +22957.png +55823.png +61120.png +64477.png +26770.png +18970.png +28867.png +04448.png +36499.png +07510.png +57280.png +10634.png +16873.png +55523.png +66986.png +12264.png +14745.png +63118.png +11582.png +02904.png +48400.png +57442.png +01409.png +31010.png +12440.png +20554.png +08491.png +20279.png +31420.png +62450.png +60519.png +55817.png +21798.png +69227.png +53255.png +36662.png +51113.png +59544.png +36926.png +68394.png +58040.png +21376.png +38523.png +47890.png +06832.png +60048.png +58572.png +43413.png +05579.png +60504.png +24489.png +53844.png +33933.png +37149.png +26622.png +53796.png +23728.png +38072.png +45572.png +35060.png +35353.png +38315.png +60749.png +15522.png +64353.png +06328.png +43752.png +10620.png +61767.png +35006.png +31806.png +41619.png +54220.png +57843.png +17928.png +62271.png +17715.png +05047.png +04829.png +07319.png +34627.png +10533.png +68114.png +42010.png +21888.png +06913.png +01883.png +41783.png +32148.png +60093.png +01324.png +47314.png +15688.png +60890.png +47441.png +51067.png +34397.png +39552.png +31752.png +25337.png +36918.png +00665.png +44713.png +66331.png +18101.png +41244.png +58731.png +28563.png +28423.png +12652.png +32192.png +32250.png +54437.png +43117.png +35985.png +60604.png +19958.png +42204.png +19036.png +45926.png +08123.png +12829.png +54273.png +10769.png +44548.png +20333.png +05002.png +02984.png +41462.png +17518.png +59589.png +44511.png +25509.png +12565.png +41353.png +41409.png +40165.png +18963.png +46054.png +63693.png +29360.png +21930.png +49424.png +67935.png +32676.png +57272.png +65503.png +09332.png +69996.png +35690.png +24553.png +54745.png +66876.png +46346.png +24694.png +52014.png +19539.png +22137.png +15986.png +28114.png +63000.png +64046.png +45054.png +12963.png +06080.png +31211.png +14273.png +34147.png +63121.png +66010.png +35171.png +06429.png +38048.png +31415.png +05333.png +62874.png +56360.png +03795.png +03815.png +23656.png +63610.png +55763.png +16222.png +68630.png +56482.png +25660.png +22818.png +49185.png +42443.png +26147.png +58413.png +33273.png +33993.png +20552.png +18100.png +11014.png +53091.png +42899.png +55786.png +04177.png +15913.png +43245.png +37962.png +26191.png +64845.png +52911.png +60810.png +69037.png +35368.png +29410.png +59333.png +66339.png +42980.png +41181.png +45407.png +27623.png +07549.png +00792.png +35573.png +58810.png +31660.png +55117.png +31911.png +20715.png +11849.png +16545.png +44700.png +12678.png +54467.png +04786.png +09833.png +49557.png +42588.png +35128.png +41322.png +21150.png +13516.png +53999.png +28470.png +36648.png +55760.png +38457.png +20608.png +64842.png +28657.png +01590.png +34699.png +58432.png +67303.png +65365.png +31144.png +19079.png +54264.png +02887.png +59798.png +34016.png +22764.png +39020.png +04476.png +44256.png +34224.png +18231.png +40141.png +37520.png +39208.png +49002.png +54098.png +09644.png +63857.png +69013.png +35105.png +32334.png +27604.png +04066.png +11045.png +35456.png +31184.png +47248.png +23153.png +20433.png +53670.png +08778.png +66203.png +54375.png +25560.png +22085.png +01649.png +07926.png +62913.png +33291.png +00446.png +19471.png +33172.png +39053.png +04254.png +45170.png +41066.png +04962.png +38906.png +30066.png +22193.png +33904.png +09423.png +23328.png +07907.png +06475.png +49300.png +34023.png +16073.png +14958.png +32134.png +06930.png +27355.png +11572.png +05032.png +52833.png +28947.png +39390.png +00162.png +00709.png +33020.png +69201.png +47614.png +11614.png +67082.png +05788.png +24403.png +03430.png +07683.png +27649.png +63660.png +69151.png +27048.png +33901.png +60376.png +43033.png +16435.png +40698.png +69353.png +28924.png +38200.png +11373.png +55854.png +64732.png +11384.png +19900.png +46413.png +25570.png +58055.png +51230.png +15547.png +06339.png +51832.png +68966.png +43133.png +50398.png +55394.png +28101.png +69525.png +25122.png +43753.png +00547.png +54452.png +06404.png +08643.png +24309.png +15035.png +16252.png +13012.png +37724.png +53740.png +52266.png +15214.png +57162.png +68601.png +59278.png +68471.png +19603.png +62205.png +20592.png +08196.png +20386.png +31766.png +34515.png +34854.png +08532.png +66639.png +66906.png +20722.png +02555.png +65289.png +49911.png +55056.png +34603.png +61146.png +38246.png +03961.png +09953.png +50489.png +02210.png +67236.png +58005.png +15152.png +38558.png +25072.png +53781.png +64558.png +14444.png +18914.png +54033.png +41069.png +61207.png +09670.png +29295.png +65744.png +52466.png +56799.png +43856.png +25754.png +15752.png +35569.png +30862.png +02276.png +69489.png +00572.png +58520.png +29103.png +03283.png +54614.png +15671.png +61645.png +43225.png +12013.png +41329.png +49938.png +59896.png +57559.png +64804.png +13466.png +04499.png +41600.png +53891.png +62145.png +30402.png +53839.png +50482.png +06215.png +33857.png +27322.png +67641.png +56133.png +00761.png +27789.png +14813.png +57598.png +25713.png +47613.png +62179.png +57114.png +09612.png +67766.png +24549.png +04362.png +30659.png +32466.png +58621.png +08366.png +07139.png +15500.png +32458.png +45620.png +26101.png +27662.png +02530.png +26471.png +59647.png +47957.png +62681.png +61148.png +19178.png +12386.png +51033.png +66875.png +29530.png +13592.png +25919.png +10484.png +62502.png +32797.png +48675.png +66510.png +56521.png +59182.png +61486.png +69527.png +69694.png +51395.png +64754.png +57775.png +68939.png +07434.png +21828.png +51689.png +45989.png +27335.png +29042.png +47472.png +67024.png +39334.png +16106.png +25764.png +45763.png +19549.png +24300.png +18455.png +54148.png +37709.png +29378.png +15820.png +04779.png +33890.png +18874.png +06123.png +40448.png +55998.png +21553.png +42455.png +62921.png +47751.png +23906.png +49517.png +65997.png +35279.png +10480.png +25265.png +24978.png +65299.png +56590.png +57752.png +48070.png +18563.png +26879.png +58099.png +50703.png +63950.png +43091.png +14137.png +27712.png +44290.png +02279.png +68124.png +39537.png +34832.png +03819.png +52494.png +28635.png +14484.png +59499.png +26856.png +09662.png +02491.png +36472.png +51725.png +15095.png +45505.png +31785.png +30986.png +43980.png +04373.png +60324.png +18750.png +62712.png +30582.png +64580.png +08005.png +26055.png +48913.png +52319.png +14472.png +20536.png +09928.png +38829.png +59511.png +27384.png +68528.png +34240.png +18587.png +21712.png +66799.png +06856.png +10762.png +00003.png +16913.png +48582.png +47254.png +24161.png +25748.png +38155.png +07110.png +12758.png +04953.png +39270.png +00228.png +42373.png +20100.png +39817.png +40805.png +02955.png +50498.png +56415.png +51856.png +38120.png +26732.png +58927.png +27657.png +33826.png +25798.png +30657.png +58859.png +53284.png +42910.png +29501.png +26406.png +44494.png +31056.png +19439.png +14961.png +35024.png +00618.png +05074.png +16401.png +02423.png +47309.png +54471.png +07905.png +65057.png +24911.png +05301.png +45852.png +57495.png +43281.png +50106.png +25951.png +09374.png +50725.png +42470.png +07229.png +15241.png +64684.png +47157.png +49628.png +11711.png +60478.png +38346.png +26265.png +21108.png +02086.png +47033.png +43837.png +32236.png +14190.png +15247.png +46635.png +67473.png +11606.png +04017.png +68943.png +60615.png +38342.png +16337.png +66419.png +08000.png +44383.png +64771.png +31194.png +58160.png +37780.png +47841.png +69284.png +69101.png +60461.png +40408.png +66219.png +52108.png +16791.png +51557.png +32812.png +12314.png +38904.png +14553.png +03299.png +11220.png +04393.png +16225.png +28538.png +16055.png +11586.png +29313.png +13709.png +59955.png +35243.png +39027.png +57897.png +10292.png +18902.png +52968.png +49007.png +21015.png +52149.png +14397.png +00415.png +46095.png +24375.png +35136.png +09951.png +26164.png +65071.png +22586.png +62618.png +21577.png +51094.png +63933.png +63384.png +07394.png +44154.png +58830.png +29994.png +32514.png +17184.png +35963.png +32830.png +08943.png +12136.png +44282.png +54858.png +02373.png +01248.png +39079.png +39452.png +21955.png +31670.png +46220.png +56490.png +30457.png +52938.png +11293.png +05754.png +07630.png +67733.png +09304.png +21752.png +22866.png +23751.png +17405.png +03602.png +04773.png +05820.png +69576.png +20712.png +14381.png +31715.png +31554.png +54334.png +66668.png +13168.png +27998.png +09931.png +39798.png +59194.png +50905.png +43740.png +05944.png +00777.png +16379.png +31439.png +16014.png +26528.png +43147.png +44792.png +05393.png +23794.png +48040.png +42060.png +56790.png +14298.png +55078.png +63682.png +04603.png +62187.png +01192.png +69357.png +26071.png +67616.png +66836.png +47900.png +69883.png +29776.png +23466.png +13445.png +35598.png +68137.png +22867.png +27560.png +13058.png +31222.png +24890.png +10402.png +04486.png +60393.png +02278.png +58943.png +42654.png +37663.png +62890.png +14494.png +56175.png +65392.png +58996.png +42754.png +23270.png +57008.png +28350.png +09067.png +45122.png +38122.png +69886.png +14833.png +28782.png +36904.png +48003.png +18925.png +47528.png +07174.png +40046.png +07334.png +03063.png +69271.png +29760.png +30308.png +08791.png +24369.png +25824.png +15107.png +08596.png +00067.png +00540.png +50060.png +52381.png +30924.png +45558.png +00391.png +33448.png +64388.png +24280.png +21807.png +65864.png +00973.png +43906.png +25452.png +63974.png +39031.png +52650.png +29597.png +63562.png +07556.png +33176.png +40320.png +33196.png +62136.png +43392.png +12741.png +00141.png +47341.png +25043.png +37940.png +65626.png +28249.png +49555.png +21003.png +02019.png +62886.png +25378.png +57305.png +34930.png +62804.png +25009.png +36718.png +18593.png +09496.png +53729.png +16016.png +20990.png +50820.png +49999.png +36351.png +23632.png +53676.png +55875.png +13014.png +18326.png +04591.png +53712.png +05362.png +37939.png +40144.png +46209.png +50415.png +34503.png +42207.png +06293.png +52362.png +47135.png +65373.png +55717.png +53428.png +68214.png +34897.png +34684.png +05668.png +03563.png +31180.png +26260.png +26695.png +12424.png +26156.png +03757.png +02412.png +41877.png +52373.png +25103.png +34720.png +28031.png +26207.png +27681.png +13990.png +22639.png +38957.png +55020.png +37472.png +39891.png +01824.png +63017.png +03937.png +19723.png +43881.png +25541.png +24821.png +03525.png +53166.png +51065.png +16982.png +30760.png +63343.png +26689.png +16510.png +33903.png +01958.png +57531.png +32268.png +07622.png +57240.png +08729.png +13446.png +46746.png +58641.png +34288.png +38472.png +55435.png +28097.png +54803.png +18215.png +04438.png +02625.png +08588.png +13160.png +07965.png +01610.png +62447.png +45873.png +10451.png +66952.png +51026.png +68703.png +40373.png +21602.png +13053.png +66679.png +59835.png +56376.png +58738.png +21053.png +45115.png +04309.png +27063.png +00085.png +29626.png +54000.png +26858.png +46608.png +50614.png +01420.png +46489.png +54612.png +64127.png +04720.png +65668.png +55479.png +17245.png +17795.png +34065.png +33287.png +49264.png +23627.png +43295.png +10999.png +41452.png +59593.png +48225.png +33784.png +38114.png +49169.png +01529.png +13762.png +08182.png +53735.png +52424.png +08823.png +63854.png +04371.png +54073.png +54674.png +06489.png +08049.png +57996.png +11838.png +34823.png +16308.png +05910.png +26409.png +08020.png +10268.png +16856.png +42728.png +66140.png +00587.png +45334.png +30762.png +14476.png +54158.png +61986.png +37307.png +68683.png +19737.png +49692.png +42298.png +57513.png +66752.png +39132.png +59769.png +68958.png +42959.png +12890.png +55481.png +35144.png +56009.png +31298.png +20064.png +17297.png +22859.png +35442.png +51561.png +15527.png +04491.png +27031.png +17093.png +06343.png +14671.png +47401.png +15044.png +37037.png +45920.png +30627.png +19174.png +21239.png +21665.png +00247.png +61329.png +07248.png +00043.png +06732.png +04123.png +11410.png +05348.png +29912.png +38704.png +11741.png +43536.png +41762.png +02160.png +50248.png +65364.png +51920.png +37878.png +20978.png +00988.png +53050.png +20521.png +08067.png +66815.png +46187.png +29752.png +55382.png +36580.png +57648.png +23918.png +47422.png +00625.png +64588.png +53070.png +53945.png +55858.png +61772.png +69192.png +20962.png +27413.png +43256.png +30429.png +56978.png +05364.png +40789.png +64602.png +23815.png +41560.png +38783.png +50746.png +58912.png +43137.png +10658.png +48567.png +26365.png +25239.png +52473.png +45470.png +50932.png +47879.png +68349.png +66151.png +34135.png +57448.png +17217.png +38164.png +19783.png +25971.png +33813.png +23850.png +34993.png +06169.png +47318.png +65839.png +38851.png +37825.png +25545.png +62935.png +57693.png +26809.png +54481.png +05757.png +49813.png +57196.png +03185.png +13227.png +48762.png +48870.png +28616.png +42989.png +37350.png +03126.png +49217.png +04376.png +10062.png +03475.png +45411.png +63916.png +49982.png +44925.png +41253.png +05257.png +05603.png +57646.png +23403.png +32453.png +62286.png +41383.png +15770.png +20830.png +47696.png +24835.png +28450.png +44116.png +40322.png +40450.png +05024.png +47066.png +53132.png +36868.png +16781.png +34538.png +08256.png +17981.png +51051.png +63239.png +69002.png +14078.png +67370.png +14286.png +36922.png +49862.png +26618.png +34768.png +21085.png +41185.png +24407.png +37739.png +55456.png +11852.png +48901.png +30790.png +40436.png +29406.png +59228.png +22328.png +29957.png +61038.png +13521.png +33525.png +63025.png +64304.png +57782.png +21715.png +36022.png +19135.png +29301.png +52195.png +53522.png +05861.png +03057.png +19759.png +10416.png +59495.png +35772.png +06691.png +46686.png +38372.png +21104.png +25229.png +38432.png +28527.png +36887.png +05252.png +07176.png +46313.png +52768.png +14700.png +02483.png +41235.png +18348.png +04542.png +56076.png +07744.png +33848.png +12385.png +51074.png +67787.png +38299.png +18743.png +49161.png +34593.png +41721.png +67841.png +52107.png +02321.png +29048.png +35210.png +11512.png +57381.png +62343.png +20933.png +26124.png +27449.png +44533.png +04941.png +58864.png +36466.png +29293.png +65223.png +59490.png +67972.png +14130.png +51726.png +61980.png +17664.png +32245.png +41095.png +46235.png +42152.png +16583.png +01053.png +59386.png +57154.png +40209.png +12115.png +10718.png +17327.png +34620.png +20401.png +40898.png +41931.png +06272.png +59709.png +55822.png +56352.png +58170.png +19204.png +37926.png +38511.png +54605.png +01932.png +04699.png +21710.png +62742.png +23614.png +22382.png +55161.png +14883.png +33324.png +26353.png +40639.png +33886.png +47600.png +34482.png +05553.png +05156.png +52800.png +58442.png +22250.png +57469.png +14499.png +59564.png +42491.png +57489.png +56936.png +43056.png +02457.png +39222.png +30267.png +14633.png +49648.png +54162.png +12404.png +17923.png +00135.png +64882.png +67535.png +38553.png +29584.png +43073.png +09078.png +15456.png +26341.png +61361.png +56370.png +14073.png +33793.png +05339.png +48648.png +49877.png +44642.png +08581.png +39309.png +27794.png +13472.png +17214.png +00384.png +32196.png +53806.png +26053.png +29178.png +66274.png +41391.png +52457.png +04843.png +30782.png +34116.png +69894.png +28462.png +16574.png +07217.png +04840.png +27755.png +65508.png +48679.png +52665.png +65647.png +07872.png +33722.png +15315.png +53079.png +20422.png +40227.png +54368.png +11128.png +28481.png +46203.png +65554.png +46128.png +14277.png +40310.png +17056.png +51942.png +19527.png +53610.png +44099.png +48031.png +54618.png +37989.png +61849.png +32064.png +34434.png +58851.png +08080.png +67498.png +46670.png +34115.png +56041.png +32317.png +38133.png +65778.png +08931.png +21359.png +52864.png +06461.png +46366.png +66628.png +07377.png +04108.png +52691.png +19540.png +65193.png +14708.png +02580.png +60751.png +08436.png +12936.png +00139.png +33567.png +41073.png +02534.png +41979.png +52898.png +31999.png +48047.png +33068.png +39529.png +43487.png +51066.png +10262.png +53019.png +17125.png +54440.png +29257.png +34898.png +20785.png +55318.png +65640.png +12376.png +31974.png +55397.png +60120.png +60827.png +22621.png +55840.png +10551.png +53248.png +18066.png +51209.png +58348.png +26033.png +26876.png +67328.png +02116.png +67142.png +53624.png +62991.png +51772.png +29166.png +42593.png +12204.png +38629.png +48371.png +42569.png +02655.png +60352.png +29003.png +34183.png +61252.png +60426.png +04662.png +68301.png +05084.png +47868.png +47301.png +26664.png +26587.png +51858.png +43208.png +65764.png +40812.png +02097.png +25644.png +22873.png +45515.png +00882.png +05409.png +56726.png +31914.png +54705.png +42961.png +66983.png +34361.png +08853.png +52350.png +54186.png +59809.png +04899.png +19314.png +23675.png +44356.png +67294.png +63589.png +46207.png +34303.png +09830.png +43538.png +38147.png +00049.png +19028.png +24554.png +28580.png +53761.png +65031.png +12125.png +39360.png +14237.png +37932.png +65458.png +55801.png +14640.png +68803.png +04363.png +25131.png +05325.png +40207.png +44149.png +64277.png +03576.png +36103.png +19103.png +31493.png +00879.png +21122.png +06643.png +39048.png +46581.png +68712.png +37918.png +56153.png +05342.png +28633.png +13114.png +20301.png +30150.png +53001.png +40453.png +65975.png +61347.png +39455.png +39149.png +23830.png +01471.png +41729.png +33919.png +17368.png +56311.png +33391.png +48650.png +60395.png +63018.png +22128.png +51130.png +65375.png +40621.png +19258.png +17896.png +09625.png +68869.png +09605.png +67092.png +66889.png +16522.png +23364.png +56606.png +38484.png +30192.png +24281.png +17082.png +38949.png +66128.png +21560.png +21506.png +52555.png +31449.png +14527.png +51260.png +14639.png +64809.png +27298.png +30781.png +46163.png +13467.png +61631.png +67965.png +43136.png +25176.png +23965.png +56151.png +61773.png +33884.png +12297.png +07740.png +59669.png +24508.png +41779.png +05675.png +21084.png +09306.png +32770.png +42092.png +18150.png +14230.png +07637.png +23134.png +34030.png +10815.png +55555.png +08466.png +53202.png +23601.png +27781.png +61876.png +34810.png +49754.png +20547.png +08550.png +58643.png +65944.png +22843.png +03275.png +14152.png +00039.png +32782.png +43327.png +37333.png +21114.png +15335.png +01774.png +64267.png +14586.png +54124.png +54464.png +43862.png +24418.png +50134.png +32576.png +21751.png +58923.png +22536.png +40750.png +47218.png +36844.png +17146.png +64709.png +65179.png +29691.png +52948.png +21908.png +48455.png +61182.png +03174.png +54722.png +17737.png +26872.png +55157.png +01677.png +41348.png +06084.png +25354.png +37423.png +53944.png +25927.png +56176.png +15511.png +48403.png +05278.png +20801.png +41726.png +01548.png +07409.png +05509.png +06403.png +49889.png +50636.png +23066.png +66943.png +21556.png +40283.png +01354.png +46771.png +37469.png +55194.png +24447.png +40640.png +03162.png +15821.png +67798.png +16128.png +05699.png +51746.png +58815.png +36753.png +41257.png +43328.png +30365.png +52820.png +15896.png +15839.png +41999.png +50799.png +12069.png +60104.png +52458.png +61883.png +64794.png +54664.png +01599.png +50231.png +46117.png +44348.png +28258.png +58498.png +55221.png +24164.png +09232.png +10535.png +69530.png +48022.png +18840.png +06984.png +55346.png +60747.png +69555.png +45931.png +06821.png +21581.png +57691.png +10408.png +48906.png +12682.png +02135.png +34829.png +57518.png +26262.png +23299.png +48941.png +52514.png +20393.png +04756.png +39566.png +22428.png +63532.png +66071.png +54724.png +39220.png +56939.png +32024.png +67997.png +48566.png +32511.png +09100.png +29703.png +37363.png +08437.png +02298.png +63028.png +45856.png +04727.png +69374.png +21847.png +24672.png +41172.png +66025.png +68395.png +69349.png +19218.png +41369.png +30452.png +07468.png +54730.png +27243.png +38920.png +53119.png +06357.png +49430.png +45379.png +57119.png +23774.png +19495.png +07703.png +26018.png +12114.png +05299.png +54763.png +02699.png +05792.png +62953.png +10968.png +02324.png +28134.png +23175.png +28838.png +18514.png +61791.png +62076.png +35567.png +33230.png +00631.png +50916.png +14112.png +07536.png +66055.png +44070.png +69244.png +65862.png +37301.png +13190.png +12235.png +11659.png +56266.png +46528.png +44550.png +41511.png +65320.png +01825.png +27432.png +52942.png +20836.png +04915.png +10752.png +61412.png +44321.png +35748.png +40352.png +43836.png +66199.png +22974.png +10983.png +50828.png +24996.png +61085.png +30629.png +03295.png +66539.png +19886.png +10586.png +39971.png +06592.png +30227.png +03688.png +61331.png +00933.png +50999.png +10776.png +59306.png +10373.png +03240.png +58341.png +23504.png +44146.png +42253.png +47885.png +26920.png +53955.png +28573.png +09466.png +29871.png +24783.png +20175.png +17793.png +56696.png +25543.png +09340.png +51536.png +00450.png +04645.png +60539.png +12241.png +23589.png +29706.png +15461.png +10577.png +05023.png +66000.png +40798.png +09294.png +22233.png +49212.png +05831.png +53772.png +23907.png +49034.png +43502.png +05533.png +00899.png +25821.png +39633.png +32407.png +44444.png +42477.png +30956.png +28063.png +09235.png +33318.png +09086.png +07813.png +42745.png +64991.png +57472.png +48356.png +29023.png +53430.png +07081.png +38727.png +43908.png +60394.png +55378.png +53807.png +34730.png +26817.png +59077.png +53952.png +40800.png +19869.png +53313.png +14445.png +58799.png +18028.png +29927.png +39686.png +17610.png +07272.png +03416.png +25418.png +50238.png +27566.png +00905.png +53928.png +37095.png +56075.png +24957.png +00230.png +44142.png +63773.png +17011.png +15171.png +23797.png +64380.png +29681.png +37136.png +52303.png +51302.png +04989.png +55818.png +69888.png +02866.png +48490.png +59710.png +08307.png +05923.png +44960.png +40823.png +64515.png +34622.png +04536.png +12127.png +25353.png +26422.png +13792.png +41476.png +39904.png +19688.png +36810.png +68819.png +45998.png +18218.png +10137.png +56277.png +26940.png +29248.png +17453.png +51648.png +60378.png +56611.png +20088.png +33628.png +18787.png +60743.png +25922.png +31808.png +10673.png +62494.png +49846.png +51771.png +46008.png +58900.png +35340.png +22614.png +55284.png +04463.png +19060.png +44976.png +35912.png +57156.png +16154.png +37283.png +11684.png +01125.png +09020.png +45509.png +10009.png +63690.png +24314.png +20293.png +13701.png +48930.png +35808.png +65380.png +00601.png +15018.png +03821.png +02319.png +40510.png +26595.png +49822.png +62566.png +42650.png +05426.png +01868.png +11193.png +21153.png +55719.png +29105.png +05947.png +66442.png +10005.png +12984.png +20316.png +59041.png +41344.png +18075.png +32764.png +05427.png +63724.png +14501.png +59990.png +45468.png +13819.png +08015.png +12377.png +57536.png +32757.png +60225.png +52186.png +39409.png +43618.png +42549.png +16620.png +30207.png +59972.png +56847.png +57990.png +55286.png +59981.png +06365.png +47048.png +28476.png +63453.png +10511.png +58486.png +31611.png +40476.png +63775.png +26971.png +07179.png +35229.png +69745.png +09600.png +32529.png +48001.png +15867.png +25344.png +05919.png +69711.png +38417.png +04396.png +10238.png +60774.png +52269.png +32039.png +30484.png +19957.png +33899.png +57015.png +65978.png +36716.png +27670.png +05343.png +11908.png +61285.png +16780.png +61952.png +62860.png +49204.png +12653.png +62464.png +15072.png +09570.png +08777.png +61572.png +39146.png +65536.png +62228.png +13618.png +51959.png +27572.png +56955.png +51315.png +54703.png +19012.png +00208.png +58826.png +27595.png +05907.png +66187.png +15293.png +22931.png +39202.png +42512.png +61769.png +38340.png +53213.png +52908.png +63611.png +22007.png +44815.png +16364.png +63560.png +15371.png +52285.png +69842.png +41814.png +21802.png +23096.png +14774.png +16150.png +35789.png +11501.png +21815.png +19925.png +27982.png +04967.png +27463.png +22975.png +08837.png +49470.png +66133.png +55497.png +68932.png +10427.png +30683.png +39684.png +24636.png +21188.png +35809.png +24645.png +50673.png +36311.png +22970.png +40336.png +62477.png +08749.png +08562.png +27960.png +68867.png +05653.png +49646.png +52425.png +11845.png +42896.png +24772.png +11951.png +52510.png +28574.png +00050.png +54266.png +27576.png +31830.png +04113.png +17801.png +53488.png +26803.png +01185.png +02161.png +12126.png +44219.png +65514.png +35134.png +15608.png +63207.png +59411.png +46162.png +58854.png +48232.png +26721.png +02516.png +47872.png +17937.png +22748.png +22936.png +08700.png +23051.png +08102.png +56492.png +69003.png +23888.png +24973.png +57509.png +11067.png +09973.png +62200.png +34661.png +13948.png +10419.png +12112.png +55136.png +46233.png +26386.png +15632.png +14362.png +63902.png +54789.png +49767.png +45264.png +57268.png +42335.png +65631.png +01792.png +14993.png +02860.png +35700.png +07187.png +15660.png +24563.png +04813.png +49505.png +46999.png +62104.png +58519.png +31831.png +10336.png +29714.png +59305.png +39412.png +27320.png +12467.png +63301.png +50242.png +11771.png +52243.png +57075.png +50496.png +09378.png +23022.png +56720.png +00512.png +22552.png +11350.png +54239.png +64402.png +17258.png +36857.png +33548.png +33911.png +35692.png +18073.png +46103.png +21055.png +39075.png +45364.png +62062.png +34750.png +28393.png +57236.png +67703.png +61979.png +58960.png +12686.png +25538.png +55914.png +40168.png +03270.png +05690.png +54112.png +66974.png +49503.png +50366.png +35501.png +51759.png +29458.png +31313.png +66472.png +31357.png +04414.png +34062.png +55779.png +51192.png +09920.png +12434.png +37366.png +27285.png +04643.png +56549.png +67816.png +32815.png +19444.png +21834.png +64512.png +46345.png +01990.png +60125.png +57197.png +59256.png +53881.png +42132.png +14576.png +01860.png +62267.png +21655.png +15028.png +33988.png +67610.png +01191.png +00719.png +15719.png +57336.png +67398.png +47977.png +18863.png +52028.png +05115.png +41606.png +15690.png +02382.png +68123.png +18996.png +08570.png +62198.png +62008.png +58505.png +52501.png +06479.png +09700.png +56219.png +31279.png +53337.png +09094.png +48426.png +44501.png +28556.png +33214.png +38569.png +30261.png +69397.png +01323.png +14609.png +63651.png +10269.png +56106.png +50591.png +33757.png +53454.png +00451.png +32310.png +48933.png +03918.png +69076.png +27199.png +50867.png +19163.png +44167.png +36650.png +34787.png +19909.png +35274.png +10025.png +27388.png +23636.png +08952.png +29392.png +18118.png +25734.png +39251.png +37560.png +11172.png +38194.png +10227.png +66341.png +39530.png +29269.png +66712.png +34415.png +14921.png +27953.png +64790.png +18030.png +37537.png +55675.png +48867.png +38749.png +68868.png +57636.png +58846.png +26149.png +65909.png +14249.png +29891.png +15427.png +51161.png +36859.png +30503.png +07783.png +51665.png +68812.png +66715.png +12802.png +52596.png +34409.png +49559.png +14025.png +31612.png +48953.png +24458.png +01374.png +63256.png +43047.png +11205.png +24124.png +48240.png +11505.png +21304.png +68234.png +23149.png +64507.png +58728.png +18539.png +28605.png +12222.png +13886.png +67929.png +60885.png +00035.png +56962.png +66304.png +36282.png +57157.png +31733.png +28677.png +47295.png +50732.png +01881.png +02120.png +38067.png +32114.png +29588.png +44018.png +24673.png +23241.png +32186.png +69456.png +17395.png +39096.png +51388.png +29064.png +48594.png +02975.png +62030.png +31257.png +38967.png +47183.png +17143.png +06200.png +57232.png +20747.png +49025.png +06224.png +27265.png +29432.png +04622.png +21826.png +21703.png +25588.png +34799.png +16020.png +35981.png +05585.png +68742.png +15874.png +46286.png +09485.png +09914.png +54519.png +50054.png +21374.png +58385.png +32410.png +69891.png +44524.png +26100.png +50808.png +67829.png +06567.png +01963.png +07913.png +56973.png +19851.png +21896.png +46766.png +30989.png +01660.png +27417.png +46987.png +33133.png +42705.png +51309.png +03718.png +09715.png +68356.png +23733.png +02900.png +60683.png +10760.png +39109.png +39481.png +49192.png +58584.png +51841.png +64266.png +14457.png +23320.png +02721.png +62801.png +18685.png +10901.png +49422.png +41005.png +50983.png +57389.png +18430.png +12665.png +03230.png +47138.png +02545.png +53775.png +47453.png +13384.png +34449.png +06813.png +45751.png +61160.png +34020.png +60926.png +49333.png +34953.png +27746.png +40541.png +08746.png +06320.png +69925.png +13383.png +12833.png +55005.png +56592.png +54999.png +66727.png +29981.png +59404.png +69112.png +35942.png +67886.png +09790.png +63058.png +04388.png +26530.png +23798.png +40460.png +31200.png +67507.png +57041.png +16995.png +25810.png +28598.png +47305.png +24992.png +06604.png +29683.png +48193.png +67340.png +41970.png +18696.png +10378.png +57170.png +19345.png +34802.png +14999.png +12318.png +63439.png +46384.png +19251.png +08303.png +29896.png +10200.png +07597.png +12231.png +09035.png +33283.png +08996.png +57756.png +42287.png +47959.png +08337.png +66744.png +64428.png +16804.png +22977.png +43466.png +20574.png +69564.png +50648.png +11585.png +47324.png +31135.png +31690.png +18312.png +04602.png +65632.png +69493.png +26013.png +10041.png +67778.png +17285.png +65208.png +40349.png +14214.png +29175.png +24210.png +22817.png +41728.png +06104.png +37365.png +47994.png +46137.png +27875.png +17438.png +51905.png +32794.png +09904.png +51132.png +35827.png +02718.png +15421.png +12775.png +61276.png +34372.png +59916.png +55438.png +50712.png +51283.png +17026.png +11616.png +39104.png +29976.png +60930.png +33062.png +14424.png +68190.png +31654.png +08459.png +17186.png +32190.png +48859.png +06724.png +63927.png +25403.png +02824.png +06050.png +67830.png +07008.png +40014.png +40108.png +62714.png +00702.png +51458.png +38762.png +16085.png +15855.png +56727.png +23872.png +33086.png +26981.png +55019.png +43214.png +39873.png +34971.png +05927.png +31671.png +07427.png +12501.png +46527.png +42390.png +37858.png +09505.png +28656.png +33524.png +12053.png +58154.png +63596.png +65940.png +61615.png +01081.png +53447.png +62264.png +68432.png +31102.png +41402.png +67545.png +19712.png +66698.png +33844.png +61294.png +31947.png +43974.png +57705.png +47521.png +68156.png +61897.png +32456.png +41335.png +36023.png +68192.png +21261.png +13542.png +51448.png +36572.png +10170.png +66260.png +27233.png +00865.png +32011.png +46693.png +29213.png +17289.png +13016.png +25273.png +46270.png +47436.png +02979.png +05436.png +31498.png +16965.png +56997.png +67836.png +13699.png +10702.png +43542.png +35746.png +06961.png +32962.png +59438.png +55395.png +03123.png +16161.png +01916.png +20317.png +04657.png +06679.png +17331.png +35824.png +43816.png +25474.png +62446.png +02957.png +14651.png +28519.png +49109.png +34279.png +07594.png +09045.png +13730.png +39908.png +24320.png +05412.png +36822.png +48820.png +51857.png +31447.png +52662.png +67015.png +28046.png +00277.png +08494.png +69008.png +12871.png +66061.png +02215.png +40989.png +21987.png +30341.png +23664.png +37212.png +46132.png +58266.png +59999.png +57667.png +53794.png +64026.png +03215.png +34447.png +06086.png +08788.png +61344.png +40391.png +13665.png +04170.png +02758.png +05029.png +04172.png +46492.png +01903.png +53025.png +59939.png +62579.png +30953.png +26293.png +57424.png +30007.png +01875.png +13308.png +43299.png +51157.png +69848.png +13143.png +58824.png +51867.png +36998.png +00836.png +45626.png +60663.png +37404.png +51351.png +19096.png +63800.png +21129.png +60348.png +17153.png +08441.png +66562.png +58898.png +62478.png +42663.png +12355.png +42337.png +02031.png +12072.png +18788.png +06495.png +48298.png +24805.png +09149.png +10893.png +02739.png +25676.png +62554.png +55334.png +03427.png +46646.png +19810.png +01705.png +59304.png +14481.png +20657.png +00328.png +54402.png +60639.png +22665.png +57258.png +13891.png +06611.png +43203.png +05415.png +63608.png +19761.png +36953.png +02525.png +13681.png +15248.png +19489.png +26074.png +40213.png +59965.png +08149.png +40513.png +68342.png +65258.png +26552.png +49582.png +12368.png +13303.png +26005.png +52915.png +56478.png +67957.png +47389.png +05976.png +15832.png +17175.png +08557.png +49445.png +51346.png +67465.png +20152.png +26245.png +12320.png +13585.png +06931.png +18070.png +08843.png +68924.png +64710.png +21570.png +31013.png +16419.png +14404.png +58819.png +65501.png +52184.png +03025.png +33327.png +63881.png +18880.png +33257.png +49005.png +62287.png +39405.png +47976.png +26336.png +37585.png +50803.png +67047.png +59766.png +29494.png +42812.png +24761.png +05851.png +05118.png +22715.png +24135.png +05667.png +11924.png +00881.png +14471.png +41526.png +29496.png +06701.png +67573.png +56918.png +16851.png +03395.png +45613.png +04266.png +31474.png +14102.png +59238.png +41990.png +37800.png +05827.png +14274.png +63862.png +03476.png +57858.png +26877.png +14877.png +06341.png +47802.png +31306.png +63759.png +67942.png +66808.png +62611.png +25301.png +13779.png +03422.png +62331.png +55124.png +31319.png +30720.png +26197.png +48322.png +67600.png +45829.png +63224.png +36223.png +65583.png +69637.png +49407.png +38639.png +61606.png +68539.png +05108.png +46387.png +32015.png +31750.png +52564.png +30464.png +34055.png +50286.png +64420.png +02991.png +09552.png +02316.png +38075.png +53766.png +47122.png +39330.png +56769.png +43924.png +56582.png +37033.png +67872.png +18356.png +63339.png +61697.png +19969.png +64404.png +43403.png +19088.png +37162.png +52380.png +25785.png +01429.png +42090.png +60858.png +56208.png +33586.png +39931.png +52401.png +30424.png +27079.png +38930.png +65722.png +16773.png +02449.png +24012.png +52023.png +09483.png +01279.png +17617.png +68380.png +65886.png +56104.png +17840.png +17499.png +37947.png +13907.png +38600.png +19579.png +25090.png +15457.png +24714.png +36050.png +13477.png +02577.png +12534.png +31160.png +02000.png +17932.png +17963.png +17747.png +30472.png +55881.png +64726.png +47829.png +33357.png +06628.png +22983.png +51826.png +33632.png +03811.png +11993.png +34362.png +03341.png +00207.png +67901.png +01658.png +47467.png +05177.png +05151.png +11372.png +51727.png +64748.png +37618.png +36900.png +07547.png +16526.png +66498.png +63144.png +62901.png +39726.png +12661.png +09666.png +21384.png +00842.png +44710.png +47639.png +63688.png +30621.png +03363.png +64378.png +31336.png +38285.png +60667.png +27018.png +19335.png +60787.png +47724.png +44778.png +03499.png +30527.png +08002.png +61694.png +53555.png +69835.png +33788.png +23950.png +61478.png +05655.png +09284.png +48920.png +19537.png +23217.png +55370.png +65292.png +24319.png +67008.png +64372.png +04118.png +23885.png +43081.png +53276.png +19426.png +56434.png +17282.png +61381.png +07180.png +57478.png +54866.png +51871.png +48217.png +51452.png +01533.png +56728.png +01148.png +54790.png +48418.png +55811.png +40993.png +22989.png +49926.png +50414.png +25163.png +41924.png +39305.png +20587.png +43527.png +12129.png +62410.png +36812.png +16677.png +20581.png +60295.png +21481.png +40751.png +38187.png +69736.png +05401.png +48397.png +41834.png +50855.png +49026.png +01771.png +66748.png +27259.png +61459.png +45694.png +09711.png +58762.png +49486.png +11971.png +57938.png +62709.png +13150.png +49168.png +18867.png +13174.png +02400.png +22814.png +56483.png +06639.png +60483.png +19015.png +43321.png +10926.png +18749.png +56057.png +67274.png +19130.png +61157.png +20421.png +22465.png +17703.png +33527.png +03857.png +61121.png +15170.png +48435.png +49042.png +07224.png +04230.png +62958.png +42380.png +23985.png +59844.png +43668.png +48826.png +32509.png +35719.png +02299.png +05369.png +58746.png +62467.png +66840.png +47191.png +45293.png +52322.png +20200.png +38997.png +14466.png +26748.png +56177.png +33636.png +10232.png +32953.png +30638.png +37957.png +57266.png +26734.png +40019.png +46186.png +42343.png +49850.png +42134.png +54002.png +31435.png +57012.png +68545.png +56911.png +32778.png +54156.png +62495.png +15087.png +41857.png +38177.png +32392.png +25555.png +22525.png +22706.png +11153.png +04201.png +01927.png +24190.png +51425.png +47462.png +52521.png +46800.png +27001.png +46444.png +67606.png +28489.png +58622.png +37249.png +39123.png +26742.png +46245.png +28414.png +13091.png +55214.png +19183.png +57730.png +50553.png +54035.png +07665.png +39314.png +16962.png +65110.png +06874.png +09022.png +52048.png +11048.png +11331.png +11661.png +17007.png +29903.png +32622.png +22755.png +00435.png +63909.png +00033.png +27644.png +63541.png +17817.png +24075.png +01037.png +31961.png +53745.png +60894.png +03450.png +61503.png +26499.png +22336.png +47504.png +17760.png +65746.png +07798.png +34507.png +33729.png +59234.png +68249.png +40553.png +41159.png +55225.png +56017.png +23333.png +08716.png +19076.png +06025.png +67946.png +40631.png +38331.png +26955.png +08820.png +03064.png +29214.png +28023.png +45185.png +60631.png +37970.png +15278.png +18183.png +10805.png +31411.png +36163.png +33361.png +57128.png +50541.png +16683.png +34460.png +11348.png +12317.png +56282.png +02922.png +43679.png +68590.png +15693.png +35373.png +08950.png +13218.png +14854.png +48535.png +01071.png +16733.png +49964.png +14456.png +01940.png +44686.png +04386.png +51743.png +44214.png +51507.png +16325.png +04625.png +05208.png +27371.png +13215.png +63616.png +49739.png +08389.png +42547.png +22554.png +55846.png +15520.png +14643.png +58032.png +14943.png +07922.png +50372.png +24444.png +65418.png +54088.png +52945.png +21591.png +21974.png +51202.png +15510.png +11319.png +16114.png +53249.png +12475.png +42988.png +13772.png +42285.png +05392.png +40758.png +06327.png +62943.png +00382.png +16078.png +10897.png +01693.png +69220.png +00072.png +53673.png +14222.png +62857.png +59139.png +05184.png +16680.png +56623.png +52972.png +50289.png +66081.png +05764.png +69280.png +25430.png +21315.png +22951.png +50274.png +43692.png +14372.png +09112.png +69166.png +31035.png +46447.png +49421.png +04885.png +33654.png +02716.png +00474.png +04857.png +53348.png +49885.png +54983.png +63104.png +48614.png +02773.png +36834.png +64235.png +45196.png +30405.png +30236.png +26713.png +26525.png +06652.png +48557.png +07741.png +51946.png +29595.png +06809.png +09279.png +01476.png +54409.png +22353.png +02833.png +21147.png +10139.png +34074.png +33534.png +06494.png +16397.png +16480.png +58276.png +54342.png +28699.png +03727.png +31983.png +04701.png +33373.png +41869.png +32715.png +66083.png +57175.png +53103.png +23692.png +46895.png +40948.png +09389.png +23388.png +01085.png +39697.png +47718.png +43235.png +39073.png +45715.png +56212.png +24076.png +19109.png +64418.png +11392.png +64896.png +21091.png +01219.png +15834.png +29157.png +60451.png +27537.png +40743.png +66540.png +14713.png +23848.png +28547.png +24144.png +08935.png +10035.png +38626.png +39099.png +22580.png +26178.png +62463.png +35611.png +65605.png +24276.png +33375.png +62238.png +27122.png +49590.png +12850.png +40733.png +38951.png +57376.png +54064.png +11805.png +65852.png +45633.png +40505.png +46980.png +01180.png +30709.png +66290.png +69740.png +56450.png +58334.png +41469.png +45127.png +17477.png +54760.png +22914.png +14783.png +67930.png +09695.png +59775.png +61165.png +10323.png +11195.png +08861.png +69746.png +48151.png +09358.png +48626.png +27981.png +66153.png +28663.png +65268.png +12198.png +54004.png +02743.png +28345.png +29461.png +46305.png +23858.png +20260.png +69185.png +57638.png +07878.png +56188.png +19241.png +45887.png +37020.png +51793.png +51004.png +23882.png +50615.png +54422.png +17489.png +56752.png +27528.png +61868.png +17619.png +44492.png +37746.png +45501.png +34836.png +54274.png +23266.png +07866.png +31403.png +62853.png +20726.png +65097.png +62662.png +00134.png +33485.png +52534.png +51621.png +22994.png +07247.png +32119.png +32344.png +23271.png +27375.png +58705.png +66345.png +56647.png +17915.png +02650.png +68763.png +23252.png +45465.png +36321.png +67360.png +43730.png +13796.png +52392.png +53485.png +09305.png +56732.png +00428.png +57817.png +05384.png +33193.png +39703.png +31746.png +59528.png +08074.png +45966.png +63590.png +25223.png +06882.png +46372.png +38619.png +43354.png +33290.png +31712.png +40370.png +43101.png +63019.png +50774.png +44628.png +33231.png +41785.png +66546.png +54900.png +12960.png +32337.png +26142.png +12265.png +38464.png +11137.png +50324.png +14598.png +62159.png +48014.png +00609.png +60493.png +50930.png +02596.png +09542.png +19427.png +22488.png +61369.png +68327.png +11911.png +09665.png +32516.png +49669.png +25349.png +52649.png +43397.png +06304.png +34726.png +35214.png +13956.png +25996.png +64191.png +20454.png +13544.png +39854.png +59749.png +27522.png +42566.png +14740.png +05607.png +47667.png +67343.png +24701.png +51808.png +36915.png +61508.png +67254.png +54726.png +08904.png +64659.png +35542.png +39790.png +20912.png +45056.png +59857.png +38059.png +55730.png +30535.png +05300.png +10705.png +50752.png +23133.png +50768.png +46452.png +20055.png +16127.png +58449.png +38927.png +32121.png +00537.png +60686.png +62842.png +04366.png +52692.png +12552.png +51473.png +58798.png +60242.png +13953.png +02007.png +58155.png +31207.png +50800.png +38369.png +66529.png +42215.png +07651.png +17169.png +17577.png +01166.png +49631.png +39746.png +16116.png +00354.png +29182.png +11749.png +28121.png +45352.png +43687.png +68913.png +23538.png +65700.png +61392.png +24548.png +39010.png +54071.png +01073.png +02107.png +07214.png +44984.png +33207.png +37311.png +19013.png +01370.png +61856.png +60186.png +59427.png +33915.png +29906.png +64796.png +07356.png +07192.png +55669.png +13119.png +61628.png +35672.png +23716.png +35326.png +62970.png +60855.png +13988.png +36001.png +13123.png +60054.png +28639.png +28315.png +08204.png +67093.png +61301.png +58942.png +09892.png +32021.png +68730.png +06521.png +06240.png +25632.png +45846.png +06796.png +41435.png +50686.png +36174.png +45698.png +69509.png +29298.png +18136.png +63837.png +17048.png +39378.png +55513.png +12354.png +43275.png +10297.png +33786.png +68262.png +54336.png +29828.png +46859.png +26167.png +68992.png +02868.png +17380.png +60527.png +68362.png +47231.png +14754.png +56051.png +58568.png +42637.png +54847.png +57034.png +37086.png +55001.png +60318.png +65960.png +56597.png +50864.png +01975.png +48165.png +00734.png +54438.png +56111.png +42864.png +10495.png +28577.png +25591.png +50033.png +57357.png +45597.png +06001.png +27527.png +03794.png +61246.png +08043.png +30260.png +56563.png +63087.png +14196.png +59726.png +37323.png +27711.png +43790.png +15968.png +31338.png +24846.png +56845.png +44358.png +45040.png +39714.png +03976.png +23206.png +56871.png +05591.png +39017.png +03997.png +43258.png +47627.png +66802.png +29944.png +19614.png +28304.png +29989.png +67155.png +09584.png +40306.png +24904.png +12163.png +61850.png +06066.png +30583.png +34205.png +23480.png +36344.png +18766.png +41598.png +04097.png +23829.png +18723.png +59737.png +16552.png +22832.png +24093.png +47280.png +29803.png +31722.png +66684.png +04479.png +43480.png +15643.png +14752.png +46522.png +46170.png +43868.png +55104.png +35475.png +24971.png +66143.png +07106.png +49331.png +21477.png +07892.png +03020.png +39646.png +50336.png +40496.png +48553.png +32961.png +07672.png +47147.png +41058.png +34628.png +52276.png +06932.png +28806.png +68168.png +24734.png +47332.png +12514.png +56630.png +56829.png +57533.png +56100.png +33224.png +36471.png +12091.png +14267.png +29063.png +51821.png +61371.png +26121.png +04974.png +19253.png +51941.png +16301.png +20046.png +25718.png +42063.png +23073.png +59103.png +31089.png +44822.png +11046.png +10364.png +09763.png +17920.png +17870.png +34856.png +23148.png +63188.png +06771.png +63581.png +61225.png +55227.png +25596.png +19491.png +06044.png +57036.png +02474.png +50505.png +34457.png +10998.png +22098.png +09274.png +47514.png +37639.png +50127.png +12157.png +61019.png +60617.png +32881.png +14309.png +52236.png +09199.png +00261.png +28876.png +51696.png +05063.png +29236.png +31133.png +60541.png +02817.png +06829.png +50852.png +49145.png +55579.png +01467.png +44239.png +09900.png +20637.png +01426.png +37929.png +57052.png +23261.png +60267.png +07501.png +23982.png +18074.png +56224.png +19542.png +47487.png +53044.png +64572.png +29330.png +02608.png +29476.png +56532.png +39562.png +26705.png +64038.png +21513.png +60132.png +52951.png +60941.png +40210.png +58677.png +12144.png +06166.png +55612.png +49720.png +02425.png +52095.png +35905.png +13710.png +19078.png +69707.png +14399.png +15242.png +37414.png +02073.png +25563.png +34124.png +48198.png +29402.png +36704.png +41319.png +32945.png +00616.png +48999.png +45948.png +43495.png +16321.png +60723.png +14666.png +19295.png +00723.png +06663.png +39972.png +23420.png +35857.png +24221.png +30679.png +03173.png +67071.png +09510.png +44692.png +02924.png +29274.png +17435.png +02666.png +32069.png +51989.png +30250.png +69452.png +57096.png +50163.png +41657.png +12159.png +57317.png +63940.png +56192.png +05471.png +61637.png +07075.png +22765.png +01364.png +48828.png +38086.png +57535.png +45361.png +64129.png +49022.png +28060.png +22451.png +67391.png +52123.png +48721.png +27601.png +23659.png +06247.png +22335.png +20106.png +17402.png +07460.png +19040.png +14226.png +17800.png +49080.png +26722.png +11250.png +01109.png +07620.png +09303.png +03315.png +22571.png +07941.png +51117.png +15160.png +54434.png +16286.png +64834.png +38673.png +44162.png +63324.png +31897.png +18516.png +41040.png +11286.png +48332.png +38235.png +54868.png +49603.png +41703.png +62969.png +55783.png +49944.png +36837.png +56819.png +58614.png +34595.png +65240.png +41669.png +53069.png +66798.png +05001.png +62600.png +11124.png +59781.png +41173.png +59890.png +51023.png +07407.png +15252.png +59940.png +28503.png +36799.png +21370.png +57679.png +13120.png +18307.png +15794.png +40796.png +23119.png +49596.png +59067.png +11780.png +44128.png +19300.png +67312.png +10700.png +09784.png +38919.png +30545.png +28575.png +16492.png +56265.png +64474.png +15501.png +01400.png +59158.png +29210.png +19156.png +25573.png +60826.png +40502.png +43788.png +08806.png +63139.png +68427.png +55062.png +21717.png +68788.png +64029.png +25840.png +69597.png +48147.png +64624.png +57721.png +28761.png +30784.png +19429.png +09577.png +09444.png +58134.png +01128.png +06375.png +49790.png +60277.png +50013.png +16101.png +53243.png +38900.png +60017.png +45415.png +52105.png +32593.png +34676.png +36469.png +44682.png +33502.png +40082.png +18380.png +17584.png +05859.png +48959.png +07847.png +32052.png +47326.png +40080.png +62724.png +05960.png +46138.png +51502.png +64316.png +36736.png +55114.png +25179.png +54245.png +35487.png +69239.png +41932.png +31728.png +23493.png +51404.png +20868.png +28734.png +48207.png +13113.png +03386.png +02330.png +28581.png +52238.png +64037.png +33560.png +61236.png +17516.png +32672.png +57540.png +34753.png +41678.png +64125.png +33869.png +59813.png +60026.png +37902.png +43611.png +35730.png +01045.png +62545.png +56081.png +46410.png +26945.png +16463.png +56689.png +59786.png +49475.png +69444.png +10652.png +24065.png +47120.png +21907.png +54837.png +42415.png +52905.png +26201.png +16748.png +32588.png +42179.png +56150.png +44716.png +13368.png +63508.png +67515.png +20731.png +39283.png +09141.png +65246.png +35558.png +48787.png +03454.png +30665.png +04341.png +28009.png +49068.png +26068.png +35434.png +47101.png +28718.png +02137.png +49436.png +14250.png +37854.png +00858.png +09173.png +30612.png +21904.png +04078.png +40140.png +58169.png +23562.png +26028.png +49182.png +45227.png +31488.png +04168.png +39897.png +04578.png +64393.png +41152.png +63116.png +10354.png +30397.png +54031.png +30992.png +59543.png +39910.png +67533.png +52132.png +55533.png +52512.png +48325.png +65980.png +50111.png +38458.png +07177.png +67887.png +10482.png +64471.png +23961.png +17450.png +25455.png +52218.png +63432.png +02034.png +54174.png +41074.png +53122.png +27374.png +62934.png +40562.png +48550.png +30418.png +43007.png +57641.png +18777.png +49747.png +03061.png +34102.png +10060.png +03538.png +14758.png +23249.png +34907.png +25704.png +57700.png +10808.png +36007.png +52846.png +53931.png +37885.png +58971.png +35215.png +27166.png +08661.png +22821.png +59979.png +41658.png +49101.png +07826.png +68203.png +16989.png +37322.png +49054.png +28780.png +27799.png +64161.png +54102.png +55637.png +41170.png +34208.png +69782.png +35545.png +50811.png +02683.png +18726.png +37978.png +24767.png +45841.png +39227.png +67506.png +00455.png +10045.png +23227.png +18675.png +61929.png +40574.png +07509.png +26258.png +34775.png +11591.png +26604.png +45280.png +48952.png +16508.png +50168.png +02475.png +55990.png +67480.png +31400.png +24732.png +31115.png +42237.png +28371.png +22483.png +19575.png +37848.png +69302.png +50628.png +46281.png +01058.png +48424.png +02575.png +56269.png +00975.png +22078.png +56631.png +24445.png +01900.png +60204.png +14548.png +61432.png +32879.png +09254.png +05411.png +12093.png +08003.png +02885.png +05552.png +58754.png +66301.png +15104.png +38576.png +40964.png +35935.png +54337.png +04557.png +55895.png +50907.png +12450.png +49535.png +26755.png +03775.png +30747.png +53460.png +38404.png +26458.png +50494.png +20007.png +60335.png +61983.png +34567.png +37192.png +32137.png +05399.png +59575.png +37895.png +67730.png +55747.png +12205.png +66504.png +61937.png +10491.png +17194.png +37843.png +10934.png +53899.png +09588.png +26715.png +38100.png +36188.png +14390.png +17379.png +68806.png +02686.png +42115.png +02352.png +41846.png +43431.png +44795.png +25751.png +23330.png +61348.png +57456.png +39715.png +09586.png +59658.png +27805.png +61814.png +44335.png +29509.png +26182.png +35548.png +26675.png +38528.png +08486.png +03491.png +28555.png +05942.png +10691.png +09574.png +02501.png +24193.png +63572.png +45252.png +09737.png +22244.png +27770.png +24226.png +52116.png +10668.png +68516.png +19611.png +49600.png +41961.png +03641.png +37882.png +02040.png +53755.png +45768.png +24595.png +57252.png +68339.png +49793.png +69758.png +25380.png +52044.png +68860.png +06885.png +66123.png +27249.png +19192.png +22729.png +11145.png +50658.png +64414.png +49810.png +49867.png +65196.png +07259.png +49325.png +13940.png +12216.png +18960.png +52663.png +29422.png +48974.png +54294.png +23741.png +51220.png +12070.png +00400.png +13835.png +50094.png +39206.png +63527.png +51855.png +16743.png +52785.png +23341.png +44176.png +39116.png +17779.png +66907.png +46368.png +40607.png +19536.png +64356.png +22568.png +59392.png +55689.png +36564.png +36451.png +64361.png +15929.png +08175.png +00621.png +46319.png +54017.png +49990.png +39242.png +65987.png +25500.png +15954.png +64766.png +03735.png +06264.png +28631.png +41934.png +41477.png +00583.png +10796.png +00708.png +42210.png +24183.png +49977.png +13572.png +39313.png +66607.png +43963.png +02456.png +04921.png +05167.png +04343.png +59198.png +17181.png +22182.png +48387.png +19837.png +65104.png +27286.png +39475.png +19052.png +12260.png +05433.png +24426.png +27278.png +31770.png +69833.png +39288.png +62348.png +65420.png +31116.png +21046.png +24702.png +63915.png +20550.png +22324.png +50409.png +25231.png +02973.png +01347.png +12765.png +64646.png +23766.png +26125.png +34870.png +38845.png +08324.png +52881.png +12273.png +61917.png +45271.png +45785.png +07361.png +15909.png +49697.png +46159.png +07215.png +42016.png +45820.png +23569.png +37630.png +01702.png +16544.png +24619.png +08360.png +54487.png +56751.png +05070.png +36266.png +54346.png +15082.png +42030.png +25778.png +51171.png +69976.png +39143.png +39510.png +04686.png +44344.png +46748.png +51044.png +07048.png +43650.png +07111.png +33211.png +30292.png +12899.png +64212.png +38434.png +52585.png +19522.png +30587.png +67768.png +09270.png +17863.png +15479.png +20506.png +05645.png +55408.png +44549.png +36730.png +00581.png +58007.png +15712.png +67075.png +55447.png +46463.png +53372.png +65735.png +39869.png +33169.png +16942.png +28891.png +09853.png +04652.png +01278.png +57814.png +22125.png +23424.png +21809.png +21076.png +12695.png +43673.png +16015.png +46378.png +58828.png +27263.png +35189.png +61807.png +04198.png +25733.png +46546.png +02785.png +13217.png +49947.png +49414.png +59446.png +21007.png +24736.png +57316.png +33094.png +25393.png +38312.png +66275.png +11903.png +21887.png +12918.png +01320.png +62452.png +40888.png +03635.png +37418.png +62902.png +55180.png +22421.png +03016.png +30994.png +58390.png +47940.png +67441.png +24791.png +07283.png +67973.png +13439.png +50593.png +25299.png +26306.png +35709.png +68264.png +17934.png +58724.png +16669.png +24989.png +51168.png +17312.png +68360.png +45331.png +34060.png +21331.png +52163.png +33991.png +07659.png +01845.png +45206.png +40316.png +62512.png +00052.png +50125.png +32837.png +55040.png +04111.png +21954.png +14220.png +59962.png +59636.png +02307.png +32535.png +67247.png +24765.png +69518.png +66671.png +15584.png +20227.png +36143.png +39690.png +67783.png +24234.png +20905.png +20001.png +48390.png +36456.png +56322.png +53159.png +05117.png +48160.png +41898.png +15742.png +11821.png +34182.png +53455.png +06297.png +57300.png +54708.png +50035.png +54276.png +35106.png +49696.png +17126.png +48485.png +17755.png +05567.png +65823.png +40212.png +28612.png +26868.png +18263.png +23002.png +40472.png +56628.png +00830.png +19702.png +56947.png +61919.png +36675.png +04740.png +25708.png +20350.png +20320.png +37094.png +33800.png +58380.png +59163.png +57126.png +23285.png +65580.png +11507.png +57905.png +17490.png +57792.png +39159.png +26570.png +07709.png +55757.png +39168.png +45612.png +20041.png +55599.png +01580.png +67206.png +23235.png +63043.png +05605.png +53008.png +67550.png +23254.png +15016.png +47426.png +48996.png +67977.png +65561.png +24749.png +61036.png +32307.png +40429.png +64850.png +40753.png +62976.png +37566.png +69045.png +10315.png +11013.png +26011.png +52400.png +47448.png +40939.png +56458.png +43815.png +52994.png +41183.png +68747.png +58098.png +54840.png +58399.png +61050.png +55064.png +04871.png +22171.png +18225.png +61970.png +23551.png +40866.png +13767.png +12875.png +13078.png +01220.png +49098.png +61517.png +58615.png +31394.png +66711.png +58763.png +00212.png +27246.png +00202.png +66816.png +43083.png +58981.png +47993.png +26841.png +19596.png +67292.png +45372.png +62636.png +56613.png +09547.png +20272.png +17826.png +69754.png +04948.png +10555.png +19503.png +07136.png +69620.png +63723.png +07380.png +51435.png +42990.png +29482.png +28214.png +46606.png +32208.png +61556.png +34152.png +48939.png +32640.png +59203.png +27307.png +01852.png +38617.png +44102.png +48370.png +45450.png +33731.png +29859.png +69927.png +38960.png +20701.png +38852.png +51055.png +66267.png +59711.png +18801.png +13158.png +32441.png +24350.png +42652.png +19628.png +21838.png +30622.png +44996.png +10353.png +63644.png +64439.png +53612.png +42228.png +08526.png +26839.png +34302.png +49327.png +25752.png +33866.png +20611.png +27811.png +01133.png +06649.png +63448.png +62394.png +26813.png +29787.png +41709.png +15664.png +49698.png +43040.png +64813.png +65920.png +18967.png +19656.png +08380.png +25686.png +59646.png +37743.png +39301.png +61530.png +60000.png +39843.png +01003.png +13404.png +13370.png +25252.png +65004.png +38555.png +42271.png +15940.png +13357.png +03213.png +20216.png +13748.png +25693.png +07986.png +52825.png +61784.png +44500.png +30263.png +37098.png +54770.png +61272.png +53913.png +49320.png +05221.png +07154.png +21449.png +17542.png +03830.png +59318.png +66273.png +28520.png +40375.png +56863.png +48844.png +18426.png +18911.png +10474.png +36961.png +45469.png +05777.png +33957.png +09316.png +22969.png +39758.png +11584.png +26649.png +13106.png +52270.png +30736.png +63471.png +64898.png +42943.png +51860.png +30164.png +13009.png +15827.png +34636.png +61583.png +28028.png +18608.png +49418.png +08108.png +46755.png +30296.png +55357.png +24117.png +41433.png +15796.png +64511.png +35137.png +14028.png +26445.png +66293.png +48484.png +28047.png +48099.png +40877.png +56180.png +26120.png +65439.png +16335.png +29918.png +38160.png +19988.png +58676.png +62840.png +29982.png +17556.png +37983.png +23224.png +65197.png +25429.png +35763.png +63580.png +58023.png +57653.png +29704.png +54107.png +34072.png +26533.png +05833.png +00104.png +09698.png +08698.png +00525.png +22815.png +53576.png +47953.png +09263.png +48125.png +66785.png +16063.png +61302.png +12721.png +22855.png +61898.png +10746.png +37992.png +60134.png +17669.png +40147.png +22507.png +33237.png +26631.png +68213.png +19669.png +49569.png +60367.png +32986.png +64728.png +38444.png +33491.png +00957.png +35823.png +35252.png +13978.png +25715.png +15993.png +58977.png +30967.png +65695.png +62948.png +18333.png +32244.png +37413.png +43727.png +25218.png +47363.png +18433.png +62797.png +49412.png +52738.png +38972.png +11907.png +16230.png +00503.png +43844.png +25427.png +60943.png +63680.png +15669.png +44295.png +51363.png +37282.png +49515.png +59389.png +11605.png +24084.png +20512.png +31495.png +40183.png +48358.png +21870.png +64422.png +04955.png +28653.png +18310.png +68160.png +11415.png +36218.png +24504.png +55118.png +34817.png +19447.png +46169.png +49463.png +42111.png +34275.png +09678.png +16254.png +12359.png +60620.png +33801.png +02571.png +14918.png +01131.png +60302.png +38984.png +21615.png +24126.png +16060.png +51176.png +01431.png +56903.png +43633.png +18488.png +14797.png +45099.png +42044.png +44885.png +07437.png +22888.png +68216.png +10870.png +60191.png +47853.png +51062.png +16433.png +61574.png +46307.png +58712.png +66251.png +18829.png +06798.png +13686.png +17442.png +21959.png +45939.png +11810.png +13667.png +41481.png +07643.png +20580.png +60762.png +20273.png +39625.png +39616.png +61463.png +16941.png +14926.png +07558.png +36522.png +46104.png +67446.png +23094.png +53351.png +38758.png +34749.png +62382.png +00244.png +34781.png +48253.png +24427.png +15607.png +52806.png +54214.png +03906.png +69516.png +44478.png +02656.png +23408.png +44068.png +19039.png +04092.png +04778.png +51456.png +61363.png +69845.png +37753.png +39528.png +25426.png +64772.png +20314.png +57322.png +04413.png +61652.png +13324.png +65243.png +39509.png +18700.png +31680.png +14892.png +03437.png +44605.png +14989.png +24266.png +15995.png +21823.png +61178.png +09795.png +19564.png +32664.png +49063.png +05701.png +18814.png +46721.png +57777.png +64263.png +59321.png +57688.png +24967.png +10737.png +26334.png +68768.png +03833.png +44870.png +13050.png +10477.png +65952.png +03705.png +29110.png +37269.png +42122.png +03897.png +09674.png +18824.png +14391.png +40340.png +68162.png +22228.png +26844.png +02547.png +66087.png +06987.png +36242.png +67229.png +44940.png +31838.png +22940.png +35132.png +25610.png +02876.png +43791.png +15569.png +07819.png +51986.png +47394.png +62124.png +47552.png +38234.png +62674.png +42413.png +44993.png +52342.png +44696.png +20576.png +09943.png +12518.png +23301.png +00667.png +35328.png +10120.png +53261.png +08225.png +23788.png +16580.png +38123.png +33608.png +44338.png +13841.png +42375.png +25360.png +13517.png +26464.png +58433.png +20075.png +56969.png +56138.png +09591.png +33602.png +16609.png +27486.png +63914.png +19122.png +08974.png +43177.png +25434.png +19454.png +08692.png +28752.png +65007.png +37124.png +35277.png +10376.png +14683.png +05911.png +67969.png +44771.png +69854.png +00349.png +68704.png +67597.png +42690.png +68655.png +10723.png +34336.png +59128.png +05421.png +42217.png +43377.png +67283.png +59188.png +08832.png +24027.png +54202.png +13703.png +58197.png +61365.png +48510.png +06366.png +63728.png +14374.png +69970.png +51830.png +33346.png +15565.png +63398.png +19369.png +45977.png +24490.png +34772.png +14967.png +27997.png +32864.png +65656.png +66456.png +68033.png +52404.png +19232.png +30814.png +05245.png +63567.png +14817.png +07226.png +27096.png +40036.png +06187.png +22376.png +01187.png +25986.png +15235.png +67907.png +28456.png +13811.png +19755.png +13212.png +42277.png +11473.png +23361.png +28601.png +53027.png +25707.png +21260.png +08689.png +16758.png +11760.png +13599.png +55249.png +22318.png +06848.png +43571.png +45077.png +29603.png +02500.png +09514.png +21668.png +39935.png +13129.png +51733.png +47346.png +28874.png +49490.png +06208.png +62096.png +30546.png +60940.png +29465.png +45051.png +35849.png +62317.png +55011.png +02582.png +37980.png +06871.png +47311.png +50631.png +29154.png +36534.png +58559.png +34919.png +66930.png +11681.png +51427.png +40969.png +04739.png +46906.png +60443.png +36184.png +05602.png +63428.png +21070.png +54078.png +08490.png +67165.png +58319.png +51833.png +37342.png +47069.png +21404.png +53102.png +06867.png +01259.png +16670.png +29708.png +42355.png +15003.png +65873.png +42097.png +56435.png +06618.png +33171.png +57899.png +57605.png +35662.png +57932.png +64153.png +39531.png +63326.png +64736.png +37427.png +32164.png +07678.png +23165.png +17222.png +06290.png +02418.png +21120.png +40282.png +42231.png +03758.png +51588.png +10161.png +55967.png +03137.png +59824.png +69935.png +37475.png +29004.png +01568.png +30114.png +66797.png +23453.png +65066.png +16501.png +14656.png +23615.png +32332.png +62471.png +24625.png +62480.png +37922.png +47558.png +62701.png +12433.png +14423.png +12978.png +35327.png +64586.png +13460.png +03196.png +63131.png +61018.png +53802.png +55915.png +19303.png +26434.png +67442.png +08202.png +22785.png +48172.png +12615.png +37171.png +14856.png +17119.png +39779.png +37819.png +67614.png +08481.png +32555.png +16536.png +25333.png +35228.png +62690.png +38138.png +48734.png +15588.png +20840.png +07762.png +16621.png +29152.png +46861.png +24227.png +39035.png +28890.png +52949.png +12290.png +39921.png +08109.png +14197.png +14672.png +57630.png +30403.png +56251.png +69741.png +50487.png +40428.png +41774.png +50137.png +51213.png +57242.png +36826.png +66886.png +31437.png +27785.png +18091.png +65740.png +59281.png +36692.png +55879.png +50634.png +09125.png +34079.png +55468.png +02802.png +67077.png +31492.png +15329.png +32147.png +42878.png +39253.png +29194.png +31990.png +15006.png +43715.png +49374.png +42492.png +00493.png +41564.png +48431.png +68829.png +05998.png +28905.png +00253.png +28014.png +59371.png +61275.png +35605.png +18272.png +67268.png +69795.png +33111.png +56515.png +50357.png +23838.png +19111.png +14382.png +48665.png +38467.png +30376.png +24766.png +27145.png +16079.png +31943.png +61795.png +41968.png +32413.png +18294.png +32557.png +52842.png +42748.png +11781.png +20994.png +49824.png +47038.png +67423.png +66316.png +48695.png +19090.png +63488.png +54784.png +55516.png +57910.png +69749.png +26653.png +24822.png +65414.png +57986.png +42883.png +65060.png +38844.png +30458.png +65541.png +41336.png +01241.png +62014.png +45052.png +29127.png +28131.png +46050.png +17911.png +33240.png +02114.png +25833.png +17350.png +02873.png +31239.png +46212.png +60475.png +37346.png +52337.png +09741.png +26658.png +30759.png +30264.png +49307.png +13155.png +06613.png +48408.png +25808.png +23481.png +37358.png +62559.png +39952.png +55813.png +21535.png +04723.png +21509.png +48091.png +17497.png +22480.png +50241.png +16076.png +66233.png +45131.png +60298.png +17421.png +50534.png +15949.png +39438.png +05143.png +11394.png +68448.png +45458.png +18393.png +47864.png +48577.png +32749.png +51818.png +65518.png +45658.png +29947.png +20432.png +32833.png +41855.png +38820.png +29469.png +06296.png +68111.png +22198.png +05254.png +38350.png +63036.png +36958.png +10210.png +48096.png +42494.png +48259.png +28202.png +02209.png +10087.png +54396.png +33260.png +66225.png +31085.png +66549.png +22185.png +56849.png +31101.png +19952.png +39680.png +46513.png +54279.png +02685.png +25077.png +37102.png +48124.png +04670.png +34411.png +29801.png +16390.png +08093.png +14061.png +15176.png +41769.png +30017.png +58741.png +14788.png +26282.png +26418.png +49038.png +35175.png +27973.png +41623.png +41285.png +58171.png +63535.png +50958.png +40950.png +60285.png +28398.png +57025.png +23823.png +63029.png +14135.png +69808.png +08326.png +65374.png +49803.png +59767.png +20676.png +28108.png +65331.png +01104.png +02392.png +67318.png +16177.png +44447.png +58909.png +56045.png +10110.png +61248.png +46893.png +15068.png +25241.png +46033.png +29785.png +58653.png +24252.png +39835.png +26538.png +16696.png +52884.png +25109.png +10990.png +23712.png +00477.png +35655.png +69660.png +36166.png +31444.png +25250.png +51434.png +43151.png +17234.png +01522.png +39702.png +14283.png +03541.png +41315.png +55607.png +22158.png +11656.png +40839.png +23015.png +17659.png +51880.png +41473.png +09754.png +18710.png +58779.png +48398.png +55354.png +10543.png +45075.png +61557.png +31390.png +55321.png +69423.png +12280.png +08217.png +61770.png +05185.png +54651.png +25398.png +35049.png +55172.png +59245.png +44558.png +43925.png +51606.png +61494.png +19411.png +27124.png +32728.png +56974.png +17897.png +45152.png +11181.png +07717.png +30512.png +00863.png +36058.png +20887.png +56852.png +54682.png +25326.png +22088.png +65915.png +24708.png +69001.png +42294.png +01865.png +07751.png +03151.png +09663.png +51872.png +60738.png +42949.png +18544.png +55640.png +02590.png +23344.png +58452.png +43274.png +47304.png +56777.png +00434.png +37330.png +46872.png +19367.png +60775.png +18238.png +34608.png +35618.png +58574.png +14964.png +26757.png +64948.png +32627.png +66538.png +33155.png +08468.png +24222.png +30282.png +04673.png +10173.png +15403.png +42365.png +02967.png +11785.png +07322.png +07895.png +21992.png +40965.png +01933.png +48805.png +20050.png +17748.png +28652.png +56470.png +06756.png +61670.png +50793.png +36159.png +19063.png +41220.png +16692.png +29135.png +66851.png +51206.png +31640.png +15614.png +46359.png +05975.png +12811.png +09650.png +38450.png +35069.png +51718.png +32744.png +04065.png +46425.png +36910.png +25621.png +04378.png +15946.png +24392.png +62911.png +21816.png +16117.png +03714.png +14957.png +16326.png +22092.png +21739.png +59566.png +33130.png +50370.png +14664.png +01287.png +63553.png +07029.png +23470.png +29761.png +07042.png +02369.png +48122.png +06253.png +62980.png +42999.png +31716.png +49384.png +37170.png +40690.png +21810.png +47550.png +58995.png +15136.png +60437.png +64050.png +50545.png +10846.png +48818.png +05233.png +02406.png +41179.png +01907.png +07335.png +16823.png +32210.png +32630.png +49133.png +48450.png +03161.png +35816.png +52625.png +36677.png +03800.png +23315.png +58571.png +41741.png +01415.png +16249.png +43353.png +58069.png +24379.png +51498.png +11825.png +66568.png +65900.png +27766.png +60364.png +40409.png +44400.png +07032.png +18932.png +67110.png +39930.png +43874.png +64824.png +26977.png +63678.png +25379.png +08781.png +15740.png +24878.png +16755.png +09512.png +61521.png +22588.png +24557.png +23778.png +12715.png +56391.png +23433.png +01410.png +57643.png +37875.png +19224.png +31824.png +13134.png +49305.png +57250.png +12990.png +06480.png +32600.png +04450.png +58926.png +11521.png +13837.png +11089.png +67261.png +29920.png +60158.png +54433.png +50683.png +62723.png +24693.png +37813.png +00125.png +59296.png +51179.png +55988.png +28971.png +28565.png +19608.png +07431.png +05750.png +26791.png +49572.png +14507.png +54526.png +10226.png +53567.png +15943.png +46611.png +37982.png +49495.png +37147.png +19160.png +04436.png +40833.png +07090.png +00940.png +38610.png +43930.png +10512.png +30852.png +63009.png +44932.png +68231.png +67381.png +56454.png +44788.png +19285.png +39091.png +14971.png +33381.png +21302.png +35455.png +18917.png +27846.png +26311.png +62994.png +55738.png +26163.png +03600.png +57440.png +65409.png +65166.png +29984.png +33285.png +43142.png +18484.png +38508.png +31976.png +50070.png +67217.png +26202.png +23077.png +06620.png +61757.png +42743.png +46293.png +41569.png +08753.png +03750.png +44648.png +53884.png +65747.png +02679.png +46455.png +01200.png +52352.png +44615.png +32463.png +40358.png +16285.png +42469.png +41906.png +29929.png +27664.png +67454.png +09771.png +43965.png +52026.png +64996.png +64146.png +04192.png +58107.png +02226.png +65614.png +02003.png +57010.png +40041.png +36120.png +64252.png +32070.png +62254.png +23215.png +28912.png +41065.png +50609.png +19948.png +31188.png +48832.png +48075.png +34161.png +63893.png +22291.png +37703.png +41583.png +50571.png +33056.png +10168.png +46691.png +07946.png +08995.png +34392.png +51372.png +21072.png +13911.png +27430.png +23239.png +16504.png +46857.png +69128.png +21861.png +13698.png +68931.png +53137.png +45538.png +59859.png +55491.png +38588.png +52042.png +35157.png +44307.png +35164.png +62349.png +04862.png +58938.png +38173.png +60922.png +25584.png +57616.png +16528.png +53045.png +02562.png +49591.png +36255.png +53584.png +30641.png +37510.png +42376.png +47780.png +26116.png +33367.png +41028.png +24317.png +55000.png +29114.png +69304.png +56330.png +25208.png +35378.png +60873.png +01972.png +34405.png +13023.png +26194.png +13213.png +56528.png +23072.png +56321.png +53583.png +21595.png +50046.png +35174.png +67086.png +09794.png +09576.png +44951.png +12699.png +05682.png +68954.png +08515.png +63960.png +19781.png +18250.png +20151.png +17039.png +58152.png +63192.png +49854.png +58085.png +03681.png +30687.png +32994.png +37704.png +56675.png +25902.png +38371.png +69508.png +36951.png +27836.png +58838.png +17055.png +13263.png +33356.png +00255.png +62490.png +36944.png +62036.png +36908.png +08987.png +66052.png +59184.png +39262.png +44989.png +15124.png +20787.png +40724.png +43000.png +28051.png +09445.png +51407.png +38862.png +67242.png +21178.png +65222.png +30505.png +32416.png +15679.png +48081.png +36459.png +24652.png +63740.png +42627.png +59666.png +30610.png +27548.png +67917.png +21366.png +16244.png +13147.png +20605.png +11892.png +32246.png +01635.png +21871.png +44119.png +20615.png +33180.png +57180.png +00784.png +16979.png +55706.png +63363.png +07221.png +31027.png +56509.png +59702.png +63637.png +65317.png +21866.png +46547.png +27268.png +24184.png +01676.png +13763.png +08679.png +20879.png +58453.png +11636.png +32454.png +32008.png +47362.png +38095.png +36622.png +35678.png +28040.png +27193.png +64497.png +28619.png +42678.png +21943.png +39233.png +00580.png +47319.png +13586.png +61717.png +40270.png +49205.png +31644.png +00433.png +40278.png +32058.png +68202.png +42257.png +31692.png +54725.png +15088.png +22773.png +46976.png +02912.png +23279.png +05498.png +50310.png +18607.png +44278.png +40725.png +59498.png +65174.png +01482.png +19774.png +04098.png +53556.png +51756.png +11217.png +12598.png +27084.png +56140.png +18968.png +49382.png +17171.png +25787.png +26574.png +34172.png +53147.png +49564.png +69449.png +40181.png +03503.png +58889.png +47232.png +33609.png +44090.png +40622.png +51652.png +56710.png +05358.png +65476.png +15064.png +62052.png +17042.png +21244.png +67738.png +34498.png +25547.png +40913.png +64620.png +55222.png +15048.png +20218.png +20026.png +07452.png +22573.png +23355.png +55629.png +58687.png +12564.png +04766.png +37256.png +31259.png +66423.png +18567.png +14543.png +39565.png +10185.png +38197.png +32751.png +43389.png +26932.png +65814.png +45108.png +59357.png +50954.png +64143.png +39215.png +04345.png +00952.png +47399.png +35715.png +14241.png +31233.png +29283.png +43408.png +56274.png +60172.png +25714.png +48693.png +25827.png +69043.png +16950.png +04552.png +20028.png +19018.png +32165.png +31953.png +17774.png +62054.png +37053.png +14005.png +16852.png +34321.png +37814.png +09399.png +33730.png +65100.png +34938.png +44906.png +38361.png +53986.png +38096.png +00585.png +48416.png +46141.png +51834.png +26184.png +22003.png +03205.png +64920.png +25085.png +65513.png +46901.png +64714.png +56680.png +05137.png +21515.png +22576.png +63696.png +56308.png +59142.png +46663.png +55812.png +16954.png +52257.png +45473.png +00309.png +41917.png +52602.png +13087.png +29306.png +45313.png +33445.png +49849.png +38002.png +03493.png +25225.png +52084.png +10063.png +41763.png +37097.png +36126.png +53953.png +54024.png +52871.png +12279.png +18316.png +17369.png +49670.png +11664.png +25310.png +50985.png +56557.png +36518.png +40566.png +54534.png +63260.png +26954.png +30357.png +22885.png +31045.png +39557.png +06095.png +43087.png +46423.png +41612.png +16469.png +03176.png +46811.png +26683.png +47795.png +63092.png +44649.png +07339.png +45982.png +20666.png +10636.png +46751.png +28993.png +24588.png +35978.png +36386.png +16784.png +68336.png +34014.png +18362.png +61187.png +52324.png +50568.png +20376.png +05385.png +51092.png +02705.png +14091.png +03804.png +22072.png +32434.png +14288.png +31938.png +06586.png +01459.png +43735.png +13194.png +44833.png +68316.png +26780.png +22194.png +61045.png +18624.png +60278.png +37431.png +05706.png +57603.png +02856.png +33353.png +28299.png +49398.png +08504.png +58194.png +33528.png +22356.png +58223.png +47134.png +29309.png +55890.png +03048.png +19231.png +25465.png +27957.png +46810.png +01236.png +50558.png +43809.png +10720.png +00593.png +03022.png +68941.png +43481.png +35416.png +13930.png +54053.png +29830.png +02722.png +66863.png +44017.png +31168.png +45671.png +69510.png +60361.png +03854.png +05260.png +55886.png +23879.png +19863.png +59398.png +03882.png +06608.png +45988.png +54384.png +15217.png +50567.png +53636.png +01984.png +13947.png +59848.png +32437.png +24683.png +30902.png +11136.png +26917.png +35237.png +44470.png +57668.png +60710.png +66675.png +12955.png +55502.png +64064.png +21590.png +29780.png +07066.png +60752.png +18366.png +01810.png +38028.png +35955.png +56243.png +02941.png +60739.png +06979.png +35996.png +15626.png +56429.png +08711.png +12972.png +18384.png +05518.png +12917.png +68396.png +00855.png +64514.png +68118.png +04909.png +08963.png +67719.png +58592.png +58528.png +49323.png +69923.png +12195.png +32860.png +04755.png +15177.png +65033.png +65665.png +32004.png +37010.png +15469.png +26211.png +53056.png +37985.png +22838.png +55883.png +43280.png +54599.png +64721.png +04235.png +07786.png +59488.png +00081.png +46964.png +31097.png +24140.png +37883.png +19703.png +08292.png +69477.png +37562.png +04060.png +69317.png +46120.png +03749.png +27038.png +16668.png +10785.png +25470.png +64737.png +18194.png +22950.png +42059.png +43533.png +37736.png +04546.png +65509.png +23683.png +68817.png +22420.png +14115.png +64909.png +11237.png +52041.png +20119.png +24958.png +68182.png +53151.png +43702.png +12024.png +41234.png +32675.png +61007.png +69265.png +55035.png +01578.png +49239.png +40848.png +38229.png +24286.png +18577.png +65526.png +04305.png +02448.png +32427.png +21115.png +46302.png +20387.png +15407.png +18855.png +30847.png +55095.png +48335.png +02700.png +03634.png +09285.png +38713.png +53330.png +41632.png +61669.png +28360.png +51288.png +03587.png +23443.png +40274.png +02106.png +29060.png +23428.png +56211.png +35008.png +28349.png +17856.png +67383.png +66422.png +51134.png +55113.png +08106.png +30112.png +16448.png +56823.png +04008.png +21901.png +66703.png +11542.png +61456.png +40586.png +53923.png +25825.png +62459.png +42299.png +11723.png +13602.png +24114.png +50662.png +45159.png +36148.png +48749.png +03014.png +54677.png +21770.png +22830.png +24763.png +02091.png +24820.png +05869.png +28444.png +06540.png +14010.png +57798.png +49633.png +08416.png +41479.png +16293.png +66791.png +40595.png +13842.png +19442.png +48271.png +48254.png +68553.png +05988.png +22955.png +20183.png +06754.png +11214.png +35383.png +07816.png +50161.png +17240.png +64610.png +04086.png +64988.png +10328.png +40679.png +30763.png +24891.png +57195.png +49662.png +10755.png +47861.png +18391.png +44866.png +43892.png +51785.png +52582.png +01622.png +63132.png +19990.png +43625.png +09074.png +62760.png +23293.png +29470.png +26257.png +34054.png +48433.png +29122.png +44283.png +01893.png +49613.png +33011.png +25997.png +07108.png +14128.png +13691.png +11863.png +51698.png +66652.png +35401.png +12111.png +34703.png +22979.png +30225.png +29353.png +63738.png +40177.png +35249.png +31482.png +36688.png +30222.png +49262.png +44997.png +50362.png +22057.png +51207.png +26667.png +51554.png +60227.png +18319.png +39706.png +18427.png +10055.png +11098.png +22080.png +41267.png +22394.png +33976.png +54179.png +07992.png +22469.png +63707.png +62439.png +14279.png +65922.png +48761.png +56646.png +54818.png +43194.png +09361.png +47390.png +26662.png +16489.png +05203.png +25166.png +09278.png +10615.png +65954.png +43284.png +39316.png +52161.png +69169.png +23412.png +20150.png +07034.png +64367.png +20125.png +68567.png +42692.png +40645.png +01646.png +41314.png +17965.png +23855.png +42459.png +01498.png +15804.png +57711.png +47425.png +28901.png +67863.png +41923.png +43375.png +50911.png +17550.png +52946.png +46238.png +07851.png +54423.png +55824.png +15230.png +64599.png +67460.png +36373.png +25213.png +59108.png +16707.png +31075.png +44727.png +45101.png +44296.png +21868.png +38977.png +47106.png +00762.png +64203.png +48329.png +30216.png +67520.png +50181.png +64886.png +19262.png +55105.png +47202.png +69402.png +30011.png +39799.png +40182.png +04274.png +14389.png +26672.png +08713.png +66914.png +15363.png +62091.png +30140.png +52500.png +33009.png +37341.png +07148.png +61311.png +02429.png +57866.png +34568.png +41808.png +19128.png +08615.png +27442.png +45968.png +16848.png +34681.png +52736.png +63825.png +56980.png +48100.png +27918.png +08792.png +17250.png +49480.png +67667.png +43488.png +11477.png +00332.png +07670.png +29258.png +69654.png +54814.png +40432.png +10741.png +49884.png +03693.png +14342.png +39457.png +10151.png +26490.png +43705.png +39791.png +17191.png +12893.png +37887.png +36950.png +38442.png +57764.png +16853.png +18425.png +26172.png +58183.png +07543.png +02490.png +30285.png +15374.png +38272.png +29632.png +17332.png +22033.png +66020.png +62321.png +10756.png +44650.png +21730.png +45070.png +08400.png +04053.png +56864.png +23317.png +38009.png +02243.png +00695.png +46075.png +08546.png +65995.png +54489.png +52672.png +13865.png +54855.png +37785.png +60185.png +04554.png +25503.png +35621.png +57674.png +22414.png +59162.png +57228.png +52980.png +38706.png +36488.png +25652.png +61550.png +10415.png +01763.png +15411.png +20766.png +36340.png +33557.png +10601.png +69939.png +45308.png +13928.png +38297.png +22260.png +17134.png +19215.png +68119.png +48562.png +05312.png +22929.png +04444.png +39899.png +51844.png +19593.png +69303.png +34850.png +62580.png +25012.png +34398.png +01292.png +23722.png +29585.png +36071.png +16027.png +34518.png +28075.png +29256.png +31129.png +57652.png +18289.png +65079.png +20465.png +17838.png +66179.png +00576.png +09944.png +16812.png +01084.png +52390.png +66204.png +20982.png +35342.png +08618.png +68523.png +24564.png +60798.png +55828.png +59476.png +60405.png +39553.png +30927.png +16983.png +58962.png +63755.png +46899.png +42313.png +25038.png +19766.png +01461.png +31096.png +22538.png +11692.png +62821.png +68384.png +13887.png +34082.png +21610.png +36458.png +23513.png +30323.png +60691.png +32787.png +48628.png +11721.png +38499.png +30369.png +58472.png +18089.png +58701.png +21854.png +59573.png +15991.png +02094.png +53652.png +64458.png +29835.png +24532.png +11965.png +39081.png +54961.png +30976.png +64797.png +19581.png +15736.png +08415.png +03221.png +37259.png +51090.png +01697.png +68544.png +27505.png +54926.png +58392.png +56427.png +06953.png +13876.png +62865.png +40880.png +16824.png +33182.png +65586.png +03012.png +15542.png +26808.png +22546.png +02493.png +28197.png +04332.png +57689.png +51063.png +13817.png +50858.png +35966.png +42657.png +29467.png +28533.png +29250.png +65141.png +45637.png +48363.png +09997.png +24669.png +21941.png +42636.png +03864.png +17010.png +51703.png +62806.png +59736.png +02179.png +23425.png +20408.png +13021.png +29727.png +59548.png +64742.png +52577.png +51231.png +60491.png +25695.png +30973.png +31836.png +38060.png +63784.png +13448.png +52469.png +11337.png +27816.png +43554.png +42716.png +38976.png +63467.png +62075.png +69414.png +31667.png +47067.png +21094.png +68350.png +31263.png +68721.png +16340.png +53694.png +55980.png +21377.png +15927.png +63493.png +67697.png +58703.png +69424.png +52397.png +29270.png +29875.png +03393.png +20186.png +22218.png +31112.png +68988.png +09626.png +62398.png +05432.png +08962.png +68669.png +28647.png +10839.png +07284.png +17447.png +21624.png +56938.png +04212.png +03903.png +46701.png +63888.png +64854.png +19049.png +36710.png +05456.png +25566.png +43432.png +13583.png +30359.png +59029.png +48334.png +36750.png +09375.png +62678.png +29978.png +62455.png +40962.png +18169.png +63083.png +13415.png +24154.png +51533.png +34036.png +50451.png +17313.png +29682.png +62869.png +63858.png +02268.png +53107.png +16556.png +00365.png +56827.png +31604.png +24596.png +06171.png +42670.png +64777.png +64084.png +43085.png +37084.png +50521.png +65956.png +23318.png +47562.png +00256.png +62038.png +63065.png +16980.png +24784.png +13848.png +53273.png +54227.png +57785.png +09272.png +25219.png +34426.png +20346.png +44791.png +65593.png +67598.png +64956.png +41790.png +04400.png +38462.png +46099.png +52271.png +09689.png +41004.png +40136.png +36147.png +06466.png +21648.png +00326.png +03259.png +06008.png +07185.png +22937.png +58499.png +06052.png +22730.png +61081.png +02144.png +57030.png +50386.png +22990.png +51705.png +12753.png +19756.png +03458.png +59267.png +04821.png +66175.png +54689.png +58625.png +37608.png +67481.png +57927.png +54039.png +37449.png +30291.png +36991.png +52069.png +54300.png +68755.png +44387.png +17408.png +45668.png +47259.png +11839.png +04646.png +20367.png +55571.png +62802.png +20849.png +39946.png +11358.png +55589.png +55119.png +64693.png +30435.png +30549.png +05396.png +07277.png +54853.png +15453.png +52990.png +67351.png +08257.png +26419.png +30334.png +30344.png +17894.png +63922.png +52883.png +31810.png +50886.png +26566.png +38695.png +26229.png +68171.png +02727.png +54472.png +15775.png +17367.png +39293.png +67688.png +63559.png +42919.png +59299.png +62951.png +61421.png +29136.png +48978.png +63422.png +21266.png +20719.png +01207.png +47980.png +19546.png +03788.png +13611.png +28564.png +37554.png +08258.png +68741.png +36258.png +33044.png +04744.png +28841.png +32766.png +48220.png +02863.png +64030.png +32793.png +39103.png +38662.png +21721.png +45860.png +20927.png +22626.png +41407.png +06206.png +46106.png +46085.png +46129.png +17476.png +13006.png +67911.png +13444.png +46373.png +14544.png +05714.png +30253.png +20405.png +38926.png +10642.png +63844.png +35004.png +04550.png +02486.png +20627.png +62873.png +43243.png +26328.png +68717.png +39424.png +29952.png +39157.png +59992.png +25796.png +27345.png +62728.png +15332.png +58548.png +31996.png +36113.png +17062.png +36482.png +14408.png +56286.png +48808.png +47116.png +34083.png +10096.png +01799.png +26688.png +42178.png +18815.png +27186.png +30889.png +23496.png +64023.png +09704.png +55498.png +07007.png +44797.png +12356.png +37650.png +36820.png +17030.png +66827.png +65294.png +25304.png +59329.png +62647.png +60567.png +08144.png +59377.png +21043.png +60647.png +14260.png +24587.png +31344.png +60865.png +66674.png +59066.png +65062.png +48637.png +32944.png +18745.png +34873.png +31874.png +66973.png +31355.png +03316.png +02953.png +38669.png +26080.png +34638.png +49950.png +27185.png +29471.png +33691.png +12941.png +03948.png +25195.png +66972.png +36150.png +18016.png +37476.png +57073.png +26051.png +29229.png +46439.png +33728.png +19509.png +39040.png +45405.png +54385.png +18626.png +41324.png +09524.png +12215.png +18133.png +37682.png +52168.png +18974.png +12468.png +34180.png +32373.png +48723.png +40133.png +55929.png +59594.png +16406.png +09089.png +68847.png +65604.png +15910.png +39820.png +33360.png +17910.png +27621.png +34719.png +10469.png +64003.png +42428.png +30563.png +54795.png +01352.png +15655.png +26628.png +35082.png +23158.png +43604.png +01689.png +66762.png +32699.png +34285.png +13082.png +23750.png +36016.png +16549.png +06209.png +58279.png +62138.png +09611.png +54807.png +26947.png +00206.png +65582.png +25826.png +02099.png +65720.png +61028.png +14859.png +13768.png +53949.png +06459.png +00119.png +29820.png +07133.png +17256.png +42320.png +18955.png +53959.png +12832.png +01313.png +06497.png +27376.png +66227.png +59211.png +59259.png +20813.png +27599.png +28330.png +14035.png +17529.png +33923.png +28834.png +36132.png +24002.png +10317.png +36978.png +07988.png +00116.png +55519.png +40335.png +10719.png +18441.png +63336.png +50472.png +44646.png +24128.png +24559.png +18116.png +05450.png +43394.png +24046.png +53930.png +63797.png +18106.png +21505.png +10352.png +38860.png +30703.png +20370.png +25095.png +14412.png +58484.png +06116.png +15698.png +64228.png +27087.png +48436.png +21087.png +60511.png +62474.png +64914.png +44388.png +55973.png +01357.png +40627.png +53989.png +61387.png +03028.png +56796.png +62925.png +18836.png +27862.png +30193.png +57102.png +24586.png +33351.png +18901.png +07494.png +46450.png +67127.png +55482.png +24833.png +04573.png +02280.png +00925.png +19410.png +44201.png +59018.png +19268.png +25634.png +46921.png +63598.png +15674.png +51153.png +07010.png +27044.png +37073.png +68982.png +29824.png +15398.png +32445.png +18237.png +67466.png +40784.png +27929.png +36913.png +31044.png +27319.png +23806.png +24095.png +10622.png +03834.png +47568.png +64279.png +15876.png +36241.png +05391.png +34319.png +15812.png +55708.png +41523.png +44685.png +51795.png +47468.png +06179.png +38288.png +64313.png +35179.png +13528.png +67352.png +18818.png +38696.png +22549.png +29383.png +06420.png +40694.png +26546.png +31798.png +63791.png +66258.png +13933.png +44645.png +37701.png +40704.png +27154.png +59258.png +34346.png +23590.png +40376.png +65288.png +51342.png +41224.png +16423.png +60608.png +17627.png +29285.png +39147.png +14653.png +24282.png +62248.png +62400.png +37211.png +48518.png +62818.png +52273.png +08260.png +36095.png +22543.png +56097.png +39902.png +06525.png +43288.png +37637.png +54939.png +17670.png +17003.png +04506.png +43676.png +05818.png +42062.png +24709.png +50680.png +30363.png +58456.png +19057.png +46482.png +27747.png +09345.png +69266.png +58657.png +40326.png +20997.png +61220.png +32505.png +62113.png +66102.png +66488.png +28927.png +38026.png +46655.png +42037.png +60436.png +11476.png +55898.png +29925.png +02684.png +02533.png +27108.png +33852.png +65977.png +54381.png +12300.png +31962.png +05482.png +32305.png +45390.png +00774.png +20656.png +22847.png +14590.png +39100.png +03640.png +56989.png +38265.png +53785.png +00344.png +07238.png +47343.png +61552.png +32644.png +40514.png +44665.png +60562.png +00649.png +42389.png +50486.png +36072.png +11932.png +23283.png +03975.png +18662.png +21849.png +34199.png +34188.png +14121.png +13714.png +02212.png +15292.png +35739.png +38483.png +31535.png +50519.png +55184.png +15161.png +52171.png +20428.png +34158.png +13860.png +31533.png +45913.png +56677.png +29870.png +21118.png +21417.png +56514.png +13331.png +52633.png +36777.png +16210.png +48430.png +52818.png +60982.png +25482.png +64240.png +66716.png +35736.png +62549.png +44138.png +23415.png +34237.png +24014.png +20062.png +50199.png +62625.png +56855.png +56359.png +49930.png +20447.png +20162.png +07565.png +05192.png +56026.png +43741.png +08403.png +61334.png +60888.png +22646.png +01387.png +22946.png +29713.png +31899.png +29289.png +17938.png +13721.png +51747.png +66001.png +27580.png +55616.png +18838.png +12744.png +01072.png +49920.png +00812.png +16635.png +00831.png +59135.png +45205.png +48159.png +24646.png +56906.png +14261.png +28477.png +57743.png +38637.png +29858.png +51940.png +68663.png +23759.png +43462.png +69120.png +14841.png +05511.png +47517.png +11862.png +23887.png +19473.png +34070.png +47622.png +59467.png +09679.png +30001.png +52080.png +63489.png +34105.png +59235.png +56043.png +31764.png +38344.png +13506.png +34711.png +40598.png +28115.png +19994.png +51752.png +50042.png +50446.png +23758.png +42238.png +23049.png +44452.png +19883.png +12002.png +50754.png +60220.png +27237.png +09732.png +32976.png +48272.png +69309.png +35254.png +64027.png +22144.png +49821.png +23834.png +64869.png +07213.png +59452.png +18065.png +24062.png +06911.png +01355.png +11252.png +33566.png +48691.png +25907.png +18584.png +21062.png +34037.png +35840.png +21714.png +45957.png +59665.png +07917.png +32795.png +13002.png +59206.png +64639.png +66243.png +64521.png +64789.png +37023.png +57862.png +41679.png +61845.png +63891.png +04513.png +21898.png +13306.png +51774.png +05461.png +06816.png +01562.png +10929.png +65423.png +66667.png +45490.png +23502.png +48221.png +11809.png +65153.png +00843.png +06978.png +42119.png +13589.png +04039.png +08549.png +14131.png +07473.png +22284.png +48231.png +40246.png +69383.png +57773.png +29539.png +25175.png +11947.png +14618.png +35158.png +37579.png +49223.png +53366.png +31843.png +33168.png +21524.png +20661.png +53048.png +69821.png +22842.png +53237.png +39672.png +16641.png +56496.png +26099.png +52832.png +53252.png +42181.png +51118.png +13124.png +02444.png +46408.png +18444.png +08450.png +14722.png +37705.png +12400.png +05965.png +50632.png +42530.png +60113.png +40933.png +18753.png +09772.png +65275.png +18448.png +23113.png +01783.png +68070.png +32800.png +24843.png +29737.png +19234.png +07022.png +62767.png +34153.png +06088.png +15100.png +27060.png +50664.png +37934.png +44029.png +49256.png +41731.png +07134.png +32409.png +33108.png +34974.png +36993.png +53938.png +16094.png +40236.png +02050.png +01634.png +04314.png +06134.png +19868.png +56479.png +55682.png +08263.png +03054.png +30951.png +14340.png +45455.png +08449.png +57117.png +04713.png +60419.png +14991.png +57165.png +54084.png +39575.png +13008.png +54714.png +01775.png +46939.png +53105.png +31055.png +52515.png +38362.png +47555.png +56743.png +25001.png +67861.png +47908.png +14166.png +40162.png +06081.png +62841.png +23147.png +17890.png +21855.png +04140.png +53429.png +54403.png +02033.png +00694.png +17571.png +65971.png +49765.png +12435.png +35610.png +65573.png +42671.png +21719.png +17299.png +08922.png +26280.png +66335.png +47629.png +28871.png +63241.png +48834.png +68563.png +68529.png +64937.png +01606.png +11349.png +51929.png +01142.png +47582.png +09820.png +58855.png +37548.png +66759.png +46676.png +62597.png +18551.png +68609.png +55776.png +50424.png +15773.png +00156.png +05326.png +58434.png +48775.png +20138.png +48461.png +20870.png +69710.png +46692.png +47745.png +39560.png +38607.png +34268.png +41778.png +02193.png +32368.png +43581.png +48276.png +08007.png +51668.png +09647.png +47433.png +07787.png +42633.png +20764.png +36197.png +44683.png +23197.png +18931.png +14491.png +61325.png +53400.png +11778.png +68579.png +63681.png +13624.png +43728.png +47091.png +29844.png +00478.png +25609.png +58689.png +21342.png +29893.png +67879.png +42860.png +39845.png +34108.png +68807.png +18977.png +20309.png +05577.png +19573.png +31527.png +63190.png +41496.png +31339.png +15670.png +02411.png +03128.png +56420.png +27364.png +55511.png +46316.png +32476.png +12531.png +41372.png +53209.png +06026.png +33258.png +54374.png +25896.png +62486.png +47830.png +03741.png +06833.png +27025.png +01741.png +25552.png +54484.png +09244.png +47778.png +68413.png +39980.png +36296.png +24936.png +39216.png +57217.png +18244.png +07704.png +63006.png +15391.png +65480.png +19919.png +29181.png +09757.png +37497.png +50655.png +06718.png +54020.png +31807.png +10740.png +55147.png +10443.png +09769.png +27053.png +62072.png +64138.png +67848.png +28803.png +65112.png +45026.png +69107.png +02436.png +64486.png +25209.png +67368.png +04333.png +64508.png +03356.png +22164.png +14206.png +38947.png +48831.png +57901.png +50592.png +34606.png +07845.png +67763.png +69074.png +48830.png +65914.png +60725.png +27138.png +59755.png +62201.png +06401.png +16915.png +09181.png +42629.png +27300.png +17881.png +13395.png +45958.png +19466.png +07232.png +30901.png +52660.png +36981.png +42523.png +41343.png +31286.png +65093.png +27028.png +29474.png +13587.png +69985.png +26256.png +15576.png +55695.png +00323.png +56753.png +24430.png +59338.png +34932.png +43077.png +25314.png +19839.png +03225.png +65068.png +54127.png +64669.png +39584.png +31783.png +30598.png +15426.png +63753.png +65821.png +17076.png +53510.png +55725.png +59406.png +25604.png +43507.png +35712.png +49177.png +14652.png +03568.png +43206.png +13723.png +69342.png +07027.png +09257.png +53533.png +61346.png +01956.png +22622.png +13447.png +27627.png +49090.png +14678.png +14529.png +45648.png +51329.png +66389.png +00535.png +19552.png +31043.png +20599.png +40396.png +24081.png +61867.png +61899.png +11990.png +52343.png +49268.png +55866.png +69898.png +56333.png +41701.png +67918.png +29499.png +35186.png +50257.png +40974.png +09636.png +28427.png +66357.png +01704.png +54986.png +26796.png +17243.png +37963.png +17428.png +50705.png +16531.png +34148.png +51353.png +19572.png +44556.png +41662.png +37960.png +13499.png +43831.png +23654.png +08616.png +09802.png +37987.png +53311.png +20357.png +29201.png +04982.png +26608.png +55362.png +56449.png +69789.png +38791.png +43763.png +09410.png +19873.png +44483.png +28681.png +58082.png +03302.png +43929.png +53611.png +46648.png +42067.png +51184.png +09114.png +56036.png +48103.png +23120.png +67251.png +68066.png +64114.png +66058.png +63852.png +66678.png +01966.png +63571.png +10453.png +24265.png +30561.png +34941.png +55991.png +69969.png +34747.png +12211.png +26869.png +56162.png +06228.png +57340.png +60321.png +59758.png +15958.png +21476.png +47561.png +24737.png +04951.png +03578.png +68744.png +19168.png +45171.png +59428.png +44436.png +01834.png +05758.png +49509.png +19419.png +00106.png +44366.png +08544.png +37304.png +55449.png +66405.png +31772.png +09424.png +57881.png +23799.png +30908.png +01132.png +02731.png +37065.png +23255.png +01968.png +26851.png +04468.png +21947.png +43213.png +42909.png +40511.png +07347.png +38104.png +67956.png +48064.png +62055.png +54508.png +43801.png +68999.png +00325.png +28416.png +67870.png +37604.png +05113.png +16787.png +09693.png +01986.png +05497.png +08714.png +57319.png +49152.png +26865.png +42645.png +18944.png +04748.png +30039.png +02874.png +56841.png +41204.png +17137.png +15621.png +51542.png +48945.png +52996.png +55167.png +49897.png +32923.png +44674.png +13639.png +63540.png +07210.png +56116.png +32608.png +54554.png +39470.png +61741.png +54447.png +23859.png +21808.png +62434.png +17482.png +54290.png +56007.png +47471.png +13210.png +23097.png +24814.png +16876.png +08505.png +69030.png +52529.png +69534.png +50233.png +50051.png +35364.png +04347.png +06925.png +00331.png +60291.png +64346.png +40393.png +11498.png +57534.png +03618.png +55245.png +62768.png +61666.png +41920.png +64319.png +56385.png +56650.png +10250.png +35934.png +53549.png +11936.png +27187.png +11799.png +48586.png +65412.png +12524.png +56257.png +17528.png +00362.png +42126.png +21695.png +37011.png +08576.png +04218.png +05819.png +60856.png +19982.png +57911.png +07884.png +34123.png +00564.png +55842.png +53803.png +36969.png +65734.png +52731.png +37405.png +46226.png +50517.png +43229.png +08116.png +62144.png +30199.png +59469.png +69926.png +16840.png +23545.png +33110.png +01964.png +67253.png +46892.png +61804.png +49147.png +55959.png +61053.png +34677.png +10501.png +44093.png +56124.png +59582.png +06302.png +13958.png +10488.png +65989.png +24197.png +23348.png +67021.png +35795.png +66190.png +38873.png +02592.png +38551.png +09557.png +60003.png +62684.png +45740.png +60653.png +59251.png +68666.png +40483.png +33782.png +02348.png +15533.png +50100.png +24993.png +43253.png +20890.png +10054.png +66053.png +61750.png +69978.png +35066.png +50594.png +14710.png +00385.png +11078.png +17123.png +39287.png +55179.png +65755.png +31159.png +18547.png +61668.png +40016.png +50802.png +27465.png +60931.png +33835.png +16747.png +47432.png +53614.png +40131.png +13559.png +47755.png +36986.png +14914.png +06672.png +53088.png +54257.png +41918.png +55673.png +06281.png +30121.png +21485.png +09417.png +55565.png +64468.png +02356.png +00751.png +01390.png +24068.png +39029.png +38083.png +06658.png +46538.png +41221.png +18284.png +11583.png +50450.png +44245.png +36270.png +21439.png +18630.png +43320.png +60071.png +41447.png +08107.png +23025.png +49974.png +26463.png +39941.png +07469.png +32286.png +14439.png +65015.png +33188.png +47003.png +68570.png +42234.png +30040.png +47997.png +24752.png +01746.png +07172.png +44515.png +52329.png +53227.png +03548.png +60825.png +45946.png +42509.png +16850.png +16429.png +25058.png +42853.png +05473.png +28975.png +35523.png +68506.png +66019.png +55399.png +47793.png +17484.png +24932.png +38971.png +63070.png +30783.png +47078.png +18024.png +66651.png +13293.png +19047.png +14087.png +18219.png +40492.png +17354.png +38821.png +50185.png +16519.png +22760.png +64434.png +30481.png +02043.png +08004.png +23869.png +30836.png +67323.png +08090.png +18299.png +13179.png +07829.png +15372.png +11495.png +18578.png +03858.png +23557.png +39478.png +23497.png +53084.png +44091.png +10380.png +12010.png +12614.png +53078.png +64045.png +36026.png +64006.png +11589.png +13406.png +19360.png +45179.png +49043.png +01546.png +40423.png +06781.png +35676.png +33559.png +34647.png +05400.png +04745.png +22409.png +06149.png +52873.png +29887.png +42113.png +38242.png +47167.png +18023.png +09080.png +30769.png +43803.png +58628.png +01252.png +31656.png +42732.png +27778.png +44345.png +30800.png +06096.png +14792.png +51899.png +00548.png +28210.png +66550.png +08346.png +45174.png +49153.png +09315.png +36094.png +57956.png +32044.png +04207.png +19644.png +67637.png +48369.png +36400.png +61735.png +50501.png +46454.png +21111.png +02819.png +08717.png +66318.png +17563.png +18081.png +13941.png +16648.png +21393.png +13508.png +53317.png +34596.png +30401.png +66536.png +56253.png +13931.png +52815.png +27979.png +44769.png +02769.png +56745.png +53218.png +31413.png +21551.png +60961.png +42827.png +11010.png +27674.png +39889.png +40865.png +13813.png +35811.png +25828.png +26034.png +61874.png +21210.png +57324.png +00464.png +61440.png +37625.png +46092.png +36029.png +06665.png +11189.png +44935.png +27877.png +37273.png +06473.png +40662.png +36277.png +16694.png +09846.png +00369.png +20146.png +12244.png +00316.png +24840.png +64716.png +57212.png +45367.png +22263.png +43124.png +12453.png +55360.png +64889.png +00097.png +60448.png +16363.png +14617.png +54930.png +29142.png +49702.png +45217.png +28566.png +23422.png +28861.png +18722.png +25981.png +14888.png +23278.png +24707.png +03585.png +57089.png +64390.png +39495.png +43061.png +36747.png +56307.png +09179.png +50408.png +13089.png +43520.png +35697.png +11680.png +12248.png +56193.png +43848.png +28068.png +09168.png +49651.png +50247.png +27082.png +65115.png +22406.png +33589.png +49685.png +13527.png +18886.png +55298.png +09091.png +18715.png +04411.png +67426.png +03910.png +44768.png +13999.png +08313.png +41795.png +64663.png +00713.png +08582.png +59584.png +20713.png +32214.png +26783.png +04432.png +58487.png +45417.png +19164.png +15348.png +54173.png +28015.png +44049.png +23921.png +35638.png +30849.png +47919.png +55543.png +66782.png +27487.png +69836.png +51341.png +53872.png +60517.png +05865.png +33298.png +48560.png +03142.png +28586.png +20457.png +35597.png +60409.png +31219.png +01266.png +69400.png +00953.png +14095.png +15294.png +03720.png +64876.png +62193.png +07526.png +65902.png +38094.png +56300.png +54450.png +29372.png +55246.png +46014.png +39404.png +36839.png +38625.png +22511.png +38870.png +56048.png +66708.png +48919.png +55954.png +24818.png +05574.png +19985.png +06831.png +11717.png +03285.png +62799.png +69306.png +03340.png +17358.png +46836.png +26031.png +09083.png +32251.png +58371.png +26333.png +63884.png +21984.png +18212.png +27504.png +32564.png +12025.png +41142.png +23690.png +24827.png +65383.png +51276.png +12332.png +58913.png +02426.png +34066.png +52278.png +51679.png +10115.png +41549.png +06537.png +13727.png +21281.png +45129.png +55662.png +16129.png +39742.png +09434.png +29017.png +26408.png +11328.png +00317.png +28054.png +68476.png +64047.png +30721.png +64463.png +11120.png +54109.png +57607.png +33970.png +19211.png +28168.png +32061.png +23634.png +59969.png +05672.png +03861.png +41187.png +46365.png +15336.png +43624.png +45001.png +31065.png +06229.png +31468.png +54461.png +32260.png +45670.png +61831.png +69053.png +25469.png +65157.png +47308.png +59099.png +19146.png +21316.png +64433.png +19902.png +49044.png +34917.png +13064.png +67548.png +38580.png +01479.png +63068.png +03988.png +43286.png +33021.png +14441.png +11480.png +53064.png +61492.png +04892.png +27000.png +52903.png +32590.png +66722.png +16731.png +07696.png +01683.png +62809.png +69291.png +51901.png +17887.png +19320.png +51241.png +05367.png +23543.png +55522.png +36115.png +13302.png +13176.png +56408.png +02781.png +29605.png +39934.png +51151.png +54322.png +03964.png +17452.png +09848.png +01584.png +15686.png +66374.png +22816.png +42579.png +25233.png +31932.png +56261.png +32382.png +58361.png +65037.png +06740.png +18975.png +68716.png +27547.png +68780.png +59790.png +13184.png +50302.png +25121.png +65941.png +63762.png +27289.png +65619.png +32745.png +60606.png +34551.png +49951.png +31418.png +24090.png +56358.png +47445.png +55026.png +42622.png +36651.png +23579.png +11044.png +28810.png +37717.png +42849.png +67468.png +60114.png +63160.png +48044.png +01116.png +65728.png +53692.png +29279.png +68500.png +19733.png +11385.png +64760.png +41628.png +22881.png +11544.png +67091.png +31630.png +46582.png +55426.png +30499.png +69382.png +19514.png +47526.png +23144.png +04165.png +09311.png +31235.png +68333.png +41162.png +40529.png +64612.png +03956.png +47665.png +68811.png +55655.png +58750.png +49604.png +53382.png +56595.png +46256.png +54780.png +64362.png +16472.png +25837.png +15654.png +45038.png +64924.png +28449.png +05069.png +66193.png +02024.png +62097.png +44455.png +60502.png +60202.png +53278.png +42196.png +40946.png +47328.png +63292.png +12223.png +46801.png +38940.png +39193.png +41485.png +57669.png +59691.png +15598.png +19229.png +09829.png +69436.png +36769.png +63640.png +23196.png +50605.png +25242.png +26348.png +51321.png +64140.png +34318.png +16342.png +41723.png +15039.png +27281.png +59847.png +56988.png +65315.png +38896.png +51445.png +12336.png +23071.png +41704.png +31919.png +61853.png +40028.png +12120.png +25303.png +51429.png +67704.png +32726.png +04173.png +03282.png +15884.png +14290.png +53965.png +48643.png +13547.png +13534.png +58929.png +38217.png +62650.png +42088.png +06958.png +59317.png +63799.png +40481.png +69728.png +30872.png +43471.png +25294.png +47454.png +68283.png +61136.png +21218.png +38040.png +09335.png +33217.png +67353.png +20822.png +06514.png +62498.png +20907.png +36814.png +37648.png +13443.png +39392.png +30969.png +31290.png +00750.png +20641.png +52932.png +34499.png +54459.png +63358.png +63413.png +13769.png +57441.png +43693.png +05140.png +39615.png +55907.png +58759.png +44324.png +30696.png +10722.png +26072.png +51417.png +59991.png +05659.png +20882.png +41413.png +01967.png +33693.png +13109.png +48348.png +54331.png +05703.png +28940.png +28024.png +45096.png +32941.png +02990.png +35209.png +58494.png +53975.png +24780.png +68756.png +42886.png +14191.png +30345.png +30153.png +27593.png +40788.png +36921.png +47796.png +44127.png +52909.png +33300.png +15806.png +57930.png +39938.png +28760.png +36657.png +21550.png +63354.png +42713.png +40984.png +30791.png +07126.png +30392.png +02897.png +07791.png +11822.png +61391.png +28221.png +07142.png +00596.png +62721.png +57654.png +48069.png +39094.png +15709.png +52233.png +02092.png +00075.png +53750.png +27780.png +38000.png +15154.png +42310.png +41748.png +09169.png +02391.png +18470.png +55989.png +12675.png +47720.png +21754.png +23128.png +32493.png +12331.png +46228.png +17889.png +61665.png +10662.png +63594.png +30383.png +60803.png +22180.png +26820.png +06812.png +43315.png +18465.png +27690.png +38385.png +51114.png +46277.png +03260.png +48712.png +64636.png +05251.png +66268.png +01542.png +26417.png +26507.png +61688.png +67241.png +65930.png +32693.png +62118.png +15219.png +31215.png +06682.png +38833.png +62443.png +06559.png +25270.png +29916.png +50440.png +64017.png +55685.png +47869.png +19793.png +14747.png +49835.png +03397.png +62672.png +15404.png +56488.png +61798.png +01430.png +23070.png +57687.png +06617.png +61648.png +17455.png +63842.png +69919.png +31694.png +38764.png +16054.png +46703.png +02971.png +41727.png +27104.png +31534.png +23587.png +09956.png +16373.png +10220.png +41651.png +58847.png +33579.png +49595.png +25671.png +00352.png +59046.png +20012.png +06843.png +19362.png +46194.png +42189.png +08305.png +28837.png +68743.png +50894.png +15744.png +55235.png +58358.png +03549.png +37079.png +19864.png +37104.png +60887.png +07178.png +20818.png +65550.png +03519.png +33850.png +35843.png +12760.png +29933.png +24094.png +58252.png +46254.png +27482.png +01491.png +13799.png +26259.png +24359.png +41972.png +16155.png +49558.png +10814.png +33956.png +02604.png +27467.png +07581.png +08882.png +15870.png +37191.png +04904.png +54261.png +68796.png +09440.png +01819.png +36715.png +27387.png +14868.png +42267.png +48150.png +61698.png +42043.png +18094.png +31407.png +38433.png +43018.png +61584.png +30188.png +27520.png +30276.png +44879.png +47559.png +04204.png +30159.png +01158.png +09167.png +12751.png +53515.png +07333.png +19139.png +04401.png +34339.png +63515.png +54040.png +32897.png +11261.png +33328.png +39978.png +65786.png +46083.png +35855.png +35619.png +06078.png +16412.png +36527.png +25735.png +09896.png +02649.png +66861.png +65081.png +53384.png +25010.png +04565.png +57596.png +62591.png +17501.png +62035.png +40196.png +14929.png +56221.png +04769.png +67568.png +58872.png +32006.png +13139.png +14502.png +32346.png +00461.png +63300.png +18160.png +19741.png +47948.png +48132.png +05894.png +34858.png +64168.png +27240.png +55968.png +38381.png +20545.png +36112.png +39129.png +35592.png +30593.png +06267.png +52570.png +48680.png +41809.png +07688.png +57553.png +24167.png +17401.png +12058.png +01167.png +42994.png +15967.png +60947.png +16919.png +43454.png +51949.png +10923.png +38416.png +61667.png +16037.png +34076.png +31732.png +34575.png +27955.png +43237.png +24039.png +46856.png +47688.png +20859.png +17511.png +50477.png +63904.png +06042.png +39350.png +43758.png +64750.png +69851.png +20757.png +31083.png +58809.png +55834.png +11302.png +13394.png +19468.png +69307.png +07140.png +27588.png +05315.png +49122.png +17340.png +53178.png +63361.png +05838.png +19956.png +63187.png +10321.png +13197.png +53539.png +05308.png +64860.png +04775.png +68296.png +07096.png +17353.png +00122.png +64767.png +09858.png +55751.png +11257.png +07275.png +54193.png +43500.png +38954.png +48961.png +23177.png +15142.png +17228.png +60177.png +55772.png +00811.png +03920.png +40473.png +66794.png +47917.png +50291.png +38284.png +61487.png +25640.png +65194.png +20442.png +57179.png +67741.png +06030.png +05389.png +17092.png +68290.png +09015.png +56803.png +38741.png +39973.png +18315.png +00242.png +67926.png +04161.png +24478.png +40757.png +12413.png +00128.png +64922.png +37133.png +16002.png +43834.png +35965.png +37062.png +30844.png +28246.png +43291.png +55116.png +26296.png +66804.png +31359.png +00907.png +66509.png +28038.png +69336.png +36788.png +00094.png +65231.png +69259.png +42366.png +23528.png +58335.png +23166.png +51412.png +53594.png +11160.png +23889.png +60596.png +53700.png +00588.png +08361.png +68142.png +64053.png +39866.png +36744.png +27600.png +33429.png +34378.png +22642.png +35511.png +14158.png +22285.png +67624.png +46657.png +43141.png +24396.png +10524.png +41796.png +09001.png +47145.png +14995.png +64467.png +54235.png +56782.png +34246.png +15854.png +45885.png +47447.png +62759.png +63649.png +57337.png +16386.png +46355.png +62520.png +28448.png +29454.png +30686.png +22720.png +54932.png +51035.png +05646.png +62292.png +01208.png +55329.png +46850.png +26452.png +09624.png +41227.png +19661.png +23427.png +48330.png +00293.png +50311.png +04055.png +58866.png +28714.png +48788.png +60713.png +45663.png +57545.png +09353.png +53000.png +46361.png +58108.png +09422.png +44419.png +65390.png +01272.png +35355.png +67459.png +42441.png +07200.png +08173.png +10361.png +14427.png +26088.png +13462.png +45674.png +69879.png +56538.png +48108.png +51193.png +27510.png +41245.png +35580.png +23186.png +19141.png +49586.png +48227.png +51997.png +65820.png +35281.png +58247.png +01960.png +04442.png +29305.png +64329.png +28778.png +36054.png +68441.png +39829.png +23204.png +45162.png +39414.png +34053.png +68546.png +11854.png +31371.png +53095.png +31975.png +04057.png +41953.png +55007.png +49615.png +14011.png +10211.png +64286.png +01555.png +01831.png +16010.png +12117.png +42634.png +38518.png +17389.png +06602.png +53758.png +59419.png +01111.png +60117.png +21674.png +05658.png +49501.png +65657.png +16255.png +62483.png +00195.png +58253.png +52490.png +25760.png +30289.png +52111.png +62848.png +10148.png +38348.png +36299.png +55856.png +38019.png +12027.png +20578.png +56172.png +36301.png +02222.png +34725.png +11573.png +02049.png +05160.png +25582.png +46028.png +64317.png +06619.png +43513.png +66012.png +52001.png +21027.png +25487.png +04115.png +26307.png +20752.png +38541.png +61240.png +14338.png +59627.png +57663.png +68069.png +24966.png +61015.png +16890.png +46257.png +32827.png +31367.png +11099.png +16964.png +69046.png +36698.png +43302.png +25795.png +67940.png +65634.png +43429.png +39312.png +59958.png +32063.png +07722.png +27624.png +63739.png +06271.png +53702.png +07039.png +18904.png +63430.png +22236.png +51908.png +30873.png +57694.png +53077.png +06569.png +56960.png +37503.png +00112.png +00219.png +33749.png +28528.png +18226.png +33764.png +40337.png +30432.png +13533.png +10259.png +11724.png +58890.png +31842.png +37795.png +48536.png +66877.png +66228.png +35283.png +30716.png +60619.png +42168.png +45832.png +19151.png +65707.png +63191.png +06452.png +32518.png +30570.png +67134.png +03799.png +56033.png +14528.png +54656.png +17161.png +59007.png +15117.png +38864.png +57506.png +10345.png +36976.png +36827.png +18107.png +26383.png +20226.png +11474.png +43247.png +30181.png +36563.png +39183.png +48592.png +19740.png +13237.png +56625.png +25999.png +41760.png +29019.png +50909.png +39018.png +31467.png +18233.png +46652.png +27840.png +65704.png +13047.png +53858.png +55238.png +22833.png +11191.png +28717.png +32607.png +16089.png +19646.png +00448.png +20505.png +29451.png +63736.png +14242.png +35636.png +27567.png +09160.png +19914.png +57609.png +38538.png +61234.png +54324.png +46443.png +47877.png +55809.png +69360.png +27383.png +54332.png +14254.png +56933.png +67405.png +48277.png +08592.png +21670.png +41757.png +13720.png +01993.png +69137.png +67924.png +08802.png +30935.png +33306.png +08037.png +13077.png +69783.png +46956.png +03376.png +03546.png +23604.png +66553.png +50933.png +23723.png +37799.png +52459.png +08915.png +15926.png +24789.png +13518.png +02269.png +46216.png +44403.png +31052.png +00692.png +09507.png +53296.png +10231.png +57209.png +24219.png +28910.png +22155.png +25436.png +43768.png +23735.png +68775.png +64528.png +45234.png +58807.png +66296.png +49413.png +47211.png +25371.png +66885.png +12560.png +47076.png +18311.png +35865.png +33405.png +46739.png +06069.png +58002.png +05366.png +41347.png +08834.png +25272.png +39993.png +35305.png +11702.png +14383.png +23062.png +40366.png +34826.png +47149.png +26931.png +02706.png +27962.png +32598.png +69067.png +34429.png +50537.png +03149.png +56314.png +07425.png +65838.png +32175.png +13403.png +10657.png +47580.png +26810.png +50516.png +31282.png +49740.png +68345.png +27637.png +23665.png +38792.png +47643.png +62497.png +67404.png +58547.png +11052.png +49303.png +26374.png +45396.png +50308.png +50576.png +14986.png +61393.png +46431.png +21308.png +38380.png +40478.png +09617.png +17913.png +51266.png +30319.png +53036.png +18742.png +11919.png +58206.png +62543.png +04746.png +27022.png +10731.png +00395.png +21906.png +10823.png +31719.png +39887.png +43251.png +18601.png +36508.png +66016.png +47906.png +54773.png +49102.png +07912.png +57912.png +25238.png +21258.png +22668.png +43549.png +06414.png +55457.png +36377.png +00660.png +37284.png +12719.png +00393.png +67721.png +31029.png +48748.png +60757.png +47243.png +10470.png +05791.png +62532.png +62705.png +67629.png +24873.png +60636.png +50285.png +18816.png +08540.png +28083.png +39607.png +63020.png +47907.png +32173.png +24597.png +60952.png +14413.png +60809.png +12050.png +19363.png +18499.png +20107.png +20577.png +13830.png +33239.png +53374.png +56466.png +04666.png +56673.png +64196.png +22278.png +03487.png +56089.png +36419.png +69408.png +11958.png +61199.png +22201.png +47728.png +42936.png +06985.png +59788.png +69912.png +32970.png +15194.png +17775.png +49221.png +02960.png +10437.png +64234.png +22079.png +05472.png +14111.png +54808.png +19896.png +30971.png +16685.png +17334.png +08201.png +42165.png +58861.png +50663.png +26151.png +37745.png +49057.png +48849.png +53684.png +65437.png +03762.png +27007.png +48036.png +11352.png +63157.png +66172.png +18490.png +02441.png +18230.png +37492.png +27059.png +35904.png +67671.png +04000.png +69086.png +59571.png +62521.png +35954.png +60660.png +68039.png +47244.png +68518.png +46961.png +38898.png +16243.png +67167.png +41958.png +01559.png +21862.png +04562.png +02710.png +02944.png +36173.png +27359.png +42402.png +16130.png +66503.png +59031.png +19308.png +37898.png +30279.png +60482.png +69960.png +33520.png +36052.png +42167.png +35507.png +11866.png +28865.png +28539.png +57218.png +21981.png +40791.png +38868.png +51780.png +33669.png +52697.png +43762.png +10369.png +60187.png +62693.png +54635.png +06802.png +66790.png +00198.png +03047.png +04220.png +21514.png +67890.png +54756.png +59153.png +39681.png +09338.png +21325.png +29575.png +55144.png +31193.png +42681.png +56859.png +66718.png +56131.png +07607.png +52754.png +10639.png +60540.png +69838.png +27176.png +41349.png +17407.png +13280.png +42000.png +25672.png +27620.png +15103.png +04548.png +06983.png +38737.png +12349.png +48744.png +35578.png +62872.png +52040.png +29373.png +62974.png +50600.png +14574.png +15710.png +24475.png +51931.png +46803.png +17480.png +26774.png +53367.png +48215.png +09753.png +50617.png +14731.png +40740.png +61224.png +17702.png +04999.png +01403.png +62481.png +15375.png +06143.png +32348.png +36765.png +47820.png +37549.png +05263.png +53052.png +26502.png +00653.png +20782.png +18394.png +56771.png +40237.png +56037.png +32684.png +33069.png +44328.png +67949.png +45815.png +62564.png +27658.png +21064.png +44460.png +10342.png +12999.png +57516.png +62928.png +43470.png +33805.png +44839.png +51936.png +58919.png +51082.png +56393.png +45300.png +16902.png +66780.png +47846.png +10817.png +09684.png +01516.png +69943.png +11667.png +42065.png +54430.png +06129.png +64640.png +08507.png +21431.png +08545.png +21608.png +33426.png +06431.png +27238.png +69419.png +64108.png +45667.png +05097.png +12863.png +55688.png +01777.png +19450.png +59285.png +00047.png +04997.png +42707.png +37968.png +60280.png +11400.png +04973.png +15212.png +59994.png +03867.png +57618.png +61039.png +23305.png +67723.png +04789.png +52916.png +03184.png +48519.png +41082.png +15931.png +31095.png +01215.png +57050.png +51359.png +29299.png +15922.png +40092.png +37042.png +49334.png +68930.png +04659.png +26915.png +11180.png +32893.png +46294.png +31452.png +13582.png +11289.png +66928.png +22949.png +41118.png +64562.png +44690.png +65393.png +12621.png +22106.png +27541.png +13196.png +69545.png +39012.png +02380.png +03345.png +03759.png +43224.png +46078.png +20206.png +66281.png +20768.png +23377.png +53560.png +44895.png +28451.png +27314.png +50556.png +20323.png +13349.png +32519.png +65842.png +58555.png +53889.png +61536.png +07940.png +00338.png +67060.png +48671.png +37344.png +03208.png +14264.png +45330.png +05026.png +12745.png +33547.png +31898.png +48119.png +06895.png +52855.png +27927.png +23775.png +44872.png +09039.png +24402.png +29740.png +54010.png +32354.png +19507.png +64469.png +36158.png +06511.png +66361.png +53860.png +28112.png +08775.png +48876.png +39437.png +08590.png +44438.png +66404.png +10518.png +37569.png +37671.png +11295.png +22179.png +14395.png +39162.png +19460.png +20680.png +64257.png +04627.png +15071.png +10068.png +36002.png +30600.png +68618.png +12606.png +20525.png +57099.png +31172.png +29674.png +09623.png +07714.png +15918.png +04426.png +25000.png +09728.png +47198.png +64795.png +03136.png +03417.png +12099.png +33412.png +51406.png +59453.png +43627.png +34277.png +11292.png +00425.png +18670.png +66534.png +30542.png +03131.png +00164.png +58285.png +30550.png +07137.png +40779.png +46998.png +17239.png +27782.png +39626.png +54621.png +30898.png +12425.png +03552.png +19639.png +16765.png +49836.png +38825.png +65169.png +04835.png +56200.png +60821.png +59509.png +69262.png +14221.png +51683.png +07411.png +47103.png +58230.png +14146.png +47015.png +48032.png +61761.png +15228.png +48947.png +11167.png +17456.png +34786.png +69214.png +22985.png +40130.png +48759.png +41297.png +67938.png +65127.png +08842.png +29766.png +27280.png +36902.png +49251.png +24796.png +01002.png +04804.png +38623.png +59367.png +27628.png +51801.png +47938.png +15267.png +15734.png +37850.png +19425.png +38409.png +45136.png +66208.png +38849.png +56022.png +26597.png +49655.png +35430.png +57948.png +51629.png +57583.png +21247.png +68280.png +53668.png +02110.png +49342.png +42481.png +59837.png +06974.png +03062.png +54694.png +12631.png +02304.png +55139.png +24963.png +55469.png +27683.png +00266.png +09839.png +11152.png +09929.png +32703.png +59947.png +59289.png +63911.png +05386.png +58723.png +22452.png +10850.png +32376.png +32570.png +65566.png +03539.png +15464.png +42931.png +07728.png +52769.png +02888.png +00360.png +68883.png +64389.png +66824.png +47513.png +41167.png +06083.png +43931.png +49979.png +61806.png +46175.png +34723.png +15914.png +33352.png +63264.png +01780.png +52399.png +35000.png +37779.png +06507.png +44830.png +56255.png +11240.png +58488.png +32774.png +01225.png +28742.png +08061.png +51524.png +61454.png +04877.png +34307.png +16998.png +26992.png +60228.png +41112.png +44152.png +46555.png +32508.png +39861.png +67083.png +27886.png +38689.png +37315.png +15420.png +53640.png +69599.png +08498.png +47064.png +59376.png +18850.png +39108.png +19570.png +61660.png +38233.png +42656.png +34366.png +49411.png +67341.png +01581.png +25515.png +26620.png +49751.png +22245.png +43503.png +46551.png +31709.png +13015.png +49677.png +30006.png +26941.png +10195.png +47975.png +19716.png +61009.png +69698.png +45735.png +59413.png +13202.png +57511.png +21470.png +59262.png +31284.png +15893.png +58583.png +26152.png +61808.png +68572.png +37594.png +03042.png +52454.png +43918.png +24393.png +30949.png +49791.png +26062.png +39160.png +58375.png +56015.png +20972.png +10420.png +15098.png +46427.png +41659.png +20543.png +31212.png +61453.png +38876.png +04063.png +55492.png +16398.png +05776.png +54777.png +54050.png +52003.png +04848.png +67002.png +51944.png +53578.png +30455.png +35269.png +04431.png +27991.png +00275.png +01781.png +35037.png +44770.png +56452.png +54404.png +07575.png +47647.png +08572.png +19641.png +52809.png +43216.png +60043.png +25657.png +66337.png +16977.png +52503.png +17162.png +31941.png +29712.png +23345.png +18982.png +60069.png +38081.png +30630.png +01445.png +00417.png +69855.png +19310.png +18223.png +41194.png +05073.png +59937.png +48730.png +29641.png +02546.png +36084.png +05106.png +40739.png +06508.png +02943.png +43968.png +59133.png +10826.png +10593.png +27066.png +34888.png +45907.png +37619.png +25047.png +60915.png +65991.png +40656.png +09477.png +68711.png +67121.png +60720.png +04934.png +65274.png +38196.png +21933.png +28764.png +46585.png +19129.png +10058.png +59050.png +23230.png +42379.png +67395.png +42075.png +35848.png +26321.png +63174.png +57271.png +62427.png +59610.png +59541.png +27437.png +35073.png +67122.png +69105.png +30155.png +11178.png +50733.png +35622.png +64923.png +44415.png +25160.png +62425.png +41566.png +42852.png +47404.png +44545.png +27491.png +01234.png +40643.png +40829.png +16969.png +23074.png +48290.png +32776.png +61040.png +49432.png +61404.png +64396.png +65813.png +33650.png +52462.png +57074.png +62905.png +02349.png +20208.png +42534.png +28357.png +44192.png +19417.png +66100.png +67387.png +52798.png +49314.png +42224.png +35101.png +07533.png +27676.png +20417.png +17381.png +47646.png +20648.png +05660.png +64868.png +05015.png +35967.png +39847.png +07604.png +64289.png +07474.png +55567.png +64576.png +07863.png +41802.png +63416.png +15767.png +14614.png +58212.png +69127.png +03803.png +07067.png +25256.png +22826.png +09200.png +61548.png +41468.png +22735.png +46523.png +48242.png +53969.png +64475.png +57460.png +59637.png +26263.png +33905.png +44668.png +46733.png +25210.png +24988.png +07227.png +56008.png +42378.png +44633.png +53297.png +07873.png +24853.png +09971.png +07976.png +26540.png +10793.png +50678.png +25123.png +25898.png +11449.png +37697.png +22134.png +32752.png +02523.png +07624.png +31781.png +45215.png +16483.png +43975.png +17704.png +38427.png +39769.png +00520.png +02249.png +58406.png +56932.png +57404.png +26754.png +67054.png +03407.png +33570.png +61375.png +09369.png +00356.png +06355.png +22153.png +05500.png +63150.png +40737.png +49226.png +25890.png +37909.png +62294.png +12109.png +02076.png +23349.png +37396.png +62415.png +33703.png +44553.png +53347.png +16450.png +28106.png +54888.png +34584.png +12986.png +57341.png +26117.png +56814.png +16753.png +48673.png +10927.png +14182.png +63277.png +29840.png +25365.png +64379.png +68509.png +43620.png +05901.png +36523.png +12966.png +15597.png +32901.png +59987.png +13853.png +32446.png +28223.png +29833.png +57318.png +63770.png +28820.png +41677.png +41812.png +04339.png +17738.png +14682.png +16778.png +14184.png +01577.png +66905.png +19193.png +46687.png +25397.png +31497.png +31661.png +68830.png +06942.png +49368.png +57623.png +09252.png +49181.png +22941.png +37536.png +01119.png +15939.png +16487.png +24861.png +30658.png +23018.png +53878.png +50307.png +61619.png +37977.png +20134.png +13821.png +36645.png +29658.png +29039.png +00140.png +39881.png +21396.png +39152.png +09773.png +37931.png +20783.png +47223.png +42584.png +30351.png +68752.png +49275.png +69441.png +47079.png +48439.png +19598.png +56194.png +26531.png +34462.png +10089.png +27610.png +10930.png +43447.png +01912.png +66237.png +64828.png +60669.png +25526.png +32861.png +06108.png +54081.png +39070.png +22064.png +67269.png +67642.png +36819.png +02172.png +45303.png +25577.png +06904.png +16865.png +01428.png +64113.png +41446.png +30845.png +52368.png +46807.png +00229.png +48664.png +59113.png +64354.png +55787.png +08099.png +28899.png +36660.png +52557.png +32030.png +38915.png +41292.png +10683.png +40886.png +14761.png +50797.png +36083.png +50862.png +12452.png +34633.png +66148.png +15795.png +40271.png +59236.png +18155.png +59508.png +06687.png +06124.png +20936.png +14739.png +33460.png +55400.png +02667.png +27752.png +55008.png +31073.png +09418.png +47059.png +49213.png +66636.png +41830.png +40240.png +08372.png +32950.png +03122.png +06276.png +67027.png +47675.png +55949.png +38698.png +29757.png +37151.png +69170.png +54352.png +10307.png +66054.png +59825.png +31017.png +50437.png +08630.png +58772.png +00088.png +02857.png +60554.png +36454.png +61910.png +35544.png +39700.png +47354.png +45463.png +19964.png +50621.png +38030.png +59368.png +36912.png +28228.png +37584.png +59164.png +46268.png +27619.png +52385.png +34300.png +13275.png +47794.png +31103.png +02696.png +44637.png +07404.png +67747.png +54531.png +51127.png +61210.png +07591.png +44933.png +14026.png +25544.png +28169.png +18405.png +55471.png +53732.png +34887.png +22234.png +46308.png +47609.png +17672.png +28615.png +68029.png +32583.png +61013.png +10694.png +38423.png +15385.png +68681.png +17888.png +17555.png +15380.png +66958.png +34842.png +11155.png +09467.png +33842.png +35126.png +21168.png +33136.png +29996.png +66024.png +60902.png +16059.png +29391.png +06311.png +38439.png +28274.png +04226.png +08766.png +31931.png +33220.png +27845.png +37565.png +21362.png +61617.png +11745.png +25444.png +23710.png +09598.png +21482.png +01153.png +38099.png +40060.png +40334.png +50433.png +37927.png +68894.png +42845.png +04166.png +62260.png +46848.png +24735.png +41444.png +36898.png +40105.png +27414.png +45537.png +06712.png +16462.png +28267.png +12432.png +37474.png +32209.png +51848.png +53900.png +65811.png +62177.png +28849.png +34278.png +38992.png +18806.png +20340.png +56957.png +33666.png +52087.png +38101.png +21061.png +59140.png +56688.png +32544.png +06642.png +01536.png +37573.png +47963.png +35747.png +30601.png +30047.png +24089.png +16785.png +31220.png +29938.png +66801.png +50036.png +42971.png +07488.png +06764.png +27224.png +33113.png +43937.png +23827.png +21394.png +08052.png +12476.png +48552.png +21627.png +38125.png +16723.png +19307.png +19379.png +56268.png +46390.png +14511.png +69632.png +44913.png +43630.png +34170.png +06625.png +17417.png +04587.png +52010.png +69558.png +47660.png +10786.png +10104.png +29788.png +27651.png +67811.png +00077.png +01806.png +23552.png +05705.png +30907.png +44859.png +26297.png +63478.png +24261.png +31708.png +15871.png +58984.png +62562.png +03035.png +43436.png +03333.png +22740.png +61818.png +01892.png +02190.png +44258.png +44242.png +62569.png +22107.png +40484.png +41454.png +01393.png +15623.png +29546.png +68789.png +09186.png +69049.png +18335.png +10547.png +68504.png +09334.png +19353.png +08433.png +04883.png +04695.png +06599.png +45684.png +47715.png +49638.png +04418.png +50794.png +56618.png +00648.png +06161.png +17644.png +62178.png +14400.png +01666.png +36079.png +30596.png +18392.png +21456.png +30528.png +21940.png +57999.png +19705.png +30603.png +31686.png +54122.png +09301.png +58648.png +08086.png +32230.png +13977.png +35290.png +52109.png +41933.png +16047.png +46360.png +62479.png +10286.png +62026.png +51343.png +13950.png +44918.png +17788.png +30118.png +69639.png +19280.png +65482.png +42610.png +07352.png +06842.png +14753.png +61388.png +40565.png +47496.png +28502.png +34956.png +44465.png +46221.png +36579.png +54901.png +24103.png +03362.png +25630.png +35791.png +14520.png +36412.png +69663.png +35421.png +52164.png +28965.png +60371.png +07156.png +66819.png +52172.png +16878.png +61102.png +08982.png +27438.png +19101.png +56831.png +58848.png +21511.png +01243.png +66813.png +40424.png +07504.png +18300.png +15013.png +65043.png +58396.png +10872.png +38317.png +36316.png +56589.png +69720.png +21617.png +53239.png +35150.png +53196.png +47663.png +17958.png +23495.png +32284.png +25157.png +59316.png +12291.png +43656.png +54815.png +44719.png +33404.png +38594.png +21658.png +65058.png +09033.png +38683.png +12705.png +20699.png +35226.png +54219.png +14110.png +22288.png +07242.png +34521.png +66449.png +01265.png +11398.png +38956.png +30954.png +47287.png +33076.png +14398.png +51102.png +61840.png +33027.png +19819.png +24906.png +65025.png +16118.png +69000.png +28256.png +53354.png +50896.png +28518.png +68735.png +66523.png +64118.png +30201.png +18035.png +47899.png +13637.png +47207.png +03051.png +22512.png +50121.png +46218.png +01043.png +15502.png +40329.png +50269.png +41571.png +46290.png +24799.png +13904.png +42803.png +59123.png +44699.png +51544.png +52765.png +08121.png +44352.png +66023.png +18359.png +31001.png +11066.png +61364.png +16888.png +43004.png +36068.png +32982.png +56386.png +09102.png +44966.png +48401.png +35345.png +23289.png +33461.png +09676.png +27273.png +18682.png +60786.png +53405.png +32977.png +30132.png +23624.png +14690.png +58045.png +10904.png +34301.png +48310.png +56500.png +02949.png +59989.png +52526.png +05572.png +26264.png +39564.png +59365.png +08085.png +04049.png +23505.png +50854.png +24954.png +63621.png +55924.png +33759.png +50566.png +14150.png +32614.png +45666.png +11775.png +28002.png +00834.png +44691.png +17520.png +10994.png +23635.png +32541.png +35090.png +29374.png +25342.png +39459.png +00757.png +22744.png +03951.png +53359.png +03946.png +10397.png +52912.png +44243.png +06345.png +19907.png +51027.png +58338.png +46178.png +14870.png +61971.png +14645.png +01496.png +50643.png +12612.png +03394.png +29457.png +50088.png +17283.png +65139.png +60171.png +16889.png +37794.png +69866.png +33096.png +47546.png +37822.png +03624.png +67453.png +62099.png +05014.png +55002.png +28833.png +22111.png +29119.png +34006.png +30325.png +14808.png +11569.png +42570.png +42651.png +66207.png +29804.png +31032.png +26948.png +68973.png +18769.png +65176.png +06641.png +21529.png +67109.png +38082.png +51710.png +46108.png +41214.png +15578.png +36541.png +17064.png +58510.png +47676.png +26002.png +26132.png +43638.png +14531.png +45618.png +60137.png +66474.png +25976.png +02559.png +25245.png +29453.png +03672.png +58697.png +26978.png +53687.png +39604.png +50313.png +09350.png +58182.png +62171.png +69463.png +55971.png +07841.png +00755.png +55851.png +14080.png +22466.png +55309.png +58593.png +02554.png +68678.png +27558.png +47446.png +52487.png +00607.png +68825.png +59996.png +52007.png +13746.png +47444.png +22205.png +10580.png +26789.png +37660.png +23059.png +56760.png +11670.png +41816.png +29328.png +56699.png +42555.png +31551.png +16320.png +61041.png +07761.png +64106.png +51439.png +63549.png +33596.png +11820.png +08320.png +39187.png +57953.png +11937.png +54143.png +69776.png +48925.png +22547.png +44172.png +07188.png +10090.png +50453.png +17977.png +64330.png +13576.png +57432.png +44271.png +51971.png +07568.png +58658.png +67407.png +33304.png +58175.png +16122.png +25251.png +52848.png +03561.png +51048.png +02200.png +14392.png +06409.png +50697.png +47250.png +33173.png +48799.png +11977.png +51819.png +63932.png +35897.png +49573.png +27293.png +33831.png +35393.png +05227.png +54758.png +42156.png +42814.png +28324.png +42029.png +20846.png +32886.png +20455.png +54059.png +03793.png +55553.png +25408.png +61324.png +34931.png +64608.png +34731.png +54125.png +63035.png +12247.png +25003.png +15448.png +15792.png +16163.png +19860.png +07084.png +66533.png +47731.png +51805.png +31760.png +44228.png +48116.png +28041.png +06700.png +61111.png +58562.png +61399.png +40787.png +05803.png +26679.png +61211.png +33223.png +51335.png +00542.png +28963.png +27380.png +18318.png +58016.png +32706.png +13261.png +11435.png +59760.png +00004.png +34754.png +25869.png +51831.png +33552.png +39666.png +69033.png +07723.png +53195.png +00756.png +13110.png +26880.png +43349.png +22110.png +13298.png +51500.png +12430.png +08245.png +61999.png +01611.png +01477.png +05246.png +20841.png +36105.png +52376.png +67735.png +08208.png +14074.png +09691.png +23370.png +53153.png +40608.png +18163.png +14565.png +62003.png +58904.png +09348.png +26069.png +11715.png +00915.png +44559.png +55815.png +59948.png +55972.png +02421.png +46375.png +53259.png +62489.png +35858.png +49643.png +34160.png +60068.png +22895.png +31041.png +13793.png +06545.png +35443.png +47786.png +15300.png +02274.png +59035.png +61529.png +19775.png +21479.png +35100.png +52083.png +35038.png +65774.png +33943.png +68305.png +16138.png +18185.png +63569.png +58310.png +38750.png +38675.png +44575.png +29473.png +47464.png +03837.png +60447.png +12752.png +49352.png +03451.png +09249.png +35436.png +16470.png +26381.png +44240.png +19067.png +44669.png +14058.png +00443.png +37115.png +31811.png +08322.png +10685.png +43367.png +50906.png +65283.png +63943.png +68751.png +14535.png +63235.png +18553.png +54521.png +13085.png +51923.png +00611.png +21386.png +40399.png +40980.png +32870.png +30650.png +37134.png +46477.png +49435.png +37678.png +43290.png +61266.png +31216.png +67308.png +09854.png +35288.png +21978.png +24599.png +49786.png +43368.png +17825.png +35435.png +44929.png +42966.png +33613.png +57823.png +24071.png +57496.png +14610.png +39608.png +47648.png +48833.png +47114.png +39277.png +31584.png +31366.png +51415.png +00080.png +05568.png +56234.png +15345.png +15470.png +60538.png +50952.png +47636.png +36666.png +46543.png +04691.png +61095.png +40395.png +14635.png +53542.png +35138.png +66093.png +60485.png +35933.png +02285.png +04805.png +04738.png +65683.png +32809.png +28772.png +55506.png +14786.png +01165.png +50194.png +61296.png +57093.png +57325.png +65758.png +39033.png +27518.png +48261.png +27565.png +34900.png +65314.png +47573.png +00008.png +40457.png +42370.png +04963.png +17791.png +35891.png +31292.png +21032.png +47833.png +07590.png +36565.png +29244.png +37808.png +41622.png +64273.png +57676.png +64134.png +69130.png +37551.png +24908.png +36919.png +65850.png +20958.png +48437.png +20488.png +16278.png +01179.png +58440.png +09264.png +35072.png +69446.png +07281.png +51888.png +68081.png +40945.png +10626.png +26288.png +50464.png +25860.png +49050.png +08683.png +39865.png +16333.png +52417.png +08251.png +63196.png +35821.png +35108.png +41935.png +56555.png +19652.png +04555.png +45384.png +62012.png +60972.png +44848.png +28685.png +39172.png +04650.png +24907.png +59671.png +33708.png +46621.png +56741.png +67044.png +14151.png +57546.png +69630.png +03816.png +56818.png +37865.png +57227.png +42708.png +28943.png +23519.png +38330.png +45695.png +67277.png +20960.png +29012.png +27686.png +65782.png +02329.png +69911.png +38183.png +54456.png +57398.png +13350.png +52453.png +29179.png +01455.png +02962.png +25039.png +32595.png +28016.png +07752.png +60262.png +63528.png +35386.png +12166.png +08013.png +33336.png +23228.png +30018.png +63374.png +69709.png +11748.png +10191.png +11460.png +04317.png +21784.png +18447.png +17696.png +68104.png +42023.png +20511.png +66717.png +27016.png +43504.png +23003.png +54097.png +20672.png +56203.png +36870.png +03350.png +00150.png +28441.png +07799.png +57426.png +32736.png +52176.png +52635.png +00073.png +58777.png +44858.png +67897.png +66647.png +32394.png +61426.png +35091.png +60727.png +48546.png +15119.png +34282.png +25428.png +57447.png +08887.png +12269.png +08816.png +21474.png +32223.png +13816.png +48366.png +54149.png +09835.png +51543.png +27439.png +11485.png +26699.png +28331.png +66588.png +69648.png +04285.png +50561.png +53633.png +55410.png +66870.png +05092.png +16438.png +48574.png +07794.png +50128.png +35643.png +50129.png +40004.png +64522.png +60830.png +09930.png +64919.png +43873.png +15872.png +24156.png +44084.png +09696.png +67040.png +04726.png +03426.png +19726.png +26573.png +46417.png +35484.png +65337.png +69777.png +34107.png +63247.png +58675.png +20087.png +37394.png +28167.png +35033.png +05328.png +60591.png +59400.png +68022.png +62771.png +28604.png +53040.png +47186.png +63214.png +13068.png +03001.png +57852.png +60090.png +25723.png +12834.png +40972.png +34700.png +59435.png +28627.png +32551.png +31036.png +30725.png +24470.png +55402.png +37771.png +09144.png +44105.png +21580.png +45111.png +59196.png +27448.png +65637.png +22341.png +43949.png +24083.png +44893.png +61075.png +16611.png +35118.png +29832.png +13735.png +19946.png +40403.png +13607.png +61754.png +58049.png +27136.png +58423.png +19818.png +38397.png +17164.png +17057.png +40951.png +17952.png +17233.png +55799.png +58448.png +49879.png +22304.png +15120.png +60481.png +01678.png +05462.png +38550.png +08857.png +50059.png +34270.png +60005.png +21970.png +22714.png +18797.png +53021.png +05807.png +20246.png +66127.png +20068.png +43846.png +20711.png +05938.png +36929.png +25624.png +16613.png +42329.png +41670.png +42700.png +51976.png +15760.png +39630.png +35581.png +31025.png +29411.png +34569.png +57023.png +55444.png +45802.png +36997.png +08141.png +62546.png +62513.png +43629.png +07346.png +14428.png +61497.png +20034.png +54455.png +36933.png +46729.png +59072.png +43887.png +69322.png +27129.png +11957.png +10265.png +42066.png +11381.png +05049.png +65577.png +56387.png +60724.png +29416.png +59631.png +45777.png +57438.png +35783.png +39093.png +42249.png +55759.png +49483.png +12190.png +36817.png +05769.png +16894.png +52629.png +53827.png +29570.png +27367.png +55966.png +40802.png +11040.png +17306.png +08021.png +27266.png +49898.png +64859.png +17396.png +51896.png +58844.png +31226.png +43690.png +16689.png +53864.png +44776.png +35425.png +54296.png +33484.png +48539.png +17420.png +67527.png +54500.png +42517.png +07718.png +51201.png +31992.png +42576.png +39207.png +09595.png +29080.png +05622.png +04930.png +55839.png +03082.png +29355.png +47352.png +55085.png +50491.png +68802.png +32096.png +11884.png +23471.png +39214.png +23605.png +13597.png +04677.png +21021.png +41771.png +61967.png +42330.png +13616.png +57049.png +65981.png +47901.png +27250.png +59641.png +05268.png +29339.png +00717.png +21738.png +25593.png +39761.png +34989.png +10309.png +62190.png +40268.png +30878.png +08574.png +15347.png +26859.png +41290.png +22062.png +24291.png +40158.png +44662.png +32616.png +44566.png +60046.png +58353.png +54537.png +04482.png +54118.png +46418.png +37146.png +29211.png +29705.png +21493.png +44891.png +34565.png +32203.png +46327.png +59346.png +11941.png +10127.png +64443.png +29696.png +03412.png +38110.png +46480.png +49144.png +37833.png +31538.png +55814.png +24091.png +36872.png +38027.png +16312.png +41649.png +23296.png +23876.png +39059.png +55538.png +44927.png +27854.png +49988.png +44113.png +25189.png +25542.png +62607.png +34283.png +26973.png +56542.png +30257.png +17086.png +11518.png +35589.png +47097.png +40814.png +45236.png +01178.png +04379.png +61357.png +63012.png +67350.png +49792.png +68100.png +59675.png +16655.png +61208.png +66935.png +11304.png +67775.png +18564.png +65445.png +14054.png +58715.png +42283.png +46122.png +42968.png +06635.png +41543.png +28791.png +58983.png +47281.png +59706.png +60507.png +69908.png +16870.png +68220.png +22475.png +56263.png +12831.png +24938.png +15498.png +04801.png +37782.png +07045.png +56971.png +16554.png +61132.png +38944.png +14348.png +26827.png +21558.png +35220.png +33241.png +66106.png +54389.png +62217.png +44389.png +18702.png +02994.png +52336.png +66306.png +58258.png +30124.png +53459.png +47511.png +30137.png +36476.png +61964.png +40847.png +30020.png +11110.png +59938.png +13647.png +46517.png +49047.png +42338.png +22238.png +06640.png +03418.png +34987.png +56683.png +52121.png +38498.png +52032.png +38855.png +28632.png +56517.png +40057.png +26910.png +40464.png +55423.png +25439.png +47735.png +10514.png +28205.png +48180.png +37145.png +24162.png +00839.png +67374.png +39816.png +11912.png +31915.png +40903.png +43191.png +25068.png +27343.png +08189.png +51924.png +58789.png +53053.png +64278.png +31225.png +69156.png +05722.png +52094.png +57718.png +20374.png +63231.png +07792.png +40050.png +47837.png +42697.png +27629.png +48447.png +54494.png +65546.png +45737.png +10004.png +29765.png +10187.png +31679.png +18557.png +34561.png +17645.png +65716.png +49394.png +62426.png +48055.png +04320.png +49431.png +29034.png +59425.png +61163.png +54615.png +62572.png +34695.png +01515.png +09356.png +15997.png +32619.png +24435.png +11644.png +62093.png +01437.png +22143.png +08533.png +20000.png +30493.png +04257.png +04306.png +08117.png +63325.png +08937.png +67424.png +23449.png +34653.png +59148.png +53231.png +08134.png +16883.png +46071.png +42537.png +68328.png +49863.png +05669.png +60587.png +69029.png +35620.png +18020.png +38694.png +67290.png +32540.png +43434.png +24322.png +26248.png +45837.png +27526.png +44396.png +66285.png +48314.png +21411.png +12076.png +58244.png +12365.png +45408.png +49208.png +32652.png +03886.png +23154.png +06761.png +31140.png +07910.png +63934.png +50176.png +31020.png +48511.png +34504.png +18341.png +48854.png +05932.png +44362.png +51076.png +21447.png +07255.png +14285.png +03069.png +42941.png +26733.png +68052.png +69427.png +35713.png +55319.png +58427.png +55593.png +06864.png +26933.png +27539.png +50515.png +69729.png +32009.png +13878.png +22811.png +18170.png +22148.png +46112.png +03318.png +23307.png +69581.png +56633.png +15334.png +10341.png +59892.png +58733.png +64870.png +15459.png +17298.png +06438.png +58666.png +34427.png +15323.png +28099.png +24725.png +01570.png +32620.png +23956.png +43074.png +26624.png +00098.png +65370.png +65011.png +47413.png +69543.png +00798.png +10649.png +26173.png +23919.png +45761.png +49456.png +21957.png +05687.png +38599.png +25496.png +62528.png +19938.png +68219.png +46000.png +10256.png +63808.png +43346.png +51804.png +42158.png +29300.png +57644.png +35068.png +15869.png +17916.png +60816.png +66354.png +04197.png +34051.png +29771.png +31511.png +13925.png +37687.png +58953.png +51868.png +18703.png +60016.png +29806.png +00403.png +12375.png +67955.png +19180.png +27205.png +22852.png +00201.png +31647.png +54916.png +21772.png +47039.png +20057.png +36712.png +25425.png +35303.png +58386.png +15063.png +07399.png +59480.png +11077.png +41792.png +20786.png +30309.png +48386.png +29569.png +04567.png +46947.png +62323.png +38609.png +09050.png +60602.png +67195.png +36798.png +33521.png +48057.png +48321.png +53378.png +66812.png +01501.png +20922.png +14518.png +67751.png +41498.png +33863.png +57144.png +35561.png +63995.png +68809.png +40007.png +16627.png +26275.png +35525.png +38294.png +54575.png +38560.png +42768.png +46910.png +44865.png +44987.png +11835.png +32657.png +26592.png +54435.png +06337.png +19805.png +47916.png +17081.png +02574.png +05209.png +10076.png +11910.png +22439.png +59868.png +61944.png +63175.png +01502.png +49764.png +40402.png +27410.png +51585.png +28658.png +67337.png +23646.png +33709.png +30824.png +21126.png +28266.png +52481.png +00216.png +54069.png diff --git a/src/taming-transformers/data/ffhqvalidation.txt b/src/taming-transformers/data/ffhqvalidation.txt new file mode 100644 index 0000000000000000000000000000000000000000..e749083689505a437a770dfcc565a6bc7e68c15e --- /dev/null +++ b/src/taming-transformers/data/ffhqvalidation.txt @@ -0,0 +1,10000 @@ +47234.png +19351.png +35914.png +69674.png +56874.png +42520.png +46003.png +17268.png +04356.png +27798.png +00215.png +52296.png +07831.png +60203.png +17370.png +60917.png +28976.png +21349.png +55110.png +39685.png +32890.png +01725.png +68917.png +33295.png +35482.png +14049.png +65090.png +57924.png +04228.png +04706.png +53727.png +58418.png +36441.png +45449.png +38796.png +21789.png +24747.png +30136.png +14578.png +46833.png +02309.png +38885.png +40590.png +01041.png +40981.png +18772.png +00711.png +29177.png +60499.png +58850.png +08701.png +23208.png +02318.png +69798.png +65569.png +03510.png +52677.png +54655.png +12710.png +15295.png +62010.png +10024.png +48676.png +63984.png +19089.png +05794.png +68558.png +67235.png +20815.png +23026.png +25627.png +04993.png +45970.png +22492.png +28417.png +59622.png +04523.png +04679.png +43920.png +46430.png +03560.png +40731.png +24277.png +10337.png +65250.png +64185.png +60498.png +15358.png +33660.png +10992.png +47089.png +46109.png +03304.png +26129.png +50029.png +54132.png +09531.png +35266.png +67031.png +60991.png +65504.png +38367.png +10013.png +24778.png +07850.png +29016.png +34227.png +51622.png +13725.png +68176.png +40837.png +14669.png +22981.png +36407.png +08654.png +26118.png +26821.png +25859.png +23773.png +24022.png +09497.png +16007.png +20074.png +65795.png +56168.png +18876.png +23974.png +04048.png +64016.png +07959.png +69553.png +56724.png +12727.png +50876.png +51902.png +34904.png +23862.png +35438.png +22600.png +24347.png +66469.png +63005.png +07614.png +53298.png +66218.png +52175.png +68459.png +38490.png +42737.png +67489.png +28308.png +33664.png +25572.png +06989.png +69056.png +49292.png +21799.png +31547.png +45523.png +29662.png +38756.png +23392.png +12599.png +08622.png +29756.png +23526.png +36906.png +48362.png +65788.png +36360.png +17569.png +65407.png +53757.png +00076.png +18915.png +20383.png +26893.png +17560.png +10312.png +22726.png +66036.png +41843.png +18545.png +03806.png +20833.png +11728.png +28368.png +46769.png +12462.png +38969.png +38354.png +19382.png +32934.png +06566.png +10684.png +42429.png +47808.png +24762.png +50166.png +32697.png +08420.png +07396.png +61551.png +27291.png +69774.png +65342.png +64563.png +49968.png +59065.png +60024.png +45494.png +03555.png +66463.png +54228.png +24325.png +28529.png +14823.png +46912.png +63507.png +62258.png +48972.png +27804.png +41829.png +46747.png +22364.png +03013.png +58956.png +59334.png +51210.png +37803.png +32072.png +40977.png +38482.png +56171.png +39773.png +32831.png +19731.png +10422.png +35306.png +09239.png +42833.png +07763.png +04983.png +60753.png +09918.png +69129.png +43088.png +39819.png +56189.png +06282.png +05931.png +20179.png +57276.png +20995.png +17398.png +11836.png +16835.png +27164.png +49856.png +65042.png +13810.png +68139.png +28730.png +42462.png +14686.png +66214.png +44215.png +48513.png +07924.png +22656.png +26317.png +65876.png +24411.png +07040.png +51575.png +13018.png +27191.png +58755.png +12472.png +37528.png +03009.png +69461.png +05284.png +55681.png +51195.png +11117.png +69825.png +60162.png +57403.png +65360.png +38301.png +04427.png +50625.png +43510.png +58791.png +66334.png +10860.png +19765.png +41719.png +08219.png +03533.png +06471.png +26511.png +03848.png +12160.png +07379.png +18377.png +14473.png +33397.png +51600.png +52067.png +45983.png +32988.png +53270.png +14231.png +15714.png +36681.png +36649.png +29173.png +35812.png +46799.png +67859.png +39038.png +45409.png +13173.png +58345.png +35503.png +60976.png +31181.png +16112.png +12685.png +28966.png +27532.png +61976.png +50844.png +43063.png +21189.png +09655.png +45710.png +28941.png +53834.png +68151.png +27959.png +52455.png +38802.png +59006.png +41991.png +44975.png +41223.png +63159.png +54568.png +33917.png +26668.png +34559.png +11674.png +40072.png +10289.png +05210.png +19937.png +31549.png +13551.png +69210.png +52952.png +01383.png +58238.png +24414.png +24622.png +07005.png +32611.png +12962.png +17980.png +34150.png +61640.png +33468.png +48092.png +16216.png +59827.png +54873.png +56142.png +05003.png +24800.png +25784.png +28181.png +34560.png +16671.png +36755.png +16145.png +04702.png +46938.png +42669.png +53849.png +08619.png +13216.png +12008.png +63179.png +46556.png +35014.png +39497.png +07966.png +23884.png +44287.png +12649.png +52970.png +15428.png +03346.png +19494.png +48237.png +28490.png +03763.png +51318.png +10783.png +60287.png +24239.png +32131.png +17005.png +34542.png +09867.png +03248.png +14329.png +29460.png +30860.png +30748.png +30438.png +03828.png +68470.png +37199.png +17225.png +56336.png +43084.png +29007.png +19027.png +60061.png +05520.png +46561.png +50288.png +01552.png +67365.png +41866.png +35399.png +69135.png +59407.png +50776.png +41338.png +05457.png +13229.png +07948.png +01843.png +00904.png +37158.png +25514.png +09185.png +00622.png +56627.png +45339.png +52856.png +14072.png +64836.png +02409.png +39720.png +03689.png +11034.png +22358.png +65974.png +07732.png +18733.png +14684.png +04609.png +09475.png +19955.png +44488.png +63278.png +28001.png +46456.png +10075.png +06744.png +13548.png +30067.png +32560.png +56375.png +30254.png +57141.png +68255.png +04289.png +36510.png +48243.png +13912.png +06982.png +35002.png +24909.png +42292.png +14980.png +34009.png +55638.png +18785.png +50584.png +08565.png +21206.png +19697.png +28925.png +58118.png +09942.png +07960.png +20198.png +18740.png +18410.png +09707.png +13522.png +56018.png +09431.png +63223.png +67596.png +44190.png +07706.png +64447.png +07927.png +17816.png +49159.png +31530.png +57366.png +51990.png +61903.png +24526.png +53595.png +15400.png +56761.png +01329.png +49627.png +00937.png +24279.png +07689.png +15325.png +29697.png +31031.png +08796.png +17029.png +42826.png +66302.png +25576.png +29877.png +14790.png +16219.png +12457.png +02048.png +19940.png +59870.png +56816.png +17425.png +25065.png +10434.png +47992.png +15799.png +64826.png +01802.png +40884.png +42600.png +56118.png +24538.png +24321.png +20551.png +35406.png +45258.png +04043.png +64425.png +15116.png +05222.png +44624.png +45497.png +25373.png +65800.png +65175.png +38692.png +33680.png +35956.png +03730.png +40930.png +32125.png +46253.png +21699.png +43915.png +47457.png +59761.png +33965.png +10667.png +51239.png +28078.png +63899.png +33673.png +16691.png +27245.png +13694.png +68890.png +09260.png +08472.png +31002.png +17729.png +29273.png +50832.png +10016.png +06067.png +67156.png +44735.png +69862.png +24912.png +65188.png +15801.png +27822.png +37408.png +07121.png +26727.png +14369.png +02424.png +32349.png +63449.png +43942.png +02787.png +27127.png +38477.png +37493.png +18948.png +22053.png +31683.png +66975.png +39382.png +61820.png +41053.png +08140.png +35696.png +49184.png +42932.png +22916.png +45062.png +05428.png +64444.png +67560.png +25030.png +58168.png +03953.png +44412.png +57526.png +39989.png +29831.png +53299.png +18775.png +06038.png +09066.png +45803.png +12897.png +01550.png +02363.png +08925.png +37990.png +06886.png +57922.png +27652.png +62732.png +16687.png +20240.png +58297.png +14453.png +04639.png +22002.png +51019.png +19147.png +12183.png +02433.png +64997.png +18036.png +49518.png +67963.png +41823.png +51608.png +35600.png +02816.png +12325.png +57876.png +51331.png +69226.png +57330.png +30837.png +08232.png +44025.png +55805.png +02826.png +56050.png +18159.png +15920.png +37251.png +02624.png +05638.png +47951.png +02529.png +32824.png +47678.png +57043.png +14432.png +45677.png +60569.png +28198.png +12287.png +04352.png +49356.png +52612.png +02136.png +03565.png +11761.png +15233.png +40343.png +20493.png +10403.png +55154.png +29377.png +02237.png +27669.png +69186.png +17152.png +58378.png +39417.png +18158.png +10621.png +04925.png +25681.png +32465.png +68979.png +11880.png +12800.png +16000.png +10056.png +39841.png +40351.png +15627.png +08889.png +37805.png +41115.png +43380.png +38406.png +48219.png +18633.png +06119.png +57048.png +65945.png +29425.png +06614.png +50704.png +54869.png +38899.png +65105.png +47264.png +12617.png +14523.png +42792.png +60160.png +38753.png +30388.png +18271.png +26319.png +05371.png +66724.png +34267.png +56373.png +36934.png +33369.png +45135.png +29174.png +22868.png +46434.png +23115.png +56031.png +48079.png +59941.png +06160.png +01338.png +59504.png +00389.png +00306.png +45619.png +56868.png +67250.png +25283.png +57875.png +15182.png +61326.png +17198.png +16828.png +14581.png +69870.png +56092.png +55912.png +31984.png +50330.png +02583.png +41695.png +56653.png +62683.png +00959.png +00718.png +59551.png +09175.png +44802.png +36892.png +05702.png +63579.png +08972.png +60471.png +35521.png +68684.png +40587.png +25076.png +03595.png +17559.png +01627.png +58911.png +05346.png +57628.png +29640.png +21410.png +39662.png +09622.png +14027.png +50840.png +56030.png +19475.png +47771.png +04826.png +05283.png +24087.png +50759.png +29556.png +24297.png +29836.png +12480.png +38661.png +42912.png +44551.png +69145.png +00267.png +19714.png +33142.png +44027.png +04760.png +28307.png +38716.png +61989.png +37437.png +64065.png +67909.png +07118.png +58029.png +17495.png +51812.png +43860.png +06777.png +49888.png +42985.png +61559.png +45394.png +56887.png +42904.png +12975.png +40706.png +26488.png +63804.png +30915.png +60012.png +22255.png +39274.png +24626.png +54560.png +20014.png +00099.png +35061.png +22724.png +08747.png +22517.png +31948.png +60399.png +25086.png +45789.png +12510.png +28881.png +02465.png +16271.png +57378.png +02344.png +61731.png +21778.png +18350.png +57354.png +18404.png +57735.png +16892.png +10837.png +07245.png +32877.png +47140.png +26048.png +21858.png +35936.png +18095.png +01855.png +25033.png +20451.png +23941.png +44209.png +41103.png +40205.png +68502.png +59051.png +63526.png +45972.png +32826.png +46882.png +30204.png +18474.png +64446.png +09865.png +02405.png +04697.png +02368.png +44327.png +69600.png +08501.png +45981.png +47045.png +55592.png +36128.png +62863.png +57497.png +29789.png +55888.png +45046.png +20258.png +50899.png +62997.png +04694.png +34803.png +34838.png +37439.png +23457.png +67196.png +69973.png +69578.png +10734.png +21165.png +07250.png +45512.png +54550.png +04248.png +14311.png +31815.png +13579.png +45093.png +10506.png +32969.png +40728.png +32253.png +68767.png +50601.png +47909.png +55950.png +09954.png +68535.png +21487.png +37448.png +12805.png +54695.png +46952.png +17115.png +07433.png +31352.png +51900.png +00137.png +12131.png +16475.png +09049.png +10624.png +05363.png +65649.png +24398.png +46741.png +48702.png +66900.png +56063.png +08930.png +08406.png +30525.png +11679.png +50974.png +14977.png +62135.png +61360.png +21037.png +48733.png +37948.png +65867.png +43102.png +08697.png +29170.png +67432.png +46877.png +08924.png +52291.png +20402.png +24671.png +31848.png +57811.png +65606.png +13902.png +35921.png +25375.png +49474.png +04530.png +57620.png +04696.png +17065.png +68388.png +47380.png +60795.png +15264.png +52679.png +26041.png +29340.png +48891.png +44422.png +51481.png +31158.png +26283.png +04763.png +65872.png +28069.png +23419.png +33544.png +36382.png +51645.png +17769.png +22347.png +01441.png +30961.png +46501.png +13163.png +11424.png +69897.png +02339.png +36653.png +24722.png +35550.png +48315.png +51947.png +25642.png +44656.png +29991.png +07332.png +01380.png +44077.png +18049.png +37788.png +26431.png +54441.png +04015.png +66005.png +13233.png +51081.png +63371.png +10239.png +60754.png +29867.png +04853.png +40239.png +15864.png +35614.png +29025.png +24733.png +62336.png +63793.png +66351.png +21148.png +53465.png +34933.png +37271.png +03955.png +28247.png +11514.png +54649.png +32054.png +64831.png +53696.png +61641.png +16550.png +42997.png +67260.png +05770.png +17998.png +44896.png +39760.png +51650.png +23663.png +27316.png +67891.png +63599.png +59482.png +68236.png +07724.png +31742.png +03172.png +34100.png +44050.png +34921.png +41128.png +13685.png +52604.png +62685.png +53441.png +67463.png +12949.png +59219.png +23007.png +57463.png +27793.png +22308.png +25142.png +09414.png +30129.png +56685.png +63310.png +53068.png +17782.png +07389.png +64858.png +49492.png +56794.png +54195.png +10179.png +46146.png +26918.png +68866.png +11758.png +49230.png +66126.png +47697.png +31100.png +47748.png +61948.png +69126.png +19827.png +69005.png +20244.png +46615.png +22908.png +32274.png +11256.png +46943.png +44297.png +66803.png +48829.png +44701.png +45226.png +09413.png +11467.png +46043.png +09863.png +41280.png +09048.png +59423.png +60550.png +15596.png +30922.png +08283.png +34380.png +35516.png +46743.png +39341.png +54557.png +53845.png +66192.png +52748.png +07901.png +59563.png +42354.png +09565.png +69153.png +54493.png +25458.png +34414.png +01579.png +34951.png +43977.png +49915.png +01457.png +24463.png +41087.png +05599.png +10690.png +56122.png +19219.png +11961.png +53148.png +30607.png +61030.png +07635.png +52117.png +09616.png +01931.png +54014.png +60397.png +31851.png +14193.png +65441.png +59703.png +27334.png +19120.png +58554.png +11190.png +66823.png +54975.png +18002.png +06721.png +10651.png +09768.png +33739.png +02690.png +10285.png +66925.png +11287.png +08663.png +24316.png +16887.png +23972.png +64075.png +45573.png +20967.png +23529.png +18323.png +50520.png +33853.png +40225.png +18649.png +57885.png +10575.png +47579.png +69327.png +43341.png +61144.png +49784.png +39753.png +30310.png +03139.png +66358.png +57453.png +29232.png +30996.png +22001.png +60938.png +10650.png +33218.png +12103.png +47170.png +09888.png +35448.png +54485.png +09139.png +60501.png +59591.png +37866.png +52917.png +09996.png +39429.png +57834.png +06629.png +69165.png +36076.png +51121.png +32087.png +37465.png +61563.png +02723.png +33522.png +10247.png +03520.png +26581.png +67096.png +29800.png +26070.png +31910.png +08500.png +09988.png +29985.png +28468.png +07150.png +20917.png +01769.png +47845.png +49796.png +62308.png +65983.png +02292.png +51869.png +03156.png +48703.png +63359.png +41216.png +55663.png +56833.png +04178.png +58624.png +35751.png +51840.png +17969.png +68865.png +04087.png +07051.png +04360.png +08908.png +42024.png +44223.png +00024.png +03187.png +53341.png +09412.png +69902.png +01518.png +11306.png +22046.png +28916.png +66765.png +07260.png +63530.png +17259.png +08911.png +34860.png +37915.png +59891.png +61894.png +14818.png +14697.png +32059.png +57302.png +41136.png +05072.png +58591.png +45949.png +30731.png +07929.png +05452.png +41897.png +66617.png +11882.png +37329.png +08431.png +07515.png +14661.png +23875.png +05176.png +40121.png +42911.png +30056.png +44251.png +33773.png +06512.png +03631.png +37478.png +15639.png +35054.png +42447.png +06195.png +51730.png +17183.png +43700.png +13104.png +21733.png +40135.png +15141.png +39911.png +02946.png +39968.png +67293.png +20957.png +29963.png +48800.png +43219.png +53445.png +23511.png +27035.png +35740.png +31231.png +50177.png +24831.png +65442.png +02963.png +32771.png +12107.png +60294.png +00890.png +13513.png +23803.png +68287.png +16053.png +64715.png +45481.png +57368.png +41926.png +53790.png +22237.png +65743.png +09697.png +21200.png +09452.png +37613.png +30328.png +20946.png +25823.png +23817.png +23749.png +33814.png +10209.png +63806.png +48811.png +66554.png +62433.png +22074.png +40096.png +64281.png +19143.png +38303.png +12790.png +28643.png +10314.png +37433.png +35231.png +47512.png +31557.png +60963.png +03415.png +19014.png +08658.png +65114.png +27173.png +10603.png +09031.png +41616.png +16266.png +36484.png +15097.png +51269.png +29689.png +68844.png +45780.png +46397.png +24647.png +69688.png +59614.png +27475.png +11018.png +14188.png +54875.png +62509.png +30450.png +31487.png +37647.png +63894.png +25493.png +41528.png +03508.png +16603.png +36874.png +03676.png +38326.png +10411.png +55927.png +56642.png +21747.png +24143.png +46637.png +59138.png +50526.png +57004.png +33449.png +03479.png +25048.png +19462.png +24839.png +33039.png +32291.png +64770.png +56201.png +33019.png +27928.png +63702.png +66655.png +24635.png +24015.png +46767.png +53453.png +29834.png +23779.png +45027.png +34914.png +34475.png +12529.png +25606.png +57312.png +13541.png +30861.png +44038.png +40979.png +53625.png +11445.png +19114.png +59081.png +27479.png +16811.png +58660.png +63031.png +62845.png +42386.png +40661.png +54884.png +41091.png +09198.png +35389.png +15772.png +65643.png +16115.png +34570.png +02021.png +52217.png +51928.png +11057.png +42816.png +35096.png +04272.png +24916.png +47902.png +33874.png +65083.png +09069.png +14496.png +24462.png +23401.png +52770.png +65641.png +57202.png +44737.png +67656.png +68848.png +65485.png +49397.png +50277.png +03433.png +35859.png +50848.png +05597.png +65311.png +00577.png +24205.png +60326.png +62196.png +38429.png +32701.png +68090.png +42546.png +17294.png +21050.png +05621.png +68080.png +60153.png +08512.png +63148.png +48190.png +65053.png +14630.png +36411.png +11005.png +43106.png +51602.png +44759.png +45489.png +43199.png +56392.png +10940.png +18871.png +15833.png +07183.png +32304.png +24900.png +58071.png +36375.png +21623.png +37382.png +50845.png +48311.png +11779.png +40863.png +47825.png +26430.png +00193.png +28611.png +01674.png +66963.png +41003.png +66514.png +51782.png +28638.png +62634.png +50569.png +12650.png +06184.png +24520.png +40029.png +23297.png +21215.png +49743.png +25870.png +49611.png +05908.png +11675.png +02708.png +64660.png +55710.png +19188.png +59617.png +15777.png +54947.png +02489.png +42308.png +15852.png +01926.png +54067.png +34473.png +40568.png +17462.png +21607.png +02443.png +05496.png +36457.png +02242.png +51985.png +06347.png +10835.png +49032.png +05581.png +54533.png +62263.png +65659.png +12316.png +10759.png +34087.png +19949.png +31265.png +22824.png +19778.png +25014.png +21428.png +59774.png +54786.png +46738.png +14719.png +09223.png +32695.png +17108.png +69659.png +62406.png +07818.png +60296.png +44294.png +53705.png +39184.png +06255.png +05235.png +05903.png +12929.png +17291.png +00210.png +27358.png +47765.png +23784.png +09908.png +49827.png +65955.png +50599.png +41660.png +42101.png +44980.png +49547.png +24618.png +35684.png +38175.png +03966.png +50348.png +49236.png +40129.png +31196.png +06128.png +55072.png +27512.png +00476.png +05489.png +30311.png +15094.png +60310.png +25629.png +03691.png +17685.png +64866.png +57891.png +01240.png +49391.png +65984.png +52828.png +30221.png +09875.png +35467.png +67070.png +61851.png +42869.png +38037.png +06937.png +53408.png +34514.png +47479.png +25701.png +07512.png +39581.png +05654.png +48266.png +50690.png +13222.png +30480.png +27739.png +17766.png +16436.png +29124.png +53222.png +65938.png +66691.png +51592.png +53615.png +00324.png +31034.png +45973.png +20889.png +26228.png +59359.png +62964.png +05762.png +52939.png +04890.png +18483.png +33881.png +52893.png +53531.png +11224.png +37326.png +01231.png +01214.png +12582.png +09568.png +14698.png +02351.png +16777.png +55294.png +68859.png +07459.png +30054.png +66262.png +00220.png +38726.png +67950.png +03683.png +59457.png +55913.png +67649.png +16427.png +35233.png +68948.png +21927.png +19058.png +00906.png +41436.png +33733.png +56935.png +68750.png +07035.png +12597.png +49489.png +13754.png +62763.png +28900.png +35777.png +55780.png +38552.png +11464.png +36194.png +35637.png +38239.png +05662.png +44260.png +03152.png +43940.png +39649.png +40038.png +43058.png +67651.png +49713.png +36549.png +18078.png +62691.png +36680.png +41671.png +69874.png +10290.png +45880.png +48781.png +15496.png +58077.png +38278.png +66430.png +63761.png +48171.png +65020.png +01076.png +49339.png +06094.png +10020.png +51446.png +50154.png +50943.png +03764.png +63286.png +02367.png +23181.png +69499.png +52788.png +30277.png +66612.png +19343.png +28600.png +46100.png +47090.png +13080.png +28589.png +63419.png +36285.png +48542.png +39781.png +18496.png +27076.png +16813.png +67289.png +61934.png +43807.png +53004.png +22857.png +50647.png +53724.png +09633.png +20296.png +44274.png +13316.png +52387.png +53867.png +48268.png +68354.png +24804.png +08703.png +34859.png +62743.png +51604.png +55476.png +21891.png +67708.png +02057.png +45432.png +32276.png +45371.png +27951.png +27054.png +11221.png +47633.png +24215.png +37981.png +01600.png +57295.png +63613.png +14351.png +53778.png +59436.png +45193.png +69834.png +31197.png +24376.png +52865.png +00897.png +64504.png +62034.png +06246.png +04375.png +50721.png +52214.png +61527.png +31426.png +01298.png +65598.png +01766.png +48491.png +09939.png +65117.png +24500.png +14608.png +57386.png +27156.png +34626.png +14304.png +33179.png +46179.png +69602.png +45003.png +51755.png +30536.png +44028.png +35761.png +43045.png +11522.png +38345.png +50838.png +21246.png +34925.png +07276.png +02183.png +61596.png +23089.png +00480.png +31741.png +11204.png +06591.png +23079.png +51046.png +65881.png +50406.png +15890.png +22701.png +42476.png +32179.png +19708.png +68126.png +46753.png +32963.png +07123.png +31797.png +08367.png +12958.png +52499.png +58644.png +56437.png +64159.png +51530.png +41605.png +61884.png +26836.png +37194.png +17695.png +36562.png +32525.png +60788.png +34186.png +36275.png +34579.png +44728.png +11116.png +50149.png +16164.png +43212.png +13557.png +00213.png +33362.png +38998.png +18068.png +07914.png +19504.png +32283.png +05041.png +38051.png +51314.png +05376.png +16402.png +15602.png +42416.png +46909.png +30305.png +51264.png +40261.png +07209.png +58604.png +39418.png +33811.png +23867.png +63923.png +31016.png +60028.png +40780.png +24213.png +58224.png +07338.png +48827.png +35543.png +15083.png +53580.png +61597.png +04453.png +45317.png +01945.png +37185.png +41124.png +07839.png +12942.png +45877.png +35606.png +04620.png +02757.png +62589.png +66738.png +03782.png +29739.png +12708.png +59597.png +55192.png +47201.png +08072.png +42991.png +61238.png +26760.png +47691.png +67204.png +53238.png +11914.png +39695.png +45770.png +52759.png +69190.png +22462.png +57401.png +47694.png +67258.png +50160.png +22630.png +11279.png +48421.png +45130.png +19257.png +03222.png +11320.png +40614.png +64412.png +20579.png +19220.png +67487.png +00263.png +23995.png +59871.png +13307.png +25165.png +20484.png +67334.png +21500.png +36271.png +19517.png +52862.png +48804.png +02266.png +22840.png +27605.png +25410.png +62899.png +40897.png +42809.png +44062.png +57059.png +02916.png +05124.png +03006.png +28907.png +24338.png +44137.png +67581.png +09236.png +61911.png +11131.png +62828.png +36031.png +22342.png +21811.png +34412.png +23586.png +04277.png +07532.png +69528.png +21453.png +41865.png +12809.png +22526.png +37444.png +04634.png +46401.png +30815.png +23236.png +43532.png +05713.png +19794.png +48407.png +24356.png +40966.png +17173.png +01168.png +41438.png +12723.png +57194.png +33950.png +09501.png +30157.png +59213.png +64183.png +19871.png +06110.png +55333.png +66164.png +65028.png +67928.png +00463.png +13604.png +34683.png +57124.png +18643.png +15941.png +34445.png +42691.png +43399.png +15238.png +45507.png +24263.png +47261.png +67849.png +19808.png +17914.png +31223.png +08492.png +30306.png +52070.png +32241.png +37135.png +34804.png +10296.png +45232.png +49447.png +17272.png +20714.png +50967.png +20195.png +08954.png +10891.png +31308.png +07603.png +23523.png +50929.png +33134.png +60640.png +43589.png +51236.png +05884.png +32903.png +35039.png +26926.png +12839.png +04457.png +01173.png +58558.png +23468.png +33565.png +48449.png +39542.png +40852.png +16413.png +63151.png +55351.png +50340.png +37131.png +29409.png +43886.png +43340.png +34868.png +33284.png +59676.png +58163.png +36306.png +32985.png +09456.png +49306.png +36883.png +16971.png +25669.png +09884.png +24728.png +23620.png +38566.png +38986.png +14702.png +32885.png +37896.png +21765.png +21975.png +30513.png +54648.png +19541.png +24629.png +07875.png +16460.png +67202.png +42382.png +36251.png +13397.png +54405.png +44677.png +65134.png +65391.png +25191.png +15676.png +06140.png +55500.png +01216.png +18656.png +43646.png +65277.png +53651.png +14585.png +38532.png +27190.png +42070.png +29337.png +23321.png +01724.png +55424.png +49588.png +43372.png +55185.png +54305.png +19056.png +59032.png +50841.png +63418.png +19825.png +66740.png +01422.png +30028.png +35564.png +32023.png +58110.png +56489.png +56881.png +53217.png +37190.png +00445.png +41681.png +00759.png +64149.png +40355.png +61515.png +26444.png +32873.png +04328.png +38366.png +22476.png +44186.png +49308.png +42353.png +30605.png +67647.png +18033.png +02532.png +50531.png +28909.png +35362.png +21647.png +51223.png +42790.png +18260.png +21779.png +23711.png +19500.png +05241.png +37088.png +10085.png +29968.png +37589.png +58074.png +05464.png +00469.png +34571.png +41039.png +37640.png +51203.png +36858.png +69163.png +25401.png +67311.png +50780.png +68524.png +04586.png +01524.png +13492.png +12864.png +64048.png +29821.png +68569.png +62530.png +22527.png +27693.png +27701.png +49420.png +30884.png +12343.png +07095.png +65410.png +48406.png +40915.png +68318.png +60836.png +39419.png +58200.png +34213.png +40251.png +66631.png +37504.png +36491.png +01537.png +49991.png +53994.png +67961.png +65896.png +32005.png +10883.png +47160.png +67478.png +30649.png +24901.png +05963.png +44379.png +18165.png +62209.png +58024.png +59080.png +16158.png +13026.png +00351.png +47460.png +07587.png +08181.png +05922.png +43178.png +05388.png +38687.png +12294.png +09226.png +21369.png +01878.png +02828.png +16599.png +59793.png +31673.png +00735.png +09534.png +24288.png +65095.png +24527.png +40389.png +28530.png +32844.png +66615.png +27337.png +69409.png +57624.png +42392.png +11436.png +13922.png +69275.png +37362.png +40374.png +69028.png +22894.png +09897.png +13496.png +44961.png +01710.png +11950.png +26665.png +46852.png +43709.png +39248.png +26613.png +54895.png +04104.png +02807.png +07104.png +11574.png +43179.png +50684.png +18866.png +21407.png +53736.png +28845.png +21006.png +17731.png +50715.png +16234.png +43154.png +04808.png +01835.png +41849.png +23685.png +63281.png +26091.png +57786.png +52699.png +29452.png +47164.png +29146.png +06382.png +11082.png +04728.png +03364.png +32507.png +23791.png +23101.png +53527.png +49636.png +60659.png +44349.png +35413.png +09685.png +60148.png +06875.png +42567.png +01608.png +56802.png +62259.png +21069.png +18339.png +10409.png +64668.png +04023.png +49903.png +40113.png +08480.png +38519.png +26268.png +06792.png +07843.png +14592.png +68588.png +16871.png +06006.png +28933.png +57532.png +16575.png +44576.png +22253.png +32979.png +49003.png +45578.png +22129.png +03901.png +19695.png +27174.png +10303.png +48713.png +14215.png +10053.png +24169.png +02006.png +45900.png +67327.png +43308.png +56746.png +26405.png +05237.png +52777.png +24295.png +22296.png +38811.png +03154.png +40853.png +24561.png +47964.png +45335.png +11858.png +55585.png +38022.png +42205.png +07891.png +21865.png +11533.png +29508.png +25666.png +01625.png +34139.png +17983.png +30972.png +13191.png +18390.png +36807.png +23046.png +62476.png +68512.png +66800.png +44561.png +63492.png +45474.png +67384.png +46487.png +04551.png +48704.png +01112.png +58147.png +49281.png +63874.png +30667.png +44660.png +45150.png +62227.png +53765.png +32937.png +44569.png +69075.png +31167.png +16947.png +55628.png +17802.png +58360.png +06226.png +50957.png +15253.png +28515.png +21389.png +03802.png +11767.png +32135.png +59772.png +12237.png +06237.png +27344.png +33665.png +08451.png +49526.png +66077.png +33676.png +44946.png +17931.png +62013.png +39687.png +54739.png +21512.png +55031.png +23568.png +51515.png +00678.png +40628.png +58532.png +39237.png +42561.png +52504.png +65233.png +65238.png +17261.png +09487.png +54804.png +30189.png +12830.png +21490.png +58868.png +24541.png +37845.png +34383.png +39389.png +69983.png +11504.png +25081.png +10132.png +01657.png +10874.png +07780.png +50730.png +51384.png +48736.png +58878.png +41852.png +44614.png +45444.png +29086.png +37438.png +06213.png +17320.png +00462.png +11673.png +01784.png +16929.png +37999.png +19311.png +48651.png +21408.png +46802.png +54700.png +07326.png +26744.png +65799.png +61318.png +30609.png +36861.png +46481.png +06673.png +58688.png +54938.png +49408.png +11601.png +55733.png +47699.png +00531.png +41439.png +56888.png +30567.png +35492.png +06533.png +53797.png +68834.png +50791.png +48434.png +22021.png +19157.png +39122.png +41882.png +16880.png +45218.png +57392.png +34468.png +59780.png +43997.png +11720.png +48046.png +40032.png +29237.png +37381.png +46786.png +20344.png +42401.png +51610.png +03521.png +25395.png +51402.png +11492.png +31769.png +31472.png +01534.png +26736.png +33073.png +17880.png +03785.png +23514.png +32339.png +54898.png +53586.png +13680.png +51970.png +29307.png +57933.png +58605.png +68670.png +38772.png +54754.png +57552.png +69781.png +67500.png +66629.png +30864.png +04787.png +01485.png +13874.png +60038.png +56571.png +01870.png +24913.png +06363.png +29738.png +08814.png +55098.png +13381.png +52165.png +16695.png +16176.png +57884.png +47912.png +57433.png +56397.png +46479.png +55201.png +29379.png +36896.png +65430.png +07894.png +14628.png +16805.png +22942.png +35642.png +39370.png +24952.png +30921.png +37839.png +09329.png +04869.png +35490.png +10405.png +13852.png +60623.png +22329.png +52155.png +12530.png +26781.png +27797.png +32719.png +18442.png +14350.png +08872.png +43724.png +15009.png +06118.png +56504.png +49196.png +25964.png +59204.png +59514.png +10236.png +20400.png +03496.png +29169.png +31634.png +29881.png +07903.png +40299.png +11233.png +26857.png +58606.png +09021.png +29531.png +32871.png +38475.png +52609.png +25683.png +64194.png +51003.png +55111.png +66202.png +10358.png +15368.png +02095.png +50745.png +64603.png +46348.png +58460.png +51144.png +45595.png +53917.png +34130.png +41652.png +62244.png +53187.png +19011.png +66710.png +33141.png +43754.png +43067.png +17271.png +14954.png +43236.png +23633.png +52657.png +16132.png +12305.png +55582.png +10822.png +11389.png +44714.png +08818.png +35546.png +67944.png +01667.png +19693.png +61766.png +12608.png +19686.png +66904.png +16481.png +34701.png +67947.png +00320.png +28293.png +27378.png +28042.png +47634.png +60065.png +22775.png +17893.png +20523.png +57517.png +39401.png +29225.png +43358.png +67660.png +28391.png +63558.png +13760.png +25220.png +15966.png +36854.png +21425.png +64936.png +29677.png +10779.png +19208.png +06499.png +34185.png +37527.png +17948.png +24664.png +37245.png +32733.png +44826.png +00342.png +32968.png +25049.png +53312.png +06504.png +30640.png +00058.png +23831.png +03456.png +37281.png +24421.png +63729.png +15901.png +44841.png +18543.png +59823.png +66432.png +08981.png +57159.png +44434.png +34840.png +02495.png +63972.png +07612.png +45118.png +11075.png +16019.png +00878.png +15043.png +03615.png +57106.png +57077.png +42324.png +20996.png +50352.png +52148.png +14009.png +30049.png +38195.png +52958.png +63077.png +09903.png +59470.png +05132.png +33677.png +40185.png +55528.png +57837.png +51392.png +47801.png +40397.png +55744.png +10059.png +02535.png +04189.png +06168.png +13995.png +50208.png +37669.png +69616.png +65103.png +00824.png +29638.png +43271.png +03249.png +35403.png +51776.png +03166.png +66547.png +65717.png +33333.png +59023.png +49656.png +09597.png +18939.png +37643.png +25814.png +50955.png +15905.png +28203.png +07047.png +61170.png +55899.png +51721.png +62822.png +01114.png +48758.png +14173.png +42898.png +52431.png +65564.png +07883.png +06814.png +57507.png +17658.png +46018.png +34821.png +20169.png +08838.png +53478.png +44898.png +00068.png +09993.png +13457.png +18400.png +40674.png +15868.png +36533.png +26786.png +58541.png +28525.png +69849.png +65237.png +00887.png +45806.png +53402.png +12379.png +41149.png +23332.png +38861.png +45499.png +69245.png +12473.png +36577.png +39468.png +26685.png +43794.png +41527.png +53136.png +18471.png +13715.png +33026.png +06743.png +37495.png +34348.png +38703.png +69840.png +52620.png +51891.png +26373.png +06759.png +48375.png +09968.png +04535.png +07542.png +53661.png +00271.png +22712.png +58114.png +57947.png +34530.png +56305.png +54061.png +47946.png +00299.png +07163.png +23732.png +16553.png +43840.png +62665.png +50488.png +62892.png +60566.png +42303.png +57622.png +67177.png +36623.png +43885.png +42975.png +61855.png +41716.png +27545.png +04340.png +28473.png +62551.png +09282.png +67281.png +09727.png +32848.png +22825.png +54167.png +15084.png +06928.png +52232.png +30086.png +26855.png +51577.png +51258.png +46012.png +54904.png +17859.png +25404.png +45849.png +19201.png +62531.png +47226.png +67627.png +24944.png +06106.png +13734.png +44080.png +28455.png +54277.png +66315.png +40176.png +29549.png +64941.png +39885.png +19663.png +15138.png +43512.png +01887.png +29647.png +24373.png +68826.png +39126.png +21336.png +31048.png +37399.png +32383.png +02872.png +22659.png +39696.png +01564.png +47230.png +01505.png +55722.png +49336.png +26346.png +17410.png +20338.png +47057.png +56536.png +09941.png +36847.png +24472.png +38076.png +17071.png +16769.png +57771.png +43570.png +39777.png +41055.png +52309.png +25719.png +46347.png +26555.png +60997.png +10876.png +64406.png +01107.png +03629.png +03052.png +35735.png +43030.png +48883.png +11992.png +27748.png +52733.png +67502.png +46763.png +13742.png +29464.png +02798.png +66185.png +58972.png +15257.png +43041.png +64689.png +09258.png +51061.png +48274.png +48118.png +67344.png +34488.png +58242.png +40868.png +06986.png +29384.png +05982.png +03989.png +56147.png +43812.png +38227.png +21264.png +48746.png +08290.png +13328.png +55429.png +23805.png +14321.png +69679.png +40018.png +23019.png +67037.png +57966.png +55887.png +15318.png +61336.png +33775.png +09143.png +45412.png +62493.png +15778.png +07063.png +08023.png +01876.png +51332.png +35877.png +43628.png +28771.png +44772.png +28072.png +50890.png +10549.png +09407.png +26775.png +42535.png +09013.png +53379.png +22556.png +04845.png +18924.png +05180.png +09321.png +06381.png +44629.png +20486.png +37400.png +62812.png +45683.png +30352.png +23464.png +24013.png +19170.png +05795.png +61413.png +10121.png +03536.png +33183.png +57980.png +28276.png +31963.png +50139.png +27945.png +42372.png +45005.png +65836.png +45601.png +58391.png +08953.png +00949.png +22313.png +21241.png +46813.png +39741.png +08536.png +34893.png +27434.png +34131.png +27814.png +61973.png +33156.png +31829.png +50694.png +67888.png +20673.png +15440.png +10174.png +45224.png +24754.png +49438.png +28754.png +54963.png +20256.png +37105.png +33979.png +59137.png +19922.png +15023.png +43995.png +52328.png +34976.png +69841.png +68023.png +03371.png +31423.png +29663.png +52294.png +07686.png +10325.png +20858.png +45178.png +66008.png +39060.png +49370.png +06170.png +56223.png +18364.png +35285.png +22608.png +48873.png +39827.png +49231.png +42604.png +35916.png +44695.png +07538.png +16532.png +39678.png +09180.png +65018.png +26300.png +53319.png +24284.png +33326.png +29028.png +28029.png +40573.png +01217.png +08031.png +01484.png +48306.png +13221.png +34330.png +20114.png +60704.png +38738.png +31202.png +41835.png +20239.png +27095.png +46161.png +67927.png +26925.png +17561.png +33619.png +57205.png +67618.png +29889.png +33017.png +48183.png +06574.png +05483.png +19243.png +68621.png +25586.png +16576.png +22629.png +24899.png +09919.png +12637.png +32093.png +60354.png +00524.png +60841.png +39751.png +01902.png +49360.png +07055.png +04223.png +38913.png +36960.png +09218.png +64838.png +23588.png +06717.png +68511.png +08289.png +06962.png +47268.png +27241.png +65538.png +65427.png +44411.png +43197.png +05977.png +17724.png +62229.png +23503.png +61727.png +52301.png +31789.png +47213.png +05220.png +68344.png +39357.png +67646.png +39496.png +20031.png +51839.png +25125.png +59744.png +18069.png +23472.png +64337.png +18113.png +37632.png +22334.png +17336.png +61537.png +17120.png +26315.png +03059.png +33920.png +53388.png +43002.png +18309.png +63377.png +26350.png +35493.png +67482.png +06000.png +07687.png +14440.png +26218.png +07796.png +63841.png +49295.png +18355.png +45992.png +19476.png +07932.png +64244.png +56244.png +49108.png +66614.png +30511.png +18208.png +37296.png +07669.png +36005.png +64832.png +10778.png +33927.png +55936.png +60891.png +37019.png +69587.png +05229.png +07951.png +25974.png +34096.png +63699.png +52185.png +63342.png +15125.png +22872.png +23509.png +19247.png +65301.png +68340.png +33299.png +08795.png +63126.png +13049.png +48774.png +29571.png +41384.png +04563.png +57961.png +47118.png +28534.png +27725.png +28117.png +62930.png +65350.png +49554.png +44378.png +55010.png +19858.png +15481.png +68994.png +52544.png +15302.png +49626.png +61024.png +31926.png +03932.png +28979.png +47654.png +25524.png +00764.png +61620.png +01925.png +37217.png +51677.png +52992.png +59872.png +54252.png +21484.png +53579.png +48684.png +06860.png +55307.png +05841.png +52432.png +03737.png +29955.png +07690.png +56134.png +23512.png +44832.png +68990.png +14042.png +34543.png +41851.png +27800.png +65675.png +02776.png +29281.png +50003.png +00437.png +63665.png +60469.png +69234.png +67676.png +03748.png +10300.png +14944.png +20816.png +15526.png +08958.png +40243.png +45332.png +27277.png +15192.png +13272.png +53718.png +43443.png +60779.png +16324.png +37316.png +31868.png +27626.png +30775.png +44134.png +20565.png +14634.png +61253.png +54953.png +42346.png +49664.png +19065.png +31209.png +10614.png +55945.png +69526.png +26251.png +66165.png +30662.png +15287.png +00276.png +66949.png +01801.png +51874.png +50144.png +29347.png +00340.png +16757.png +04196.png +55768.png +52574.png +28158.png +22016.png +55977.png +59925.png +33038.png +60463.png +43978.png +15243.png +59655.png +63518.png +57468.png +10338.png +24344.png +09987.png +13054.png +50215.png +18744.png +15844.png +05141.png +11433.png +22211.png +14504.png +00922.png +53381.png +48798.png +34709.png +56374.png +21592.png +08734.png +22689.png +14806.png +15950.png +01262.png +52386.png +59670.png +10457.png +09927.png +19544.png +21678.png +03904.png +19378.png +14894.png +12684.png +25600.png +47296.png +24315.png +62875.png +05179.png +16458.png +45363.png +67717.png +05135.png +15733.png +57139.png +35577.png +46394.png +07527.png +66239.png +20266.png +34176.png +55133.png +13717.png +53979.png +32922.png +53853.png +59086.png +63078.png +09105.png +04031.png +41133.png +39034.png +25366.png +44177.png +60657.png +62236.png +68469.png +39724.png +47999.png +29400.png +41401.png +44414.png +25866.png +30246.png +26633.png +52689.png +08379.png +04795.png +69351.png +55383.png +15677.png +51977.png +45649.png +09581.png +60479.png +00894.png +30069.png +11354.png +44418.png +44623.png +67537.png +02238.png +23014.png +06632.png +47300.png +29365.png +37487.png +64068.png +15432.png +11007.png +42620.png +38784.png +14090.png +02746.png +38863.png +37210.png +12865.png +61001.png +45876.png +36967.png +56403.png +55455.png +18360.png +25044.png +60489.png +46449.png +01885.png +59932.png +68856.png +67012.png +59721.png +07803.png +38936.png +57967.png +48319.png +63184.png +53885.png +36768.png +55060.png +14415.png +55204.png +67633.png +55958.png +40879.png +61134.png +16288.png +20238.png +46495.png +11623.png +37268.png +49140.png +10771.png +37609.png +09150.png +61227.png +33049.png +12270.png +20291.png +04810.png +19736.png +53398.png +15416.png +51470.png +64673.png +00334.png +22132.png +09777.png +55427.png +62283.png +15067.png +38437.png +10631.png +32491.png +44437.png +48627.png +08124.png +67319.png +65322.png +55699.png +57833.png +58041.png +10431.png +38964.png +03690.png +51466.png +22431.png +31297.png +10905.png +16899.png +67148.png +37840.png +35352.png +29147.png +16339.png +50200.png +29089.png +61173.png +55965.png +44079.png +36245.png +44567.png +45792.png +05731.png +66413.png +66702.png +29851.png +53331.png +21702.png +58088.png +59378.png +38723.png +46214.png +44721.png +56770.png +49761.png +32737.png +08709.png +06009.png +11823.png +22405.png +16498.png +18771.png +30991.png +59270.png +55332.png +59656.png +49663.png +49493.png +51152.png +58914.png +03163.png +56670.png +58654.png +28064.png +46051.png +62931.png +10921.png +52145.png +66687.png +59150.png +10525.png +64437.png +54159.png +04945.png +43383.png +60948.png +01851.png +19906.png +50252.png +63140.png +58767.png +42479.png +50668.png +69824.png +25381.png +48429.png +62967.png +33658.png +50220.png +04185.png +36728.png +49114.png +37534.png +47702.png +51773.png +11696.png +13934.png +19371.png +48228.png +24793.png +57087.png +44096.png +68998.png +38421.png +57732.png +66329.png +55955.png +06222.png +53072.png +19762.png +47954.png +58287.png +21467.png +12402.png +65495.png +38088.png +34171.png +46822.png +32671.png +57347.png +14593.png +49943.png +24905.png +17891.png +37154.png +02794.png +13781.png +17359.png +17197.png +00939.png +69184.png +32734.png +67910.png +23338.png +60921.png +40801.png +33639.png +33815.png +32336.png +35707.png +12092.png +50829.png +55081.png +46745.png +17443.png +41781.png +23602.png +17678.png +07446.png +45383.png +47943.png +07457.png +66104.png +60763.png +00170.png +64343.png +05275.png +19623.png +10638.png +57698.png +15532.png +49234.png +62239.png +15441.png +61825.png +30646.png +68724.png +63102.png +49736.png +33942.png +69794.png +52532.png +54288.png +23274.png +54414.png +06733.png +28625.png +14162.png +54518.png +42511.png +42617.png +50148.png +47682.png +59505.png +45253.png +55902.png +44602.png +56867.png +12644.png +32287.png +41213.png +60824.png +52202.png +26614.png +11270.png +05149.png +46671.png +63149.png +12556.png +59002.png +03186.png +08599.png +60490.png +55680.png +20205.png +59432.png +28159.png +33499.png +48194.png +29962.png +01316.png +37421.png +61309.png +02012.png +22042.png +68008.png +21518.png +64657.png +11194.png +55170.png +02938.png +32281.png +17900.png +02988.png +26561.png +32919.png +59260.png +05419.png +43484.png +68051.png +68693.png +26356.png +63958.png +40223.png +43126.png +02536.png +18428.png +68042.png +43941.png +50471.png +31653.png +07942.png +47267.png +39568.png +00893.png +29621.png +54684.png +59431.png +69377.png +21723.png +31544.png +20829.png +33112.png +46036.png +51847.png +38091.png +15099.png +03742.png +04863.png +04262.png +34204.png +02600.png +46557.png +36394.png +06919.png +52690.png +33779.png +11890.png +00196.png +34635.png +61147.png +57822.png +49458.png +15305.png +69167.png +64479.png +41976.png +21435.png +61188.png +33170.png +33807.png +03004.png +45580.png +26086.png +65851.png +12428.png +37351.png +27514.png +44882.png +26448.png +33787.png +17372.png +59899.png +30055.png +49235.png +58569.png +56572.png +25099.png +58680.png +10747.png +17446.png +33498.png +65979.png +57936.png +28184.png +55337.png +40444.png +51861.png +27861.png +02252.png +47030.png +53871.png +53421.png +20709.png +15512.png +55657.png +10030.png +64509.png +02804.png +04613.png +32295.png +39303.png +13245.png +69157.png +21171.png +56002.png +25800.png +08610.png +55542.png +62137.png +43612.png +56937.png +40386.png +65687.png +40145.png +40952.png +00738.png +16587.png +64692.png +64821.png +54908.png +17235.png +41491.png +00814.png +36460.png +01795.png +58950.png +01776.png +14068.png +49357.png +11015.png +38237.png +41445.png +16709.png +46554.png +10623.png +13099.png +18187.png +35798.png +01342.png +66147.png +37280.png +67472.png +01681.png +43670.png +69596.png +59493.png +30684.png +22417.png +58381.png +24079.png +50918.png +49689.png +02075.png +49820.png +00060.png +16711.png +23431.png +17102.png +29431.png +26741.png +26772.png +63234.png +46870.png +63122.png +65542.png +01794.png +67490.png +69329.png +57390.png +59068.png +60049.png +39830.png +54839.png +51922.png +44088.png +22444.png +57797.png +00358.png +52332.png +56541.png +17469.png +26482.png +42563.png +22101.png +35122.png +22739.png +29838.png +14975.png +02260.png +43310.png +29567.png +65129.png +66736.png +46576.png +25585.png +35919.png +38676.png +44517.png +32489.png +03272.png +63705.png +29189.png +22805.png +37356.png +27132.png +10225.png +42227.png +60791.png +28105.png +29792.png +67865.png +43232.png +15628.png +45137.png +61149.png +19826.png +61889.png +30247.png +10960.png +62252.png +39072.png +64055.png +11558.png +69484.png +39044.png +28541.png +09362.png +34533.png +20866.png +36162.png +38872.png +02230.png +52836.png +51973.png +48869.png +20160.png +33611.png +44892.png +49639.png +26559.png +49592.png +37994.png +45660.png +15704.png +40642.png +09396.png +10576.png +15682.png +64441.png +24774.png +69203.png +48255.png +66981.png +05250.png +61958.png +15122.png +46123.png +68854.png +21958.png +47701.png +48506.png +03829.png +33004.png +22258.png +25005.png +45700.png +39592.png +25597.png +23010.png +07297.png +67066.png +32506.png +31725.png +16885.png +07256.png +48720.png +65638.png +68032.png +34080.png +08158.png +28270.png +40494.png +05062.png +27357.png +49516.png +55512.png +52005.png +69905.png +57269.png +18998.png +08824.png +20851.png +17503.png +10830.png +16107.png +05640.png +21048.png +38425.png +60331.png +35457.png +38408.png +20124.png +39878.png +31156.png +25345.png +49534.png +13678.png +55622.png +62653.png +17229.png +66378.png +45767.png +22447.png +36175.png +51658.png +44487.png +05761.png +41593.png +69038.png +27195.png +17686.png +34780.png +31958.png +43336.png +12085.png +29790.png +53266.png +69547.png +44947.png +28457.png +05981.png +45592.png +33753.png +11639.png +11550.png +04252.png +49013.png +52058.png +29511.png +55365.png +16084.png +48312.png +68739.png +08422.png +50991.png +44715.png +22539.png +15341.png +01751.png +06910.png +04139.png +55082.png +56772.png +14545.png +12431.png +62686.png +42735.png +18988.png +46572.png +45238.png +19903.png +46991.png +55595.png +67661.png +37869.png +35607.png +55306.png +68065.png +51661.png +04156.png +00645.png +28116.png +48797.png +54355.png +53980.png +63273.png +21065.png +39446.png +12855.png +17251.png +61655.png +15505.png +41480.png +49037.png +35682.png +29517.png +02293.png +48852.png +66382.png +18038.png +01034.png +64791.png +30597.png +59515.png +51080.png +62529.png +26524.png +31780.png +61813.png +47812.png +56404.png +64085.png +09322.png +51178.png +64605.png +61362.png +39613.png +31019.png +53377.png +61506.png +41825.png +00064.png +36036.png +28684.png +05121.png +17543.png +38761.png +56883.png +69767.png +18014.png +65067.png +05110.png +01901.png +27905.png +56580.png +02551.png +42184.png +34163.png +64015.png +31376.png +65113.png +05022.png +29711.png +03608.png +13073.png +68906.png +05028.png +63237.png +55652.png +37591.png +68505.png +30465.png +17763.png +36702.png +67670.png +25729.png +30717.png +58234.png +54204.png +37178.png +34631.png +26762.png +13797.png +69751.png +04007.png +52471.png +35749.png +31061.png +02035.png +27188.png +03125.png +49410.png +12604.png +64192.png +19004.png +09602.png +31790.png +20591.png +18971.png +55860.png +36226.png +57647.png +06749.png +21724.png +12078.png +53888.png +22862.png +37603.png +53895.png +28487.png +58096.png +36789.png +04838.png +22613.png +69057.png +67333.png +09029.png +05583.png +41440.png +18032.png +64288.png +29333.png +06354.png +04103.png +23679.png +48469.png +10637.png +45059.png +16191.png +41113.png +34906.png +49280.png +20793.png +02771.png +69458.png +00114.png +03514.png +51692.png +39535.png +61074.png +23435.png +09580.png +40054.png +31030.png +10033.png +65077.png +31945.png +12017.png +40053.png +05091.png +44973.png +20807.png +62628.png +37353.png +65069.png +66862.png +15594.png +49124.png +57744.png +13729.png +13252.png +68515.png +38185.png +44369.png +08845.png +37193.png +63622.png +45292.png +66393.png +24841.png +11341.png +19162.png +23105.png +23544.png +63895.png +45158.png +23098.png +59331.png +05236.png +35420.png +58834.png +61988.png +59214.png +46970.png +57761.png +08992.png +46711.png +47144.png +66505.png +68916.png +29634.png +25656.png +67443.png +33951.png +27137.png +50691.png +21909.png +38681.png +08867.png +44311.png +60260.png +27330.png +52897.png +24290.png +47870.png +36595.png +54176.png +38394.png +57803.png +06896.png +17905.png +10101.png +21031.png +14081.png +61062.png +14302.png +14784.png +64594.png +45061.png +58270.png +35473.png +01027.png +59530.png +40474.png +52888.png +37384.png +68451.png +08364.png +53593.png +44464.png +42921.png +31675.png +12935.png +57661.png +10530.png +46876.png +26183.png +36250.png +32512.png +67410.png +35922.png +32439.png +36438.png +09088.png +43283.png +57919.png +43468.png +41467.png +29207.png +24413.png +64360.png +02695.png +09632.png +19945.png +49941.png +21262.png +09229.png +30984.png +20324.png +11587.png +09135.png +64778.png +58933.png +24503.png +66154.png +59699.png +02244.png +50786.png +10048.png +55282.png +50279.png +16920.png +57255.png +02811.png +53226.png +31067.png +25287.png +22677.png +52676.png +23083.png +35930.png +41688.png +09206.png +42631.png +06971.png +26473.png +34424.png +12787.png +13056.png +32900.png +63054.png +61706.png +22819.png +11765.png +32122.png +48905.png +66150.png +68403.png +47466.png +31991.png +65725.png +15435.png +14547.png +11581.png +36989.png +04313.png +12680.png +29885.png +25623.png +61269.png +56072.png +09583.png +09190.png +48466.png +41993.png +36865.png +18144.png +34604.png +52852.png +19358.png +19655.png +36004.png +57807.png +43708.png +09980.png +55130.png +61719.png +36943.png +52421.png +43813.png +51769.png +42749.png +53210.png +20337.png +60009.png +59053.png +50147.png +24192.png +30883.png +38744.png +15579.png +19983.png +25564.png +59930.png +22886.png +08291.png +37484.png +54746.png +54223.png +29195.png +28809.png +45711.png +25703.png +64229.png +39025.png +61959.png +61427.png +49202.png +41015.png +20617.png +45819.png +54161.png +51550.png +46954.png +32351.png +56672.png +05187.png +02146.png +03031.png +17301.png +60272.png +17600.png +06936.png +67359.png +13115.png +41996.png +30744.png +41288.png +45381.png +69359.png +47185.png +31688.png +00562.png +34441.png +61282.png +47028.png +23000.png +15277.png +50739.png +33777.png +55724.png +22610.png +45747.png +34095.png +32981.png +55767.png +27317.png +43780.png +46499.png +23852.png +17157.png +42903.png +54592.png +51378.png +52586.png +05782.png +62633.png +11710.png +06491.png +57776.png +49842.png +31354.png +17771.png +55141.png +15019.png +11906.png +16013.png +32321.png +62750.png +22502.png +33734.png +26648.png +06219.png +23643.png +24485.png +26584.png +46625.png +15089.png +21635.png +03220.png +34120.png +53920.png +52675.png +63362.png +12500.png +38989.png +22753.png +03036.png +40526.png +47044.png +65159.png +18807.png +18817.png +62924.png +50843.png +02840.png +13672.png +31621.png +40124.png +03659.png +68582.png +68010.png +09649.png +26600.png +46426.png +59880.png +00549.png +37787.png +61523.png +32819.png +66433.png +58503.png +13075.png +65039.png +24113.png +19754.png +28543.png +49899.png +62051.png +22114.png +39518.png +01353.png +25315.png +36178.png +53051.png +03480.png +02478.png +36403.png +33213.png +12036.png +12981.png +45259.png +53498.png +39788.png +44101.png +27616.png +22075.png +28093.png +19807.png +33243.png +13292.png +37247.png +43287.png +59069.png +33774.png +25217.png +44962.png +14721.png +08722.png +09575.png +05694.png +13098.png +53973.png +49242.png +06555.png +34665.png +07376.png +15543.png +37000.png +29687.png +52623.png +30316.png +22454.png +09070.png +12508.png +09893.png +02859.png +31483.png +50610.png +40488.png +55086.png +18759.png +07241.png +56639.png +26883.png +45776.png +42464.png +00483.png +05647.png +23671.png +26670.png +09250.png +46505.png +45520.png +33388.png +35845.png +53335.png +66853.png +43467.png +68030.png +35489.png +59403.png +37099.png +63758.png +69577.png +00386.png +50782.png +01728.png +22425.png +44734.png +11557.png +21483.png +30722.png +47811.png +32989.png +15186.png +25607.png +01237.png +27732.png +03279.png +63795.png +07945.png +56626.png +31408.png +50856.png +36434.png +52055.png +49987.png +04029.png +20682.png +15381.png +15842.png +51628.png +02295.png +46793.png +53199.png +34437.png +18976.png +66634.png +61270.png +66395.png +68949.png +35452.png +17324.png +02557.png +60459.png +64575.png +21494.png +13290.png +20039.png +54229.png +35892.png +69909.png +33090.png +67902.png +43238.png +20589.png +42658.png +59288.png +42439.png +08666.png +36806.png +30793.png +63243.png +51716.png +13753.png +37063.png +08215.png +61179.png +59976.png +03501.png +37003.png +39624.png +32762.png +28618.png +63945.png +38871.png +29802.png +31651.png +52128.png +49744.png +41943.png +55573.png +66041.png +30167.png +63245.png +34225.png +28931.png +23084.png +41052.png +39723.png +22059.png +59345.png +02770.png +45544.png +53626.png +09238.png +63663.png +04358.png +57465.png +40942.png +43773.png +19516.png +09214.png +26368.png +62000.png +42842.png +47570.png +19021.png +43146.png +22598.png +55630.png +15008.png +27051.png +02704.png +39295.png +65869.png +52183.png +17995.png +34619.png +53751.png +21284.png +02918.png +51173.png +35940.png +59839.png +12083.png +32003.png +11643.png +12842.png +64340.png +20443.png +38328.png +62715.png +61310.png +46806.png +57896.png +24131.png +13108.png +23316.png +54349.png +43492.png +48006.png +25706.png +64001.png +12902.png +18933.png +51956.png +34999.png +47737.png +30343.png +13321.png +32345.png +23845.png +33867.png +68158.png +52093.png +11463.png +66435.png +33100.png +54752.png +25842.png +25254.png +25340.png +21557.png +57799.png +49785.png +12572.png +00844.png +41736.png +08938.png +10869.png +02823.png +49597.png +12307.png +14981.png +22850.png +67540.png +01594.png +58101.png +06199.png +64092.png +09366.png +42171.png +30074.png +41683.png +42448.png +07969.png +32913.png +22422.png +38901.png +48010.png +16533.png +36253.png +01979.png +09071.png +22602.png +31008.png +69655.png +07258.png +64814.png +62594.png +63064.png +02883.png +48922.png +53709.png +69546.png +60156.png +01449.png +69090.png +34201.png +40896.png +37338.png +25399.png +46862.png +14835.png +18693.png +49657.png +63511.png +64630.png +40437.png +03662.png +01334.png +19246.png +46917.png +13504.png +58281.png +67764.png +68513.png +55566.png +50549.png +54486.png +38824.png +33493.png +07939.png +03566.png +18947.png +47196.png +51825.png +31410.png +38275.png +43534.png +03550.png +00856.png +68411.png +51960.png +33679.png +24659.png +04447.png +25325.png +46602.png +29538.png +02187.png +08979.png +18166.png +56487.png +54287.png +33820.png +08631.png +28224.png +52674.png +64506.png +38540.png +62440.png +21371.png +56275.png +03390.png +15611.png +11325.png +33651.png +04800.png +14031.png +46818.png +61166.png +68006.png +64785.png +68699.png +05174.png +29710.png +37195.png +10955.png +33519.png +55367.png +09661.png +59180.png +40189.png +32820.png +09827.png +47054.png +42937.png +43839.png +07073.png +51587.png +24326.png +47524.png +04153.png +46153.png +34410.png +55207.png +26394.png +63619.png +04750.png +21696.png +55920.png +13442.png +24593.png +40996.png +54985.png +05077.png +53133.png +51790.png +07569.png +47717.png +13355.png +43017.png +31450.png +43889.png +29000.png +21245.png +01726.png +08331.png +45804.png +59119.png +67257.png +31280.png +10430.png +34048.png +65621.png +11568.png +31618.png +29618.png +27476.png +44758.png +04887.png +65116.png +09291.png +20892.png +40152.png +01603.png +14613.png +29700.png +51145.png +63952.png +60671.png +53619.png +23833.png +24605.png +04062.png +42487.png +10527.png +19698.png +27642.png +48443.png +40077.png +27398.png +23994.png +66059.png +17458.png +15878.png +31964.png +08212.png +10133.png +21502.png +52752.png +48143.png +30414.png +50533.png +14508.png +11216.png +19373.png +26235.png +25018.png +00258.png +12278.png +01224.png +14927.png +17885.png +49598.png +52779.png +26929.png +37048.png +28587.png +28295.png +21537.png +27685.png +23809.png +03111.png +28347.png +57791.png +01463.png +33439.png +51911.png +47939.png +58337.png +16952.png +24098.png +18529.png +51088.png +34827.png +47824.png +14419.png +42574.png +31499.png +50230.png +62393.png +57740.png +10407.png +02869.png +54134.png +43781.png +02813.png +53211.png +36775.png +40346.png +58053.png +57660.png +13258.png +58454.png +37692.png +01145.png +30177.png +13524.png +67652.png +00014.png +48138.png +55120.png +60722.png +20161.png +32531.png +06386.png +27848.png +46462.png +63048.png +15165.png +44638.png +23561.png +57291.png +06981.png +68876.png +58999.png +24746.png +37776.png +62430.png +66028.png +56792.png +19217.png +35994.png +66137.png +51077.png +22025.png +33742.png +50536.png +15881.png +13005.png +39190.png +35759.png +59801.png +48222.png +38592.png +54742.png +26923.png +10537.png +58157.png +55558.png +21504.png +21179.png +68828.png +37696.png +49086.png +04398.png +10119.png +48561.png +58278.png +23042.png +43927.png +31906.png +04232.png +51442.png +00794.png +18536.png +04391.png +20616.png +27584.png +31588.png +00343.png +43472.png +66370.png +60734.png +28599.png +55392.png +34621.png +51522.png +46562.png +12891.png +11422.png +12603.png +15090.png +45662.png +23486.png +51150.png +60163.png +58685.png +52819.png +29218.png +21351.png +08740.png +10701.png +54019.png +63695.png +39015.png +66665.png +69132.png +39858.png +26835.png +49289.png +23597.png +17730.png +49703.png +65201.png +07289.png +12507.png +59909.png +33078.png +62603.png +21011.png +03993.png +57420.png +15793.png +59725.png +63111.png +05784.png +16204.png +02473.png +65770.png +64863.png +45272.png +58211.png +52805.png +47085.png +69593.png +00241.png +42383.png +07422.png +55773.png +22575.png +20775.png +41832.png +25478.png +43863.png +44871.png +41800.png +01829.png +50448.png +45164.png +57379.png +47463.png +10423.png +33700.png +39725.png +24468.png +03366.png +60934.png +10969.png +23619.png +29719.png +40461.png +22165.png +22572.png +10986.png +01070.png +28582.png +26960.png +65937.png +55017.png +00739.png +48463.png +04585.png +19694.png +18541.png +50183.png +68974.png +67178.png +53161.png +05934.png +55234.png +47482.png +08047.png +16783.png +31477.png +33980.png +38517.png +52538.png +36493.png +33128.png +24074.png +28429.png +11357.png +55413.png +04406.png +04583.png +28799.png +68827.png +36773.png +33637.png +54314.png +34830.png +32668.png +36292.png +02834.png +55704.png +68122.png +50107.png +66939.png +12054.png +23129.png +05587.png +36504.png +22482.png +63778.png +47637.png +35029.png +28763.png +21333.png +51183.png +49707.png +41093.png +37239.png +21785.png +01221.png +41510.png +36792.png +04471.png +65727.png +22172.png +29243.png +61827.png +11021.png +10248.png +55644.png +00871.png +26246.png +44581.png +19619.png +55584.png +11979.png +31130.png +14680.png +22737.png +29011.png +36078.png +42524.png +34140.png +18879.png +25312.png +29072.png +52598.png +47934.png +42031.png +13277.png +48212.png +46614.png +67005.png +63463.png +30730.png +69177.png +34639.png +68079.png +10971.png +67192.png +60764.png +64031.png +39235.png +03377.png +40677.png +11313.png +36687.png +63957.png +13151.png +64687.png +18432.png +34214.png +37429.png +09985.png +60828.png +39647.png +21644.png +39516.png +00651.png +63801.png +52753.png +57784.png +09087.png +49931.png +18728.png +01074.png +01616.png +47339.png +01641.png +39395.png +39156.png +04035.png +13674.png +20048.png +15650.png +05989.png +37523.png +45333.png +42667.png +23904.png +39432.png +45008.png +31532.png +62725.png +36139.png +50245.png +12193.png +36842.png +08530.png +46720.png +23063.png +58633.png +22459.png +40783.png +53734.png +49927.png +26862.png +21666.png +54023.png +39617.png +05051.png +27181.png +65199.png +42009.png +43732.png +41986.png +67934.png +20084.png +39265.png +32480.png +58318.png +56413.png +52360.png +00826.png +12445.png +12537.png +26541.png +30574.png +06061.png +45433.png +17341.png +58515.png +22678.png +06811.png +60862.png +21782.png +62045.png +65973.png +03712.png +19221.png +20642.png +11956.png +30858.png +18660.png +66579.png +60913.png +21451.png +45225.png +61447.png +28263.png +27036.png +15167.png +42454.png +38188.png +20993.png +54660.png +61549.png +41143.png +14280.png +52626.png +65841.png +34121.png +23085.png +68196.png +45351.png +64019.png +35387.png +52617.png +07812.png +13138.png +05712.png +38020.png +39198.png +57692.png +64697.png +62085.png +33618.png +49672.png +20593.png +32577.png +51028.png +37807.png +17507.png +39948.png +30203.png +02067.png +49017.png +26669.png +38007.png +66613.png +34018.png +64538.png +12229.png +14878.png +68150.png +41475.png +48517.png +11737.png +01011.png +05034.png +38644.png +02054.png +27116.png +15850.png +58215.png +13000.png +05050.png +50589.png +05169.png +21491.png +51598.png +17860.png +16644.png +43623.png +35271.png +31723.png +12236.png +14498.png +57200.png +28660.png +55849.png +23180.png +16100.png +08611.png +18800.png +30326.png +56090.png +55229.png +60011.png +45606.png +08138.png +60247.png +23185.png +50303.png +66610.png +63208.png +20544.png +10661.png +35737.png +34419.png +40419.png +20817.png +54089.png +27847.png +37684.png +20727.png +38934.png +29999.png +43632.png +65477.png +51859.png +36732.png +30463.png +62704.png +04159.png +36008.png +31166.png +07168.png +03991.png +68056.png +59152.png +43182.png +17602.png +33914.png +55741.png +09261.png +46530.png +30332.png +54965.png +48997.png +28113.png +04454.png +41672.png +67300.png +26015.png +30165.png +53770.png +67621.png +04811.png +52495.png +44042.png +19547.png +53246.png +11290.png +48446.png +08157.png +19776.png +33946.png +66360.png +04725.png +48157.png +08396.png +06439.png +57158.png +06412.png +45378.png +28689.png +03105.png +33359.png +34995.png +30941.png +32235.png +55986.png +29983.png +51693.png +44790.png +47704.png +27368.png +55995.png +30715.png +10159.png +01026.png +64723.png +44200.png +43156.png +59995.png +45018.png +59534.png +49075.png +29134.png +21820.png +37347.png +54142.png +60818.png +60477.png +41072.png +39442.png +48853.png +50741.png +08941.png +43485.png +33095.png +17940.png +66857.png +41519.png +14063.png +69947.png +00239.png +40736.png +14300.png +09779.png +64413.png +31438.png +26866.png +53768.png +58026.png +58351.png +63393.png +01971.png +16821.png +21081.png +52138.png +64095.png +18606.png +57103.png +33415.png +20494.png +64426.png +60853.png +01633.png +65539.png +45047.png +68993.png +59388.png +31659.png +12947.png +42701.png +06287.png +27810.png +25015.png +10318.png +35202.png +69857.png +60099.png +20410.png +43185.png +64136.png +47166.png +61198.png +39515.png +67026.png +51697.png +65798.png +63930.png +49969.png +55276.png +66484.png +62086.png +50150.png +16716.png +05823.png +33072.png +08122.png +69760.png +14649.png +14490.png +37415.png +61869.png +14992.png +50405.png +08776.png +29580.png +33274.png +45382.png +06384.png +25416.png +46601.png +51005.png +47759.png +44169.png +04020.png +46781.png +17352.png +38819.png +25966.png +06709.png +33163.png +35906.png +13351.png +51323.png +61382.png +66166.png +01573.png +55391.png +56388.png +69236.png +53435.png +03079.png +23600.png +49561.png +27771.png +68274.png +37877.png +50452.png +11669.png +36972.png +01421.png +37802.png +34767.png +12795.png +44736.png +11663.png +41538.png +10803.png +04540.png +08503.png +40582.png +03628.png +43329.png +64762.png +30774.png +08012.png +51779.png +39499.png +34328.png +35160.png +34244.png +32562.png +47228.png +39594.png +24165.png +19944.png +28233.png +33428.png +57794.png +22227.png +57343.png +52228.png +37873.png +09585.png +23256.png +46824.png +05146.png +10936.png +03494.png +55700.png +44986.png +27519.png +03148.png +57751.png +09687.png +56357.png +69915.png +69152.png +63283.png +30816.png +53499.png +64172.png +32401.png +61094.png +36354.png +57427.png +59635.png +09653.png +49992.png +10379.png +09116.png +45610.png +12590.png +11997.png +36290.png +27255.png +00110.png +56278.png +36264.png +40786.png +50159.png +47584.png +54270.png +48865.png +26023.png +18084.png +45095.png +53507.png +34327.png +68397.png +57069.png +40388.png +31329.png +09093.png +45561.png +11949.png +61729.png +19497.png +30869.png +31542.png +20325.png +37498.png +47367.png +64036.png +04768.png +54028.png +62959.png +62627.png +41868.png +31942.png +37716.png +19202.png +34548.png +33162.png +03842.png +66278.png +46191.png +50934.png +32471.png +13801.png +39041.png +10471.png +41840.png +44476.png +36283.png +10044.png +24808.png +20489.png +21980.png +20364.png +59012.png +46145.png +20635.png +08241.png +29873.png +42908.png +31485.png +62978.png +08888.png +03935.png +20467.png +08684.png +04349.png +68406.png +08073.png +16187.png +07832.png +05730.png +63506.png +47960.png +25098.png +22493.png +24235.png +11513.png +38136.png +54596.png +66917.png +56950.png +30500.png +58800.png +30560.png +64207.png +45057.png +53793.png +56748.png +17063.png +69272.png +40068.png +38933.png +56700.png +59373.png +24806.png +27071.png +02051.png +16729.png +25052.png +17717.png +08240.png +51866.png +49301.png +55171.png +28232.png +64100.png +13385.png +62204.png +16134.png +09055.png +22595.png +15376.png +69732.png +13366.png +43451.png +32972.png +29971.png +53307.png +69662.png +43494.png +27296.png +61498.png +26254.png +22676.png +18959.png +43895.png +27839.png +30604.png +69603.png +38476.png +17200.png +24959.png +59414.png +00733.png +61924.png +61483.png +17515.png +29362.png +14172.png +64725.png +44165.png +12692.png +67104.png +39964.png +12206.png +46775.png +29254.png +18266.png +60174.png +10438.png +35094.png +35351.png +64298.png +24420.png +58102.png +59661.png +38634.png +05068.png +10943.png +30004.png +16291.png +04722.png +48578.png +49130.png +51182.png +19749.png +40792.png +35515.png +11012.png +62011.png +43249.png +68416.png +68886.png +42889.png +47347.png +40173.png +25488.png +55189.png +58051.png +35156.png +11011.png +62329.png +00658.png +07754.png +10602.png +28521.png +40693.png +12479.png +53024.png +36187.png +51957.png +36907.png +28098.png +63331.png +09438.png +01716.png +45088.png +60960.png +03931.png +05405.png +23580.png +18135.png +32278.png +47798.png +17852.png +68864.png +03179.png +35887.png +05885.png +31616.png +52771.png +45822.png +17236.png +56443.png +11037.png +31119.png +20629.png +49092.png +51116.png +37432.png +28667.png +03436.png +65339.png +64101.png +19254.png +15256.png +01839.png +19105.png +45113.png +64892.png +46519.png +05858.png +12191.png +58079.png +13755.png +40321.png +16311.png +69048.png +05138.png +20414.png +12807.png +11030.png +52685.png +54392.png +00440.png +66527.png +39954.png +00889.png +53869.png +45429.png +24289.png +54520.png +11842.png +53327.png +62982.png +63468.png +25625.png +58784.png +03637.png +34245.png +03656.png +26441.png +30415.png +65397.png +11818.png +36462.png +34425.png +23843.png +52607.png +11998.png +17721.png +19510.png +17103.png +41586.png +23849.png +06263.png +24337.png +42193.png +18045.png +56527.png +63367.png +15853.png +39130.png +60980.png +03033.png +04520.png +20440.png +12006.png +27985.png +56491.png +63880.png +02202.png +49608.png +32290.png +00527.png +19620.png +02987.png +25445.png +41323.png +00659.png +12857.png +31707.png +01952.png +42760.png +57572.png +26174.png +21002.png +52634.png +29188.png +13502.png +03625.png +45033.png +10384.png +68707.png +04395.png +61232.png +20941.png +30704.png +26811.png +20261.png +12022.png +14662.png +56003.png +06445.png +65769.png +10018.png +34939.png +42539.png +26277.png +61927.png +50675.png +56964.png +24710.png +58882.png +41794.png +28816.png +24028.png +26657.png +41249.png +57393.png +04338.png +51043.png +22424.png +50019.png +52061.png +15785.png +15075.png +13382.png +34232.png +43795.png +68450.png +47800.png +46632.png +65330.png +36520.png +58437.png +35524.png +33210.png +51630.png +25694.png +52442.png +03771.png +13981.png +20777.png +07827.png +49157.png +24609.png +46500.png +66086.png +33106.png +44332.png +07765.png +22326.png +09629.png +67986.png +12186.png +39800.png +21897.png +50073.png +55279.png +05159.png +00399.png +09327.png +12061.png +63642.png +35197.png +51770.png +67130.png +01117.png +40002.png +31009.png +41880.png +42752.png +11794.png +66078.png +04816.png +69497.png +58696.png +22671.png +23340.png +51508.png +28485.png +17988.png +69348.png +40087.png +12372.png +44572.png +14843.png +12303.png +57185.png +20585.png +41451.png +56594.png +16008.png +69065.png +29413.png +54130.png +17531.png +07823.png +63172.png +42434.png +56346.png +12461.png +51788.png +67019.png +61947.png +43123.png +19696.png +69176.png +49179.png +13520.png +48908.png +27451.png +23991.png +67613.png +58514.png +04933.png +24972.png +12150.png +22371.png +04736.png +07822.png +61966.png +56272.png +06993.png +35380.png +52317.png +43188.png +01786.png +46710.png +30531.png +58142.png +35400.png +04487.png +12696.png +00074.png +07327.png +49574.png +16987.png +20983.png +47224.png +52079.png +09933.png +59093.png +42500.png +62466.png +44236.png +16443.png +42034.png +42280.png +66571.png +60438.png +58349.png +43894.png +28142.png +28392.png +34757.png +20371.png +26308.png +67993.png +58324.png +51242.png +40940.png +21549.png +02821.png +28594.png +17633.png +06239.png +47133.png +31593.png +57584.png +32151.png +21905.png +26974.png +68089.png +03175.png +56503.png +55453.png +66229.png +40405.png +25598.png +36561.png +38818.png +26217.png +25302.png +04524.png +15802.png +08860.png +24759.png +68597.png +21350.png +68499.png +33997.png +56119.png +45404.png +41062.png +35330.png +46217.png +31619.png +19884.png +03403.png +33690.png +31091.png +08218.png +24360.png +59439.png +37085.png +10750.png +68727.png +52870.png +63482.png +39988.png +05515.png +28808.png +67495.png +35648.png +26481.png +30037.png +43254.png +14942.png +47395.png +23937.png +17861.png +44912.png +36724.png +11268.png +39600.png +12341.png +31380.png +14890.png +42906.png +04421.png +67780.png +21131.png +19080.png +57914.png +46732.png +07449.png +07997.png +49847.png +49107.png +62367.png +63520.png +59770.png +07429.png +23913.png +38249.png +40263.png +20750.png +06727.png +11282.png +11647.png +25092.png +21144.png +00886.png +23920.png +50688.png +20774.png +15784.png +36320.png +19559.png +19515.png +67212.png +02805.png +57942.png +66460.png +50068.png +34815.png +46176.png +12256.png +39161.png +37114.png +13563.png +24231.png +46001.png +09122.png +24024.png +53798.png +43770.png +18590.png +22993.png +43696.png +39896.png +36353.png +33347.png +42078.png +29591.png +55470.png +28550.png +66326.png +67876.png +22901.png +12033.png +03880.png +54785.png +65085.png +64670.png +26025.png +35556.png +11243.png +46388.png +65010.png +40504.png +24519.png +31208.png +34849.png +37786.png +56004.png +14336.png +30133.png +02543.png +09991.png +00773.png +64500.png +53504.png +12315.png +03805.png +47883.png +68537.png +58873.png +61538.png +66821.png +00115.png +37541.png +34250.png +63892.png +37966.png +69231.png +06174.png +61472.png +35671.png +03517.png +38398.png +11106.png +29554.png +05543.png +54412.png +68053.png +14459.png +01015.png +30727.png +08340.png +38071.png +12724.png +27118.png +24264.png +50514.png +65696.png +09147.png +44503.png +09503.png +21757.png +68687.png +32329.png +66680.png +31877.png +27288.png +14922.png +04737.png +41874.png +07962.png +38043.png +04186.png +22045.png +60654.png +60529.png +18718.png +30691.png +24811.png +11847.png +18604.png +66450.png +39128.png +34872.png +35624.png +12664.png +15190.png +69779.png +04502.png +41472.png +18695.png +46021.png +69006.png +32597.png +18240.png +05882.png +20222.png +15268.png +40871.png +18737.png +16881.png +40500.png +64702.png +58885.png +39905.png +55993.png +16600.png +46594.png +05334.png +53401.png +61657.png +13148.png +17570.png +40816.png +30726.png +14124.png +27727.png +14930.png +17941.png +58421.png +63578.png +37540.png +45925.png +52370.png +33065.png +68325.png +53263.png +16891.png +03421.png +08456.png +48033.png +54172.png +31986.png +11364.png +69747.png +68407.png +11536.png +30856.png +42522.png +04772.png +10347.png +64847.png +60140.png +28851.png +38407.png +29608.png +56032.png +56149.png +51200.png +42753.png +42446.png +32724.png +20176.png +21166.png +08275.png +46351.png +60998.png +64927.png +11150.png +04912.png +38093.png +13590.png +01325.png +36578.png +25926.png +00401.png +08699.png +01147.png +60523.png +19788.png +08022.png +67417.png +24556.png +16006.png +47119.png +39474.png +21780.png +51663.png +14266.png +18940.png +13386.png +52545.png +55443.png +17036.png +23866.png +24085.png +13207.png +29005.png +23086.png +65438.png +40238.png +63010.png +23609.png +49745.png +28204.png +27365.png +60728.png +09606.png +52049.png +39916.png +05700.png +50500.png +68364.png +49519.png +13823.png +53491.png +30398.png +47440.png +06770.png +66897.png +06012.png +20863.png +41404.png +08627.png +43817.png +67619.png +65399.png +11482.png +25041.png +43776.png +15883.png +34691.png +15316.png +45942.png +57265.png +33059.png +58124.png +49012.png +26843.png +32825.png +57960.png +24935.png +42015.png +36475.png +16663.png +13177.png +69772.png +08298.png +68668.png +42841.png +23854.png +09108.png +25171.png +45456.png +05889.png +11297.png +41876.png +35863.png +06079.png +51357.png +56995.png +06500.png +06891.png +52212.png +47229.png +00888.png +38485.png +60422.png +33504.png +52630.png +57549.png +08413.png +03258.png +45567.png +24386.png +51749.png +25957.png +28011.png +00100.png +32050.png +14186.png +57261.png +43409.png +25424.png +30565.png +44593.png +55661.png +43877.png +38289.png +44831.png +69238.png +48481.png +04537.png +31779.png +31296.png +59336.png +10330.png +05078.png +53602.png +41883.png +44643.png +07129.png +47124.png +01223.png +35323.png +26818.png +05956.png +41303.png +44632.png +25776.png +22152.png +05359.png +36189.png +21077.png +56535.png +31515.png +04101.png +48023.png +25007.png +07062.png +40999.png +66131.png +26403.png +54329.png +08633.png +10165.png +39119.png +40709.png +17008.png +08849.png +65263.png +09726.png +36914.png +68536.png +38504.png +60718.png +61710.png +14259.png +53590.png +31303.png +41735.png +25813.png +22518.png +42917.png +30110.png +52097.png +26066.png +25716.png +69290.png +68120.png +36442.png +40456.png +03892.png +44583.png +18644.png +02267.png +62291.png +36391.png +62114.png +42352.png +09256.png +18301.png +54582.png +02898.png +36265.png +53822.png +34740.png +33861.png +10206.png +13617.png +56731.png +40309.png +05979.png +46914.png +03881.png +54673.png +67785.png +36771.png +56717.png +47518.png +44454.png +23814.png +47592.png +67062.png +55109.png +57610.png +44911.png +57725.png +55847.png +11026.png +46654.png +57060.png +56445.png +64259.png +51715.png +34572.png +32012.png +22224.png +41432.png +08577.png +52333.png +28147.png +61502.png +60256.png +27790.png +29399.png +05635.png +57836.png +16456.png +60128.png +60741.png +63573.png +23058.png +06510.png +58495.png +46314.png +69615.png +43046.png +03982.png +49099.png +10124.png +47109.png +41801.png +44257.png +65089.png +29639.png +69022.png +08757.png +35153.png +01079.png +62527.png +06938.png +61568.png +13372.png +54278.png +69568.png +26339.png +56220.png +45151.png +02088.png +15361.png +37679.png +16102.png +32412.png +23194.png +58405.png +41013.png +22330.png +12026.png +04572.png +60782.png +36851.png +39639.png +14295.png +07691.png +04181.png +64626.png +62746.png +36349.png +02414.png +03424.png +21971.png +53537.png +22713.png +10806.png +51932.png +45758.png +34242.png +67153.png +14595.png +27688.png +03874.png +22390.png +40670.png +05223.png +25327.png +09171.png +11687.png +14344.png +37110.png +35983.png +49415.png +40305.png +39833.png +36709.png +59034.png +60193.png +43387.png +37748.png +43746.png +09255.png +32993.png +27857.png +16830.png +45209.png +26302.png +62112.png +14637.png +38786.png +19263.png +30131.png +66445.png +20071.png +23592.png +48062.png +64225.png +12940.png +67284.png +59778.png +40985.png +12184.png +49605.png +28217.png +53841.png +57064.png +30139.png +42424.png +67185.png +61060.png +26379.png +68623.png +00000.png +59122.png +20572.png +20395.png +09509.png +40084.png +06291.png +48597.png +56982.png +43032.png +05195.png +00979.png +24432.png +37525.png +58042.png +67937.png +14303.png +61987.png +16789.png +30734.png +41139.png +66742.png +09230.png +31106.png +34649.png +41896.png +16262.png +13389.png +58549.png +52137.png +40793.png +54411.png +18757.png +68793.png +50296.png +47418.png +50637.png +20514.png +30885.png +27222.png +46199.png +21632.png +19448.png +08128.png +45672.png +24529.png +57617.png +69544.png +63782.png +09720.png +41939.png +53012.png +53257.png +11629.png +62598.png +63182.png +50030.png +49060.png +23537.png +47292.png +02673.png +42815.png +38925.png +53135.png +62322.png +17783.png +01048.png +48540.png +52472.png +31141.png +39266.png +25928.png +47023.png +31163.png +06130.png +30723.png +42933.png +54495.png +23375.png +55756.png +46715.png +26466.png +01339.png +12392.png +10316.png +43751.png +57560.png +06914.png +26812.png +44552.png +32878.png +65473.png +56303.png +05729.png +18288.png +54867.png +48342.png +15460.png +51370.png +52460.png +36938.png +05957.png +17858.png +63039.png +39664.png +48963.png +15591.png +40745.png +67896.png +65078.png +08780.png +53258.png +20081.png +43186.png +11548.png +07253.png +10696.png +68692.png +65535.png +34385.png +51432.png +63757.png +06785.png +15765.png +34857.png +26195.png +66381.png +31585.png +19651.png +25705.png +06449.png +41534.png +29946.png +38424.png +05720.png +05256.png +21748.png +46969.png +22022.png +18061.png +24385.png +35379.png +03746.png +03598.png +28102.png +15266.png +49178.png +47000.png +05431.png +26768.png +05618.png +20964.png +35056.png +12090.png +31717.png +01587.png +12394.png +07412.png +33671.png +40438.png +29930.png +64397.png +17148.png +69041.png +06285.png +41813.png +02750.png +36420.png +34144.png +66035.png +21547.png +27585.png +13825.png +34491.png +60083.png +03018.png +02401.png +12714.png +11299.png +32263.png +39134.png +33366.png +41615.png +43603.png +20122.png +21689.png +61647.png +55820.png +14715.png +36325.png +67326.png +11651.png +25613.png +36371.png +38962.png +36576.png +14019.png +52516.png +43062.png +52357.png +21952.png +53637.png +56108.png +17974.png +55043.png +20042.png +32111.png +56285.png +10962.png +43300.png +52447.png +00127.png +15636.png +06040.png +35225.png +65040.png +60832.png +64062.png +39427.png +44150.png +48659.png +18935.png +68921.png +42407.png +53395.png +44744.png +50809.png +02676.png +39052.png +47507.png +12657.png +32042.png +68024.png +58629.png +62454.png +47897.png +68402.png +61875.png +46490.png +31849.png +13641.png +47336.png +27858.png +33969.png +26643.png +46446.png +57815.png +01632.png +21395.png +09752.png +10000.png +25051.png +51450.png +25413.png +59651.png +54881.png +51362.png +47972.png +51383.png +17498.png +65822.png +33340.png +64807.png +30698.png +18680.png +12182.png +39007.png +53821.png +05643.png +45781.png +04382.png +30174.png +63953.png +08299.png +10186.png +31664.png +21735.png +27252.png +13156.png +64611.png +56629.png +67842.png +35349.png +18264.png +51097.png +52267.png +08034.png +45073.png +22184.png +21277.png +29417.png +68095.png +65148.png +32592.png +09370.png +42022.png +48965.png +52580.png +36879.png +67564.png +66428.png +51240.png +67583.png +63062.png +13951.png +25293.png +11595.png +02065.png +09451.png +45697.png +65492.png +28017.png +01684.png +03703.png +69404.png +06488.png +19849.png +66609.png +37349.png +08880.png +54876.png +31641.png +01382.png +54356.png +44031.png +24731.png +54021.png +53937.png +41400.png +53464.png +22879.png +55649.png +20051.png +67445.png +35247.png +26413.png +69994.png +58105.png +68320.png +64049.png +67095.png +42398.png +15934.png +23583.png +39763.png +36368.png +44829.png +49449.png +36764.png +52464.png +09615.png +64472.png +44950.png +20751.png +23399.png +16846.png +01169.png +22563.png +47051.png +55368.png +45654.png +41520.png +49036.png +37998.png +44231.png +53373.png +11008.png +60895.png +47323.png +45696.png +10977.png +65588.png +53998.png +59255.png +08859.png +67305.png +53481.png +17383.png +56035.png +40684.png +26815.png +11598.png +04715.png +02408.png +67065.png +28431.png +22699.png +62745.png +31734.png +35050.png +55864.png +68715.png +45826.png +29919.png +58500.png +25854.png +51233.png +26036.png +03388.png +50995.png +67188.png +05193.png +52638.png +46392.png +12568.png +34251.png +59956.png +26233.png +60385.png +31090.png +11126.png +51766.png +27354.png +67061.png +35284.png +66399.png +66425.png +28402.png +17564.png +47046.png +08410.png +23234.png +34162.png +49710.png +04671.png +06565.png +33446.png +64052.png +08782.png +50178.png +08852.png +02550.png +32996.png +12577.png +20763.png +65232.png +32356.png +24690.png +19721.png +43989.png +11471.png +00132.png +53236.png +60121.png +03669.png +30675.png +57290.png +19700.png +38015.png +50695.png +44954.png +63742.png +54632.png +65936.png +55900.png +33630.png +32224.png +18952.png +44168.png +60665.png +22315.png +65567.png +13622.png +43241.png +36324.png +38357.png +16861.png +02437.png +35461.png +57394.png +04943.png +26478.png +47111.png +04711.png +32634.png +32129.png +02902.png +49549.png +33698.png +38645.png +48028.png +49476.png +51742.png +04902.png +15528.png +10596.png +51532.png +39771.png +15751.png +61475.png +26907.png +62401.png +33235.png +68907.png +01082.png +17356.png +61333.png +18154.png +36339.png +10490.png +16645.png +26601.png +32142.png +08715.png +13828.png +39619.png +30733.png +59201.png +39086.png +10387.png +06019.png +56407.png +68373.png +08103.png +65943.png +56795.png +68138.png +61046.png +38410.png +59618.png +35980.png +26323.png +51724.png +31274.png +52851.png +15004.png +46620.png +59919.png +41064.png +10426.png +23629.png +62150.png +46222.png +21158.png +52272.png +39513.png +07053.png +26199.png +07060.png +59553.png +69511.png +40452.png +34230.png +40730.png +32258.png +14923.png +56704.png +10417.png +49328.png +24471.png +69889.png +28212.png +65530.png +22325.png +68777.png +22560.png +69565.png +51757.png +36557.png +24576.png +12488.png +62972.png +53220.png +54137.png +50255.png +21902.png +14872.png +05038.png +00327.png +01025.png +43719.png +04624.png +40968.png +03715.png +06775.png +46243.png +43564.png +64682.png +08642.png +46900.png +31372.png +06758.png +31921.png +36544.png +46617.png +21597.png +27391.png +15694.png +50861.png +26095.png +21098.png +40714.png +68841.png +06321.png +10023.png +04346.png +69445.png +51396.png +10763.png +62068.png +18280.png +24045.png +09153.png +17853.png +25619.png +53194.png +52775.png +16634.png +44009.png +20290.png +34401.png +61241.png +62216.png +15996.png +11967.png +51436.png +27542.png +61928.png +13339.png +42865.png +26089.png +42321.png +42808.png +46213.png +27956.png +51964.png +64366.png +35908.png +13554.png +03497.png +65667.png +19589.png +29246.png +27182.png +14483.png +39765.png +49367.png +09266.png +14217.png +09293.png +61092.png +06522.png +48188.png +66142.png +04776.png +66980.png +20453.png +47705.png +66784.png +09831.png +47009.png +59394.png +38891.png +56459.png +67158.png +27694.png +30821.png +19816.png +41264.png +39587.png +33955.png +50518.png +61954.png +24130.png +64918.png +01108.png +40703.png +27635.png +36495.png +52091.png +12037.png +15406.png +08446.png +35248.png +37952.png +29695.png +44370.png +58008.png +22389.png +14775.png +45745.png +61047.png +51339.png +09060.png +60067.png +38041.png +43806.png +45644.png +26904.png +63767.png +48494.png +64569.png +32702.png +35726.png +69393.png +43357.png +06202.png +21299.png +36303.png +39415.png +60415.png +22887.png +09324.png +17322.png +40463.png +13246.png +27910.png +63391.png +34946.png +38053.png +48184.png +42532.png +17252.png +51584.png +10879.png +54394.png +22899.png +35217.png +41458.png +58640.png +09828.png +08233.png +24893.png +58271.png +36795.png +65145.png +55224.png +12410.png +14759.png +34734.png +30391.png +09506.png +15382.png +03504.png +35453.png +55414.png +21756.png +13175.png +11231.png +57039.png +64384.png +49928.png +41092.png +61600.png +41382.png +10851.png +34090.png +18138.png +58202.png +04412.png +12973.png +13297.png +03877.png +10571.png +29191.png +34091.png +49878.png +39074.png +20569.png +55248.png +32656.png +20690.png +60946.png +14443.png +20584.png +53559.png +54530.png +32315.png +57810.png +37691.png +08056.png +69042.png +10572.png +02445.png +32201.png +37489.png +05719.png +26737.png +45547.png +67611.png +36070.png +26380.png +69536.png +58590.png +37707.png +27808.png +07278.png +37728.png +68440.png +00983.png +46725.png +24339.png +23650.png +02198.png +49343.png +20303.png +41151.png +68087.png +28578.png +08042.png +35087.png +40099.png +24168.png +52244.png +47371.png +07899.png +00918.png +64705.png +34390.png +24150.png +41218.png +58735.png +09429.png +68431.png +18934.png +02251.png +33379.png +36770.png +27010.png +54192.png +62932.png +67743.png +33099.png +62197.png +49606.png +10279.png +61623.png +49892.png +54925.png +17237.png +64566.png +46168.png +48094.png +26776.png +67287.png +30145.png +53260.png +05872.png +32429.png +45809.png +31625.png +21250.png +36624.png +47711.png +40265.png +11833.png +45914.png +65681.png +25846.png +68738.png +38707.png +02152.png +33595.png +58566.png +20202.png +12874.png +44751.png +63727.png +39173.png +33399.png +65381.png +25374.png +33688.png +20403.png +14940.png +22803.png +55183.png +43891.png +64542.png +41927.png +25875.png +65559.png +40332.png +56196.png +03305.png +61722.png +14436.png +33045.png +68795.png +64933.png +35155.png +58248.png +09613.png +13501.png +64270.png +10898.png +02588.png +29484.png +47866.png +69938.png +08933.png +64763.png +30771.png +66660.png +34624.png +69403.png +19140.png +64213.png +02480.png +00007.png +12258.png +19029.png +50971.png +40005.png +31006.png +34311.png +33040.png +03198.png +00057.png +35165.png +62423.png +13896.png +53230.png +13802.png +28744.png +23870.png +58070.png +62206.png +40255.png +56338.png +69699.png +34350.png +49540.png +27866.png +63675.png +20434.png +29125.png +07417.png +22666.png +08584.png +42410.png +46395.png +43440.png +55186.png +62133.png +66992.png +05565.png +21073.png +13334.png +54567.png +06659.png +07368.png +21639.png +14738.png +25244.png +06558.png +63561.png +01105.png +60565.png +27568.png +22374.png +63447.png +58857.png +08527.png +18555.png +44508.png +65555.png +45321.png +00650.png +39164.png +18732.png +08905.png +59327.png +45775.png +58841.png +30444.png +16032.png +68933.png +44664.png +09845.png +37760.png +28693.png +49734.png +09686.png +68170.png +01122.png +13932.png +16833.png +59581.png +29883.png +27112.png +53011.png +37741.png +38199.png +40339.png +46891.png +67372.png +19691.png +14482.png +07464.png +37008.png +53140.png +55411.png +11704.png +26521.png +32625.png +09984.png +06964.png +22095.png +57631.png +10343.png +63735.png +11253.png +11417.png +30070.png +21522.png +22704.png +54623.png +38688.png +02320.png +57198.png +41646.png +54321.png +69117.png +21478.png +15851.png +18103.png +30718.png +29403.png +65673.png +48756.png +59189.png +53365.png +24569.png +16525.png +35902.png +16190.png +35077.png +44880.png +57314.png +17954.png +41307.png +00974.png +03053.png +57842.png +61349.png +31700.png +45320.png +42798.png +33154.png +48163.png +07760.png +26136.png +60232.png +22243.png +60085.png +21618.png +24883.png +05202.png +20745.png +14479.png +08773.png +64399.png +69799.png +46709.png +66109.png +06644.png +60235.png +02471.png +59538.png +45814.png +57780.png +40384.png +25903.png +65218.png +09040.png +40051.png +24425.png +62592.png +28326.png +54502.png +05398.png +17012.png +10861.png +45028.png +20117.png +16192.png +40973.png +26823.png +39670.png +56556.png +08613.png +44749.png +49774.png +31331.png +23776.png +52126.png +64157.png +44467.png +43079.png +57861.png +30064.png +50620.png +01965.png +52355.png +44477.png +22401.png +61033.png +20466.png +43160.png +30620.png +69809.png +03290.png +64895.png +37892.png +65718.png +57880.png +52642.png +44410.png +19383.png +27915.png +27706.png +68480.png +25084.png +10436.png +12281.png +03863.png +46279.png +28182.png +18926.png +66566.png +48109.png +45589.png +17624.png +07086.png +05458.png +08131.png +21107.png +19554.png +63226.png +46683.png +05598.png +69316.png +68643.png +11689.png +44949.png +11676.png +46190.png +61526.png +14701.png +36436.png +25372.png +16505.png +39585.png +20347.png +31892.png +09000.png +54129.png +45340.png +59898.png +12481.png +24753.png +23626.png +23525.png +29960.png +20541.png +47249.png +04265.png +37025.png +66265.png +68486.png +45889.png +02303.png +24019.png +42856.png +67408.png +22076.png +00687.png +33834.png +56146.png +23168.png +69542.png +53093.png +42642.png +35464.png +08105.png +56834.png +18602.png +67622.png +16410.png +12583.png +32232.png +37391.png +23787.png +67724.png +49917.png +47355.png +62577.png +41313.png +06180.png +34106.png +33908.png +61993.png +51204.png +23765.png +04206.png +16025.png +56889.png +42264.png +18012.png +38678.png +58778.png +43966.png +18653.png +24892.png +20710.png +59799.png +57909.png +02460.png +35446.png +37325.png +57477.png +58530.png +53463.png +22877.png +43559.png +31847.png +25592.png +34417.png +62668.png +07498.png +13868.png +41747.png +41718.png +49379.png +55277.png +21925.png +06350.png +16104.png +64123.png +25309.png +62044.png +05420.png +16832.png +64162.png +63921.png +39322.png +08575.png +54779.png +65808.png +32605.png +23170.png +60967.png +06748.png +55884.png +47893.png +40043.png +35335.png +17999.png +09024.png +52845.png +38201.png +08082.png +42719.png +35630.png +29354.png +45541.png +65894.png +30893.png +14328.png +18533.png +25159.png +35193.png +40066.png +57965.png +16943.png +40331.png +22066.png +59903.png +31396.png +36547.png +38286.png +10509.png +50052.png +19394.png +19942.png +66457.png +18794.png +11714.png +25740.png +64662.png +44291.png +63671.png +54453.png +21910.png +39117.png +28362.png +60958.png +04283.png +06762.png +52688.png +30805.png +38013.png +11079.png +10528.png +37340.png +07471.png +35555.png +58849.png +09008.png +46189.png +43059.png +36829.png +69966.png +11697.png +06093.png +56836.png +64578.png +55353.png +03992.png +13033.png +49401.png +38065.png +51954.png +50407.png +14963.png +62185.png +00353.png +44697.png +41094.png +52576.png +44131.png +25700.png +21343.png +26580.png +57793.png +61982.png +49188.png +29684.png +24537.png +34793.png +07805.png +23669.png +07246.png +44367.png +53437.png +41871.png +32264.png +65701.png +54800.png +31305.png +34585.png +31015.png +04663.png +60624.png +16686.png +42531.png +32040.png +58122.png +04269.png +49787.png +48247.png +65249.png +61835.png +06455.png +63555.png +08657.png +65313.png +25042.png +59751.png +06557.png +17648.png +39275.png +31321.png +37051.png +62936.png +30022.png +11246.png +50543.png +59271.png +38839.png +59393.png +58839.png +61854.png +18269.png +66189.png +10674.png +10391.png +35238.png +29633.png +27433.png +35366.png +18151.png +43098.png +00994.png +09402.png +27052.png +16570.png +61701.png +30934.png +32027.png +53039.png +46412.png +30226.png +36766.png +68737.png +16137.png +20675.png +20847.png +23555.png +19986.png +45235.png +46685.png +59550.png +59897.png +67430.png +36751.png +02128.png +46649.png +41810.png +04312.png +37511.png +55728.png +14096.png +60638.png +22839.png +48077.png +51282.png +21763.png +25940.png +19526.png +00590.png +54074.png +47585.png +26771.png +08025.png +43038.png +54775.png +47060.png +59274.png +00861.png +31491.png +18008.png +56486.png +11051.png +29455.png +30142.png +17739.png +55647.png +45011.png +47782.png +46780.png +56519.png +05058.png +53169.png +59019.png +16173.png +59057.png +43651.png +61264.png +35278.png +02399.png +57856.png +19099.png +56922.png +32558.png +04897.png +55933.png +14017.png +00173.png +50726.png +18080.png +39728.png +07054.png +38300.png +17104.png +19249.png +27235.png +36229.png +44479.png +42211.png +22200.png +47107.png +32829.png +63404.png +21917.png +45680.png +30978.png +63390.png +19787.png +46340.png +40782.png +01276.png +58146.png +59342.png +69668.png +47680.png +37706.png +11747.png +36983.png +31917.png +66007.png +11940.png +38711.png +17639.png +20008.png +03021.png +47495.png +15915.png +66854.png +14644.png +09430.png +28340.png +56662.png +06112.png +07846.png +12591.png +03792.png +16918.png +19523.png +21745.png +45315.png +22710.png +36511.png +03193.png +53756.png +04818.png +37606.png +12799.png +44232.png +08890.png +00118.png +53232.png +44560.png +15866.png +04518.png +42881.png +29895.png +47743.png +26740.png +17208.png +15126.png +43979.png +46873.png +65928.png +04575.png +58822.png +00163.png +13132.png +07524.png +06695.png +02720.png +34444.png +51344.png +03878.png +55999.png +34794.png +48739.png +30732.png +63624.png +17024.png +40768.png +22907.png +37958.png +04240.png +15978.png +24476.png +14556.png +40759.png +69950.png +10252.png +44482.png +66414.png +44004.png +54462.png +17502.png +23894.png +47889.png +57431.png +00292.png +69314.png +56432.png +21471.png +52708.png +56961.png +52658.png +37662.png +28253.png +18331.png +19336.png +13531.png +48532.png +08035.png +56899.png +52993.png +14200.png +34141.png +39734.png +56759.png +27556.png +45725.png +62152.png +65919.png +38118.png +29587.png +54189.png +66157.png +65969.png +27832.png +64359.png +11483.png +40803.png +26312.png +65385.png +60797.png +11222.png +21486.png +15749.png +03827.png +66976.png +34796.png +32865.png +18992.png +51675.png +10125.png +69612.png +35022.png +25639.png +19767.png +49816.png +00943.png +43555.png +38211.png +27571.png +53505.png +30175.png +35112.png +11934.png +12137.png +18117.png +30701.png +67183.png +32220.png +63815.png +63689.png +41212.png +17846.png +42049.png +23864.png +48483.png +60253.png +37159.png +67136.png +41333.png +30057.png +29037.png +30668.png +07854.png +05295.png +08311.png +43733.png +11763.png +05945.png +12671.png +34940.png +62990.png +14141.png +11547.png +51333.png +36668.png +42180.png +55324.png +41824.png +06752.png +62819.png +25164.png +03465.png +26137.png +52038.png +35046.png +43864.png +34669.png +53302.png +11797.png +02623.png +24328.png +57579.png +46629.png +13238.png +46337.png +49228.png +48973.png +62983.png +50420.png +19133.png +49218.png +09134.png +04824.png +65421.png +27923.png +33222.png +62926.png +51879.png +55494.png +29316.png +45365.png +51667.png +55755.png +27497.png +58795.png +53506.png +57315.png +60979.png +03068.png +27061.png +03743.png +69579.png +32863.png +23720.png +29155.png +19007.png +55797.png +37864.png +16874.png +18603.png +06956.png +40620.png +22479.png +16945.png +12538.png +00785.png +43269.png +14549.png +01773.png +15721.png +24829.png +10355.png +62468.png +29090.png +29514.png +47058.png +54436.png +34196.png +13783.png +27462.png +42887.png +14357.png +03722.png +41575.png +61116.png +40616.png +42502.png +37605.png +66707.png +36357.png +07059.png +04162.png +11383.png +67252.png +24877.png +21803.png +33074.png +33661.png +66255.png +58787.png +08192.png +10868.png +20297.png +63044.png +69223.png +11613.png +37148.png +18029.png +41171.png +54420.png +02442.png +35212.png +62432.png +45165.png +30441.png +01212.png +12738.png +15260.png +53731.png +56709.png +22869.png +13498.png +26367.png +33018.png +34119.png +52475.png +27511.png +51617.png +54583.png +50986.png +48674.png +34112.png +28952.png +46677.png +26292.png +68584.png +05446.png +22766.png +17314.png +15283.png +20082.png +43282.png +40552.png +68227.png +45980.png +36211.png +40155.png +61816.png +36726.png +41902.png +61473.png +39431.png +17557.png +65452.png +25960.png +16126.png +21289.png +60165.png +21994.png +59226.png +68726.png +18665.png +50676.png +05948.png +44021.png +00016.png +39983.png +18452.png +04721.png +10204.png +57739.png +48475.png +42322.png +22491.png +04681.png +05864.png +34262.png +08949.png +02646.png +59272.png +33126.png +17308.png +30468.png +40382.png +62996.png +57929.png +64903.png +01088.png +50359.png +27401.png +00984.png +39351.png +58522.png +56754.png +03145.png +51531.png +68900.png +54354.png +04461.png +65382.png +11905.png +60829.png +40518.png +62786.png +13330.png +42195.png +14869.png +47080.png +25442.png +37173.png +33625.png +12378.png +41228.png +06349.png +24262.png +68503.png +18677.png +53184.png +46809.png +30440.png +34539.png +61638.png +66080.png +44268.png +41453.png +24670.png +56848.png +22065.png +58951.png +21156.png +64930.png +36543.png +34309.png +67189.png +44377.png +69110.png +64535.png +45058.png +15010.png +19880.png +27776.png +26363.png +10866.png +69036.png +24499.png +34026.png +10071.png +17514.png +54525.png +29578.png +32204.png +21507.png +03144.png +03334.png +08741.png +40927.png +13900.png +18887.png +44033.png +08350.png +26467.png +14176.png +44280.png +16403.png +19214.png +60599.png +37152.png +27864.png +35410.png +44620.png +59680.png +41647.png +27152.png +61678.png +28381.png +12346.png +54634.png +35095.png +09455.png +43830.png +39545.png +05324.png +20674.png +10610.png +51728.png +49155.png +05031.png +49828.png +31412.png +19222.png +40558.png +38542.png +12532.png +69986.png +20335.png +29943.png +53911.png +01332.png +33517.png +55586.png +49780.png +59729.png +46013.png +00205.png +05408.png +67792.png +68311.png +30445.png +11970.png +64290.png +48515.png +53573.png +26782.png +50962.png +34959.png +51467.png +22034.png +42664.png +16579.png +55632.png +20582.png +05213.png +69455.png +20502.png +46627.png +50718.png +54258.png +03597.png +43379.png +61342.png +47804.png +13059.png +18456.png +08894.png +63388.png +48936.png +03372.png +45938.png +58601.png +09862.png +28260.png +03124.png +08873.png +69514.png +69180.png +18334.png +52110.png +01075.png +54339.png +21718.png +46060.png +42450.png +37390.png +30702.png +61700.png +55670.png +29951.png +55935.png +30555.png +27820.png +17818.png +17335.png +03990.png +59961.png +47247.png +10677.png +37596.png +36257.png +60918.png +39394.png +22669.png +18013.png +23616.png +14360.png +33430.png +53109.png +20053.png +38798.png +66946.png +54940.png +26377.png +34645.png +11603.png +61882.png +38667.png +58080.png +28058.png +38248.png +51454.png +58103.png +60977.png +36319.png +03586.png +67883.png +59694.png +17020.png +26369.png +15713.png +07719.png +33832.png +32330.png +56820.png +31730.png +08731.png +66962.png +16557.png +66276.png +05272.png +40303.png +41601.png +58959.png +39967.png +59352.png +67338.png +16618.png +40467.png +33587.png +63142.png +13844.png +37767.png +11223.png +54066.png +65102.png +28507.png +15198.png +30338.png +15239.png +52869.png +64926.png +48441.png +48117.png +41899.png +60412.png +48454.png +39247.png +00507.png +39194.png +62788.png +06612.png +23553.png +15830.png +66170.png +50997.png +56591.png +48967.png +21672.png +28071.png +35246.png +65101.png +64768.png +65826.png +58425.png +35633.png +01762.png +39527.png +15503.png +00909.png +39740.png +08091.png +52261.png +41570.png +47690.png +67834.png +24073.png +45074.png +35208.png +10398.png +01307.png +52348.png +60974.png +66465.png +58300.png +65236.png +61008.png +10757.png +00383.png +16515.png +38958.png +57120.png +05205.png +17583.png +28201.png +06257.png +06568.png +43441.png +51852.png +43205.png +55562.png +31687.png +03404.png +39047.png +21162.png +67630.png +37826.png +60766.png +60802.png +21096.png +21063.png +10698.png +46002.png +52289.png +36852.png +65192.png +55527.png +01425.png +14772.png +23928.png +48836.png +14564.png +62729.png +18295.png +54584.png +18755.png +30562.png +07825.png +63703.png +52488.png +15534.png +11236.png +22219.png +07478.png +63040.png +11219.png +30331.png +14904.png +53197.png +41948.png +50395.png +20679.png +33577.png +68275.png +40691.png +66924.png +64208.png +34446.png +51709.png +52614.png +43721.png +68136.png +58465.png +48882.png +64451.png +04216.png +52984.png +21320.png +69817.png +11113.png +35880.png +48750.png +39361.png +36655.png +53456.png +59319.png +09592.png +07535.png +69773.png +16387.png +01805.png +66909.png +20519.png +10254.png +09656.png +49309.png +23245.png +57812.png +03189.png +31672.png +40200.png +21339.png +14367.png +68452.png +10467.png +20382.png +06571.png +35646.png +35309.png +40712.png +64733.png +16306.png +38846.png +11791.png +17798.png +62040.png +32806.png +28236.png +01565.png +11076.png +09864.png +09205.png +26515.png +58546.png +21334.png +62488.png +69095.png +07931.png +03140.png +44959.png +46604.png +10842.png +51086.png +54558.png +38001.png +05216.png +53588.png +32647.png +44342.png +07189.png +31326.png +32193.png +16999.png +13076.png +05666.png +33058.png +25982.png +07537.png +22087.png +38058.png +24260.png +41231.png +66573.png +50385.png +53833.png +24030.png +56499.png +27443.png +12096.png +02652.png +40606.png +18385.png +07359.png +21548.png +17140.png +21381.png +27180.png +31580.png +44406.png +03133.png +01770.png +69828.png +35291.png +36087.png +46280.png +26912.png +63645.png +50922.png +11210.png +11251.png +54104.png +33330.png +52773.png +68885.png +27807.png +04949.png +28059.png +68661.png +10918.png +57742.png +29678.png +09796.png +61352.png +54230.png +53974.png +30101.png +12482.png +41135.png +01253.png +44159.png +01890.png +10744.png +62942.png +43792.png +31458.png +04880.png +20384.png +55490.png +32234.png +10440.png +27211.png +40435.png +25556.png +13549.png +13943.png +18342.png +68252.png +61265.png +04451.png +64255.png +00484.png +49610.png +15861.png +34613.png +34257.png +13495.png +24927.png +40799.png +54249.png +22332.png +67584.png +05562.png +45269.png +06506.png +35341.png +46553.png +39709.png +31384.png +00765.png +48154.png +24250.png +27346.png +55428.png +52713.png +17821.png +02756.png +32952.png +02549.png +50530.png +56844.png +02541.png +28025.png +35885.png +65338.png +18046.png +35915.png +25594.png +02862.png +63099.png +37646.png +43761.png +67143.png +64718.png +12251.png +69696.png +18443.png +69742.png +67377.png +29046.png +66608.png +63386.png +18076.png +00636.png +26141.png +18599.png +63050.png +20032.png +51025.png +66499.png +18691.png +64823.png +64265.png +49895.png +61969.png +46577.png +60793.png +43971.png +49839.png +61918.png +65486.png +29075.png +45730.png +62731.png +66683.png +04501.png +23930.png +29489.png +24865.png +45784.png +66596.png +55838.png +14245.png +68208.png +38590.png +61787.png +16596.png +11369.png +51244.png +32869.png +68447.png +32643.png +46181.png +36600.png +29596.png +28483.png +61658.png +60453.png +40098.png +46874.png +12861.png +38089.png +41420.png +19980.png +18688.png +35201.png +02084.png +56291.png +07225.png +51032.png +25876.png +50737.png +66155.png +39679.png +02662.png +16507.png +26470.png +04372.png +49000.png +31739.png +33145.png +44763.png +56170.png +31317.png +23213.png +68102.png +26017.png +69532.png +13666.png +07370.png +14780.png +43293.png +34878.png +16912.png +10249.png +52519.png +68348.png +41237.png +61501.png +62487.png +28549.png +28334.png +31087.png +33796.png +47532.png +52985.png +60556.png +33470.png +53389.png +44983.png +52608.png +54123.png +30407.png +50639.png +07552.png +21413.png +08180.png +00490.png +21249.png +17124.png +11824.png +38877.png +05484.png +16844.png +26087.png +44693.png +66037.png +04758.png +07100.png +04109.png +04688.png +60315.png +05832.png +62344.png +66383.png +02394.png +63046.png +33414.png +30083.png +32823.png +55633.png +31206.png +59420.png +10134.png +26200.png +54398.png +68923.png +52561.png +00153.png +20848.png +01543.png +27030.png +50792.png +25923.png +26586.png +59686.png +59422.png +65633.png +28469.png +14291.png +59604.png +52844.png +11215.png +17220.png +32231.png +27210.png +21127.png +11176.png +69682.png +23438.png +65719.png +01532.png +40822.png +47641.png +11554.png +20329.png +33286.png +20137.png +56058.png +17869.png +67224.png +35926.png +31994.png +11074.png +48864.png +22264.png +20558.png +04211.png +27202.png +50143.png +05612.png +53738.png +35166.png +32178.png +31174.png +47653.png +39657.png +22446.png +08927.png +65132.png +12611.png +34644.png +16361.png +35312.png +47523.png +28199.png +12390.png +63704.png +46173.png +54110.png +69991.png +03582.png +66891.png +21197.png +29900.png +11620.png +06685.png +10463.png +24613.png +12466.png +13963.png +55212.png +47488.png +66002.png +13560.png +53916.png +10794.png +30669.png +67295.png +34968.png +67043.png +46520.png +13105.png +44120.png +36073.png +19557.png +02935.png +40846.png +42516.png +33743.png +61586.png +03244.png +06590.png +19730.png +24770.png +31004.png +27818.png +37928.png +13458.png +29899.png +02753.png +49522.png +20214.png +37945.png +60908.png +40137.png +13024.png +34742.png +03502.png +62278.png +58030.png +30773.png +28200.png +00296.png +11183.png +68273.png +48324.png +57270.png +17532.png +46017.png +23959.png +65119.png +57662.png +34981.png +58402.png +40193.png +40170.png +10368.png +46967.png +08968.png +35938.png +63977.png +33710.png +24976.png +54976.png +27444.png +58623.png +52739.png +16801.png +47563.png +38655.png +63204.png +04608.png +01695.png +50213.png +59191.png +00303.png +53486.png +50152.png +48318.png +14314.png +39852.png +52479.png +12876.png +47302.png +23201.png +60106.png +05508.png +41714.png +43227.png +59861.png +49110.png +38841.png +27656.png +10635.png +66648.png +38813.png +28395.png +54280.png +11344.png +32688.png +63076.png +55059.png +27349.png +48909.png +63790.png +61848.png +33981.png +02838.png +15813.png +03522.png +13055.png +46399.png +57847.png +33394.png +27167.png +18399.png +68714.png +27230.png +14650.png +04268.png +25892.png +67709.png +55963.png +34766.png +26106.png +08573.png +43986.png +32546.png +44013.png +11948.png +15781.png +63167.png +23793.png +63501.png +00820.png +32654.png +65290.png +33792.png +69337.png +19534.png +42858.png +68652.png +00910.png +47008.png +33103.png +58941.png +18956.png +24517.png +53991.png +33530.png +58916.png +39300.png +67603.png +01151.png +27386.png +10742.png +62605.png +20312.png +44390.png +68159.png +57808.png +26526.png +17419.png +61723.png +10216.png +24042.png +48349.png +47805.png +20533.png +27411.png +57979.png +53861.png +67099.png +67162.png +65532.png +58251.png +17276.png +18451.png +12333.png +61891.png +09995.png +62482.png +19205.png +57151.png +20819.png +36040.png +65708.png +62371.png +30636.png +08376.png +17037.png +45276.png +07070.png +26850.png +37441.png +57080.png +02597.png +18370.png +37879.png +64929.png +39713.png +05541.png +63866.png +19683.png +56807.png +07633.png +31256.png +42824.png +20328.png +21036.png +31558.png +66560.png +61323.png +66065.png +17330.png +23157.png +15352.png +42081.png +31566.png +26758.png +41325.png +51644.png +47819.png +08062.png +28383.png +33539.png +08059.png +63926.png +38493.png +50917.png +26215.png +39712.png +38739.png +57193.png +03463.png +35426.png +13636.png +67732.png +65396.png +49939.png +12593.png +06227.png +34623.png +66725.png +52265.png +41889.png +44834.png +52782.png +65999.png +58235.png +52804.png +53411.png +32685.png +63268.png +47799.png +58837.png +34812.png +16414.png +35889.png +37765.png +13883.png +49200.png +11814.png +39310.png +10532.png +34229.png +51430.png +59395.png +30417.png +24828.png +31247.png +23621.png +33830.png +06992.png +50824.png +55452.png +11922.png +15471.png +27517.png +53843.png +23657.png +66569.png +38016.png +19207.png +23628.png +61747.png +17718.png +48357.png +45951.png +10331.png +01321.png +60914.png +47719.png +42175.png +38379.png +44153.png +20063.png +38646.png +54108.png +15208.png +47338.png +28583.png +18337.png +26534.png +23324.png +21348.png +61099.png +46398.png +44509.png +19809.png +25291.png +37847.png +38189.png +58862.png +65771.png +27331.png +33678.png +50849.png +66406.png +41837.png +29718.png +54796.png +34918.png +07101.png +22099.png +69253.png +02850.png +41127.png +35102.png +18093.png +49693.png +51297.png +33505.png +23231.png +17347.png +56930.png +54225.png +12189.png +60342.png +66161.png +46101.png +19999.png +54284.png +52647.png +60612.png +01381.png +01275.png +66494.png +67266.png +67159.png +27579.png +56525.png +69405.png +05727.png +05277.png +06164.png +21489.png +28721.png +06581.png +59831.png +68977.png +61096.png diff --git a/src/taming-transformers/data/flickr_tags.txt b/src/taming-transformers/data/flickr_tags.txt new file mode 100644 index 0000000000000000000000000000000000000000..24c7af9acf9e4b7264855488238d520c8960a46c --- /dev/null +++ b/src/taming-transformers/data/flickr_tags.txt @@ -0,0 +1,40 @@ +alaska_lakes +alaska_mountains +antarctica_landscape +australia +black_forest +british_columbia_landscape +canada +carribean +cliff_ocean +desert +dramatic_landscape +geysir +glacier_national_park +glacier_sunset +glacier_waterton_national_park +gobi_landscape +greenland_landscape +iceland_landscape +ireland +jungle +kamchatka_landscape +lakes +meadow +mongolia +mountain_inversion +mountains_autumn +mountain_sunset +newzealand_np +norway +prairie_landscape +rondane_national_park +scotland +sunset +swiss_landscape +swiss_mountains +taiga_landscape +tibet_landscape +tundra_landscape +utah_landscape +volcano diff --git a/src/taming-transformers/data/open_images_annotations_100/class-descriptions-boxable.csv b/src/taming-transformers/data/open_images_annotations_100/class-descriptions-boxable.csv new file mode 100644 index 0000000000000000000000000000000000000000..9f634a5a56350db062cd8ed9601bd146f9a61e84 --- /dev/null +++ b/src/taming-transformers/data/open_images_annotations_100/class-descriptions-boxable.csv @@ -0,0 +1,601 @@ +/m/011k07,Tortoise +/m/011q46kg,Container +/m/012074,Magpie +/m/0120dh,Sea turtle +/m/01226z,Football +/m/012n7d,Ambulance +/m/012w5l,Ladder +/m/012xff,Toothbrush +/m/012ysf,Syringe +/m/0130jx,Sink +/m/0138tl,Toy +/m/013y1f,Organ (Musical Instrument) +/m/01432t,Cassette deck +/m/014j1m,Apple +/m/014sv8,Human eye +/m/014trl,Cosmetics +/m/014y4n,Paddle +/m/0152hh,Snowman +/m/01599,Beer +/m/01_5g,Chopsticks +/m/015h_t,Human beard +/m/015p6,Bird +/m/015qbp,Parking meter +/m/015qff,Traffic light +/m/015wgc,Croissant +/m/015x4r,Cucumber +/m/015x5n,Radish +/m/0162_1,Towel +/m/0167gd,Doll +/m/016m2d,Skull +/m/0174k2,Washing machine +/m/0174n1,Glove +/m/0175cv,Tick +/m/0176mf,Belt +/m/017ftj,Sunglasses +/m/018j2,Banjo +/m/018p4k,Cart +/m/018xm,Ball +/m/01940j,Backpack +/m/0199g,Bicycle +/m/019dx1,Home appliance +/m/019h78,Centipede +/m/019jd,Boat +/m/019w40,Surfboard +/m/01b638,Boot +/m/01b7fy,Headphones +/m/01b9xk,Hot dog +/m/01bfm9,Shorts +/m/01_bhs,Fast food +/m/01bjv,Bus +/m/01bl7v,Boy +/m/01bms0,Screwdriver +/m/01bqk0,Bicycle wheel +/m/01btn,Barge +/m/01c648,Laptop +/m/01cmb2,Miniskirt +/m/01d380,Drill (Tool) +/m/01d40f,Dress +/m/01dws,Bear +/m/01dwsz,Waffle +/m/01dwwc,Pancake +/m/01dxs,Brown bear +/m/01dy8n,Woodpecker +/m/01f8m5,Blue jay +/m/01f91_,Pretzel +/m/01fb_0,Bagel +/m/01fdzj,Tower +/m/01fh4r,Teapot +/m/01g317,Person +/m/01g3x7,Bow and arrow +/m/01gkx_,Swimwear +/m/01gllr,Beehive +/m/01gmv2,Brassiere +/m/01h3n,Bee +/m/01h44,Bat (Animal) +/m/01h8tj,Starfish +/m/01hrv5,Popcorn +/m/01j3zr,Burrito +/m/01j4z9,Chainsaw +/m/01j51,Balloon +/m/01j5ks,Wrench +/m/01j61q,Tent +/m/01jfm_,Vehicle registration plate +/m/01jfsr,Lantern +/m/01k6s3,Toaster +/m/01kb5b,Flashlight +/m/01knjb,Billboard +/m/01krhy,Tiara +/m/01lcw4,Limousine +/m/01llwg,Necklace +/m/01lrl,Carnivore +/m/01lsmm,Scissors +/m/01lynh,Stairs +/m/01m2v,Computer keyboard +/m/01m4t,Printer +/m/01mqdt,Traffic sign +/m/01mzpv,Chair +/m/01n4qj,Shirt +/m/01n5jq,Poster +/m/01nkt,Cheese +/m/01nq26,Sock +/m/01pns0,Fire hydrant +/m/01prls,Land vehicle +/m/01r546,Earrings +/m/01rkbr,Tie +/m/01rzcn,Watercraft +/m/01s105,Cabinetry +/m/01s55n,Suitcase +/m/01tcjp,Muffin +/m/01vbnl,Bidet +/m/01ww8y,Snack +/m/01x3jk,Snowmobile +/m/01x3z,Clock +/m/01xgg_,Medical equipment +/m/01xq0k1,Cattle +/m/01xqw,Cello +/m/01xs3r,Jet ski +/m/01x_v,Camel +/m/01xygc,Coat +/m/01xyhv,Suit +/m/01y9k5,Desk +/m/01yrx,Cat +/m/01yx86,Bronze sculpture +/m/01z1kdw,Juice +/m/02068x,Gondola +/m/020jm,Beetle +/m/020kz,Cannon +/m/020lf,Computer mouse +/m/021mn,Cookie +/m/021sj1,Office building +/m/0220r2,Fountain +/m/0242l,Coin +/m/024d2,Calculator +/m/024g6,Cocktail +/m/02522,Computer monitor +/m/025dyy,Box +/m/025fsf,Stapler +/m/025nd,Christmas tree +/m/025rp__,Cowboy hat +/m/0268lbt,Hiking equipment +/m/026qbn5,Studio couch +/m/026t6,Drum +/m/0270h,Dessert +/m/0271qf7,Wine rack +/m/0271t,Drink +/m/027pcv,Zucchini +/m/027rl48,Ladle +/m/0283dt1,Human mouth +/m/0284d,Dairy Product +/m/029b3,Dice +/m/029bxz,Oven +/m/029tx,Dinosaur +/m/02bm9n,Ratchet (Device) +/m/02crq1,Couch +/m/02ctlc,Cricket ball +/m/02cvgx,Winter melon +/m/02d1br,Spatula +/m/02d9qx,Whiteboard +/m/02ddwp,Pencil sharpener +/m/02dgv,Door +/m/02dl1y,Hat +/m/02f9f_,Shower +/m/02fh7f,Eraser +/m/02fq_6,Fedora +/m/02g30s,Guacamole +/m/02gzp,Dagger +/m/02h19r,Scarf +/m/02hj4,Dolphin +/m/02jfl0,Sombrero +/m/02jnhm,Tin can +/m/02jvh9,Mug +/m/02jz0l,Tap +/m/02l8p9,Harbor seal +/m/02lbcq,Stretcher +/m/02mqfb,Can opener +/m/02_n6y,Goggles +/m/02p0tk3,Human body +/m/02p3w7d,Roller skates +/m/02p5f1q,Coffee cup +/m/02pdsw,Cutting board +/m/02pjr4,Blender +/m/02pkr5,Plumbing fixture +/m/02pv19,Stop sign +/m/02rdsp,Office supplies +/m/02rgn06,Volleyball (Ball) +/m/02s195,Vase +/m/02tsc9,Slow cooker +/m/02vkqh8,Wardrobe +/m/02vqfm,Coffee +/m/02vwcm,Whisk +/m/02w3r3,Paper towel +/m/02w3_ws,Personal care +/m/02wbm,Food +/m/02wbtzl,Sun hat +/m/02wg_p,Tree house +/m/02wmf,Flying disc +/m/02wv6h6,Skirt +/m/02wv84t,Gas stove +/m/02x8cch,Salt and pepper shakers +/m/02x984l,Mechanical fan +/m/02xb7qb,Face powder +/m/02xqq,Fax +/m/02xwb,Fruit +/m/02y6n,French fries +/m/02z51p,Nightstand +/m/02zn6n,Barrel +/m/02zt3,Kite +/m/02zvsm,Tart +/m/030610,Treadmill +/m/0306r,Fox +/m/03120,Flag +/m/0319l,French horn +/m/031b6r,Window blind +/m/031n1,Human foot +/m/0323sq,Golf cart +/m/032b3c,Jacket +/m/033cnk,Egg (Food) +/m/033rq4,Street light +/m/0342h,Guitar +/m/034c16,Pillow +/m/035r7c,Human leg +/m/035vxb,Isopod +/m/0388q,Grape +/m/039xj_,Human ear +/m/03bbps,Power plugs and sockets +/m/03bj1,Panda +/m/03bk1,Giraffe +/m/03bt1vf,Woman +/m/03c7gz,Door handle +/m/03d443,Rhinoceros +/m/03dnzn,Bathtub +/m/03fj2,Goldfish +/m/03fp41,Houseplant +/m/03fwl,Goat +/m/03g8mr,Baseball bat +/m/03grzl,Baseball glove +/m/03hj559,Mixing bowl +/m/03hl4l9,Marine invertebrates +/m/03hlz0c,Kitchen utensil +/m/03jbxj,Light switch +/m/03jm5,House +/m/03k3r,Horse +/m/03kt2w,Stationary bicycle +/m/03l9g,Hammer +/m/03ldnb,Ceiling fan +/m/03m3pdh,Sofa bed +/m/03m3vtv,Adhesive tape +/m/03m5k,Harp +/m/03nfch,Sandal +/m/03p3bw,Bicycle helmet +/m/03q5c7,Saucer +/m/03q5t,Harpsichord +/m/03q69,Human hair +/m/03qhv5,Heater +/m/03qjg,Harmonica +/m/03qrc,Hamster +/m/03rszm,Curtain +/m/03ssj5,Bed +/m/03s_tn,Kettle +/m/03tw93,Fireplace +/m/03txqz,Scale +/m/03v5tg,Drinking straw +/m/03vt0,Insect +/m/03wvsk,Hair dryer +/m/03_wxk,Kitchenware +/m/03wym,Indoor rower +/m/03xxp,Invertebrate +/m/03y6mg,Food processor +/m/03__z0,Bookcase +/m/040b_t,Refrigerator +/m/04169hn,Wood-burning stove +/m/0420v5,Punching bag +/m/043nyj,Common fig +/m/0440zs,Cocktail shaker +/m/0449p,Jaguar (Animal) +/m/044r5d,Golf ball +/m/0463sg,Fashion accessory +/m/046dlr,Alarm clock +/m/047j0r,Filing cabinet +/m/047v4b,Artichoke +/m/04bcr3,Table +/m/04brg2,Tableware +/m/04c0y,Kangaroo +/m/04cp_,Koala +/m/04ctx,Knife +/m/04dr76w,Bottle +/m/04f5ws,Bottle opener +/m/04g2r,Lynx +/m/04gth,Lavender (Plant) +/m/04h7h,Lighthouse +/m/04h8sr,Dumbbell +/m/04hgtk,Human head +/m/04kkgm,Bowl +/m/04lvq_,Humidifier +/m/04m6gz,Porch +/m/04m9y,Lizard +/m/04p0qw,Billiard table +/m/04rky,Mammal +/m/04rmv,Mouse +/m/04_sv,Motorcycle +/m/04szw,Musical instrument +/m/04tn4x,Swim cap +/m/04v6l4,Frying pan +/m/04vv5k,Snowplow +/m/04y4h8h,Bathroom cabinet +/m/04ylt,Missile +/m/04yqq2,Bust +/m/04yx4,Man +/m/04z4wx,Waffle iron +/m/04zpv,Milk +/m/04zwwv,Ring binder +/m/050gv4,Plate +/m/050k8,Mobile phone +/m/052lwg6,Baked goods +/m/052sf,Mushroom +/m/05441v,Crutch +/m/054fyh,Pitcher (Container) +/m/054_l,Mirror +/m/054xkw,Personal flotation device +/m/05_5p_0,Table tennis racket +/m/05676x,Pencil case +/m/057cc,Musical keyboard +/m/057p5t,Scoreboard +/m/0584n8,Briefcase +/m/058qzx,Kitchen knife +/m/05bm6,Nail (Construction) +/m/05ctyq,Tennis ball +/m/05gqfk,Plastic bag +/m/05kms,Oboe +/m/05kyg_,Chest of drawers +/m/05n4y,Ostrich +/m/05r5c,Piano +/m/05r655,Girl +/m/05s2s,Plant +/m/05vtc,Potato +/m/05w9t9,Hair spray +/m/05y5lj,Sports equipment +/m/05z55,Pasta +/m/05z6w,Penguin +/m/05zsy,Pumpkin +/m/061_f,Pear +/m/061hd_,Infant bed +/m/0633h,Polar bear +/m/063rgb,Mixer +/m/0642b4,Cupboard +/m/065h6l,Jacuzzi +/m/0663v,Pizza +/m/06_72j,Digital clock +/m/068zj,Pig +/m/06bt6,Reptile +/m/06c54,Rifle +/m/06c7f7,Lipstick +/m/06_fw,Skateboard +/m/06j2d,Raven +/m/06k2mb,High heels +/m/06l9r,Red panda +/m/06m11,Rose +/m/06mf6,Rabbit +/m/06msq,Sculpture +/m/06ncr,Saxophone +/m/06nrc,Shotgun +/m/06nwz,Seafood +/m/06pcq,Submarine sandwich +/m/06__v,Snowboard +/m/06y5r,Sword +/m/06z37_,Picture frame +/m/07030,Sushi +/m/0703r8,Loveseat +/m/071p9,Ski +/m/071qp,Squirrel +/m/073bxn,Tripod +/m/073g6,Stethoscope +/m/074d1,Submarine +/m/0755b,Scorpion +/m/076bq,Segway +/m/076lb9,Training bench +/m/078jl,Snake +/m/078n6m,Coffee table +/m/079cl,Skyscraper +/m/07bgp,Sheep +/m/07c52,Television +/m/07c6l,Trombone +/m/07clx,Tea +/m/07cmd,Tank +/m/07crc,Taco +/m/07cx4,Telephone +/m/07dd4,Torch +/m/07dm6,Tiger +/m/07fbm7,Strawberry +/m/07gql,Trumpet +/m/07j7r,Tree +/m/07j87,Tomato +/m/07jdr,Train +/m/07k1x,Tool +/m/07kng9,Picnic basket +/m/07mcwg,Cooking spray +/m/07mhn,Trousers +/m/07pj7bq,Bowling equipment +/m/07qxg_,Football helmet +/m/07r04,Truck +/m/07v9_z,Measuring cup +/m/07xyvk,Coffeemaker +/m/07y_7,Violin +/m/07yv9,Vehicle +/m/080hkjn,Handbag +/m/080n7g,Paper cutter +/m/081qc,Wine +/m/083kb,Weapon +/m/083wq,Wheel +/m/084hf,Worm +/m/084rd,Wok +/m/084zz,Whale +/m/0898b,Zebra +/m/08dz3q,Auto part +/m/08hvt4,Jug +/m/08ks85,Pizza cutter +/m/08p92x,Cream +/m/08pbxl,Monkey +/m/096mb,Lion +/m/09728,Bread +/m/099ssp,Platter +/m/09b5t,Chicken +/m/09csl,Eagle +/m/09ct_,Helicopter +/m/09d5_,Owl +/m/09ddx,Duck +/m/09dzg,Turtle +/m/09f20,Hippopotamus +/m/09f_2,Crocodile +/m/09g1w,Toilet +/m/09gtd,Toilet paper +/m/09gys,Squid +/m/09j2d,Clothing +/m/09j5n,Footwear +/m/09k_b,Lemon +/m/09kmb,Spider +/m/09kx5,Deer +/m/09ld4,Frog +/m/09qck,Banana +/m/09rvcxw,Rocket +/m/09tvcd,Wine glass +/m/0b3fp9,Countertop +/m/0bh9flk,Tablet computer +/m/0bjyj5,Waste container +/m/0b_rs,Swimming pool +/m/0bt9lr,Dog +/m/0bt_c3,Book +/m/0bwd_0j,Elephant +/m/0by6g,Shark +/m/0c06p,Candle +/m/0c29q,Leopard +/m/0c2jj,Axe +/m/0c3m8g,Hand dryer +/m/0c3mkw,Soap dispenser +/m/0c568,Porcupine +/m/0c9ph5,Flower +/m/0ccs93,Canary +/m/0cd4d,Cheetah +/m/0cdl1,Palm tree +/m/0cdn1,Hamburger +/m/0cffdh,Maple +/m/0cgh4,Building +/m/0ch_cf,Fish +/m/0cjq5,Lobster +/m/0cjs7,Garden Asparagus +/m/0c_jw,Furniture +/m/0cl4p,Hedgehog +/m/0cmf2,Airplane +/m/0cmx8,Spoon +/m/0cn6p,Otter +/m/0cnyhnx,Bull +/m/0_cp5,Oyster +/m/0cqn2,Horizontal bar +/m/0crjs,Convenience store +/m/0ct4f,Bomb +/m/0cvnqh,Bench +/m/0cxn2,Ice cream +/m/0cydv,Caterpillar +/m/0cyf8,Butterfly +/m/0cyfs,Parachute +/m/0cyhj_,Orange +/m/0czz2,Antelope +/m/0d20w4,Beaker +/m/0d_2m,Moths and butterflies +/m/0d4v4,Window +/m/0d4w1,Closet +/m/0d5gx,Castle +/m/0d8zb,Jellyfish +/m/0dbvp,Goose +/m/0dbzx,Mule +/m/0dftk,Swan +/m/0dj6p,Peach +/m/0djtd,Coconut +/m/0dkzw,Seat belt +/m/0dq75,Raccoon +/m/0_dqb,Chisel +/m/0dt3t,Fork +/m/0dtln,Lamp +/m/0dv5r,Camera +/m/0dv77,Squash (Plant) +/m/0dv9c,Racket +/m/0dzct,Human face +/m/0dzf4,Human arm +/m/0f4s2w,Vegetable +/m/0f571,Diaper +/m/0f6nr,Unicycle +/m/0f6wt,Falcon +/m/0f8s22,Chime +/m/0f9_l,Snail +/m/0fbdv,Shellfish +/m/0fbw6,Cabbage +/m/0fj52s,Carrot +/m/0fldg,Mango +/m/0fly7,Jeans +/m/0fm3zh,Flowerpot +/m/0fp6w,Pineapple +/m/0fqfqc,Drawer +/m/0fqt361,Stool +/m/0frqm,Envelope +/m/0fszt,Cake +/m/0ft9s,Dragonfly +/m/0ftb8,Common sunflower +/m/0fx9l,Microwave oven +/m/0fz0h,Honeycomb +/m/0gd2v,Marine mammal +/m/0gd36,Sea lion +/m/0gj37,Ladybug +/m/0gjbg72,Shelf +/m/0gjkl,Watch +/m/0gm28,Candy +/m/0grw1,Salad +/m/0gv1x,Parrot +/m/0gxl3,Handgun +/m/0h23m,Sparrow +/m/0h2r6,Van +/m/0h8jyh6,Grinder +/m/0h8kx63,Spice rack +/m/0h8l4fh,Light bulb +/m/0h8lkj8,Corded phone +/m/0h8mhzd,Sports uniform +/m/0h8my_4,Tennis racket +/m/0h8mzrc,Wall clock +/m/0h8n27j,Serving tray +/m/0h8n5zk,Kitchen & dining room table +/m/0h8n6f9,Dog bed +/m/0h8n6ft,Cake stand +/m/0h8nm9j,Cat furniture +/m/0h8nr_l,Bathroom accessory +/m/0h8nsvg,Facial tissue holder +/m/0h8ntjv,Pressure cooker +/m/0h99cwc,Kitchen appliance +/m/0h9mv,Tire +/m/0hdln,Ruler +/m/0hf58v5,Luggage and bags +/m/0hg7b,Microphone +/m/0hkxq,Broccoli +/m/0hnnb,Umbrella +/m/0hnyx,Pastry +/m/0hqkz,Grapefruit +/m/0j496,Band-aid +/m/0jbk,Animal +/m/0jg57,Bell pepper +/m/0jly1,Turkey +/m/0jqgx,Lily +/m/0jwn_,Pomegranate +/m/0jy4k,Doughnut +/m/0jyfg,Glasses +/m/0k0pj,Human nose +/m/0k1tl,Pen +/m/0_k2,Ant +/m/0k4j,Car +/m/0k5j,Aircraft +/m/0k65p,Human hand +/m/0km7z,Skunk +/m/0kmg4,Teddy bear +/m/0kpqd,Watermelon +/m/0kpt_,Cantaloupe +/m/0ky7b,Dishwasher +/m/0l14j_,Flute +/m/0l3ms,Balance beam +/m/0l515,Sandwich +/m/0ll1f78,Shrimp +/m/0llzx,Sewing machine +/m/0lt4_,Binoculars +/m/0m53l,Rays and skates +/m/0mcx2,Ipod +/m/0mkg,Accordion +/m/0mw_6,Willow +/m/0n28_,Crab +/m/0nl46,Crown +/m/0nybt,Seahorse +/m/0p833,Perfume +/m/0pcr,Alpaca +/m/0pg52,Taxi +/m/0ph39,Canoe +/m/0qjjc,Remote control +/m/0qmmr,Wheelchair +/m/0wdt60w,Rugby ball +/m/0xfy,Armadillo +/m/0xzly,Maracas +/m/0zvk5,Helmet diff --git a/src/taming-transformers/data/open_images_annotations_100/oidv6-train-annotations-bbox.csv b/src/taming-transformers/data/open_images_annotations_100/oidv6-train-annotations-bbox.csv new file mode 100644 index 0000000000000000000000000000000000000000..c027a074d6dae374936b94d6f594bfc4c081acb6 --- /dev/null +++ b/src/taming-transformers/data/open_images_annotations_100/oidv6-train-annotations-bbox.csv @@ -0,0 +1,949 @@ +ImageID,Source,LabelName,Confidence,XMin,XMax,YMin,YMax,IsOccluded,IsTruncated,IsGroupOf,IsDepiction,IsInside,XClick1X,XClick2X,XClick3X,XClick4X,XClick1Y,XClick2Y,XClick3Y,XClick4Y +000ab31e6be35fed,activemil,/m/02fq_6,1,0.013125,0.303750,0.288333,0.734167,-1,-1,-1,-1,-1,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000ab31e6be35fed,xclick,/m/02jfl0,1,0.000000,0.297500,0.310000,0.733333,0,1,0,0,0,0.173750,0.297500,0.146250,0.000000,0.733333,0.603333,0.310000,0.464167 +000ab31e6be35fed,xclick,/m/02wbtzl,1,0.000000,0.295625,0.310833,0.730833,0,1,0,0,0,0.139375,0.000000,0.172500,0.295625,0.310833,0.458333,0.730833,0.601667 +000ab31e6be35fed,xclick,/m/03bt1vf,1,0.420625,0.627500,0.434167,0.999167,1,1,0,0,0,0.475000,0.627500,0.420625,0.511250,0.434167,0.766667,0.542500,0.999167 +000ab31e6be35fed,xclick,/m/03bt1vf,1,0.553750,0.637500,0.428333,0.571667,1,0,0,0,0,0.590000,0.637500,0.553750,0.588750,0.428333,0.485833,0.499167,0.571667 +000ab31e6be35fed,xclick,/m/03bt1vf,1,0.590625,0.721875,0.392500,0.721667,1,0,0,0,0,0.673750,0.721875,0.642500,0.590625,0.392500,0.522500,0.721667,0.581667 +000ab31e6be35fed,xclick,/m/03bt1vf,1,0.632500,0.843125,0.355000,0.999167,1,1,0,0,0,0.786250,0.843125,0.632500,0.755000,0.355000,0.489167,0.823333,0.999167 +000ab31e6be35fed,xclick,/m/03bt1vf,1,0.796875,0.926875,0.430833,0.999167,1,1,0,0,0,0.855000,0.926875,0.796875,0.850625,0.430833,0.600833,0.604167,0.999167 +000ab31e6be35fed,xclick,/m/03bt1vf,1,0.867500,0.999375,0.490833,0.999167,1,1,0,0,0,0.999375,0.999375,0.867500,0.880625,0.490833,0.633333,0.947500,0.999167 +000ab31e6be35fed,xclick,/m/0crjs,1,0.000000,0.999375,0.000000,0.999167,1,1,0,0,1,0.000000,0.423125,0.999375,0.575000,0.449167,0.000000,0.540833,0.999167 +000ab7bec71cc50a,activemil,/m/0284d,1,0.397000,0.668000,0.203733,0.572317,0,0,0,0,0,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000ab7bec71cc50a,activemil,/m/0cxn2,1,0.379000,0.678000,0.192846,0.606532,0,0,0,0,0,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000ab7bec71cc50a,xclick,/m/0284d,1,0.655000,0.824000,0.562986,0.772939,0,0,0,0,0,0.655000,0.724000,0.720000,0.824000,0.751166,0.562986,0.772939,0.609642 +000ab7bec71cc50a,xclick,/m/09728,1,0.068000,0.750000,0.393468,0.931571,0,0,0,0,0,0.308000,0.750000,0.068000,0.399000,0.393468,0.536547,0.766719,0.931571 +000ab7bec71cc50a,xclick,/m/09728,1,0.487000,0.959000,0.447900,0.920684,1,0,1,0,0,0.789000,0.487000,0.959000,0.758000,0.447900,0.920684,0.765163,0.920684 +000ab8c20b3e5b58,xclick,/m/0jqgx,1,0.251250,0.423125,0.148889,0.420000,1,0,0,0,0,0.251250,0.279375,0.423125,0.319375,0.201111,0.148889,0.244444,0.420000 +000ab8c20b3e5b58,xclick,/m/0jqgx,1,0.275625,0.528125,0.196667,0.705556,0,0,0,0,0,0.275625,0.469375,0.528125,0.471875,0.393333,0.196667,0.484444,0.705556 +000abc075d659122,xclick,/m/01g317,1,0.000000,0.033125,0.460000,0.820000,0,1,0,1,0,0.008750,0.000000,0.006250,0.033125,0.460000,0.595000,0.820000,0.543333 +000abc075d659122,xclick,/m/01g317,1,0.115625,0.175000,0.458333,0.751667,0,0,0,1,0,0.145625,0.115625,0.144375,0.175000,0.458333,0.563333,0.751667,0.548333 +000abc075d659122,xclick,/m/01g317,1,0.223125,0.258125,0.469167,0.711667,0,0,0,1,0,0.240000,0.223125,0.229375,0.258125,0.469167,0.680833,0.711667,0.692500 +000abc075d659122,xclick,/m/01g317,1,0.290000,0.326250,0.467500,0.682500,0,0,0,1,0,0.306875,0.290000,0.300625,0.326250,0.467500,0.550000,0.682500,0.530833 +000abc075d659122,xclick,/m/01g317,1,0.323750,0.400000,0.467500,0.803333,1,0,0,0,0,0.366250,0.323750,0.360000,0.400000,0.467500,0.577500,0.803333,0.634167 +000abc075d659122,xclick,/m/01g317,1,0.458125,0.515000,0.474167,0.672500,1,0,0,0,0,0.483750,0.458125,0.482500,0.515000,0.474167,0.522500,0.672500,0.665000 +000abc075d659122,xclick,/m/01g317,1,0.562500,0.606875,0.475833,0.650000,0,0,0,1,0,0.562500,0.576875,0.606875,0.576875,0.530833,0.475833,0.532500,0.650000 +000abc075d659122,xclick,/m/01g317,1,0.648125,0.696875,0.484167,0.658333,0,0,0,1,0,0.648125,0.680000,0.696875,0.681250,0.569167,0.484167,0.529167,0.658333 +000abc075d659122,xclick,/m/01g317,1,0.765625,0.813125,0.482500,0.665000,0,0,0,1,0,0.783750,0.765625,0.790000,0.813125,0.482500,0.515833,0.665000,0.579167 +000abc075d659122,xclick,/m/01g317,1,0.923125,0.945000,0.484167,0.701667,0,0,0,1,0,0.924375,0.923125,0.929375,0.945000,0.701667,0.700000,0.484167,0.558333 +000abc075d659122,xclick,/m/01g317,1,0.956875,0.977500,0.480833,0.748333,0,0,0,1,0,0.969375,0.956875,0.968125,0.977500,0.480833,0.551667,0.748333,0.535833 +000abc075d659122,xclick,/m/01g317,1,0.968125,0.999375,0.534167,0.880833,0,1,0,0,0,0.999375,0.968125,0.990000,0.999375,0.534167,0.608333,0.880833,0.815000 +000abc075d659122,xclick,/m/09j5n,1,0.334375,0.370625,0.776667,0.802500,0,0,0,0,0,0.352500,0.334375,0.348750,0.370625,0.802500,0.795833,0.776667,0.791667 +000abc075d659122,xclick,/m/09j5n,1,0.363750,0.390000,0.761667,0.787500,1,0,0,0,0,0.378125,0.374375,0.363750,0.390000,0.761667,0.787500,0.772500,0.777500 +000abc075d659122,xclick,/m/09j5n,1,0.466250,0.491875,0.663333,0.675833,1,0,0,0,0,0.473750,0.480000,0.491875,0.466250,0.663333,0.675833,0.674167,0.672500 +000abc075d659122,xclick,/m/09j5n,1,0.495625,0.510000,0.661667,0.670833,1,0,0,0,0,0.502500,0.502500,0.495625,0.510000,0.661667,0.670833,0.670833,0.666667 +000abc075d659122,xclick,/m/09j5n,1,0.981250,0.999375,0.844167,0.875833,0,1,0,0,0,0.991875,0.999375,0.995625,0.981250,0.844167,0.856667,0.875833,0.865000 +000abc821f66a892,xclick,/m/033rq4,1,0.615625,0.660937,0.299550,0.522523,1,0,0,0,0,0.646875,0.615625,0.645312,0.660937,0.299550,0.331081,0.522523,0.313063 +000abc821f66a892,xclick,/m/033rq4,1,0.657812,0.726562,0.000000,0.518018,1,0,0,0,0,0.657812,0.726562,0.690625,0.703125,0.117117,0.103604,0.000000,0.518018 +000abe5eddc5b303,activemil,/m/01g317,1,0.755000,0.803125,0.421111,0.605556,-1,-1,-1,-1,-1,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000abe5eddc5b303,xclick,/m/01g317,1,0.147500,0.217500,0.686667,0.846667,0,0,0,0,0,0.165625,0.147500,0.194375,0.217500,0.686667,0.844444,0.846667,0.755556 +000abe5eddc5b303,xclick,/m/01g317,1,0.339375,0.421250,0.578889,0.758889,0,0,0,0,0,0.372500,0.339375,0.421250,0.365000,0.578889,0.672222,0.733333,0.758889 +000abe5eddc5b303,xclick,/m/07yv9,1,0.953750,0.999375,0.387778,0.538889,0,0,0,0,0,0.999375,0.953750,0.999375,0.999375,0.387778,0.491111,0.538889,0.470000 +000ac34008b0ba4c,xclick,/m/01g317,1,0.070000,0.243333,0.773585,0.998742,0,0,0,0,0,0.172500,0.070000,0.243333,0.230000,0.773585,0.923270,0.949686,0.998742 +000ac34008b0ba4c,xclick,/m/033rq4,1,0.445833,0.620000,0.056604,0.998742,0,1,0,0,0,0.475000,0.525833,0.620000,0.445833,0.056604,0.998742,0.147170,0.103145 +000ac8c676b6077a,xclick,/m/01n5jq,1,0.046667,0.956667,0.031667,0.975000,0,0,0,0,0,0.463333,0.488333,0.046667,0.956667,0.031667,0.975000,0.596667,0.611667 +000ac8c676b6077a,xclick,/m/07j7r,1,0.043333,0.275000,0.041667,0.868333,1,1,1,1,0,0.053333,0.275000,0.066667,0.043333,0.041667,0.490000,0.868333,0.868333 +000ac8c676b6077a,xclick,/m/07j7r,1,0.366667,0.963333,0.038333,0.966667,1,1,1,1,0,0.723333,0.366667,0.791667,0.963333,0.038333,0.046667,0.966667,0.376667 +000ac8c676b6077a,xclick,/m/0c9ph5,1,0.528333,0.965000,0.038333,0.963333,1,1,1,1,0,0.675000,0.965000,0.808333,0.528333,0.038333,0.605000,0.963333,0.101667 +000ac95750ac7399,xclick,/m/01n4qj,1,0.224375,0.457500,0.367978,0.795880,1,0,0,0,0,0.228750,0.224375,0.453750,0.457500,0.367978,0.382959,0.722846,0.795880 +000ac95750ac7399,xclick,/m/01n4qj,1,0.497500,0.598750,0.670412,0.893258,1,0,0,0,0,0.497500,0.497500,0.598750,0.574375,0.670412,0.706929,0.893258,0.766854 +000ac95750ac7399,xclick,/m/01rkbr,1,0.305625,0.466250,0.464419,0.892322,1,0,0,0,0,0.330000,0.305625,0.466250,0.460000,0.464419,0.506554,0.892322,0.813670 +000ac95750ac7399,xclick,/m/01rkbr,1,0.570625,0.633125,0.768727,0.958802,1,0,0,0,0,0.581875,0.570625,0.628125,0.633125,0.768727,0.778090,0.951311,0.958802 +000ac95750ac7399,xclick,/m/01xygc,1,0.056250,0.515000,0.392322,0.999064,0,1,0,0,0,0.221250,0.056250,0.194375,0.515000,0.392322,0.776217,0.999064,0.818352 +000ac95750ac7399,xclick,/m/01xygc,1,0.651875,0.823750,0.852996,0.999064,0,1,0,0,0,0.706875,0.651875,0.708125,0.823750,0.852996,0.997191,0.999064,0.999064 +000ac95750ac7399,xclick,/m/01xyhv,1,0.049375,0.563125,0.384831,0.999064,0,1,0,0,0,0.220625,0.049375,0.563125,0.524375,0.384831,0.740637,0.999064,0.997191 +000ac95750ac7399,xclick,/m/01xyhv,1,0.495625,0.661875,0.670412,0.999064,1,1,0,0,0,0.495625,0.505625,0.660625,0.661875,0.670412,0.937266,0.991573,0.999064 +000ac95750ac7399,xclick,/m/02dl1y,1,0.466875,0.646250,0.500000,0.605805,1,0,0,0,0,0.553125,0.646250,0.466875,0.492500,0.500000,0.538390,0.556180,0.605805 +000ac95750ac7399,xclick,/m/02dl1y,1,0.663750,0.808125,0.637640,0.789326,0,0,0,0,0,0.773750,0.808125,0.691875,0.663750,0.637640,0.676030,0.789326,0.752809 +000ac95750ac7399,xclick,/m/04yx4,1,0.049375,0.560625,0.084270,0.999064,0,1,0,0,0,0.319375,0.049375,0.287500,0.560625,0.084270,0.717228,0.999064,0.993446 +000ac95750ac7399,xclick,/m/04yx4,1,0.485625,0.658750,0.496255,0.999064,1,0,0,0,0,0.552500,0.485625,0.658750,0.596250,0.496255,0.682584,0.999064,0.999064 +000acf666d991c39,xclick,/m/0bt9lr,1,0.177500,0.749375,0.461251,0.999066,1,1,0,0,0,0.423750,0.177500,0.608125,0.749375,0.461251,0.601307,0.999066,0.989729 +000acf666d991c39,xclick,/m/0bt9lr,1,0.449375,0.999375,0.038282,0.999066,0,1,0,0,0,0.753125,0.449375,0.818125,0.999375,0.038282,0.729225,0.999066,0.794585 +000ad0ecfb21ee63,xclick,/m/01d40f,1,0.643646,0.999309,0.412551,0.998971,1,1,0,0,0,0.856354,0.643646,0.799033,0.999309,0.412551,0.856996,0.998971,0.769547 +000ad0ecfb21ee63,xclick,/m/0dzf4,1,0.116713,0.219613,0.516461,0.998971,1,1,0,0,0,0.173343,0.219613,0.116713,0.131906,0.516461,0.598765,0.944444,0.998971 +000ad0ecfb21ee63,xclick,/m/0dzf4,1,0.342541,0.422652,0.522634,0.826132,1,0,0,0,0,0.368785,0.422652,0.405387,0.342541,0.522634,0.792181,0.826132,0.770576 +000ad0ecfb21ee63,xclick,/m/0dzf4,1,0.636740,0.709945,0.491770,0.998971,1,1,0,0,0,0.678177,0.636740,0.657459,0.709945,0.491770,0.861111,0.998971,0.856996 +000ad0ecfb21ee63,xclick,/m/0dzf4,1,0.866713,0.999309,0.447531,0.849794,1,1,0,0,0,0.932320,0.866713,0.974448,0.999309,0.447531,0.776749,0.849794,0.696502 +000ad0ecfb21ee63,xclick,/m/0k65p,1,0.341851,0.411602,0.736625,0.829218,1,0,0,0,0,0.399171,0.411602,0.405387,0.341851,0.736625,0.786008,0.829218,0.745885 +000ad0ecfb21ee63,xclick,/m/0k65p,1,0.860497,0.960635,0.735597,0.836420,1,0,0,0,0,0.942680,0.960635,0.914365,0.860497,0.836420,0.796296,0.735597,0.782922 +000ad20b5e452b24,xclick,/m/050k8,1,0.000000,0.603125,0.192188,0.917188,0,1,0,0,0,0.170313,0.340625,0.603125,0.000000,0.192188,0.917188,0.642188,0.446875 +000ad20b5e452b24,xclick,/m/050k8,1,0.407813,0.998438,0.134375,0.918750,1,1,0,0,0,0.679688,0.798438,0.407813,0.998438,0.134375,0.918750,0.289062,0.701562 +000ad3d42653f5f6,xclick,/m/019jd,1,0.000000,0.665556,0.485000,0.778333,0,1,0,0,0,0.032222,0.143333,0.665556,0.000000,0.778333,0.485000,0.585000,0.641667 +000ad3d42653f5f6,xclick,/m/019jd,1,0.612222,0.860000,0.416667,0.708333,1,0,0,0,0,0.761111,0.860000,0.818889,0.612222,0.708333,0.660000,0.416667,0.695000 +000ad3d42653f5f6,xclick,/m/019jd,1,0.781111,0.953333,0.431667,0.703333,1,0,0,0,0,0.923333,0.867778,0.953333,0.781111,0.703333,0.431667,0.645000,0.546667 +000ad3d42653f5f6,xclick,/m/019jd,1,0.912222,0.998889,0.523333,0.671667,1,1,0,0,0,0.983333,0.964444,0.998889,0.912222,0.671667,0.523333,0.580000,0.548333 +000ad3d42653f5f6,xclick,/m/07j7r,1,0.360000,0.453333,0.236667,0.498333,0,0,0,0,0,0.416667,0.440000,0.360000,0.453333,0.236667,0.498333,0.325000,0.265000 +000ad6c520be9ec5,xclick,/m/03fwl,1,0.093750,0.668125,0.192500,0.940833,0,0,0,1,0,0.204375,0.282500,0.668125,0.093750,0.192500,0.940833,0.391667,0.396667 +000ad6c520be9ec5,xclick,/m/06msq,1,0.000000,0.094375,0.720833,0.824167,0,1,0,1,0,0.000000,0.094375,0.000000,0.000000,0.720833,0.777500,0.790833,0.824167 +000ad6c520be9ec5,xclick,/m/06msq,1,0.086875,0.663750,0.210833,0.940833,0,0,0,1,0,0.431250,0.663750,0.086875,0.279375,0.210833,0.441667,0.401667,0.940833 +000ad6c520be9ec5,xclick,/m/06msq,1,0.711875,0.932500,0.115833,0.445000,0,0,0,1,0,0.857500,0.932500,0.711875,0.741250,0.115833,0.375833,0.415833,0.445000 +000ad6fa67b5ad96,xclick,/m/06msq,1,0.067542,0.999062,0.353750,0.999375,1,1,0,0,0,0.999062,0.693246,0.151970,0.067542,0.873750,0.999375,0.353750,0.370625 +000ad6fa67b5ad96,xclick,/m/0jbk,1,0.075047,0.999062,0.363125,0.998750,0,1,0,0,0,0.195122,0.075047,0.470919,0.999062,0.363125,0.388750,0.998750,0.711875 +000adcdd7244ce4a,xclick,/m/01g317,1,0.119176,0.415771,0.091610,0.941176,0,0,0,1,0,0.174731,0.119176,0.244624,0.415771,0.941176,0.309547,0.091610,0.629701 +000adcdd7244ce4a,xclick,/m/01g317,1,0.551971,0.933692,0.304725,0.945034,0,0,0,1,0,0.674731,0.551971,0.836918,0.933692,0.304725,0.433944,0.945034,0.522662 +000adcdd7244ce4a,xclick,/m/04hgtk,1,0.145161,0.277778,0.085824,0.264224,0,0,0,1,0,0.277778,0.229391,0.145161,0.225806,0.134041,0.085824,0.138862,0.264224 +000adcdd7244ce4a,xclick,/m/04hgtk,1,0.554659,0.853047,0.315333,0.686596,0,0,0,1,0,0.654122,0.554659,0.853047,0.729391,0.315333,0.523626,0.469624,0.686596 +000adcdd7244ce4a,xclick,/m/04rky,1,0.114695,0.413082,0.093539,0.942141,0,1,0,1,0,0.218638,0.413082,0.114695,0.188172,0.093539,0.624879,0.314368,0.942141 +000adcdd7244ce4a,xclick,/m/04rky,1,0.553763,0.935484,0.310511,0.942141,1,1,0,1,0,0.553763,0.670251,0.935484,0.850358,0.456123,0.310511,0.617165,0.942141 +000adcdd7244ce4a,xclick,/m/0dzf4,1,0.116487,0.259857,0.224687,0.479267,0,0,0,1,0,0.259857,0.116487,0.170251,0.259857,0.224687,0.305689,0.479267,0.259402 +000adcdd7244ce4a,xclick,/m/0dzf4,1,0.299283,0.413082,0.290260,0.671167,0,0,0,1,0,0.299283,0.299283,0.387097,0.413082,0.290260,0.465767,0.671167,0.648987 +000adef7197e3118,xclick,/m/07j7r,1,0.000000,0.999375,0.000000,0.886064,1,1,1,0,0,0.331250,0.000000,0.517500,0.999375,0.000000,0.299435,0.886064,0.303202 +000adef7197e3118,xclick,/m/07j7r,1,0.790625,0.950000,0.000000,0.306968,1,1,0,0,0,0.857500,0.790625,0.950000,0.866250,0.000000,0.301318,0.008475,0.306968 +000adef7197e3118,xclick,/m/0cvnqh,1,0.380000,0.481875,0.314501,0.409605,1,0,0,0,0,0.381250,0.380000,0.481875,0.420000,0.314501,0.409605,0.402072,0.320151 +000adef7197e3118,xclick,/m/0cvnqh,1,0.423750,0.562500,0.580038,0.831450,1,0,0,0,0,0.455625,0.455625,0.423750,0.562500,0.580038,0.831450,0.813559,0.592279 +000adef7197e3118,xclick,/m/0cvnqh,1,0.648125,0.791875,0.568738,0.842750,1,0,0,0,0,0.722500,0.791875,0.778750,0.648125,0.568738,0.807910,0.842750,0.568738 +000adfe5b817011c,activemil,/m/0cgh4,1,0.065833,1.000000,0.106250,0.843125,-1,-1,-1,-1,-1,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000adfe5b817011c,xclick,/m/0cgh4,1,0.008333,0.260833,0.000000,0.195625,1,1,0,0,0,0.183333,0.260833,0.008333,0.015000,0.000000,0.118750,0.195625,0.132500 +000ae235808cc1e8,xclick,/m/019jd,1,0.000741,0.040741,0.644444,0.683333,1,1,0,0,0,0.040741,0.000741,0.029630,0.033333,0.644444,0.644444,0.683333,0.683333 +000ae235808cc1e8,xclick,/m/019jd,1,0.037037,0.108148,0.634444,0.696667,1,0,0,0,0,0.083704,0.037037,0.061481,0.108148,0.634444,0.646667,0.696667,0.644444 +000ae235808cc1e8,xclick,/m/019jd,1,0.061481,0.183704,0.636667,0.733333,1,0,0,0,0,0.122222,0.061481,0.137778,0.183704,0.636667,0.675556,0.733333,0.673333 +000ae235808cc1e8,xclick,/m/019jd,1,0.154074,0.395556,0.636667,0.810000,0,0,0,0,0,0.212593,0.154074,0.373333,0.395556,0.636667,0.714444,0.810000,0.722222 +000ae235808cc1e8,xclick,/m/019jd,1,0.442222,0.712593,0.694444,0.783333,1,0,0,0,0,0.590370,0.442222,0.443704,0.712593,0.694444,0.741111,0.783333,0.770000 +000ae235808cc1e8,xclick,/m/019jd,1,0.692593,0.815556,0.702222,0.751111,1,0,0,0,0,0.745926,0.692593,0.814815,0.815556,0.702222,0.741111,0.743333,0.751111 +000ae235808cc1e8,xclick,/m/019jd,1,0.721482,0.994815,0.633333,0.766667,1,1,0,0,0,0.956296,0.721482,0.828889,0.994815,0.633333,0.673333,0.766667,0.715556 +000ae235808cc1e8,xclick,/m/019jd,1,0.927407,0.999259,0.612222,0.710000,1,1,0,0,0,0.996296,0.927407,0.998519,0.999259,0.612222,0.627778,0.685556,0.710000 +000ae235808cc1e8,xclick,/m/03jm5,1,0.055556,0.080000,0.488889,0.631111,0,0,0,0,0,0.071852,0.055556,0.065185,0.080000,0.488889,0.588889,0.631111,0.617778 +000ae235808cc1e8,xclick,/m/03jm5,1,0.080000,0.106667,0.497778,0.660000,0,0,0,0,0,0.080000,0.096296,0.106667,0.094815,0.617778,0.497778,0.565556,0.660000 +000ae235808cc1e8,xclick,/m/03jm5,1,0.104444,0.146667,0.494444,0.644444,0,0,0,0,0,0.104444,0.120741,0.146667,0.142963,0.644444,0.494444,0.621111,0.641111 +000ae235808cc1e8,xclick,/m/03jm5,1,0.141481,0.190370,0.507778,0.688889,0,0,0,0,0,0.141481,0.153333,0.178519,0.190370,0.643333,0.507778,0.688889,0.635556 +000ae235808cc1e8,xclick,/m/03jm5,1,0.190370,0.242222,0.403333,0.635556,0,0,0,0,0,0.190370,0.199259,0.239259,0.242222,0.635556,0.442222,0.403333,0.575556 +000ae235808cc1e8,xclick,/m/03jm5,1,0.234074,0.297037,0.371111,0.614444,0,0,0,0,0,0.234074,0.237778,0.297037,0.296296,0.614444,0.490000,0.371111,0.546667 +000ae235808cc1e8,xclick,/m/03jm5,1,0.296296,0.380741,0.345556,0.670000,0,0,0,0,0,0.296296,0.328148,0.380741,0.360000,0.610000,0.345556,0.424444,0.670000 +000ae235808cc1e8,xclick,/m/03jm5,1,0.388889,0.588889,0.205556,0.710000,0,0,0,0,0,0.502222,0.588889,0.388889,0.528889,0.205556,0.273333,0.647778,0.710000 +000ae235808cc1e8,xclick,/m/03jm5,1,0.600000,0.661481,0.283333,0.586667,0,0,0,0,0,0.600000,0.629630,0.661481,0.660000,0.571111,0.283333,0.432222,0.586667 +000ae235808cc1e8,xclick,/m/03jm5,1,0.654815,0.714074,0.335556,0.660000,0,0,0,0,0,0.654815,0.670370,0.714074,0.714074,0.623333,0.335556,0.442222,0.660000 +000ae235808cc1e8,xclick,/m/03jm5,1,0.715556,0.769630,0.418889,0.623333,0,0,0,0,0,0.715556,0.728148,0.766667,0.769630,0.623333,0.421111,0.418889,0.610000 +000ae235808cc1e8,xclick,/m/03jm5,1,0.769630,0.808148,0.416667,0.670000,0,0,0,0,0,0.769630,0.808148,0.796296,0.796296,0.573333,0.670000,0.416667,0.416667 +000ae235808cc1e8,xclick,/m/03jm5,1,0.796296,0.850370,0.393333,0.644444,0,0,0,0,0,0.796296,0.822222,0.850370,0.808148,0.416667,0.393333,0.643333,0.644444 +000ae235808cc1e8,xclick,/m/03jm5,1,0.822222,0.888148,0.403333,0.646667,0,0,0,0,0,0.822222,0.846667,0.888148,0.857037,0.546667,0.403333,0.646667,0.646667 +000ae235808cc1e8,xclick,/m/03jm5,1,0.857037,0.957778,0.353333,0.646667,0,0,0,0,0,0.857037,0.888148,0.944444,0.957778,0.646667,0.442222,0.353333,0.617778 +000ae235808cc1e8,xclick,/m/03jm5,1,0.960000,0.999259,0.364444,0.646667,0,0,0,0,0,0.999259,0.994815,0.960000,0.991852,0.496667,0.364444,0.536667,0.646667 +000ae28755d2d20e,xclick,/m/04yx4,1,0.245000,0.538750,0.221667,0.999167,1,1,0,0,0,0.312500,0.538750,0.368750,0.245000,0.221667,0.632500,0.999167,0.842500 +000ae28755d2d20e,xclick,/m/07j7r,1,0.162500,0.533125,0.043333,0.505833,1,1,1,0,0,0.206250,0.220625,0.162500,0.533125,0.505833,0.043333,0.090833,0.390833 +000ae28755d2d20e,xclick,/m/07mhn,1,0.243750,0.446875,0.790000,0.999167,1,1,0,0,0,0.256875,0.243750,0.446875,0.427500,0.790000,0.838333,0.995833,0.999167 +000ae28755d2d20e,xclick,/m/07mhn,1,0.667500,0.707500,0.775833,0.913333,1,0,0,0,0,0.699375,0.667500,0.681250,0.707500,0.775833,0.884167,0.913333,0.784167 +000ae28755d2d20e,xclick,/m/0dzf4,1,0.216250,0.490625,0.475833,0.716667,0,0,0,0,0,0.241875,0.490625,0.216250,0.313750,0.475833,0.681667,0.558333,0.716667 +000ae28755d2d20e,xclick,/m/0dzf4,1,0.394375,0.528125,0.476667,0.657500,0,0,0,0,0,0.394375,0.396875,0.425000,0.528125,0.476667,0.554167,0.657500,0.657500 +000ae28755d2d20e,xclick,/m/0jyfg,1,0.286250,0.380000,0.320000,0.350833,1,0,0,0,0,0.374375,0.343750,0.286250,0.380000,0.320000,0.350833,0.320000,0.334167 +000aecd78b230135,xclick,/m/01n4qj,1,0.043750,0.402500,0.274254,0.761194,1,0,0,0,0,0.233750,0.402500,0.043750,0.261250,0.274254,0.535448,0.542910,0.761194 +000aecd78b230135,xclick,/m/01n4qj,1,0.636250,0.998750,0.177239,0.798507,1,1,0,0,0,0.786250,0.998750,0.915000,0.636250,0.177239,0.458955,0.798507,0.389925 +000aecd78b230135,xclick,/m/035r7c,1,0.105000,0.267500,0.742537,0.998134,1,1,0,0,0,0.140000,0.267500,0.242500,0.105000,0.742537,0.794776,0.998134,0.938433 +000aecd78b230135,xclick,/m/035r7c,1,0.242500,0.478750,0.727612,0.998134,1,1,0,0,0,0.302500,0.478750,0.428750,0.242500,0.727612,0.972015,0.998134,0.753731 +000aecd78b230135,xclick,/m/035r7c,1,0.371250,0.535000,0.718284,0.947761,1,1,0,0,0,0.408750,0.371250,0.535000,0.477500,0.718284,0.781716,0.800373,0.947761 +000aecd78b230135,xclick,/m/035r7c,1,0.478750,0.667500,0.654851,0.990672,1,1,0,0,0,0.566250,0.667500,0.641250,0.478750,0.654851,0.805970,0.990672,0.979478 +000aecd78b230135,xclick,/m/035r7c,1,0.668750,0.865000,0.727612,0.998134,1,1,0,0,0,0.830000,0.668750,0.865000,0.800000,0.727612,0.820896,0.819030,0.998134 +000aecd78b230135,xclick,/m/035r7c,1,0.838750,0.998750,0.722015,0.893657,1,1,0,0,0,0.838750,0.998750,0.998750,0.858750,0.722015,0.802239,0.893657,0.804104 +000aecd78b230135,xclick,/m/0fly7,1,0.082500,0.468750,0.716418,0.998134,0,1,0,0,0,0.326250,0.468750,0.206250,0.082500,0.716418,0.968284,0.998134,0.899254 +000aecd78b230135,xclick,/m/0fly7,1,0.380000,0.653750,0.666045,0.998134,0,1,0,0,0,0.563750,0.545000,0.380000,0.653750,0.666045,0.998134,0.744403,0.811567 +000aecd78b230135,xclick,/m/0fly7,1,0.660000,0.993750,0.697761,0.985075,1,1,0,0,0,0.993750,0.660000,0.661250,0.697500,0.707090,0.985075,0.809701,0.697761 +000aee0af66d4237,xclick,/m/011k07,1,0.088750,0.908750,0.000000,0.808333,1,0,0,0,0,0.468125,0.908750,0.798750,0.088750,0.000000,0.763333,0.808333,0.437500 +000aee0af66d4237,xclick,/m/0120dh,1,0.095000,0.916875,0.005000,0.830000,1,0,0,0,0,0.478750,0.916875,0.095000,0.848125,0.005000,0.762500,0.458333,0.830000 +000aee0af66d4237,xclick,/m/05s2s,1,0.000000,0.999375,0.000000,0.999167,1,1,1,0,0,0.413125,0.000000,0.486875,0.999375,0.000000,0.388333,0.999167,0.809167 +000aee0af66d4237,xclick,/m/0f4s2w,1,0.000000,0.546875,0.504167,0.999167,1,1,0,0,0,0.088125,0.546875,0.276250,0.000000,0.504167,0.999167,0.999167,0.915000 +000aee0af66d4237,xclick,/m/0kpqd,1,0.247500,0.793750,0.574167,0.900833,1,0,0,0,0,0.300625,0.247500,0.553750,0.793750,0.574167,0.582500,0.900833,0.606667 +000af180a3163f17,activemil,/m/01bl7v,1,0.593750,0.998438,0.000000,0.997642,-1,-1,-1,-1,-1,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000af180a3163f17,xclick,/m/014sv8,1,0.592969,0.642969,0.383255,0.457547,0,0,0,0,0,0.609375,0.592969,0.625000,0.642969,0.383255,0.451651,0.457547,0.400943 +000af180a3163f17,xclick,/m/014sv8,1,0.702344,0.775781,0.320755,0.375000,0,0,0,0,0,0.734375,0.775781,0.746094,0.702344,0.320755,0.331368,0.366745,0.375000 +000af180a3163f17,xclick,/m/0283dt1,1,0.660937,0.776563,0.541274,0.640330,0,0,0,0,0,0.776563,0.703125,0.660937,0.757031,0.547170,0.640330,0.579009,0.541274 +000af180a3163f17,xclick,/m/03q69,1,0.553906,0.943750,0.031840,0.387972,1,0,0,0,0,0.743750,0.553906,0.869531,0.943750,0.031840,0.251179,0.387972,0.318396 +000af180a3163f17,xclick,/m/04hgtk,1,0.612500,0.917969,0.093160,0.745283,1,0,0,0,0,0.612500,0.658594,0.747656,0.917969,0.503538,0.093160,0.745283,0.304245 +000af180a3163f17,xclick,/m/0dzct,1,0.575000,0.896094,0.142689,0.771226,1,0,0,0,0,0.575000,0.671875,0.896094,0.735938,0.380896,0.142689,0.419811,0.771226 +000af631fb329557,xclick,/m/01g317,1,0.056000,0.258000,0.658000,0.949000,0,1,0,0,0,0.056000,0.056000,0.173000,0.258000,0.949000,0.949000,0.658000,0.698000 +000af631fb329557,xclick,/m/01g317,1,0.056000,0.332000,0.344000,0.629000,0,0,0,0,0,0.197000,0.332000,0.140000,0.056000,0.344000,0.465000,0.629000,0.453000 +000af631fb329557,xclick,/m/01g317,1,0.244000,0.343000,0.647000,0.945000,0,1,0,1,0,0.244000,0.319000,0.326000,0.343000,0.722000,0.647000,0.945000,0.933000 +000af631fb329557,xclick,/m/01g317,1,0.260000,0.357000,0.143000,0.337000,0,1,0,1,0,0.350000,0.260000,0.327000,0.357000,0.143000,0.243000,0.337000,0.299000 +000af631fb329557,xclick,/m/01g317,1,0.379000,0.656000,0.051000,0.334000,0,1,0,0,0,0.379000,0.485000,0.656000,0.622000,0.219000,0.051000,0.216000,0.334000 +000af631fb329557,xclick,/m/01g317,1,0.420000,0.654000,0.354000,0.646000,0,1,0,0,0,0.420000,0.535000,0.654000,0.654000,0.505000,0.354000,0.646000,0.646000 +000af631fb329557,xclick,/m/01g317,1,0.490000,0.658000,0.665000,0.958000,0,1,0,1,0,0.561000,0.490000,0.582000,0.658000,0.665000,0.805000,0.958000,0.819000 +000af631fb329557,xclick,/m/01g317,1,0.686000,0.859000,0.812000,0.958000,0,1,0,1,0,0.721000,0.859000,0.780000,0.686000,0.812000,0.904000,0.958000,0.932000 +000af631fb329557,xclick,/m/01g317,1,0.743000,0.967000,0.394000,0.646000,0,1,0,1,0,0.950000,0.967000,0.743000,0.800000,0.394000,0.509000,0.642000,0.646000 +000af631fb329557,xclick,/m/0dzct,1,0.047000,0.168000,0.767000,0.947000,0,1,0,1,0,0.078000,0.106000,0.047000,0.168000,0.767000,0.947000,0.902000,0.853000 +000af631fb329557,xclick,/m/0dzct,1,0.114000,0.251000,0.347000,0.562000,0,0,0,1,0,0.189000,0.197000,0.114000,0.251000,0.347000,0.562000,0.443000,0.444000 +000af631fb329557,xclick,/m/0dzct,1,0.310000,0.347000,0.791000,0.937000,0,1,0,1,0,0.343000,0.338000,0.310000,0.347000,0.791000,0.937000,0.867000,0.855000 +000af631fb329557,xclick,/m/0dzct,1,0.525000,0.659000,0.351000,0.533000,0,1,0,1,0,0.627000,0.631000,0.525000,0.659000,0.351000,0.533000,0.443000,0.410000 +000af631fb329557,xclick,/m/0dzct,1,0.641000,0.660000,0.822000,0.926000,0,1,0,1,0,0.648000,0.653000,0.660000,0.641000,0.822000,0.926000,0.864000,0.878000 +000afe7726e121ea,xclick,/m/02p0tk3,1,0.213125,0.407500,0.162289,0.993433,0,1,0,0,0,0.311875,0.213125,0.274375,0.407500,0.162289,0.448405,0.993433,0.351782 +000afe7726e121ea,xclick,/m/04yx4,1,0.215625,0.413750,0.169794,0.999062,1,1,0,0,0,0.215625,0.327500,0.413750,0.353125,0.451220,0.169794,0.753283,0.999062 +000afe7726e121ea,xclick,/m/0dzf4,1,0.241250,0.411875,0.250469,0.512195,1,0,0,0,0,0.343125,0.241250,0.411875,0.357500,0.250469,0.423077,0.357411,0.512195 +000afe7726e121ea,xclick,/m/0k65p,1,0.339375,0.388750,0.244841,0.321764,0,0,0,0,0,0.339375,0.340625,0.380625,0.388750,0.244841,0.257974,0.321764,0.299250 +000b06c0eed42a4c,xclick,/m/01n4qj,1,0.139167,0.462500,0.161875,0.395625,1,0,0,0,0,0.214167,0.139167,0.305000,0.462500,0.161875,0.240000,0.395625,0.211250 +000b06c0eed42a4c,xclick,/m/01n4qj,1,0.155000,0.421667,0.612500,0.913125,1,0,0,0,0,0.248333,0.155000,0.255000,0.421667,0.612500,0.770000,0.913125,0.728750 +000b06c0eed42a4c,xclick,/m/01n4qj,1,0.617500,0.873333,0.140625,0.424375,1,0,0,0,0,0.712500,0.873333,0.617500,0.742500,0.140625,0.235625,0.259375,0.424375 +000b06c0eed42a4c,xclick,/m/01n4qj,1,0.617500,0.888333,0.619375,0.898125,1,0,0,0,0,0.708333,0.617500,0.740000,0.888333,0.619375,0.773125,0.898125,0.759375 +000b06c0eed42a4c,xclick,/m/03q69,1,0.195000,0.390000,0.051250,0.213125,0,0,0,0,0,0.292500,0.195000,0.390000,0.335833,0.051250,0.133125,0.133125,0.213125 +000b06c0eed42a4c,xclick,/m/03q69,1,0.219167,0.360000,0.499375,0.618750,0,0,0,0,0,0.291667,0.219167,0.332500,0.360000,0.499375,0.540625,0.618750,0.560625 +000b06c0eed42a4c,xclick,/m/03q69,1,0.667500,0.820000,0.495625,0.618750,0,0,0,0,0,0.742500,0.667500,0.704167,0.820000,0.495625,0.548750,0.618750,0.553750 +000b06c0eed42a4c,xclick,/m/03q69,1,0.681667,0.818333,0.021250,0.147500,0,0,0,0,0,0.759167,0.681667,0.790833,0.818333,0.021250,0.085625,0.147500,0.123750 +000b06c0eed42a4c,xclick,/m/0dzf4,1,0.089167,0.241667,0.674375,0.918125,1,0,0,0,0,0.241667,0.089167,0.139167,0.221667,0.918125,0.913125,0.691250,0.674375 +000b06c0eed42a4c,xclick,/m/0dzf4,1,0.135000,0.232500,0.206250,0.443750,1,0,0,0,0,0.185000,0.135000,0.157500,0.232500,0.206250,0.218125,0.443750,0.426250 +000b06c0eed42a4c,xclick,/m/0dzf4,1,0.296667,0.428333,0.656875,0.931875,1,0,0,0,0,0.360000,0.428333,0.296667,0.365000,0.656875,0.682500,0.918125,0.931875 +000b06c0eed42a4c,xclick,/m/0dzf4,1,0.326667,0.458333,0.172500,0.354375,1,0,0,0,0,0.408333,0.326667,0.458333,0.345000,0.172500,0.349375,0.237500,0.354375 +000b06c0eed42a4c,xclick,/m/0dzf4,1,0.620000,0.700000,0.195625,0.428125,0,0,0,0,0,0.620000,0.681667,0.629167,0.700000,0.195625,0.211250,0.428125,0.419375 +000b06c0eed42a4c,xclick,/m/0dzf4,1,0.624167,0.695000,0.661875,0.918125,1,0,0,0,0,0.695000,0.658333,0.624167,0.667500,0.894375,0.918125,0.675625,0.661875 +000b06c0eed42a4c,xclick,/m/0dzf4,1,0.775000,0.865833,0.233125,0.416250,1,0,0,0,0,0.775000,0.865833,0.856667,0.813333,0.416250,0.407500,0.233125,0.233125 +000b06c0eed42a4c,xclick,/m/0dzf4,1,0.795000,0.881667,0.710000,0.903125,1,0,0,0,0,0.820000,0.881667,0.795000,0.868333,0.710000,0.711875,0.887500,0.903125 +000b06c0eed42a4c,xclick,/m/0fly7,1,0.162500,0.388333,0.900625,0.998125,1,1,0,0,0,0.322500,0.162500,0.367500,0.388333,0.900625,0.998125,0.990000,0.916250 +000b06c0eed42a4c,xclick,/m/0fly7,1,0.176667,0.381667,0.349375,0.499375,1,0,0,0,0,0.276667,0.176667,0.381667,0.381667,0.349375,0.499375,0.499375,0.499375 +000b06c0eed42a4c,xclick,/m/0fly7,1,0.638333,0.858333,0.398750,0.497500,1,0,0,0,0,0.735833,0.697500,0.638333,0.858333,0.398750,0.497500,0.461875,0.439375 +000b06c0eed42a4c,xclick,/m/0fly7,1,0.650000,0.860000,0.888750,0.996250,1,1,0,0,0,0.650000,0.650000,0.735000,0.860000,0.907500,0.926250,0.888750,0.996250 +000b093da01e5bfe,xclick,/m/07j7r,1,0.000000,0.291875,0.439183,0.726091,1,1,1,0,0,0.006250,0.000000,0.291875,0.051875,0.439183,0.535747,0.608171,0.726091 +000b093da01e5bfe,xclick,/m/07j7r,1,0.000000,0.999375,0.199629,0.544104,1,1,1,0,0,0.880625,0.999375,0.741875,0.000000,0.199629,0.239554,0.544104,0.415970 +000b093da01e5bfe,xclick,/m/07j7r,1,0.034375,0.363750,0.722377,0.999071,0,1,0,0,0,0.168750,0.034375,0.362500,0.363750,0.722377,0.972145,0.992572,0.999071 +000b093da01e5bfe,xclick,/m/07j7r,1,0.107500,0.362500,0.305478,0.705664,1,0,1,0,0,0.241875,0.107500,0.362500,0.121250,0.305478,0.703807,0.587744,0.705664 +000b093da01e5bfe,xclick,/m/07j7r,1,0.116875,0.196250,0.490251,0.713092,1,0,0,0,0,0.168125,0.196250,0.170625,0.116875,0.490251,0.616527,0.713092,0.698236 +000b093da01e5bfe,xclick,/m/07j7r,1,0.206875,0.226875,0.553389,0.669452,1,0,0,0,0,0.206875,0.226875,0.220625,0.206875,0.553389,0.629526,0.669452,0.669452 +000b093da01e5bfe,xclick,/m/07j7r,1,0.232500,0.273125,0.319406,0.663881,1,0,0,0,0,0.232500,0.273125,0.245000,0.232500,0.319406,0.598886,0.658310,0.663881 +000b093da01e5bfe,xclick,/m/07j7r,1,0.251250,0.276875,0.393686,0.636954,1,0,0,0,0,0.259375,0.276875,0.270625,0.251250,0.393686,0.580316,0.635097,0.636954 +000b093da01e5bfe,xclick,/m/07j7r,1,0.274375,0.313125,0.475395,0.636954,1,0,0,0,0,0.287500,0.313125,0.302500,0.274375,0.475395,0.557103,0.616527,0.636954 +000b093da01e5bfe,xclick,/m/07j7r,1,0.313125,0.363125,0.417827,0.646240,1,0,0,0,0,0.326875,0.363125,0.336250,0.313125,0.417827,0.600743,0.646240,0.623955 +000b093da01e5bfe,xclick,/m/07j7r,1,0.323125,0.469375,0.035283,0.635098,1,0,0,0,0,0.421875,0.469375,0.415625,0.323125,0.035283,0.513463,0.635098,0.618384 +000b093da01e5bfe,xclick,/m/07j7r,1,0.441250,0.496250,0.272052,0.553389,1,0,0,0,0,0.464375,0.496250,0.469375,0.441250,0.272052,0.492108,0.553389,0.542247 +000b093da01e5bfe,xclick,/m/07j7r,1,0.468750,0.723750,0.162488,0.549675,1,0,1,0,0,0.582500,0.468750,0.723750,0.627500,0.162488,0.435469,0.490251,0.549675 +000b093da01e5bfe,xclick,/m/07j7r,1,0.475625,0.578125,0.221913,0.538533,1,0,0,0,0,0.538750,0.578125,0.575625,0.475625,0.221913,0.509749,0.538533,0.515320 +000b093da01e5bfe,xclick,/m/07j7r,1,0.561875,0.598125,0.178273,0.545961,1,0,0,0,0,0.578750,0.598125,0.583750,0.561875,0.178273,0.479109,0.545961,0.298979 +000b093da01e5bfe,xclick,/m/07j7r,1,0.591250,0.636875,0.364902,0.551532,1,0,0,0,0,0.625625,0.636875,0.620625,0.591250,0.364902,0.493965,0.547818,0.551532 +000b093da01e5bfe,xclick,/m/07j7r,1,0.602500,0.683125,0.269266,0.547818,1,0,0,0,0,0.646250,0.683125,0.663750,0.602500,0.269266,0.471681,0.540390,0.547818 +000b093da01e5bfe,xclick,/m/07j7r,1,0.696250,0.723125,0.345404,0.547818,1,0,0,0,0,0.716250,0.723125,0.710000,0.696250,0.345404,0.467967,0.547818,0.542247 +000b093da01e5bfe,xclick,/m/07j7r,1,0.729375,0.813750,0.448468,0.549675,1,0,1,0,0,0.803750,0.813750,0.800000,0.729375,0.448468,0.488394,0.519034,0.549675 +000b093da01e5bfe,xclick,/m/07j7r,1,0.738750,0.999375,0.183844,0.537604,1,1,1,0,0,0.981250,0.738750,0.999375,0.748125,0.183844,0.528319,0.427112,0.537604 +000b093da01e5bfe,xclick,/m/07j7r,1,0.863750,0.886875,0.391829,0.500464,1,0,0,0,0,0.874375,0.886875,0.875625,0.863750,0.391829,0.435469,0.497679,0.500464 +000b093da01e5bfe,xclick,/m/07j7r,1,0.885625,0.908750,0.357474,0.493965,1,0,0,0,0,0.900000,0.908750,0.894375,0.885625,0.357474,0.454039,0.493965,0.493965 +000b093da01e5bfe,xclick,/m/07j7r,1,0.897500,0.926875,0.337976,0.492108,1,0,0,0,0,0.912500,0.926875,0.905000,0.897500,0.337976,0.439183,0.492108,0.488394 +000b093da01e5bfe,xclick,/m/07j7r,1,0.916250,0.952500,0.296193,0.484680,1,0,0,0,0,0.931875,0.952500,0.934375,0.916250,0.296193,0.446611,0.484680,0.482823 +000b093da01e5bfe,xclick,/m/07j7r,1,0.946875,0.999375,0.189415,0.475395,1,1,0,0,0,0.983125,0.999375,0.991875,0.946875,0.189415,0.328691,0.466110,0.475395 +000b093da01e5bfe,xclick,/m/0c9ph5,1,0.141250,0.200625,0.718663,0.824513,0,0,0,0,0,0.170625,0.141250,0.200625,0.173125,0.718663,0.783658,0.774373,0.824513 +000b093da01e5bfe,xclick,/m/0c9ph5,1,0.147500,0.183750,0.730734,0.790158,0,0,1,0,0,0.160625,0.170625,0.147500,0.183750,0.730734,0.790158,0.765088,0.754875 +000b09d5d3fc821f,xclick,/m/0167gd,1,0.426667,0.815238,0.060000,0.680000,0,0,0,0,0,0.754286,0.426667,0.815238,0.565714,0.060000,0.497143,0.165714,0.680000 +000b09d5d3fc821f,xclick,/m/01d40f,1,0.432381,0.725714,0.205714,0.598571,1,0,0,0,0,0.666667,0.432381,0.725714,0.657143,0.205714,0.502857,0.447143,0.598571 +000b09d5d3fc821f,xclick,/m/07bgp,1,0.000000,0.215238,0.588571,0.851429,0,1,0,1,0,0.076190,0.000000,0.215238,0.076190,0.588571,0.648571,0.777143,0.851429 +000b09d5d3fc821f,xclick,/m/07bgp,1,0.211429,0.489524,0.370000,0.647143,1,0,0,1,0,0.411429,0.489524,0.384762,0.211429,0.370000,0.414286,0.647143,0.534286 +000b0f235dcf2caa,xclick,/m/01g317,1,0.589375,0.611250,0.864615,0.933846,1,0,0,0,0,0.601875,0.589375,0.611250,0.601875,0.864615,0.889231,0.895385,0.933846 +000b0f235dcf2caa,xclick,/m/01g317,1,0.640625,0.683125,0.861538,0.998462,0,1,0,0,0,0.667500,0.683125,0.640625,0.672500,0.861538,0.998462,0.998462,0.998462 +000b0f235dcf2caa,xclick,/m/01g317,1,0.688750,0.738750,0.850769,0.998462,0,1,0,0,0,0.708750,0.688750,0.738750,0.726875,0.850769,0.992308,0.995385,0.998462 +000b0f235dcf2caa,xclick,/m/01g317,1,0.725000,0.737500,0.858462,0.909231,1,0,0,0,0,0.731250,0.725000,0.737500,0.727500,0.858462,0.892308,0.880000,0.909231 +000b0f235dcf2caa,xclick,/m/01g317,1,0.882500,0.999375,0.840000,0.998462,1,1,1,0,0,0.914375,0.882500,0.999375,0.998125,0.840000,0.889231,0.921538,0.998462 +000b0f235dcf2caa,xclick,/m/01knjb,1,0.606875,0.756250,0.133846,0.292308,0,0,0,0,0,0.672500,0.756250,0.676250,0.606875,0.133846,0.267692,0.292308,0.283077 +000b0f235dcf2caa,xclick,/m/0cgh4,1,0.000000,0.349375,0.389231,0.856923,1,1,0,0,0,0.349375,0.334375,0.000000,0.000000,0.403077,0.824615,0.389231,0.856923 +000b0f235dcf2caa,xclick,/m/0cgh4,1,0.000000,0.999375,0.247692,0.998462,1,1,1,0,0,0.121875,0.000000,0.757500,0.999375,0.998462,0.566154,0.247692,0.373846 +000b0f235dcf2caa,xclick,/m/0cgh4,1,0.073750,0.354375,0.383077,0.655385,1,0,0,0,0,0.237500,0.073750,0.354375,0.210625,0.383077,0.512308,0.484615,0.655385 +000b0f235dcf2caa,xclick,/m/0cgh4,1,0.358125,0.860625,0.266154,0.824615,1,0,0,0,0,0.603125,0.358125,0.626875,0.860625,0.266154,0.418462,0.824615,0.587692 +000b0f235dcf2caa,xclick,/m/0cgh4,1,0.914375,0.995000,0.361538,0.881538,1,1,0,0,0,0.995000,0.993750,0.928750,0.914375,0.361538,0.881538,0.515385,0.836923 +000b0f235dcf2caa,xclick,/m/0d4v4,1,0.076875,0.168750,0.536923,0.624615,1,0,1,0,0,0.090625,0.076875,0.166250,0.168750,0.536923,0.587692,0.624615,0.552308 +000b0f235dcf2caa,xclick,/m/0d4v4,1,0.245625,0.343125,0.404615,0.636923,1,0,1,0,0,0.245625,0.248125,0.286875,0.343125,0.404615,0.423077,0.636923,0.432308 +000b0f235dcf2caa,xclick,/m/0d4v4,1,0.253750,0.265625,0.533846,0.561538,0,0,0,0,0,0.255000,0.265625,0.264375,0.253750,0.561538,0.561538,0.540000,0.533846 +000b0f235dcf2caa,xclick,/m/0d4v4,1,0.355000,0.598125,0.287692,0.643077,1,0,1,0,0,0.582500,0.598125,0.567500,0.355000,0.287692,0.461538,0.643077,0.533846 +000b0f235dcf2caa,xclick,/m/0k4j,1,0.361875,0.459375,0.850769,0.938462,1,0,0,0,0,0.361875,0.421875,0.459375,0.459375,0.923077,0.850769,0.938462,0.938462 +000b0f235dcf2caa,xclick,/m/0k4j,1,0.445000,0.537500,0.833846,0.929231,1,0,0,0,0,0.445000,0.490000,0.537500,0.518125,0.863077,0.833846,0.920000,0.929231 +000b0f235dcf2caa,xclick,/m/0k4j,1,0.527500,0.586250,0.847692,0.950769,1,0,0,0,0,0.527500,0.561875,0.586250,0.554375,0.910769,0.847692,0.913846,0.950769 +000b0f235dcf2caa,xclick,/m/0k4j,1,0.729375,0.774375,0.856923,0.907692,1,0,0,0,0,0.729375,0.747500,0.774375,0.761875,0.875385,0.856923,0.890769,0.907692 +000b0f235dcf2caa,xclick,/m/0k4j,1,0.801250,0.883750,0.844615,0.998462,0,0,0,0,0,0.851875,0.883750,0.814375,0.801250,0.844615,0.923077,0.998462,0.932308 +000b0f5159f54105,xclick,/m/01g317,1,0.378750,0.405000,0.518889,0.617778,1,0,0,0,0,0.388125,0.378750,0.405000,0.384375,0.518889,0.553333,0.555556,0.617778 +000b0f5159f54105,xclick,/m/07j7r,1,0.000000,0.992500,0.000000,0.563333,1,1,1,0,0,0.000000,0.184375,0.992500,0.942500,0.236667,0.000000,0.316667,0.563333 +000b0f5159f54105,xclick,/m/07j7r,1,0.496875,0.593125,0.297778,0.526667,0,0,0,0,0,0.556875,0.496875,0.545625,0.593125,0.297778,0.412222,0.526667,0.415556 +000b168e791f591d,xclick,/m/09j5n,1,0.154784,0.274859,0.618750,0.658125,1,0,0,0,0,0.233583,0.154784,0.274859,0.261726,0.618750,0.656250,0.630625,0.658125 +000b168e791f591d,xclick,/m/09j5n,1,0.257974,0.321764,0.586250,0.632500,1,0,0,0,0,0.309568,0.278612,0.257974,0.321764,0.586250,0.632500,0.622500,0.595000 +000b168e791f591d,xclick,/m/09j5n,1,0.755159,0.801126,0.364375,0.391875,0,0,0,0,0,0.796435,0.788931,0.755159,0.801126,0.364375,0.390000,0.391875,0.376250 +000b168e791f591d,xclick,/m/09j5n,1,0.842402,0.907129,0.378125,0.398750,0,0,0,0,0,0.878049,0.873358,0.842402,0.907129,0.378125,0.398750,0.396875,0.391875 +000b168e791f591d,xclick,/m/09j5n,1,0.957786,0.978424,0.359375,0.381250,0,0,0,0,0,0.978424,0.975610,0.957786,0.978424,0.359375,0.381250,0.376250,0.374375 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.155625,0.160625,0.389464,0.527752,0,0,0,0,0,0.160625,0.156875,0.160625,0.155625,0.389464,0.518344,0.506115,0.527752 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.390625,0.441875,0.411101,0.515522,0,0,0,0,0,0.413750,0.441875,0.422500,0.390625,0.411101,0.493885,0.515522,0.471308 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.443125,0.466250,0.476952,0.550329,0,0,0,0,0,0.463750,0.466250,0.456875,0.443125,0.476952,0.532455,0.550329,0.517404 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.470000,0.500625,0.495767,0.569144,0,0,0,0,0,0.490625,0.500625,0.493125,0.470000,0.495767,0.539040,0.569144,0.546566 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.493125,0.521250,0.495767,0.572907,0,0,0,0,0,0.499375,0.521250,0.506875,0.493125,0.495767,0.544685,0.572907,0.548448 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.515000,0.537500,0.436500,0.548448,0,0,0,0,0,0.522500,0.515000,0.526250,0.537500,0.436500,0.490122,0.548448,0.523048 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.532500,0.577500,0.346190,0.536218,0,0,0,0,0,0.551875,0.577500,0.560625,0.532500,0.346190,0.461900,0.536218,0.425212 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.593125,0.617500,0.444026,0.567262,0,0,0,0,0,0.598125,0.617500,0.609375,0.593125,0.444026,0.530574,0.567262,0.532455 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.611875,0.704375,0.423330,0.569144,0,0,0,0,0,0.655625,0.704375,0.655625,0.611875,0.423330,0.478833,0.569144,0.495767 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.704375,0.771250,0.399812,0.493885,0,0,0,0,0,0.735000,0.704375,0.728750,0.771250,0.399812,0.436500,0.493885,0.463782 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.771250,0.845000,0.409219,0.542803,0,0,0,0,0,0.771250,0.843750,0.845000,0.796875,0.409219,0.414864,0.542803,0.542803 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.814375,0.826250,0.381938,0.528692,0,0,0,0,0,0.814375,0.825000,0.826250,0.814375,0.381938,0.471308,0.528692,0.471308 +000b1971d8daaeef,xclick,/m/01fdzj,1,0.845000,0.887500,0.376294,0.539040,0,0,0,0,0,0.861875,0.887500,0.880000,0.845000,0.376294,0.471308,0.539040,0.480715 +000b1971d8daaeef,xclick,/m/033rq4,1,0.219375,0.245000,0.479774,0.642521,1,0,0,0,0,0.241250,0.219375,0.233750,0.245000,0.642521,0.493885,0.479774,0.488241 +000b1971d8daaeef,xclick,/m/033rq4,1,0.478750,0.498125,0.419567,0.659454,1,0,0,0,0,0.490625,0.498125,0.478750,0.486250,0.419567,0.425212,0.432738,0.659454 +000b1971d8daaeef,xclick,/m/033rq4,1,0.925625,0.958750,0.310442,0.653810,1,0,0,0,0,0.950000,0.925625,0.940625,0.958750,0.653810,0.341486,0.310442,0.341486 +000b1971d8daaeef,xclick,/m/079cl,1,0.390625,0.438125,0.429915,0.508937,1,0,0,0,0,0.416250,0.390625,0.438125,0.438125,0.429915,0.457197,0.508937,0.508937 +000b1971d8daaeef,xclick,/m/079cl,1,0.535000,0.565000,0.359360,0.558796,0,0,0,0,0,0.555625,0.545625,0.535000,0.565000,0.359360,0.558796,0.458137,0.463782 +000b1971d8daaeef,xclick,/m/079cl,1,0.840000,0.882500,0.387582,0.549389,1,0,0,0,0,0.860625,0.840000,0.850625,0.882500,0.387582,0.497648,0.549389,0.491063 +000b1b3b85edd850,xclick,/m/032b3c,1,0.153750,0.368750,0.439962,0.876173,1,0,0,0,0,0.258750,0.153750,0.273750,0.368750,0.439962,0.691370,0.876173,0.722326 +000b1b3b85edd850,xclick,/m/04yx4,1,0.315625,0.561250,0.129456,0.998124,1,1,0,0,0,0.433750,0.315625,0.373125,0.561250,0.129456,0.469981,0.998124,0.553471 +000b1b3b85edd850,xclick,/m/07j7r,1,0.000000,0.746250,0.000000,0.962477,1,1,1,0,0,0.055625,0.000000,0.183125,0.746250,0.962477,0.672608,0.000000,0.034709 +000b1b3b85edd850,xclick,/m/07j7r,1,0.740625,0.999375,0.314259,0.397749,1,1,1,0,0,0.789375,0.779375,0.999375,0.740625,0.397749,0.314259,0.352720,0.341463 +000b1b3b85edd850,xclick,/m/07j7r,1,0.930625,0.999375,0.000000,0.166979,1,1,0,0,0,0.930625,0.938125,0.999375,0.993125,0.022514,0.000000,0.037523,0.166979 +000b1b92f0800e94,xclick,/m/01bfm9,1,0.352500,0.468750,0.611667,0.781667,1,0,0,0,0,0.461875,0.362500,0.352500,0.468750,0.611667,0.781667,0.781667,0.665000 +000b1b92f0800e94,xclick,/m/01bfm9,1,0.569375,0.696875,0.569167,0.755000,1,0,0,0,0,0.588125,0.569375,0.696875,0.663125,0.569167,0.735833,0.595833,0.755000 +000b1b92f0800e94,xclick,/m/01n4qj,1,0.770000,0.897500,0.480000,0.627500,1,0,0,0,0,0.826250,0.897500,0.770000,0.786875,0.480000,0.539167,0.575000,0.627500 +000b1b92f0800e94,xclick,/m/02p0tk3,1,0.328125,0.585625,0.232500,0.999167,0,0,0,0,0,0.430000,0.585625,0.328125,0.381875,0.232500,0.433333,0.655000,0.999167 +000b1b92f0800e94,xclick,/m/02p0tk3,1,0.460625,0.592500,0.312500,0.995833,1,0,0,0,0,0.531875,0.460625,0.540625,0.592500,0.312500,0.574167,0.995833,0.462500 +000b1b92f0800e94,xclick,/m/02p0tk3,1,0.562500,0.724375,0.224167,0.995833,1,0,0,0,0,0.620625,0.571875,0.562500,0.724375,0.224167,0.725833,0.995833,0.534167 +000b1b92f0800e94,xclick,/m/02p0tk3,1,0.769375,0.902500,0.408333,0.787500,1,0,0,0,0,0.841875,0.769375,0.790000,0.902500,0.408333,0.565833,0.787500,0.543333 +000b1b92f0800e94,xclick,/m/02p0tk3,1,0.928125,0.998125,0.441667,0.572500,1,0,0,0,0,0.963125,0.928125,0.943750,0.998125,0.441667,0.501667,0.572500,0.520833 +000b1b92f0800e94,xclick,/m/035r7c,1,0.336875,0.414375,0.593333,0.995833,1,1,0,0,0,0.355000,0.414375,0.380625,0.336875,0.593333,0.670833,0.995833,0.956667 +000b1b92f0800e94,xclick,/m/035r7c,1,0.385625,0.456875,0.629167,0.995833,1,1,0,0,0,0.456875,0.385625,0.443750,0.442500,0.629167,0.935833,0.965000,0.995833 +000b1b92f0800e94,xclick,/m/035r7c,1,0.470000,0.533125,0.680833,0.958333,1,1,0,0,0,0.501875,0.470000,0.533125,0.516250,0.680833,0.729167,0.892500,0.958333 +000b1b92f0800e94,xclick,/m/035r7c,1,0.511250,0.575625,0.685833,0.999167,1,1,0,0,0,0.547500,0.511250,0.575625,0.550000,0.685833,0.763333,0.732500,0.999167 +000b1b92f0800e94,xclick,/m/035r7c,1,0.559375,0.630625,0.573333,0.999167,1,1,0,0,0,0.585000,0.630625,0.559375,0.583750,0.573333,0.676667,0.978333,0.999167 +000b1b92f0800e94,xclick,/m/035r7c,1,0.637500,0.709375,0.585833,0.991667,1,1,0,0,0,0.637500,0.693750,0.646875,0.709375,0.655000,0.585833,0.991667,0.632500 +000b1b92f0800e94,xclick,/m/035r7c,1,0.775625,0.832500,0.603333,0.774167,1,1,0,0,0,0.804375,0.775625,0.832500,0.792500,0.603333,0.635833,0.627500,0.774167 +000b1b92f0800e94,xclick,/m/04yx4,1,0.332500,0.592500,0.235000,0.999167,1,1,0,0,0,0.332500,0.441250,0.379375,0.592500,0.445000,0.235000,0.999167,0.419167 +000b1b92f0800e94,xclick,/m/04yx4,1,0.566875,0.724375,0.230833,0.999167,1,1,0,0,0,0.623125,0.724375,0.573750,0.566875,0.230833,0.630000,0.999167,0.421667 +000b1b92f0800e94,xclick,/m/04yx4,1,0.770625,0.908750,0.411667,0.795833,1,0,0,0,0,0.770625,0.851875,0.786250,0.908750,0.565000,0.411667,0.795833,0.539167 +000b1b92f0800e94,xclick,/m/04yx4,1,0.786250,0.841875,0.440000,0.500000,1,0,0,0,0,0.786250,0.815625,0.804375,0.841875,0.493333,0.440000,0.500000,0.482500 +000b1b92f0800e94,xclick,/m/07mhn,1,0.466250,0.568750,0.692500,0.928333,1,0,0,0,0,0.515625,0.466250,0.568750,0.549375,0.692500,0.708333,0.819167,0.928333 +000b1b92f0800e94,xclick,/m/07mhn,1,0.786250,0.851875,0.616667,0.761667,1,0,0,0,0,0.851875,0.816875,0.786250,0.801250,0.650000,0.616667,0.670000,0.761667 +000b1b92f0800e94,xclick,/m/09j5n,1,0.334375,0.390000,0.909167,0.999167,1,0,0,0,0,0.373125,0.334375,0.360000,0.390000,0.909167,0.999167,0.999167,0.995000 +000b1b92f0800e94,xclick,/m/09j5n,1,0.380625,0.446250,0.902500,0.999167,1,0,0,0,0,0.409375,0.380625,0.426875,0.446250,0.902500,0.933333,0.999167,0.986667 +000b1b92f0800e94,xclick,/m/09j5n,1,0.491875,0.530625,0.880000,0.954167,1,0,0,0,0,0.521250,0.491875,0.515000,0.530625,0.880000,0.940000,0.954167,0.900833 +000b1b92f0800e94,xclick,/m/09j5n,1,0.516250,0.560000,0.923333,0.999167,1,0,0,0,0,0.558750,0.516250,0.538125,0.560000,0.923333,0.995000,0.999167,0.981667 +000b1b92f0800e94,xclick,/m/09j5n,1,0.558750,0.618125,0.912500,0.999167,1,0,0,0,0,0.593750,0.558750,0.573125,0.618125,0.912500,0.991667,0.999167,0.933333 +000b1b92f0800e94,xclick,/m/09j5n,1,0.635625,0.676250,0.883333,0.990833,1,0,0,0,0,0.651250,0.648750,0.676250,0.635625,0.990833,0.883333,0.954167,0.926667 +000b1b92f0800e94,xclick,/m/09j5n,1,0.773125,0.818750,0.747500,0.788333,1,0,0,0,0,0.793750,0.773125,0.796875,0.818750,0.747500,0.775000,0.788333,0.750833 +000b1b92f0800e94,xclick,/m/09j5n,1,0.828750,0.885625,0.720000,0.786667,1,0,0,0,0,0.858750,0.828750,0.863750,0.885625,0.720000,0.747500,0.786667,0.773333 +000b21663becc68e,xclick,/m/01g317,1,0.180625,0.884375,0.428983,0.854362,1,1,0,1,0,0.884375,0.180625,0.233125,0.671250,0.666907,0.428983,0.854362,0.808219 +000b21663becc68e,xclick,/m/025dyy,1,0.030000,0.966875,0.084355,0.957462,0,0,0,0,0,0.733750,0.030000,0.079375,0.966875,0.084355,0.868061,0.957462,0.849315 +000b21663becc68e,xclick,/m/0k65p,1,0.381250,0.481875,0.615717,0.749820,1,0,0,0,0,0.422500,0.481875,0.381250,0.409375,0.615717,0.691420,0.696467,0.749820 +000b260e1f08a32a,xclick,/m/01fdzj,1,0.064375,0.873750,0.025000,0.999167,0,1,0,0,0,0.064375,0.676250,0.860000,0.873750,0.999167,0.025000,0.999167,0.987500 +000b260e1f08a32a,xclick,/m/0d4v4,1,0.150000,0.183750,0.955000,0.999167,0,1,0,0,0,0.179375,0.150000,0.163125,0.183750,0.955000,0.999167,0.999167,0.958333 +000b260e1f08a32a,xclick,/m/0d4v4,1,0.303750,0.361875,0.906667,0.999167,0,1,0,0,0,0.361875,0.303750,0.358125,0.361875,0.906667,0.999167,0.999167,0.999167 +000b260e1f08a32a,xclick,/m/0d4v4,1,0.342500,0.381250,0.459167,0.559167,0,0,0,0,0,0.380000,0.342500,0.343750,0.381250,0.459167,0.541667,0.559167,0.462500 +000b260e1f08a32a,xclick,/m/0d4v4,1,0.443125,0.501250,0.835000,0.999167,0,1,0,0,0,0.500000,0.443125,0.500000,0.501250,0.835000,0.999167,0.999167,0.999167 +000b260e1f08a32a,xclick,/m/0d4v4,1,0.541250,0.600625,0.796667,0.999167,0,1,0,0,0,0.600625,0.541250,0.596875,0.596875,0.796667,0.999167,0.998333,0.998333 +000b260e1f08a32a,xclick,/m/0d4v4,1,0.564375,0.598125,0.520833,0.690000,0,0,0,0,0,0.591875,0.564375,0.568750,0.598125,0.520833,0.596667,0.690000,0.641667 +000b260e1f08a32a,xclick,/m/0d4v4,1,0.600625,0.625000,0.321667,0.431667,0,0,0,0,0,0.621250,0.600625,0.625000,0.607500,0.321667,0.355833,0.421667,0.431667 +000b29496f75c8e5,xclick,/m/01g317,1,0.335648,0.756944,0.109694,0.964286,0,0,0,1,0,0.354167,0.756944,0.625000,0.335648,0.109694,0.301020,0.964286,0.109694 +000b29496f75c8e5,xclick,/m/06msq,1,0.349537,0.759259,0.119898,0.938776,1,0,0,0,0,0.349537,0.349537,0.759259,0.622685,0.119898,0.122449,0.306122,0.938776 +000b299b5f5ed902,xclick,/m/01g317,1,0.000000,0.999280,0.255319,0.999149,1,1,1,0,0,0.455331,0.999280,0.872478,0.000000,0.255319,0.628936,0.999149,0.665532 +000b299b5f5ed902,xclick,/m/01g317,1,0.514409,0.928674,0.508936,0.999149,0,0,0,0,0,0.596542,0.514409,0.883285,0.928674,0.508936,0.609362,0.999149,0.757447 +000b299b5f5ed902,xclick,/m/04rky,1,0.000000,0.051873,0.363404,0.828085,1,1,0,0,0,0.006484,0.051873,0.007925,0.000000,0.363404,0.434043,0.828085,0.713191 +000b299b5f5ed902,xclick,/m/04rky,1,0.000000,0.152017,0.296170,0.561702,1,1,0,0,0,0.120317,0.152017,0.049712,0.000000,0.296170,0.337021,0.561702,0.430638 +000b299b5f5ed902,xclick,/m/04rky,1,0.000000,0.216138,0.797447,0.995745,1,1,0,0,0,0.096542,0.000000,0.032421,0.216138,0.797447,0.891915,0.995745,0.967660 +000b299b5f5ed902,xclick,/m/04rky,1,0.123199,0.312680,0.309787,0.628936,1,0,0,0,0,0.213256,0.123199,0.304035,0.312680,0.309787,0.538723,0.628936,0.578723 +000b299b5f5ed902,xclick,/m/04rky,1,0.197406,0.245677,0.908085,0.999149,1,1,0,0,0,0.217579,0.197406,0.217579,0.245677,0.908085,0.940426,0.999149,0.999149 +000b299b5f5ed902,xclick,/m/04rky,1,0.291066,0.623199,0.295319,0.999149,1,0,0,0,0,0.435879,0.291066,0.364553,0.623199,0.295319,0.514043,0.999149,0.517447 +000b299b5f5ed902,xclick,/m/04rky,1,0.298271,0.396974,0.402553,0.630638,1,0,0,0,0,0.332853,0.396974,0.346542,0.298271,0.402553,0.494468,0.630638,0.492766 +000b299b5f5ed902,xclick,/m/04rky,1,0.392651,0.652738,0.602553,0.926809,1,0,0,0,0,0.608790,0.652738,0.452450,0.392651,0.602553,0.635745,0.926809,0.859574 +000b299b5f5ed902,xclick,/m/04rky,1,0.516571,0.922190,0.501277,0.999149,1,1,0,0,0,0.799712,0.922190,0.871758,0.516571,0.501277,0.783830,0.999149,0.575319 +000b299b5f5ed902,xclick,/m/04rky,1,0.701009,0.930115,0.375319,0.673191,1,0,0,0,0,0.839337,0.930115,0.894813,0.701009,0.375319,0.560000,0.673191,0.590638 +000b299b5f5ed902,xclick,/m/04rky,1,0.896254,0.999280,0.308085,0.866383,1,1,0,0,0,0.998559,0.896254,0.979107,0.999280,0.308085,0.669787,0.866383,0.787234 +000b2a982a903d0d,xclick,/m/01lrl,1,0.000000,0.717188,0.000000,0.998438,1,1,0,0,0,0.717188,0.434375,0.000000,0.337500,0.589063,0.998438,0.317188,0.000000 +000b2a982a903d0d,xclick,/m/04hgtk,1,0.362500,0.632812,0.717188,0.970312,0,0,0,1,0,0.393750,0.362500,0.554688,0.632812,0.770312,0.845313,0.970312,0.717188 +000b2a982a903d0d,xclick,/m/0f6wt,1,0.075000,0.709375,0.114063,0.996875,0,1,0,1,0,0.075000,0.332813,0.709375,0.532813,0.226562,0.114063,0.757812,0.996875 +000b2b00065e564a,xclick,/m/01n4qj,1,0.210173,0.349328,0.316875,0.469375,1,0,0,0,0,0.225528,0.210173,0.262956,0.349328,0.316875,0.328750,0.469375,0.423125 +000b2b00065e564a,xclick,/m/01n4qj,1,0.789827,0.904031,0.339375,0.531250,1,0,0,0,0,0.899232,0.904031,0.789827,0.789827,0.339375,0.344375,0.531250,0.531250 +000b2b00065e564a,xclick,/m/01rkbr,1,0.274472,0.342610,0.390625,0.618125,1,0,0,0,0,0.274472,0.310940,0.310940,0.342610,0.418125,0.390625,0.618125,0.486250 +000b2b00065e564a,xclick,/m/01rkbr,1,0.778311,0.840691,0.397500,0.647500,1,0,0,0,0,0.824376,0.787908,0.840691,0.778311,0.397500,0.542500,0.518125,0.647500 +000b2b00065e564a,xclick,/m/01xyhv,1,0.000960,0.421305,0.313750,0.694375,1,1,0,0,0,0.207294,0.304223,0.000960,0.421305,0.313750,0.694375,0.676250,0.538125 +000b2b00065e564a,xclick,/m/01xyhv,1,0.679463,0.999040,0.341250,0.653750,1,1,0,0,0,0.900192,0.679463,0.999040,0.695777,0.341250,0.624375,0.595625,0.653750 +000b2b00065e564a,xclick,/m/04yx4,1,0.000000,0.466411,0.188125,0.694375,0,1,0,0,0,0.301344,0.466411,0.014395,0.000000,0.188125,0.679375,0.694375,0.541875 +000b2b00065e564a,xclick,/m/04yx4,1,0.686180,0.996161,0.202500,0.658750,1,1,0,0,0,0.822457,0.686180,0.996161,0.917466,0.202500,0.628125,0.539375,0.658750 +000b2d1789d5f80d,xclick,/m/01fdzj,1,0.111250,0.168750,0.714958,0.936971,0,0,0,0,0,0.138125,0.111250,0.111250,0.168750,0.714958,0.936971,0.936971,0.761994 +000b2d1789d5f80d,xclick,/m/01fdzj,1,0.573750,0.712500,0.000000,0.290687,0,0,0,0,0,0.644375,0.573750,0.573750,0.712500,0.000000,0.290687,0.290687,0.281279 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.506875,0.526250,0.400753,0.437441,0,0,0,0,0,0.506875,0.506875,0.523750,0.526250,0.406397,0.437441,0.431797,0.400753 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.510000,0.528750,0.457197,0.510818,0,0,0,0,0,0.516250,0.510000,0.528750,0.511250,0.457197,0.508937,0.510818,0.466604 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.595625,0.615000,0.347131,0.398871,0,0,0,0,0,0.595625,0.595625,0.612500,0.615000,0.352775,0.395108,0.398871,0.347131 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.598125,0.615000,0.452493,0.501411,0,0,0,0,0,0.598125,0.599375,0.615000,0.615000,0.452493,0.501411,0.499530,0.452493 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.622500,0.636875,0.111947,0.136406,0,0,0,0,0,0.622500,0.623750,0.635000,0.636875,0.111947,0.134525,0.136406,0.111947 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.645625,0.667500,0.345249,0.395108,0,0,0,0,0,0.645625,0.645625,0.667500,0.666250,0.349012,0.395108,0.393227,0.345249 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.645625,0.667500,0.443086,0.497648,0,0,0,0,0,0.646875,0.645625,0.667500,0.666250,0.443086,0.497648,0.495767,0.448730 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.696875,0.722500,0.336783,0.393227,0,0,0,0,0,0.700625,0.696875,0.722500,0.711875,0.343368,0.393227,0.391345,0.336783 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.701875,0.717500,0.437441,0.491063,0,0,0,0,0,0.701875,0.701875,0.717500,0.717500,0.441204,0.491063,0.491063,0.437441 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.756875,0.776250,0.433678,0.489182,0,0,0,0,0,0.756875,0.756875,0.776250,0.773750,0.439323,0.489182,0.489182,0.433678 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.756875,0.777500,0.339605,0.385701,0,0,0,0,0,0.758125,0.756875,0.777500,0.771250,0.341486,0.385701,0.381938,0.339605 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.803125,0.823750,0.334901,0.383819,0,0,0,0,0,0.803125,0.803125,0.823750,0.823750,0.334901,0.383819,0.381938,0.336783 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.805625,0.823750,0.433678,0.483537,0,0,0,0,0,0.806875,0.805625,0.823750,0.823750,0.433678,0.483537,0.483537,0.433678 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.858125,0.880000,0.428034,0.483537,0,0,0,0,0,0.858125,0.859375,0.877500,0.880000,0.431797,0.483537,0.481656,0.428034 +000b2d1789d5f80d,xclick,/m/0d4v4,1,0.860000,0.875000,0.335842,0.381938,0,0,0,0,0,0.860000,0.873750,0.875000,0.860000,0.339605,0.335842,0.378175,0.381938 +000b2d1789d5f80d,xclick,/m/0d5gx,1,0.101250,0.979375,0.002822,0.997178,0,0,0,0,0,0.645000,0.101250,0.979375,0.710625,0.002822,0.857949,0.745061,0.997178 +000b38d9f2f664fe,xclick,/m/05s2s,1,0.103750,0.790000,0.000000,0.999167,1,1,0,0,0,0.103750,0.498750,0.790000,0.680625,0.672500,0.000000,0.251667,0.999167 +000b38d9f2f664fe,xclick,/m/05s2s,1,0.215625,0.781250,0.000000,0.527500,1,1,0,0,0,0.518750,0.215625,0.399375,0.781250,0.000000,0.260833,0.527500,0.249167 +000b393437134262,xclick,/m/0k4j,1,0.111250,0.901250,0.090056,0.939024,0,0,0,0,0,0.111250,0.494375,0.901250,0.708125,0.640713,0.939024,0.428705,0.090056 +000b393437134262,xclick,/m/0k4j,1,0.898750,0.927500,0.232645,0.271107,0,0,0,0,0,0.909375,0.927500,0.898750,0.918125,0.232645,0.247655,0.269231,0.271107 +000b393437134262,xclick,/m/0k4j,1,0.904375,0.973125,0.188555,0.382739,0,0,0,0,0,0.968125,0.904375,0.930000,0.973125,0.190432,0.342402,0.382739,0.188555 +000b3940e7d25c03,xclick,/m/020jm,1,0.228277,0.600884,0.182711,0.646365,0,0,0,0,0,0.228277,0.469809,0.600884,0.244477,0.182711,0.646365,0.565815,0.624754 +000b3940e7d25c03,xclick,/m/020jm,1,0.480118,0.880707,0.000000,0.695481,1,1,0,0,0,0.680412,0.480118,0.880707,0.620029,0.000000,0.245580,0.204322,0.695481 +000b3940e7d25c03,xclick,/m/04rky,1,0.223859,0.642121,0.135560,0.638507,1,0,0,0,0,0.229750,0.223859,0.642121,0.539028,0.135560,0.638507,0.632613,0.286837 +000b3940e7d25c03,xclick,/m/0c9ph5,1,0.379971,0.556701,0.208251,0.459725,0,0,0,0,0,0.421208,0.379971,0.556701,0.536082,0.208251,0.326130,0.312377,0.459725 +000b3940e7d25c03,xclick,/m/0c9ph5,1,0.440353,0.553756,0.090373,0.265226,1,0,0,0,0,0.477172,0.440353,0.509573,0.553756,0.090373,0.125737,0.265226,0.186640 +000b397382b2464a,xclick,/m/05s2s,1,0.000000,0.894375,0.474874,0.937186,1,1,1,0,0,0.000000,0.643750,0.894375,0.816250,0.823283,0.474874,0.773032,0.937186 +000b397382b2464a,xclick,/m/05s2s,1,0.261875,0.298125,0.952261,0.999162,1,0,0,0,0,0.293125,0.261875,0.298125,0.287500,0.952261,0.969849,0.994975,0.999162 +000b397382b2464a,xclick,/m/05s2s,1,0.301875,0.326250,0.909548,0.940536,1,0,0,0,0,0.322500,0.301875,0.326250,0.323750,0.909548,0.929648,0.935511,0.940536 +000b397382b2464a,xclick,/m/05s2s,1,0.373750,0.405000,0.906198,0.966499,1,0,0,0,0,0.396875,0.373750,0.405000,0.393125,0.906198,0.926298,0.940536,0.966499 +000b42cae15622e0,xclick,/m/02dgv,1,0.643125,0.846250,0.455000,0.875833,1,0,0,0,0,0.643125,0.846250,0.820625,0.650000,0.455000,0.875833,0.520833,0.629167 +000b42cae15622e0,xclick,/m/03jm5,1,0.061250,0.928125,0.000000,0.999167,0,0,0,0,0,0.696875,0.061250,0.211250,0.928125,0.000000,0.629167,0.999167,0.195000 +000b42cae15622e0,xclick,/m/07j7r,1,0.000000,0.114375,0.229167,0.954167,1,1,0,0,0,0.021875,0.114375,0.000000,0.000000,0.229167,0.815833,0.928333,0.954167 +000b42cae15622e0,xclick,/m/07j7r,1,0.000000,0.184375,0.000000,0.260000,0,1,0,0,0,0.011250,0.000000,0.184375,0.184375,0.260000,0.000000,0.000000,0.000000 +000b42cae15622e0,xclick,/m/07j7r,1,0.148125,0.785000,0.394167,0.999167,0,1,0,0,0,0.148125,0.456250,0.785000,0.463750,0.968333,0.394167,0.817500,0.999167 +000b42cae15622e0,xclick,/m/07j7r,1,0.189375,0.580625,0.000000,0.318333,0,1,0,0,0,0.269375,0.580625,0.190625,0.189375,0.318333,0.000000,0.000000,0.000000 +000b42cae15622e0,xclick,/m/07j7r,1,0.740000,0.999375,0.308333,0.999167,0,1,0,0,0,0.966875,0.740000,0.999375,0.999375,0.308333,0.699167,0.999167,0.999167 +000b42cae15622e0,xclick,/m/07j7r,1,0.853125,0.999375,0.000000,0.394167,0,1,0,0,0,0.853125,0.998125,0.999375,0.999375,0.194167,0.000000,0.368333,0.394167 +000b42cae15622e0,xclick,/m/0d4v4,1,0.110000,0.147500,0.734167,0.897500,1,0,0,0,0,0.126875,0.147500,0.134375,0.110000,0.748333,0.734167,0.885833,0.897500 +000b42cae15622e0,xclick,/m/0d4v4,1,0.643125,0.839375,0.443333,0.794167,1,0,0,0,0,0.643125,0.816250,0.839375,0.644375,0.443333,0.534167,0.794167,0.579167 +000b42cae15622e0,xclick,/m/0d4v4,1,0.757500,0.827500,0.162500,0.287500,0,0,0,0,0,0.757500,0.820000,0.769375,0.827500,0.162500,0.213333,0.256667,0.287500 +000b432ae644b679,xclick,/m/017ftj,1,0.440263,0.552211,0.230552,0.304102,1,0,0,0,0,0.533396,0.552211,0.440263,0.463782,0.304102,0.256011,0.241867,0.230552 +000b432ae644b679,xclick,/m/01xygc,1,0.014111,0.143932,0.380481,0.700141,0,0,0,0,0,0.062088,0.014111,0.062088,0.143932,0.380481,0.489392,0.700141,0.553041 +000b432ae644b679,xclick,/m/01xygc,1,0.273754,0.387582,0.321075,0.678925,1,0,0,0,0,0.329257,0.273754,0.352775,0.387582,0.321075,0.408769,0.678925,0.322489 +000b432ae644b679,xclick,/m/032b3c,1,0.016933,0.140169,0.374823,0.697313,0,0,0,0,0,0.049859,0.016933,0.061148,0.140169,0.374823,0.480905,0.697313,0.540311 +000b432ae644b679,xclick,/m/032b3c,1,0.216369,0.307620,0.330976,0.462518,1,0,0,0,0,0.242709,0.216369,0.262465,0.307620,0.330976,0.356436,0.462518,0.333805 +000b432ae644b679,xclick,/m/032b3c,1,0.338664,0.602070,0.343706,0.998586,1,1,0,0,0,0.406397,0.338664,0.483537,0.602070,0.343706,0.557284,0.998586,0.966054 +000b432ae644b679,xclick,/m/032b3c,1,0.552211,0.841016,0.294201,0.710042,1,0,0,0,0,0.603010,0.552211,0.841016,0.705550,0.294201,0.519095,0.482320,0.710042 +000b432ae644b679,xclick,/m/0fly7,1,0.060207,0.171214,0.666195,0.981612,0,0,0,0,0,0.132643,0.140169,0.171214,0.060207,0.666195,0.981612,0.895332,0.701556 +000b432ae644b679,xclick,/m/0fly7,1,0.126058,0.218250,0.374823,0.507779,0,0,0,0,0,0.150517,0.218250,0.154280,0.126058,0.374823,0.374823,0.507779,0.408769 +000b432ae644b679,xclick,/m/0jyfg,1,0.499530,0.550329,0.244696,0.304102,1,0,0,0,0,0.507056,0.538100,0.499530,0.550329,0.250354,0.304102,0.244696,0.270156 +000b4671075914cd,xclick,/m/01xyhv,1,0.331075,0.779848,0.396442,0.768742,1,0,0,0,0,0.538527,0.757832,0.779848,0.331075,0.396442,0.768742,0.743329,0.612452 +000b4671075914cd,xclick,/m/01xyhv,1,0.753599,0.780694,0.327827,0.438374,1,0,0,0,0,0.762913,0.753599,0.780694,0.760373,0.327827,0.329098,0.351970,0.438374 +000b4671075914cd,xclick,/m/01xyhv,1,0.810330,0.838273,0.336722,0.420584,1,0,0,0,0,0.816257,0.810330,0.838273,0.818798,0.336722,0.343075,0.355781,0.420584 +000b4671075914cd,xclick,/m/021sj1,1,0.000847,0.999153,0.000000,0.998729,1,1,0,0,1,0.522439,0.000847,0.321761,0.999153,0.998729,0.471410,0.000000,0.569250 +000b485cedacbf97,xclick,/m/01yx86,1,0.123827,0.981238,0.066875,0.915000,0,0,0,0,0,0.981238,0.123827,0.455910,0.616323,0.655000,0.622500,0.066875,0.915000 +000b485cedacbf97,xclick,/m/04hgtk,1,0.445591,0.593809,0.188125,0.305625,0,0,0,1,0,0.516886,0.445591,0.593809,0.466229,0.188125,0.288125,0.238750,0.305625 +000b485cedacbf97,xclick,/m/04hgtk,1,0.812383,0.963415,0.609375,0.691250,0,0,0,1,0,0.914634,0.812383,0.901501,0.963415,0.609375,0.656875,0.691250,0.650000 +000b4935979bf4b5,xclick,/m/03g8mr,1,0.425781,0.498698,0.221790,0.430934,1,0,0,0,0,0.436849,0.492188,0.498698,0.425781,0.221790,0.430934,0.415370,0.233463 +000b4935979bf4b5,xclick,/m/03grzl,1,0.580078,0.598958,0.158560,0.193580,1,0,0,0,0,0.586589,0.580078,0.586589,0.598958,0.158560,0.176070,0.193580,0.181907 +000b4935979bf4b5,xclick,/m/04yx4,1,0.205729,0.460938,0.428016,0.959144,1,0,0,0,0,0.381510,0.205729,0.414714,0.460938,0.428016,0.903696,0.959144,0.939689 +000b4935979bf4b5,xclick,/m/04yx4,1,0.414714,0.641927,0.530156,0.943580,1,0,0,0,0,0.529948,0.641927,0.573568,0.414714,0.530156,0.897860,0.943580,0.850195 +000b4935979bf4b5,xclick,/m/04yx4,1,0.460938,0.660807,0.382296,0.813230,1,0,0,0,0,0.490234,0.460938,0.634115,0.660807,0.382296,0.603113,0.813230,0.483463 +000b4935979bf4b5,xclick,/m/04yx4,1,0.485026,0.590495,0.045720,0.213035,1,0,0,0,0,0.554036,0.485026,0.590495,0.493490,0.045720,0.187743,0.138132,0.213035 +000b4935979bf4b5,xclick,/m/09j5n,1,0.203125,0.239583,0.903696,0.922179,1,0,0,0,0,0.209635,0.218750,0.203125,0.239583,0.903696,0.922179,0.920233,0.920233 +000b4935979bf4b5,xclick,/m/09j5n,1,0.367839,0.452474,0.911479,0.959144,1,0,0,0,0,0.423828,0.432943,0.367839,0.452474,0.911479,0.959144,0.951362,0.945525 +000b4935979bf4b5,xclick,/m/09j5n,1,0.548177,0.591797,0.855058,0.949416,0,0,0,0,0,0.562500,0.548177,0.591797,0.580078,0.855058,0.884241,0.932879,0.949416 +000b4935979bf4b5,xclick,/m/09j5n,1,0.600911,0.641927,0.781128,0.815175,1,0,0,0,0,0.610026,0.615234,0.600911,0.641927,0.781128,0.815175,0.811284,0.797665 +000b4935979bf4b5,xclick,/m/0h8mhzd,1,0.201823,0.451823,0.472763,0.950389,1,0,0,0,0,0.367188,0.201823,0.451823,0.354167,0.472763,0.881323,0.894942,0.950389 +000b4935979bf4b5,xclick,/m/0h8mhzd,1,0.413411,0.643229,0.423152,0.852140,0,0,0,0,0,0.639323,0.643229,0.449870,0.413411,0.423152,0.577821,0.852140,0.781128 +000b4935979bf4b5,xclick,/m/0h8mhzd,1,0.427734,0.641927,0.601167,0.932879,1,0,0,0,0,0.541667,0.427734,0.595703,0.641927,0.601167,0.739300,0.932879,0.885214 +000b4935979bf4b5,xclick,/m/0h8mhzd,1,0.495443,0.595703,0.071012,0.203307,1,0,0,0,0,0.545573,0.495443,0.595703,0.585286,0.071012,0.201362,0.114786,0.203307 +000b4fcdf1af3361,xclick,/m/07j7r,1,0.000000,0.999167,0.307500,0.998750,1,1,1,0,0,0.548333,0.700833,0.999167,0.000000,0.998750,0.307500,0.472500,0.510000 +000b4fcdf1af3361,xclick,/m/07j7r,1,0.391667,0.468333,0.467500,0.628750,0,0,0,0,0,0.424167,0.468333,0.409167,0.391667,0.467500,0.555000,0.628750,0.537500 +000b50bdd1933a36,xclick,/m/06nwz,1,0.179375,0.989375,0.023333,0.866667,1,0,1,0,0,0.179375,0.399375,0.989375,0.893750,0.148333,0.023333,0.587500,0.866667 +000b50bdd1933a36,xclick,/m/0grw1,1,0.000000,0.999375,0.006667,0.999167,0,1,0,0,0,0.518125,0.000000,0.489375,0.999375,0.006667,0.465833,0.999167,0.492500 +000b55559b0244d7,xclick,/m/015h_t,1,0.727500,0.828125,0.256795,0.384255,0,0,0,0,0,0.818750,0.828125,0.768750,0.727500,0.256795,0.283974,0.384255,0.331771 +000b55559b0244d7,xclick,/m/02wbtzl,1,0.121250,0.260000,0.375820,0.491097,0,0,0,0,0,0.181875,0.121250,0.260000,0.240625,0.375820,0.487348,0.466729,0.491097 +000b55559b0244d7,xclick,/m/02wbtzl,1,0.338125,0.466250,0.253046,0.384255,0,0,0,0,0,0.388125,0.338125,0.466250,0.446875,0.253046,0.349578,0.357076,0.384255 +000b55559b0244d7,xclick,/m/02wbtzl,1,0.500625,0.670625,0.103093,0.243674,0,0,0,0,0,0.570000,0.670625,0.500625,0.523750,0.103093,0.214620,0.230553,0.243674 +000b55559b0244d7,xclick,/m/02wbtzl,1,0.700625,0.828750,0.113402,0.254920,0,0,0,0,0,0.776250,0.700625,0.828750,0.795625,0.113402,0.254920,0.192127,0.232427 +000b55559b0244d7,xclick,/m/03bt1vf,1,0.005000,0.281250,0.376757,0.999063,1,1,0,0,0,0.189375,0.005000,0.050625,0.281250,0.376757,0.999063,0.999063,0.753515 +000b55559b0244d7,xclick,/m/03bt1vf,1,0.045625,0.130000,0.386129,0.609185,1,0,0,0,0,0.078750,0.045625,0.077500,0.130000,0.386129,0.536082,0.609185,0.521087 +000b55559b0244d7,xclick,/m/03bt1vf,1,0.245625,0.518750,0.257732,0.999063,1,1,0,0,0,0.245625,0.372500,0.518750,0.403125,0.521087,0.999063,0.749766,0.257732 +000b55559b0244d7,xclick,/m/03bt1vf,1,0.465000,0.527500,0.328960,0.426429,1,0,0,0,0,0.488750,0.465000,0.478750,0.527500,0.328960,0.389878,0.426429,0.358013 +000b55559b0244d7,xclick,/m/0jyfg,1,0.071875,0.104375,0.442362,0.459231,0,0,0,0,0,0.082500,0.104375,0.071875,0.077500,0.442362,0.446111,0.446111,0.459231 +000b55559b0244d7,xclick,/m/0jyfg,1,0.715000,0.816875,0.231490,0.282099,1,0,0,0,0,0.787500,0.816875,0.715000,0.733125,0.237113,0.231490,0.249297,0.282099 +000b55e339f0b131,xclick,/m/019jd,1,0.549167,0.686667,0.650000,0.685556,0,0,0,0,0,0.615833,0.549167,0.685000,0.686667,0.685556,0.670000,0.667778,0.650000 +000b55e339f0b131,xclick,/m/0cdl1,1,0.000000,0.295000,0.000000,0.985556,0,1,0,0,0,0.117500,0.000000,0.295000,0.067500,0.000000,0.358889,0.407778,0.985556 +000b55e339f0b131,xclick,/m/0cdl1,1,0.302500,0.746667,0.000000,0.998889,0,1,0,0,0,0.451667,0.302500,0.746667,0.407500,0.000000,0.313333,0.376667,0.998889 +000b55e339f0b131,xclick,/m/0cdl1,1,0.755000,0.999167,0.000000,0.998889,0,1,0,0,0,0.872500,0.999167,0.755000,0.806667,0.000000,0.285556,0.288889,0.998889 +000b567c26dd4e5d,xclick,/m/01jfsr,1,0.345625,0.732500,0.076582,0.795782,0,0,0,0,0,0.345625,0.450625,0.732500,0.581250,0.429523,0.076582,0.397336,0.795782 +000b567c26dd4e5d,xclick,/m/05zsy,1,0.338750,0.772500,0.032186,0.806881,0,0,0,0,0,0.579375,0.772500,0.574375,0.338750,0.032186,0.534961,0.806881,0.386238 +000b59a7822679e6,xclick,/m/01g317,1,0.000000,0.999219,0.301042,0.618750,1,1,1,1,0,0.564844,0.000000,0.999219,0.999219,0.301042,0.472917,0.386458,0.618750 +000b59a7822679e6,xclick,/m/01g317,1,0.085156,0.180469,0.402083,0.646875,1,0,0,0,0,0.117969,0.085156,0.180469,0.172656,0.402083,0.612500,0.633333,0.646875 +000b59a7822679e6,xclick,/m/01g317,1,0.156250,0.651563,0.327083,0.952083,1,0,0,0,0,0.430469,0.651563,0.496875,0.156250,0.327083,0.616667,0.952083,0.682292 +000b59a7822679e6,xclick,/m/01g317,1,0.168750,0.313281,0.443750,0.941667,1,0,0,0,0,0.235156,0.168750,0.313281,0.267969,0.443750,0.797917,0.608333,0.941667 +000b59a7822679e6,xclick,/m/01g317,1,0.702344,0.835156,0.396875,0.837500,1,0,0,0,0,0.800000,0.702344,0.835156,0.744531,0.396875,0.498958,0.422917,0.837500 +000b59a7822679e6,xclick,/m/01g317,1,0.830469,0.975000,0.394792,0.846875,1,0,0,0,0,0.916406,0.830469,0.975000,0.882031,0.394792,0.607292,0.582292,0.846875 +000b59a7822679e6,xclick,/m/07c52,1,0.581250,0.650781,0.234375,0.327083,1,0,0,0,0,0.637500,0.650781,0.623437,0.581250,0.234375,0.283333,0.327083,0.264583 +000b59a7822679e6,xclick,/m/0dzf4,1,0.114063,0.189844,0.492708,0.652083,1,0,0,1,0,0.125781,0.114063,0.176563,0.189844,0.492708,0.596875,0.652083,0.626042 +000b59a7822679e6,xclick,/m/0dzf4,1,0.157813,0.365625,0.364583,0.854167,1,0,0,1,0,0.358594,0.157813,0.246094,0.365625,0.364583,0.702083,0.854167,0.382292 +000b59a7822679e6,xclick,/m/0dzf4,1,0.193750,0.217969,0.523958,0.577083,1,0,0,1,0,0.211719,0.193750,0.207813,0.217969,0.523958,0.555208,0.577083,0.553125 +000b59a7822679e6,xclick,/m/0dzf4,1,0.492969,0.653125,0.469792,0.742708,1,0,0,1,0,0.522656,0.653125,0.629687,0.492969,0.469792,0.617708,0.742708,0.545833 +000b59a7822679e6,xclick,/m/0dzf4,1,0.697656,0.760938,0.480208,0.565625,1,0,0,1,0,0.721094,0.697656,0.737500,0.760938,0.480208,0.498958,0.565625,0.544792 +000b59a7822679e6,xclick,/m/0dzf4,1,0.736719,0.809375,0.501042,0.631250,1,0,0,1,0,0.783594,0.736719,0.741406,0.809375,0.501042,0.545833,0.631250,0.563542 +000b59a7822679e6,xclick,/m/0dzf4,1,0.818750,0.914844,0.518750,0.655208,1,0,0,1,0,0.903125,0.818750,0.877344,0.914844,0.518750,0.565625,0.655208,0.633333 +000b5bc07c0c5df7,xclick,/m/014sv8,1,0.511250,0.564375,0.253333,0.306667,0,0,0,0,0,0.535625,0.530625,0.511250,0.564375,0.253333,0.306667,0.271667,0.265000 +000b5bc07c0c5df7,xclick,/m/014sv8,1,0.599375,0.659375,0.249167,0.305833,0,0,0,0,0,0.621250,0.599375,0.659375,0.631875,0.249167,0.271667,0.281667,0.305833 +000b5bc07c0c5df7,xclick,/m/015h_t,1,0.521250,0.740625,0.327500,0.544167,0,0,0,0,0,0.710000,0.740625,0.582500,0.521250,0.327500,0.362500,0.544167,0.425000 +000b5bc07c0c5df7,xclick,/m/01n4qj,1,0.423125,0.999375,0.450833,0.996667,1,1,0,0,0,0.751875,0.999375,0.423125,0.681875,0.450833,0.775000,0.969167,0.996667 +000b5bc07c0c5df7,xclick,/m/03q69,1,0.525625,0.811250,0.056667,0.474167,0,0,0,0,0,0.650000,0.525625,0.811250,0.733750,0.056667,0.146667,0.220833,0.474167 +000b5bc07c0c5df7,xclick,/m/04hgtk,1,0.513750,0.806250,0.060000,0.530000,0,0,0,0,0,0.658125,0.806250,0.598125,0.513750,0.060000,0.226667,0.530000,0.260833 +000b5bc07c0c5df7,xclick,/m/04yx4,1,0.422500,0.999375,0.055000,0.999167,0,1,0,0,0,0.648750,0.999375,0.422500,0.633125,0.055000,0.820000,0.996667,0.999167 +000b5bc07c0c5df7,xclick,/m/0dzct,1,0.516250,0.730625,0.119167,0.540833,1,0,0,0,0,0.603125,0.730625,0.596875,0.516250,0.119167,0.340000,0.540833,0.242500 +000b5bc07c0c5df7,xclick,/m/0hg7b,1,0.340625,0.548750,0.465000,0.731667,0,0,0,0,0,0.511250,0.340625,0.360000,0.548750,0.465000,0.712500,0.731667,0.504167 +000b5bc07c0c5df7,xclick,/m/0k0pj,1,0.545625,0.608125,0.260000,0.365833,0,0,0,0,0,0.571250,0.565000,0.608125,0.545625,0.260000,0.365833,0.346667,0.339167 +000b606e130bdf5e,xclick,/m/01g317,1,0.000000,0.350625,0.186667,0.999167,1,1,0,0,0,0.008750,0.350625,0.000000,0.000625,0.999167,0.926667,0.346667,0.186667 +000b606e130bdf5e,xclick,/m/01g317,1,0.106875,0.318750,0.417500,0.999167,1,1,0,0,0,0.159375,0.106875,0.194375,0.318750,0.417500,0.460000,0.999167,0.744167 +000b606e130bdf5e,xclick,/m/01g317,1,0.268125,0.902500,0.063333,0.999167,1,1,0,0,0,0.465625,0.268125,0.517500,0.902500,0.063333,0.994167,0.999167,0.860833 +000b606e130bdf5e,xclick,/m/01g317,1,0.509375,0.779375,0.245000,0.999167,1,1,0,0,0,0.509375,0.693125,0.700625,0.779375,0.403333,0.245000,0.999167,0.529167 +000b606e130bdf5e,xclick,/m/01g317,1,0.844375,0.905000,0.900833,0.999167,1,1,0,0,0,0.867500,0.844375,0.870000,0.905000,0.900833,0.994167,0.999167,0.935833 +000b606e130bdf5e,xclick,/m/01g317,1,0.848125,0.926875,0.427500,0.849167,1,0,0,0,0,0.848125,0.910000,0.888125,0.926875,0.747500,0.427500,0.849167,0.829167 +000b606e130bdf5e,xclick,/m/01g317,1,0.893125,0.999375,0.212500,0.999167,1,1,0,0,0,0.893125,0.999375,0.936875,0.999375,0.477500,0.212500,0.999167,0.873333 +000b606e130bdf5e,xclick,/m/02fq_6,1,0.316875,0.633750,0.059167,0.224167,0,0,0,0,0,0.468125,0.389375,0.316875,0.633750,0.059167,0.224167,0.217500,0.207500 +000b606e130bdf5e,xclick,/m/04rky,1,0.000000,0.363750,0.124167,0.997500,1,1,0,0,0,0.000000,0.363750,0.265625,0.001875,0.124167,0.918333,0.997500,0.585833 +000b606e130bdf5e,xclick,/m/04rky,1,0.000000,0.390625,0.019167,0.999167,1,1,0,0,0,0.036875,0.390625,0.136250,0.000000,0.019167,0.456667,0.999167,0.410000 +000b606e130bdf5e,xclick,/m/04rky,1,0.111875,0.308125,0.411667,0.995833,1,0,0,0,0,0.168750,0.111875,0.308125,0.188125,0.411667,0.461667,0.737500,0.995833 +000b606e130bdf5e,xclick,/m/04rky,1,0.270625,0.905000,0.052500,0.999167,0,1,0,0,0,0.468125,0.270625,0.905000,0.461875,0.052500,0.992500,0.853333,0.999167 +000b606e130bdf5e,xclick,/m/04rky,1,0.518750,0.780000,0.254167,0.999167,1,1,0,0,0,0.693125,0.518750,0.724375,0.780000,0.254167,0.440833,0.999167,0.527500 +000b606e130bdf5e,xclick,/m/04rky,1,0.845625,0.901250,0.899167,0.999167,1,0,0,0,0,0.870000,0.863750,0.901250,0.845625,0.899167,0.999167,0.921667,0.992500 +000b606e130bdf5e,xclick,/m/04rky,1,0.848125,0.917500,0.443333,0.830833,1,0,0,0,0,0.910000,0.848125,0.917500,0.861250,0.443333,0.830833,0.825000,0.829167 +000b606e130bdf5e,xclick,/m/04rky,1,0.876250,0.999375,0.207500,0.999167,0,1,0,0,0,0.999375,0.876250,0.968125,0.999375,0.207500,0.995833,0.999167,0.975000 +000b63a1445f53c8,xclick,/m/03jm5,1,0.000000,0.966250,0.000000,0.885833,0,0,0,0,0,0.081250,0.000000,0.015000,0.966250,0.000000,0.182500,0.885833,0.586667 +000b63a1445f53c8,xclick,/m/03jm5,1,0.941250,0.999375,0.438333,0.729167,1,1,0,0,0,0.941250,0.986250,0.999375,0.947500,0.467500,0.438333,0.500000,0.729167 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.283125,0.337500,0.555000,0.651667,0,0,0,0,0,0.285625,0.283125,0.334375,0.337500,0.555000,0.651667,0.650000,0.563333 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.340625,0.493125,0.189167,0.406667,1,0,0,0,0,0.416875,0.340625,0.493125,0.435000,0.189167,0.292500,0.323333,0.406667 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.373125,0.458750,0.283333,0.386667,0,0,0,0,0,0.380000,0.373125,0.453750,0.458750,0.283333,0.351667,0.386667,0.315833 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.455625,0.503125,0.568333,0.650833,0,0,0,0,0,0.465625,0.493125,0.503125,0.455625,0.575000,0.568333,0.637500,0.650833 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.533125,0.620625,0.292500,0.430833,1,0,0,0,0,0.585000,0.533125,0.620625,0.601250,0.292500,0.340833,0.358333,0.430833 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.570000,0.604375,0.336667,0.425833,0,0,0,0,0,0.570000,0.570000,0.598125,0.604375,0.336667,0.393333,0.425833,0.355000 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.689375,0.766875,0.382500,0.520000,1,0,0,0,0,0.738750,0.689375,0.766875,0.736875,0.382500,0.435833,0.445833,0.520000 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.719375,0.749375,0.434167,0.505000,0,0,0,0,0,0.719375,0.719375,0.749375,0.748125,0.434167,0.462500,0.505000,0.445000 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.727500,0.768750,0.627500,0.696667,0,0,0,0,0,0.733750,0.727500,0.765000,0.768750,0.627500,0.685833,0.696667,0.634167 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.793750,0.853125,0.437500,0.547500,1,0,0,0,0,0.821250,0.793750,0.853125,0.832500,0.437500,0.497500,0.502500,0.547500 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.807500,0.838125,0.482500,0.530833,0,0,0,0,0,0.812500,0.807500,0.833125,0.838125,0.482500,0.501667,0.530833,0.496667 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.821875,0.846250,0.646667,0.692500,0,0,0,0,0,0.821875,0.825625,0.846250,0.846250,0.648333,0.689167,0.692500,0.646667 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.904375,0.926250,0.561667,0.620833,0,0,0,0,0,0.904375,0.905625,0.926250,0.921250,0.561667,0.613333,0.620833,0.569167 +000b63a1445f53c8,xclick,/m/0d4v4,1,0.917500,0.944375,0.674167,0.740833,0,0,0,0,0,0.917500,0.920000,0.944375,0.939375,0.679167,0.737500,0.740833,0.674167 +000b63a1445f53c8,xclick,/m/0d5gx,1,0.000000,0.999375,0.000000,0.895000,1,1,0,0,0,0.165625,0.000000,0.999375,0.000000,0.000000,0.366667,0.515833,0.895000 +000b65a36ad46f9e,xclick,/m/01g317,1,0.461250,0.909375,0.148333,0.999167,1,1,0,0,0,0.653125,0.461250,0.909375,0.637500,0.148333,0.830833,0.687500,0.999167 +000b65a36ad46f9e,xclick,/m/04szw,1,0.644375,0.951250,0.003333,0.999167,1,1,0,0,0,0.883750,0.644375,0.951250,0.839375,0.003333,0.999167,0.998333,0.999167 +000b65a36ad46f9e,xclick,/m/04szw,1,0.850625,0.999375,0.506667,0.905000,1,1,0,0,0,0.920625,0.850625,0.936875,0.999375,0.506667,0.537500,0.905000,0.865000 +000b65a36ad46f9e,xclick,/m/04szw,1,0.880625,0.986250,0.236667,0.327500,1,0,0,0,0,0.905000,0.880625,0.973125,0.986250,0.236667,0.256667,0.325833,0.327500 +000b65a36ad46f9e,xclick,/m/04szw,1,0.906250,0.998125,0.146667,0.193333,1,1,0,0,0,0.931875,0.906250,0.970625,0.998125,0.146667,0.170833,0.193333,0.193333 +000b65a36ad46f9e,xclick,/m/04szw,1,0.945000,0.999375,0.275833,0.535833,1,1,0,0,0,0.999375,0.945000,0.999375,0.999375,0.275833,0.446667,0.535833,0.534167 +000b65a36ad46f9e,xclick,/m/0hg7b,1,0.461875,0.576875,0.334167,0.397500,0,0,0,0,0,0.461875,0.547500,0.576875,0.568125,0.397500,0.334167,0.358333,0.389167 +000b65a36ad46f9e,xclick,/m/0hg7b,1,0.896250,0.948750,0.410000,0.439167,1,0,0,0,0,0.896250,0.948750,0.941250,0.919375,0.410000,0.418333,0.439167,0.421667 +000b70a84aab664b,xclick,/m/026t6,1,0.473750,0.533750,0.686679,0.899625,1,0,0,0,0,0.482500,0.508125,0.473750,0.533750,0.686679,0.899625,0.772983,0.727017 +000b70a84aab664b,xclick,/m/026t6,1,0.485000,0.533750,0.558161,0.661351,1,0,0,0,0,0.508125,0.503125,0.485000,0.533750,0.558161,0.661351,0.646341,0.575047 +000b70a84aab664b,xclick,/m/026t6,1,0.523125,0.566875,0.557223,0.665103,1,0,0,0,0,0.536250,0.523125,0.559375,0.566875,0.557223,0.646341,0.665103,0.559099 +000b70a84aab664b,xclick,/m/0342h,1,0.180000,0.231250,0.315197,0.697936,1,0,0,0,0,0.225000,0.180000,0.186875,0.231250,0.315197,0.590056,0.697936,0.532833 +000b70a84aab664b,xclick,/m/0342h,1,0.361875,0.457500,0.388368,0.639775,1,0,0,0,0,0.457500,0.370000,0.361875,0.455000,0.388368,0.639775,0.632270,0.398687 +000b72e1446f8849,xclick,/m/02crq1,1,0.000000,0.640000,0.561090,0.999060,0,0,0,0,0,0.000000,0.376875,0.640000,0.220000,0.812970,0.561090,0.805451,0.999060 +000b72e1446f8849,xclick,/m/02crq1,1,0.648750,0.999375,0.564850,0.992481,1,1,0,0,0,0.648750,0.999375,0.978125,0.978125,0.618421,0.564850,0.992481,0.992481 +000b72e1446f8849,xclick,/m/035r7c,1,0.361875,0.600625,0.646617,0.999060,1,1,0,0,0,0.446875,0.600625,0.593750,0.361875,0.646617,0.992481,0.999060,0.705827 +000b72e1446f8849,xclick,/m/035r7c,1,0.440625,0.499375,0.733083,0.999060,1,1,0,0,0,0.440625,0.470000,0.499375,0.441875,0.756579,0.733083,0.806391,0.999060 +000b72e1446f8849,xclick,/m/035r7c,1,0.655625,0.732500,0.718045,0.999060,1,1,0,0,0,0.655625,0.706875,0.732500,0.732500,0.718045,0.999060,0.958647,0.958647 +000b72e1446f8849,xclick,/m/035r7c,1,0.667500,0.780000,0.734962,0.999060,1,1,0,0,0,0.667500,0.735000,0.780000,0.780000,0.734962,0.999060,0.999060,0.999060 +000b72e1446f8849,xclick,/m/03bt1vf,1,0.348125,0.608125,0.315789,0.999060,1,1,0,0,0,0.466250,0.348125,0.595625,0.608125,0.315789,0.715226,0.999060,0.996241 +000b72e1446f8849,xclick,/m/03bt1vf,1,0.648125,0.906875,0.291353,0.999060,1,1,0,0,0,0.756250,0.736875,0.906875,0.648125,0.291353,0.999060,0.749060,0.708647 +000b72e1446f8849,xclick,/m/03q69,1,0.420000,0.512500,0.310150,0.451128,1,0,0,0,0,0.460000,0.445625,0.420000,0.512500,0.310150,0.451128,0.381579,0.375940 +000b72e1446f8849,xclick,/m/03q69,1,0.707500,0.809375,0.291353,0.402256,1,0,0,0,0,0.739375,0.780625,0.809375,0.707500,0.291353,0.402256,0.367481,0.345865 +000b76a9b80ba43a,xclick,/m/079cl,1,0.000000,0.064375,0.324444,0.677778,1,1,0,0,0,0.009375,0.064375,0.033750,0.000000,0.324444,0.486667,0.677778,0.623333 +000b76a9b80ba43a,xclick,/m/079cl,1,0.041250,0.243750,0.347778,0.660000,0,0,0,0,0,0.079375,0.041250,0.133125,0.243750,0.347778,0.484444,0.660000,0.621111 +000b76a9b80ba43a,xclick,/m/079cl,1,0.133750,0.269375,0.313333,0.452222,1,0,0,0,0,0.247500,0.133750,0.133750,0.269375,0.313333,0.331111,0.452222,0.426667 +000b76a9b80ba43a,xclick,/m/079cl,1,0.237500,0.408750,0.404444,0.653333,0,0,0,0,0,0.325625,0.237500,0.334375,0.408750,0.404444,0.466667,0.653333,0.603333 +000b76a9b80ba43a,xclick,/m/079cl,1,0.370625,0.476875,0.423333,0.638889,0,0,0,0,0,0.411250,0.370625,0.447500,0.476875,0.423333,0.486667,0.638889,0.616667 +000b76a9b80ba43a,xclick,/m/079cl,1,0.447500,0.620000,0.417778,0.643333,0,0,0,0,0,0.506250,0.447500,0.500000,0.620000,0.417778,0.468889,0.643333,0.575556 +000b76a9b80ba43a,xclick,/m/079cl,1,0.496250,0.613750,0.400000,0.516667,0,0,0,0,0,0.548750,0.496250,0.558750,0.613750,0.400000,0.402222,0.516667,0.491111 +000b76a9b80ba43a,xclick,/m/079cl,1,0.591875,0.750000,0.441111,0.630000,0,0,0,0,0,0.638125,0.591875,0.667500,0.750000,0.441111,0.495556,0.630000,0.614444 +000b76a9b80ba43a,xclick,/m/079cl,1,0.678125,0.771250,0.406667,0.536667,0,0,0,0,0,0.748125,0.678125,0.744375,0.771250,0.406667,0.427778,0.536667,0.536667 +000b76a9b80ba43a,xclick,/m/079cl,1,0.735625,0.766250,0.408889,0.506667,1,0,0,0,0,0.746250,0.735625,0.751250,0.766250,0.408889,0.452222,0.504444,0.506667 +000b76a9b80ba43a,xclick,/m/079cl,1,0.765000,0.856250,0.495556,0.651111,1,0,0,0,0,0.820000,0.765000,0.794375,0.856250,0.495556,0.521111,0.651111,0.621111 +000b76a9b80ba43a,xclick,/m/079cl,1,0.841875,0.920000,0.495556,0.616667,0,0,0,0,0,0.855000,0.841875,0.920000,0.918750,0.495556,0.508889,0.616667,0.538889 +000b76a9b80ba43a,xclick,/m/079cl,1,0.916250,0.999375,0.514444,0.645556,1,1,0,0,0,0.956250,0.916250,0.956250,0.999375,0.514444,0.554444,0.645556,0.638889 +000b76a9b80ba43a,xclick,/m/07yv9,1,0.771875,0.873750,0.818889,0.896667,1,0,0,0,0,0.847500,0.873750,0.784375,0.771875,0.818889,0.885556,0.896667,0.867778 +000b7dfaa1810a83,xclick,/m/01g317,1,0.745625,0.801250,0.600753,0.720339,0,0,1,0,0,0.745625,0.766250,0.801250,0.788125,0.646893,0.600753,0.669492,0.720339 +000b7dfaa1810a83,xclick,/m/01g317,1,0.819375,0.858125,0.592279,0.731638,0,0,0,0,0,0.823750,0.833750,0.858125,0.819375,0.641243,0.592279,0.645009,0.731638 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.000000,0.094375,0.267420,0.599812,1,1,0,0,0,0.043125,0.000000,0.030625,0.094375,0.267420,0.298493,0.599812,0.358757 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.035625,0.105000,0.390772,0.452919,1,0,0,0,0,0.070000,0.035625,0.067500,0.105000,0.390772,0.414313,0.452919,0.433145 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.130625,0.399375,0.348399,0.587571,1,0,1,0,0,0.355000,0.130625,0.163750,0.399375,0.348399,0.449153,0.587571,0.506591 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.150000,0.194375,0.292844,0.513183,1,0,0,0,0,0.165000,0.150000,0.165000,0.194375,0.292844,0.317326,0.513183,0.323917 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.186875,0.278125,0.323917,0.502825,1,0,0,0,0,0.223750,0.186875,0.235625,0.278125,0.323917,0.392655,0.502825,0.381356 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.203750,0.324375,0.117702,0.477401,1,0,0,0,0,0.324375,0.274375,0.203750,0.253750,0.234463,0.117702,0.226930,0.477401 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.306250,0.341875,0.226930,0.576271,1,0,0,0,0,0.333125,0.306250,0.329375,0.341875,0.226930,0.371940,0.576271,0.290960 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.338125,0.863125,0.151601,0.418079,1,0,1,0,0,0.841875,0.338125,0.475000,0.863125,0.151601,0.261770,0.418079,0.300377 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.394375,0.435625,0.223164,0.530132,1,0,0,0,0,0.406250,0.394375,0.401875,0.435625,0.223164,0.392655,0.530132,0.515066 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.421250,0.470000,0.206215,0.572505,0,0,0,0,0,0.443125,0.421250,0.450625,0.470000,0.206215,0.561205,0.572505,0.485876 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.496875,0.543125,0.188324,0.518832,1,0,0,0,0,0.506875,0.496875,0.512500,0.543125,0.188324,0.489642,0.518832,0.469868 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.656875,0.704375,0.142185,0.576271,1,0,0,0,0,0.671250,0.656875,0.686250,0.704375,0.142185,0.520716,0.576271,0.506591 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.711875,0.755625,0.144068,0.506591,1,0,0,0,0,0.722500,0.711875,0.731250,0.755625,0.144068,0.485876,0.506591,0.419962 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.850625,0.903125,0.002825,0.344633,1,1,0,0,0,0.856875,0.850625,0.850625,0.903125,0.002825,0.258004,0.344633,0.248588 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.871250,0.905625,0.063089,0.234463,1,0,0,0,0,0.891250,0.871250,0.894375,0.905625,0.063089,0.080038,0.234463,0.090395 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.887500,0.921250,0.120527,0.254237,1,0,0,0,0,0.899375,0.887500,0.899375,0.921250,0.120527,0.149718,0.254237,0.246704 +000b7dfaa1810a83,xclick,/m/07j7r,1,0.940000,0.986250,0.028249,0.190207,1,0,0,0,0,0.963125,0.940000,0.963125,0.986250,0.028249,0.057439,0.190207,0.047081 +000b81b5757963e0,xclick,/m/01xyhv,1,0.361875,0.641250,0.411820,0.967167,1,0,0,0,0,0.571875,0.361875,0.641250,0.469375,0.411820,0.786116,0.532833,0.967167 +000b81b5757963e0,xclick,/m/01xyhv,1,0.478125,0.914375,0.495310,0.999062,1,1,0,0,0,0.478125,0.802500,0.914375,0.809375,0.947467,0.495310,0.668856,0.999062 +000b825dea3016eb,activemil,/m/0jyfg,1,0.254687,0.745313,0.073437,0.253125,-1,-1,-1,-1,-1,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000b825dea3016eb,xclick,/m/01g317,1,0.221875,0.309375,0.556250,0.829687,0,0,0,0,0,0.265625,0.221875,0.309375,0.235937,0.556250,0.635938,0.698438,0.829687 +000b825dea3016eb,xclick,/m/01g317,1,0.395312,0.606250,0.615625,0.764063,0,0,0,0,0,0.451562,0.606250,0.395312,0.509375,0.615625,0.729688,0.750000,0.764063 +000b87119cc301cf,xclick,/m/01xygc,1,0.195312,0.731250,0.622917,0.997917,0,1,0,0,0,0.446875,0.195312,0.321875,0.731250,0.622917,0.997917,0.997917,0.997917 +000b87119cc301cf,xclick,/m/03bt1vf,1,0.184375,0.707812,0.283333,0.997917,0,1,0,0,0,0.385937,0.370312,0.707812,0.184375,0.283333,0.997917,0.943750,0.895833 +000b87119cc301cf,xclick,/m/04yx4,1,0.635938,0.859375,0.068750,0.993750,1,1,0,0,0,0.659375,0.635938,0.859375,0.739062,0.068750,0.716667,0.683333,0.993750 +000b8d80f7386698,activemil,/m/03q69,1,0.345313,0.520312,0.163146,0.415493,1,0,0,0,0,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000b8d80f7386698,activemil,/m/04hgtk,1,0.345313,0.520312,0.163146,0.415493,1,0,0,0,0,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000b8d80f7386698,activemil,/m/05s2s,1,0.564844,0.989062,0.451878,0.951878,1,1,0,0,0,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000b8d80f7386698,activemil,/m/0dzf4,1,0.095312,0.367969,0.333333,0.477700,1,0,0,0,0,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000b8d80f7386698,xclick,/m/01d40f,1,0.399219,0.579687,0.623239,0.998826,1,1,0,0,0,0.503125,0.399219,0.443750,0.579687,0.998826,0.853286,0.623239,0.995305 +000b8d80f7386698,xclick,/m/01xyhv,1,0.000000,0.128906,0.267606,0.998826,0,0,0,0,0,0.039062,0.128906,0.007031,0.000000,0.267606,0.375587,0.998826,0.471831 +000b8d80f7386698,xclick,/m/01xyhv,1,0.028906,0.639844,0.392019,0.998826,1,1,0,0,0,0.398438,0.639844,0.249219,0.028906,0.392019,0.530516,0.998826,0.901408 +000b8d80f7386698,xclick,/m/03bt1vf,1,0.095312,0.582812,0.178404,0.998826,1,1,0,0,0,0.413281,0.095312,0.507031,0.582812,0.178404,0.426056,0.998826,0.997653 +000b8d80f7386698,xclick,/m/03bt1vf,1,0.609375,0.666406,0.430751,0.612676,1,0,0,0,0,0.634375,0.609375,0.636719,0.666406,0.430751,0.473005,0.612676,0.508216 +000b8d80f7386698,xclick,/m/03bt1vf,1,0.684375,0.726562,0.442488,0.575117,1,0,0,0,0,0.703125,0.684375,0.700781,0.726562,0.575117,0.510563,0.442488,0.514085 +000b8d80f7386698,xclick,/m/03q69,1,0.000000,0.048437,0.112676,0.210094,1,1,0,0,0,0.034375,0.048437,0.000000,0.000000,0.210094,0.190141,0.115023,0.112676 +000b8d80f7386698,xclick,/m/03q69,1,0.195312,0.343750,0.188967,0.350939,1,0,0,0,0,0.324219,0.343750,0.263281,0.195312,0.350939,0.284038,0.188967,0.308685 +000b8d80f7386698,xclick,/m/04hgtk,1,0.000000,0.050781,0.104460,0.278169,0,1,0,0,0,0.000000,0.000000,0.000000,0.050781,0.104460,0.278169,0.227700,0.205399 +000b8d80f7386698,xclick,/m/04hgtk,1,0.199219,0.348437,0.188967,0.352113,1,0,0,0,0,0.267188,0.199219,0.348437,0.329688,0.188967,0.321596,0.322770,0.352113 +000b8d80f7386698,xclick,/m/04yx4,1,0.000000,0.125781,0.110329,0.998826,1,1,0,0,0,0.000000,0.125781,0.064062,0.000000,0.110329,0.373239,0.998826,0.865023 +000b8d80f7386698,xclick,/m/04yx4,1,0.025781,0.638281,0.180751,0.998826,1,1,0,0,0,0.275781,0.638281,0.253906,0.025781,0.180751,0.534038,0.998826,0.908451 +000b8d80f7386698,xclick,/m/04yx4,1,0.609375,0.657031,0.423709,0.611502,1,0,0,0,0,0.639844,0.609375,0.657031,0.642188,0.423709,0.474178,0.507042,0.611502 +000b8d80f7386698,xclick,/m/04yx4,1,0.660937,0.689062,0.464789,0.563380,1,0,0,0,0,0.671094,0.660937,0.677344,0.689062,0.464789,0.518779,0.563380,0.512911 +000b8d80f7386698,xclick,/m/04yx4,1,0.716406,0.759375,0.443662,0.585681,1,0,0,0,0,0.750000,0.716406,0.752344,0.759375,0.443662,0.475352,0.585681,0.523474 +000b8d80f7386698,xclick,/m/0dzct,1,0.000000,0.043750,0.126761,0.279343,0,1,0,0,0,0.000000,0.000000,0.043750,0.002344,0.217136,0.126761,0.213615,0.279343 +000b8d80f7386698,xclick,/m/0dzct,1,0.346875,0.452344,0.204225,0.399061,1,0,0,0,0,0.346875,0.391406,0.452344,0.444531,0.300469,0.204225,0.339202,0.399061 +000b8d80f7386698,xclick,/m/0dzf4,1,0.085156,0.131250,0.354460,0.553991,1,0,0,0,0,0.085156,0.131250,0.093750,0.115625,0.431925,0.403756,0.354460,0.553991 +000b8d80f7386698,xclick,/m/0dzf4,1,0.367188,0.575781,0.620892,0.998826,0,1,0,0,0,0.476562,0.575781,0.410156,0.367188,0.631455,0.620892,0.998826,0.962441 +000b8d80f7386698,xclick,/m/0dzf4,1,0.394531,0.664062,0.454225,0.615023,1,0,0,0,0,0.493750,0.492188,0.394531,0.664062,0.615023,0.454225,0.465962,0.530516 +000b8d80f7386698,xclick,/m/0dzf4,1,0.626562,0.656250,0.460094,0.501174,1,0,0,0,0,0.656250,0.626562,0.642188,0.652344,0.495305,0.501174,0.460094,0.498826 +000b8d80f7386698,xclick,/m/0dzf4,1,0.692187,0.735937,0.504695,0.549296,1,0,0,0,0,0.735937,0.692187,0.700000,0.717969,0.543427,0.504695,0.549296,0.510563 +000b8d80f7386698,xclick,/m/0dzf4,1,0.730469,0.748438,0.476526,0.539906,0,0,0,0,0,0.730469,0.746094,0.743750,0.748438,0.507042,0.492958,0.476526,0.539906 +000b8d80f7386698,xclick,/m/0k0pj,1,0.362500,0.393750,0.255869,0.322770,0,0,0,0,0,0.389844,0.381250,0.362500,0.393750,0.255869,0.322770,0.288732,0.272300 +000b9007a01f7405,xclick,/m/01g317,1,0.001876,0.813321,0.086875,0.999375,1,1,0,0,0,0.486867,0.387430,0.001876,0.813321,0.086875,0.999375,0.528750,0.411250 +000b9007a01f7405,xclick,/m/02p0tk3,1,0.000000,0.823640,0.079375,0.999375,0,1,0,0,0,0.507505,0.823640,0.000000,0.145403,0.079375,0.516250,0.533125,0.999375 +000b9007a01f7405,xclick,/m/0dzf4,1,0.001876,0.314259,0.084375,0.586250,1,1,0,0,0,0.268293,0.001876,0.135084,0.314259,0.084375,0.536875,0.586250,0.376250 +000b9007a01f7405,xclick,/m/0dzf4,1,0.279550,0.804878,0.081250,0.582500,1,0,0,0,0,0.279550,0.297373,0.804878,0.524390,0.081250,0.521250,0.481875,0.582500 +000b9007a01f7405,xclick,/m/0hg7b,1,0.196060,0.423077,0.051250,0.213125,1,0,0,0,0,0.198874,0.196060,0.423077,0.400563,0.051250,0.083750,0.173750,0.213125 +000b9007a01f7405,xclick,/m/0k65p,1,0.204503,0.296435,0.116250,0.260000,1,0,0,0,0,0.238274,0.204503,0.273921,0.296435,0.116250,0.143750,0.155625,0.260000 +000b9007a01f7405,xclick,/m/0k65p,1,0.258912,0.409944,0.078750,0.241875,1,0,0,0,0,0.312383,0.258912,0.297373,0.409944,0.078750,0.090625,0.241875,0.141250 +000b93644609911f,xclick,/m/01d40f,1,0.240625,0.416250,0.474672,0.998124,1,1,0,0,0,0.416250,0.366250,0.240625,0.275000,0.990619,0.998124,0.901501,0.474672 +000b93644609911f,xclick,/m/01d40f,1,0.639375,0.900625,0.310507,0.999062,1,1,0,0,0,0.740625,0.639375,0.900625,0.680000,0.310507,0.494371,0.988743,0.999062 +000b93644609911f,xclick,/m/01rkbr,1,0.516250,0.552500,0.423077,0.512195,1,0,0,0,0,0.516250,0.536875,0.552500,0.516250,0.512195,0.423077,0.505629,0.506567 +000b93644609911f,xclick,/m/01xyhv,1,0.394375,0.655625,0.363977,0.999062,1,1,0,0,0,0.556875,0.655625,0.592500,0.394375,0.363977,0.914634,0.999062,0.643527 +000b93644609911f,xclick,/m/03bt1vf,1,0.210000,0.415000,0.295497,0.999062,1,1,0,0,0,0.307500,0.210000,0.317500,0.415000,0.295497,0.678236,0.999062,0.526266 +000b93644609911f,xclick,/m/03bt1vf,1,0.616875,0.885000,0.171670,0.996248,1,1,0,0,0,0.663125,0.616875,0.773750,0.885000,0.171670,0.264540,0.996248,0.946529 +000b93644609911f,xclick,/m/03rszm,1,0.080625,0.703125,0.106942,0.997186,1,1,0,0,0,0.153750,0.080625,0.703125,0.677500,0.202627,0.830206,0.106942,0.997186 +000b93644609911f,xclick,/m/03rszm,1,0.716250,0.999375,0.062852,0.999062,1,1,0,0,0,0.965000,0.841250,0.716250,0.999375,0.999062,0.062852,0.134146,0.197936 +000b9814a07fd974,xclick,/m/01jfsr,1,0.105973,0.233141,0.107417,0.602302,0,0,0,0,0,0.105973,0.180154,0.158960,0.233141,0.500000,0.107417,0.602302,0.280051 +000b9814a07fd974,xclick,/m/01jfsr,1,0.754335,0.875723,0.182864,0.630435,0,0,0,0,0,0.754335,0.803468,0.819846,0.875723,0.530691,0.182864,0.630435,0.519182 +000b9a97776b3634,xclick,/m/04hgtk,1,0.002500,0.102500,0.135338,0.337406,1,1,0,0,0,0.043125,0.002500,0.067500,0.102500,0.135338,0.204887,0.337406,0.216165 +000b9a97776b3634,xclick,/m/04hgtk,1,0.244375,0.361250,0.150376,0.344925,1,0,0,0,0,0.298125,0.244375,0.361250,0.275000,0.150376,0.250940,0.245301,0.344925 +000b9a97776b3634,xclick,/m/04hgtk,1,0.330625,0.430000,0.121241,0.275376,1,0,0,0,0,0.377500,0.330625,0.430000,0.395625,0.121241,0.171992,0.190789,0.275376 +000b9a97776b3634,xclick,/m/04hgtk,1,0.476875,0.660000,0.033835,0.388158,0,0,0,0,0,0.577500,0.563125,0.660000,0.476875,0.033835,0.388158,0.161654,0.188910 +000b9a97776b3634,xclick,/m/04hgtk,1,0.655625,0.796875,0.044173,0.271617,1,0,0,0,0,0.726250,0.655625,0.796875,0.722500,0.044173,0.161654,0.137218,0.271617 +000b9a97776b3634,xclick,/m/04yx4,1,0.012500,0.291875,0.127820,0.930451,1,1,0,0,0,0.012500,0.040625,0.156250,0.291875,0.188910,0.127820,0.930451,0.545113 +000b9a97776b3634,xclick,/m/04yx4,1,0.107500,0.528750,0.154135,0.902256,1,0,0,0,0,0.291875,0.107500,0.239375,0.528750,0.154135,0.561090,0.902256,0.537594 +000b9a97776b3634,xclick,/m/04yx4,1,0.236875,0.425000,0.121241,0.397556,1,0,0,0,0,0.376250,0.271250,0.236875,0.425000,0.121241,0.397556,0.337406,0.202068 +000b9a97776b3634,xclick,/m/04yx4,1,0.316875,0.941250,0.033835,0.999060,1,1,0,0,0,0.573125,0.941250,0.316875,0.593750,0.033835,0.679511,0.796992,0.999060 +000b9a97776b3634,xclick,/m/04yx4,1,0.662500,0.999375,0.046053,0.607143,1,1,0,0,0,0.727500,0.932500,0.999375,0.662500,0.046053,0.607143,0.545113,0.109962 +000b9a97776b3634,xclick,/m/083kb,1,0.440625,0.513750,0.513158,0.680451,1,0,0,0,0,0.486875,0.440625,0.513750,0.451875,0.513158,0.618421,0.620301,0.680451 +000b9a97776b3634,xclick,/m/09j2d,1,0.017500,0.998750,0.243421,0.999060,1,1,1,0,0,0.115000,0.017500,0.737500,0.998750,0.243421,0.569549,0.999060,0.513158 +000b9b00d7aef8f5,xclick,/m/09tvcd,1,0.055625,0.104375,0.509461,0.786026,1,0,0,0,0,0.055625,0.104375,0.077500,0.095000,0.515284,0.509461,0.759825,0.786026 +000b9b00d7aef8f5,xclick,/m/09tvcd,1,0.088750,0.145000,0.553130,0.834061,1,0,0,0,0,0.088750,0.142500,0.104375,0.145000,0.563319,0.553130,0.834061,0.816594 +000b9b00d7aef8f5,xclick,/m/09tvcd,1,0.260625,0.313750,0.410480,0.892285,0,1,0,0,0,0.310000,0.260625,0.305000,0.313750,0.410480,0.496361,0.892285,0.529840 +000b9b00d7aef8f5,xclick,/m/09tvcd,1,0.392500,0.451250,0.532751,0.807860,1,0,0,0,0,0.392500,0.451250,0.397500,0.443750,0.532751,0.532751,0.786026,0.807860 +000b9b00d7aef8f5,xclick,/m/09tvcd,1,0.423125,0.480625,0.574964,0.854440,1,0,0,0,0,0.423125,0.470625,0.452500,0.480625,0.592431,0.574964,0.854440,0.834061 +000b9b00d7aef8f5,xclick,/m/09tvcd,1,0.601250,0.653750,0.427948,0.911208,0,1,0,0,0,0.601250,0.651250,0.611250,0.653750,0.443959,0.427948,0.893741,0.911208 +000b9b00d7aef8f5,xclick,/m/09tvcd,1,0.752500,0.810000,0.532751,0.804949,1,0,0,0,0,0.752500,0.810000,0.773125,0.793125,0.538574,0.532751,0.788937,0.804949 +000b9b00d7aef8f5,xclick,/m/09tvcd,1,0.790625,0.838125,0.566230,0.876274,1,0,0,0,0,0.790625,0.831875,0.816250,0.838125,0.592431,0.566230,0.876274,0.854440 +000b9b00d7aef8f5,xclick,/m/09tvcd,1,0.961250,0.999375,0.430859,0.911208,0,1,0,0,0,0.961250,0.999375,0.967500,0.998125,0.452693,0.430859,0.902475,0.911208 +000b9b00d7aef8f5,xclick,/m/0dzf4,1,0.005000,0.094375,0.346434,0.815138,1,0,0,0,0,0.091875,0.005000,0.094375,0.015000,0.346434,0.713246,0.695779,0.815138 +000b9b00d7aef8f5,xclick,/m/0dzf4,1,0.055000,0.295625,0.391557,0.835517,0,0,0,0,0,0.118750,0.055000,0.295625,0.220000,0.391557,0.510917,0.678311,0.835517 +000b9b00d7aef8f5,xclick,/m/0dzf4,1,0.312500,0.451875,0.084425,0.612809,1,0,0,0,0,0.449375,0.312500,0.389375,0.451875,0.084425,0.564774,0.612809,0.366812 +000b9b00d7aef8f5,xclick,/m/0dzf4,1,0.363750,0.639375,0.433770,0.820961,1,0,0,0,0,0.616250,0.363750,0.639375,0.530000,0.433770,0.480349,0.713246,0.820961 +000b9b00d7aef8f5,xclick,/m/0dzf4,1,0.659375,0.804375,0.331878,0.809316,1,0,0,0,0,0.680000,0.659375,0.804375,0.718750,0.331878,0.379913,0.531295,0.809316 +000b9b00d7aef8f5,xclick,/m/0dzf4,1,0.822500,0.979375,0.270742,0.816594,0,0,0,0,0,0.870000,0.822500,0.916250,0.979375,0.270742,0.393013,0.816594,0.602620 +000b9b00d7aef8f5,xclick,/m/0jyfg,1,0.155000,0.230625,0.141194,0.197962,1,0,0,0,0,0.165000,0.155000,0.230625,0.215000,0.141194,0.164483,0.187773,0.197962 +000b9b00d7aef8f5,xclick,/m/0jyfg,1,0.473125,0.539375,0.145560,0.222707,1,0,0,0,0,0.535000,0.473125,0.539375,0.510625,0.145560,0.202329,0.180495,0.222707 +000b9b00d7aef8f5,xclick,/m/0jyfg,1,0.826250,0.901875,0.167394,0.218341,1,0,0,0,0,0.845625,0.826250,0.901875,0.880000,0.167394,0.184862,0.197962,0.218341 +000b9b00d7aef8f5,xclick,/m/0k65p,1,0.044375,0.117500,0.368268,0.544396,1,0,0,0,0,0.065000,0.044375,0.094375,0.117500,0.544396,0.502183,0.368268,0.395924 +000b9b00d7aef8f5,xclick,/m/0k65p,1,0.070000,0.146875,0.393013,0.544396,1,0,0,0,0,0.116250,0.146875,0.116250,0.070000,0.544396,0.478894,0.393013,0.499272 +000b9b00d7aef8f5,xclick,/m/0k65p,1,0.365000,0.480000,0.425036,0.574964,0,0,0,0,0,0.454375,0.480000,0.428750,0.365000,0.574964,0.481805,0.425036,0.496361 +000b9b00d7aef8f5,xclick,/m/0k65p,1,0.398125,0.474375,0.077147,0.317322,0,0,0,0,0,0.451250,0.474375,0.415000,0.398125,0.077147,0.209607,0.317322,0.266376 +000b9b00d7aef8f5,xclick,/m/0k65p,1,0.656875,0.735000,0.333333,0.574964,0,0,0,0,0,0.709375,0.656875,0.676250,0.735000,0.574964,0.388646,0.333333,0.490539 +000b9b00d7aef8f5,xclick,/m/0k65p,1,0.818125,0.900625,0.257642,0.526929,0,0,0,0,0,0.864375,0.818125,0.866875,0.900625,0.526929,0.393013,0.257642,0.475983 +000b9b61afea2cd4,xclick,/m/01g317,1,0.055823,0.222329,0.787772,0.935348,1,1,0,1,0,0.055823,0.222329,0.104909,0.057748,0.825720,0.935348,0.787772,0.829234 +000b9b61afea2cd4,xclick,/m/01g317,1,0.056785,0.260828,0.298665,0.589599,1,1,0,1,0,0.141482,0.260828,0.056785,0.146295,0.298665,0.367533,0.475053,0.589599 +000b9b61afea2cd4,xclick,/m/01g317,1,0.107796,0.262753,0.702038,0.851019,1,1,0,1,0,0.107796,0.187680,0.262753,0.194418,0.735067,0.851019,0.815179,0.702038 +000b9b61afea2cd4,xclick,/m/01g317,1,0.217517,0.337825,0.640197,0.851019,1,1,0,1,0,0.217517,0.323388,0.337825,0.337825,0.674631,0.851019,0.640197,0.655657 +000b9b61afea2cd4,xclick,/m/01g317,1,0.362849,0.485082,0.662684,0.808152,1,1,0,1,0,0.375361,0.362849,0.447546,0.485082,0.662684,0.808152,0.748419,0.664793 +000b9b61afea2cd4,xclick,/m/01g317,1,0.388835,0.642926,0.748419,0.940267,0,1,0,1,0,0.388835,0.480269,0.642926,0.485082,0.904427,0.940267,0.794800,0.748419 +000b9b61afea2cd4,xclick,/m/01g317,1,0.450433,0.689124,0.685172,0.837667,0,1,0,1,0,0.530318,0.689124,0.564966,0.450433,0.685172,0.743500,0.837667,0.784259 +000b9b61afea2cd4,xclick,/m/01g317,1,0.476420,0.856593,0.193254,0.680253,1,0,0,1,0,0.589028,0.476420,0.595765,0.856593,0.193254,0.277583,0.680253,0.630358 +000b9b61afea2cd4,xclick,/m/01g317,1,0.650626,0.969201,0.325369,0.674631,1,1,0,1,0,0.828681,0.969201,0.908566,0.650626,0.325369,0.392129,0.674631,0.513703 +000b9b61afea2cd4,xclick,/m/01n5jq,1,0.000000,0.999038,0.000000,0.990162,0,0,0,0,0,0.000000,0.999038,0.674687,0.689124,0.751933,0.581869,0.000000,0.990162 +000b9c365c9e307a,activemil,/m/0kmg4,1,0.012500,0.596875,0.017874,0.954845,-1,-1,-1,-1,-1,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000b9c365c9e307a,xclick,/m/0167gd,1,0.000000,0.591250,0.007526,0.948260,0,0,0,0,0,0.346875,0.000000,0.591250,0.361875,0.007526,0.133584,0.585136,0.948260 +000b9d6c0f7d794d,xclick,/m/01g317,1,0.365957,0.689362,0.496815,0.971338,1,0,0,1,0,0.510638,0.365957,0.582979,0.689362,0.496815,0.866242,0.971338,0.697452 +000b9d6c0f7d794d,xclick,/m/01g317,1,0.468085,0.995745,0.079618,0.484076,1,1,1,1,0,0.957447,0.995745,0.995745,0.468085,0.079618,0.146497,0.484076,0.286624 +000b9d6c0f7d794d,xclick,/m/01g317,1,0.634043,0.995745,0.550955,0.996815,0,1,0,1,0,0.995745,0.995745,0.795745,0.634043,0.550955,0.748408,0.996815,0.993631 +000b9d6c0f7d794d,xclick,/m/0bt_c3,1,0.000000,0.995745,0.006369,0.996815,1,1,1,0,0,0.204255,0.000000,0.995745,0.191489,0.006369,0.340764,0.308917,0.996815 +000b9d6c0f7d794d,xclick,/m/0bt_c3,1,0.582979,0.995745,0.433121,0.996815,0,1,0,0,0,0.582979,0.893617,0.995745,0.791489,0.996815,0.996815,0.923567,0.433121 +000b9f3ba4891c11,xclick,/m/025rp__,1,0.189189,0.735736,0.084000,0.352000,0,0,0,0,0,0.456456,0.189189,0.735736,0.297297,0.084000,0.280000,0.220000,0.352000 +000b9f3ba4891c11,xclick,/m/02jfl0,1,0.183183,0.759760,0.094000,0.364000,1,0,0,0,0,0.183183,0.318318,0.759760,0.501502,0.286000,0.364000,0.176000,0.094000 +000b9f3ba4891c11,xclick,/m/02wbtzl,1,0.183183,0.747748,0.092000,0.360000,0,0,0,0,0,0.501502,0.747748,0.183183,0.300300,0.092000,0.186000,0.290000,0.360000 +000b9f3ba4891c11,xclick,/m/03fp41,1,0.006006,0.450450,0.612000,0.998000,0,0,0,0,0,0.063063,0.450450,0.006006,0.006006,0.612000,0.822000,0.998000,0.998000 +000b9f3ba4891c11,xclick,/m/04yx4,1,0.153153,0.996997,0.082000,0.998000,1,1,0,0,0,0.153153,0.483483,0.996997,0.708709,0.288000,0.082000,0.496000,0.998000 +000b9f3ba4891c11,xclick,/m/0c9ph5,1,0.000000,0.078078,0.856000,0.932000,0,1,0,0,0,0.012012,0.006006,0.000000,0.078078,0.856000,0.932000,0.896000,0.884000 +000b9f3ba4891c11,xclick,/m/0c9ph5,1,0.000000,0.240240,0.204000,0.686000,1,0,1,0,0,0.066066,0.027027,0.000000,0.240240,0.204000,0.686000,0.298000,0.376000 +000b9f3ba4891c11,xclick,/m/0c9ph5,1,0.012012,0.438438,0.642000,0.886000,1,0,1,0,0,0.153153,0.147147,0.012012,0.438438,0.642000,0.886000,0.750000,0.774000 +000b9f3ba4891c11,xclick,/m/0c9ph5,1,0.102102,0.174174,0.076000,0.120000,0,0,0,0,0,0.147147,0.132132,0.102102,0.174174,0.076000,0.120000,0.094000,0.090000 +000b9f3ba4891c11,xclick,/m/0c9ph5,1,0.225225,0.426426,0.768000,0.878000,0,0,0,0,0,0.336336,0.312312,0.426426,0.225225,0.878000,0.768000,0.804000,0.844000 +000b9f3ba4891c11,xclick,/m/0c9ph5,1,0.249249,0.402402,0.094000,0.158000,1,0,1,0,0,0.354354,0.321321,0.249249,0.402402,0.096000,0.158000,0.136000,0.094000 +000b9f3ba4891c11,xclick,/m/0c9ph5,1,0.654655,0.834835,0.106000,0.200000,1,0,0,0,0,0.747748,0.795796,0.654655,0.834835,0.106000,0.200000,0.156000,0.150000 +000b9f3ba4891c11,xclick,/m/0c9ph5,1,0.876877,0.909910,0.154000,0.176000,0,0,0,0,0,0.891892,0.891892,0.876877,0.909910,0.154000,0.176000,0.168000,0.158000 +000b9f3ba4891c11,xclick,/m/0c9ph5,1,0.978979,0.996997,0.252000,0.318000,0,1,0,0,0,0.990991,0.984985,0.978979,0.996997,0.252000,0.318000,0.280000,0.276000 +000b9f3ba4891c11,xclick,/m/0fm3zh,1,0.000000,0.081081,0.116000,0.212000,1,1,0,0,0,0.033033,0.000000,0.060060,0.081081,0.116000,0.150000,0.212000,0.132000 +000b9f3ba4891c11,xclick,/m/0fm3zh,1,0.000000,0.321321,0.864000,0.998000,1,1,0,0,0,0.270270,0.000000,0.093093,0.321321,0.864000,0.992000,0.998000,0.868000 +000b9f3ba4891c11,xclick,/m/0fm3zh,1,0.150150,0.285285,0.416000,0.502000,1,0,0,0,0,0.258258,0.150150,0.189189,0.285285,0.416000,0.438000,0.502000,0.468000 +000b9f3ba4891c11,xclick,/m/0fm3zh,1,0.660661,0.732733,0.358000,0.398000,1,0,0,0,0,0.687688,0.660661,0.690691,0.732733,0.358000,0.386000,0.398000,0.374000 +000b9f3ba4891c11,xclick,/m/0fm3zh,1,0.702703,0.780781,0.210000,0.272000,1,0,0,0,0,0.771772,0.702703,0.756757,0.780781,0.210000,0.264000,0.272000,0.222000 +000b9f3ba4891c11,xclick,/m/0fm3zh,1,0.852853,0.906907,0.216000,0.276000,1,0,0,0,0,0.891892,0.852853,0.873874,0.906907,0.216000,0.226000,0.276000,0.250000 +000b9f3ba4891c11,xclick,/m/0jyfg,1,0.330330,0.663664,0.232000,0.330000,1,0,0,0,0,0.615616,0.330330,0.663664,0.456456,0.232000,0.314000,0.254000,0.330000 +000ba221f70676c6,xclick,/m/01226z,1,0.660625,0.746875,0.818949,0.944653,0,0,0,0,0,0.704375,0.660625,0.746875,0.711875,0.818949,0.890244,0.890244,0.944653 +000ba221f70676c6,xclick,/m/01bl7v,1,0.000000,0.083750,0.000000,0.284240,1,1,0,0,0,0.000000,0.040625,0.083750,0.028750,0.258912,0.000000,0.149156,0.284240 +000ba221f70676c6,xclick,/m/01bl7v,1,0.000000,0.216875,0.095685,0.832083,0,0,0,0,0,0.000000,0.216875,0.128750,0.001875,0.405253,0.498124,0.095685,0.832083 +000ba221f70676c6,xclick,/m/01bl7v,1,0.819375,0.890000,0.105066,0.545966,1,0,0,0,0,0.819375,0.855625,0.890000,0.865625,0.183865,0.105066,0.507505,0.545966 +000ba221f70676c6,xclick,/m/05s2s,1,0.000000,0.999375,0.000000,0.999062,1,1,1,0,0,0.334375,0.999375,0.804375,0.000000,0.000000,0.451220,0.999062,0.416510 +000ba28d70b1a999,xclick,/m/01g317,1,0.000000,0.960600,0.000000,0.999375,0,1,0,0,0,0.540338,0.000000,0.300188,0.960600,0.000000,0.597500,0.999375,0.759375 +000ba28d70b1a999,xclick,/m/035r7c,1,0.000000,0.382739,0.174375,0.999375,0,0,0,0,0,0.112570,0.000000,0.176360,0.382739,0.174375,0.528125,0.999375,0.946250 +000ba28d70b1a999,xclick,/m/09j5n,1,0.249531,0.617261,0.585625,0.830625,1,0,0,0,0,0.545966,0.443715,0.249531,0.617261,0.585625,0.830625,0.725000,0.616250 +000ba28d70b1a999,xclick,/m/0fly7,1,0.004690,0.999062,0.396875,0.999375,0,0,0,0,0,0.124765,0.213884,0.004690,0.999062,0.396875,0.999375,0.781250,0.774375 +000ba28d70b1a999,xclick,/m/0k65p,1,0.086304,0.565666,0.233125,0.546875,1,0,0,0,0,0.383677,0.086304,0.565666,0.373358,0.233125,0.406875,0.357500,0.546875 +000ba28d70b1a999,xclick,/m/0k65p,1,0.275797,0.999062,0.207500,0.605000,1,0,0,0,0,0.772983,0.999062,0.275797,0.489681,0.207500,0.394375,0.440000,0.605000 +000ba3ca8a2ca955,xclick,/m/02dgv,1,0.000000,0.058161,0.613750,0.965625,0,1,0,0,0,0.058161,0.016886,0.058161,0.000000,0.618750,0.613750,0.960625,0.965625 +000ba3ca8a2ca955,xclick,/m/02dgv,1,0.880863,0.906191,0.678750,0.828750,1,0,0,0,0,0.898687,0.888368,0.906191,0.880863,0.678750,0.828750,0.823750,0.806875 +000ba3ca8a2ca955,xclick,/m/03jm5,1,0.000000,0.939963,0.003125,0.996875,0,1,0,0,0,0.000000,0.939963,0.895872,0.018762,0.785625,0.858750,0.003125,0.996875 +000ba3ca8a2ca955,xclick,/m/03jm5,1,0.959662,0.999062,0.131250,0.848750,1,1,0,0,0,0.959662,0.993433,0.999062,0.999062,0.716875,0.131250,0.848750,0.665625 +000ba3ca8a2ca955,xclick,/m/0d4v4,1,0.000000,0.090994,0.000000,0.246250,1,1,0,0,0,0.000000,0.068480,0.090994,0.083490,0.000000,0.000000,0.243125,0.246250 +000ba3ca8a2ca955,xclick,/m/0d4v4,1,0.237336,0.332083,0.007500,0.292500,1,0,0,0,0,0.237336,0.332083,0.330206,0.278612,0.007500,0.046875,0.277500,0.292500 +000ba3ca8a2ca955,xclick,/m/0d4v4,1,0.442777,0.531895,0.103125,0.315000,1,0,0,0,0,0.442777,0.514071,0.531895,0.496248,0.103125,0.125000,0.315000,0.315000 +000ba3ca8a2ca955,xclick,/m/0d4v4,1,0.706379,0.760788,0.238125,0.405625,1,0,0,0,0,0.709193,0.740150,0.760788,0.706379,0.238125,0.241250,0.383125,0.405625 +000ba3ca8a2ca955,xclick,/m/0d4v4,1,0.841463,0.897749,0.259375,0.463750,1,0,0,0,0,0.847092,0.897749,0.882739,0.841463,0.259375,0.375000,0.463750,0.363125 +000ba3ca8a2ca955,xclick,/m/0d4v4,1,0.851782,0.939024,0.245625,0.506250,1,0,0,0,0,0.872420,0.939024,0.910882,0.851782,0.245625,0.398750,0.506250,0.391875 +000ba3ca8a2ca955,xclick,/m/0d4v4,1,0.965291,0.999062,0.333750,0.413750,1,0,0,0,0,0.965291,0.999062,0.996248,0.965291,0.335625,0.333750,0.403750,0.413750 +000ba40bf7a2b458,xclick,/m/03jm5,1,0.000000,0.978333,0.000000,0.957286,0,0,0,0,0,0.763333,0.978333,0.000000,0.710000,0.000000,0.301508,0.500000,0.957286 +000ba40bf7a2b458,xclick,/m/03jm5,1,0.898333,0.998333,0.520100,0.859297,0,1,0,0,0,0.998333,0.898333,0.918333,0.998333,0.520100,0.638191,0.831658,0.859297 +000ba40bf7a2b458,xclick,/m/05s2s,1,0.000000,0.998333,0.836683,0.997487,1,1,0,0,0,0.000000,0.998333,0.983333,0.768333,0.861809,0.836683,0.997487,0.841709 +000ba40bf7a2b458,xclick,/m/05s2s,1,0.066667,0.111667,0.798995,0.864322,0,0,0,0,0,0.066667,0.080000,0.111667,0.098333,0.839196,0.798995,0.831658,0.864322 +000ba40bf7a2b458,xclick,/m/0d4v4,1,0.906667,0.955000,0.660804,0.726131,1,0,0,0,0,0.906667,0.955000,0.953333,0.908333,0.665829,0.660804,0.721106,0.726131 +000ba40bf7a2b458,xclick,/m/0d4v4,1,0.970000,0.998333,0.658291,0.721106,0,1,0,0,0,0.970000,0.971667,0.998333,0.998333,0.660804,0.721106,0.721106,0.658291 +000ba940f8cfc9bf,xclick,/m/014sv8,1,0.329167,0.357500,0.180258,0.261803,1,0,0,0,0,0.329167,0.355000,0.338333,0.357500,0.180258,0.193133,0.244635,0.261803 +000ba940f8cfc9bf,xclick,/m/014sv8,1,0.459167,0.490833,0.503577,0.543634,0,0,0,0,0,0.490833,0.459167,0.475833,0.475833,0.535050,0.515021,0.503577,0.543634 +000ba940f8cfc9bf,xclick,/m/0283dt1,1,0.289167,0.330833,0.307582,0.386266,0,0,0,0,0,0.289167,0.320833,0.291667,0.330833,0.307582,0.313305,0.386266,0.341917 +000ba940f8cfc9bf,xclick,/m/0283dt1,1,0.408333,0.434167,0.537911,0.579399,0,0,0,0,0,0.434167,0.427500,0.408333,0.415833,0.573677,0.537911,0.579399,0.546495 +000ba940f8cfc9bf,xclick,/m/039xj_,1,0.179167,0.236667,0.035765,0.177396,1,0,0,0,0,0.236667,0.199167,0.179167,0.207500,0.037196,0.035765,0.137339,0.177396 +000ba940f8cfc9bf,xclick,/m/03bt1vf,1,0.000000,0.650833,0.000000,0.998569,1,1,0,0,0,0.226667,0.650833,0.000000,0.118333,0.000000,0.958512,0.735336,0.998569 +000ba940f8cfc9bf,xclick,/m/04hgtk,1,0.000000,0.417500,0.000000,0.450644,1,1,0,0,0,0.313333,0.417500,0.274167,0.000000,0.000000,0.067239,0.450644,0.264664 +000ba940f8cfc9bf,xclick,/m/04hgtk,1,0.400833,0.587500,0.457797,0.646638,1,0,0,0,0,0.484167,0.587500,0.400833,0.440833,0.457797,0.557940,0.592275,0.646638 +000ba940f8cfc9bf,xclick,/m/0dzct,1,0.203333,0.384167,0.070100,0.450644,1,0,0,0,0,0.355000,0.384167,0.203333,0.275000,0.070100,0.164521,0.224607,0.450644 +000ba940f8cfc9bf,xclick,/m/0dzct,1,0.408333,0.507500,0.473534,0.638054,1,0,0,0,0,0.479167,0.408333,0.439167,0.507500,0.473534,0.559371,0.638054,0.519313 +000baa6f7dae9b79,activemil,/m/01g317,1,0.773125,0.959375,0.245833,0.941667,1,0,0,1,0,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000baa6f7dae9b79,xclick,/m/01g317,1,0.000000,0.999375,0.205000,0.921667,1,1,1,1,0,0.161875,0.000000,0.394375,0.999375,0.205000,0.369167,0.921667,0.590833 +000baa6f7dae9b79,xclick,/m/01g317,1,0.017500,0.044375,0.198333,0.235000,1,0,0,0,0,0.034375,0.017500,0.036875,0.044375,0.198333,0.220833,0.235000,0.220833 +000baa6f7dae9b79,xclick,/m/01g317,1,0.062500,0.097500,0.203333,0.250000,1,0,0,0,0,0.083125,0.097500,0.065000,0.062500,0.203333,0.225833,0.250000,0.245000 +000baa6f7dae9b79,xclick,/m/01g317,1,0.332500,0.362500,0.188333,0.235000,1,0,0,0,0,0.346875,0.362500,0.344375,0.332500,0.188333,0.222500,0.235000,0.230833 +000baa6f7dae9b79,xclick,/m/01g317,1,0.486250,0.561250,0.162500,0.241667,1,0,0,0,0,0.528750,0.561250,0.520000,0.486250,0.162500,0.225833,0.241667,0.225833 +000baa6f7dae9b79,xclick,/m/01j51,1,0.000000,0.999375,0.206667,0.497500,1,1,1,0,0,0.166250,0.122500,0.000000,0.999375,0.206667,0.497500,0.368333,0.282500 +000baa6f7dae9b79,xclick,/m/07j7r,1,0.000000,0.161250,0.000000,0.217500,1,1,1,0,0,0.056250,0.000000,0.058750,0.161250,0.000000,0.067500,0.217500,0.174167 +000baa6f7dae9b79,xclick,/m/07j7r,1,0.113125,0.205000,0.000000,0.218333,1,1,0,0,0,0.205000,0.165000,0.146875,0.113125,0.218333,0.000000,0.000000,0.020833 +000baa6f7dae9b79,xclick,/m/07j7r,1,0.305625,0.800625,0.000000,0.203333,1,1,1,0,0,0.305625,0.486875,0.800625,0.471250,0.127500,0.000000,0.072500,0.203333 +000baa6f7dae9b79,xclick,/m/07j7r,1,0.317500,0.482500,0.004167,0.207500,1,1,1,0,0,0.389375,0.398750,0.317500,0.482500,0.004167,0.170833,0.119167,0.207500 +000baa6f7dae9b79,xclick,/m/07j7r,1,0.328750,0.515000,0.000000,0.055833,0,1,0,0,0,0.432500,0.450000,0.515000,0.328750,0.000000,0.055833,0.015833,0.009167 +000baa6f7dae9b79,xclick,/m/07j7r,1,0.494375,0.695625,0.000000,0.232500,1,1,0,0,0,0.600625,0.695625,0.586250,0.494375,0.000000,0.114167,0.232500,0.105833 +000baa6f7dae9b79,xclick,/m/07j7r,1,0.706250,0.781250,0.005833,0.167500,1,1,0,0,0,0.770625,0.734375,0.781250,0.706250,0.005833,0.167500,0.130000,0.086667 +000baa6f7dae9b79,xclick,/m/07j7r,1,0.799375,0.921875,0.000000,0.235833,1,1,0,0,0,0.833750,0.921875,0.843125,0.799375,0.235833,0.172500,0.000000,0.000000 +000baa6f7dae9b79,xclick,/m/09j2d,1,0.334375,0.361250,0.195833,0.235833,1,0,0,0,0,0.334375,0.352500,0.361250,0.336875,0.220000,0.195833,0.220000,0.235833 +000baa6f7dae9b79,xclick,/m/09j2d,1,0.495000,0.561250,0.200833,0.239167,1,0,0,0,0,0.521875,0.495000,0.561250,0.553125,0.200833,0.223333,0.221667,0.239167 +000bab5b1a67844e,xclick,/m/03jm5,1,0.000000,0.235625,0.078889,0.853333,0,0,0,0,0,0.033125,0.000000,0.235625,0.135625,0.078889,0.258889,0.395556,0.853333 +000bab5b1a67844e,xclick,/m/03jm5,1,0.284375,0.548125,0.181111,0.843333,0,0,0,0,0,0.548125,0.298125,0.284375,0.356250,0.366667,0.181111,0.208889,0.843333 +000bab5b1a67844e,xclick,/m/03jm5,1,0.540625,0.944375,0.131111,0.840000,0,0,0,0,0,0.828750,0.540625,0.944375,0.738125,0.131111,0.517778,0.370000,0.840000 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.000000,0.015000,0.316667,0.448889,1,1,0,0,0,0.000000,0.015000,0.010000,0.000000,0.323333,0.316667,0.412222,0.448889 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.007500,0.063750,0.145556,0.246667,1,1,0,0,0,0.007500,0.063750,0.062500,0.058750,0.145556,0.171111,0.234444,0.246667 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.040625,0.101250,0.327778,0.440000,1,0,0,0,0,0.040625,0.101250,0.098750,0.045625,0.327778,0.337778,0.440000,0.428889 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.185625,0.231875,0.360000,0.483333,1,0,0,0,0,0.189375,0.221250,0.231875,0.185625,0.360000,0.362222,0.483333,0.478889 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.205000,0.236875,0.227778,0.312222,1,0,0,0,0,0.205000,0.222500,0.236875,0.213750,0.227778,0.238889,0.303333,0.312222 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.308750,0.336875,0.271111,0.351111,1,0,0,0,0,0.308750,0.323750,0.336875,0.312500,0.271111,0.282222,0.340000,0.351111 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.462500,0.495625,0.357778,0.426667,1,0,0,0,0,0.462500,0.491875,0.495625,0.494375,0.357778,0.360000,0.421111,0.426667 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.576250,0.606875,0.318889,0.421111,0,0,0,0,0,0.576250,0.606875,0.605625,0.578750,0.335556,0.318889,0.398889,0.421111 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.650625,0.680000,0.290000,0.390000,0,0,0,0,0,0.650625,0.672500,0.680000,0.655625,0.301111,0.290000,0.371111,0.390000 +000bab5b1a67844e,xclick,/m/0d4v4,1,0.729375,0.784375,0.224444,0.343333,1,0,0,0,0,0.781875,0.784375,0.735625,0.729375,0.224444,0.326667,0.343333,0.254444 +000bb0ae453283b0,xclick,/m/015qff,1,0.081875,0.086875,0.463303,0.477982,0,0,0,0,0,0.081875,0.086875,0.085625,0.081875,0.465138,0.463303,0.477982,0.477982 +000bb0ae453283b0,xclick,/m/015qff,1,0.106250,0.111250,0.463303,0.477982,0,0,0,0,0,0.106250,0.111250,0.110000,0.106250,0.465138,0.463303,0.477982,0.477982 +000bb0ae453283b0,xclick,/m/015qff,1,0.191875,0.196875,0.474312,0.497248,0,0,0,0,0,0.194375,0.191875,0.194375,0.196875,0.474312,0.485321,0.497248,0.489908 +000bb0ae453283b0,xclick,/m/015qff,1,0.309375,0.318125,0.395413,0.423853,0,0,0,0,0,0.311250,0.316875,0.309375,0.318125,0.395413,0.396330,0.423853,0.420183 +000bb0ae453283b0,xclick,/m/015qff,1,0.348750,0.361875,0.404587,0.438532,0,0,0,0,0,0.357500,0.348750,0.356250,0.361875,0.438532,0.422018,0.404587,0.417431 +000bb0ae453283b0,xclick,/m/015qff,1,0.440625,0.448125,0.472477,0.511927,0,0,0,0,0,0.445625,0.440625,0.443125,0.448125,0.472477,0.489908,0.511927,0.491743 +000bb0ae453283b0,xclick,/m/015qff,1,0.523750,0.530000,0.485321,0.502752,0,0,0,0,0,0.527500,0.530000,0.526250,0.523750,0.485321,0.493578,0.502752,0.493578 +000bb0ae453283b0,xclick,/m/015qff,1,0.536875,0.541875,0.493578,0.504587,0,0,0,0,0,0.539375,0.541875,0.540625,0.536875,0.493578,0.502752,0.504587,0.500917 +000bb0ae453283b0,xclick,/m/015qff,1,0.715000,0.721250,0.466972,0.495413,1,0,0,0,0,0.720000,0.715000,0.717500,0.721250,0.466972,0.479817,0.495413,0.485321 +000bb0ae453283b0,xclick,/m/015qff,1,0.893125,0.901875,0.468807,0.502752,0,0,0,0,0,0.899375,0.901875,0.898125,0.893125,0.468807,0.489908,0.502752,0.485321 +000bb0ae453283b0,xclick,/m/033rq4,1,0.086875,0.140625,0.427523,0.523853,1,0,0,0,0,0.115000,0.086875,0.089375,0.140625,0.523853,0.438532,0.427523,0.429358 +000bb0ae453283b0,xclick,/m/033rq4,1,0.120625,0.211250,0.145872,0.540367,1,0,0,0,0,0.168125,0.120625,0.147500,0.211250,0.540367,0.171560,0.145872,0.169725 +000bb0ae453283b0,xclick,/m/033rq4,1,0.130625,0.190625,0.291743,0.522018,1,0,0,0,0,0.165000,0.130625,0.140625,0.190625,0.522018,0.307339,0.291743,0.305505 +000bb0ae453283b0,xclick,/m/033rq4,1,0.206250,0.386875,0.121101,0.570642,1,0,0,0,0,0.386875,0.206250,0.231875,0.305625,0.164220,0.164220,0.121101,0.570642 +000bb0ae453283b0,xclick,/m/033rq4,1,0.375625,0.445625,0.203670,0.540367,1,0,0,0,0,0.406250,0.375625,0.386875,0.445625,0.540367,0.212844,0.203670,0.226606 +000bb0ae453283b0,xclick,/m/033rq4,1,0.841875,0.868750,0.296330,0.540367,1,0,0,0,0,0.861250,0.841875,0.863750,0.868750,0.540367,0.332110,0.296330,0.312844 +000bb0ae453283b0,xclick,/m/033rq4,1,0.945625,0.962500,0.343119,0.525688,1,0,0,0,0,0.951875,0.945625,0.958125,0.962500,0.525688,0.371560,0.343119,0.348624 +000bb0ae453283b0,xclick,/m/079cl,1,0.263125,0.399375,0.138532,0.512844,0,0,0,0,0,0.263125,0.340000,0.399375,0.348125,0.498165,0.138532,0.199083,0.512844 +000bb200fc78fc30,xclick,/m/05s2s,1,0.000000,0.995313,0.651563,0.998438,1,1,0,0,0,0.000000,0.000000,0.445312,0.995313,0.656250,0.942187,0.998438,0.651563 +000bb200fc78fc30,xclick,/m/09ld4,1,0.325000,0.950000,0.314063,0.942187,0,0,0,0,0,0.765625,0.950000,0.531250,0.325000,0.942187,0.609375,0.314063,0.517188 +000bb2f7132013dc,activemil,/m/0d5gx,1,0.013021,0.924479,0.231250,0.970312,-1,-1,-1,-1,-1,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000bb2f7132013dc,xclick,/m/01fdzj,1,0.562500,0.798177,0.212500,0.693750,0,0,0,0,0,0.677083,0.562500,0.798177,0.798177,0.212500,0.367969,0.693750,0.693750 +000bb2f7132013dc,xclick,/m/01x3z,1,0.621094,0.682292,0.368750,0.411719,0,0,0,0,0,0.649740,0.682292,0.653646,0.621094,0.368750,0.391406,0.411719,0.394531 +000bb2f7132013dc,xclick,/m/07j7r,1,0.000000,0.298177,0.619531,0.999219,0,1,0,0,0,0.062500,0.000000,0.298177,0.053385,0.619531,0.704688,0.835156,0.999219 +000bb2f7132013dc,xclick,/m/07j7r,1,0.269531,0.839844,0.787500,0.999219,0,1,0,0,0,0.621094,0.516927,0.269531,0.839844,0.787500,0.999219,0.994531,0.996094 +000bb2f7132013dc,xclick,/m/07j7r,1,0.782552,0.998698,0.619531,0.877344,1,1,1,0,0,0.942708,0.782552,0.997396,0.998698,0.636719,0.619531,0.877344,0.857031 +000bb2f7132013dc,xclick,/m/0d4v4,1,0.320312,0.360677,0.703125,0.776563,0,0,0,0,0,0.320312,0.334635,0.355469,0.360677,0.776563,0.714844,0.703125,0.706250 +000bb2f7132013dc,xclick,/m/0d4v4,1,0.385417,0.430990,0.871094,0.912500,0,0,0,0,0,0.385417,0.421875,0.430990,0.393229,0.876563,0.871094,0.912500,0.910937 +000bb2f7132013dc,xclick,/m/0d4v4,1,0.424479,0.446615,0.800781,0.833594,0,0,0,0,0,0.424479,0.424479,0.446615,0.446615,0.833594,0.800781,0.800781,0.833594 +000bb2f7132013dc,xclick,/m/0d4v4,1,0.460938,0.486979,0.802344,0.833594,0,0,0,0,0,0.460938,0.472656,0.481771,0.486979,0.833594,0.803906,0.802344,0.832031 +000bb2f7132013dc,xclick,/m/0d4v4,1,0.486979,0.529948,0.866406,0.922656,1,0,0,0,0,0.498698,0.489583,0.486979,0.529948,0.872656,0.903906,0.922656,0.866406 +000bb2f7132013dc,xclick,/m/0d4v4,1,0.606771,0.641927,0.431250,0.489844,0,0,0,0,0,0.615885,0.606771,0.632812,0.641927,0.489844,0.471094,0.432812,0.431250 +000bb2f7132013dc,xclick,/m/0d4v4,1,0.658854,0.692708,0.428125,0.492969,0,0,0,0,0,0.661458,0.658854,0.675781,0.692708,0.489844,0.465625,0.428125,0.492969 +000bb2f7132013dc,xclick,/m/0d4v4,1,0.678385,0.710938,0.835156,0.879687,0,0,0,0,0,0.678385,0.682292,0.690104,0.710938,0.879687,0.842187,0.835156,0.871094 +000bb81adefe7332,xclick,/m/01g317,1,0.290000,0.393125,0.081667,0.296667,1,0,0,0,0,0.325625,0.290000,0.393125,0.393125,0.081667,0.130833,0.211667,0.296667 +000bb81adefe7332,xclick,/m/01n5jq,1,0.385625,0.980000,0.005833,0.995833,0,1,0,0,0,0.385625,0.980000,0.959375,0.397500,0.007500,0.005833,0.995833,0.989167 +000bb846e2629e83,xclick,/m/01mzpv,1,0.000000,0.998145,0.437500,0.998958,1,1,0,0,0,0.927644,0.220779,0.000000,0.998145,0.437500,0.998958,0.780208,0.691667 +000bb846e2629e83,xclick,/m/035r7c,1,0.000000,0.226345,0.723958,0.994792,1,0,0,0,0,0.152134,0.000000,0.011132,0.226345,0.723958,0.848958,0.994792,0.784375 +000bb846e2629e83,xclick,/m/0dzf4,1,0.217069,0.955473,0.460417,0.704167,1,0,0,0,0,0.873840,0.955473,0.333952,0.217069,0.460417,0.508333,0.704167,0.666667 +000bb846e2629e83,xclick,/m/0dzf4,1,0.419295,0.669759,0.366667,0.479167,1,0,0,0,0,0.575139,0.419295,0.512059,0.669759,0.366667,0.458333,0.479167,0.372917 +000bb846e2629e83,xclick,/m/0k65p,1,0.207792,0.417440,0.625000,0.706250,1,0,0,0,0,0.307978,0.417440,0.207792,0.304267,0.625000,0.658333,0.665625,0.706250 +000bb846e2629e83,xclick,/m/0k65p,1,0.519481,0.649351,0.382292,0.439583,1,0,0,0,0,0.552876,0.519481,0.614100,0.649351,0.439583,0.423958,0.382292,0.403125 +000bb8bd9b1bca65,xclick,/m/0138tl,1,0.440000,0.646875,0.790000,0.999167,0,1,0,0,0,0.465625,0.440000,0.561250,0.646875,0.790000,0.928333,0.999167,0.828333 +000bb8bd9b1bca65,xclick,/m/0220r2,1,0.211250,0.566250,0.515000,0.805833,0,0,0,0,0,0.385625,0.397500,0.211250,0.566250,0.515000,0.805833,0.722500,0.709167 +000bb8bd9b1bca65,xclick,/m/07j7r,1,0.000000,0.099375,0.355000,0.583333,0,1,0,0,0,0.024375,0.000000,0.099375,0.055000,0.355000,0.463333,0.495833,0.583333 +000bb8bd9b1bca65,xclick,/m/07j7r,1,0.000000,0.254375,0.034167,0.580000,0,1,0,0,0,0.213750,0.000000,0.254375,0.125000,0.034167,0.294167,0.255000,0.580000 +000bb8bd9b1bca65,xclick,/m/07j7r,1,0.000000,0.294375,0.000000,0.195833,0,1,0,0,0,0.181875,0.000000,0.294375,0.293125,0.000000,0.195833,0.065000,0.065000 +000bb8bd9b1bca65,xclick,/m/07j7r,1,0.254375,0.424375,0.000000,0.320000,0,1,0,0,0,0.361250,0.254375,0.424375,0.390000,0.000000,0.305000,0.299167,0.320000 +000bb8bd9b1bca65,xclick,/m/07j7r,1,0.317500,0.470000,0.330833,0.535833,1,0,0,0,0,0.392500,0.317500,0.470000,0.397500,0.330833,0.423333,0.400833,0.535833 +000bb8bd9b1bca65,xclick,/m/07j7r,1,0.426875,0.999375,0.000000,0.484167,0,1,0,0,0,0.426875,0.999375,0.999375,0.801875,0.000000,0.000000,0.150000,0.484167 +000bb8bd9b1bca65,xclick,/m/07j7r,1,0.460625,0.550000,0.315000,0.568333,0,0,0,0,0,0.511250,0.460625,0.550000,0.517500,0.315000,0.499167,0.463333,0.568333 +000bb8bd9b1bca65,xclick,/m/07j7r,1,0.551250,0.630000,0.306667,0.545833,0,0,0,0,0,0.586250,0.551250,0.626250,0.630000,0.306667,0.444167,0.492500,0.545833 +000bb8bd9b1bca65,xclick,/m/07j7r,1,0.626250,0.707500,0.256667,0.585833,0,0,0,0,0,0.662500,0.626250,0.707500,0.680625,0.256667,0.439167,0.485833,0.585833 +000bbdf0dc8099d8,xclick,/m/01g317,1,0.000000,0.346516,0.421250,0.903750,0,1,0,0,0,0.248588,0.346516,0.000000,0.080038,0.421250,0.798125,0.660625,0.903750 +000bbdf0dc8099d8,xclick,/m/01g317,1,0.403955,0.632768,0.087500,0.964375,1,0,0,1,0,0.632768,0.506591,0.403955,0.604520,0.941875,0.087500,0.240625,0.964375 +000bbdf0dc8099d8,xclick,/m/01g317,1,0.416196,0.745763,0.010625,0.319375,1,0,0,1,0,0.478343,0.416196,0.745763,0.689266,0.010625,0.201250,0.290000,0.319375 +000bbdf0dc8099d8,xclick,/m/01yx86,1,0.378531,0.749529,0.012500,0.978125,0,0,0,0,0,0.598870,0.475518,0.749529,0.378531,0.978125,0.012500,0.279375,0.851875 +000bbdf0dc8099d8,xclick,/m/02p0tk3,1,0.000000,0.310734,0.424375,0.903750,0,1,0,0,0,0.243879,0.310734,0.000000,0.087571,0.424375,0.540000,0.638750,0.903750 +000bbdf0dc8099d8,xclick,/m/02p0tk3,1,0.398305,0.607345,0.086875,0.968125,0,0,0,1,0,0.514124,0.398305,0.586629,0.607345,0.086875,0.516875,0.243750,0.968125 +000bbdf0dc8099d8,xclick,/m/02p0tk3,1,0.439736,0.741055,0.010000,0.327500,1,0,0,1,0,0.475518,0.439736,0.741055,0.699623,0.010000,0.057500,0.285000,0.327500 +000bbdf0dc8099d8,xclick,/m/035r7c,1,0.000000,0.125235,0.596875,0.905000,-1,-1,-1,-1,-1,0.001883,0.000000,0.081921,0.125235,0.596875,0.627500,0.905000,0.894375 +000bbdf0dc8099d8,xclick,/m/035r7c,1,0.145009,0.340866,0.588125,0.811875,1,0,0,0,0,0.145009,0.340866,0.309793,0.183616,0.600000,0.790000,0.811875,0.588125 +000bbdf0dc8099d8,xclick,/m/0dzf4,1,0.000000,0.236347,0.512500,0.747500,0,0,0,0,0,0.023540,0.000000,0.236347,0.218456,0.512500,0.603125,0.698125,0.747500 +000bbdf0dc8099d8,xclick,/m/0dzf4,1,0.177024,0.246704,0.479375,0.737500,1,0,0,0,0,0.228814,0.177024,0.228814,0.246704,0.479375,0.583750,0.737500,0.598750 +000bbdf0dc8099d8,xclick,/m/0dzf4,1,0.387947,0.496234,0.129375,0.341250,0,0,0,1,0,0.387947,0.450094,0.472693,0.496234,0.341250,0.328750,0.129375,0.141250 +000bbdf0dc8099d8,xclick,/m/0dzf4,1,0.500942,0.576271,0.176875,0.360000,0,0,0,1,0,0.545198,0.576271,0.500942,0.508475,0.176875,0.195625,0.341250,0.360000 +000bc1eb7f74adae,xclick,/m/01xyhv,1,0.000000,0.391875,0.254206,0.994393,0,1,0,0,0,0.140625,0.391875,0.358125,0.000000,0.254206,0.872897,0.994393,0.388785 +000bc1eb7f74adae,xclick,/m/01xyhv,1,0.655625,0.999375,0.298131,0.999065,1,1,0,0,0,0.891250,0.999375,0.799375,0.655625,0.298131,0.591589,0.999065,0.752336 +000bc1eb7f74adae,xclick,/m/04yx4,1,0.000000,0.422500,0.000000,0.992523,1,1,0,0,0,0.242500,0.000000,0.422500,0.283750,0.000000,0.435514,0.805607,0.992523 +000bc1eb7f74adae,xclick,/m/04yx4,1,0.603750,0.999375,0.040187,0.999065,1,1,0,0,0,0.603750,0.817500,0.789375,0.999375,0.842991,0.040187,0.999065,0.760748 +000bc33717a6371f,xclick,/m/01mzpv,1,0.014375,0.300625,0.422500,0.796667,1,0,0,0,0,0.091250,0.014375,0.275625,0.300625,0.422500,0.493333,0.796667,0.597500 +000bc33717a6371f,xclick,/m/01mzpv,1,0.258125,0.363750,0.320000,0.520000,1,0,0,0,0,0.260625,0.363750,0.357500,0.258125,0.320000,0.413333,0.520000,0.327500 +000bc33717a6371f,xclick,/m/01mzpv,1,0.755000,0.918125,0.410000,0.794167,1,0,0,0,0,0.856250,0.918125,0.818750,0.755000,0.410000,0.616667,0.794167,0.430833 +000bc33717a6371f,xclick,/m/01s105,1,0.505625,0.798125,0.463333,0.711667,0,0,0,0,0,0.583750,0.505625,0.730625,0.798125,0.463333,0.486667,0.711667,0.550000 +000bc33717a6371f,xclick,/m/01y9k5,1,0.738750,0.999375,0.458333,0.857500,1,1,0,0,0,0.738750,0.999375,0.879375,0.884375,0.519167,0.554167,0.857500,0.458333 +000bc33717a6371f,xclick,/m/03m3pdh,1,0.000000,0.446875,0.573333,0.999167,0,1,0,0,0,0.107500,0.000000,0.123125,0.446875,0.573333,0.719167,0.999167,0.980833 +000bc33717a6371f,xclick,/m/03rszm,1,0.131875,0.288125,0.015000,0.332500,1,0,0,0,0,0.221875,0.184375,0.131875,0.288125,0.332500,0.015000,0.157500,0.136667 +000bc33717a6371f,xclick,/m/04bcr3,1,0.247500,0.455625,0.334167,0.554167,1,0,0,0,0,0.247500,0.455625,0.367500,0.343125,0.339167,0.356667,0.554167,0.334167 +000bc33717a6371f,xclick,/m/04bcr3,1,0.739375,0.999375,0.474167,0.853333,1,1,0,0,0,0.739375,0.876875,0.969375,0.999375,0.503333,0.853333,0.474167,0.575000 +000bc33717a6371f,xclick,/m/07c52,1,0.308125,0.381875,0.146667,0.255000,0,0,0,0,0,0.376250,0.381875,0.365000,0.308125,0.255000,0.255000,0.146667,0.153333 +000bc33717a6371f,xclick,/m/07c52,1,0.564375,0.703750,0.152500,0.325000,0,0,0,0,0,0.689375,0.638750,0.703750,0.564375,0.152500,0.325000,0.157500,0.162500 +000bc33717a6371f,xclick,/m/0dtln,1,0.375000,0.446875,0.199167,0.358333,0,0,0,0,0,0.440000,0.375000,0.411875,0.446875,0.358333,0.268333,0.199167,0.303333 +000bc33717a6371f,xclick,/m/0gjbg72,1,0.325000,0.445000,0.268333,0.313333,1,0,0,0,0,0.352500,0.325000,0.445000,0.416875,0.268333,0.292500,0.299167,0.313333 +000bc33717a6371f,xclick,/m/0gjbg72,1,0.510000,0.804375,0.492500,0.702500,1,0,0,0,0,0.518750,0.510000,0.783750,0.804375,0.492500,0.602500,0.557500,0.702500 +000bc33717a6371f,xclick,/m/0gjbg72,1,0.591250,0.774375,0.330833,0.434167,1,0,0,0,0,0.603125,0.591250,0.773125,0.774375,0.330833,0.370000,0.382500,0.434167 +000bc387c731dd97,activemil,/m/04yx4,1,0.785000,0.986875,0.091111,0.965556,1,1,0,0,0,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000,-1.000000 +000bc387c731dd97,xclick,/m/03bt1vf,1,0.323750,0.393125,0.290000,0.522222,1,0,0,0,0,0.345625,0.323750,0.375000,0.393125,0.290000,0.322222,0.522222,0.427778 +000bc387c731dd97,xclick,/m/03bt1vf,1,0.575000,0.645625,0.210000,0.998889,1,1,0,0,0,0.635625,0.645625,0.575000,0.622500,0.210000,0.214444,0.503333,0.998889 +000bc387c731dd97,xclick,/m/03bt1vf,1,0.651875,0.767500,0.275556,0.998889,1,1,0,0,0,0.736875,0.651875,0.710000,0.767500,0.275556,0.548889,0.998889,0.867778 +000bc387c731dd97,xclick,/m/03bt1vf,1,0.916250,0.982500,0.181111,0.407778,1,0,0,0,0,0.923750,0.982500,0.975000,0.916250,0.181111,0.322222,0.407778,0.255556 +000bc387c731dd97,xclick,/m/04rky,1,0.000000,0.017500,0.244444,0.368889,1,1,0,0,0,0.005000,0.000000,0.000000,0.017500,0.244444,0.314444,0.368889,0.316667 +000bc387c731dd97,xclick,/m/04rky,1,0.000000,0.101250,0.268889,0.594444,1,1,0,0,0,0.020000,0.000000,0.101250,0.101250,0.268889,0.457778,0.594444,0.594444 +000bc387c731dd97,xclick,/m/04rky,1,0.111250,0.231875,0.227778,0.590000,1,0,0,0,0,0.181875,0.111250,0.231875,0.216250,0.227778,0.390000,0.431111,0.590000 +000bc387c731dd97,xclick,/m/04rky,1,0.273750,0.339375,0.260000,0.592222,1,0,0,0,0,0.301875,0.273750,0.288125,0.339375,0.260000,0.476667,0.592222,0.462222 +000bc387c731dd97,xclick,/m/04rky,1,0.322500,0.400625,0.294444,0.565556,1,0,0,0,0,0.348125,0.322500,0.400625,0.366250,0.294444,0.316667,0.481111,0.565556 +000bc387c731dd97,xclick,/m/04rky,1,0.375000,0.468750,0.236667,0.603333,1,0,0,0,0,0.440625,0.375000,0.418750,0.468750,0.236667,0.553333,0.603333,0.327778 +000bc387c731dd97,xclick,/m/04rky,1,0.412500,0.586875,0.160000,0.988889,1,0,0,0,0,0.548125,0.412500,0.465000,0.586875,0.160000,0.834444,0.988889,0.470000 +000bc387c731dd97,xclick,/m/04rky,1,0.486875,0.609375,0.186667,0.867778,1,0,0,0,0,0.589375,0.486875,0.538125,0.609375,0.186667,0.583333,0.867778,0.253333 +000bc387c731dd97,xclick,/m/04rky,1,0.562500,0.643125,0.157778,0.431111,1,0,0,0,0,0.615000,0.562500,0.568750,0.643125,0.157778,0.394444,0.431111,0.193333 +000bc387c731dd97,xclick,/m/04rky,1,0.585625,0.655625,0.207778,0.492222,1,0,0,0,0,0.625000,0.586875,0.655625,0.585625,0.207778,0.492222,0.207778,0.492222 +000bc387c731dd97,xclick,/m/04rky,1,0.585625,0.696875,0.205556,0.542222,1,0,0,0,0,0.650625,0.585625,0.596875,0.696875,0.205556,0.503333,0.542222,0.318889 +000bc387c731dd97,xclick,/m/04rky,1,0.586875,0.743125,0.207778,0.998889,1,0,0,0,0,0.725000,0.586875,0.650625,0.743125,0.207778,0.626667,0.998889,0.218889 +000bc387c731dd97,xclick,/m/04rky,1,0.650625,0.759375,0.271111,0.998889,1,0,0,0,0,0.732500,0.650625,0.682500,0.759375,0.271111,0.553333,0.998889,0.861111 +000bc387c731dd97,xclick,/m/04rky,1,0.672500,0.748125,0.088889,0.327778,1,0,0,0,0,0.717500,0.672500,0.686250,0.748125,0.088889,0.268889,0.327778,0.173333 +000bc387c731dd97,xclick,/m/04rky,1,0.694375,0.825000,0.160000,0.998889,1,1,0,0,0,0.768750,0.694375,0.825000,0.790625,0.160000,0.517778,0.346667,0.998889 +000bc387c731dd97,xclick,/m/04rky,1,0.776250,0.867500,0.188889,0.998889,1,1,0,0,0,0.841875,0.776250,0.809375,0.867500,0.188889,0.628889,0.998889,0.292222 +000bc387c731dd97,xclick,/m/04rky,1,0.792500,0.995625,0.111111,0.998889,1,1,0,0,0,0.883750,0.792500,0.868125,0.995625,0.111111,0.817778,0.998889,0.983333 +000bc387c731dd97,xclick,/m/04rky,1,0.910625,0.954375,0.177778,0.310000,1,0,0,0,0,0.928750,0.910625,0.954375,0.949375,0.177778,0.264444,0.298889,0.310000 +000bc387c731dd97,xclick,/m/04yx4,1,0.000000,0.103750,0.268889,0.596667,1,1,0,0,0,0.024375,0.103750,0.000000,0.005000,0.268889,0.576667,0.520000,0.596667 +000bc387c731dd97,xclick,/m/04yx4,1,0.115000,0.235625,0.234444,0.590000,1,0,0,0,0,0.188125,0.235625,0.115000,0.217500,0.234444,0.421111,0.396667,0.590000 +000bc387c731dd97,xclick,/m/04yx4,1,0.271250,0.335625,0.271111,0.592222,1,0,0,0,0,0.300625,0.335625,0.271250,0.301875,0.271111,0.421111,0.478889,0.592222 +000bc387c731dd97,xclick,/m/04yx4,1,0.366250,0.476250,0.257778,0.598889,1,0,0,0,0,0.453125,0.476250,0.366250,0.411250,0.257778,0.373333,0.548889,0.598889 +000bc387c731dd97,xclick,/m/04yx4,1,0.406250,0.594375,0.134444,0.986667,1,0,0,0,0,0.556875,0.594375,0.406250,0.463750,0.134444,0.248889,0.954444,0.986667 +000bc387c731dd97,xclick,/m/04yx4,1,0.499375,0.612500,0.193333,0.836667,1,0,0,0,0,0.589375,0.612500,0.499375,0.515000,0.193333,0.280000,0.737778,0.836667 +000bc387c731dd97,xclick,/m/04yx4,1,0.589375,0.698125,0.207778,0.544444,1,0,0,0,0,0.650625,0.698125,0.589375,0.605625,0.207778,0.318889,0.472222,0.544444 +000bc387c731dd97,xclick,/m/04yx4,1,0.673750,0.758125,0.097778,0.330000,1,0,0,0,0,0.728750,0.758125,0.673750,0.689375,0.097778,0.191111,0.280000,0.330000 +000bc387c731dd97,xclick,/m/04yx4,1,0.696875,0.827500,0.188889,0.998889,1,1,0,0,0,0.788750,0.827500,0.696875,0.722500,0.188889,0.351111,0.485556,0.998889 +000bc387c731dd97,xclick,/m/05r655,1,0.323125,0.396250,0.282222,0.564444,1,0,0,0,0,0.340000,0.396250,0.323125,0.373125,0.282222,0.426667,0.323333,0.564444 +000bc387c731dd97,xclick,/m/09j5n,1,0.450625,0.499375,0.850000,0.971111,1,0,0,0,0,0.461250,0.450625,0.485625,0.499375,0.850000,0.908889,0.971111,0.961111 +000bc387c731dd97,xclick,/m/0fly7,1,0.150000,0.225625,0.501111,0.583333,1,0,0,0,0,0.193750,0.184375,0.225625,0.150000,0.501111,0.583333,0.561111,0.540000 +000bc5006eb7fd98,xclick,/m/01bl7v,1,0.000000,0.422139,0.000000,0.452500,0,0,0,0,0,0.228893,0.000000,0.422139,0.095685,0.000000,0.245000,0.221250,0.452500 +000bc5006eb7fd98,xclick,/m/035r7c,1,0.000000,0.193246,0.248750,0.457500,0,1,0,0,0,0.193246,0.000938,0.000000,0.101313,0.303750,0.248750,0.341250,0.457500 +000bc5006eb7fd98,xclick,/m/035r7c,1,0.000000,0.421201,0.713750,0.999375,1,1,0,0,0,0.000000,0.170732,0.421201,0.144465,0.732500,0.713750,0.921875,0.999375 +000bc5006eb7fd98,xclick,/m/035r7c,1,0.106942,0.839587,0.730625,0.986875,0,1,0,0,0,0.106942,0.354597,0.839587,0.759850,0.839375,0.730625,0.917500,0.986875 +000bc5006eb7fd98,xclick,/m/03q69,1,0.099437,0.339587,0.000000,0.096250,0,1,0,0,0,0.232645,0.099437,0.306754,0.339587,0.000000,0.046875,0.096250,0.028125 +000bc5006eb7fd98,xclick,/m/03q69,1,0.329268,0.803940,0.118125,0.563750,0,0,0,0,0,0.614447,0.500000,0.803940,0.329268,0.118125,0.551875,0.563750,0.543125 +000bc5006eb7fd98,xclick,/m/03q69,1,0.380863,0.596623,0.000000,0.201875,1,1,0,0,0,0.424953,0.380863,0.414634,0.596623,0.000000,0.106250,0.201875,0.015625 +000bc5006eb7fd98,xclick,/m/03q69,1,0.596623,0.814259,0.000625,0.150625,0,0,0,0,0,0.732645,0.814259,0.744841,0.596623,0.000625,0.061875,0.150625,0.096250 +000bc5006eb7fd98,xclick,/m/03q69,1,0.898687,0.999062,0.000000,0.116875,0,1,0,0,0,0.965291,0.999062,0.975610,0.898687,0.000000,0.022500,0.116875,0.050000 +000bc5006eb7fd98,xclick,/m/05r655,1,0.000000,0.836773,0.113750,0.999375,1,1,0,0,0,0.606004,0.000000,0.836773,0.775797,0.113750,0.679375,0.937500,0.999375 +000bc5006eb7fd98,xclick,/m/05r655,1,0.794559,0.999062,0.000000,0.390000,1,1,0,0,0,0.794559,0.936210,0.999062,0.848968,0.175000,0.000000,0.045000,0.390000 +000bc5006eb7fd98,xclick,/m/09j5n,1,0.031895,0.255159,0.358125,0.445000,1,0,0,0,0,0.075985,0.123827,0.031895,0.255159,0.358125,0.445000,0.404375,0.393750 +000bc5006eb7fd98,xclick,/m/09j5n,1,0.062852,0.375235,0.879375,0.999375,0,1,0,0,0,0.231707,0.203565,0.062852,0.375235,0.999375,0.879375,0.942500,0.950625 +000bc5006eb7fd98,xclick,/m/09j5n,1,0.626642,0.833021,0.892500,0.991250,0,1,0,0,0,0.690432,0.626642,0.833021,0.757036,0.892500,0.956875,0.958750,0.991250 +000bc5006eb7fd98,xclick,/m/09j5n,1,0.957786,0.999062,0.523750,0.633125,0,1,0,0,0,0.999062,0.957786,0.999062,0.996248,0.578750,0.590625,0.523750,0.633125 +000bc5006eb7fd98,xclick,/m/0dzf4,1,0.000000,0.145403,0.108125,0.258750,1,1,0,0,0,0.142589,0.000000,0.009381,0.145403,0.108125,0.195000,0.258750,0.227500 +000bc5006eb7fd98,xclick,/m/0dzf4,1,0.142589,0.416510,0.164375,0.348750,1,0,0,0,0,0.370544,0.416510,0.237336,0.142589,0.164375,0.282500,0.348750,0.263750 +000bc5006eb7fd98,xclick,/m/0dzf4,1,0.144465,0.739212,0.453125,0.740625,1,0,0,0,0,0.708255,0.144465,0.739212,0.396811,0.453125,0.728750,0.516250,0.740625 +000bc5006eb7fd98,xclick,/m/0dzf4,1,0.555347,0.627580,0.017500,0.133750,1,1,0,0,0,0.590994,0.627580,0.558161,0.555347,0.017500,0.063750,0.133750,0.096250 +000bc5006eb7fd98,xclick,/m/0dzf4,1,0.742964,0.870544,0.203750,0.410625,1,0,0,0,0,0.842402,0.870544,0.809568,0.742964,0.203750,0.306250,0.410625,0.338750 +000bc5006eb7fd98,xclick,/m/0dzf4,1,0.799250,0.922139,0.033125,0.233125,1,0,0,0,0,0.876173,0.799250,0.914634,0.922139,0.033125,0.173125,0.233125,0.231250 +000bc5006eb7fd98,xclick,/m/0dzf4,1,0.893996,0.993433,0.220625,0.282500,1,1,0,0,0,0.993433,0.893996,0.924953,0.993433,0.220625,0.248125,0.280625,0.282500 +000bc5ad4cc3ae73,xclick,/m/014sv8,1,0.109375,0.129883,0.313324,0.335286,0,0,0,0,0,0.122070,0.109375,0.129883,0.129883,0.313324,0.329429,0.335286,0.322108 +000bc5ad4cc3ae73,xclick,/m/014sv8,1,0.681641,0.702148,0.084919,0.109810,0,0,0,0,0,0.687500,0.694336,0.702148,0.681641,0.084919,0.109810,0.093704,0.098097 +000bc5ad4cc3ae73,xclick,/m/02p0tk3,1,0.000000,0.539062,0.209370,0.998536,1,1,0,0,0,0.085938,0.000000,0.539062,0.252930,0.209370,0.351391,0.588580,0.998536 +000bc5ad4cc3ae73,xclick,/m/02p0tk3,1,0.413086,0.933594,0.000000,0.998536,0,0,0,0,0,0.706055,0.933594,0.413086,0.732422,0.000000,0.452416,0.612006,0.998536 +000bc5ad4cc3ae73,xclick,/m/039xj_,1,0.032227,0.065430,0.327965,0.389458,0,0,0,0,0,0.037109,0.032227,0.051758,0.065430,0.327965,0.346999,0.389458,0.389458 +000bc5ad4cc3ae73,xclick,/m/039xj_,1,0.756836,0.777344,0.071742,0.131772,0,0,0,0,0,0.764648,0.756836,0.763672,0.777344,0.071742,0.102489,0.131772,0.101025 +000bc5ad4cc3ae73,xclick,/m/04yx4,1,0.000000,0.543945,0.206442,0.998536,1,1,0,0,0,0.061523,0.543945,0.109375,0.000000,0.206442,0.575403,0.998536,0.919473 +000bc5ad4cc3ae73,xclick,/m/04yx4,1,0.412109,0.932617,0.000000,0.998536,1,1,0,0,0,0.778320,0.932617,0.412109,0.730469,0.000000,0.487555,0.613470,0.998536 +000bc5ad4cc3ae73,xclick,/m/0dzf4,1,0.064453,0.541992,0.513909,0.840410,1,0,0,0,0,0.109375,0.064453,0.322266,0.541992,0.513909,0.749634,0.840410,0.515373 +000bc5ad4cc3ae73,xclick,/m/0dzf4,1,0.416992,0.664062,0.462665,0.737921,1,0,0,0,0,0.664062,0.652344,0.502930,0.416992,0.462665,0.737921,0.705710,0.556369 +000bc5ad4cc3ae73,xclick,/m/0dzf4,1,0.450195,0.921875,0.303075,0.726208,1,0,0,0,0,0.867188,0.450195,0.775391,0.921875,0.303075,0.458272,0.726208,0.458272 +000bc5ad4cc3ae73,xclick,/m/0k65p,1,0.410156,0.506836,0.503660,0.667643,1,0,0,0,0,0.485352,0.506836,0.435547,0.410156,0.667643,0.628111,0.503660,0.620791 +000bc5ad4cc3ae73,xclick,/m/0k65p,1,0.427734,0.541992,0.484627,0.657394,1,0,0,0,0,0.454102,0.427734,0.458984,0.541992,0.657394,0.622255,0.484627,0.575403 +000bc5ad4cc3ae73,xclick,/m/0k65p,1,0.449219,0.585938,0.351391,0.560761,0,0,0,0,0,0.536133,0.585938,0.449219,0.544922,0.351391,0.458272,0.468521,0.560761 +000bc75d38907c78,xclick,/m/01bfm9,1,0.600224,0.753639,0.552426,0.737089,1,0,0,0,0,0.615901,0.600224,0.753639,0.690929,0.552426,0.633803,0.636933,0.737089 +000bc75d38907c78,xclick,/m/01bl7v,1,0.142217,0.273236,0.133020,0.871674,1,0,0,0,0,0.228443,0.273236,0.180291,0.142217,0.133020,0.547731,0.871674,0.543036 +000bc75d38907c78,xclick,/m/01bl7v,1,0.319149,0.477044,0.048513,0.935837,1,0,0,0,0,0.402016,0.319149,0.477044,0.403135,0.048513,0.802817,0.665102,0.935837 +000bc75d38907c78,xclick,/m/01bl7v,1,0.578947,0.795073,0.156495,0.918623,1,0,0,0,0,0.695409,0.578947,0.795073,0.617021,0.156495,0.881064,0.912363,0.918623 +000bc75d38907c78,xclick,/m/0220r2,1,0.000000,0.998880,0.000000,0.851330,0,1,0,0,0,0.617021,0.426652,0.000000,0.998880,0.000000,0.851330,0.469484,0.524257 +000bc75d38907c78,xclick,/m/02p0tk3,1,0.137738,0.246361,0.123631,0.826291,0,0,0,0,0,0.220605,0.137738,0.246361,0.189250,0.123631,0.461659,0.641628,0.826291 +000bc75d38907c78,xclick,/m/02p0tk3,1,0.315789,0.472564,0.050078,0.884194,0,0,0,0,0,0.382979,0.315789,0.472564,0.409854,0.050078,0.378717,0.663537,0.884194 +000bc75d38907c78,xclick,/m/02p0tk3,1,0.583427,0.799552,0.158059,0.924883,0,0,0,0,0,0.698768,0.583427,0.764838,0.799552,0.158059,0.887324,0.924883,0.907668 +000bc75d38907c78,xclick,/m/031n1,1,0.155655,0.202688,0.813772,0.879499,1,0,0,0,0,0.179171,0.155655,0.185890,0.202688,0.813772,0.837246,0.879499,0.863850 +000bc75d38907c78,xclick,/m/031n1,1,0.190370,0.265398,0.805947,0.868545,1,0,0,0,0,0.220605,0.190370,0.258679,0.265398,0.805947,0.846635,0.868545,0.860720 +000bc75d38907c78,xclick,/m/031n1,1,0.322508,0.384099,0.765258,0.907668,1,0,0,0,0,0.356103,0.322508,0.368421,0.384099,0.765258,0.796557,0.901408,0.907668 +000bc75d38907c78,xclick,/m/031n1,1,0.370661,0.436730,0.841941,0.928012,1,0,0,0,0,0.399776,0.370661,0.413214,0.436730,0.841941,0.912363,0.928012,0.924883 +000bc75d38907c78,xclick,/m/031n1,1,0.591265,0.637178,0.835681,0.907668,1,0,0,0,0,0.591265,0.597984,0.637178,0.622620,0.862285,0.835681,0.892019,0.907668 +000bc75d38907c78,xclick,/m/031n1,1,0.723404,0.779395,0.868545,0.920188,1,0,0,0,0,0.746920,0.723404,0.763718,0.779395,0.868545,0.909233,0.920188,0.898279 +000bc75d38907c78,xclick,/m/04yx4,1,0.000000,0.082867,0.359937,0.583725,1,1,0,0,0,0.055991,0.000000,0.014558,0.082867,0.359937,0.488263,0.583725,0.399061 +000bc75d38907c78,xclick,/m/04yx4,1,0.141097,0.277716,0.133020,0.879499,1,0,0,0,0,0.218365,0.277716,0.179171,0.141097,0.133020,0.535211,0.879499,0.347418 +000bc75d38907c78,xclick,/m/04yx4,1,0.319149,0.472564,0.054773,0.928012,1,0,0,0,0,0.385218,0.319149,0.438970,0.472564,0.054773,0.804382,0.928012,0.657277 +000bc75d38907c78,xclick,/m/04yx4,1,0.585666,0.797312,0.162754,0.917058,0,0,0,0,0,0.695409,0.751400,0.797312,0.585666,0.162754,0.917058,0.912363,0.885759 +000bc75d38907c78,xclick,/m/06_fw,1,0.315789,0.541993,0.477308,0.566510,1,0,0,0,0,0.315789,0.319149,0.541993,0.501680,0.477308,0.489828,0.511737,0.566510 +000bc7b0a1889bcb,xclick,/m/07j7r,1,0.000000,0.998889,0.000000,0.908898,1,1,1,0,0,0.000000,0.000000,0.998889,0.998889,0.000000,0.908898,0.699153,0.699153 +000bc7b0a1889bcb,xclick,/m/07j7r,1,0.801111,0.998889,0.000000,0.449153,1,1,1,0,0,0.801111,0.924444,0.998889,0.935556,0.148305,0.000000,0.141949,0.449153 +000bc7b0a1889bcb,xclick,/m/0c9ph5,1,0.000000,0.012222,0.349576,0.379237,1,1,0,0,0,0.004444,0.003333,0.000000,0.012222,0.349576,0.379237,0.355932,0.370763 +000bc7b0a1889bcb,xclick,/m/0c9ph5,1,0.000000,0.151111,0.101695,0.531780,1,1,1,0,0,0.098889,0.151111,0.010000,0.000000,0.101695,0.250000,0.531780,0.493644 +000bc7b0a1889bcb,xclick,/m/0c9ph5,1,0.238889,0.502222,0.067797,0.345339,1,0,1,0,0,0.238889,0.272222,0.367778,0.502222,0.110169,0.067797,0.345339,0.188559 +000bc7b0a1889bcb,xclick,/m/0c9ph5,1,0.752222,0.914444,0.122881,0.572034,1,0,1,0,0,0.752222,0.816667,0.847778,0.914444,0.347458,0.122881,0.572034,0.430085 +000bcd3bcd95cbb3,xclick,/m/02p0tk3,1,0.251250,0.383125,0.232645,0.720450,0,0,0,0,0,0.350625,0.383125,0.371250,0.251250,0.232645,0.288931,0.720450,0.265478 +000bcd3bcd95cbb3,xclick,/m/02p0tk3,1,0.383750,0.465000,0.296435,0.575047,0,0,0,0,0,0.383750,0.432500,0.465000,0.417500,0.538462,0.296435,0.406191,0.575047 +000bcd3bcd95cbb3,xclick,/m/02p0tk3,1,0.420000,0.548125,0.481238,0.707317,0,0,0,0,0,0.420000,0.485000,0.548125,0.537500,0.569418,0.481238,0.635084,0.707317 +000bcd3bcd95cbb3,xclick,/m/035r7c,1,0.316250,0.385000,0.469981,0.723265,0,0,0,0,0,0.348750,0.316250,0.385000,0.376875,0.469981,0.493433,0.510319,0.723265 +000bcd3bcd95cbb3,xclick,/m/035r7c,1,0.381250,0.427500,0.430582,0.536585,1,0,0,0,0,0.422500,0.381250,0.391875,0.427500,0.430582,0.532833,0.536585,0.438086 +000bcd3bcd95cbb3,xclick,/m/035r7c,1,0.413750,0.428750,0.439962,0.573171,1,0,0,0,0,0.427500,0.413750,0.428750,0.423750,0.439962,0.573171,0.496248,0.488743 +000bcd3bcd95cbb3,xclick,/m/035r7c,1,0.441875,0.494375,0.582552,0.670732,1,0,0,0,0,0.441875,0.470000,0.494375,0.468750,0.582552,0.670732,0.609756,0.582552 +000bcd3bcd95cbb3,xclick,/m/035r7c,1,0.504375,0.540000,0.576923,0.682927,1,0,0,0,0,0.504375,0.540000,0.514375,0.528750,0.632270,0.576923,0.682927,0.670732 +000bcd3bcd95cbb3,xclick,/m/09j5n,1,0.381875,0.407500,0.503752,0.547842,1,0,0,0,0,0.396875,0.407500,0.396875,0.381875,0.503752,0.529081,0.547842,0.536585 +000bcd3bcd95cbb3,xclick,/m/09j5n,1,0.411250,0.426250,0.548781,0.572233,1,0,0,0,0,0.411250,0.420000,0.426250,0.425000,0.568480,0.548781,0.570356,0.572233 +000bcd3bcd95cbb3,xclick,/m/0dzf4,1,0.253125,0.310000,0.255159,0.384615,1,0,0,0,0,0.267500,0.310000,0.253125,0.278125,0.255159,0.367730,0.271107,0.384615 +000bcd3bcd95cbb3,xclick,/m/0dzf4,1,0.341250,0.390000,0.236398,0.348030,1,0,0,0,0,0.353750,0.341250,0.369375,0.390000,0.236398,0.324578,0.348030,0.290807 +000bcd3bcd95cbb3,xclick,/m/0dzf4,1,0.405000,0.455000,0.359287,0.436210,1,0,0,0,0,0.407500,0.405000,0.425625,0.455000,0.359287,0.424953,0.436210,0.404315 +000bcd3bcd95cbb3,xclick,/m/0dzf4,1,0.418125,0.456250,0.529081,0.668856,1,0,0,0,0,0.453750,0.418125,0.442500,0.456250,0.529081,0.590056,0.661351,0.668856 +000bcd3bcd95cbb3,xclick,/m/0dzf4,1,0.448750,0.531875,0.525328,0.707317,1,0,0,0,0,0.516875,0.448750,0.480625,0.531875,0.525328,0.694184,0.707317,0.555347 +000bcee5bed5446b,xclick,/m/03jm5,1,0.000000,0.051643,0.364375,0.603750,0,0,0,0,0,0.041315,0.000000,0.008451,0.051643,0.364375,0.408125,0.603750,0.593750 +000bcee5bed5446b,xclick,/m/03jm5,1,0.000000,0.221596,0.182500,0.483125,0,0,0,0,0,0.000000,0.079812,0.221596,0.113615,0.308750,0.182500,0.421250,0.483125 +000bcee5bed5446b,xclick,/m/03jm5,1,0.116432,0.999061,0.209375,0.381875,0,0,0,0,0,0.116432,0.131455,0.999061,0.704225,0.218125,0.209375,0.301875,0.381875 +000bcee5bed5446b,xclick,/m/03jm5,1,0.742723,0.999061,0.348125,0.698125,0,0,0,0,0,0.742723,0.831925,0.999061,0.999061,0.441875,0.348125,0.523750,0.698125 +000bcee5bed5446b,xclick,/m/0k4j,1,0.165258,0.249765,0.508125,0.548750,0,0,0,0,0,0.175587,0.216901,0.165258,0.249765,0.508125,0.548750,0.533750,0.521250 +000bcee5bed5446b,xclick,/m/0k4j,1,0.170892,0.260094,0.478750,0.508125,1,0,0,0,0,0.209390,0.216901,0.170892,0.260094,0.478750,0.506250,0.495625,0.508125 +000bcee5bed5446b,xclick,/m/0k4j,1,0.295775,0.347418,0.406875,0.436250,1,0,0,0,0,0.329577,0.295775,0.295775,0.347418,0.406875,0.436250,0.424375,0.424375 +000bcee5bed5446b,xclick,/m/0k4j,1,0.606573,0.661033,0.492500,0.530000,0,0,0,0,0,0.627230,0.642254,0.606573,0.661033,0.492500,0.530000,0.513125,0.509375 +000bcee5bed5446b,xclick,/m/0k4j,1,0.607512,0.683568,0.618125,0.670625,0,0,0,0,0,0.643192,0.607512,0.622535,0.683568,0.618125,0.626875,0.670625,0.653750 +000bcee5bed5446b,xclick,/m/0k4j,1,0.624413,0.661033,0.480625,0.494375,1,0,0,0,0,0.642254,0.650704,0.624413,0.661033,0.480625,0.494375,0.485625,0.489375 +000bcee5bed5446b,xclick,/m/0k4j,1,0.673239,0.822535,0.499375,0.533750,0,0,0,0,0,0.735211,0.693897,0.673239,0.822535,0.499375,0.533750,0.520000,0.520000 +000bcee5bed5446b,xclick,/m/0k4j,1,0.739906,0.883568,0.608750,0.636250,1,0,0,0,0,0.812207,0.812207,0.739906,0.883568,0.608750,0.636250,0.622500,0.608750 +000bcee5bed5446b,xclick,/m/0k4j,1,0.799061,0.999061,0.668750,0.726250,0,0,0,0,0,0.865728,0.832864,0.799061,0.999061,0.668750,0.726250,0.702500,0.702500 diff --git a/src/taming-transformers/data/open_images_annotations_100/train-images-boxable.csv b/src/taming-transformers/data/open_images_annotations_100/train-images-boxable.csv new file mode 100644 index 0000000000000000000000000000000000000000..7dfaa769b0632e7944650e2cdd2fb659d0d55565 --- /dev/null +++ b/src/taming-transformers/data/open_images_annotations_100/train-images-boxable.csv @@ -0,0 +1,101 @@ +image_name,image_url +000abe5eddc5b303.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000abe5eddc5b303.jpg +000b567c26dd4e5d.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b567c26dd4e5d.jpg +000b9814a07fd974.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b9814a07fd974.jpg +000b63a1445f53c8.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b63a1445f53c8.jpg +000b59a7822679e6.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b59a7822679e6.jpg +000ab31e6be35fed.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ab31e6be35fed.jpg +000bc387c731dd97.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bc387c731dd97.jpg +000afe7726e121ea.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000afe7726e121ea.jpg +000b4671075914cd.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b4671075914cd.jpg +000bb200fc78fc30.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bb200fc78fc30.jpg +000bc75d38907c78.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bc75d38907c78.jpg +000b5bc07c0c5df7.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b5bc07c0c5df7.jpg +000ba221f70676c6.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ba221f70676c6.jpg +000b9007a01f7405.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b9007a01f7405.jpg +000ab8c20b3e5b58.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ab8c20b3e5b58.jpg +000b260e1f08a32a.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b260e1f08a32a.jpg +000ac34008b0ba4c.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ac34008b0ba4c.jpg +000baa6f7dae9b79.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000baa6f7dae9b79.jpg +000b87119cc301cf.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b87119cc301cf.jpg +000b1971d8daaeef.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b1971d8daaeef.jpg +000b21663becc68e.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b21663becc68e.jpg +000ad6c520be9ec5.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ad6c520be9ec5.jpg +000bc1eb7f74adae.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bc1eb7f74adae.jpg +000b9d6c0f7d794d.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b9d6c0f7d794d.jpg +000ac8c676b6077a.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ac8c676b6077a.jpg +000ab7bec71cc50a.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ab7bec71cc50a.jpg +000b09d5d3fc821f.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b09d5d3fc821f.jpg +000ae235808cc1e8.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ae235808cc1e8.jpg +000b8d80f7386698.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b8d80f7386698.jpg +000bbdf0dc8099d8.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bbdf0dc8099d8.jpg +000b93644609911f.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b93644609911f.jpg +000b4fcdf1af3361.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b4fcdf1af3361.jpg +000b168e791f591d.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b168e791f591d.jpg +000b393437134262.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b393437134262.jpg +000aecd78b230135.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000aecd78b230135.jpg +000b76a9b80ba43a.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b76a9b80ba43a.jpg +000b55559b0244d7.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b55559b0244d7.jpg +000b72e1446f8849.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b72e1446f8849.jpg +000bcee5bed5446b.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bcee5bed5446b.jpg +000b9f3ba4891c11.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b9f3ba4891c11.jpg +000b9b61afea2cd4.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b9b61afea2cd4.jpg +000b1b92f0800e94.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b1b92f0800e94.jpg +000b29496f75c8e5.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b29496f75c8e5.jpg +000bc33717a6371f.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bc33717a6371f.jpg +000b70a84aab664b.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b70a84aab664b.jpg +000acf666d991c39.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000acf666d991c39.jpg +000bc5ad4cc3ae73.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bc5ad4cc3ae73.jpg +000b4935979bf4b5.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b4935979bf4b5.jpg +000ac95750ac7399.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ac95750ac7399.jpg +000bc7b0a1889bcb.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bc7b0a1889bcb.jpg +000b0f235dcf2caa.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b0f235dcf2caa.jpg +000b55e339f0b131.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b55e339f0b131.jpg +000b06c0eed42a4c.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b06c0eed42a4c.jpg +000af631fb329557.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000af631fb329557.jpg +000b9a97776b3634.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b9a97776b3634.jpg +000abc821f66a892.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000abc821f66a892.jpg +000adef7197e3118.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000adef7197e3118.jpg +000adcdd7244ce4a.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000adcdd7244ce4a.jpg +000b606e130bdf5e.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b606e130bdf5e.jpg +000b50bdd1933a36.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b50bdd1933a36.jpg +000ad6fa67b5ad96.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ad6fa67b5ad96.jpg +000b299b5f5ed902.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b299b5f5ed902.jpg +000adfe5b817011c.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000adfe5b817011c.jpg +000bcd3bcd95cbb3.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bcd3bcd95cbb3.jpg +000b2d1789d5f80d.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b2d1789d5f80d.jpg +000bb8bd9b1bca65.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bb8bd9b1bca65.jpg +000b9c365c9e307a.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b9c365c9e307a.jpg +000ba3ca8a2ca955.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ba3ca8a2ca955.jpg +000b42cae15622e0.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b42cae15622e0.jpg +000b9b00d7aef8f5.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b9b00d7aef8f5.jpg +000ad3d42653f5f6.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ad3d42653f5f6.jpg +000bc5006eb7fd98.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bc5006eb7fd98.jpg +000b2b00065e564a.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b2b00065e564a.jpg +000b2a982a903d0d.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b2a982a903d0d.jpg +000ae28755d2d20e.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ae28755d2d20e.jpg +000bab5b1a67844e.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bab5b1a67844e.jpg +000b38d9f2f664fe.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b38d9f2f664fe.jpg +000bb2f7132013dc.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bb2f7132013dc.jpg +000bb0ae453283b0.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bb0ae453283b0.jpg +000b093da01e5bfe.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b093da01e5bfe.jpg +000b825dea3016eb.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b825dea3016eb.jpg +000abc075d659122.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000abc075d659122.jpg +000b1b3b85edd850.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b1b3b85edd850.jpg +000b7dfaa1810a83.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b7dfaa1810a83.jpg +000ad20b5e452b24.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ad20b5e452b24.jpg +000b485cedacbf97.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b485cedacbf97.jpg +000b81b5757963e0.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b81b5757963e0.jpg +000ba940f8cfc9bf.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ba940f8cfc9bf.jpg +000bb81adefe7332.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bb81adefe7332.jpg +000b397382b2464a.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b397382b2464a.jpg +000ba28d70b1a999.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ba28d70b1a999.jpg +000b0f5159f54105.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b0f5159f54105.jpg +000b3940e7d25c03.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b3940e7d25c03.jpg +000ad0ecfb21ee63.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ad0ecfb21ee63.jpg +000bb846e2629e83.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000bb846e2629e83.jpg +000aee0af66d4237.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000aee0af66d4237.jpg +000af180a3163f17.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000af180a3163f17.jpg +000b65a36ad46f9e.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b65a36ad46f9e.jpg +000b432ae644b679.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000b432ae644b679.jpg +000ba40bf7a2b458.jpg,https://requestor-proxy.figure-eight.com/figure_eight_datasets/open-images/train/000ba40bf7a2b458.jpg diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ab31e6be35fed.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ab31e6be35fed.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8f9ee0bdf8140eed5ccddfe7f9ef0d1d1aa2d8d6 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ab31e6be35fed.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ab7bec71cc50a.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ab7bec71cc50a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6190d85e7db67938a314bfea524568fc9a14e61b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ab7bec71cc50a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ab8c20b3e5b58.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ab8c20b3e5b58.jpg new file mode 100644 index 0000000000000000000000000000000000000000..35c297421ad934b14aa4534d66a17f92edae0b02 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ab8c20b3e5b58.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000abc075d659122.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000abc075d659122.jpg new file mode 100644 index 0000000000000000000000000000000000000000..00f720e93c652de1e8cd532d0981e7c150ff889d Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000abc075d659122.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000abc821f66a892.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000abc821f66a892.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a7d35a5845f16141f141a27736b806fd622d830c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000abc821f66a892.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000abe5eddc5b303.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000abe5eddc5b303.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f22b56793b74ab27883c536a0d069d912442dbdd Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000abe5eddc5b303.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ac34008b0ba4c.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ac34008b0ba4c.jpg new file mode 100644 index 0000000000000000000000000000000000000000..479828bbb67e2cb50a4dd6ac685f59ff8d7f079b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ac34008b0ba4c.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ac8c676b6077a.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ac8c676b6077a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2a6ddf7cb86b5c83f1a557c8a4c6b06d49bfe7ef Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ac8c676b6077a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ac95750ac7399.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ac95750ac7399.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2f21d7b6e8e3729cb872fbb8b713dd966a7ba94f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ac95750ac7399.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000acf666d991c39.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000acf666d991c39.jpg new file mode 100644 index 0000000000000000000000000000000000000000..125a6388cbca5b8cd257b4d26b9f855c8b6c1e8a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000acf666d991c39.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ad0ecfb21ee63.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ad0ecfb21ee63.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2c641326a0b74914d2dcb6f4fc321d5805d624b9 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ad0ecfb21ee63.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ad20b5e452b24.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ad20b5e452b24.jpg new file mode 100644 index 0000000000000000000000000000000000000000..30f07632c94100bc05ce4a7b6635b62a3d67e2fa Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ad20b5e452b24.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ad3d42653f5f6.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ad3d42653f5f6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ac3c86072508b7f53232cb4cd64ffaab4b9331af Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ad3d42653f5f6.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ad6c520be9ec5.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ad6c520be9ec5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d093fa6caded27a72cf446a37c93c550ffc2670c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ad6c520be9ec5.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ad6fa67b5ad96.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ad6fa67b5ad96.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d4e7d5cd161ebeb5fd8a61b0469b4681b02837b3 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ad6fa67b5ad96.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000adcdd7244ce4a.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000adcdd7244ce4a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ffa766c24cb6e79d09d6e6ef212bd6c51b5c1636 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000adcdd7244ce4a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000adef7197e3118.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000adef7197e3118.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2e78ca86c2ee54fd66f5315dd86f775c52d4f6d2 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000adef7197e3118.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000adfe5b817011c.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000adfe5b817011c.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c813703dc17323b5f93de522bc7b90b0432687b1 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000adfe5b817011c.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ae235808cc1e8.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ae235808cc1e8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a9a8c395a9d3de92af57033904a4b461084fa360 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ae235808cc1e8.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ae28755d2d20e.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ae28755d2d20e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..50f69656372b5d2eeffb9ba82d8f0c6f03cebd37 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ae28755d2d20e.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000aecd78b230135.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000aecd78b230135.jpg new file mode 100644 index 0000000000000000000000000000000000000000..840105ae16b78d3ee7ec1bfcbe3cedbfb11c6e3f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000aecd78b230135.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000aee0af66d4237.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000aee0af66d4237.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c72432184a09505724c8df2632aff0ead89c45e0 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000aee0af66d4237.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000af180a3163f17.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000af180a3163f17.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6634316e8ae2d71cb54bb8fa56a71c85ba123092 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000af180a3163f17.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000af631fb329557.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000af631fb329557.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cf4fa6e8dc9337ae6fdd54a953aa48736ceb4195 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000af631fb329557.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000afe7726e121ea.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000afe7726e121ea.jpg new file mode 100644 index 0000000000000000000000000000000000000000..39bff8eb0d463d5a38fc8e2711c8e71723d5417c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000afe7726e121ea.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b06c0eed42a4c.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b06c0eed42a4c.jpg new file mode 100644 index 0000000000000000000000000000000000000000..972b7d7f0b09ef77a8824026bbd9479408b28d4b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b06c0eed42a4c.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b093da01e5bfe.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b093da01e5bfe.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a02b3ec7d09dd1e809c910642bacec28c0e73be9 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b093da01e5bfe.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b09d5d3fc821f.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b09d5d3fc821f.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1e5eb3cdf698cc8c994992320cb5c1324b67ab14 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b09d5d3fc821f.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b0f235dcf2caa.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b0f235dcf2caa.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a90b85e6b4324a7657e38799863fb90490583b73 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b0f235dcf2caa.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b0f5159f54105.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b0f5159f54105.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7fdbbab55e8e534d85fdd3b79fb420868352e82a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b0f5159f54105.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b168e791f591d.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b168e791f591d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a238b116b1d2f0c29ff5b7cb60f443c0ddfa22a0 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b168e791f591d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b1971d8daaeef.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b1971d8daaeef.jpg new file mode 100644 index 0000000000000000000000000000000000000000..46e0277b80ab153377e962a1e25f1aacd31369f5 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b1971d8daaeef.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b1b3b85edd850.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b1b3b85edd850.jpg new file mode 100644 index 0000000000000000000000000000000000000000..72419a8b818a104561ed1fd0b17e5ac567a7f442 --- /dev/null +++ b/src/taming-transformers/data/open_images_annotations_100/train/000b1b3b85edd850.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:78c5af25af6c0cc17892bacae70b86c2177d71f20c5f945bdf6d1b316fcd48d1 +size 1848832 diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b1b92f0800e94.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b1b92f0800e94.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4198cc100e13e4f16d6c1415eed6edfa5f5e6fe4 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b1b92f0800e94.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b21663becc68e.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b21663becc68e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e5a1bb12aa807925285e634c9c3787235ef11729 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b21663becc68e.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b260e1f08a32a.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b260e1f08a32a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4d421904e3612790a2d4f346da25c4654353cc97 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b260e1f08a32a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b29496f75c8e5.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b29496f75c8e5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b406a2babd8f6871b4c3484b3cc114d2e815e808 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b29496f75c8e5.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b299b5f5ed902.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b299b5f5ed902.jpg new file mode 100644 index 0000000000000000000000000000000000000000..58c076f52bdaaddcd411845f71c1d3ab3abfc100 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b299b5f5ed902.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b2a982a903d0d.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b2a982a903d0d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e669b5593af1060f9b1c98998ab6fdf6a6ad41cb Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b2a982a903d0d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b2b00065e564a.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b2b00065e564a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..50db9688692e84ba156e3cb376960d6ed6a1db6b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b2b00065e564a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b2d1789d5f80d.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b2d1789d5f80d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..adc14fdeda11c18f26c39905a5f0d59105e5175b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b2d1789d5f80d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b38d9f2f664fe.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b38d9f2f664fe.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bf18ce1497b23fc4a4c95836673e97b94f0a3075 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b38d9f2f664fe.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b393437134262.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b393437134262.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6771a9a4e4e0131a51853166b22b5e8b4bea8351 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b393437134262.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b3940e7d25c03.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b3940e7d25c03.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b150e88f51bae66fe7a0a83fc7afb64476872a21 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b3940e7d25c03.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b397382b2464a.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b397382b2464a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5fd92cef39665e9339fe9c9e464e0aa9d3d1c5a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b397382b2464a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b42cae15622e0.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b42cae15622e0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fa1c943ea02566eac0b47e5175df66bbf497d749 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b42cae15622e0.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b432ae644b679.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b432ae644b679.jpg new file mode 100644 index 0000000000000000000000000000000000000000..32aa12d50d97e84056d76260f13ca32bc494f43c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b432ae644b679.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b4671075914cd.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b4671075914cd.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b66b1bbce44059fcc5b6400b1a9bf609f6ba3b8a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b4671075914cd.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b485cedacbf97.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b485cedacbf97.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2e684e0b9d2a408fd5c409c6ec4506c10fcc06de Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b485cedacbf97.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b4935979bf4b5.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b4935979bf4b5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1ee7299271d8941d723dc2957694d2307d0cd344 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b4935979bf4b5.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b4fcdf1af3361.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b4fcdf1af3361.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bce290fd6ace18b725a8c2526c35b291efcf5143 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b4fcdf1af3361.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b50bdd1933a36.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b50bdd1933a36.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ad5a54cfd1f3ddca512daf11818442f340530cdf Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b50bdd1933a36.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b55559b0244d7.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b55559b0244d7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..35ec466bc9beaabe27b5d5497aadbf7e593a3b75 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b55559b0244d7.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b55e339f0b131.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b55e339f0b131.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5fdbe1f88747abd17abaecbbae2a3cad4e09a3aa Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b55e339f0b131.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b567c26dd4e5d.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b567c26dd4e5d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..52d6301674428d85157886b8288a9f37766eeb9c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b567c26dd4e5d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b59a7822679e6.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b59a7822679e6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..540cc8206cc723f23ea5d675b6ac7e8113d52438 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b59a7822679e6.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b5bc07c0c5df7.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b5bc07c0c5df7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a54b8882af26d56fca8465c482aa00752852c23a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b5bc07c0c5df7.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b606e130bdf5e.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b606e130bdf5e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fbd92a53934e03704f38e984b3614172f2bc5aec Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b606e130bdf5e.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b63a1445f53c8.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b63a1445f53c8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..73b6387b413204297a9dd1c8f4db1c00da7194e2 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b63a1445f53c8.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b65a36ad46f9e.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b65a36ad46f9e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5685cbe48ec5b54c603bc625e886a2d06b56f65c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b65a36ad46f9e.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b70a84aab664b.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b70a84aab664b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff21b53f2980c71d35cc00ae659ceb7c6cc9c913 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b70a84aab664b.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b72e1446f8849.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b72e1446f8849.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b2247932547a67b8a76352ef4dda4e6b01187b84 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b72e1446f8849.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b76a9b80ba43a.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b76a9b80ba43a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f8fb655a381cbe1ae1f988bce772e855afe4cef4 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b76a9b80ba43a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b7dfaa1810a83.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b7dfaa1810a83.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2d4315169cddfd44d3ac71e707abff47d8dacb3f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b7dfaa1810a83.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b81b5757963e0.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b81b5757963e0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..94888211441256a2f5d360b947976eacab633e83 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b81b5757963e0.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b825dea3016eb.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b825dea3016eb.jpg new file mode 100644 index 0000000000000000000000000000000000000000..48a7cc1b32470b259d909229a6eb695c2c7891a5 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b825dea3016eb.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b87119cc301cf.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b87119cc301cf.jpg new file mode 100644 index 0000000000000000000000000000000000000000..957979e9dd8d7049748bad20b00f526e551054e3 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b87119cc301cf.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b8d80f7386698.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b8d80f7386698.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b39e0eeabf8f701771e5cba5ca54bb4f14a84e3d Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b8d80f7386698.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b9007a01f7405.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b9007a01f7405.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3049b8cb4b4213250e2a7d5c4f9e09df8a79d6eb Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b9007a01f7405.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b93644609911f.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b93644609911f.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0923a8843921e5dc53842c6461b940c7cb96c4bf Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b93644609911f.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b9814a07fd974.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b9814a07fd974.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1e9b44a761731c9cdfb191068f8ebfbce6f06bdf Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b9814a07fd974.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b9a97776b3634.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b9a97776b3634.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eef935950d77b4a6b38827d753fc8f7b5613f1ec Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b9a97776b3634.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b9b00d7aef8f5.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b9b00d7aef8f5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99ae6ee9165c376734173a9de21ee63a9ca4f548 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b9b00d7aef8f5.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b9b61afea2cd4.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b9b61afea2cd4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7a4481a9b4ccf106f39adb1190360b6b10cf8408 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b9b61afea2cd4.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b9c365c9e307a.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b9c365c9e307a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0346db79852ef17d9391cc098421679295626fa9 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b9c365c9e307a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b9d6c0f7d794d.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b9d6c0f7d794d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2f49300dffa6c8acc5226be92b0e07f42466285a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b9d6c0f7d794d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000b9f3ba4891c11.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000b9f3ba4891c11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..712fd7b7393e694025d2b8486150a474ed4deb04 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000b9f3ba4891c11.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ba221f70676c6.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ba221f70676c6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ad7c336f0a49ba2306e723170cfd242c87c61d3e Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ba221f70676c6.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ba28d70b1a999.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ba28d70b1a999.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b21c3d2ddac8bd94beba0663022639b553794a1f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ba28d70b1a999.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ba3ca8a2ca955.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ba3ca8a2ca955.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69e7641ab79b9a625a76ea1591ff30332c8102ce Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ba3ca8a2ca955.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ba40bf7a2b458.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ba40bf7a2b458.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9388acbf762a366cf012717f866f80e7594871a8 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ba40bf7a2b458.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000ba940f8cfc9bf.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000ba940f8cfc9bf.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8de230d4b8019735bdd36fcf2b98d615f5c71cd9 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000ba940f8cfc9bf.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000baa6f7dae9b79.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000baa6f7dae9b79.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ddde6d90922c1b3f3ddcf87740396aa6d8c026b4 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000baa6f7dae9b79.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bab5b1a67844e.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bab5b1a67844e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..618593811196e391d4ed214c3ad6384202df1e9f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bab5b1a67844e.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bb0ae453283b0.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bb0ae453283b0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..68546f9c90923ec69d17c915f706a72e9780efba Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bb0ae453283b0.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bb200fc78fc30.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bb200fc78fc30.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e2f9c1634edf7af40040aad5e84b98cc32c29106 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bb200fc78fc30.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bb2f7132013dc.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bb2f7132013dc.jpg new file mode 100644 index 0000000000000000000000000000000000000000..87cdc39303199bc83cc3b58f02c9ffe40aea9bfd Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bb2f7132013dc.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bb81adefe7332.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bb81adefe7332.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9eb5d7f6e6b8dfb622179f2a6a12d4c178b4d0d7 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bb81adefe7332.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bb846e2629e83.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bb846e2629e83.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5c2d6554780496f8dc94a1ccca134901db9c72e2 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bb846e2629e83.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bb8bd9b1bca65.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bb8bd9b1bca65.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b807c88b42da1b0b3da3f176d7f9b8b34af065c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bb8bd9b1bca65.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bbdf0dc8099d8.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bbdf0dc8099d8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e0f0462c5cf347dc39aad25d0656e7ea5ec8bb36 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bbdf0dc8099d8.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bc1eb7f74adae.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bc1eb7f74adae.jpg new file mode 100644 index 0000000000000000000000000000000000000000..360c25a641046217cbddfa3c27197db4bad59ad6 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bc1eb7f74adae.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bc33717a6371f.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bc33717a6371f.jpg new file mode 100644 index 0000000000000000000000000000000000000000..98ebb775231569fbed32a7dc553c7da4933df6a7 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bc33717a6371f.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bc387c731dd97.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bc387c731dd97.jpg new file mode 100644 index 0000000000000000000000000000000000000000..42becfc435c7b8cb6c979bc05b362215f71ce2d1 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bc387c731dd97.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bc5006eb7fd98.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bc5006eb7fd98.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0b9e840ec8f6f3db6f89d594650b6761694573f9 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bc5006eb7fd98.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bc5ad4cc3ae73.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bc5ad4cc3ae73.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0a93dadca5fd54e7ff81accae42d9a9b9b9c9a0c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bc5ad4cc3ae73.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bc75d38907c78.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bc75d38907c78.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5b5a3a38acae0e7e9c04567a022ec6a57e25203f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bc75d38907c78.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bc7b0a1889bcb.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bc7b0a1889bcb.jpg new file mode 100644 index 0000000000000000000000000000000000000000..97b64d59e1f373d50e8f7df73c50ea8a273a01a4 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bc7b0a1889bcb.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bcd3bcd95cbb3.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bcd3bcd95cbb3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..53ec8aff3143463d5dac290595989ae66b1ec9cc Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bcd3bcd95cbb3.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/train/000bcee5bed5446b.jpg b/src/taming-transformers/data/open_images_annotations_100/train/000bcee5bed5446b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f9ce8ebb9d2cd1016e4eced5bf3da948436d876b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/train/000bcee5bed5446b.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation-annotations-bbox.csv b/src/taming-transformers/data/open_images_annotations_100/validation-annotations-bbox.csv new file mode 100644 index 0000000000000000000000000000000000000000..62f1780b4bc34ab6760dc0e5db3c888e6028b955 --- /dev/null +++ b/src/taming-transformers/data/open_images_annotations_100/validation-annotations-bbox.csv @@ -0,0 +1,895 @@ +ImageID,Source,LabelName,Confidence,XMin,XMax,YMin,YMax,IsOccluded,IsTruncated,IsGroupOf,IsDepiction,IsInside +09c5b4d6bc25788d,xclick,/m/0dzct,1,0.43651927,0.51640517,0.35159817,0.51826483,0,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/0dzct,1,0.5977175,0.6091298,0.8538813,0.8767123,0,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/0dzct,1,0.66333807,0.6761769,0.8584475,0.8812785,0,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/03q69,1,0.4293866,0.52639085,0.3127854,0.4155251,0,0,0,1,0 +09c5b4d6bc25788d,xclick,/m/04hgtk,1,0.43223965,0.53067046,0.3127854,0.5525114,0,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/0k65p,1,0.553495,0.7089872,0.3584475,0.55707765,0,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/0dzf4,1,0.3951498,0.43937233,0.60730594,0.7648402,1,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/0dzf4,1,0.5520685,0.7089872,0.3561644,0.6438356,0,0,0,1,0 +09c5b4d6bc25788d,xclick,/m/0dzf4,1,0.5920114,0.5977175,0.88812786,0.9041096,1,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/0dzf4,1,0.6119829,0.6319544,0.8538813,0.89269406,1,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/0dzf4,1,0.6504993,0.66333807,0.8789954,0.9041096,1,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/0dzf4,1,0.6804565,0.6918688,0.8812785,0.9041096,1,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/04yx4,1,0.39657632,0.7104137,0.30821916,0.7648402,0,1,0,0,0 +09c5b4d6bc25788d,xclick,/m/04yx4,1,0.58773184,0.617689,0.84474885,0.9063927,0,0,0,0,0 +09c5b4d6bc25788d,xclick,/m/04yx4,1,0.6519258,0.6904422,0.84703195,0.9041096,0,1,0,1,0 +09c67960e389e4df,xclick,/m/0bt9lr,1,0.8082596,0.9587021,0.46460176,0.63495576,1,0,0,0,0 +09c67960e389e4df,xclick,/m/0k4j,1,0,0.29056048,0.3340708,0.5154867,1,1,0,0,0 +09c67960e389e4df,xclick,/m/0k4j,1,0.0014749262,0.072271384,0.33628318,0.38053098,1,1,0,0,0 +09c67960e389e4df,xclick,/m/0k4j,1,0.0029498525,0.26548672,0.32964602,0.40486726,1,0,0,0,0 +09c67960e389e4df,xclick,/m/0k4j,1,0.17551622,0.8318584,0.23451327,0.7632743,0,0,0,0,0 +09c67960e389e4df,xclick,/m/0k4j,1,0.23746313,0.5722714,0.3340708,0.44911504,1,0,0,0,0 +09c67960e389e4df,xclick,/m/01prls,1,0.0014749262,0.8303835,0.2300885,0.7654867,1,1,1,0,0 +09c67960e389e4df,xclick,/m/01prls,1,0.7787611,0.8982301,0.2721239,0.3539823,1,0,0,0,0 +09c67960e389e4df,xclick,/m/01prls,1,0.8746313,0.9852507,0.23230088,0.3141593,1,1,0,0,0 +09c67960e389e4df,xclick,/m/04rky,1,0.06342183,1,0.21017699,0.67477876,0,1,1,0,0 +09c6ddd2c210450e,xclick,/m/0dzct,1,0.5077605,0.60310423,0.101620026,0.18114875,0,0,0,0,0 +09c6ddd2c210450e,xclick,/m/01yx86,1,0.28381374,0.75388026,0.060382918,0.95287186,0,0,0,0,0 +09c6ddd2c210450e,xclick,/m/03q69,1,0.4767184,0.6186253,0.06332842,0.19734904,0,0,0,1,0 +09c6ddd2c210450e,xclick,/m/035r7c,1,0.33702883,0.5631929,0.46980855,0.83505154,0,0,0,1,0 +09c6ddd2c210450e,xclick,/m/035r7c,1,0.4745011,0.54545456,0.47717232,0.65537554,1,0,0,0,0 +09c6ddd2c210450e,xclick,/m/05r655,1,0.28381374,0.76053214,0.06480118,0.9484536,0,0,0,1,0 +09c6ddd2c210450e,xclick,/m/0k0pj,1,0.54323727,0.5698448,0.13696612,0.15905744,0,0,0,1,0 +09c6ddd2c210450e,xclick,/m/04hgtk,1,0.48337027,0.6053215,0.06332842,0.18114875,0,0,0,1,0 +09c6ddd2c210450e,xclick,/m/04rky,1,0.28381374,0.72505546,0.0544919,0.8453608,0,0,0,1,0 +09c6ddd2c210450e,xclick,/m/0dzf4,1,0.28824833,0.50554323,0.072164945,0.23858616,0,0,0,1,0 +09c6ddd2c210450e,xclick,/m/0dzf4,1,0.6097561,0.7339246,0.21207659,0.40795287,0,0,0,1,0 +09c6ddd2c210450e,xclick,/m/03bt1vf,1,0.28824833,0.75166297,0.06332842,0.83505154,0,0,0,1,0 +09c7f89055cf399b,xclick,/m/05s2s,1,0,1,0,1,0,0,1,0,0 +09c7f89055cf399b,xclick,/m/0c9ph5,1,0.05277402,0.19079837,0.43855423,0.63373494,1,0,0,0,0 +09c7f89055cf399b,xclick,/m/0c9ph5,1,0.17456022,0.7510149,0,0.87710845,0,0,0,0,0 +09c7f89055cf399b,xclick,/m/0c9ph5,1,0.6752368,0.932341,0.5253012,0.913253,1,0,0,0,0 +09c863d76bcf6b00,xclick,/m/0dzct,1,0.1875,0.84166664,0.040625,0.678125,0,0,0,1,0 +09c863d76bcf6b00,xclick,/m/01yx86,1,0,0.96666664,0,1,0,0,0,0,0 +09c863d76bcf6b00,xclick,/m/01g317,1,0,0.96875,0,0.9984375,1,0,0,1,0 +09c863d76bcf6b00,xclick,/m/0k0pj,1,0.46458334,0.7125,0.3203125,0.465625,0,0,0,1,0 +09c863d76bcf6b00,xclick,/m/09j2d,1,0.025,0.95625,0.5203125,0.9984375,0,1,0,1,0 +09c863d76bcf6b00,xclick,/m/04hgtk,1,0.00625,0.8541667,0,0.675,0,0,0,1,0 +09c863d76bcf6b00,xclick,/m/04yqq2,1,0,0.96666664,0,1,0,0,0,0,0 +09c993afacd01547,xclick,/m/015p6,1,0.109375,0.496875,0.16666667,0.6958333,1,0,0,0,0 +09c993afacd01547,xclick,/m/015p6,1,0.4515625,0.8859375,0.3875,0.83958334,0,0,0,0,0 +09cbba9f5e097a19,xclick,/m/0k4j,1,0.015625,0.51875,0.295,0.575,1,0,0,0,0 +09cbba9f5e097a19,xclick,/m/0k4j,1,0.1171875,0.934375,0.2825,0.6875,1,0,0,0,0 +09cbba9f5e097a19,xclick,/m/0k4j,1,0.3234375,1,0.23,1,0,1,0,0,0 +09cbba9f5e097a19,xclick,/m/07yv9,1,0.0171875,1,0.23,1,0,1,1,0,0 +09d2112596d9155b,xclick,/m/0k4j,1,0,0.25516224,0.33849558,0.6924779,1,1,0,0,0 +09d2112596d9155b,xclick,/m/0k4j,1,0.06342183,0.96460176,0.03539823,0.9358407,0,0,0,0,0 +09d2112596d9155b,xclick,/m/0k4j,1,0.71091443,0.9896755,0.34070796,0.6880531,1,0,0,0,0 +09d2112596d9155b,xclick,/m/08dz3q,1,0.39823008,0.83923304,0.5221239,0.6216814,0,0,0,0,0 +09d2112596d9155b,xclick,/m/083wq,1,0.072271384,0.109144546,0.5641593,0.829646,0,0,0,0,0 +09d2112596d9155b,xclick,/m/083wq,1,0.26253688,0.37905604,0.59070796,0.9380531,0,0,0,0,0 +09d2112596d9155b,xclick,/m/083wq,1,0.53687316,0.57669616,0.460177,0.48451328,1,0,0,0,0 +09d2112596d9155b,xclick,/m/083wq,1,0.9380531,0.95132744,0.65929204,0.6880531,1,0,0,0,0 +09d354dbd3dcc857,xclick,/m/0dzct,1,0.64254063,0.6706056,0.42384106,0.47019866,1,0,0,0,0 +09d354dbd3dcc857,xclick,/m/03q69,1,0.64254063,0.67799115,0.40397352,0.44591612,0,0,0,0,0 +09d354dbd3dcc857,xclick,/m/0k4j,1,0.23338257,0.89660263,0.3112583,0.79911697,0,0,0,0,0 +09d354dbd3dcc857,xclick,/m/01g317,1,0.64254063,0.7666174,0.401766,0.49668875,1,0,0,0,0 +09d354dbd3dcc857,xclick,/m/04hgtk,1,0.64254063,0.68242246,0.40397352,0.46578366,0,0,0,0,0 +09d354dbd3dcc857,xclick,/m/083wq,1,0.4549483,0.5731167,0.61147904,0.79911697,1,0,0,0,0 +09d354dbd3dcc857,xclick,/m/083wq,1,0.7917282,0.8537666,0.58278143,0.69757175,1,0,0,0,0 +09d45c49c4adbae4,xclick,/m/07r04,1,0.09066306,0.9201624,0.09638554,0.9518072,0,0,0,0,0 +09d45c49c4adbae4,xclick,/m/01g317,1,0.41407308,0.45737484,0.23614457,0.34698796,1,0,0,0,0 +09d45c49c4adbae4,xclick,/m/01prls,1,0.8173207,1,0.48192772,1,0,1,0,0,0 +09d45c49c4adbae4,xclick,/m/0h2r6,1,0,0.34506088,0.15421687,0.66024095,1,1,0,0,0 +09d45c49c4adbae4,xclick,/m/0h9mv,1,0.37483084,0.5277402,0.6698795,0.9518072,0,0,0,0,0 +09d45c49c4adbae4,xclick,/m/0h9mv,1,0.74695534,0.849797,0.59518075,0.80963856,1,0,0,0,0 +09d45c49c4adbae4,xclick,/m/0h9mv,1,0.83897156,0.97158325,0.7638554,1,1,1,0,0,0 +09d45c49c4adbae4,xclick,/m/083wq,1,0.37483084,0.5277402,0.6578313,0.95421684,0,0,0,0,0 +09d45c49c4adbae4,xclick,/m/083wq,1,0.74695534,0.8376184,0.5975904,0.81445783,1,0,0,0,0 +09d64f43c7111879,xclick,/m/0dzct,1,0.058035713,0.79464287,0.27192983,0.9298246,0,0,0,0,0 +09d64f43c7111879,xclick,/m/01xyhv,1,0,0.99776787,0.7719298,0.99707603,0,1,0,0,0 +09d64f43c7111879,xclick,/m/03q69,1,0,0.90848213,0.05263158,0.94152045,0,0,0,0,0 +09d64f43c7111879,xclick,/m/0k0pj,1,0.2767857,0.46205357,0.5204678,0.69298244,0,0,0,0,0 +09d64f43c7111879,xclick,/m/02p0tk3,1,0,0.99776787,0.05116959,0.99707603,0,1,0,0,0 +09d64f43c7111879,xclick,/m/04hgtk,1,0,0.91741073,0.05263158,0.9356725,0,0,0,0,0 +09d64f43c7111879,xclick,/m/014sv8,1,0.13392857,0.28794643,0.5233918,0.5628655,0,0,0,0,0 +09d64f43c7111879,xclick,/m/014sv8,1,0.4330357,0.6183036,0.50438595,0.5409357,0,0,0,0,0 +09d64f43c7111879,xclick,/m/039xj_,1,0.81473213,0.9129464,0.42251462,0.5994152,1,0,0,0,0 +09d64f43c7111879,xclick,/m/0283dt1,1,0.28348213,0.56026787,0.73391813,0.80994153,0,0,0,0,0 +09d64f43c7111879,xclick,/m/015h_t,1,0.27901787,0.625,0.83625734,0.9356725,0,0,0,0,0 +09d64f43c7111879,xclick,/m/04yx4,1,0,1,0.05263158,1,0,1,0,0,0 +09d8aa2d19ff724d,xclick,/m/0c_jw,1,0,0.99826086,0.59737825,0.99812734,1,1,0,0,0 +09d8aa2d19ff724d,xclick,/m/04hgtk,1,0.31304348,0.43130434,0.24531835,0.41011235,0,0,0,0,0 +09d8aa2d19ff724d,xclick,/m/04rky,1,0.18086956,0.6,0.2340824,0.6310862,1,0,0,0,0 +09d8aa2d19ff724d,xclick,/m/04rky,1,0.32173914,0.43826088,0.87265915,0.99812734,0,1,0,1,0 +09d8aa2d19ff724d,xclick,/m/04rky,1,0.7026087,0.8069565,0.8857678,0.99812734,0,1,0,1,0 +09d8aa2d19ff724d,xclick,/m/04rky,1,0.7547826,0.8382609,0.43820226,0.6573034,0,0,0,1,0 +09d8aa2d19ff724d,xclick,/m/04yx4,1,0.18086956,0.6017391,0.24531835,0.6310862,1,0,0,0,0 +09dcb9b52055d40f,xclick,/m/0k4j,1,0.10932945,0.74489796,0.37583894,0.95302016,0,0,0,0,0 +09dcb9b52055d40f,xclick,/m/01prls,1,0.07580175,0.12244898,0.5525727,0.57941836,0,0,0,0,0 +09dcb9b52055d40f,xclick,/m/083wq,1,0.07725947,0.08309038,0.5704698,0.57941836,0,0,0,0,0 +09dd0671cd633432,xclick,/m/05s2s,1,0,1,0.0022123894,0.84513277,0,0,1,0,0 +09dd0671cd633432,xclick,/m/01g317,1,0.072271384,0.90707964,0.06415929,0.96460176,0,0,1,0,0 +09dd0671cd633432,xclick,/m/09j2d,1,0.07079646,0.24631268,0.15707965,0.9314159,0,0,0,0,0 +09dd0671cd633432,xclick,/m/09j2d,1,0.23303835,0.4218289,0.1659292,0.8982301,0,0,0,0,0 +09dd0671cd633432,xclick,/m/09j2d,1,0.39823008,0.6061947,0.2079646,0.8783186,0,0,0,0,0 +09dd0671cd633432,xclick,/m/09j2d,1,0.5678466,0.7463127,0.29867256,0.8584071,0,0,0,0,0 +09dd0671cd633432,xclick,/m/09j2d,1,0.72861356,0.9056047,0.24115044,0.8893805,0,0,0,0,0 +09dd0671cd633432,xclick,/m/02p0tk3,1,0.072271384,0.24041298,0.061946902,0.9623894,1,0,0,0,0 +09dd0671cd633432,xclick,/m/02p0tk3,1,0.23303835,0.42035398,0.07743363,0.95132744,1,0,0,0,0 +09dd0671cd633432,xclick,/m/02p0tk3,1,0.39675516,0.60471976,0.119469024,0.9314159,1,0,0,0,0 +09dd0671cd633432,xclick,/m/02p0tk3,1,0.5678466,0.74336284,0.19690265,0.90707964,1,0,0,0,0 +09dd0671cd633432,xclick,/m/02p0tk3,1,0.71533924,0.90855455,0.13938053,0.9358407,1,0,0,0,0 +09dd0671cd633432,xclick,/m/07j7r,1,0,0.9985251,0,0.5287611,0,1,1,0,0 +09dd0671cd633432,xclick,/m/04yx4,1,0.07079646,0.24926254,0.06858407,0.9756637,1,0,0,0,0 +09dd0671cd633432,xclick,/m/04yx4,1,0.2359882,0.42477876,0.086283185,0.9557522,1,0,0,0,0 +09dd0671cd633432,xclick,/m/04yx4,1,0.39675516,0.60471976,0.123893805,0.9314159,0,0,0,0,0 +09df63bd01367ca3,xclick,/m/01bms0,1,0.14040561,0.51326054,0.44885176,0.6263048,0,0,0,0,0 +09df63bd01367ca3,xclick,/m/07k1x,1,0.4274571,0.9984399,0.0960334,0.2901879,0,1,0,0,0 +09df63bd01367ca3,xclick,/m/07k1x,1,0.5039002,0.9984399,0.38204592,0.57202506,1,1,0,0,0 +09e094375efab7fe,xclick,/m/01mzpv,1,0.565625,0.734375,0.2875,0.45833334,1,0,1,0,0 +09e094375efab7fe,xclick,/m/01mzpv,1,0.8390625,0.9984375,0.6125,0.74375,1,1,0,0,0 +09e094375efab7fe,xclick,/m/03q69,1,0.3421875,0.4,0.016666668,0.08541667,1,0,0,0,0 +09e094375efab7fe,xclick,/m/0qmmr,1,0.1609375,0.6078125,0.15833333,0.9166667,1,0,0,0,0 +09e094375efab7fe,xclick,/m/0c_jw,1,0.6578125,1,0.725,1,0,1,0,0,0 +09e094375efab7fe,xclick,/m/0c_jw,1,0.8421875,1,0.64166665,0.75,1,1,0,0,0 +09e094375efab7fe,xclick,/m/035r7c,1,0.265625,0.5875,0.40416667,0.95,1,0,0,0,0 +09e094375efab7fe,xclick,/m/035r7c,1,0.4171875,0.5453125,0.39375,0.94375,1,0,0,0,0 +09e094375efab7fe,xclick,/m/035r7c,1,0.5890625,0.8515625,0.35208333,0.77708334,1,0,0,0,0 +09e094375efab7fe,xclick,/m/035r7c,1,0.6859375,0.8546875,0.4875,0.8520833,1,0,0,0,0 +09e094375efab7fe,xclick,/m/01g317,1,0.590625,1,0,0.85,0,1,0,0,0 +09e094375efab7fe,xclick,/m/01g317,1,0.60625,0.640625,0.25833333,0.35416666,1,0,0,0,0 +09e094375efab7fe,xclick,/m/01g317,1,0.6390625,0.6796875,0.24583334,0.34166667,1,0,0,0,0 +09e094375efab7fe,xclick,/m/01g317,1,0.6984375,0.7390625,0.275,0.33541667,1,0,0,0,0 +09e094375efab7fe,xclick,/m/09j2d,1,0.19375,0.5390625,0.014583333,0.77916664,1,0,0,0,0 +09e094375efab7fe,xclick,/m/09j2d,1,0.609375,0.6390625,0.27916667,0.33958334,1,0,0,0,0 +09e094375efab7fe,xclick,/m/09j2d,1,0.6390625,0.68125,0.26666668,0.34375,1,0,0,0,0 +09e094375efab7fe,xclick,/m/09j2d,1,0.7015625,0.740625,0.275,0.34375,1,0,0,0,0 +09e094375efab7fe,xclick,/m/09j2d,1,0.7203125,0.9984375,0.072916664,0.73541665,1,1,0,0,0 +09e094375efab7fe,xclick,/m/02p0tk3,1,0.1875,0.56875,0,0.95,0,0,0,0,0 +09e094375efab7fe,xclick,/m/02p0tk3,1,0.5859375,1,0,0.8375,0,1,0,0,0 +09e094375efab7fe,xclick,/m/04rky,1,0.1953125,0.5875,0.014583333,0.9458333,1,0,0,0,0 +09e094375efab7fe,xclick,/m/04rky,1,0.59375,0.9984375,0,0.83958334,1,0,0,0,0 +09e094375efab7fe,xclick,/m/09j5n,1,0.4609375,0.5359375,0.83958334,0.9479167,1,0,0,0,0 +09e094375efab7fe,xclick,/m/09j5n,1,0.590625,0.7296875,0.68541664,0.77708334,0,0,0,0,0 +09e094375efab7fe,xclick,/m/09j5n,1,0.6890625,0.746875,0.77708334,0.85,0,1,0,0,0 +09e094375efab7fe,xclick,/m/0dzf4,1,0.1953125,0.396875,0.1625,0.36458334,0,0,0,0,0 +09e094375efab7fe,xclick,/m/0dzf4,1,0.4109375,0.5140625,0.12916666,0.34375,1,0,0,0,0 +09e094375efab7fe,xclick,/m/0dzf4,1,0.7625,0.96875,0.20416667,0.4125,1,0,0,0,0 +09e094375efab7fe,xclick,/m/0dzf4,1,0.8109375,1,0.1625,0.66875,1,1,0,0,0 +09e094375efab7fe,xclick,/m/03bt1vf,1,0.1921875,0.5859375,0.0125,0.95,1,0,0,0,0 +09e617d9d3120b32,xclick,/m/01mzpv,1,0.23946784,0.827051,0.35882354,0.99852943,1,1,0,0,0 +09e617d9d3120b32,xclick,/m/03q69,1,0.29268292,0.6518847,0.16617647,0.51911765,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/035r7c,1,0.079822615,0.3991131,0.6485294,1,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/035r7c,1,0.5609756,1,0.62647057,1,0,1,0,0,0 +09e617d9d3120b32,xclick,/m/05r655,1,0.2572062,0.72283816,0.31323528,0.7352941,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/09j2d,1,0.24168514,0.72505546,0.30294117,0.725,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/02p0tk3,1,0.07538803,1,0.16617647,1,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/04hgtk,1,0.37694013,0.52549887,0.16617647,0.28529412,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/014sv8,1,0.38137472,0.41241685,0.20588236,0.225,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/014sv8,1,0.4368071,0.4789357,0.1882353,0.20441176,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/0k65p,1,0.3924612,0.5121951,0.64411765,0.7705882,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/0k65p,1,0.4878049,0.6097561,0.62647057,0.7058824,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/0dzf4,1,0.29268292,0.50554323,0.3779412,0.7735294,1,0,0,0,0 +09e617d9d3120b32,xclick,/m/0dzf4,1,0.4789357,0.72283816,0.34264705,0.70735294,0,0,0,0,0 +09e617d9d3120b32,xclick,/m/03bt1vf,1,0.07760532,1,0.16617647,1,0,0,0,0,0 +09ea349ee555b61d,xclick,/m/0dzct,1,0.34264705,0.4617647,0.36807096,0.6474501,0,0,0,0,0 +09ea349ee555b61d,xclick,/m/0dzct,1,0.6573529,0.7470588,0.4345898,0.5898004,1,0,0,0,0 +09ea349ee555b61d,xclick,/m/02522,1,0,0.85588235,0,0.9977827,0,1,0,0,0 +09ea349ee555b61d,xclick,/m/01m2v,1,0.6073529,0.99852943,0.85365856,0.9977827,0,1,0,0,0 +09ea349ee555b61d,xclick,/m/01g317,1,0.14558823,0.80588233,0.32150775,1,0,0,1,1,0 +09ea349ee555b61d,xclick,/m/09j2d,1,0.18235295,0.5779412,0.6141907,0.9756098,1,1,0,1,0 +09ea349ee555b61d,xclick,/m/09j2d,1,0.57941175,0.67058825,0.54545456,0.84035474,1,0,0,1,0 +09ea349ee555b61d,xclick,/m/09j2d,1,0.67058825,0.69264704,0.73170733,0.789357,0,1,0,1,0 +09ea349ee555b61d,xclick,/m/09j2d,1,0.6897059,0.7235294,0.6851441,0.7849224,1,1,0,1,0 +09ea349ee555b61d,xclick,/m/09j2d,1,0.7823529,0.7985294,0.63414633,0.6984479,1,0,0,1,0 +09ea349ee555b61d,xclick,/m/04hgtk,1,0.32058823,0.475,0.32372504,0.6518847,0,0,0,1,0 +09ea349ee555b61d,xclick,/m/04hgtk,1,0.6426471,0.76029414,0.37028825,0.58314854,0,0,0,0,0 +09ea349ee555b61d,xclick,/m/04hgtk,1,0.6985294,0.71617645,0.6385809,0.6851441,0,0,0,0,0 +09ea349ee555b61d,xclick,/m/01c648,1,0,1,0,1,0,1,0,0,0 +09ea349ee555b61d,xclick,/m/0dzf4,1,0.15294118,0.34558824,0.7006652,1,0,0,0,1,0 +09ea349ee555b61d,xclick,/m/0dzf4,1,0.5029412,0.6,0.6518847,0.88913524,1,1,0,0,0 +09ea349ee555b61d,xclick,/m/0dzf4,1,0.5926471,0.7647059,0.62971175,0.8226164,1,1,0,0,0 +09ea349ee555b61d,xclick,/m/0dzf4,1,0.6720588,0.69411767,0.67184037,0.73170733,0,1,0,0,0 +09ea349ee555b61d,xclick,/m/0dzf4,1,0.6867647,0.7132353,0.70288247,0.75609756,1,0,0,0,0 +09ea349ee555b61d,xclick,/m/0dzf4,1,0.72205883,0.7867647,0.6430155,0.71175164,0,0,0,0,0 +09ea349ee555b61d,xclick,/m/04yx4,1,0.15147059,0.58235294,0.32372504,1,0,1,0,1,0 +09ea349ee555b61d,xclick,/m/04yx4,1,0.57941175,0.8117647,0.36807096,0.8470067,1,0,0,1,0 +09ebcee57699eb98,xclick,/m/014trl,1,0.0031201248,0.12480499,0.28392485,0.7494781,0,0,0,0,0 +09ebcee57699eb98,xclick,/m/014trl,1,0.63026524,0.73322934,0.24843423,0.6868476,0,0,0,1,0 +09f531fe4f6d95f3,xclick,/m/05s2s,1,0,0.996875,0.58958334,0.99791664,1,0,1,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.0421875,0.1390625,0.37708333,0.5854167,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.128125,0.2296875,0.36458334,0.5875,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.2125,0.278125,0.38125,0.55625,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.253125,0.3125,0.42291668,0.56458336,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.2796875,0.3765625,0.37083334,0.5708333,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.31875,0.375,0.34791666,0.59583336,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.3546875,0.41875,0.3875,0.5708333,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.4171875,0.515625,0.375,0.5708333,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.44375,0.478125,0.45833334,0.5875,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.49375,0.5390625,0.38958332,0.57708335,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.5390625,0.6421875,0.38333333,0.58125,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.5609375,0.690625,0.09583333,0.6125,0,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.5609375,0.5875,0.475,0.5833333,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.66875,0.68125,0.50416666,0.5833333,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.678125,0.6984375,0.48541668,0.5875,1,0,0,0,0 +09f531fe4f6d95f3,xclick,/m/01fdzj,1,0.690625,0.7171875,0.49166667,0.58125,1,0,0,0,0 +09f8b77a88f224d9,xclick,/m/0k4j,1,0.085798815,0.8816568,0.26211452,0.66519827,0,0,0,0,0 +09f8b77a88f224d9,xclick,/m/01prls,1,0.9674556,1,0.33920705,0.5396476,0,1,0,0,0 +09f8b77a88f224d9,xclick,/m/0h9mv,1,0.21745563,0.33284023,0.49779737,0.66519827,0,0,0,0,0 +09f8b77a88f224d9,xclick,/m/0h9mv,1,0.7026627,0.8076923,0.5,0.6629956,1,0,0,0,0 +09f8b77a88f224d9,xclick,/m/0d4v4,1,0.44674557,0.5325444,0,0.06387665,0,1,0,0,0 +09f8b77a88f224d9,xclick,/m/0d4v4,1,0.59319526,0.69822484,0.002202643,0.06828194,0,1,0,0,0 +09f8b77a88f224d9,xclick,/m/0d4v4,1,0.78846157,0.841716,0,0.06828194,1,1,0,0,0 +09f8b77a88f224d9,xclick,/m/083wq,1,0.21597633,0.33431953,0.5,0.6674009,0,0,0,0,0 +09f8b77a88f224d9,xclick,/m/083wq,1,0.6997042,0.8091716,0.49779737,0.6585903,1,0,0,0,0 +09f8e760f60df0da,xclick,/m/01yrx,1,0.21091445,0.56489676,0.21902655,0.6792035,1,0,0,0,0 +09f8e760f60df0da,xclick,/m/01yrx,1,0.37168142,0.8377581,0.21902655,1,0,0,0,0,0 +09fa093bcd300c1a,xclick,/m/01g317,1,0.42774567,0.50578034,0.30248308,0.3792325,1,0,0,0,0 +09fa093bcd300c1a,xclick,/m/01g317,1,0.61416185,0.63728327,0.34311512,0.40632054,1,0,0,0,0 +09fa093bcd300c1a,xclick,/m/04rky,1,0.43641618,0.49710983,0.30022573,0.3792325,1,0,0,0,0 +09fa093bcd300c1a,xclick,/m/04rky,1,0.59393066,0.63728327,0.34988713,0.4288939,1,0,0,0,0 +09fa093bcd300c1a,xclick,/m/019jd,1,0.23121387,0.90751445,0,0.69074494,1,0,0,0,0 +0a02c648d24f39fb,xclick,/m/0dzct,1,0.3888889,0.57905984,0.10534351,0.259542,0,0,0,0,0 +0a02c648d24f39fb,xclick,/m/03q69,1,0.3696581,0.6559829,0.045801528,0.25496182,0,0,0,0,0 +0a02c648d24f39fb,xclick,/m/0fly7,1,0.17521368,1,0.68854964,1,0,1,0,0,0 +0a02c648d24f39fb,xclick,/m/0k0pj,1,0.44230768,0.4957265,0.15267175,0.1908397,0,0,0,0,0 +0a02c648d24f39fb,xclick,/m/09j2d,1,0.05982906,1,0.23816794,1,0,0,0,0,0 +0a02c648d24f39fb,xclick,/m/04hgtk,1,0.36752138,0.6559829,0.047328245,0.26259542,0,0,0,0,0 +0a02c648d24f39fb,xclick,/m/014sv8,1,0.40811965,0.4636752,0.13587786,0.15877862,0,0,0,0,0 +0a02c648d24f39fb,xclick,/m/014sv8,1,0.491453,0.5405983,0.14198473,0.16183206,0,0,0,0,0 +0a02c648d24f39fb,xclick,/m/04rky,1,0.0042735045,0.99786323,0.05496183,0.9984733,1,1,0,0,0 +0a02c648d24f39fb,xclick,/m/0283dt1,1,0.42521366,0.5106838,0.19541985,0.22290076,0,0,0,0,0 +0a02c648d24f39fb,xclick,/m/0mkg,1,0.23290598,1,0.2687023,0.75114506,0,0,0,0,0 +0a02c648d24f39fb,xclick,/m/04yx4,1,0.0021367522,1,0.047328245,1,0,0,0,0,0 +0a02e8b6820064f5,xclick,/m/0k4j,1,0.06636501,0.9366516,0.2857143,0.76623374,0,0,0,0,0 +0a02e8b6820064f5,xclick,/m/04hgtk,1,0.47209653,0.4856712,0.36796537,0.3917749,1,0,0,0,0 +0a02e8b6820064f5,xclick,/m/08dz3q,1,0.57315236,0.5882353,0.4047619,0.44588745,1,0,0,0,0 +0a02e8b6820064f5,xclick,/m/083wq,1,0.13574661,0.2820513,0.5714286,0.7619048,0,0,0,0,0 +0a02e8b6820064f5,xclick,/m/083wq,1,0.71342385,0.8567119,0.54545456,0.7467533,0,0,0,0,0 +0a03326036647703,xclick,/m/0f4s2w,1,0.044313148,0.6573117,0.1942605,0.44591612,0,0,0,0,1 +0a03326036647703,xclick,/m/0f4s2w,1,0.20088626,0.96750367,0.4437086,0.7682119,0,0,0,0,1 +0a08a4711c728078,xclick,/m/05s2s,1,0,0.45060894,0.426506,0.78313255,1,0,1,0,0 +0a08a4711c728078,xclick,/m/05s2s,1,0.37077132,0.6725305,0.44096386,0.6915663,1,0,1,0,0 +0a08a4711c728078,xclick,/m/05s2s,1,0.66441137,0.8254398,0.5036145,0.70843375,0,0,0,0,0 +0a08a4711c728078,xclick,/m/05s2s,1,0.80108255,1,0.25301206,0.70843375,1,1,1,0,0 +0a08a4711c728078,xclick,/m/05s2s,1,0.9093369,1,0.46506023,0.7783133,0,1,0,0,0 +0a08a4711c728078,xclick,/m/07j7r,1,0,1,0,0.6096386,1,1,1,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0,0.023564065,0.63716817,0.88495576,0,1,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.0044182623,0.02945508,0.65707964,0.8163717,1,1,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.095729016,0.15758468,0.63053095,0.9181416,1,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.25184095,0.3107511,0.63716817,0.9314159,0,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.41678938,0.5154639,0.7787611,0.94911504,0,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.5022091,0.5640648,0.829646,0.94911504,1,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.5699558,0.6141384,0.6946903,0.95353985,1,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.6892489,0.73048604,0.6946903,0.96902657,0,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.73048604,0.7540501,0.83849555,0.9756637,0,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.7378498,0.7790869,0.7323009,0.9778761,1,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.7761414,0.79675996,0.7256637,0.8893805,1,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.86008835,0.89838,0.86283183,0.9712389,0,0,0,0,0 +0a120822d362dddf,xclick,/m/01g317,1,0.89838,0.9425626,0.8738938,0.9778761,0,0,0,0,0 +0a120822d362dddf,xclick,/m/09ct_,1,0.0353461,1,0.14823009,0.78539824,0,0,1,0,0 +0a120822d362dddf,xclick,/m/07yv9,1,0,1,0.1460177,0.92699116,0,0,1,0,0 +0a13dcaaab9a35e0,xclick,/m/0dzct,1,0.38,0.5282353,0.20498616,0.7063712,0,0,0,1,0 +0a13dcaaab9a35e0,xclick,/m/03q69,1,0.35764706,0.5411765,0.09972299,0.4570637,0,0,0,0,0 +0a13dcaaab9a35e0,xclick,/m/01g317,1,0.30588236,0.5423529,0.09695291,0.9196676,0,1,1,0,0 +0a13dcaaab9a35e0,xclick,/m/0k0pj,1,0.45764706,0.5035294,0.43213296,0.5207756,0,0,0,1,0 +0a13dcaaab9a35e0,xclick,/m/04hgtk,1,0.35058823,0.5411765,0.09418283,0.70914125,0,0,0,1,0 +0a13dcaaab9a35e0,xclick,/m/0283dt1,1,0.43529412,0.5035294,0.54293627,0.6066482,0,0,0,1,0 +0a1b11867383b13e,xclick,/m/0c9ph5,1,0.18436578,0.7418879,0,0.8938053,0,0,0,0,0 +0a1b11867383b13e,xclick,/m/07j7r,1,0,0.9985251,0,0.99557525,1,1,1,0,0 +0a1bd356f90aaab6,xclick,/m/03q69,1,0.6645833,1,0,0.2234375,0,1,0,0,0 +0a1bd356f90aaab6,xclick,/m/035r7c,1,0.0125,0.86875,0.46875,0.784375,1,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/035r7c,1,0.13125,0.65,0.3125,0.96875,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/01g317,1,0.008333334,1,0,0.96875,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/09j2d,1,0.20833333,0.825,0.0828125,0.75625,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/02p0tk3,1,0.039583333,1,0,0.9625,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/04hgtk,1,0.7291667,1,0,0.1828125,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/014sv8,1,0.8354167,0.86041665,0.053125,0.08125,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/014sv8,1,0.87708336,0.90208334,0.1046875,0.134375,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/0k65p,1,0.45,0.65208334,0.2671875,0.3609375,1,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/0283dt1,1,0.7729167,0.82916665,0.0921875,0.1640625,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/0dzf4,1,0.40208334,0.62916666,0.0578125,0.3125,0,1,0,0,0 +0a1bd356f90aaab6,xclick,/m/0dzf4,1,0.46458334,0.8666667,0.2203125,0.5015625,1,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/03nfch,1,0.010416667,0.27291667,0.5734375,0.7828125,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/03nfch,1,0.13541667,0.40625,0.7484375,0.96875,0,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/031n1,1,0.010416667,0.32291666,0.571875,0.78125,1,0,0,0,0 +0a1bd356f90aaab6,xclick,/m/031n1,1,0.13125,0.41666666,0.7015625,0.96875,1,0,0,0,0 +0a1f4761dc7fe1eb,xclick,/m/015p6,1,0.29082775,0.78970915,0.3842795,0.9796215,1,0,0,0,0 +0a1f4761dc7fe1eb,xclick,/m/07j7r,1,0,1,0,1,0,1,0,0,0 +0a23d3f0e7d850f4,xclick,/m/0284d,1,0.2796875,0.7015625,0.28333333,0.8208333,0,0,0,0,0 +0a23d3f0e7d850f4,xclick,/m/04brg2,1,0.0109375,0.9375,0,0.99791664,1,1,0,0,0 +0a23d3f0e7d850f4,xclick,/m/04brg2,1,0.440625,0.9984375,0.46666667,0.7729167,1,1,0,0,0 +0a23d3f0e7d850f4,xclick,/m/04brg2,1,0.7765625,0.9984375,0,0.225,1,1,0,0,0 +0a278d979b63fc72,xclick,/m/0k4j,1,0,0.92330384,0.17920354,0.96681416,0,1,0,0,0 +0a278d979b63fc72,xclick,/m/0k4j,1,0.8053097,0.95132744,0.36725664,0.5132743,1,0,0,0,0 +0a278d979b63fc72,xclick,/m/0k4j,1,0.920354,1,0.3761062,0.59070796,1,1,0,0,0 +0a278d979b63fc72,xclick,/m/01prls,1,0.8067847,0.94690263,0.36725664,0.44247788,1,0,0,0,0 +0a278d979b63fc72,xclick,/m/0h9mv,1,0.6563422,0.75516224,0.829646,0.9159292,1,0,0,0,0 +0a278d979b63fc72,xclick,/m/083wq,1,0.6666667,0.7477876,0.8318584,0.90707964,1,0,0,0,0 +0a2c6ef66896fb92,xclick,/m/0463sg,1,0.10279001,0.68281937,0.10421286,0.93791574,0,0,0,0,0 +0a2c6ef66896fb92,xclick,/m/0463sg,1,0.4375918,0.80469894,0.09534368,0.7427938,1,0,0,0,0 +0a2c6ef66896fb92,xclick,/m/06k2mb,1,0.09985316,0.68281937,0.101995565,0.9467849,1,0,0,0,0 +0a2c6ef66896fb92,xclick,/m/06k2mb,1,0.43612334,0.8061674,0.09756097,0.7405765,1,0,0,0,0 +0a2c6ef66896fb92,xclick,/m/01b638,1,0.09985316,0.68135095,0.10421286,0.94013304,0,0,0,0,0 +0a2c6ef66896fb92,xclick,/m/01b638,1,0.43612334,0.80469894,0.09312639,0.7427938,1,0,0,0,0 +0a34d80ee1db201e,xclick,/m/03vt0,1,0.14306785,0.63126844,0.19247788,0.83849555,0,0,0,0,0 +0a34d80ee1db201e,xclick,/m/03vt0,1,0.36135694,0.85545725,0.22345133,0.9823009,0,0,0,0,0 +0a37aa0734ac8016,xclick,/m/0k4j,1,0,1,0.1460177,0.84513277,0,1,1,0,0 +0a37aa0734ac8016,xclick,/m/01prls,1,0,0.49484536,0.14380531,0.46238938,0,1,1,0,0 +0a37aa0734ac8016,xclick,/m/01prls,1,0.22238587,0.9587629,0.14823009,0.8473451,0,0,1,0,0 +0a37aa0734ac8016,xclick,/m/01prls,1,0.9513991,1,0.19690265,0.30973452,0,1,1,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.026509574,0.08541974,0.37168142,0.40044248,0,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.48159057,0.49189985,0.19247788,0.21902655,0,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.5154639,0.52577317,0.21460177,0.22345133,0,1,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.54050076,0.5552283,0.2300885,0.24336283,0,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.5581738,0.6126657,0.32964602,0.39823008,1,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.5832106,0.59204715,0.21681416,0.24336283,0,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.6303387,0.72312224,0.57743365,0.84292036,1,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.8026509,0.8468336,0.42920354,0.5818584,1,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.8645066,0.89985275,0.3539823,0.47566372,1,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.90279824,0.9234168,0.32079646,0.40707964,1,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.93519884,0.9455081,0.2721239,0.289823,0,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.9837997,0.9911635,0.26769912,0.29646018,1,0,0,0,0 +0a37aa0734ac8016,xclick,/m/083wq,1,0.98821795,1,0.27433628,0.31637168,1,1,0,0,0 +0a37aa0734ac8016,xclick,/m/01jfm_,1,0.020618556,0.04712813,0.25442478,0.28318584,0,0,0,0,0 +0a37aa0734ac8016,xclick,/m/01jfm_,1,0.16936672,0.20618556,0.34734514,0.38716814,0,0,0,0,0 +0a37aa0734ac8016,xclick,/m/01jfm_,1,0.31222385,0.39027983,0.6017699,0.69911504,0,0,0,0,0 +0a3873442ad329c2,xclick,/m/09j2d,1,0.20353982,0.53244835,0.31637168,0.95132744,1,0,0,0,0 +0a3873442ad329c2,xclick,/m/02p0tk3,1,0.20058997,0.5825959,0.18584071,0.960177,1,0,0,0,0 +0a3873442ad329c2,xclick,/m/013y1f,1,0.45132744,1,0.35840708,1,0,1,0,0,0 +0a3873442ad329c2,xclick,/m/05r5c,1,0.45280236,1,0.35840708,1,0,0,0,0,0 +0a3873442ad329c2,xclick,/m/0bt_c3,1,0.4498525,1,0.38716814,1,0,1,0,0,0 +0a3873442ad329c2,xclick,/m/04yx4,1,0.20353982,0.5899705,0.19026549,0.96460176,1,0,0,0,0 +0a392d80c905a9df,xclick,/m/02wbm,1,0.012635379,0.900722,0.2202166,0.55595666,0,0,1,0,0 +0a392d80c905a9df,xclick,/m/02wbm,1,0.039711192,0.9909747,0.5740072,1,0,0,1,0,0 +0a392d80c905a9df,xclick,/m/02wbm,1,0.2833935,0.8790614,0.0018050541,0.23104693,0,0,1,0,0 +0a39325e5ad7f5a0,xclick,/m/0dzct,1,0.4734375,0.8546875,0.29166666,0.86875,0,0,0,0,0 +0a39325e5ad7f5a0,xclick,/m/03q69,1,0,1,0,1,0,0,0,0,0 +0a39325e5ad7f5a0,xclick,/m/0463sg,1,0.4890625,0.7375,0.58125,0.8958333,0,0,0,0,0 +0a39325e5ad7f5a0,xclick,/m/01g317,1,0,0.9734375,0,1,0,1,0,1,0 +0a39325e5ad7f5a0,xclick,/m/0k0pj,1,0.71875,0.8328125,0.45416668,0.62291664,0,0,0,1,0 +0a39325e5ad7f5a0,xclick,/m/02p0tk3,1,0,1,0,1,0,1,0,0,0 +0a39325e5ad7f5a0,xclick,/m/014sv8,1,0.621875,0.7140625,0.44375,0.5104167,1,0,0,0,0 +0a39325e5ad7f5a0,xclick,/m/014sv8,1,0.7859375,0.8375,0.4375,0.50208336,0,0,0,0,0 +0a39325e5ad7f5a0,xclick,/m/04rky,1,0,0.9546875,0,0.99791664,1,1,0,0,0 +0a39325e5ad7f5a0,xclick,/m/0283dt1,1,0.73125,0.8625,0.65833336,0.77708334,0,0,0,0,0 +0a3c01759e77a02d,xclick,/m/03q69,1,0.009375,0.996875,0,0.077083334,0,0,1,0,0 +0a3c01759e77a02d,xclick,/m/0k4j,1,0,0.0296875,0.039583333,0.110416666,1,1,0,0,0 +0a3c01759e77a02d,xclick,/m/0k4j,1,0,0.028125,0.110416666,0.18958333,0,1,0,0,0 +0a3c01759e77a02d,xclick,/m/0k4j,1,0.0859375,0.8546875,0.04375,0.7916667,0,0,0,0,0 +0a3c01759e77a02d,xclick,/m/0k4j,1,0.209375,0.7796875,0,0.10208333,1,1,1,0,0 +0a3c01759e77a02d,xclick,/m/0k4j,1,0.559375,1,0.047916666,0.46041667,1,1,0,0,0 +0a3c01759e77a02d,xclick,/m/01g317,1,0.0078125,0.9984375,0,0.18333334,0,1,1,0,0 +0a3c01759e77a02d,xclick,/m/09j2d,1,0.0140625,1,0,0.17291667,0,0,1,0,0 +0a3c01759e77a02d,xclick,/m/01prls,1,0,1,0,0.7895833,0,0,1,0,0 +0a3c01759e77a02d,xclick,/m/04rky,1,0.0078125,0.996875,0,0.17916666,1,0,1,0,0 +0a3c01759e77a02d,xclick,/m/083wq,1,0.09375,0.1234375,0.24375,0.39583334,1,0,0,0,0 +0a3c01759e77a02d,xclick,/m/083wq,1,0.23125,0.321875,0.40625,0.70208335,0,0,0,0,0 +0a3c01759e77a02d,xclick,/m/083wq,1,0.9125,1,0.28958333,0.46458334,0,0,0,0,0 +0a3c01759e77a02d,xclick,/m/04yx4,1,0.009375,0.9453125,0,0.14166667,0,1,1,0,0 +0a3f577a327ca7cc,xclick,/m/0cgh4,1,0,1,0,1,0,1,0,0,0 +0a3f577a327ca7cc,xclick,/m/0d4v4,1,0,0.99791664,0.0015625,1,0,0,1,0,0 +0a3f9b3d57ef354a,xclick,/m/0k4j,1,0.052336447,0.9364486,0.16928446,0.92670155,0,0,0,0,0 +0a3f9b3d57ef354a,xclick,/m/0k4j,1,0.72149533,1,0.19546248,0.37696335,0,0,0,0,0 +0a3f9b3d57ef354a,xclick,/m/07yv9,1,0,1,0.03141361,0.9249564,0,0,0,0,0 +0a41cda5f44baaf6,xclick,/m/0k4j,1,0,0.22566372,0,0.3960177,1,1,0,0,0 +0a41cda5f44baaf6,xclick,/m/0k4j,1,0.013274336,0.37758112,0.03318584,0.095132746,1,0,1,0,0 +0a41cda5f44baaf6,xclick,/m/0k4j,1,0.032448377,0.9734513,0.14380531,0.8716814,0,0,0,0,0 +0a41cda5f44baaf6,xclick,/m/0k4j,1,0.28466076,0.71681416,0,0.30309734,0,0,0,0,0 +0a41cda5f44baaf6,xclick,/m/0k4j,1,0.82300884,1,0.015486726,0.49336284,1,1,0,0,0 +0a41cda5f44baaf6,xclick,/m/01prls,1,0,1,0,0.8738938,0,0,1,0,0 +0a41cda5f44baaf6,xclick,/m/083wq,1,0.056047197,0.12831858,0.38053098,0.59513277,1,0,0,0,0 +0a41cda5f44baaf6,xclick,/m/083wq,1,0.2581121,0.38053098,0.5575221,0.86725664,1,0,0,0,0 +0a41cda5f44baaf6,xclick,/m/083wq,1,0.6342183,0.6946903,0.25663716,0.29867256,1,0,0,0,0 +0a41cda5f44baaf6,xclick,/m/083wq,1,0.82448375,0.859882,0.17256637,0.21681416,1,0,0,0,0 +0a47e7d602855f93,xclick,/m/0k4j,1,0,1,0.08483755,0.8935018,0,1,0,0,0 +0a47e7d602855f93,xclick,/m/0h9mv,1,0.59386283,0.7833935,0.5740072,0.8953069,0,0,0,0,0 +0a47e7d602855f93,xclick,/m/0h9mv,1,0.8880866,0.99638987,0.42238268,0.6028881,0,0,0,0,0 +0a47e7d602855f93,xclick,/m/0d4v4,1,0.6805054,0.7021661,0.06498195,0.10108303,1,0,0,0,0 +0a47e7d602855f93,xclick,/m/0d4v4,1,0.71119136,0.7400722,0.066787004,0.102888085,1,0,0,0,0 +0a47e7d602855f93,xclick,/m/0d4v4,1,0.7454874,0.77075815,0.066787004,0.1064982,1,0,0,0,0 +0a47e7d602855f93,xclick,/m/0d4v4,1,0.77797836,0.799639,0.06317689,0.1064982,1,0,0,0,0 +0a47e7d602855f93,xclick,/m/0d4v4,1,0.8194946,0.96570396,0.16245487,0.32129964,0,0,0,0,0 +0a47e7d602855f93,xclick,/m/0d4v4,1,0.92057765,0.9476534,0.0866426,0.11732852,1,0,0,0,0 +0a47e7d602855f93,xclick,/m/0d4v4,1,0.96570396,1,0.18050541,0.3032491,0,1,0,0,0 +0a47e7d602855f93,xclick,/m/07j7r,1,0.86823106,1,0.023465704,0.13537906,1,0,0,0,0 +0a4abf0a8071b917,xclick,/m/0cmf2,1,0.04733728,0.9585799,0.24229075,0.7995595,0,0,0,0,0 +0a4abf0a8071b917,xclick,/m/01g317,1,0.5192308,0.5473373,0.42731276,0.4735683,1,0,0,0,0 +0a4abf0a8071b917,xclick,/m/04rky,1,0.5192308,0.556213,0.42951542,0.47797358,1,0,0,0,0 +0a4db5693da70448,xclick,/m/03q69,1,0.49791667,0.7125,0,0.1140625,1,1,0,0,0 +0a4db5693da70448,xclick,/m/05s2s,1,0.08125,0.48541668,0.240625,0.5390625,1,0,1,0,0 +0a4db5693da70448,xclick,/m/03fp41,1,0,1,0.2,1,0,0,1,0,0 +0a4db5693da70448,xclick,/m/09j2d,1,0.23125,0.98541665,0.1140625,1,1,1,0,0,0 +0a4db5693da70448,xclick,/m/04rky,1,0.22291666,0.98541665,0,0.9984375,1,1,0,0,0 +0a4db5693da70448,xclick,/m/0dzf4,1,0.23125,0.52708334,0.0609375,0.4015625,0,0,0,0,0 +0a4db5693da70448,xclick,/m/0dzf4,1,0.68958336,0.96875,0.1578125,0.4828125,0,0,0,0,0 +0a4db5693da70448,xclick,/m/07j7r,1,0,1,0,0.6671875,1,1,0,0,0 +0a4db5693da70448,xclick,/m/07j7r,1,0.0020833334,0.18333334,0.565625,1,0,1,0,0,0 +0a4db5693da70448,xclick,/m/07j7r,1,0.0875,0.13541667,0.309375,0.4796875,1,0,0,0,0 +0a4db5693da70448,xclick,/m/07j7r,1,0.15625,1,0.2,0.925,1,1,0,0,0 +0a4db5693da70448,xclick,/m/04yx4,1,0.22916667,0.98541665,0,0.9984375,1,1,0,0,0 +0a50911d08250183,xclick,/m/03q69,1,0.72083336,0.9791667,0.2359375,0.453125,0,0,0,0,0 +0a50911d08250183,xclick,/m/01g317,1,0.93333334,1,0.4328125,0.5625,0,1,0,0,0 +0a50911d08250183,xclick,/m/09j2d,1,0.6166667,1,0.484375,1,0,1,0,0,0 +0a50911d08250183,xclick,/m/02p0tk3,1,0.32083333,1,0.234375,0.9984375,0,1,0,0,0 +0a50911d08250183,xclick,/m/02p0tk3,1,0.9375,1,0.4328125,0.5625,1,1,0,0,0 +0a50911d08250183,xclick,/m/04hgtk,1,0.6645833,0.98125,0.240625,0.4921875,0,0,0,0,0 +0a50911d08250183,xclick,/m/03jm5,1,0,0.99791664,0,0.9984375,1,1,0,0,0 +0a50911d08250183,xclick,/m/0k65p,1,0.32083333,0.46875,0.3515625,0.4421875,0,0,0,0,0 +0a50911d08250183,xclick,/m/0k65p,1,0.42083332,0.6166667,0.6734375,0.8421875,0,0,0,0,0 +0a50911d08250183,xclick,/m/04rky,1,0.3125,0.99791664,0.240625,0.9984375,1,1,0,0,0 +0a50911d08250183,xclick,/m/0283dt1,1,0.68125,0.6979167,0.4140625,0.4453125,1,0,0,0,0 +0a50911d08250183,xclick,/m/0dzf4,1,0.31458333,0.725,0.3484375,0.5796875,0,0,0,0,0 +0a50911d08250183,xclick,/m/0dzf4,1,0.425,1,0.6703125,1,0,0,0,0,0 +0a50911d08250183,xclick,/m/04yx4,1,0.31458333,0.99791664,0.234375,0.9984375,0,1,0,0,0 +0a556c8163b58fae,xclick,/m/0c_jw,1,0.0125,0.4703125,0.4125,0.6875,0,0,0,0,0 +0a556c8163b58fae,xclick,/m/0cgh4,1,0,1,0,1,0,0,0,0,1 +0a556c8163b58fae,xclick,/m/04bcr3,1,0.953125,0.9984375,0.56041664,0.60833335,1,1,0,0,0 +0a556c8163b58fae,xclick,/m/0d4v4,1,0.0078125,0.4078125,0.11875,0.45208332,0,0,0,0,0 +0a563d05ebab4fe3,xclick,/m/05s2s,1,0,1,0,1,0,0,1,0,0 +0a563d05ebab4fe3,xclick,/m/01yrx,1,0.415625,1,0.21041666,0.76666665,0,0,0,0,0 +0a5972c68b6bb265,xclick,/m/01g317,1,0.29228687,0.36806494,0.57349396,0.84819275,1,0,0,0,0 +0a5972c68b6bb265,xclick,/m/01g317,1,0.37483084,0.43301758,0.5518072,0.8385542,1,0,0,0,0 +0a5972c68b6bb265,xclick,/m/01g317,1,0.4939107,0.5277402,0.5975904,0.84819275,1,0,0,0,0 +0a5972c68b6bb265,xclick,/m/01g317,1,0.5805142,0.65629226,0.5710843,0.853012,1,0,0,0,0 +0a5972c68b6bb265,xclick,/m/01g317,1,0.699594,0.7388363,0.57831323,0.8457831,1,0,0,0,0 +0a599940d33b6b2b,xclick,/m/0c9ph5,1,0.196468,0.89183223,0.062038403,0.9527326,0,0,0,0,0 +0a599940d33b6b2b,xclick,/m/0c9ph5,1,0.5629139,0.9602649,0.15214181,0.2791728,0,0,0,0,0 +0a600f1148d1023c,xclick,/m/0c9ph5,1,0.08681672,0.1221865,0.29817444,0.326572,0,0,0,0,0 +0a600f1148d1023c,xclick,/m/07j7r,1,0,1,0,1,0,0,1,0,0 +0a6a03c8f23ee744,xclick,/m/01g317,1,0.04992658,0.5198238,0.3503326,0.8980044,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/01g317,1,0.7048458,0.99412626,0.28603104,0.85809314,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/083kb,1,0.47723934,0.7283407,0.28159645,0.48337027,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/083kb,1,0.6020558,0.7283407,0.031042129,0.383592,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/09j2d,1,0.086637296,0.49779737,0.41685143,0.8780488,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/09j2d,1,0.7107195,0.9809104,0.31929046,0.80266076,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/02p0tk3,1,0.04992658,0.5227606,0.3503326,0.9002217,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/02p0tk3,1,0.7048458,0.99412626,0.28603104,0.85809314,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.04845815,0.105726875,0.8470067,0.9002217,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.29809105,0.37151247,0.345898,0.46119735,1,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.30983847,0.36857563,0.35254988,0.45454547,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.40234947,0.4684288,0.827051,0.8780488,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.5095448,0.72246695,0.28603104,0.48337027,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.6079295,0.72393537,0.05321508,0.383592,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.74596184,0.8120411,0.28603104,0.40133038,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.7753304,0.83994126,0.7716186,0.85365856,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.88105726,0.9985316,0.49667406,0.6696231,0,0,0,0,0 +0a6a03c8f23ee744,xclick,/m/05y5lj,1,0.9676946,0.99265784,0.7849224,0.849224,0,0,0,0,0 +0a6bc386b28f2aac,xclick,/m/01mzpv,1,0.282,0.41,0.40533334,0.632,1,0,0,0,0 +0a6bc386b28f2aac,xclick,/m/0c_jw,1,0.184,0.998,0.49866667,1,0,0,0,0,0 +0a6bc386b28f2aac,xclick,/m/02z51p,1,0.422,0.538,0.53333336,0.59466666,1,0,0,0,0 +0a6bc386b28f2aac,xclick,/m/03jm5,1,0,0.998,0,0.99733335,1,1,0,0,1 +0a6bc386b28f2aac,xclick,/m/04bcr3,1,0.036,0.284,0.528,0.6906667,0,0,0,0,0 +0a6bc386b28f2aac,xclick,/m/03ssj5,1,0.182,0.716,0.536,0.928,0,0,0,0,0 +0a6bc386b28f2aac,xclick,/m/03ssj5,1,0.376,0.99,0.59466666,1,0,0,0,0,0 +0a7074a2a5515531,xclick,/m/01g317,1,0.4078125,0.625,0.18541667,0.7875,0,0,0,1,0 +0a7074a2a5515531,xclick,/m/09j2d,1,0.3875,0.759375,0.35833332,0.8375,1,0,0,1,0 +0a7074a2a5515531,xclick,/m/04hgtk,1,0.49375,0.5796875,0.24166666,0.35208333,0,0,0,0,0 +0a7074a2a5515531,xclick,/m/04rky,1,0.3875,0.6734375,0.1875,0.78333336,1,0,0,1,0 +0a7074a2a5515531,xclick,/m/06msq,1,0.334375,0.7640625,0.1875,0.84583336,1,0,0,0,0 +0a72fef43a51c479,xclick,/m/0gd2v,1,0,1,0.0072202166,0.78880864,0,1,1,0,0 +0a72fef43a51c479,xclick,/m/0by6g,1,0,0.70397115,0.11732852,0.64440435,0,1,0,0,0 +0a72fef43a51c479,xclick,/m/0by6g,1,0.092057765,0.2599278,0.0054151625,0.13537906,0,1,0,0,0 +0a72fef43a51c479,xclick,/m/0by6g,1,0.25812274,0.6805054,0.59386283,0.7833935,0,0,0,0,0 +0a72fef43a51c479,xclick,/m/0by6g,1,0.33574006,0.99819493,0.13718411,0.37184116,0,1,0,0,0 +0a72fef43a51c479,xclick,/m/0by6g,1,0.80144405,0.99819493,0.3736462,0.54873645,0,1,0,0,0 +0a72fef43a51c479,xclick,/m/02hj4,1,0.0018050541,0.70577615,0.11732852,0.64440435,0,1,0,0,0 +0a72fef43a51c479,xclick,/m/02hj4,1,0.08483755,1,0,0.2202166,1,1,0,0,0 +0a72fef43a51c479,xclick,/m/02hj4,1,0.25451264,0.67509025,0.5956679,0.7978339,0,0,0,0,0 +0a72fef43a51c479,xclick,/m/02hj4,1,0.3393502,1,0.13537906,0.3772563,0,0,0,0,0 +0a72fef43a51c479,xclick,/m/02hj4,1,0.7906137,1,0.37545127,0.55595666,0,1,0,0,0 +0a73064c82730ff5,xclick,/m/02wbm,1,0.25625,0.8625,0.0125,0.76666665,0,0,0,0,0 +0a73064c82730ff5,xclick,/m/0cgh4,1,0,0.9984375,0,0.99791664,0,1,0,0,1 +0a73064c82730ff5,xclick,/m/01g317,1,0,0.5140625,0.3,1,0,1,0,0,0 +0a73064c82730ff5,xclick,/m/09j2d,1,0,0.371875,0.51666665,0.99791664,0,1,0,0,0 +0a73064c82730ff5,xclick,/m/02p0tk3,1,0,0.5125,0.30208334,1,0,1,0,0,0 +0a73064c82730ff5,xclick,/m/0k65p,1,0.45,0.5140625,0.82708335,0.92291665,0,0,0,0,0 +0a73064c82730ff5,xclick,/m/04rky,1,0,0.5140625,0.30625,0.99791664,0,1,0,0,0 +0a78374f2d3949ae,xclick,/m/052lwg6,1,0.055646483,0.3747954,0.187251,0.5557769,1,0,0,0,0 +0a78374f2d3949ae,xclick,/m/052lwg6,1,0.15711948,0.5581015,0.40239045,0.8306773,0,0,0,0,0 +0a78374f2d3949ae,xclick,/m/052lwg6,1,0.36988544,0.700491,0.119521916,0.49402392,1,0,0,0,0 +0a78374f2d3949ae,xclick,/m/052lwg6,1,0.5450082,0.9230769,0.32868525,0.7768924,0,0,0,0,0 +0a78374f2d3949ae,xclick,/m/0cdn1,1,0.058919802,0.37315875,0.18924303,0.55378485,1,0,0,0,0 +0a78374f2d3949ae,xclick,/m/0cdn1,1,0.14729951,0.5581015,0.41035858,0.8386454,0,0,0,0,0 +0a78374f2d3949ae,xclick,/m/0cdn1,1,0.36988544,0.705401,0.12948208,0.47808766,1,0,0,0,0 +0a78374f2d3949ae,xclick,/m/0cdn1,1,0.5531915,0.9230769,0.32868525,0.77091634,0,0,0,0,0 +0a7be0b883a12966,xclick,/m/0k4j,1,0,0.41948578,0,0.19036144,0,1,0,0,0 +0a7be0b883a12966,xclick,/m/0k4j,1,0.01894452,1,0.106024094,0.98313254,0,0,0,0,0 +0a7be0b883a12966,xclick,/m/0k4j,1,0.38430312,0.47496617,0,0.072289154,0,1,0,0,0 +0a7be0b883a12966,xclick,/m/083wq,1,0,0.07848444,0,0.10120482,1,0,0,0,0 +0a7be0b883a12966,xclick,/m/083wq,1,0.29228687,0.3585927,0.0939759,0.18554217,1,0,0,0,0 +0a7be0b883a12966,xclick,/m/083wq,1,0.3991881,0.41542625,0.01686747,0.040963855,0,0,0,0,0 +0a7be0b883a12966,xclick,/m/083wq,1,0.44790256,0.46414074,0.045783132,0.06746988,1,0,0,0,0 +0a7be0b883a12966,xclick,/m/083wq,1,0.4668471,0.58457375,0.67228913,0.97831327,1,0,0,0,0 +0a7be0b883a12966,xclick,/m/083wq,1,0.84167796,0.9039242,0.6313253,0.74698794,1,0,0,0,0 +0a7c597abf1e90d4,xclick,/m/01mzpv,1,0,0.35625,0.44583333,0.99791664,0,1,0,0,0 +0a7c597abf1e90d4,xclick,/m/01mzpv,1,0.378125,0.771875,0.45208332,0.99791664,1,1,0,0,0 +0a7c597abf1e90d4,xclick,/m/05s2s,1,0.2234375,0.44375,0.31041667,0.49166667,0,0,0,0,0 +0a7c597abf1e90d4,xclick,/m/07j7r,1,0,0.5375,0,0.45,1,1,0,0,0 +0a7c597abf1e90d4,xclick,/m/07j7r,1,0.4984375,0.9984375,0,0.38125,1,1,0,0,0 +0a7c597abf1e90d4,xclick,/m/07j7r,1,0.71875,0.9984375,0.3875,0.93125,1,1,0,0,0 +0a7d56b2fb989fe8,xclick,/m/01g317,1,0.4734375,0.615625,0.25416666,0.56041664,0,0,0,0,0 +0a7d56b2fb989fe8,xclick,/m/09j2d,1,0.5,0.5765625,0.29375,0.5229167,1,0,0,0,0 +0a7d56b2fb989fe8,xclick,/m/02p0tk3,1,0.471875,0.615625,0.25416666,0.55833334,0,0,0,1,0 +0a7d56b2fb989fe8,xclick,/m/04hgtk,1,0.471875,0.509375,0.25416666,0.32291666,0,0,0,0,0 +0a7f13330a5d0023,xclick,/m/0k4j,1,0,1,0.17870036,0.8104693,0,0,1,0,0 +0a7f13330a5d0023,xclick,/m/01g317,1,0.6137184,0.87725633,0.15703972,0.90613717,0,0,0,0,0 +0a7f13330a5d0023,xclick,/m/0h9mv,1,0.62815887,0.732852,0.6191336,0.78519857,1,0,0,0,0 +0a7f13330a5d0023,xclick,/m/0h9mv,1,0.84476537,0.89169675,0.42238268,0.56498194,1,0,0,0,0 +0a7f13330a5d0023,xclick,/m/0d4v4,1,0.23646209,0.2761733,0.037906136,0.08122744,1,0,0,0,0 +0a7f13330a5d0023,xclick,/m/083wq,1,0.62274367,0.73465705,0.62454873,0.79422385,1,0,0,0,0 +0a7f13330a5d0023,xclick,/m/083wq,1,0.8574007,0.8953069,0.42057762,0.55595666,0,0,0,0,0 +0a7f13330a5d0023,xclick,/m/01jfm_,1,0.8935018,0.92779785,0.2870036,0.3068592,0,0,0,0,0 +0a7f4d9a0ccb9afe,xclick,/m/0bjyj5,1,0.1515625,0.421875,0.22916667,0.70416665,1,0,0,0,0 +0a7f4d9a0ccb9afe,xclick,/m/0bjyj5,1,0.565625,0.8265625,0.2125,0.6979167,1,0,0,0,0 +0a7f4d9a0ccb9afe,xclick,/m/07j7r,1,0.4828125,0.7265625,0.110416666,0.40625,1,0,0,0,0 +0a7f4d9a0ccb9afe,xclick,/m/07j7r,1,0.5578125,0.9984375,0,0.21875,1,1,0,0,0 +0a7fbc1d68e4e5ae,xclick,/m/0k4j,1,0.0947226,0.8755074,0.06746988,0.92771083,0,0,0,0,0 +0a7fbc1d68e4e5ae,xclick,/m/0k4j,1,0.13667117,0.202977,0.01686747,0.12048193,1,0,0,1,0 +0a7fbc1d68e4e5ae,xclick,/m/0k4j,1,0.42083898,0.45737484,0,0.045783132,1,0,0,1,0 +0a7fbc1d68e4e5ae,xclick,/m/0k4j,1,0.4451962,0.47767252,0,0.040963855,1,0,0,1,0 +0a7fbc1d68e4e5ae,xclick,/m/0k4j,1,0.8430311,1,0.13493976,0.33493975,1,1,0,0,0 +0a7fbc1d68e4e5ae,xclick,/m/0k4j,1,0.864682,1,0.2433735,0.50843376,1,1,0,0,0 +0a7fbc1d68e4e5ae,xclick,/m/083wq,1,0.4668471,0.6008119,0.5710843,0.90361446,0,0,0,0,0 +0a7fbc1d68e4e5ae,xclick,/m/083wq,1,0.7916103,0.8633288,0.42168674,0.63373494,0,0,0,0,0 +0a7fbc1d68e4e5ae,xclick,/m/083wq,1,0.8930988,0.97023004,0.3759036,0.5036145,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/03jm5,1,0.06197655,0.93467337,0.074074075,0.9649123,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.11725293,0.8358459,0.56530213,0.9298246,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.11725293,0.2562814,0.76413256,0.9259259,1,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.16582915,0.26130652,0.582846,0.69590646,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.18927974,0.24288107,0.4269006,0.53216374,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.3400335,0.39363486,0.57894737,0.69005847,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.3400335,0.3919598,0.7738792,0.9278752,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.49078727,0.6515913,0.56725144,0.69005847,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.49078727,0.6532663,0.76413256,0.9298246,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.5410385,0.59463984,0.4093567,0.5126706,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.7403685,0.8726968,0.37037036,0.49317738,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.74539363,0.8559464,0.3957115,0.49317738,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.7470687,0.8743719,0.7465887,0.9220273,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/0d4v4,1,0.7788945,0.8291457,0.57894737,0.69590646,0,0,0,0,0 +0a7ffd65766a4741,xclick,/m/07j7r,1,0.9480737,0.99832493,0.65497077,0.9590643,0,1,0,0,0 +0a82f0443c940816,xclick,/m/02wbm,1,0.076696165,1,0,0.82522124,0,1,0,0,0 +0a82f0443c940816,xclick,/m/01g317,1,0.8303835,0.9985251,0,0.19026549,1,1,0,0,0 +0a8657e8b5c9d7bb,xclick,/m/0dzct,1,0.38053098,0.49705014,0.1460177,0.34513274,0,0,0,0,0 +0a8657e8b5c9d7bb,xclick,/m/03q69,1,0.15044248,0.16371681,0.670354,0.6924779,0,0,0,0,0 +0a8657e8b5c9d7bb,xclick,/m/03q69,1,0.37758112,0.5117994,0.13938053,0.22787611,0,1,0,1,0 +0a8657e8b5c9d7bb,xclick,/m/0jyfg,1,0.3761062,0.5,0.16150442,0.27654868,0,0,0,1,0 +0a8657e8b5c9d7bb,xclick,/m/017ftj,1,0.37758112,0.5,0.16150442,0.2721239,0,0,0,0,0 +0a8657e8b5c9d7bb,xclick,/m/0k0pj,1,0.41887906,0.44837758,0.23672566,0.2920354,0,0,0,1,0 +0a8657e8b5c9d7bb,xclick,/m/02p0tk3,1,0.120943956,0.6106195,0.13716814,0.76106197,0,0,0,1,0 +0a8657e8b5c9d7bb,xclick,/m/04hgtk,1,0.36873156,0.5162242,0.13938053,0.35176992,0,0,0,1,0 +0a8657e8b5c9d7bb,xclick,/m/0k65p,1,0.1519174,0.28023598,0.36946902,0.6084071,0,0,0,1,0 +0a8657e8b5c9d7bb,xclick,/m/0k65p,1,0.46755162,0.6106195,0.53539824,0.7234513,1,1,0,1,0 +0a8657e8b5c9d7bb,xclick,/m/0283dt1,1,0.40560472,0.44690266,0.29646018,0.31858408,0,0,0,1,0 +0a877314ca2039d9,xclick,/m/01d40f,1,0.4692082,0.9354839,0.4318182,0.99545455,0,1,0,0,0 +0a877314ca2039d9,xclick,/m/03q69,1,0.55131966,0.8914956,0,0.7590909,0,1,0,0,0 +0a877314ca2039d9,xclick,/m/0463sg,1,0.53958946,0.60117304,0.35454544,0.55,1,0,0,0,0 +0a877314ca2039d9,xclick,/m/0463sg,1,0.78299123,0.8504399,0.37272727,0.5681818,1,0,0,0,0 +0a877314ca2039d9,xclick,/m/05r655,1,0.4398827,1,0,1,0,1,0,0,0 +0a877314ca2039d9,xclick,/m/0k0pj,1,0.6451613,0.7096774,0.32272726,0.45454547,0,0,0,0,0 +0a877314ca2039d9,xclick,/m/02p0tk3,1,0.4340176,1,0,1,0,1,0,0,0 +0a877314ca2039d9,xclick,/m/04hgtk,1,0.542522,0.856305,0,0.6045455,0,0,0,0,0 +0a877314ca2039d9,xclick,/m/014sv8,1,0.5894428,0.6568915,0.29090908,0.35454544,0,0,0,0,0 +0a877314ca2039d9,xclick,/m/014sv8,1,0.7038123,0.78299123,0.3,0.36363637,0,0,0,0,0 +0a877314ca2039d9,xclick,/m/039xj_,1,0.54545456,0.56891495,0.18636364,0.31363636,0,0,0,0,0 +0a877314ca2039d9,xclick,/m/039xj_,1,0.80938417,0.85337245,0.2090909,0.3909091,0,0,0,0,0 +0a877314ca2039d9,xclick,/m/0283dt1,1,0.6363636,0.72140765,0.48181817,0.5318182,0,0,0,0,0 +0a877314ca2039d9,xclick,/m/0dzf4,1,0.4222874,0.55718476,0.48636365,1,0,1,0,0,0 +0a877314ca2039d9,xclick,/m/0dzf4,1,0.83870965,1,0.55,1,0,1,0,0,0 +0a877314ca2039d9,xclick,/m/03bt1vf,1,0.44281524,1,0,1,0,1,0,0,0 +0a917bbca24cf75d,xclick,/m/02wbm,1,0.018050542,0.98194945,0.018050542,0.98194945,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.08303249,0.1101083,0.52527076,0.5505415,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.092057765,0.12815884,0.32129964,0.34837544,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.09386282,0.12815884,0.4963899,0.5361011,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.18953069,0.23826715,0.3501805,0.37906137,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.25631768,0.27797833,0.47833934,0.51263535,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.2635379,0.32129964,0.42057762,0.44223827,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.29422382,0.32851985,0.1696751,0.20397112,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.31949458,0.7454874,0.08483755,0.63898915,1,0,1,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.44765344,0.4765343,0.7599278,0.8267148,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.5830325,0.599278,0.057761732,0.08844765,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.62274367,0.66064984,0.7527076,0.78880864,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.68231046,0.7238267,0.7833935,0.8375451,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.6859206,0.72202164,0.48375452,0.53429604,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.7075812,0.84115523,0.58844763,0.6768953,1,0,1,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.71299636,0.7599278,0.78519857,0.8303249,1,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.732852,0.767148,0.3736462,0.4097473,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.7978339,0.84837544,0.70397115,0.77978337,1,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.83212996,0.86281586,0.7617329,0.8032491,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.8429603,0.9025271,0.37184116,0.41877255,0,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.87545127,0.8935018,0.45306858,0.4765343,1,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.88447654,0.9169675,0.49097472,0.5,1,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0f4s2w,1,0.900722,0.92057765,0.5379061,0.566787,1,0,0,0,0 +0a917bbca24cf75d,xclick,/m/0grw1,1,0.07400722,0.9801444,0.054151624,0.85559565,0,0,0,0,0 +0a94296ff543a1dc,xclick,/m/0k4j,1,0,1,0,1,0,0,0,0,1 +0a94296ff543a1dc,xclick,/m/08dz3q,1,0,1,0,1,0,0,0,0,0 +0a9f183e46c76019,xclick,/m/0dzct,1,0.3734375,0.6296875,0.28541666,0.7416667,0,0,0,0,0 +0a9f183e46c76019,xclick,/m/03q69,1,0.3015625,0.79375,0.035416666,1,0,1,0,0,0 +0a9f183e46c76019,xclick,/m/0463sg,1,0.45625,0.6734375,0.8229167,0.99791664,1,1,0,0,0 +0a9f183e46c76019,xclick,/m/05r655,1,0.0453125,1,0.06875,1,0,1,0,0,0 +0a9f183e46c76019,xclick,/m/0k0pj,1,0.4,0.4671875,0.44166666,0.5729167,0,0,0,0,0 +0a9f183e46c76019,xclick,/m/09j2d,1,0.6296875,0.83125,0.7625,0.99791664,1,1,0,0,0 +0a9f183e46c76019,xclick,/m/02p0tk3,1,0.046875,1,0.052083332,1,0,1,0,0,0 +0a9f183e46c76019,xclick,/m/04hgtk,1,0.303125,0.80625,0.05,0.7416667,0,0,0,0,0 +0a9f183e46c76019,xclick,/m/014sv8,1,0.365625,0.4234375,0.42916667,0.48333332,0,0,0,0,0 +0a9f183e46c76019,xclick,/m/014sv8,1,0.471875,0.546875,0.41875,0.475,0,0,0,0,0 +0a9f183e46c76019,xclick,/m/0283dt1,1,0.4109375,0.5,0.59583336,0.6791667,0,0,0,0,0 +0a9f183e46c76019,xclick,/m/0dzf4,1,0.046875,0.3109375,0.725,1,0,1,0,0,0 +0a9f183e46c76019,xclick,/m/0dzf4,1,0.7953125,1,0.76458335,1,0,1,0,0,0 +0a9f183e46c76019,xclick,/m/03bt1vf,1,0.046875,1,0.052083332,1,0,1,0,0,0 +0a9f73b3c2557150,xclick,/m/01yx86,1,0,0.70208335,0,0.9984375,0,1,0,0,0 +0a9f73b3c2557150,xclick,/m/06msq,1,0.4125,1,0.09375,0.615625,1,0,0,0,0 +0a9ff75a7897e757,xclick,/m/01ww8y,1,0.3515625,0.5515625,0.57916665,0.78125,1,0,0,0,0 +0a9ff75a7897e757,xclick,/m/01ww8y,1,0.3578125,0.5453125,0.42083332,0.61875,1,0,0,0,0 +0a9ff75a7897e757,xclick,/m/01ww8y,1,0.4828125,0.6296875,0.325,0.5229167,1,0,0,0,0 +0a9ff75a7897e757,xclick,/m/01ww8y,1,0.509375,0.73125,0.7,0.83125,1,0,0,0,0 +0a9ff75a7897e757,xclick,/m/01ww8y,1,0.5609375,0.765625,0.48541668,0.7125,1,0,0,0,0 +0a9ff75a7897e757,xclick,/m/01ww8y,1,0.6703125,0.8453125,0.33333334,0.54375,1,0,0,0,0 +0a9ff75a7897e757,xclick,/m/01ww8y,1,0.7171875,0.9671875,0.6625,0.83125,1,0,0,0,0 +0a9ff75a7897e757,xclick,/m/01ww8y,1,0.7890625,0.9859375,0.48125,0.70625,1,0,0,0,0 +0a9ff75a7897e757,xclick,/m/0271t,1,0.0265625,0.25,0.44583333,0.59166664,0,0,0,0,0 +0a9ff75a7897e757,xclick,/m/07clx,1,0.0015625,0.3453125,0.29375,0.66875,0,0,0,0,0 +0aa206fa7ea80036,xclick,/m/07j7r,1,0.019125683,0.11065574,0.7947494,0.8353222,0,0,1,0,0 +0aa206fa7ea80036,xclick,/m/07j7r,1,0.11065574,0.21994536,0.7732697,0.8281623,0,0,1,0,0 +0aa206fa7ea80036,xclick,/m/07j7r,1,0.22404371,0.28961748,0.7040573,0.83054894,0,0,1,0,0 +0aa206fa7ea80036,xclick,/m/07j7r,1,0.3852459,0.53688526,0.6300716,0.8162291,0,0,1,0,0 +0aa206fa7ea80036,xclick,/m/07j7r,1,0.534153,0.62568307,0.59188545,0.7899761,1,0,0,0,0 +0aa206fa7ea80036,xclick,/m/07j7r,1,0.61885244,0.6953552,0.58472556,0.8019093,1,0,0,0,0 +0aa206fa7ea80036,xclick,/m/07j7r,1,0.67349726,1,0.60143197,0.7875895,0,0,1,0,0 +0aa3a6c33fca122b,xclick,/m/01n5jq,1,0,0.99638987,0,0.99819493,0,0,0,0,0 +0aa3a6c33fca122b,xclick,/m/01g317,1,0.23646209,0.9187726,0.3393502,1,0,0,0,1,0 +0aa3a6c33fca122b,xclick,/m/09j2d,1,0.29602888,0.8574007,0.3393502,1,1,1,0,1,0 +0aaad833ac61ac9d,xclick,/m/05s2s,1,0,0.1472754,0.518847,0.8780488,1,1,1,0,0 +0aaad833ac61ac9d,xclick,/m/05s2s,1,0.101620026,0.41237113,0.0022172949,0.4878049,1,0,1,0,0 +0aaad833ac61ac9d,xclick,/m/05s2s,1,0.8173785,0.9926362,0,0.68292683,1,1,1,0,0 +0aaad833ac61ac9d,xclick,/m/052sf,1,0.0736377,0.3431517,0.44345897,0.7649667,0,0,1,0,0 +0aaad833ac61ac9d,xclick,/m/052sf,1,0.35051546,0.91163474,0.40798226,0.84257203,0,0,1,0,0 +0aaad833ac61ac9d,xclick,/m/07j7r,1,0,1,0,0.6962306,0,1,0,0,0 +0aacbdb54e853a0a,xclick,/m/0k4j,1,0,0.11875,0.2375,0.37083334,1,1,0,0,0 +0aacbdb54e853a0a,xclick,/m/0k4j,1,0.0578125,0.1171875,0.28541666,0.41875,1,0,0,0,0 +0aacbdb54e853a0a,xclick,/m/0k4j,1,0.096875,0.95625,0.15416667,0.95,0,0,0,0,0 +0aacbdb54e853a0a,xclick,/m/01g317,1,0.0015625,1,0.19166666,0.41666666,1,0,1,0,0 +0aacbdb54e853a0a,xclick,/m/01prls,1,0.046875,0.1125,0.28125,0.41041666,1,0,0,0,0 +0aacbdb54e853a0a,xclick,/m/0h9mv,1,0.1,0.2046875,0.43333334,0.6458333,0,0,0,0,0 +0aacbdb54e853a0a,xclick,/m/0h9mv,1,0.35,0.58125,0.56666666,0.9479167,0,0,0,0,0 +0aacbdb54e853a0a,xclick,/m/0h9mv,1,0.78125,0.90625,0.68958336,0.7708333,0,0,0,0,0 +0aacbdb54e853a0a,xclick,/m/083wq,1,0.1,0.2046875,0.43333334,0.6479167,0,0,0,0,0 +0aacbdb54e853a0a,xclick,/m/083wq,1,0.35,0.58125,0.56666666,0.9458333,0,0,0,0,0 +0aacbdb54e853a0a,xclick,/m/083wq,1,0.5234375,0.5921875,0.28541666,0.31666666,1,0,0,0,0 +0aacbdb54e853a0a,xclick,/m/083wq,1,0.7859375,0.9015625,0.68958336,0.76666665,1,0,0,0,0 +0aad9fc79a35bd53,xclick,/m/0k4j,1,0.07060334,0.9268293,0.17258883,0.83502537,0,0,0,0,0 +0aad9fc79a35bd53,xclick,/m/083wq,1,0.14249037,0.29268292,0.5786802,0.84010154,0,0,0,0,0 +0aad9fc79a35bd53,xclick,/m/083wq,1,0.70731705,0.84852374,0.5329949,0.8096447,0,0,0,0,0 +0aae34863935e33a,xclick,/m/05s2s,1,0,1,0,1,0,0,1,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.03539823,0.11504425,0.19247788,0.32079646,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.16961652,0.27286136,0.1039823,0.3318584,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.35840708,0.44247788,0.22123894,0.3761062,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.41445428,0.58112097,0.4380531,0.7079646,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.5014749,0.6460177,0.048672568,0.28318584,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.5147493,0.59882003,0.42256638,0.5707965,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.5516224,0.60324484,0.29646018,0.38938054,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.5973451,0.6342183,0.43141592,0.47123894,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.7743363,0.81120944,0.17035398,0.25,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.8466077,0.87905604,0.18362832,0.25,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.8480826,0.899705,0.090707965,0.19469027,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.85103244,0.8982301,0.21681416,0.28539824,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.89528024,0.9734513,0.26769912,0.38274336,0,0,0,0,0 +0aae34863935e33a,xclick,/m/0c9ph5,1,0.98082596,1,0.5221239,0.5862832,0,1,0,0,0 +0ab050b51e78acdb,xclick,/m/07fbm7,1,0.16144201,0.70376176,0.10602911,0.7567568,0,0,1,0,0 +0ab050b51e78acdb,xclick,/m/0284d,1,0.15360501,0.70846397,0.06652807,0.93970895,0,0,0,0,0 +0ab050b51e78acdb,xclick,/m/01ww8y,1,0.17554858,0.70062697,0.1018711,0.7546778,1,0,0,0,0 +0ab050b51e78acdb,xclick,/m/0270h,1,0.15360501,0.70689654,0.064449064,0.93970895,0,0,0,0,0 +0ab10a6417ef2301,xclick,/m/02zt3,1,0.065625,0.1,0.5520833,0.57916665,0,0,0,0,0 +0ab10a6417ef2301,xclick,/m/02zt3,1,0.3125,0.3546875,0.4125,0.44375,0,0,0,0,0 +0ab10a6417ef2301,xclick,/m/02zt3,1,0.421875,1,0.28333333,0.5729167,0,0,0,0,0 +0ab10a6417ef2301,xclick,/m/02zt3,1,0.6375,0.75,0.29375,0.37083334,0,0,0,0,0 +0ab10a6417ef2301,xclick,/m/01g317,1,0.403125,0.571875,0.46875,0.7291667,1,0,0,1,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.0375,0.05,0.71666664,0.76458335,0,0,0,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.0609375,0.078125,0.72291666,0.7604167,0,0,0,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.128125,0.14375,0.71458334,0.775,0,0,0,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.20625,0.2234375,0.71875,0.7583333,1,0,0,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.2359375,0.25625,0.71458334,0.7604167,0,0,0,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.2546875,0.2734375,0.71458334,0.7583333,1,0,0,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.284375,0.721875,0.71875,0.775,1,0,1,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.40625,0.575,0.46458334,0.72083336,1,0,1,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.76875,0.8546875,0.71875,0.76666665,1,0,1,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.796875,0.8203125,0.72083336,0.78333336,1,0,0,0,0 +0ab10a6417ef2301,xclick,/m/04rky,1,0.9265625,0.9796875,0.72291666,0.76666665,1,0,1,0,0 +0ab10a6417ef2301,xclick,/m/04yx4,1,0,0.98125,0.71666664,0.79791665,0,0,1,0,0 +0ab2b64f27f8baca,xclick,/m/01g317,1,0.084684685,0.9279279,0.02173913,0.7862319,0,0,0,0,0 +0ab2b64f27f8baca,xclick,/m/02p0tk3,1,0.084684685,0.9279279,0.019927537,0.7826087,0,0,0,1,0 +0ab2b64f27f8baca,xclick,/m/0138tl,1,0.08108108,0.93153155,0.02173913,0.7880435,0,0,0,1,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.052083332,0.25625,0.4640625,0.5390625,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.052083332,0.26041666,0.5890625,0.646875,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.16041666,0.45833334,0.1546875,0.2109375,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.20416667,0.46666667,0.8125,0.9203125,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.31666666,0.5375,0.396875,0.4578125,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.38125,0.65625,0.71875,0.784375,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.59375,0.81666666,0.2875,0.371875,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.64166665,0.8833333,0.196875,0.2546875,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.6625,0.89375,0.75625,0.83125,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.6666667,0.92291665,0.628125,0.696875,0,0,0,0,0 +0ab5c690eebfad95,xclick,/m/01ww8y,1,0.68541664,0.94166666,0.7203125,0.76875,0,0,0,0,0 +0ac166d12e401a98,xclick,/m/03q69,1,0.221875,0.2859375,0.73333335,0.77916664,1,0,0,0,0 +0ac166d12e401a98,xclick,/m/03q69,1,0.3765625,0.409375,0.7125,0.77708334,1,0,0,0,0 +0ac166d12e401a98,xclick,/m/03q69,1,0.64375,0.665625,0.68958336,0.73333335,1,0,0,0,0 +0ac166d12e401a98,xclick,/m/03q69,1,0.9,1,0.49166667,0.72291666,1,1,0,0,0 +0ac166d12e401a98,xclick,/m/01g317,1,0.121875,1,0.40625,1,0,1,1,0,0 +0ac166d12e401a98,xclick,/m/0k0pj,1,0.7328125,0.7515625,0.59375,0.61875,0,0,0,0,0 +0ac166d12e401a98,xclick,/m/09j2d,1,0.1046875,1,0.6125,1,0,1,1,0,0 +0ac166d12e401a98,xclick,/m/04rky,1,0.128125,0.346875,0.65833336,0.99791664,1,1,0,0,0 +0ac166d12e401a98,xclick,/m/04rky,1,0.29375,0.521875,0.64166665,0.99791664,1,1,0,0,0 +0ac166d12e401a98,xclick,/m/04rky,1,0.453125,0.5125,0.58125,0.68333334,1,0,0,0,0 +0ac166d12e401a98,xclick,/m/04rky,1,0.5078125,0.584375,0.59166664,0.7395833,1,0,0,0,0 +0ac166d12e401a98,xclick,/m/04rky,1,0.596875,0.6765625,0.65,0.99791664,1,0,0,0,0 +0ac166d12e401a98,xclick,/m/04rky,1,0.640625,0.853125,0.47916666,0.99791664,1,1,0,0,0 +0ac166d12e401a98,xclick,/m/04rky,1,0.69375,0.725,0.6041667,0.65,1,0,0,0,0 +0ac166d12e401a98,xclick,/m/04rky,1,0.834375,0.9984375,0.40833333,0.99791664,1,1,0,0,0 +0ac2f91a7995aa8b,xclick,/m/08pbxl,1,0.0068965517,0.78965515,0.04914934,0.96219283,0,0,0,0,0 +0ac2f91a7995aa8b,xclick,/m/08pbxl,1,0.2551724,0.99482757,0.0018903592,0.9584121,1,0,0,0,0 +0ac2f91a7995aa8b,xclick,/m/07j7r,1,0,0.9982759,0,0.9962193,1,1,0,0,0 +0ac3c1db1b3645f2,xclick,/m/0463sg,1,0.40384614,0.7795858,0.24669604,0.68281937,0,0,0,0,0 +0ac3c1db1b3645f2,xclick,/m/0463sg,1,0.60650885,0.9408284,0.2290749,0.69162995,0,0,0,0,0 +0ac51477636a6933,xclick,/m/0bt9lr,1,0.23485968,0.5450517,0.22516556,0.73289186,0,0,0,0,0 +0ac51477636a6933,xclick,/m/0bt9lr,1,0.65140325,0.8183161,0.22737306,0.73730683,0,0,0,0,0 +0ac52440f73b5c80,xclick,/m/03hl4l9,1,0,1,0.2625,1,0,0,0,1,0 +0ac52440f73b5c80,xclick,/m/0ch_cf,1,0,1,0,0.3765625,0,0,0,1,0 +0ac52440f73b5c80,xclick,/m/0ch_cf,1,0,1,0.2578125,1,0,0,0,1,0 +0acfa779589204bf,xclick,/m/0dzct,1,0.35920578,0.8104693,0.27797833,0.8375451,1,0,0,0,0 +0acfa779589204bf,xclick,/m/03q69,1,0.32310468,0.84837544,0.05234657,0.46570396,0,0,0,0,0 +0acfa779589204bf,xclick,/m/04dr76w,1,0,0.22202165,0.066787004,0.9476534,0,0,0,0,0 +0acfa779589204bf,xclick,/m/01599,1,0,0.22202165,0.066787004,0.9476534,0,0,0,0,0 +0acfa779589204bf,xclick,/m/01g317,1,0,1,0.054151624,1,0,1,0,0,0 +0acfa779589204bf,xclick,/m/0k0pj,1,0.59205776,0.71480143,0.6101083,0.7454874,1,0,0,0,0 +0acfa779589204bf,xclick,/m/09j2d,1,0.20397112,0.99819493,0.48194945,0.99819493,1,1,0,0,0 +0acfa779589204bf,xclick,/m/09j2d,1,0.83935016,0.86101085,0.23104693,0.31949458,1,0,0,0,0 +0acfa779589204bf,xclick,/m/02p0tk3,1,0,0.99819493,0.05956679,0.99819493,1,1,0,0,0 +0acfa779589204bf,xclick,/m/04hgtk,1,0.299639,0.85559565,0.050541516,0.8357401,1,0,0,0,0 +0acfa779589204bf,xclick,/m/014sv8,1,0.44945848,0.57942235,0.54151624,0.62274367,0,0,0,0,0 +0acfa779589204bf,xclick,/m/014sv8,1,0.6624549,0.7689531,0.51805055,0.59205776,0,0,0,0,0 +0acfa779589204bf,xclick,/m/0k65p,1,0,0.38267148,0.6173285,1,0,1,0,0,0 +0acfa779589204bf,xclick,/m/0k65p,1,0.63718414,1,0.7833935,1,0,1,0,0,0 +0acfa779589204bf,xclick,/m/081qc,1,0,0.22382672,0.06498195,0.9494585,0,0,0,0,0 +0acfa779589204bf,xclick,/m/081qc,1,0.5270758,0.77075815,0.7454874,1,1,0,0,0,0 +0acfa779589204bf,xclick,/m/0dzf4,1,0,0.39350182,0.6119134,0.99819493,1,1,0,0,0 +0acfa779589204bf,xclick,/m/0dzf4,1,0.65162456,0.99819493,0.51805055,0.99819493,1,1,0,0,0 +0acfa779589204bf,xclick,/m/04yx4,1,0.20758122,1,0.050541516,1,0,1,0,0,0 +0ad602c943c9f568,xclick,/m/03q69,1,0.76957166,1,0.09713025,0.8278146,0,1,0,0,0 +0ad602c943c9f568,xclick,/m/0c_jw,1,0,0.31905466,0.7571744,0.9977925,1,1,0,0,0 +0ad602c943c9f568,xclick,/m/0c_jw,1,0.019202363,0.38552436,0.66225165,0.9977925,1,1,0,0,0 +0ad602c943c9f568,xclick,/m/01g317,1,0.49039882,1,0.09713025,1,0,1,0,0,0 +0ad602c943c9f568,xclick,/m/083kb,1,0.5731167,0.6026588,0.6578366,0.7240618,1,0,0,0,0 +0ad602c943c9f568,xclick,/m/09j2d,1,0.6144756,0.9985229,0.607064,0.9977925,1,1,0,0,0 +0ad602c943c9f568,xclick,/m/0dzf4,1,0.48153618,0.6883309,0.598234,0.9977925,1,1,0,0,0 +0ad602c943c9f568,xclick,/m/0dzf4,1,0.65435743,0.7843427,0.5452539,0.6467991,1,0,0,0,0 +0ad7884032419621,xclick,/m/03q69,1,0.34375,0.409375,0.40208334,0.58125,1,0,0,0,0 +0ad7884032419621,xclick,/m/035r7c,1,0.7828125,1,0.5520833,0.76458335,0,1,0,0,0 +0ad7884032419621,xclick,/m/035r7c,1,0.9265625,1,0.70208335,0.73125,0,0,0,0,0 +0ad7884032419621,xclick,/m/01g317,1,0.26875,1,0.15,0.7729167,0,0,0,0,0 +0ad7884032419621,xclick,/m/09j2d,1,0.2703125,1,0.31666666,0.7708333,0,1,0,0,0 +0ad7884032419621,xclick,/m/02p0tk3,1,0.2703125,1,0.15208334,0.76458335,0,0,0,0,0 +0ad7884032419621,xclick,/m/04hgtk,1,0.3375,0.45625,0.375,0.51458335,1,0,0,0,0 +0ad7884032419621,xclick,/m/0k65p,1,0.7984375,0.8984375,0.15208334,0.32291666,0,0,0,0,0 +0ad7884032419621,xclick,/m/04rky,1,0.26875,0.9984375,0.15,0.7729167,0,1,0,0,0 +0ad7884032419621,xclick,/m/039xj_,1,0.340625,0.3875,0.48333332,0.51666665,0,0,0,0,0 +0ad7884032419621,xclick,/m/0dzf4,1,0.4859375,0.896875,0.15208334,0.5854167,0,0,0,0,0 +0ad7bad30cd432df,xclick,/m/01g317,1,0,1,0.19469027,0.9314159,0,0,1,0,0 +0ad7bad30cd432df,xclick,/m/09j2d,1,0,1,0.28318584,0.90929204,0,0,1,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0,0.0899705,0.22566372,0.46460176,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.07522124,0.18141593,0.22123894,0.4778761,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.13864307,0.20058997,0.2920354,0.43362832,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.14011799,0.39823008,0.34513274,0.8584071,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.18141593,0.21828909,0.39159292,0.45132744,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.20501475,0.2640118,0.2920354,0.45575222,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.27876106,0.32153392,0.29424778,0.36725664,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.34070796,0.39823008,0.34513274,0.47123894,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.36873156,0.44247788,0.2699115,0.46238938,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.42330384,0.4719764,0.24778761,0.45132744,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.4660767,0.52507377,0.22787611,0.3318584,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.4719764,0.5265487,0.33849558,0.45353982,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.48820058,0.55309737,0.29867256,0.45353982,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.5103245,0.55309737,0.28097346,0.38495576,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.54867256,0.6061947,0.30530974,0.44911504,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.59144545,0.63716817,0.28097346,0.42035398,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.6135693,0.7300885,0.30752212,0.6836283,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.63716817,0.6696165,0.30088496,0.36946902,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.64306784,0.8023599,0.33628318,0.69911504,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.78318584,0.8318584,0.3119469,0.4181416,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.8023599,0.82890856,0.2721239,0.32522124,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.8303835,0.86725664,0.28761062,0.40265486,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.8480826,0.8923304,0.32079646,0.41371682,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.8480826,0.9985251,0.53318584,0.8119469,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.86725664,0.89085543,0.28097346,0.31858408,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.9056047,0.96312684,0.29867256,0.42256638,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04rky,1,0.9306785,0.9557522,0.38938054,0.41371682,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/09j5n,1,0.14011799,0.19026549,0.7920354,0.86504424,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/09j5n,1,0.37168142,0.40265486,0.789823,0.86946905,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/09j5n,1,0.6563422,0.6858407,0.63716817,0.6902655,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.14159292,0.19174041,0.7920354,0.86725664,0,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.21386431,0.3318584,0.579646,0.88053095,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.26106194,0.320059,0.34955752,0.46681416,0,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.2861357,0.31858408,0.6216814,0.6637168,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.31120944,0.359882,0.5199115,0.59070796,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.3761062,0.40117994,0.79867256,0.8761062,0,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.60471976,0.66519177,0.18141593,0.4181416,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.65929204,0.6902655,0.6261062,0.6814159,0,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.6814159,0.71091443,0.3119469,0.37168142,0,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.71533924,0.9985251,0.8053097,0.9336283,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.71681416,0.7300885,0.579646,0.63716817,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.7418879,0.7758112,0.34292036,0.42035398,0,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.75663716,0.9985251,0.88495576,0.9314159,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/05y5lj,1,0.88053095,0.9292035,0.539823,0.6858407,0,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04yx4,1,0,0.10176991,0.21681416,0.46681416,1,1,0,0,0 +0ad7bad30cd432df,xclick,/m/04yx4,1,0.072271384,0.18141593,0.21017699,0.46902654,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04yx4,1,0.4218289,0.46460176,0.24778761,0.45575222,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04yx4,1,0.46312684,0.52359885,0.2300885,0.34292036,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04yx4,1,0.51917404,0.5501475,0.2721239,0.38274336,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04yx4,1,0.59144545,0.6283186,0.27433628,0.42035398,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04yx4,1,0.63716817,0.6740413,0.28761062,0.36283186,1,0,0,0,0 +0ad7bad30cd432df,xclick,/m/04yx4,1,0.7787611,0.960177,0.28097346,0.4181416,1,0,1,0,0 +0ad96a2881998657,xclick,/m/0k4j,1,0.028485756,0.14392804,0.1764706,0.47930282,0,1,0,0,0 +0ad96a2881998657,xclick,/m/0k4j,1,0.046476763,0.91454273,0.18300654,0.73638344,0,0,0,0,0 +0ad96a2881998657,xclick,/m/0k4j,1,0.20539731,0.47826087,0.11328976,0.3224401,0,1,0,0,0 +0ad96a2881998657,xclick,/m/083wq,1,0.049475264,0.12593703,0.32026145,0.47058824,1,0,0,0,0 +0ad96a2881998657,xclick,/m/083wq,1,0.6041979,0.7196402,0.39651415,0.7298475,1,0,0,0,0 +0ad96a2881998657,xclick,/m/083wq,1,0.8305847,0.90854573,0.37908497,0.5795207,1,0,0,0,0 +0ad99d610a9092e6,xclick,/m/04bcr3,1,0,1,0,1,0,0,0,0,0 +0ad99d610a9092e6,xclick,/m/04kkgm,1,0,1,0,1,0,0,1,0,0 +0ad99d610a9092e6,xclick,/m/03hj559,1,0,0.998645,0,0.99759036,1,1,1,0,0 +0ada35baba28134b,xclick,/m/0k4j,1,0.030674847,0.96779144,0.036093418,0.9872612,0,0,0,0,0 +0ada35baba28134b,xclick,/m/07yv9,1,0,0.30981594,0.11677282,0.4564756,0,1,0,0,0 +0ada35baba28134b,xclick,/m/083wq,1,0.17638037,0.21932516,0.35881105,0.44798303,1,0,0,0,0 +0ada35baba28134b,xclick,/m/083wq,1,0.2101227,0.25460124,0.36305732,0.44585988,0,0,0,0,0 +0ada35baba28134b,xclick,/m/083wq,1,0.61809814,0.7791411,0.6348195,0.9723992,0,0,0,1,0 +0ada35baba28134b,xclick,/m/083wq,1,0.8803681,0.9570552,0.462845,0.6390658,0,0,0,0,0 +0adc1330287b2e66,xclick,/m/03q69,1,0.24678111,0.32618025,0.2336874,0.3141123,0,0,0,1,0 +0adc1330287b2e66,xclick,/m/01g317,1,0.21244635,0.32832617,0.24279211,0.5007587,0,0,0,1,0 +0adc1330287b2e66,xclick,/m/0k0pj,1,0.24892704,0.2832618,0.26251897,0.28983307,0,0,0,0,0 +0adc1330287b2e66,xclick,/m/04hgtk,1,0.24248926,0.31759655,0.23520486,0.3141123,0,0,0,1,0 +0adc1330287b2e66,xclick,/m/04hgtk,1,0.77253217,0.85193133,0.5037936,0.54172987,0,0,0,1,0 +0adc1330287b2e66,xclick,/m/09j5n,1,0.20171674,0.2532189,0.46130502,0.491654,0,0,0,1,0 +0adc1330287b2e66,xclick,/m/09j5n,1,0.27682403,0.3025751,0.4157815,0.46130502,0,0,0,1,0 +0adc1330287b2e66,xclick,/m/0dzf4,1,0.2167382,0.31759655,0.3080425,0.39453718,0,0,0,1,0 +0adc373e996aadc2,xclick,/m/0cmf2,1,0.1109375,0.8125,0.43958333,0.71458334,0,0,0,0,0 +0adc373e996aadc2,xclick,/m/01g317,1,0.415625,0.4765625,0.4625,0.5083333,1,0,0,0,0 +0adc373e996aadc2,xclick,/m/083wq,1,0.3078125,0.3390625,0.6645833,0.7104167,0,0,0,0,0 +0adc373e996aadc2,xclick,/m/083wq,1,0.4859375,0.5203125,0.65208334,0.7083333,0,0,0,0,0 +0add91a2efb3f33d,xclick,/m/035r7c,1,0,1,0.26548672,0.8477876,0,0,1,0,0 +0add91a2efb3f33d,xclick,/m/05r655,1,0,0.20626152,0.1840708,0.52743363,1,1,0,0,0 +0add91a2efb3f33d,xclick,/m/05r655,1,0.08471455,0.4217311,0.10619469,0.7575221,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/05r655,1,0.10128913,0.86924493,0.35044247,0.87256634,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/05r655,1,0.6335175,0.76243097,0.10973451,0.42477876,0,1,0,0,0 +0add91a2efb3f33d,xclick,/m/01g317,1,0,0.10865562,0.07079646,0.22123894,1,1,0,0,0 +0add91a2efb3f33d,xclick,/m/01g317,1,0.05893186,0.20626152,0.19115044,0.39292035,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/01g317,1,0.06445672,0.18416207,0.17168142,0.3699115,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/01g317,1,0.24309392,0.3756906,0.10619469,0.32743362,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/01g317,1,0.89134437,1,0,0.64247787,0,1,0,0,0 +0add91a2efb3f33d,xclick,/m/0h8mhzd,1,0.08839779,0.42541435,0.099115044,0.7840708,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/0h8mhzd,1,0.15285452,0.8674033,0.3539823,0.8513274,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/02p0tk3,1,0,1,0,1,1,0,1,0,0 +0add91a2efb3f33d,xclick,/m/04rky,1,0,0.08655617,0.0761062,0.2141593,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/04rky,1,0,0.21731123,0.18938053,0.5168142,1,1,0,0,0 +0add91a2efb3f33d,xclick,/m/04rky,1,0.06629834,0.18416207,0.18938053,0.3681416,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/04rky,1,0.08839779,0.4198895,0.107964605,0.7823009,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/04rky,1,0.14917128,0.8655617,0.3539823,0.87256634,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/04rky,1,0.2320442,0.3664825,0.10442478,0.31681415,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/04rky,1,0.62983423,0.7642726,0.107964605,0.41061947,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/04rky,1,0.76979744,0.97974217,0.21769911,0.49557522,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/04rky,1,0.8802947,0.9981584,0,0.660177,1,1,0,0,0 +0add91a2efb3f33d,xclick,/m/09j5n,1,0.027624309,0.07550645,0.4920354,0.52566373,0,0,0,0,0 +0add91a2efb3f33d,xclick,/m/09j5n,1,0.17127071,0.24309392,0.71327436,0.7504425,0,0,0,0,0 +0add91a2efb3f33d,xclick,/m/09j5n,1,0.17679559,0.22467771,0.76637167,0.8070797,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/09j5n,1,0.6869245,0.72007364,0.3876106,0.42477876,0,0,0,0,0 +0add91a2efb3f33d,xclick,/m/0dzf4,1,0,0.34254143,0.16283186,0.46725664,1,1,1,0,0 +0add91a2efb3f33d,xclick,/m/0dzf4,1,0.19152854,0.41436464,0.2920354,0.52389383,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/0dzf4,1,0.3941068,0.65377533,0.4460177,0.7044248,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/0dzf4,1,0.62246776,0.8379374,0.57699114,0.87079644,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/0dzf4,1,0.6353591,0.7053407,0.17699115,0.3061947,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/0dzf4,1,0.73664826,0.7642726,0.1840708,0.29557523,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/0dzf4,1,0.78268874,0.92449355,0.30265486,0.40884957,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/0dzf4,1,0.88766116,0.9742173,0,0.22123894,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/0dzf4,1,0.9097606,0.946593,0.31150442,0.43362832,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/03bt1vf,1,0,0.22467771,0.18584071,0.52920353,1,1,0,0,0 +0add91a2efb3f33d,xclick,/m/03bt1vf,1,0.08839779,0.42541435,0.107964605,0.7840708,1,0,0,0,0 +0add91a2efb3f33d,xclick,/m/03bt1vf,1,0.15285452,0.86924493,0.35929203,0.87079644,0,0,0,0,0 +0add91a2efb3f33d,xclick,/m/04yx4,1,0.76979744,0.9815838,0.21769911,0.49911505,0,0,0,0,0 +0ade7aef439e2102,xclick,/m/0k4j,1,0,0.0796875,0.22083333,0.48125,1,1,0,0,0 +0ade7aef439e2102,xclick,/m/0k4j,1,0.028125,0.9765625,0.175,0.9895833,0,0,0,0,0 +0ade7aef439e2102,xclick,/m/0d4v4,1,0.06875,0.240625,0.21875,0.35625,0,0,0,0,0 +0ade7aef439e2102,xclick,/m/0d4v4,1,0.075,0.184375,0.21666667,0.35625,0,0,0,0,0 +0ade7aef439e2102,xclick,/m/083wq,1,0.034375,0.103125,0.4125,0.59375,0,0,0,0,0 +0ade7aef439e2102,xclick,/m/083wq,1,0.3046875,0.5125,0.5875,0.98333335,0,0,0,0,0 +0ade7aef439e2102,xclick,/m/083wq,1,0.4140625,0.4765625,0.2625,0.29166666,1,0,0,0,0 +0ade7aef439e2102,xclick,/m/07j7r,1,0.9671875,1,0.0375,0.17916666,0,0,0,0,0 diff --git a/src/taming-transformers/data/open_images_annotations_100/validation-images.csv b/src/taming-transformers/data/open_images_annotations_100/validation-images.csv new file mode 100644 index 0000000000000000000000000000000000000000..ef3475cb8e1fa186f30a5a1a7b6fd13048612fed --- /dev/null +++ b/src/taming-transformers/data/open_images_annotations_100/validation-images.csv @@ -0,0 +1 @@ +image_name,image_url diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09c5b4d6bc25788d.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09c5b4d6bc25788d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..471cb350fa6039bb3b258e5348b98508e42c5c3e Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09c5b4d6bc25788d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09c67960e389e4df.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09c67960e389e4df.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e29bfed9ffbd1ca52da6cbed37c94985cc0a2dbe Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09c67960e389e4df.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09c6ddd2c210450e.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09c6ddd2c210450e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..14b8363faada5ef01127fada0d9244f8c605c47f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09c6ddd2c210450e.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09c7f89055cf399b.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09c7f89055cf399b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cafd7c904507c2299259a7a76625462b7c8d0a84 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09c7f89055cf399b.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09c863d76bcf6b00.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09c863d76bcf6b00.jpg new file mode 100644 index 0000000000000000000000000000000000000000..efcda7fe38ac58fc4ba84021f0a080c18caf8c7c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09c863d76bcf6b00.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09c993afacd01547.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09c993afacd01547.jpg new file mode 100644 index 0000000000000000000000000000000000000000..603d471b542169156f7e30fc3d651d602aad9b31 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09c993afacd01547.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09cbba9f5e097a19.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09cbba9f5e097a19.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d030f672e0db6443a3caa187b16ad2e84f6c5f76 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09cbba9f5e097a19.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09d2112596d9155b.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09d2112596d9155b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b605302b4b748fb62a6475e043a2585028f5b803 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09d2112596d9155b.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09d354dbd3dcc857.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09d354dbd3dcc857.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4fed27e553d6ed2dd7e8fe71b5dcff410964d0d8 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09d354dbd3dcc857.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09d45c49c4adbae4.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09d45c49c4adbae4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6e6093fe69ead3a413b57d8225eec01dac2a4f87 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09d45c49c4adbae4.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09d64f43c7111879.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09d64f43c7111879.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3330af1d748a315aeb4a34e02f1034de12eccc38 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09d64f43c7111879.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09d8aa2d19ff724d.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09d8aa2d19ff724d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f0f5cec96319f96cf34fbe6ae2d2bcb036bd66c4 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09d8aa2d19ff724d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09dcb9b52055d40f.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09dcb9b52055d40f.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4db52d24f50bd646e12eb1ec205d6a26982c77f6 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09dcb9b52055d40f.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09dd0671cd633432.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09dd0671cd633432.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8c2cd660381e4e88de0c938f04f26875b1ba928e Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09dd0671cd633432.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09df63bd01367ca3.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09df63bd01367ca3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3bffb062119e736db771577ca0922be5e8d6550f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09df63bd01367ca3.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09e094375efab7fe.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09e094375efab7fe.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ba8a78bf25e760b152ed44d5e95006638f284cff Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09e094375efab7fe.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09e617d9d3120b32.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09e617d9d3120b32.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bf400bd74b40f9a170fcdfb7f4a72aa644e30be2 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09e617d9d3120b32.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09ea349ee555b61d.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09ea349ee555b61d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b58795cd245bf0b3237d9c63a4cac0b7ad5b8c4b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09ea349ee555b61d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09ebcee57699eb98.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09ebcee57699eb98.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5564c57a5f1f3c6ec5a31e78d571f084aafc85b1 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09ebcee57699eb98.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09f531fe4f6d95f3.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09f531fe4f6d95f3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a2d8f8082cc07d8428eb7d0e3a731432ffd53b1a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09f531fe4f6d95f3.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09f8b77a88f224d9.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09f8b77a88f224d9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5bb7b2ebf0e27e3070318aaa142362de3d000a9c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09f8b77a88f224d9.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09f8e760f60df0da.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09f8e760f60df0da.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5796ef07a752d1aa3733ebf5e50653f012ee9db Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09f8e760f60df0da.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/09fa093bcd300c1a.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/09fa093bcd300c1a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0f2370d36af1831c47acb87fd57d19ac7b2c28b4 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/09fa093bcd300c1a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a02c648d24f39fb.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a02c648d24f39fb.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1336750ad8fbd404a10cd65b932835bdfae40abf Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a02c648d24f39fb.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a02e8b6820064f5.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a02e8b6820064f5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8acc3cabcb9d986462c2b5b52265eb509f10134c Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a02e8b6820064f5.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a03326036647703.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a03326036647703.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b2336f13eae949dd9f06e3a4fb818f8947329b4e Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a03326036647703.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a08a4711c728078.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a08a4711c728078.jpg new file mode 100644 index 0000000000000000000000000000000000000000..213cb61b0750ddbe38606e1589bf794d098860b5 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a08a4711c728078.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a120822d362dddf.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a120822d362dddf.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e78d1c5695ec5fcd8d5707be2b4e0a72d546cf49 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a120822d362dddf.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a13dcaaab9a35e0.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a13dcaaab9a35e0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9cd5094e8d08719c602b47c59b5a8f5ada1386fa Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a13dcaaab9a35e0.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a1b11867383b13e.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a1b11867383b13e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..92ee63d48d35583db6e5da19a32a0fef89d06505 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a1b11867383b13e.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a1bd356f90aaab6.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a1bd356f90aaab6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7c2c4d25fa860036ca94d49216d5ee55badfae14 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a1bd356f90aaab6.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a1f4761dc7fe1eb.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a1f4761dc7fe1eb.jpg new file mode 100644 index 0000000000000000000000000000000000000000..22ec6ca038a995595d04f04dc08d1bc5f22bf57e Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a1f4761dc7fe1eb.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a23d3f0e7d850f4.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a23d3f0e7d850f4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..364c3e74f628f1acc7f8fb3762006f1781f013e5 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a23d3f0e7d850f4.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a278d979b63fc72.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a278d979b63fc72.jpg new file mode 100644 index 0000000000000000000000000000000000000000..953af129f05b208ab5f5bc4c0a394db1d07202cc Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a278d979b63fc72.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a2c6ef66896fb92.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a2c6ef66896fb92.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aba0ca5ab4440401e2e2699e9a6031d9fadfd8fd Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a2c6ef66896fb92.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a34d80ee1db201e.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a34d80ee1db201e.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e1cc00adc6f4e15627bf50e6f4cb980d80839035 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a34d80ee1db201e.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a37aa0734ac8016.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a37aa0734ac8016.jpg new file mode 100644 index 0000000000000000000000000000000000000000..36f866b20d8f95619d216d01681c282c0e928119 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a37aa0734ac8016.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a3873442ad329c2.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a3873442ad329c2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..39ed3591f628a0befefabecb6fa2820a258b820f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a3873442ad329c2.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a392d80c905a9df.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a392d80c905a9df.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b6c0382a91a6e38f482ae7cfac0a3e9e50b84462 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a392d80c905a9df.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a39325e5ad7f5a0.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a39325e5ad7f5a0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3285932559a2c29e104d1cd7ec3e52cc78ad59d3 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a39325e5ad7f5a0.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a3c01759e77a02d.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a3c01759e77a02d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d5af7563ea809c996861ab6202b6dc803294635f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a3c01759e77a02d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a3f577a327ca7cc.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a3f577a327ca7cc.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aa9ce199be5563147e090772548bb108aeffba05 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a3f577a327ca7cc.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a3f9b3d57ef354a.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a3f9b3d57ef354a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..92067bb765839840bddfc98415ae880baa818fb0 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a3f9b3d57ef354a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a41cda5f44baaf6.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a41cda5f44baaf6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2aad348475a7699cd044e2c17345d90a133e4788 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a41cda5f44baaf6.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a47e7d602855f93.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a47e7d602855f93.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ed07ef915bad7807e8f372b5fc81d91ea012bf5a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a47e7d602855f93.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a4abf0a8071b917.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a4abf0a8071b917.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3cc1c237a4959dd88a22f6ac301bf0044ab8e3a8 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a4abf0a8071b917.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a4db5693da70448.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a4db5693da70448.jpg new file mode 100644 index 0000000000000000000000000000000000000000..64b717c26f5f1040ac4995ce903b80cbd767ce54 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a4db5693da70448.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a50911d08250183.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a50911d08250183.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6f546628abcc887384370d52e43659cfc3ddca9b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a50911d08250183.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a556c8163b58fae.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a556c8163b58fae.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a5e9932ee91666edf28645ce6ed107ddfe542b8d Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a556c8163b58fae.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a563d05ebab4fe3.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a563d05ebab4fe3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e172cf5f3d96e96e269f119d03ad856181b6fd0a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a563d05ebab4fe3.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a5972c68b6bb265.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a5972c68b6bb265.jpg new file mode 100644 index 0000000000000000000000000000000000000000..87115b6b6789828ae29d6994ae8188de4b33bcb6 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a5972c68b6bb265.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a599940d33b6b2b.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a599940d33b6b2b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2ac203e2999b1f2878344cde69dae57612dbaed1 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a599940d33b6b2b.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a600f1148d1023c.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a600f1148d1023c.jpg new file mode 100644 index 0000000000000000000000000000000000000000..adf0ea9b5b5a26dc246e31414ef00a20e2c63ca6 --- /dev/null +++ b/src/taming-transformers/data/open_images_annotations_100/validation/0a600f1148d1023c.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bcfb917af6632ed456d0a7ca09a940b313cf563cd0149985fe9812b1f7ebf8f8 +size 1347699 diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a6a03c8f23ee744.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a6a03c8f23ee744.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d424fd4fae2c61e0aea0c67f4540a57343e163dc Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a6a03c8f23ee744.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a6bc386b28f2aac.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a6bc386b28f2aac.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f6a6d72b93ce61558662a86cf020279c19320f7b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a6bc386b28f2aac.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a7074a2a5515531.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a7074a2a5515531.jpg new file mode 100644 index 0000000000000000000000000000000000000000..021e5bb3f69c0d3db5b05b37c41b3f076ac144d9 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a7074a2a5515531.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a72fef43a51c479.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a72fef43a51c479.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e2b8f9dd36cf01616b8dce412e6893a01346839e Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a72fef43a51c479.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a73064c82730ff5.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a73064c82730ff5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09b552ebe2b2ec9c8c424d411c9f178d197b6778 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a73064c82730ff5.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a78374f2d3949ae.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a78374f2d3949ae.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9999c93a0e9195af4c634d97db0cada4f1f3be83 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a78374f2d3949ae.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a7be0b883a12966.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a7be0b883a12966.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7e596263f0904cc8eda6704c38431faa49e1cc25 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a7be0b883a12966.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a7c597abf1e90d4.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a7c597abf1e90d4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e5f2e3fa9cb9e3be6d22f3031167645f0e7936da Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a7c597abf1e90d4.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a7d56b2fb989fe8.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a7d56b2fb989fe8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e6e664356966efe77772a7a54724f5c0038d5922 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a7d56b2fb989fe8.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a7f13330a5d0023.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a7f13330a5d0023.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0bbb8e6beef26f648418acf69fa06d23b5dc8a09 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a7f13330a5d0023.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a7f4d9a0ccb9afe.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a7f4d9a0ccb9afe.jpg new file mode 100644 index 0000000000000000000000000000000000000000..00aec11478603ae73b2330238dfe5c46eceb0696 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a7f4d9a0ccb9afe.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a7fbc1d68e4e5ae.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a7fbc1d68e4e5ae.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ab1a384b9b575a3e306395c276424e3e988ad895 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a7fbc1d68e4e5ae.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a7ffd65766a4741.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a7ffd65766a4741.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a5cf1be2b1a05f42b3c99b25708b9cfcef8d82ff Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a7ffd65766a4741.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a82f0443c940816.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a82f0443c940816.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e6278ff6bea0cdc27f0895b1a767a77ae8c3722d Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a82f0443c940816.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a8657e8b5c9d7bb.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a8657e8b5c9d7bb.jpg new file mode 100644 index 0000000000000000000000000000000000000000..232dd6e724c9376408853ec69ee78bb508eeee75 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a8657e8b5c9d7bb.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a877314ca2039d9.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a877314ca2039d9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5483a07e904bffe986421a9381afecf9376ef9f4 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a877314ca2039d9.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a917bbca24cf75d.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a917bbca24cf75d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b976be17c473575a5eccbd5d604740369f9e2987 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a917bbca24cf75d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a94296ff543a1dc.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a94296ff543a1dc.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c91fb319395dbef76295f689cb9f3d9a64d52d80 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a94296ff543a1dc.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a9f183e46c76019.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a9f183e46c76019.jpg new file mode 100644 index 0000000000000000000000000000000000000000..37f68db633a57a81bdc8f01ba8013a49a02529a2 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a9f183e46c76019.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a9f73b3c2557150.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a9f73b3c2557150.jpg new file mode 100644 index 0000000000000000000000000000000000000000..59b96baf4713eb039d78f872362a5e1f571f6243 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a9f73b3c2557150.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0a9ff75a7897e757.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0a9ff75a7897e757.jpg new file mode 100644 index 0000000000000000000000000000000000000000..32457a6a82e794b1d86af6d52e46ed0aea984d04 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0a9ff75a7897e757.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0aa206fa7ea80036.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0aa206fa7ea80036.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fab1344a1addaa32cb23d1fc1494b822184fe3ce Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0aa206fa7ea80036.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0aa3a6c33fca122b.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0aa3a6c33fca122b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..deabad442164c4fb306ae71f836c62f67d56f996 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0aa3a6c33fca122b.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0aaad833ac61ac9d.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0aaad833ac61ac9d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e21a748e592aae8cc73016b62adc0d222a29b93b Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0aaad833ac61ac9d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0aacbdb54e853a0a.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0aacbdb54e853a0a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..303f98f33c6345e210726e181be1295fb42e6a19 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0aacbdb54e853a0a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0aad9fc79a35bd53.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0aad9fc79a35bd53.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b4f4d52a3064141a83293d73a83b467372f200fb Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0aad9fc79a35bd53.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0aae34863935e33a.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0aae34863935e33a.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e6d011b2912574ec7fb44bdd1f49df310fa1c670 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0aae34863935e33a.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ab050b51e78acdb.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ab050b51e78acdb.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a6a27771f0f187916f8ec16bd3f6483887d9290f Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ab050b51e78acdb.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ab10a6417ef2301.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ab10a6417ef2301.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bcc10330f20f78df26e987ee71453cebc59b4531 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ab10a6417ef2301.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ab2b64f27f8baca.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ab2b64f27f8baca.jpg new file mode 100644 index 0000000000000000000000000000000000000000..50fc9e090415e85fed471067745626160c0936f2 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ab2b64f27f8baca.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ab5c690eebfad95.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ab5c690eebfad95.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9bbcc7267d57b036e15d5d205b39860cb0e7f9ce Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ab5c690eebfad95.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ac166d12e401a98.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ac166d12e401a98.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c461b7734437e88aa0ceede7bef2551e51859f4d Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ac166d12e401a98.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ac2f91a7995aa8b.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ac2f91a7995aa8b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0cb2c79c850b475d1bdd4f2f334b5c5c2b5c2afc Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ac2f91a7995aa8b.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ac3c1db1b3645f2.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ac3c1db1b3645f2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..23b2e91593bf1759f1567999636a71401a6b9767 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ac3c1db1b3645f2.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ac51477636a6933.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ac51477636a6933.jpg new file mode 100644 index 0000000000000000000000000000000000000000..60fb7feeb54d013903eb64cfdb98171b005708d8 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ac51477636a6933.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ac52440f73b5c80.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ac52440f73b5c80.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1898dc9449812573bffbc92cac49d0c1bf946da Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ac52440f73b5c80.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0acfa779589204bf.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0acfa779589204bf.jpg new file mode 100644 index 0000000000000000000000000000000000000000..21ea2a7fd6a03f1c9347d5234f65cade291e1824 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0acfa779589204bf.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ad602c943c9f568.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ad602c943c9f568.jpg new file mode 100644 index 0000000000000000000000000000000000000000..84f838cd442e5e38f6119f8ac5c7c988338da70a Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ad602c943c9f568.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ad7884032419621.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ad7884032419621.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c98d361492c8e69ad5ba08815244220bfa87b2dc Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ad7884032419621.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ad7bad30cd432df.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ad7bad30cd432df.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1355ddb8efe73b695f27d24e8c40ec2197460125 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ad7bad30cd432df.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ad96a2881998657.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ad96a2881998657.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f48beffddceb92619d5c0f574c1d72173b7ba6e Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ad96a2881998657.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ad99d610a9092e6.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ad99d610a9092e6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..530660e8f9c922c6ca00ba48823a6410b2765d43 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ad99d610a9092e6.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ada35baba28134b.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ada35baba28134b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eb3a7e7a8b8017a72dcb979468b5477eef0b39ca Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ada35baba28134b.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0adc1330287b2e66.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0adc1330287b2e66.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b4ecedaff192b7641a7db902ad1a6e9aed3aae01 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0adc1330287b2e66.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0adc373e996aadc2.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0adc373e996aadc2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..77c47c168ffe983fc2e41cf7b0ebe4f9ed488c28 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0adc373e996aadc2.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0add91a2efb3f33d.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0add91a2efb3f33d.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d00e99e95568d930d7167e32aa08cc10c1a44dca Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0add91a2efb3f33d.jpg differ diff --git a/src/taming-transformers/data/open_images_annotations_100/validation/0ade7aef439e2102.jpg b/src/taming-transformers/data/open_images_annotations_100/validation/0ade7aef439e2102.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be75e772365d2524dfca24afcdaf1e01a829a4e1 Binary files /dev/null and b/src/taming-transformers/data/open_images_annotations_100/validation/0ade7aef439e2102.jpg differ diff --git a/src/taming-transformers/data/sflckr_examples.txt b/src/taming-transformers/data/sflckr_examples.txt new file mode 100644 index 0000000000000000000000000000000000000000..cd3f45eeb43b61bfecab6ea1e779b79bfe24e445 --- /dev/null +++ b/src/taming-transformers/data/sflckr_examples.txt @@ -0,0 +1,25 @@ +canada/256743165_9f130ba95b_b.jpg +swiss_landscape/4079319632_0133685b2c_b.jpg +black_forest/44974691685_8e7372e2b1_b.jpg +swiss_mountains/33509672006_bf4c416afd_b.jpg +desert/4534149722_3cc4f92891_b.jpg +geysir/3542389801_a2cbfee1e1_b.jpg +geysir/14996762478_a9bdbf959a_b.jpg +ireland/15570753471_74db396d14_b.jpg +norway/25735082181_999927fe5a_b.jpg +norway/20099378793_cc2df820af_b.jpg +newzealand_np/7942812194_9348729b93_b.jpg +geysir/26320755536_7c769b6218_b.jpg +australia/8720651218_ca82a6608e_b.jpg +black_forest/8364557382_c6c9ee2fd6_b.jpg +australia/12822389285_a7723081b5_b.jpg +canada/2883773_881c197107_c.jpg +geysir/4748115806_7219c2b3be_b.jpg +meadow/18864473291_844325caab_b.jpg +carribean/18176301_c9d27557cf_b.jpg +cliff_ocean/36142796444_45d452f567_b.jpg +volcano/50254383883_27ed6ea93a_b.jpg +alaska_lakes/43259216952_59352d7204_b.jpg +carribean/14351041152_ef77484a1f_b.jpg +mongolia/6076373946_e9ea2aee32_b.jpg +lakes/39933489595_f0e5d85b6d_b.jpg diff --git a/src/taming-transformers/data/sflckr_images/alaska_lakes/43259216952_59352d7204_b.jpg b/src/taming-transformers/data/sflckr_images/alaska_lakes/43259216952_59352d7204_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..033e17b9ed294be65910c03301ea3b04a148328c Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/alaska_lakes/43259216952_59352d7204_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/australia/12822389285_a7723081b5_b.jpg b/src/taming-transformers/data/sflckr_images/australia/12822389285_a7723081b5_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..38353398b2f5d07e3c2361d46e32094f88a97428 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/australia/12822389285_a7723081b5_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/australia/8720651218_ca82a6608e_b.jpg b/src/taming-transformers/data/sflckr_images/australia/8720651218_ca82a6608e_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..15e5491561c13220d3155e030bce9cf7383cdeaf Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/australia/8720651218_ca82a6608e_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/black_forest/44974691685_8e7372e2b1_b.jpg b/src/taming-transformers/data/sflckr_images/black_forest/44974691685_8e7372e2b1_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9aaff142509c5b5712f9aa94da5fef213caf3aa4 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/black_forest/44974691685_8e7372e2b1_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/black_forest/8364557382_c6c9ee2fd6_b.jpg b/src/taming-transformers/data/sflckr_images/black_forest/8364557382_c6c9ee2fd6_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c063db013414c10a6b565776a091ab7e225e4f47 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/black_forest/8364557382_c6c9ee2fd6_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/canada/256743165_9f130ba95b_b.jpg b/src/taming-transformers/data/sflckr_images/canada/256743165_9f130ba95b_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ab0e7e2c82329dc0c73b1200c659d7cff065ced5 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/canada/256743165_9f130ba95b_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/canada/2883773_881c197107_c.jpg b/src/taming-transformers/data/sflckr_images/canada/2883773_881c197107_c.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2e65e6563d8815aea2c646d0d796c901bfd42a91 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/canada/2883773_881c197107_c.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/carribean/14351041152_ef77484a1f_b.jpg b/src/taming-transformers/data/sflckr_images/carribean/14351041152_ef77484a1f_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b3afab018da8e1625ebf0322997303bc2131a96b Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/carribean/14351041152_ef77484a1f_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/carribean/18176301_c9d27557cf_b.jpg b/src/taming-transformers/data/sflckr_images/carribean/18176301_c9d27557cf_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..25589cbea1824741ab8cc7f5b683ea2258e56377 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/carribean/18176301_c9d27557cf_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/cliff_ocean/36142796444_45d452f567_b.jpg b/src/taming-transformers/data/sflckr_images/cliff_ocean/36142796444_45d452f567_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99fe980a0bd29f75cc2e7205a7661387b07dd75c Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/cliff_ocean/36142796444_45d452f567_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/desert/4534149722_3cc4f92891_b.jpg b/src/taming-transformers/data/sflckr_images/desert/4534149722_3cc4f92891_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..48171e0a98562422f396d3c43fe883ebce7cf85a Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/desert/4534149722_3cc4f92891_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/geysir/14996762478_a9bdbf959a_b.jpg b/src/taming-transformers/data/sflckr_images/geysir/14996762478_a9bdbf959a_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9baeb5a8ef4b8118dcd4eb2baf6b0a9132fc7772 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/geysir/14996762478_a9bdbf959a_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/geysir/26320755536_7c769b6218_b.jpg b/src/taming-transformers/data/sflckr_images/geysir/26320755536_7c769b6218_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..491772dcfd83c1b8344b01c712f034569ab7d23a Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/geysir/26320755536_7c769b6218_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/geysir/3542389801_a2cbfee1e1_b.jpg b/src/taming-transformers/data/sflckr_images/geysir/3542389801_a2cbfee1e1_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fc0d950bc3d1a81ec8a821299e6cd222423ed2f9 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/geysir/3542389801_a2cbfee1e1_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/geysir/4748115806_7219c2b3be_b.jpg b/src/taming-transformers/data/sflckr_images/geysir/4748115806_7219c2b3be_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..37b81897d864818a8052825a1a528185d5da925e Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/geysir/4748115806_7219c2b3be_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/ireland/15570753471_74db396d14_b.jpg b/src/taming-transformers/data/sflckr_images/ireland/15570753471_74db396d14_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..94763908099204b90d4e06e9a84e615030c3c0ea Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/ireland/15570753471_74db396d14_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/lakes/39933489595_f0e5d85b6d_b.jpg b/src/taming-transformers/data/sflckr_images/lakes/39933489595_f0e5d85b6d_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..576da0db19a49516abe3b3c7c64e41ee0d4b09ac Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/lakes/39933489595_f0e5d85b6d_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/meadow/18864473291_844325caab_b.jpg b/src/taming-transformers/data/sflckr_images/meadow/18864473291_844325caab_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..917eebc065dd13b7bc791c8b5781e7abf1031769 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/meadow/18864473291_844325caab_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/mongolia/6076373946_e9ea2aee32_b.jpg b/src/taming-transformers/data/sflckr_images/mongolia/6076373946_e9ea2aee32_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ba600ec426bf714bc8180d53f13da09ae8780052 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/mongolia/6076373946_e9ea2aee32_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/newzealand_np/7942812194_9348729b93_b.jpg b/src/taming-transformers/data/sflckr_images/newzealand_np/7942812194_9348729b93_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..227725c1ac5598af8c534766330b3d43ca604107 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/newzealand_np/7942812194_9348729b93_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/norway/20099378793_cc2df820af_b.jpg b/src/taming-transformers/data/sflckr_images/norway/20099378793_cc2df820af_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d5ea9aee07f1206f5443a066a16c755eddba4a43 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/norway/20099378793_cc2df820af_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/norway/25735082181_999927fe5a_b.jpg b/src/taming-transformers/data/sflckr_images/norway/25735082181_999927fe5a_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2cf643bc54068a53669365849e2be90ab0a9777 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/norway/25735082181_999927fe5a_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/swiss_landscape/4079319632_0133685b2c_b.jpg b/src/taming-transformers/data/sflckr_images/swiss_landscape/4079319632_0133685b2c_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..62d2ced2c5009d4724c85ec2b40d403e0276b4a6 Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/swiss_landscape/4079319632_0133685b2c_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/swiss_mountains/33509672006_bf4c416afd_b.jpg b/src/taming-transformers/data/sflckr_images/swiss_mountains/33509672006_bf4c416afd_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a35fe578e46d1bcd1fb6c31ff1b178e6dbd62bad Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/swiss_mountains/33509672006_bf4c416afd_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_images/volcano/50254383883_27ed6ea93a_b.jpg b/src/taming-transformers/data/sflckr_images/volcano/50254383883_27ed6ea93a_b.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09f086287e0b6e864b6e57f0ec689f2c472b327c Binary files /dev/null and b/src/taming-transformers/data/sflckr_images/volcano/50254383883_27ed6ea93a_b.jpg differ diff --git a/src/taming-transformers/data/sflckr_segmentations/alaska_lakes/43259216952_59352d7204_b.png b/src/taming-transformers/data/sflckr_segmentations/alaska_lakes/43259216952_59352d7204_b.png new file mode 100644 index 0000000000000000000000000000000000000000..9e117848ac1988895f5e0253c4730c32ad76523b Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/alaska_lakes/43259216952_59352d7204_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/australia/12822389285_a7723081b5_b.png b/src/taming-transformers/data/sflckr_segmentations/australia/12822389285_a7723081b5_b.png new file mode 100644 index 0000000000000000000000000000000000000000..c1e963480795bfe76e26ea7ff37e74efb22763cf Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/australia/12822389285_a7723081b5_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/australia/8720651218_ca82a6608e_b.png b/src/taming-transformers/data/sflckr_segmentations/australia/8720651218_ca82a6608e_b.png new file mode 100644 index 0000000000000000000000000000000000000000..42bfee79c3deab8317d9f8387941b2f961a78f55 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/australia/8720651218_ca82a6608e_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/black_forest/44974691685_8e7372e2b1_b.png b/src/taming-transformers/data/sflckr_segmentations/black_forest/44974691685_8e7372e2b1_b.png new file mode 100644 index 0000000000000000000000000000000000000000..6a66beecc360eb07a1d1fe4bcf1c863c24b5a8d0 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/black_forest/44974691685_8e7372e2b1_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/black_forest/8364557382_c6c9ee2fd6_b.png b/src/taming-transformers/data/sflckr_segmentations/black_forest/8364557382_c6c9ee2fd6_b.png new file mode 100644 index 0000000000000000000000000000000000000000..d703b2bd478e4599518aef1e6ce6c9d12246c9ad Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/black_forest/8364557382_c6c9ee2fd6_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/canada/256743165_9f130ba95b_b.png b/src/taming-transformers/data/sflckr_segmentations/canada/256743165_9f130ba95b_b.png new file mode 100644 index 0000000000000000000000000000000000000000..cedcc521650ebd3c2f5f51c24d6b0478ee3fa04f Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/canada/256743165_9f130ba95b_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/canada/2883773_881c197107_c.png b/src/taming-transformers/data/sflckr_segmentations/canada/2883773_881c197107_c.png new file mode 100644 index 0000000000000000000000000000000000000000..a48bc81b95f1bf662ad249a49280696490b23044 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/canada/2883773_881c197107_c.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/carribean/14351041152_ef77484a1f_b.png b/src/taming-transformers/data/sflckr_segmentations/carribean/14351041152_ef77484a1f_b.png new file mode 100644 index 0000000000000000000000000000000000000000..7b304253b44f3bb4ca43211cbd8e1ac3b1a405d7 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/carribean/14351041152_ef77484a1f_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/carribean/18176301_c9d27557cf_b.png b/src/taming-transformers/data/sflckr_segmentations/carribean/18176301_c9d27557cf_b.png new file mode 100644 index 0000000000000000000000000000000000000000..7c126357ded408afcd093463a8f5e1df9c0f1dc3 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/carribean/18176301_c9d27557cf_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/cliff_ocean/36142796444_45d452f567_b.png b/src/taming-transformers/data/sflckr_segmentations/cliff_ocean/36142796444_45d452f567_b.png new file mode 100644 index 0000000000000000000000000000000000000000..cc12c39622fa1941d4427229a8fbfc2cb5cecfbe Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/cliff_ocean/36142796444_45d452f567_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/desert/4534149722_3cc4f92891_b.png b/src/taming-transformers/data/sflckr_segmentations/desert/4534149722_3cc4f92891_b.png new file mode 100644 index 0000000000000000000000000000000000000000..d31f4ffd816caed8852d1166f5e07c2a9c58c84e Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/desert/4534149722_3cc4f92891_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/geysir/14996762478_a9bdbf959a_b.png b/src/taming-transformers/data/sflckr_segmentations/geysir/14996762478_a9bdbf959a_b.png new file mode 100644 index 0000000000000000000000000000000000000000..8ccb797ce2030e3ae7dac3e71aaeafe03fb40b6e Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/geysir/14996762478_a9bdbf959a_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/geysir/26320755536_7c769b6218_b.png b/src/taming-transformers/data/sflckr_segmentations/geysir/26320755536_7c769b6218_b.png new file mode 100644 index 0000000000000000000000000000000000000000..34966fe42fba78fc86af480a1385b36d41e70a62 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/geysir/26320755536_7c769b6218_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/geysir/3542389801_a2cbfee1e1_b.png b/src/taming-transformers/data/sflckr_segmentations/geysir/3542389801_a2cbfee1e1_b.png new file mode 100644 index 0000000000000000000000000000000000000000..4465c34a933b90c9cd54b3c597270b2357991b42 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/geysir/3542389801_a2cbfee1e1_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/geysir/4748115806_7219c2b3be_b.png b/src/taming-transformers/data/sflckr_segmentations/geysir/4748115806_7219c2b3be_b.png new file mode 100644 index 0000000000000000000000000000000000000000..fff9b09e9b6e9a2adff744a2cc6905362a8da866 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/geysir/4748115806_7219c2b3be_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/ireland/15570753471_74db396d14_b.png b/src/taming-transformers/data/sflckr_segmentations/ireland/15570753471_74db396d14_b.png new file mode 100644 index 0000000000000000000000000000000000000000..a5dd6c7935abb4000018a8781aa506789df0fa2f Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/ireland/15570753471_74db396d14_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/lakes/39933489595_f0e5d85b6d_b.png b/src/taming-transformers/data/sflckr_segmentations/lakes/39933489595_f0e5d85b6d_b.png new file mode 100644 index 0000000000000000000000000000000000000000..79031a1443e34f1f5e5791c17ecc167235d61308 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/lakes/39933489595_f0e5d85b6d_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/meadow/18864473291_844325caab_b.png b/src/taming-transformers/data/sflckr_segmentations/meadow/18864473291_844325caab_b.png new file mode 100644 index 0000000000000000000000000000000000000000..f3774ed7e7c34ba9800403583dc60aa4fccadd81 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/meadow/18864473291_844325caab_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/mongolia/6076373946_e9ea2aee32_b.png b/src/taming-transformers/data/sflckr_segmentations/mongolia/6076373946_e9ea2aee32_b.png new file mode 100644 index 0000000000000000000000000000000000000000..46a70b9aed5f692bc4b92545f8b6fdcba997760f Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/mongolia/6076373946_e9ea2aee32_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/newzealand_np/7942812194_9348729b93_b.png b/src/taming-transformers/data/sflckr_segmentations/newzealand_np/7942812194_9348729b93_b.png new file mode 100644 index 0000000000000000000000000000000000000000..0c5feb09dd7df4f878facbe8a1577a212713eceb Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/newzealand_np/7942812194_9348729b93_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/norway/20099378793_cc2df820af_b.png b/src/taming-transformers/data/sflckr_segmentations/norway/20099378793_cc2df820af_b.png new file mode 100644 index 0000000000000000000000000000000000000000..6f2022224c0ca02eb99c9c1be57f3f1605bd13ce Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/norway/20099378793_cc2df820af_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/norway/25735082181_999927fe5a_b.png b/src/taming-transformers/data/sflckr_segmentations/norway/25735082181_999927fe5a_b.png new file mode 100644 index 0000000000000000000000000000000000000000..56d7e166413d3c4d27372335b905ab9e852e0f41 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/norway/25735082181_999927fe5a_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/swiss_landscape/4079319632_0133685b2c_b.png b/src/taming-transformers/data/sflckr_segmentations/swiss_landscape/4079319632_0133685b2c_b.png new file mode 100644 index 0000000000000000000000000000000000000000..46c30af6f8d353ef3c4d2be4b44be9455622fd20 Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/swiss_landscape/4079319632_0133685b2c_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/swiss_mountains/33509672006_bf4c416afd_b.png b/src/taming-transformers/data/sflckr_segmentations/swiss_mountains/33509672006_bf4c416afd_b.png new file mode 100644 index 0000000000000000000000000000000000000000..66cb0ccf209d2c3d0df8c21a0fa40835663c91ae Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/swiss_mountains/33509672006_bf4c416afd_b.png differ diff --git a/src/taming-transformers/data/sflckr_segmentations/volcano/50254383883_27ed6ea93a_b.png b/src/taming-transformers/data/sflckr_segmentations/volcano/50254383883_27ed6ea93a_b.png new file mode 100644 index 0000000000000000000000000000000000000000..61abb205ec9514233d7e7637c0e62c8cf425550c Binary files /dev/null and b/src/taming-transformers/data/sflckr_segmentations/volcano/50254383883_27ed6ea93a_b.png differ diff --git a/src/taming-transformers/data/subreddits.txt b/src/taming-transformers/data/subreddits.txt new file mode 100644 index 0000000000000000000000000000000000000000..564c2990a4aad40bdcd25bc716cfa26f7b76ad57 --- /dev/null +++ b/src/taming-transformers/data/subreddits.txt @@ -0,0 +1,12 @@ +AutumnPorn +BeachPorn +DesertPorn +EarthPorn +LakePorn +LavaPorn +MushroomPorn +SkyPorn +SpacePorn +SpringPorn +WeatherPorn +WinterPorn diff --git a/src/taming-transformers/environment.yaml b/src/taming-transformers/environment.yaml new file mode 100644 index 0000000000000000000000000000000000000000..3fbba586e55dbe64184d006319fad969805ef16f --- /dev/null +++ b/src/taming-transformers/environment.yaml @@ -0,0 +1,25 @@ +name: taming +channels: + - pytorch + - defaults +dependencies: + - python=3.8.5 + - pip=20.3 + - cudatoolkit=10.2 + - pytorch=1.7.0 + - torchvision=0.8.1 + - numpy=1.19.2 + - pip: + - albumentations==0.4.3 + - opencv-python==4.1.2.30 + - pudb==2019.2 + - imageio==2.9.0 + - imageio-ffmpeg==0.4.2 + - pytorch-lightning==1.0.8 + - omegaconf==2.0.0 + - test-tube>=0.7.5 + - streamlit>=0.73.1 + - einops==0.3.0 + - more-itertools>=8.0.0 + - transformers==4.3.1 + - -e . diff --git a/src/taming-transformers/main.py b/src/taming-transformers/main.py new file mode 100644 index 0000000000000000000000000000000000000000..3d83cb21c1dc5d0f5d7f396479c74e64691ec364 --- /dev/null +++ b/src/taming-transformers/main.py @@ -0,0 +1,585 @@ +import argparse, os, sys, datetime, glob, importlib +from omegaconf import OmegaConf +import numpy as np +from PIL import Image +import torch +import torchvision +from torch.utils.data import random_split, DataLoader, Dataset +import pytorch_lightning as pl +from pytorch_lightning import seed_everything +from pytorch_lightning.trainer import Trainer +from pytorch_lightning.callbacks import ModelCheckpoint, Callback, LearningRateMonitor +from pytorch_lightning.utilities.distributed import rank_zero_only + +from taming.data.utils import custom_collate + + +def get_obj_from_str(string, reload=False): + module, cls = string.rsplit(".", 1) + if reload: + module_imp = importlib.import_module(module) + importlib.reload(module_imp) + return getattr(importlib.import_module(module, package=None), cls) + + +def get_parser(**parser_kwargs): + def str2bool(v): + if isinstance(v, bool): + return v + if v.lower() in ("yes", "true", "t", "y", "1"): + return True + elif v.lower() in ("no", "false", "f", "n", "0"): + return False + else: + raise argparse.ArgumentTypeError("Boolean value expected.") + + parser = argparse.ArgumentParser(**parser_kwargs) + parser.add_argument( + "-n", + "--name", + type=str, + const=True, + default="", + nargs="?", + help="postfix for logdir", + ) + parser.add_argument( + "-r", + "--resume", + type=str, + const=True, + default="", + nargs="?", + help="resume from logdir or checkpoint in logdir", + ) + parser.add_argument( + "-b", + "--base", + nargs="*", + metavar="base_config.yaml", + help="paths to base configs. Loaded from left-to-right. " + "Parameters can be overwritten or added with command-line options of the form `--key value`.", + default=list(), + ) + parser.add_argument( + "-t", + "--train", + type=str2bool, + const=True, + default=False, + nargs="?", + help="train", + ) + parser.add_argument( + "--no-test", + type=str2bool, + const=True, + default=False, + nargs="?", + help="disable test", + ) + parser.add_argument("-p", "--project", help="name of new or path to existing project") + parser.add_argument( + "-d", + "--debug", + type=str2bool, + nargs="?", + const=True, + default=False, + help="enable post-mortem debugging", + ) + parser.add_argument( + "-s", + "--seed", + type=int, + default=23, + help="seed for seed_everything", + ) + parser.add_argument( + "-f", + "--postfix", + type=str, + default="", + help="post-postfix for default name", + ) + + return parser + + +def nondefault_trainer_args(opt): + parser = argparse.ArgumentParser() + parser = Trainer.add_argparse_args(parser) + args = parser.parse_args([]) + return sorted(k for k in vars(args) if getattr(opt, k) != getattr(args, k)) + + +def instantiate_from_config(config): + if not "target" in config: + raise KeyError("Expected key `target` to instantiate.") + return get_obj_from_str(config["target"])(**config.get("params", dict())) + + +class WrappedDataset(Dataset): + """Wraps an arbitrary object with __len__ and __getitem__ into a pytorch dataset""" + def __init__(self, dataset): + self.data = dataset + + def __len__(self): + return len(self.data) + + def __getitem__(self, idx): + return self.data[idx] + + +class DataModuleFromConfig(pl.LightningDataModule): + def __init__(self, batch_size, train=None, validation=None, test=None, + wrap=False, num_workers=None): + super().__init__() + self.batch_size = batch_size + self.dataset_configs = dict() + self.num_workers = num_workers if num_workers is not None else batch_size*2 + if train is not None: + self.dataset_configs["train"] = train + self.train_dataloader = self._train_dataloader + if validation is not None: + self.dataset_configs["validation"] = validation + self.val_dataloader = self._val_dataloader + if test is not None: + self.dataset_configs["test"] = test + self.test_dataloader = self._test_dataloader + self.wrap = wrap + + def prepare_data(self): + for data_cfg in self.dataset_configs.values(): + instantiate_from_config(data_cfg) + + def setup(self, stage=None): + self.datasets = dict( + (k, instantiate_from_config(self.dataset_configs[k])) + for k in self.dataset_configs) + if self.wrap: + for k in self.datasets: + self.datasets[k] = WrappedDataset(self.datasets[k]) + + def _train_dataloader(self): + return DataLoader(self.datasets["train"], batch_size=self.batch_size, + num_workers=self.num_workers, shuffle=True, collate_fn=custom_collate) + + def _val_dataloader(self): + return DataLoader(self.datasets["validation"], + batch_size=self.batch_size, + num_workers=self.num_workers, collate_fn=custom_collate) + + def _test_dataloader(self): + return DataLoader(self.datasets["test"], batch_size=self.batch_size, + num_workers=self.num_workers, collate_fn=custom_collate) + + +class SetupCallback(Callback): + def __init__(self, resume, now, logdir, ckptdir, cfgdir, config, lightning_config): + super().__init__() + self.resume = resume + self.now = now + self.logdir = logdir + self.ckptdir = ckptdir + self.cfgdir = cfgdir + self.config = config + self.lightning_config = lightning_config + + def on_pretrain_routine_start(self, trainer, pl_module): + if trainer.global_rank == 0: + # Create logdirs and save configs + os.makedirs(self.logdir, exist_ok=True) + os.makedirs(self.ckptdir, exist_ok=True) + os.makedirs(self.cfgdir, exist_ok=True) + + print("Project config") + print(self.config.pretty()) + OmegaConf.save(self.config, + os.path.join(self.cfgdir, "{}-project.yaml".format(self.now))) + + print("Lightning config") + print(self.lightning_config.pretty()) + OmegaConf.save(OmegaConf.create({"lightning": self.lightning_config}), + os.path.join(self.cfgdir, "{}-lightning.yaml".format(self.now))) + + else: + # ModelCheckpoint callback created log directory --- remove it + if not self.resume and os.path.exists(self.logdir): + dst, name = os.path.split(self.logdir) + dst = os.path.join(dst, "child_runs", name) + os.makedirs(os.path.split(dst)[0], exist_ok=True) + try: + os.rename(self.logdir, dst) + except FileNotFoundError: + pass + + +class ImageLogger(Callback): + def __init__(self, batch_frequency, max_images, clamp=True, increase_log_steps=True): + super().__init__() + self.batch_freq = batch_frequency + self.max_images = max_images + self.logger_log_images = { + pl.loggers.WandbLogger: self._wandb, + pl.loggers.TestTubeLogger: self._testtube, + } + self.log_steps = [2 ** n for n in range(int(np.log2(self.batch_freq)) + 1)] + if not increase_log_steps: + self.log_steps = [self.batch_freq] + self.clamp = clamp + + @rank_zero_only + def _wandb(self, pl_module, images, batch_idx, split): + raise ValueError("No way wandb") + grids = dict() + for k in images: + grid = torchvision.utils.make_grid(images[k]) + grids[f"{split}/{k}"] = wandb.Image(grid) + pl_module.logger.experiment.log(grids) + + @rank_zero_only + def _testtube(self, pl_module, images, batch_idx, split): + for k in images: + grid = torchvision.utils.make_grid(images[k]) + grid = (grid+1.0)/2.0 # -1,1 -> 0,1; c,h,w + + tag = f"{split}/{k}" + pl_module.logger.experiment.add_image( + tag, grid, + global_step=pl_module.global_step) + + @rank_zero_only + def log_local(self, save_dir, split, images, + global_step, current_epoch, batch_idx): + root = os.path.join(save_dir, "images", split) + for k in images: + grid = torchvision.utils.make_grid(images[k], nrow=4) + + grid = (grid+1.0)/2.0 # -1,1 -> 0,1; c,h,w + grid = grid.transpose(0,1).transpose(1,2).squeeze(-1) + grid = grid.numpy() + grid = (grid*255).astype(np.uint8) + filename = "{}_gs-{:06}_e-{:06}_b-{:06}.png".format( + k, + global_step, + current_epoch, + batch_idx) + path = os.path.join(root, filename) + os.makedirs(os.path.split(path)[0], exist_ok=True) + Image.fromarray(grid).save(path) + + def log_img(self, pl_module, batch, batch_idx, split="train"): + if (self.check_frequency(batch_idx) and # batch_idx % self.batch_freq == 0 + hasattr(pl_module, "log_images") and + callable(pl_module.log_images) and + self.max_images > 0): + logger = type(pl_module.logger) + + is_train = pl_module.training + if is_train: + pl_module.eval() + + with torch.no_grad(): + images = pl_module.log_images(batch, split=split, pl_module=pl_module) + + for k in images: + N = min(images[k].shape[0], self.max_images) + images[k] = images[k][:N] + if isinstance(images[k], torch.Tensor): + images[k] = images[k].detach().cpu() + if self.clamp: + images[k] = torch.clamp(images[k], -1., 1.) + + self.log_local(pl_module.logger.save_dir, split, images, + pl_module.global_step, pl_module.current_epoch, batch_idx) + + logger_log_images = self.logger_log_images.get(logger, lambda *args, **kwargs: None) + logger_log_images(pl_module, images, pl_module.global_step, split) + + if is_train: + pl_module.train() + + def check_frequency(self, batch_idx): + if (batch_idx % self.batch_freq) == 0 or (batch_idx in self.log_steps): + try: + self.log_steps.pop(0) + except IndexError: + pass + return True + return False + + def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx): + self.log_img(pl_module, batch, batch_idx, split="train") + + def on_validation_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx): + self.log_img(pl_module, batch, batch_idx, split="val") + + + +if __name__ == "__main__": + # custom parser to specify config files, train, test and debug mode, + # postfix, resume. + # `--key value` arguments are interpreted as arguments to the trainer. + # `nested.key=value` arguments are interpreted as config parameters. + # configs are merged from left-to-right followed by command line parameters. + + # model: + # base_learning_rate: float + # target: path to lightning module + # params: + # key: value + # data: + # target: main.DataModuleFromConfig + # params: + # batch_size: int + # wrap: bool + # train: + # target: path to train dataset + # params: + # key: value + # validation: + # target: path to validation dataset + # params: + # key: value + # test: + # target: path to test dataset + # params: + # key: value + # lightning: (optional, has sane defaults and can be specified on cmdline) + # trainer: + # additional arguments to trainer + # logger: + # logger to instantiate + # modelcheckpoint: + # modelcheckpoint to instantiate + # callbacks: + # callback1: + # target: importpath + # params: + # key: value + + now = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S") + + # add cwd for convenience and to make classes in this file available when + # running as `python main.py` + # (in particular `main.DataModuleFromConfig`) + sys.path.append(os.getcwd()) + + parser = get_parser() + parser = Trainer.add_argparse_args(parser) + + opt, unknown = parser.parse_known_args() + if opt.name and opt.resume: + raise ValueError( + "-n/--name and -r/--resume cannot be specified both." + "If you want to resume training in a new log folder, " + "use -n/--name in combination with --resume_from_checkpoint" + ) + if opt.resume: + if not os.path.exists(opt.resume): + raise ValueError("Cannot find {}".format(opt.resume)) + if os.path.isfile(opt.resume): + paths = opt.resume.split("/") + idx = len(paths)-paths[::-1].index("logs")+1 + logdir = "/".join(paths[:idx]) + ckpt = opt.resume + else: + assert os.path.isdir(opt.resume), opt.resume + logdir = opt.resume.rstrip("/") + ckpt = os.path.join(logdir, "checkpoints", "last.ckpt") + + opt.resume_from_checkpoint = ckpt + base_configs = sorted(glob.glob(os.path.join(logdir, "configs/*.yaml"))) + opt.base = base_configs+opt.base + _tmp = logdir.split("/") + nowname = _tmp[_tmp.index("logs")+1] + else: + if opt.name: + name = "_"+opt.name + elif opt.base: + cfg_fname = os.path.split(opt.base[0])[-1] + cfg_name = os.path.splitext(cfg_fname)[0] + name = "_"+cfg_name + else: + name = "" + nowname = now+name+opt.postfix + logdir = os.path.join("logs", nowname) + + ckptdir = os.path.join(logdir, "checkpoints") + cfgdir = os.path.join(logdir, "configs") + seed_everything(opt.seed) + + try: + # init and save configs + configs = [OmegaConf.load(cfg) for cfg in opt.base] + cli = OmegaConf.from_dotlist(unknown) + config = OmegaConf.merge(*configs, cli) + lightning_config = config.pop("lightning", OmegaConf.create()) + # merge trainer cli with config + trainer_config = lightning_config.get("trainer", OmegaConf.create()) + # default to ddp + trainer_config["distributed_backend"] = "ddp" + for k in nondefault_trainer_args(opt): + trainer_config[k] = getattr(opt, k) + if not "gpus" in trainer_config: + del trainer_config["distributed_backend"] + cpu = True + else: + gpuinfo = trainer_config["gpus"] + print(f"Running on GPUs {gpuinfo}") + cpu = False + trainer_opt = argparse.Namespace(**trainer_config) + lightning_config.trainer = trainer_config + + # model + model = instantiate_from_config(config.model) + + # trainer and callbacks + trainer_kwargs = dict() + + # default logger configs + # NOTE wandb < 0.10.0 interferes with shutdown + # wandb >= 0.10.0 seems to fix it but still interferes with pudb + # debugging (wrongly sized pudb ui) + # thus prefer testtube for now + default_logger_cfgs = { + "wandb": { + "target": "pytorch_lightning.loggers.WandbLogger", + "params": { + "name": nowname, + "save_dir": logdir, + "offline": opt.debug, + "id": nowname, + } + }, + "testtube": { + "target": "pytorch_lightning.loggers.TestTubeLogger", + "params": { + "name": "testtube", + "save_dir": logdir, + } + }, + } + default_logger_cfg = default_logger_cfgs["testtube"] + logger_cfg = lightning_config.logger or OmegaConf.create() + logger_cfg = OmegaConf.merge(default_logger_cfg, logger_cfg) + trainer_kwargs["logger"] = instantiate_from_config(logger_cfg) + + # modelcheckpoint - use TrainResult/EvalResult(checkpoint_on=metric) to + # specify which metric is used to determine best models + default_modelckpt_cfg = { + "target": "pytorch_lightning.callbacks.ModelCheckpoint", + "params": { + "dirpath": ckptdir, + "filename": "{epoch:06}", + "verbose": True, + "save_last": True, + } + } + if hasattr(model, "monitor"): + print(f"Monitoring {model.monitor} as checkpoint metric.") + default_modelckpt_cfg["params"]["monitor"] = model.monitor + default_modelckpt_cfg["params"]["save_top_k"] = 3 + + modelckpt_cfg = lightning_config.modelcheckpoint or OmegaConf.create() + modelckpt_cfg = OmegaConf.merge(default_modelckpt_cfg, modelckpt_cfg) + trainer_kwargs["checkpoint_callback"] = instantiate_from_config(modelckpt_cfg) + + # add callback which sets up log directory + default_callbacks_cfg = { + "setup_callback": { + "target": "main.SetupCallback", + "params": { + "resume": opt.resume, + "now": now, + "logdir": logdir, + "ckptdir": ckptdir, + "cfgdir": cfgdir, + "config": config, + "lightning_config": lightning_config, + } + }, + "image_logger": { + "target": "main.ImageLogger", + "params": { + "batch_frequency": 750, + "max_images": 4, + "clamp": True + } + }, + "learning_rate_logger": { + "target": "main.LearningRateMonitor", + "params": { + "logging_interval": "step", + #"log_momentum": True + } + }, + } + callbacks_cfg = lightning_config.callbacks or OmegaConf.create() + callbacks_cfg = OmegaConf.merge(default_callbacks_cfg, callbacks_cfg) + trainer_kwargs["callbacks"] = [instantiate_from_config(callbacks_cfg[k]) for k in callbacks_cfg] + + trainer = Trainer.from_argparse_args(trainer_opt, **trainer_kwargs) + + # data + data = instantiate_from_config(config.data) + # NOTE according to https://pytorch-lightning.readthedocs.io/en/latest/datamodules.html + # calling these ourselves should not be necessary but it is. + # lightning still takes care of proper multiprocessing though + data.prepare_data() + data.setup() + + # configure learning rate + bs, base_lr = config.data.params.batch_size, config.model.base_learning_rate + if not cpu: + ngpu = len(lightning_config.trainer.gpus.strip(",").split(',')) + else: + ngpu = 1 + accumulate_grad_batches = lightning_config.trainer.accumulate_grad_batches or 1 + print(f"accumulate_grad_batches = {accumulate_grad_batches}") + lightning_config.trainer.accumulate_grad_batches = accumulate_grad_batches + model.learning_rate = accumulate_grad_batches * ngpu * bs * base_lr + print("Setting learning rate to {:.2e} = {} (accumulate_grad_batches) * {} (num_gpus) * {} (batchsize) * {:.2e} (base_lr)".format( + model.learning_rate, accumulate_grad_batches, ngpu, bs, base_lr)) + + # allow checkpointing via USR1 + def melk(*args, **kwargs): + # run all checkpoint hooks + if trainer.global_rank == 0: + print("Summoning checkpoint.") + ckpt_path = os.path.join(ckptdir, "last.ckpt") + trainer.save_checkpoint(ckpt_path) + + def divein(*args, **kwargs): + if trainer.global_rank == 0: + import pudb; pudb.set_trace() + + import signal + signal.signal(signal.SIGUSR1, melk) + signal.signal(signal.SIGUSR2, divein) + + # run + if opt.train: + try: + trainer.fit(model, data) + except Exception: + melk() + raise + if not opt.no_test and not trainer.interrupted: + trainer.test(model, data) + except Exception: + if opt.debug and trainer.global_rank==0: + try: + import pudb as debugger + except ImportError: + import pdb as debugger + debugger.post_mortem() + raise + finally: + # move newly created debug project to debug_runs + if opt.debug and not opt.resume and trainer.global_rank==0: + dst, name = os.path.split(logdir) + dst = os.path.join(dst, "debug_runs", name) + os.makedirs(os.path.split(dst)[0], exist_ok=True) + os.rename(logdir, dst) diff --git a/src/taming-transformers/scripts/extract_depth.py b/src/taming-transformers/scripts/extract_depth.py new file mode 100644 index 0000000000000000000000000000000000000000..d6aa0d80c63a3e580fa28e0f2c7af4e9ae003b64 --- /dev/null +++ b/src/taming-transformers/scripts/extract_depth.py @@ -0,0 +1,112 @@ +import os +import torch +import numpy as np +from tqdm import trange +from PIL import Image + + +def get_state(gpu): + import torch + midas = torch.hub.load("intel-isl/MiDaS", "MiDaS") + if gpu: + midas.cuda() + midas.eval() + + midas_transforms = torch.hub.load("intel-isl/MiDaS", "transforms") + transform = midas_transforms.default_transform + + state = {"model": midas, + "transform": transform} + return state + + +def depth_to_rgba(x): + assert x.dtype == np.float32 + assert len(x.shape) == 2 + y = x.copy() + y.dtype = np.uint8 + y = y.reshape(x.shape+(4,)) + return np.ascontiguousarray(y) + + +def rgba_to_depth(x): + assert x.dtype == np.uint8 + assert len(x.shape) == 3 and x.shape[2] == 4 + y = x.copy() + y.dtype = np.float32 + y = y.reshape(x.shape[:2]) + return np.ascontiguousarray(y) + + +def run(x, state): + model = state["model"] + transform = state["transform"] + hw = x.shape[:2] + with torch.no_grad(): + prediction = model(transform((x + 1.0) * 127.5).cuda()) + prediction = torch.nn.functional.interpolate( + prediction.unsqueeze(1), + size=hw, + mode="bicubic", + align_corners=False, + ).squeeze() + output = prediction.cpu().numpy() + return output + + +def get_filename(relpath, level=-2): + # save class folder structure and filename: + fn = relpath.split(os.sep)[level:] + folder = fn[-2] + file = fn[-1].split('.')[0] + return folder, file + + +def save_depth(dataset, path, debug=False): + os.makedirs(path) + N = len(dset) + if debug: + N = 10 + state = get_state(gpu=True) + for idx in trange(N, desc="Data"): + ex = dataset[idx] + image, relpath = ex["image"], ex["relpath"] + folder, filename = get_filename(relpath) + # prepare + folderabspath = os.path.join(path, folder) + os.makedirs(folderabspath, exist_ok=True) + savepath = os.path.join(folderabspath, filename) + # run model + xout = run(image, state) + I = depth_to_rgba(xout) + Image.fromarray(I).save("{}.png".format(savepath)) + + +if __name__ == "__main__": + from taming.data.imagenet import ImageNetTrain, ImageNetValidation + out = "data/imagenet_depth" + if not os.path.exists(out): + print("Please create a folder or symlink '{}' to extract depth data ".format(out) + + "(be prepared that the output size will be larger than ImageNet itself).") + exit(1) + + # go + dset = ImageNetValidation() + abspath = os.path.join(out, "val") + if os.path.exists(abspath): + print("{} exists - not doing anything.".format(abspath)) + else: + print("preparing {}".format(abspath)) + save_depth(dset, abspath) + print("done with validation split") + + dset = ImageNetTrain() + abspath = os.path.join(out, "train") + if os.path.exists(abspath): + print("{} exists - not doing anything.".format(abspath)) + else: + print("preparing {}".format(abspath)) + save_depth(dset, abspath) + print("done with train split") + + print("done done.") diff --git a/src/taming-transformers/scripts/extract_segmentation.py b/src/taming-transformers/scripts/extract_segmentation.py new file mode 100644 index 0000000000000000000000000000000000000000..235b3c4b4575981b7533ce18bceaff97e05b55f9 --- /dev/null +++ b/src/taming-transformers/scripts/extract_segmentation.py @@ -0,0 +1,130 @@ +import sys, os +import numpy as np +import scipy +import torch +import torch.nn as nn +from scipy import ndimage +from tqdm import tqdm, trange +from PIL import Image +import torch.hub +import torchvision +import torch.nn.functional as F + +# download deeplabv2_resnet101_msc-cocostuff164k-100000.pth from +# https://github.com/kazuto1011/deeplab-pytorch/releases/download/v1.0/deeplabv2_resnet101_msc-cocostuff164k-100000.pth +# and put the path here +CKPT_PATH = "TODO" + +rescale = lambda x: (x + 1.) / 2. + +def rescale_bgr(x): + x = (x+1)*127.5 + x = torch.flip(x, dims=[0]) + return x + + +class COCOStuffSegmenter(nn.Module): + def __init__(self, config): + super().__init__() + self.config = config + self.n_labels = 182 + model = torch.hub.load("kazuto1011/deeplab-pytorch", "deeplabv2_resnet101", n_classes=self.n_labels) + ckpt_path = CKPT_PATH + model.load_state_dict(torch.load(ckpt_path)) + self.model = model + + normalize = torchvision.transforms.Normalize(mean=self.mean, std=self.std) + self.image_transform = torchvision.transforms.Compose([ + torchvision.transforms.Lambda(lambda image: torch.stack( + [normalize(rescale_bgr(x)) for x in image])) + ]) + + def forward(self, x, upsample=None): + x = self._pre_process(x) + x = self.model(x) + if upsample is not None: + x = torch.nn.functional.upsample_bilinear(x, size=upsample) + return x + + def _pre_process(self, x): + x = self.image_transform(x) + return x + + @property + def mean(self): + # bgr + return [104.008, 116.669, 122.675] + + @property + def std(self): + return [1.0, 1.0, 1.0] + + @property + def input_size(self): + return [3, 224, 224] + + +def run_model(img, model): + model = model.eval() + with torch.no_grad(): + segmentation = model(img, upsample=(img.shape[2], img.shape[3])) + segmentation = torch.argmax(segmentation, dim=1, keepdim=True) + return segmentation.detach().cpu() + + +def get_input(batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format) + return x.float() + + +def save_segmentation(segmentation, path): + # --> class label to uint8, save as png + os.makedirs(os.path.dirname(path), exist_ok=True) + assert len(segmentation.shape)==4 + assert segmentation.shape[0]==1 + for seg in segmentation: + seg = seg.permute(1,2,0).numpy().squeeze().astype(np.uint8) + seg = Image.fromarray(seg) + seg.save(path) + + +def iterate_dataset(dataloader, destpath, model): + os.makedirs(destpath, exist_ok=True) + num_processed = 0 + for i, batch in tqdm(enumerate(dataloader), desc="Data"): + try: + img = get_input(batch, "image") + img = img.cuda() + seg = run_model(img, model) + + path = batch["relative_file_path_"][0] + path = os.path.splitext(path)[0] + + path = os.path.join(destpath, path + ".png") + save_segmentation(seg, path) + num_processed += 1 + except Exception as e: + print(e) + print("but anyhow..") + + print("Processed {} files. Bye.".format(num_processed)) + + +from taming.data.sflckr import Examples +from torch.utils.data import DataLoader + +if __name__ == "__main__": + dest = sys.argv[1] + batchsize = 1 + print("Running with batch-size {}, saving to {}...".format(batchsize, dest)) + + model = COCOStuffSegmenter({}).cuda() + print("Instantiated model.") + + dataset = Examples() + dloader = DataLoader(dataset, batch_size=batchsize) + iterate_dataset(dataloader=dloader, destpath=dest, model=model) + print("done.") diff --git a/src/taming-transformers/scripts/extract_submodel.py b/src/taming-transformers/scripts/extract_submodel.py new file mode 100644 index 0000000000000000000000000000000000000000..559bc5e04281a7cf833a82e3cd48627b20f1a76d --- /dev/null +++ b/src/taming-transformers/scripts/extract_submodel.py @@ -0,0 +1,17 @@ +import torch +import sys + +if __name__ == "__main__": + inpath = sys.argv[1] + outpath = sys.argv[2] + submodel = "cond_stage_model" + if len(sys.argv) > 3: + submodel = sys.argv[3] + + print("Extracting {} from {} to {}.".format(submodel, inpath, outpath)) + + sd = torch.load(inpath, map_location="cpu") + new_sd = {"state_dict": dict((k.split(".", 1)[-1],v) + for k,v in sd["state_dict"].items() + if k.startswith("cond_stage_model"))} + torch.save(new_sd, outpath) diff --git a/src/taming-transformers/scripts/make_samples.py b/src/taming-transformers/scripts/make_samples.py new file mode 100644 index 0000000000000000000000000000000000000000..5e4d6995cd41cc07b4e8861cb941c6052b0f5517 --- /dev/null +++ b/src/taming-transformers/scripts/make_samples.py @@ -0,0 +1,292 @@ +import argparse, os, sys, glob, math, time +import torch +import numpy as np +from omegaconf import OmegaConf +from PIL import Image +from main import instantiate_from_config, DataModuleFromConfig +from torch.utils.data import DataLoader +from torch.utils.data.dataloader import default_collate +from tqdm import trange + + +def save_image(x, path): + c,h,w = x.shape + assert c==3 + x = ((x.detach().cpu().numpy().transpose(1,2,0)+1.0)*127.5).clip(0,255).astype(np.uint8) + Image.fromarray(x).save(path) + + +@torch.no_grad() +def run_conditional(model, dsets, outdir, top_k, temperature, batch_size=1): + if len(dsets.datasets) > 1: + split = sorted(dsets.datasets.keys())[0] + dset = dsets.datasets[split] + else: + dset = next(iter(dsets.datasets.values())) + print("Dataset: ", dset.__class__.__name__) + for start_idx in trange(0,len(dset)-batch_size+1,batch_size): + indices = list(range(start_idx, start_idx+batch_size)) + example = default_collate([dset[i] for i in indices]) + + x = model.get_input("image", example).to(model.device) + for i in range(x.shape[0]): + save_image(x[i], os.path.join(outdir, "originals", + "{:06}.png".format(indices[i]))) + + cond_key = model.cond_stage_key + c = model.get_input(cond_key, example).to(model.device) + + scale_factor = 1.0 + quant_z, z_indices = model.encode_to_z(x) + quant_c, c_indices = model.encode_to_c(c) + + cshape = quant_z.shape + + xrec = model.first_stage_model.decode(quant_z) + for i in range(xrec.shape[0]): + save_image(xrec[i], os.path.join(outdir, "reconstructions", + "{:06}.png".format(indices[i]))) + + if cond_key == "segmentation": + # get image from segmentation mask + num_classes = c.shape[1] + c = torch.argmax(c, dim=1, keepdim=True) + c = torch.nn.functional.one_hot(c, num_classes=num_classes) + c = c.squeeze(1).permute(0, 3, 1, 2).float() + c = model.cond_stage_model.to_rgb(c) + + idx = z_indices + + half_sample = False + if half_sample: + start = idx.shape[1]//2 + else: + start = 0 + + idx[:,start:] = 0 + idx = idx.reshape(cshape[0],cshape[2],cshape[3]) + start_i = start//cshape[3] + start_j = start %cshape[3] + + cidx = c_indices + cidx = cidx.reshape(quant_c.shape[0],quant_c.shape[2],quant_c.shape[3]) + + sample = True + + for i in range(start_i,cshape[2]-0): + if i <= 8: + local_i = i + elif cshape[2]-i < 8: + local_i = 16-(cshape[2]-i) + else: + local_i = 8 + for j in range(start_j,cshape[3]-0): + if j <= 8: + local_j = j + elif cshape[3]-j < 8: + local_j = 16-(cshape[3]-j) + else: + local_j = 8 + + i_start = i-local_i + i_end = i_start+16 + j_start = j-local_j + j_end = j_start+16 + patch = idx[:,i_start:i_end,j_start:j_end] + patch = patch.reshape(patch.shape[0],-1) + cpatch = cidx[:, i_start:i_end, j_start:j_end] + cpatch = cpatch.reshape(cpatch.shape[0], -1) + patch = torch.cat((cpatch, patch), dim=1) + logits,_ = model.transformer(patch[:,:-1]) + logits = logits[:, -256:, :] + logits = logits.reshape(cshape[0],16,16,-1) + logits = logits[:,local_i,local_j,:] + + logits = logits/temperature + + if top_k is not None: + logits = model.top_k_logits(logits, top_k) + # apply softmax to convert to probabilities + probs = torch.nn.functional.softmax(logits, dim=-1) + # sample from the distribution or take the most likely + if sample: + ix = torch.multinomial(probs, num_samples=1) + else: + _, ix = torch.topk(probs, k=1, dim=-1) + idx[:,i,j] = ix + + xsample = model.decode_to_img(idx[:,:cshape[2],:cshape[3]], cshape) + for i in range(xsample.shape[0]): + save_image(xsample[i], os.path.join(outdir, "samples", + "{:06}.png".format(indices[i]))) + + +def get_parser(): + parser = argparse.ArgumentParser() + parser.add_argument( + "-r", + "--resume", + type=str, + nargs="?", + help="load from logdir or checkpoint in logdir", + ) + parser.add_argument( + "-b", + "--base", + nargs="*", + metavar="base_config.yaml", + help="paths to base configs. Loaded from left-to-right. " + "Parameters can be overwritten or added with command-line options of the form `--key value`.", + default=list(), + ) + parser.add_argument( + "-c", + "--config", + nargs="?", + metavar="single_config.yaml", + help="path to single config. If specified, base configs will be ignored " + "(except for the last one if left unspecified).", + const=True, + default="", + ) + parser.add_argument( + "--ignore_base_data", + action="store_true", + help="Ignore data specification from base configs. Useful if you want " + "to specify a custom datasets on the command line.", + ) + parser.add_argument( + "--outdir", + required=True, + type=str, + help="Where to write outputs to.", + ) + parser.add_argument( + "--top_k", + type=int, + default=100, + help="Sample from among top-k predictions.", + ) + parser.add_argument( + "--temperature", + type=float, + default=1.0, + help="Sampling temperature.", + ) + return parser + + +def load_model_from_config(config, sd, gpu=True, eval_mode=True): + if "ckpt_path" in config.params: + print("Deleting the restore-ckpt path from the config...") + config.params.ckpt_path = None + if "downsample_cond_size" in config.params: + print("Deleting downsample-cond-size from the config and setting factor=0.5 instead...") + config.params.downsample_cond_size = -1 + config.params["downsample_cond_factor"] = 0.5 + try: + if "ckpt_path" in config.params.first_stage_config.params: + config.params.first_stage_config.params.ckpt_path = None + print("Deleting the first-stage restore-ckpt path from the config...") + if "ckpt_path" in config.params.cond_stage_config.params: + config.params.cond_stage_config.params.ckpt_path = None + print("Deleting the cond-stage restore-ckpt path from the config...") + except: + pass + + model = instantiate_from_config(config) + if sd is not None: + missing, unexpected = model.load_state_dict(sd, strict=False) + print(f"Missing Keys in State Dict: {missing}") + print(f"Unexpected Keys in State Dict: {unexpected}") + if gpu: + model.cuda() + if eval_mode: + model.eval() + return {"model": model} + + +def get_data(config): + # get data + data = instantiate_from_config(config.data) + data.prepare_data() + data.setup() + return data + + +def load_model_and_dset(config, ckpt, gpu, eval_mode): + # get data + dsets = get_data(config) # calls data.config ... + + # now load the specified checkpoint + if ckpt: + pl_sd = torch.load(ckpt, map_location="cpu") + global_step = pl_sd["global_step"] + else: + pl_sd = {"state_dict": None} + global_step = None + model = load_model_from_config(config.model, + pl_sd["state_dict"], + gpu=gpu, + eval_mode=eval_mode)["model"] + return dsets, model, global_step + + +if __name__ == "__main__": + sys.path.append(os.getcwd()) + + parser = get_parser() + + opt, unknown = parser.parse_known_args() + + ckpt = None + if opt.resume: + if not os.path.exists(opt.resume): + raise ValueError("Cannot find {}".format(opt.resume)) + if os.path.isfile(opt.resume): + paths = opt.resume.split("/") + try: + idx = len(paths)-paths[::-1].index("logs")+1 + except ValueError: + idx = -2 # take a guess: path/to/logdir/checkpoints/model.ckpt + logdir = "/".join(paths[:idx]) + ckpt = opt.resume + else: + assert os.path.isdir(opt.resume), opt.resume + logdir = opt.resume.rstrip("/") + ckpt = os.path.join(logdir, "checkpoints", "last.ckpt") + print(f"logdir:{logdir}") + base_configs = sorted(glob.glob(os.path.join(logdir, "configs/*-project.yaml"))) + opt.base = base_configs+opt.base + + if opt.config: + if type(opt.config) == str: + opt.base = [opt.config] + else: + opt.base = [opt.base[-1]] + + configs = [OmegaConf.load(cfg) for cfg in opt.base] + cli = OmegaConf.from_dotlist(unknown) + if opt.ignore_base_data: + for config in configs: + if hasattr(config, "data"): del config["data"] + config = OmegaConf.merge(*configs, cli) + + print(ckpt) + gpu = True + eval_mode = True + show_config = False + if show_config: + print(OmegaConf.to_container(config)) + + dsets, model, global_step = load_model_and_dset(config, ckpt, gpu, eval_mode) + print(f"Global step: {global_step}") + + outdir = os.path.join(opt.outdir, "{:06}_{}_{}".format(global_step, + opt.top_k, + opt.temperature)) + os.makedirs(outdir, exist_ok=True) + print("Writing samples to ", outdir) + for k in ["originals", "reconstructions", "samples"]: + os.makedirs(os.path.join(outdir, k), exist_ok=True) + run_conditional(model, dsets, outdir, opt.top_k, opt.temperature) diff --git a/src/taming-transformers/scripts/make_scene_samples.py b/src/taming-transformers/scripts/make_scene_samples.py new file mode 100644 index 0000000000000000000000000000000000000000..c096b98460874be0acbe5b85464593fbad4bedd0 --- /dev/null +++ b/src/taming-transformers/scripts/make_scene_samples.py @@ -0,0 +1,198 @@ +import glob +import os +import sys +from itertools import product +from pathlib import Path +from typing import Literal, List, Optional, Tuple + +import numpy as np +import torch +from omegaconf import OmegaConf +from pytorch_lightning import seed_everything +from torch import Tensor +from torchvision.utils import save_image +from tqdm import tqdm + +from scripts.make_samples import get_parser, load_model_and_dset +from taming.data.conditional_builder.objects_center_points import ObjectsCenterPointsConditionalBuilder +from taming.data.helper_types import BoundingBox, Annotation +from taming.data.annotated_objects_dataset import AnnotatedObjectsDataset +from taming.models.cond_transformer import Net2NetTransformer + +seed_everything(42424242) +device: Literal['cuda', 'cpu'] = 'cuda' +first_stage_factor = 16 +trained_on_res = 256 + + +def _helper(coord: int, coord_max: int, coord_window: int) -> (int, int): + assert 0 <= coord < coord_max + coord_desired_center = (coord_window - 1) // 2 + return np.clip(coord - coord_desired_center, 0, coord_max - coord_window) + + +def get_crop_coordinates(x: int, y: int) -> BoundingBox: + WIDTH, HEIGHT = desired_z_shape[1], desired_z_shape[0] + x0 = _helper(x, WIDTH, first_stage_factor) / WIDTH + y0 = _helper(y, HEIGHT, first_stage_factor) / HEIGHT + w = first_stage_factor / WIDTH + h = first_stage_factor / HEIGHT + return x0, y0, w, h + + +def get_z_indices_crop_out(z_indices: Tensor, predict_x: int, predict_y: int) -> Tensor: + WIDTH, HEIGHT = desired_z_shape[1], desired_z_shape[0] + x0 = _helper(predict_x, WIDTH, first_stage_factor) + y0 = _helper(predict_y, HEIGHT, first_stage_factor) + no_images = z_indices.shape[0] + cut_out_1 = z_indices[:, y0:predict_y, x0:x0+first_stage_factor].reshape((no_images, -1)) + cut_out_2 = z_indices[:, predict_y, x0:predict_x] + return torch.cat((cut_out_1, cut_out_2), dim=1) + + +@torch.no_grad() +def sample(model: Net2NetTransformer, annotations: List[Annotation], dataset: AnnotatedObjectsDataset, + conditional_builder: ObjectsCenterPointsConditionalBuilder, no_samples: int, + temperature: float, top_k: int) -> Tensor: + x_max, y_max = desired_z_shape[1], desired_z_shape[0] + + annotations = [a._replace(category_no=dataset.get_category_number(a.category_id)) for a in annotations] + + recompute_conditional = any((desired_resolution[0] > trained_on_res, desired_resolution[1] > trained_on_res)) + if not recompute_conditional: + crop_coordinates = get_crop_coordinates(0, 0) + conditional_indices = conditional_builder.build(annotations, crop_coordinates) + c_indices = conditional_indices.to(device).repeat(no_samples, 1) + z_indices = torch.zeros((no_samples, 0), device=device).long() + output_indices = model.sample(z_indices, c_indices, steps=x_max*y_max, temperature=temperature, + sample=True, top_k=top_k) + else: + output_indices = torch.zeros((no_samples, y_max, x_max), device=device).long() + for predict_y, predict_x in tqdm(product(range(y_max), range(x_max)), desc='sampling_image', total=x_max*y_max): + crop_coordinates = get_crop_coordinates(predict_x, predict_y) + z_indices = get_z_indices_crop_out(output_indices, predict_x, predict_y) + conditional_indices = conditional_builder.build(annotations, crop_coordinates) + c_indices = conditional_indices.to(device).repeat(no_samples, 1) + new_index = model.sample(z_indices, c_indices, steps=1, temperature=temperature, sample=True, top_k=top_k) + output_indices[:, predict_y, predict_x] = new_index[:, -1] + z_shape = ( + no_samples, + model.first_stage_model.quantize.e_dim, # codebook embed_dim + desired_z_shape[0], # z_height + desired_z_shape[1] # z_width + ) + x_sample = model.decode_to_img(output_indices, z_shape) * 0.5 + 0.5 + x_sample = x_sample.to('cpu') + + plotter = conditional_builder.plot + figure_size = (x_sample.shape[2], x_sample.shape[3]) + scene_graph = conditional_builder.build(annotations, (0., 0., 1., 1.)) + plot = plotter(scene_graph, dataset.get_textual_label_for_category_no, figure_size) + return torch.cat((x_sample, plot.unsqueeze(0))) + + +def get_resolution(resolution_str: str) -> (Tuple[int, int], Tuple[int, int]): + if not resolution_str.count(',') == 1: + raise ValueError("Give resolution as in 'height,width'") + res_h, res_w = resolution_str.split(',') + res_h = max(int(res_h), trained_on_res) + res_w = max(int(res_w), trained_on_res) + z_h = int(round(res_h/first_stage_factor)) + z_w = int(round(res_w/first_stage_factor)) + return (z_h, z_w), (z_h*first_stage_factor, z_w*first_stage_factor) + + +def add_arg_to_parser(parser): + parser.add_argument( + "-R", + "--resolution", + type=str, + default='256,256', + help=f"give resolution in multiples of {first_stage_factor}, default is '256,256'", + ) + parser.add_argument( + "-C", + "--conditional", + type=str, + default='objects_bbox', + help=f"objects_bbox or objects_center_points", + ) + parser.add_argument( + "-N", + "--n_samples_per_layout", + type=int, + default=4, + help=f"how many samples to generate per layout", + ) + return parser + + +if __name__ == "__main__": + sys.path.append(os.getcwd()) + + parser = get_parser() + parser = add_arg_to_parser(parser) + + opt, unknown = parser.parse_known_args() + + ckpt = None + if opt.resume: + if not os.path.exists(opt.resume): + raise ValueError("Cannot find {}".format(opt.resume)) + if os.path.isfile(opt.resume): + paths = opt.resume.split("/") + try: + idx = len(paths)-paths[::-1].index("logs")+1 + except ValueError: + idx = -2 # take a guess: path/to/logdir/checkpoints/model.ckpt + logdir = "/".join(paths[:idx]) + ckpt = opt.resume + else: + assert os.path.isdir(opt.resume), opt.resume + logdir = opt.resume.rstrip("/") + ckpt = os.path.join(logdir, "checkpoints", "last.ckpt") + print(f"logdir:{logdir}") + base_configs = sorted(glob.glob(os.path.join(logdir, "configs/*-project.yaml"))) + opt.base = base_configs+opt.base + + if opt.config: + if type(opt.config) == str: + opt.base = [opt.config] + else: + opt.base = [opt.base[-1]] + + configs = [OmegaConf.load(cfg) for cfg in opt.base] + cli = OmegaConf.from_dotlist(unknown) + if opt.ignore_base_data: + for config in configs: + if hasattr(config, "data"): + del config["data"] + config = OmegaConf.merge(*configs, cli) + desired_z_shape, desired_resolution = get_resolution(opt.resolution) + conditional = opt.conditional + + print(ckpt) + gpu = True + eval_mode = True + show_config = False + if show_config: + print(OmegaConf.to_container(config)) + + dsets, model, global_step = load_model_and_dset(config, ckpt, gpu, eval_mode) + print(f"Global step: {global_step}") + + data_loader = dsets.val_dataloader() + print(dsets.datasets["validation"].conditional_builders) + conditional_builder = dsets.datasets["validation"].conditional_builders[conditional] + + outdir = Path(opt.outdir).joinpath(f"{global_step:06}_{opt.top_k}_{opt.temperature}") + outdir.mkdir(exist_ok=True, parents=True) + print("Writing samples to ", outdir) + + p_bar_1 = tqdm(enumerate(iter(data_loader)), desc='batch', total=len(data_loader)) + for batch_no, batch in p_bar_1: + save_img: Optional[Tensor] = None + for i, annotations in tqdm(enumerate(batch['annotations']), desc='within_batch', total=data_loader.batch_size): + imgs = sample(model, annotations, dsets.datasets["validation"], conditional_builder, + opt.n_samples_per_layout, opt.temperature, opt.top_k) + save_image(imgs, outdir.joinpath(f'{batch_no:04}_{i:02}.png'), n_row=opt.n_samples_per_layout+1) diff --git a/src/taming-transformers/scripts/reconstruction_usage.ipynb b/src/taming-transformers/scripts/reconstruction_usage.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..35ca2a43cfaa05c59b82f4f7b181799882dc6998 --- /dev/null +++ b/src/taming-transformers/scripts/reconstruction_usage.ipynb @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:389aa20c5070678317cbf562755277833feec6d85a2e7f26ee92138241cc9197 +size 13700393 diff --git a/src/taming-transformers/scripts/sample_conditional.py b/src/taming-transformers/scripts/sample_conditional.py new file mode 100644 index 0000000000000000000000000000000000000000..174cf2af07c1a1ca4e6c35fc0e4f8d6e53591b56 --- /dev/null +++ b/src/taming-transformers/scripts/sample_conditional.py @@ -0,0 +1,355 @@ +import argparse, os, sys, glob, math, time +import torch +import numpy as np +from omegaconf import OmegaConf +import streamlit as st +from streamlit import caching +from PIL import Image +from main import instantiate_from_config, DataModuleFromConfig +from torch.utils.data import DataLoader +from torch.utils.data.dataloader import default_collate + + +rescale = lambda x: (x + 1.) / 2. + + +def bchw_to_st(x): + return rescale(x.detach().cpu().numpy().transpose(0,2,3,1)) + +def save_img(xstart, fname): + I = (xstart.clip(0,1)[0]*255).astype(np.uint8) + Image.fromarray(I).save(fname) + + + +def get_interactive_image(resize=False): + image = st.file_uploader("Input", type=["jpg", "JPEG", "png"]) + if image is not None: + image = Image.open(image) + if not image.mode == "RGB": + image = image.convert("RGB") + image = np.array(image).astype(np.uint8) + print("upload image shape: {}".format(image.shape)) + img = Image.fromarray(image) + if resize: + img = img.resize((256, 256)) + image = np.array(img) + return image + + +def single_image_to_torch(x, permute=True): + assert x is not None, "Please provide an image through the upload function" + x = np.array(x) + x = torch.FloatTensor(x/255.*2. - 1.)[None,...] + if permute: + x = x.permute(0, 3, 1, 2) + return x + + +def pad_to_M(x, M): + hp = math.ceil(x.shape[2]/M)*M-x.shape[2] + wp = math.ceil(x.shape[3]/M)*M-x.shape[3] + x = torch.nn.functional.pad(x, (0,wp,0,hp,0,0,0,0)) + return x + +@torch.no_grad() +def run_conditional(model, dsets): + if len(dsets.datasets) > 1: + split = st.sidebar.radio("Split", sorted(dsets.datasets.keys())) + dset = dsets.datasets[split] + else: + dset = next(iter(dsets.datasets.values())) + batch_size = 1 + start_index = st.sidebar.number_input("Example Index (Size: {})".format(len(dset)), value=0, + min_value=0, + max_value=len(dset)-batch_size) + indices = list(range(start_index, start_index+batch_size)) + + example = default_collate([dset[i] for i in indices]) + + x = model.get_input("image", example).to(model.device) + + cond_key = model.cond_stage_key + c = model.get_input(cond_key, example).to(model.device) + + scale_factor = st.sidebar.slider("Scale Factor", min_value=0.5, max_value=4.0, step=0.25, value=1.00) + if scale_factor != 1.0: + x = torch.nn.functional.interpolate(x, scale_factor=scale_factor, mode="bicubic") + c = torch.nn.functional.interpolate(c, scale_factor=scale_factor, mode="bicubic") + + quant_z, z_indices = model.encode_to_z(x) + quant_c, c_indices = model.encode_to_c(c) + + cshape = quant_z.shape + + xrec = model.first_stage_model.decode(quant_z) + st.write("image: {}".format(x.shape)) + st.image(bchw_to_st(x), clamp=True, output_format="PNG") + st.write("image reconstruction: {}".format(xrec.shape)) + st.image(bchw_to_st(xrec), clamp=True, output_format="PNG") + + if cond_key == "segmentation": + # get image from segmentation mask + num_classes = c.shape[1] + c = torch.argmax(c, dim=1, keepdim=True) + c = torch.nn.functional.one_hot(c, num_classes=num_classes) + c = c.squeeze(1).permute(0, 3, 1, 2).float() + c = model.cond_stage_model.to_rgb(c) + + st.write(f"{cond_key}: {tuple(c.shape)}") + st.image(bchw_to_st(c), clamp=True, output_format="PNG") + + idx = z_indices + + half_sample = st.sidebar.checkbox("Image Completion", value=False) + if half_sample: + start = idx.shape[1]//2 + else: + start = 0 + + idx[:,start:] = 0 + idx = idx.reshape(cshape[0],cshape[2],cshape[3]) + start_i = start//cshape[3] + start_j = start %cshape[3] + + if not half_sample and quant_z.shape == quant_c.shape: + st.info("Setting idx to c_indices") + idx = c_indices.clone().reshape(cshape[0],cshape[2],cshape[3]) + + cidx = c_indices + cidx = cidx.reshape(quant_c.shape[0],quant_c.shape[2],quant_c.shape[3]) + + xstart = model.decode_to_img(idx[:,:cshape[2],:cshape[3]], cshape) + st.image(bchw_to_st(xstart), clamp=True, output_format="PNG") + + temperature = st.number_input("Temperature", value=1.0) + top_k = st.number_input("Top k", value=100) + sample = st.checkbox("Sample", value=True) + update_every = st.number_input("Update every", value=75) + + st.text(f"Sampling shape ({cshape[2]},{cshape[3]})") + + animate = st.checkbox("animate") + if animate: + import imageio + outvid = "sampling.mp4" + writer = imageio.get_writer(outvid, fps=25) + elapsed_t = st.empty() + info = st.empty() + st.text("Sampled") + if st.button("Sample"): + output = st.empty() + start_t = time.time() + for i in range(start_i,cshape[2]-0): + if i <= 8: + local_i = i + elif cshape[2]-i < 8: + local_i = 16-(cshape[2]-i) + else: + local_i = 8 + for j in range(start_j,cshape[3]-0): + if j <= 8: + local_j = j + elif cshape[3]-j < 8: + local_j = 16-(cshape[3]-j) + else: + local_j = 8 + + i_start = i-local_i + i_end = i_start+16 + j_start = j-local_j + j_end = j_start+16 + elapsed_t.text(f"Time: {time.time() - start_t} seconds") + info.text(f"Step: ({i},{j}) | Local: ({local_i},{local_j}) | Crop: ({i_start}:{i_end},{j_start}:{j_end})") + patch = idx[:,i_start:i_end,j_start:j_end] + patch = patch.reshape(patch.shape[0],-1) + cpatch = cidx[:, i_start:i_end, j_start:j_end] + cpatch = cpatch.reshape(cpatch.shape[0], -1) + patch = torch.cat((cpatch, patch), dim=1) + logits,_ = model.transformer(patch[:,:-1]) + logits = logits[:, -256:, :] + logits = logits.reshape(cshape[0],16,16,-1) + logits = logits[:,local_i,local_j,:] + + logits = logits/temperature + + if top_k is not None: + logits = model.top_k_logits(logits, top_k) + # apply softmax to convert to probabilities + probs = torch.nn.functional.softmax(logits, dim=-1) + # sample from the distribution or take the most likely + if sample: + ix = torch.multinomial(probs, num_samples=1) + else: + _, ix = torch.topk(probs, k=1, dim=-1) + idx[:,i,j] = ix + + if (i*cshape[3]+j)%update_every==0: + xstart = model.decode_to_img(idx[:, :cshape[2], :cshape[3]], cshape,) + + xstart = bchw_to_st(xstart) + output.image(xstart, clamp=True, output_format="PNG") + + if animate: + writer.append_data((xstart[0]*255).clip(0, 255).astype(np.uint8)) + + xstart = model.decode_to_img(idx[:,:cshape[2],:cshape[3]], cshape) + xstart = bchw_to_st(xstart) + output.image(xstart, clamp=True, output_format="PNG") + #save_img(xstart, "full_res_sample.png") + if animate: + writer.close() + st.video(outvid) + + +def get_parser(): + parser = argparse.ArgumentParser() + parser.add_argument( + "-r", + "--resume", + type=str, + nargs="?", + help="load from logdir or checkpoint in logdir", + ) + parser.add_argument( + "-b", + "--base", + nargs="*", + metavar="base_config.yaml", + help="paths to base configs. Loaded from left-to-right. " + "Parameters can be overwritten or added with command-line options of the form `--key value`.", + default=list(), + ) + parser.add_argument( + "-c", + "--config", + nargs="?", + metavar="single_config.yaml", + help="path to single config. If specified, base configs will be ignored " + "(except for the last one if left unspecified).", + const=True, + default="", + ) + parser.add_argument( + "--ignore_base_data", + action="store_true", + help="Ignore data specification from base configs. Useful if you want " + "to specify a custom datasets on the command line.", + ) + return parser + + +def load_model_from_config(config, sd, gpu=True, eval_mode=True): + if "ckpt_path" in config.params: + st.warning("Deleting the restore-ckpt path from the config...") + config.params.ckpt_path = None + if "downsample_cond_size" in config.params: + st.warning("Deleting downsample-cond-size from the config and setting factor=0.5 instead...") + config.params.downsample_cond_size = -1 + config.params["downsample_cond_factor"] = 0.5 + try: + if "ckpt_path" in config.params.first_stage_config.params: + config.params.first_stage_config.params.ckpt_path = None + st.warning("Deleting the first-stage restore-ckpt path from the config...") + if "ckpt_path" in config.params.cond_stage_config.params: + config.params.cond_stage_config.params.ckpt_path = None + st.warning("Deleting the cond-stage restore-ckpt path from the config...") + except: + pass + + model = instantiate_from_config(config) + if sd is not None: + missing, unexpected = model.load_state_dict(sd, strict=False) + st.info(f"Missing Keys in State Dict: {missing}") + st.info(f"Unexpected Keys in State Dict: {unexpected}") + if gpu: + model.cuda() + if eval_mode: + model.eval() + return {"model": model} + + +def get_data(config): + # get data + data = instantiate_from_config(config.data) + data.prepare_data() + data.setup() + return data + + +@st.cache(allow_output_mutation=True, suppress_st_warning=True) +def load_model_and_dset(config, ckpt, gpu, eval_mode): + # get data + dsets = get_data(config) # calls data.config ... + + # now load the specified checkpoint + if ckpt: + pl_sd = torch.load(ckpt, map_location="cpu") + global_step = pl_sd["global_step"] + else: + pl_sd = {"state_dict": None} + global_step = None + model = load_model_from_config(config.model, + pl_sd["state_dict"], + gpu=gpu, + eval_mode=eval_mode)["model"] + return dsets, model, global_step + + +if __name__ == "__main__": + sys.path.append(os.getcwd()) + + parser = get_parser() + + opt, unknown = parser.parse_known_args() + + ckpt = None + if opt.resume: + if not os.path.exists(opt.resume): + raise ValueError("Cannot find {}".format(opt.resume)) + if os.path.isfile(opt.resume): + paths = opt.resume.split("/") + try: + idx = len(paths)-paths[::-1].index("logs")+1 + except ValueError: + idx = -2 # take a guess: path/to/logdir/checkpoints/model.ckpt + logdir = "/".join(paths[:idx]) + ckpt = opt.resume + else: + assert os.path.isdir(opt.resume), opt.resume + logdir = opt.resume.rstrip("/") + ckpt = os.path.join(logdir, "checkpoints", "last.ckpt") + print(f"logdir:{logdir}") + base_configs = sorted(glob.glob(os.path.join(logdir, "configs/*-project.yaml"))) + opt.base = base_configs+opt.base + + if opt.config: + if type(opt.config) == str: + opt.base = [opt.config] + else: + opt.base = [opt.base[-1]] + + configs = [OmegaConf.load(cfg) for cfg in opt.base] + cli = OmegaConf.from_dotlist(unknown) + if opt.ignore_base_data: + for config in configs: + if hasattr(config, "data"): del config["data"] + config = OmegaConf.merge(*configs, cli) + + st.sidebar.text(ckpt) + gs = st.sidebar.empty() + gs.text(f"Global step: ?") + st.sidebar.text("Options") + #gpu = st.sidebar.checkbox("GPU", value=True) + gpu = True + #eval_mode = st.sidebar.checkbox("Eval Mode", value=True) + eval_mode = True + #show_config = st.sidebar.checkbox("Show Config", value=False) + show_config = False + if show_config: + st.info("Checkpoint: {}".format(ckpt)) + st.json(OmegaConf.to_container(config)) + + dsets, model, global_step = load_model_and_dset(config, ckpt, gpu, eval_mode) + gs.text(f"Global step: {global_step}") + run_conditional(model, dsets) diff --git a/src/taming-transformers/scripts/sample_fast.py b/src/taming-transformers/scripts/sample_fast.py new file mode 100644 index 0000000000000000000000000000000000000000..ff546c7dcbe459807ac3b70f834ccc1082fe8b4e --- /dev/null +++ b/src/taming-transformers/scripts/sample_fast.py @@ -0,0 +1,260 @@ +import argparse, os, sys, glob +import torch +import time +import numpy as np +from omegaconf import OmegaConf +from PIL import Image +from tqdm import tqdm, trange +from einops import repeat + +from main import instantiate_from_config +from taming.modules.transformer.mingpt import sample_with_past + + +rescale = lambda x: (x + 1.) / 2. + + +def chw_to_pillow(x): + return Image.fromarray((255*rescale(x.detach().cpu().numpy().transpose(1,2,0))).clip(0,255).astype(np.uint8)) + + +@torch.no_grad() +def sample_classconditional(model, batch_size, class_label, steps=256, temperature=None, top_k=None, callback=None, + dim_z=256, h=16, w=16, verbose_time=False, top_p=None): + log = dict() + assert type(class_label) == int, f'expecting type int but type is {type(class_label)}' + qzshape = [batch_size, dim_z, h, w] + assert not model.be_unconditional, 'Expecting a class-conditional Net2NetTransformer.' + c_indices = repeat(torch.tensor([class_label]), '1 -> b 1', b=batch_size).to(model.device) # class token + t1 = time.time() + index_sample = sample_with_past(c_indices, model.transformer, steps=steps, + sample_logits=True, top_k=top_k, callback=callback, + temperature=temperature, top_p=top_p) + if verbose_time: + sampling_time = time.time() - t1 + print(f"Full sampling takes about {sampling_time:.2f} seconds.") + x_sample = model.decode_to_img(index_sample, qzshape) + log["samples"] = x_sample + log["class_label"] = c_indices + return log + + +@torch.no_grad() +def sample_unconditional(model, batch_size, steps=256, temperature=None, top_k=None, top_p=None, callback=None, + dim_z=256, h=16, w=16, verbose_time=False): + log = dict() + qzshape = [batch_size, dim_z, h, w] + assert model.be_unconditional, 'Expecting an unconditional model.' + c_indices = repeat(torch.tensor([model.sos_token]), '1 -> b 1', b=batch_size).to(model.device) # sos token + t1 = time.time() + index_sample = sample_with_past(c_indices, model.transformer, steps=steps, + sample_logits=True, top_k=top_k, callback=callback, + temperature=temperature, top_p=top_p) + if verbose_time: + sampling_time = time.time() - t1 + print(f"Full sampling takes about {sampling_time:.2f} seconds.") + x_sample = model.decode_to_img(index_sample, qzshape) + log["samples"] = x_sample + return log + + +@torch.no_grad() +def run(logdir, model, batch_size, temperature, top_k, unconditional=True, num_samples=50000, + given_classes=None, top_p=None): + batches = [batch_size for _ in range(num_samples//batch_size)] + [num_samples % batch_size] + if not unconditional: + assert given_classes is not None + print("Running in pure class-conditional sampling mode. I will produce " + f"{num_samples} samples for each of the {len(given_classes)} classes, " + f"i.e. {num_samples*len(given_classes)} in total.") + for class_label in tqdm(given_classes, desc="Classes"): + for n, bs in tqdm(enumerate(batches), desc="Sampling Class"): + if bs == 0: break + logs = sample_classconditional(model, batch_size=bs, class_label=class_label, + temperature=temperature, top_k=top_k, top_p=top_p) + save_from_logs(logs, logdir, base_count=n * batch_size, cond_key=logs["class_label"]) + else: + print(f"Running in unconditional sampling mode, producing {num_samples} samples.") + for n, bs in tqdm(enumerate(batches), desc="Sampling"): + if bs == 0: break + logs = sample_unconditional(model, batch_size=bs, temperature=temperature, top_k=top_k, top_p=top_p) + save_from_logs(logs, logdir, base_count=n * batch_size) + + +def save_from_logs(logs, logdir, base_count, key="samples", cond_key=None): + xx = logs[key] + for i, x in enumerate(xx): + x = chw_to_pillow(x) + count = base_count + i + if cond_key is None: + x.save(os.path.join(logdir, f"{count:06}.png")) + else: + condlabel = cond_key[i] + if type(condlabel) == torch.Tensor: condlabel = condlabel.item() + os.makedirs(os.path.join(logdir, str(condlabel)), exist_ok=True) + x.save(os.path.join(logdir, str(condlabel), f"{count:06}.png")) + + +def get_parser(): + def str2bool(v): + if isinstance(v, bool): + return v + if v.lower() in ("yes", "true", "t", "y", "1"): + return True + elif v.lower() in ("no", "false", "f", "n", "0"): + return False + else: + raise argparse.ArgumentTypeError("Boolean value expected.") + + parser = argparse.ArgumentParser() + parser.add_argument( + "-r", + "--resume", + type=str, + nargs="?", + help="load from logdir or checkpoint in logdir", + ) + parser.add_argument( + "-o", + "--outdir", + type=str, + nargs="?", + help="path where the samples will be logged to.", + default="" + ) + parser.add_argument( + "-b", + "--base", + nargs="*", + metavar="base_config.yaml", + help="paths to base configs. Loaded from left-to-right. " + "Parameters can be overwritten or added with command-line options of the form `--key value`.", + default=list(), + ) + parser.add_argument( + "-n", + "--num_samples", + type=int, + nargs="?", + help="num_samples to draw", + default=50000 + ) + parser.add_argument( + "--batch_size", + type=int, + nargs="?", + help="the batch size", + default=25 + ) + parser.add_argument( + "-k", + "--top_k", + type=int, + nargs="?", + help="top-k value to sample with", + default=250, + ) + parser.add_argument( + "-t", + "--temperature", + type=float, + nargs="?", + help="temperature value to sample with", + default=1.0 + ) + parser.add_argument( + "-p", + "--top_p", + type=float, + nargs="?", + help="top-p value to sample with", + default=1.0 + ) + parser.add_argument( + "--classes", + type=str, + nargs="?", + help="specify comma-separated classes to sample from. Uses 1000 classes per default.", + default="imagenet" + ) + return parser + + +def load_model_from_config(config, sd, gpu=True, eval_mode=True): + model = instantiate_from_config(config) + if sd is not None: + model.load_state_dict(sd) + if gpu: + model.cuda() + if eval_mode: + model.eval() + return {"model": model} + + +def load_model(config, ckpt, gpu, eval_mode): + # load the specified checkpoint + if ckpt: + pl_sd = torch.load(ckpt, map_location="cpu") + global_step = pl_sd["global_step"] + print(f"loaded model from global step {global_step}.") + else: + pl_sd = {"state_dict": None} + global_step = None + model = load_model_from_config(config.model, pl_sd["state_dict"], gpu=gpu, eval_mode=eval_mode)["model"] + return model, global_step + + +if __name__ == "__main__": + sys.path.append(os.getcwd()) + parser = get_parser() + + opt, unknown = parser.parse_known_args() + assert opt.resume + + ckpt = None + + if not os.path.exists(opt.resume): + raise ValueError("Cannot find {}".format(opt.resume)) + if os.path.isfile(opt.resume): + paths = opt.resume.split("/") + try: + idx = len(paths)-paths[::-1].index("logs")+1 + except ValueError: + idx = -2 # take a guess: path/to/logdir/checkpoints/model.ckpt + logdir = "/".join(paths[:idx]) + ckpt = opt.resume + else: + assert os.path.isdir(opt.resume), opt.resume + logdir = opt.resume.rstrip("/") + ckpt = os.path.join(logdir, "checkpoints", "last.ckpt") + + base_configs = sorted(glob.glob(os.path.join(logdir, "configs/*-project.yaml"))) + opt.base = base_configs+opt.base + + configs = [OmegaConf.load(cfg) for cfg in opt.base] + cli = OmegaConf.from_dotlist(unknown) + config = OmegaConf.merge(*configs, cli) + + model, global_step = load_model(config, ckpt, gpu=True, eval_mode=True) + + if opt.outdir: + print(f"Switching logdir from '{logdir}' to '{opt.outdir}'") + logdir = opt.outdir + + if opt.classes == "imagenet": + given_classes = [i for i in range(1000)] + else: + cls_str = opt.classes + assert not cls_str.endswith(","), 'class string should not end with a ","' + given_classes = [int(c) for c in cls_str.split(",")] + + logdir = os.path.join(logdir, "samples", f"top_k_{opt.top_k}_temp_{opt.temperature:.2f}_top_p_{opt.top_p}", + f"{global_step}") + + print(f"Logging to {logdir}") + os.makedirs(logdir, exist_ok=True) + + run(logdir, model, opt.batch_size, opt.temperature, opt.top_k, unconditional=model.be_unconditional, + given_classes=given_classes, num_samples=opt.num_samples, top_p=opt.top_p) + + print("done.") diff --git a/src/taming-transformers/scripts/taming-transformers.ipynb b/src/taming-transformers/scripts/taming-transformers.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..05f096c600cad909fed42368c9c03658b8a0489b --- /dev/null +++ b/src/taming-transformers/scripts/taming-transformers.ipynb @@ -0,0 +1,659 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "taming-transformers.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "2U0NA9HrrZey" + }, + "source": [ + "# Taming Transformers\n", + "\n", + "This notebook is a minimal working example to generate landscape images as in [Taming Transformers for High-Resolution Image Synthesis](https://github.com/CompVis/taming-transformers). **tl;dr** We combine the efficiancy of convolutional approaches with the expressivity of transformers by introducing a convolutional VQGAN, which learns a codebook of context-rich visual parts, whose composition is modeled with an autoregressive transformer." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4hdc6YonrvoC" + }, + "source": [ + "## Setup\n", + "The setup code in this section was written to be [run in a Colab environment](https://colab.research.google.com/github/CompVis/taming-transformers/blob/master/scripts/taming-transformers.ipynb). For a full, local setup, we recommend the provided [conda environment](https://github.com/CompVis/taming-transformers/blob/master/environment.yaml), as [described in the readme](https://github.com/CompVis/taming-transformers#requirements). This will also allow you to run a streamlit based demo.\n", + "\n", + "Here, we first clone the repository and download a model checkpoint and config." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Wwj8j_l201aF", + "outputId": "833f54a6-0620-4dc1-dd8c-69ab01433d17" + }, + "source": [ + "!git clone https://github.com/CompVis/taming-transformers\n", + "%cd taming-transformers\n", + "!mkdir -p logs/2020-11-09T13-31-51_sflckr/checkpoints\n", + "!wget 'https://heibox.uni-heidelberg.de/d/73487ab6e5314cb5adba/files/?p=%2Fcheckpoints%2Flast.ckpt&dl=1' -O 'logs/2020-11-09T13-31-51_sflckr/checkpoints/last.ckpt'\n", + "!mkdir logs/2020-11-09T13-31-51_sflckr/configs\n", + "!wget 'https://heibox.uni-heidelberg.de/d/73487ab6e5314cb5adba/files/?p=%2Fconfigs%2F2020-11-09T13-31-51-project.yaml&dl=1' -O 'logs/2020-11-09T13-31-51_sflckr/configs/2020-11-09T13-31-51-project.yaml'" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Cloning into 'taming-transformers'...\n", + "remote: Enumerating objects: 287, done.\u001B[K\n", + "remote: Counting objects: 100% (287/287), done.\u001B[K\n", + "remote: Compressing objects: 100% (232/232), done.\u001B[K\n", + "remote: Total 287 (delta 47), reused 285 (delta 45), pack-reused 0\u001B[K\n", + "Receiving objects: 100% (287/287), 50.50 MiB | 47.84 MiB/s, done.\n", + "Resolving deltas: 100% (47/47), done.\n", + "/content/taming-transformers\n", + "--2021-01-03 21:17:37-- https://heibox.uni-heidelberg.de/d/73487ab6e5314cb5adba/files/?p=%2Fcheckpoints%2Flast.ckpt&dl=1\n", + "Resolving heibox.uni-heidelberg.de (heibox.uni-heidelberg.de)... 129.206.7.113\n", + "Connecting to heibox.uni-heidelberg.de (heibox.uni-heidelberg.de)|129.206.7.113|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://heibox.uni-heidelberg.de/seafhttp/files/0fa273f3-83b9-41a5-a7b6-49d825c6a892/last.ckpt [following]\n", + "--2021-01-03 21:17:38-- https://heibox.uni-heidelberg.de/seafhttp/files/0fa273f3-83b9-41a5-a7b6-49d825c6a892/last.ckpt\n", + "Reusing existing connection to heibox.uni-heidelberg.de:443.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 4263525412 (4.0G) [application/octet-stream]\n", + "Saving to: ‘logs/2020-11-09T13-31-51_sflckr/checkpoints/last.ckpt’\n", + "\n", + "logs/2020-11-09T13- 100%[===================>] 3.97G 10.0MB/s in 6m 50s \n", + "\n", + "2021-01-03 21:24:28 (9.91 MB/s) - ‘logs/2020-11-09T13-31-51_sflckr/checkpoints/last.ckpt’ saved [4263525412/4263525412]\n", + "\n", + "--2021-01-03 21:24:28-- https://heibox.uni-heidelberg.de/d/73487ab6e5314cb5adba/files/?p=%2Fconfigs%2F2020-11-09T13-31-51-project.yaml&dl=1\n", + "Resolving heibox.uni-heidelberg.de (heibox.uni-heidelberg.de)... 129.206.7.113\n", + "Connecting to heibox.uni-heidelberg.de (heibox.uni-heidelberg.de)|129.206.7.113|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://heibox.uni-heidelberg.de/seafhttp/files/7f8d75ed-f754-4341-8027-f5e2c8eb906a/2020-11-09T13-31-51-project.yaml [following]\n", + "--2021-01-03 21:24:29-- https://heibox.uni-heidelberg.de/seafhttp/files/7f8d75ed-f754-4341-8027-f5e2c8eb906a/2020-11-09T13-31-51-project.yaml\n", + "Reusing existing connection to heibox.uni-heidelberg.de:443.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1603 (1.6K) [application/octet-stream]\n", + "Saving to: ‘logs/2020-11-09T13-31-51_sflckr/configs/2020-11-09T13-31-51-project.yaml’\n", + "\n", + "logs/2020-11-09T13- 100%[===================>] 1.57K --.-KB/s in 0.1s \n", + "\n", + "2021-01-03 21:24:29 (12.8 KB/s) - ‘logs/2020-11-09T13-31-51_sflckr/configs/2020-11-09T13-31-51-project.yaml’ saved [1603/1603]\n", + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eeBqWgMQDjZb" + }, + "source": [ + "Next, we install minimal required dependencies." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hzQNmIuT_0uF", + "outputId": "e6e1ce0f-bce9-4ebe-a852-95003ca7b630" + }, + "source": [ + "%pip install omegaconf>=2.0.0 pytorch-lightning>=1.0.8 einops transformers\n", + "import sys\n", + "sys.path.append(\".\")" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Collecting omegaconf==2.0.0\n", + " Downloading https://files.pythonhosted.org/packages/3d/95/ebd73361f9c6e94bd0f3b19ffe31c24e833834c022f1c0328ac71b2d6c90/omegaconf-2.0.0-py3-none-any.whl\n", + "Collecting pytorch-lightning==1.0.8\n", + "\u001B[?25l Downloading https://files.pythonhosted.org/packages/2e/92/078c5524c875c274ded8a0317ef31a2bb86d02c5c74089ab754d0f12b29c/pytorch_lightning-1.0.8-py3-none-any.whl (561kB)\n", + "\u001B[K |████████████████████████████████| 563kB 17.7MB/s \n", + "\u001B[?25hRequirement already satisfied: typing-extensions in /usr/local/lib/python3.6/dist-packages (from omegaconf==2.0.0) (3.7.4.3)\n", + "Requirement already satisfied: dataclasses; python_version == \"3.6\" in /usr/local/lib/python3.6/dist-packages (from omegaconf==2.0.0) (0.8)\n", + "Requirement already satisfied: PyYAML in /usr/local/lib/python3.6/dist-packages (from omegaconf==2.0.0) (3.13)\n", + "Requirement already satisfied: tensorboard>=2.2.0 in /usr/local/lib/python3.6/dist-packages (from pytorch-lightning==1.0.8) (2.4.0)\n", + "Requirement already satisfied: torch>=1.3 in /usr/local/lib/python3.6/dist-packages (from pytorch-lightning==1.0.8) (1.7.0+cu101)\n", + "Requirement already satisfied: tqdm>=4.41.0 in /usr/local/lib/python3.6/dist-packages (from pytorch-lightning==1.0.8) (4.41.1)\n", + "Requirement already satisfied: numpy>=1.16.4 in /usr/local/lib/python3.6/dist-packages (from pytorch-lightning==1.0.8) (1.19.4)\n", + "Collecting future>=0.17.1\n", + "\u001B[?25l Downloading https://files.pythonhosted.org/packages/45/0b/38b06fd9b92dc2b68d58b75f900e97884c45bedd2ff83203d933cf5851c9/future-0.18.2.tar.gz (829kB)\n", + "\u001B[K |████████████████████████████████| 829kB 51.0MB/s \n", + "\u001B[?25hCollecting fsspec>=0.8.0\n", + "\u001B[?25l Downloading https://files.pythonhosted.org/packages/ec/80/72ac0982cc833945fada4b76c52f0f65435ba4d53bc9317d1c70b5f7e7d5/fsspec-0.8.5-py3-none-any.whl (98kB)\n", + "\u001B[K |████████████████████████████████| 102kB 15.7MB/s \n", + "\u001B[?25hRequirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (0.10.0)\n", + "Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (1.32.0)\n", + "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (51.0.0)\n", + "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (1.7.0)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (2.23.0)\n", + "Requirement already satisfied: wheel>=0.26; python_version >= \"3\" in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (0.36.2)\n", + "Requirement already satisfied: google-auth<2,>=1.6.3 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (1.17.2)\n", + "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (0.4.2)\n", + "Requirement already satisfied: protobuf>=3.6.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (3.12.4)\n", + "Requirement already satisfied: six>=1.10.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (1.15.0)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (3.3.3)\n", + "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.6/dist-packages (from tensorboard>=2.2.0->pytorch-lightning==1.0.8) (1.0.1)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (2020.12.5)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (3.0.4)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (1.24.3)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (2.10)\n", + "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (4.2.0)\n", + "Requirement already satisfied: rsa<5,>=3.1.4; python_version >= \"3\" in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (4.6)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (0.2.8)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (1.3.0)\n", + "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.6/dist-packages (from markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (3.3.0)\n", + "Requirement already satisfied: pyasn1>=0.1.3 in /usr/local/lib/python3.6/dist-packages (from rsa<5,>=3.1.4; python_version >= \"3\"->google-auth<2,>=1.6.3->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (0.4.8)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.6/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (3.1.0)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.6/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard>=2.2.0->pytorch-lightning==1.0.8) (3.4.0)\n", + "Building wheels for collected packages: future\n", + " Building wheel for future (setup.py) ... \u001B[?25l\u001B[?25hdone\n", + " Created wheel for future: filename=future-0.18.2-cp36-none-any.whl size=491057 sha256=77114a99b4b6e1a15924fdf57670f539d17f33b42f8ff0e951f27d6712e10848\n", + " Stored in directory: /root/.cache/pip/wheels/8b/99/a0/81daf51dcd359a9377b110a8a886b3895921802d2fc1b2397e\n", + "Successfully built future\n", + "\u001B[31mERROR: pytorch-lightning 1.0.8 has requirement PyYAML>=5.1, but you'll have pyyaml 3.13 which is incompatible.\u001B[0m\n", + "Installing collected packages: omegaconf, future, fsspec, pytorch-lightning\n", + " Found existing installation: future 0.16.0\n", + " Uninstalling future-0.16.0:\n", + " Successfully uninstalled future-0.16.0\n", + "Successfully installed fsspec-0.8.5 future-0.18.2 omegaconf-2.0.0 pytorch-lightning-1.0.8\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5gaAQZXTxFxD" + }, + "source": [ + "## Loading the model\n", + "\n", + "We load and print the config." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hUOUJaTj02Bq", + "outputId": "6671562d-f7f6-4407-ee40-22e1b83421e3" + }, + "source": [ + "from omegaconf import OmegaConf\n", + "config_path = \"logs/2020-11-09T13-31-51_sflckr/configs/2020-11-09T13-31-51-project.yaml\"\n", + "config = OmegaConf.load(config_path)\n", + "import yaml\n", + "print(yaml.dump(OmegaConf.to_container(config)))" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "text": [ + "data:\n", + " params:\n", + " batch_size: 1\n", + " validation: {target: taming.data.sflckr.Examples}\n", + " target: main.DataModuleFromConfig\n", + "model:\n", + " base_learning_rate: 4.5e-06\n", + " params:\n", + " cond_stage_config:\n", + " params:\n", + " ddconfig:\n", + " attn_resolutions: [16]\n", + " ch: 128\n", + " ch_mult: [1, 1, 2, 2, 4]\n", + " double_z: false\n", + " dropout: 0.0\n", + " in_channels: 182\n", + " num_res_blocks: 2\n", + " out_ch: 182\n", + " resolution: 256\n", + " z_channels: 256\n", + " embed_dim: 256\n", + " image_key: segmentation\n", + " lossconfig: {target: taming.modules.losses.DummyLoss}\n", + " n_embed: 1024\n", + " target: taming.models.vqgan.VQModel\n", + " cond_stage_key: segmentation\n", + " first_stage_config:\n", + " params:\n", + " ddconfig:\n", + " attn_resolutions: [16]\n", + " ch: 128\n", + " ch_mult: [1, 1, 2, 2, 4]\n", + " double_z: false\n", + " dropout: 0.0\n", + " in_channels: 3\n", + " num_res_blocks: 2\n", + " out_ch: 3\n", + " resolution: 256\n", + " z_channels: 256\n", + " embed_dim: 256\n", + " lossconfig: {target: taming.modules.losses.DummyLoss}\n", + " n_embed: 1024\n", + " target: taming.models.vqgan.VQModel\n", + " first_stage_key: image\n", + " transformer_config:\n", + " params: {block_size: 512, n_embd: 1024, n_head: 16, n_layer: 24, vocab_size: 1024}\n", + " target: taming.modules.transformer.mingpt.GPT\n", + " target: taming.models.cond_transformer.Net2NetTransformer\n", + "\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FzQqNgiLEJ9J" + }, + "source": [ + "Instantiate the model." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sWvDDVoz3RB4", + "outputId": "08462e1d-77da-4f9d-d3e9-43bdd2be74b8" + }, + "source": [ + "from taming.models.cond_transformer import Net2NetTransformer\n", + "model = Net2NetTransformer(**config.model.params)" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n", + "Working with z of shape (1, 256, 16, 16) = 65536 dimensions.\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "njAiY_aqENwV" + }, + "source": [ + "Load the checkpoint." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "QABLRpVsDhba" + }, + "source": [ + "import torch\n", + "ckpt_path = \"logs/2020-11-09T13-31-51_sflckr/checkpoints/last.ckpt\"\n", + "sd = torch.load(ckpt_path, map_location=\"cpu\")[\"state_dict\"]\n", + "missing, unexpected = model.load_state_dict(sd, strict=False)" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iYN9cREY-r3N", + "outputId": "0954af07-f4b9-474a-d6bf-45355f2b360d" + }, + "source": [ + "model.cuda().eval()\n", + "torch.set_grad_enabled(False)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tTusbqk2y0u3" + }, + "source": [ + "## Load example data\n", + "\n", + "Load an example segmentation and visualize." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "8LiAOU6C-vTP" + }, + "source": [ + "from PIL import Image\n", + "import numpy as np\n", + "segmentation_path = \"data/sflckr_segmentations/norway/25735082181_999927fe5a_b.png\"\n", + "segmentation = Image.open(segmentation_path)\n", + "segmentation = np.array(segmentation)\n", + "segmentation = np.eye(182)[segmentation]\n", + "segmentation = torch.tensor(segmentation.transpose(2,0,1)[None]).to(dtype=torch.float32, device=model.device)" + ], + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oCNy13FGPMy6" + }, + "source": [ + "Visualize" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 700 + }, + "id": "eZFxCkQ5McKG", + "outputId": "367a3774-3fcc-405c-c643-4477aad91a2d" + }, + "source": [ + "def show_segmentation(s):\n", + " s = s.detach().cpu().numpy().transpose(0,2,3,1)[0,:,:,None,:]\n", + " colorize = np.random.RandomState(1).randn(1,1,s.shape[-1],3)\n", + " colorize = colorize / colorize.sum(axis=2, keepdims=True)\n", + " s = s@colorize\n", + " s = s[...,0,:]\n", + " s = ((s+1.0)*127.5).clip(0,255).astype(np.uint8)\n", + " s = Image.fromarray(s)\n", + " display(s)\n", + "\n", + "show_segmentation(segmentation)" + ], + "execution_count": 28, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hNBdHGbNTrfM" + }, + "source": [ + "Our model also employs a VQGAN for the conditioning information, i.e. the segmentation in this example. Let's autoencode the segmentation map. Encoding returns both the quantized code and its representation in terms of indices of a learned codebook." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 724 + }, + "id": "y_HS2hCCORLr", + "outputId": "770227a3-533e-4e77-a017-8f6a9b919940" + }, + "source": [ + "c_code, c_indices = model.encode_to_c(segmentation)\n", + "print(\"c_code\", c_code.shape, c_code.dtype)\n", + "print(\"c_indices\", c_indices.shape, c_indices.dtype)\n", + "assert c_code.shape[2]*c_code.shape[3] == c_indices.shape[0]\n", + "segmentation_rec = model.cond_stage_model.decode(c_code)\n", + "show_segmentation(torch.softmax(segmentation_rec, dim=1))" + ], + "execution_count": 29, + "outputs": [ + { + "output_type": "stream", + "text": [ + "c_code torch.Size([1, 256, 42, 64]) torch.float32\n", + "c_indices torch.Size([1, 2688]) torch.int64\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pp-OsC1RXAQ9" + }, + "source": [ + "Let's sample indices corresponding to codes from the image VQGAN given the segmentation code. We init randomly and take a look." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 689 + }, + "id": "VTfao3jJSCfW", + "outputId": "1a3320ff-a389-4759-ced3-5dee58bf7a29" + }, + "source": [ + "def show_image(s):\n", + " s = s.detach().cpu().numpy().transpose(0,2,3,1)[0]\n", + " s = ((s+1.0)*127.5).clip(0,255).astype(np.uint8)\n", + " s = Image.fromarray(s)\n", + " display(s)\n", + "\n", + "codebook_size = config.model.params.first_stage_config.params.embed_dim\n", + "z_indices_shape = c_indices.shape\n", + "z_code_shape = c_code.shape\n", + "z_indices = torch.randint(codebook_size, z_indices_shape, device=model.device)\n", + "x_sample = model.decode_to_img(z_indices, z_code_shape)\n", + "show_image(x_sample)" + ], + "execution_count": 30, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ftDWneY3zJZ5" + }, + "source": [ + "## Sample an image\n", + "\n", + "We use the transformer in a sliding window manner to sample all code entries sequentially. The code below assumes a window size of $16\\times 16$." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 724 + }, + "id": "5rVRrUOwbEH0", + "outputId": "f5f860e0-6a3c-44ac-9361-bd4d1be8318e" + }, + "source": [ + "from IPython.display import clear_output\n", + "import time\n", + "\n", + "idx = z_indices\n", + "idx = idx.reshape(z_code_shape[0],z_code_shape[2],z_code_shape[3])\n", + "\n", + "cidx = c_indices\n", + "cidx = cidx.reshape(c_code.shape[0],c_code.shape[2],c_code.shape[3])\n", + "\n", + "temperature = 1.0\n", + "top_k = 100\n", + "update_every = 50\n", + "\n", + "start_t = time.time()\n", + "for i in range(0, z_code_shape[2]-0):\n", + " if i <= 8:\n", + " local_i = i\n", + " elif z_code_shape[2]-i < 8:\n", + " local_i = 16-(z_code_shape[2]-i)\n", + " else:\n", + " local_i = 8\n", + " for j in range(0,z_code_shape[3]-0):\n", + " if j <= 8:\n", + " local_j = j\n", + " elif z_code_shape[3]-j < 8:\n", + " local_j = 16-(z_code_shape[3]-j)\n", + " else:\n", + " local_j = 8\n", + "\n", + " i_start = i-local_i\n", + " i_end = i_start+16\n", + " j_start = j-local_j\n", + " j_end = j_start+16\n", + " \n", + " patch = idx[:,i_start:i_end,j_start:j_end]\n", + " patch = patch.reshape(patch.shape[0],-1)\n", + " cpatch = cidx[:, i_start:i_end, j_start:j_end]\n", + " cpatch = cpatch.reshape(cpatch.shape[0], -1)\n", + " patch = torch.cat((cpatch, patch), dim=1)\n", + " logits,_ = model.transformer(patch[:,:-1])\n", + " logits = logits[:, -256:, :]\n", + " logits = logits.reshape(z_code_shape[0],16,16,-1)\n", + " logits = logits[:,local_i,local_j,:]\n", + "\n", + " logits = logits/temperature\n", + "\n", + " if top_k is not None:\n", + " logits = model.top_k_logits(logits, top_k)\n", + "\n", + " probs = torch.nn.functional.softmax(logits, dim=-1)\n", + " idx[:,i,j] = torch.multinomial(probs, num_samples=1)\n", + "\n", + " step = i*z_code_shape[3]+j\n", + " if step%update_every==0 or step==z_code_shape[2]*z_code_shape[3]-1:\n", + " x_sample = model.decode_to_img(idx, z_code_shape)\n", + " clear_output()\n", + " print(f\"Time: {time.time() - start_t} seconds\")\n", + " print(f\"Step: ({i},{j}) | Local: ({local_i},{local_j}) | Crop: ({i_start}:{i_end},{j_start}:{j_end})\")\n", + " show_image(x_sample)" + ], + "execution_count": 31, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Time: 378.9832909107208 seconds\n", + "Step: (41,63) | Local: (15,15) | Crop: (26:42,48:64)\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "3Pu-VjGHnFta" + }, + "source": [ + "" + ], + "execution_count": 31, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/src/taming-transformers/setup.py b/src/taming-transformers/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..a220d12b21d96c5093a218c406cf47f1e7c8761a --- /dev/null +++ b/src/taming-transformers/setup.py @@ -0,0 +1,13 @@ +from setuptools import setup, find_packages + +setup( + name='taming-transformers', + version='0.0.1', + description='Taming Transformers for High-Resolution Image Synthesis', + packages=find_packages(), + install_requires=[ + 'torch', + 'numpy', + 'tqdm', + ], +) diff --git a/src/taming-transformers/taming/data/ade20k.py b/src/taming-transformers/taming/data/ade20k.py new file mode 100644 index 0000000000000000000000000000000000000000..366dae97207dbb8356598d636e14ad084d45bc76 --- /dev/null +++ b/src/taming-transformers/taming/data/ade20k.py @@ -0,0 +1,124 @@ +import os +import numpy as np +import cv2 +import albumentations +from PIL import Image +from torch.utils.data import Dataset + +from taming.data.sflckr import SegmentationBase # for examples included in repo + + +class Examples(SegmentationBase): + def __init__(self, size=256, random_crop=False, interpolation="bicubic"): + super().__init__(data_csv="data/ade20k_examples.txt", + data_root="data/ade20k_images", + segmentation_root="data/ade20k_segmentations", + size=size, random_crop=random_crop, + interpolation=interpolation, + n_labels=151, shift_segmentation=False) + + +# With semantic map and scene label +class ADE20kBase(Dataset): + def __init__(self, config=None, size=None, random_crop=False, interpolation="bicubic", crop_size=None): + self.split = self.get_split() + self.n_labels = 151 # unknown + 150 + self.data_csv = {"train": "data/ade20k_train.txt", + "validation": "data/ade20k_test.txt"}[self.split] + self.data_root = "data/ade20k_root" + with open(os.path.join(self.data_root, "sceneCategories.txt"), "r") as f: + self.scene_categories = f.read().splitlines() + self.scene_categories = dict(line.split() for line in self.scene_categories) + with open(self.data_csv, "r") as f: + self.image_paths = f.read().splitlines() + self._length = len(self.image_paths) + self.labels = { + "relative_file_path_": [l for l in self.image_paths], + "file_path_": [os.path.join(self.data_root, "images", l) + for l in self.image_paths], + "relative_segmentation_path_": [l.replace(".jpg", ".png") + for l in self.image_paths], + "segmentation_path_": [os.path.join(self.data_root, "annotations", + l.replace(".jpg", ".png")) + for l in self.image_paths], + "scene_category": [self.scene_categories[l.split("/")[1].replace(".jpg", "")] + for l in self.image_paths], + } + + size = None if size is not None and size<=0 else size + self.size = size + if crop_size is None: + self.crop_size = size if size is not None else None + else: + self.crop_size = crop_size + if self.size is not None: + self.interpolation = interpolation + self.interpolation = { + "nearest": cv2.INTER_NEAREST, + "bilinear": cv2.INTER_LINEAR, + "bicubic": cv2.INTER_CUBIC, + "area": cv2.INTER_AREA, + "lanczos": cv2.INTER_LANCZOS4}[self.interpolation] + self.image_rescaler = albumentations.SmallestMaxSize(max_size=self.size, + interpolation=self.interpolation) + self.segmentation_rescaler = albumentations.SmallestMaxSize(max_size=self.size, + interpolation=cv2.INTER_NEAREST) + + if crop_size is not None: + self.center_crop = not random_crop + if self.center_crop: + self.cropper = albumentations.CenterCrop(height=self.crop_size, width=self.crop_size) + else: + self.cropper = albumentations.RandomCrop(height=self.crop_size, width=self.crop_size) + self.preprocessor = self.cropper + + def __len__(self): + return self._length + + def __getitem__(self, i): + example = dict((k, self.labels[k][i]) for k in self.labels) + image = Image.open(example["file_path_"]) + if not image.mode == "RGB": + image = image.convert("RGB") + image = np.array(image).astype(np.uint8) + if self.size is not None: + image = self.image_rescaler(image=image)["image"] + segmentation = Image.open(example["segmentation_path_"]) + segmentation = np.array(segmentation).astype(np.uint8) + if self.size is not None: + segmentation = self.segmentation_rescaler(image=segmentation)["image"] + if self.size is not None: + processed = self.preprocessor(image=image, mask=segmentation) + else: + processed = {"image": image, "mask": segmentation} + example["image"] = (processed["image"]/127.5 - 1.0).astype(np.float32) + segmentation = processed["mask"] + onehot = np.eye(self.n_labels)[segmentation] + example["segmentation"] = onehot + return example + + +class ADE20kTrain(ADE20kBase): + # default to random_crop=True + def __init__(self, config=None, size=None, random_crop=True, interpolation="bicubic", crop_size=None): + super().__init__(config=config, size=size, random_crop=random_crop, + interpolation=interpolation, crop_size=crop_size) + + def get_split(self): + return "train" + + +class ADE20kValidation(ADE20kBase): + def get_split(self): + return "validation" + + +if __name__ == "__main__": + dset = ADE20kValidation() + ex = dset[0] + for k in ["image", "scene_category", "segmentation"]: + print(type(ex[k])) + try: + print(ex[k].shape) + except: + print(ex[k]) diff --git a/src/taming-transformers/taming/data/annotated_objects_coco.py b/src/taming-transformers/taming/data/annotated_objects_coco.py new file mode 100644 index 0000000000000000000000000000000000000000..af000ecd943d7b8a85d7eb70195c9ecd10ab5edc --- /dev/null +++ b/src/taming-transformers/taming/data/annotated_objects_coco.py @@ -0,0 +1,139 @@ +import json +from itertools import chain +from pathlib import Path +from typing import Iterable, Dict, List, Callable, Any +from collections import defaultdict + +from tqdm import tqdm + +from taming.data.annotated_objects_dataset import AnnotatedObjectsDataset +from taming.data.helper_types import Annotation, ImageDescription, Category + +COCO_PATH_STRUCTURE = { + 'train': { + 'top_level': '', + 'instances_annotations': 'annotations/instances_train2017.json', + 'stuff_annotations': 'annotations/stuff_train2017.json', + 'files': 'train2017' + }, + 'validation': { + 'top_level': '', + 'instances_annotations': 'annotations/instances_val2017.json', + 'stuff_annotations': 'annotations/stuff_val2017.json', + 'files': 'val2017' + } +} + + +def load_image_descriptions(description_json: List[Dict]) -> Dict[str, ImageDescription]: + return { + str(img['id']): ImageDescription( + id=img['id'], + license=img.get('license'), + file_name=img['file_name'], + coco_url=img['coco_url'], + original_size=(img['width'], img['height']), + date_captured=img.get('date_captured'), + flickr_url=img.get('flickr_url') + ) + for img in description_json + } + + +def load_categories(category_json: Iterable) -> Dict[str, Category]: + return {str(cat['id']): Category(id=str(cat['id']), super_category=cat['supercategory'], name=cat['name']) + for cat in category_json if cat['name'] != 'other'} + + +def load_annotations(annotations_json: List[Dict], image_descriptions: Dict[str, ImageDescription], + category_no_for_id: Callable[[str], int], split: str) -> Dict[str, List[Annotation]]: + annotations = defaultdict(list) + total = sum(len(a) for a in annotations_json) + for ann in tqdm(chain(*annotations_json), f'Loading {split} annotations', total=total): + image_id = str(ann['image_id']) + if image_id not in image_descriptions: + raise ValueError(f'image_id [{image_id}] has no image description.') + category_id = ann['category_id'] + try: + category_no = category_no_for_id(str(category_id)) + except KeyError: + continue + + width, height = image_descriptions[image_id].original_size + bbox = (ann['bbox'][0] / width, ann['bbox'][1] / height, ann['bbox'][2] / width, ann['bbox'][3] / height) + + annotations[image_id].append( + Annotation( + id=ann['id'], + area=bbox[2]*bbox[3], # use bbox area + is_group_of=ann['iscrowd'], + image_id=ann['image_id'], + bbox=bbox, + category_id=str(category_id), + category_no=category_no + ) + ) + return dict(annotations) + + +class AnnotatedObjectsCoco(AnnotatedObjectsDataset): + def __init__(self, use_things: bool = True, use_stuff: bool = True, **kwargs): + """ + @param data_path: is the path to the following folder structure: + coco/ + ├── annotations + │ ├── instances_train2017.json + │ ├── instances_val2017.json + │ ├── stuff_train2017.json + │ └── stuff_val2017.json + ├── train2017 + │ ├── 000000000009.jpg + │ ├── 000000000025.jpg + │ └── ... + ├── val2017 + │ ├── 000000000139.jpg + │ ├── 000000000285.jpg + │ └── ... + @param: split: one of 'train' or 'validation' + @param: desired image size (give square images) + """ + super().__init__(**kwargs) + self.use_things = use_things + self.use_stuff = use_stuff + + with open(self.paths['instances_annotations']) as f: + inst_data_json = json.load(f) + with open(self.paths['stuff_annotations']) as f: + stuff_data_json = json.load(f) + + category_jsons = [] + annotation_jsons = [] + if self.use_things: + category_jsons.append(inst_data_json['categories']) + annotation_jsons.append(inst_data_json['annotations']) + if self.use_stuff: + category_jsons.append(stuff_data_json['categories']) + annotation_jsons.append(stuff_data_json['annotations']) + + self.categories = load_categories(chain(*category_jsons)) + self.filter_categories() + self.setup_category_id_and_number() + + self.image_descriptions = load_image_descriptions(inst_data_json['images']) + annotations = load_annotations(annotation_jsons, self.image_descriptions, self.get_category_number, self.split) + self.annotations = self.filter_object_number(annotations, self.min_object_area, + self.min_objects_per_image, self.max_objects_per_image) + self.image_ids = list(self.annotations.keys()) + self.clean_up_annotations_and_image_descriptions() + + def get_path_structure(self) -> Dict[str, str]: + if self.split not in COCO_PATH_STRUCTURE: + raise ValueError(f'Split [{self.split} does not exist for COCO data.]') + return COCO_PATH_STRUCTURE[self.split] + + def get_image_path(self, image_id: str) -> Path: + return self.paths['files'].joinpath(self.image_descriptions[str(image_id)].file_name) + + def get_image_description(self, image_id: str) -> Dict[str, Any]: + # noinspection PyProtectedMember + return self.image_descriptions[image_id]._asdict() diff --git a/src/taming-transformers/taming/data/annotated_objects_dataset.py b/src/taming-transformers/taming/data/annotated_objects_dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..53cc346a1c76289a4964d7dc8a29582172f33dc0 --- /dev/null +++ b/src/taming-transformers/taming/data/annotated_objects_dataset.py @@ -0,0 +1,218 @@ +from pathlib import Path +from typing import Optional, List, Callable, Dict, Any, Union +import warnings + +import PIL.Image as pil_image +from torch import Tensor +from torch.utils.data import Dataset +from torchvision import transforms + +from taming.data.conditional_builder.objects_bbox import ObjectsBoundingBoxConditionalBuilder +from taming.data.conditional_builder.objects_center_points import ObjectsCenterPointsConditionalBuilder +from taming.data.conditional_builder.utils import load_object_from_string +from taming.data.helper_types import BoundingBox, CropMethodType, Image, Annotation, SplitType +from taming.data.image_transforms import CenterCropReturnCoordinates, RandomCrop1dReturnCoordinates, \ + Random2dCropReturnCoordinates, RandomHorizontalFlipReturn, convert_pil_to_tensor + + +class AnnotatedObjectsDataset(Dataset): + def __init__(self, data_path: Union[str, Path], split: SplitType, keys: List[str], target_image_size: int, + min_object_area: float, min_objects_per_image: int, max_objects_per_image: int, + crop_method: CropMethodType, random_flip: bool, no_tokens: int, use_group_parameter: bool, + encode_crop: bool, category_allow_list_target: str = "", category_mapping_target: str = "", + no_object_classes: Optional[int] = None): + self.data_path = data_path + self.split = split + self.keys = keys + self.target_image_size = target_image_size + self.min_object_area = min_object_area + self.min_objects_per_image = min_objects_per_image + self.max_objects_per_image = max_objects_per_image + self.crop_method = crop_method + self.random_flip = random_flip + self.no_tokens = no_tokens + self.use_group_parameter = use_group_parameter + self.encode_crop = encode_crop + + self.annotations = None + self.image_descriptions = None + self.categories = None + self.category_ids = None + self.category_number = None + self.image_ids = None + self.transform_functions: List[Callable] = self.setup_transform(target_image_size, crop_method, random_flip) + self.paths = self.build_paths(self.data_path) + self._conditional_builders = None + self.category_allow_list = None + if category_allow_list_target: + allow_list = load_object_from_string(category_allow_list_target) + self.category_allow_list = {name for name, _ in allow_list} + self.category_mapping = {} + if category_mapping_target: + self.category_mapping = load_object_from_string(category_mapping_target) + self.no_object_classes = no_object_classes + + def build_paths(self, top_level: Union[str, Path]) -> Dict[str, Path]: + top_level = Path(top_level) + sub_paths = {name: top_level.joinpath(sub_path) for name, sub_path in self.get_path_structure().items()} + for path in sub_paths.values(): + if not path.exists(): + raise FileNotFoundError(f'{type(self).__name__} data structure error: [{path}] does not exist.') + return sub_paths + + @staticmethod + def load_image_from_disk(path: Path) -> Image: + return pil_image.open(path).convert('RGB') + + @staticmethod + def setup_transform(target_image_size: int, crop_method: CropMethodType, random_flip: bool): + transform_functions = [] + if crop_method == 'none': + transform_functions.append(transforms.Resize((target_image_size, target_image_size))) + elif crop_method == 'center': + transform_functions.extend([ + transforms.Resize(target_image_size), + CenterCropReturnCoordinates(target_image_size) + ]) + elif crop_method == 'random-1d': + transform_functions.extend([ + transforms.Resize(target_image_size), + RandomCrop1dReturnCoordinates(target_image_size) + ]) + elif crop_method == 'random-2d': + transform_functions.extend([ + Random2dCropReturnCoordinates(target_image_size), + transforms.Resize(target_image_size) + ]) + elif crop_method is None: + return None + else: + raise ValueError(f'Received invalid crop method [{crop_method}].') + if random_flip: + transform_functions.append(RandomHorizontalFlipReturn()) + transform_functions.append(transforms.Lambda(lambda x: x / 127.5 - 1.)) + return transform_functions + + def image_transform(self, x: Tensor) -> (Optional[BoundingBox], Optional[bool], Tensor): + crop_bbox = None + flipped = None + for t in self.transform_functions: + if isinstance(t, (RandomCrop1dReturnCoordinates, CenterCropReturnCoordinates, Random2dCropReturnCoordinates)): + crop_bbox, x = t(x) + elif isinstance(t, RandomHorizontalFlipReturn): + flipped, x = t(x) + else: + x = t(x) + return crop_bbox, flipped, x + + @property + def no_classes(self) -> int: + return self.no_object_classes if self.no_object_classes else len(self.categories) + + @property + def conditional_builders(self) -> ObjectsCenterPointsConditionalBuilder: + # cannot set this up in init because no_classes is only known after loading data in init of superclass + if self._conditional_builders is None: + self._conditional_builders = { + 'objects_center_points': ObjectsCenterPointsConditionalBuilder( + self.no_classes, + self.max_objects_per_image, + self.no_tokens, + self.encode_crop, + self.use_group_parameter, + getattr(self, 'use_additional_parameters', False) + ), + 'objects_bbox': ObjectsBoundingBoxConditionalBuilder( + self.no_classes, + self.max_objects_per_image, + self.no_tokens, + self.encode_crop, + self.use_group_parameter, + getattr(self, 'use_additional_parameters', False) + ) + } + return self._conditional_builders + + def filter_categories(self) -> None: + if self.category_allow_list: + self.categories = {id_: cat for id_, cat in self.categories.items() if cat.name in self.category_allow_list} + if self.category_mapping: + self.categories = {id_: cat for id_, cat in self.categories.items() if cat.id not in self.category_mapping} + + def setup_category_id_and_number(self) -> None: + self.category_ids = list(self.categories.keys()) + self.category_ids.sort() + if '/m/01s55n' in self.category_ids: + self.category_ids.remove('/m/01s55n') + self.category_ids.append('/m/01s55n') + self.category_number = {category_id: i for i, category_id in enumerate(self.category_ids)} + if self.category_allow_list is not None and self.category_mapping is None \ + and len(self.category_ids) != len(self.category_allow_list): + warnings.warn('Unexpected number of categories: Mismatch with category_allow_list. ' + 'Make sure all names in category_allow_list exist.') + + def clean_up_annotations_and_image_descriptions(self) -> None: + image_id_set = set(self.image_ids) + self.annotations = {k: v for k, v in self.annotations.items() if k in image_id_set} + self.image_descriptions = {k: v for k, v in self.image_descriptions.items() if k in image_id_set} + + @staticmethod + def filter_object_number(all_annotations: Dict[str, List[Annotation]], min_object_area: float, + min_objects_per_image: int, max_objects_per_image: int) -> Dict[str, List[Annotation]]: + filtered = {} + for image_id, annotations in all_annotations.items(): + annotations_with_min_area = [a for a in annotations if a.area > min_object_area] + if min_objects_per_image <= len(annotations_with_min_area) <= max_objects_per_image: + filtered[image_id] = annotations_with_min_area + return filtered + + def __len__(self): + return len(self.image_ids) + + def __getitem__(self, n: int) -> Dict[str, Any]: + image_id = self.get_image_id(n) + sample = self.get_image_description(image_id) + sample['annotations'] = self.get_annotation(image_id) + + if 'image' in self.keys: + sample['image_path'] = str(self.get_image_path(image_id)) + sample['image'] = self.load_image_from_disk(sample['image_path']) + sample['image'] = convert_pil_to_tensor(sample['image']) + sample['crop_bbox'], sample['flipped'], sample['image'] = self.image_transform(sample['image']) + sample['image'] = sample['image'].permute(1, 2, 0) + + for conditional, builder in self.conditional_builders.items(): + if conditional in self.keys: + sample[conditional] = builder.build(sample['annotations'], sample['crop_bbox'], sample['flipped']) + + if self.keys: + # only return specified keys + sample = {key: sample[key] for key in self.keys} + return sample + + def get_image_id(self, no: int) -> str: + return self.image_ids[no] + + def get_annotation(self, image_id: str) -> str: + return self.annotations[image_id] + + def get_textual_label_for_category_id(self, category_id: str) -> str: + return self.categories[category_id].name + + def get_textual_label_for_category_no(self, category_no: int) -> str: + return self.categories[self.get_category_id(category_no)].name + + def get_category_number(self, category_id: str) -> int: + return self.category_number[category_id] + + def get_category_id(self, category_no: int) -> str: + return self.category_ids[category_no] + + def get_image_description(self, image_id: str) -> Dict[str, Any]: + raise NotImplementedError() + + def get_path_structure(self): + raise NotImplementedError + + def get_image_path(self, image_id: str) -> Path: + raise NotImplementedError diff --git a/src/taming-transformers/taming/data/annotated_objects_open_images.py b/src/taming-transformers/taming/data/annotated_objects_open_images.py new file mode 100644 index 0000000000000000000000000000000000000000..aede6803d2cef7a74ca784e7907d35fba6c71239 --- /dev/null +++ b/src/taming-transformers/taming/data/annotated_objects_open_images.py @@ -0,0 +1,137 @@ +from collections import defaultdict +from csv import DictReader, reader as TupleReader +from pathlib import Path +from typing import Dict, List, Any +import warnings + +from taming.data.annotated_objects_dataset import AnnotatedObjectsDataset +from taming.data.helper_types import Annotation, Category +from tqdm import tqdm + +OPEN_IMAGES_STRUCTURE = { + 'train': { + 'top_level': '', + 'class_descriptions': 'class-descriptions-boxable.csv', + 'annotations': 'oidv6-train-annotations-bbox.csv', + 'file_list': 'train-images-boxable.csv', + 'files': 'train' + }, + 'validation': { + 'top_level': '', + 'class_descriptions': 'class-descriptions-boxable.csv', + 'annotations': 'validation-annotations-bbox.csv', + 'file_list': 'validation-images.csv', + 'files': 'validation' + }, + 'test': { + 'top_level': '', + 'class_descriptions': 'class-descriptions-boxable.csv', + 'annotations': 'test-annotations-bbox.csv', + 'file_list': 'test-images.csv', + 'files': 'test' + } +} + + +def load_annotations(descriptor_path: Path, min_object_area: float, category_mapping: Dict[str, str], + category_no_for_id: Dict[str, int]) -> Dict[str, List[Annotation]]: + annotations: Dict[str, List[Annotation]] = defaultdict(list) + with open(descriptor_path) as file: + reader = DictReader(file) + for i, row in tqdm(enumerate(reader), total=14620000, desc='Loading OpenImages annotations'): + width = float(row['XMax']) - float(row['XMin']) + height = float(row['YMax']) - float(row['YMin']) + area = width * height + category_id = row['LabelName'] + if category_id in category_mapping: + category_id = category_mapping[category_id] + if area >= min_object_area and category_id in category_no_for_id: + annotations[row['ImageID']].append( + Annotation( + id=i, + image_id=row['ImageID'], + source=row['Source'], + category_id=category_id, + category_no=category_no_for_id[category_id], + confidence=float(row['Confidence']), + bbox=(float(row['XMin']), float(row['YMin']), width, height), + area=area, + is_occluded=bool(int(row['IsOccluded'])), + is_truncated=bool(int(row['IsTruncated'])), + is_group_of=bool(int(row['IsGroupOf'])), + is_depiction=bool(int(row['IsDepiction'])), + is_inside=bool(int(row['IsInside'])) + ) + ) + if 'train' in str(descriptor_path) and i < 14000000: + warnings.warn(f'Running with subset of Open Images. Train dataset has length [{len(annotations)}].') + return dict(annotations) + + +def load_image_ids(csv_path: Path) -> List[str]: + with open(csv_path) as file: + reader = DictReader(file) + return [row['image_name'] for row in reader] + + +def load_categories(csv_path: Path) -> Dict[str, Category]: + with open(csv_path) as file: + reader = TupleReader(file) + return {row[0]: Category(id=row[0], name=row[1], super_category=None) for row in reader} + + +class AnnotatedObjectsOpenImages(AnnotatedObjectsDataset): + def __init__(self, use_additional_parameters: bool, **kwargs): + """ + @param data_path: is the path to the following folder structure: + open_images/ + │ oidv6-train-annotations-bbox.csv + ├── class-descriptions-boxable.csv + ├── oidv6-train-annotations-bbox.csv + ├── test + │ ├── 000026e7ee790996.jpg + │ ├── 000062a39995e348.jpg + │ └── ... + ├── test-annotations-bbox.csv + ├── test-images.csv + ├── train + │ ├── 000002b66c9c498e.jpg + │ ├── 000002b97e5471a0.jpg + │ └── ... + ├── train-images-boxable.csv + ├── validation + │ ├── 0001eeaf4aed83f9.jpg + │ ├── 0004886b7d043cfd.jpg + │ └── ... + ├── validation-annotations-bbox.csv + └── validation-images.csv + @param: split: one of 'train', 'validation' or 'test' + @param: desired image size (returns square images) + """ + + super().__init__(**kwargs) + self.use_additional_parameters = use_additional_parameters + + self.categories = load_categories(self.paths['class_descriptions']) + self.filter_categories() + self.setup_category_id_and_number() + + self.image_descriptions = {} + annotations = load_annotations(self.paths['annotations'], self.min_object_area, self.category_mapping, + self.category_number) + self.annotations = self.filter_object_number(annotations, self.min_object_area, self.min_objects_per_image, + self.max_objects_per_image) + self.image_ids = list(self.annotations.keys()) + self.clean_up_annotations_and_image_descriptions() + + def get_path_structure(self) -> Dict[str, str]: + if self.split not in OPEN_IMAGES_STRUCTURE: + raise ValueError(f'Split [{self.split} does not exist for Open Images data.]') + return OPEN_IMAGES_STRUCTURE[self.split] + + def get_image_path(self, image_id: str) -> Path: + return self.paths['files'].joinpath(f'{image_id:0>16}.jpg') + + def get_image_description(self, image_id: str) -> Dict[str, Any]: + image_path = self.get_image_path(image_id) + return {'file_path': str(image_path), 'file_name': image_path.name} diff --git a/src/taming-transformers/taming/data/base.py b/src/taming-transformers/taming/data/base.py new file mode 100644 index 0000000000000000000000000000000000000000..e21667df4ce4baa6bb6aad9f8679bd756e2ffdb7 --- /dev/null +++ b/src/taming-transformers/taming/data/base.py @@ -0,0 +1,70 @@ +import bisect +import numpy as np +import albumentations +from PIL import Image +from torch.utils.data import Dataset, ConcatDataset + + +class ConcatDatasetWithIndex(ConcatDataset): + """Modified from original pytorch code to return dataset idx""" + def __getitem__(self, idx): + if idx < 0: + if -idx > len(self): + raise ValueError("absolute value of index should not exceed dataset length") + idx = len(self) + idx + dataset_idx = bisect.bisect_right(self.cumulative_sizes, idx) + if dataset_idx == 0: + sample_idx = idx + else: + sample_idx = idx - self.cumulative_sizes[dataset_idx - 1] + return self.datasets[dataset_idx][sample_idx], dataset_idx + + +class ImagePaths(Dataset): + def __init__(self, paths, size=None, random_crop=False, labels=None): + self.size = size + self.random_crop = random_crop + + self.labels = dict() if labels is None else labels + self.labels["file_path_"] = paths + self._length = len(paths) + + if self.size is not None and self.size > 0: + self.rescaler = albumentations.SmallestMaxSize(max_size = self.size) + if not self.random_crop: + self.cropper = albumentations.CenterCrop(height=self.size,width=self.size) + else: + self.cropper = albumentations.RandomCrop(height=self.size,width=self.size) + self.preprocessor = albumentations.Compose([self.rescaler, self.cropper]) + else: + self.preprocessor = lambda **kwargs: kwargs + + def __len__(self): + return self._length + + def preprocess_image(self, image_path): + image = Image.open(image_path) + if not image.mode == "RGB": + image = image.convert("RGB") + image = np.array(image).astype(np.uint8) + image = self.preprocessor(image=image)["image"] + image = (image/127.5 - 1.0).astype(np.float32) + return image + + def __getitem__(self, i): + example = dict() + example["image"] = self.preprocess_image(self.labels["file_path_"][i]) + for k in self.labels: + example[k] = self.labels[k][i] + return example + + +class NumpyPaths(ImagePaths): + def preprocess_image(self, image_path): + image = np.load(image_path).squeeze(0) # 3 x 1024 x 1024 + image = np.transpose(image, (1,2,0)) + image = Image.fromarray(image, mode="RGB") + image = np.array(image).astype(np.uint8) + image = self.preprocessor(image=image)["image"] + image = (image/127.5 - 1.0).astype(np.float32) + return image diff --git a/src/taming-transformers/taming/data/coco.py b/src/taming-transformers/taming/data/coco.py new file mode 100644 index 0000000000000000000000000000000000000000..2b2f7838448cb63dcf96daffe9470d58566d975a --- /dev/null +++ b/src/taming-transformers/taming/data/coco.py @@ -0,0 +1,176 @@ +import os +import json +import albumentations +import numpy as np +from PIL import Image +from tqdm import tqdm +from torch.utils.data import Dataset + +from taming.data.sflckr import SegmentationBase # for examples included in repo + + +class Examples(SegmentationBase): + def __init__(self, size=256, random_crop=False, interpolation="bicubic"): + super().__init__(data_csv="data/coco_examples.txt", + data_root="data/coco_images", + segmentation_root="data/coco_segmentations", + size=size, random_crop=random_crop, + interpolation=interpolation, + n_labels=183, shift_segmentation=True) + + +class CocoBase(Dataset): + """needed for (image, caption, segmentation) pairs""" + def __init__(self, size=None, dataroot="", datajson="", onehot_segmentation=False, use_stuffthing=False, + crop_size=None, force_no_crop=False, given_files=None): + self.split = self.get_split() + self.size = size + if crop_size is None: + self.crop_size = size + else: + self.crop_size = crop_size + + self.onehot = onehot_segmentation # return segmentation as rgb or one hot + self.stuffthing = use_stuffthing # include thing in segmentation + if self.onehot and not self.stuffthing: + raise NotImplemented("One hot mode is only supported for the " + "stuffthings version because labels are stored " + "a bit different.") + + data_json = datajson + with open(data_json) as json_file: + self.json_data = json.load(json_file) + self.img_id_to_captions = dict() + self.img_id_to_filepath = dict() + self.img_id_to_segmentation_filepath = dict() + + assert data_json.split("/")[-1] in ["captions_train2017.json", + "captions_val2017.json"] + if self.stuffthing: + self.segmentation_prefix = ( + "data/cocostuffthings/val2017" if + data_json.endswith("captions_val2017.json") else + "data/cocostuffthings/train2017") + else: + self.segmentation_prefix = ( + "data/coco/annotations/stuff_val2017_pixelmaps" if + data_json.endswith("captions_val2017.json") else + "data/coco/annotations/stuff_train2017_pixelmaps") + + imagedirs = self.json_data["images"] + self.labels = {"image_ids": list()} + for imgdir in tqdm(imagedirs, desc="ImgToPath"): + self.img_id_to_filepath[imgdir["id"]] = os.path.join(dataroot, imgdir["file_name"]) + self.img_id_to_captions[imgdir["id"]] = list() + pngfilename = imgdir["file_name"].replace("jpg", "png") + self.img_id_to_segmentation_filepath[imgdir["id"]] = os.path.join( + self.segmentation_prefix, pngfilename) + if given_files is not None: + if pngfilename in given_files: + self.labels["image_ids"].append(imgdir["id"]) + else: + self.labels["image_ids"].append(imgdir["id"]) + + capdirs = self.json_data["annotations"] + for capdir in tqdm(capdirs, desc="ImgToCaptions"): + # there are in average 5 captions per image + self.img_id_to_captions[capdir["image_id"]].append(np.array([capdir["caption"]])) + + self.rescaler = albumentations.SmallestMaxSize(max_size=self.size) + if self.split=="validation": + self.cropper = albumentations.CenterCrop(height=self.crop_size, width=self.crop_size) + else: + self.cropper = albumentations.RandomCrop(height=self.crop_size, width=self.crop_size) + self.preprocessor = albumentations.Compose( + [self.rescaler, self.cropper], + additional_targets={"segmentation": "image"}) + if force_no_crop: + self.rescaler = albumentations.Resize(height=self.size, width=self.size) + self.preprocessor = albumentations.Compose( + [self.rescaler], + additional_targets={"segmentation": "image"}) + + def __len__(self): + return len(self.labels["image_ids"]) + + def preprocess_image(self, image_path, segmentation_path): + image = Image.open(image_path) + if not image.mode == "RGB": + image = image.convert("RGB") + image = np.array(image).astype(np.uint8) + + segmentation = Image.open(segmentation_path) + if not self.onehot and not segmentation.mode == "RGB": + segmentation = segmentation.convert("RGB") + segmentation = np.array(segmentation).astype(np.uint8) + if self.onehot: + assert self.stuffthing + # stored in caffe format: unlabeled==255. stuff and thing from + # 0-181. to be compatible with the labels in + # https://github.com/nightrome/cocostuff/blob/master/labels.txt + # we shift stuffthing one to the right and put unlabeled in zero + # as long as segmentation is uint8 shifting to right handles the + # latter too + assert segmentation.dtype == np.uint8 + segmentation = segmentation + 1 + + processed = self.preprocessor(image=image, segmentation=segmentation) + image, segmentation = processed["image"], processed["segmentation"] + image = (image / 127.5 - 1.0).astype(np.float32) + + if self.onehot: + assert segmentation.dtype == np.uint8 + # make it one hot + n_labels = 183 + flatseg = np.ravel(segmentation) + onehot = np.zeros((flatseg.size, n_labels), dtype=np.bool) + onehot[np.arange(flatseg.size), flatseg] = True + onehot = onehot.reshape(segmentation.shape + (n_labels,)).astype(int) + segmentation = onehot + else: + segmentation = (segmentation / 127.5 - 1.0).astype(np.float32) + return image, segmentation + + def __getitem__(self, i): + img_path = self.img_id_to_filepath[self.labels["image_ids"][i]] + seg_path = self.img_id_to_segmentation_filepath[self.labels["image_ids"][i]] + image, segmentation = self.preprocess_image(img_path, seg_path) + captions = self.img_id_to_captions[self.labels["image_ids"][i]] + # randomly draw one of all available captions per image + caption = captions[np.random.randint(0, len(captions))] + example = {"image": image, + "caption": [str(caption[0])], + "segmentation": segmentation, + "img_path": img_path, + "seg_path": seg_path, + "filename_": img_path.split(os.sep)[-1] + } + return example + + +class CocoImagesAndCaptionsTrain(CocoBase): + """returns a pair of (image, caption)""" + def __init__(self, size, onehot_segmentation=False, use_stuffthing=False, crop_size=None, force_no_crop=False): + super().__init__(size=size, + dataroot="data/coco/train2017", + datajson="data/coco/annotations/captions_train2017.json", + onehot_segmentation=onehot_segmentation, + use_stuffthing=use_stuffthing, crop_size=crop_size, force_no_crop=force_no_crop) + + def get_split(self): + return "train" + + +class CocoImagesAndCaptionsValidation(CocoBase): + """returns a pair of (image, caption)""" + def __init__(self, size, onehot_segmentation=False, use_stuffthing=False, crop_size=None, force_no_crop=False, + given_files=None): + super().__init__(size=size, + dataroot="data/coco/val2017", + datajson="data/coco/annotations/captions_val2017.json", + onehot_segmentation=onehot_segmentation, + use_stuffthing=use_stuffthing, crop_size=crop_size, force_no_crop=force_no_crop, + given_files=given_files) + + def get_split(self): + return "validation" diff --git a/src/taming-transformers/taming/data/conditional_builder/objects_bbox.py b/src/taming-transformers/taming/data/conditional_builder/objects_bbox.py new file mode 100644 index 0000000000000000000000000000000000000000..15881e76b7ab2a914df8f2dfe08ae4f0c6c511b5 --- /dev/null +++ b/src/taming-transformers/taming/data/conditional_builder/objects_bbox.py @@ -0,0 +1,60 @@ +from itertools import cycle +from typing import List, Tuple, Callable, Optional + +from PIL import Image as pil_image, ImageDraw as pil_img_draw, ImageFont +from more_itertools.recipes import grouper +from taming.data.image_transforms import convert_pil_to_tensor +from torch import LongTensor, Tensor + +from taming.data.helper_types import BoundingBox, Annotation +from taming.data.conditional_builder.objects_center_points import ObjectsCenterPointsConditionalBuilder +from taming.data.conditional_builder.utils import COLOR_PALETTE, WHITE, GRAY_75, BLACK, additional_parameters_string, \ + pad_list, get_plot_font_size, absolute_bbox + + +class ObjectsBoundingBoxConditionalBuilder(ObjectsCenterPointsConditionalBuilder): + @property + def object_descriptor_length(self) -> int: + return 3 + + def _make_object_descriptors(self, annotations: List[Annotation]) -> List[Tuple[int, ...]]: + object_triples = [ + (self.object_representation(ann), *self.token_pair_from_bbox(ann.bbox)) + for ann in annotations + ] + empty_triple = (self.none, self.none, self.none) + object_triples = pad_list(object_triples, empty_triple, self.no_max_objects) + return object_triples + + def inverse_build(self, conditional: LongTensor) -> Tuple[List[Tuple[int, BoundingBox]], Optional[BoundingBox]]: + conditional_list = conditional.tolist() + crop_coordinates = None + if self.encode_crop: + crop_coordinates = self.bbox_from_token_pair(conditional_list[-2], conditional_list[-1]) + conditional_list = conditional_list[:-2] + object_triples = grouper(conditional_list, 3) + assert conditional.shape[0] == self.embedding_dim + return [ + (object_triple[0], self.bbox_from_token_pair(object_triple[1], object_triple[2])) + for object_triple in object_triples if object_triple[0] != self.none + ], crop_coordinates + + def plot(self, conditional: LongTensor, label_for_category_no: Callable[[int], str], figure_size: Tuple[int, int], + line_width: int = 3, font_size: Optional[int] = None) -> Tensor: + plot = pil_image.new('RGB', figure_size, WHITE) + draw = pil_img_draw.Draw(plot) + font = ImageFont.truetype( + "/usr/share/fonts/truetype/lato/Lato-Regular.ttf", + size=get_plot_font_size(font_size, figure_size) + ) + width, height = plot.size + description, crop_coordinates = self.inverse_build(conditional) + for (representation, bbox), color in zip(description, cycle(COLOR_PALETTE)): + annotation = self.representation_to_annotation(representation) + class_label = label_for_category_no(annotation.category_no) + ' ' + additional_parameters_string(annotation) + bbox = absolute_bbox(bbox, width, height) + draw.rectangle(bbox, outline=color, width=line_width) + draw.text((bbox[0] + line_width, bbox[1] + line_width), class_label, anchor='la', fill=BLACK, font=font) + if crop_coordinates is not None: + draw.rectangle(absolute_bbox(crop_coordinates, width, height), outline=GRAY_75, width=line_width) + return convert_pil_to_tensor(plot) / 127.5 - 1. diff --git a/src/taming-transformers/taming/data/conditional_builder/objects_center_points.py b/src/taming-transformers/taming/data/conditional_builder/objects_center_points.py new file mode 100644 index 0000000000000000000000000000000000000000..9a480329cc47fb38a7b8729d424e092b77d40749 --- /dev/null +++ b/src/taming-transformers/taming/data/conditional_builder/objects_center_points.py @@ -0,0 +1,168 @@ +import math +import random +import warnings +from itertools import cycle +from typing import List, Optional, Tuple, Callable + +from PIL import Image as pil_image, ImageDraw as pil_img_draw, ImageFont +from more_itertools.recipes import grouper +from taming.data.conditional_builder.utils import COLOR_PALETTE, WHITE, GRAY_75, BLACK, FULL_CROP, filter_annotations, \ + additional_parameters_string, horizontally_flip_bbox, pad_list, get_circle_size, get_plot_font_size, \ + absolute_bbox, rescale_annotations +from taming.data.helper_types import BoundingBox, Annotation +from taming.data.image_transforms import convert_pil_to_tensor +from torch import LongTensor, Tensor + + +class ObjectsCenterPointsConditionalBuilder: + def __init__(self, no_object_classes: int, no_max_objects: int, no_tokens: int, encode_crop: bool, + use_group_parameter: bool, use_additional_parameters: bool): + self.no_object_classes = no_object_classes + self.no_max_objects = no_max_objects + self.no_tokens = no_tokens + self.encode_crop = encode_crop + self.no_sections = int(math.sqrt(self.no_tokens)) + self.use_group_parameter = use_group_parameter + self.use_additional_parameters = use_additional_parameters + + @property + def none(self) -> int: + return self.no_tokens - 1 + + @property + def object_descriptor_length(self) -> int: + return 2 + + @property + def embedding_dim(self) -> int: + extra_length = 2 if self.encode_crop else 0 + return self.no_max_objects * self.object_descriptor_length + extra_length + + def tokenize_coordinates(self, x: float, y: float) -> int: + """ + Express 2d coordinates with one number. + Example: assume self.no_tokens = 16, then no_sections = 4: + 0 0 0 0 + 0 0 # 0 + 0 0 0 0 + 0 0 0 x + Then the # position corresponds to token 6, the x position to token 15. + @param x: float in [0, 1] + @param y: float in [0, 1] + @return: discrete tokenized coordinate + """ + x_discrete = int(round(x * (self.no_sections - 1))) + y_discrete = int(round(y * (self.no_sections - 1))) + return y_discrete * self.no_sections + x_discrete + + def coordinates_from_token(self, token: int) -> (float, float): + x = token % self.no_sections + y = token // self.no_sections + return x / (self.no_sections - 1), y / (self.no_sections - 1) + + def bbox_from_token_pair(self, token1: int, token2: int) -> BoundingBox: + x0, y0 = self.coordinates_from_token(token1) + x1, y1 = self.coordinates_from_token(token2) + return x0, y0, x1 - x0, y1 - y0 + + def token_pair_from_bbox(self, bbox: BoundingBox) -> Tuple[int, int]: + return self.tokenize_coordinates(bbox[0], bbox[1]), \ + self.tokenize_coordinates(bbox[0] + bbox[2], bbox[1] + bbox[3]) + + def inverse_build(self, conditional: LongTensor) \ + -> Tuple[List[Tuple[int, Tuple[float, float]]], Optional[BoundingBox]]: + conditional_list = conditional.tolist() + crop_coordinates = None + if self.encode_crop: + crop_coordinates = self.bbox_from_token_pair(conditional_list[-2], conditional_list[-1]) + conditional_list = conditional_list[:-2] + table_of_content = grouper(conditional_list, self.object_descriptor_length) + assert conditional.shape[0] == self.embedding_dim + return [ + (object_tuple[0], self.coordinates_from_token(object_tuple[1])) + for object_tuple in table_of_content if object_tuple[0] != self.none + ], crop_coordinates + + def plot(self, conditional: LongTensor, label_for_category_no: Callable[[int], str], figure_size: Tuple[int, int], + line_width: int = 3, font_size: Optional[int] = None) -> Tensor: + plot = pil_image.new('RGB', figure_size, WHITE) + draw = pil_img_draw.Draw(plot) + circle_size = get_circle_size(figure_size) + font = ImageFont.truetype('/usr/share/fonts/truetype/lato/Lato-Regular.ttf', + size=get_plot_font_size(font_size, figure_size)) + width, height = plot.size + description, crop_coordinates = self.inverse_build(conditional) + for (representation, (x, y)), color in zip(description, cycle(COLOR_PALETTE)): + x_abs, y_abs = x * width, y * height + ann = self.representation_to_annotation(representation) + label = label_for_category_no(ann.category_no) + ' ' + additional_parameters_string(ann) + ellipse_bbox = [x_abs - circle_size, y_abs - circle_size, x_abs + circle_size, y_abs + circle_size] + draw.ellipse(ellipse_bbox, fill=color, width=0) + draw.text((x_abs, y_abs), label, anchor='md', fill=BLACK, font=font) + if crop_coordinates is not None: + draw.rectangle(absolute_bbox(crop_coordinates, width, height), outline=GRAY_75, width=line_width) + return convert_pil_to_tensor(plot) / 127.5 - 1. + + def object_representation(self, annotation: Annotation) -> int: + modifier = 0 + if self.use_group_parameter: + modifier |= 1 * (annotation.is_group_of is True) + if self.use_additional_parameters: + modifier |= 2 * (annotation.is_occluded is True) + modifier |= 4 * (annotation.is_depiction is True) + modifier |= 8 * (annotation.is_inside is True) + return annotation.category_no + self.no_object_classes * modifier + + def representation_to_annotation(self, representation: int) -> Annotation: + category_no = representation % self.no_object_classes + modifier = representation // self.no_object_classes + # noinspection PyTypeChecker + return Annotation( + area=None, image_id=None, bbox=None, category_id=None, id=None, source=None, confidence=None, + category_no=category_no, + is_group_of=bool((modifier & 1) * self.use_group_parameter), + is_occluded=bool((modifier & 2) * self.use_additional_parameters), + is_depiction=bool((modifier & 4) * self.use_additional_parameters), + is_inside=bool((modifier & 8) * self.use_additional_parameters) + ) + + def _crop_encoder(self, crop_coordinates: BoundingBox) -> List[int]: + return list(self.token_pair_from_bbox(crop_coordinates)) + + def _make_object_descriptors(self, annotations: List[Annotation]) -> List[Tuple[int, ...]]: + object_tuples = [ + (self.object_representation(a), + self.tokenize_coordinates(a.bbox[0] + a.bbox[2] / 2, a.bbox[1] + a.bbox[3] / 2)) + for a in annotations + ] + empty_tuple = (self.none, self.none) + object_tuples = pad_list(object_tuples, empty_tuple, self.no_max_objects) + return object_tuples + + def build(self, annotations: List, crop_coordinates: Optional[BoundingBox] = None, horizontal_flip: bool = False) \ + -> LongTensor: + if len(annotations) == 0: + warnings.warn('Did not receive any annotations.') + if len(annotations) > self.no_max_objects: + warnings.warn('Received more annotations than allowed.') + annotations = annotations[:self.no_max_objects] + + if not crop_coordinates: + crop_coordinates = FULL_CROP + + random.shuffle(annotations) + annotations = filter_annotations(annotations, crop_coordinates) + if self.encode_crop: + annotations = rescale_annotations(annotations, FULL_CROP, horizontal_flip) + if horizontal_flip: + crop_coordinates = horizontally_flip_bbox(crop_coordinates) + extra = self._crop_encoder(crop_coordinates) + else: + annotations = rescale_annotations(annotations, crop_coordinates, horizontal_flip) + extra = [] + + object_tuples = self._make_object_descriptors(annotations) + flattened = [token for tuple_ in object_tuples for token in tuple_] + extra + assert len(flattened) == self.embedding_dim + assert all(0 <= value < self.no_tokens for value in flattened) + return LongTensor(flattened) diff --git a/src/taming-transformers/taming/data/conditional_builder/utils.py b/src/taming-transformers/taming/data/conditional_builder/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d0ee175f2e05a80dbc71c22acbecb22dddadbb42 --- /dev/null +++ b/src/taming-transformers/taming/data/conditional_builder/utils.py @@ -0,0 +1,105 @@ +import importlib +from typing import List, Any, Tuple, Optional + +from taming.data.helper_types import BoundingBox, Annotation + +# source: seaborn, color palette tab10 +COLOR_PALETTE = [(30, 118, 179), (255, 126, 13), (43, 159, 43), (213, 38, 39), (147, 102, 188), + (139, 85, 74), (226, 118, 193), (126, 126, 126), (187, 188, 33), (22, 189, 206)] +BLACK = (0, 0, 0) +GRAY_75 = (63, 63, 63) +GRAY_50 = (127, 127, 127) +GRAY_25 = (191, 191, 191) +WHITE = (255, 255, 255) +FULL_CROP = (0., 0., 1., 1.) + + +def intersection_area(rectangle1: BoundingBox, rectangle2: BoundingBox) -> float: + """ + Give intersection area of two rectangles. + @param rectangle1: (x0, y0, w, h) of first rectangle + @param rectangle2: (x0, y0, w, h) of second rectangle + """ + rectangle1 = rectangle1[0], rectangle1[1], rectangle1[0] + rectangle1[2], rectangle1[1] + rectangle1[3] + rectangle2 = rectangle2[0], rectangle2[1], rectangle2[0] + rectangle2[2], rectangle2[1] + rectangle2[3] + x_overlap = max(0., min(rectangle1[2], rectangle2[2]) - max(rectangle1[0], rectangle2[0])) + y_overlap = max(0., min(rectangle1[3], rectangle2[3]) - max(rectangle1[1], rectangle2[1])) + return x_overlap * y_overlap + + +def horizontally_flip_bbox(bbox: BoundingBox) -> BoundingBox: + return 1 - (bbox[0] + bbox[2]), bbox[1], bbox[2], bbox[3] + + +def absolute_bbox(relative_bbox: BoundingBox, width: int, height: int) -> Tuple[int, int, int, int]: + bbox = relative_bbox + bbox = bbox[0] * width, bbox[1] * height, (bbox[0] + bbox[2]) * width, (bbox[1] + bbox[3]) * height + return int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3]) + + +def pad_list(list_: List, pad_element: Any, pad_to_length: int) -> List: + return list_ + [pad_element for _ in range(pad_to_length - len(list_))] + + +def rescale_annotations(annotations: List[Annotation], crop_coordinates: BoundingBox, flip: bool) -> \ + List[Annotation]: + def clamp(x: float): + return max(min(x, 1.), 0.) + + def rescale_bbox(bbox: BoundingBox) -> BoundingBox: + x0 = clamp((bbox[0] - crop_coordinates[0]) / crop_coordinates[2]) + y0 = clamp((bbox[1] - crop_coordinates[1]) / crop_coordinates[3]) + w = min(bbox[2] / crop_coordinates[2], 1 - x0) + h = min(bbox[3] / crop_coordinates[3], 1 - y0) + if flip: + x0 = 1 - (x0 + w) + return x0, y0, w, h + + return [a._replace(bbox=rescale_bbox(a.bbox)) for a in annotations] + + +def filter_annotations(annotations: List[Annotation], crop_coordinates: BoundingBox) -> List: + return [a for a in annotations if intersection_area(a.bbox, crop_coordinates) > 0.0] + + +def additional_parameters_string(annotation: Annotation, short: bool = True) -> str: + sl = slice(1) if short else slice(None) + string = '' + if not (annotation.is_group_of or annotation.is_occluded or annotation.is_depiction or annotation.is_inside): + return string + if annotation.is_group_of: + string += 'group'[sl] + ',' + if annotation.is_occluded: + string += 'occluded'[sl] + ',' + if annotation.is_depiction: + string += 'depiction'[sl] + ',' + if annotation.is_inside: + string += 'inside'[sl] + return '(' + string.strip(",") + ')' + + +def get_plot_font_size(font_size: Optional[int], figure_size: Tuple[int, int]) -> int: + if font_size is None: + font_size = 10 + if max(figure_size) >= 256: + font_size = 12 + if max(figure_size) >= 512: + font_size = 15 + return font_size + + +def get_circle_size(figure_size: Tuple[int, int]) -> int: + circle_size = 2 + if max(figure_size) >= 256: + circle_size = 3 + if max(figure_size) >= 512: + circle_size = 4 + return circle_size + + +def load_object_from_string(object_string: str) -> Any: + """ + Source: https://stackoverflow.com/a/10773699 + """ + module_name, class_name = object_string.rsplit(".", 1) + return getattr(importlib.import_module(module_name), class_name) diff --git a/src/taming-transformers/taming/data/custom.py b/src/taming-transformers/taming/data/custom.py new file mode 100644 index 0000000000000000000000000000000000000000..33f302a4b55ba1e8ec282ec3292b6263c06dfb91 --- /dev/null +++ b/src/taming-transformers/taming/data/custom.py @@ -0,0 +1,38 @@ +import os +import numpy as np +import albumentations +from torch.utils.data import Dataset + +from taming.data.base import ImagePaths, NumpyPaths, ConcatDatasetWithIndex + + +class CustomBase(Dataset): + def __init__(self, *args, **kwargs): + super().__init__() + self.data = None + + def __len__(self): + return len(self.data) + + def __getitem__(self, i): + example = self.data[i] + return example + + + +class CustomTrain(CustomBase): + def __init__(self, size, training_images_list_file): + super().__init__() + with open(training_images_list_file, "r") as f: + paths = f.read().splitlines() + self.data = ImagePaths(paths=paths, size=size, random_crop=False) + + +class CustomTest(CustomBase): + def __init__(self, size, test_images_list_file): + super().__init__() + with open(test_images_list_file, "r") as f: + paths = f.read().splitlines() + self.data = ImagePaths(paths=paths, size=size, random_crop=False) + + diff --git a/src/taming-transformers/taming/data/faceshq.py b/src/taming-transformers/taming/data/faceshq.py new file mode 100644 index 0000000000000000000000000000000000000000..6912d04b66a6d464c1078e4b51d5da290f5e767e --- /dev/null +++ b/src/taming-transformers/taming/data/faceshq.py @@ -0,0 +1,134 @@ +import os +import numpy as np +import albumentations +from torch.utils.data import Dataset + +from taming.data.base import ImagePaths, NumpyPaths, ConcatDatasetWithIndex + + +class FacesBase(Dataset): + def __init__(self, *args, **kwargs): + super().__init__() + self.data = None + self.keys = None + + def __len__(self): + return len(self.data) + + def __getitem__(self, i): + example = self.data[i] + ex = {} + if self.keys is not None: + for k in self.keys: + ex[k] = example[k] + else: + ex = example + return ex + + +class CelebAHQTrain(FacesBase): + def __init__(self, size, keys=None): + super().__init__() + root = "data/celebahq" + with open("data/celebahqtrain.txt", "r") as f: + relpaths = f.read().splitlines() + paths = [os.path.join(root, relpath) for relpath in relpaths] + self.data = NumpyPaths(paths=paths, size=size, random_crop=False) + self.keys = keys + + +class CelebAHQValidation(FacesBase): + def __init__(self, size, keys=None): + super().__init__() + root = "data/celebahq" + with open("data/celebahqvalidation.txt", "r") as f: + relpaths = f.read().splitlines() + paths = [os.path.join(root, relpath) for relpath in relpaths] + self.data = NumpyPaths(paths=paths, size=size, random_crop=False) + self.keys = keys + + +class FFHQTrain(FacesBase): + def __init__(self, size, keys=None): + super().__init__() + root = "data/ffhq" + with open("data/ffhqtrain.txt", "r") as f: + relpaths = f.read().splitlines() + paths = [os.path.join(root, relpath) for relpath in relpaths] + self.data = ImagePaths(paths=paths, size=size, random_crop=False) + self.keys = keys + + +class FFHQValidation(FacesBase): + def __init__(self, size, keys=None): + super().__init__() + root = "data/ffhq" + with open("data/ffhqvalidation.txt", "r") as f: + relpaths = f.read().splitlines() + paths = [os.path.join(root, relpath) for relpath in relpaths] + self.data = ImagePaths(paths=paths, size=size, random_crop=False) + self.keys = keys + + +class FacesHQTrain(Dataset): + # CelebAHQ [0] + FFHQ [1] + def __init__(self, size, keys=None, crop_size=None, coord=False): + d1 = CelebAHQTrain(size=size, keys=keys) + d2 = FFHQTrain(size=size, keys=keys) + self.data = ConcatDatasetWithIndex([d1, d2]) + self.coord = coord + if crop_size is not None: + self.cropper = albumentations.RandomCrop(height=crop_size,width=crop_size) + if self.coord: + self.cropper = albumentations.Compose([self.cropper], + additional_targets={"coord": "image"}) + + def __len__(self): + return len(self.data) + + def __getitem__(self, i): + ex, y = self.data[i] + if hasattr(self, "cropper"): + if not self.coord: + out = self.cropper(image=ex["image"]) + ex["image"] = out["image"] + else: + h,w,_ = ex["image"].shape + coord = np.arange(h*w).reshape(h,w,1)/(h*w) + out = self.cropper(image=ex["image"], coord=coord) + ex["image"] = out["image"] + ex["coord"] = out["coord"] + ex["class"] = y + return ex + + +class FacesHQValidation(Dataset): + # CelebAHQ [0] + FFHQ [1] + def __init__(self, size, keys=None, crop_size=None, coord=False): + d1 = CelebAHQValidation(size=size, keys=keys) + d2 = FFHQValidation(size=size, keys=keys) + self.data = ConcatDatasetWithIndex([d1, d2]) + self.coord = coord + if crop_size is not None: + self.cropper = albumentations.CenterCrop(height=crop_size,width=crop_size) + if self.coord: + self.cropper = albumentations.Compose([self.cropper], + additional_targets={"coord": "image"}) + + def __len__(self): + return len(self.data) + + def __getitem__(self, i): + ex, y = self.data[i] + if hasattr(self, "cropper"): + if not self.coord: + out = self.cropper(image=ex["image"]) + ex["image"] = out["image"] + else: + h,w,_ = ex["image"].shape + coord = np.arange(h*w).reshape(h,w,1)/(h*w) + out = self.cropper(image=ex["image"], coord=coord) + ex["image"] = out["image"] + ex["coord"] = out["coord"] + ex["class"] = y + return ex diff --git a/src/taming-transformers/taming/data/helper_types.py b/src/taming-transformers/taming/data/helper_types.py new file mode 100644 index 0000000000000000000000000000000000000000..fb51e301da08602cfead5961c4f7e1d89f6aba79 --- /dev/null +++ b/src/taming-transformers/taming/data/helper_types.py @@ -0,0 +1,49 @@ +from typing import Dict, Tuple, Optional, NamedTuple, Union +from PIL.Image import Image as pil_image +from torch import Tensor + +try: + from typing import Literal +except ImportError: + from typing_extensions import Literal + +Image = Union[Tensor, pil_image] +BoundingBox = Tuple[float, float, float, float] # x0, y0, w, h +CropMethodType = Literal['none', 'random', 'center', 'random-2d'] +SplitType = Literal['train', 'validation', 'test'] + + +class ImageDescription(NamedTuple): + id: int + file_name: str + original_size: Tuple[int, int] # w, h + url: Optional[str] = None + license: Optional[int] = None + coco_url: Optional[str] = None + date_captured: Optional[str] = None + flickr_url: Optional[str] = None + flickr_id: Optional[str] = None + coco_id: Optional[str] = None + + +class Category(NamedTuple): + id: str + super_category: Optional[str] + name: str + + +class Annotation(NamedTuple): + area: float + image_id: str + bbox: BoundingBox + category_no: int + category_id: str + id: Optional[int] = None + source: Optional[str] = None + confidence: Optional[float] = None + is_group_of: Optional[bool] = None + is_truncated: Optional[bool] = None + is_occluded: Optional[bool] = None + is_depiction: Optional[bool] = None + is_inside: Optional[bool] = None + segmentation: Optional[Dict] = None diff --git a/src/taming-transformers/taming/data/image_transforms.py b/src/taming-transformers/taming/data/image_transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..657ac332174e0ac72f68315271ffbd757b771a0f --- /dev/null +++ b/src/taming-transformers/taming/data/image_transforms.py @@ -0,0 +1,132 @@ +import random +import warnings +from typing import Union + +import torch +from torch import Tensor +from torchvision.transforms import RandomCrop, functional as F, CenterCrop, RandomHorizontalFlip, PILToTensor +from torchvision.transforms.functional import _get_image_size as get_image_size + +from taming.data.helper_types import BoundingBox, Image + +pil_to_tensor = PILToTensor() + + +def convert_pil_to_tensor(image: Image) -> Tensor: + with warnings.catch_warnings(): + # to filter PyTorch UserWarning as described here: https://github.com/pytorch/vision/issues/2194 + warnings.simplefilter("ignore") + return pil_to_tensor(image) + + +class RandomCrop1dReturnCoordinates(RandomCrop): + def forward(self, img: Image) -> (BoundingBox, Image): + """ + Additionally to cropping, returns the relative coordinates of the crop bounding box. + Args: + img (PIL Image or Tensor): Image to be cropped. + + Returns: + Bounding box: x0, y0, w, h + PIL Image or Tensor: Cropped image. + + Based on: + torchvision.transforms.RandomCrop, torchvision 1.7.0 + """ + if self.padding is not None: + img = F.pad(img, self.padding, self.fill, self.padding_mode) + + width, height = get_image_size(img) + # pad the width if needed + if self.pad_if_needed and width < self.size[1]: + padding = [self.size[1] - width, 0] + img = F.pad(img, padding, self.fill, self.padding_mode) + # pad the height if needed + if self.pad_if_needed and height < self.size[0]: + padding = [0, self.size[0] - height] + img = F.pad(img, padding, self.fill, self.padding_mode) + + i, j, h, w = self.get_params(img, self.size) + bbox = (j / width, i / height, w / width, h / height) # x0, y0, w, h + return bbox, F.crop(img, i, j, h, w) + + +class Random2dCropReturnCoordinates(torch.nn.Module): + """ + Additionally to cropping, returns the relative coordinates of the crop bounding box. + Args: + img (PIL Image or Tensor): Image to be cropped. + + Returns: + Bounding box: x0, y0, w, h + PIL Image or Tensor: Cropped image. + + Based on: + torchvision.transforms.RandomCrop, torchvision 1.7.0 + """ + + def __init__(self, min_size: int): + super().__init__() + self.min_size = min_size + + def forward(self, img: Image) -> (BoundingBox, Image): + width, height = get_image_size(img) + max_size = min(width, height) + if max_size <= self.min_size: + size = max_size + else: + size = random.randint(self.min_size, max_size) + top = random.randint(0, height - size) + left = random.randint(0, width - size) + bbox = left / width, top / height, size / width, size / height + return bbox, F.crop(img, top, left, size, size) + + +class CenterCropReturnCoordinates(CenterCrop): + @staticmethod + def get_bbox_of_center_crop(width: int, height: int) -> BoundingBox: + if width > height: + w = height / width + h = 1.0 + x0 = 0.5 - w / 2 + y0 = 0. + else: + w = 1.0 + h = width / height + x0 = 0. + y0 = 0.5 - h / 2 + return x0, y0, w, h + + def forward(self, img: Union[Image, Tensor]) -> (BoundingBox, Union[Image, Tensor]): + """ + Additionally to cropping, returns the relative coordinates of the crop bounding box. + Args: + img (PIL Image or Tensor): Image to be cropped. + + Returns: + Bounding box: x0, y0, w, h + PIL Image or Tensor: Cropped image. + Based on: + torchvision.transforms.RandomHorizontalFlip (version 1.7.0) + """ + width, height = get_image_size(img) + return self.get_bbox_of_center_crop(width, height), F.center_crop(img, self.size) + + +class RandomHorizontalFlipReturn(RandomHorizontalFlip): + def forward(self, img: Image) -> (bool, Image): + """ + Additionally to flipping, returns a boolean whether it was flipped or not. + Args: + img (PIL Image or Tensor): Image to be flipped. + + Returns: + flipped: whether the image was flipped or not + PIL Image or Tensor: Randomly flipped image. + + Based on: + torchvision.transforms.RandomHorizontalFlip (version 1.7.0) + """ + if torch.rand(1) < self.p: + return True, F.hflip(img) + return False, img diff --git a/src/taming-transformers/taming/data/imagenet.py b/src/taming-transformers/taming/data/imagenet.py new file mode 100644 index 0000000000000000000000000000000000000000..9a02ec44ba4af9e993f58c91fa43482a4ecbe54c --- /dev/null +++ b/src/taming-transformers/taming/data/imagenet.py @@ -0,0 +1,558 @@ +import os, tarfile, glob, shutil +import yaml +import numpy as np +from tqdm import tqdm +from PIL import Image +import albumentations +from omegaconf import OmegaConf +from torch.utils.data import Dataset + +from taming.data.base import ImagePaths +from taming.util import download, retrieve +import taming.data.utils as bdu + + +def give_synsets_from_indices(indices, path_to_yaml="data/imagenet_idx_to_synset.yaml"): + synsets = [] + with open(path_to_yaml) as f: + di2s = yaml.load(f) + for idx in indices: + synsets.append(str(di2s[idx])) + print("Using {} different synsets for construction of Restriced Imagenet.".format(len(synsets))) + return synsets + + +def str_to_indices(string): + """Expects a string in the format '32-123, 256, 280-321'""" + assert not string.endswith(","), "provided string '{}' ends with a comma, pls remove it".format(string) + subs = string.split(",") + indices = [] + for sub in subs: + subsubs = sub.split("-") + assert len(subsubs) > 0 + if len(subsubs) == 1: + indices.append(int(subsubs[0])) + else: + rang = [j for j in range(int(subsubs[0]), int(subsubs[1]))] + indices.extend(rang) + return sorted(indices) + + +class ImageNetBase(Dataset): + def __init__(self, config=None): + self.config = config or OmegaConf.create() + if not type(self.config)==dict: + self.config = OmegaConf.to_container(self.config) + self._prepare() + self._prepare_synset_to_human() + self._prepare_idx_to_synset() + self._load() + + def __len__(self): + return len(self.data) + + def __getitem__(self, i): + return self.data[i] + + def _prepare(self): + raise NotImplementedError() + + def _filter_relpaths(self, relpaths): + ignore = set([ + "n06596364_9591.JPEG", + ]) + relpaths = [rpath for rpath in relpaths if not rpath.split("/")[-1] in ignore] + if "sub_indices" in self.config: + indices = str_to_indices(self.config["sub_indices"]) + synsets = give_synsets_from_indices(indices, path_to_yaml=self.idx2syn) # returns a list of strings + files = [] + for rpath in relpaths: + syn = rpath.split("/")[0] + if syn in synsets: + files.append(rpath) + return files + else: + return relpaths + + def _prepare_synset_to_human(self): + SIZE = 2655750 + URL = "https://heibox.uni-heidelberg.de/f/9f28e956cd304264bb82/?dl=1" + self.human_dict = os.path.join(self.root, "synset_human.txt") + if (not os.path.exists(self.human_dict) or + not os.path.getsize(self.human_dict)==SIZE): + download(URL, self.human_dict) + + def _prepare_idx_to_synset(self): + URL = "https://heibox.uni-heidelberg.de/f/d835d5b6ceda4d3aa910/?dl=1" + self.idx2syn = os.path.join(self.root, "index_synset.yaml") + if (not os.path.exists(self.idx2syn)): + download(URL, self.idx2syn) + + def _load(self): + with open(self.txt_filelist, "r") as f: + self.relpaths = f.read().splitlines() + l1 = len(self.relpaths) + self.relpaths = self._filter_relpaths(self.relpaths) + print("Removed {} files from filelist during filtering.".format(l1 - len(self.relpaths))) + + self.synsets = [p.split("/")[0] for p in self.relpaths] + self.abspaths = [os.path.join(self.datadir, p) for p in self.relpaths] + + unique_synsets = np.unique(self.synsets) + class_dict = dict((synset, i) for i, synset in enumerate(unique_synsets)) + self.class_labels = [class_dict[s] for s in self.synsets] + + with open(self.human_dict, "r") as f: + human_dict = f.read().splitlines() + human_dict = dict(line.split(maxsplit=1) for line in human_dict) + + self.human_labels = [human_dict[s] for s in self.synsets] + + labels = { + "relpath": np.array(self.relpaths), + "synsets": np.array(self.synsets), + "class_label": np.array(self.class_labels), + "human_label": np.array(self.human_labels), + } + self.data = ImagePaths(self.abspaths, + labels=labels, + size=retrieve(self.config, "size", default=0), + random_crop=self.random_crop) + + +class ImageNetTrain(ImageNetBase): + NAME = "ILSVRC2012_train" + URL = "http://www.image-net.org/challenges/LSVRC/2012/" + AT_HASH = "a306397ccf9c2ead27155983c254227c0fd938e2" + FILES = [ + "ILSVRC2012_img_train.tar", + ] + SIZES = [ + 147897477120, + ] + + def _prepare(self): + self.random_crop = retrieve(self.config, "ImageNetTrain/random_crop", + default=True) + cachedir = os.environ.get("XDG_CACHE_HOME", os.path.expanduser("~/.cache")) + self.root = os.path.join(cachedir, "autoencoders/data", self.NAME) + self.datadir = os.path.join(self.root, "data") + self.txt_filelist = os.path.join(self.root, "filelist.txt") + self.expected_length = 1281167 + if not bdu.is_prepared(self.root): + # prep + print("Preparing dataset {} in {}".format(self.NAME, self.root)) + + datadir = self.datadir + if not os.path.exists(datadir): + path = os.path.join(self.root, self.FILES[0]) + if not os.path.exists(path) or not os.path.getsize(path)==self.SIZES[0]: + import academictorrents as at + atpath = at.get(self.AT_HASH, datastore=self.root) + assert atpath == path + + print("Extracting {} to {}".format(path, datadir)) + os.makedirs(datadir, exist_ok=True) + with tarfile.open(path, "r:") as tar: + tar.extractall(path=datadir) + + print("Extracting sub-tars.") + subpaths = sorted(glob.glob(os.path.join(datadir, "*.tar"))) + for subpath in tqdm(subpaths): + subdir = subpath[:-len(".tar")] + os.makedirs(subdir, exist_ok=True) + with tarfile.open(subpath, "r:") as tar: + tar.extractall(path=subdir) + + + filelist = glob.glob(os.path.join(datadir, "**", "*.JPEG")) + filelist = [os.path.relpath(p, start=datadir) for p in filelist] + filelist = sorted(filelist) + filelist = "\n".join(filelist)+"\n" + with open(self.txt_filelist, "w") as f: + f.write(filelist) + + bdu.mark_prepared(self.root) + + +class ImageNetValidation(ImageNetBase): + NAME = "ILSVRC2012_validation" + URL = "http://www.image-net.org/challenges/LSVRC/2012/" + AT_HASH = "5d6d0df7ed81efd49ca99ea4737e0ae5e3a5f2e5" + VS_URL = "https://heibox.uni-heidelberg.de/f/3e0f6e9c624e45f2bd73/?dl=1" + FILES = [ + "ILSVRC2012_img_val.tar", + "validation_synset.txt", + ] + SIZES = [ + 6744924160, + 1950000, + ] + + def _prepare(self): + self.random_crop = retrieve(self.config, "ImageNetValidation/random_crop", + default=False) + cachedir = os.environ.get("XDG_CACHE_HOME", os.path.expanduser("~/.cache")) + self.root = os.path.join(cachedir, "autoencoders/data", self.NAME) + self.datadir = os.path.join(self.root, "data") + self.txt_filelist = os.path.join(self.root, "filelist.txt") + self.expected_length = 50000 + if not bdu.is_prepared(self.root): + # prep + print("Preparing dataset {} in {}".format(self.NAME, self.root)) + + datadir = self.datadir + if not os.path.exists(datadir): + path = os.path.join(self.root, self.FILES[0]) + if not os.path.exists(path) or not os.path.getsize(path)==self.SIZES[0]: + import academictorrents as at + atpath = at.get(self.AT_HASH, datastore=self.root) + assert atpath == path + + print("Extracting {} to {}".format(path, datadir)) + os.makedirs(datadir, exist_ok=True) + with tarfile.open(path, "r:") as tar: + tar.extractall(path=datadir) + + vspath = os.path.join(self.root, self.FILES[1]) + if not os.path.exists(vspath) or not os.path.getsize(vspath)==self.SIZES[1]: + download(self.VS_URL, vspath) + + with open(vspath, "r") as f: + synset_dict = f.read().splitlines() + synset_dict = dict(line.split() for line in synset_dict) + + print("Reorganizing into synset folders") + synsets = np.unique(list(synset_dict.values())) + for s in synsets: + os.makedirs(os.path.join(datadir, s), exist_ok=True) + for k, v in synset_dict.items(): + src = os.path.join(datadir, k) + dst = os.path.join(datadir, v) + shutil.move(src, dst) + + filelist = glob.glob(os.path.join(datadir, "**", "*.JPEG")) + filelist = [os.path.relpath(p, start=datadir) for p in filelist] + filelist = sorted(filelist) + filelist = "\n".join(filelist)+"\n" + with open(self.txt_filelist, "w") as f: + f.write(filelist) + + bdu.mark_prepared(self.root) + + +def get_preprocessor(size=None, random_crop=False, additional_targets=None, + crop_size=None): + if size is not None and size > 0: + transforms = list() + rescaler = albumentations.SmallestMaxSize(max_size = size) + transforms.append(rescaler) + if not random_crop: + cropper = albumentations.CenterCrop(height=size,width=size) + transforms.append(cropper) + else: + cropper = albumentations.RandomCrop(height=size,width=size) + transforms.append(cropper) + flipper = albumentations.HorizontalFlip() + transforms.append(flipper) + preprocessor = albumentations.Compose(transforms, + additional_targets=additional_targets) + elif crop_size is not None and crop_size > 0: + if not random_crop: + cropper = albumentations.CenterCrop(height=crop_size,width=crop_size) + else: + cropper = albumentations.RandomCrop(height=crop_size,width=crop_size) + transforms = [cropper] + preprocessor = albumentations.Compose(transforms, + additional_targets=additional_targets) + else: + preprocessor = lambda **kwargs: kwargs + return preprocessor + + +def rgba_to_depth(x): + assert x.dtype == np.uint8 + assert len(x.shape) == 3 and x.shape[2] == 4 + y = x.copy() + y.dtype = np.float32 + y = y.reshape(x.shape[:2]) + return np.ascontiguousarray(y) + + +class BaseWithDepth(Dataset): + DEFAULT_DEPTH_ROOT="data/imagenet_depth" + + def __init__(self, config=None, size=None, random_crop=False, + crop_size=None, root=None): + self.config = config + self.base_dset = self.get_base_dset() + self.preprocessor = get_preprocessor( + size=size, + crop_size=crop_size, + random_crop=random_crop, + additional_targets={"depth": "image"}) + self.crop_size = crop_size + if self.crop_size is not None: + self.rescaler = albumentations.Compose( + [albumentations.SmallestMaxSize(max_size = self.crop_size)], + additional_targets={"depth": "image"}) + if root is not None: + self.DEFAULT_DEPTH_ROOT = root + + def __len__(self): + return len(self.base_dset) + + def preprocess_depth(self, path): + rgba = np.array(Image.open(path)) + depth = rgba_to_depth(rgba) + depth = (depth - depth.min())/max(1e-8, depth.max()-depth.min()) + depth = 2.0*depth-1.0 + return depth + + def __getitem__(self, i): + e = self.base_dset[i] + e["depth"] = self.preprocess_depth(self.get_depth_path(e)) + # up if necessary + h,w,c = e["image"].shape + if self.crop_size and min(h,w) < self.crop_size: + # have to upscale to be able to crop - this just uses bilinear + out = self.rescaler(image=e["image"], depth=e["depth"]) + e["image"] = out["image"] + e["depth"] = out["depth"] + transformed = self.preprocessor(image=e["image"], depth=e["depth"]) + e["image"] = transformed["image"] + e["depth"] = transformed["depth"] + return e + + +class ImageNetTrainWithDepth(BaseWithDepth): + # default to random_crop=True + def __init__(self, random_crop=True, sub_indices=None, **kwargs): + self.sub_indices = sub_indices + super().__init__(random_crop=random_crop, **kwargs) + + def get_base_dset(self): + if self.sub_indices is None: + return ImageNetTrain() + else: + return ImageNetTrain({"sub_indices": self.sub_indices}) + + def get_depth_path(self, e): + fid = os.path.splitext(e["relpath"])[0]+".png" + fid = os.path.join(self.DEFAULT_DEPTH_ROOT, "train", fid) + return fid + + +class ImageNetValidationWithDepth(BaseWithDepth): + def __init__(self, sub_indices=None, **kwargs): + self.sub_indices = sub_indices + super().__init__(**kwargs) + + def get_base_dset(self): + if self.sub_indices is None: + return ImageNetValidation() + else: + return ImageNetValidation({"sub_indices": self.sub_indices}) + + def get_depth_path(self, e): + fid = os.path.splitext(e["relpath"])[0]+".png" + fid = os.path.join(self.DEFAULT_DEPTH_ROOT, "val", fid) + return fid + + +class RINTrainWithDepth(ImageNetTrainWithDepth): + def __init__(self, config=None, size=None, random_crop=True, crop_size=None): + sub_indices = "30-32, 33-37, 151-268, 281-285, 80-100, 365-382, 389-397, 118-121, 300-319" + super().__init__(config=config, size=size, random_crop=random_crop, + sub_indices=sub_indices, crop_size=crop_size) + + +class RINValidationWithDepth(ImageNetValidationWithDepth): + def __init__(self, config=None, size=None, random_crop=False, crop_size=None): + sub_indices = "30-32, 33-37, 151-268, 281-285, 80-100, 365-382, 389-397, 118-121, 300-319" + super().__init__(config=config, size=size, random_crop=random_crop, + sub_indices=sub_indices, crop_size=crop_size) + + +class DRINExamples(Dataset): + def __init__(self): + self.preprocessor = get_preprocessor(size=256, additional_targets={"depth": "image"}) + with open("data/drin_examples.txt", "r") as f: + relpaths = f.read().splitlines() + self.image_paths = [os.path.join("data/drin_images", + relpath) for relpath in relpaths] + self.depth_paths = [os.path.join("data/drin_depth", + relpath.replace(".JPEG", ".png")) for relpath in relpaths] + + def __len__(self): + return len(self.image_paths) + + def preprocess_image(self, image_path): + image = Image.open(image_path) + if not image.mode == "RGB": + image = image.convert("RGB") + image = np.array(image).astype(np.uint8) + image = self.preprocessor(image=image)["image"] + image = (image/127.5 - 1.0).astype(np.float32) + return image + + def preprocess_depth(self, path): + rgba = np.array(Image.open(path)) + depth = rgba_to_depth(rgba) + depth = (depth - depth.min())/max(1e-8, depth.max()-depth.min()) + depth = 2.0*depth-1.0 + return depth + + def __getitem__(self, i): + e = dict() + e["image"] = self.preprocess_image(self.image_paths[i]) + e["depth"] = self.preprocess_depth(self.depth_paths[i]) + transformed = self.preprocessor(image=e["image"], depth=e["depth"]) + e["image"] = transformed["image"] + e["depth"] = transformed["depth"] + return e + + +def imscale(x, factor, keepshapes=False, keepmode="bicubic"): + if factor is None or factor==1: + return x + + dtype = x.dtype + assert dtype in [np.float32, np.float64] + assert x.min() >= -1 + assert x.max() <= 1 + + keepmode = {"nearest": Image.NEAREST, "bilinear": Image.BILINEAR, + "bicubic": Image.BICUBIC}[keepmode] + + lr = (x+1.0)*127.5 + lr = lr.clip(0,255).astype(np.uint8) + lr = Image.fromarray(lr) + + h, w, _ = x.shape + nh = h//factor + nw = w//factor + assert nh > 0 and nw > 0, (nh, nw) + + lr = lr.resize((nw,nh), Image.BICUBIC) + if keepshapes: + lr = lr.resize((w,h), keepmode) + lr = np.array(lr)/127.5-1.0 + lr = lr.astype(dtype) + + return lr + + +class ImageNetScale(Dataset): + def __init__(self, size=None, crop_size=None, random_crop=False, + up_factor=None, hr_factor=None, keep_mode="bicubic"): + self.base = self.get_base() + + self.size = size + self.crop_size = crop_size if crop_size is not None else self.size + self.random_crop = random_crop + self.up_factor = up_factor + self.hr_factor = hr_factor + self.keep_mode = keep_mode + + transforms = list() + + if self.size is not None and self.size > 0: + rescaler = albumentations.SmallestMaxSize(max_size = self.size) + self.rescaler = rescaler + transforms.append(rescaler) + + if self.crop_size is not None and self.crop_size > 0: + if len(transforms) == 0: + self.rescaler = albumentations.SmallestMaxSize(max_size = self.crop_size) + + if not self.random_crop: + cropper = albumentations.CenterCrop(height=self.crop_size,width=self.crop_size) + else: + cropper = albumentations.RandomCrop(height=self.crop_size,width=self.crop_size) + transforms.append(cropper) + + if len(transforms) > 0: + if self.up_factor is not None: + additional_targets = {"lr": "image"} + else: + additional_targets = None + self.preprocessor = albumentations.Compose(transforms, + additional_targets=additional_targets) + else: + self.preprocessor = lambda **kwargs: kwargs + + def __len__(self): + return len(self.base) + + def __getitem__(self, i): + example = self.base[i] + image = example["image"] + # adjust resolution + image = imscale(image, self.hr_factor, keepshapes=False) + h,w,c = image.shape + if self.crop_size and min(h,w) < self.crop_size: + # have to upscale to be able to crop - this just uses bilinear + image = self.rescaler(image=image)["image"] + if self.up_factor is None: + image = self.preprocessor(image=image)["image"] + example["image"] = image + else: + lr = imscale(image, self.up_factor, keepshapes=True, + keepmode=self.keep_mode) + + out = self.preprocessor(image=image, lr=lr) + example["image"] = out["image"] + example["lr"] = out["lr"] + + return example + +class ImageNetScaleTrain(ImageNetScale): + def __init__(self, random_crop=True, **kwargs): + super().__init__(random_crop=random_crop, **kwargs) + + def get_base(self): + return ImageNetTrain() + +class ImageNetScaleValidation(ImageNetScale): + def get_base(self): + return ImageNetValidation() + + +from skimage.feature import canny +from skimage.color import rgb2gray + + +class ImageNetEdges(ImageNetScale): + def __init__(self, up_factor=1, **kwargs): + super().__init__(up_factor=1, **kwargs) + + def __getitem__(self, i): + example = self.base[i] + image = example["image"] + h,w,c = image.shape + if self.crop_size and min(h,w) < self.crop_size: + # have to upscale to be able to crop - this just uses bilinear + image = self.rescaler(image=image)["image"] + + lr = canny(rgb2gray(image), sigma=2) + lr = lr.astype(np.float32) + lr = lr[:,:,None][:,:,[0,0,0]] + + out = self.preprocessor(image=image, lr=lr) + example["image"] = out["image"] + example["lr"] = out["lr"] + + return example + + +class ImageNetEdgesTrain(ImageNetEdges): + def __init__(self, random_crop=True, **kwargs): + super().__init__(random_crop=random_crop, **kwargs) + + def get_base(self): + return ImageNetTrain() + +class ImageNetEdgesValidation(ImageNetEdges): + def get_base(self): + return ImageNetValidation() diff --git a/src/taming-transformers/taming/data/open_images_helper.py b/src/taming-transformers/taming/data/open_images_helper.py new file mode 100644 index 0000000000000000000000000000000000000000..8feb7c6e705fc165d2983303192aaa88f579b243 --- /dev/null +++ b/src/taming-transformers/taming/data/open_images_helper.py @@ -0,0 +1,379 @@ +open_images_unify_categories_for_coco = { + '/m/03bt1vf': '/m/01g317', + '/m/04yx4': '/m/01g317', + '/m/05r655': '/m/01g317', + '/m/01bl7v': '/m/01g317', + '/m/0cnyhnx': '/m/01xq0k1', + '/m/01226z': '/m/018xm', + '/m/05ctyq': '/m/018xm', + '/m/058qzx': '/m/04ctx', + '/m/06pcq': '/m/0l515', + '/m/03m3pdh': '/m/02crq1', + '/m/046dlr': '/m/01x3z', + '/m/0h8mzrc': '/m/01x3z', +} + + +top_300_classes_plus_coco_compatibility = [ + ('Man', 1060962), + ('Clothing', 986610), + ('Tree', 748162), + ('Woman', 611896), + ('Person', 610294), + ('Human face', 442948), + ('Girl', 175399), + ('Building', 162147), + ('Car', 159135), + ('Plant', 155704), + ('Human body', 137073), + ('Flower', 133128), + ('Window', 127485), + ('Human arm', 118380), + ('House', 114365), + ('Wheel', 111684), + ('Suit', 99054), + ('Human hair', 98089), + ('Human head', 92763), + ('Chair', 88624), + ('Boy', 79849), + ('Table', 73699), + ('Jeans', 57200), + ('Tire', 55725), + ('Skyscraper', 53321), + ('Food', 52400), + ('Footwear', 50335), + ('Dress', 50236), + ('Human leg', 47124), + ('Toy', 46636), + ('Tower', 45605), + ('Boat', 43486), + ('Land vehicle', 40541), + ('Bicycle wheel', 34646), + ('Palm tree', 33729), + ('Fashion accessory', 32914), + ('Glasses', 31940), + ('Bicycle', 31409), + ('Furniture', 30656), + ('Sculpture', 29643), + ('Bottle', 27558), + ('Dog', 26980), + ('Snack', 26796), + ('Human hand', 26664), + ('Bird', 25791), + ('Book', 25415), + ('Guitar', 24386), + ('Jacket', 23998), + ('Poster', 22192), + ('Dessert', 21284), + ('Baked goods', 20657), + ('Drink', 19754), + ('Flag', 18588), + ('Houseplant', 18205), + ('Tableware', 17613), + ('Airplane', 17218), + ('Door', 17195), + ('Sports uniform', 17068), + ('Shelf', 16865), + ('Drum', 16612), + ('Vehicle', 16542), + ('Microphone', 15269), + ('Street light', 14957), + ('Cat', 14879), + ('Fruit', 13684), + ('Fast food', 13536), + ('Animal', 12932), + ('Vegetable', 12534), + ('Train', 12358), + ('Horse', 11948), + ('Flowerpot', 11728), + ('Motorcycle', 11621), + ('Fish', 11517), + ('Desk', 11405), + ('Helmet', 10996), + ('Truck', 10915), + ('Bus', 10695), + ('Hat', 10532), + ('Auto part', 10488), + ('Musical instrument', 10303), + ('Sunglasses', 10207), + ('Picture frame', 10096), + ('Sports equipment', 10015), + ('Shorts', 9999), + ('Wine glass', 9632), + ('Duck', 9242), + ('Wine', 9032), + ('Rose', 8781), + ('Tie', 8693), + ('Butterfly', 8436), + ('Beer', 7978), + ('Cabinetry', 7956), + ('Laptop', 7907), + ('Insect', 7497), + ('Goggles', 7363), + ('Shirt', 7098), + ('Dairy Product', 7021), + ('Marine invertebrates', 7014), + ('Cattle', 7006), + ('Trousers', 6903), + ('Van', 6843), + ('Billboard', 6777), + ('Balloon', 6367), + ('Human nose', 6103), + ('Tent', 6073), + ('Camera', 6014), + ('Doll', 6002), + ('Coat', 5951), + ('Mobile phone', 5758), + ('Swimwear', 5729), + ('Strawberry', 5691), + ('Stairs', 5643), + ('Goose', 5599), + ('Umbrella', 5536), + ('Cake', 5508), + ('Sun hat', 5475), + ('Bench', 5310), + ('Bookcase', 5163), + ('Bee', 5140), + ('Computer monitor', 5078), + ('Hiking equipment', 4983), + ('Office building', 4981), + ('Coffee cup', 4748), + ('Curtain', 4685), + ('Plate', 4651), + ('Box', 4621), + ('Tomato', 4595), + ('Coffee table', 4529), + ('Office supplies', 4473), + ('Maple', 4416), + ('Muffin', 4365), + ('Cocktail', 4234), + ('Castle', 4197), + ('Couch', 4134), + ('Pumpkin', 3983), + ('Computer keyboard', 3960), + ('Human mouth', 3926), + ('Christmas tree', 3893), + ('Mushroom', 3883), + ('Swimming pool', 3809), + ('Pastry', 3799), + ('Lavender (Plant)', 3769), + ('Football helmet', 3732), + ('Bread', 3648), + ('Traffic sign', 3628), + ('Common sunflower', 3597), + ('Television', 3550), + ('Bed', 3525), + ('Cookie', 3485), + ('Fountain', 3484), + ('Paddle', 3447), + ('Bicycle helmet', 3429), + ('Porch', 3420), + ('Deer', 3387), + ('Fedora', 3339), + ('Canoe', 3338), + ('Carnivore', 3266), + ('Bowl', 3202), + ('Human eye', 3166), + ('Ball', 3118), + ('Pillow', 3077), + ('Salad', 3061), + ('Beetle', 3060), + ('Orange', 3050), + ('Drawer', 2958), + ('Platter', 2937), + ('Elephant', 2921), + ('Seafood', 2921), + ('Monkey', 2915), + ('Countertop', 2879), + ('Watercraft', 2831), + ('Helicopter', 2805), + ('Kitchen appliance', 2797), + ('Personal flotation device', 2781), + ('Swan', 2739), + ('Lamp', 2711), + ('Boot', 2695), + ('Bronze sculpture', 2693), + ('Chicken', 2677), + ('Taxi', 2643), + ('Juice', 2615), + ('Cowboy hat', 2604), + ('Apple', 2600), + ('Tin can', 2590), + ('Necklace', 2564), + ('Ice cream', 2560), + ('Human beard', 2539), + ('Coin', 2536), + ('Candle', 2515), + ('Cart', 2512), + ('High heels', 2441), + ('Weapon', 2433), + ('Handbag', 2406), + ('Penguin', 2396), + ('Rifle', 2352), + ('Violin', 2336), + ('Skull', 2304), + ('Lantern', 2285), + ('Scarf', 2269), + ('Saucer', 2225), + ('Sheep', 2215), + ('Vase', 2189), + ('Lily', 2180), + ('Mug', 2154), + ('Parrot', 2140), + ('Human ear', 2137), + ('Sandal', 2115), + ('Lizard', 2100), + ('Kitchen & dining room table', 2063), + ('Spider', 1977), + ('Coffee', 1974), + ('Goat', 1926), + ('Squirrel', 1922), + ('Cello', 1913), + ('Sushi', 1881), + ('Tortoise', 1876), + ('Pizza', 1870), + ('Studio couch', 1864), + ('Barrel', 1862), + ('Cosmetics', 1841), + ('Moths and butterflies', 1841), + ('Convenience store', 1817), + ('Watch', 1792), + ('Home appliance', 1786), + ('Harbor seal', 1780), + ('Luggage and bags', 1756), + ('Vehicle registration plate', 1754), + ('Shrimp', 1751), + ('Jellyfish', 1730), + ('French fries', 1723), + ('Egg (Food)', 1698), + ('Football', 1697), + ('Musical keyboard', 1683), + ('Falcon', 1674), + ('Candy', 1660), + ('Medical equipment', 1654), + ('Eagle', 1651), + ('Dinosaur', 1634), + ('Surfboard', 1630), + ('Tank', 1628), + ('Grape', 1624), + ('Lion', 1624), + ('Owl', 1622), + ('Ski', 1613), + ('Waste container', 1606), + ('Frog', 1591), + ('Sparrow', 1585), + ('Rabbit', 1581), + ('Pen', 1546), + ('Sea lion', 1537), + ('Spoon', 1521), + ('Sink', 1512), + ('Teddy bear', 1507), + ('Bull', 1495), + ('Sofa bed', 1490), + ('Dragonfly', 1479), + ('Brassiere', 1478), + ('Chest of drawers', 1472), + ('Aircraft', 1466), + ('Human foot', 1463), + ('Pig', 1455), + ('Fork', 1454), + ('Antelope', 1438), + ('Tripod', 1427), + ('Tool', 1424), + ('Cheese', 1422), + ('Lemon', 1397), + ('Hamburger', 1393), + ('Dolphin', 1390), + ('Mirror', 1390), + ('Marine mammal', 1387), + ('Giraffe', 1385), + ('Snake', 1368), + ('Gondola', 1364), + ('Wheelchair', 1360), + ('Piano', 1358), + ('Cupboard', 1348), + ('Banana', 1345), + ('Trumpet', 1335), + ('Lighthouse', 1333), + ('Invertebrate', 1317), + ('Carrot', 1268), + ('Sock', 1260), + ('Tiger', 1241), + ('Camel', 1224), + ('Parachute', 1224), + ('Bathroom accessory', 1223), + ('Earrings', 1221), + ('Headphones', 1218), + ('Skirt', 1198), + ('Skateboard', 1190), + ('Sandwich', 1148), + ('Saxophone', 1141), + ('Goldfish', 1136), + ('Stool', 1104), + ('Traffic light', 1097), + ('Shellfish', 1081), + ('Backpack', 1079), + ('Sea turtle', 1078), + ('Cucumber', 1075), + ('Tea', 1051), + ('Toilet', 1047), + ('Roller skates', 1040), + ('Mule', 1039), + ('Bust', 1031), + ('Broccoli', 1030), + ('Crab', 1020), + ('Oyster', 1019), + ('Cannon', 1012), + ('Zebra', 1012), + ('French horn', 1008), + ('Grapefruit', 998), + ('Whiteboard', 997), + ('Zucchini', 997), + ('Crocodile', 992), + + ('Clock', 960), + ('Wall clock', 958), + + ('Doughnut', 869), + ('Snail', 868), + + ('Baseball glove', 859), + + ('Panda', 830), + ('Tennis racket', 830), + + ('Pear', 652), + + ('Bagel', 617), + ('Oven', 616), + ('Ladybug', 615), + ('Shark', 615), + ('Polar bear', 614), + ('Ostrich', 609), + + ('Hot dog', 473), + ('Microwave oven', 467), + ('Fire hydrant', 20), + ('Stop sign', 20), + ('Parking meter', 20), + ('Bear', 20), + ('Flying disc', 20), + ('Snowboard', 20), + ('Tennis ball', 20), + ('Kite', 20), + ('Baseball bat', 20), + ('Kitchen knife', 20), + ('Knife', 20), + ('Submarine sandwich', 20), + ('Computer mouse', 20), + ('Remote control', 20), + ('Toaster', 20), + ('Sink', 20), + ('Refrigerator', 20), + ('Alarm clock', 20), + ('Wall clock', 20), + ('Scissors', 20), + ('Hair dryer', 20), + ('Toothbrush', 20), + ('Suitcase', 20) +] diff --git a/src/taming-transformers/taming/data/sflckr.py b/src/taming-transformers/taming/data/sflckr.py new file mode 100644 index 0000000000000000000000000000000000000000..91101be5953b113f1e58376af637e43f366b3dee --- /dev/null +++ b/src/taming-transformers/taming/data/sflckr.py @@ -0,0 +1,91 @@ +import os +import numpy as np +import cv2 +import albumentations +from PIL import Image +from torch.utils.data import Dataset + + +class SegmentationBase(Dataset): + def __init__(self, + data_csv, data_root, segmentation_root, + size=None, random_crop=False, interpolation="bicubic", + n_labels=182, shift_segmentation=False, + ): + self.n_labels = n_labels + self.shift_segmentation = shift_segmentation + self.data_csv = data_csv + self.data_root = data_root + self.segmentation_root = segmentation_root + with open(self.data_csv, "r") as f: + self.image_paths = f.read().splitlines() + self._length = len(self.image_paths) + self.labels = { + "relative_file_path_": [l for l in self.image_paths], + "file_path_": [os.path.join(self.data_root, l) + for l in self.image_paths], + "segmentation_path_": [os.path.join(self.segmentation_root, l.replace(".jpg", ".png")) + for l in self.image_paths] + } + + size = None if size is not None and size<=0 else size + self.size = size + if self.size is not None: + self.interpolation = interpolation + self.interpolation = { + "nearest": cv2.INTER_NEAREST, + "bilinear": cv2.INTER_LINEAR, + "bicubic": cv2.INTER_CUBIC, + "area": cv2.INTER_AREA, + "lanczos": cv2.INTER_LANCZOS4}[self.interpolation] + self.image_rescaler = albumentations.SmallestMaxSize(max_size=self.size, + interpolation=self.interpolation) + self.segmentation_rescaler = albumentations.SmallestMaxSize(max_size=self.size, + interpolation=cv2.INTER_NEAREST) + self.center_crop = not random_crop + if self.center_crop: + self.cropper = albumentations.CenterCrop(height=self.size, width=self.size) + else: + self.cropper = albumentations.RandomCrop(height=self.size, width=self.size) + self.preprocessor = self.cropper + + def __len__(self): + return self._length + + def __getitem__(self, i): + example = dict((k, self.labels[k][i]) for k in self.labels) + image = Image.open(example["file_path_"]) + if not image.mode == "RGB": + image = image.convert("RGB") + image = np.array(image).astype(np.uint8) + if self.size is not None: + image = self.image_rescaler(image=image)["image"] + segmentation = Image.open(example["segmentation_path_"]) + assert segmentation.mode == "L", segmentation.mode + segmentation = np.array(segmentation).astype(np.uint8) + if self.shift_segmentation: + # used to support segmentations containing unlabeled==255 label + segmentation = segmentation+1 + if self.size is not None: + segmentation = self.segmentation_rescaler(image=segmentation)["image"] + if self.size is not None: + processed = self.preprocessor(image=image, + mask=segmentation + ) + else: + processed = {"image": image, + "mask": segmentation + } + example["image"] = (processed["image"]/127.5 - 1.0).astype(np.float32) + segmentation = processed["mask"] + onehot = np.eye(self.n_labels)[segmentation] + example["segmentation"] = onehot + return example + + +class Examples(SegmentationBase): + def __init__(self, size=None, random_crop=False, interpolation="bicubic"): + super().__init__(data_csv="data/sflckr_examples.txt", + data_root="data/sflckr_images", + segmentation_root="data/sflckr_segmentations", + size=size, random_crop=random_crop, interpolation=interpolation) diff --git a/src/taming-transformers/taming/data/utils.py b/src/taming-transformers/taming/data/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2b3c3d53cd2b6c72b481b59834cf809d3735b394 --- /dev/null +++ b/src/taming-transformers/taming/data/utils.py @@ -0,0 +1,169 @@ +import collections +import os +import tarfile +import urllib +import zipfile +from pathlib import Path + +import numpy as np +import torch +from taming.data.helper_types import Annotation +from torch._six import string_classes +from torch.utils.data._utils.collate import np_str_obj_array_pattern, default_collate_err_msg_format +from tqdm import tqdm + + +def unpack(path): + if path.endswith("tar.gz"): + with tarfile.open(path, "r:gz") as tar: + tar.extractall(path=os.path.split(path)[0]) + elif path.endswith("tar"): + with tarfile.open(path, "r:") as tar: + tar.extractall(path=os.path.split(path)[0]) + elif path.endswith("zip"): + with zipfile.ZipFile(path, "r") as f: + f.extractall(path=os.path.split(path)[0]) + else: + raise NotImplementedError( + "Unknown file extension: {}".format(os.path.splitext(path)[1]) + ) + + +def reporthook(bar): + """tqdm progress bar for downloads.""" + + def hook(b=1, bsize=1, tsize=None): + if tsize is not None: + bar.total = tsize + bar.update(b * bsize - bar.n) + + return hook + + +def get_root(name): + base = "data/" + root = os.path.join(base, name) + os.makedirs(root, exist_ok=True) + return root + + +def is_prepared(root): + return Path(root).joinpath(".ready").exists() + + +def mark_prepared(root): + Path(root).joinpath(".ready").touch() + + +def prompt_download(file_, source, target_dir, content_dir=None): + targetpath = os.path.join(target_dir, file_) + while not os.path.exists(targetpath): + if content_dir is not None and os.path.exists( + os.path.join(target_dir, content_dir) + ): + break + print( + "Please download '{}' from '{}' to '{}'.".format(file_, source, targetpath) + ) + if content_dir is not None: + print( + "Or place its content into '{}'.".format( + os.path.join(target_dir, content_dir) + ) + ) + input("Press Enter when done...") + return targetpath + + +def download_url(file_, url, target_dir): + targetpath = os.path.join(target_dir, file_) + os.makedirs(target_dir, exist_ok=True) + with tqdm( + unit="B", unit_scale=True, unit_divisor=1024, miniters=1, desc=file_ + ) as bar: + urllib.request.urlretrieve(url, targetpath, reporthook=reporthook(bar)) + return targetpath + + +def download_urls(urls, target_dir): + paths = dict() + for fname, url in urls.items(): + outpath = download_url(fname, url, target_dir) + paths[fname] = outpath + return paths + + +def quadratic_crop(x, bbox, alpha=1.0): + """bbox is xmin, ymin, xmax, ymax""" + im_h, im_w = x.shape[:2] + bbox = np.array(bbox, dtype=np.float32) + bbox = np.clip(bbox, 0, max(im_h, im_w)) + center = 0.5 * (bbox[0] + bbox[2]), 0.5 * (bbox[1] + bbox[3]) + w = bbox[2] - bbox[0] + h = bbox[3] - bbox[1] + l = int(alpha * max(w, h)) + l = max(l, 2) + + required_padding = -1 * min( + center[0] - l, center[1] - l, im_w - (center[0] + l), im_h - (center[1] + l) + ) + required_padding = int(np.ceil(required_padding)) + if required_padding > 0: + padding = [ + [required_padding, required_padding], + [required_padding, required_padding], + ] + padding += [[0, 0]] * (len(x.shape) - 2) + x = np.pad(x, padding, "reflect") + center = center[0] + required_padding, center[1] + required_padding + xmin = int(center[0] - l / 2) + ymin = int(center[1] - l / 2) + return np.array(x[ymin : ymin + l, xmin : xmin + l, ...]) + + +def custom_collate(batch): + r"""source: pytorch 1.9.0, only one modification to original code """ + + elem = batch[0] + elem_type = type(elem) + if isinstance(elem, torch.Tensor): + out = None + if torch.utils.data.get_worker_info() is not None: + # If we're in a background process, concatenate directly into a + # shared memory tensor to avoid an extra copy + numel = sum([x.numel() for x in batch]) + storage = elem.storage()._new_shared(numel) + out = elem.new(storage) + return torch.stack(batch, 0, out=out) + elif elem_type.__module__ == 'numpy' and elem_type.__name__ != 'str_' \ + and elem_type.__name__ != 'string_': + if elem_type.__name__ == 'ndarray' or elem_type.__name__ == 'memmap': + # array of string classes and object + if np_str_obj_array_pattern.search(elem.dtype.str) is not None: + raise TypeError(default_collate_err_msg_format.format(elem.dtype)) + + return custom_collate([torch.as_tensor(b) for b in batch]) + elif elem.shape == (): # scalars + return torch.as_tensor(batch) + elif isinstance(elem, float): + return torch.tensor(batch, dtype=torch.float64) + elif isinstance(elem, int): + return torch.tensor(batch) + elif isinstance(elem, string_classes): + return batch + elif isinstance(elem, collections.abc.Mapping): + return {key: custom_collate([d[key] for d in batch]) for key in elem} + elif isinstance(elem, tuple) and hasattr(elem, '_fields'): # namedtuple + return elem_type(*(custom_collate(samples) for samples in zip(*batch))) + if isinstance(elem, collections.abc.Sequence) and isinstance(elem[0], Annotation): # added + return batch # added + elif isinstance(elem, collections.abc.Sequence): + # check to make sure that the elements in batch have consistent size + it = iter(batch) + elem_size = len(next(it)) + if not all(len(elem) == elem_size for elem in it): + raise RuntimeError('each element in list of batch should be of equal size') + transposed = zip(*batch) + return [custom_collate(samples) for samples in transposed] + + raise TypeError(default_collate_err_msg_format.format(elem_type)) diff --git a/src/taming-transformers/taming/lr_scheduler.py b/src/taming-transformers/taming/lr_scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..e598ed120159c53da6820a55ad86b89f5c70c82d --- /dev/null +++ b/src/taming-transformers/taming/lr_scheduler.py @@ -0,0 +1,34 @@ +import numpy as np + + +class LambdaWarmUpCosineScheduler: + """ + note: use with a base_lr of 1.0 + """ + def __init__(self, warm_up_steps, lr_min, lr_max, lr_start, max_decay_steps, verbosity_interval=0): + self.lr_warm_up_steps = warm_up_steps + self.lr_start = lr_start + self.lr_min = lr_min + self.lr_max = lr_max + self.lr_max_decay_steps = max_decay_steps + self.last_lr = 0. + self.verbosity_interval = verbosity_interval + + def schedule(self, n): + if self.verbosity_interval > 0: + if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_lr}") + if n < self.lr_warm_up_steps: + lr = (self.lr_max - self.lr_start) / self.lr_warm_up_steps * n + self.lr_start + self.last_lr = lr + return lr + else: + t = (n - self.lr_warm_up_steps) / (self.lr_max_decay_steps - self.lr_warm_up_steps) + t = min(t, 1.0) + lr = self.lr_min + 0.5 * (self.lr_max - self.lr_min) * ( + 1 + np.cos(t * np.pi)) + self.last_lr = lr + return lr + + def __call__(self, n): + return self.schedule(n) + diff --git a/src/taming-transformers/taming/models/cond_transformer.py b/src/taming-transformers/taming/models/cond_transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..e4c63730fa86ac1b92b37af14c14fb696595b1ab --- /dev/null +++ b/src/taming-transformers/taming/models/cond_transformer.py @@ -0,0 +1,352 @@ +import os, math +import torch +import torch.nn.functional as F +import pytorch_lightning as pl + +from main import instantiate_from_config +from taming.modules.util import SOSProvider + + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +class Net2NetTransformer(pl.LightningModule): + def __init__(self, + transformer_config, + first_stage_config, + cond_stage_config, + permuter_config=None, + ckpt_path=None, + ignore_keys=[], + first_stage_key="image", + cond_stage_key="depth", + downsample_cond_size=-1, + pkeep=1.0, + sos_token=0, + unconditional=False, + ): + super().__init__() + self.be_unconditional = unconditional + self.sos_token = sos_token + self.first_stage_key = first_stage_key + self.cond_stage_key = cond_stage_key + self.init_first_stage_from_ckpt(first_stage_config) + self.init_cond_stage_from_ckpt(cond_stage_config) + if permuter_config is None: + permuter_config = {"target": "taming.modules.transformer.permuter.Identity"} + self.permuter = instantiate_from_config(config=permuter_config) + self.transformer = instantiate_from_config(config=transformer_config) + + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + self.downsample_cond_size = downsample_cond_size + self.pkeep = pkeep + + def init_from_ckpt(self, path, ignore_keys=list()): + sd = torch.load(path, map_location="cpu")["state_dict"] + for k in sd.keys(): + for ik in ignore_keys: + if k.startswith(ik): + self.print("Deleting key {} from state_dict.".format(k)) + del sd[k] + self.load_state_dict(sd, strict=False) + print(f"Restored from {path}") + + def init_first_stage_from_ckpt(self, config): + model = instantiate_from_config(config) + model = model.eval() + model.train = disabled_train + self.first_stage_model = model + + def init_cond_stage_from_ckpt(self, config): + if config == "__is_first_stage__": + print("Using first stage also as cond stage.") + self.cond_stage_model = self.first_stage_model + elif config == "__is_unconditional__" or self.be_unconditional: + print(f"Using no cond stage. Assuming the training is intended to be unconditional. " + f"Prepending {self.sos_token} as a sos token.") + self.be_unconditional = True + self.cond_stage_key = self.first_stage_key + self.cond_stage_model = SOSProvider(self.sos_token) + else: + model = instantiate_from_config(config) + model = model.eval() + model.train = disabled_train + self.cond_stage_model = model + + def forward(self, x, c): + # one step to produce the logits + _, z_indices = self.encode_to_z(x) + _, c_indices = self.encode_to_c(c) + + if self.training and self.pkeep < 1.0: + mask = torch.bernoulli(self.pkeep*torch.ones(z_indices.shape, + device=z_indices.device)) + mask = mask.round().to(dtype=torch.int64) + r_indices = torch.randint_like(z_indices, self.transformer.config.vocab_size) + a_indices = mask*z_indices+(1-mask)*r_indices + else: + a_indices = z_indices + + cz_indices = torch.cat((c_indices, a_indices), dim=1) + + # target includes all sequence elements (no need to handle first one + # differently because we are conditioning) + target = z_indices + # make the prediction + logits, _ = self.transformer(cz_indices[:, :-1]) + # cut off conditioning outputs - output i corresponds to p(z_i | z_{ -1: + c = F.interpolate(c, size=(self.downsample_cond_size, self.downsample_cond_size)) + quant_c, _, [_,_,indices] = self.cond_stage_model.encode(c) + if len(indices.shape) > 2: + indices = indices.view(c.shape[0], -1) + return quant_c, indices + + @torch.no_grad() + def decode_to_img(self, index, zshape): + index = self.permuter(index, reverse=True) + bhwc = (zshape[0],zshape[2],zshape[3],zshape[1]) + quant_z = self.first_stage_model.quantize.get_codebook_entry( + index.reshape(-1), shape=bhwc) + x = self.first_stage_model.decode(quant_z) + return x + + @torch.no_grad() + def log_images(self, batch, temperature=None, top_k=None, callback=None, lr_interface=False, **kwargs): + log = dict() + + N = 4 + if lr_interface: + x, c = self.get_xc(batch, N, diffuse=False, upsample_factor=8) + else: + x, c = self.get_xc(batch, N) + x = x.to(device=self.device) + c = c.to(device=self.device) + + quant_z, z_indices = self.encode_to_z(x) + quant_c, c_indices = self.encode_to_c(c) + + # create a "half"" sample + z_start_indices = z_indices[:,:z_indices.shape[1]//2] + index_sample = self.sample(z_start_indices, c_indices, + steps=z_indices.shape[1]-z_start_indices.shape[1], + temperature=temperature if temperature is not None else 1.0, + sample=True, + top_k=top_k if top_k is not None else 100, + callback=callback if callback is not None else lambda k: None) + x_sample = self.decode_to_img(index_sample, quant_z.shape) + + # sample + z_start_indices = z_indices[:, :0] + index_sample = self.sample(z_start_indices, c_indices, + steps=z_indices.shape[1], + temperature=temperature if temperature is not None else 1.0, + sample=True, + top_k=top_k if top_k is not None else 100, + callback=callback if callback is not None else lambda k: None) + x_sample_nopix = self.decode_to_img(index_sample, quant_z.shape) + + # det sample + z_start_indices = z_indices[:, :0] + index_sample = self.sample(z_start_indices, c_indices, + steps=z_indices.shape[1], + sample=False, + callback=callback if callback is not None else lambda k: None) + x_sample_det = self.decode_to_img(index_sample, quant_z.shape) + + # reconstruction + x_rec = self.decode_to_img(z_indices, quant_z.shape) + + log["inputs"] = x + log["reconstructions"] = x_rec + + if self.cond_stage_key in ["objects_bbox", "objects_center_points"]: + figure_size = (x_rec.shape[2], x_rec.shape[3]) + dataset = kwargs["pl_module"].trainer.datamodule.datasets["validation"] + label_for_category_no = dataset.get_textual_label_for_category_no + plotter = dataset.conditional_builders[self.cond_stage_key].plot + log["conditioning"] = torch.zeros_like(log["reconstructions"]) + for i in range(quant_c.shape[0]): + log["conditioning"][i] = plotter(quant_c[i], label_for_category_no, figure_size) + log["conditioning_rec"] = log["conditioning"] + elif self.cond_stage_key != "image": + cond_rec = self.cond_stage_model.decode(quant_c) + if self.cond_stage_key == "segmentation": + # get image from segmentation mask + num_classes = cond_rec.shape[1] + + c = torch.argmax(c, dim=1, keepdim=True) + c = F.one_hot(c, num_classes=num_classes) + c = c.squeeze(1).permute(0, 3, 1, 2).float() + c = self.cond_stage_model.to_rgb(c) + + cond_rec = torch.argmax(cond_rec, dim=1, keepdim=True) + cond_rec = F.one_hot(cond_rec, num_classes=num_classes) + cond_rec = cond_rec.squeeze(1).permute(0, 3, 1, 2).float() + cond_rec = self.cond_stage_model.to_rgb(cond_rec) + log["conditioning_rec"] = cond_rec + log["conditioning"] = c + + log["samples_half"] = x_sample + log["samples_nopix"] = x_sample_nopix + log["samples_det"] = x_sample_det + return log + + def get_input(self, key, batch): + x = batch[key] + if len(x.shape) == 3: + x = x[..., None] + if len(x.shape) == 4: + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format) + if x.dtype == torch.double: + x = x.float() + return x + + def get_xc(self, batch, N=None): + x = self.get_input(self.first_stage_key, batch) + c = self.get_input(self.cond_stage_key, batch) + if N is not None: + x = x[:N] + c = c[:N] + return x, c + + def shared_step(self, batch, batch_idx): + x, c = self.get_xc(batch) + logits, target = self(x, c) + loss = F.cross_entropy(logits.reshape(-1, logits.size(-1)), target.reshape(-1)) + return loss + + def training_step(self, batch, batch_idx): + loss = self.shared_step(batch, batch_idx) + self.log("train/loss", loss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + return loss + + def validation_step(self, batch, batch_idx): + loss = self.shared_step(batch, batch_idx) + self.log("val/loss", loss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + return loss + + def configure_optimizers(self): + """ + Following minGPT: + This long function is unfortunately doing something very simple and is being very defensive: + We are separating out all parameters of the model into two buckets: those that will experience + weight decay for regularization and those that won't (biases, and layernorm/embedding weights). + We are then returning the PyTorch optimizer object. + """ + # separate out all parameters to those that will and won't experience regularizing weight decay + decay = set() + no_decay = set() + whitelist_weight_modules = (torch.nn.Linear, ) + blacklist_weight_modules = (torch.nn.LayerNorm, torch.nn.Embedding) + for mn, m in self.transformer.named_modules(): + for pn, p in m.named_parameters(): + fpn = '%s.%s' % (mn, pn) if mn else pn # full param name + + if pn.endswith('bias'): + # all biases will not be decayed + no_decay.add(fpn) + elif pn.endswith('weight') and isinstance(m, whitelist_weight_modules): + # weights of whitelist modules will be weight decayed + decay.add(fpn) + elif pn.endswith('weight') and isinstance(m, blacklist_weight_modules): + # weights of blacklist modules will NOT be weight decayed + no_decay.add(fpn) + + # special case the position embedding parameter in the root GPT module as not decayed + no_decay.add('pos_emb') + + # validate that we considered every parameter + param_dict = {pn: p for pn, p in self.transformer.named_parameters()} + inter_params = decay & no_decay + union_params = decay | no_decay + assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params), ) + assert len(param_dict.keys() - union_params) == 0, "parameters %s were not separated into either decay/no_decay set!" \ + % (str(param_dict.keys() - union_params), ) + + # create the pytorch optimizer object + optim_groups = [ + {"params": [param_dict[pn] for pn in sorted(list(decay))], "weight_decay": 0.01}, + {"params": [param_dict[pn] for pn in sorted(list(no_decay))], "weight_decay": 0.0}, + ] + optimizer = torch.optim.AdamW(optim_groups, lr=self.learning_rate, betas=(0.9, 0.95)) + return optimizer diff --git a/src/taming-transformers/taming/models/dummy_cond_stage.py b/src/taming-transformers/taming/models/dummy_cond_stage.py new file mode 100644 index 0000000000000000000000000000000000000000..6e19938078752e09b926a3e749907ee99a258ca0 --- /dev/null +++ b/src/taming-transformers/taming/models/dummy_cond_stage.py @@ -0,0 +1,22 @@ +from torch import Tensor + + +class DummyCondStage: + def __init__(self, conditional_key): + self.conditional_key = conditional_key + self.train = None + + def eval(self): + return self + + @staticmethod + def encode(c: Tensor): + return c, None, (None, None, c) + + @staticmethod + def decode(c: Tensor): + return c + + @staticmethod + def to_rgb(c: Tensor): + return c diff --git a/src/taming-transformers/taming/models/vqgan.py b/src/taming-transformers/taming/models/vqgan.py new file mode 100644 index 0000000000000000000000000000000000000000..a6950baa5f739111cd64c17235dca8be3a5f8037 --- /dev/null +++ b/src/taming-transformers/taming/models/vqgan.py @@ -0,0 +1,404 @@ +import torch +import torch.nn.functional as F +import pytorch_lightning as pl + +from main import instantiate_from_config + +from taming.modules.diffusionmodules.model import Encoder, Decoder +from taming.modules.vqvae.quantize import VectorQuantizer2 as VectorQuantizer +from taming.modules.vqvae.quantize import GumbelQuantize +from taming.modules.vqvae.quantize import EMAVectorQuantizer + +class VQModel(pl.LightningModule): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + remap=None, + sane_index_shape=False, # tell vector quantizer to return indices as bhw + ): + super().__init__() + self.image_key = image_key + self.encoder = Encoder(**ddconfig) + self.decoder = Decoder(**ddconfig) + self.loss = instantiate_from_config(lossconfig) + self.quantize = VectorQuantizer(n_embed, embed_dim, beta=0.25, + remap=remap, sane_index_shape=sane_index_shape) + self.quant_conv = torch.nn.Conv2d(ddconfig["z_channels"], embed_dim, 1) + self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1) + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + self.image_key = image_key + if colorize_nlabels is not None: + assert type(colorize_nlabels)==int + self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1)) + if monitor is not None: + self.monitor = monitor + + def init_from_ckpt(self, path, ignore_keys=list()): + sd = torch.load(path, map_location="cpu")["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + self.load_state_dict(sd, strict=False) + print(f"Restored from {path}") + + def encode(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + quant, emb_loss, info = self.quantize(h) + return quant, emb_loss, info + + def decode(self, quant): + quant = self.post_quant_conv(quant) + dec = self.decoder(quant) + return dec + + def decode_code(self, code_b): + quant_b = self.quantize.embed_code(code_b) + dec = self.decode(quant_b) + return dec + + def forward(self, input): + quant, diff, _ = self.encode(input) + dec = self.decode(quant) + return dec, diff + + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format) + return x.float() + + def training_step(self, batch, batch_idx, optimizer_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + + if optimizer_idx == 0: + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log("train/aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + if optimizer_idx == 1: + # discriminator + discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log("train/discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return discloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step, + last_layer=self.get_last_layer(), split="val") + + discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step, + last_layer=self.get_last_layer(), split="val") + rec_loss = log_dict_ae["val/rec_loss"] + self.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + self.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def configure_optimizers(self): + lr = self.learning_rate + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quantize.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr, betas=(0.5, 0.9)) + opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(), + lr=lr, betas=(0.5, 0.9)) + return [opt_ae, opt_disc], [] + + def get_last_layer(self): + return self.decoder.conv_out.weight + + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + xrec, _ = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec.shape[1] > 3 + x = self.to_rgb(x) + xrec = self.to_rgb(xrec) + log["inputs"] = x + log["reconstructions"] = xrec + return log + + def to_rgb(self, x): + assert self.image_key == "segmentation" + if not hasattr(self, "colorize"): + self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x)) + x = F.conv2d(x, weight=self.colorize) + x = 2.*(x-x.min())/(x.max()-x.min()) - 1. + return x + + +class VQSegmentationModel(VQModel): + def __init__(self, n_labels, *args, **kwargs): + super().__init__(*args, **kwargs) + self.register_buffer("colorize", torch.randn(3, n_labels, 1, 1)) + + def configure_optimizers(self): + lr = self.learning_rate + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quantize.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr, betas=(0.5, 0.9)) + return opt_ae + + def training_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, split="train") + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, split="val") + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + total_loss = log_dict_ae["val/total_loss"] + self.log("val/total_loss", total_loss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + return aeloss + + @torch.no_grad() + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + xrec, _ = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec.shape[1] > 3 + # convert logits to indices + xrec = torch.argmax(xrec, dim=1, keepdim=True) + xrec = F.one_hot(xrec, num_classes=x.shape[1]) + xrec = xrec.squeeze(1).permute(0, 3, 1, 2).float() + x = self.to_rgb(x) + xrec = self.to_rgb(xrec) + log["inputs"] = x + log["reconstructions"] = xrec + return log + + +class VQNoDiscModel(VQModel): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None + ): + super().__init__(ddconfig=ddconfig, lossconfig=lossconfig, n_embed=n_embed, embed_dim=embed_dim, + ckpt_path=ckpt_path, ignore_keys=ignore_keys, image_key=image_key, + colorize_nlabels=colorize_nlabels) + + def training_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, self.global_step, split="train") + output = pl.TrainResult(minimize=aeloss) + output.log("train/aeloss", aeloss, + prog_bar=True, logger=True, on_step=True, on_epoch=True) + output.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return output + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, self.global_step, split="val") + rec_loss = log_dict_ae["val/rec_loss"] + output = pl.EvalResult(checkpoint_on=rec_loss) + output.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=True, on_epoch=True) + output.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=True, on_epoch=True) + output.log_dict(log_dict_ae) + + return output + + def configure_optimizers(self): + optimizer = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quantize.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=self.learning_rate, betas=(0.5, 0.9)) + return optimizer + + +class GumbelVQ(VQModel): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + temperature_scheduler_config, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + kl_weight=1e-8, + remap=None, + ): + + z_channels = ddconfig["z_channels"] + super().__init__(ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=ignore_keys, + image_key=image_key, + colorize_nlabels=colorize_nlabels, + monitor=monitor, + ) + + self.loss.n_classes = n_embed + self.vocab_size = n_embed + + self.quantize = GumbelQuantize(z_channels, embed_dim, + n_embed=n_embed, + kl_weight=kl_weight, temp_init=1.0, + remap=remap) + + self.temperature_scheduler = instantiate_from_config(temperature_scheduler_config) # annealing of temp + + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + + def temperature_scheduling(self): + self.quantize.temperature = self.temperature_scheduler(self.global_step) + + def encode_to_prequant(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + return h + + def decode_code(self, code_b): + raise NotImplementedError + + def training_step(self, batch, batch_idx, optimizer_idx): + self.temperature_scheduling() + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + + if optimizer_idx == 0: + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + self.log("temperature", self.quantize.temperature, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + if optimizer_idx == 1: + # discriminator + discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return discloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x, return_pred_indices=True) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step, + last_layer=self.get_last_layer(), split="val") + + discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step, + last_layer=self.get_last_layer(), split="val") + rec_loss = log_dict_ae["val/rec_loss"] + self.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + self.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + # encode + h = self.encoder(x) + h = self.quant_conv(h) + quant, _, _ = self.quantize(h) + # decode + x_rec = self.decode(quant) + log["inputs"] = x + log["reconstructions"] = x_rec + return log + + +class EMAVQ(VQModel): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + remap=None, + sane_index_shape=False, # tell vector quantizer to return indices as bhw + ): + super().__init__(ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=ignore_keys, + image_key=image_key, + colorize_nlabels=colorize_nlabels, + monitor=monitor, + ) + self.quantize = EMAVectorQuantizer(n_embed=n_embed, + embedding_dim=embed_dim, + beta=0.25, + remap=remap) + def configure_optimizers(self): + lr = self.learning_rate + #Remove self.quantize from parameter list since it is updated via EMA + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr, betas=(0.5, 0.9)) + opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(), + lr=lr, betas=(0.5, 0.9)) + return [opt_ae, opt_disc], [] \ No newline at end of file diff --git a/src/taming-transformers/taming/modules/diffusionmodules/model.py b/src/taming-transformers/taming/modules/diffusionmodules/model.py new file mode 100644 index 0000000000000000000000000000000000000000..d3a5db6aa2ef915e270f1ae135e4a9918fdd884c --- /dev/null +++ b/src/taming-transformers/taming/modules/diffusionmodules/model.py @@ -0,0 +1,776 @@ +# pytorch_diffusion + derived encoder decoder +import math +import torch +import torch.nn as nn +import numpy as np + + +def get_timestep_embedding(timesteps, embedding_dim): + """ + This matches the implementation in Denoising Diffusion Probabilistic Models: + From Fairseq. + Build sinusoidal embeddings. + This matches the implementation in tensor2tensor, but differs slightly + from the description in Section 3.5 of "Attention Is All You Need". + """ + assert len(timesteps.shape) == 1 + + half_dim = embedding_dim // 2 + emb = math.log(10000) / (half_dim - 1) + emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb) + emb = emb.to(device=timesteps.device) + emb = timesteps.float()[:, None] * emb[None, :] + emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1) + if embedding_dim % 2 == 1: # zero pad + emb = torch.nn.functional.pad(emb, (0,1,0,0)) + return emb + + +def nonlinearity(x): + # swish + return x*torch.sigmoid(x) + + +def Normalize(in_channels): + return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True) + + +class Upsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest") + if self.with_conv: + x = self.conv(x) + return x + + +class Downsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + # no asymmetric padding in torch conv, must do it ourselves + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=2, + padding=0) + + def forward(self, x): + if self.with_conv: + pad = (0,1,0,1) + x = torch.nn.functional.pad(x, pad, mode="constant", value=0) + x = self.conv(x) + else: + x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2) + return x + + +class ResnetBlock(nn.Module): + def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False, + dropout, temb_channels=512): + super().__init__() + self.in_channels = in_channels + out_channels = in_channels if out_channels is None else out_channels + self.out_channels = out_channels + self.use_conv_shortcut = conv_shortcut + + self.norm1 = Normalize(in_channels) + self.conv1 = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + if temb_channels > 0: + self.temb_proj = torch.nn.Linear(temb_channels, + out_channels) + self.norm2 = Normalize(out_channels) + self.dropout = torch.nn.Dropout(dropout) + self.conv2 = torch.nn.Conv2d(out_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + self.conv_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + else: + self.nin_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=1, + stride=1, + padding=0) + + def forward(self, x, temb): + h = x + h = self.norm1(h) + h = nonlinearity(h) + h = self.conv1(h) + + if temb is not None: + h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None] + + h = self.norm2(h) + h = nonlinearity(h) + h = self.dropout(h) + h = self.conv2(h) + + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + x = self.conv_shortcut(x) + else: + x = self.nin_shortcut(x) + + return x+h + + +class AttnBlock(nn.Module): + def __init__(self, in_channels): + super().__init__() + self.in_channels = in_channels + + self.norm = Normalize(in_channels) + self.q = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.k = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.v = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.proj_out = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + + + def forward(self, x): + h_ = x + h_ = self.norm(h_) + q = self.q(h_) + k = self.k(h_) + v = self.v(h_) + + # compute attention + b,c,h,w = q.shape + q = q.reshape(b,c,h*w) + q = q.permute(0,2,1) # b,hw,c + k = k.reshape(b,c,h*w) # b,c,hw + w_ = torch.bmm(q,k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j] + w_ = w_ * (int(c)**(-0.5)) + w_ = torch.nn.functional.softmax(w_, dim=2) + + # attend to values + v = v.reshape(b,c,h*w) + w_ = w_.permute(0,2,1) # b,hw,hw (first hw of k, second of q) + h_ = torch.bmm(v,w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j] + h_ = h_.reshape(b,c,h,w) + + h_ = self.proj_out(h_) + + return x+h_ + + +class Model(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, use_timestep=True): + super().__init__() + self.ch = ch + self.temb_ch = self.ch*4 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + self.use_timestep = use_timestep + if self.use_timestep: + # timestep embedding + self.temb = nn.Module() + self.temb.dense = nn.ModuleList([ + torch.nn.Linear(self.ch, + self.temb_ch), + torch.nn.Linear(self.temb_ch, + self.temb_ch), + ]) + + # downsampling + self.conv_in = torch.nn.Conv2d(in_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + skip_in = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + if i_block == self.num_res_blocks: + skip_in = ch*in_ch_mult[i_level] + block.append(ResnetBlock(in_channels=block_in+skip_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + + def forward(self, x, t=None): + #assert x.shape[2] == x.shape[3] == self.resolution + + if self.use_timestep: + # timestep embedding + assert t is not None + temb = get_timestep_embedding(t, self.ch) + temb = self.temb.dense[0](temb) + temb = nonlinearity(temb) + temb = self.temb.dense[1](temb) + else: + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block]( + torch.cat([h, hs.pop()], dim=1), temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class Encoder(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, z_channels, double_z=True, **ignore_kwargs): + super().__init__() + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + # downsampling + self.conv_in = torch.nn.Conv2d(in_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + 2*z_channels if double_z else z_channels, + kernel_size=3, + stride=1, + padding=1) + + + def forward(self, x): + #assert x.shape[2] == x.shape[3] == self.resolution, "{}, {}, {}".format(x.shape[2], x.shape[3], self.resolution) + + # timestep embedding + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class Decoder(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, z_channels, give_pre_end=False, **ignorekwargs): + super().__init__() + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + self.give_pre_end = give_pre_end + + # compute in_ch_mult, block_in and curr_res at lowest res + in_ch_mult = (1,)+tuple(ch_mult) + block_in = ch*ch_mult[self.num_resolutions-1] + curr_res = resolution // 2**(self.num_resolutions-1) + self.z_shape = (1,z_channels,curr_res,curr_res) + print("Working with z of shape {} = {} dimensions.".format( + self.z_shape, np.prod(self.z_shape))) + + # z to block_in + self.conv_in = torch.nn.Conv2d(z_channels, + block_in, + kernel_size=3, + stride=1, + padding=1) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, z): + #assert z.shape[1:] == self.z_shape[1:] + self.last_z_shape = z.shape + + # timestep embedding + temb = None + + # z to block_in + h = self.conv_in(z) + + # middle + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block](h, temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + if self.give_pre_end: + return h + + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class VUNet(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, + in_channels, c_channels, + resolution, z_channels, use_timestep=False, **ignore_kwargs): + super().__init__() + self.ch = ch + self.temb_ch = self.ch*4 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + + self.use_timestep = use_timestep + if self.use_timestep: + # timestep embedding + self.temb = nn.Module() + self.temb.dense = nn.ModuleList([ + torch.nn.Linear(self.ch, + self.temb_ch), + torch.nn.Linear(self.temb_ch, + self.temb_ch), + ]) + + # downsampling + self.conv_in = torch.nn.Conv2d(c_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + self.z_in = torch.nn.Conv2d(z_channels, + block_in, + kernel_size=1, + stride=1, + padding=0) + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=2*block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + skip_in = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + if i_block == self.num_res_blocks: + skip_in = ch*in_ch_mult[i_level] + block.append(ResnetBlock(in_channels=block_in+skip_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + + def forward(self, x, z): + #assert x.shape[2] == x.shape[3] == self.resolution + + if self.use_timestep: + # timestep embedding + assert t is not None + temb = get_timestep_embedding(t, self.ch) + temb = self.temb.dense[0](temb) + temb = nonlinearity(temb) + temb = self.temb.dense[1](temb) + else: + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + z = self.z_in(z) + h = torch.cat((h,z),dim=1) + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block]( + torch.cat([h, hs.pop()], dim=1), temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class SimpleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, *args, **kwargs): + super().__init__() + self.model = nn.ModuleList([nn.Conv2d(in_channels, in_channels, 1), + ResnetBlock(in_channels=in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=2 * in_channels, + out_channels=4 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=4 * in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + nn.Conv2d(2*in_channels, in_channels, 1), + Upsample(in_channels, with_conv=True)]) + # end + self.norm_out = Normalize(in_channels) + self.conv_out = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + for i, layer in enumerate(self.model): + if i in [1,2,3]: + x = layer(x, None) + else: + x = layer(x) + + h = self.norm_out(x) + h = nonlinearity(h) + x = self.conv_out(h) + return x + + +class UpsampleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, ch, num_res_blocks, resolution, + ch_mult=(2,2), dropout=0.0): + super().__init__() + # upsampling + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + block_in = in_channels + curr_res = resolution // 2 ** (self.num_resolutions - 1) + self.res_blocks = nn.ModuleList() + self.upsample_blocks = nn.ModuleList() + for i_level in range(self.num_resolutions): + res_block = [] + block_out = ch * ch_mult[i_level] + for i_block in range(self.num_res_blocks + 1): + res_block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + self.res_blocks.append(nn.ModuleList(res_block)) + if i_level != self.num_resolutions - 1: + self.upsample_blocks.append(Upsample(block_in, True)) + curr_res = curr_res * 2 + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + # upsampling + h = x + for k, i_level in enumerate(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks + 1): + h = self.res_blocks[i_level][i_block](h, None) + if i_level != self.num_resolutions - 1: + h = self.upsample_blocks[k](h) + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + diff --git a/src/taming-transformers/taming/modules/discriminator/model.py b/src/taming-transformers/taming/modules/discriminator/model.py new file mode 100644 index 0000000000000000000000000000000000000000..2aaa3110d0a7bcd05de7eca1e45101589ca5af05 --- /dev/null +++ b/src/taming-transformers/taming/modules/discriminator/model.py @@ -0,0 +1,67 @@ +import functools +import torch.nn as nn + + +from taming.modules.util import ActNorm + + +def weights_init(m): + classname = m.__class__.__name__ + if classname.find('Conv') != -1: + nn.init.normal_(m.weight.data, 0.0, 0.02) + elif classname.find('BatchNorm') != -1: + nn.init.normal_(m.weight.data, 1.0, 0.02) + nn.init.constant_(m.bias.data, 0) + + +class NLayerDiscriminator(nn.Module): + """Defines a PatchGAN discriminator as in Pix2Pix + --> see https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/master/models/networks.py + """ + def __init__(self, input_nc=3, ndf=64, n_layers=3, use_actnorm=False): + """Construct a PatchGAN discriminator + Parameters: + input_nc (int) -- the number of channels in input images + ndf (int) -- the number of filters in the last conv layer + n_layers (int) -- the number of conv layers in the discriminator + norm_layer -- normalization layer + """ + super(NLayerDiscriminator, self).__init__() + if not use_actnorm: + norm_layer = nn.BatchNorm2d + else: + norm_layer = ActNorm + if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters + use_bias = norm_layer.func != nn.BatchNorm2d + else: + use_bias = norm_layer != nn.BatchNorm2d + + kw = 4 + padw = 1 + sequence = [nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True)] + nf_mult = 1 + nf_mult_prev = 1 + for n in range(1, n_layers): # gradually increase the number of filters + nf_mult_prev = nf_mult + nf_mult = min(2 ** n, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=2, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + nf_mult_prev = nf_mult + nf_mult = min(2 ** n_layers, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=1, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + sequence += [ + nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)] # output 1 channel prediction map + self.main = nn.Sequential(*sequence) + + def forward(self, input): + """Standard forward.""" + return self.main(input) diff --git a/src/taming-transformers/taming/modules/losses/__init__.py b/src/taming-transformers/taming/modules/losses/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d09caf9eb805f849a517f1b23503e1a4d6ea1ec5 --- /dev/null +++ b/src/taming-transformers/taming/modules/losses/__init__.py @@ -0,0 +1,2 @@ +from taming.modules.losses.vqperceptual import DummyLoss + diff --git a/src/taming-transformers/taming/modules/losses/lpips.py b/src/taming-transformers/taming/modules/losses/lpips.py new file mode 100644 index 0000000000000000000000000000000000000000..a7280447694ffc302a7636e7e4d6183408e0aa95 --- /dev/null +++ b/src/taming-transformers/taming/modules/losses/lpips.py @@ -0,0 +1,123 @@ +"""Stripped version of https://github.com/richzhang/PerceptualSimilarity/tree/master/models""" + +import torch +import torch.nn as nn +from torchvision import models +from collections import namedtuple + +from taming.util import get_ckpt_path + + +class LPIPS(nn.Module): + # Learned perceptual metric + def __init__(self, use_dropout=True): + super().__init__() + self.scaling_layer = ScalingLayer() + self.chns = [64, 128, 256, 512, 512] # vg16 features + self.net = vgg16(pretrained=True, requires_grad=False) + self.lin0 = NetLinLayer(self.chns[0], use_dropout=use_dropout) + self.lin1 = NetLinLayer(self.chns[1], use_dropout=use_dropout) + self.lin2 = NetLinLayer(self.chns[2], use_dropout=use_dropout) + self.lin3 = NetLinLayer(self.chns[3], use_dropout=use_dropout) + self.lin4 = NetLinLayer(self.chns[4], use_dropout=use_dropout) + self.load_from_pretrained() + for param in self.parameters(): + param.requires_grad = False + + def load_from_pretrained(self, name="vgg_lpips"): + ckpt = get_ckpt_path(name, "taming/modules/autoencoder/lpips") + self.load_state_dict(torch.load(ckpt, map_location=torch.device("cpu")), strict=False) + print("loaded pretrained LPIPS loss from {}".format(ckpt)) + + @classmethod + def from_pretrained(cls, name="vgg_lpips"): + if name != "vgg_lpips": + raise NotImplementedError + model = cls() + ckpt = get_ckpt_path(name) + model.load_state_dict(torch.load(ckpt, map_location=torch.device("cpu")), strict=False) + return model + + def forward(self, input, target): + in0_input, in1_input = (self.scaling_layer(input), self.scaling_layer(target)) + outs0, outs1 = self.net(in0_input), self.net(in1_input) + feats0, feats1, diffs = {}, {}, {} + lins = [self.lin0, self.lin1, self.lin2, self.lin3, self.lin4] + for kk in range(len(self.chns)): + feats0[kk], feats1[kk] = normalize_tensor(outs0[kk]), normalize_tensor(outs1[kk]) + diffs[kk] = (feats0[kk] - feats1[kk]) ** 2 + + res = [spatial_average(lins[kk].model(diffs[kk]), keepdim=True) for kk in range(len(self.chns))] + val = res[0] + for l in range(1, len(self.chns)): + val += res[l] + return val + + +class ScalingLayer(nn.Module): + def __init__(self): + super(ScalingLayer, self).__init__() + self.register_buffer('shift', torch.Tensor([-.030, -.088, -.188])[None, :, None, None]) + self.register_buffer('scale', torch.Tensor([.458, .448, .450])[None, :, None, None]) + + def forward(self, inp): + return (inp - self.shift) / self.scale + + +class NetLinLayer(nn.Module): + """ A single linear layer which does a 1x1 conv """ + def __init__(self, chn_in, chn_out=1, use_dropout=False): + super(NetLinLayer, self).__init__() + layers = [nn.Dropout(), ] if (use_dropout) else [] + layers += [nn.Conv2d(chn_in, chn_out, 1, stride=1, padding=0, bias=False), ] + self.model = nn.Sequential(*layers) + + +class vgg16(torch.nn.Module): + def __init__(self, requires_grad=False, pretrained=True): + super(vgg16, self).__init__() + vgg_pretrained_features = models.vgg16(pretrained=pretrained).features + self.slice1 = torch.nn.Sequential() + self.slice2 = torch.nn.Sequential() + self.slice3 = torch.nn.Sequential() + self.slice4 = torch.nn.Sequential() + self.slice5 = torch.nn.Sequential() + self.N_slices = 5 + for x in range(4): + self.slice1.add_module(str(x), vgg_pretrained_features[x]) + for x in range(4, 9): + self.slice2.add_module(str(x), vgg_pretrained_features[x]) + for x in range(9, 16): + self.slice3.add_module(str(x), vgg_pretrained_features[x]) + for x in range(16, 23): + self.slice4.add_module(str(x), vgg_pretrained_features[x]) + for x in range(23, 30): + self.slice5.add_module(str(x), vgg_pretrained_features[x]) + if not requires_grad: + for param in self.parameters(): + param.requires_grad = False + + def forward(self, X): + h = self.slice1(X) + h_relu1_2 = h + h = self.slice2(h) + h_relu2_2 = h + h = self.slice3(h) + h_relu3_3 = h + h = self.slice4(h) + h_relu4_3 = h + h = self.slice5(h) + h_relu5_3 = h + vgg_outputs = namedtuple("VggOutputs", ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3', 'relu5_3']) + out = vgg_outputs(h_relu1_2, h_relu2_2, h_relu3_3, h_relu4_3, h_relu5_3) + return out + + +def normalize_tensor(x,eps=1e-10): + norm_factor = torch.sqrt(torch.sum(x**2,dim=1,keepdim=True)) + return x/(norm_factor+eps) + + +def spatial_average(x, keepdim=True): + return x.mean([2,3],keepdim=keepdim) + diff --git a/src/taming-transformers/taming/modules/losses/segmentation.py b/src/taming-transformers/taming/modules/losses/segmentation.py new file mode 100644 index 0000000000000000000000000000000000000000..4ba77deb5159a6307ed2acba9945e4764a4ff0a5 --- /dev/null +++ b/src/taming-transformers/taming/modules/losses/segmentation.py @@ -0,0 +1,22 @@ +import torch.nn as nn +import torch.nn.functional as F + + +class BCELoss(nn.Module): + def forward(self, prediction, target): + loss = F.binary_cross_entropy_with_logits(prediction,target) + return loss, {} + + +class BCELossWithQuant(nn.Module): + def __init__(self, codebook_weight=1.): + super().__init__() + self.codebook_weight = codebook_weight + + def forward(self, qloss, target, prediction, split): + bce_loss = F.binary_cross_entropy_with_logits(prediction,target) + loss = bce_loss + self.codebook_weight*qloss + return loss, {"{}/total_loss".format(split): loss.clone().detach().mean(), + "{}/bce_loss".format(split): bce_loss.detach().mean(), + "{}/quant_loss".format(split): qloss.detach().mean() + } diff --git a/src/taming-transformers/taming/modules/losses/vqperceptual.py b/src/taming-transformers/taming/modules/losses/vqperceptual.py new file mode 100644 index 0000000000000000000000000000000000000000..c2febd445728479d4cd9aacdb2572cb1f1af04db --- /dev/null +++ b/src/taming-transformers/taming/modules/losses/vqperceptual.py @@ -0,0 +1,136 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from taming.modules.losses.lpips import LPIPS +from taming.modules.discriminator.model import NLayerDiscriminator, weights_init + + +class DummyLoss(nn.Module): + def __init__(self): + super().__init__() + + +def adopt_weight(weight, global_step, threshold=0, value=0.): + if global_step < threshold: + weight = value + return weight + + +def hinge_d_loss(logits_real, logits_fake): + loss_real = torch.mean(F.relu(1. - logits_real)) + loss_fake = torch.mean(F.relu(1. + logits_fake)) + d_loss = 0.5 * (loss_real + loss_fake) + return d_loss + + +def vanilla_d_loss(logits_real, logits_fake): + d_loss = 0.5 * ( + torch.mean(torch.nn.functional.softplus(-logits_real)) + + torch.mean(torch.nn.functional.softplus(logits_fake))) + return d_loss + + +class VQLPIPSWithDiscriminator(nn.Module): + def __init__(self, disc_start, codebook_weight=1.0, pixelloss_weight=1.0, + disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0, + perceptual_weight=1.0, use_actnorm=False, disc_conditional=False, + disc_ndf=64, disc_loss="hinge"): + super().__init__() + assert disc_loss in ["hinge", "vanilla"] + self.codebook_weight = codebook_weight + self.pixel_weight = pixelloss_weight + self.perceptual_loss = LPIPS().eval() + self.perceptual_weight = perceptual_weight + + self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels, + n_layers=disc_num_layers, + use_actnorm=use_actnorm, + ndf=disc_ndf + ).apply(weights_init) + self.discriminator_iter_start = disc_start + if disc_loss == "hinge": + self.disc_loss = hinge_d_loss + elif disc_loss == "vanilla": + self.disc_loss = vanilla_d_loss + else: + raise ValueError(f"Unknown GAN loss '{disc_loss}'.") + print(f"VQLPIPSWithDiscriminator running with {disc_loss} loss.") + self.disc_factor = disc_factor + self.discriminator_weight = disc_weight + self.disc_conditional = disc_conditional + + def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None): + if last_layer is not None: + nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0] + else: + nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0] + + d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4) + d_weight = torch.clamp(d_weight, 0.0, 1e4).detach() + d_weight = d_weight * self.discriminator_weight + return d_weight + + def forward(self, codebook_loss, inputs, reconstructions, optimizer_idx, + global_step, last_layer=None, cond=None, split="train"): + rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous()) + if self.perceptual_weight > 0: + p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous()) + rec_loss = rec_loss + self.perceptual_weight * p_loss + else: + p_loss = torch.tensor([0.0]) + + nll_loss = rec_loss + #nll_loss = torch.sum(nll_loss) / nll_loss.shape[0] + nll_loss = torch.mean(nll_loss) + + # now the GAN part + if optimizer_idx == 0: + # generator update + if cond is None: + assert not self.disc_conditional + logits_fake = self.discriminator(reconstructions.contiguous()) + else: + assert self.disc_conditional + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1)) + g_loss = -torch.mean(logits_fake) + + try: + d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer) + except RuntimeError: + assert not self.training + d_weight = torch.tensor(0.0) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + loss = nll_loss + d_weight * disc_factor * g_loss + self.codebook_weight * codebook_loss.mean() + + log = {"{}/total_loss".format(split): loss.clone().detach().mean(), + "{}/quant_loss".format(split): codebook_loss.detach().mean(), + "{}/nll_loss".format(split): nll_loss.detach().mean(), + "{}/rec_loss".format(split): rec_loss.detach().mean(), + "{}/p_loss".format(split): p_loss.detach().mean(), + "{}/d_weight".format(split): d_weight.detach(), + "{}/disc_factor".format(split): torch.tensor(disc_factor), + "{}/g_loss".format(split): g_loss.detach().mean(), + } + return loss, log + + if optimizer_idx == 1: + # second pass for discriminator update + if cond is None: + logits_real = self.discriminator(inputs.contiguous().detach()) + logits_fake = self.discriminator(reconstructions.contiguous().detach()) + else: + logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1)) + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1)) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + d_loss = disc_factor * self.disc_loss(logits_real, logits_fake) + + log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(), + "{}/logits_real".format(split): logits_real.detach().mean(), + "{}/logits_fake".format(split): logits_fake.detach().mean() + } + return d_loss, log diff --git a/src/taming-transformers/taming/modules/misc/coord.py b/src/taming-transformers/taming/modules/misc/coord.py new file mode 100644 index 0000000000000000000000000000000000000000..ee69b0c897b6b382ae673622e420f55e494f5b09 --- /dev/null +++ b/src/taming-transformers/taming/modules/misc/coord.py @@ -0,0 +1,31 @@ +import torch + +class CoordStage(object): + def __init__(self, n_embed, down_factor): + self.n_embed = n_embed + self.down_factor = down_factor + + def eval(self): + return self + + def encode(self, c): + """fake vqmodel interface""" + assert 0.0 <= c.min() and c.max() <= 1.0 + b,ch,h,w = c.shape + assert ch == 1 + + c = torch.nn.functional.interpolate(c, scale_factor=1/self.down_factor, + mode="area") + c = c.clamp(0.0, 1.0) + c = self.n_embed*c + c_quant = c.round() + c_ind = c_quant.to(dtype=torch.long) + + info = None, None, c_ind + return c_quant, None, info + + def decode(self, c): + c = c/self.n_embed + c = torch.nn.functional.interpolate(c, scale_factor=self.down_factor, + mode="nearest") + return c diff --git a/src/taming-transformers/taming/modules/transformer/mingpt.py b/src/taming-transformers/taming/modules/transformer/mingpt.py new file mode 100644 index 0000000000000000000000000000000000000000..d14b7b68117f4b9f297b2929397cd4f55089334c --- /dev/null +++ b/src/taming-transformers/taming/modules/transformer/mingpt.py @@ -0,0 +1,415 @@ +""" +taken from: https://github.com/karpathy/minGPT/ +GPT model: +- the initial stem consists of a combination of token encoding and a positional encoding +- the meat of it is a uniform sequence of Transformer blocks + - each Transformer is a sequential combination of a 1-hidden-layer MLP block and a self-attention block + - all blocks feed into a central residual pathway similar to resnets +- the final decoder is a linear projection into a vanilla Softmax classifier +""" + +import math +import logging + +import torch +import torch.nn as nn +from torch.nn import functional as F +from transformers import top_k_top_p_filtering + +logger = logging.getLogger(__name__) + + +class GPTConfig: + """ base GPT config, params common to all GPT versions """ + embd_pdrop = 0.1 + resid_pdrop = 0.1 + attn_pdrop = 0.1 + + def __init__(self, vocab_size, block_size, **kwargs): + self.vocab_size = vocab_size + self.block_size = block_size + for k,v in kwargs.items(): + setattr(self, k, v) + + +class GPT1Config(GPTConfig): + """ GPT-1 like network roughly 125M params """ + n_layer = 12 + n_head = 12 + n_embd = 768 + + +class CausalSelfAttention(nn.Module): + """ + A vanilla multi-head masked self-attention layer with a projection at the end. + It is possible to use torch.nn.MultiheadAttention here but I am including an + explicit implementation here to show that there is nothing too scary here. + """ + + def __init__(self, config): + super().__init__() + assert config.n_embd % config.n_head == 0 + # key, query, value projections for all heads + self.key = nn.Linear(config.n_embd, config.n_embd) + self.query = nn.Linear(config.n_embd, config.n_embd) + self.value = nn.Linear(config.n_embd, config.n_embd) + # regularization + self.attn_drop = nn.Dropout(config.attn_pdrop) + self.resid_drop = nn.Dropout(config.resid_pdrop) + # output projection + self.proj = nn.Linear(config.n_embd, config.n_embd) + # causal mask to ensure that attention is only applied to the left in the input sequence + mask = torch.tril(torch.ones(config.block_size, + config.block_size)) + if hasattr(config, "n_unmasked"): + mask[:config.n_unmasked, :config.n_unmasked] = 1 + self.register_buffer("mask", mask.view(1, 1, config.block_size, config.block_size)) + self.n_head = config.n_head + + def forward(self, x, layer_past=None): + B, T, C = x.size() + + # calculate query, key, values for all heads in batch and move head forward to be the batch dim + k = self.key(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + q = self.query(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + v = self.value(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + + present = torch.stack((k, v)) + if layer_past is not None: + past_key, past_value = layer_past + k = torch.cat((past_key, k), dim=-2) + v = torch.cat((past_value, v), dim=-2) + + # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T) + att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) + if layer_past is None: + att = att.masked_fill(self.mask[:,:,:T,:T] == 0, float('-inf')) + + att = F.softmax(att, dim=-1) + att = self.attn_drop(att) + y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs) + y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side + + # output projection + y = self.resid_drop(self.proj(y)) + return y, present # TODO: check that this does not break anything + + +class Block(nn.Module): + """ an unassuming Transformer block """ + def __init__(self, config): + super().__init__() + self.ln1 = nn.LayerNorm(config.n_embd) + self.ln2 = nn.LayerNorm(config.n_embd) + self.attn = CausalSelfAttention(config) + self.mlp = nn.Sequential( + nn.Linear(config.n_embd, 4 * config.n_embd), + nn.GELU(), # nice + nn.Linear(4 * config.n_embd, config.n_embd), + nn.Dropout(config.resid_pdrop), + ) + + def forward(self, x, layer_past=None, return_present=False): + # TODO: check that training still works + if return_present: assert not self.training + # layer past: tuple of length two with B, nh, T, hs + attn, present = self.attn(self.ln1(x), layer_past=layer_past) + + x = x + attn + x = x + self.mlp(self.ln2(x)) + if layer_past is not None or return_present: + return x, present + return x + + +class GPT(nn.Module): + """ the full GPT language model, with a context size of block_size """ + def __init__(self, vocab_size, block_size, n_layer=12, n_head=8, n_embd=256, + embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0): + super().__init__() + config = GPTConfig(vocab_size=vocab_size, block_size=block_size, + embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop, + n_layer=n_layer, n_head=n_head, n_embd=n_embd, + n_unmasked=n_unmasked) + # input embedding stem + self.tok_emb = nn.Embedding(config.vocab_size, config.n_embd) + self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd)) + self.drop = nn.Dropout(config.embd_pdrop) + # transformer + self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)]) + # decoder head + self.ln_f = nn.LayerNorm(config.n_embd) + self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False) + self.block_size = config.block_size + self.apply(self._init_weights) + self.config = config + logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters())) + + def get_block_size(self): + return self.block_size + + def _init_weights(self, module): + if isinstance(module, (nn.Linear, nn.Embedding)): + module.weight.data.normal_(mean=0.0, std=0.02) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + + def forward(self, idx, embeddings=None, targets=None): + # forward the GPT model + token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector + + if embeddings is not None: # prepend explicit embeddings + token_embeddings = torch.cat((embeddings, token_embeddings), dim=1) + + t = token_embeddings.shape[1] + assert t <= self.block_size, "Cannot forward, model block size is exhausted." + position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector + x = self.drop(token_embeddings + position_embeddings) + x = self.blocks(x) + x = self.ln_f(x) + logits = self.head(x) + + # if we are given some desired targets also calculate the loss + loss = None + if targets is not None: + loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1)) + + return logits, loss + + def forward_with_past(self, idx, embeddings=None, targets=None, past=None, past_length=None): + # inference only + assert not self.training + token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector + if embeddings is not None: # prepend explicit embeddings + token_embeddings = torch.cat((embeddings, token_embeddings), dim=1) + + if past is not None: + assert past_length is not None + past = torch.cat(past, dim=-2) # n_layer, 2, b, nh, len_past, dim_head + past_shape = list(past.shape) + expected_shape = [self.config.n_layer, 2, idx.shape[0], self.config.n_head, past_length, self.config.n_embd//self.config.n_head] + assert past_shape == expected_shape, f"{past_shape} =/= {expected_shape}" + position_embeddings = self.pos_emb[:, past_length, :] # each position maps to a (learnable) vector + else: + position_embeddings = self.pos_emb[:, :token_embeddings.shape[1], :] + + x = self.drop(token_embeddings + position_embeddings) + presents = [] # accumulate over layers + for i, block in enumerate(self.blocks): + x, present = block(x, layer_past=past[i, ...] if past is not None else None, return_present=True) + presents.append(present) + + x = self.ln_f(x) + logits = self.head(x) + # if we are given some desired targets also calculate the loss + loss = None + if targets is not None: + loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1)) + + return logits, loss, torch.stack(presents) # _, _, n_layer, 2, b, nh, 1, dim_head + + +class DummyGPT(nn.Module): + # for debugging + def __init__(self, add_value=1): + super().__init__() + self.add_value = add_value + + def forward(self, idx): + return idx + self.add_value, None + + +class CodeGPT(nn.Module): + """Takes in semi-embeddings""" + def __init__(self, vocab_size, block_size, in_channels, n_layer=12, n_head=8, n_embd=256, + embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0): + super().__init__() + config = GPTConfig(vocab_size=vocab_size, block_size=block_size, + embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop, + n_layer=n_layer, n_head=n_head, n_embd=n_embd, + n_unmasked=n_unmasked) + # input embedding stem + self.tok_emb = nn.Linear(in_channels, config.n_embd) + self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd)) + self.drop = nn.Dropout(config.embd_pdrop) + # transformer + self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)]) + # decoder head + self.ln_f = nn.LayerNorm(config.n_embd) + self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False) + self.block_size = config.block_size + self.apply(self._init_weights) + self.config = config + logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters())) + + def get_block_size(self): + return self.block_size + + def _init_weights(self, module): + if isinstance(module, (nn.Linear, nn.Embedding)): + module.weight.data.normal_(mean=0.0, std=0.02) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + + def forward(self, idx, embeddings=None, targets=None): + # forward the GPT model + token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector + + if embeddings is not None: # prepend explicit embeddings + token_embeddings = torch.cat((embeddings, token_embeddings), dim=1) + + t = token_embeddings.shape[1] + assert t <= self.block_size, "Cannot forward, model block size is exhausted." + position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector + x = self.drop(token_embeddings + position_embeddings) + x = self.blocks(x) + x = self.taming_cinln_f(x) + logits = self.head(x) + + # if we are given some desired targets also calculate the loss + loss = None + if targets is not None: + loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1)) + + return logits, loss + + + +#### sampling utils + +def top_k_logits(logits, k): + v, ix = torch.topk(logits, k) + out = logits.clone() + out[out < v[:, [-1]]] = -float('Inf') + return out + +@torch.no_grad() +def sample(model, x, steps, temperature=1.0, sample=False, top_k=None): + """ + take a conditioning sequence of indices in x (of shape (b,t)) and predict the next token in + the sequence, feeding the predictions back into the model each time. Clearly the sampling + has quadratic complexity unlike an RNN that is only linear, and has a finite context window + of block_size, unlike an RNN that has an infinite context window. + """ + block_size = model.get_block_size() + model.eval() + for k in range(steps): + x_cond = x if x.size(1) <= block_size else x[:, -block_size:] # crop context if needed + logits, _ = model(x_cond) + # pluck the logits at the final step and scale by temperature + logits = logits[:, -1, :] / temperature + # optionally crop probabilities to only the top k options + if top_k is not None: + logits = top_k_logits(logits, top_k) + # apply softmax to convert to probabilities + probs = F.softmax(logits, dim=-1) + # sample from the distribution or take the most likely + if sample: + ix = torch.multinomial(probs, num_samples=1) + else: + _, ix = torch.topk(probs, k=1, dim=-1) + # append to the sequence and continue + x = torch.cat((x, ix), dim=1) + + return x + + +@torch.no_grad() +def sample_with_past(x, model, steps, temperature=1., sample_logits=True, + top_k=None, top_p=None, callback=None): + # x is conditioning + sample = x + cond_len = x.shape[1] + past = None + for n in range(steps): + if callback is not None: + callback(n) + logits, _, present = model.forward_with_past(x, past=past, past_length=(n+cond_len-1)) + if past is None: + past = [present] + else: + past.append(present) + logits = logits[:, -1, :] / temperature + if top_k is not None: + logits = top_k_top_p_filtering(logits, top_k=top_k, top_p=top_p) + + probs = F.softmax(logits, dim=-1) + if not sample_logits: + _, x = torch.topk(probs, k=1, dim=-1) + else: + x = torch.multinomial(probs, num_samples=1) + # append to the sequence and continue + sample = torch.cat((sample, x), dim=1) + del past + sample = sample[:, cond_len:] # cut conditioning off + return sample + + +#### clustering utils + +class KMeans(nn.Module): + def __init__(self, ncluster=512, nc=3, niter=10): + super().__init__() + self.ncluster = ncluster + self.nc = nc + self.niter = niter + self.shape = (3,32,32) + self.register_buffer("C", torch.zeros(self.ncluster,nc)) + self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8)) + + def is_initialized(self): + return self.initialized.item() == 1 + + @torch.no_grad() + def initialize(self, x): + N, D = x.shape + assert D == self.nc, D + c = x[torch.randperm(N)[:self.ncluster]] # init clusters at random + for i in range(self.niter): + # assign all pixels to the closest codebook element + a = ((x[:, None, :] - c[None, :, :])**2).sum(-1).argmin(1) + # move each codebook element to be the mean of the pixels that assigned to it + c = torch.stack([x[a==k].mean(0) for k in range(self.ncluster)]) + # re-assign any poorly positioned codebook elements + nanix = torch.any(torch.isnan(c), dim=1) + ndead = nanix.sum().item() + print('done step %d/%d, re-initialized %d dead clusters' % (i+1, self.niter, ndead)) + c[nanix] = x[torch.randperm(N)[:ndead]] # re-init dead clusters + + self.C.copy_(c) + self.initialized.fill_(1) + + + def forward(self, x, reverse=False, shape=None): + if not reverse: + # flatten + bs,c,h,w = x.shape + assert c == self.nc + x = x.reshape(bs,c,h*w,1) + C = self.C.permute(1,0) + C = C.reshape(1,c,1,self.ncluster) + a = ((x-C)**2).sum(1).argmin(-1) # bs, h*w indices + return a + else: + # flatten + bs, HW = x.shape + """ + c = self.C.reshape( 1, self.nc, 1, self.ncluster) + c = c[bs*[0],:,:,:] + c = c[:,:,HW*[0],:] + x = x.reshape(bs, 1, HW, 1) + x = x[:,3*[0],:,:] + x = torch.gather(c, dim=3, index=x) + """ + x = self.C[x] + x = x.permute(0,2,1) + shape = shape if shape is not None else self.shape + x = x.reshape(bs, *shape) + + return x diff --git a/src/taming-transformers/taming/modules/transformer/permuter.py b/src/taming-transformers/taming/modules/transformer/permuter.py new file mode 100644 index 0000000000000000000000000000000000000000..0d43bb135adde38d94bf18a7e5edaa4523cd95cf --- /dev/null +++ b/src/taming-transformers/taming/modules/transformer/permuter.py @@ -0,0 +1,248 @@ +import torch +import torch.nn as nn +import numpy as np + + +class AbstractPermuter(nn.Module): + def __init__(self, *args, **kwargs): + super().__init__() + def forward(self, x, reverse=False): + raise NotImplementedError + + +class Identity(AbstractPermuter): + def __init__(self): + super().__init__() + + def forward(self, x, reverse=False): + return x + + +class Subsample(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + C = 1 + indices = np.arange(H*W).reshape(C,H,W) + while min(H, W) > 1: + indices = indices.reshape(C,H//2,2,W//2,2) + indices = indices.transpose(0,2,4,1,3) + indices = indices.reshape(C*4,H//2, W//2) + H = H//2 + W = W//2 + C = C*4 + assert H == W == 1 + idx = torch.tensor(indices.ravel()) + self.register_buffer('forward_shuffle_idx', + nn.Parameter(idx, requires_grad=False)) + self.register_buffer('backward_shuffle_idx', + nn.Parameter(torch.argsort(idx), requires_grad=False)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +def mortonify(i, j): + """(i,j) index to linear morton code""" + i = np.uint64(i) + j = np.uint64(j) + + z = np.uint(0) + + for pos in range(32): + z = (z | + ((j & (np.uint64(1) << np.uint64(pos))) << np.uint64(pos)) | + ((i & (np.uint64(1) << np.uint64(pos))) << np.uint64(pos+1)) + ) + return z + + +class ZCurve(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + reverseidx = [np.int64(mortonify(i,j)) for i in range(H) for j in range(W)] + idx = np.argsort(reverseidx) + idx = torch.tensor(idx) + reverseidx = torch.tensor(reverseidx) + self.register_buffer('forward_shuffle_idx', + idx) + self.register_buffer('backward_shuffle_idx', + reverseidx) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +class SpiralOut(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + assert H == W + size = W + indices = np.arange(size*size).reshape(size,size) + + i0 = size//2 + j0 = size//2-1 + + i = i0 + j = j0 + + idx = [indices[i0, j0]] + step_mult = 0 + for c in range(1, size//2+1): + step_mult += 1 + # steps left + for k in range(step_mult): + i = i - 1 + j = j + idx.append(indices[i, j]) + + # step down + for k in range(step_mult): + i = i + j = j + 1 + idx.append(indices[i, j]) + + step_mult += 1 + if c < size//2: + # step right + for k in range(step_mult): + i = i + 1 + j = j + idx.append(indices[i, j]) + + # step up + for k in range(step_mult): + i = i + j = j - 1 + idx.append(indices[i, j]) + else: + # end reached + for k in range(step_mult-1): + i = i + 1 + idx.append(indices[i, j]) + + assert len(idx) == size*size + idx = torch.tensor(idx) + self.register_buffer('forward_shuffle_idx', idx) + self.register_buffer('backward_shuffle_idx', torch.argsort(idx)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +class SpiralIn(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + assert H == W + size = W + indices = np.arange(size*size).reshape(size,size) + + i0 = size//2 + j0 = size//2-1 + + i = i0 + j = j0 + + idx = [indices[i0, j0]] + step_mult = 0 + for c in range(1, size//2+1): + step_mult += 1 + # steps left + for k in range(step_mult): + i = i - 1 + j = j + idx.append(indices[i, j]) + + # step down + for k in range(step_mult): + i = i + j = j + 1 + idx.append(indices[i, j]) + + step_mult += 1 + if c < size//2: + # step right + for k in range(step_mult): + i = i + 1 + j = j + idx.append(indices[i, j]) + + # step up + for k in range(step_mult): + i = i + j = j - 1 + idx.append(indices[i, j]) + else: + # end reached + for k in range(step_mult-1): + i = i + 1 + idx.append(indices[i, j]) + + assert len(idx) == size*size + idx = idx[::-1] + idx = torch.tensor(idx) + self.register_buffer('forward_shuffle_idx', idx) + self.register_buffer('backward_shuffle_idx', torch.argsort(idx)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +class Random(nn.Module): + def __init__(self, H, W): + super().__init__() + indices = np.random.RandomState(1).permutation(H*W) + idx = torch.tensor(indices.ravel()) + self.register_buffer('forward_shuffle_idx', idx) + self.register_buffer('backward_shuffle_idx', torch.argsort(idx)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +class AlternateParsing(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + indices = np.arange(W*H).reshape(H,W) + for i in range(1, H, 2): + indices[i, :] = indices[i, ::-1] + idx = indices.flatten() + assert len(idx) == H*W + idx = torch.tensor(idx) + self.register_buffer('forward_shuffle_idx', idx) + self.register_buffer('backward_shuffle_idx', torch.argsort(idx)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +if __name__ == "__main__": + p0 = AlternateParsing(16, 16) + print(p0.forward_shuffle_idx) + print(p0.backward_shuffle_idx) + + x = torch.randint(0, 768, size=(11, 256)) + y = p0(x) + xre = p0(y, reverse=True) + assert torch.equal(x, xre) + + p1 = SpiralOut(2, 2) + print(p1.forward_shuffle_idx) + print(p1.backward_shuffle_idx) diff --git a/src/taming-transformers/taming/modules/util.py b/src/taming-transformers/taming/modules/util.py new file mode 100644 index 0000000000000000000000000000000000000000..9ee16385d8b1342a2d60a5f1aa5cadcfbe934bd8 --- /dev/null +++ b/src/taming-transformers/taming/modules/util.py @@ -0,0 +1,130 @@ +import torch +import torch.nn as nn + + +def count_params(model): + total_params = sum(p.numel() for p in model.parameters()) + return total_params + + +class ActNorm(nn.Module): + def __init__(self, num_features, logdet=False, affine=True, + allow_reverse_init=False): + assert affine + super().__init__() + self.logdet = logdet + self.loc = nn.Parameter(torch.zeros(1, num_features, 1, 1)) + self.scale = nn.Parameter(torch.ones(1, num_features, 1, 1)) + self.allow_reverse_init = allow_reverse_init + + self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8)) + + def initialize(self, input): + with torch.no_grad(): + flatten = input.permute(1, 0, 2, 3).contiguous().view(input.shape[1], -1) + mean = ( + flatten.mean(1) + .unsqueeze(1) + .unsqueeze(2) + .unsqueeze(3) + .permute(1, 0, 2, 3) + ) + std = ( + flatten.std(1) + .unsqueeze(1) + .unsqueeze(2) + .unsqueeze(3) + .permute(1, 0, 2, 3) + ) + + self.loc.data.copy_(-mean) + self.scale.data.copy_(1 / (std + 1e-6)) + + def forward(self, input, reverse=False): + if reverse: + return self.reverse(input) + if len(input.shape) == 2: + input = input[:,:,None,None] + squeeze = True + else: + squeeze = False + + _, _, height, width = input.shape + + if self.training and self.initialized.item() == 0: + self.initialize(input) + self.initialized.fill_(1) + + h = self.scale * (input + self.loc) + + if squeeze: + h = h.squeeze(-1).squeeze(-1) + + if self.logdet: + log_abs = torch.log(torch.abs(self.scale)) + logdet = height*width*torch.sum(log_abs) + logdet = logdet * torch.ones(input.shape[0]).to(input) + return h, logdet + + return h + + def reverse(self, output): + if self.training and self.initialized.item() == 0: + if not self.allow_reverse_init: + raise RuntimeError( + "Initializing ActNorm in reverse direction is " + "disabled by default. Use allow_reverse_init=True to enable." + ) + else: + self.initialize(output) + self.initialized.fill_(1) + + if len(output.shape) == 2: + output = output[:,:,None,None] + squeeze = True + else: + squeeze = False + + h = output / self.scale - self.loc + + if squeeze: + h = h.squeeze(-1).squeeze(-1) + return h + + +class AbstractEncoder(nn.Module): + def __init__(self): + super().__init__() + + def encode(self, *args, **kwargs): + raise NotImplementedError + + +class Labelator(AbstractEncoder): + """Net2Net Interface for Class-Conditional Model""" + def __init__(self, n_classes, quantize_interface=True): + super().__init__() + self.n_classes = n_classes + self.quantize_interface = quantize_interface + + def encode(self, c): + c = c[:,None] + if self.quantize_interface: + return c, None, [None, None, c.long()] + return c + + +class SOSProvider(AbstractEncoder): + # for unconditional training + def __init__(self, sos_token, quantize_interface=True): + super().__init__() + self.sos_token = sos_token + self.quantize_interface = quantize_interface + + def encode(self, x): + # get batch size from data and replicate sos_token + c = torch.ones(x.shape[0], 1)*self.sos_token + c = c.long().to(x.device) + if self.quantize_interface: + return c, None, [None, None, c] + return c diff --git a/src/taming-transformers/taming/modules/vqvae/quantize.py b/src/taming-transformers/taming/modules/vqvae/quantize.py new file mode 100644 index 0000000000000000000000000000000000000000..d75544e41fa01bce49dd822b1037963d62f79b51 --- /dev/null +++ b/src/taming-transformers/taming/modules/vqvae/quantize.py @@ -0,0 +1,445 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from torch import einsum +from einops import rearrange + + +class VectorQuantizer(nn.Module): + """ + see https://github.com/MishaLaskin/vqvae/blob/d761a999e2267766400dc646d82d3ac3657771d4/models/quantizer.py + ____________________________________________ + Discretization bottleneck part of the VQ-VAE. + Inputs: + - n_e : number of embeddings + - e_dim : dimension of embedding + - beta : commitment cost used in loss term, beta * ||z_e(x)-sg[e]||^2 + _____________________________________________ + """ + + # NOTE: this class contains a bug regarding beta; see VectorQuantizer2 for + # a fix and use legacy=False to apply that fix. VectorQuantizer2 can be + # used wherever VectorQuantizer has been used before and is additionally + # more efficient. + def __init__(self, n_e, e_dim, beta): + super(VectorQuantizer, self).__init__() + self.n_e = n_e + self.e_dim = e_dim + self.beta = beta + + self.embedding = nn.Embedding(self.n_e, self.e_dim) + self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e) + + def forward(self, z): + """ + Inputs the output of the encoder network z and maps it to a discrete + one-hot vector that is the index of the closest embedding vector e_j + z (continuous) -> z_q (discrete) + z.shape = (batch, channel, height, width) + quantization pipeline: + 1. get encoder input (B,C,H,W) + 2. flatten input to (B*H*W,C) + """ + # reshape z -> (batch, height, width, channel) and flatten + z = z.permute(0, 2, 3, 1).contiguous() + z_flattened = z.view(-1, self.e_dim) + # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z + + d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \ + torch.sum(self.embedding.weight**2, dim=1) - 2 * \ + torch.matmul(z_flattened, self.embedding.weight.t()) + + ## could possible replace this here + # #\start... + # find closest encodings + min_encoding_indices = torch.argmin(d, dim=1).unsqueeze(1) + + min_encodings = torch.zeros( + min_encoding_indices.shape[0], self.n_e).to(z) + min_encodings.scatter_(1, min_encoding_indices, 1) + + # dtype min encodings: torch.float32 + # min_encodings shape: torch.Size([2048, 512]) + # min_encoding_indices.shape: torch.Size([2048, 1]) + + # get quantized latent vectors + z_q = torch.matmul(min_encodings, self.embedding.weight).view(z.shape) + #.........\end + + # with: + # .........\start + #min_encoding_indices = torch.argmin(d, dim=1) + #z_q = self.embedding(min_encoding_indices) + # ......\end......... (TODO) + + # compute loss for embedding + loss = torch.mean((z_q.detach()-z)**2) + self.beta * \ + torch.mean((z_q - z.detach()) ** 2) + + # preserve gradients + z_q = z + (z_q - z).detach() + + # perplexity + e_mean = torch.mean(min_encodings, dim=0) + perplexity = torch.exp(-torch.sum(e_mean * torch.log(e_mean + 1e-10))) + + # reshape back to match original input shape + z_q = z_q.permute(0, 3, 1, 2).contiguous() + + return z_q, loss, (perplexity, min_encodings, min_encoding_indices) + + def get_codebook_entry(self, indices, shape): + # shape specifying (batch, height, width, channel) + # TODO: check for more easy handling with nn.Embedding + min_encodings = torch.zeros(indices.shape[0], self.n_e).to(indices) + min_encodings.scatter_(1, indices[:,None], 1) + + # get quantized latent vectors + z_q = torch.matmul(min_encodings.float(), self.embedding.weight) + + if shape is not None: + z_q = z_q.view(shape) + + # reshape back to match original input shape + z_q = z_q.permute(0, 3, 1, 2).contiguous() + + return z_q + + +class GumbelQuantize(nn.Module): + """ + credit to @karpathy: https://github.com/karpathy/deep-vector-quantization/blob/main/model.py (thanks!) + Gumbel Softmax trick quantizer + Categorical Reparameterization with Gumbel-Softmax, Jang et al. 2016 + https://arxiv.org/abs/1611.01144 + """ + def __init__(self, num_hiddens, embedding_dim, n_embed, straight_through=True, + kl_weight=5e-4, temp_init=1.0, use_vqinterface=True, + remap=None, unknown_index="random"): + super().__init__() + + self.embedding_dim = embedding_dim + self.n_embed = n_embed + + self.straight_through = straight_through + self.temperature = temp_init + self.kl_weight = kl_weight + + self.proj = nn.Conv2d(num_hiddens, n_embed, 1) + self.embed = nn.Embedding(n_embed, embedding_dim) + + self.use_vqinterface = use_vqinterface + + self.remap = remap + if self.remap is not None: + self.register_buffer("used", torch.tensor(np.load(self.remap))) + self.re_embed = self.used.shape[0] + self.unknown_index = unknown_index # "random" or "extra" or integer + if self.unknown_index == "extra": + self.unknown_index = self.re_embed + self.re_embed = self.re_embed+1 + print(f"Remapping {self.n_embed} indices to {self.re_embed} indices. " + f"Using {self.unknown_index} for unknown indices.") + else: + self.re_embed = n_embed + + def remap_to_used(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + match = (inds[:,:,None]==used[None,None,...]).long() + new = match.argmax(-1) + unknown = match.sum(2)<1 + if self.unknown_index == "random": + new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device) + else: + new[unknown] = self.unknown_index + return new.reshape(ishape) + + def unmap_to_all(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + if self.re_embed > self.used.shape[0]: # extra token + inds[inds>=self.used.shape[0]] = 0 # simply set to zero + back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds) + return back.reshape(ishape) + + def forward(self, z, temp=None, return_logits=False): + # force hard = True when we are in eval mode, as we must quantize. actually, always true seems to work + hard = self.straight_through if self.training else True + temp = self.temperature if temp is None else temp + + logits = self.proj(z) + if self.remap is not None: + # continue only with used logits + full_zeros = torch.zeros_like(logits) + logits = logits[:,self.used,...] + + soft_one_hot = F.gumbel_softmax(logits, tau=temp, dim=1, hard=hard) + if self.remap is not None: + # go back to all entries but unused set to zero + full_zeros[:,self.used,...] = soft_one_hot + soft_one_hot = full_zeros + z_q = einsum('b n h w, n d -> b d h w', soft_one_hot, self.embed.weight) + + # + kl divergence to the prior loss + qy = F.softmax(logits, dim=1) + diff = self.kl_weight * torch.sum(qy * torch.log(qy * self.n_embed + 1e-10), dim=1).mean() + + ind = soft_one_hot.argmax(dim=1) + if self.remap is not None: + ind = self.remap_to_used(ind) + if self.use_vqinterface: + if return_logits: + return z_q, diff, (None, None, ind), logits + return z_q, diff, (None, None, ind) + return z_q, diff, ind + + def get_codebook_entry(self, indices, shape): + b, h, w, c = shape + assert b*h*w == indices.shape[0] + indices = rearrange(indices, '(b h w) -> b h w', b=b, h=h, w=w) + if self.remap is not None: + indices = self.unmap_to_all(indices) + one_hot = F.one_hot(indices, num_classes=self.n_embed).permute(0, 3, 1, 2).float() + z_q = einsum('b n h w, n d -> b d h w', one_hot, self.embed.weight) + return z_q + + +class VectorQuantizer2(nn.Module): + """ + Improved version over VectorQuantizer, can be used as a drop-in replacement. Mostly + avoids costly matrix multiplications and allows for post-hoc remapping of indices. + """ + # NOTE: due to a bug the beta term was applied to the wrong term. for + # backwards compatibility we use the buggy version by default, but you can + # specify legacy=False to fix it. + def __init__(self, n_e, e_dim, beta, remap=None, unknown_index="random", + sane_index_shape=False, legacy=True): + super().__init__() + self.n_e = n_e + self.e_dim = e_dim + self.beta = beta + self.legacy = legacy + + self.embedding = nn.Embedding(self.n_e, self.e_dim) + self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e) + + self.remap = remap + if self.remap is not None: + self.register_buffer("used", torch.tensor(np.load(self.remap))) + self.re_embed = self.used.shape[0] + self.unknown_index = unknown_index # "random" or "extra" or integer + if self.unknown_index == "extra": + self.unknown_index = self.re_embed + self.re_embed = self.re_embed+1 + print(f"Remapping {self.n_e} indices to {self.re_embed} indices. " + f"Using {self.unknown_index} for unknown indices.") + else: + self.re_embed = n_e + + self.sane_index_shape = sane_index_shape + + def remap_to_used(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + match = (inds[:,:,None]==used[None,None,...]).long() + new = match.argmax(-1) + unknown = match.sum(2)<1 + if self.unknown_index == "random": + new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device) + else: + new[unknown] = self.unknown_index + return new.reshape(ishape) + + def unmap_to_all(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + if self.re_embed > self.used.shape[0]: # extra token + inds[inds>=self.used.shape[0]] = 0 # simply set to zero + back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds) + return back.reshape(ishape) + + def forward(self, z, temp=None, rescale_logits=False, return_logits=False): + assert temp is None or temp==1.0, "Only for interface compatible with Gumbel" + assert rescale_logits==False, "Only for interface compatible with Gumbel" + assert return_logits==False, "Only for interface compatible with Gumbel" + # reshape z -> (batch, height, width, channel) and flatten + z = rearrange(z, 'b c h w -> b h w c').contiguous() + z_flattened = z.view(-1, self.e_dim) + # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z + + d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \ + torch.sum(self.embedding.weight**2, dim=1) - 2 * \ + torch.einsum('bd,dn->bn', z_flattened, rearrange(self.embedding.weight, 'n d -> d n')) + + min_encoding_indices = torch.argmin(d, dim=1) + z_q = self.embedding(min_encoding_indices).view(z.shape) + perplexity = None + min_encodings = None + + # compute loss for embedding + if not self.legacy: + loss = self.beta * torch.mean((z_q.detach()-z)**2) + \ + torch.mean((z_q - z.detach()) ** 2) + else: + loss = torch.mean((z_q.detach()-z)**2) + self.beta * \ + torch.mean((z_q - z.detach()) ** 2) + + # preserve gradients + z_q = z + (z_q - z).detach() + + # reshape back to match original input shape + z_q = rearrange(z_q, 'b h w c -> b c h w').contiguous() + + if self.remap is not None: + min_encoding_indices = min_encoding_indices.reshape(z.shape[0],-1) # add batch axis + min_encoding_indices = self.remap_to_used(min_encoding_indices) + min_encoding_indices = min_encoding_indices.reshape(-1,1) # flatten + + if self.sane_index_shape: + min_encoding_indices = min_encoding_indices.reshape( + z_q.shape[0], z_q.shape[2], z_q.shape[3]) + + return z_q, loss, (perplexity, min_encodings, min_encoding_indices) + + def get_codebook_entry(self, indices, shape): + # shape specifying (batch, height, width, channel) + if self.remap is not None: + indices = indices.reshape(shape[0],-1) # add batch axis + indices = self.unmap_to_all(indices) + indices = indices.reshape(-1) # flatten again + + # get quantized latent vectors + z_q = self.embedding(indices) + + if shape is not None: + z_q = z_q.view(shape) + # reshape back to match original input shape + z_q = z_q.permute(0, 3, 1, 2).contiguous() + + return z_q + +class EmbeddingEMA(nn.Module): + def __init__(self, num_tokens, codebook_dim, decay=0.99, eps=1e-5): + super().__init__() + self.decay = decay + self.eps = eps + weight = torch.randn(num_tokens, codebook_dim) + self.weight = nn.Parameter(weight, requires_grad = False) + self.cluster_size = nn.Parameter(torch.zeros(num_tokens), requires_grad = False) + self.embed_avg = nn.Parameter(weight.clone(), requires_grad = False) + self.update = True + + def forward(self, embed_id): + return F.embedding(embed_id, self.weight) + + def cluster_size_ema_update(self, new_cluster_size): + self.cluster_size.data.mul_(self.decay).add_(new_cluster_size, alpha=1 - self.decay) + + def embed_avg_ema_update(self, new_embed_avg): + self.embed_avg.data.mul_(self.decay).add_(new_embed_avg, alpha=1 - self.decay) + + def weight_update(self, num_tokens): + n = self.cluster_size.sum() + smoothed_cluster_size = ( + (self.cluster_size + self.eps) / (n + num_tokens * self.eps) * n + ) + #normalize embedding average with smoothed cluster size + embed_normalized = self.embed_avg / smoothed_cluster_size.unsqueeze(1) + self.weight.data.copy_(embed_normalized) + + +class EMAVectorQuantizer(nn.Module): + def __init__(self, n_embed, embedding_dim, beta, decay=0.99, eps=1e-5, + remap=None, unknown_index="random"): + super().__init__() + self.codebook_dim = codebook_dim + self.num_tokens = num_tokens + self.beta = beta + self.embedding = EmbeddingEMA(self.num_tokens, self.codebook_dim, decay, eps) + + self.remap = remap + if self.remap is not None: + self.register_buffer("used", torch.tensor(np.load(self.remap))) + self.re_embed = self.used.shape[0] + self.unknown_index = unknown_index # "random" or "extra" or integer + if self.unknown_index == "extra": + self.unknown_index = self.re_embed + self.re_embed = self.re_embed+1 + print(f"Remapping {self.n_embed} indices to {self.re_embed} indices. " + f"Using {self.unknown_index} for unknown indices.") + else: + self.re_embed = n_embed + + def remap_to_used(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + match = (inds[:,:,None]==used[None,None,...]).long() + new = match.argmax(-1) + unknown = match.sum(2)<1 + if self.unknown_index == "random": + new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device) + else: + new[unknown] = self.unknown_index + return new.reshape(ishape) + + def unmap_to_all(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + if self.re_embed > self.used.shape[0]: # extra token + inds[inds>=self.used.shape[0]] = 0 # simply set to zero + back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds) + return back.reshape(ishape) + + def forward(self, z): + # reshape z -> (batch, height, width, channel) and flatten + #z, 'b c h w -> b h w c' + z = rearrange(z, 'b c h w -> b h w c') + z_flattened = z.reshape(-1, self.codebook_dim) + + # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z + d = z_flattened.pow(2).sum(dim=1, keepdim=True) + \ + self.embedding.weight.pow(2).sum(dim=1) - 2 * \ + torch.einsum('bd,nd->bn', z_flattened, self.embedding.weight) # 'n d -> d n' + + + encoding_indices = torch.argmin(d, dim=1) + + z_q = self.embedding(encoding_indices).view(z.shape) + encodings = F.one_hot(encoding_indices, self.num_tokens).type(z.dtype) + avg_probs = torch.mean(encodings, dim=0) + perplexity = torch.exp(-torch.sum(avg_probs * torch.log(avg_probs + 1e-10))) + + if self.training and self.embedding.update: + #EMA cluster size + encodings_sum = encodings.sum(0) + self.embedding.cluster_size_ema_update(encodings_sum) + #EMA embedding average + embed_sum = encodings.transpose(0,1) @ z_flattened + self.embedding.embed_avg_ema_update(embed_sum) + #normalize embed_avg and update weight + self.embedding.weight_update(self.num_tokens) + + # compute loss for embedding + loss = self.beta * F.mse_loss(z_q.detach(), z) + + # preserve gradients + z_q = z + (z_q - z).detach() + + # reshape back to match original input shape + #z_q, 'b h w c -> b c h w' + z_q = rearrange(z_q, 'b h w c -> b c h w') + return z_q, loss, (perplexity, encodings, encoding_indices) diff --git a/src/taming-transformers/taming/util.py b/src/taming-transformers/taming/util.py new file mode 100644 index 0000000000000000000000000000000000000000..06053e5defb87977f9ab07e69bf4da12201de9b7 --- /dev/null +++ b/src/taming-transformers/taming/util.py @@ -0,0 +1,157 @@ +import os, hashlib +import requests +from tqdm import tqdm + +URL_MAP = { + "vgg_lpips": "https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1" +} + +CKPT_MAP = { + "vgg_lpips": "vgg.pth" +} + +MD5_MAP = { + "vgg_lpips": "d507d7349b931f0638a25a48a722f98a" +} + + +def download(url, local_path, chunk_size=1024): + os.makedirs(os.path.split(local_path)[0], exist_ok=True) + with requests.get(url, stream=True) as r: + total_size = int(r.headers.get("content-length", 0)) + with tqdm(total=total_size, unit="B", unit_scale=True) as pbar: + with open(local_path, "wb") as f: + for data in r.iter_content(chunk_size=chunk_size): + if data: + f.write(data) + pbar.update(chunk_size) + + +def md5_hash(path): + with open(path, "rb") as f: + content = f.read() + return hashlib.md5(content).hexdigest() + + +def get_ckpt_path(name, root, check=False): + assert name in URL_MAP + path = os.path.join(root, CKPT_MAP[name]) + if not os.path.exists(path) or (check and not md5_hash(path) == MD5_MAP[name]): + print("Downloading {} model from {} to {}".format(name, URL_MAP[name], path)) + download(URL_MAP[name], path) + md5 = md5_hash(path) + assert md5 == MD5_MAP[name], md5 + return path + + +class KeyNotFoundError(Exception): + def __init__(self, cause, keys=None, visited=None): + self.cause = cause + self.keys = keys + self.visited = visited + messages = list() + if keys is not None: + messages.append("Key not found: {}".format(keys)) + if visited is not None: + messages.append("Visited: {}".format(visited)) + messages.append("Cause:\n{}".format(cause)) + message = "\n".join(messages) + super().__init__(message) + + +def retrieve( + list_or_dict, key, splitval="/", default=None, expand=True, pass_success=False +): + """Given a nested list or dict return the desired value at key expanding + callable nodes if necessary and :attr:`expand` is ``True``. The expansion + is done in-place. + + Parameters + ---------- + list_or_dict : list or dict + Possibly nested list or dictionary. + key : str + key/to/value, path like string describing all keys necessary to + consider to get to the desired value. List indices can also be + passed here. + splitval : str + String that defines the delimiter between keys of the + different depth levels in `key`. + default : obj + Value returned if :attr:`key` is not found. + expand : bool + Whether to expand callable nodes on the path or not. + + Returns + ------- + The desired value or if :attr:`default` is not ``None`` and the + :attr:`key` is not found returns ``default``. + + Raises + ------ + Exception if ``key`` not in ``list_or_dict`` and :attr:`default` is + ``None``. + """ + + keys = key.split(splitval) + + success = True + try: + visited = [] + parent = None + last_key = None + for key in keys: + if callable(list_or_dict): + if not expand: + raise KeyNotFoundError( + ValueError( + "Trying to get past callable node with expand=False." + ), + keys=keys, + visited=visited, + ) + list_or_dict = list_or_dict() + parent[last_key] = list_or_dict + + last_key = key + parent = list_or_dict + + try: + if isinstance(list_or_dict, dict): + list_or_dict = list_or_dict[key] + else: + list_or_dict = list_or_dict[int(key)] + except (KeyError, IndexError, ValueError) as e: + raise KeyNotFoundError(e, keys=keys, visited=visited) + + visited += [key] + # final expansion of retrieved value + if expand and callable(list_or_dict): + list_or_dict = list_or_dict() + parent[last_key] = list_or_dict + except KeyNotFoundError as e: + if default is None: + raise e + else: + list_or_dict = default + success = False + + if not pass_success: + return list_or_dict + else: + return list_or_dict, success + + +if __name__ == "__main__": + config = {"keya": "a", + "keyb": "b", + "keyc": + {"cc1": 1, + "cc2": 2, + } + } + from omegaconf import OmegaConf + config = OmegaConf.create(config) + print(config) + retrieve(config, "keya") + diff --git a/src/taming-transformers/taming_transformers.egg-info/PKG-INFO b/src/taming-transformers/taming_transformers.egg-info/PKG-INFO new file mode 100644 index 0000000000000000000000000000000000000000..a9f90162ef22c6128a5a09bb05241a588626e554 --- /dev/null +++ b/src/taming-transformers/taming_transformers.egg-info/PKG-INFO @@ -0,0 +1,4 @@ +Metadata-Version: 2.1 +Name: taming-transformers +Version: 0.0.1 +Summary: Taming Transformers for High-Resolution Image Synthesis diff --git a/src/taming-transformers/taming_transformers.egg-info/SOURCES.txt b/src/taming-transformers/taming_transformers.egg-info/SOURCES.txt new file mode 100644 index 0000000000000000000000000000000000000000..30a640334f1a156d739794180a154e5b5ce6406d --- /dev/null +++ b/src/taming-transformers/taming_transformers.egg-info/SOURCES.txt @@ -0,0 +1,7 @@ +README.md +setup.py +taming_transformers.egg-info/PKG-INFO +taming_transformers.egg-info/SOURCES.txt +taming_transformers.egg-info/dependency_links.txt +taming_transformers.egg-info/requires.txt +taming_transformers.egg-info/top_level.txt \ No newline at end of file diff --git a/src/taming-transformers/taming_transformers.egg-info/dependency_links.txt b/src/taming-transformers/taming_transformers.egg-info/dependency_links.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/src/taming-transformers/taming_transformers.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/src/taming-transformers/taming_transformers.egg-info/requires.txt b/src/taming-transformers/taming_transformers.egg-info/requires.txt new file mode 100644 index 0000000000000000000000000000000000000000..8cb0fc949dc18643ff84a6b0d62232e4fb1ebc65 --- /dev/null +++ b/src/taming-transformers/taming_transformers.egg-info/requires.txt @@ -0,0 +1,3 @@ +torch +numpy +tqdm diff --git a/src/taming-transformers/taming_transformers.egg-info/top_level.txt b/src/taming-transformers/taming_transformers.egg-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/src/taming-transformers/taming_transformers.egg-info/top_level.txt @@ -0,0 +1 @@ +