{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ff5e92e4",
   "metadata": {
    "id": "9-a3wNZ9mxWT"
   },
   "source": [
    "# Multivariate Probabilistic Time Series Forecasting with Informer\n",
    "\n",
    "## Introduction\n",
    "\n",
    "A few months ago we introduced the [Time Series Transformer](https://huggingface.co/blog/time-series-transformers), which is the vanilla Transformer ([Vaswani et al., 2017](https://arxiv.org/abs/1706.03762)) applied to forecasting, and showed an example for the **univariate** probabilistic forecasting task (i.e. predicting each time series' 1-d distribution individually). In this post we introduce the _Informer_ model ([Zhou, Haoyi, et al., 2021](https://arxiv.org/abs/2012.07436)), AAAI21 best paper which is [now available](https://huggingface.co/docs/transformers/main/en/model_doc/informer) in 🤗 Transformers. We will show how to use the Informer model for the **multivariate** probabilistic forecasting task, i.e., predicting the distribution of a future **vector** of time-series target values. Note that this will also work for the vanilla Time Series Transformer model.\n",
    "\n",
    "##  Multivariate Probabilistic Time Series Forecasting\n",
    "\n",
    "As far as the modeling aspect of probabilistic forecasting is concerned, the Transformer/Informer will require no change when dealing with multivariate time series. In both the univariate and multivariate setting, the model will receive a sequence of vectors and thus the only change is on the output or emission side.\n",
    "\n",
    "Modeling the full joint conditional distribution of high dimensional data can get computationally expensive and thus methods resort to some approximation of the distribution, the easiest being to model the data as an independent distribution from the same family, or some low-rank approximation to the full covariance, etc. Here we will just resort to the independent (or diagonal) emissions which are supported for the families of distributions we have implemented [here](https://huggingface.co/docs/transformers/main/en/internal/time_series_utils).\n",
    "\n",
    "## Informer - Under The Hood\n",
    "\n",
    "Based on the vanilla Transformer ([Vaswani et al., 2017](https://arxiv.org/abs/1706.03762)), Informer employs two major improvements. To understand these improvements, let's recall the drawbacks of the vanilla Transformer:\n",
    "\n",
    "1. **Quadratic computation of canonical self-attention:** The vanilla Transformer has a computational complexity of $O(T^2 D)$ where $T$ is the time series length and $D$ is the dimension of the hidden states. For long sequence time-series forecasting (also known as the _LSTF problem_), this might be really computationally expensive. To solve this problem, Informer employs a new self-attention mechanism called _ProbSparse_ attention, which has $O(T \\log T)$ time and space complexity.\n",
    "1. **Memory bottleneck when stacking layers:** When stacking $N$ encoder/decoder layers, the vanilla Transformer has a memory usage of $O(N T^2)$, which limits the model's capacity for long sequences. Informer uses a _Distilling_ operation, for reducing the input size between layers into its half slice. By doing so, it reduces the whole memory usage to be $O(N\\cdot T \\log T)$.\n",
    "\n",
    "As you can see, the motivation for the Informer model is similar to Longformer ([Beltagy et el., 2020](https://arxiv.org/abs/2004.05150)), Sparse Transformer ([Child et al., 2019](https://arxiv.org/abs/1904.10509)) and other NLP papers for reducing the quadratic complexity of the self-attention mechanism **when the input sequence is long**. Now, let's dive into _ProbSparse_ attention and the _Distilling_ operation with code examples. \n",
    "\n",
    "### ProbSparse Attention\n",
    "\n",
    "The main idea of ProbSparse is that the canonical self-attention scores form a long-tail distribution, where the \"active\" queries lie in the \"head\" scores and \"lazy\" queries lie in the \"tail\" area. By \"active\" query we mean a query $q_i$ such that the dot-product $\\langle q_i,k_i \\rangle$ **contributes** to the major attention, whereas a \"lazy\" query forms a dot-product which generates  **trivial** attention. Here, $q_i$ and $k_i$ are the $i$-th rows in $Q$ and $K$ attention matrices respectively. \n",
    "\n",
    "| ![informer_full_vs_sparse_attention](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/informer/informer_full_vs_sparse_attention.png) |\n",
    "|:--:|\n",
    "|  Vanilla self attention vs ProbSparse attention from [Autoformer (Wu, Haixu, et al., 2021)](https://wuhaixu2016.github.io/pdf/NeurIPS2021_Autoformer.pdf) |\n",
    "\n",
    "Given the idea of \"active\" and \"lazy\" queries, the ProbSparse attention selects the \"active\" queries, and creates a reduced query matrix $Q_{reduced}$ which is used to calculate the attention weights in $O(T \\log T)$. Let's see this more in detail with a code example. \n",
    "    \n",
    "Recall the canonical self-attention formula:\n",
    "\n",
    "$$\n",
    "\\textrm{Attention}(Q, K, V) = \\textrm{softmax}(\\frac{QK^T}{\\sqrt{d_k}} )V\n",
    "$$\n",
    "\n",
    "Where $Q\\in \\mathbb{R}^{L_Q \\times d}, K\\in \\mathbb{R}^{L_K \\times d}, V\\in \\mathbb{R}^{L_V \\times d}$. Note that in practice, the input length of queries and keys are typically equivalent in the self-attention computation, i.e. $L_Q = L_K = T$ where $T$ is the time series length. Therefore, the $QK^T$ multiplication takes $O(T^2 \\cdot d)$ computational complexity. In ProbSparse attention, our goal is to create a new $Q_{reduce}$ matrix and define:\n",
    "\n",
    "$$\n",
    "\\textrm{ProbSparseAttention}(Q, K, V) = \\textrm{softmax}(\\frac{Q_{reduce}K^T}{\\sqrt{d_k}} )V\n",
    "$$\n",
    "\n",
    "where the $Q_{reduce}$ matrix only selects the Top $u$ \"active\" queries. Here, $u = c \\cdot \\log L_Q$ and $c$ called the _sampling factor_ hyperparameter for the ProbSparse attention. Since $Q_{reduce}$ selects only the Top $u$ queries, its size is $c\\cdot \\log L_Q \\times d$, so the multiplication $Q_{reduce}K^T$ takes only $O(L_K \\log L_Q) = O(T \\log T)$.\n",
    "\n",
    "This is good! But how can we select the $u$ \"active\" queries to create $Q_{reduce}$? Let's define the _Query Sparsity Measurement_.\n",
    "\n",
    "#### Query Sparsity Measurement\n",
    "Query Sparsity Measurement $M(q_i, K)$ is used for selecting the $u$ \"active\" queries $q_i$ in $Q$ to create $Q_{reduce}$. In theory, the dominant $\\langle q_i,k_i \\rangle$ pairs encourage the \"active\" $q_i$'s probability distribution **away** from the uniform distribution as can be seen in the figure below. Hence, the [KL divergence](https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence) between the actual queries distribution and the uniform distribution is used to define the sparsity measurement. \n",
    "\n",
    "| ![informer_probsparse](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/informer/informer_probsparse.png) | \n",
    "|:--:|\n",
    "| The illustration of ProbSparse Attention from official [repository](https://github.com/zhouhaoyi/Informer2020)|\n",
    "\n",
    "\n",
    "In practice, the measurement is defined as:\n",
    "\n",
    "$$\n",
    "M(q_i, K) = \\max_j \\frac{q_ik_j^T}{\\sqrt{d}}-\\frac{1}{L_k} \\sum_{j=1}^{L_k}\\frac{q_ik_j^T}{\\sqrt{d}}\n",
    "$$\n",
    "\n",
    "\n",
    "The important thing to understand here is when $M(q_i, K)$ is larger, the query $q_i$ should be in $Q_{reduce}$ and vice versa.\n",
    "\n",
    "But how can we calculate the term $q_ik_j^T$ in non-quadratic time? Recall that most of the dot-product $\\langle q_i,k_i \\rangle$ generate either way the trivial attention (i.e. long-tail distribution property), so it is enough to randomly sample a subset of keys from $K$, which will be called `K_sample` in the code.\n",
    "\n",
    "Now, we are ready to see the code of `probsparse_attention`:\n",
    "    \n",
    "```python\n",
    "from torch import nn\n",
    "import math\n",
    "\n",
    "\n",
    "def probsparse_attention(query_states, key_states, value_states, sampling_factor=5):\n",
    "    \"\"\"\n",
    "    Compute the probsparse self-attention.\n",
    "    Input shape: Batch x Time x Channel\n",
    "\n",
    "    Note the additional `sampling_factor` input.\n",
    "    \"\"\"\n",
    "    # get input sizes with logs\n",
    "    L_K = key_states.size(1)\n",
    "    L_Q = query_states.size(1)\n",
    "    log_L_K = np.ceil(np.log1p(L_K)).astype(\"int\").item()\n",
    "    log_L_Q = np.ceil(np.log1p(L_Q)).astype(\"int\").item()\n",
    "\n",
    "    # calculate a subset of samples to slice from K and create Q_K_sample\n",
    "    U_part = min(sampling_factor * L_Q * log_L_K, L_K)\n",
    "\n",
    "    # create Q_K_sample (the q_i * k_j^T term in the sparsity measurement)\n",
    "    index_sample = torch.randint(0, L_K, (U_part,))\n",
    "    K_sample = key_states[:, index_sample, :]\n",
    "    Q_K_sample = torch.bmm(query_states, K_sample.transpose(1, 2))\n",
    "\n",
    "    # calculate the query sparsity measurement with Q_K_sample\n",
    "    M = Q_K_sample.max(dim=-1)[0] - torch.div(Q_K_sample.sum(dim=-1), L_K)\n",
    "\n",
    "    # calculate u to find the Top-u queries under the sparsity measurement\n",
    "    u = min(sampling_factor * log_L_Q, L_Q)\n",
    "    M_top = M.topk(u, sorted=False)[1]\n",
    "\n",
    "    # calculate Q_reduce as query_states[:, M_top]\n",
    "    dim_for_slice = torch.arange(query_states.size(0)).unsqueeze(-1)\n",
    "    Q_reduce = query_states[dim_for_slice, M_top]  # size: c*log_L_Q x channel\n",
    "\n",
    "    # and now, same as the canonical\n",
    "    d_k = query_states.size(-1)\n",
    "    attn_scores = torch.bmm(Q_reduce, key_states.transpose(-2, -1))  # Q_reduce x K^T\n",
    "    attn_scores = attn_scores / math.sqrt(d_k)\n",
    "    attn_probs = nn.functional.softmax(attn_scores, dim=-1)\n",
    "    attn_output = torch.bmm(attn_probs, value_states)\n",
    "\n",
    "    return attn_output, attn_scores\n",
    "```\n",
    "Note that in the implementation, $U_{part}$ contain $L_Q$ in the calculation for stability issues (see [this disccusion](https://discuss.huggingface.co/t/probsparse-attention-in-informer/34428) for more information).\n",
    "\n",
    "We did it! Please be aware that this is only a partial implementation of the `probsparse_attention`, and the full implementation can be found in 🤗 Transformers.\n",
    "\n",
    "### Distilling\n",
    "\n",
    "Because of the ProbSparse self-attention, the encoder’s feature map has some redundancy that can be removed. Therefore,\n",
    "the distilling operation is used to reduce the input size between encoder layers into its half slice, thus in theory removing this redundancy. In practice, Informer's \"distilling\" operation just adds 1D convolution layers with max pooling between each of the encoder layers. Let $X_n$ be the output of the $n$-th encoder layer, the distilling operation is then defined as:\n",
    "\n",
    "\n",
    "$$\n",
    "X_{n+1} = \\textrm{MaxPool} ( \\textrm{ELU}(\\textrm{Conv1d}(X_n))\n",
    "$$\n",
    "\n",
    "\n",
    "Let's see this in code:\n",
    "    \n",
    "```python\n",
    "from torch import nn\n",
    "\n",
    "# ConvLayer is a class with forward pass applying ELU and MaxPool1d\n",
    "def informer_encoder_forward(x_input, num_encoder_layers=3, distil=True):\n",
    "    # Initialize the convolution layers\n",
    "    if distil:\n",
    "        conv_layers = nn.ModuleList([ConvLayer() for _ in range(num_encoder_layers - 1)])\n",
    "        conv_layers.append(None)\n",
    "    else:\n",
    "        conv_layers = [None] * num_encoder_layers\n",
    "    \n",
    "    # Apply conv_layer between each encoder_layer\n",
    "    for encoder_layer, conv_layer in zip(encoder_layers, conv_layers):\n",
    "        output = encoder_layer(x_input)\n",
    "        if conv_layer is not None:\n",
    "            output = conv_layer(loutput)\n",
    "    \n",
    "    return output\n",
    "```\n",
    "    \n",
    "By reducing the input of each layer by two, we get a memory usage of $O(N\\cdot T \\log T)$ instead of $O(N\\cdot T^2)$ where $N$ is the number of encoder/decoder layers. This is what we wanted!\n",
    "    \n",
    "The Informer model in [now available](https://huggingface.co/docs/transformers/main/en/model_doc/informer) in the 🤗 Transformers library, and simply called `InformerModel`. In the sections below, we will show how to train this model on a custom multivariate time-series dataset.\n",
    "\n",
    "\n",
    "## Set-up Environment\n",
    "\n",
    "First, let's install the necessary libraries: 🤗 Transformers, 🤗 Datasets, 🤗 Evaluate,  🤗 Accelerate and [GluonTS](https://github.com/awslabs/gluonts).\n",
    "\n",
    "As we will show, GluonTS will be used for transforming the data to create features as well as for creating appropriate training, validation and test batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7AkJMJAunLP9",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7AkJMJAunLP9",
    "outputId": "b57a63c6-d3da-4034-b081-e3f2da24a8f4"
   },
   "outputs": [],
   "source": [
    "%pip install -q transformers datasets evaluate accelerate gluonts ujson"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaebea67",
   "metadata": {
    "id": "eaebea67"
   },
   "source": [
    "We also quickly upload some telemetry - this tells us which examples and software versions are getting used so we know where to prioritize our maintenance efforts. We don't collect (or care about) any personally identifiable information, but if you'd prefer not to be counted, feel free to skip this step or delete this cell entirely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "98c2cf63",
   "metadata": {
    "id": "98c2cf63"
   },
   "outputs": [],
   "source": [
    "from transformers.utils import send_example_telemetry\n",
    "\n",
    "send_example_telemetry(\"multivariate_informer_notebook\", framework=\"pytorch\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4m_7_MKqmzfE",
   "metadata": {
    "id": "4m_7_MKqmzfE"
   },
   "source": [
    "## Load Dataset\n",
    "\n",
    "In this blog post, we'll use the `traffic_hourly` dataset, which is available on the [Hugging Face Hub](https://huggingface.co/datasets/monash_tsf). This dataset contains the San Francisco Traffic dataset used by [Lai et al. (2017)](https://arxiv.org/abs/1703.07015). It contains 862 hourly time series showing the road occupancy rates in the range $[0, 1]$ on the San Francisco Bay area freeways from 2015 to 2016.\n",
    "\n",
    "This dataset is part of the [Monash Time Series Forecasting](https://forecastingdata.org/) repository, a collection of time series datasets from a number of domains. It can be viewed as the [GLUE benchmark](https://gluebenchmark.com/) of time series forecasting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d93a3f41",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 264,
     "referenced_widgets": [
      "956dc45f3dde496d94f2d2520f62a241",
      "dc1ad0316a634e0e81eecdd09d271136",
      "5c531b5b3ce4406abde898297f4bc80b",
      "8b30e8b778fb456bbf8af4d6931f415c",
      "d1f7dc29912b40e7ac4a9081a4068836",
      "f8af035c2033430ca41cb3c81719ddc8",
      "682be41e57c341189bdc3e7a6b7246d3",
      "b7e131bcb6454ccbb5de0813a734586a",
      "3e1c8ac5bfac429993d5404f7abf748d",
      "630d2a4aba53498b8e6f40d713fe50d1",
      "313d214425c541b6845f70638f8a5937",
      "2dc9cef88370404184dc1f629d062a04",
      "ed58c5b583f344cdbfea76562259190e",
      "c56009b340984f2296ad2959e8d72f25",
      "b2eeaecdd52343a4977954915f38bc9b",
      "c55cb9a98afe49d59838a3e2d88cd774",
      "672ee2ad96ac42fa90645a4049c7dd16",
      "96acfb4ec404421b8523e39b6a4bc41a",
      "c6fa8ced2f844e28a6e5cf4b31e362b1",
      "b65097925371428eb2b58eec672f9b81",
      "726309e90e0247628487e1f4816e6fd9",
      "e791aeda253f40d3bf28da3aaf0ec3f3",
      "87d63881c376462b88a7703f62495a83",
      "af5add21a56b4ef4945a90fed06d7c89",
      "c0822d9ca57b4b23ba552b93f139d96e",
      "2ec6b12a621f4ce681554397392bdda8",
      "8de92b21ea1b4dfc966d653e0ca7043b",
      "bcaa24789c664ed181eb3af6c93a618e",
      "e4015a34ae9744ceaa57d8b50a024d9a",
      "23207dda3c7c45ef942fb26b6d3e8f4a",
      "0a4bcc907dbc48f3af39fac4c0652bd4",
      "6a39d27a5d5e484385f3d8163665641f",
      "649640a4dacf4edab3aba273d7e09bbf",
      "0d037e1f14794a0fb68ab472b42ee60a",
      "eaa70494878f4eba927868ecbbd034b4",
      "b9f43527572c41849f66e100e4d2df83",
      "f0019a4884124eebb44571ca0a7b262e",
      "a79295d7dc77434282636a0ef665a70b",
      "b0b4e07185574c5eba5144a28c611971",
      "01a6160718434f7bb73bb4a094ee8b0f",
      "a70e5dadc1d547cc90da492ef9b72172",
      "3ff0a924499f414ca7fd03a902b51102",
      "0452728577c4433d9d15eca97045d1f4",
      "53938941490b4afea31c63aad4bdce0a",
      "1076c8e3f8e1413fad4aa5cb16c71c31",
      "dbb568c5b348421a9e2f9f4e07cd5f01",
      "966ca413bd824a77b50a20784e8bd1b4",
      "e81a3f25949247eeb696ccd3b0df3da0",
      "228e4cf452a04b1f8f324be138857c30",
      "addaf03f64e9421ab8debbba4f096d7e",
      "94aa0a38801e4fa0b79150fbd7bcc6cc",
      "044030ba2c5948d2ac6545aea773ef4a",
      "a54e00389ce148829b4db5b7439ae879",
      "435416a295674774a15aa700ff7ce007",
      "d7be4847987e4d6996c56eb42feb78b9",
      "43daab71788e4a5c80687a9e73bf3b67",
      "67f8fc82c7044090a0408294bc1c2d15",
      "7cd0096ebb94429dab18e3226fc4cdbf",
      "0bf375322d12400ab773e85c08cd3e62",
      "e3641728ace74d8ab4742007d1725ee8",
      "3c850c33752443afa6658a1cb997549e",
      "3366b16d73d949508f24d647558db059",
      "741afc0fb9a7469cac4a1d6b0dc130d8",
      "df02d3127e634862b1029787be8908b8",
      "22c8c8ecb39c491798602abe0144eba1",
      "36a6c51643ba4375b314e9395c0aea07",
      "83c39de970e84954b6fa043390b85d4c",
      "009a21c6a2dd4c5da79a7fb3eec8ff43",
      "9059a60d370c4825a0eb1b31c9f9cd0a",
      "028908857f134943af7b47a2503ce403",
      "445f2ef3f71a4573ae453144dd4c5e81",
      "a8b516bf196946a09a55732d937dfe2a",
      "53a3ad2f991648439e57362c4a7a5f60",
      "db1af11912fa4774b718242b8861a18c",
      "2e0511f2f1844758a6f6d10af7233a72",
      "50e91b016b0a4ce69325e8196a09dce6",
      "9c573dc9c14248deb512162af5f9b0fa",
      "ed32d5154c8e45ff91608c8dca664d8e",
      "d2e3caaeded749fc807de397f79e98e7",
      "f9d799cf26574229ad1d77373cb511c5",
      "17a314c74019462e9ba2e923b9235bed",
      "2435607c37f2439aa1f0d545009b375e",
      "09cc068788e64c1fbc1edd0992f43f42",
      "46e05d2996a84b5e8f456adbb6453350",
      "7cc6a3332eaf4e9bb012097ca03c6ef6",
      "7bb9e900006840a7a892a1a48d676560",
      "6b97acade12a49d683ec81855e1bf58a",
      "45b1dbee32a440328f91bf0c398d4a88",
      "048591e682544b57abbcba613c81f9b4",
      "d8a6361f19894be1b730137b0801e4e8",
      "2c375a08b1cb4f71a0a0a169c999aa94",
      "ea1af7f963e848d19ea363331027109b",
      "b68b7b7b072e457980e834113ff0a670",
      "764abccaae30410ba68405f44875c8d6",
      "89dd9177f7cd4edc87e43d5e23c5f587",
      "a3384254326f49eb907bfa6d2032b1a8",
      "68e542f3c052435f9254e135e5c481e8",
      "d0cecf202f814209abe965e2ec13c49e",
      "331752b5913245e380752532ab15f128"
     ]
    },
    "id": "d93a3f41",
    "outputId": "5708bef0-3c78-4f58-9a1f-7db01177cfe2"
   },
   "outputs": [],
   "source": [
    "from datasets import load_dataset\n",
    "\n",
    "dataset = load_dataset(\"monash_tsf\", \"traffic_hourly\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sG1ZNNzwpwmg",
   "metadata": {
    "id": "sG1ZNNzwpwmg"
   },
   "source": [
    "As can be seen, the dataset contains 3 splits: train, validation and test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d45ae147",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "d45ae147",
    "outputId": "c8b9ea06-c8ea-443c-8bf2-72acb311be39"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatasetDict({\n",
       "    train: Dataset({\n",
       "        features: ['start', 'target', 'feat_static_cat', 'feat_dynamic_real', 'item_id'],\n",
       "        num_rows: 862\n",
       "    })\n",
       "    test: Dataset({\n",
       "        features: ['start', 'target', 'feat_static_cat', 'feat_dynamic_real', 'item_id'],\n",
       "        num_rows: 862\n",
       "    })\n",
       "    validation: Dataset({\n",
       "        features: ['start', 'target', 'feat_static_cat', 'feat_dynamic_real', 'item_id'],\n",
       "        num_rows: 862\n",
       "    })\n",
       "})"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26KIJLY2qFXI",
   "metadata": {
    "id": "26KIJLY2qFXI"
   },
   "source": [
    "Each example contains a few keys, of which `start` and `target` are the most important ones. Let us have a look at the first time series in the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "oHlRCUPkoN1N",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oHlRCUPkoN1N",
    "outputId": "fe314df1-b6f8-45b9-b3a9-fe7caf44d30b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['start', 'target', 'feat_static_cat', 'feat_dynamic_real', 'item_id'])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_example = dataset[\"train\"][0]\n",
    "train_example.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "gbVF5vAcqzJG",
   "metadata": {
    "id": "gbVF5vAcqzJG"
   },
   "source": [
    "The `start` simply indicates the start of the time series (as a datetime), and the `target` contains the actual values of the time series.\n",
    "\n",
    "The `start` will be useful to add time related features to the time series values, as extra input to the model (such as \"month of year\"). Since we know the frequency of the data is `hourly`, we know for instance that the second value has the timestamp `2015-01-01 01:00:01`, `2015-01-01 02:00:01`, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1PDt8bvwoUbN",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1PDt8bvwoUbN",
    "outputId": "774b6c03-b1c9-4e7a-f3b8-a31a23abdb51"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2015-01-01 00:00:01\n",
      "17448\n"
     ]
    }
   ],
   "source": [
    "print(train_example[\"start\"])\n",
    "print(len(train_example[\"target\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "DfkPxhCkquKL",
   "metadata": {
    "id": "DfkPxhCkquKL"
   },
   "source": [
    "The validation set contains the same data as the training set, just for a `prediction_length` longer amount of time. This allows us to validate the model's predictions against the ground truth.\n",
    "\n",
    "The test set is again one `prediction_length` longer data compared to the validation set (or some multiple of  `prediction_length` longer data compared to the training set for testing on multiple rolling windows)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eRQhm4EGpa0y",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "eRQhm4EGpa0y",
    "outputId": "bb5e8298-cd62-4cd8-bb54-62377d8f8ca1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['start', 'target', 'feat_static_cat', 'feat_dynamic_real', 'item_id'])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "validation_example = dataset[\"validation\"][0]\n",
    "validation_example.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "x5PI_Jn7rDfj",
   "metadata": {
    "id": "x5PI_Jn7rDfj"
   },
   "source": [
    "The initial values are exactly the same as the corresponding training example. However, this example has `prediction_length=48` (48 hours, or 2 days) additional values compared to the training example. Let us verify it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "__j4Z5Ohp8gg",
   "metadata": {
    "id": "__j4Z5Ohp8gg"
   },
   "outputs": [],
   "source": [
    "freq = \"1H\"\n",
    "prediction_length = 48\n",
    "\n",
    "assert len(train_example[\"target\"]) + prediction_length == len(\n",
    "    dataset[\"validation\"][0][\"target\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "PGq2e9D-rhtg",
   "metadata": {
    "id": "PGq2e9D-rhtg"
   },
   "source": [
    "Let's visualize this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cYDyml0tsnlL",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "cYDyml0tsnlL",
    "outputId": "0942f1ea-b333-4af4-d0d2-8cd3034b104d"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "num_of_samples = 150\n",
    "\n",
    "figure, axes = plt.subplots()\n",
    "axes.plot(train_example[\"target\"][-num_of_samples:], color=\"blue\")\n",
    "axes.plot(\n",
    "    validation_example[\"target\"][-num_of_samples - prediction_length :],\n",
    "    color=\"red\",\n",
    "    alpha=0.5,\n",
    ")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4pGV6_ZduUaA",
   "metadata": {
    "id": "4pGV6_ZduUaA"
   },
   "source": [
    "Let's split up the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7eb15a6a",
   "metadata": {
    "id": "7eb15a6a"
   },
   "outputs": [],
   "source": [
    "train_dataset = dataset[\"train\"]\n",
    "test_dataset = dataset[\"test\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0125722c",
   "metadata": {
    "id": "0125722c"
   },
   "source": [
    "## Update `start` to `pd.Period`\n",
    "\n",
    "The first thing we'll do is convert the `start` feature of each time series to a pandas `Period` index using the data's `freq`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "249a9da4",
   "metadata": {
    "id": "249a9da4"
   },
   "outputs": [],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "@lru_cache(10_000)\n",
    "def convert_to_pandas_period(date, freq):\n",
    "    return pd.Period(date, freq)\n",
    "\n",
    "\n",
    "def transform_start_field(batch, freq):\n",
    "    batch[\"start\"] = [convert_to_pandas_period(date, freq) for date in batch[\"start\"]]\n",
    "    return batch"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "D7goNkUB1MPB",
   "metadata": {
    "id": "D7goNkUB1MPB"
   },
   "source": [
    "We now use `datasets`' [`set_transform`](https://huggingface.co/docs/datasets/v2.7.0/en/package_reference/main_classes#datasets.Dataset.set_transform) functionality to do this on-the-fly in place:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b43c7551",
   "metadata": {
    "id": "b43c7551"
   },
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "\n",
    "train_dataset.set_transform(partial(transform_start_field, freq=freq))\n",
    "test_dataset.set_transform(partial(transform_start_field, freq=freq))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "909db77b",
   "metadata": {},
   "source": [
    "Now, let's convert the dataset into a multivariate time series using the `MultivariateGrouper` from GluonTS. This grouper will convert the individual 1-dimensional time series into a single 2D matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0088e817",
   "metadata": {},
   "outputs": [],
   "source": [
    "from gluonts.dataset.multivariate_grouper import MultivariateGrouper\n",
    "\n",
    "num_of_variates = len(train_dataset)\n",
    "\n",
    "train_grouper = MultivariateGrouper(max_target_dim=num_of_variates)\n",
    "test_grouper = MultivariateGrouper(\n",
    "    max_target_dim=num_of_variates,\n",
    "    num_test_dates=len(test_dataset) // num_of_variates, # number of rolling test windows\n",
    ")\n",
    "\n",
    "multi_variate_train_dataset = train_grouper(train_dataset)\n",
    "multi_variate_test_dataset = test_grouper(test_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "469f5ec3",
   "metadata": {},
   "source": [
    "Note that now the target is 2 dimensional, where the first dim is the number of variates (number of time-series) and the second is the time-series values (time dimension): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "12a8e9c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "multi_variate_train_example[\"target\"].shape = (862, 17448)\n"
     ]
    }
   ],
   "source": [
    "multi_variate_train_example = multi_variate_train_dataset[0]\n",
    "print(\"multi_variate_train_example[\"target\"].shape =\", multi_variate_train_example[\"target\"].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50efb119",
   "metadata": {
    "id": "50efb119"
   },
   "source": [
    "## Define the model\n",
    "\n",
    "Next, let's instantiate a model. The model will be trained from scratch, hence we won't use the `from_pretrained` method here, but rather randomly initialize the model from a [`config`](https://huggingface.co/docs/transformers/main/en/model_doc/informer#transformers.InformerConfig).\n",
    "\n",
    "We specify a couple of additional parameters to the model:\n",
    "- `prediction_length` (in our case, `48` hours): this is the horizon that the decoder of the Informer will learn to predict for;\n",
    "- `context_length`: the model will set the `context_length` (input of the encoder) equal to the `prediction_length`, if no `context_length` is specified;\n",
    "- `lags` for a given frequency: these specify an efficient \"look back\" mechanism, where we concatenate values from the past to the current values as additional features, e.g. for a `Daily` frequency we might consider a look back of `[1, 7, 30, ...]` or for `Minute` data we might consider `[1, 30, 60, 60*24, ...]` etc.;\n",
    "- the number of time features: in our case, this will be `5` as we'll add `HourOfDay`, `DayOfWeek`, ..., and `Age` features (see below).\n",
    "\n",
    "Let us check the default lags provided by GluonTS for the given frequency (\"hourly\"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6CF4M8Ms7W-q",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6CF4M8Ms7W-q",
    "outputId": "4481a9bd-343c-45bd-b569-88d233ab8d40"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 23, 24, 25, 47, 48, 49, 71, 72, 73, 95, 96, 97, 119, 120, 121, 143, 144, 145, 167, 168, 169, 335, 336, 337, 503, 504, 505, 671, 672, 673, 719, 720, 721]\n"
     ]
    }
   ],
   "source": [
    "from gluonts.time_feature import get_lags_for_frequency\n",
    "\n",
    "lags_sequence = get_lags_for_frequency(freq)\n",
    "print(lags_sequence)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "q6ZuFx8yCSAM",
   "metadata": {
    "id": "q6ZuFx8yCSAM"
   },
   "source": [
    "This means that this would look back up to 721 hours (~30 days) for each time step, as additional features. However, the resulting feature vector would end up being of size `len(lags_sequence)*num_of_variates` which for our case will be 34480! This is not going to work so we will use our own sensible lags.\n",
    "\n",
    "Let us also check the default time features which GluonTS provides us:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "VlP_0E5I76lg",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "VlP_0E5I76lg",
    "outputId": "03d14e28-8609-4c8e-ef7c-efb17f41076a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<function hour_of_day at 0x7f3809539240>, <function day_of_week at 0x7f3809539360>, <function day_of_month at 0x7f3809539480>, <function day_of_year at 0x7f38095395a0>]\n"
     ]
    }
   ],
   "source": [
    "from gluonts.time_feature import time_features_from_frequency_str\n",
    "\n",
    "time_features = time_features_from_frequency_str(freq)\n",
    "print(time_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "m0_f7lm9CbNG",
   "metadata": {
    "id": "m0_f7lm9CbNG"
   },
   "source": [
    "In this case, there are four additional features, namely \"hour of day\", \"day of week\", \"day of month\" and \"day of year\". This means that for each time step, we'll add these features as a scalar values. For example, consider the timestamp `2015-01-01 01:00:01`. The four additional features will be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "99d3d336",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'hour_of_day': array([-0.45652174]), 'day_of_week': array([0.]), 'day_of_month': array([-0.5]), 'day_of_year': array([-0.5])}\n"
     ]
    }
   ],
   "source": [
    "from pandas.core.arrays.period import period_array\n",
    "\n",
    "timestamp = pd.Period(\"2015-01-01 01:00:01\", freq=freq)\n",
    "timestamp_as_index = pd.PeriodIndex(data=period_array([timestamp]))\n",
    "additional_features = [\n",
    "    (time_feature.__name__, time_feature(timestamp_as_index))\n",
    "    for time_feature in time_features\n",
    "]\n",
    "print(dict(additional_features))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bd7b8b9",
   "metadata": {},
   "source": [
    "Note that hours and days are encoded as values between `[-0.5, 0.5]` from GluonTS. For more information about `time_features`, please see [this](https://github.com/awslabs/gluonts/blob/dev/src/gluonts/time_feature/_base.py). Besides those 4 features, we'll also add an \"age\" feature as we'll see later on in the data transformations.\n",
    "\n",
    "We now have everything to define the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "3dda0e78",
   "metadata": {
    "id": "3dda0e78"
   },
   "outputs": [],
   "source": [
    "from transformers import InformerConfig, InformerForPrediction\n",
    "\n",
    "config = InformerConfig(\n",
    "    # in the multivariate setting, input_size is the number of variates in the time series per time step\n",
    "    input_size=num_of_variates,\n",
    "    # prediction length:\n",
    "    prediction_length=prediction_length,\n",
    "    # context length:\n",
    "    context_length=prediction_length * 2,\n",
    "    # lags value copied from 1 week before:\n",
    "    lags_sequence=[1, 24 * 7],\n",
    "    # we'll add 5 time features (\"hour_of_day\", ..., and \"age\"):\n",
    "    num_time_features=len(time_features) + 1,\n",
    "    \n",
    "    # informer params:\n",
    "    dropout=0.1,\n",
    "    encoder_layers=6,\n",
    "    decoder_layers=4,\n",
    "    # project input from num_of_variates*len(lags_sequence)+num_time_features to:\n",
    "    d_model=64,\n",
    ")\n",
    "\n",
    "model = InformerForPrediction(config)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "T6rCeV4dsUnF",
   "metadata": {
    "id": "T6rCeV4dsUnF"
   },
   "source": [
    "By default, the model uses a diagonal Student-t distribution (but this is [configurable](https://huggingface.co/docs/transformers/main/en/internal/time_series_utils)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "EaoKZyujsuIA",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "EaoKZyujsuIA",
    "outputId": "e711cbea-c734-463f-f28c-4009e5317a4e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'student_t'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.config.distribution_output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af82c60d",
   "metadata": {
    "id": "af82c60d"
   },
   "source": [
    "## Define Transformations\n",
    "\n",
    "Next, we define the transformations for the data, in particular for the creation of the time features (based on the dataset or universal ones).\n",
    "\n",
    "Again, we'll use the GluonTS library for this. We define a `Chain` of transformations (which is a bit comparable to `torchvision.transforms.Compose` for images). It allows us to combine several transformations into a single pipeline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "tR87yKPSn8SZ",
   "metadata": {
    "id": "tR87yKPSn8SZ"
   },
   "outputs": [],
   "source": [
    "from gluonts.time_feature import TimeFeature\n",
    "from gluonts.dataset.field_names import FieldName\n",
    "from gluonts.transform import (\n",
    "    AddAgeFeature,\n",
    "    AddObservedValuesIndicator,\n",
    "    AddTimeFeatures,\n",
    "    AsNumpyArray,\n",
    "    Chain,\n",
    "    ExpectedNumInstanceSampler,\n",
    "    InstanceSplitter,\n",
    "    RemoveFields,\n",
    "    SelectFields,\n",
    "    SetField,\n",
    "    TestSplitSampler,\n",
    "    Transformation,\n",
    "    ValidationSplitSampler,\n",
    "    VstackFeatures,\n",
    "    RenameFields,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4Qql4CInFWO7",
   "metadata": {
    "id": "4Qql4CInFWO7"
   },
   "source": [
    "The transformations below are annotated with comments, to explain what they do. At a high level, we will iterate over the individual time series of our dataset and add/remove fields or features:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "20fe036e",
   "metadata": {
    "id": "20fe036e"
   },
   "outputs": [],
   "source": [
    "from transformers import PretrainedConfig\n",
    "\n",
    "\n",
    "def create_transformation(freq: str, config: PretrainedConfig) -> Transformation:\n",
    "    # create list of fields to remove later\n",
    "    remove_field_names = []\n",
    "    if config.num_static_real_features == 0:\n",
    "        remove_field_names.append(FieldName.FEAT_STATIC_REAL)\n",
    "    if config.num_dynamic_real_features == 0:\n",
    "        remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL)\n",
    "    if config.num_static_categorical_features == 0:\n",
    "        remove_field_names.append(FieldName.FEAT_STATIC_CAT)\n",
    "\n",
    "    return Chain(\n",
    "        # step 1: remove static/dynamic fields if not specified\n",
    "        [RemoveFields(field_names=remove_field_names)]\n",
    "        # step 2: convert the data to NumPy (potentially not needed)\n",
    "        + (\n",
    "            [\n",
    "                AsNumpyArray(\n",
    "                    field=FieldName.FEAT_STATIC_CAT,\n",
    "                    expected_ndim=1,\n",
    "                    dtype=int,\n",
    "                )\n",
    "            ]\n",
    "            if config.num_static_categorical_features > 0\n",
    "            else []\n",
    "        )\n",
    "        + (\n",
    "            [\n",
    "                AsNumpyArray(\n",
    "                    field=FieldName.FEAT_STATIC_REAL,\n",
    "                    expected_ndim=1,\n",
    "                )\n",
    "            ]\n",
    "            if config.num_static_real_features > 0\n",
    "            else []\n",
    "        )\n",
    "        + [\n",
    "            AsNumpyArray(\n",
    "                field=FieldName.TARGET,\n",
    "                # we expect an extra dim for the multivariate case:\n",
    "                expected_ndim=1 if config.input_size == 1 else 2,\n",
    "            ),\n",
    "            # step 3: handle the NaN's by filling in the target with zero\n",
    "            # and return the mask (which is in the observed values)\n",
    "            # true for observed values, false for nan's\n",
    "            # the decoder uses this mask (no loss is incurred for unobserved values)\n",
    "            # see loss_weights inside the xxxForPrediction model\n",
    "            AddObservedValuesIndicator(\n",
    "                target_field=FieldName.TARGET,\n",
    "                output_field=FieldName.OBSERVED_VALUES,\n",
    "            ),\n",
    "            # step 4: add temporal features based on freq of the dataset\n",
    "            # these serve as positional encodings\n",
    "            AddTimeFeatures(\n",
    "                start_field=FieldName.START,\n",
    "                target_field=FieldName.TARGET,\n",
    "                output_field=FieldName.FEAT_TIME,\n",
    "                time_features=time_features_from_frequency_str(freq),\n",
    "                pred_length=config.prediction_length,\n",
    "            ),\n",
    "            # step 5: add another temporal feature (just a single number)\n",
    "            # tells the model where in the life the value of the time series is\n",
    "            # sort of running counter\n",
    "            AddAgeFeature(\n",
    "                target_field=FieldName.TARGET,\n",
    "                output_field=FieldName.FEAT_AGE,\n",
    "                pred_length=config.prediction_length,\n",
    "                log_scale=True,\n",
    "            ),\n",
    "            # step 6: vertically stack all the temporal features into the key FEAT_TIME\n",
    "            VstackFeatures(\n",
    "                output_field=FieldName.FEAT_TIME,\n",
    "                input_fields=[FieldName.FEAT_TIME, FieldName.FEAT_AGE]\n",
    "                + (\n",
    "                    [FieldName.FEAT_DYNAMIC_REAL]\n",
    "                    if config.num_dynamic_real_features > 0\n",
    "                    else []\n",
    "                ),\n",
    "            ),\n",
    "            # step 7: rename to match HuggingFace names\n",
    "            RenameFields(\n",
    "                mapping={\n",
    "                    FieldName.FEAT_STATIC_CAT: \"static_categorical_features\",\n",
    "                    FieldName.FEAT_STATIC_REAL: \"static_real_features\",\n",
    "                    FieldName.FEAT_TIME: \"time_features\",\n",
    "                    FieldName.TARGET: \"values\",\n",
    "                    FieldName.OBSERVED_VALUES: \"observed_mask\",\n",
    "                }\n",
    "            ),\n",
    "        ]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bab46d0",
   "metadata": {
    "id": "8bab46d0"
   },
   "source": [
    "## Define `InstanceSplitter`\n",
    "\n",
    "For training/validation/testing we next create an `InstanceSplitter` which is used to sample windows from the dataset (as, remember, we can't pass the entire history of values to the model due to time- and memory constraints).\n",
    "\n",
    "The instance splitter samples random `context_length` sized and subsequent `prediction_length` sized windows from the data, and appends a `past_` or `future_` key to any temporal keys for the respective windows. This makes sure that the `values` will be split into `past_values` and subsequent `future_values` keys, which will serve as the encoder and decoder inputs respectively. The same happens for any keys in the `time_series_fields` argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "cae7600d",
   "metadata": {
    "id": "cae7600d"
   },
   "outputs": [],
   "source": [
    "from gluonts.transform.sampler import InstanceSampler\n",
    "from typing import Optional\n",
    "\n",
    "\n",
    "def create_instance_splitter(\n",
    "    config: PretrainedConfig,\n",
    "    mode: str,\n",
    "    train_sampler: Optional[InstanceSampler] = None,\n",
    "    validation_sampler: Optional[InstanceSampler] = None,\n",
    ") -> Transformation:\n",
    "    assert mode in [\"train\", \"validation\", \"test\"]\n",
    "\n",
    "    instance_sampler = {\n",
    "        \"train\": train_sampler\n",
    "        or ExpectedNumInstanceSampler(\n",
    "            num_instances=1.0, min_future=config.prediction_length\n",
    "        ),\n",
    "        \"validation\": validation_sampler\n",
    "        or ValidationSplitSampler(min_future=config.prediction_length),\n",
    "        \"test\": TestSplitSampler(),\n",
    "    }[mode]\n",
    "\n",
    "    return InstanceSplitter(\n",
    "        target_field=\"values\",\n",
    "        is_pad_field=FieldName.IS_PAD,\n",
    "        start_field=FieldName.START,\n",
    "        forecast_start_field=FieldName.FORECAST_START,\n",
    "        instance_sampler=instance_sampler,\n",
    "        past_length=config.context_length + max(config.lags_sequence),\n",
    "        future_length=config.prediction_length,\n",
    "        time_series_fields=[\"time_features\", \"observed_mask\"],\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "958e050d",
   "metadata": {
    "id": "958e050d"
   },
   "source": [
    "## Create PyTorch DataLoaders\n",
    "\n",
    "Next, it's time to create PyTorch DataLoaders, which allow us to have batches of (input, output) pairs - or in other words (`past_values`, `future_values`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "6995101c",
   "metadata": {
    "id": "6995101c"
   },
   "outputs": [],
   "source": [
    "from typing import Iterable\n",
    "\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "from gluonts.itertools import Cached, Cyclic, IterableSlice, PseudoShuffled\n",
    "from gluonts.torch.util import IterableDataset\n",
    "\n",
    "\n",
    "def create_train_dataloader(\n",
    "    config: PretrainedConfig,\n",
    "    freq,\n",
    "    data,\n",
    "    batch_size: int,\n",
    "    num_batches_per_epoch: int,\n",
    "    shuffle_buffer_length: Optional[int] = None,\n",
    "    cache_data: bool = True,\n",
    "    **kwargs,\n",
    ") -> Iterable:\n",
    "    PREDICTION_INPUT_NAMES = [\n",
    "        \"past_time_features\",\n",
    "        \"past_values\",\n",
    "        \"past_observed_mask\",\n",
    "        \"future_time_features\",\n",
    "    ]\n",
    "    if config.num_static_categorical_features > 0:\n",
    "        PREDICTION_INPUT_NAMES.append(\"static_categorical_features\")\n",
    "\n",
    "    if config.num_static_real_features > 0:\n",
    "        PREDICTION_INPUT_NAMES.append(\"static_real_features\")\n",
    "\n",
    "    TRAINING_INPUT_NAMES = PREDICTION_INPUT_NAMES + [\n",
    "        \"future_values\",\n",
    "        \"future_observed_mask\",\n",
    "    ]\n",
    "\n",
    "    transformation = create_transformation(freq, config)\n",
    "    transformed_data = transformation.apply(data, is_train=True)\n",
    "    if cache_data:\n",
    "        transformed_data = Cached(transformed_data)\n",
    "\n",
    "    # we initialize a Training instance\n",
    "    instance_splitter = create_instance_splitter(config, \"train\") + SelectFields(\n",
    "        TRAINING_INPUT_NAMES\n",
    "    )\n",
    "\n",
    "    # the instance splitter will sample a window of\n",
    "    # context length + lags + prediction length (from all the possible transformed time series, 1 in our case)\n",
    "    # randomly from within the target time series and return an iterator.\n",
    "    training_instances = instance_splitter.apply(\n",
    "        Cyclic(transformed_data)\n",
    "        if shuffle_buffer_length is None\n",
    "        else PseudoShuffled(\n",
    "            Cyclic(transformed_data),\n",
    "            shuffle_buffer_length=shuffle_buffer_length,\n",
    "        )\n",
    "    )\n",
    "\n",
    "    # from the training instances iterator we now return a Dataloader which will\n",
    "    # continue to sample random windows for as long as it is called\n",
    "    # to return batch_size of the appropriate tensors ready for training!\n",
    "    return IterableSlice(\n",
    "        iter(\n",
    "            DataLoader(\n",
    "                IterableDataset(training_instances),\n",
    "                batch_size=batch_size,\n",
    "                **kwargs,\n",
    "            )\n",
    "        ),\n",
    "        num_batches_per_epoch,\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "10c55455",
   "metadata": {
    "id": "10c55455"
   },
   "outputs": [],
   "source": [
    "def create_test_dataloader(\n",
    "    config: PretrainedConfig,\n",
    "    freq,\n",
    "    data,\n",
    "    batch_size: int,\n",
    "    **kwargs,\n",
    "):\n",
    "    PREDICTION_INPUT_NAMES = [\n",
    "        \"past_time_features\",\n",
    "        \"past_values\",\n",
    "        \"past_observed_mask\",\n",
    "        \"future_time_features\",\n",
    "    ]\n",
    "    if config.num_static_categorical_features > 0:\n",
    "        PREDICTION_INPUT_NAMES.append(\"static_categorical_features\")\n",
    "\n",
    "    if config.num_static_real_features > 0:\n",
    "        PREDICTION_INPUT_NAMES.append(\"static_real_features\")\n",
    "\n",
    "    transformation = create_transformation(freq, config)\n",
    "    transformed_data = transformation.apply(data, is_train=False)\n",
    "\n",
    "    # we create a Test Instance splitter which will sample the very last\n",
    "    # context window seen during training only for the encoder.\n",
    "    instance_sampler = create_instance_splitter(config, \"test\") + SelectFields(\n",
    "        PREDICTION_INPUT_NAMES\n",
    "    )\n",
    "\n",
    "    # we apply the transformations in test mode\n",
    "    testing_instances = instance_sampler.apply(transformed_data, is_train=False)\n",
    "\n",
    "    # This returns a Dataloader which will go over the dataset once.\n",
    "    return DataLoader(\n",
    "        IterableDataset(testing_instances), batch_size=batch_size, **kwargs\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "20e2338b",
   "metadata": {
    "id": "20e2338b"
   },
   "outputs": [],
   "source": [
    "train_dataloader = create_train_dataloader(\n",
    "    config=config,\n",
    "    freq=freq,\n",
    "    data=multi_variate_train_dataset,\n",
    "    batch_size=256,\n",
    "    num_batches_per_epoch=100,\n",
    "    num_workers=2,\n",
    ")\n",
    "\n",
    "test_dataloader = create_test_dataloader(\n",
    "    config=config,\n",
    "    freq=freq,\n",
    "    data=multi_variate_test_dataset,\n",
    "    batch_size=32,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ES2U8g-2G2Jd",
   "metadata": {
    "id": "ES2U8g-2G2Jd"
   },
   "source": [
    "Let's check the first batch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "YU2h9OOB5IsX",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YU2h9OOB5IsX",
    "outputId": "ba8073bb-f450-4cd1-faee-3fb129f35c7e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "past_time_features torch.Size([256, 264, 5]) torch.FloatTensor\n",
      "past_values torch.Size([256, 264, 862]) torch.FloatTensor\n",
      "past_observed_mask torch.Size([256, 264, 862]) torch.FloatTensor\n",
      "future_time_features torch.Size([256, 48, 5]) torch.FloatTensor\n",
      "future_values torch.Size([256, 48, 862]) torch.FloatTensor\n",
      "future_observed_mask torch.Size([256, 48, 862]) torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "batch = next(iter(train_dataloader))\n",
    "for k, v in batch.items():\n",
    "    print(k, v.shape, v.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "HvvPlSF8HBYd",
   "metadata": {
    "id": "HvvPlSF8HBYd"
   },
   "source": [
    "As can be seen, we don't feed `input_ids` and `attention_mask` to the encoder (as would be the case for NLP models), but rather `past_values`, along with `past_observed_mask`, `past_time_features` and `static_real_features`.\n",
    "\n",
    "The decoder inputs consist of `future_values`, `future_observed_mask` and `future_time_features`. The `future_values` can be seen as the equivalent of `decoder_input_ids` in NLP.\n",
    "\n",
    "We refer to the [docs](https://huggingface.co/docs/transformers/main/en/model_doc/informer#transformers.InformerForPrediction.forward.past_values) for a detailed explanation for each of them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "_cev4ufVv1yf",
   "metadata": {
    "id": "_cev4ufVv1yf"
   },
   "source": [
    "## Forward pass\n",
    "\n",
    "Let's perform a single forward pass with the batch we just created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "sD8fav6qTApR",
   "metadata": {
    "id": "sD8fav6qTApR"
   },
   "outputs": [],
   "source": [
    "# perform forward pass\n",
    "outputs = model(\n",
    "    past_values=batch[\"past_values\"],\n",
    "    past_time_features=batch[\"past_time_features\"],\n",
    "    past_observed_mask=batch[\"past_observed_mask\"],\n",
    "    static_categorical_features=batch[\"static_categorical_features\"]\n",
    "    if config.num_static_categorical_features > 0\n",
    "    else None,\n",
    "    static_real_features=batch[\"static_real_features\"]\n",
    "    if config.num_static_real_features > 0\n",
    "    else None,\n",
    "    future_values=batch[\"future_values\"],\n",
    "    future_time_features=batch[\"future_time_features\"],\n",
    "    future_observed_mask=batch[\"future_observed_mask\"],\n",
    "    output_hidden_states=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "j2KnnHTCX4RC",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "j2KnnHTCX4RC",
    "outputId": "7b11e3b4-c4e1-48fd-c93e-69a21f28e072"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: -1071.5718994140625\n"
     ]
    }
   ],
   "source": [
    "print(\"Loss:\", outputs.loss.item())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "V9K8s2j9y8x7",
   "metadata": {
    "id": "V9K8s2j9y8x7"
   },
   "source": [
    "Note that the model is returning a loss. This is possible as the decoder automatically shifts the `future_values` one position to the right in order to have the labels. This allows computing a loss between the predicted values and the labels. The loss is the negative log-likelihood of the predicted distribution with respect to the ground truth values and tends to negative infinity.\n",
    "\n",
    "Also note that the decoder uses a causal mask to not look into the future as the values it needs to predict are in the `future_values` tensor."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "SxHDCa7vwPBF",
   "metadata": {
    "id": "SxHDCa7vwPBF"
   },
   "source": [
    "## Train the Model\n",
    "\n",
    "It's time to train the model! We'll use a standard PyTorch training loop.\n",
    "\n",
    "We will use the 🤗 [Accelerate](https://huggingface.co/docs/accelerate/index) library here, which automatically places the model, optimizer and dataloader on the appropriate `device`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "gMLYvQaNHuXQ",
   "metadata": {
    "id": "gMLYvQaNHuXQ",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1081.978515625\n",
      "-2187.323486328125\n",
      "-2398.588134765625\n",
      "-2561.66748046875\n",
      "-2574.604736328125\n",
      "-2624.291015625\n",
      "-2672.052734375\n",
      "-2680.340576171875\n",
      "-2703.502197265625\n",
      "-2706.705810546875\n",
      "-2745.5244140625\n",
      "-2744.054931640625\n",
      "-2665.214599609375\n",
      "-2814.014404296875\n",
      "-2826.083984375\n",
      "-2798.385986328125\n",
      "-2819.287353515625\n",
      "-2799.678955078125\n",
      "-2703.65966796875\n",
      "-2833.270263671875\n",
      "-2881.44921875\n",
      "-2712.630126953125\n",
      "-2892.16796875\n",
      "-2847.453125\n",
      "-2877.723876953125\n"
     ]
    }
   ],
   "source": [
    "from accelerate import Accelerator\n",
    "from torch.optim import AdamW\n",
    "\n",
    "epochs = 25\n",
    "loss_history = []\n",
    "\n",
    "accelerator = Accelerator()\n",
    "device = accelerator.device\n",
    "\n",
    "model.to(device)\n",
    "optimizer = AdamW(model.parameters(), lr=6e-4, betas=(0.9, 0.95), weight_decay=1e-1)\n",
    "\n",
    "model, optimizer, train_dataloader = accelerator.prepare(\n",
    "    model,\n",
    "    optimizer,\n",
    "    train_dataloader,\n",
    ")\n",
    "\n",
    "model.train()\n",
    "for epoch in range(epochs):\n",
    "    for idx, batch in enumerate(train_dataloader):\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(\n",
    "            static_categorical_features=batch[\"static_categorical_features\"].to(device)\n",
    "            if config.num_static_categorical_features > 0\n",
    "            else None,\n",
    "            static_real_features=batch[\"static_real_features\"].to(device)\n",
    "            if config.num_static_real_features > 0\n",
    "            else None,\n",
    "            past_time_features=batch[\"past_time_features\"].to(device),\n",
    "            past_values=batch[\"past_values\"].to(device),\n",
    "            future_time_features=batch[\"future_time_features\"].to(device),\n",
    "            future_values=batch[\"future_values\"].to(device),\n",
    "            past_observed_mask=batch[\"past_observed_mask\"].to(device),\n",
    "            future_observed_mask=batch[\"future_observed_mask\"].to(device),\n",
    "        )\n",
    "        loss = outputs.loss\n",
    "\n",
    "        # Backpropagation\n",
    "        accelerator.backward(loss)\n",
    "        optimizer.step()\n",
    "\n",
    "        loss_history.append(loss.item())\n",
    "        if idx % 100 == 0:\n",
    "            print(loss.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "cb1e9bb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2cAAAHYCAYAAADJSJDsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACaVUlEQVR4nOzdeXhM1xsH8O9k32STFUHstYYgklJUKlpt6aJ7lSqluiit0tqqixYt1U391NJFq1rVFlWEWCP2NRJCCCERIrtsM/f3R5KbubNlZjKTmUm+n+eZx8y9Z+6cmVzJfeec874yQRAEEBERERERkUXZWboDRERERERExOCMiIiIiIjIKjA4IyIiIiIisgIMzoiIiIiIiKwAgzMiIiIiIiIrwOCMiIiIiIjICjA4IyIiIiIisgIMzoiIiIiIiKwAgzMiIiIiIiIrwOCMiIiokkwmg0wms3Q3iIiogWJwRkREREREZAUYnBEREREREVkBBmdERERERERWgMEZERGRka5cuYKXX34ZLVq0gLOzMwICAvDoo4/i0KFDGtufPn0azz33HFq1agUXFxf4+/sjLCwMkyZNwvXr1yVt9+/fj+HDh4vHDgoKQu/evTFt2jQUFBTUxdsjIqI6JhMEQbB0J4iIiKxBVTIQff40njp1Cvfeey9u3ryJ9u3bo3v37khLS8P+/fvh4OCANWvWYMSIEWL7I0eOoG/fviguLkbXrl3RoUMHFBUV4eLFi0hMTMTOnTsxYMAAAMA///yD4cOHQxAE9O7dG6GhocjJycH58+dx4cIFpKamomXLlub4CIiIyIIcLN0BIiIiWyMIAp599lncvHkTU6dOxSeffCIGdn/88QeeeOIJvPjii+jbty+Cg4MBAEuWLEFxcTEWLlyIKVOmSI6XlJQELy8v8fHChQuhUCjw+++/47HHHpO0PXToEBo3bmzmd0hERJbAaY1EREQGiouLw6lTp9C8eXN8+OGHkvT7jz32GIYPH46CggKsWLFC3J6VlQUAiI6OVjtehw4dxCCupra9evVCo0aNTPZeiIjIejA4IyIiMtCePXsAAE888QQcHR3V9j///POSdgAQHh4OAJg4cSLi4uJQXl6u9fhVbZ9//nkcOnQICoXCZH0nIiLrxeCMiIjIQNeuXQMAreu+qranp6eL295++20MGDAA+/btw8CBA+Hj44PBgwfjiy++QG5uruT5H3/8Mbp164Z//vkHvXv3hp+fHx5++GEsX74cxcXFZnlPRERkeQzOiIiITEx5mmMVT09P7NixA3v27MHUqVPRsWNH7NixA5MmTUL79u1x/vx5sW1ISAgOHz6M//77D6+99hpCQkLwzz//YOzYsejatStu3bpVl2+HiIjqCIMzIiIiAzVp0gQAcPnyZY37L126BABo2rSpZLtMJkPfvn3x6aefIiEhAdeuXcPTTz+NzMxMvPfee5K2Dg4OGDx4MJYsWYITJ07g0qVLuPfee3H+/Hl8+umnpn9TRERkcQzOiIiIDNSvXz8AwLp16yCXy9X2//TTT5J22gQEBGDOnDkAKmqg6dKiRQu88847erUlIiLbxOCMiIjIQAMGDECXLl1w6dIlzJo1S1IX7c8//8T69evh4eGBF198Udy+dOlSpKamqh1r8+bNACqmMlZZtGgRMjIy9GpLRET1B4tQExERVapaKxYREaG1zUsvvYSXXnoJp06dwsCBA3Hr1i3cddddCAsLQ1paGvbt2wcHBwf8/PPPeOKJJ8TnhYWF4cSJE+jYsSPuuusuODg4ICkpCSdOnICLiwu2b9+Ou+++GwDg7e2N/Px8dOvWDW3btoUgCDhx4gTOnTsHX19fHDhwAG3btjXvh0FERHWOwRkREVElTYk8VM2ePVucipiWloYPP/wQW7ZsQUZGBry8vNC3b19Mnz4dvXv3ljzvn3/+wYYNG5CQkID09HSUlpaiWbNmuOeee/DWW2+hffv2Ytsff/wRW7ZswZEjR8TMkCEhIRgyZAgmT56stpaNiIjqBwZnREREREREVoBrzoiIiIiIiKwAgzMiIiIiIiIrwOCMiIiIiIjICjA4IyIiIiIisgIMzoiIiIiIiKyAzQRnH330EaKiouDm5gZvb2+NbdLS0jB06FC4ubkhICAAb7/9NsrLyyVt4uLi0KNHDzg7O6NNmzZYtWqV2nG+/vprtGzZEi4uLoiIiMDBgwfN8I6IiIiIiIiqOVi6A/oqLS3FiBEjEBkZie+//15tv1wux9ChQxEUFIT9+/fj+vXrGDlyJBwdHfHxxx8DAFJTUzF06FCMHz8eP//8M2JjY/HSSy8hODgYMTExAIC1a9di8uTJWLp0KSIiIrB48WLExMQgOTkZAQEBevVVoVDg2rVraNSokV41c4iIiIiIqH4SBAH5+flo0qQJ7OxqGBsTbMzKlSsFLy8vte2bN28W7OzshIyMDHHbt99+K3h6egolJSWCIAjC1KlThU6dOkme9+STTwoxMTHi4969ewsTJ04UH8vlcqFJkybCvHnz9O7jlStXBAC88cYbb7zxxhtvvPHGG28CAOHKlSs1xhE2M3JWk/j4eHTp0gWBgYHitpiYGEyYMAFnzpxB9+7dER8fj+joaMnzYmJiMGnSJAAVo3NHjhzB9OnTxf12dnaIjo5GfHy81tcuKSlBSUmJ+FiorOt95coVeHp6muLtERERERGRDcrLy0NISAgaNWpUY9t6E5xlZGRIAjMA4uOMjAydbfLy8nDnzh3cvn0bcrlcY5ukpCStrz1v3jy8//77ats9PT0ZnBERERERkV7LnSyaEGTatGmQyWQ6b7qCImsxffp05ObmircrV65YuktERERERGRjLDpyNmXKFIwaNUpnm1atWul1rKCgILWsipmZmeK+qn+rtim38fT0hKurK+zt7WFvb6+xTdUxNHF2doazs7Ne/SQiIiIiItLEosGZv78//P39TXKsyMhIfPTRR7hx44aYVXHbtm3w9PREx44dxTabN2+WPG/btm2IjIwEADg5OSE8PByxsbEYPnw4gIrMi7GxsXj11VdN0k8iIiIiIiJNbGbNWVpaGrKzs5GWlga5XI7jx48DANq0aQMPDw8MHjwYHTt2xPPPP4/58+cjIyMDM2bMwMSJE8VRrfHjx+Orr77C1KlT8eKLL2LHjh347bffsGnTJvF1Jk+ejBdeeAE9e/ZE7969sXjxYhQWFmL06NGWeNtERERERGYnl8tRVlZm6W7YJHt7ezg4OJikhJZMqEotaOVGjRqF1atXq23fuXMnBgwYAAC4fPkyJkyYgLi4OLi7u+OFF17AJ598AgeH6hg0Li4Ob775JhITE9GsWTPMnDlTbWrlV199hQULFiAjIwNhYWFYsmQJIiIi9O5rXl4evLy8kJuby4QgRERERGTVCgoKcPXqVdhIWGCV3NzcEBwcDCcnJ7V9hsQGNhOc2RIGZ0RERERkC+RyOc6fPw83Nzf4+/ubZPSnIREEAaWlpcjKyoJcLkfbtm3VCk0bEhvYzLRGIiIiIiIyrbKyMgiCAH9/f7i6ulq6OzbJ1dUVjo6OuHz5MkpLS+Hi4mL0sSyaSp+IiIiIiCyPI2a1ozpaZvRxTHIUIiIiIiIiqhUGZ0RERERERFaAwRkRERERETVYLVu2xOLFiy3dDQBMCEJERERERDZmwIABCAsLM0lQdejQIbi7u9e+UybA4IyIiIiIiOoVQRAgl8sl9Y618ff3r4Me6YfTGuu5N349hgELduLElRxLd4WIiIiIrJwgCCgqLbfITd/yy6NGjcKuXbvwxRdfQCaTQSaTYdWqVZDJZPj3338RHh4OZ2dn7N27FxcuXMCwYcMQGBgIDw8P9OrVC9u3b5ccT3Vao0wmw/Lly/HII4/Azc0Nbdu2xd9//23Kj1krjpzVc9dy7uDSrSJcvX0H3UK8Ld0dIiIiIrJid8rk6DjrP4u8duLcGLg51RyefPHFFzh37hw6d+6MuXPnAgDOnDkDAJg2bRoWLlyIVq1awcfHB1euXMEDDzyAjz76CM7Ozvjhhx/w0EMPITk5Gc2bN9f6Gu+//z7mz5+PBQsW4Msvv8Szzz6Ly5cvw9fX1zRvVguOnNVzTbwrigley7lj4Z4QEREREdWel5cXnJyc4ObmhqCgIAQFBcHe3h4AMHfuXNx3331o3bo1fH190a1bN7z88svo3Lkz2rZtiw8++ACtW7eucSRs1KhRePrpp9GmTRt8/PHHKCgowMGDB83+3jhyVs9VBWdp2UUW7gkRERERWTtXR3skzo2x2GvXVs+ePSWPCwoKMGfOHGzatAnXr19HeXk57ty5g7S0NJ3H6dq1q3jf3d0dnp6euHHjRq37VxMGZ/Vch6BGAICT6bkW7gkRERERWTuZTKbX1EJrpZp18a233sK2bduwcOFCtGnTBq6urnj88cdRWlqq8ziOjo6SxzKZDAqFwuT9VWW7nzzpJdSv4gS9kVds4Z4QEREREZmGk5MT5HJ5je327duHUaNG4ZFHHgFQMZJ26dIlM/fOeFxzVs+5O1fE3wUl5RbuCRERERGRabRs2RIJCQm4dOkSbt68qXVUq23btli/fj2OHz+OEydO4JlnnqmTETBjMTir5zwqg7OiUrne6UmJiIiIiKzZW2+9BXt7e3Ts2BH+/v5a15B9/vnn8PHxQVRUFB566CHExMSgR48eddxb/ckEXrGbXF5eHry8vJCbmwtPT0+L9iW/uAxd5mwFACR9MAQuJlhoSURERET1Q3FxMVJTUxEaGgoXFxdLd8dm6focDYkNOHJWzykv6Czk1EYiIiIiIqvF4Kyes7eTiWlJC0tqXjRJRERERESWweCsAfB2q0gFertId8pQIiIiIiKyHAZnDYCvuxMAILuQwRkRERERkbVicNYAVAVntxicEREREZEGzBFYO6b6/BicNQB+Hs4AgOzCEgv3hIiIiIisib19RW6C0lJ+iV8bRUVFAABHR8daHceh5iZk6zhyRkRERESaODg4wM3NDVlZWXB0dISdHcduDCEIAoqKinDjxg14e3uLwa6xGJw1AGJwVsDgjIiIiIiqyWQyBAcHIzU1FZcvX7Z0d2yWt7c3goKCan0cBmcNQGMmBCEiIiIiLZycnNC2bVtObTSSo6NjrUfMqjA4awA4rZGIiIiIdLGzs4OLi4ulu9HgcVJpA9CYCUGIiIiIiKweg7MGoDHXnBERERERWT0GZw2Ar0dFcFZUKkdxmdzCvSEiIiIiIk0YnDUAjZwd4GgvA8B1Z0RERERE1orBWQMgk8nEpCDZnNpIRERERGSVGJw1EI3dK5KC3GJSECIiIiIiq8TgrIFo7MGkIERERERE1ozBWQPhy0LURERERERWjcFZA8FC1ERERERE1o3BWQPh5eoIAMgrLrNwT4iIiIiISBObCc4++ugjREVFwc3NDd7e3mr7T5w4gaeffhohISFwdXXFXXfdhS+++ELSJi4uDjKZTO2WkZEhaff111+jZcuWcHFxQUREBA4ePGjOt1YnGrlUBGf5xeUW7gkREREREWniYOkO6Ku0tBQjRoxAZGQkvv/+e7X9R44cQUBAAH766SeEhIRg//79GDduHOzt7fHqq69K2iYnJ8PT01N8HBAQIN5fu3YtJk+ejKVLlyIiIgKLFy9GTEwMkpOTJe1sTSOXih91PkfOiIiIiIisks0EZ++//z4AYNWqVRr3v/jii5LHrVq1Qnx8PNavX68WnAUEBGgcfQOAzz//HGPHjsXo0aMBAEuXLsWmTZuwYsUKTJs2rXZvwoIaOVf8qAs4ckZEREREZJVsZlqjMXJzc+Hr66u2PSwsDMHBwbjvvvuwb98+cXtpaSmOHDmC6OhocZudnR2io6MRHx+v9XVKSkqQl5cnuVkbTmskIiIiIrJu9TY4279/P9auXYtx48aJ24KDg7F06VL88ccf+OOPPxASEoIBAwbg6NGjAICbN29CLpcjMDBQcqzAwEC1dWnK5s2bBy8vL/EWEhJinjdVC5zWSERERERk3SwanE2bNk1jgg7lW1JSksHHPX36NIYNG4bZs2dj8ODB4vb27dvj5ZdfRnh4OKKiorBixQpERUVh0aJFtXof06dPR25urni7cuVKrY5nDh5VwVkJR86IiIiIiKyRRdecTZkyBaNGjdLZplWrVgYdMzExEYMGDcK4ceMwY8aMGtv37t0be/fuBQD4+fnB3t4emZmZkjaZmZkICgrSegxnZ2c4Ozsb1M+6VjVyVlBSDoVCgJ2dzMI9IiIiIiIiZRYNzvz9/eHv72+y4505cwb33nsvXnjhBXz00Ud6Pef48eMIDg4GADg5OSE8PByxsbEYPnw4AEChUCA2NlYtqYit8axccyYIQGFpubgGjYiIiIiIrIPNZGtMS0tDdnY20tLSIJfLcfz4cQBAmzZt4OHhgdOnT+Pee+9FTEwMJk+eLK4Rs7e3FwPAxYsXIzQ0FJ06dUJxcTGWL1+OHTt2YOvWreLrTJ48GS+88AJ69uyJ3r17Y/HixSgsLBSzN9oqZwc7ONrLUCYXkFfM4IyIiIiIyNrYTHA2a9YsrF69WnzcvXt3AMDOnTsxYMAA/P7778jKysJPP/2En376SWzXokULXLp0CUBFNsYpU6YgPT0dbm5u6Nq1K7Zv346BAweK7Z988klkZWVh1qxZyMjIQFhYGLZs2aKWJMTWyGQy+Lg54UZ+CW4XlqKpt6ulu0REREREREpkgiAIlu5EfZOXlwcvLy/k5uZKil1b2v1f7MHZ63lYNboXBrS33YLaRERERES2wpDYoN6m0id1fh5OAIBbBaUW7gkREREREalicNaANHavDM4KSyzcEyIiIiIiUsXgrAFp7FGR7p8jZ0RERERE1ofBWQPSuHJa400GZ0REREREVofBWQPi5145csZpjUREREREVofBWQPi14gJQYiIiIiIrBWDswakcdXIWQFHzoiIiIiIrA2DswZEXHNWWAqWtyMiIiIisi4MzhqQqpGz0nIFCkrKLdwbIiIiIiJSxuCsAXF1soe7kz0ArjsjIiIiIrI2DM4aGF8PFqImIiIiIrJGDM4aGC9XRwBA3h1OayQiIiIisiYMzhqYRs6VwVlxmYV7QkREREREyhicNTCNXBwAAPnFHDkjIiIiIrImDM4aGI/K4IzZGomIiIiIrAuDswbG06ViWmM+pzUSEREREVkVBmcNDKc1EhERERFZJwZnDQyDMyIiIiIi68TgrIHxcK6a1sjgjIiIiIjImjA4a2CqR8645oyIiIiIyJowOGtgPCuLUOfeYXBGRERERGRNGJw1MI3dnQAAtwpLLdwTIiIiIiJSxuCsgQlo5AwAuFVQArlCsHBviIiIiIioCoOzBsbX3QkyGaAQgGyOnhERERERWQ0GZw2Mg72dOLUxK7/Ewr0hIiIiIqIqDM4aID+PiqmNNwsYnBERERERWQsGZw2Qf+W6M46cERERERFZDwZnDZB/5chZFkfOiIiIiIisBoOzBogjZ0RERERE1ofBWQPE4IyIiIiIyPowOGuAGJwREREREVkfBmcNENecERERERFZHwZnDRBHzoiIiIiIrA+DswaoKjjLvVOGknK5hXtDREREREQAg7MGycvVEY72MgDArYJSC/eGiIiIiIgABmcNkkwmg58HpzYSEREREVkTBmcNlLebEwAg506ZhXtCRERERESADQVnH330EaKiouDm5gZvb2+NbWQymdrt119/lbSJi4tDjx494OzsjDZt2mDVqlVqx/n666/RsmVLuLi4ICIiAgcPHjTDO7IsL1cHABXrzoiIiIiIyPJsJjgrLS3FiBEjMGHCBJ3tVq5cievXr4u34cOHi/tSU1MxdOhQDBw4EMePH8ekSZPw0ksv4b///hPbrF27FpMnT8bs2bNx9OhRdOvWDTExMbhx44a53ppFeLk6AmBwRkRERERkLRws3QF9vf/++wCgcaRLmbe3N4KCgjTuW7p0KUJDQ/HZZ58BAO666y7s3bsXixYtQkxMDADg888/x9ixYzF69GjxOZs2bcKKFSswbdo0E70by/N2rZzWWMiEIERERERE1sBmRs70NXHiRPj5+aF3795YsWIFBEEQ98XHxyM6OlrSPiYmBvHx8QAqRueOHDkiaWNnZ4fo6GixjSYlJSXIy8uT3KxdE29XAEBadpGFe0JERERERIANjZzpY+7cubj33nvh5uaGrVu34pVXXkFBQQFef/11AEBGRgYCAwMlzwkMDEReXh7u3LmD27dvQy6Xa2yTlJSk9XXnzZsnjuzZilb+7gCA1JuFFu4JEREREREBFh45mzZtmsYkHso3XUGRqpkzZ+Luu+9G9+7d8c4772Dq1KlYsGCBGd9BhenTpyM3N1e8XblyxeyvWVuNPSqmNXLNGRERERGRdbDoyNmUKVMwatQonW1atWpl9PEjIiLwwQcfoKSkBM7OzggKCkJmZqakTWZmJjw9PeHq6gp7e3vY29trbKNtHRsAODs7w9nZ2eh+WoKnS0VCkLxiBmdERERERNbAosGZv78//P39zXb848ePw8fHRwycIiMjsXnzZkmbbdu2ITIyEgDg5OSE8PBwxMbGilkeFQoFYmNj8eqrr5qtn5ZQla0x7065hXtCRERERESADa05S0tLQ3Z2NtLS0iCXy3H8+HEAQJs2beDh4YF//vkHmZmZ6NOnD1xcXLBt2zZ8/PHHeOutt8RjjB8/Hl999RWmTp2KF198ETt27MBvv/2GTZs2iW0mT56MF154AT179kTv3r2xePFiFBYWitkb64tGLhU/+jtlcpTJFXC0r3e5YYiIiIiIbIrNBGezZs3C6tWrxcfdu3cHAOzcuRMDBgyAo6Mjvv76a7z55psQBAFt2rQR0+JXCQ0NxaZNm/Dmm2/iiy++QLNmzbB8+XIxjT4APPnkk8jKysKsWbOQkZGBsLAwbNmyRS1JiK1r5OIImQwQBOB2USkCGrlYuktERERERA2aTFDONU8mkZeXBy8vL+Tm5sLT09PS3dGq10fbkZVfgo2v9UXnpl6W7g4RERERUb1jSGzAuWwNWKBnxVq8G/nFFu4JERERERExOGvAGrtXBGe3Ckot3BMiIiIiImJw1oB5u1VkbGStMyIiIiIiy2Nw1oB5uzI4IyIiIiKyFgzOGrCqWmc5RQzOiIiIiIgsjcFZA+bl5gQAyOHIGRERERGRxTE4a8CqR86YEISIiIiIyNIYnDVgVWvO8jhyRkRERERkcQzOGrCqbI2c1khEREREZHkMzhow78o1Z9msc0ZEREREZHEMzhqwAM+KItT5JeW4Uyq3cG+IiIiIiBo2BmcNWCNnB7g62gMAMvOKLdwbIiIiIqKGjcFZAyaTydA6wB0AcDTttoV7Q0RERETUsDE4a+C6NPUGAFzJvmPZjhARERERNXAMzho4N6eKaY13yrjmjIiIiIjIkhicNXBVa86KGZwREREREVkUg7MGzsWx4hRgtkYiIiIiIsticNbAuThyWiMRERERkTVgcNbAuXLNGRERERGRVWBw1sBxzRkRERERkXVgcNbANXJxBADkFJVZuCdERERERA0bg7MGrqm3KwDg6u0iC/eEiIiIiKhhY3DWwDXzrQjObheVMWMjEREREZEFMThr4Bo5O8DRXgYAuF1UauHeEBERERE1XAzOGjiZTAYvVycADM6IiIiIiCyJwRnBx60iKUguk4IQEREREVkMgzOCd2VwlnOHwRkRERERkaUwOCO4OTkAAIqYEISIiIiIyGIYnBHcnSsKUReVllu4J0REREREDReDM+LIGRERERGRFWBwRnBzqhg5++9MhoV7QkRERETUcDE4I+w6lwUAOJaWY9mOEBERERE1YAzOCFGt/cT7hSVcd0ZEREREZAkMzgjTH+gg3k/PuWPBnhARERERNVwMzgieLo5o6u0KgCNnRERERESWwuCMAFSn07/DjI1ERERERBZhM8HZRx99hKioKLi5ucHb21tt/6pVqyCTyTTebty4AQCIi4vTuD8jQ5ql8Ouvv0bLli3h4uKCiIgIHDx4sC7eokW5VqbTL2RwRkRERERkETYTnJWWlmLEiBGYMGGCxv1PPvkkrl+/LrnFxMSgf//+CAgIkLRNTk6WtFPev3btWkyePBmzZ8/G0aNH0a1bN8TExIgBXn3l5shC1EREREREluRg6Q7o6/333wdQMUKmiaurK1xdXcXHWVlZ2LFjB77//nu1tgEBARpH3wDg888/x9ixYzF69GgAwNKlS7Fp0yasWLEC06ZNq92bsGJVtc44rZGIiIiIyDJsZuTMUD/88APc3Nzw+OOPq+0LCwtDcHAw7rvvPuzbt0/cXlpaiiNHjiA6OlrcZmdnh+joaMTHx2t9rZKSEuTl5UlutsbNuSJOL2BCECIiIiIii6i3wdn333+PZ555RjKaFhwcjKVLl+KPP/7AH3/8gZCQEAwYMABHjx4FANy8eRNyuRyBgYGSYwUGBqqtS1M2b948eHl5ibeQkBDzvCkz8nVzBADcLiq1cE+IiIiIiBomiwZn06ZN05rEo+qWlJRk8HHj4+Nx9uxZjBkzRrK9ffv2ePnllxEeHo6oqCisWLECUVFRWLRoUa3ex/Tp05Gbmyverly5UqvjWYJ/I2cAQFZ+iYV7QkRERETUMFl0zdmUKVMwatQonW1atWpl8HGXL1+OsLAwhIeH19i2d+/e2Lt3LwDAz88P9vb2yMzMlLTJzMxEUFCQ1mM4OzvD2dnZ4H5ak6rgLDOPwRkRERERkSVYNDjz9/eHv7+/SY9ZUFCA3377DfPmzdOr/fHjxxEcHAwAcHJyQnh4OGJjYzF8+HAAgEKhQGxsLF599VWT9tPaNPd1BwDsOpcFuUKAvZ3Mwj0iIiIiImpYbCZbY1paGrKzs5GWlga5XI7jx48DANq0aQMPDw+x3dq1a1FeXo7nnntO7RiLFy9GaGgoOnXqhOLiYixfvhw7duzA1q1bxTaTJ0/GCy+8gJ49e6J3795YvHgxCgsLxeyN9VX7oEbi/YSLtxDVxs+CvSEiIiIianhsJjibNWsWVq9eLT7u3r07AGDnzp0YMGCAuP3777/Ho48+qjFVfmlpKaZMmYL09HS4ubmha9eu2L59OwYOHCi2efLJJ5GVlYVZs2YhIyMDYWFh2LJli1qSkPrG190JLo52KC5T4GrOHUt3h4iIiIiowZEJgiBYuhP1TV5eHry8vJCbmwtPT09Ld0dvk9cex/pj6Zh2fweM79/a0t0hIiIiIrJ5hsQG9TaVPhmusYcTAOBWAZOCEBERERHVNQZnJGrsUZGx8VYha50REREREdU1Bmck8nWvGjljcEZEREREVNcYnJHIr2paYyGnNRIRERER1TUGZyRq7F4xrTGbI2dERERERHWOwRmJqqY13iwsBZN4EhERERHVLQZnJKrK1lharkBBSbmFe0NERERE1LAwOCORm5MDvFwdAQD7Um5auDdERERERA0LgzOS6NfWDwCQnFFg4Z4QERERETUsDM5IIqCRCwBg0fZzFu4JEREREVHDwuCMJEL93cX7peUKC/aEiIiIiKhhYXBGEk/0bCbez71TZsGeEBERERE1LAzOSMLZwR6eLg4AGJwREREREdUlBmekxtutst5ZQYmFe0JERERE1HAwOCM1VUHZU8sOWLgnREREREQNB4MzUlNUKrd0F4iIiIiIGhwGZ0RERERERFaAwRkREREREZEVYHBGap7r01y8L1cIFuwJEREREVHDweCM1Lz7wF3i/aLScgv2hIiIiIio4WBwRmpcHe1hbycDAOQUsdYZEREREVFdYHBGamQyGTo18QQAHLl828K9ISIiIiJqGBickUZt/D0AAJPWHsfuc1kW7g0RERERUf3H4Iw08nV3Eu+P/+mIBXtCRERERNQwMDgjjXw9qoMzhcCMjURERERE5sbgjDRq4esu3vdydbRgT4iIiIiIGgYGZ6RR37Z+4v0OQZ4W7AkRERERUcPA4Iw08nJ1xPzHuwJgIWoiIiIiorrA4Iy08q6czlhQwkLURERERETmxuCMtGri7QoAuHCjAOVyhYV7Q0RERERUvzE4I63uCvaEj5sj8kvKceJqjqW7Q0RERERUrzE4I63s7WToFuINAEi5UWDZzhARERER1XMMzkinqjT6+cVcd0ZEREREZE4MzkgnD2cHAEwKQkRERERkbgzOSCcPl8rgjCNnRERERERmxeCMdGrEkTMiIiIiojrB4Ix08nV3BgD8eugKLmYxKQgRERERkbnoHZydPHlS75upXbp0CWPGjEFoaChcXV3RunVrzJ49G6WlpWp97NevH1xcXBASEoL58+erHWvdunXo0KEDXFxc0KVLF2zevFmyXxAEzJo1C8HBwXB1dUV0dDTOnz9v8vdkK7o09RLv3/vZLgv2hIiIiIiofnPQt2FYWBhkMhkEQdC4v2qfTCaDXC43WQcBICkpCQqFAt999x3atGmD06dPY+zYsSgsLMTChQsBAHl5eRg8eDCio6OxdOlSnDp1Ci+++CK8vb0xbtw4AMD+/fvx9NNPY968eXjwwQexZs0aDB8+HEePHkXnzp0BAPPnz8eSJUuwevVqhIaGYubMmYiJiUFiYiJcXFxM+r5sQeemnmji5YJrucUAgMOXstGzpa+Fe0VEREREVP/IBG3RlorLly/rfdAWLVoY3SF9LViwAN9++y0uXrwIAPj222/x3nvvISMjA05OTgCAadOmYcOGDUhKSgIAPPnkkygsLMTGjRvF4/Tp0wdhYWFYunQpBEFAkyZNMGXKFLz11lsAgNzcXAQGBmLVqlV46qmn9OpbXl4evLy8kJubC09PT1O+bYtIvVmIgQvjAABdm3nh71f7WrZDREREREQ2wpDYQO+Rs7oIuAyRm5sLX9/qEZz4+Hjcc889YmAGADExMfj0009x+/Zt+Pj4ID4+HpMnT5YcJyYmBhs2bAAApKamIiMjA9HR0eJ+Ly8vREREID4+XmtwVlJSgpKSEvFxXl6eKd6i1Qj0dBbvK/SL5YmIiIiIyEB6B2d///233gd9+OGHjeqMvlJSUvDll1+KUxoBICMjA6GhoZJ2gYGB4j4fHx9kZGSI25TbZGRkiO2Un6epjSbz5s3D+++/b/wbsnJuTg6IbNUY8RdvWborRERERET1lt7B2fDhw/VqZ8ias2nTpuHTTz/V2ebs2bPo0KGD+Dg9PR1DhgzBiBEjMHbsWL1ex9ymT58uGZHLy8tDSEiIBXtkejMevAtDl+zF6fQ8nLiSg24h3pbuEhERERFRvaJ3cKZQKEz+4lOmTMGoUaN0tmnVqpV4/9q1axg4cCCioqKwbNkySbugoCBkZmZKtlU9DgoK0tlGeX/VtuDgYEmbsLAwrX10dnaGs7Oz1v31ga979XTRYV/vw6VPhlqwN0RERERE9Y/ewZmq2NhYxMbG4saNG5LATSaT4fvvv9frGP7+/vD399erbXp6OgYOHIjw8HCsXLkSdnbSKgCRkZF47733UFZWBkdHRwDAtm3b0L59e/j4+IhtYmNjMWnSJPF527ZtQ2RkJAAgNDQUQUFBiI2NFYOxvLw8JCQkYMKECXr1s77ycXOSPC4sKYe7s9GnDxERERERqTCqCPX777+PwYMHIzY2Fjdv3sTt27fFW3Z2tqn7iPT0dAwYMADNmzfHwoULkZWVhYyMDMk6sGeeeQZOTk4YM2YMzpw5g7Vr1+KLL76QTDd84403sGXLFnz22WdISkrCnDlzcPjwYbz66qsAKgLLSZMm4cMPP8Tff/+NU6dOYeTIkWjSpIne0zrrKxdHe8njoUv2WKgnRERERET1k1FDH0uXLsWqVavw/PPPm7o/Gm3btg0pKSlISUlBs2bNJPuqKgF4eXlh69atmDhxIsLDw+Hn54dZs2aJNc4AICoqCmvWrMGMGTPw7rvvom3bttiwYYNY4wwApk6disLCQowbNw45OTno27cvtmzZ0iBrnOly6VaRpbtARERERFSv6F3nTFnjxo1x8OBBtG7d2hx9snn1rc5ZlZbTNkken5g1GF5ujhbqDRERERGR9TMkNjBqWuNLL72ENWvWGNU5sl2/j4+UPP5+X6qFekJEREREVP8YNa2xuLgYy5Ytw/bt29G1a1cxAUeVzz//3CSdI+vSs6Wv5HH67TsW6gkRERERUf1jVHB28uRJMZvh6dOnJftkMlmtO0W2IfdOqaW7QERERERUbxgVnO3cudPU/SAbdJUjZ0REREREJmPUmjNquMb2CxXvJ2XkI/dOmQV7Q0RERERUfzA4I4O8N7QjTs0ZLD7u9v5WFJaUW7BHRERERET1A4MzMlgjF2kCmBNXcizTESIiIiKieoTBGdWaowNPIyIiIiKi2uJVNRnl1YFtxPuGlzEnIiIiIiJVDM7IKK5O9uL9olKuOSMiIiIiqi0GZ2SUgEbO4v1RKw9B4PAZEREREVGtMDgjowzv3lTyOKugxEI9ISIiIiKqHxickVEc7e0Q7OUiPk65UWDB3hARERER2T4GZ2Q0mdL9whK5xfpBRERERFQfMDgjo7k4MikIEREREZGpMDgjoykHZzcLSgEAvx5Mw97zNy3VJSIiIiIim8XgjIz2wfDO1fc3JuLQpWxMW38Kz32fYMFeERERERHZJgZnZLTwFj64K9hTfPxLQpoFe0NEREREZNsYnFGtXMiqztK4/li6eJ91z4iIiIiIDMPgjGplUnRbjduZWp+IiIiIyDAMzqhWxvVrpXH7fYt2o6Sc6fWJiIiIiPTF4IxqxcHeDs193TTuKyhmen0iIiIiIn0xOKNae65Pc43bi8sVddwTIqC4TI6Ei7dQLuf5R0RERLaFwRnV2ot3h2rcnltUhieWxuOL7efruEfUkL265iieXHYAi3neERERkY1hcEa15mBvhxOzBqtt//VQGg5eysai7ecs0CtqqLafvQEAWL3/kmU7QkRERGQgBmdkEp6uDmrbfoi/bIGeEBERERHZJgZnZBIymQyp8x6wdDeIiIiIiGwWgzMyGZlMZukuEBERERHZLAZnZFIPdg3WuF0QhDruCRERERGRbWFwRia1cEQ3jdufXHagjntCRERERGRbGJyRSbk42uO+joFq2w+mZqOUdc+IiIiIiLRicEYmt/BxzaNnd0rlddwTIiIiIiLbweCMTM7LzVHj9jtlDM6IiIiIiLRhcEZmsfOtAWrbikrL674jREREREQ2gsEZmUWon7vatiJOayQiIiIi0orBGZnNuvGRksfFnNZIRERERKSVTQRnly5dwpgxYxAaGgpXV1e0bt0as2fPRmlpqdgmLi4Ow4YNQ3BwMNzd3REWFoaff/5ZcpxVq1ZBJpNJbi4uLpI2giBg1qxZCA4OhqurK6Kjo3H+/Pk6eZ/1Ta+WvujazEt8nFNUZsHeEBERERFZN5sIzpKSkqBQKPDdd9/hzJkzWLRoEZYuXYp3331XbLN//3507doVf/zxB06ePInRo0dj5MiR2Lhxo+RYnp6euH79uni7fPmyZP/8+fOxZMkSLF26FAkJCXB3d0dMTAyKi4vr5L3WNx7ODuL9v09cw62CEgv2hoiIiIjIeskEQRAs3QljLFiwAN9++y0uXryotc3QoUMRGBiIFStWAKgYOZs0aRJycnI0thcEAU2aNMGUKVPw1ltvAQByc3MRGBiIVatW4amnntKrb3l5efDy8kJubi48PT0Ne2P1zDP/O4D9F25Jtl36ZKiFekMNQctpmwAAjZwdcOr9GAv3hoiIiBo6Q2IDmxg50yQ3Nxe+vr4GtykoKECLFi0QEhKCYcOG4cyZM+K+1NRUZGRkIDo6Wtzm5eWFiIgIxMfHa32dkpIS5OXlSW5UoUtTL7VtyRn5FugJNTQ2+a0TERERNWg2GZylpKTgyy+/xMsvv6y1zW+//YZDhw5h9OjR4rb27dtjxYoV+Ouvv/DTTz9BoVAgKioKV69eBQBkZGQAAAIDAyXHCgwMFPdpMm/ePHh5eYm3kJCQ2ry9euWN6LZoH9hIsi1m8W4L9YaIiIiIyHpZNDibNm2aWoIO1VtSUpLkOenp6RgyZAhGjBiBsWPHajzuzp07MXr0aPzvf/9Dp06dxO2RkZEYOXIkwsLC0L9/f6xfvx7+/v747rvvavU+pk+fjtzcXPF25cqVWh2vPnFzcsCHj3TWur+0XFGHvaGGRGbpDhAREREZyKHmJuYzZcoUjBo1SmebVq1aifevXbuGgQMHIioqCsuWLdPYfteuXXjooYewaNEijBw5UuexHR0d0b17d6SkpAAAgoKCAACZmZkIDg4W22VmZiIsLEzrcZydneHs7KzztRoyHzdHjdsvZhVg8KLdeK5PC8x5uJPGNkREREREDYVFgzN/f3/4+/vr1TY9PR0DBw5EeHg4Vq5cCTs79UG/uLg4PPjgg/j0008xbty4Go8pl8tx6tQpPPDAAwCA0NBQBAUFITY2VgzG8vLykJCQgAkTJuj/xkjC281J4/avdqSgXCFg1f5LDM7I5LjmjIiIiGyNRYMzfaWnp2PAgAFo0aIFFi5ciKysLHFf1WjXzp078eCDD+KNN97AY489Jq4Rc3JyEpOCzJ07F3369EGbNm2Qk5ODBQsW4PLly3jppZcAADKZDJMmTcKHH36Itm3bIjQ0FDNnzkSTJk0wfPjwun3T9Yi3q+aRMzs7TjwjIiIiIqpiE8HZtm3bkJKSgpSUFDRr1kyyr6oSwOrVq1FUVIR58+Zh3rx54v7+/fsjLi4OAHD79m2MHTsWGRkZ8PHxQXh4OPbv34+OHTuK7adOnYrCwkKMGzcOOTk56Nu3L7Zs2aJWrJr052Bvh7AQbxy/kiNuEwQBjM3InHh6ERERka2x2Tpn1ox1ztSVlivQbsa/4uP90+7FlzvO45eDFclTWPuMTIV1zoiIiMiaNIg6Z2RbnBykp9rXO1NgJ6se25ix4RQOXLyl+jQRv0MgQ/GMISIiIlvD4IzqTHNfN/G+XCGgXF59+fzTgTQ8teyAxucVl8kxcGEcJv16zOx9JCIiIiKyFAZnVGd+filCvP/roStYe1i9Hty1nDuQK6RjHtsSM3HpVhE2HL9m9j5S/cE1Z0RERGRrGJxRnQnxdcMDXYJ0ton6ZAfG/3REsk3BKY1ERERE1AAwOKM6lV1YWmObbYmZddATqu8Y0hMREZGtYXBGdWrG0I41N1LBgTMiIiIiaggYnFGd6tzUy6D2JeVytTVoRPrgmjMiIiKyNTZRhJoapqLScvT5OBZ5xeWW7grZIIb0REREZGs4ckZW69Cl2wzMiIiIiKjBYHBGdW7hiG6w02POmYOGRgpOcSSyGbl3ynAt546lu0FERGQzGJxRnXs8vBnOfjCkxnb2GoIzObODkJ645szyur2/FVGf7MCN/GJLd4WIiMgmMDgji3B2sK+xjaO9huCMI2ekJ54p1uN0eq6lu0BERGQTGJyRxXz7bA+t+55edgCaxj5YkJrI9vC/LRERkX4YnJHF3N8lGG0CPDTui794Cz/GX1LbzpEzIiIiIqqvGJyRRT3SvanWfRuOX1PbplDUfEyBX9MTuOaMiIiIbA+DM7Kosf1a4d4OAXq3rykhSHGZHNGf78Lb607Utmtk4xiiExERka1hcEYW5eRghxWjeuH1e9vo1X7q7yeQW1Smdf9/ZzJwIasQ645cNVUXiaiWZBzGJCIi0guDM7IKkwe316vd9rM3MP6nI1r3fxt3wVRdIiIiIiKqUwzOyGr89nKkXu3iL97CW+tO4Fxmvtq+pAz1bdQwcbCGiIiIbA2DM7IavUN9sfOtAXq1/f3IVQxetBt/HU83b6fIZnHNGREREdkaBmdkVUL93A1q/8avx/Hun6eQrGHEjFkbiawD/ysSERHph8EZWZ0fx/Q2qP2ahDTELN6N2X+dlmwvk/OKkIiIiIhsB4Mzsjr92vojdd4DBj9vdfxlyeOScrmpukREREREZHYMzsgqyWQyNHZ3qtUxvth+3kS9ISIiIiIyPwdLd4BIG2eH2n13sHxvKpp4u+Kedv5oE+Bhol4REREREZkHR87IaoX4utX6GHM3JiL6810m6A0RERERkXkxOCOrtXBEN8njRi4c6CUiIiKi+ovBGVmtEF83RN8VKD7+9tlwC/aGrMGlm4VYtO0ccopKLd0VIiIiIpPjUARZNeXRsvziMgv2xLwOX8rG7nNZePXetnCq5Vq7+mzokj0oLJUj5UYBvn62h6W7Q3pinTMiIiL98CqQrNqwsCYAgGY+rvBydZTs+3B45zrpQ2m5QmNB6693pmDq7yfEfVn5Jbiee8eo13h8aTyW7EjBD/GXatPVeq+wtKI8wuHL2RbuCREREZHpceSMrNqA9gH485UotPLzgKerA16/tw2OpN3G5PvaIy270OyvX1hSjsh5sejYxBO/jouU7FvwXzIA4MlezdGjuTd6fbQdAHBqzmA0cnFUO5Y+zmcW1K7DRFZC0xcaREREpBuDM7J63Zv7iPcnD24v3k/PMWyUShAEyGQyvdvvOZ+FQ5duI6+4HAcuah+pKSmTQ66ovhA9ez0fvUN9DepbFQUvaKme4KlMRERkOAZnZLMMSQrRctom8f6Fjx+AvZ3uIO1KdhGe//6g3scvVwrOMvOK9X6eKgUvaKme4KlMRERkOK45I5sV6Oli1PNOXM2psU1No3LKI2WQSR/n1SJxCaeC2badyTdw9nqepbthFXguk7X6asd5PPO/Aygpl1u6K0REahickc26765APNqjqcHPK5fXfNHoaK97ZK1coRDvyyCTjJzVhpwXtDbrXGY+Rq88hPu/2GPprlgFnslkrRZuPYf9F27hr+PXLN0VIiI1DM7IZtnZyTCmb6jBz5PrEUg52Kn/11B+nvJ9mQxQmCg447RG25Vyg8lclPF7BrJ2JWUcOSMi68PgjGxamYZRsD6tdCfjePp/B9By2iYkXstDYUk5dp/LQplcIWljpyFxiPJomfJImUzlcW0CLF0JQYpKy7Hu8BVkF6qvtZMrBIxeeRCf/Jtk/IsTmZDAsTMiIiKD2URwdunSJYwZMwahoaFwdXVF69atMXv2bJSWlkrayGQytduBAwckx1q3bh06dOgAFxcXdOnSBZs3b5bsFwQBs2bNQnBwMFxdXREdHY3z58/Xyfskw3Vu4okuTb0Q3sIHgzsG4tdxffDruEgsfa7mAsUPLNmDiWuOYuSKg1i4NRk7kjJxq6AEgDQQq6I8HVL5vkwmk46qydWfqy9d63Rm/3UGb/9+EiNXJKjt25dyEzuTs7B01wWjX5tqp4YcMw0OR86IiIgMZxPZGpOSkqBQKPDdd9+hTZs2OH36NMaOHYvCwkIsXLhQ0nb79u3o1KmT+Lhx48bi/f379+Ppp5/GvHnz8OCDD2LNmjUYPnw4jh49is6dKwoaz58/H0uWLMHq1asRGhqKmTNnIiYmBomJiXBxMS4BBZmPg70d/n71brUU+UM6B+O3lyPxxHfxOp8fl5wFAPhu10V8t+simnq7Yt+0ezVOfVQeHYu/cEu8LwiCZK1YfnG5Ue8FADTEhKKNJ68DAE6nSxNOJFy8hZEr9M8sSebC6IzIlvD7AyKyRjYRnA0ZMgRDhgwRH7dq1QrJycn49ttv1YKzxo0bIygoSONxvvjiCwwZMgRvv/02AOCDDz7Atm3b8NVXX2Hp0qUQBAGLFy/GjBkzMGzYMADADz/8gMDAQGzYsAFPPfWUmd4h1Ya22mXG1BqrytKoKcFHudKI2MQ1R8X7coUAudJI2mfbzmHV/kt4oEswPhje2aDX1zWtUVuJtieXHdC8g+qUASX0iIiIiDSyiWmNmuTm5sLXV/3i++GHH0ZAQAD69u2Lv//+W7IvPj4e0dHRkm0xMTGIj68YXUlNTUVGRoakjZeXFyIiIsQ2mpSUlCAvL09yI9umaeRMWyKRFfsu4diV25JttwpL8eOBywa/LhOC2C7GZlKc1khERGQ4mwzOUlJS8OWXX+Lll18Wt3l4eOCzzz7DunXrsGnTJvTt2xfDhw+XBGgZGRkIDAyUHCswMBAZGRni/qpt2tpoMm/ePHh5eYm3kJCQWr9HMo0/X4nC2zHtMTKyhd7PmftPolqCEAAo0xI5bT+biTd+PW5sFyV0jZyRddM2gttQMSGI6RWXyXHkcrZeGWepZvx1SzX5Ji4Fo1ce1HhNQGQuFp3WOG3aNHz66ac625w9exYdOnQQH6enp2PIkCEYMWIExo4dK2738/PD5MmTxce9evXCtWvXsGDBAjz88MOm77yS6dOnS147Ly+PAZqV6N7cB92b+wAA7m7jh5d/PFLjc1bsS0VadpHadrke9dFqS+e0RrO/OtWG8s9HEIQGH6zxwtf0Xv7xCHady8LUIe3xyoA2lu4OUb03f0syAGDjyWt4pHszC/eGGgqLBmdTpkzBqFGjdLZp1aqVeP/atWsYOHAgoqKisGzZshqPHxERgW3btomPg4KCkJmZKWmTmZkprlGr+jczMxPBwcGSNmFhYVpfx9nZGc7OzjX2hyyrY7Cn3m23n81U27bvwk00b9wcl28V6n2cMrkCjvb6D1Dr+kK8lN/cWTXlWEwhADXUMa/3BC33yXi7zlUkMFq9/xKDMxPQlR3XlqxJSMPyPRex+sXeCPF1s3R36qXaJPoiMpRFpzX6+/ujQ4cOOm9OTk4AKkbMBgwYgPDwcKxcuRJ2GooEqzp+/LgkyIqMjERsbKykzbZt2xAZGQkACA0NRVBQkKRNXl4eEhISxDZku0J83bDmpQijnz99/SkAQP8FcXo/54vt6mUY5AoB5zLzNV4YaLtYuJBVoLGmm+Z+nkRecZnefSTTUA7OOO2s/lz4WiOeXqTs3T9P4eLNQvFvFJmevn9/iUzBJrI1VgVmLVq0wMKFC5GVlSXuqxrtWr16NZycnNC9e3cAwPr167FixQosX75cbPvGG2+gf//++OyzzzB06FD8+uuvOHz4sDgKJ5PJMGnSJHz44Ydo27atmEq/SZMmGD58eN29YTKbqDZ+tXq+oUHP6v2X8FZMe8m2uf+cwer4y5h8Xzu8PqgtFJIC1pr/AHy9I0Xv1/zl4BW0C2yE0XeHGtRXADhw8RZuFpTgwa5NDH5uQydTmtjItYMcLTMnBaMz0uBaZbZhMj25rjo3RCZmE8HZtm3bkJKSgpSUFDRrJp3zq/zt7AcffIDLly/DwcEBHTp0wNq1a/H444+L+6OiorBmzRrMmDED7777Ltq2bYsNGzaINc4AYOrUqSgsLMS4ceOQk5ODvn37YsuWLaxxVo90a+aFE1dzjXruyr2XDGqvKSX/6viKLI6fbzuH1we1lbTR9vvfxcnesNc18lu+pyrT8ncM9kQrfw+dba/eLsLOpBt4PDwErgb2r16STGvkxTM/AvPh+WUa9e1TvFlQYuku1FscOaO6ZBPZGkeNGgVBEDTeqrzwwgtITExEYWEhcnNzkZCQIAnMqowYMQLJyckoKSnB6dOn8cADD0j2y2QyzJ07FxkZGSguLsb27dvRrl07s79HqjtrxvZBr5Y+Rj130fZzBrW/UybHktjzSLymvbyC8hS4+Iu3cC4zX62Nm6NhwY+zY+3+a2fkFtfY5oEv9mDmX2fw2dbkWr1WfaG8xIzTGsmceHqRJnlcF2U2xn7hSWQMmwjOiEzJ3dkB68ZHYd6jXerk9T7fdg6v/XJUbbtd5dX8898nSLZ/8m+SWtu6GJlSniplZ1dzNouqC4G9KTfN1idbkJVfgn9PXZeMZvDiGVqHJb7emYK/jqfXbV/qGY6cmQY/RtJXOac1Uh2yiWmNRObg71Fzhk17OxmWPheOP49dxeZT2mvd1eRClnqGRzuZDIUl5Th8WVrA2lFDmj8XA0fOTuo5bbO0XIGz1/PQuamX5I+PXQNPA2+IoUv24EZ+Cfq1rV7PaOiaoMKScmw5nYFBdwXA283J1F20CE11zk5ezcGC/ypGWoeFNa3rLtUbDCqI6hanNVJd4sgZNVidmlan1n99UFuNbfZMHYj7OgYi9uyNWr/e5LXHkZVfvSbATiZDUob6dEdfd/Wg0UGPkSxlvx+5qle7qb+fwLCv92HprgsoLa8OzgzI/m9yBy7ewuu/HJN8VtbsRmU/95yvHkGUG3j1PH39KUxZdwLjfqi5Dp+t0PQR3CosrfuO1ENyhYDbhaX4If4SbvMzJTK7cpayoTrE4IwarGAvV2x+vR/ip9+Lyfe1w2cjugEAxvYLhZ0MeKBLEJp4uwIASsrVfzFPHdJebZsu64+l44ONieJjmQxIvK6+vmzjyWsmSUOuzzE2HL8GAPhyx3mVbwZlmPzbcSyJVS8FoP46xvZQs6eWHcDfJ65h1l+ntbaRQYbiMrkkoLQmhk47+/tExc/h4KVsc3THIiR1zio/D47HmoZCEPDqL0cx668zGP9T/Qno6xrHQkhfmpJ7EZkLgzNq0Do28USwV0UA9lh4M5yaMxjvDe2Ik3Ni8NXTPcR23Zt7qz13Qv/WatvaBOjOcFh1EQ5UBHw38tQTb+QXl0vaAeojMVeyizBk8W6dI2QpNwqwbPcF5GtI/19YUo4r2UXi49JyBcqUvhk8evk21h9Nx+fbDEuAYkpXbhdp3VdcLkfXOVsxcGFc3XXIAFyeoPnLARmny5qEIAD7Um4BABJSjQ/oU28WIv7CLVN1i6je4pozqksMzoiUNHJxBAB4ODtIkmIseLyrWltNF5qujvawN2AKoraU/gdTs/H6L8fw1LJ45BSVYvmeVMn+uRsTkZSRj7fWndB67PsW7cbHm5Pw/j+Javv6L9iJfvN3io8VAiSjUPkl1Vm/oubF4tJN9TVzVTStLTK3nKIylMoVSM+5o3WEsKCkHEWllsleZui0xvqIn4D5mCohyMCFcXj6fwc0Tq+ur1gcvWG7VVCCDzcmasyKrAuzNVJdYnBGpIdmPm56tXNxtMPjPZrV3LDS7nNZGrf/nJCGv09cw4GL2Qibuw3ZKutKDhrwbfk+DdkUbxaor1MpVRo523qmOvnJtdxivP/PGb1fr67pmm3y3a6Leh/nr+PpGP/jEZMEdCwSLJ3uWnW3NuNm38Sl4O5PdrDQLkyfrTFJw/Tq+kpyXjJQa3CmrT+F5XtTMXjRboOex1OF6hKDMyI9ODvo91+lfzt/zH64IxY83hVvaEkyYgq5d9SnKmojA3A6PRfP/O8ATl7N0dpOeX1ZUob0Yk3XfHu5QsDolQfx4Ub1Ebq6oGu6yfVc/S/k3/j1OLacyVAbpTQGU51rpjzYbOiF8fwtyUjPuYPPtlpuqq21YOxvPP7fbNh0/Q3UxRIzRKjhYnBGpAfVKYy/jusDoHq646iolpj3aBdMGNAGbk4OGNEzBL7u1pESXSaT4allB7D/wi088V281nZ/Hb+mdZ/y9UxxmVyy70JWIXYmZ2H5Xu1Bzc2CEmw6eV2yrs1UdBV8trcz/Ffclewi/HU8HQUlxo+gzd+SjM2nrhv9/PpA+WJG0/WwsdfIvLim2jDn2bNyXyrikmuf2ZeIGjbWOSMy0ILHu6JPq8YAgBE9QzCkc5C4Vk2ZtUyZkckgBhrFZbULjraczsArPx/RWsBbEASNa/GeWBqPizcL8WZ0O7wRrf+IYk5RKbYlZuL+LsHwcNb860rXqJ5yzbi3153Atdw7+PHFCJ1FttcduYp1R67ivo6B+N/Innr3VdmmU9ex6dR1XPpkqFHPrxcE9QcypYmNCkGAnZ4THVNuVI/kWsv/K7JN5gruj1zOFtf3Nuj/90RUaxw5IzJQK39pRkZNgRkABHm51EV3aqQaKxmzHqpqFGT8T0egEIB3/jilsd2dMjlW77+EZJVpkRcrE4psPKl9dE6TcT8cwdu/n8T09ZpfDwDkOhZqKxfTXnfkKval3MLJdP0KdG9LzNS/o6RG+adSlVVU+Vw0JGnK8K/3m6hX1NCZK7a/nqueeZesj8zIla/W/p3QsbTb+O3QFUt3g0yEwRmRnv6YEIXPRnRDeAsfvdoP7hiEmE6BZu5Vza5kS9ddlZqxmObKfZcw++8ziFmsebG1IbViZJCJdb/+OaE9qNN1TE3Fuw2ZWqlQCJArBPxz4hqe/z5BLTELaad8MbO9soi78k8j747+00aVp5ia8xqpqLScyVzqOWlCEMv1g8iUHvlmP6b+cRL7NSQAI9vD4IxIT+EtfPBYuP6ZGO3sZHj/4c5q25+NaG7KbhnMmOBM34uYmrJIGhIY6bsAW9eas+V7U/HBxkTJVDhDUiI/tnQ/Bi/ahdd+OYY952/is63Jej+3oavp5zdwYZxZ1iAa63ruHXSc9R9eWHnQ0l0hMzLXtEZjR2RM8tosH2gWyn83bCWOv6Cj7A3ZDgZnRGYU5OWCD4Z1kmx7RiU42zN1IH54sTcmDlQvam0OJbVcd6aLrkAJME+tmL0pN5F4TXudpu/3puKOUhKTmvqo7FhaDi5kVf+xa0gjZ5tOXsesv06j3MgASuM1sNJFZEFJuUFZR3Ue1wQ2HKsYnd1znt8812eC5L6tXHLrpmmGANUeR1bJUpgQhMjMno9sidikG4hLrqhp1qmJFw69F41jabfR1McVIb5uCPF1Q4egRjidnoeHuzXB9PWnzDb90JjjXszS79u4mkZCdO2/XVgKHyMyXFYV4ta1CP92UXUQoCv1vjXQllSlrk1ccxQA0K2Zt0EjxlX0ua6xposfXuA2DPUx22fFqF39e1+WVh/PFbINHDkjqgNzH+6Mzk09seTp7gAA/0bOGNwpCJ2aeIltAjxdsPrF3ngsvBkS58aYrS+l5YYHJxl5xUi5UVBju5pGpbQFZ78duoLuH2zDN3EpBvdNH1/vrD7ujfwSo49TFzGTIQXG64Kxn5emrIqqU7+s6eLHwV79h7v1TAb+Op5ugd6QuZjrlLPo9yn8XsEsJKOs1vOrSqeTV3Is3QUyAQZnRHWgeWM3bHytHx7u1kSv9g725vuvaUxwBgBvrj1eY5uaEn5o2z/1j5MAKuqDmcOahLTq1/r9JC4ZOS9f9Q+0sQVNdZEkvxAEbEvMxLUc9WLaJeVyvLn2OH48cLnG9PJFpeXYcvo6ikqNr91mDoZMMTU31f9zcoWAcT8ewRu/HkdWLQL6+igpIw+/HEyzyeQpknVEttd9jRibmYc1fXmkr3VHrlrd73kyHIMzIis1//GuaBPgAXcnewDAo92b6h3cAUBTb1eN2w1NZ1/llB4p6I0dOdPE0Jpshlzob03MMOjY2jz+rfai3oCRZQsqn3IxqwC/Hb6CsT8cRtQnO9TarT10BX8eS8fMDafx8eazOo/59u8nMf6no+IUUIP6Y+R0KY2Fp1WOZUxwZq7LJUeVaY3KfcsrNnxtXH02ZPEeTF9/Cn/ryKJqLf46no77Pt8ljvybK540R4D076nrOJp2u+bXZnRmFpLMnjY0bTS/mMGZrWNwRmSlnugZgu2T++Pge9H4+9W78dkT3bDk6e6YMEC/xCGTtBR7/nKHeaYOAtLgS9OFd5lcwE8HLqOkXK62T5U+0yiVGbKWzKlylCTlRj5uFRg/KlLT+j1DanlVEQAkXsvDvZ/t0lpPDgBuFlQnJ/nfnlSdx9x08joAYPMpw4NSU355rHqsT7Ykme7gtWRvp33KZX2/9jX2wvO0njUDLemNX4/j/I0C8YsJW8nAl5yRjwk/H8Wj37DGn6Uo/77KMyJ5kaXY4IAfqWBwRmTl3J0d0LWZt5gkYvJ97fDby5FaExh4uTrijwmRcHG0r8tuApAGZFUZElWn3M3YcBpfbD+PG/mmLdpqSCZIZ0d7XL5ViOjPdyP8w+0Gv9a+lJuI+Ljm5+kaGZIrBKxJSMOFLGkQKggCdp3LMrhPp9NzMeGnI0g1Ysrm3H8S8eR38UZnZtRE48iZyraqoNGw45rnysNRaVqjvLK+XRVrSNACVH+pQIarmuql/F/SlKeSqU+Ry7f0/39syTT+tsaQn5Pylxbbz96wqtIfVL/xNz2RjXG0t0PvUF+1+fCt/Nwx7f4OODF7MMJb+MJXz8yHf02822R9O6802vXgkj0oLVfgvzOZau2+ibuA3h/FmjT5hSEFrp0d7HDoUvV0oaQM7an4NXl2eQIy82oecdMVnK09dAXv/nkK93+xR7JdIQAhvpqnpOry8Fd78e/pDIz/8YjBz12xLxUJqdliGnlNa9wMpWk0xprXcCiPnJWWK4wa9TQ3Z0fT/ckWJCODDefiXvm8NNf5aK4vELSxku8O6h3VX9+2MnpmS1MwSTMGZ0Q26qtneoj3Axo5Y8ukezC+f/WUx8YeNQdnh2dEo1uItzm6h0u3ihD9+S58vk17ko8nvovHzqQbJnk9Q0Z9nBzsJBdmY384bJI+qJJLkg9I/2DuOlfxvtUTtAj6pXVXOV7VhYTqSJwhyhUCzlzLlaxxM/ZCU/VpBSXlJrkYNtdlh/JnXipXSNYLmuLad93hK9iRpP5FhSFMORpuq+tpjFX1fiXv26RBVPVZYq7YzJQj29buyOXsWk05NwXV31fWMoJeEyv8XsmkbuQXY/yPR7DnvOEzTGwFgzMiG/VAl2Cc+/B+bHvzHvw58W44OUj/O/t5ONd4jKo2a16KELftmTrQZH1Myy7CuUzdwcLoVYf0OlZN61veqcz4qA+5QpBcmF3Jrv1IkcbXqZxqmZyRj4iPY/HTgcviPm2jFYKgeRQw7VYRNhxLF0fjtP39tatFvS6FIOC1NcfU+mMM1ae9ufa4VV802KmOnEmmNdbu2Kk3C/H27yfx4qrafQngYsqRM5MdybYoX3Ar1z80JVOMuqoGAnHJN3DXrC1Yd/iKelul+3U9amcOu89l4bFv49Fv/k6L9sNWP0ob7bbe5v6TiC1nMvD89wct3RWzYXBGZMOcHOzQNrCRxsyMfh7OmDqkvV7HiWrjh0ufDEXqvAcQ4uuGp3s3N3VXa+3BL/fq3L/97A3kFJXqbFOlXC6YLWubsqqLtJl/ncaN/BLM2HBa3KftQluA5umQ9yzYiUlrj2u8OFNWm1rKP8ZfxkWVNWvGfkyqF4nbEjM1jtB8qiEpiEIh4Pu9qTh1te4STih3t0wundaYeC0PQ5fswc5k40Z5TZWK39GEa84UJpzWeDA1G8v3XLTqwKCqZ8pd/H5vKk6YqC6UcixljumSL60+jDK5gLd/V/8SSjmQs+Ifgd6q/p8VldacOMqcVM/n2vxcC0vK8d+ZDNyp4/eUlV+C1345hv0Xbtbp65rTDT2WFNg6BmdE9dgrA9qgfzt/vdtX/ZH/cHhnxE7pb65umc2lW0V6tStXKOrkIuZC5Ro8TcGWtpdXCILO5CYJNazTszNwmEe5b3tTTPcHXNM70JRQ89u4C2rbjqbdxgcbE/HQV3uNqsuXnnPH4ClgyhdipeUKSV8n/HwUZ67lYfRK/UZ5VZlqNpShP1tdlC80jS6XUPnvE9/F48NNZxF71jRTlM1J9QJ72Nf7an3M3DtleFlprWddB0jKZ4U1r+vUl7WsgVT9KGtT1+/Ntcfx8o9H8N6f2jPwmory77I5f5/BPyeu4Zn/JZj9deuK6iyh+qj+v0OiBm7WQx3RzMcVgzsG6v0cezsZWvm5m7FX5jFczwutUrlg1EXMv6cz8Mg3+l/MPbnsAB75Zp/GDIraEpiUy4UaywJk5Bbjl4NpGvepBjNnrukefVJ+LU3X/qa81tP3M1eebnZbdTS0hkPsT7mJuz/ZYfCUF4WOkbPaMtW0M1NesprjGv6SARkG61rV526O9636BYMpAiSDftaSUbtav7TZFJWWY+W+VKTXkHDIWpZ2qf4ca/M7YWtixXrT9cfSa9UnfSh388pt/b6wtCWO9lZygpiRg6U7QETm1drfA3vfuRcAMOizOFzIqriA+vyJbjqfJ5PJsOn1viguU+Dk1Rwcv5KDv45Li85+OLwzTl3NxV8n0mssGu3p4oA8KymOOXPDaXQM9jTqucfSckzSXtvITkm5XGfmyT+PpSP+wi1JnTPJcVWeO3SJ9umgu85l4cONieJjN0d7FKpMuzFlEepxRmSSNHTk7MfKdX3xF28Z9DzlC7GScgVcHE0YnKlcPBt7bWHKkTPln4+xIxW2dokkCILJS3gA6kXKLRkgWfPI2cebz+KnA2n4ckcKjs68T2s7c55Xhhxb9ZPUlX3XmljzOWAKDWHkjMEZUQOy9c3+KCguh5ebo17tOzXxAgCEt/ABADzTuzlKyhUYuaJiVMLJ3g6fPt4VHz3SGW3e+1fnsV6IaikWwLaTqV/AtA3wkKTi10drf3cx2DRU4nXD0uebmrapi+/8cQrPRuhe85eRp98F5o0a2o1aeVByke7q5KAenBn9d974CwTli6BNp6S10GoKFmvqb2ZeMeZvScbIyBaSTKXKFzTf703Fn1q+4c69U4bDl7JxTzt/o9aAyRWCWsFrXXLvlOFcZj56tvAx6YiCKaY1qrL2bHZLYlOwaPs5kx9X9V2b4+JY10crHZk1+UubzO5zFdOmswt1rw2uTVKjmhjy8aj+HGuY0GA1FJIvXuofU669tVb1/x0SkcjeTqZ3YKZJRKvGuKedPwZ1CICTvR16hfoCABzs7fDNsz0Q1box1o7ro/G5T/QMweEZ0Tj/0f04/X4Mjql8c9qiseHTKK34OkSnQ5eyEaujhMDPCZqnLOrrRn4xisvkGKJSQw2ApJCq6oWcpiQlxicEMfKJkAZnn/yrnjBE5+vW0OP3/jyFP45eVVtrpNxfbYEZAIxccRBjVh/GV5VfNBjK0Av3YV/txYil8fj7xDXTjpxp2CZXCCgp1z9hgeoxrPlCUAC0Bma1WUsEqAdOgokv4muaCqscFNvKqMkBHSPbVnMeqXyU1lj7UBNbGeEzlhODMyIidd89H45D70UjVGld2gNdgrFmbB9EtGqMGUPvkrRv0dgNIb5u8PNwhqO9HdycHOCjUiR7zsMd0aWpF14d2AYxnarXxy16Ujr9cuLA1tBHt2Zehr6tOjNiabxZjz9/SzJu5JVo/IZ6+Z5U8b4+Izg5RaUoLpNesOcXl2Hd4SvI1ZGK3NjLg9oWgK7puuSilpFWfS9qq7L7/XH0qgG9Mv7iuSrJzT8nrptt5KzK8K/3oeeH2+s8o1yd0PGxT1xzVO/DlJTLcTo9V2cRb5OsOTNyHZmtBGdndcxcMOcIrCFHVv3cbSXokQTzVj6arcvp9Fz8dVz9i7KGMK2x/r9DIjI5B3s7nSNwL/VrhVNzBuPx8GYAgMn3tdPY7j6lJCXNfNzwz2t98VZMe3z3fE+08ndHI2cH3N85WPIcyRokHX8rv3kuHK8MaI3fx0fq8Y7qTl2kG79VUILcO5oDp+1nqwshq8Zmmrr2Q/xldJr9H64qLSyf+vtJvP37SUxccxRlcgViz2aqBWrGvM2NJ6+h3Yx/8ccRQwIfqZpeV9sfdkOvuwRB/5+l8vWRsRd4pj5vNI3unErPRX5xOY6l3dbrGKqXfbW9DpQrBHy6JQlxRpYsMNa/pzP0bvvKT0fx4Jd78UO8Us1Clfeta+TVGApB0LkuUPn/8fHKLw9KyxX49WAarmTbXkIIa4kn1KY12kjgayMxZI0e/HIv3vj1OBJURlk5rZGIyEiNXBzxyaNdEPfWAAwLa6qxzVfPdEdEqC9ev7eN2r7/Jt2DQzOi4eJojxGVQR4APNkrBIM6BAAAXuwbihWjemo8to+bI6YO6YCeLX3Rr62fCd6RfuYO64S972gv5K0tkYcp7UzOwkNfaU4EYq905aP6DbW2iw+5QkDfT3eitFyBTSevixeze1NuYmncBYxZfRjPfS9N1WzIOqaqqZavVhbA3nUuS+/n5t4pUxnZ0/26zlqDM8OuaNJz7iD8w+01ZsNUex0jp7wJ0B54fr3T8CmW+v58kjPyMe2Pk7hWQ4Y9Y129XYTBi3bhl4Np+P3IFXwbdwGjKksW3CoowcNf7cUP8ZfM8trGqJqOvHJf9Qi0aiwxVynJjinUdG4q/z+uylK6fO9FTFt/CoM+32XSvtQFTeU1LEHfhCBZ+SVWVePPVoJIfZ1TWYvuwGyNRETGc7C3Q0sdKfmdHeyx9mXNI1uO9nZwtK+4v2BEN8x7tAvKFQJcHO3x7XPhuJBVgA5BjSCTydAmwAMpKr/AleeluznZ1/7N6MHHzREjI1vqbNPro+110hdt7Co/li2nM9QyIdaUGbGwpFxtCljV9L5T6dIgxZDrg+Iyud7fhiofN+VGAaI/3wX/Rs449F60Xq/r7KDlXDDieia7sBTv/HESG1/rp7Od8qWEsVM2BUF7OLXgv2RMHKj+BYcuqteZquuujqbdxpFLt/HR5rMAgOTMfPz5yt3SPqkc05hLpnmbk3AuswDT15/C+P7SKctf7kjByau5OHk1t8b/V5Zkjml4yoc05pTZU5l8w5g6gZZ0Ot2wLzvMSXUEX1NwtvHkNby65hiejWiOjx7pUldd00m5n/UxjDHl2ltrxZEzIrIJDvZ2cKmM1pwc7HBXsKd4UaRpQb+D0sW+q2PdBGeqmQ6tkb2dDMVlcoz/ST2t/a0asqiVakj/ryvtv76KyxT47fAVg56zfM9FRFeOCmTll4jTt2rqjbNS0pOnlsXjZkEJAOO/bVb9SApLyrEmIU08rnp7415HYcA0Sn0oH0sQ1H+Oj36zXwzMAO0lIWrbp6LS6vIaqoGE8r7asuWxhJrOTU0/A1tJXqFK23RsUzEkkP58mzSBjKafw/wtyQBqn8RJH+VyBc5n5qv9vNUfm70rFlX/QzMGZ0RUD9QUILg6VU8SaNnYTbLP24jslY+HN8OXT3dX296vTfX0ydc0TNXUZfTdLTEpuq3BfTHUvpRb2KEjU6Qumr6Fv3pbOt1NEAR8vjUZWwxYx7P9bCam/n5Sr7ZVFx4fbjor2f789wn4emcKTl7N0fl85WmNBy5m47OtFRdgxsaYqhcK7/15Cu/+eQqv/Fw9wqh8UWdsEGjq6y3l91sRnNU8wqK6OF8Gw4PNM9c0L/IHgFK59MuNqmQopmDOaWfm/iJfIUDnFammH4E1TbOrUtvRQEsz1VqujzYlIv6CYXUYAWD8T0dx36Ld+EklEFT9LE0xrfHHA5cx/scj1jHyquP9WON5bgoMzojI5r0Q1VLnfuWRs79f6yvZ5+2qOzgb3781Dr47CI5K89xlABq5SGeFvx3THvMf7yo+nhTdDn++EoWVo3rpPL6HswPejmmP2Q91wuCOQTrb6tKzshadPpQDB0P8d0Z3wPXfmQy8sPIQluxIwRex5/U+7vT1p/Rum1dcpnGk9NKtIiz4L7nGNX3bz0oD09uVo4WmCpo2VBZqP5iaLW5T7m5tEoKY8jpEMnIGoExL3T1ls/8+o7ZN+YsRfUYlhi6pWOS/9/xNtX1l5dI+KH+G1szYIt76HtOYkbP6khTCmlT9380vLsNDX+7FVzv0/x2n7H97UvH0/w4Y9Jys/BIxmdNSlTV5uhKXGPvFwcwNp7HlTIaBWWnrhikSLFk7mwjOLl26hDFjxiA0NBSurq5o3bo1Zs+ejdLS6j/Cc+bMgUwmU7u5u1evd1m1apXafhcXF8lrCYKAWbNmITg4GK6uroiOjsb588b9BySiujFKJThTHYFqE+Ah3vd0kQZjT/ZqjrcGt8Oq0dVB1A8v9hbvh4V4I8DTBbunVif5aB/USK3WysSBbdDYw1l8bG8nQ/fmPhjYIQCn34/R2vfVL/YS1wt5OBu/DPibZ3vg7Zj2Rj9fH6qjVape/vEIdhuQzMMY+y/cQqt3N+vdPjOvGC+uOoSdSTckNd5UmfMbWOVg0vjgzLQL/ZWPpBAEvfqlGhQLMP5CUHWNIgCdPx+dx7qaq7Osg7mZfeRMIeg+dzVsqy8XrbWtQWdKVef6jwcu41R6LhZuNX1Bc23+PX1drR9VVD8hU/6eyLHg/yuRyn8waV2/uu5M3bCJhCBJSUlQKBT47rvv0KZNG5w+fRpjx45FYWEhFi5cCAB46623MH78eMnzBg0ahF69pN9ae3p6Ijk5WXys+k3f/PnzsWTJEqxevRqhoaGYOXMmYmJikJiYqBbIEZF1sLeTYeub9+B/uy/ijei2aOYjnbr4RM9mSMsuQmTrxpLtTb1d8UJUC7g5SX8Vtg7wwJ+vROH0tTyx5lqwlyv+fCUKu85lYWRkyxqnzynTFXQFNKr+veLmXD3CN2PoXTUGQ8oc7O0Q6MnfUao+3nwWO5JuYEfSDZyYPVhtf1WaDVP/kVdO2a98bEMunASV6ZA1PXPhf8kokysw/YG7amgp7YcgCChXuvg3ZL2SsWsONU2X0rSmsSb7L9zEM/9LQGN3JxxRKWyvrKZeKhQCvtt9Ed2be6NPq8Y1tJYyR2ym/NN+YeUhjaOmhSXlcHOyV9t3LO02LmQVqD/BBh2/moMezfWfFWBOVQGvJeoAKp9jasGZ2rRGzc8zhtzY9LJmpOuzqC9sIjgbMmQIhgwZIj5u1aoVkpOT8e2334rBmYeHBzw8qr8dP3HiBBITE7F06VLJsWQyGYKCNE8dEgQBixcvxowZMzBs2DAAwA8//IDAwEBs2LABTz31lKnfGhGZSLvARlgwopvGfQ72dph2fwfx8RdPheHI5duY/VAnSSHmHVP6I+dOGZp6u6Kptyu6q1wUdG/uI24LC/GGk4MdSssVaO2vPSNlTUJ8qwNJ5SCufVAjfDaiG6asO6HXcRzsZegY7Gl0P+or5cQcmi6q/juTibRbRcZPa9TyPHuZ5mlpH28+iymD26NdYCNJ+3OZ+fDzcIZvZXH2LaczJElbaqqrll9chq8qU+qPu6eVZBRXU5+vZN9ReiwNssq1THFU/TJTBkCu1FbXhWC5XIElSlNdq9aXKb+SIWshC0vK4e7sgK1nKqZ61ZTMpqYf78ZT1/HpliQAwKVPhurdD8D8I2dVhc+VHb6UjRdWHERMpyC18+KRb/ZLHl/PvYNgL1dzdtFsHv1mv8E/D3M5eTUHJ67kGPUlQm0p/9+raY2ZKUcbTZHwqdZU37CkQLsV9M8MbCI40yQ3Nxe+vr5a9y9fvhzt2rVDv37SFMcFBQVo0aIFFAoFevTogY8//hidOnUCAKSmpiIjIwPR0dFiey8vL0RERCA+Pl5rcFZSUoKSkuoLgLy8vNq8NSIys2FhTTXWXmvl76GhtWYO9nY49+H9SM+5Az8PJ5P0SzlZhaujPR4LbwaFIOBtPZJlONnboWMTT/xvZE+M/eGwSfpj6zafug4XpdT52rL/vbH2GB7s2sSkr32nsvbahmPpmPXXaXH7f2cy8d+ZTMkF55XsIgxetBsezg44XFnbTzWbZvxF3QkETl2tniao6XqqKotkTKcg/JRwGct2X5S0Vw7ISso1jwzIZOpr1ZQv3nRdx/12+CqW7Kiux1ZSpn6BW1TDiERc8g1cvlWEDkGN8OSyAxjTN9RkgdHrvxwT7ysUAo6m3UanJl5wraEMxx9HrmLlvkum6YQBXl1zDIWlcqzXo+B15LwdFgtwyuQKLPgvGRGh2q/XlFnztfbHmyuCd/9G2r/4MBeZAQGJKTN1avuixpKU12PWl+m7qmxizZmqlJQUfPnll3j55Zc17i8uLsbPP/+MMWPGSLa3b98eK1aswF9//YWffvoJCoUCUVFRuHq1YsFjRkbFYvfAwEDJ8wIDA8V9msybNw9eXl7iLSQkpDZvj4hsSFNvV+21swwkk8kwMrIFBrT3F0foRvQMwcbX+mLHlP6Stne3kU69cqgcAbyvY6CkrpuXqyNGhDeDnYaL2I8f6YIPhnWSbHs7pj3Wjddce87WvPLzUWQXVY+oaLv4T7qunp7aFFJu5GPS2uPIK9adEj69ssBzQUm5WvZLfSknYMkpKlUrjt1p9n/4aPNZ3P/FbklgBlRc7JUpTV8qLNEeJClfC32/NxUHlILG2X+f0fo5Xs4ulDwuqSELnOpxMvOKMWrlIcz++wyeqkym8P3eVJ3HMNaq/Zfw+NJ4vKyh3ESVqpGMKetOmGV0oabZZBl5xSZ/TXNYGncBy3ZfxJjV0i+MNH1iWfkl+HaX4QXV61pWvuYyGeakHJDcLChVm/KsTPlhbWvwWcXImdqas+r71tA9c7BocDZt2jSNSTyUb0lJSZLnpKenY8iQIRgxYgTGjh2r8bh//vkn8vPz8cILL0i2R0ZGYuTIkQgLC0P//v2xfv16+Pv747vvvqvV+5g+fTpyc3PF25UrhtXrIaL6b9GT3TC0a7Bk2+bX1YsXzx3WGatG95ZMt+zc1EsyqrdwRDf8/FIfyfOU24eFeIv3974zEAtGdMPFeerfnN/XMRDPR7bE831aAAA+G9ENEwe2MSjzo7J3hnSouVGlxpXT92Y+2LHGtgtHdMNTvYz70ku5Ppe2GkrlCoVZpsdoqw0GVAdkgHT91c8Jl416rQSlzIb3LdqNoUv2islZlC/kNNXiEyD9BlrXVFrVb6pfUxpxAqpLKxxMzcbdn+xAbGWGuf0p0pG/Hw9cRkGJ9qC17Xv/Sh4/vaw6u53k4lPPVTWqK/YGtvfX2nbFvoqgT1dyG0EQzJqsor5M19ql9Bnqekt7zmeh10fbsS9FfYS43ALTCHVRTgaVli0t96BQCDidnmvyPqvGWKqlMKT7NE81vqWl9qIudb3mrFyuwOVbhTrbKE9Pt6aEMaZk0eBsypQpOHv2rM5bq1atxPbXrl3DwIEDERUVhWXLlmk97vLly/Hggw+qjYCpcnR0RPfu3ZGSUvFNTdVatMzMTEm7zMxMrevUAMDZ2Rmenp6SGxGRske6N8PXz/TAEz2bids6NjHsd8XBdwdhy6R+eDy84hhj+oaK+5S/IV30ZBhGRbXE9sn90chFe6mAqnIAc4d1wr5p9+KxyuNWjeAZ4rk+zfFMRHON++7SsBZu99SB2DftXsl70OSedv54sGswPn6ki0H90eTZ5Qkat5fJBezRkNpdH0kZ+biWo3m0q7hM+wjUU8vixfvKwZkpp8j9nHAZF7IKakyTLwi6swFWkUH/oGHUyoNIz7kjjphoys64eNs5raGV6jf2F29qvmAzdmDAwV775Y++o5dlZrxwNeclZ021q6b8dgLPf59gkgtfbTX+PtiYiKW7qlPCP//9Qa3HsMQaL1109eebuBQ8+OVeTP1Dv7qN+lI9zeUK7SNn2n5sq+MN/+JHnxIbpvTyj0fQf0EcNp68Vr1R5f2t2n9JvG+rxdZrYtHgzN/fHx06dNB5c3Kq+HY1PT0dAwYMQHh4OFauXAk7O81dT01Nxc6dO9WmNGoil8tx6tQpBAdXfJsdGhqKoKAgxMbGim3y8vKQkJCAyMj6Mc2HiCxLV6KGmgR4uqBDUHWg80ZlyQA3lXUxgZ4umPNwJ0kJAaBipEyZS2X9N5lMhqbe2hMGKK+F0+bD4V3g6aJ5GbPyhYWroz3mDusEd2cH8TXfGKS5+La9nQw/vNgbLo72sLOT4bEezTS2MwVjgzMAGPvDYSRey1MbVbqjIzi7kn0HyRn5AIxPIV+T/85kYtBnu3CihsyiCoWg19qS20VlWL7nos42VUFVTevHACBVS8BlDqrXcKqlMIxhzvUuuqbZGjMCUmX+liTcNWsLEq9pXxv/x9Gr2HP+Js5mmHb9vOpb+uTfJM0NVdRlIeTfDl8RR3uN8WXlusr1R2teC2gI1S8h9qXcxMCFcdh86joeWLJHsk9bUK3P1G1BECRF4ut6TVdsZVKg5Xv0m7JcX0aYVdnEmrOqwKx58+ZYuHAhsrKykJGRoXEd2IoVKxAcHIz7779fbd/cuXOxdetWXLx4EUePHsVzzz2Hy5cv46WXXgJQcYEyadIkfPjhh/j7779x6tQpjBw5Ek2aNMHw4cPN/TaJqAGYMKA1+rX1wwKlgtXG8nRxxPFZ9+HIDO0pxJUtez4ccW8N0KvtU70qRsFkMmBnDc95qFuTyraahzGUN59+PwYjI1tK9r8+qC3uCvZUCyZVLwxU69dZizPX8vDAkj2SkQAAKNaQ9EJZzOLdAMw/MnDhhu606l/uSNF7bUlNtZ0MuZCOTbqBncm1q4unfMYt33NR73pnykXljaXrM6vtqJOup4d/uN3o434TdwFyhYD5/2kOjJT7PX9LMm7km25tm6YLaX0ChroKzi7dLMTU30+qrY+zBqrTd0evOoTUm4V45eejksyrgPaARRCAQ5eysS9F+xdRW05n4I1fj4uPNZ3jJeVys081lbyqjuFxK8z0bxI2ka1x27ZtSElJQUpKCpo1k35zKlkUqVBg1apVGDVqFOzt1Rfo3759G2PHjkVGRgZ8fHwQHh6O/fv3o2PH6jUPU6dORWFhIcaNG4ecnBz07dsXW7ZsYY0zIjIJTxdH/DgmwmTH83bTP1OkTCZDSz93xL01AJ6u2qc7AhVTLg/PiIa3qyMc7O1wfNZ9SL1ZiD3nb2LCgNaSNUGfPKp7yuGchzthxNJ4vD6orWRtXBV7Oxn+faNi/V1c8g2MWnkIAMQac7ZiwX/Jkse6Rs6qyBWCWnKM67nGJQXR5v1/EnXuv1VYivf+PGWS1yopl9dpQWjl67YPN53FwdRsLBvZE4Ul5ShUys6per3a1Kf2qeWPXr6tdV+5QoCThnP9Rl4xnvrfATzZMwQv92+t8blfxp7H0TTtxzbG/C1JmKq0JtROywWv8sX4rnNZePXnY/hNJUHQvpSbcHWy16v+mPLHrmkUprhMUWNGzJqSx9RWmVyBzaeuS343mbMovVEM+C5BW2BfrhAwYmnFdOpjM++Dj7v6345jKmUbVNecFZfJEfFxLAI9nbH1TWmSKlPS9OXGjfxiTPlNuh62vo6c2URwNmrUKIwaNarGdnZ2djqTcSxatAiLFi3SeQyZTIa5c+di7ty5hnaTiMgmtPTTry6bn9IUTG83J3Rv7iRmkezWzAsnrubi08e6wF2pPpuTvZ04EvTL2D5o0dgNTbxdkfTBEHEapS4D2gfg+Kz78O/pDDzQRZpApZmPK6JaN8b+C9VJA5p6u0qSayhT7ou+Hu3RFCXlCmw6eV1t32M9muGPo1f1PlaRjoQXVbILS9VGBsb/qD1LoLLT78dg8trj2JqoexqWPkFiUuUUy9oqLlMgr1ganCXUUAbAlKo+i8h5sZIsmarlAVRHabXJzCtGYUm5WpkNmUwmfomgya3CErXaYsVlcvT+uGLZxLx/k/Bi31A4qkyvPJZ2G59t0z06aYxv4i7oFZypBlAHL2VLHmfll4hrNw1Nz68paMgvKat1cLb+6FUUlsrFxEaGWrE3FfNUplhaW4p2bT8vTZRLhig/Tfn3zO2iUo3BmSrV6c7JGfnIvVOG3DtluFVQAicHO53rmo0lCboq73+86aza9HNr+zmZik1MayQiIuvy40sR+GlMBB4Pl2ZRfKlfRYKPmE6BiGzdGE0q15XpE5hV8XZzwtO9m8NLZXRPJpNhzdg+SHh3EPq388f3L/TEvmn34vCMaPxvZE+146x/JUq876ey1k/b+jVXR3t8/UwPjfveGdIev4ztgyMzojXuV3WzhsLIQEWRbNU1ZyeuqifP0MTD2UGvbJd16du4FJy9Ll2r9KRSpkVT0zaVVrV8wc0C6c8iyFO/kbOIj2Nx72e7cCGrABm51VP8ahpZWXtI/Yti1dGwLnP+w/wt1UHBtZw7agWkzUVTaQ2g5gQLmUop/PWZuql8OE2jHAXF5VoT6lSJ/nyX5LNXJlcImPzbCczccFrSN200nS5xGqbWWkUKeSWGTMJ949fjiD2biTl/n8GhS9XnnPLvGW3vTvV1VD+HcqWRtPAPt+Pxb+NhDpo+ftX/w4B118WrDQZnRERkME8XR/Rt66c2TfHN+9phzUsRWPxkd7O9dqCnC1a/2BuD7qqY9ujn4Yz7Ogbi13F98HyfFniwazCejWguGR2Z83B1EPNYj2YYFdVS47GrvqHeMqkfRt8tbePl5ojI1o31nkqalVdz4obnlicgv4Y6aJq0D2wEAAjxdTP4uea0MzkL4/Qc+TMFTRet+kxJC/B0RjMDpjZuOZ2BPvNia25YafH289ifchPzNp9F/wU7kV1YCleVLyiKyxT4Jq56naKxZRSMoWl6MQDIDcjOZ2i2Sk2jHJtPXUfUJztqfO6nWzSvkVMOOAr1GKnWRFPAZm0ZIg2NQcasPizJaghUlK8wlOrPTDV7Y3KmaUbc1V9X6fPXMWrIbI1EREQ1cLS3Q1QbvxqnKplDn1aN8cHwzvjqmR746JEuktG6rk29xftNvF3QpZkXlj7XA490byo5Rn7llLwOQZ6Y/VB1ge6lz4WLxca1XdiqUp0SpsmtwlJ8bsQ0tmkPVE9RG9JJe6mXhki1yLYmfu7O+H18VI3tqqiuJ9THM8sT8N3ui7h8qwgr96VqXR9TVe+ttqM1G1/ri9b++k1Z1jRN7kp2ER75Zp/O5ym/BX2mlCm30PT+a0owUyW/WFuNwupjGjL1DwDSblXUKNP0tLI6zBCpD1PX89J6PJXPomqk7MSVHGTkFpsss+yqfamY9OsxreeQpu2afk6c1khERGRjNr7WFz+82BvNG1ePMFWt8xnSORidm3pJ2qsOHMRO6Y9Vo3thSGdpAPTB8M4Y3781Uuc9gNPvxxjUpxfv1l3brSZvx7THgHbVRZRnP1z3Uxvvaae9iHOd0nDBprp+SBM3Z3sEedVdoq9yDYlfqry25igAoKSG7J41aR/UCCtH9darrQBBLRPjjA2ntdaT08TQGljGjBBX2X72hqT4sNgHpc/U0Jp3eyuzFmoqZF7X9b1qYuoRIn1HBuUKASeu5GDY1/vwyDf7NH6BYGiAVC5XYM4/idhw/Bq2aVkvKzmkjveuupa0vmBwRkRE9Vbnpl5iINGyMkBTDrSUU6rf3zlILV1/a38PDGgfoHbc5/u0wLT7O0Amk8HD2QEPV5YTqImvuxNmPdQRP2nI2Pl07xC1bd1CvNW2hYV4S9ZaqSaeqOKg5whfTc6oBJ+DOgTghxelQYApSkMYQ9vFXU1UE3H0allz5sHaSLyWpzU425mche/3pqpNQzOUo70dnB31u6zbfCoDvT+KxSml9Y1Z+TVPw1Ue/arrUYutierlk5SnVhrane92V0wp1ThyZuQIkXIXbtaiHp0qU3/WuXfURyKv5dzBd7uko87lCgG/Vq6fvJ5brLGsgaGflXKpAm1TUfWtgTj+p7qbQl2XGJwREVGDsPmNftgzdSDaVa7XAoDh3Zuiqbcrnolojm+fC0drf/2y+Kn6/IlueK5PRW24N6PbIXGu5tG0X8b2AQD0beuHTx+TliAYqCEIfPf+DmrbdF2oBTSqTnyi/C33y/1b6Sw0rou7swPmP9YVHs4O+HFMb3w/qhcAaVHz1npmP9TmjwlReKxHM2x8ra9Bz7uYZZpC1m0CGtXcSMmlyilx+tp1Lgsr9movrPvBRt3lDvSlOp14RHhF4hs3J3tJIFbll0Np4n1t0y6Vs6Eqn1N61boy4YiPQhDw94lreOXnI2JGQuURLtW070DF9L3RKw+KpSKUu3NZnNaoaeSs9tP3hi7Zg2w9kgLpsi0xExtPXsMvB9NqbmyAl39QD2o0ldMolwsoUcr2Wqwh86uh03F3natOwKLXaKeORso13jJyi/Hun6eQbKLMs5bE4IyIiBoENycHtQQani6O2PvOQHz8iO5abTVxsLfD7Ic6Yeub9+CN6LZwc3JAcw3JOtoHVQcBqn3p1dJX8nh4WBP0DvXFuw90wIpR1dkoNU1x+mNCJD56pDP+nHg3WjR2w4yhd0n2T7//LuyZOhC+KumzNfVRkyd6heDk7MHo17Z6OqPyaJmHc+0q84S38MFnT3RD56Ze2PrmPVrbueg5MmQotzpYI6maBtwcPF0c0a1Z9VTdqlHjRi4OeOirvWrtFQoBZ6/nobRcoTU4u1spYYdy0FKuEHAlu0jjBbs5yCDD678cw+ZTGfgi9jwEQZAEiJqChMTrediZnIWfE9IgCOpTSwVB0JhUpqZpjU72ms9D5WNl5pWgxwfb1IrT6+tOqRxjfziMV9ccw5lreTU/wQD5GkasbmgYOS1XKGCnNAKvaeqtIUlkVBk6FVWXaetPYk1CGoZ8sdt0B7UQBmdERNSgaUvHbihHezvJqNyWSf1weEY0eodWBF0tGksDochWjfH+w50w+u6WWDm6l1rdoRkPdoRMJsO4e1rj3g7Vo1SaFvOHt/DFsxEt0NTbFbveHoiX+rVSa2NnJ0OP5t7i42+e7YHtk/vju+fDtb6nlaN7SZ6vzNvNCU/0bIYB7f3RRmXEcfGTYeitEmzqq11gI7XPqoqmaVW18cHwzugW4o2JA9tgWJh+U1NrovyZ1ZWOwZ7i/Un3tRPvV2WkzNSSOfTXQ1dw/xd78NzyBL2mzinXvYr6ZAf6zd+JB7+sCPoEQcCuc1nIyi/BtsRMvL3uhNYae7Wdcvvdrot4/59EFCsFC3dK5Yg9mykmDykuk0uCyeIyBW4VSj+HvOJyjQHCN3EpOl/fkC8JPtFjDaQm2pKgmIum2FyuECQ/qywNUzWrppbmFpXhnxPXDArWNa33U5WSma+zVmJV0fvzmQUAKt7HA1/swd46+DLEXGyiCDUREZGtcXNygJuTA75/oSeWxJ7HsDBpZkiZTIYXVFL6n5wzGCVlCvi6O2nNCqnvNKK3Y9pjwX/JePme6kDt40e7wG/rOTwb0QJdKkdYYjoFYfJ97XAt5w4e7dEMX+1Mwe5zWRgV1VLjVEtl8x/vJt6/K9gTZ6/nYeXoXhjYPgB3t/HDE9/F671+RNlTvZrj0y1J8HZzRE5R9UVq56ZeOKlnHTh9PN+nhVi8+IunumNsv1ZisGGsmj4zUwlo5Iw/J96NNQmX8UxEdQHmbKV6UD56ln2oKbPob4ev4KGuTTRO90u5UXFR/M/J63j9l2PwcXPE7SLdgcWIns3wy0H1WnC6qAZRq/ZfwoWsAvHxt3EXsDUxE1GtG2P6/XepjRS+8esxtQDkTqkcx6/kqL3WX8evSR7vfGsAJv58FImVNfxU1ywC+pVw0FdOUSne1TDN0Jw09b5MLki+lNGUtXT3uSw82qMZXlx9CEcu38YLkS3w/rDOer2mPt+LrY6/jNXxlxHo6axxf7e5W3HovWg0cqkOaRKv5+G57xMMLpRuLRicERERmVEjF0e8N1S/jIqeLo5ADUkE9a3P9cqA1ri/cxBaNq5Orx7QyAWfPKaevOP1QdWJUH4I7Y3bhaXwdnNUa6fLXxPvRmFJuTgC6N/IGctf6IlBn+0S29jJgB9ejMC13Dv4YGMi8ovLxZFFZWP7haJrMy90aeaFl1YdFoOH8BY+GNuvFV775ZhBfevd0lc8xq/j+mht18TIdXlARe25yYPb1dzQQN1CvHFCQwDh5GCHpt6ueDtGui5x0F0B8HFzRO9QX7XRWGNN/f0kdibdUCs9UaWkXI61levXagrMAECfEmmRrRojXmnERNO0S+Wpolsrk8Psv3ALH25SX8O3VUPymMLScknwr8my58MR6ueO754PR7/5OwEADvbqUcXsv88YXI/sSnYRNp+6jmcimqORS/X/t7fWncD2szcMPJphqkbgVUfElR2/kgMnB92jhJN/O4FHezTDkcsVBa/XH0s3IDjTfwRV2+gvACRn5MPT1bDfV9aMwRkREZEN+H18JNJz7qBTE6+aG6PiwqeVkQlOjLmod3Kwg5OD9Hmt/T1w8N1BSLyehw82JmLeo13FYOzhbk2w/WymZB1bFQd7O9zdxg8A8Nv4SHywMRG/HkzDyMiWCPVzx9nreZICzn9MiMKBi7cQfVcgYharrzkZ3ClQEuBp4+5cvfZs42t9sWjbOcQm1XyRvHxkT0QrJUj57eVIxCXfwMAOARixNF7SdlhYE7WRGV1WjuqFHh9sU9uu7aLZ280JCe9Gw9FeBplMhqd7NzdJQol/T2fgwa6ap362n7FF7+N8NqIb9pzPqrFdmwAPSXBW05RWezuZODUzIbXmGoMAUKBHev+qtaDKa0Qd7NQ/+x/iDSvynFdcJgZ7V2/fwQfDqwMacwdmANDq3c0AgKMz71Nbi6rsoJ6fZRVddSBVRxdNNdooF4Q6WTdaV7jmjIiIyAb0bOmrNjXSFgR4umBA+wDEThkgGSVzcbTHg12bwEuPb7xnPtgRx2YNRqhfxSigcoC6/pUohLfwwcSBbdA+qBHWvxKFvybejUEdqqcXKk9D0zQlrUpVoXGg4mK8KjOlMuU1epPva4ctk/pJAjMA6B3qi6lDOqgleXl9UFt88VR3rdk8NfF1d8LCEd0QEeorSfQy80Hto7FODnbiqES/tn56v1ZNJlbWZKsNDxcH9NUQkKsad4903eSSWN3rwIxJNz/ux8M697cL9NA4gqw8hc5YXedsFe//eOAyDulRtN4cqgL/2gRKHyplG1UtBh5/4RZe++UYbhaUiAXXq2w4lo6i0nI8/u1+fL1T989Xl9PpuSYrHWINOHJGREREVk95pOj+zkGY+WBH9Gjuje7NpSNhPSof77tQPeUtolVFkNRYjxHBg+8OQnGZQgwap9zXDp9tOwegYlrmYKVAbEjnIEkSGE1ev7cNluxIwfCwJphcmayjai2ics0nXR4Pb4bHK9PiP9W7ORSCUDEFVg+6RkUswdPFEffdFYi31p3Q2ibI0wV+HtI1Rsop/U1F11Q5AHiiZ4hk6t3nT3TD59vO4fMnwvDAkj0m7cuIpfE4+O4gnMssqLmxiZXJFRqzNepruVKZCNUY6en/HQBQkcnyDZU6kjuTs/DnsXQcvnwbhyunRRpD01o4ADifmY+2Nfz/tEYcOSMiIiKbYmcnw5i+oWqBmbIPKte9uDvZo0OQJ47NvA9737m3xmMHeLqguVK2yNeU1uM52FeMSM17tAteH9S2xsAMAN68rx1Wju6F2Q91kmwfdFegpMC3n4d+QZSHs4PegRkANNFSpNxS3J3tYWcnE2uwDVYZdQQq6rW5Otlj6XM9NBZirytBXtIFoI/2aIa979yLjk08tTyjdvZfuIXtZ40rrF4bY1YfrnVNtira1pFduV2EGxqC4ff+PG2S19UkI6/YbMc2JwZnREREVO+M6BmC/dPuxenKAMjH3UmtSLOhqupbPd27uTgKVhOZTIaB7QM0ruNzV6oPN6JniNr+r57pbmRPq6kGGJpUTRetC1XrteY92gUbJt6N+Y+rJ6hxrhwlHdI5GOsnRJm8Dz11rDtU5u+hOUMgAEwY0Bqhfu7451XDCqfrsv/CTazaf8lkx9PX7nM1rwHUV9XI2fbETAz6LE5pu0xjKn5zUp6mbEsYnBEREVG91MTb1WR17ADzFMH++JEuiAj1xfj+rcVtz/dpgYsfP6A1AYchnBzsMHdYJ51rcra+eQ+WPR+OH8f0Fre998BdWtsbauNr1QFM64CKQNDB3g5hId7w1pDuP/qu6tE0XQkmjHWfhtE6TfwbaQ/O3hnSATvfGoAWfvoVctfHb4evmuxYmphy/aE29jIZCkrK8dIPh3Ehq7qMhp0MuFHHI1mmLHJdl7jmjIiIiEiHTx/rgg82nsXXz/Qw+bGfiWiOZyKaAwB2vT0ABSXlemfk1NfIyJZ4omcIZm44jXVHqgOAtwa3Q3THQDja22FwpyCxD95uTvBydcRHm8+qHeuPCVH4bGsy9l/QXhhYVeemXkj56H7IBUHjaMaeqQORX1wOLzfHyrpZ5k18ExbijYBGzuI6qwHt/RGXXDF6dHebxtiXUvHeAjxrHnV0d7KuS+nXB7XFktjzGvc9Ht5MUn7AHGQyGYZoyJh6p0yODzdVnE/BXi64nmv+QG1NQhoKSsrrrPagqXDkjIiIiEiHJ3s1x8nZgxHRqrFZX6dFY3eTB2ZVXBztsWBEN9zdpuI9PBvRHK/e2xYdgqTrp1o0dheToax/JQofDKteK9fY3QnhLXywZmwfPNVLfRqmJlUpzh3s7bROMwvxdUPHJp5o6u2Kp3s3N/t0NB93J0S2rv5ZKmeGVK4L6K7HNFh7OxnG9guVbFPO5vjby5G16apo2fPhODlncI3tNI3uPtAlCD+/FIFhYU2xbnwkxvYLxfCw2o3KznlIc7bQ9Jw7uHpbPXnL6fQ88X735t61em0A6KTHur8/j6Xj/b/P1Pq16pp1hftEREREVkhXsV5b8s2z4dhzPksydVCbHs190KO5D2b+VXGBqzxNbO6wztibclNyIf5Ez2ZqU/NaG1lrz1gzH+wIX3dHpN4sQsdgT9zIL8awbk3RbW516npPF0co/zSbK9Uw69fWD028XdHc103vKbED2gfgf3sqMhY+1SsEnZp6YeaGikQXvUN9kTrvAYRO31yr91U1svnDi73x5Y7zeGVAG7g42ovZEAEgplMgmioVUk94dxD2nr+JB7sFiwFvr5a+YokHOzsZ1h9NN7gv/dr64fnIlpjzj3qxb314uepOfnN/5yA82SsEo1Ye0tnOxdEOxWW669/ZYnFqBmdEREREDYSXq6PBa9lmPtgRH2xMxGdPhInbnBzs8Ocrd2PaHyfFQt0jI1uqBWdlct0Xz/roGOyJxOt5mPdoF0xffwpARXbLmwUVGQa/eCoMPZr7oKm3a41BdPRdgQjycpGkWPdRWvfm5uSAiQPbGNS/qNaN8cqA1mgf1AjDwpqipFyOveez0LeykLpMJkPvUF8cTM3Gm9HtsGj7OcnzDSmrcE87f9zTrqJOnHJttzF9Q/FGdFu4Ozng8KXb6NnSB4GeLnisMiumJl2aehkVnMkVAuztZPBv5IwsI1LwO9rr/hl99EgXSVHp5r5uSMsukrRRCBWjkg9/tU/nsUxRk66u2V6PiYiIiKjOjOkbimcjmsPFUTrNz7+RM74f1QsL/kvCnVIFOjf1wolZg+HmbI+27/0LAGgfVPs6U79PiERadhE6BHmiS1Mv/HH0Kp6NaIHoz3cBgF7F2fdNuxdXs4vEqamj726JnKJSDOkcJAkEjKkLJ5PJMHVIB/Gxs4M9vnu+p6TN9y/0RFJGPnq28JEEZ5tf74eOTTwx7p5WWLb7ori9azMvPNq9Keb8k4gXIltofF17OxkmDmyN/OJySVHyD4Z31qvfytNHv322Byb8XF1k/NWBbfCVlsLQJeUVAff8x7tidOXo1pKnu+P1X47p9brDuzfFD/GXNe4L9nIRfwbfPtsDckHAD/svqwVngiCgazPvGl/LkLIT1oLBGRERERHppBqYKXs7pjow8XKruBje+FpfrDt8BW9E61dyQBc3JwdxbVznpl7o3LRiXd7edwbqnZCjqberZMqfm5MD3htaHdB8OLwzruXc0WstkzEauTiK0wlH390SK/ddwofDO4s106bGtMf9nYPQys8D8RdvoX87f7g62ePeDoFo5qO9Vp3yZ294n6o/u/u7BIv3X7+3DSYPbo/wFj64WVCCjNxiZBeVYuW+SwCA0srgrINS4P1A5yC8rsdrThzYGkE6Eq208q9e81fVp5aN3fHm2uOY+WBHnL2eh4Vbk/Hxo130eYsMzoiIiIiIlIMoc2nmY7o09s/10Tw6ZQ4zhnbEsxEt0FopEHGwtxOLqg/pHCRuVy6IbmpDOgdhRHgz9A71lWzvXlkHbmAHaZZD1eAs2MsVWyb1g5erY2XCFztxVE0be5kMDjqmNWpaQ9a5qRe2Te4PoGJa55i+oXCorDn4zpAO+HRLkti2WzMvnLiaKz72drO94IzZGomIiIiI6oi9nQxtAjxMWoPPGI72dlgwoptYAH375Hvw5dPdMaByTZuqZytLPrypVIC9Q5Angr0qRva+ez5c3D6og+b09VdUMjlOim6LHVP6i49LyuU19rsqMAMqioEra+XvgbXj+oiP9SnCbm04ckZERERE1MC1CWiENgHa1wh+OLwzJkW301qce0D7ACR/OAQ3C0rRxMtFY4bKUD93+Hs4o08rXzja2+GNQW0lQWpRSc3BmarlI3vipR8qEqo83bs5WiqNNuqaQmmtGJwREREREZFOMplMa2BWxdnBXlzbN3dYJ/x7KgOLnwrDJ/8m4VZhKcb0DYVMJsMvY/toHDm8dKvQ4H5FdwxEykf3I6ugBMFerhAEAU/1CsHV23fQT8sooDWTCYIg1NyMDJGXlwcvLy/k5ubC09M8C0uJiIiIiOqDT7ck4du4C3j3gQ4Yd0/rmp9gYwyJDThyRkREREREFvPW4PYYHtYU7QLrtmi5NWJwRkREREREFmNvJzNJTbz6gNkaiYiIiIiIrACDMyIiIiIiIivA4IyIiIiIiMgKMDgjIiIiIiKyAgzOiIiIiIiIrACDMyIiIiIiIivA4IyIiIiIiMgKMDgjIiIiIiKyAjYTnD388MNo3rw5XFxcEBwcjOeffx7Xrl2TtDl58iT69esHFxcXhISEYP78+WrHWbduHTp06AAXFxd06dIFmzdvluwXBAGzZs1CcHAwXF1dER0djfPnz5v1vREREREREdlMcDZw4ED89ttvSE5Oxh9//IELFy7g8ccfF/fn5eVh8ODBaNGiBY4cOYIFCxZgzpw5WLZsmdhm//79ePrppzFmzBgcO3YMw4cPx/Dhw3H69Gmxzfz587FkyRIsXboUCQkJcHd3R0xMDIqLi+v0/RIRERERUcMiEwRBsHQnjPH3339j+PDhKCkpgaOjI7799lu89957yMjIgJOTEwBg2rRp2LBhA5KSkgAATz75JAoLC7Fx40bxOH369EFYWBiWLl0KQRDQpEkTTJkyBW+99RYAIDc3F4GBgVi1ahWeeuopvfqWl5cHLy8v5ObmwtPT08TvnIiIiIiIbIUhsYHNjJwpy87Oxs8//4yoqCg4OjoCAOLj43HPPfeIgRkAxMTEIDk5Gbdv3xbbREdHS44VExOD+Ph4AEBqaioyMjIkbby8vBARESG20aSkpAR5eXmSGxERERERkSFsKjh755134O7ujsaNGyMtLQ1//fWXuC8jIwOBgYGS9lWPMzIydLZR3q/8PE1tNJk3bx68vLzEW0hIiJHvkIiIiIiIGiqLBmfTpk2DTCbTeauakggAb7/9No4dO4atW7fC3t4eI0eOhDXMypw+fTpyc3PF25UrVyzdJSIiIiIisjEOlnzxKVOmYNSoUTrbtGrVSrzv5+cHPz8/tGvXDnfddRdCQkJw4MABREZGIigoCJmZmZLnVj0OCgoS/9XURnl/1bbg4GBJm7CwMK19dHZ2hrOzs/i4KmDk9EYiIiIiooatKibQZ1DJosGZv78//P39jXquQqEAULHeCwAiIyPx3nvvoaysTFyHtm3bNrRv3x4+Pj5im9jYWEyaNEk8zrZt2xAZGQkACA0NRVBQEGJjY8VgLC8vDwkJCZgwYYLefcvPzwcATm8kIiIiIiIAFTGCl5eXzjY2ka0xISEBhw4dQt++feHj44MLFy5g5syZyMzMxJkzZ+Ds7Izc3Fy0b98egwcPxjvvvIPTp0/jxRdfxKJFizBu3DgAFan0+/fvj08++QRDhw7Fr7/+io8//hhHjx5F586dAQCffvopPvnkE6xevRqhoaGYOXMmTp48icTERLi4uOjVX4VCgWvXrqFRo0aQyWRm+1z0kZeXh5CQEFy5coWZI0kvPGfIUDxnyFA8Z8hQPGfIUNZ0zgiCgPz8fDRp0gR2drpXlVl05Exfbm5uWL9+PWbPno3CwkIEBwdjyJAhmDFjhjid0MvLC1u3bsXEiRMRHh4OPz8/zJo1SwzMACAqKgpr1qzBjBkz8O6776Jt27bYsGGDGJgBwNSpU1FYWIhx48YhJycHffv2xZYtW/QOzADAzs4OzZo1M90HYAKenp4WPzHJtvCcIUPxnCFD8ZwhQ/GcIUNZyzlT04hZFZsYOSPjseYaGYrnDBmK5wwZiucMGYrnDBnKVs8Zm0qlT0REREREVF8xOKvnnJ2dMXv2bEk2SSJdeM6QoXjOkKF4zpCheM6QoWz1nOG0RiIiIiIiIivAkTMiIiIiIiIrwOCMiIiIiIjICjA4IyIiIiIisgIMzoiIiIiIiKwAg7N67uuvv0bLli3h4uKCiIgIHDx40NJdIguYM2cOZDKZ5NahQwdxf3FxMSZOnIjGjRvDw8MDjz32GDIzMyXHSEtLw9ChQ+Hm5oaAgAC8/fbbKC8vr+u3Qmaye/duPPTQQ2jSpAlkMhk2bNgg2S8IAmbNmoXg4GC4uroiOjoa58+fl7TJzs7Gs88+C09PT3h7e2PMmDEoKCiQtDl58iT69esHFxcXhISEYP78+eZ+a2QmNZ0zo0aNUvu9M2TIEEkbnjMNy7x589CrVy80atQIAQEBGD58OJKTkyVtTPX3KC4uDj169ICzszPatGmDVatWmfvtkRnoc84MGDBA7XfN+PHjJW1s6ZxhcFaPrV27FpMnT8bs2bNx9OhRdOvWDTExMbhx44alu0YW0KlTJ1y/fl287d27V9z35ptv4p9//sG6deuwa9cuXLt2DY8++qi4Xy6XY+jQoSgtLcX+/fuxevVqrFq1CrNmzbLEWyEzKCwsRLdu3fD1119r3D9//nwsWbIES5cuRUJCAtzd3RETE4Pi4mKxzbPPPoszZ85g27Zt2LhxI3bv3o1x48aJ+/Py8jB48GC0aNECR44cwYIFCzBnzhwsW7bM7O+PTK+mcwYAhgwZIvm988svv0j285xpWHbt2oWJEyfiwIED2LZtG8rKyjB48GAUFhaKbUzx9yg1NRVDhw7FwIEDcfz4cUyaNAkvvfQS/vvvvzp9v1R7+pwzADB27FjJ7xrlL3Fs7pwRqN7q3bu3MHHiRPGxXC4XmjRpIsybN8+CvSJLmD17ttCtWzeN+3JycgRHR0dh3bp14razZ88KAIT4+HhBEARh8+bNgp2dnZCRkSG2+fbbbwVPT0+hpKTErH2nugdA+PPPP8XHCoVCCAoKEhYsWCBuy8nJEZydnYVffvlFEARBSExMFAAIhw4dEtv8+++/gkwmE9LT0wVBEIRvvvlG8PHxkZwz77zzjtC+fXszvyMyN9VzRhAE4YUXXhCGDRum9Tk8Z+jGjRsCAGHXrl2CIJju79HUqVOFTp06SV7rySefFGJiYsz9lsjMVM8ZQRCE/v37C2+88YbW59jaOcORs3qqtLQUR44cQXR0tLjNzs4O0dHRiI+Pt2DPyFLOnz+PJk2aoFWrVnj22WeRlpYGADhy5AjKysok50qHDh3QvHlz8VyJj49Hly5dEBgYKLaJiYlBXl4ezpw5U7dvhOpcamoqMjIyJOeIl5cXIiIiJOeIt7c3evbsKbaJjo6GnZ0dEhISxDb33HMPnJycxDYxMTFITk7G7du36+jdUF2Ki4tDQEAA2rdvjwkTJuDWrVviPp4zlJubCwDw9fUFYLq/R/Hx8ZJjVLXh9Y/tUz1nqvz888/w8/ND586dMX36dBQVFYn7bO2ccajzV6Q6cfPmTcjlcsmJCACBgYFISkqyUK/IUiIiIrBq1Sq0b98e169fx/vvv49+/frh9OnTyMjIgJOTE7y9vSXPCQwMREZGBgAgIyND47lUtY/qt6qfsaZzQPkcCQgIkOx3cHCAr6+vpE1oaKjaMar2+fj4mKX/ZBlDhgzBo48+itDQUFy4cAHvvvsu7r//fsTHx8Pe3p7nTAOnUCgwadIk3H333ejcuTMAmOzvkbY2eXl5uHPnDlxdXc3xlsjMNJ0zAPDMM8+gRYsWaNKkCU6ePIl33nkHycnJWL9+PQDbO2cYnBE1APfff794v2vXroiIiECLFi3w22+/8Y8UEZnFU089Jd7v0qULunbtitatWyMuLg6DBg2yYM/IGkycOBGnT5+WrH8m0kXbOaO8TrVLly4IDg7GoEGDcOHCBbRu3bquu1lrnNZYT/n5+cHe3l4tw1FmZiaCgoIs1CuyFt7e3mjXrh1SUlIQFBSE0tJS5OTkSNoonytBQUEaz6WqfVS/Vf2Mdf0+CQoKUks2VF5ejuzsbJ5HBABo1aoV/Pz8kJKSAoDnTEP26quvYuPGjdi5cyeaNWsmbjfV3yNtbTw9PfmFpI3Sds5oEhERAQCS3zW2dM4wOKunnJycEB4ejtjYWHGbQqFAbGwsIiMjLdgzsgYFBQW4cOECgoODER4eDkdHR8m5kpycjLS0NPFciYyMxKlTpyQXUtu2bYOnpyc6duxY5/2nuhUaGoqgoCDJOZKXl4eEhATJOZKTk4MjR46IbXbs2AGFQiH+oYyMjMTu3btRVlYmttm2bRvat2/P6WkNwNWrV3Hr1i0EBwcD4DnTEAmCgFdffRV//vknduzYoTZl1VR/jyIjIyXHqGrD6x/bU9M5o8nx48cBQPK7xqbOmTpPQUJ15tdffxWcnZ2FVatWCYmJicK4ceMEb29vSbYaahimTJkixMXFCampqcK+ffuE6Ohowc/PT7hx44YgCIIwfvx4oXnz5sKOHTuEw4cPC5GRkUJkZKT4/PLycqFz587C4MGDhePHjwtbtmwR/P39henTp1vqLZGJ5efnC8eOHROOHTsmABA+//xz4dixY8Lly5cFQRCETz75RPD29hb++usv4eTJk8KwYcOE0NBQ4c6dO+IxhgwZInTv3l1ISEgQ9u7dK7Rt21Z4+umnxf05OTlCYGCg8PzzzwunT58Wfv31V8HNzU347rvv6vz9Uu3pOmfy8/OFt956S4iPjxdSU1OF7du3Cz169BDatm0rFBcXi8fgOdOwTJgwQfDy8hLi4uL+387dhUS57XEc/03mjDOpoSZmloppJUJaVDelmUIaURQGElLWhQZloph1UUbaRQVGZEYXXTQFlRKU3hUUQ2EWFORLKJbmC4RdmBCpvViuc7H3Hs5sN0XnmI7b7wcGZp5nPWv9n2HB8JtZs0x/f7/7MTIy4m4zEZ9Hb968MQ6Hw5SWlpr29nZz8eJF4+PjY+7evTup94v/38/mTGdnp6moqDDPnz833d3dpr6+3sTExJiUlBR3H9NtzhDO/uUuXLhgIiMjjdVqNWvWrDFPnz6d6pIwBbKzs014eLixWq0mIiLCZGdnm87OTvf5T58+mf3795ugoCDjcDjM9u3bTX9/v0cfPT09ZtOmTcZut5t58+aZkpISMzo6Otm3gt/E5XIZSeMeubm5xpg/ttMvKyszYWFhxmazmfT0dNPR0eHRx/v3783OnTuNv7+/CQwMNHv37jUfP370aNPc3GzWrVtnbDabiYiIMKdPn56sW8QE+9GcGRkZMRs3bjShoaHG19fXREVFmby8vHFfDjJnZpZ/mi+SzJUrV9xtJurzyOVymaSkJGO1Wk1MTIzHGJg+fjZn+vr6TEpKigkODjY2m83Exsaa0tJS8+HDB49+ptOcsRhjzOT9TgcAAAAA+Cf85wwAAAAAvADhDAAAAAC8AOEMAAAAALwA4QwAAAAAvADhDAAAAAC8AOEMAAAAALwA4QwAAAAAvADhDAAAAAC8AOEMADBjpKamqqioaKrL8GCxWFRXVzfVZQAAvIDFGGOmuggAACbD4OCgfH19FRAQoOjoaBUVFU1aWDtx4oTq6urU1NTkcfzdu3cKCgqSzWablDoAAN5r9lQXAADAZAkODp7wPr9+/Sqr1fo/Xz9//vwJrAYAMJ2xrBEAMGP8tawxNTVVvb29Ki4ulsVikcVicbdpaGhQcnKy7Ha7Fi1apMLCQg0PD7vPR0dH6+TJk9q9e7cCAwOVn58vSTpy5IiWLFkih8OhmJgYlZWVaXR0VJLkdDpVXl6u5uZm93hOp1PS+GWNra2tSktLk91uV0hIiPLz8zU0NOQ+v2fPHm3btk2VlZUKDw9XSEiIDhw44B4LADB9Ec4AADPO7du3tXDhQlVUVKi/v1/9/f2SpK6uLmVmZiorK0stLS2qra1VQ0ODCgoKPK6vrKxUYmKiXrx4obKyMklSQECAnE6n2tradP78eV2+fFnnzp2TJGVnZ6ukpEQJCQnu8bKzs8fVNTw8rIyMDAUFBenZs2e6deuW7t+/P258l8ulrq4uuVwuXb16VU6n0x32AADTF8saAQAzTnBwsHx8fBQQEOCxrPDUqVPKyclx/w8tLi5OVVVVWr9+vS5duiQ/Pz9JUlpamkpKSjz6PHbsmPt5dHS0Dh06pJqaGh0+fFh2u13+/v6aPXv2D5cx3rhxQ58/f9a1a9c0Z84cSVJ1dbW2bNmiM2fOKCwsTJIUFBSk6upq+fj4aNmyZdq8ebMePHigvLy8CXl/AABTg3AGAMCfmpub1dLSouvXr7uPGWM0Njam7u5uxcfHS5JWrVo17tra2lpVVVWpq6tLQ0ND+vbtmwIDA39p/Pb2diUmJrqDmSStXbtWY2Nj6ujocIezhIQE+fj4uNuEh4ertbX1l8YCAHgfwhkAAH8aGhrSvn37VFhYOO5cZGSk+/l/hydJevLkiXJyclReXq6MjAzNnTtXNTU1Onv27G+p09fX1+O1xWLR2NjYbxkLADB5CGcAgBnJarXq+/fvHsdWrlyptrY2xcbG/lJfjY2NioqK0tGjR93Hent7fzre38XHx8vpdGp4eNgdAB8/fqxZs2Zp6dKlv1QTAGD6YUMQAMCMFB0drUePHunt27caGBiQ9MeOi42NjSooKFBTU5Nev36t+vr6cRty/F1cXJz6+vpUU1Ojrq4uVVVV6c6dO+PG6+7uVlNTkwYGBvTly5dx/eTk5MjPz0+5ubl6+fKlXC6XDh48qF27drmXNAIA/r0IZwCAGamiokI9PT1avHixQkNDJUnLly/Xw4cP9erVKyUnJ2vFihU6fvy4FixY8MO+tm7dquLiYhUUFCgpKUmNjY3uXRz/kpWVpczMTG3YsEGhoaG6efPmuH4cDofu3bunwcFBrV69Wjt27FB6erqqq6sn7sYBAF7LYowxU10EAAAAAMx0/HIGAAAAAF6AcAYAAAAAXoBwBgAAAABegHAGAAAAAF6AcAYAAAAAXoBwBgAAAABegHAGAAAAAF6AcAYAAAAAXoBwBgAAAABegHAGAAAAAF6AcAYAAAAAXuA/ETHRaTItxEUAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# view training\n",
    "loss_history = np.array(loss_history).reshape(-1)\n",
    "x = range(loss_history.shape[0])\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(x, loss_history, label=\"train\")\n",
    "plt.title(\"Loss\", fontsize=15)\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.xlabel(\"iteration\")\n",
    "plt.ylabel(\"nll\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Q1U6YhaFXlSp",
   "metadata": {
    "id": "Q1U6YhaFXlSp"
   },
   "source": [
    "## Inference\n",
    "\n",
    "At inference time, it's recommended to use the `generate()` method for autoregressive generation, similar to NLP models.\n",
    "\n",
    "Forecasting involves getting data from the test instance sampler, which will sample the very last `context_length` sized window of values from each time series in the dataset, and pass it to the model. Note that we pass `future_time_features`, which are known ahead of time, to the decoder.\n",
    "\n",
    "The model will autoregressively sample a certain number of values from the predicted distribution and pass them back to the decoder to return the prediction outputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "7c7482c1",
   "metadata": {
    "id": "7c7482c1"
   },
   "outputs": [],
   "source": [
    "model.eval()\n",
    "\n",
    "forecasts_ = []\n",
    "\n",
    "for batch in test_dataloader:\n",
    "    outputs = model.generate(\n",
    "        static_categorical_features=batch[\"static_categorical_features\"].to(device)\n",
    "        if config.num_static_categorical_features > 0\n",
    "        else None,\n",
    "        static_real_features=batch[\"static_real_features\"].to(device)\n",
    "        if config.num_static_real_features > 0\n",
    "        else None,\n",
    "        past_time_features=batch[\"past_time_features\"].to(device),\n",
    "        past_values=batch[\"past_values\"].to(device),\n",
    "        future_time_features=batch[\"future_time_features\"].to(device),\n",
    "        past_observed_mask=batch[\"past_observed_mask\"].to(device),\n",
    "    )\n",
    "    forecasts_.append(outputs.sequences.cpu().numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "kPLiRcOeZR67",
   "metadata": {
    "id": "kPLiRcOeZR67"
   },
   "source": [
    "The model outputs a tensor of shape (`batch_size`, `number of samples`, `prediction length`, `input_size`). \n",
    "\n",
    "In this case, we get `100` possible values for the next `48` hours for each of the `862` time series (for each example in the batch which is of size `1` since we only have a single multivariate time series):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "DwAfSZitZNAQ",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DwAfSZitZNAQ",
    "outputId": "8ca71318-2361-4c9c-ae93-88ba9a453fef"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 100, 48, 862)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "forecasts_[0].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fCTBw_t91xwH",
   "metadata": {
    "id": "fCTBw_t91xwH"
   },
   "source": [
    "We'll stack them vertically, to get forecasts for all time-series in the test dataset (just in case there are more time series in the test set):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "du1GyJVXlpHp",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "du1GyJVXlpHp",
    "outputId": "cfd3e777-da77-4ca6-eedd-e0d0f22da872"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 100, 48, 862)\n"
     ]
    }
   ],
   "source": [
    "forecasts = np.vstack(forecasts_)\n",
    "print(forecasts.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "wlvFCdgiA9oy",
   "metadata": {
    "id": "wlvFCdgiA9oy"
   },
   "source": [
    "We can evaluate the resulting forecast with respect to the ground truth out of sample values present in the test set. For that, we'll use the 🤗 [Evaluate](https://huggingface.co/docs/evaluate/index) library, which includes the [MASE](https://huggingface.co/spaces/evaluate-metric/mase) and [sMAPE](https://huggingface.co/spaces/evaluate-metric/smape) metrics.\n",
    "\n",
    "We calculate both metrics for each time series variate in the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "0yb9RnczYE4z",
   "metadata": {
    "id": "0yb9RnczYE4z"
   },
   "outputs": [],
   "source": [
    "from evaluate import load\n",
    "from gluonts.time_feature import get_seasonality\n",
    "\n",
    "mase_metric = load(\"evaluate-metric/mase\")\n",
    "smape_metric = load(\"evaluate-metric/smape\")\n",
    "\n",
    "forecast_median = np.median(forecasts, 1).squeeze(0).T\n",
    "\n",
    "mase_metrics = []\n",
    "smape_metrics = []\n",
    "\n",
    "for item_id, ts in enumerate(test_dataset):\n",
    "    training_data = ts[\"target\"][:-prediction_length]\n",
    "    ground_truth = ts[\"target\"][-prediction_length:]\n",
    "    mase = mase_metric.compute(\n",
    "        predictions=forecast_median[item_id],\n",
    "        references=np.array(ground_truth),\n",
    "        training=np.array(training_data),\n",
    "        periodicity=get_seasonality(freq),\n",
    "    )\n",
    "    mase_metrics.append(mase[\"mase\"])\n",
    "\n",
    "    smape = smape_metric.compute(\n",
    "        predictions=forecast_median[item_id],\n",
    "        references=np.array(ground_truth),\n",
    "    )\n",
    "    smape_metrics.append(smape[\"smape\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "fuuFbNYdZlIR",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fuuFbNYdZlIR",
    "outputId": "9a010645-30fc-4af8-bc53-636391ba0ec6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MASE: 1.1913437728068093\n"
     ]
    }
   ],
   "source": [
    "print(f\"MASE: {np.mean(mase_metrics)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "w6ETpUrML2wE",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "w6ETpUrML2wE",
    "outputId": "77127e13-36b1-4cd2-9f90-63f3f23c6db0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sMAPE: 0.5322665081607634\n"
     ]
    }
   ],
   "source": [
    "print(f\"sMAPE: {np.mean(smape_metrics)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "b649b65e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(mase_metrics, smape_metrics, alpha=0.2)\n",
    "plt.xlabel(\"MASE\")\n",
    "plt.ylabel(\"sMAPE\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "moksM2QmMACr",
   "metadata": {
    "id": "moksM2QmMACr"
   },
   "source": [
    "To plot the prediction for any time series variate with respect the ground truth test data we define the following helper:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "4e35b93e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.dates as mdates\n",
    "\n",
    "\n",
    "def plot(ts_index, mv_index):\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    index = pd.period_range(\n",
    "        start=multi_variate_test_dataset[ts_index][FieldName.START],\n",
    "        periods=len(multi_variate_test_dataset[ts_index][FieldName.TARGET]),\n",
    "        freq=multi_variate_test_dataset[ts_index][FieldName.START].freq,\n",
    "    ).to_timestamp()\n",
    "\n",
    "    ax.xaxis.set_minor_locator(mdates.HourLocator())\n",
    "\n",
    "    ax.plot(\n",
    "        index[-2 * prediction_length :],\n",
    "        multi_variate_test_dataset[ts_index][\"target\"][mv_index, -2 * prediction_length :],\n",
    "        label=\"actual\",\n",
    "    )\n",
    "\n",
    "    ax.plot(\n",
    "        index[-prediction_length:],\n",
    "        forecasts[ts_index, ..., mv_index].mean(axis=0),\n",
    "        label=\"mean\",\n",
    "    )\n",
    "    ax.fill_between(\n",
    "        index[-prediction_length:],\n",
    "        forecasts[ts_index, ..., mv_index].mean(0)\n",
    "        - forecasts[ts_index, ..., mv_index].std(axis=0),\n",
    "        forecasts[ts_index, ..., mv_index].mean(0)\n",
    "        + forecasts[ts_index, ..., mv_index].std(axis=0),\n",
    "        alpha=0.2,\n",
    "        interpolate=True,\n",
    "        label=\"+/- 1-std\",\n",
    "    )\n",
    "    ax.legend()\n",
    "    fig.autofmt_xdate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mwtksAcxMHoK",
   "metadata": {
    "id": "mwtksAcxMHoK"
   },
   "source": [
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "5N8fdnm_MKQP",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "5N8fdnm_MKQP",
    "outputId": "3b221c31-ee20-4626-9592-2492ce143b4a"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(0, 344)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Nf4Y8MvLMOi8",
   "metadata": {
    "id": "Nf4Y8MvLMOi8"
   },
   "source": [
    "## Conclusion\n",
    "\n",
    "How do we compare against other models? The [Monash Time Series Repository](https://forecastingdata.org/#results) has a comparison table of test set MASE metrics which we can add to:\n",
    "\n",
    "|Dataset | \tSES| \tTheta | \tTBATS| \tETS\t| (DHR-)ARIMA| \tPR|\tCatBoost |\tFFNN\t| DeepAR | \tN-BEATS | \tWaveNet|  Transformer (uni.) | **Informer (mv. our)**| \n",
    "|:------------------:|:-----------------:|:--:|:--:|:--:|:--:|:--:|:--:|:---:|:---:|:--:|:--:|:--:|:--:|\n",
    "|Traffic Hourly | 1.922\t| 1.922\t| 2.482 |\t2.294|\t2.535|\t1.281|\t1.571\t|0.892|\t0.825\t|1.100|\t1.066\t| **0.821** | 1.191 |\n",
    "\n",
    "As can be seen, and perhaps surprising to some, the multivariate forecasts are typically _worse_ than the univariate ones, the reason being the difficulty in estimating the cross-series correlations/relationships. The additional variance added by the estimates often harms the resulting forecasts or the model learns spurious correlations. We refer to [this paper](https://openreview.net/forum?id=GpW327gxLTF) for further reading. Multivariate models tend to work well when trained on a lot of data.\n",
    "\n",
    "So the vanilla Transformer still performs best here! In the future, we hope to better benchmark these models in a central place to ease reproducing the results of several papers. Stay tuned for more!\n",
    "\n",
    "## Resources\n",
    "\n",
    "We recommend to check out the [Informer docs](https://huggingface.co/docs/transformers/main/en/model_doc/informer) and the example notebook linked at the top of this blog post."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec04e604",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "include_colab_link": true,
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "009a21c6a2dd4c5da79a7fb3eec8ff43": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_a8b516bf196946a09a55732d937dfe2a",
      "placeholder": "​",
      "style": "IPY_MODEL_53a3ad2f991648439e57362c4a7a5f60",
      "value": "Generating test split:  89%"
     }
    },
    "01a6160718434f7bb73bb4a094ee8b0f": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "028908857f134943af7b47a2503ce403": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_50e91b016b0a4ce69325e8196a09dce6",
      "placeholder": "​",
      "style": "IPY_MODEL_9c573dc9c14248deb512162af5f9b0fa",
      "value": " 326/366 [00:00&lt;00:00, 615.43 examples/s]"
     }
    },
    "044030ba2c5948d2ac6545aea773ef4a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "0452728577c4433d9d15eca97045d1f4": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "048591e682544b57abbcba613c81f9b4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_d8a6361f19894be1b730137b0801e4e8",
       "IPY_MODEL_2c375a08b1cb4f71a0a0a169c999aa94",
       "IPY_MODEL_ea1af7f963e848d19ea363331027109b"
      ],
      "layout": "IPY_MODEL_b68b7b7b072e457980e834113ff0a670"
     }
    },
    "09cc068788e64c1fbc1edd0992f43f42": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "0a4bcc907dbc48f3af39fac4c0652bd4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "0bf375322d12400ab773e85c08cd3e62": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_22c8c8ecb39c491798602abe0144eba1",
      "placeholder": "​",
      "style": "IPY_MODEL_36a6c51643ba4375b314e9395c0aea07",
      "value": " 311/366 [00:01&lt;00:00, 436.98 examples/s]"
     }
    },
    "0d037e1f14794a0fb68ab472b42ee60a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_eaa70494878f4eba927868ecbbd034b4",
       "IPY_MODEL_b9f43527572c41849f66e100e4d2df83",
       "IPY_MODEL_f0019a4884124eebb44571ca0a7b262e"
      ],
      "layout": "IPY_MODEL_a79295d7dc77434282636a0ef665a70b"
     }
    },
    "1076c8e3f8e1413fad4aa5cb16c71c31": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_dbb568c5b348421a9e2f9f4e07cd5f01",
       "IPY_MODEL_966ca413bd824a77b50a20784e8bd1b4",
       "IPY_MODEL_e81a3f25949247eeb696ccd3b0df3da0"
      ],
      "layout": "IPY_MODEL_228e4cf452a04b1f8f324be138857c30"
     }
    },
    "17a314c74019462e9ba2e923b9235bed": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_6b97acade12a49d683ec81855e1bf58a",
      "placeholder": "​",
      "style": "IPY_MODEL_45b1dbee32a440328f91bf0c398d4a88",
      "value": " 346/366 [00:00&lt;00:00, 663.14 examples/s]"
     }
    },
    "228e4cf452a04b1f8f324be138857c30": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "22c8c8ecb39c491798602abe0144eba1": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "23207dda3c7c45ef942fb26b6d3e8f4a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "2435607c37f2439aa1f0d545009b375e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": "hidden",
      "width": null
     }
    },
    "2c375a08b1cb4f71a0a0a169c999aa94": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_a3384254326f49eb907bfa6d2032b1a8",
      "max": 3,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_68e542f3c052435f9254e135e5c481e8",
      "value": 3
     }
    },
    "2dc9cef88370404184dc1f629d062a04": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_ed58c5b583f344cdbfea76562259190e",
       "IPY_MODEL_c56009b340984f2296ad2959e8d72f25",
       "IPY_MODEL_b2eeaecdd52343a4977954915f38bc9b"
      ],
      "layout": "IPY_MODEL_c55cb9a98afe49d59838a3e2d88cd774"
     }
    },
    "2e0511f2f1844758a6f6d10af7233a72": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "2ec6b12a621f4ce681554397392bdda8": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_6a39d27a5d5e484385f3d8163665641f",
      "placeholder": "​",
      "style": "IPY_MODEL_649640a4dacf4edab3aba273d7e09bbf",
      "value": " 31.2k/31.2k [00:00&lt;00:00, 18.6kB/s]"
     }
    },
    "313d214425c541b6845f70638f8a5937": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "331752b5913245e380752532ab15f128": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "3366b16d73d949508f24d647558db059": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "36a6c51643ba4375b314e9395c0aea07": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "3c850c33752443afa6658a1cb997549e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "3e1c8ac5bfac429993d5404f7abf748d": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "3ff0a924499f414ca7fd03a902b51102": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "435416a295674774a15aa700ff7ce007": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "43daab71788e4a5c80687a9e73bf3b67": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_67f8fc82c7044090a0408294bc1c2d15",
       "IPY_MODEL_7cd0096ebb94429dab18e3226fc4cdbf",
       "IPY_MODEL_0bf375322d12400ab773e85c08cd3e62"
      ],
      "layout": "IPY_MODEL_e3641728ace74d8ab4742007d1725ee8"
     }
    },
    "445f2ef3f71a4573ae453144dd4c5e81": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": "hidden",
      "width": null
     }
    },
    "45b1dbee32a440328f91bf0c398d4a88": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "46e05d2996a84b5e8f456adbb6453350": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "50e91b016b0a4ce69325e8196a09dce6": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "53938941490b4afea31c63aad4bdce0a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "53a3ad2f991648439e57362c4a7a5f60": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "5c531b5b3ce4406abde898297f4bc80b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_b7e131bcb6454ccbb5de0813a734586a",
      "max": 24887,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_3e1c8ac5bfac429993d5404f7abf748d",
      "value": 24887
     }
    },
    "630d2a4aba53498b8e6f40d713fe50d1": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "649640a4dacf4edab3aba273d7e09bbf": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "672ee2ad96ac42fa90645a4049c7dd16": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "67f8fc82c7044090a0408294bc1c2d15": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_3c850c33752443afa6658a1cb997549e",
      "placeholder": "​",
      "style": "IPY_MODEL_3366b16d73d949508f24d647558db059",
      "value": "Generating train split:  85%"
     }
    },
    "682be41e57c341189bdc3e7a6b7246d3": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "68e542f3c052435f9254e135e5c481e8": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "6a39d27a5d5e484385f3d8163665641f": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "6b97acade12a49d683ec81855e1bf58a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "726309e90e0247628487e1f4816e6fd9": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "741afc0fb9a7469cac4a1d6b0dc130d8": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "764abccaae30410ba68405f44875c8d6": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7bb9e900006840a7a892a1a48d676560": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "7cc6a3332eaf4e9bb012097ca03c6ef6": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7cd0096ebb94429dab18e3226fc4cdbf": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_741afc0fb9a7469cac4a1d6b0dc130d8",
      "max": 366,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_df02d3127e634862b1029787be8908b8",
      "value": 366
     }
    },
    "83c39de970e84954b6fa043390b85d4c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_009a21c6a2dd4c5da79a7fb3eec8ff43",
       "IPY_MODEL_9059a60d370c4825a0eb1b31c9f9cd0a",
       "IPY_MODEL_028908857f134943af7b47a2503ce403"
      ],
      "layout": "IPY_MODEL_445f2ef3f71a4573ae453144dd4c5e81"
     }
    },
    "87d63881c376462b88a7703f62495a83": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_af5add21a56b4ef4945a90fed06d7c89",
       "IPY_MODEL_c0822d9ca57b4b23ba552b93f139d96e",
       "IPY_MODEL_2ec6b12a621f4ce681554397392bdda8"
      ],
      "layout": "IPY_MODEL_8de92b21ea1b4dfc966d653e0ca7043b"
     }
    },
    "89dd9177f7cd4edc87e43d5e23c5f587": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "8b30e8b778fb456bbf8af4d6931f415c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_630d2a4aba53498b8e6f40d713fe50d1",
      "placeholder": "​",
      "style": "IPY_MODEL_313d214425c541b6845f70638f8a5937",
      "value": " 24.9k/24.9k [00:00&lt;00:00, 18.5kB/s]"
     }
    },
    "8de92b21ea1b4dfc966d653e0ca7043b": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "9059a60d370c4825a0eb1b31c9f9cd0a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_db1af11912fa4774b718242b8861a18c",
      "max": 366,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_2e0511f2f1844758a6f6d10af7233a72",
      "value": 366
     }
    },
    "94aa0a38801e4fa0b79150fbd7bcc6cc": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "956dc45f3dde496d94f2d2520f62a241": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_dc1ad0316a634e0e81eecdd09d271136",
       "IPY_MODEL_5c531b5b3ce4406abde898297f4bc80b",
       "IPY_MODEL_8b30e8b778fb456bbf8af4d6931f415c"
      ],
      "layout": "IPY_MODEL_d1f7dc29912b40e7ac4a9081a4068836"
     }
    },
    "966ca413bd824a77b50a20784e8bd1b4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_044030ba2c5948d2ac6545aea773ef4a",
      "max": 199791,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_a54e00389ce148829b4db5b7439ae879",
      "value": 199791
     }
    },
    "96acfb4ec404421b8523e39b6a4bc41a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "9c573dc9c14248deb512162af5f9b0fa": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "a3384254326f49eb907bfa6d2032b1a8": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a54e00389ce148829b4db5b7439ae879": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "a70e5dadc1d547cc90da492ef9b72172": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a79295d7dc77434282636a0ef665a70b": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a8b516bf196946a09a55732d937dfe2a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "addaf03f64e9421ab8debbba4f096d7e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "af5add21a56b4ef4945a90fed06d7c89": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_bcaa24789c664ed181eb3af6c93a618e",
      "placeholder": "​",
      "style": "IPY_MODEL_e4015a34ae9744ceaa57d8b50a024d9a",
      "value": "Downloading readme: 100%"
     }
    },
    "b0b4e07185574c5eba5144a28c611971": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b2eeaecdd52343a4977954915f38bc9b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_726309e90e0247628487e1f4816e6fd9",
      "placeholder": "​",
      "style": "IPY_MODEL_e791aeda253f40d3bf28da3aaf0ec3f3",
      "value": " 68.1k/68.1k [00:00&lt;00:00, 93.5kB/s]"
     }
    },
    "b65097925371428eb2b58eec672f9b81": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "b68b7b7b072e457980e834113ff0a670": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b7e131bcb6454ccbb5de0813a734586a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b9f43527572c41849f66e100e4d2df83": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_a70e5dadc1d547cc90da492ef9b72172",
      "max": 7544,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_3ff0a924499f414ca7fd03a902b51102",
      "value": 7544
     }
    },
    "bcaa24789c664ed181eb3af6c93a618e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "c0822d9ca57b4b23ba552b93f139d96e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_23207dda3c7c45ef942fb26b6d3e8f4a",
      "max": 31241,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_0a4bcc907dbc48f3af39fac4c0652bd4",
      "value": 31241
     }
    },
    "c55cb9a98afe49d59838a3e2d88cd774": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "c56009b340984f2296ad2959e8d72f25": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_c6fa8ced2f844e28a6e5cf4b31e362b1",
      "max": 68082,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_b65097925371428eb2b58eec672f9b81",
      "value": 68082
     }
    },
    "c6fa8ced2f844e28a6e5cf4b31e362b1": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "d0cecf202f814209abe965e2ec13c49e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "d1f7dc29912b40e7ac4a9081a4068836": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "d2e3caaeded749fc807de397f79e98e7": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_09cc068788e64c1fbc1edd0992f43f42",
      "placeholder": "​",
      "style": "IPY_MODEL_46e05d2996a84b5e8f456adbb6453350",
      "value": "Generating validation split:  95%"
     }
    },
    "d7be4847987e4d6996c56eb42feb78b9": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "d8a6361f19894be1b730137b0801e4e8": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_764abccaae30410ba68405f44875c8d6",
      "placeholder": "​",
      "style": "IPY_MODEL_89dd9177f7cd4edc87e43d5e23c5f587",
      "value": "100%"
     }
    },
    "db1af11912fa4774b718242b8861a18c": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "dbb568c5b348421a9e2f9f4e07cd5f01": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_addaf03f64e9421ab8debbba4f096d7e",
      "placeholder": "​",
      "style": "IPY_MODEL_94aa0a38801e4fa0b79150fbd7bcc6cc",
      "value": "Downloading data: 100%"
     }
    },
    "dc1ad0316a634e0e81eecdd09d271136": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_f8af035c2033430ca41cb3c81719ddc8",
      "placeholder": "​",
      "style": "IPY_MODEL_682be41e57c341189bdc3e7a6b7246d3",
      "value": "Downloading builder script: 100%"
     }
    },
    "df02d3127e634862b1029787be8908b8": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "e3641728ace74d8ab4742007d1725ee8": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": "hidden",
      "width": null
     }
    },
    "e4015a34ae9744ceaa57d8b50a024d9a": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "e791aeda253f40d3bf28da3aaf0ec3f3": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "e81a3f25949247eeb696ccd3b0df3da0": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_435416a295674774a15aa700ff7ce007",
      "placeholder": "​",
      "style": "IPY_MODEL_d7be4847987e4d6996c56eb42feb78b9",
      "value": " 200k/200k [00:00&lt;00:00, 269kB/s]"
     }
    },
    "ea1af7f963e848d19ea363331027109b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_d0cecf202f814209abe965e2ec13c49e",
      "placeholder": "​",
      "style": "IPY_MODEL_331752b5913245e380752532ab15f128",
      "value": " 3/3 [00:00&lt;00:00, 36.01it/s]"
     }
    },
    "eaa70494878f4eba927868ecbbd034b4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_b0b4e07185574c5eba5144a28c611971",
      "placeholder": "​",
      "style": "IPY_MODEL_01a6160718434f7bb73bb4a094ee8b0f",
      "value": "Downloading extra modules: 100%"
     }
    },
    "ed32d5154c8e45ff91608c8dca664d8e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_d2e3caaeded749fc807de397f79e98e7",
       "IPY_MODEL_f9d799cf26574229ad1d77373cb511c5",
       "IPY_MODEL_17a314c74019462e9ba2e923b9235bed"
      ],
      "layout": "IPY_MODEL_2435607c37f2439aa1f0d545009b375e"
     }
    },
    "ed58c5b583f344cdbfea76562259190e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_672ee2ad96ac42fa90645a4049c7dd16",
      "placeholder": "​",
      "style": "IPY_MODEL_96acfb4ec404421b8523e39b6a4bc41a",
      "value": "Downloading metadata: 100%"
     }
    },
    "f0019a4884124eebb44571ca0a7b262e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_0452728577c4433d9d15eca97045d1f4",
      "placeholder": "​",
      "style": "IPY_MODEL_53938941490b4afea31c63aad4bdce0a",
      "value": " 7.54k/7.54k [00:00&lt;00:00, 8.92kB/s]"
     }
    },
    "f8af035c2033430ca41cb3c81719ddc8": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "f9d799cf26574229ad1d77373cb511c5": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_7cc6a3332eaf4e9bb012097ca03c6ef6",
      "max": 366,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_7bb9e900006840a7a892a1a48d676560",
      "value": 366
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}