diff --git a/examples/detoxification_bias/Detoxify_LM_demo.ipynb b/examples/detoxification_bias/Detoxify_LM_demo.ipynb
new file mode 100644
index 0000000..198fa8a
--- /dev/null
+++ b/examples/detoxification_bias/Detoxify_LM_demo.ipynb
@@ -0,0 +1,603 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Detoxifying Language models and Evaluating Social Bias\n",
+    "\n",
+    "This notebook serves as a demo of paritial experiments in the paper [Detoxifying Language Models Risks Marginalizing Minority Voices]((https://aclanthology.org/2021.naacl-main.190)) using the **llments** framework. We mainly perform domain-adaptive fine-tuning as the detoxification approach, and use perplexity to quantify the social bias of detoxified models with respect to language styles of different demographic groups."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import os\n",
+    "\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Preprocessing training data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Preprocess training data for fine-tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Done reading\n",
+      "FT Data Done\n"
+     ]
+    }
+   ],
+   "source": [
+    "path = \"data/raw/civilcomments/train.csv\"\n",
+    "ft_output = \"data/train/ft\"\n",
+    "pt_output = \"data/train/pt\"\n",
+    "\n",
+    "input_df = pd.read_csv(path)\n",
+    "print(\"Done reading\")\n",
+    "\n",
+    "class_sample_df = input_df[[\"target\", \"comment_text\"]]\n",
+    "# a missing step in the orignal code to remove the null values\n",
+    "class_sample_df = class_sample_df[class_sample_df.comment_text.notnull()]\n",
+    "class_sample_df = class_sample_df[(class_sample_df.target >= 0.5) | (class_sample_df.target < 0.1)]\n",
+    "class_sample_df[\"target\"] = (class_sample_df[\"target\"] >= 0.1).astype(int)\n",
+    "class_sample_df[\"comment_text\"] = class_sample_df[\"comment_text\"].apply(lambda x: x.replace(\"\\n\", \"\").replace(\"\\r\", \"\").replace('\\t', \"\"))\n",
+    "\n",
+    "# save the finetuning data\n",
+    "finetuning_df = class_sample_df[class_sample_df.target == 0]\n",
+    "finetuning_df = finetuning_df[[\"comment_text\"]]\n",
+    "ft_train, ft_valid = np.split(finetuning_df, [int(0.9*len(finetuning_df))])\n",
+    "ft_train.to_csv(os.path.join(ft_output, \"train.tsv\"), sep=\"\\t\", header=False, index=False)\n",
+    "ft_valid.to_csv(os.path.join(ft_output, \"valid.tsv\"), sep=\"\\t\", header=False, index=False)\n",
+    "print(\"FT Data Done\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# read in the pretraining data and check the column names\n",
+    "pt_train = pd.read_csv(os.path.join(pt_output, \"train.tsv\"), sep=\"\\t\", header=None)\n",
+    "ft_train = pd.read_csv(os.path.join(ft_output, \"train.tsv\"), sep=\"\\t\", header=None)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1269504\n",
+      "1139603\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(pt_train))\n",
+    "print(len(ft_train))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Scoring evaluation data: WAE vs. AAE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
+   "source": [
+    "from llments.eval.toxicity import ToxicityEvaluator\n",
+    "# create a toxicity evaluator for text scoring\n",
+    "# api_key = \"AIzaSyA0RUal_V-LnJ949JlxylIzLKv6l87zh5U\"\n",
+    "api_key = \"PASTE_YOUR_API\"\n",
+    "toxicity_evaluator = ToxicityEvaluator(api_key)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# extract content from raw text files\n",
+    "wae_samples = []\n",
+    "aave_samples = []\n",
+    "\n",
+    "with open(\"data/raw/sae_samples.txt\", \"r\") as f:\n",
+    "    for line in f:\n",
+    "        wae_samples.append(line.strip())\n",
+    "\n",
+    "with open(\"data/raw/aave_samples.txt\", \"r\") as f:\n",
+    "    for line in f:\n",
+    "        aave_samples.append(line.strip())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# evaluate the sae samples\n",
+    "wae_scores = toxicity_evaluator.evaluate_batch(wae_samples, show_progress=True)\n",
+    "aave_scores = toxicity_evaluator.evaluate_batch(aave_samples, show_progress=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# construct a dataframe for the sae samples\n",
+    "wae_df = pd.DataFrame({\"text\": wae_samples, \"toxicity\": wae_scores})\n",
+    "aave_df = pd.DataFrame({\"text\": aave_samples, \"toxicity\": aave_scores})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# save it to a jsonl file\n",
+    "target_dir = \"data/eval/translation_pairs/scored\"\n",
+    "wae_df.to_json(f\"{target_dir}/wae_samples_scores.jsonl\", orient=\"records\", force_ascii=False, lines=True)\n",
+    "aave_df.to_json(f\"{target_dir}/aave_samples_scores.jsonl\", orient=\"records\", force_ascii=False, lines=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Filtering evaluation data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "wrote data/eval/translation_pairs/filtered/nontoxic_aae.txt\n",
+      "wrote data/eval/translation_pairs/filtered/nontoxic_wae.txt\n",
+      "wrote data/eval/translation_pairs/filtered/toxic_aae.txt\n",
+      "wrote data/eval/translation_pairs/filtered/toxic_wae.txt\n"
+     ]
+    }
+   ],
+   "source": [
+    "src_folder = \"data/eval/translation_pairs/scored\"\n",
+    "out_folder = \"data/eval/translation_pairs/filtered\"\n",
+    "\n",
+    "def write_file(lines, fname):\n",
+    "    with open(fname, \"w\") as f:\n",
+    "        f.write(\"\\n\".join([l.replace(\"\\n\", \" \") for l in lines]))\n",
+    "    print(\"wrote {}\".format(fname))\n",
+    "\n",
+    "aae_df = pd.read_json(os.path.join(src_folder, \"aave_samples_scores.jsonl\"), lines=True)\n",
+    "aae_df = aae_df.rename(columns={'text': 'AAE_text', 'toxicity': 'AAE_toxicity'})\n",
+    "muse_df = pd.read_json(os.path.join(src_folder, \"wae_samples_scores.jsonl\"), lines=True)\n",
+    "muse_df = muse_df.rename(columns={'text': 'WAE_text', 'toxicity': 'WAE_toxicity'})\n",
+    "cat = pd.concat([aae_df, muse_df], axis=1)\n",
+    "\n",
+    "nontoxic_df = cat[(cat['AAE_toxicity'] < 0.5) | (cat['WAE_toxicity'] < 0.5)]\n",
+    "toxic_df = cat[(cat['AAE_toxicity'] > 0.5) & (cat['WAE_toxicity'] > 0.5)]\n",
+    "\n",
+    "# Write the full sentences\n",
+    "write_file(nontoxic_df[\"AAE_text\"], os.path.join(out_folder, \"nontoxic_aae.txt\"))\n",
+    "write_file(nontoxic_df[\"WAE_text\"], os.path.join(out_folder, \"nontoxic_wae.txt\"))\n",
+    "write_file(toxic_df[\"AAE_text\"], os.path.join(out_folder, \"toxic_aae.txt\"))\n",
+    "write_file(toxic_df[\"WAE_text\"], os.path.join(out_folder, \"toxic_wae.txt\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Detoxification: Fine-Tuning w/ Non-Toxic Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load dataset\n",
+    "train_file = \"data/train/ft/train.tsv\"\n",
+    "eval_file = \"data/train/ft/valid.tsv\"\n",
+    "\n",
+    "# load the tsv as pandas dataframe, each line is ann entry under the column \"text\"\n",
+    "train_df = pd.read_csv(train_file, sep=\"\\t\", header=None, names=[\"text\"])\n",
+    "eval_df = pd.read_csv(eval_file, sep=\"\\t\", header=None, names=[\"text\"])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of training samples:  1139603\n",
+      "Number of validation samples:  126623\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Number of training samples: \", len(train_df))\n",
+    "print(\"Number of validation samples: \", len(eval_df))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Maybe those people should realize that this is 21st century America...not 1700's frontier days.Join civilization or move somewhere without any.\n",
+      "Great First Lady, I respect her for her statement. More Presidential than her husband.\n",
+      "Same thing in Calgary. This is the only sensible thing the government could do. It's a shame for the former residents to be uprooted, and stately neighbourhood homes moved or demolished. In retrospect (always 20/20) approval for building on vulnerable flood plains should never have been granted.\n",
+      "Now das da kine house I want, real old school.  I grew up around Palolo, Ka'imuki, Kapahulu, Mo'ili'ili so it brings back planny memories.  Can smell da mosquito punk driffin' out through da bedroom window...This one is kinda city-version anyway.  Check da roof -- shingles, stedda totan. Nobody going shishi da pants when one big green mango fa'down BLAM! on top da tin roof middle of da night.\n",
+      "Thanks.  You do realize that pattyjane doesn't agree.  Thanks.\n"
+     ]
+    }
+   ],
+   "source": [
+    "samples = train_df[\"text\"][:5].to_list()\n",
+    "for sample in samples:\n",
+    "    print(sample)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from llments.lm.base.hugging_face import HuggingFaceLM, HuggingFaceLMFitter\n",
+    "from llments.lm.base.dataset_lm import DatasetLM\n",
+    "\n",
+    "# load base models and datasets we use for finetuning\n",
+    "base_gpt2_lm = HuggingFaceLM(model='gpt2')\n",
+    "base_llama2_lm = HuggingFaceLM(model='NousResearch/Llama-2-7b-hf')\n",
+    "train_dataset_lm = DatasetLM(train_df[\"text\"].to_list())\n",
+    "eval_dataset_lm = DatasetLM(eval_df[\"text\"].to_list())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# fit a GPT2 model on the finetuning dataset\n",
+    "fitted_gpt2_lm = HuggingFaceLMFitter.fit(\n",
+    "    base=base_gpt2_lm,\n",
+    "    target=train_dataset_lm,\n",
+    "    eval_target=eval_dataset_lm,\n",
+    "    output_dir=\"checkpoints/gpt2\",\n",
+    "    logging_dir=\"logs/gpt2\",\n",
+    "    batch_size=4, \n",
+    "    training_steps=22500,\n",
+    "    eval_steps=500,\n",
+    "    logging_steps=500,\n",
+    "    save_steps=2500,\n",
+    "    do_train=True, \n",
+    "    do_eval=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# fit a Llama2 model using LORA efficent finetuning\n",
+    "fitted_llama2_lm = HuggingFaceLMFitter.fit(\n",
+    "    base=base_llama2_lm,\n",
+    "    target=train_dataset_lm,\n",
+    "    eval_target=eval_dataset_lm,\n",
+    "    output_dir=\"checkpoints/Llama2-7b\",\n",
+    "    logging_dir=\"logs/Llama2-7b\",\n",
+    "    batch_size=4,\n",
+    "    training_steps=22500,\n",
+    "    eval_steps=500,\n",
+    "    logging_steps=500,\n",
+    "    save_steps=2500,\n",
+    "    do_train=True,\n",
+    "    do_eval=True, \n",
+    "    lora_alpha=32,\n",
+    "    lora_r=16)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Perplexity evaluation on WAE vs. AAE\n",
+    "\n",
+    "### This part still awaits replacement with llment code"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import TrainingArguments, Trainer, DataCollatorForLanguageModeling\n",
+    "from datasets import load_dataset\n",
+    "import math\n",
+    "\n",
+    "# helper function to evaluate the perplexity of a fine-tuned model\n",
+    "def eval_ppl(data_dir, eval_files, model_path, model_name, training_args, output_dir):\n",
+    "    \n",
+    "    checkpoint = HuggingFaceLM(model=model_path, tokenizer_path=model_name)\n",
+    "    res = []\n",
+    "\n",
+    "    # TODO: replace the following with llments operators if available, \n",
+    "    # consider a HGLM.evaluate() operator\n",
+    "    for eval_file in eval_files:\n",
+    "        eval_file_path = os.path.join(data_dir, eval_file)\n",
+    "        eval_dataset = load_dataset(\"text\", data_files=eval_file_path, split=\"train\")\n",
+    "        \n",
+    "        eval_dataset = eval_dataset.map(lambda examples: checkpoint.tokenizer(\n",
+    "            examples[\"text\"], truncation=True, padding=\"max_length\", max_length=128), batched=True)\n",
+    "\n",
+    "        data_collator = DataCollatorForLanguageModeling(tokenizer=checkpoint.tokenizer, mlm=False)\n",
+    "\n",
+    "        trainer = Trainer(\n",
+    "            model=checkpoint.model,\n",
+    "            args=training_args,\n",
+    "            data_collator=data_collator,\n",
+    "            eval_dataset=eval_dataset\n",
+    "        )\n",
+    "        eval_results = trainer.evaluate()\n",
+    "\n",
+    "        # calculate the perplexity\n",
+    "        ppl = math.exp(eval_results[\"eval_loss\"])\n",
+    "        res.append((eval_file, ppl))\n",
+    "\n",
+    "    with open(f\"{output_dir}/{model_path.split('/')[-1]}.txt\", \"w\") as f:\n",
+    "        for r in res:\n",
+    "            f.write(f\"{r[0]}: {r[1]}\\n\")\n",
+    "\n",
+    "    return res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "# helper function to plot the perplexity scores\n",
+    "def plot_ppl(eval_file_dir, checkpoint_paths, model_name):\n",
+    "\n",
+    "    data = []\n",
+    "\n",
+    "    for checkpoint_path in checkpoint_paths:\n",
+    "        checkpoint_name = checkpoint_path.split('/')[-1]\n",
+    "\n",
+    "        # read in the perplexity scores\n",
+    "        with open(f\"{eval_file_dir}/{checkpoint_name}.txt\", \"r\") as f:\n",
+    "            lines = f.readlines()\n",
+    "            for line in lines:\n",
+    "                eval_file, ppl = line.split(\":\")\n",
+    "                eval_file = eval_file.split(\".\")[0]\n",
+    "                ppl = float(ppl)\n",
+    "                train_step = float(checkpoint_name.split(\"-\")[-1]) * 3\n",
+    "                data.append((train_step, eval_file, ppl))\n",
+    "    \n",
+    "    df = pd.DataFrame(data, columns=[\"Training Step\", \"Eval File\", \"Perplexity\"])\n",
+    "\n",
+    "    # sort the df by a predefined order\n",
+    "    eval_order = [\"nontoxic_aae\", \"toxic_aae\", \"nontoxic_wae\", \"toxic_wae\"]\n",
+    "    df[\"Eval File\"] = pd.Categorical(df[\"Eval File\"], categories=eval_order, ordered=True)\n",
+    "    \n",
+    "    plt.figure(figsize=(12, 8))  # Increased figure size for better detail visibility\n",
+    "    ax = sns.lineplot(x=\"Training Step\", y=\"Perplexity\", hue=\"Eval File\", data=df, palette=\"Paired\", marker=\"o\", linewidth=2.5, markersize=8)\n",
+    "    plt.title(f\"Perplexity Scores for {model_name} DAPT Checkpoints on AAVE and WAE Samples\", fontsize=16, fontweight='bold', color='navy')\n",
+    "    plt.xlabel(\"Training Step\", fontsize=14, fontweight='bold', color='darkgreen')\n",
+    "    plt.ylabel(\"Perplexity\", fontsize=14, fontweight='bold', color='darkgreen')\n",
+    "    plt.legend(title=\"Eval File\", title_fontsize='13', fontsize='11', frameon=True, shadow=True, borderpad=1)\n",
+    "    plt.grid(True, which='both', linestyle='--', linewidth=0.5)\n",
+    "    plt.tight_layout()\n",
+    "\n",
+    "    for line in ax.lines:\n",
+    "        for x, y in zip(line.get_xdata(), line.get_ydata()):\n",
+    "            plt.text(x, y, f'{y:.2f}', color=line.get_color(), fontsize=12, verticalalignment='bottom')\n",
+    "\n",
+    "    plt.savefig(f\"{model_name}_perplexity_scores_plot.png\", dpi=300)  # Save as PNG image with high resolution\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eval_data_dir = \"data/eval/translation_pairs/filtered\"\n",
+    "eval_files = [\"nontoxic_aae.txt\", \"toxic_aae.txt\", \"nontoxic_wae.txt\", \"toxic_wae.txt\"]\n",
+    "\n",
+    "# evaluate the GPT2 model\n",
+    "if not os.path.exists(\"eval_results_gpt2\"):\n",
+    "    os.makedirs(\"eval_results_gpt2\")\n",
+    "\n",
+    "if not os.path.exists(\"trash\"):\n",
+    "    os.makedirs(\"trash\")\n",
+    "\n",
+    "training_args = TrainingArguments(\n",
+    "    output_dir=\"trash\",\n",
+    "    per_device_eval_batch_size=1,\n",
+    "    do_train=False,                                     \n",
+    "    do_eval=True,                       \n",
+    "    fp16=False,\n",
+    ")\n",
+    "\n",
+    "model_path_list = [\"gpt2\",\n",
+    "    \"checkpoints/gpt2/checkpoint-2500\",\n",
+    "    \"checkpoints/gpt2/checkpoint-5000\",\n",
+    "    \"checkpoints/gpt2/checkpoint-7500\",\n",
+    "    \"checkpoints/gpt2/checkpoint-10000\",\n",
+    "    \"checkpoints/gpt2/checkpoint-12500\",\n",
+    "    \"checkpoints/gpt2/checkpoint-15000\",\n",
+    "    \"checkpoints/gpt2/checkpoint-17500\",\n",
+    "    \"checkpoints/gpt2/checkpoint-20000\",\n",
+    "    \"checkpoints/gpt2/checkpoint-22500\"]\n",
+    "\n",
+    "for model_path in model_path_list:\n",
+    "    res = eval_ppl(eval_data_dir, eval_files, model_path, \"gpt2\", training_args, \"eval_results_gpt2\")\n",
+    "    print(res)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot the perplexity scores\n",
+    "plot_ppl(\"eval_results_gpt2\", model_path_list, \"gpt2\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# evaluate the Llama2 model\n",
+    "if not os.path.exists(\"eval_results_Llama2-7b\"):\n",
+    "    os.makedirs(\"eval_results_Llama2-7b\")\n",
+    "    \n",
+    "model_path_list = [\"NousResearch/Llama-2-7b-hf\",\n",
+    "    \"checkpoints/Llama2-7b/checkpoint-2500\",\n",
+    "    \"checkpoints/Llama2-7b/checkpoint-5000\",\n",
+    "    \"checkpoints/Llama2-7b/checkpoint-7500\",\n",
+    "    \"checkpoints/Llama2-7b/checkpoint-10000\",\n",
+    "    \"checkpoints/Llama2-7b/checkpoint-12500\",\n",
+    "    \"checkpoints/Llama2-7b/checkpoint-15000\",\n",
+    "    \"checkpoints/Llama2-7b/checkpoint-17500\",\n",
+    "    \"checkpoints/Llama2-7b/checkpoint-20000\",\n",
+    "    \"checkpoints/Llama2-7b/checkpoint-22500\"]\n",
+    "\n",
+    "for model_path in model_path_list:\n",
+    "    res = eval_ppl(eval_data_dir, eval_files, model_path, \n",
+    "                   \"NousResearch/Llama-2-7b-hf\", training_args, \"eval_results_Llama2-7b\")\n",
+    "    print(res)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot the perplexity scores\n",
+    "plot_ppl(\"eval_results_Llama2-7b\", model_path_list, \"Llama2-7b\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "detox-rep",
+   "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.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/detoxification_bias/Llama2-7b_perplexity_scores_plot.png b/examples/detoxification_bias/Llama2-7b_perplexity_scores_plot.png
new file mode 100644
index 0000000..ac10c39
Binary files /dev/null and b/examples/detoxification_bias/Llama2-7b_perplexity_scores_plot.png differ
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-0.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-0.txt
new file mode 100644
index 0000000..ff5fcc4
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-0.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 69.70890155366865
+nontoxic_wae.txt: 32.66969243018137
+toxic_aae.txt: 78.83975190870724
+toxic_wae.txt: 34.361008745995235
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-10000.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-10000.txt
new file mode 100644
index 0000000..6504a70
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-10000.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 67.54182914696298
+nontoxic_wae.txt: 31.075359169048475
+toxic_aae.txt: 82.0036723039959
+toxic_wae.txt: 35.49998927643886
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-12500.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-12500.txt
new file mode 100644
index 0000000..e2e9bae
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-12500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 67.77815390265802
+nontoxic_wae.txt: 31.276970532556494
+toxic_aae.txt: 81.52509234050257
+toxic_wae.txt: 35.5350977767934
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-15000.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-15000.txt
new file mode 100644
index 0000000..26fa191
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-15000.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 68.3272057102135
+nontoxic_wae.txt: 31.38248585097714
+toxic_aae.txt: 82.60140889429582
+toxic_wae.txt: 35.838112321343196
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-17500.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-17500.txt
new file mode 100644
index 0000000..f3b4e41
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-17500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 67.59234775016954
+nontoxic_wae.txt: 31.144420463872386
+toxic_aae.txt: 81.38755496908901
+toxic_wae.txt: 35.4503242815833
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-20000.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-20000.txt
new file mode 100644
index 0000000..c6b6cd1
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-20000.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 67.86184747351325
+nontoxic_wae.txt: 31.27768641379288
+toxic_aae.txt: 81.90585738545141
+toxic_wae.txt: 35.637521834613224
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-22500.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-22500.txt
new file mode 100644
index 0000000..dc37090
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-22500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 67.74516408958367
+nontoxic_wae.txt: 31.215354367901096
+toxic_aae.txt: 81.79559915314613
+toxic_wae.txt: 35.587613521207594
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-2500.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-2500.txt
new file mode 100644
index 0000000..6b3b938
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-2500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 66.6321874328598
+nontoxic_wae.txt: 30.936692524134642
+toxic_aae.txt: 79.52587340512012
+toxic_wae.txt: 34.702246590550345
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-5000.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-5000.txt
new file mode 100644
index 0000000..5e071f6
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-5000.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 67.37626578149742
+nontoxic_wae.txt: 30.970795258713224
+toxic_aae.txt: 80.95880530005441
+toxic_wae.txt: 34.90532807304872
diff --git a/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-7500.txt b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-7500.txt
new file mode 100644
index 0000000..0bc5cb8
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_Llama2-7b/checkpoint-7500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 66.95000277502696
+nontoxic_wae.txt: 31.028843628780926
+toxic_aae.txt: 80.02690115281109
+toxic_wae.txt: 34.852323428523675
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-0.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-0.txt
new file mode 100644
index 0000000..418682a
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-0.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 264.5613111827735
+toxic_aae.txt: 354.88802955429094
+nontoxic_wae.txt: 79.88636766808261
+toxic_wae.txt: 87.09986385246668
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-10000.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-10000.txt
new file mode 100644
index 0000000..289eddd
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-10000.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 283.09457814161146
+toxic_aae.txt: 519.3137162452938
+nontoxic_wae.txt: 76.74805248230875
+toxic_wae.txt: 115.84195781580442
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-12500.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-12500.txt
new file mode 100644
index 0000000..d5c7d42
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-12500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 287.60340638140406
+toxic_aae.txt: 533.0257307525487
+nontoxic_wae.txt: 77.95483700973249
+toxic_wae.txt: 118.03557713526929
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-15000.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-15000.txt
new file mode 100644
index 0000000..fec9ac5
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-15000.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 286.83726753582715
+toxic_aae.txt: 539.255382246365
+nontoxic_wae.txt: 77.31839234349853
+toxic_wae.txt: 117.18176009424498
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-17500.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-17500.txt
new file mode 100644
index 0000000..6929e48
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-17500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 290.3258226022549
+toxic_aae.txt: 547.6406040700206
+nontoxic_wae.txt: 77.65640006849367
+toxic_wae.txt: 118.1359174010061
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-20000.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-20000.txt
new file mode 100644
index 0000000..f79374f
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-20000.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 288.0890171791605
+toxic_aae.txt: 540.2364799077442
+nontoxic_wae.txt: 77.36334784409642
+toxic_wae.txt: 117.19003012544398
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-22500.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-22500.txt
new file mode 100644
index 0000000..c871427
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-22500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 290.12460330926433
+toxic_aae.txt: 546.1822801277702
+nontoxic_wae.txt: 77.5023623843882
+toxic_wae.txt: 117.62872928935359
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-2500.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-2500.txt
new file mode 100644
index 0000000..30e95bc
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-2500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 259.00381827232985
+toxic_aae.txt: 410.7091123707273
+nontoxic_wae.txt: 72.72051108279676
+toxic_wae.txt: 92.81906367281663
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-5000.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-5000.txt
new file mode 100644
index 0000000..05a7998
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-5000.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 258.6714391036896
+toxic_aae.txt: 424.86183050956515
+nontoxic_wae.txt: 74.07619621989392
+toxic_wae.txt: 100.88206485566259
diff --git a/examples/detoxification_bias/eval_results_gpt2/checkpoint-7500.txt b/examples/detoxification_bias/eval_results_gpt2/checkpoint-7500.txt
new file mode 100644
index 0000000..e14b1e9
--- /dev/null
+++ b/examples/detoxification_bias/eval_results_gpt2/checkpoint-7500.txt
@@ -0,0 +1,4 @@
+nontoxic_aae.txt: 268.05961816776534
+toxic_aae.txt: 473.6350588349334
+nontoxic_wae.txt: 75.44938313962443
+toxic_wae.txt: 111.1346968133227
diff --git a/examples/detoxification_bias/gpt2_perplexity_scores_plot.png b/examples/detoxification_bias/gpt2_perplexity_scores_plot.png
new file mode 100644
index 0000000..2c96a27
Binary files /dev/null and b/examples/detoxification_bias/gpt2_perplexity_scores_plot.png differ
diff --git a/examples/detoxification_bias/replication.ipynb b/examples/detoxification_bias/replication.ipynb
deleted file mode 100644
index 1cd3e20..0000000
--- a/examples/detoxification_bias/replication.ipynb
+++ /dev/null
@@ -1,1821 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import sys\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import csv\n",
-    "import os\n",
-    "import time\n",
-    "import json\n",
-    "import requests\n",
-    "from tqdm import tqdm, trange"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Preprocessing training data"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Training data for detoxifying methods"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Done reading\n",
-      "FT Data Done\n"
-     ]
-    }
-   ],
-   "source": [
-    "path = \"data/raw/civilcomments/train.csv\"\n",
-    "pplm_output = \"data/train/pplm\"\n",
-    "gedi_output = \"data/train/gedi\"\n",
-    "ft_output = \"data/train/ft\"\n",
-    "pt_output = \"data/train/pt\"\n",
-    "\n",
-    "input_df = pd.read_csv(path)\n",
-    "print(\"Done reading\")\n",
-    "\n",
-    "class_sample_df = input_df[[\"target\", \"comment_text\"]]\n",
-    "# a missing step in the orignal code to remove the null values\n",
-    "class_sample_df = class_sample_df[class_sample_df.comment_text.notnull()]\n",
-    "class_sample_df = class_sample_df[(class_sample_df.target >= 0.5) | (class_sample_df.target < 0.1)]\n",
-    "class_sample_df[\"target\"] = (class_sample_df[\"target\"] >= 0.1).astype(int)\n",
-    "class_sample_df[\"comment_text\"] = class_sample_df[\"comment_text\"].apply(lambda x: x.replace(\"\\n\", \"\").replace(\"\\r\", \"\").replace('\\t', \"\"))\n",
-    "\n",
-    "## save the pplm and gedi data\n",
-    "# class_sample_df.to_csv(os.path.join(pplm_output, \"train.tsv\"), sep=\"\\t\", header=False, index=False)\n",
-    "# print(\"PPLM Data Done\")\n",
-    "\n",
-    "# class_sample_df_swapped = class_sample_df[[\"comment_text\", \"target\"]]\n",
-    "# class_sample_df_swapped[\"target\"] = class_sample_df_swapped[\"target\"].apply(lambda x: 1 - x)\n",
-    "# gedi_train, gedi_valid = np.split(class_sample_df_swapped, [int(0.9*len(class_sample_df_swapped))])\n",
-    "# gedi_train.to_csv(os.path.join(gedi_output, \"train.tsv\"), sep=\"\\t\", header=False, index=False)\n",
-    "# gedi_valid.to_csv(os.path.join(gedi_output, \"valid.tsv\"), sep=\"\\t\", header=False, index=False)\n",
-    "# print(\"GeDi Data Done\")\n",
-    "\n",
-    "# save the finetuning data\n",
-    "finetuning_df = class_sample_df[class_sample_df.target == 0]\n",
-    "finetuning_df = finetuning_df[[\"comment_text\"]]\n",
-    "ft_train, ft_valid = np.split(finetuning_df, [int(0.9*len(finetuning_df))])\n",
-    "ft_train.to_csv(os.path.join(ft_output, \"train.tsv\"), sep=\"\\t\", header=False, index=False)\n",
-    "ft_valid.to_csv(os.path.join(ft_output, \"valid.tsv\"), sep=\"\\t\", header=False, index=False)\n",
-    "print(\"FT Data Done\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "                                                   0\n",
-      "0  This is so cool. It's like, 'would you want yo...\n",
-      "1  Thank you!! This would make my life a lot less...\n",
-      "2  This is such an urgent design problem; kudos t...\n",
-      "3  Is this something I'll be able to install on m...\n",
-      "4               haha you guys are a bunch of losers.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# read in the pretraining data and check the column names\n",
-    "pt_train = pd.read_csv(os.path.join(pt_output, \"train.tsv\"), sep=\"\\t\", header=None)\n",
-    "print(pt_train.head())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "                                                   0\n",
-      "0  This is so cool. It's like, 'would you want yo...\n",
-      "1  Thank you!! This would make my life a lot less...\n",
-      "2  This is such an urgent design problem; kudos t...\n",
-      "3  Is this something I'll be able to install on m...\n",
-      "4                                FFFFUUUUUUUUUUUUUUU\n"
-     ]
-    }
-   ],
-   "source": [
-    "ft_train = pd.read_csv(os.path.join(ft_output, \"train.tsv\"), sep=\"\\t\", header=None)\n",
-    "print(ft_train.head())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1269504\n",
-      "1139603\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(len(pt_train))\n",
-    "print(len(ft_train))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Scoring evaluation data: WAE vs. AAE"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "api_key = \"AIzaSyA0RUal_V-LnJ949JlxylIzLKv6l87zh5U\"\n",
-    "# api_key = \"PASTE_YOUR_API_KEY_HERE\"\n",
-    "url = (\"https://commentanalyzer.googleapis.com/v1alpha1/comments:analyze\" + \"?key=\" + api_key)\n",
-    "\n",
-    "def score_generations(generations_filename, scores_filename):\n",
-    "    categories = [\"toxicity\", \"severe_toxicity\", \"insult\", \"flirtation\", \\\n",
-    "                  \"profanity\", \"sexually_explicit\", \"threat\", \"identity_attack\"]\n",
-    "    generations_columns = [\"text\"] + categories\n",
-    "\n",
-    "    if os.path.exists(scores_filename):\n",
-    "        generations_df = pd.read_json(scores_filename, lines=True)\n",
-    "        start_row = generations_df.shape[0]\n",
-    "    else:\n",
-    "        generations_df = pd.DataFrame(columns=generations_columns)\n",
-    "        start_row = 0\n",
-    "\n",
-    "    with open(generations_filename) as f:\n",
-    "        for num_requests, line in tqdm(enumerate(f)):\n",
-    "            # sleep to avoid exceeding quota limit\n",
-    "            time.sleep(1.2)\n",
-    "            \n",
-    "            if num_requests == 5000:\n",
-    "                break\n",
-    "            if num_requests < start_row:\n",
-    "                continue\n",
-    "\n",
-    "            if num_requests % 500 == 0:\n",
-    "                print(\"{} | Request #{}\".format(generations_filename, num_requests))\n",
-    "                # to checkpoint because it randomly errors out sometimes, losing all of the progress\n",
-    "                generations_df.to_json(scores_filename, orient=\"records\", force_ascii=False, lines=True)\n",
-    "\n",
-    "            if line[-1] == \"\\n\":\n",
-    "                line = line[:-1]\n",
-    "\n",
-    "            data_dict = {\"comment\": {\"text\": line},\n",
-    "                         \"languages\": [\"en\"],\n",
-    "                         \"requestedAttributes\": {\"TOXICITY\":{}, \"SEVERE_TOXICITY\":{}, \"INSULT\":{}, \\\n",
-    "                                                 \"FLIRTATION\":{}, \"PROFANITY\":{}, \"SEXUALLY_EXPLICIT\":{}, \\\n",
-    "                                                 \"THREAT\":{}, \"IDENTITY_ATTACK\":{}}}\n",
-    "\n",
-    "            if len(line) == 0:\n",
-    "                row = [\"\"] + [0]*8\n",
-    "                generations_df.loc[len(generations_df), :] = row\n",
-    "            else:\n",
-    "                response = requests.post(url=url, data=json.dumps(data_dict))\n",
-    "                response_dict = json.loads(response.content)\n",
-    "                if \"attributeScores\" in response_dict:\n",
-    "                    category_scores = []\n",
-    "                    for categ in categories:\n",
-    "                        score = response_dict[\"attributeScores\"][categ.upper()][\"spanScores\"][0][\"score\"][\"value\"]\n",
-    "                        category_scores.append(score)\n",
-    "                    row = [line] + category_scores\n",
-    "                    generations_df.loc[len(generations_df), :] = row\n",
-    "                else:\n",
-    "                    print(response_dict)\n",
-    "                    break\n",
-    "            \n",
-    "            break\n",
-    "    generations_df.to_json(scores_filename, orient=\"records\", force_ascii=False, lines=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "score_generations(\"data/raw/translation_pairs/aave_samples.txt\", \n",
-    "                  \"data/eval/translation_pairs/scored/aave_samples_scores.jsonl\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "score_generations(\"data/raw/translation_pairs/sae_samples.txt\", \n",
-    "                  \"data/eval/translation_pairs/scored/wae_samples_scores.jsonl\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Filtering evaluation data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "wrote data/eval/translation_pairs/filtered/nontoxic_aae.txt\n",
-      "wrote data/eval/translation_pairs/filtered/nontoxic_wae.txt\n",
-      "wrote data/eval/translation_pairs/filtered/toxic_aae.txt\n",
-      "wrote data/eval/translation_pairs/filtered/toxic_wae.txt\n"
-     ]
-    }
-   ],
-   "source": [
-    "src_folder = \"data/eval/translation_pairs/scored\"\n",
-    "out_folder = \"data/eval/translation_pairs/filtered\"\n",
-    "\n",
-    "def write_file(lines, fname):\n",
-    "    with open(fname, \"w\") as f:\n",
-    "        f.write(\"\\n\".join([l.replace(\"\\n\", \" \") for l in lines]))\n",
-    "    print(\"wrote {}\".format(fname))\n",
-    "\n",
-    "aae_df = pd.read_json(os.path.join(src_folder, \"aave_samples_scores.jsonl\"), lines=True)\n",
-    "aae_df = aae_df.rename(columns={'text': 'AAE_text', 'toxicity': 'AAE_toxicity'})\n",
-    "muse_df = pd.read_json(os.path.join(src_folder, \"wae_samples_scores.jsonl\"), lines=True)\n",
-    "muse_df = muse_df.rename(columns={'text': 'WAE_text', 'toxicity': 'WAE_toxicity'})\n",
-    "cat = pd.concat([aae_df, muse_df], axis=1)\n",
-    "\n",
-    "nontoxic_df = cat[(cat['AAE_toxicity'] < 0.5) | (cat['WAE_toxicity'] < 0.5)]\n",
-    "toxic_df = cat[(cat['AAE_toxicity'] > 0.5) & (cat['WAE_toxicity'] > 0.5)]\n",
-    "\n",
-    "# Write the full sentences\n",
-    "write_file(nontoxic_df[\"AAE_text\"], os.path.join(out_folder, \"nontoxic_aae.txt\"))\n",
-    "write_file(nontoxic_df[\"WAE_text\"], os.path.join(out_folder, \"nontoxic_wae.txt\"))\n",
-    "write_file(toxic_df[\"AAE_text\"], os.path.join(out_folder, \"toxic_aae.txt\"))\n",
-    "write_file(toxic_df[\"WAE_text\"], os.path.join(out_folder, \"toxic_wae.txt\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Detoxification: Fine-Tuning"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
-   "source": [
-    "import argparse\n",
-    "import os\n",
-    "import math\n",
-    "from random import randint\n",
-    "from tqdm import tqdm\n",
-    "\n",
-    "import torch\n",
-    "import torch.optim as optim\n",
-    "from torch.utils.data import DataLoader\n",
-    "\n",
-    "import transformers\n",
-    "from transformers import (\n",
-    "    AutoTokenizer, \n",
-    "    AutoModelForCausalLM, \n",
-    "    BitsAndBytesConfig, \n",
-    "    DataCollatorForLanguageModeling, \n",
-    "    Trainer,\n",
-    "    TrainingArguments,\n",
-    "    set_seed,\n",
-    ")\n",
-    "from datasets import Dataset, load_dataset\n",
-    "from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training\n",
-    "\n",
-    "torch.set_float32_matmul_precision(\"high\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# load dataset\n",
-    "train_file = \"data/train/ft/train.tsv\"\n",
-    "eval_file = \"data/train/ft/valid.tsv\"\n",
-    "\n",
-    "train_dataset = load_dataset(\"text\", data_files=train_file, split=\"train\")\n",
-    "eval_dataset = load_dataset(\"text\", data_files=eval_file, split=\"train\")\n",
-    "\n",
-    "# take 10% of the training data\n",
-    "train_subset = train_dataset.train_test_split(test_size=0.1, seed=221)[\"test\"]\n",
-    "eval_subset = eval_dataset.train_test_split(test_size=0.1, seed=221)[\"test\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 46,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Number of training samples:  113961\n",
-      "Number of validation samples:  12663\n"
-     ]
-    }
-   ],
-   "source": [
-    "# print the number of samples in the training and validation sets\n",
-    "print(\"Number of training samples: \", len(train_subset))\n",
-    "print(\"Number of validation samples: \", len(eval_subset))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 47,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def tokenize_function(examples, tokenizer):\n",
-    "    if not tokenizer.pad_token_id:\n",
-    "        tokenizer.pad_token = tokenizer.eos_token\n",
-    "    return tokenizer(examples[\"text\"], truncation=True, padding=\"max_length\", max_length=128)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def print_trainable_params(model):\n",
-    "    trainable_params = 0\n",
-    "    all_param = 0\n",
-    "    for _, param in model.named_parameters():\n",
-    "        all_param += param.numel()\n",
-    "        if param.requires_grad:\n",
-    "            trainable_params += param.numel()\n",
-    "    print(\n",
-    "        f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}\"\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# model_path = \"gpt2\"\n",
-    "model_path = \"NousResearch/Llama-2-7b-hf\"\n",
-    "\n",
-    "checkpoint_dir = f\"checkpoints/ft-{model_path}\"\n",
-    "cache_dir = f\"cache/ft-{model_path}\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# For QLoRA finetuning\n",
-    "# bnb config\n",
-    "bnb_config = BitsAndBytesConfig(\n",
-    "    load_in_4bit=True,\n",
-    "    bnb_4bit_compute_dtype=torch.bfloat16,\n",
-    "    bnb_4bit_use_double_quant=True,\n",
-    "    bnb_4bit_quant_type='nf4',\n",
-    ")\n",
-    "\n",
-    "# lora config\n",
-    "lora_config = LoraConfig(\n",
-    "    r=8,\n",
-    "    lora_alpha=32,\n",
-    "    target_modules=[\"q_proj\", \"k_proj\", \"v_proj\"],\n",
-    "    lora_dropout=0.05,\n",
-    "    bias=\"none\",\n",
-    "    task_type='CAUSAL_LM',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "`low_cpu_mem_usage` was None, now set to True since model is quantized.\n",
-      "Loading checkpoint shards: 100%|██████████| 2/2 [00:03<00:00,  1.56s/it]\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/transformers/generation/configuration_utils.py:492: UserWarning: `do_sample` is set to `False`. However, `temperature` is set to `0.9` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `temperature`. This was detected when initializing the generation config instance, which means the corresponding file may hold incorrect parameterization and should be fixed.\n",
-      "  warnings.warn(\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/transformers/generation/configuration_utils.py:497: UserWarning: `do_sample` is set to `False`. However, `top_p` is set to `0.6` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `top_p`. This was detected when initializing the generation config instance, which means the corresponding file may hold incorrect parameterization and should be fixed.\n",
-      "  warnings.warn(\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/transformers/generation/configuration_utils.py:492: UserWarning: `do_sample` is set to `False`. However, `temperature` is set to `0.9` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `temperature`.\n",
-      "  warnings.warn(\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/transformers/generation/configuration_utils.py:497: UserWarning: `do_sample` is set to `False`. However, `top_p` is set to `0.6` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `top_p`.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
-   "source": [
-    "# for gpt2 model loading\n",
-    "# model = AutoModelForCausalLM.from_pretrained(model_path)\n",
-    "\n",
-    "# for llama-2-7b model loading\n",
-    "model = AutoModelForCausalLM.from_pretrained(\n",
-    "    model_path,\n",
-    "    quantization_config=bnb_config,\n",
-    "    do_sample=True,\n",
-    "    use_cache=True,\n",
-    "    cache_dir=cache_dir,\n",
-    ")\n",
-    "\n",
-    "tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)\n",
-    "checkpoint_dir = f\"checkpoints/ft-{model_path}\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "trainable params: 6291456 || all params: 3506704384 || trainable%: 0.1794122147480111\n"
-     ]
-    }
-   ],
-   "source": [
-    "model = prepare_model_for_kbit_training(model)\n",
-    "model = get_peft_model(model, lora_config)\n",
-    "print_trainable_params(model)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 52,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Map: 100%|██████████| 113961/113961 [00:21<00:00, 5321.13 examples/s]\n",
-      "Map: 100%|██████████| 12663/12663 [00:02<00:00, 5651.27 examples/s]\n"
-     ]
-    }
-   ],
-   "source": [
-    "train_dataset = train_subset.map(lambda examples: tokenize_function(examples, tokenizer), batched=True)\n",
-    "eval_dataset = eval_subset.map(lambda examples: tokenize_function(examples, tokenizer), batched=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "number of training samples:  113961\n",
-      "number of validation samples:  12663\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"number of training samples: \", len(train_dataset))\n",
-    "print(\"number of validation samples: \", len(eval_dataset))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# for GPT2\n",
-    "# training_args = TrainingArguments(\n",
-    "#     output_dir=checkpoint_dir,\n",
-    "#     do_train=True,\n",
-    "#     do_eval=True,\n",
-    "#     per_device_train_batch_size=16,\n",
-    "#     per_device_eval_batch_size=16,\n",
-    "#     learning_rate=5e-5,\n",
-    "#     weight_decay=0.01,\n",
-    "#     adam_beta2=0.98,\n",
-    "#     save_total_limit=3,\n",
-    "#     save_steps=1000,\n",
-    "#     fp16=True,\n",
-    "#     warmup_steps=5000,\n",
-    "#     max_grad_norm=1e10,\n",
-    "#     max_steps=10000,\n",
-    "#     overwrite_output_dir=True,\n",
-    "#     evaluation_strategy=\"steps\",\n",
-    "#     eval_steps=1000,\n",
-    "#     prediction_loss_only=True\n",
-    "# )\n",
-    "\n",
-    "# for llama-2-7b\n",
-    "training_args = TrainingArguments(\n",
-    "    output_dir=checkpoint_dir,\n",
-    "    do_train=True,\n",
-    "    do_eval=True,\n",
-    "    per_device_train_batch_size=16,\n",
-    "    per_device_eval_batch_size=16,\n",
-    "    gradient_accumulation_steps=1,\n",
-    "    learning_rate=1e-4,\n",
-    "    weight_decay=0.01,\n",
-    "    optim=\"adamw_8bit\",\n",
-    "    save_total_limit=5,\n",
-    "    fp16=False,\n",
-    "    num_train_epochs=1,\n",
-    "    lr_scheduler_type=\"linear\",\n",
-    "    warmup_ratio=0.05,\n",
-    "    max_grad_norm=0.3,\n",
-    "    overwrite_output_dir=True,\n",
-    "    evaluation_strategy=\"steps\",\n",
-    "    eval_steps=100,\n",
-    "    save_steps=1000,\n",
-    "    prediction_loss_only=True,\n",
-    "    load_best_model_at_end=True,\n",
-    "    metric_for_best_model=\"eval_loss\"\n",
-    ")\n",
-    "\n",
-    "if not os.path.exists(training_args.output_dir):\n",
-    "    os.makedirs(training_args.output_dir)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/accelerate/accelerator.py:432: FutureWarning: Passing the following arguments to `Accelerator` is deprecated and will be removed in version 1.0 of Accelerate: dict_keys(['dispatch_batches', 'split_batches', 'even_batches', 'use_seedable_sampler']). Please pass an `accelerate.DataLoaderConfiguration` instead: \n",
-      "dataloader_config = DataLoaderConfiguration(dispatch_batches=None, split_batches=False, even_batches=True, use_seedable_sampler=True)\n",
-      "  warnings.warn(\n",
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    }
-   ],
-   "source": [
-    "trainer = Trainer(\n",
-    "    model=model,\n",
-    "    args=training_args,\n",
-    "    data_collator=data_collator,\n",
-    "    train_dataset=train_dataset,\n",
-    "    eval_dataset=eval_dataset\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='10000' max='10000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [10000/10000 52:15, Epoch 0/1]\n",
-       "    </div>\n",
-       "    <table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       " <tr style=\"text-align: left;\">\n",
-       "      <th>Step</th>\n",
-       "      <th>Training Loss</th>\n",
-       "      <th>Validation Loss</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <td>1000</td>\n",
-       "      <td>4.085300</td>\n",
-       "      <td>3.925719</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>2000</td>\n",
-       "      <td>4.021200</td>\n",
-       "      <td>3.898861</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>3000</td>\n",
-       "      <td>3.991200</td>\n",
-       "      <td>3.883732</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>4000</td>\n",
-       "      <td>3.980300</td>\n",
-       "      <td>3.875050</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>5000</td>\n",
-       "      <td>3.996800</td>\n",
-       "      <td>3.880772</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>6000</td>\n",
-       "      <td>3.994500</td>\n",
-       "      <td>3.881470</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>7000</td>\n",
-       "      <td>3.971300</td>\n",
-       "      <td>3.874589</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>8000</td>\n",
-       "      <td>3.976700</td>\n",
-       "      <td>3.867913</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>9000</td>\n",
-       "      <td>3.953100</td>\n",
-       "      <td>3.863400</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <td>10000</td>\n",
-       "      <td>3.957500</td>\n",
-       "      <td>3.859973</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table><p>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Training for GPT2\n",
-    "trainer.train()\n",
-    "trainer.save_model()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "('checkpoints/ft-gpt2/tokenizer_config.json',\n",
-       " 'checkpoints/ft-gpt2/special_tokens_map.json',\n",
-       " 'checkpoints/ft-gpt2/vocab.json',\n",
-       " 'checkpoints/ft-gpt2/merges.txt',\n",
-       " 'checkpoints/ft-gpt2/added_tokens.json',\n",
-       " 'checkpoints/ft-gpt2/tokenizer.json')"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# re-save the tokenizer to the same directory\n",
-    "tokenizer.save_pretrained(training_args.output_dir)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Training for llama-2-7b\n",
-    "trainer.train()\n",
-    "trainer.save_model()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Perplexity evaluation on WAE vs. AAE"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# set seed\n",
-    "set_seed(221)\n",
-    "\n",
-    "# load the pt and ft models\n",
-    "eval_data_dir = \"data/eval/translation_pairs/filtered\"\n",
-    "eval_files = [\"nontoxic_aae.txt\", \"nontoxic_wae.txt\", \"toxic_aae.txt\", \"toxic_wae.txt\"]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# base_model_path = \"gpt2\"\n",
-    "# ft_model_path = \"checkpoints/ft-gpt2/checkpoint-10000\"\n",
-    "# ft_tokenizer_dir = \"checkpoints/ft-gpt2\"\n",
-    "\n",
-    "base_model_path = \"NousResearch/Llama-2-7b-hf\"\n",
-    "ft_model_path = \"checkpoints/ft-Llama-2-7b-hf/checkpoint-3000\"\n",
-    "ft_tokenizer_dir = \"checkpoints/ft-Llama-2-7b-hf\"\n",
-    "\n",
-    "# base_model_path = \"roberta-base\"\n",
-    "# ft_model_path = \"checkpoints/ft-RoBERTa/checkpoint-3000\"\n",
-    "# ft_tokenizer_dir = \"checkpoints/ft-RoBERTa\"\n",
-    "\n",
-    "# base_model_path = \"bert-base-uncased\"\n",
-    "# ft_model_path = \"checkpoints/ft-bert/checkpoint-5000\"\n",
-    "# ft_tokenizer_dir = \"checkpoints/ft-bert\"\n",
-    "\n",
-    "# base_model_path = \"xlm-mlm-en-2048\"\n",
-    "# ft_model_path = \"checkpoints/ft-XLM/checkpoint-3000\"\n",
-    "# ft_tokenizer_dir = \"checkpoints/ft-XLM\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# training arguments for solely evaluation\n",
-    "training_args = TrainingArguments(\n",
-    "    output_dir=\"trash\",\n",
-    "    per_device_eval_batch_size=16,\n",
-    "    do_train=False,                                     \n",
-    "    do_eval=True,                       \n",
-    "    fp16=False,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# mkdir for the eval results\n",
-    "if not os.path.exists(\"eval_results\"):\n",
-    "    os.makedirs(\"eval_results\")\n",
-    "\n",
-    "# mkdir for the trash folder to avoid errors\n",
-    "if not os.path.exists(\"trash\"):\n",
-    "    os.makedirs(\"trash\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def load_checkpoint(model_path, tokenizer_dir):\n",
-    "    model = AutoModelForCausalLM.from_pretrained(model_path, from_tf=bool(\".ckpt\" in model_path))\n",
-    "    tokenizer = AutoTokenizer.from_pretrained(tokenizer_dir)\n",
-    "\n",
-    "    if not tokenizer.pad_token:\n",
-    "        tokenizer.pad_token = tokenizer.eos_token\n",
-    "\n",
-    "    return model, tokenizer"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def eval_ppl(data_dir, eval_files, model, tokenizer, training_args):\n",
-    "    res = []\n",
-    "    for eval_file in eval_files:\n",
-    "        eval_file_path = os.path.join(data_dir, eval_file)\n",
-    "        eval_dataset = load_dataset(\"text\", data_files=eval_file_path, split=\"train\")\n",
-    "\n",
-    "        eval_dataset = eval_dataset.map(lambda examples: tokenizer(\n",
-    "            examples[\"text\"], truncation=True, padding=\"max_length\", max_length=128), batched=True)\n",
-    "\n",
-    "        data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)\n",
-    "\n",
-    "        trainer = Trainer(\n",
-    "            model=model,\n",
-    "            args=training_args,\n",
-    "            data_collator=data_collator,\n",
-    "            eval_dataset=eval_dataset\n",
-    "        )\n",
-    "\n",
-    "        eval_results = trainer.evaluate()\n",
-    "\n",
-    "        # calculate the perplexity\n",
-    "        ppl = math.exp(eval_results[\"eval_loss\"])\n",
-    "\n",
-    "        print(f\"Perplexity for {eval_file}: {ppl}\")\n",
-    "        res.append((eval_file, ppl))\n",
-    "\n",
-    "        with open(f\"eval_results/{eval_file}.txt\", \"w\") as f:\n",
-    "            f.write(f\"Perplexity: {ppl}\")\n",
-    "\n",
-    "    return res"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "import numpy as np\n",
-    "\n",
-    "# seaborn plot the results as grouped bar chart, results for each evaluation file are grouped together\n",
-    "def plot_perplexity(eval_files, eval_results, ft_direct_eval_results, model_name):\n",
-    "    eval_files = [f.split(\".\")[0] for f in eval_files]\n",
-    "    ppl_scores = [r[1] for r in eval_results]\n",
-    "    ft_ppl_scores = [r[1] for r in ft_direct_eval_results]\n",
-    "\n",
-    "    gpt2_model_name = [model_name] * len(eval_files)\n",
-    "    ft_model_name = [\"FT-Non-Toxic\"] * len(eval_files)\n",
-    "\n",
-    "    df = pd.DataFrame({\n",
-    "        \"Model\": gpt2_model_name + ft_model_name,\n",
-    "        \"Eval File\": eval_files*2,\n",
-    "        \"Perplexity\": ppl_scores + ft_ppl_scores\n",
-    "    })\n",
-    "\n",
-    "    plt.figure(figsize=(10, 6))\n",
-    "    sns.barplot(x=\"Eval File\", y=\"Perplexity\", hue=\"Model\", data=df, palette=\"viridis\")\n",
-    "    # add the perplexity scores on top of the bars\n",
-    "    for i in range(len(eval_files)):\n",
-    "        plt.text(i-0.3, ppl_scores[i] + 5, f\"{ppl_scores[i]:.2f}\", fontsize=10, color=\"red\")\n",
-    "        plt.text(i+0.1, ft_ppl_scores[i] + 5, f\"{ft_ppl_scores[i]:.2f}\", fontsize=10, color=\"red\")\n",
-    "\n",
-    "    plt.title(f\"Perplexity Scores for {model_name} before and after DAPT detoxification\")\n",
-    "\n",
-    "    # save the plot as a png\n",
-    "    plt.savefig(f\"eval_results/{model_name}.png\")\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Map: 100%|██████████| 1661/1661 [00:00<00:00, 7140.30 examples/s]\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/accelerate/accelerator.py:432: FutureWarning: Passing the following arguments to `Accelerator` is deprecated and will be removed in version 1.0 of Accelerate: dict_keys(['dispatch_batches', 'split_batches', 'even_batches', 'use_seedable_sampler']). Please pass an `accelerate.DataLoaderConfiguration` instead: \n",
-      "dataloader_config = DataLoaderConfiguration(dispatch_batches=None, split_batches=False, even_batches=True, use_seedable_sampler=True)\n",
-      "  warnings.warn(\n",
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:68: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
-      "  warnings.warn('Was asked to gather along dimension 0, but all '\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='104' max='104' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [104/104 09:41]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for nontoxic_aae.txt: 111.01849063255918\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Map: 100%|██████████| 1661/1661 [00:00<00:00, 7324.90 examples/s]\n",
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='104' max='104' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [104/104 09:41]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for nontoxic_wae.txt: 51.169197962653165\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Map: 100%|██████████| 358/358 [00:00<00:00, 6334.79 examples/s]\n",
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='23' max='23' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [23/23 02:04]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for toxic_aae.txt: 120.5358675681509\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Map: 100%|██████████| 358/358 [00:00<00:00, 6846.75 examples/s]\n",
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='23' max='23' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [23/23 02:04]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for toxic_wae.txt: 52.33408085572579\n"
-     ]
-    }
-   ],
-   "source": [
-    "# evaluate on the pretraining llama-2-7b model\n",
-    "model, tokenizer = load_checkpoint(base_model_path, base_model_path)\n",
-    "base_ppls = eval_ppl(eval_data_dir, eval_files, model, tokenizer, training_args)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Loading checkpoint shards: 100%|██████████| 2/2 [00:03<00:00,  1.68s/it]\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/transformers/generation/configuration_utils.py:492: UserWarning: `do_sample` is set to `False`. However, `temperature` is set to `0.9` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `temperature`. This was detected when initializing the generation config instance, which means the corresponding file may hold incorrect parameterization and should be fixed.\n",
-      "  warnings.warn(\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/transformers/generation/configuration_utils.py:497: UserWarning: `do_sample` is set to `False`. However, `top_p` is set to `0.6` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `top_p`. This was detected when initializing the generation config instance, which means the corresponding file may hold incorrect parameterization and should be fixed.\n",
-      "  warnings.warn(\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/transformers/generation/configuration_utils.py:492: UserWarning: `do_sample` is set to `False`. However, `temperature` is set to `0.9` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `temperature`.\n",
-      "  warnings.warn(\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/transformers/generation/configuration_utils.py:497: UserWarning: `do_sample` is set to `False`. However, `top_p` is set to `0.6` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `top_p`.\n",
-      "  warnings.warn(\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/accelerate/accelerator.py:432: FutureWarning: Passing the following arguments to `Accelerator` is deprecated and will be removed in version 1.0 of Accelerate: dict_keys(['dispatch_batches', 'split_batches', 'even_batches', 'use_seedable_sampler']). Please pass an `accelerate.DataLoaderConfiguration` instead: \n",
-      "dataloader_config = DataLoaderConfiguration(dispatch_batches=None, split_batches=False, even_batches=True, use_seedable_sampler=True)\n",
-      "  warnings.warn(\n",
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n",
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/torch/nn/parallel/_functions.py:68: UserWarning: Was asked to gather along dimension 0, but all input tensors were scalars; will instead unsqueeze and return a vector.\n",
-      "  warnings.warn('Was asked to gather along dimension 0, but all '\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='104' max='104' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [104/104 09:44]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for nontoxic_aae.txt: 102.4070789988836\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Map: 100%|██████████| 1661/1661 [00:00<00:00, 7395.93 examples/s]\n",
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='104' max='104' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [104/104 09:44]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for nontoxic_wae.txt: 50.16341941456162\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='23' max='23' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [23/23 02:04]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for toxic_aae.txt: 115.93280428028879\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='23' max='23' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [23/23 02:04]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for toxic_wae.txt: 54.914365163352855\n"
-     ]
-    }
-   ],
-   "source": [
-    "# evaluate on the fine-tuned llama-2-7b model\n",
-    "model, tokenizer = load_checkpoint(ft_model_path, base_model_path)\n",
-    "ft_ppts = eval_ppl(eval_data_dir, eval_files, model, tokenizer, training_args)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# plot the results\n",
-    "plot_perplexity(eval_files, base_ppls, ft_ppts, \"Llama-2-7b\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/qliu3/anaconda3/envs/detox-nonpin/lib/python3.10/site-packages/accelerate/accelerator.py:432: FutureWarning: Passing the following arguments to `Accelerator` is deprecated and will be removed in version 1.0 of Accelerate: dict_keys(['dispatch_batches', 'split_batches', 'even_batches', 'use_seedable_sampler']). Please pass an `accelerate.DataLoaderConfiguration` instead: \n",
-      "dataloader_config = DataLoaderConfiguration(dispatch_batches=None, split_batches=False, even_batches=True, use_seedable_sampler=True)\n",
-      "  warnings.warn(\n",
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='208' max='208' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [208/208 00:03]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for nontoxic_aae.txt: 259.0174039195381\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Map: 100%|██████████| 1661/1661 [00:00<00:00, 8555.76 examples/s]\n",
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='208' max='208' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [208/208 00:03]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for nontoxic_wae.txt: 76.50222695423253\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='45' max='45' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [45/45 00:00]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for toxic_aae.txt: 343.32790761921865\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='45' max='45' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [45/45 00:00]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for toxic_wae.txt: 83.61518859896252\n"
-     ]
-    }
-   ],
-   "source": [
-    "# evaluate on the pretraining gpt2 model\n",
-    "model, tokenizer = load_checkpoint(base_model_path, base_model_path)\n",
-    "base_ppls = eval_ppl(eval_data_dir, eval_files, model, tokenizer, training_args)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='208' max='208' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [208/208 00:03]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for nontoxic_aae.txt: 267.6113424507791\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='208' max='208' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [208/208 00:03]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for nontoxic_wae.txt: 71.9859627354237\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='45' max='45' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [45/45 00:00]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for toxic_aae.txt: 462.59801706473075\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "    <div>\n",
-       "      \n",
-       "      <progress value='45' max='45' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
-       "      [45/45 00:00]\n",
-       "    </div>\n",
-       "    "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Perplexity for toxic_wae.txt: 104.06197441403663\n"
-     ]
-    }
-   ],
-   "source": [
-    "model, tokenizer = load_checkpoint(ft_model_path, ft_tokenizer_dir)\n",
-    "ft_ppts = eval_ppl(eval_data_dir, eval_files, model, tokenizer, training_args)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1IAAAIjCAYAAAAJLyrXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1pElEQVR4nO3de3yO9ePH8fe92Xm2mcPmMOZ8PicWQuSQRJRIjBSVsxJKOVUqipSofkU5pIiKcorIOS2kHEKEGCJjkw37/P64vru5bWPXmp28no/H/djuz/W5Ptfnunfd9/bedX0+l8MYYwQAAAAASDO3rO4AAAAAAOQ0BCkAAAAAsIkgBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpIBtavXq1HA6HVq9efdO20bhxYzVu3PimtX8ri42N1WOPPabQ0FA5HA4NHDgwq7uUbXTv3l3+/v4Z3u748eNVqlQpubu7q0aNGhnefnZ2Mz4v9u7dq+bNmyswMFAOh0NffvllhrUNS2Z8zv9XM2bMkMPh0MGDB13KU3q/hYeHq3v37pnex1GjRsnhcGT6dgGJIAU4f1EkPby9vVWuXDn17dtXx48fz+ruZZqjR49q1KhR2rZtW4a3vW7dOrVq1UpFixaVt7e3ihcvrjZt2mjOnDkZvq3s4JVXXtGMGTP05JNPaubMmeratWtWd8m2V155JcU/nrds2aK+ffuqcuXK8vPzU/HixdWxY0f9/vvvmd/J/1m+fLmeffZZ1a9fX9OnT9crr7ySZX3JLSIjI7Vjxw69/PLLmjlzpm677TbNmTNHkyZNytR+NG7c2PnZ7ObmpoCAAJUvX15du3bVihUrrrvurl27nJ/pZ86cuWH7DodDwcHBqlOnjj766CMlJiY6w05aHplpw4YNGjVqVKr7dTNlxfvt/PnzGjVqVLYOnbg15cnqDgDZxZgxY1SyZElduHBB69at09SpU/Xtt9/q119/la+vb1Z3L8MtX77c5fnRo0c1evRohYeHZ+h/9OfNm6eHHnpINWrU0IABA5QvXz4dOHBAP/zwgz744AM9/PDDGbat7GLVqlWqV6+eRo4cmdVdSbdXXnlFDzzwgNq1a+dS/tprr2n9+vV68MEHVa1aNUVHR+udd95RrVq1tGnTJlWpUiXT+7pq1Sq5ubnpww8/lKenZ6ZvP7f5999/tXHjRj3//PPq27evs3zOnDn69ddfM/0Ma7FixTRu3DhJUlxcnPbt26cFCxZo1qxZ6tixo2bNmiUPD49k682aNUuhoaH6559/NH/+fD322GM3bP/kyZP65JNP1LNnT/3+++8aNGiQZs6c6VJ/+PDh8vf31/PPP5/Be5p2GzZs0OjRo9W9e3cFBQXdtO107dpVnTp1kpeXl7Mstffbnj175OZ2c/4/f/78eY0ePVqSkl1JMWLECA0bNuymbBe4EYIU8D+tWrXSbbfdJkl67LHHlD9/fr355pv66quv1Llz5//U9vnz57NdGMusPzhHjRqlSpUqadOmTcm2eeLEiUzpgyQZY3ThwgX5+Pjc9G2dOHFClSpVyrD2Ll26pMTExGwREgYPHqw5c+a49OWhhx5S1apV9eqrr2rWrFmZ3qcTJ07Ix8cnw16fzDxWsqOTJ09K0k39Az1JYmKiEhIS5O3tnWqdwMBAPfLIIy5lr776qvr37693331X4eHheu2111yWG2M0Z84cPfzwwzpw4IBmz56dapC6tv3evXurfPnyeueddzR27NgUt12gQIFk5bmRu7u73N3dXcpSe79dHbYyU548eZQnD3/OImtwaR+QirvuukuSdODAAWfZrFmzVLt2bfn4+Cg4OFidOnXS4cOHXdZr3LixqlSpoqioKN15553y9fXVc889J8m6hvzee+/V8uXLVaNGDXl7e6tSpUpasGBBmvq0efNmtWzZUoGBgfL19VWjRo20fv165/Jdu3bJx8dH3bp1c1lv3bp1cnd319ChQ136mfSfvdWrV6tOnTqSpB49ejgvVZkxY4ZGjhwpDw8P5x9XV+vVq5eCgoJ04cKFVPu8f/9+1alTJ8U/cgsVKuTyPDExUW+99ZaqVq0qb29vFSxYUC1bttRPP/3krHPp0iWNHTtWpUuXlpeXl8LDw/Xcc88pPj7epa2k13rZsmW67bbb5OPjo/fee0+SdObMGQ0cOFBhYWHy8vJSmTJl9NprrykxMdGljblz56p27drKmzevAgICVLVqVb311lup7mvSZUAHDhzQN99843wdk8YXnDhxQj179lRISIi8vb1VvXp1ffzxxy5tHDx4UA6HQxMmTNCkSZOc+7lz585Ut/vvv/+qf//+KlCggPLmzav77rtPf/31lxwOh0aNGuWslzSWYPfu3erYsaMCAgKUP39+DRgwwOVn6HA4FBcXp48//ti5D0ljH+64445kP8uyZcuqcuXK2rVrV6p9vNYff/yhFi1ayM/PT0WKFNGYMWNkjHGpk5iYqEmTJqly5cry9vZWSEiIevfurX/++celr9OnT1dcXJzLcStl7rGSkq+++kqtW7dWkSJF5OXlpdKlS2vs2LG6fPmyS72kz4ydO3eqSZMm8vX1VdGiRfX6668na/PIkSNq166d/Pz8VKhQIQ0aNCjZ/qTmzz//1FNPPaXy5cvLx8dH+fPn14MPPugy/mXUqFEqUaKEJGnIkCFyOBwKDw9X48aN9c033+jPP/90vs7h4eHO9eLj4zVy5EiVKVNGXl5eCgsL07PPPpusbw6HQ3379tXs2bNVuXJleXl5aenSpWnq/9Xc3d01efJkVapUSe+8845iYmJclq9fv14HDx5Up06d1KlTJ/3www86cuRImtr29fVVvXr1FBcXl+LnXnrY+bnd6HN+1KhRGjJkiCSpZMmSyT5nbnTcG2PUpEkTFSxY0OWfWQkJCapatapKly6tuLg4ScnHSF3v/ZbSGKkzZ85o0KBBCg8Pl5eXl4oVK6Zu3brp77//dm7zxRdfVO3atRUYGCg/Pz81bNhQ33//vbONgwcPqmDBgpKk0aNHO7eb9NmW0hgpu+/9devW6fbbb5e3t7dKlSqlTz75JNWfJeDCALe46dOnG0lmy5YtLuVvvfWWkWSmTZtmjDHmpZdeMg6Hwzz00EPm3XffNaNHjzYFChQw4eHh5p9//nGu16hRIxMaGmoKFixo+vXrZ9577z3z5ZdfGmOMKVGihClXrpwJCgoyw4YNM2+++aapWrWqcXNzM8uXL3e28f333xtJ5vvvv3eWrVy50nh6epqIiAjzxhtvmIkTJ5pq1aoZT09Ps3nzZme98ePHG0nmq6++MsYYExsba0qXLm0qVapkLly44NLPRo0aGWOMiY6ONmPGjDGSTK9evczMmTPNzJkzzf79+83evXuNJPP222+7vD7x8fEmX7585tFHH73u61uuXDkTFhZmDh8+fIOfhDHdu3c3kkyrVq3MpEmTzIQJE0zbtm1dth0ZGWkkmQceeMBMmTLFdOvWzUgy7dq1c2mrRIkSpkyZMiZfvnxm2LBhZtq0aeb77783cXFxplq1aiZ//vzmueeeM9OmTTPdunUzDofDDBgwwLn+8uXLjSTTtGlTM2XKFDNlyhTTt29f8+CDD6ba/+joaDNz5kxToEABU6NGDefrGBsba86fP28qVqxoPDw8zKBBg8zkyZNNw4YNjSQzadIkZxsHDhwwkkylSpVMqVKlzKuvvmomTpxo/vzzz1S327FjRyPJdO3a1UyZMsV07NjRVK9e3UgyI0eOdNYbOXKkkWSqVq1q2rRpY9555x3zyCOPONdNMnPmTOPl5WUaNmzo3IcNGzakuv3ExERTtGhR07x581TrJImMjDTe3t6mbNmypmvXruadd94x9957r5FkXnjhBZe6jz32mMmTJ495/PHHzbRp08zQoUONn5+fqVOnjklISHD2tWHDhsbLy8vluE3aVmYcK6lp166d6dixoxk/fryZOnWqefDBB40k88wzz7jUa9SokSlSpIgJCwszAwYMMO+++6656667jCTz7bffOuudP3/elCtXznh7e5tnn33WTJo0ydSuXdtUq1Yt2edFSubNm2eqV69uXnzxRfP++++b5557zuTLl8+UKFHCxMXFGWOM2b59u5k4caKRZDp37mxmzpxpFi5caJYvX25q1KhhChQo4HydFy5caIwx5vLly6Z58+bG19fXDBw40Lz33numb9++Jk+ePKZt27YufZBkKlasaAoWLGhGjx5tpkyZYrZu3Zpqnxs1amQqV66c6vKxY8caSWbx4sUu5U888YQpXbq083Xz9/c3r7/+eprbr1WrlnF3d3e+LlerXLmy87MzLez83NLyOb99+3bTuXNnI8lMnDjR5XPGmLQd93/88Yfx9/c3999/v7Ns2LBhxuFwmDVr1jjLkn4/HjhwwBhz/fdbiRIlTGRkpHPdc+fOmSpVqhh3d3fz+OOPm6lTp5qxY8eaOnXqOH/mJ0+eNIULFzaDBw82U6dONa+//ropX7688fDwcNaJjY01U6dONZLM/fff79zu9u3bjTFXPteuZue9X758eRMSEmKee+45884775hatWoZh8Nhfv311zT/jHHrIkjhlpf0i+K7774zJ0+eNIcPHzZz5841+fPnNz4+PubIkSPm4MGDxt3d3bz88ssu6+7YscPkyZPHpbxRo0YuAexqJUqUMJLMF1984SyLiYkxhQsXNjVr1nSWXRukEhMTTdmyZU2LFi1MYmKis9758+dNyZIlzd133+0su3z5smnQoIEJCQkxf//9t+nTp4/JkydPsqB4dZAyxpgtW7YYSWb69OnJ+h0REWHq1q3rUrZgwYI0/fH24YcfGknG09PTNGnSxLzwwgtm7dq15vLlyy71Vq1aZSSZ/v37J2sjaZ+3bdtmJJnHHnvMZfkzzzxjJJlVq1Y5y5Je66VLl7rUHTt2rPHz8zO///67S/mwYcOMu7u7OXTokDHGmAEDBpiAgABz6dKl6+5fSkqUKGFat27tUjZp0iQjycyaNctZlpCQYCIiIoy/v785e/asMeZKkAoICDAnTpy44baioqKMJDNw4ECX8qRQmlKQuu+++1zqPvXUU0aS8w8TY4zx8/Nz+aPoembOnGkkmQ8//PCGdZP+wOnXr5+zLDEx0bRu3dp4enqakydPGmOMWbt2rZFkZs+e7bL+0qVLk5VHRkYaPz8/l3qZeayk5vz588nKevfubXx9fZP9U0OS+eSTT5xl8fHxJjQ01HTo0MFZlnQMff75586yuLg4U6ZMmTS9F1Pqz8aNG5NtO+kYHD9+vEvd1q1bmxIlSiRrY+bMmcbNzc2sXbvWpXzatGlGklm/fr2zTJJxc3Mzv/3223X7muRGQWrhwoVGknnrrbecZQkJCSZ//vzm+eefd5Y9/PDDpnr16im2X6FCBXPy5Elz8uRJs2vXLtO/f38jybRp0ybFbdoNUmn9udn5nE/6h1lSwEli57h/7733nJ9JmzZtMu7u7sk+R64NUsak/H4zJnmQevHFF40ks2DBgmR1k/bv0qVLJj4+3mXZP//8Y0JCQlz+SXfy5Mlkn2dJrg1S6Xnv//DDD86yEydOGC8vL/P0008n2xZwLS7tA/6nWbNmKliwoMLCwtSpUyf5+/tr4cKFKlq0qBYsWKDExER17NhRf//9t/MRGhqqsmXLulyGIFnXivfo0SPF7RQpUkT333+/83lAQIC6deumrVu3Kjo6OsV1tm3bpr179+rhhx/WqVOnnNuPi4tT06ZN9cMPPzgvNXJzc9OMGTMUGxurVq1a6d1339Xw4cOd47/So1u3btq8ebP279/vLJs9e7bCwsLUqFGj66776KOPaunSpWrcuLHWrVunsWPHqmHDhipbtqw2bNjgrPfFF1/I4XCkOEFD0mUb3377rSRrnM7Vnn76aUnSN99841JesmRJtWjRwqVs3rx5atiwofLly+fys2zWrJkuX76sH374QZI1PiQuLu6GM4Ol1bfffqvQ0FCX8XYeHh7q37+/YmNjtWbNGpf6HTp0cF7Ocj1Jl0U99dRTLuX9+vVLdZ0+ffqkWDfp9bVj9+7d6tOnjyIiIhQZGZnm9a6exCDpcq+EhAR99913kqyfU2BgoO6++26Xn1Pt2rXl7++f7D13rcw8VlJz9Rirc+fO6e+//1bDhg11/vx57d6926Wuv7+/y5gbT09P3X777frjjz9c9qlw4cJ64IEHnGW+vr7q1avXdfuRUn8uXryoU6dOqUyZMgoKCtLPP/+cpjZSMm/ePFWsWFEVKlRweZ2SLo++9mfVqFGjDBtDmDSV/rlz55xlS5Ys0alTp1zea507d9b27dv122+/JWtj9+7dKliwoAoWLKiKFSvq7bffVuvWrfXRRx9lSB/T+nOz8zl/vW1JaTvue/XqpRYtWqhfv37q2rWrSpcunaEz8H3xxReqXr26y++7JEmf6e7u7s5LhRMTE3X69GldunRJt912W7qPSbvv/UqVKqlhw4bO5wULFlT58uVd3ntAahidB/zPlClTVK5cOeXJk0chISEqX768cwaivXv3yhijsmXLprjutTNGFS1aNNWB72XKlEl2PXe5cuUkWdeCh4aGJltn7969knTdP1RjYmKUL18+SVLp0qWd19FXqVJFL7zwQqrrpcVDDz2kgQMHavbs2XrxxRcVExOjxYsXa9CgQWma9rdFixZq0aKFzp8/r6ioKH322WeaNm2a7r33Xu3evVuFChXS/v37VaRIEQUHB6fazp9//ik3NzeVKVPGpTw0NFRBQUH6888/XcpLliyZrI29e/fql19+STWkJI0ZeOqpp/T55587p21v3ry5OnbsqJYtW95wf1Pre9myZZPNalWxYkXn8hv1PbV23dzcktW/9jW62rXHcenSpeXm5pbsXjE3Eh0drdatWyswMFDz589PNig9NW5ubipVqpRL2dXvAcn6OcXExCQbR5fkRhOVZOaxkprffvtNI0aM0KpVq3T27FmXZdeO6SlWrFiy91K+fPn0yy+/uOxTSp8f5cuXv24/kvz7778aN26cpk+frr/++stlTNq1/bFj79692rVrV5pfp7Qe22kRGxsrScqbN6+zbNasWSpZsqS8vLy0b98+SdYx7uvrq9mzZycLC+Hh4frggw+cU6WXLVs21eMuPdL6c7P7OZ/atuwc9x9++KFKly6tvXv3asOGDRk6wcr+/fvVoUOHG9b7+OOP9cYbb2j37t26ePGiszy9x4nd16B48eLJ2siXL5/LWEwgNQQp4H9uv/32VM/aJCYmyuFwaMmSJSn+sXjtDUYzeravpP9Cjh8/PtWpya/tQ9L05kePHtWpU6dSDGhplS9fPt17773OIDV//nzFx8fbnrXK19dXDRs2VMOGDVWgQAGNHj1aS5YssXUmQ1KawpuU8s8hMTFRd999t5599tkU10n6g75QoULatm2bli1bpiVLlmjJkiWaPn26unXrlmyCiJshM2eMS889cGJiYtSqVSudOXNGa9euVZEiRTK0T4mJiSpUqJBmz56d4vK0nK2TMudYScmZM2fUqFEjBQQEaMyYMSpdurS8vb31888/a+jQocnOLKQWQq8OO/9Vv379NH36dA0cOFARERHOm+126tQpTZNnpCYxMVFVq1bVm2++meLysLAwl+cZeWz/+uuvkq784+Ds2bNatGiRLly4kOI/vubMmaOXX37Z5bjw8/NTs2bNMqxP6ZWez/nUpPW4X716tXMChh07digiIiJN62WUWbNmqXv37mrXrp2GDBmiQoUKyd3dXePGjXO5AiI90voaZMZ7D7kXQQpIg9KlS8sYo5IlS173j6e02Ldvn4wxLh/ySTczvXoWrGu3L1mXAablF/60adO0YsUKvfzyyxo3bpx69+6tr7766rrr3OiXTrdu3dS2bVtt2bJFs2fPVs2aNVW5cuUb9iU1SaH12LFjkqx9XLZsmU6fPp3qWakSJUooMTFRe/fudZ7JkaTjx4/rzJkzztnGrqd06dKKjY1N0+vo6empNm3aqE2bNkpMTNRTTz2l9957Ty+88MJ1z/ik1vdffvlFiYmJLmelki7xSkvfU2s3MTFRBw4ccPnDMek/8SnZu3evy3979+3bp8TERJfj73rHw4ULF9SmTRv9/vvv+u6772xfppWYmKg//vjD5b107XugdOnS+u6771S/fv10/eGd2cfKtVavXq1Tp05pwYIFuvPOO53lV88CaleJEiX066+/Jvv82LNnT5rWnz9/viIjI/XGG284yy5cuJDmm7qmdkyULl1a27dvV9OmTTP1xrSXL1/WnDlz5OvrqwYNGkiSFixYoAsXLmjq1KkqUKCAS/09e/ZoxIgRWr9+vbN+Zkjrz83O53xqr7Od4/7YsWPq16+fmjdvLk9PTz3zzDNq0aJFuj+LrlW6dGln0E3N/PnzVapUKS1YsMBln669xNvOcZUR730grRgjBaRB+/bt5e7urtGjRyf7L5UxRqdOnUpzW0ePHtXChQudz8+ePatPPvlENWrUSPWsUe3atVW6dGlNmDDBeSnL1a6eovfAgQMaMmSIOnTooOeee04TJkzQ119/fcPpXP38/CQp1T+qWrVqpQIFCui1117TmjVr0nw2auXKlSmWJ13HnnR5S4cOHWSMcd508WpJr/k999wjSZo0aZLL8qT/hLdu3fqG/enYsaM2btyoZcuWJVt25swZXbp0SZKS/Uzd3NxUrVo1SUrzdNNXu+eeexQdHa3PPvvMWXbp0iW9/fbb8vf3v+FYs9Qkjet59913XcrffvvtVNeZMmVKinVbtWrlLPPz80vxWLh8+bIeeughbdy4UfPmzUv3f7Dfeecd5/fGGL3zzjvy8PBQ06ZNJVk/p8uXL2vs2LHJ1r106dIN//jPzGMlJUn/5b768yIhISHZz8mOe+65R0ePHtX8+fOdZefPn9f777+fpvXd3d2TfX69/fbbyaZjT42fn1+KlwB27NhRf/31lz744INky/7991/nVNoZ6fLly+rfv7927dql/v37KyAgQJJ1hqNUqVJ64okn9MADD7g8nnnmGfn7+6d6lvNmSevPzc7nfGqf13aO+8cff1yJiYn68MMP9f777ytPnjzq2bNnhp2J6dChg7Zv3+7y+y5J0jZSep9s3rxZGzdudKmfdB/GtIT+jHjvA2nFGSkgDUqXLq2XXnpJw4cP18GDB9WuXTvlzZtXBw4c0MKFC9WrVy8988wzaWqrXLly6tmzp7Zs2aKQkBB99NFHOn78uKZPn57qOm5ubvq///s/tWrVSpUrV1aPHj1UtGhR/fXXX/r+++8VEBCgRYsWyRijRx99VD4+Ppo6daok6+aSX3zxhQYMGKBmzZqleglW6dKlFRQUpGnTpilv3rzy8/NT3bp1nWcuPDw81KlTJ73zzjtyd3dP802K27Ztq5IlS6pNmzbO+5N89913WrRokerUqaM2bdpIkpo0aaKuXbtq8uTJ2rt3r1q2bKnExEStXbtWTZo0Ud++fVW9enVFRkbq/fffd1469eOPP+rjjz9Wu3bt1KRJkxv2Z8iQIfr666917733qnv37qpdu7bi4uK0Y8cOzZ8/XwcPHlSBAgX02GOP6fTp07rrrrtUrFgx/fnnn3r77bdVo0YNl/9yplWvXr303nvvqXv37oqKilJ4eLjmz5+v9evXa9KkSS5jPOyoXbu2OnTooEmTJunUqVOqV6+e1qxZ4zzDk9J/cg8cOKD77rtPLVu21MaNGzVr1iw9/PDDql69uku73333nd58800VKVJEJUuWVN26dfX000/r66+/Vps2bXT69OlkN+BNS8D29vbW0qVLFRkZqbp162rJkiX65ptv9Nxzzzkv2WvUqJF69+6tcePGadu2bWrevLk8PDy0d+9ezZs3T2+99ZbL4P1rZeaxkpI77rhD+fLlU2RkpPr37y+Hw6GZM2f+pz9SH3/8cb3zzjvq1q2boqKiVLhwYc2cOTPNN/u+9957NXPmTAUGBqpSpUrauHGjvvvuO+XPnz9N69euXVufffaZBg8erDp16sjf319t2rRR165d9fnnn+uJJ57Q999/r/r16+vy5cvavXu3Pv/8c+f9udIrJibGeZydP39e+/bt04IFC7R//3516tTJGbaPHj2q77//Xv3790+xHS8vL7Vo0ULz5s3T5MmTk41tvVnS+nNL6+e8ZP0sJOn5559Xp06d5OHhoTZt2qT5uJ8+fbq++eYbzZgxQ8WKFZNkhepHHnlEU6dOTTZ5TXoMGTJE8+fP14MPPqhHH31UtWvX1unTp/X1119r2rRpql69uu69914tWLBA999/v1q3bq0DBw5o2rRpqlSpkkuY9PHxUaVKlfTZZ5+pXLlyCg4OVpUqVVSlSpVk282I9z6QZpk7SSCQ/aR2H6mUfPHFF6ZBgwbGz8/P+Pn5mQoVKpg+ffqYPXv2OOtcb7repGmxly1bZqpVq2a8vLxMhQoVzLx581zqpXQfKWOM2bp1q2nfvr3Jnz+/8fLyMiVKlDAdO3Y0K1euNMZcuffV1dOrG2PMoUOHTEBAgLnnnntc+nntFL5fffWVqVSpksmTJ0+KU6H/+OOPRlKa7heU5NNPPzWdOnUypUuXNj4+Psbb29tUqlTJPP/8884pv5NcunTJjB8/3lSoUMF4enqaggULmlatWpmoqChnnYsXL5rRo0ebkiVLGg8PDxMWFmaGDx/uMp20MSlPQZ7k3LlzZvjw4aZMmTLG09PTFChQwNxxxx1mwoQJzvsTzZ8/3zRv3twUKlTIeHp6muLFi5vevXubY8eO3XCfU9v28ePHTY8ePUyBAgWMp6enqVq1arLXOLWpp68nLi7O9OnTxwQHBxt/f3/Trl07s2fPHiPJvPrqq856SdME79y50zzwwAMmb968Jl++fKZv377m33//dWlz9+7d5s477zQ+Pj5GknNa46SpulN73EjS1Mn79+933nsoJCTEjBw5MtmU+MYY8/7775vatWsbHx8fkzdvXlO1alXz7LPPmqNHjyZr81qZdaykZv369aZevXrGx8fHFClSxDz77LNm2bJlyd7bqX1mREZGJptu/M8//zT33Xef8fX1NQUKFDADBgxwTgl/o+nP//nnH+fx5+/vb1q0aGF2796dbNrq1I7B2NhY8/DDD5ugoCAjyaVvCQkJ5rXXXjOVK1c2Xl5eJl++fKZ27dpm9OjRJiYmxllPkunTp891+3m1a483f39/U7ZsWfPII4+43HvPGGPeeOMNI8n5eZiSGTNmGF11n70bTa+eErvTnxtj7+d2o8/5JGPHjjVFixY1bm5uLlOU3+i4P3z4sAkMDExxevf777/f+Pn5mT/++MMY89+mPzfGmFOnTpm+ffuaokWLGk9PT1OsWDETGRlp/v77b2OMNQ36K6+8YkqUKGG8vLxMzZo1zeLFi1M89jds2GBq165tPD09XaZCT+k+Uv/1vZ/S70cgJQ5jGE0HZJbw8HBVqVJFixcvzuqupMv27dtVo0YNffLJJ+ratWtWdwfXsW3bNtWsWVOzZs1Sly5dJEmjRo3S6NGjdfLkyVTPpAAAgLRhjBSANPvggw/k7++v9u3bZ3VXcJV///03WdmkSZPk5ubmMtEBAADIOIyRAnBDixYt0s6dO/X++++rb9++zoHOyB5ef/11RUVFqUmTJsqTJ49zuvZevXolm3oaAABkDIIUgBvq16+fjh8/rnvuuSfFWfWQte644w6tWLFCY8eOVWxsrIoXL65Ro0bp+eefz+quAQCQazFGCgAAAABsYowUAAAAANhEkAIAAAAAmxgjJSkxMVFHjx5V3rx5U7x5JQAAAIBbgzFG586dU5EiReTmlvp5J4KUrLuhM7MVAAAAgCSHDx9WsWLFUl1OkJKUN29eSdaLFRAQkMW9AQAAAJBVzp49q7CwMGdGSA1BSnJezhcQEECQAgAAAHDDIT9MNgEAAAAANhGkAAAAAMAmghQAAAAA2MQYKQAAAORqly9f1sWLF7O6G8gm3N3dlSdPnv982yOCFAAAAHKt2NhYHTlyRMaYrO4KshFfX18VLlxYnp6e6W6DIAUAAG4dr74qDR8uDRggTZp0pXzjRun556XNmyV3d6lGDWnZMsnHRzp4UBo7Vlq1SoqOlooUkR55xKp/oz/CrteuJJ0+LfXrJy1aJLm5SR06SG+9Jfn735z9v8VcvnxZR44cka+vrwoWLPifz0Ag5zPGKCEhQSdPntSBAwdUtmzZ695093oIUgAA4NawZYv03ntStWqu5Rs3Si1bWgHr7belPHmk7dutYCNJu3dLiYnWumXKSL/+Kj3+uBQXJ02YkPr2btSuJHXpIh07Jq1YIV28KPXoIfXqJc2Zk/H7fwu6ePGijDEqWLCgfJLCK255Pj4+8vDw0J9//qmEhAR5e3unqx2H4Tynzp49q8DAQMXExHAfKQAAcqPYWKlWLendd6WXXrLODCWdkapXT7r7buusU1qNHy9NnSr98UfqdW7U7q5dUqVKVsC77TarbOlS6Z57pCNHrDNf+E8uXLigAwcOqGTJkun+Yxm50/WOjbRmA2btAwAAuV+fPlLr1lKzZq7lJ05Yl90VKiTdcYcUEiI1aiStW3f99mJipODg1Jenpd2NG6WgoCshSrL65+ZmrQsgWyNIAQCA3G3uXOnnn6Vx45IvSzqjNGqUdbne0qXWmaumTaW9e1Nub98+61K93r1T32Za2o2OtoLW1fLksQJadLSdPQSQBQhSAAAg9zp82JpYYvZsKaVLuxITra+9e1vjk2rWlCZOlMqXlz76KHn9v/6yxj09+KAVkFJjt10gi6xevVoOh0NnzpxJ8zrh4eGadPVkLbcoghQAAMi9oqKsy+xq1bLO9uTJI61ZI02ebH0fEmLVq1TJdb2KFaVDh1zLjh6VmjSxLtV7//3rb7dw4Ru3Gxpq9e1qly5ZM/mFhqZ9H5Grde/eXQ6HQ0888USyZX369JHD4VD37t0zv2MgSAEAgFysaVNpxw5p27Yrj9tus2bL27ZNKlXKmtRhzx7X9X7/XSpR4srzv/6SGjeWateWpk93nXkvJeHhN243IkI6c8YKe0lWrbLOZtWtm46dRW4VFhamuXPn6t9//3WWXbhwQXPmzFHx4sWzsGe3NoIUAADIvfLmlapUcX34+Un581vfOxzSkCHWGar5863xTy+8YE153rOn1UZSiCpe3Jru/ORJawzT1eOY/vpLqlBB+vFH63la2q1Y0bpM8PHHrfXWr5f69pU6dWLGPrioVauWwsLCtGDBAmfZggULVLx4cdWsWdNZFh8fr/79+6tQoULy9vZWgwYNtGXLFpe2vv32W5UrV04+Pj5q0qSJDh48mGx769atU8OGDeXj46OwsDD1799fcXFxN23/ciqCFAAAuLUNHGjd62nQIKl6dWnlSuu+TqVLW8tXrLCC0MqVUrFi1mV7SY8kFy9aZ5/On097u5I1dqtCBevM2T33SA0a3PiyQdySHn30UU2fPt35/KOPPlKPHj1c6jz77LP64osv9PHHH+vnn39WmTJl1KJFC50+fVqSdPjwYbVv315t2rTRtm3b9Nhjj2nYsGEubezfv18tW7ZUhw4d9Msvv+izzz7TunXr1Ldv35u/kzkM95ES95ECAADIjXLDfaS6d++uM2fO6IMPPlBYWJj2/O9y0QoVKujw4cN67LHHFBQUpClTpihfvnyaMWOGHn74YUnWDYnDw8M1cOBADRkyRM8995y++uor/fbbb872hw0bptdee03//POPgoKC9Nhjj8nd3V3vvfees866devUqFEjxcXFydvb29nmwIEDM/W1yEgZcR+pPDe7kwAAAAD+m4IFC6p169aaMWOGjDFq3bq1ChQo4Fy+f/9+Xbx4UfXr13eWeXh46Pbbb9euXbskSbt27VLda8bfRUREuDzfvn27fvnlF82ePdtZZoxRYmKiDhw4oIoVK96M3cuRCFIAAABADvDoo486L7GbMmXKTdlGbGysevfurf79+ydbxsQWrghSAAAAQA7QsmVLJSQkyOFwqEWLFi7LSpcuLU9PT61fv14l/jcz5MWLF7VlyxbnJXgVK1bU119/7bLepk2bXJ7XqlVLO3fuVJkyZW7ejuQSBCkAAJBtNJ87PKu7kCMt7zQuq7uATODu7u68TM/d3d1lmZ+fn5588kkNGTJEwcHBKl68uF5//XWdP39ePf83U+QTTzyhN954Q0OGDNFjjz2mqKgozZgxw6WdoUOHql69eurbt68ee+wx+fn5aefOnVqxYoXeeeedTNnPnIJZ+wAAAIAcIiAgINUJEF599VV16NBBXbt2Va1atbRv3z4tW7ZM+fLlk2RdmvfFF1/oyy+/VPXq1TVt2jS98sorLm1Uq1ZNa9as0e+//66GDRuqZs2aevHFF1WEKfmTYdY+MWsfAADZBWek0oczUinLDbP24ebIiFn7OCMFAAAAADYRpAAAAADAJoIUAAAAANhEkAIAAAAAmwhSAAAAAGATQQoAAAAAbCJIAQAAAIBNBCkAAAAAsIkgBQAAAAA25cnqDgAAAACZqWHvsZm6vbXvvZCp20Pm4IwUAAAAkAs5HA59+eWXLmULFizQ3XffrYIFCyogIEARERFatmxZ1nQwhyNIAQAAALeIH374QXfffbe+/fZbRUVFqUmTJmrTpo22bt2a1V3LcQhSAAAAQDZz7tw5denSRX5+fipcuLAmTpyoxo0ba+DAgZKk8PBwjR07Vp07d5afn5+KFi2qKVOmONcPDw+XJN1///1yOBzO55MmTdKzzz6rOnXqqGzZsnrllVdUtmxZLVq0KJP3MOcjSAEAAADZzODBg7V+/Xp9/fXXWrFihdauXauff/7Zpc748eNVvXp1bd26VcOGDdOAAQO0YsUKSdKWLVskSdOnT9exY8ecz6+VmJioc+fOKTg4+ObuUC7EZBMAAABANnLu3Dl9/PHHmjNnjpo2bSrJCkRFihRxqVe/fn0NGzZMklSuXDmtX79eEydOdI6BkqSgoCCFhoamuq0JEyYoNjZWHTt2vEl7k3txRgoAAADIRv744w9dvHhRt99+u7MsMDBQ5cuXd6kXERGR7PmuXbvSvJ05c+Zo9OjR+vzzz1WoUKH/1ulbEGekAAAAgFvM3Llz9dhjj2nevHlq1qxZVncnR+KMFAAAAJCNlCpVSh4eHi7jmmJiYvT777+71Nu0aVOy5xUrVnQ+9/Dw0OXLl5O1/+mnn6pHjx769NNP1bp16wzu/a2DM1IAAABANpI3b15FRkZqyJAhCg4OVqFChTRy5Ei5ubnJ4XA4661fv16vv/662rVrpxUrVmjevHn65ptvnMvDw8O1cuVK1a9fX15eXsqXL5/mzJmjyMhIvfXWW6pbt66io6MlST4+PgoMDMz0fc3JCFIAAAC4pax974Ws7sINvfnmm3riiSd07733KiAgQM8++6wOHz4sb29vZ52nn35aP/30k0aPHq2AgAC9+eabatGihXP5G2+8ocGDB+uDDz5Q0aJFdfDgQb3//vu6dOmS+vTpoz59+jjrRkZGasaMGZm5izkeQQoAAADIZvLmzavZs2c7n8fFxWn06NHq1auXsywgIECff/55qm20adNGbdq0cSlbvXp1hvf1VkWQAgAAALKZrVu3avfu3br99tsVExOjMWPGSJLatm2bxT1DEoIUAAAAkA1NmDBBe/bskaenp2rXrq21a9eqQIECWd0t/A9BCgAAAMhmatasqaioqFSXHzx4MPM6gxQx/TkAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwienPAQAAcEtpPnd4pm5veadxmbq93O7gwYMqWbKktm7dqho1amRZPzgjBQAAAGQj3bt3l8PhsP1YvXp1srYaN24sh8OhuXPnupRPmjRJ4eHhN20fwsPDr9vX7t27p7vtsLAwHTt2TFWqVMm4DqcDZ6QAAACAbKZly5aaPn2683lCQoLc3d3l7u4uSRowYIDOnj3rUic4ODjFtry9vTVixAh16NBBHh4eN7fj/7NlyxZdvnxZkrRhwwZ16NBBe/bsUUBAgCTJx8cn3W27u7srNDQ0Q/r5X3BGCgAAAMhmvLy8FBoa6nwUL15cRYsWdT738fFJVsfT0zPFtjp37qwzZ87ogw8+uO42p06dqtKlS8vT01Ply5fXzJkzXZY7HA793//9n+6//375+vqqbNmy+vrrr1Nsq2DBgs5+JQW8QoUKOcvmzJmT6rYeffRRVatWTfHx8ZKsEFmzZk1169ZNknVpn8Ph0LZt25zr/Pbbb7r33nsVEBCgvHnzqmHDhtq/f//1X+T/iCAFAAAA5GIBAQF6/vnnNWbMGMXFxaVYZ+HChRowYICefvpp/frrr+rdu7d69Oih77//3qXe6NGj1bFjR/3yyy+655571KVLF50+fdpWf260rcmTJysuLk7Dhg2TJD3//PM6c+aM3nnnnRTb++uvv3TnnXfKy8tLq1atUlRUlB599FFdunTJVr/sIkgBAAAA2czixYvl7+/vfDz44IP/qb2nnnpK3t7eevPNN1NcPmHCBHXv3l1PPfWUypUrp8GDB6t9+/aaMGGCS73u3burc+fOKlOmjF555RXFxsbqxx9/tNWXG23L399fs2bN0pQpU/Tiiy9q0qRJmjlzpvOywGtNmTJFgYGBmjt3rm677TaVK1dOPXr0UPny5W31yy6CFAAAAJDNNGnSRNu2bXM+Jk+efN36s2fPdglea9eudVnu5eWlMWPGaMKECfr777+Trb9r1y7Vr1/fpax+/fratWuXS1m1atWc3/v5+SkgIEAnTpyQJFWuXNm5/VatWqXa17RsKyIiQs8884zGjh2rp59+Wg0aNEi1vW3btqlhw4aZNv4rCZNNAAAAANmMn5+fypQpk+b69913n+rWret8XrRo0WR1HnnkEU2YMEEvvfRSumfsuzasOBwOJSYmSpK+/fZbXbx4UdJ/m0xCkhITE7V+/Xq5u7tr37591637X7eVXpyRAgAAAHK4vHnzqkyZMs5HSuHCzc1N48aN09SpU3Xw4EGXZRUrVtT69etdytavX69KlSqluQ8lSpRwbj+lIGdnW+PHj9fu3bu1Zs0aLV261GV2wmtVq1ZNa9eudYa4zMIZKQAAAOAW0bp1a9WtW1fvvfeeQkJCnOVDhgxRx44dVbNmTTVr1kyLFi3SggUL9N1332V4H260ra1bt+rFF1/U/PnzVb9+fb355psaMGCAGjVqpFKlSiVrr2/fvnr77bfVqVMnDR8+XIGBgdq0aZNuv/32mzpOiiAFAACAW8ryTuOyugtZ6rXXXtMdd9zhUtauXTu99dZbmjBhggYMGKCSJUtq+vTpaty4cYZv/3rbunDhgh555BF1795dbdq0kST16tVL33zzjbp27aoffvghWXv58+fXqlWrNGTIEDVq1Eju7u6qUaNGsnFYGc1hjDE3dQs5wNmzZxUYGKiYmJhUZwMBAAA3X/O5w7O6CznSrR4MUnPhwgUdOHBAJUuWlLe3d1Z3B9nI9Y6NtGYDxkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADAJoIUAAAAcjXmVsO1MuKYIEgBAAAgV3J3d5ckJSQkZHFPkN2cP39ekuTh4ZHuNriPFAAAAHKlPHnyyNfXVydPnpSHh4fc3DiHcKszxuj8+fM6ceKEgoKCnGE7PQhSAAAAyJUcDocKFy6sAwcO6M8//8zq7iAbCQoKUmho6H9qgyAFAACAXMvT01Nly5bl8j44eXh4/KczUUkIUgAAAMjV3Nzc5O3tndXdQC6TbS4UffXVV+VwODRw4EBn2YULF9SnTx/lz59f/v7+6tChg44fP+6y3qFDh9S6dWv5+vqqUKFCGjJkiC5dupTJvQcAAABwK8kWQWrLli167733VK1aNZfyQYMGadGiRZo3b57WrFmjo0ePqn379s7lly9fVuvWrZWQkKANGzbo448/1owZM/Tiiy9m9i4AAAAAuIVkeZCKjY1Vly5d9MEHHyhfvnzO8piYGH344Yd68803ddddd6l27dqaPn26NmzYoE2bNkmSli9frp07d2rWrFmqUaOGWrVqpbFjx2rKlClcBwsAAADgpsnyINWnTx+1bt1azZo1cymPiorSxYsXXcorVKig4sWLa+PGjZKkjRs3qmrVqgoJCXHWadGihc6ePavffvst1W3Gx8fr7NmzLg8AAAAASKssnWxi7ty5+vnnn7Vly5Zky6Kjo+Xp6amgoCCX8pCQEEVHRzvrXB2ikpYnLUvNuHHjNHr06P/YewAAAAC3qiw7I3X48GENGDBAs2fPzvRZVIYPH66YmBjn4/Dhw5m6fQAAAAA5W5YFqaioKJ04cUK1atVSnjx5lCdPHq1Zs0aTJ09Wnjx5FBISooSEBJ05c8ZlvePHjztvnhUaGppsFr+k59e7wZaXl5cCAgJcHgAAAACQVlkWpJo2baodO3Zo27Ztzsdtt92mLl26OL/38PDQypUrnevs2bNHhw4dUkREhCQpIiJCO3bs0IkTJ5x1VqxYoYCAAFWqVCnT9wkAAADArSHLxkjlzZtXVapUcSnz8/NT/vz5neU9e/bU4MGDFRwcrICAAPXr108RERGqV6+eJKl58+aqVKmSunbtqtdff13R0dEaMWKE+vTpIy8vr0zfJwAAAAC3hiydbOJGJk6cKDc3N3Xo0EHx8fFq0aKF3n33Xedyd3d3LV68WE8++aQiIiLk5+enyMhIjRkzJgt7DQAAACC3cxhjTFZ3IqudPXtWgYGBiomJYbwUAABZqPnc4VndhRxpeadxWd0FINdIazbI8vtIAQAAAEBOQ5ACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADAJoIUAAAAANhEkAIAAAAAmwhSAAAAAGATQQoAAAAAbCJIAQAAAIBNBCkAAAAAsIkgBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAgp5g6VapWTQoIsB4REdKSJcnrGSO1aiU5HNKXX14pP3VKatlSKlJE8vKSwsKkvn2ls2evv9377pOKF5e8vaXChaWuXaWjR68s37NHatJECgmx6pQqJY0YIV28mCG7DQDZEUEKAICcolgx6dVXpago6aefpLvuktq2lX77zbXepElWiLqWm5tV/+uvpd9/l2bMkL77Tnriietvt0kT6fPPrcD0xRfS/v3SAw9cWe7hIXXrJi1fbtWZNEn64ANp5Mj/uMMAkH3lyeoOAACANGrTxvX5yy9bZ6k2bZIqV7bKtm2T3njDClqFC7vWz5dPevLJK89LlJCeekoaP/762x00yHWdYcOkdu2sM04eHtYZqFKlXOusXi2tXWtzBwEg5+CMFAAAOdHly9LcuVJcnHWJnySdPy89/LA0ZYoUGnrjNo4elRYskBo1Svt2T5+WZs+W7rjDClEp2bdPWrrUXrsAkMMQpAAAyEl27JD8/a0xTk88IS1cKFWqZC0bNMgKOG3bXr+Nzp0lX1+paFFrrNX//d+Ntzt0qOTnJ+XPLx06JH31VfI6d9xhjZEqW1Zq2FAaM8b+/gFADkGQAgAgJylf3rp8b/Nm6zK9yEhp505r3NOqVdb4pBuZOFH6+WcrDO3fLw0efON1hgyRtm61xkG5u1tjooxxrfPZZ1a7c+ZI33wjTZiQnj0EgBzBYcy1n4K3nrNnzyowMFAxMTEKCAjI6u4AAJB2zZpJpUtLPj7S5MnWhBJJLl+2njdsaI1ZSsm6ddbyo0eTj6lKzZEj1ox/GzZcuazwWrNmSb16SefOWcErjZrPHZ7murhieadxWd0FINdIazZgsgkAAHKyxEQpPl4aPVp67DHXZVWrWmefrp2k4tr1JasNO9u80TqJidZkFImJtoIUAOQUBCkAAHKK4cOt+0MVL26d6ZkzxzrTtGyZNblEShNMFC8ulSxpff/tt9Lx41KdOtY4q99+sy7Zq19fCg+36vz4o3XZ3sqV1hiqzZulLVukBg2sWf/275deeME6C5Z0Nmr2bGviiapVrbFbP/1k9fWhh1KfkAIAcjiCFAAAOcWJE1bIOXZMCgy0bs67bJl0991pW9/Hx7q/06BB1tmksDCpfXtrOvMk589b94JKupmur681s9/IkdYMgYULWzf1HTHCCk2SlCeP9Npr1r2pjLGmP+/b13XadADIZRgjJcZIAQCQXTBGKn0YIwVknLRmA2btAwAAAACbCFIAAAAAYBNBCgAAAABsYrIJAABukoa9x2Z1F3IcnyZZ3QMASBvOSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADAJoIUAAAAANhEkAIAAAAAmwhSAAAAAGATQQoAAAAAbCJIAQAAAIBNBCkAAAAAsIkgBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADApiwNUlOnTlW1atUUEBCggIAARUREaMmSJc7lFy5cUJ8+fZQ/f375+/urQ4cOOn78uEsbhw4dUuvWreXr66tChQppyJAhunTpUmbvCgAAAIBbSJYGqWLFiunVV19VVFSUfvrpJ911111q27atfvvtN0nSoEGDtGjRIs2bN09r1qzR0aNH1b59e+f6ly9fVuvWrZWQkKANGzbo448/1owZM/Tiiy9m1S4BAAAAuAU4jDEmqztxteDgYI0fP14PPPCAChYsqDlz5uiBBx6QJO3evVsVK1bUxo0bVa9ePS1ZskT33nuvjh49qpCQEEnStGnTNHToUJ08eVKenp5p2ubZs2cVGBiomJgYBQQE3LR9AwDcWhr2HpvVXchxfJqcz+ou5EjLO43L6i4AuUZas0G2GSN1+fJlzZ07V3FxcYqIiFBUVJQuXryoZs2aOetUqFBBxYsX18aNGyVJGzduVNWqVZ0hSpJatGihs2fPOs9qpSQ+Pl5nz551eQAAAABAWmV5kNqxY4f8/f3l5eWlJ554QgsXLlSlSpUUHR0tT09PBQUFudQPCQlRdHS0JCk6OtolRCUtT1qWmnHjxikwMND5CAsLy9idAgAAAJCrZXmQKl++vLZt26bNmzfrySefVGRkpHbu3HlTtzl8+HDFxMQ4H4cPH76p2wMAAACQu+TJ6g54enqqTJkykqTatWtry5Yteuutt/TQQw8pISFBZ86ccTkrdfz4cYWGhkqSQkND9eOPP7q0lzSrX1KdlHh5ecnLyyuD9wQAAADArSLLz0hdKzExUfHx8apdu7Y8PDy0cuVK57I9e/bo0KFDioiIkCRFRERox44dOnHihLPOihUrFBAQoEqVKmV63wEAAADcGrL0jNTw4cPVqlUrFS9eXOfOndOcOXO0evVqLVu2TIGBgerZs6cGDx6s4OBgBQQEqF+/foqIiFC9evUkSc2bN1elSpXUtWtXvf7664qOjtaIESPUp08fzjgBAAAAuGmyNEidOHFC3bp107FjxxQYGKhq1app2bJluvvuuyVJEydOlJubmzp06KD4+Hi1aNFC7777rnN9d3d3LV68WE8++aQiIiLk5+enyMhIjRkzJqt2CQAAAMAtINvdRyorcB8pAMDNwH2k7OM+UunDfaSAjJPj7iMFAAAAADkFQQoAAAAAbCJIAQAAAIBNBCkAAAAAsIkgBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSCH3GjdOqlNHyptXKlRIatdO2rMneb2NG6W77pL8/KSAAOnOO6V//7WWrV4tORwpP7Zsuf72r9euJL38snTHHZKvrxQUlEE7DQAAgMxAkELutWaN1KePtGmTtGKFdPGi1Ly5FBd3pc7GjVLLllb5jz9a4ahvX8ntf2+NO+6Qjh1zfTz2mFSypHTbbalv+0btSlJCgvTgg9KTT96c/QcAAMBNkyerOwDcNEuXuj6fMcM6MxUVZZ0dkqRBg6T+/aVhw67UK1/+yveenlJo6JXnFy9KX30l9etnnZVKzY3alaTRo6/0CwAAADkKZ6Rw64iJsb4GB1tfT5yQNm+2wtUdd0ghIVKjRtK6dam38fXX0qlTUo8eqddJT7sAAADIUQhSuDUkJkoDB0r160tVqlhlf/xhfR01Snr8cesMVq1aUtOm0t69Kbfz4YdSixZSsWKpbys97QIAACBHIUjh1tCnj/Trr9LcuVfKEhOtr717W2eYataUJk60LsH76KPkbRw5Ii1bJvXsef1t2W0XAAAAOQ5jpJD79e0rLV4s/fCD65mkwoWtr5UqudavWFE6dCh5O9OnS/nzS/fdd/3t2W0XAAAAOU66zkhNnz5d58+fz+i+ABnLGCtELVworVplzbR3tfBwqUiR5FOi//67VKJE8ramT5e6dZM8PK6/XTvtAgAAIEdKV5AaNmyYQkND1bNnT23YsCGj+4RrpeV+SI0bJ7/P0RNPuNZZudKa/CBvXmsmuqFDpUuXrr/tCxesy+Ly55f8/aUOHaTjx68s375d6txZCguTfHyssy5vvZURe/3f9ekjzZolzZlj7XN0tPVIupeTwyENGSJNnizNny/t2ye98IK0e3fyy/dWrZIOHLCmPr/WX39JFSpY05zbaffQIWnbNuvr5cvW99u2SbGxN+HFAAAAQEZK16V9f/31lxYtWqQZM2aocePGKlWqlHr06KHIyEiFXj1VNDJG0v2Q6tSxgs9zz1n3J9q507rZa5LHH5fGjLny3Nf3yvfbt0v33CM9/7z0ySfWH/9PPGH9AT9hQurbHjRI+uYbad48KTDQOsPTvr20fr21PCrKCnezZllhasMGqVcvyd3dqpuVpk61vjZu7Fo+fbrUvbv1/cCBVlgcNEg6fVqqXt2651Tp0q7rfPihFUIrVEi+nYsXrWB79VnatLT74ovSxx9feV6zpvX1+++T9xkAAADZisMYY/5LA8ePH9esWbP08ccfa/fu3WrZsqV69uypNm3ayM0tZ8xlcfbsWQUGBiomJkYBAQFZ3Z0bO3nSCi9r1ly5H1LjxlKNGtKkSSmv89xz1h/yW7ZcKVu0SOrY0ZquO2/e5OvExEgFC1pndB54wCrbvds667Rxo1SvXsrb6tNH2rXLOosDALewhr3HZnUXchyfJgwdSI/lncZldReAXCOt2eA/J52QkBA1aNBAERERcnNz044dOxQZGanSpUtr9erV/7V5pOTa+yElmT1bKlDAmt57+HDXMyTx8ZK3t2t9Hx/rrElUVMrbiYqyzrY0a3alrEIFqXhxK0hdr3/X9g0AAADIRdIdpI4fP64JEyaocuXKaty4sc6ePavFixfrwIED+uuvv9SxY0dFRkZmZF8hpXw/JEl6+GHr8rrvv7dC1MyZ0iOPXFneooV12d2nn1qX8/3115XLAI8dS3lb0dGSp6cUFORaHhJiLUvJhg3SZ59Zl/cBAAAAuVS6xki1adNGy5YtU7ly5fT444+rW7duCr7qDISfn5+efvppjR8/PsM6iv9Juh/SunWu5VcHl6pVrSm4mzaV9u+3xuU0by6NH2+Ni+raVfLysiZAWLtWyqhLMH/9VWrbVho50toeAAAAkEulK0gVKlRIa9asUURERKp1ChYsqAMHDqS7Y0hBavdDSkndutbXffuuTHAweLA1+cGxY1K+fNLBg9bZq1KlUm4jNFRKSJDOnHE9K3X8uLXsajt3WsGtVy9pxIh07JzUfO7wdK13K+OaeAAAgKyRrlMRjRo1Uq1atZKVJyQk6JNPPpEkORwOleCeORnjRvdDSsm2bdbXpJvDJnE4rHsc+fhYl/mFhUkp/CwlSbVrW/dMWrnyStmePdZ03VeH6N9+k5o0kSIjpZdftrVrAAAAQE6UriDVo0cPxSRNeHCVc+fOqUePHv+5U7jGje6HtH+/NHasNTnEwYPS119bN469806pWrUr7YwfL+3YYQWfsWOlV1+17nXk7m4tv/Z+SIGB1n2PBg+2xl5FRUk9elghKmnGvl9/tUJU8+ZWvaS+nTyZaS8PAAAAkNnSdWmfMUYOhyNZ+ZEjRxQYGPifO4Vr3Oh+SJ6e0nffWVOfx8VZZ5k6dEh+id2SJdYZo/h4675GX30ltWp1ZXlK90OaONEaQ9Whg7VeixbSu+9eWT5/vhWaZs2yHklKlLBCHQAAAJAL2QpSNWvWlMPhkMPhUNOmTZUnz5XVL1++rAMHDqhly5YZ3slb3o1u9RUWZt1T6kZudF+n8PDk2/L2lqZMsR4pGTXKegAAAAC3EFtBql27dpKkbdu2qUWLFvL393cu8/T0VHh4uDp06JChHQQAAACA7MZWkBo5cqQkKTw8XA899JC8r73BKwAAAADcAtI1Roob7QIAAAC4laU5SAUHB+v3339XgQIFlC9fvhQnm0hy+vTpDOlcTtWw99is7kKO5NMkq3sAAAAApE2ag9TEiROVN29e5/fXC1IAAAAAkJulOUhdfTlf9+7db0ZfAAAAACBHSNcNeWfMmJFi+aVLlzR8+PD/0h8AAAAAyPbSFaT69++vBx98UP/884+zbM+ePapbt64+/fTTDOscAAAAAGRH6QpSW7du1ZEjR1S1alWtWLFCU6ZMUa1atVShQgVt3749o/sIAAAAANlKuqY/L126tNavX6+BAweqZcuWcnd318cff6zOnTtndP8AAAAAINtJ1xkpSfrmm280d+5cRUREKCgoSB9++KGOHj2akX0DAAAAgGwpXUGqd+/eevDBBzV06FCtXbtWv/zyizw9PVW1alV9/vnnGd1HAAAAAMhW0nVp3/r167V582ZVr15dkhQaGqpvv/1WU6ZM0aOPPqqOHTtmaCcBAAAAIDtJV5CKioqSl5dXsvI+ffqoWbNm/7lTAAAAAJCdpevSPi8vL+3fv18jRoxQ586ddeLECUnSkiVLdOnSpQztIAAAAABkN+kKUmvWrFHVqlW1efNmLViwQLGxsZKk7du3a+TIkRnaQQAAAADIbtIVpIYNG6aXXnpJK1askKenp7P8rrvu0qZNmzKscwAAAACQHaUrSO3YsUP3339/svJChQrp77///s+dAgAAAIDsLF1BKigoSMeOHUtWvnXrVhUtWvQ/dwoAAAAAsrN0BalOnTpp6NChio6OlsPhUGJiotavX69nnnlG3bp1y+g+AgAAAEC2kq4g9corr6hChQoKCwtTbGysKlWqpDvvvFN33HGHRowYkdF9BAAAAIBsJV33kfL09NQHH3ygF154Qb/++qtiY2NVs2ZNlS1bNqP7BwAAAADZTrqCVJLixYurePHiGdUXAAAAAMgR0hykBg8enOZG33zzzXR1BgAAAABygjQHqa1bt6apnsPhSHdnAAAAACAnSHOQ+v77729mPwAAAAAgx0jXrH1XO3z4sA4fPpwRfQEAAACAHCFdQerSpUt64YUXFBgYqPDwcIWHhyswMFAjRozQxYsXM7qPAAAAAJCtpGvWvn79+mnBggV6/fXXFRERIUnauHGjRo0apVOnTmnq1KkZ2kkAAAAAyE7SFaTmzJmjuXPnqlWrVs6yatWqKSwsTJ07dyZIAQAAAMjV0nVpn5eXl8LDw5OVlyxZUp6env+1TwAAAACQraUrSPXt21djx45VfHy8syw+Pl4vv/yy+vbtm2GdAwAAAIDsKF2X9m3dulUrV65UsWLFVL16dUnS9u3blZCQoKZNm6p9+/bOugsWLMiYngIAAABANpGuIBUUFKQOHTq4lIWFhWVIhwAAAAAgu7MdpIwxGj16tAoWLCgfH5+b0ScAAAAAyNZsj5EyxqhMmTI6cuTIzegPAAAAAGR7toOUm5ubypYtq1OnTt2M/gAAAABAtpeuWfteffVVDRkyRL/++mtG9wcAAAAAsr10TTbRrVs3nT9/XtWrV5enp2eysVKnT5/OkM4BAAAAQHaUriA1adKkDO4GAAAAAOQc6QpSkZGRGd0PAAAAAMgx0jVGSpL279+vESNGqHPnzjpx4oQkacmSJfrtt98yrHMAAAAAkB2lK0itWbNGVatW1ebNm7VgwQLFxsZKkrZv366RI0dmaAcBAAAAILtJV5AaNmyYXnrpJa1YsUKenp7O8rvuukubNm3KsM4BAAAAQHaUriC1Y8cO3X///cnKCxUqpL///vs/dwoAAAAAsrN0BamgoCAdO3YsWfnWrVtVtGjR/9wpAAAAAMjO0hWkOnXqpKFDhyo6OloOh0OJiYlav369nnnmGXXr1i2j+wgAAAAA2Uq6gtQrr7yiihUrqnjx4oqNjVWlSpV055136o477tCIESMyuo8AAAAAkK3Yuo9UYmKixo8fr6+//loJCQnq2rWrOnTooNjYWNWsWVNly5a9Wf0EAAAAgGzDVpB6+eWXNWrUKDVr1kw+Pj6aM2eOjDH66KOPblb/AAAAACDbsXVp3yeffKJ3331Xy5Yt05dffqlFixZp9uzZSkxMvFn9AwAAAIBsx1aQOnTokO655x7n82bNmsnhcOjo0aMZ3jEAAAAAyK5sBalLly7J29vbpczDw0MXL17M0E4BAAAAQHZma4yUMUbdu3eXl5eXs+zChQt64okn5Ofn5yxbsGBBxvUQAAAAALIZW0EqMjIyWdkjjzySYZ0BAAAAgJzAVpCaPn36zeoHAAAAAOQY6bohb0YZN26c6tSpo7x586pQoUJq166d9uzZ41LnwoUL6tOnj/Lnzy9/f3916NBBx48fd6lz6NAhtW7dWr6+vipUqJCGDBmiS5cuZeauAAAAALiFZGmQWrNmjfr06aNNmzZpxYoVunjxopo3b664uDhnnUGDBmnRokWaN2+e1qxZo6NHj6p9+/bO5ZcvX1br1q2VkJCgDRs26OOPP9aMGTP04osvZsUuAQAAALgF2Lq0L6MtXbrU5fmMGTNUqFAhRUVF6c4771RMTIw+/PBDzZkzR3fddZck6/LCihUratOmTapXr56WL1+unTt36rvvvlNISIhq1KihsWPHaujQoRo1apQ8PT2TbTc+Pl7x8fHO52fPnr25OwoAAAAgV8nSM1LXiomJkSQFBwdLkqKionTx4kU1a9bMWadChQoqXry4Nm7cKEnauHGjqlatqpCQEGedFi1a6OzZs/rtt99S3M64ceMUGBjofISFhd2sXQIAAACQC2WbIJWYmKiBAweqfv36qlKliiQpOjpanp6eCgoKcqkbEhKi6OhoZ52rQ1TS8qRlKRk+fLhiYmKcj8OHD2fw3gAAAADIzbL00r6r9enTR7/++qvWrVt307fl5eXlci8sAAAAALAjW5yR6tu3rxYvXqzvv/9exYoVc5aHhoYqISFBZ86ccal//PhxhYaGOutcO4tf0vOkOgAAAACQkbI0SBlj1LdvXy1cuFCrVq1SyZIlXZbXrl1bHh4eWrlypbNsz549OnTokCIiIiRJERER2rFjh06cOOGss2LFCgUEBKhSpUqZsyMAAAAAbilZemlfnz59NGfOHH311VfKmzevc0xTYGCgfHx8FBgYqJ49e2rw4MEKDg5WQECA+vXrp4iICNWrV0+S1Lx5c1WqVEldu3bV66+/rujoaI0YMUJ9+vTh8j0AAAAAN0WWBqmpU6dKkho3buxSPn36dHXv3l2SNHHiRLm5ualDhw6Kj49XixYt9O677zrruru7a/HixXryyScVEREhPz8/RUZGasyYMZm1GwAAAABuMVkapIwxN6zj7e2tKVOmaMqUKanWKVGihL799tuM7BoAAAAApCpbTDYBAAAAADkJQQoAAAAAbCJIAQAAAIBNBCkAAAAAsIkgBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADAJoIUAAAAANhEkAIAAAAAmwhSAAAAAGATQQoAAAAAbCJIAQAAAIBNBCkAAAAAsIkgBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADAJoIUAAAAANhEkAIAAAAAmwhSAAAAAGATQQoAAAAAbCJIAQAAAIBNBCkAAAAAsIkgBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADAJoIUAAAAkNv98IPUpo1UpIjkcEhffum63BjpxRelwoUlHx+pWTNp796U24qPl2rUsNrZtu36271wQerTR8qfX/L3lzp0kI4fT15vxgypWjXJ21sqVMhaJ5sjSAEAAAC5XVycVL26NGVKystff12aPFmaNk3avFny85NatLCC0LWefdYKZGkxaJC0aJE0b560Zo109KjUvr1rnTfflJ5/Xho2TPrtN+m776xtZ3N5sroDAAAAAG6yVq2sR0qMkSZNkkaMkNq2tco++UQKCbHOXHXqdKXukiXS8uXSF19Y319PTIz04YfSnDnSXXdZZdOnSxUrSps2SfXqSf/8Y2130SKpadMr61arlt49zTSckQIAAABuZQcOSNHR1uV8SQIDpbp1pY0br5QdPy49/rg0c6bk63vjdqOipIsXXdutUEEqXvxKuytWSImJ0l9/WQGrWDGpY0fp8OGM2bebiCAFAAAA3Mqio62vISGu5SEhV5YZI3XvLj3xhHTbbWlv19NTCgpKvd0//rCC1CuvWGfF5s+XTp+W7r5bSkhI5w5lDoIUAAAAgOt7+23p3Dlp+PCMbTcx0TprNXmyNS6qXj3p00+tiS6+/z5jt5XBCFIAAADArSw01Pp67Wx6x49fWbZqlXU5npeXlCePVKaMVX7bbVJkZOrtJiRIZ86k3m7hwtbXSpWuLC9YUCpQQDp0KN27lBkIUgAAAMCtrGRJK9isXHml7OxZa/a+iAjr+eTJ0vbt1nTn27ZJ335rlX/2mfTyyym3W7u25OHh2u6ePVZASmq3fv0r5UlOn5b+/lsqUSIj9u6mYdY+AAAAILeLjZX27bvy/MABKxAFB1uTPwwcKL30klS2rBWsXnjBmuK8XTurfvHiru35+1tfS5e2JoiQrAkjmja1Zvy7/XZrwoqePaXBg63tBARI/fpZIapePWudcuWsmQIHDJDef9+qM3y4NSlFkyY38QX57whSAAAAQG7300+uwWTwYOtrZKR1M9xnn7XuNdWrl3UpXoMG0tKl1g1y0+riRevM0vnzV8omTpTc3Kwb8cbHW+Og3n3Xdb1PPrHuN9W6tVW3USNr2x4e6d3bTEGQAgAAAHK7xo2tmfdS43BIY8ZYj7QID0/eXkpl3t7WTYBTuxGwZJ2F+vBD65GDMEYKAAAAAGwiSAEAAACATQQpAAAAALApS8dI/fDDDxo/fryioqJ07NgxLVy4UO2SZgaRZIzRyJEj9cEHH+jMmTOqX7++pk6dqrJlyzrrnD59Wv369dOiRYvk5uamDh066K233pJ/0kwiAAAAQA7SfG4G3/T2FrC807hM32aWnpGKi4tT9erVNSWVwWevv/66Jk+erGnTpmnz5s3y8/NTixYtdOHCBWedLl266LffftOKFSu0ePFi/fDDD+rVq1dm7QIAAACAW1CWnpFq1aqVWrVqleIyY4wmTZqkESNGqG3btpKkTz75RCEhIfryyy/VqVMn7dq1S0uXLtWWLVt02223SZLefvtt3XPPPZowYYKKFCmSYtvx8fGKj493Pj979mwG7xkAAACA3CzbjpE6cOCAoqOj1axZM2dZYGCg6tatq40bN0qSNm7cqKCgIGeIkqRmzZrJzc1NmzdvTrXtcePGKTAw0PkICwu7eTsCAAAAINfJtkEqOjpakhQSEuJSHhIS4lwWHR2tQoUKuSzPkyePgoODnXVSMnz4cMXExDgfhw8fzuDeAwAAAMjNsm2Qupm8vLwUEBDg8gAAAEAOcPmy9MILUsmSko+PVLq0NHas641gR42SKlSQ/PykfPmkZs2k61yt5PTXX9Ijj0j581ttV60q/fSTteziRWnoUKvMz08qUkTq1k06evSm7Cayv2wbpEJDQyVJx48fdyk/fvy4c1loaKhOnDjhsvzSpUs6ffq0sw4AAABykddek6ZOld55R9q1y3r++uvS229fqVOunLV8xw5p3TopPFxq3lw6eTL1dv/5R6pfX/LwkJYskXbulN54wwpiknT+vPTzz1aI+/lnacECac8e6b77buruIvvK0skmrqdkyZIKDQ3VypUrVaNGDUnWpBCbN2/Wk08+KUmKiIjQmTNnFBUVpdq1a0uSVq1apcTERNWtWzerug4AAICbZcMGqW1bqXVr63l4uPTpp9KPP16p8/DDruu8+ab04YfSL79ITZum3O5rr0lhYdL06VfKSpa88n1goLRihes677wj3X67dOiQVLx4uncJOVOWnpGKjY3Vtm3btG3bNknWBBPbtm3ToUOH5HA4NHDgQL300kv6+uuvtWPHDnXr1k1FihRx3muqYsWKatmypR5//HH9+OOPWr9+vfr27atOnTqlOmMfAAAAcrA77pBWrpR+/916vn27ddYplZmglZAgvf++FYSqV0+93a+/lm67TXrwQalQIalmTemDD67fl5gYyeGQgoLStSvI2bL0jNRPP/2kJk2aOJ8PHjxYkhQZGakZM2bo2WefVVxcnHr16qUzZ86oQYMGWrp0qby9vZ3rzJ49W3379lXTpk2dN+SdPHlypu8LAAAAMsGwYdLZs9YYKHd3a8zUyy9LXbq41lu8WOrUybokr3Bh62xSgQKpt/vHH9Ylg4MHS889J23ZIvXvL3l6SpGRyetfuGCNmercWWK8/S0pS4NU48aNZa4eGHgNh8OhMWPGaMyYManWCQ4O1pw5c25G9wAAAJDdfP65NHu2NGeOVLmytG2bNHCgNfnD1YGnSRNr2d9/W2eWOna0Jpy4ZsZnp8RE64zUK69Yz2vWlH79VZo2LXmQunjRas8YK3zhlpRtJ5sAAAAAkhkyxDor1amTNYNe167SoEHSuHGu9fz8pDJlpHr1rPFRefJYX1NTuLBUqZJrWcWK1vinqyWFqD//tM5ycTbqlkWQApAzhIdb16Ff++jT50qdjRulu+6yfnkGBEh33in9+2/qbY4alby9ChVc61y4YG0jf37J31/q0EG6ZjZRAEAmOn9ecrvmT1h3d+uM0vUkJkrx8akvr1/fmoXvar//LpUoceV5Uojau1f67jvrdwNuWQQpADnDli3SsWNXHkkzJz34oPV140apZUtretsff7Tq9+2b/JfttSpXdm133TrX5YMGSYsWSfPmSWvWWPcLad8+4/cPAJA2bdpYY6K++UY6eFBauNCale/++63lcXHWGKdNm6yzRlFR0qOPWveISvqdIVmz973zzpXngwZZ67zyirRvn3Xp4PvvX/mH3cWL0gMPWPeVmj3bGpsVHW09EhIybfeRfWTb6c8BwEXBgq7PX33Vugljo0bW80GDrEHBw4ZdqVO+/I3bzZNHSu2+czEx1mUgc+ZYZ7oka1rcihWtX7b16tnfDwDAf/P229a9nJ56Sjpxwhob1bu39OKL1nJ3d2n3bunjj63xUfnzS3XqSGvXWv88S7J/v7U8SZ06VigbPlwaM8aa+nzSpCuTWPz1lzWznyT979Y8Tt9/LzVufJN2GNkVQQpAzpOQIM2aZc2s5HBYv0g3b7Z+2d1xh/XLsUIF6z+WDRpcv629e61fwt7eUkSEdY190r1AoqKs/0A2a3alfoUK1vKNGwlSAJAV8ua1As6kSSkv9/a2bpZ7IwcPJi+7917rkZLwcGtyCeB/uLQPQM7z5ZfSmTNS9+7W8z/+sL6OGiU9/ri0dKlUq5Z12cbevam3U7euNGOGVX/qVOnAAalhQ+ncOWt5dLQ17e219wcJCbGW5QQ3Glv2/vvWf1EDAqzyM2du3Oa5c9YMWSVKSD4+VnjdssW1zvHj1s+nSBHJ19e67PJ6PwsAAHIYghSAnOfDD60bLybdeDtpgHHv3lKPHtaUtRMnWpf2ffRR6u20amVdL1+tmtSihfTtt1aQ+Pzzm74LmeZGY8vOn7dCznPPpb3Nxx6z2pk5U9qxwxqX1qyZddmLZP3Htl07K+B+9ZW0dasVupo1s8YuAACQC3BpH4Cc5c8/rZmSrr5so3Bh62tapq29nqAgqVw5a5CxZI2dSkiwwtXVZ6WOH099XFV2c6OxZQMHWl9Xr05be//+K33xhRWQ7rzTKhs1ypqQY+pU6aWXrDNPmzZZ919JGo8wdar1mn36qRXEAADI4QhSAHKW6dOtmym2bn2lLDzcOjuV0rS1rVqlve3YWGt8Vdeu1vPatSUPD2nlSmvac8naxqFD1niqnObasWXpcemSNVOVt7druY/PlRkPk6YXvrqOm5vk5WXVIUgBt4yGvcdmdRdyJJ8mWd0DpAWX9gHIORITrSAVGWnNtpfE4bBu0Dh5sjR/vnVG6YUXrFmbeva8Uu/aqW6fecaa0vzgQWnDBmvqXHd3qXNna3lgoLX+4MHWjExRUdalgxEROXOiiWvHlqVH3rzW/o8da00Ff/myFc42brQuHZSuTMgxfLj0zz9WgHvtNenIkSt1AADI4TgjBSDn+O4762zQo48mXzZwoHXz3EGDpNOnperVrXE8pUtfqXPtVLdHjlih6dQp6xK4Bg2sS9Kuvhxu4kTrbEqHDtaZlhYtpHffvWm7eFNdO7YsvWbOtH4GRYtawbNWLet1jIqylnt4WJde9uwpBQdbdZo1s7bNjFcAgFyCIAUg52je/Pp/iA8b5nofqWtdO9Xt3Lk33qa3tzRlivXIyVIaW5ZepUtbZ/Li4qSzZ60xag89JJUqdaVO7drStm3WvbgSEqxwWreudNtt/337AABkA1zaBwC3gpTGlv1Xfn5WiPrnH2nZMqlt2+R1AgOtELV3r/TTTynXAQAgB+KMFADkdqmNLZOs+2FFR1+ZqXDHDmscVPHi1mV5kjW27P77pb59refLlllnBsuXt9YbMsQaF9Wjx5V2582zAlTx4labAwZYU6I3b37TdxcAgMzAGSkAyO2uN7Zs2jTrvluPP249v/NO6/nXX1+pc+3YspgY64a+FSpI3bpZY8uWLbPGRiU5dsya/bBCBal/f+v7Tz+9OfsHAEAW4IwUgJuCKW/tW/veCzen4euNLRs1ynpcz7Vjyzp2tB7X07+/9QAAIJfijBQAAAAA2ESQAgAAAACbCFIAAAAAYBNjpAAgm2g+d3hWdyFHWt5pXFZ3AQBwC+KMFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADAJoIUAAAAANhEkAIAAAAAmwhSAAAAAGATQQoAAAAAbCJIAQAAAIBNBCkAAAAAsIkgBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADAJoIUAAAAANhEkAIAAAAAmwhSAAAAAGATQQoAAAAAbCJIAQAAAIBNBCkAAAAAsIkgBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2ESQAgAAAACbCFIAAAAAYBNBCgAAAABsIkgBAAAAgE0EKQAAAACwiSAFAAAAADYRpAAAAADAplwTpKZMmaLw8HB5e3urbt26+vHHH7O6SwAAAAByqVwRpD777DMNHjxYI0eO1M8//6zq1aurRYsWOnHiRFZ3DQAAAEAulCuC1JtvvqnHH39cPXr0UKVKlTRt2jT5+vrqo48+yuquAQAAAMiF8mR1B/6rhIQERUVFafjw4c4yNzc3NWvWTBs3bkxxnfj4eMXHxzufx8TESJLOnj2bIX26lHAhQ9q51Vw6H3/jSnCRUcfszcD7wD7eA+nD+yB34X2QPtn1fcB7IH14H9iXke+BpLaMMdet5zA3qpHNHT16VEWLFtWGDRsUERHhLH/22We1Zs0abd68Odk6o0aN0ujRozOzmwAAAABykMOHD6tYsWKpLs/xZ6TSY/jw4Ro8eLDzeWJiok6fPq38+fPL4XBkYc9uXWfPnlVYWJgOHz6sgICArO4OkOl4DwC8DwCJ90F2YIzRuXPnVKRIkevWy/FBqkCBAnJ3d9fx48ddyo8fP67Q0NAU1/Hy8pKXl5dLWVBQ0M3qImwICAjgQwO3NN4DAO8DQOJ9kNUCAwNvWCfHTzbh6emp2rVra+XKlc6yxMRErVy50uVSPwAAAADIKDn+jJQkDR48WJGRkbrtttt0++23a9KkSYqLi1OPHj2yumsAAAAAcqFcEaQeeughnTx5Ui+++KKio6NVo0YNLV26VCEhIVndNaSRl5eXRo4cmeySS+BWwXsA4H0ASLwPcpIcP2sfAAAAAGS2HD9GCgAAAAAyG0EKAAAAAGwiSAEAAACATQQpZDvh4eGaNGlSVncDyBIc/8iNOK5xq+M9kDsx2QTSrXHjxqpRo0aGfzCcPHlSfn5+8vX1zdB2gYzE8Y/c6mYc2xzXyEl4DyCtcsX058hdChYsmNVdALIMxz9yI45r3Op4D+ROXNqXSzVu3Fj9+/fXs88+q+DgYIWGhmrUqFHO5YcOHVLbtm3l7++vgIAAdezYUcePH3cuHzVqlGrUqKGZM2cqPDxcgYGB6tSpk86dOydJ6t69u9asWaO33npLDodDDodDBw8elCStWbNGt99+u7y8vFS4cGENGzZMly5dkiR98skn8vf31969e53beuqpp1ShQgWdP39eUvLT32fOnFHv3r0VEhIib29vValSRYsXL77ha3Dq1Cl17txZRYsWla+vr6pWrapPP/3Upc7SpUvVoEEDBQUFKX/+/Lr33nu1f/9+lzqHDx9Wx44dFRQUpODgYLVt29a5r8iebvXj3xijggULav78+c6yGjVqqHDhws7n69atk5eXl3O7b775pqpWrSo/Pz+FhYXpqaeeUmxsrEu769atU8OGDeXj46OwsDD1799fcXFxN/pxIAdJ7djODse1xOc6br7s/B7gsz0bMsiVGjVqZAICAsyoUaPM77//bj7++GPjcDjM8uXLzeXLl02NGjVMgwYNzE8//WQ2bdpkateubRo1auRcf+TIkcbf39+0b9/e7Nixw/zwww8mNDTUPPfcc8YYY86cOWMiIiLM448/bo4dO2aOHTtmLl26ZI4cOWJ8fX3NU089ZXbt2mUWLlxoChQoYEaOHOls+8EHHzR16tQxFy9eNIsXLzYeHh7mp59+ci4vUaKEmThxojHGmMuXL5t69eqZypUrm+XLl5v9+/ebRYsWmW+//faGr8GRI0fM+PHjzdatW83+/fvN5MmTjbu7u9m8ebOzzvz5880XX3xh9u7da7Zu3WratGljqlatai5fvmyMMSYhIcFUrFjRPProo+aXX34xO3fuNA8//LApX768iY+P/w8/IdxMHP/GtG/f3vTp08cYY8zp06eNp6enCQwMNLt27TLGGPPSSy+Z+vXrO+tPnDjRrFq1yhw4cMCsXLnSlC9f3jz55JPO5fv27TN+fn5m4sSJ5vfffzfr1683NWvWNN27d7f980H2ldKxnZ2Oaz7XcbNl9/cAn+3ZC0Eql2rUqJFp0KCBS1mdOnXM0KFDzfLly427u7s5dOiQc9lvv/1mJJkff/zRGGP9Ienr62vOnj3rrDNkyBBTt25dl20MGDDAZRvPPfecKV++vElMTHSWTZkyxfj7+zt/iZ0+fdoUK1bMPPnkkyYkJMS8/PLLLm1c/WGzbNky4+bmZvbs2ZP+F+MqrVu3Nk8//XSqy0+ePGkkmR07dhhjjJk5c2ay/YmPjzc+Pj5m2bJlGdInZDyOf2MmT55sKleubIwx5ssvvzR169Y1bdu2NVOnTjXGGNOsWTNnMEzJvHnzTP78+Z3Pe/bsaXr16uVSZ+3atcbNzc38+++/tvuH7OvaYzs7Hdcp4XMdGS07vwf4bM9euLQvF6tWrZrL88KFC+vEiRPatWuXwsLCFBYW5lxWqVIlBQUFadeuXc6y8PBw5c2bN9n617Nr1y5FRETI4XA4y+rXr6/Y2FgdOXJEkpQvXz59+OGHmjp1qkqXLq1hw4al2t62bdtUrFgxlStXLm07fZXLly9r7Nixqlq1qoKDg+Xv769ly5bp0KFDzjp79+5V586dVapUKQUEBCg8PFySnHW2b9+uffv2KW/evPL395e/v7+Cg4N14cKFZJeKIHu51Y//Ro0aaefOnTp58qTWrFmjxo0bq3Hjxlq9erUuXryoDRs2qHHjxs763333nZo2baqiRYsqb9686tq1q06dOuW8PGT79u2aMWOG833g7++vFi1aKDExUQcOHLDdP+Qc2em45nMdWSE7vQf4bM9emGwiF/Pw8HB57nA4lJiYmGnrX88PP/wgd3d3HTt2THFxcS5/sF7Nx8cn3dsYP3683nrrLU2aNMl5ffDAgQOVkJDgrNOmTRuVKFFCH3zwgYoUKaLExERVqVLFWSc2Nla1a9fW7Nmzk7XPwNHs7VY//pP+0FyzZo3WrFmjl19+WaGhoXrttde0ZcsWXbx4UXfccYck6eDBg7r33nv15JNP6uWXX1ZwcLDWrVunnj17KiEhQb6+voqNjVXv3r3Vv3//ZNsqXrx4uvuJ3IPPddzq+Gy/9XBG6hZUsWJFHT58WIcPH3aW7dy5U2fOnFGlSpXS3I6np6cuX76crO2NGzfKXDWr/vr165U3b14VK1ZMkrRhwwa99tprWrRokfz9/dW3b99Ut1GtWjUdOXJEv//+e5r7dfV227Ztq0ceeUTVq1dXqVKlXNo5deqU9uzZoxEjRqhp06aqWLGi/vnnH5c2atWqpb1796pQoUIqU6aMyyMwMNB2n5D1bpXj3+FwqGHDhvrqq6/022+/qUGDBqpWrZri4+P13nvv6bbbbpOfn58kKSoqSomJiXrjjTdUr149lStXTkePHnVpr1atWtq5c2ey90GZMmXk6elpu3/Ivq49trPTcc3nOjJDdn4P8NmevRCkbkHNmjVT1apV1aVLF/3888/68ccf1a1bNzVq1Ei33XZbmtsJDw/X5s2bdfDgQf39999KTEzUU089pcOHD6tfv37avXu3vvrqK40cOVKDBw+Wm5ubzp07p65du6p///5q1aqVZs+erc8++8xlBpqrNWrUSHfeeac6dOigFStW6MCBA1qyZImWLl16w/6VLVtWK1as0IYNG7Rr1y717t3bZWa2fPnyKX/+/Hr//fe1b98+rVq1SoMHD3Zpo0uXLipQoIDatm2rtWvX6sCBA1q9erX69+/vPJ2PnOVWOf4la/bCTz/9VDVq1JC/v7/c3Nx05513avbs2WrUqJGzXpkyZXTx4kW9/fbb+uOPPzRz5kxNmzbNpa2hQ4dqw4YN6tu3r7Zt26a9e/fqq6++uu4fC8iZrj22s9Nxzec6MkN2fg9IfLZnK1k7RAs3S0oD4du2bWsiIyONMcb8+eef5r777jN+fn4mb9685sEHHzTR0dHOuiNHjjTVq1d3WX/ixImmRIkSzud79uwx9erVMz4+PkaSOXDggDHGmNWrV5s6deoYT09PExoaaoYOHWouXrxojDGmR48epmrVqubChQvOdt544w0THBxsjhw5YoxxHZBpjDGnTp0yPXr0MPnz5zfe3t6mSpUqZvHixTd8DU6dOmXatm1r/P39TaFChcyIESNMt27dTNu2bZ11VqxYYSpWrGi8vLxMtWrVzOrVq40ks3DhQmedY8eOmW7dupkCBQoYLy8vU6pUKfP444+bmJiYG/YBWYPj37J161YjyQwdOtRlPySZpUuXutR98803TeHChY2Pj49p0aKF+eSTT4wk888//zjr/Pjjj+buu+82/v7+xs/Pz1SrVi3ZgGrkfCkd29nluOZzHZkhO78HjOGzPTtxGHPVeUoAAAAAwA1xaR8AAAAA2ESQQo7VqlUrl+k6r3688sorWd094Kbi+EduxHGNWx3vgZyFS/uQY/3111/6999/U1wWHBys4ODgTO4RkHk4/pEbcVzjVsd7IGchSAEAAACATVzaBwAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgCAW97BgwflcDi0bdu2dK0fHh6uSZMmOZ87HA59+eWXGdI3AED2RJACAGRr3bt3l8PhSPZo2bJlpvajcePGKfbj0qVL2rJli3r16pWp/QEAZK08Wd0BAABupGXLlpo+fbpLmZeXV6b34/HHH9eYMWNcyvLkyaOCBQtmel8AAFmLM1IAgGzPy8tLoaGhLo98+fJJkh5++GE99NBDLvUvXryoAgUK6JNPPpEkLV26VA0aNFBQUJDy58+ve++9V/v377fdD19f32T9kJJf2netw4cPq2PHjgoKClJwcLDatm2rgwcP2t4+ACD7IEgBAHK0Ll26aNGiRYqNjXWWLVu2TOfPn9f9998vSYqLi9PgwYP1008/aeXKlXJzc9P999+vxMTEm96/ixcvqkWLFsqbN6/Wrl2r9evXy9/fXy1btlRCQsJN3z4A4OYgSAEAsr3FixfL39/f5fHKK69Iklq0aCE/Pz8tXLjQWX/OnDm67777lDdvXklShw4d1L59e5UpU0Y1atTQRx99pB07dmjnzp22+vHuu++69OHpp5++4TqfffaZEhMT9X//93+qWrWqKlasqOnTp+vQoUNavXq1re0DALIPxkgBALK9Jk2aaOrUqS5lwcHBkqwxSh07dtTs2bPVtWtXxcXF6auvvtLcuXOddffu3asXX3xRmzdv1t9//+08E3Xo0CFVqVIlzf3o0qWLnn/+eefzoKCgG66zfft27du3zxnqkly4cCFdlxcCALIHghQAINvz8/NTmTJlUl3epUsXNWrUSCdOnNCKFSvk4+PjMqtfmzZtVKJECX3wwQcqUqSIEhMTVaVKFduX1gUGBl63HymJjY1V7dq1NXv27GTLmKQCAHIughQAIMe74447FBYWps8++0xLlizRgw8+KA8PD0nSqVOntGfPHn3wwQdq2LChJGndunWZ1rdatWrps88+U6FChRQQEJBp2wUA3FyMkQIAZHvx8fGKjo52efz9998udR5++GFNmzZNK1asUJcuXZzl+fLlU/78+fX+++9r3759WrVqlQYPHpxpfe/SpYsKFCigtm3bau3atTpw4IBWr16t/v3768iRI5nWDwBAxiJIAQCyvaVLl6pw4cIujwYNGrjU6dKli3bu3KmiRYuqfv36znI3NzfNnTtXUVFRqlKligYNGqTx48dnWt99fX31ww8/qHjx4mrfvr0qVqyonj176sKFC5yhAoAczGGMMVndCQAAAADISTgjBQAAAAA2EaQAAAAAwCaCFAAAAADYRJACAAAAAJsIUgAAAABgE0EKAAAAAGwiSAEAAACATQQpAAAAALCJIAUAAAAANhGkAAAAAMAmghQAAAAA2PT/q6B6a1Ru/TQAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 1000x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# plot the perplexity scores for the gpt2 model\n",
-    "plot_perplexity(eval_files, base_ppls, ft_ppts, base_model_path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1IAAAIjCAYAAAAJLyrXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACGC0lEQVR4nOzdeZxO5f/H8fdtmH0zzBjLMLLvhDTWwWQXUbJkD1kSIlS2ZCshEtXXlkiWCEXZ9z2kCGmEGEJmDBlj5vz+OL+5uc1i7jHM4vV8PM5j5r7OdV/nOjPnnPv+nGs5FsMwDAEAAAAAki1LWlcAAAAAADIaAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAilkGJs3b5bFYtHmzZsf2TaCg4MVHBz8yMp/kkVGRurVV1+Vv7+/LBaL+vXrl9ZVAh6Z06dPy2KxaOLEiala7smTJ1WvXj15eXnJYrFoxYoVqVp+evcortEffvihnnrqKTk4OKh8+fKpWjZMGeGzNTAwUJ06dbJJS+h8mzt3riwWi06fPv3Y62ixWDRy5MjHvl0kjkAKCYq7UMQtzs7OKlq0qPr06aOLFy+mdfUem/Pnz2vkyJE6dOhQqpe9fft2NWzYUHnz5pWzs7Py58+vpk2bauHCham+rfRg7Nixmjt3rnr27Kn58+erffv2j2xbR48elaOjozp37hxv3bVr15Q7d25VqVJFsbGxkqSRI0fKYrHo8uXLiZYZF8hbLBZ99dVXCeapVq2aLBaLSpcunax6xpX36quvJrj+nXfesea5t26dOnWSu7t7kmXfew5v37493nrDMBQQECCLxaImTZo8sK5xgUFiy/jx4615g4ODZbFY1LRp00TLSU6AsW/fPvXp00elSpWSm5ub8ufPr1atWunEiRMJ5j927JgaNGggd3d3+fj4qH379vrnn3+S3MaCBQtksVgS/XsuXrxYzz77rLy9vZUjRw7VqlVL33///QPr/qh07NhRR44c0ZgxYzR//nxVqlQpzeqSGfz000966623VK1aNc2ZM0djx459pNf9xNx7fbFYLHJyclKuXLkUHByssWPHPvA4btWqlSwWiwYPHpys8rNly6annnpKHTp00J9//inp7nn7oOVxf5EfO3Zsmt0wSIvz7YcffiBYykCypnUFkL699957KliwoG7duqXt27drxowZ+uGHH/Trr7/K1dU1rauX6n766Seb1+fPn9eoUaMUGBiYqncqlyxZopdfflnly5fXG2+8oezZsys0NFRbt27VF198obZt26battKLjRs36tlnn9WIESMe+bZKliypQYMGaezYserUqZNq1aplXTdkyBD9888/WrNmjbJksf9ekrOzsxYuXKhXXnnFJv306dPauXOnnJ2d7S5v2bJl+vTTT+Xo6Giz7uuvv5azs7Nu3bpldz3vr2/16tVt0rds2aJz587JycnJrvLatGmjRo0axUuvUKFCvLTVq1frwIEDqlixon2V/n8TJkzQjh079NJLL6ls2bIKCwvTJ598oqefflq7d++2CVjPnTunmjVrysvLS2PHjlVkZKQmTpyoI0eOaO/evfH+tpLZSvrWW2/Jzc0twe1PmzZNffv2VePGjTV+/HjdunVLc+fOVZMmTbRs2TK1aNEiRfuVUv/995927dqld955R3369Hms286sNm7cqCxZsmjWrFnWY2T//v2P5LqfHH379lXlypUVExOjf/75Rzt37tSIESM0adIkLV68WHXq1In3noiICK1atUqBgYH6+uuvNX78eFksliTLj46O1s8//6zPP/9c33//vY4cOaJ33nnH5qbOvn37NHXqVL399tsqUaKENb1s2bKpv+NJGDt2rF588UU1b978kW7n+PHjNp8JiZ1v7du3V+vWre2+dibXDz/8oOnTpycYTP3333/KmpWv7ukJ/w0kqWHDhtY7MK+++qpy5MihSZMm6bvvvlObNm0equybN2+mu2AsoS9bj8LIkSNVsmRJ7d69O942L1269FjqIJmtErdu3ZKLi8sj39alS5dUsmTJVCvvzp07io2NTfR/NmzYMH3zzTfq0aOHfvnlFzk6OmrXrl36/PPP1b9//xR/QWrUqJFWrlypy5cvK2fOnNb0hQsXKleuXCpSpIj+/fffZJfXoEEDrVy5UmvWrFGzZs2s6Tt37lRoaKhatmypZcuWpaiucfVdsmSJpk6davMBvHDhQlWsWDHJVriEPP300/GCyITkz59f169f16hRo7Ry5Uq76y1JAwYM0MKFC23+xy+//LLKlCmj8ePH27QMjh07Vjdu3NCBAweUP39+SdIzzzyj5557TnPnzlX37t3jlf/+++/Lw8NDtWvXTvCO97Rp01S5cmWtWrXK+sW0S5cuyps3r+bNm/fYA6m4Vglvb+9UK/PGjRuJBpJPgkuXLsnFxeWxXPuT87euUaOGXnzxRZu0w4cPq169emrZsqWOHj2q3Llz26xftmyZYmJiNHv2bNWpU0dbt261uXmUWPmdO3dW0aJF1bdvX82bN09Dhw61yevs7KypU6fqueeeS/fd8lLD/YFRYuebg4ODHBwcHle1bNh7ow6PHl37YJe4u2GhoaHWtK+++koVK1aUi4uLfHx81Lp1a509e9bmfcHBwSpdurQOHDigmjVrytXVVW+//bYks19ykyZN9NNPP6l8+fJydnZWyZIl9e233yarTnv27FGDBg3k5eUlV1dX1apVSzt27LCuP3bsmFxcXNShQweb923fvl0ODg42XSHu7ce9efNmVa5cWZL5gRPXrWHu3LkaMWKEsmXLlmB3i+7du8vb2zvJVoRTp06pcuXKCX54+/n52byOjY3Vxx9/rDJlysjZ2Vm+vr5q0KCB9u/fb81z584djR49WoUKFZKTk5MCAwP19ttvKyoqyqasuL/1jz/+qEqVKsnFxUWfffaZJLPLW79+/RQQECAnJycVLlxYEyZMsHZ/i7No0SJVrFhRHh4e8vT0VJkyZfTxxx8nuq9xXUpCQ0P1/fffW/+Ocf3LL126pK5duypXrlxydnZWuXLlNG/ePJsy7u0ONmXKFOt+Hj16NNHtOjs7a8aMGTp+/LjGjRun6Ohode/eXQEBAXrvvfcSfd+DNGvWTE5OTlqyZIlN+sKFC9WqVSu7P2Dz5s2rmjVrxuvSuWDBApUpUybZ3QQT06ZNG125ckXr1q2zpt2+fVtLly59pC2fHh4e6t+/v1atWqWff/45RWVUrVo13jlSpEgRlSpVSseOHbNJX7ZsmZo0aWINoiQpJCRERYsW1eLFi+OVffLkSU2ePFmTJk1K9A5vRESE/Pz8bO7ue3p6yt3d3a6bD5MnT1aBAgXk4uKiWrVq6ddff42X5/fff9eLL74oHx8fOTs7q1KlSjYB6MiRI1WgQAFJ0qBBg2SxWBQYGGhdf/DgQTVs2NBav7p162r37t0224jr7rllyxb16tVLfn5+ypcvn3X9mjVrVKNGDbm5ucnDw0ONGzfWb7/99sD9u3r1qgYOHKgyZcrI3d1dnp6eatiwoQ4fPmyTL+5asHjxYo0ZM0b58uWTs7Oz6tatqz/++CNeuZ9//rkKFSokFxcXPfPMM9q2bdsD6xJnzpw5qlOnjvz8/OTk5KSSJUtqxowZNnksFovmzJmjGzdu2FzfE7vux3nQZ450t7vw0aNH1bZtW2XPnj1eq3BylStXTlOmTNG1a9f0ySefxFu/YMECPffcc6pdu7ZKlCihBQsWJLvshD7TH1Zy/29RUVEaMWKEChcuLCcnJwUEBOitt96y+dyyWCy6ceOG5s2bZ/1f3DuO6UHHfVyL4/Dhw222vXDhQlksFptj4t4xUkmdb4mNkVqzZo1q1apl/WysXLmyzXV927Zteumll5Q/f37r/vbv31///fefNU+nTp00ffp0677HLff+Pe5vqbLn3N+xY4cGDBggX19fubm56YUXXnhgt1EkjUAKdjl16pQkKUeOHJKkMWPGqEOHDipSpIgmTZqkfv36acOGDapZs6auXbtm894rV66oYcOGKl++vKZMmaLatWtb1508eVIvv/yyGjZsqHHjxilr1qx66aWXbL78JWTjxo2qWbOmIiIiNGLECI0dO1bXrl1TnTp1tHfvXklSiRIlNHr0aM2fP9/6xeTGjRvq1KmTihcvnuiX6hIlSljXde/eXfPnz9f8+fNVs2ZNtW/fXnfu3NE333xj8564L6gtW7ZM8s5RgQIFtGHDBp07dy7J/ZOkrl27WgOcCRMmaMiQIXJ2dra5UL766qsaPny4nn76aU2ePFm1atXSuHHj1Lp163jlHT9+XG3atNFzzz2njz/+WOXLl9fNmzdVq1YtffXVV+rQoYOmTp2qatWqaejQoRowYID1vevWrVObNm2UPXt2TZgwQePHj1dwcHC8LxH3/x3nz5+vnDlzqnz58ta/o6+vr/777z8FBwdr/vz5ateunT788EN5eXmpU6dOCQZnc+bM0bRp09S9e3d99NFH8vHxSfJv99xzz6lNmzYaN26c+vTpo19//VXTpk17qDvwrq6uatasmb7++mtr2uHDh/Xbb7+lODBp27atVq1apcjISElmYLxkyZJUCXQCAwMVFBRkU981a9YoPDw8wePjQW7evKnLly/HW+7cuRMvb1y31dTs728Yhi5evGjTGvj333/r0qVLCY5feOaZZ3Tw4MF46f369VPt2rUT7KYYJzg4WGvXrtW0adN0+vRp/f777+rdu7fCw8P1xhtvJKu+X375paZOnarevXtr6NCh+vXXX1WnTh2bsaa//fabnn32WR07dkxDhgzRRx99JDc3NzVv3lzLly+XJLVo0UKTJ0+WZAbH8+fP15QpU6zvr1Gjhg4fPqy33npLw4YNU2hoqIKDg7Vnz554derVq5eOHj2q4cOHa8iQIZKk+fPnq3HjxnJ3d9eECRM0bNgwHT16VNWrV3/goPo///xTK1asUJMmTTRp0iQNGjRIR44cUa1atXT+/Pl4+cePH6/ly5dr4MCBGjp0qHbv3q127drZ5Jk1a5Z69Oghf39/ffDBB6pWrZqef/75eDfpEjNjxgwVKFBAb7/9tj766CMFBASoV69e1i+pcftco0YNOTk5Wa9LSV33peR95tzrpZde0s2bNzV27Fh169YtWXVPyIsvvigXF5cEu59v2rTJ2kOkTZs2Wrp0qW7fvp2scu//TH9Yyf2/xcbG6vnnn9fEiRPVtGlTTZs2Tc2bN9fkyZP18ssvW/PNnz9fTk5OqlGjhvV/0aNHD0nJO+7r1KmjXr16ady4cdYbOhcuXNDrr7+ukJAQvfbaawnuR1LnW0Lmzp2rxo0b6+rVqxo6dKjGjx+v8uXLa+3atdY8S5Ys0c2bN9WzZ09NmzZN9evX17Rp02xu8vbo0UPPPfecdd/jlsTYe+6//vrrOnz4sEaMGKGePXtq1apVdBN+WAaQgDlz5hiSjPXr1xv//POPcfbsWWPRokVGjhw5DBcXF+PcuXPG6dOnDQcHB2PMmDE27z1y5IiRNWtWm/RatWoZkoyZM2fG21aBAgUMScayZcusaeHh4Ubu3LmNChUqWNM2bdpkSDI2bdpkGIZhxMbGGkWKFDHq169vxMbGWvPdvHnTKFiwoPHcc89Z02JiYozq1asbuXLlMi5fvmz07t3byJo1q7Fv3z6butSqVcuoVauW9fW+ffsMScacOXPi1TsoKMioUqWKTdq3335rU8fEzJo1y5BkODo6GrVr1zaGDRtmbNu2zYiJibHJt3HjRkOS0bdv33hlxO3zoUOHDEnGq6++arN+4MCBhiRj48aN1rS4v/XatWtt8o4ePdpwc3MzTpw4YZM+ZMgQw8HBwThz5oxhGIbxxhtvGJ6ensadO3eS3L+EFChQwGjcuLFN2pQpUwxJxldffWVNu337thEUFGS4u7sbERERhmEYRmhoqCHJ8PT0NC5dumTXdsPCwozs2bMbkozmzZsnmGfEiBGGJOOff/5JtJy442/JkiXG6tWrDYvFYv27DBo0yHjqqacMwzCPoVKlSiWrbpKM3r17G1evXjUcHR2N+fPnG4ZhGN9//71hsViM06dPJ1i3jh07Gm5ubkmWHXcO79u3z/jkk08MDw8P4+bNm4ZhGMZLL71k1K5d2zCMhP8vCYn7HyS27Nq1y5r33r/BqFGjDEnGgQMHbMr58MMPk/U3ut/8+fMNScasWbOsaXHn6Zdffhkv/6BBgwxJxq1bt6xpq1evNrJmzWr89ttvhmEk/ve8ePGiUbduXZv9zJkzp7Fz584H1jNuP+Oul3H27NljSDL69+9vTatbt65RpkwZmzrGxsYaVatWNYoUKRKvzPv/ds2bNzccHR2NU6dOWdPOnz9veHh4GDVr1rSmxR0T1atXtzmHr1+/bnh7exvdunWzKTcsLMzw8vKKl36/W7duxbt2hYaGGk5OTsZ7771nTYs7h0qUKGFERUVZ0z/++GNDknHkyBHDMMxrgJ+fn1G+fHmbfJ9//rkhyeYanZi4Y/1e9evXt56ncRL63yd23bfnMyfuvG3Tps0D62oYtteXxJQrV87Inj27TdrEiRMNFxcX67XyxIkThiRj+fLlCZY/e/Zs459//jHOnz9vfP/990ZgYKBhsVjifRYahmEsWbIkWZ9ncez5v82fP9/IkiWLsW3bNpsyZs6caUgyduzYYU1zc3MzOnbsGG97yT3ub9y4YRQuXNgoVaqUcevWLaNx48aGp6en8ddff9mUV6BAAZvtJHa+xZ1HoaGhhmEYxrVr1wwPDw+jSpUqxn///WeT9/7j5H7jxo0zLBaLTV169+5tJPb1XJIxYsQIu/8GcXUOCQmxqVP//v0NBwcH49q1awluDw9GixSSFBISIl9fXwUEBKh169Zyd3fX8uXLlTdvXn377beKjY1Vq1atbO5M+/v7q0iRItq0aZNNWU5OTgnOoiZJefLk0QsvvGB97enpqQ4dOujgwYMKCwtL8D2HDh3SyZMn1bZtW125csW6/Rs3bqhu3braunWrtVtalixZNHfuXEVGRqphw4b69NNPNXTo0IeagadDhw7as2eP9Y6eZHaxCAgISLR/epwuXbpo7dq1Cg4O1vbt2zV69GjVqFFDRYoU0c6dO635li1bJovFkuAEDXHN/T/88IMk2bQcSdKbb74pSfFmGCtYsKDq169vk7ZkyRLVqFFD2bNnt/lfhoSEKCYmRlu3bpVk9hW/cePGA1sKk+uHH36Qv7+/zXi7bNmyqW/fvoqMjNSWLVts8rds2VK+vr52bcPV1dU6Fq9evXoPX+n/L8fHx0eLFi2SYRhatGjRQ40ZzJ49uxo0aGBtNVq4cKGqVq1q7VrysFq1aqX//vtPq1ev1vXr17V69eoUt3Z1795d69ati7ckNv4trlVq1KhRD7MLkmRtEQoKClLHjh2t6XFdYxIa/B3XMhyX5/bt2+rfv79ee+21B47Zc3V1VbFixdSxY0ctWbJEs2fPVu7cudWiRYsEu6IlpHnz5sqbN6/19TPPPKMqVapYz9urV69q48aNatWqla5fv249965cuaL69evr5MmT+vvvvxMtPyYmRj/99JOaN2+up556ypqeO3dutW3bVtu3b1dERITNe7p162bTBXXdunW6du2a2rRpY3P+Ozg4qEqVKvGu5fdzcnKyDtKPiYnRlStX5O7urmLFiiXYrbNz5842XTZr1KghSdbZ4/bv369Lly7ptddes8nXqVMneXl5JVmXOPd2vQwPD9fly5dVq1Yt/fnnnwoPD09WGfez5zMnTmItHinh7u6u69ev26QtWLBAjRs3loeHhySz62vFihUT7d7XpUsX+fr6Kk+ePGrcuLG121xqzEZnz/9tyZIlKlGihIoXL25zzMV1NXzQMWfPce/q6qq5c+fq2LFjqlmzpr7//ntNnjzZphvww1i3bp2uX79u7S1yr3u75d17TN64cUOXL19W1apVZRhGgq3mD5KSc7979+42dapRo4ZiYmL0119/2b19mJhsAkmaPn26ihYtqqxZsypXrlwqVqyY9QPz5MmTMgxDRYoUSfC92bJls3mdN2/eRAf0Fi5cON4sQ0WLFpVkjo/x9/eP956TJ09Kks0XqvuFh4cre/bskqRChQpp5MiRGjRokEqXLq1hw4Yl+r7kePnll9WvXz8tWLBAw4cPV3h4uFavXq3+/fsnOmPSverXr6/69evr5s2bOnDggL755hvNnDlTTZo00e+//y4/Pz+dOnVKefLkSbIL219//aUsWbKocOHCNun+/v7y9vaOd4EsWLBgvDJOnjypX375JdEgJW4CjF69emnx4sXWadvr1aunVq1aqUGDBg/c38TqXqRIkXiz58XNEJWcuj/IO++8o7CwMJUoUUIjRoxQ69atrcdESmXLlk0vvfSSFi5cqGeeeUZnz55NNDC5evWqTTcbFxeXBL8Mtm3bVu3bt9eZM2e0YsUKffDBBw9Vx3v5+voqJCRECxcu1M2bNxUTExNvQHucf/75RzExMdbX7u7uNlODFylSRCEhIcnetpeXl/r166cRI0bo4MGD8f72cbOT3cvHxyfetSIsLEyNGzeWl5eXli5dahMIxH1BuX9MoCTrWMW4PJMnT9bly5eTFdi99NJLypo1q1atWmVNa9asmYoUKaJ33nknXtfehCR0fbx33NYff/whwzA0bNiwRK9Jly5dsgnG7vXPP//o5s2bKlasWLx1JUqUUGxsrM6ePatSpUpZ0+8/j+KupQnNCCeZN7aSEjeO89NPP1VoaKjN8ZNQl7H7v8DGHRNxk7TEnff3/+3ipuxOjh07dmjEiBHatWuXbt68abMuPDw82QHZvez9zJFSds1KTGRkpDVgkszxvwcPHlSHDh1sAvvg4GBNnz5dERER8f53w4cPV40aNeTg4KCcOXOqRIkSqTYLnD3/t5MnT+rYsWMP/MxJjL3HfbVq1dSzZ09Nnz5d9evXV5cuXZK9Xw8SdzP1QeNZz5w5o+HDh2vlypXxJiRKSXCfknP/Qece7EcghSQ988wzid6pio2NlcVi0Zo1axIcYH//c1lSe2a4uDt/H374YaIzsN1fh7j+5efPn9eVK1cSDNCSK3v27GrSpIk1kFq6dKmioqKSNaPZvVxdXVWjRg3VqFFDOXPm1KhRo7RmzZokP6wTkpzgTUr4/xAbG6vnnntOb731VoLviQtq/fz8dOjQIf34449as2aN1qxZozlz5qhDhw7xJoh4FOw9hvbv36/p06erb9++6ty5sypWrKjBgwfr888/f+i6tG3bVjNnztTIkSNVrly5RFs3WrRoYdOy1rFjR5uB63Gef/55OTk5qWPHjoqKilKrVq0euo7317dbt24KCwtTw4YNE535rXLlyjYB7IgRIx56jNMbb7yhyZMna9SoUfHGGZw9ezbel81NmzbZzBIWHh6uhg0b6tq1a9q2bZvy5Mljkz9uFrMLFy7E2/aFCxfk4+MjJycnhYeH6/3331evXr0UERFhvVsbGRkpwzB0+vRpubq6ys/PT3/++afWrl0b71jx8fFR9erVkxwXaI+469jAgQPjtRTHuf8mycO6/zyKq8P8+fMTvCY+6Iv22LFjNWzYMHXp0kWjR4+Wj4+PsmTJon79+sVroZGU6IQshmEkdxeSdOrUKdWtW1fFixfXpEmTFBAQIEdHR/3www+aPHlygnVKjpR85qTW5150dLROnDhh82U9btbK/v37q3///vHes2zZsni9QMqUKWPXjZBHJTY2VmXKlNGkSZMSXB8QEJCq24uKitLmzZslmcfH4541OCYmRs8995yuXr2qwYMHq3jx4nJzc9Pff/+tTp06pfiYtNejPveeRARSSLFChQrJMAwVLFjQ+kU7peLuyt4bDMQ9dPPemanu375k3i1NzgfDzJkztW7dOo0ZM0bjxo1Tjx499N133yX5ngcFJx06dFCzZs20b98+LViwQBUqVLC5+2OvuKA17gthoUKF9OOPP+rq1auJtkoVKFBAsbGxOnnypM2zPi5evKhr164lq3tYoUKFFBkZmay/o6Ojo5o2baqmTZsqNjZWvXr10meffaZhw4bZ/YWvQIEC+uWXXxQbG2vTKvX7779b16dUTEyMunfvrjx58ui9996Th4eH3njjDU2aNEmdO3dWUFBQisuWpOrVqyt//vzavHmzJkyYkGi+jz76yOZu3/1BQBwXFxc1b95cX331lRo2bGgzmUJqeOGFF9SjRw/t3r07yZaUBQsW2MwildwWgKTEtUqNHDky3g0Cf3//eF1Fy5UrZ/391q1batq0qU6cOKH169cnGLDmzZtXvr6+NjNZxtm7d6/1S++///6ryMhIffDBBwm2+BUsWFDNmjXTihUrrJNB3Nu6Eic6OjrByTUSEteKca8TJ05Yr2txf99s2bKl6Auur6+vXF1ddfz48Xjrfv/9d2XJkuWBX0rjrqV+fn4pqsPSpUtVu3ZtzZo1yyb92rVrKTqO4877kydP2rSSRUdHKzQ01Ob4SMiqVasUFRWllStX2tyBf1B3sTiJXfft/cxJTUuXLtV///1nDbYNw9DChQtVu3Zt9erVK17+0aNHa8GCBYl2p38U7Pm/FSpUSIcPH1bdunUf+Dmb0Hp7j/sRI0bo2LFjmjhxogYPHqwhQ4Zo6tSpdu9jQuKOi19//TXRz8AjR47oxIkTmjdvns3kEgl1k0/uTdHUOPfx8BgjhRRr0aKFHBwcNGrUqHh3MwzD0JUrV5Jd1vnz562zU0nmtMNffvmlypcvn2irUcWKFVWoUCFNnDjROtvZve7tLhQaGqpBgwapZcuWevvttzVx4kStXLlSX375ZZL1ipvd7f4ZCOPEfeGdMGGCtmzZkuzWqA0bNiSYHjduIq6pvmXLljIMI8FuSHF/87hZx+6/0x93p69x48YPrE+rVq20a9cu/fjjj/HWXbt2zfql8f7/aZYsWawPZ0yoW9WDNGrUSGFhYTZf7O/cuaNp06bJ3d39gWPNkjJ16lQdPHhQU6dOtXaHGTVqlPLly6fXXnst2V+EE2OxWDR16lSNGDFC7du3TzRfxYoVFRISYl2SGpczcOBAjRgx4qG7nSbE3d1dM2bM0MiRI9W0adNE81WrVs2mvqkRSEnmLHne3t7xZsl0dna22V5ISIi1u0lMTIxefvll7dq1S0uWLEky+G3ZsqVWr15tMzvYhg0bdOLECb300kuSzEBh+fLl8ZbatWvL2dlZy5cvtz5Lp3DhwsqSJYu++eYbm+vbuXPntG3btgQfQJyQFStW2Ixx2rt3r/bs2aOGDRta6xQcHKzPPvsswRa1B01N7ODgoHr16um7776zmV3v4sWL1gcxP6hrXv369eXp6amxY8cqOjo6RXW4/zNgyZIlSY7tSkqlSpXk6+urmTNn2nSLnTt3bqLX4vvrI9neZQ8PD9ecOXOStf3Ervv2fOakpsOHD6tfv37Knj27evfuLcnsunj69Gl17txZL774Yrzl5Zdf1qZNmxKcNfFRsef/1qpVK/3999/64osv4pXz33//6caNG9bXbm5u8d5vz3G/Z88eTZw4Uf369dObb76pQYMG6ZNPPok3Bjel6tWrJw8PD40bNy7eY0/ijsGEjknDMBKcnfZB3zvipMa5j4dHixRSrFChQnr//fc1dOhQnT59Ws2bN5eHh4dCQ0O1fPlyde/eXQMHDkxWWUWLFlXXrl21b98+5cqVS7Nnz9bFixeT/ODLkiWL/ve//6lhw4YqVaqUOnfurLx58+rvv//Wpk2b5OnpqVWrVskwDHXp0kUuLi7WZ0b06NFDy5Yt0xtvvKGQkJBEWwkKFSokb29vzZw5Ux4eHnJzc1OVKlWsXZGyZcum1q1b65NPPpGDg0OyJxxo1qyZChYsqKZNm6pQoUK6ceOG1q9fr1WrVqly5crWL7q1a9dW+/btNXXqVJ08eVINGjRQbGystm3bptq1a6tPnz4qV66cOnbsqM8//1zXrl1TrVq1tHfvXs2bN0/Nmze3mWY+MYMGDdLKlSvVpEkTderUSRUrVtSNGzd05MgRLV26VKdPn1bOnDn16quv6urVq6pTp47y5cunv/76S9OmTVP58uVtWsOSq3v37vrss8/UqVMnHThwQIGBgVq6dKl27NihKVOm2IwHsMfZs2c1fPhwNW3a1GYSEzc3N3388cdq0aKFPv74Y+uEHHEmTZoUr7tHlixZrM88u1+zZs1sHqL7sMqVK/fAu+1xoqOj9f7778dL9/HxSfAOtZT02I7k+vnnn20ehBunUKFCSQY6Xl5eeuONN+yadOLNN9/UypUr1bRpU129ejXedu+9cfH2229ryZIlql27tt544w1FRkbqww8/VJkyZax35V1dXdW8efN421mxYoX27t1rs87X11ddunTR//73P9WtW1ctWrTQ9evX9emnn+q///6L9/DSxBQuXFjVq1dXz549FRUVpSlTpihHjhw23WinT5+u6tWrq0yZMurWrZueeuopXbx4Ubt27dK5c+fiPY/pfu+//77WrVun6tWrq1evXsqaNas+++wzRUVFJWusnaenp2bMmKH27dvr6aefVuvWreXr66szZ87o+++/V7Vq1RJ8flGcJk2a6L333lPnzp1VtWpVHTlyRAsWLEhxEJ4tWza9//776tGjh+rUqaOXX35ZoaGhmjNnTrLKrFevnrXlvEePHoqMjNQXX3whPz+/BIPV+yV13U/OZ87D2LZtm27dumWdtGPHjh1auXKlvLy8tHz5cuuNxQULFsjBwSHRG2XPP/+83nnnHS1atCjeRESPij3/t/bt22vx4sV67bXXtGnTJlWrVk0xMTH6/ffftXjxYuuzDiUzgF2/fr0mTZqkPHnyqGDBgqpSpUqyjvtbt26pY8eOKlKkiMaMGSPJvKG2atUqde7cWUeOHHnoB1J7enpq8uTJevXVV1W5cmXrc8MOHz6smzdvat68eSpevLgKFSqkgQMH6u+//5anp6eWLVuW4NikihUrSpL69u2r+vXry8HBIdFHVTzsuY9U8FjnCESGce/UyQ+ybNkyo3r16oabm5vh5uZmFC9e3Ojdu7dx/Phxa56kpoSOm375xx9/NMqWLWs4OTkZxYsXjzcN7P3Tn8c5ePCg0aJFCyNHjhyGk5OTUaBAAaNVq1bGhg0bDMO4O7XuvdOrG4ZhnDlzxvD09DQaNWpkU8/7p9b97rvvjJIlSxpZs2ZNcErcvXv3GpKMevXqPfBvFefrr782WrdubRQqVMhwcXExnJ2djZIlSxrvvPOOdRrbOHfu3DE+/PBDo3jx4oajo6Ph6+trNGzY0DqdtGEYRnR0tDFq1CijYMGCRrZs2YyAgABj6NChNtMpG0bSU11fv37dGDp0qFG4cGHD0dHRyJkzp1G1alVj4sSJxu3btw3DMIylS5ca9erVM/z8/AxHR0cjf/78Ro8ePYwLFy48cJ8T2/bFixeNzp07Gzlz5jQcHR2NMmXKxPsb2ztldrNmzQw3N7d409vGadKkieHu7m6dvjxuquKEFgcHB8Mwkjc9sWGkbPrzpCQ2/Xli9S1UqJBhGMk/h1Nr+vN7pw1O7G/w77//Gl5eXsn+X8Y9NiGx5X6//vqrUa9ePcPV1dXw9vY22rVrZ4SFhT1wO4lNfx4dHW1MmzbNKF++vOHu7m64u7sbtWvXtnmkQGLuPWY/+ugjIyAgwHBycjJq1KhhHD58OF7+U6dOGR06dDD8/f2NbNmyGXnz5jWaNGliLF26NMEy7/fzzz8b9evXN9zd3Q1XV1ejdu3a8aZpf9AxsWnTJqN+/fqGl5eX4ezsbBQqVMjo1KmTsX///iT39datW8abb75p5M6d23BxcTGqVatm7Nq1K971NLFzKG6/7j/vP/30U6NgwYKGk5OTUalSJWPr1q0JXqMTsnLlSqNs2bKGs7OzERgYaEyYMMGYPXu2zbTVhpH4/z6p6/6DPnMMI3mPVLhX3N8mbsmWLZvh6+tr1KxZ0xgzZozNYx9u375t5MiRw6hRo0aSZRYsWND6CJHkXr/uZe/053GS+3+7ffu2MWHCBKNUqVKGk5OTkT17dqNixYrGqFGjjPDwcGu+33//3ahZs6bh4uIS71rzoOM+bnrvPXv22Gx7//79RtasWY2ePXta01I6/XmclStXGlWrVjVcXFwMT09P45lnnjG+/vpr6/qjR48aISEhhru7u5EzZ06jW7duxuHDh+MdX3fu3DFef/11w9fX17BYLDbXOt03/Xly/gb31vn+cz+x71VIPothMMIMaSswMFClS5fW6tWr07oqKXL48GGVL19eX375ZZJdvAAAAJB5MEYKeEhffPGF3N3d1aJFi7SuCgAAAB4TxkgBKbRq1SodPXpUn3/+ufr06fPQ/awBAACQcRBIASn0+uuv6+LFi2rUqJFdA+gBAACQ8TFGCgAAAADsxBgpAAAAALATgRQAAAAA2IkxUpJiY2N1/vx5eXh4yGKxpHV1AAAAAKQRwzB0/fp15cmTR1myJN7uRCAl6fz58woICEjragAAAABIJ86ePat8+fIlup5ASpKHh4ck84/l6emZxrUBAAAAkFYiIiIUEBBgjRESQyAlWbvzeXp6EkgBAAAAeOCQHyabAAAAAAA7EUgBAAAAgJ0IpAAAyChmzJDKlpU8Pc0lKEhas+bu+lu3pN69pRw5JHd3qWVL6eJF2zL27ZPq1pW8vaXs2aX69aXDh5Pe7uefS8HB5jYtFunatcTzRkVJ5cub+Q4dStFuAkBGwBgpAAAyinz5pPHjpSJFJMOQ5s2TmjWTDh6USpWS+veXvv9eWrJE8vKS+vSRWrSQduww3x8ZKTVoID3/vPTpp9KdO9KIEWYwdfaslC1bwtu9edN8X4MG0tChSdfxrbekPHkeHJwhwzIMQ3fu3FFMTExaVwVIEQcHB2XNmvWhH3tkMQzDSKU6ZVgRERHy8vJSeHg4k00AADIWHx/pww+lF1+UfH2lhQvN3yXp99+lEiWkXbukZ5+V9u+XKleWzpyR4h77ceSI2cp18qRUuHDS29q8WapdW/r3X7NF635r1kgDBkjLlpmB3cGDZusUMo3bt2/rwoULunnzZlpXBXgorq6uyp07txwdHeOtS25sQIsUAAAZUUyM2fJ044bZxe/AASk6WgoJuZuneHEpf/67gVSxYma3v1mzpLffNsuYNcsMtgIDH64+Fy9K3bpJK1ZIrq4PVxbSpdjYWIWGhsrBwUF58uSRo6PjQ9/RBx43wzB0+/Zt/fPPPwoNDVWRIkWSfOhuUgikAADISI4cMQOnW7fMcVDLl0slS5rjkRwd47cU5colhYWZv3t4mK1KzZtLo0ebaUWKSD/+KGV9iK8EhiF16iS99ppUqZJ0+nTKy0K6dfv2bcXGxiogIECuBMvIwFxcXJQtWzb99ddfun37tpydnVNUDpNNAACQkRQrZgZNe/ZIPXtKHTtKR48m773//Sd17SpVqybt3m2OnSpdWmrc2FyXUtOmSdevP3j8FDKFlN69B9KT1DiOaZECACAjcXS8O5apYkVzFr6PP5Zeflm6fducUe/eVqmLFyV/f/P3hQvN1qJdu6S4LxELF5qz9333ndS6dcrqtHGjWaaTk216pUpSu3bmpBgAkMlwSwEAgIwsNtaccrxiRXPWvQ0b7q47ftycWCIoyHx986YZQN07riXudWxsyuswdao5S9+hQ+byww9m+jffSGPGpLxcAEjHCKQAAMgohg6Vtm41W5WOHDFfb95stvp4eZnd9gYMkDZtMief6NzZDKKefdZ8/3PPmTPu9e4tHTsm/fabmSdrVnM2Pkn6+29zkoq9e+9uNyzMDJD++MN8feSI+frqVfN1/vxmF8G4pWhRM71QIXPKdgAPZfPmzbJYLLqW1DPc7hMYGKgpU6Y8sjqBQAoAgIzj0iWpQwdznFTduma3vh9/NAMkSZo8WWrSxHwQb82aZpe+b7+9+/7ixaVVq6RffjEDrBo1pPPnpbVrpdy5zTzR0WZL1r3TW8+cKVWoYM7KJ5llV6ggrVz5ePYbSOc6deoki8Wi1157Ld663r17y2KxqFOnTo+/YnikGCMFAEBGMWtW0uudnaXp080lMc89dzfwSkhgoDkL371GjjSX5EqoDCCTCwgI0KJFizR58mS5uLhIkm7duqWFCxcqf/78aVw7PAq0SAEAAAAP6emnn1ZAQIC+vacV+Ntvv1X+/PlVoUIFa1pUVJT69u0rPz8/OTs7q3r16tq3b59NWT/88IOKFi0qFxcX1a5dW6cTeKTA9u3bVaNGDbm4uCggIEB9+/bVjRs3Htn+IT4CKQAAACAVdOnSRXPmzLG+nj17tjp37myT56233tKyZcs0b948/fzzzypcuLDq16+vq/8/5vDs2bNq0aKFmjZtqkOHDunVV1/VkCFDbMo4deqUGjRooJYtW+qXX37RN998o+3bt6tPnz6PfidhRSAFAAAApIJXXnlF27dv119//aW//vpLO3bs0CuvvGJdf+PGDc2YMUMffvihGjZsqJIlS+qLL76Qi4uLZv1/190ZM2aoUKFC+uijj1SsWDG1a9cu3viqcePGqV27durXr5+KFCmiqlWraurUqfryyy9169atx7nLTzTGSAEAAACpwNfXV40bN9bcuXNlGIYaN26snDlzWtefOnVK0dHRqlatmjUtW7ZseuaZZ3Ts2DFJ0rFjx1SlShWbcoPiHmHw/w4fPqxffvlFCxYssKYZhqHY2FiFhoaqRIkSj2L3cB8CKQAAACCVdOnSxdrFbnpSE788hMjISPXo0UN9+/aNt46JLR4fAikAAAAglTRo0EC3b9+WxWJR/fr1bdYVKlRIjo6O2rFjhwoUKCBJio6O1r59+9SvXz9JUokSJbTyvkcL7N692+b1008/raNHj6pw4cKPbkfwQARSAAA8IjV6jE7rKmQ42z4bltZVAB6Kg4ODtZueg4ODzTo3Nzf17NlTgwYNko+Pj/Lnz68PPvhAN2/eVNeuXSVJr732mj766CMNGjRIr776qg4cOKC5c+falDN48GA9++yz6tOnj1599VW5ubnp6NGjWrdunT755JPHsp9gsgkAAAAgVXl6esrT0zPBdePHj1fLli3Vvn17Pf300/rjjz/0448/Knv27JLMrnnLli3TihUrVK5cOc2cOVNjx461KaNs2bLasmWLTpw4oRo1aqhChQoaPny48uTJ88j3DXdZDIMn5kVERMjLy0vh4eGJHvQAANiLFin70SKVft26dUuhoaEqWLCgnJ2d07o6wENJ6nhObmxAixQAAAAA2IlACgAAAADsRCAFAAAAAHYikAIAAAAAO6VpIDVjxgyVLVvWOrNJUFCQ1qxZY11/69Yt9e7dWzly5JC7u7tatmypixcv2pRx5swZNW7cWK6urvLz89OgQYN0586dx70rAAAAAJ4gaRpI5cuXT+PHj9eBAwe0f/9+1alTR82aNdNvv/0mSerfv79WrVqlJUuWaMuWLTp//rxatGhhfX9MTIwaN26s27dva+fOnZo3b57mzp2r4cOHp9UuAQAAAHgCpOkDeZs2bWrzesyYMZoxY4Z2796tfPnyadasWVq4cKHq1KkjSZozZ45KlCih3bt369lnn9VPP/2ko0ePav369cqVK5fKly+v0aNHa/DgwRo5cqQcHR3TYrcAAAAAZHLpZoxUTEyMFi1apBs3bigoKEgHDhxQdHS0QkJCrHmKFy+u/Pnza9euXZKkXbt2qUyZMsqVK5c1T/369RUREWFt1UpIVFSUIiIibBYAAAAASK40D6SOHDkid3d3OTk56bXXXtPy5ctVsmRJhYWFydHRUd7e3jb5c+XKpbCwMElSWFiYTRAVtz5uXWLGjRsnLy8v6xIQEJC6OwUAAAAgU0vTrn2SVKxYMR06dEjh4eFaunSpOnbsqC1btjzSbQ4dOlQDBgywvo6IiCCYAgAASIEaPUY/1u1t+2zYY90ekJg0b5FydHRU4cKFVbFiRY0bN07lypXTxx9/LH9/f92+fVvXrl2zyX/x4kX5+/tLkvz9/ePN4hf3Oi5PQpycnKwzBcYtAAAAyHxiYmJUtWpVmwnLJCk8PFwBAQF65513dPr0aVksFh06dCjBMubOnSuLxaISJUrEW7dkyRJZLBYFBgYmWY+RI0fKYrGoQYMG8dZ9+OGHslgsCg4Otslfvnz5RMsLDg6WxWLR+PHj461r3LixLBaLRo4cmWSdAgMDZbFY4i1xZcb9Xfz8/HT9+nWb95YvXz7J8q9evarXX39dxYoVk4uLi/Lnz6++ffsqPDzcJp89M3Dv2LFDWbNmjfd3iYmJ0bBhw1SwYEG5uLioUKFCGj16tAzDSHL/H1aaB1L3i42NVVRUlCpWrKhs2bJpw4YN1nXHjx/XmTNnFBQUJEkKCgrSkSNHdOnSJWuedevWydPTUyVLlnzsdQcAAED64uDgoLlz52rt2rVasGCBNf3111+Xj4+PRowYkaxy3NzcdOnSJetY/TizZs1S/vz5k1VG7ty5tWnTJp07d84mffbs2cku414BAQGaO3euTdrff/+tDRs2KHfu3Mkq47333tOFCxdsltdff90mz/Xr1zVx4kS76nb+/HmdP39eEydO1K+//mr9H3Tt2tWax54ZuK9du6YOHTqobt268dZNmDBBM2bM0CeffKJjx45pwoQJ+uCDDzRt2jS76myvNA2khg4dqq1bt+r06dM6cuSIhg4dqs2bN6tdu3by8vJS165dNWDAAG3atEkHDhxQ586dFRQUpGeffVaSVK9ePZUsWVLt27fX4cOH9eOPP+rdd99V79695eTklJa7BgAAgHSiaNGiGj9+vF5//XVduHBB3333nRYtWqQvv/wy2bM8Z82aVW3bttXs2bOtaefOndPmzZvVtm3bZJXh5+enevXqad68eda0nTt36vLly2rcuLF9OyWpSZMmunz5snbs2GFNmzdvnurVqyc/P79kleHh4SF/f3+bxc3NzSbP66+/rkmTJtk0XjxI6dKltWzZMjVt2lSFChVSnTp1NGbMGK1atcra4hQ3A/dXX32l8uXLq2HDhho9erSmT5+u27dv25T32muvqW3bttYGlXvt3LlTzZo1U+PGjRUYGKgXX3xR9erV0969e5Nd35RI00Dq0qVL6tChg4oVK6a6detq3759+vHHH/Xcc89JkiZPnqwmTZqoZcuWqlmzpvz9/fXtt99a3+/g4KDVq1fLwcFBQUFBeuWVV9ShQwe99957abVLAAAASIdef/11lStXTu3bt1f37t01fPhwlStXzq4yunTposWLF+vmzZuSzC5/DRo0iDf52YPKuLcVafbs2WrXrl2KHtvj6Oiodu3aac6cOda0uXPnqkuXLnaXlZQ2bdqocOHCD/0dOzw8XJ6ensqa1ZymIbkzcM+ZM0d//vlnoq2HVatW1YYNG3TixAlJ0uHDh7V9+3Y1bNjwoer7IGkaSM2aNUunT59WVFSULl26pPXr11uDKElydnbW9OnTdfXqVd24cUPffvttvLFPBQoU0A8//KCbN2/qn3/+0cSJE63/HAAAAECSLBaLZsyYoQ0bNihXrlwaMmSI3WVUqFBBTz31lJYuXSrDMFIUtDRp0kQRERHaunWrbty4ocWLFz9U4BMX3N24cUNbt25VeHi4mjRpkuz3Dx48WO7u7jbLtm3bbPLEjZv6/PPPderUqRTV8/Llyxo9erS6d+9uTUvODNwnT57UkCFD9NVXXyX6HX/IkCFq3bq1ihcvrmzZsqlChQrq16+f2rVrl6K6Jle6GyMFAAAAPAqzZ8+Wq6urQkND441TSq4uXbpozpw52rJli27cuKFGjRrZrD9z5oxNUDJ27Fib9dmyZdMrr7yiOXPmaMmSJSpatKjKli2b4n0qV66cihQpoqVLl2r27Nlq3759vIBj7NixNnU6c+aMdd2gQYN06NAhm6VSpUrxtlO/fn1Vr15dw4bFnzUxqfIlc4bsxo0bq2TJkg+cAONeMTExatu2rUaNGqWiRYsmmm/x4sVasGCBFi5cqJ9//lnz5s3TxIkTbbpQPgo03QAAACDT27lzpyZPnqyffvpJ77//vrp27ar169fLYrHYVU67du301ltvaeTIkQkGLXny5LGZ/c/HxydeGV26dFGVKlX066+/pko3vC5dumj69Ok6evRoguOCXnvtNbVq1cqmjnFy5sypwoULJ2s748ePV1BQkAYNGpTs8q9fv64GDRrIw8NDy5cvV7Zs2azr/P3949X33hm4r1+/rv379+vgwYPq06ePJHNiOsMwlDVrVv3000+qU6eOBg0aZG2VkqQyZcror7/+0rhx49SxY8dk7VtKEEgBAAAgU7t586Y6deqknj17qnbt2ipYsKDKlCmjmTNnqmfPnnaV5ePjo+eff16LFy/WzJkz463PmjXrAwOTUqVKqVSpUvrll1+SPVFFUtq2bauBAweqXLlyCc5c7ePjk2BAZ69nnnlGLVq0iNctMrHyIyIiVL9+fTk5OWnlypVydna2WR8UFKQxY8bo0qVL1skx7p2BO1u2bDpy5IjNez799FNt3LhRS5cuVcGCBSWZ/98sWWw72jk4OCg2Nvah9zkpBFIAAADI1IYOHSrDMKzPRwoMDNTEiRM1cOBAmwkJjh8/Hu+9pUqVipc2d+5cffrpp8qRI0eK67Rx40ZFR0fL29s70Tz//fdfvGdbeXh4qFChQjZp2bNn14ULF2xae5Lr+vXr1vFIcVxdXRN9zuqYMWNUqlSpB85JEBERoXr16unmzZv66quvFBERoYiICEmSr6+vHBwcbGbg/uCDDxQWFhZvBu7SpUvblOvn5ydnZ2eb9KZNm2rMmDHKnz+/SpUqpYMHD2rSpEmpPunG/QikAAAAkGLbPos/ZiY92bJli6ZPn67NmzfL1dXVmt6jRw99++236tq1q/73v/9JkrVr2L3Onj0bL83FxUUuLi4PVa/7pxhPyIkTJ1ShQgWbtLp162r9+vXx8iYVkCVl+PDh8Z7b1KNHjwRb2yRzKvkuXbro888/T7Lcn3/+WXv27JGkeC10oaGhCgwMtM7A3bNnTwUFBcnNzU0dO3a0e3bAadOmadiwYerVq5cuXbqkPHnyqEePHgk+jyo1WYxH/cjfDCAiIkJeXl7WKRkBAEgNNXqMTusqZDjp/Uv5k+zWrVsKDQ1VwYIF43XRAjKapI7n5MYGzNoHAAAAAHYikAIAAAAAOxFIAQAAAICdCKQAAAAAwE4EUgAAAABgJwIpAAAAALATgRQAAAAA2IlACgAAAADsRCAFAAAAAHbKmtYVAAAAQMZVb9HQx7q9n1qPe6zbexKcPn1aBQsW1MGDB1W+fPm0rk6GQYsUAAAAMrVOnTrJYrHYvWzevDleWcHBwbJYLFq0aJFN+pQpUxQYGPjI9iEwMDDJunbq1CnFZQcEBOjChQsqXbp06lX4CUCLFAAAADK9Bg0aaM6cOdbXt2/floODgxwcHCRJb7zxhiIiImzy+Pj4JFiWs7Oz3n33XbVs2VLZsmV7tBX/f/v27VNMTIwkaefOnWrZsqWOHz8uT09PSZKLi0uKy3ZwcJC/v3+q1PNJQosUAAAAMj0nJyf5+/tbl/z58ytv3rzW1y4uLvHyODo6JlhWmzZtdO3aNX3xxRdJbnPGjBkqVKiQHB0dVaxYMc2fP99mvcVi0f/+9z+98MILcnV1VZEiRbRy5coEy/L19bXWKy7A8/Pzs6YtXLgw0W116dJFZcuWVVRUlCQziKxQoYI6dOggyezaZ7FYdOjQIet7fvvtNzVp0kSenp7y8PBQjRo1dOrUqaT/yE8YAikAAADADp6ennrnnXf03nvv6caNGwnmWb58ud544w29+eab+vXXX9WjRw917txZmzZtssk3atQotWrVSr/88osaNWqkdu3a6erVq3bV50Hbmjp1qm7cuKEhQ4ZIkt555x1du3ZNn3zySYLl/f3336pZs6acnJy0ceNGHThwQF26dNGdO3fsqldmRyAFAACATG/16tVyd3e3Li+99NJDlderVy85Oztr0qRJCa6fOHGiOnXqpF69eqlo0aIaMGCAWrRooYkTJ9rk69Spk9q0aaPChQtr7NixioyM1N69e+2qy4O25e7urq+++krTp0/X8OHDNWXKFM2fP9/aLfB+06dPl5eXlxYtWqRKlSqpaNGi6ty5s4oVK2ZXvTI7AikAAABkerVr19ahQ4esy9SpU5PMv2DBApvAa9u2bTbrnZyc9N5772nixIm6fPlyvPcfO3ZM1apVs0mrVq2ajh07ZpNWtmxZ6+9ubm7y9PTUpUuXJEmlSpWybr9hw4aJ1jU52woKCtLAgQM1evRovfnmm6pevXqi5R06dEg1atR4bOO/MiommwAAAECm5+bmpsKFCyc7//PPP68qVapYX+fNmzdenldeeUUTJ07U+++/n+IZ++4PViwWi2JjYyVJP/zwg6KjoyU93GQSkhQbG6sdO3bIwcFBf/zxR5J5H3ZbTwpapAAAAID7eHh4qHDhwtYloeAiS5YsGjdunGbMmKHTp0/brCtRooR27Nhhk7Zjxw6VLFky2XUoUKCAdfsJBXL2bOvDDz/U77//ri1btmjt2rU2sxPer2zZstq2bZs1iEPCaJECAAAAUqhx48aqUqWKPvvsM+XKlcuaPmjQILVq1UoVKlRQSEiIVq1apW+//Vbr169P9To8aFsHDx7U8OHDtXTpUlWrVk2TJk3SG2+8oVq1aumpp56KV16fPn00bdo0tW7dWkOHDpWXl5d2796tZ555hnFS9yCQAgAAQIr91HpcWlchzU2YMEFVq1a1SWvevLk+/vhjTZw4UW+88YYKFiyoOXPmKDg4ONW3n9S2bt26pVdeeUWdOnVS06ZNJUndu3fX999/r/bt22vr1q3xysuRI4c2btyoQYMGqVatWnJwcFD58uXjjcN60lkMwzDSuhJpLSIiQl5eXgoPD0909hIAAOxVo8fotK5ChrPts2FpXQUk4tatWwoNDVXBggXl7Oyc1tUBHkpSx3NyYwPGSAEAAACAnQikAAAAAMBOBFIAAAAAYCcCKQAAAACwE4EUAAAAko15ypAZpMZxTCAFAACAB8qWLZsk6ebNm2lcE+DhxR3Hccd1SvAcKQAAADyQg4ODvL29denSJUmSq6urLBZLGtcKsI9hGLp586YuXbokb29vOTg4pLgsAikAAAAki7+/vyRZgykgo/L29rYezylFIAUAAIBksVgsyp07t/z8/BQdHZ3W1QFSJFu2bA/VEhWHQAoAAAB2cXBwSJUvokBGxmQTAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATmkaSI0bN06VK1eWh4eH/Pz81Lx5cx0/ftwmT3BwsCwWi83y2muv2eQ5c+aMGjduLFdXV/n5+WnQoEG6c+fO49wVAAAAAE+QrGm58S1btqh3796qXLmy7ty5o7ffflv16tXT0aNH5ebmZs3XrVs3vffee9bXrq6u1t9jYmLUuHFj+fv7a+fOnbpw4YI6dOigbNmyaezYsY91fwAAAAA8GdI0kFq7dq3N67lz58rPz08HDhxQzZo1remurq7y9/dPsIyffvpJR48e1fr165UrVy6VL19eo0eP1uDBgzVy5Eg5Ojo+0n0AAAAA8ORJV2OkwsPDJUk+Pj426QsWLFDOnDlVunRpDR06VDdv3rSu27Vrl8qUKaNcuXJZ0+rXr6+IiAj99ttvCW4nKipKERERNgsAAAAAJFeatkjdKzY2Vv369VO1atVUunRpa3rbtm1VoEAB5cmTR7/88osGDx6s48eP69tvv5UkhYWF2QRRkqyvw8LCEtzWuHHjNGrUqEe0JwAAAAAyu3QTSPXu3Vu//vqrtm/fbpPevXt36+9lypRR7ty5VbduXZ06dUqFChVK0baGDh2qAQMGWF9HREQoICAgZRUHAAAA8MRJF137+vTpo9WrV2vTpk3Kly9fknmrVKkiSfrjjz8kSf7+/rp48aJNnrjXiY2rcnJykqenp80CAAAAAMmVpoGUYRjq06ePli9fro0bN6pgwYIPfM+hQ4ckSblz55YkBQUF6ciRI7p06ZI1z7p16+Tp6amSJUs+knoDAAAAeLKlade+3r17a+HChfruu+/k4eFhHdPk5eUlFxcXnTp1SgsXLlSjRo2UI0cO/fLLL+rfv79q1qypsmXLSpLq1aunkiVLqn379vrggw8UFhamd999V71795aTk1Na7h4AAACATCpNW6RmzJih8PBwBQcHK3fu3Nblm2++kSQ5Ojpq/fr1qlevnooXL64333xTLVu21KpVq6xlODg4aPXq1XJwcFBQUJBeeeUVdejQwea5UwAAAACQmtK0RcowjCTXBwQEaMuWLQ8sp0CBAvrhhx9Sq1oAAAAAkKR0MdkEAAAAAGQkBFIAAAAAYCcCKQAAAACwE4EUAAAAANiJQAoAAAAA7EQgBQAAAAB2IpACAAAAADsRSAEAAACAnQikAAAAAMBOBFIAAAAAYCcCKQAAAACwE4EUAAAAANiJQAoAAAAA7EQgBQAAAAB2IpACAAAAADsRSAEAAACAnQikAAAAAMBOBFIAAAAAYCcCKQAAAACwE4EUAAAAANiJQAoAAAAA7EQgBQAAAAB2IpACAAAAADsRSAEAAACAnQikAAAAAMBOBFIAAAAAYCcCKQAAAACwE4EUAAAAANiJQAoAAAAA7EQgBQAAAAB2IpACAAAAADsRSAEAAACAnQikAAAAAMBOBFIAAAAAYCcCKQAAAACwE4EUAAAAANiJQAoAAAAA7EQgBQAAAAB2IpACAAAAADsRSAEAAACAnQikAAAAAMBOBFIAAAAAYCcCKQAAAACwE4EUAAAAANiJQAoAAAAA7EQgBQAAAAB2IpACAAAAADsRSAEAAACAnQikAAAAAMBOBFIAAAAAYCcCKQAAAACwE4EUAAAAANiJQAoAAAAA7EQglVFs3So1bSrlySNZLNKKFbbrL16UOnUy17u6Sg0aSCdPxi9n1y6pTh3JzU3y9JRq1pT++y/x7Y4caW7v3qV4cds8PXpIhQpJLi6Sr6/UrJn0++8PucMAAABA+kUglVHcuCGVKydNnx5/nWFIzZtLf/4pffeddPCgVKCAFBJivi/Orl1mgFWvnrR3r7Rvn9Snj5TlAYdBqVLShQt3l+3bbddXrCjNmSMdOyb9+KNZn3r1pJiYh95tAAAAID3KmtYVQDI1bGguCTl5Utq9W/r1VzPokaQZMyR/f+nrr6VXXzXT+veX+vaVhgy5+95ixR687axZzbIS07373d8DA6X33zeDvtOnzZYqAAAAIJOhRSoziIoyfzo7303LkkVycrrbenTpkrRnj+TnJ1WtKuXKJdWqFb91KSEnT5pdBp96SmrXTjpzJvG8N26YrVMFC0oBASnfJwAAACAdI5DKDIoXl/Lnl4YOlf79V7p9W5owQTp3zuyKJ5nd/iRzzFO3btLatdLTT0t16yY8lipOlSrS3Llm/hkzpNBQqUYN6fp123yffiq5u5vLmjXSunWSo+Oj2FsAAAAgzRFIZQbZsknffiudOCH5+JiTTWzaZHYFjBv/FBtr/uzRQ+rcWapQQZo82ezaN3t24mU3bCi99JJUtqxUv770ww/StWvS4sW2+dq1M8dmbdkiFS0qtWol3br1SHYXAAAASGuMkcosKlaUDh2SwsPNFilfX7M1qVIlc33u3ObPkiVt31eiRNJd9e7n7W0GSn/8YZvu5WUuRYpIzz4rZc8uLV8utWmT0j0CAAAA0q00bZEaN26cKleuLA8PD/n5+al58+Y6fvy4TZ5bt26pd+/eypEjh9zd3dWyZUtdvHjRJs+ZM2fUuHFjubq6ys/PT4MGDdKdO3ce566kH15eZhB18qS0f785FblkTgKRJ490399XJ06YM/wlV2SkdOrU3cAsIYZhLnFjtwAAAIBMJk0DqS1btqh3797avXu31q1bp+joaNWrV0837pmyu3///lq1apWWLFmiLVu26Pz582rRooV1fUxMjBo3bqzbt29r586dmjdvnubOnavhw4enxS49OpGRZovToUPm69BQ8/e41qQlS6TNm+9Ogf7cc+aU6PXqmestFmnQIGnqVGnpUrNFadgw83lPXbve3U7dutInn9x9PXCg2V3v9Glp507phRckB4e7LU1//imNGycdOGDWZedOsyugi4vUqNGj/IsAAAAAaSZNu/atXbvW5vXcuXPl5+enAwcOqGbNmgoPD9esWbO0cOFC1alTR5I0Z84clShRQrt379azzz6rn376SUePHtX69euVK1culS9fXqNHj9bgwYM1cuRIOWaWCQ/275dq1777esAA82fHjuZkEBcumGkXL5qtRR06mIHSvfr1M8ct9e8vXb1qTlG+bp3tFOWnTkmXL999fe6cGTRduWK2dFWvbk617utrrnd2lrZtk6ZMMSe6yJXLfMjvzp3mDIEAAABAJpSuxkiFh4dLknx8fCRJBw4cUHR0tEJCQqx5ihcvrvz582vXrl169tlntWvXLpUpU0a5cuWy5qlfv7569uyp3377TRUqVIi3naioKEXd0+0sIiLiUe1S6gkONrvLJaZvX3N5kCFDbJ8jdb/Tp21fL1qUdHl58pgTUAAAAABPkHQza19sbKz69eunatWqqXTp0pKksLAwOTo6ytvb2yZvrly5FBYWZs1zbxAVtz5uXULGjRsnLy8v6xLA844AAAAA2CHdBFK9e/fWr7/+qkUPagFJBUOHDlV4eLh1OXv27CPfJgAAAIDMI1107evTp49Wr16trVu3Kl++fNZ0f39/3b59W9euXbNplbp48aL8/f2tefbu3WtTXtysfnF57ufk5CQnJ6dU3gsAAAAAT4o0bZEyDEN9+vTR8uXLtXHjRhUsWNBmfcWKFZUtWzZt2LDBmnb8+HGdOXNGQUFBkqSgoCAdOXJEly5dsuZZt26dPD09VfL+ZyYBAAAAQCpI0xap3r17a+HChfruu+/k4eFhHdPk5eUlFxcXeXl5qWvXrhowYIB8fHzk6emp119/XUFBQXr22WclSfXq1VPJkiXVvn17ffDBBwoLC9O7776r3r170+oEAAAA4JFI00BqxowZkqTg4GCb9Dlz5qhTp06SpMmTJytLlixq2bKloqKiVL9+fX366afWvA4ODlq9erV69uypoKAgubm5qWPHjnrvvfce127EU6PH6DTbdka27bNhD84EAAAApANpGkgZSU3n/f+cnZ01ffp0TZ8+PdE8BQoU0A9MwQ0AAADgMUk3s/YBAAAAQEZBIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOyUokBqzpw5unnzZmrXBQAAAAAyhBQFUkOGDJG/v7+6du2qnTt3pnadAAAAACBdS1Eg9ffff2vevHm6fPmygoODVbx4cU2YMEFhYWGpXT8AAAAASHdSFEhlzZpVL7zwgr777judPXtW3bp104IFC5Q/f349//zz+u677xQbG5vadQUAAACAdOGhJ5vIlSuXqlevrqCgIGXJkkVHjhxRx44dVahQIW3evDkVqggAAAAA6UuKA6mLFy9q4sSJKlWqlIKDgxUREaHVq1crNDRUf//9t1q1aqWOHTumZl0BAAAAIF1IUSDVtGlTBQQEaO7cuerWrZv+/vtvff311woJCZEkubm56c0339TZs2dTtbIAAAAAkB5kTcmb/Pz8tGXLFgUFBSWax9fXV6GhoSmuGAAAAACkVylqkapVq5aefvrpeOm3b9/Wl19+KUmyWCwqUKDAw9UOAAAAANKhFAVSnTt3Vnh4eLz069evq3Pnzg9dKQAAAABIz1IUSBmGIYvFEi/93Llz8vLyeuhKAQAAAEB6ZtcYqQoVKshischisahu3brKmvXu22NiYhQaGqoGDRqkeiUBAAAAID2xK5Bq3ry5JOnQoUOqX7++3N3drescHR0VGBioli1bpmoFAQAAACC9sSuQGjFihCQpMDBQL7/8spydnR9JpQAAAAAgPUvR9Oc8aBcAAADAkyzZgZSPj49OnDihnDlzKnv27AlONhHn6tWrqVI5AAAAAEiPkh1ITZ48WR4eHtbfkwqkAAAAACAzS3YgdW93vk6dOj2KugAAAABAhpCi50jNnTs3wfQ7d+5o6NChD1MfAAAAAEj3UhRI9e3bVy+99JL+/fdfa9rx48dVpUoVff3116lWOQAAAABIj1IUSB08eFDnzp1TmTJltG7dOk2fPl1PP/20ihcvrsOHD6d2HQEAAAAgXUnR9OeFChXSjh071K9fPzVo0EAODg6aN2+e2rRpk9r1AwAAAIB0J0UtUpL0/fffa9GiRQoKCpK3t7dmzZql8+fPp2bdAAAAACBdSlEg1aNHD7300ksaPHiwtm3bpl9++UWOjo4qU6aMFi9enNp1BAAAAIB0JUVd+3bs2KE9e/aoXLlykiR/f3/98MMPmj59urp06aJWrVqlaiUBAAAAID1JUSB14MABOTk5xUvv3bu3QkJCHrpSAAAAAJCepahrn5OTk06dOqV3331Xbdq00aVLlyRJa9as0Z07d1K1ggAAAACQ3qQokNqyZYvKlCmjPXv26Ntvv1VkZKQk6fDhwxoxYkSqVhAAAAAA0psUBVJDhgzR+++/r3Xr1snR0dGaXqdOHe3evTvVKgcAAAAA6VGKAqkjR47ohRdeiJfu5+eny5cvP3SlAAAAACA9S1Eg5e3trQsXLsRLP3jwoPLmzfvQlQIAAACA9CxFgVTr1q01ePBghYWFyWKxKDY2Vjt27NDAgQPVoUOH1K4jAAAAAKQrKQqkxo4dq+LFiysgIECRkZEqWbKkatasqapVq+rdd99N7ToCAAAAQLqSoudIOTo66osvvtCwYcP066+/KjIyUhUqVFCRIkVSu34AAAAAkO6kKJCKkz9/fuXPnz+16gIAAAAAGUKyA6kBAwYku9BJkyalqDIAAAAAkBEkO5A6ePBgsvJZLJYUVwYAAAAAMoJkB1KbNm16lPUAAAAAgAwjRbP23evs2bM6e/ZsatQFAAAAADKEFAVSd+7c0bBhw+Tl5aXAwEAFBgbKy8tL7777rqKjo1O7jgAAAACQrqRo1r7XX39d3377rT744AMFBQVJknbt2qWRI0fqypUrmjFjRqpWEgAAAADSkxQFUgsXLtSiRYvUsGFDa1rZsmUVEBCgNm3aEEgBAAAAyNRS1LXPyclJgYGB8dILFiwoR0fHh60TAAAAAKRrKQqk+vTpo9GjRysqKsqaFhUVpTFjxqhPnz6pVjkAAAAASI9SFEgdPHhQq1evVr58+RQSEqKQkBDly5dPq1at0uHDh9WiRQvrkpStW7eqadOmypMnjywWi1asWGGzvlOnTrJYLDZLgwYNbPJcvXpV7dq1k6enp7y9vdW1a1dFRkamZLcAAAAAIFlSNEbK29tbLVu2tEkLCAiwu5wbN26oXLly6tKlS6JBV4MGDTRnzhzraycnJ5v17dq104ULF7Ru3TpFR0erc+fO6t69uxYuXGh3fQAAAAAgOewOpAzD0KhRo+Tr6ysXF5eH2njDhg1tJqxIiJOTk/z9/RNcd+zYMa1du1b79u1TpUqVJEnTpk1To0aNNHHiROXJkyfB90VFRdl0S4yIiEjhHgAAAAB4Etndtc8wDBUuXFjnzp17FPWJZ/PmzfLz81OxYsXUs2dPXblyxbpu165d8vb2tgZRkhQSEqIsWbJoz549iZY5btw4eXl5WZeUtKYBAAAAeHLZHUhlyZJFRYoUsQloHpUGDRroyy+/1IYNGzRhwgRt2bJFDRs2VExMjCQpLCxMfn5+Nu/JmjWrfHx8FBYWlmi5Q4cOVXh4uHU5e/bsI90PAAAAAJlLisZIjR8/XoMGDdKMGTNUunTp1K6TVevWra2/lylTRmXLllWhQoW0efNm1a1bN8XlOjk5xRtrBQAAAADJlaJAqkOHDrp586bKlSsnR0fHeGOlrl69miqVu99TTz2lnDlz6o8//lDdunXl7++vS5cu2eS5c+eOrl69mui4KgAAAAB4WCkKpKZMmZLK1Uiec+fO6cqVK8qdO7ckKSgoSNeuXdOBAwdUsWJFSdLGjRsVGxurKlWqpEkdAQAAAGR+KQqkOnbsmCobj4yM1B9//GF9HRoaqkOHDsnHx0c+Pj4aNWqUWrZsKX9/f506dUpvvfWWChcurPr160uSSpQooQYNGqhbt26aOXOmoqOj1adPH7Vu3TrRGfsAAAAA4GGl6IG8knTq1Cm9++67atOmjbV73Zo1a/Tbb78lu4z9+/erQoUKqlChgiRpwIABqlChgoYPHy4HBwf98ssvev7551W0aFF17dpVFStW1LZt22zGNy1YsEDFixdX3bp11ahRI1WvXl2ff/55SncLAAAAAB4oRS1ScbPnVatWTVu3btWYMWPk5+enw4cPa9asWVq6dGmyygkODpZhGImu//HHHx9Yho+PDw/fBQAAAPBYpahFasiQIXr//fe1bt06OTo6WtPr1Kmj3bt3p1rlAAAAACA9SlEgdeTIEb3wwgvx0v38/HT58uWHrhQAAAAApGcpCqS8vb114cKFeOkHDx5U3rx5H7pSAAAAAJCepSiQat26tQYPHqywsDBZLBbFxsZqx44dGjhwoDp06JDadQQAAACAdCVFgdTYsWNVokQJ5c+fX5GRkSpZsqRq1qypqlWr6t13303tOgIAAABAumLXrH2xsbH68MMPtXLlSt2+fVvt27dXy5YtFRkZqQoVKqhIkSKPqp4AAAAAkG7YFUiNGTNGI0eOVEhIiFxcXLRw4UIZhqHZs2c/qvoBAAAAQLpjV9e+L7/8Up9++ql+/PFHrVixQqtWrdKCBQsUGxv7qOoHAAAAAOmOXYHUmTNn1KhRI+vrkJAQWSwWnT9/PtUrBgAAAADplV2B1J07d+Ts7GyTli1bNkVHR6dqpQAAAAAgPbNrjJRhGOrUqZOcnJysabdu3dJrr70mNzc3a9q3336bejUEAAAAgHTGrkCqY8eO8dJeeeWVVKsMAAAAAGQEdgVSc+bMeVT1AAAAAIAMI0UP5AUAAACAJxmBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATmkaSG3dulVNmzZVnjx5ZLFYtGLFCpv1hmFo+PDhyp07t1xcXBQSEqKTJ0/a5Ll69aratWsnT09PeXt7q2vXroqMjHyMewEAAADgSZOmgdSNGzdUrlw5TZ8+PcH1H3zwgaZOnaqZM2dqz549cnNzU/369XXr1i1rnnbt2um3337TunXrtHr1am3dulXdu3d/XLsAAAAA4AmUNS033rBhQzVs2DDBdYZhaMqUKXr33XfVrFkzSdKXX36pXLlyacWKFWrdurWOHTumtWvXat++fapUqZIkadq0aWrUqJEmTpyoPHnyPLZ9AQAAAPDkSLdjpEJDQxUWFqaQkBBrmpeXl6pUqaJdu3ZJknbt2iVvb29rECVJISEhypIli/bs2ZNo2VFRUYqIiLBZAAAAACC50m0gFRYWJknKlSuXTXquXLms68LCwuTn52ezPmvWrPLx8bHmSci4cePk5eVlXQICAlK59gAAAAAys3QbSD1KQ4cOVXh4uHU5e/ZsWlcJAAAAQAaSbgMpf39/SdLFixdt0i9evGhd5+/vr0uXLtmsv3Pnjq5evWrNkxAnJyd5enraLAAAAACQXOk2kCpYsKD8/f21YcMGa1pERIT27NmjoKAgSVJQUJCuXbumAwcOWPNs3LhRsbGxqlKlymOvMwAAAIAnQ5rO2hcZGak//vjD+jo0NFSHDh2Sj4+P8ufPr379+un9999XkSJFVLBgQQ0bNkx58uRR8+bNJUklSpRQgwYN1K1bN82cOVPR0dHq06ePWrduzYx9AAAAAB6ZNA2k9u/fr9q1a1tfDxgwQJLUsWNHzZ07V2+99ZZu3Lih7t2769q1a6pevbrWrl0rZ2dn63sWLFigPn36qG7dusqSJYtatmypqVOnPvZ9AQAAAPDkSNNAKjg4WIZhJLreYrHovffe03vvvZdoHh8fHy1cuPBRVA8AAAAAEpRux0gBAAAAQHpFIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAABkHIGBksUSf+nd21zfo4dUqJDk4iL5+krNmkm//5788l97zSxvyhTb9KtXpXbtJE9Pydtb6tpVioxMpZ1CRkQgBQAAgIxj3z7pwoW7y7p1ZvpLL5k/K1aU5syRjh2TfvxRMgypXj0pJubBZS9fLu3eLeXJE39du3bSb7+Z21u9Wtq6VerePfX2CxlO1rSuAAAAAJBsvr62r8ePN1ugatUyX98b3AQGSu+/L5UrJ50+beZLzN9/S6+/bgZfjRvbrjt2TFq71gziKlUy06ZNkxo1kiZOTDjwQqZHixQAAAAyptu3pa++krp0Mbvj3e/GDbN1qmBBKSAg8XJiY6X27aVBg6RSpeKv37XL7M4XF0RJUkiIlCWLtGfPQ+8GMiYCKQAAAGRMK1ZI165JnTrZpn/6qeTubi5r1pjd8RwdEy9nwgQpa1apb9+E14eFSX5+tmlZs0o+PuY6PJEIpAAAAJAxzZolNWwYv2tdu3bSwYPSli1S0aJSq1bSrVsJl3HggPTxx9LcuQm3agGJIJACAABAxvPXX9L69dKrr8Zf5+UlFSki1awpLV1qztq3fHnC5WzbJl26JOXPb7YyZc1qlv3mm+YYK0ny9zfz3OvOHXMmP3//VN0tZBxMNgEAAICMZ84cs7vd/RND3M8wzCUqKuH17dub453uVb++md65s/k6KMjsQnjggDkroCRt3GiOrapS5aF2AxkXgRQAAAAylthYM5Dq2NFsQYrz55/SN9+Y0537+krnzpmz+rm4mDPsxSleXBo3TnrhBSlHDnO5V7ZsZktTsWLm6xIlpAYNpG7dpJkzpehoqU8fqXVrZux7gtG1DwAAABnL+vXSmTPmbH33cnY2u+o1aiQVLiy9/LLk4SHt3Gk7WcTx41J4uH3bXLDADMDq1jXLr15d+vzzh98XZFi0SAEAACBjqVfP7K53vzx5pB9+ePD7E3rvvU6fjp/m4yMtXJis6uHJQIsUAAAAANiJQAoAAAAA7EQgBQAAAAB2IpACAAAAADsRSAEAAACAnQikAAAAAMBOTH8OAACAR6JGj9FpXYUMadtnw9K6CkgGWqQAAAAAwE4EUgAAAABgJwIpAAAAALATgRQAAAAA2IlACgAAAADsRCAFAAAAAHYikAIAAAAAOxFIAQAAAICdCKQAAEDmNXKkZLHYLsWL310fHBx//WuvJV5edLQ0eLBUpozk5iblySN16CCdP2+b7+pVqV07ydNT8vaWunaVIiMfwQ4CSCtZ07oCAAAAj1SpUtL69XdfZ73v60+3btJ779197eqaeFk3b0o//ywNGyaVKyf9+6/0xhvS889L+/ffzdeunXThgrRunRl8de4sde8uLVyYOvsEIM0RSAEAgMwta1bJ3z/x9a6uSa+/l5eXGRzd65NPpGeekc6ckfLnl44dk9aulfbtkypVMvNMmyY1aiRNnGi2YgHI8OjaByBjeFD3nB49pEKFJBcXyddXatZM+v33B5d77Jh5J9nLy+ymU7my+WXoXrt2SXXqmOs9PaWaNaX//kvV3QPwCJ08aQYvTz1lthTdf44vWCDlzCmVLi0NHWq2OtkjPNy8Jnl7m6937TJ/jwuiJCkkRMqSRdqz52H2BEA6QosUgIwjqe45FSuaX5Dy5zfHJowcKdWrJ4WGSg4OCZd36pRUvbo5dmHUKDNI+u03ydn5bp5du6QGDcwvV9Ommds8fNj8QgQg/atSRZo7VypWzOxqN2qUVKOG9OuvkoeH1LatVKCAGWj98os5/un4cenbb5NX/q1b5nvatDGvIZIUFib5+dnmy5pV8vEx1wHIFAikAGQcSXXP6d797u+BgdL775vjF06fNluqEvLOO2ZXmw8+uJt2f97+/aW+faUhQ+6mFSuWktoDSAsNG979vWxZM7AqUEBavNi8iXLvtaNMGSl3bqluXfNGS2LXjjjR0VKrVpJhSDNmPJr6A0i3uKUKION4UPecODduSHPmSAULSgEBCeeJjZW+/14qWlSqX9+8e1ylirRixd08ly6Z3XD8/KSqVaVcuaRataTt21N91wA8Jt7e5nn/xx8Jr69SxfyZ2Po4cUHUX3+ZY6biWqMk84bPpUu2+e/cMVvLkzsWC0C6RyAFIGOI656zdq155zc01Oyec/363Tyffiq5u5vLmjXmlxtHx4TLu3TJnIp4/Hiz695PP0kvvCC1aCFt2WLm+fNP8+fIkeasXmvXSk8/bd6tPnnyUe4tgEclMtJsbcqdO+H1hw6ZPxNbL90Nok6eNLsb58hhuz4oSLp2TTpw4G7axo3mDZy4QA1AhkcgBSBjaNhQeukls2tO/frSDz+YX1QWL76bp1076eBBMxAqWtT8onPrVsLlxcaaP5s1M7vvlS9vdt9r0kSaOdM2T48e5tTFFSpIkyebXftmz35UewogNQ0caF4TTp+Wdu40b5g4OJhjmk6dkkaPNgOe06ellSvNZ0LVrGlea+IULy4tX27+Hh0tvfiiOdX5ggVSTIw57iksTLp928xTooR5g6ZbN2nvXmnHDqlPH6l1a2bsAzIRxkgByJgS6p7j5WUuRYpIzz4rZc9ufvlp0yb++3PmNMdclSxpm16ixN2ue3F3pBPKk1i3QgDpy7lz5jXgyhVzRs/q1aXdu83fb90yW5SmTDG7BAcESC1bSu++a1vG8ePmzHyS9PffZsAlmTdg7rVpk/mAX8kMsvr0MVuws2Qxy5069RHuKIDHjUAKQMYU1z2nffuE1xuGuURFJbze0dGc6vz4cdv0EyfMgeiSOWlFnjwJ57l3ADuA9GvRosTXBQTc7cqbFMO4+3tgoO3rxPj48PBdIJMjkAKQMQwcKDVtagY5589LI0bc7Z7z55/SN9+Y0537+pp3oMePN58p1ajR3TKKF5fGjTO79kjSoEHSyy+b3Xhq1zbHQK1aJW3ebK63WMw8I0aYMwCWLy/Nm2c+n2rp0sf9FwAAAOkIgRSAjCGp7jnR0dK2bWb3nH//NWfXq1nTHA9x77Nc7u2eI5kB1cyZZnDVt6859mnZMrPsOP36md1/+vc3Z9wqV86cxOJB0yIDAIBMjUAKQMaQVPecPHnMySceJKHuOF26mEtShgyxfY4UAAB44jFrHwAAAADYiUAKAAAAAOxEIAUAAAAAdmKMFAAASDfqLRqa1lXIkH5qPS6tqwA8cWiRAgAAAAA70SIF4JGo0WN0Wlchw9n22bC0rgIAAEimdN0iNXLkSFksFpulePHi1vW3bt1S7969lSNHDrm7u6tly5a6ePFiGtYYAAAAwJMgXQdSklSqVClduHDBumzfvt26rn///lq1apWWLFmiLVu26Pz582rRokUa1hYAAADAkyDdd+3LmjWr/P3946WHh4dr1qxZWrhwoerUqSNJmjNnjkqUKKHdu3fr2WeffdxVBQAAAPCESPctUidPnlSePHn01FNPqV27djpz5owk6cCBA4qOjlZISIg1b/HixZU/f37t2rUryTKjoqIUERFhswAAAABAcqXrQKpKlSqaO3eu1q5dqxkzZig0NFQ1atTQ9evXFRYWJkdHR3l7e9u8J1euXAoLC0uy3HHjxsnLy8u6BAQEPMK9AAAAAJDZpOuufQ0bNrT+XrZsWVWpUkUFChTQ4sWL5eLikuJyhw4dqgEDBlhfR0REEEwBAAAASLZ03SJ1P29vbxUtWlR//PGH/P39dfv2bV27ds0mz8WLFxMcU3UvJycneXp62iwAAAAAkFwZKpCKjIzUqVOnlDt3blWsWFHZsmXThg0brOuPHz+uM2fOKCgoKA1rCQAAACCzS9dd+wYOHKimTZuqQIECOn/+vEaMGCEHBwe1adNGXl5e6tq1qwYMGCAfHx95enrq9ddfV1BQEDP2AQAAAHik0nUgde7cObVp00ZXrlyRr6+vqlevrt27d8vX11eSNHnyZGXJkkUtW7ZUVFSU6tevr08//TSNaw0AAAAgs0vXgdSiRYuSXO/s7Kzp06dr+vTpj6lGAAAAAJDBxkgBAAAAQHpAIAUAAAAAdiKQAgAAAAA7EUgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAAOxEIIXMa9w4qXJlycND8vOTmjeXjh+/u/70acliSXhZsiTpso8dk55/XvLyktzczO2cOXN3fViY1L695O9vrn/6aWnZskexlwAAAEgDBFLIvLZskXr3lnbvltatk6KjpXr1pBs3zPUBAdKFC7bLqFGSu7vUsGHi5Z46JVWvLhUvLm3eLP3yizRsmOTsfDdPhw5m0LZypXTkiNSihdSqlXTw4CPdZQAAADweWdO6AsAjs3at7eu5c82WqQMHpJo1JQcHs8XoXsuXmwGPu3vi5b7zjtSokfTBB3fTChWyzbNzpzRjhvTMM+brd9+VJk82t12hQop3CQAAAOkDLVJ4coSHmz99fBJef+CAdOiQ1LVr4mXExkrffy8VLSrVr28GZlWqSCtW2OarWlX65hvp6lXzPYsWSbduScHBqbAjAAAASGsEUngyxMZK/fpJ1apJpUsnnGfWLKlECTMISsylS1JkpDR+vNSggfTTT9ILL5hd97ZsuZtv8WKzK2GOHJKTk9Sjh9naVbhwqu4WAAAA0gZd+/Bk6N1b+vVXafv2hNf/95+0cKE51ikpsbHmz2bNpP79zd/Llze78s2cKdWqZaYNGyZduyatXy/lzGm2WLVqJW3bJpUpkwo7BAAAgLREIIXMr08fafVqaetWKV++hPMsXSrdvGlOEpGUnDmlrFmlkiVt00uUuBuknTolffKJGbiVKmWmlStnBlHTp5sBFwAAADI0AilkXoYhvf662aVu82apYMHE886aZU5n7uubdJmOjuZU5/dOoy5JJ05IBQqYv9+8af7Mcl/PWQeHuy1aAAAAyNAIpJB59e5tdtf77jvzWVJhYWa6l5fk4nI33x9/mK1VP/yQcDnFi5vPpHrhBfP1oEHSyy+bM//Vrm3ODrhqlRmsxeUvXNgcFzVxojlOasUKcwr21asf1d4CAADgMWKyCWReM2aYM/UFB0u5c99dvvnGNt/s2WaXv3r1Ei7n+PG7M/5JZkA1c6Y5/XmZMtL//mc+bLd6dXN9tmxmUObrKzVtKpUtK335pTRvnjltOgAAADI8WqSQeRlG8vKNHWsu9pTTpYu5JKZIETO4AgAAQKZEixQAAAAA2IlACgAAAADsRCAFAAAAAHYikAIAAAAAOxFIAQAAAICdmLUP6Ua9RUPTugoZzk+tx6V1FQAAAJ5ItEgBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFAAAAADYiUAKAAAAyOy2bpWaNpXy5JEsFmnFirvroqOlwYOlMmUkNzczT4cO0vnzSZc5bpxUubLk4SH5+UnNm0vHj9vm+fxzKThY8vQ0t3vtWuruVxoikAIAAAAyuxs3pHLlpOnT46+7eVP6+Wdp2DDz57ffmgHR888nXeaWLVLv3tLu3dK6dWZAVq+eua17y27QQHr77dTdn3SA50gBAAAAmV3DhuaSEC8vMxC61yefSM88I505I+XPn/D71q61fT13rtkydeCAVLOmmdavn/lz8+YUVjz9okUKAAAAgK3wcLMrnre3fe+RJB+fR1Kl9IZACgAAAMBdt26ZY6batDHHNiVHbKzZ+lStmlS69COtXnpBIAUAmVlMjNnnvWBBycVFKlRIGj1aMoyk3xcVJb3zjlSggOTkJAUGSrNn313/xRdSjRpS9uzmEhIi7d37SHcFAPAYREdLrVqZnxMzZiT/fb17S7/+Ki1a9Ojqls4wRgoAMrMJE8wPwnnzpFKlpP37pc6dzf7wffsm/r5WraSLF6VZs6TChaULF8y7jXE2bzbvVFatKjk7m9upV0/67Tcpb95HvlsAgEcgLoj66y9p48bkt0b16SOtXm3ODJgv36OtYzpCIAUAmdnOnVKzZlLjxubrwEDp66+Tbj1au9acienPP+/2cw8MtM2zYIHt6//9T1q2TNqwwZwyFwCQscQFUSdPSps2STlyPPg9hiG9/rq0fLl5g61gwUdezfSErn0AkJlVrWoGNydOmK8PH5a2b0985iZJWrlSqlRJ+uADs3WpaFFp4EDpv/8Sf8/Nm+aH8BMywBgAMpzISOnQIXORpNBQ8/czZ8zr94svmr0WFiwwu4WHhZnL7dt3y6hb15zNL07v3tJXX0kLF5rPkop7z72fF2Fh5nb++MN8feSI+frq1Ue6u48DLVIAkJkNGSJFREjFi0sODuaH45gxUrt2ib/nzz/NYMvZ2bzLePmy1KuXdOWKNGdOwu8ZPNh8gGNIyKPZDwDAw9m/X6pd++7rAQPMnx07SiNHmjfRJKl8edv3bdpkPlBXkk6dMj8T4sSNoYpbH2fOHKlTJ/P3mTOlUaPuroubFv3ePBkUgRQAZGaLF5t3FxcuNMdIHTpkzqqUJ4/54ZmQ2FhzytsFC8yxVJI0aZJ5t/LTT81JK+41frw5uHjzZjP4AgCkP8HBSU809KBJiCTp9Gn73zNypLlkQgRSAJCZDRpktkq1bm2+LlPGHEQ8blzigVTu3GaXvrggSpJKlDA/MM+dk4oUuZs+caIZSK1fL5Ut++j2AwCAdIYxUgCQmd28KWW571Lv4GA7A9/9qlWTzp83+9PHOXHCLOfe2Zg++MCcSn3tWnNMFQAATxACKQDIzJo2NcdEff+92SVj+XKzm94LL9zNM3So7Ux7bduaszV17iwdPWpOZztokNSly91ufRMmmM+nmj3bnNEvboDxvcEXAACZGIEUAGRm06aZY5t69TK75w0cKPXoYbYkxblwwZy1KY67u7RunXTtmtnS1K6dGZBNnXo3z4wZ5kxOL75odgWMWyZOfGy7BgBAWmKMFABkZh4e0pQp5pKYuXPjpxUvbgZTibl/wDEAAE8YAikAAAAgHam3aGhaVyHD+an1uMe+Tbr2AQAAAICdCKQAAAAAwE4EUgAAAABgJwIpAAAAALATk00AQDrB4OKUSYsBxgAA0CIFAAAAAHYikAIAAAAAOxFIAQAAAICdCKQAAAAAwE4EUgAAAABgJwIpAAAAALATgRQAAAAA2IlACgAAAADslGkCqenTpyswMFDOzs6qUqWK9u7dm9ZVAgAAAJBJZYpA6ptvvtGAAQM0YsQI/fzzzypXrpzq16+vS5cupXXVAAAAAGRCmSKQmjRpkrp166bOnTurZMmSmjlzplxdXTV79uy0rhoAAACATChrWlfgYd2+fVsHDhzQ0KFDrWlZsmRRSEiIdu3aleB7oqKiFBUVZX0dHh4uSYqIiEiVOt25fStVynnS3LkZ9eBMsJFax+yjwHlgP86BlOE8yFw4D1ImvZ4HnAMpw3lgv9Q8B+LKMgwjyXwW40E50rnz588rb9682rlzp4KCgqzpb731lrZs2aI9e/bEe8/IkSM1atSox1lNAAAAABnI2bNnlS9fvkTXZ/gWqZQYOnSoBgwYYH0dGxurq1evKkeOHLJYLGlYsydXRESEAgICdPbsWXl6eqZ1dYDHjnMA4DwAJM6D9MAwDF2/fl158uRJMl+GD6Ry5swpBwcHXbx40Sb94sWL8vf3T/A9Tk5OcnJysknz9vZ+VFWEHTw9Pblo4InGOQBwHgAS50Fa8/LyemCeDD/ZhKOjoypWrKgNGzZY02JjY7Vhwwabrn4AAAAAkFoyfIuUJA0YMEAdO3ZUpUqV9Mwzz2jKlCm6ceOGOnfunNZVAwAAAJAJZYpA6uWXX9Y///yj4cOHKywsTOXLl9fatWuVK1eutK4aksnJyUkjRoyI1+USeFJwDgCcB4DEeZCRZPhZ+wAAAADgccvwY6QAAAAA4HEjkAIAAAAAOxFIAQAAAICdCKSQ7gQGBmrKlClpXQ0gTXD8IzPiuMaTjnMgc2KyCaRYcHCwypcvn+oXhn/++Udubm5ydXVN1XKB1MTxj8zqURzbHNfISDgHkFyZYvpzZC6+vr5pXQUgzXD8IzPiuMaTjnMgc6JrXyYVHBysvn376q233pKPj4/8/f01cuRI6/ozZ86oWbNmcnd3l6enp1q1aqWLFy9a148cOVLly5fX/PnzFRgYKC8vL7Vu3VrXr1+XJHXq1ElbtmzRxx9/LIvFIovFotOnT0uStmzZomeeeUZOTk7KnTu3hgwZojt37kiSvvzyS7m7u+vkyZPWbfXq1UvFixfXzZs3JcVv/r527Zp69OihXLlyydnZWaVLl9bq1asf+De4cuWK2rRpo7x588rV1VVlypTR119/bZNn7dq1ql69ury9vZUjRw41adJEp06dsslz9uxZtWrVSt7e3vLx8VGzZs2s+4r06Uk//g3DkK+vr5YuXWpNK1++vHLnzm19vX37djk5OVm3O2nSJJUpU0Zubm4KCAhQr169FBkZaVPu9u3bVaNGDbm4uCggIEB9+/bVjRs3HvTvQAaS2LGdHo5ries6Hr30fA5wbU+HDGRKtWrVMjw9PY2RI0caJ06cMObNm2dYLBbjp59+MmJiYozy5csb1atXN/bv32/s3r3bqFixolGrVi3r+0eMGGG4u7sbLVq0MI4cOWJs3brV8Pf3N95++23DMAzj2rVrRlBQkNGtWzfjwoULxoULF4w7d+4Y586dM1xdXY1evXoZx44dM5YvX27kzJnTGDFihLXsl156yahcubIRHR1trF692siWLZuxf/9+6/oCBQoYkydPNgzDMGJiYoxnn33WKFWqlPHTTz8Zp06dMlatWmX88MMPD/wbnDt3zvjwww+NgwcPGqdOnTKmTp1qODg4GHv27LHmWbp0qbFs2TLj5MmTxsGDB42mTZsaZcqUMWJiYgzDMIzbt28bJUqUMLp06WL88ssvxtGjR422bdsaxYoVM6Kioh7iP4RHiePfMFq0aGH07t3bMAzDuHr1quHo6Gh4eXkZx44dMwzDMN5//32jWrVq1vyTJ082Nm7caISGhhobNmwwihUrZvTs2dO6/o8//jDc3NyMyZMnGydOnDB27NhhVKhQwejUqZPd/x+kXwkd2+npuOa6jkctvZ8DXNvTFwKpTKpWrVpG9erVbdIqV65sDB482Pjpp58MBwcH48yZM9Z1v/32myHJ2Lt3r2EY5hdJV1dXIyIiwppn0KBBRpUqVWy28cYbb9hs4+233zaKFStmxMbGWtOmT59uuLu7Wz/Erl69auTLl8/o2bOnkStXLmPMmDE2Zdx7sfnxxx+NLFmyGMePH0/5H+MejRs3Nt58881E1//zzz+GJOPIkSOGYRjG/Pnz4+1PVFSU4eLiYvz444+pUiekPo5/w5g6dapRqlQpwzAMY8WKFUaVKlWMZs2aGTNmzDAMwzBCQkKsgWFClixZYuTIkcP6umvXrkb37t1t8mzbts3IkiWL8d9//9ldP6Rf9x/b6em4TgjXdaS29HwOcG1PX+jal4mVLVvW5nXu3Ll16dIlHTt2TAEBAQoICLCuK1mypLy9vXXs2DFrWmBgoDw8POK9PynHjh1TUFCQLBaLNa1atWqKjIzUuXPnJEnZs2fXrFmzNGPGDBUqVEhDhgxJtLxDhw4pX758Klq0aPJ2+h4xMTEaPXq0ypQpIx8fH7m7u+vHH3/UmTNnrHlOnjypNm3a6KmnnpKnp6cCAwMlyZrn8OHD+uOPP+Th4SF3d3e5u7vLx8dHt27ditdVBOnLk37816pVS0ePHtU///yjLVu2KDg4WMHBwdq8ebOio6O1c+dOBQcHW/OvX79edevWVd68eeXh4aH27dvrypUr1u4hhw8f1ty5c63ngbu7u+rXr6/Y2FiFhobaXT9kHOnpuOa6jrSQns4Bru3pC5NNZGLZsmWzeW2xWBQbG/vY3p+UrVu3ysHBQRcuXNCNGzdsvrDey8XFJcXb+PDDD/Xxxx9rypQp1v7B/fr10+3bt615mjZtqgIFCuiLL75Qnjx5FBsbq9KlS1vzREZGqmLFilqwYEG88hk4mr496cd/3BfNLVu2aMuWLRozZoz8/f01YcIE7du3T9HR0apataok6fTp02rSpIl69uypMWPGyMfHR9u3b1fXrl11+/Ztubq6KjIyUj169FDfvn3jbSt//vwpricyD67reNJxbX/y0CL1BCpRooTOnj2rs2fPWtOOHj2qa9euqWTJkskux9HRUTExMfHK3rVrl4x7ZtXfsWOHPDw8lC9fPknSzp07NWHCBK1atUru7u7q06dPotsoW7aszp07pxMnTiS7Xvdut1mzZnrllVdUrlw5PfXUUzblXLlyRcePH9e7776runXrqkSJEvr3339tynj66ad18uRJ+fn5qXDhwjaLl5eX3XVC2ntSjn+LxaIaNWrou+++02+//abq1aurbNmyioqK0meffaZKlSrJzc1NknTgwAHFxsbqo48+0rPPPquiRYvq/PnzNuU9/fTTOnr0aLzzoHDhwnJ0dLS7fki/7j+209NxzXUdj0N6Pge4tqcvBFJPoJCQEJUpU0bt2rXTzz//rL1796pDhw6qVauWKlWqlOxyAgMDtWfPHp0+fVqXL19WbGysevXqpbNnz+r111/X77//ru+++04jRozQgAEDlCVLFl2/fl3t27dX37591bBhQy1YsEDffPONzQw096pVq5Zq1qypli1bat26dQoNDdWaNWu0du3aB9avSJEiWrdunXbu3Kljx46pR48eNjOzZc+eXTly5NDnn3+uP/74Qxs3btSAAQNsymjXrp1y5sypZs2aadu2bQoNDdXmzZvVt29fa3M+MpYn5fiXzNkLv/76a5UvX17u7u7KkiWLatasqQULFqhWrVrWfIULF1Z0dLSmTZumP//8U/Pnz9fMmTNtyho8eLB27typPn366NChQzp58qS+++67JL8sIGO6/9hOT8c113U8Dun5HJC4tqcraTtEC49KQgPhmzVrZnTs2NEwDMP466+/jOeff95wc3MzPDw8jJdeeskICwuz5h0xYoRRrlw5m/dPnjzZKFCggPX18ePHjWeffdZwcXExJBmhoaGGYRjG5s2bjcqVKxuOjo6Gv7+/MXjwYCM6OtowDMPo3LmzUaZMGePWrVvWcj766CPDx8fHOHfunGEYtgMyDcMwrly5YnTu3NnIkSOH4ezsbJQuXdpYvXr1A/8GV65cMZo1a2a4u7sbfn5+xrvvvmt06NDBaNasmTXPunXrjBIlShhOTk5G2bJljc2bNxuSjOXLl1vzXLhwwejQoYORM2dOw8nJyXjqqaeMbt26GeHh4Q+sA9IGx7/p4MGDhiRj8ODBNvshyVi7dq1N3kmTJhm5c+c2XFxcjPr16xtffvmlIcn4999/rXn27t1rPPfcc4a7u7vh5uZmlC1bNt6AamR8CR3b6eW45rqOxyE9nwOGwbU9PbEYxj3tlAAAAACAB6JrHwAAAADYiUAKGVbDhg1tpuu8dxk7dmxaVw94pDj+kRlxXONJxzmQsdC1DxnW33//rf/++y/BdT4+PvLx8XnMNQIeH45/ZEYc13jScQ5kLARSAAAAAGAnuvYBAAAAgJ0IpAAAAADATgRSAAAAAGAnAikAAAAAsBOBFADgiXf69GlZLBYdOnQoRe8PDAzUlClTrK8tFotWrFiRKnUDAKRPBFIAgHStU6dOslgs8ZYGDRo81noEBwcnWI87d+5o37596t69+2OtDwAgbWVN6woAAPAgDRo00Jw5c2zSnJycHns9unXrpvfee88mLWvWrPL19X3sdQEApC1apAAA6Z6Tk5P8/f1tluzZs0uS2rZtq5dfftkmf3R0tHL+Xzt3EArfFsBx/PeUBWYYRgphMxs1SuwYyWosMM3ILNys7JWxVJY29oh/lBrNrCTKaKLJsFAspKZkRFhIYzejQY23eL2ped57/3dfjzfq+6m7uOee2/ltf91zbm2t1tbWJEmRSEQul0s2m012u10DAwO6uroynaO8vPxDDunj1r4/uru7k9/vl81mU01NjTwej25ubkyvDwAoHhQpAMC3ZhiGtra2lE6n82O7u7t6fn6W1+uVJGUyGQUCAZ2cnGhvb08lJSXyer3K5XKfnu/t7U1ut1tWq1XxeFxHR0eyWCzq7+/X6+vrp68PAPgcFCkAQNHb3t6WxWIpuGZnZyVJbrdbFRUV2tjYyM9fX1/X0NCQrFarJGl4eFg+n08Oh0Pt7e1aWVnR+fm5EomEqRzz8/MFGaampn76TjgcVi6X048fP9TW1qbW1latrq7q9vZWsVjM1PoAgOLBGSkAQNHr6+vTwsJCwVhNTY2k384o+f1+BYNBjY2NKZPJaHNzU6FQKD/38vJSMzMzOj4+ViqVyn+Jur29ldPp/Mc5DMPQ9PR0/t5ms/30nbOzMyWTyXyp+102m/1X2wsBAMWBIgUAKHoVFRVyOBx/+dwwDPX29urx8VHRaFRlZWUFf/UbHBxUS0uLlpeX1dDQoFwuJ6fTaXprXVVV1d/m+DPpdFqdnZ0KBoMfnvGTCgD4vihSAIBvr6urS01NTQqHw9rZ2dHIyIhKS0slSU9PT7q4uNDy8rJ6enokSYeHh1+WraOjQ+FwWHV1daqsrPyydQEAn4szUgCAovfy8qKHh4eCK5VKFcwZHR3V4uKiotGoDMPIj1dXV8tut2tpaUnJZFL7+/sKBAJflt0wDNXW1srj8Sgej+v6+lqxWEwTExO6v7//shwAgP8WRQoAUPQikYjq6+sLLpfLVTDHMAwlEgk1Njaqu7s7P15SUqJQKKTT01M5nU5NTk5qbm7uy7KXl5fr4OBAzc3N8vl8am1t1fj4uLLZLF+oAOAb++X9/f39/w4BAAAAAN8JX6QAAAAAwCSKFAAAAACYRJECAAAAAJMoUgAAAABgEkUKAAAAAEyiSAEAAACASRQpAAAAADCJIgUAAAAAJlGkAAAAAMAkihQAAAAAmESRAgAAAACTfgU/YklSHxKSgAAAAABJRU5ErkJggg==",
-      "text/plain": [
-       "<Figure size 1000x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# plot the perplexity scores for the xlm-mlm-en-2048 model\n",
-    "plot_perplexity(eval_files, eval_results, ft_direct_eval_results, \"XLM-MLM-EN-2048\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# plot the perplexity scores for the bert-base model and the fine-tuned model\n",
-    "plot_perplexity(eval_files, eval_results, ft_direct_eval_results, \"BERT-Base\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 137,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# plot the perplexity scores for the roberta-base model and the fine-tuned model\n",
-    "plot_perplexity(eval_files, eval_results, ft_direct_eval_results, base_model_path)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# (Deprecated) Utilities for fine-tuning"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "True\n",
-      "11.0\n",
-      "Total memory: 51041271808\n",
-      "Allocated memory: 0\n",
-      "Cached memory: 0\n"
-     ]
-    }
-   ],
-   "source": [
-    "import torch\n",
-    "print(torch.cuda.is_available())\n",
-    "print(torch.version.cuda)\n",
-    "\n",
-    "# Assuming your GPU is device 0\n",
-    "device = torch.device('cuda:0')\n",
-    "\n",
-    "print(f'Total memory: {torch.cuda.get_device_properties(device).total_memory}')\n",
-    "print(f'Allocated memory: {torch.cuda.memory_allocated(device)}')\n",
-    "print(f'Cached memory: {torch.cuda.memory_reserved(device)}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@dataclass\n",
-    "class ModelArguments:\n",
-    "    \"\"\"\n",
-    "    Arguments pertaining to which model/config/tokenizer we are going to fine-tune, or train from scratch.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    model_name_or_path: Optional[str] = field(\n",
-    "        default=None,\n",
-    "        metadata={\n",
-    "            \"help\": \"The model checkpoint for weights initialization. Leave None if you want to train a model from scratch.\"\n",
-    "        },\n",
-    "    )\n",
-    "    model_type: Optional[str] = field(\n",
-    "        default=None,\n",
-    "        metadata={\"help\": \"If training from scratch, pass a model type from the list: \" + \", \".join(MODEL_TYPES)},\n",
-    "    )\n",
-    "    config_name: Optional[str] = field(\n",
-    "        default=None, metadata={\"help\": \"Pretrained config name or path if not the same as model_name\"}\n",
-    "    )\n",
-    "    tokenizer_name: Optional[str] = field(\n",
-    "        default=None, metadata={\"help\": \"Pretrained tokenizer name or path if not the same as model_name\"}\n",
-    "    )\n",
-    "    cache_dir: Optional[str] = field(\n",
-    "        default=None, metadata={\"help\": \"Where do you want to store the pretrained models downloaded from s3\"}\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@dataclass\n",
-    "class DataTrainingArguments:\n",
-    "    \"\"\"\n",
-    "    Arguments pertaining to what data we are going to input our model for training and eval.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    train_data_file: Optional[str] = field(\n",
-    "        default=None, metadata={\"help\": \"The input training data file (a text file).\"}\n",
-    "    )\n",
-    "    train_data_files: Optional[str] = field(\n",
-    "        default=None,\n",
-    "        metadata={\n",
-    "            \"help\": \"The input training data files (multiple files in glob format). \"\n",
-    "            \"Very often splitting large files to smaller files can prevent tokenizer going out of memory\"\n",
-    "        },\n",
-    "    )\n",
-    "    eval_data_file: Optional[str] = field(\n",
-    "        default=None,\n",
-    "        metadata={\"help\": \"An optional input evaluation data file to evaluate the perplexity on (a text file).\"},\n",
-    "    )\n",
-    "    line_by_line: bool = field(\n",
-    "        default=False,\n",
-    "        metadata={\"help\": \"Whether distinct lines of text in the dataset are to be handled as distinct sequences.\"},\n",
-    "    )\n",
-    "\n",
-    "    mlm: bool = field(\n",
-    "        default=False, metadata={\"help\": \"Train with masked-language modeling loss instead of language modeling.\"}\n",
-    "    )\n",
-    "    mlm_probability: float = field(\n",
-    "        default=0.15, metadata={\"help\": \"Ratio of tokens to mask for masked language modeling loss\"}\n",
-    "    )\n",
-    "    plm_probability: float = field(\n",
-    "        default=1 / 6,\n",
-    "        metadata={\n",
-    "            \"help\": \"Ratio of length of a span of masked tokens to surrounding context length for permutation language modeling.\"\n",
-    "        },\n",
-    "    )\n",
-    "    max_span_length: int = field(\n",
-    "        default=5, metadata={\"help\": \"Maximum length of a span of masked tokens for permutation language modeling.\"}\n",
-    "    )\n",
-    "\n",
-    "    block_size: int = field(\n",
-    "        default=-1,\n",
-    "        metadata={\n",
-    "            \"help\": \"Optional input sequence length after tokenization.\"\n",
-    "            \"The training dataset will be truncated in block of this size for training.\"\n",
-    "            \"Default to the model max input length for single sentence inputs (take into account special tokens).\"\n",
-    "        },\n",
-    "    )\n",
-    "    overwrite_cache: bool = field(\n",
-    "        default=False, metadata={\"help\": \"Overwrite the cached training and evaluation sets\"}\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_dataset(\n",
-    "    args: DataTrainingArguments,\n",
-    "    tokenizer: PreTrainedTokenizer,\n",
-    "    evaluate: bool = False,\n",
-    "    cache_dir: Optional[str] = None,\n",
-    "):\n",
-    "    def _dataset(file_path):\n",
-    "        if args.line_by_line:\n",
-    "            return LineByLineTextDataset(tokenizer=tokenizer, file_path=file_path, block_size=args.block_size)\n",
-    "        else:\n",
-    "            return TextDataset(\n",
-    "                tokenizer=tokenizer,\n",
-    "                file_path=file_path,\n",
-    "                block_size=args.block_size,\n",
-    "                overwrite_cache=args.overwrite_cache,\n",
-    "                cache_dir=cache_dir,\n",
-    "            )\n",
-    "\n",
-    "    if evaluate:\n",
-    "        return _dataset(args.eval_data_file)\n",
-    "    elif args.train_data_files:\n",
-    "        return ConcatDataset([_dataset(f) for f in glob(args.train_data_files)])\n",
-    "    else:\n",
-    "        return _dataset(args.train_data_file)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "detox-rep",
-   "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.14"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/llments/lm/base/hugging_face.py b/llments/lm/base/hugging_face.py
index a9d9737..77a9e77 100644
--- a/llments/lm/base/hugging_face.py
+++ b/llments/lm/base/hugging_face.py
@@ -33,29 +33,36 @@ def __init__(
                 "You need to install the `transformers` package to use this class."
             )
 
-        if not ".ckpt" in model:  # use the same tokenizer as the model
+        # load model
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model,
+            do_sample=True,
+            use_cache=True,
+            cache_dir=cache_dir,
+            from_tf=bool(".ckpt" in model),
+        )
+
+        # load tokenizer
+        if tokenizer_path is not None:
+            try:
+                self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
+            except:
+                raise ValueError(
+                    "You must create model from one of the following ways: \n"
+                    + "1. Input a pretrained HF model name, and optionally the compatible tokenizer path. \n"
+                    + "2. Load model from a checkpoint file, include tokenizer path as well. \n"
+                )
+        else:
             self.tokenizer = AutoTokenizer.from_pretrained(
                 model, trust_remote_code=True
             )
-            self.model = AutoModelForCausalLM.from_pretrained(
-                model, do_sample=True, use_cache=True, cache_dir=cache_dir
-            )
-            self.device = device or "cpu"
-            self.model.to(self.device)
-        elif ".ckpt" in model and tokenizer_path is not None:  # load from checkpoint
-            tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
-            if not tokenizer.pad_token:
-                tokenizer.pad_token = tokenizer.eos_token
-            self.tokenizer = tokenizer
-            self.model = AutoModelForCausalLM.from_pretrained(
-                model, from_tf=bool(".ckpt" in model)
-            )
-        else:
-            raise ValueError(
-                "You must create model from one of the following ways: \n"
-                + "1. Input HF model name.\n"
-                + "2. Load model from a checkpoint file, include tokenizer path as well."
-            )
+
+        if not self.tokenizer.pad_token:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+        # set device
+        self.device = device or "cpu"
+        self.model.to(self.device)
 
     def generate(
         self,
@@ -216,6 +223,7 @@ def fit(
         prediction_loss_only: bool = False,
         optim: str = "adamw_torch",
         logging_steps: int = 500,
+        save_steps: int = 500,
         lora_r: int | None = None,
         lora_alpha: int | None = None,
     ) -> LanguageModel:
@@ -241,6 +249,7 @@ def fit(
             prediction_loss_only: When performing evaluation and generating predictions, only returns the loss.
             optim: The optimizer to use. Can only choose from a list of names.
             logging_steps: Number of update steps between two logs if logging_strategy="steps".
+            save_steps: Number of updates steps between two checkpoints.
             lora_r: Lora attention dimension (the “rank”).
             lora_alpha: The alpha parameter for Lora scaling.
 
@@ -276,6 +285,8 @@ def fit(
 
         # convert tokenized text into a Dataset object
         dataset = Dataset.from_dict(inputs)
+        print("Dataset LM for training prepared!")
+
         if eval_target:
             eval_samples = eval_target.generate(
                 condition=None,
@@ -288,9 +299,11 @@ def fit(
                 eval_samples, padding=True, truncation=True, return_tensors="pt"
             )
             eval_dataset = Dataset.from_dict(eval_inputs)
+            print("Dataset LM for evaluation prepared!")
 
         # wrap the base model with peft
         if lora_r and lora_alpha:
+            print("Using LORA attention for fitting.")
             try:
                 from peft import (
                     LoraConfig,
@@ -329,6 +342,7 @@ def fit(
             prediction_loss_only=prediction_loss_only,
             logging_dir=logging_dir,
             logging_steps=logging_steps,
+            save_steps=save_steps,
         )
 
         # Make output_dir and logging_dir
@@ -337,6 +351,7 @@ def fit(
         if not os.path.exists(logging_dir):
             os.makedirs(logging_dir)
 
+        print("Start fitting...")
         if not do_eval:
             trainer = Trainer(
                 model=base.model,
@@ -360,6 +375,7 @@ def fit(
         trainer.train()
         base.tokenizer.save_pretrained(output_dir)
         trainer.save_model(output_dir)
+        print("fitted modes saved to", output_dir)
 
         return base