diff --git a/convokit/__init__.py b/convokit/__init__.py
index 1a14f019..2ca89e9f 100644
--- a/convokit/__init__.py
+++ b/convokit/__init__.py
@@ -21,6 +21,7 @@
     from .expected_context_framework import *
     from .surprise import *
     from .convokitConfig import *
+    from .balance import *
     from .redirection import *
     from .pivotal_framework import *
     from .utterance_simulator import *
diff --git a/convokit/balance/__init__.py b/convokit/balance/__init__.py
new file mode 100644
index 00000000..3ed849aa
--- /dev/null
+++ b/convokit/balance/__init__.py
@@ -0,0 +1 @@
+from .balance import *
diff --git a/convokit/balance/balance.py b/convokit/balance/balance.py
new file mode 100644
index 00000000..04bc8aaf
--- /dev/null
+++ b/convokit/balance/balance.py
@@ -0,0 +1,183 @@
+from convokit.model import Corpus
+from convokit.transformer import Transformer
+from tqdm import tqdm
+from typing import Callable
+from convokit.model.conversation import Conversation
+import re
+
+from .balance_util import (
+    _get_ps,
+    _convo_balance_score,
+    _convo_balance_lst,
+    _plot_individual_conversation_floors,
+    _plot_multi_conversation_floors,
+)
+
+
+def plot_single_conversation_balance(
+    corpus,
+    convo_id,
+    window_ps_threshold,
+    window_size,
+    sliding_size,
+    remove_first_last_utt,
+    min_utt_words,
+    plot_name=None,
+    window_ss_threshold=None,
+):
+    if window_ss_threshold is None:
+        window_ss_threshold = window_ps_threshold
+    _plot_individual_conversation_floors(
+        corpus,
+        convo_id,
+        window_ps_threshold,
+        window_ss_threshold,
+        window_size,
+        sliding_size,
+        remove_first_last_utt,
+        min_utt_words,
+        plot_name=plot_name,
+    )
+
+
+def plot_multi_conversation_balance(
+    corpus,
+    convo_id_lst,
+    window_ps_threshold,
+    window_ss_threshold,
+    window_size,
+    sliding_size,
+    remove_first_last_utt,
+    min_utt_words,
+    plot_name=None,
+):
+    if window_ss_threshold is None:
+        window_ss_threshold = window_ps_threshold
+    _plot_multi_conversation_floors(
+        corpus,
+        convo_id_lst,
+        window_ps_threshold,
+        window_ss_threshold,
+        window_size,
+        sliding_size,
+        remove_first_last_utt,
+        min_utt_words,
+        plot_name=plot_name,
+    )
+
+
+class Balance(Transformer):
+    """
+    The Balance transformer quantifies and annotates conversations' talk-time sharing dynamics
+    between predefined speaker groups within a corpus.
+
+    It assigns each conversation a primary speaker group (more talkative), a secondary
+    speaker group (less talkative), and a scalar imbalance score. It also computes a
+    list of windowed imbalance scores over a sliding windows of the conversation.
+
+    Each utterance is expected to have a speaker group label under `utt.meta['utt_group']`,
+    which can be precomputed or inferred from `convo.meta['speaker_groups']`.
+    Annotation of speaker groups for each utterance is required before using the Balance transformer.
+    The transform() function assumes either `convo.meta['speaker_groups']`  or `utt.meta['utt_group']`
+    is already presented in the corpus for correct computation.
+
+    :param primary_threshold: Minimum talk-time share to label a group as the primary speaker.
+    :param window_ps_threshold: Talk-time share threshold for identifying dominance in a time window for primary speaker group.
+    :param window_ss_threshold: Talk-time share threshold for identifying dominance in a time window for secondary speaker group. If not provided, defaults to `window_ps_threshold`.
+    :param window_size: Length (in minutes) of each analysis window.
+    :param sliding_size: Step size (in seconds) to slide the window forward.
+    :param min_utt_words: Exclude utterances shorter than this number of words from the analysis.
+    :param remove_first_last_utt: Whether to exclude the first and last utterance.
+    """
+
+    def __init__(
+        self,
+        primary_threshold=0.50001,
+        window_ps_threshold=0.6,
+        window_ss_threshold=None,
+        window_size=2.5,
+        sliding_size=30,
+        min_utt_words=0,
+        remove_first_last_utt=True,
+    ):
+        self.primary_threshold = primary_threshold
+        self.window_ps_threshold = window_ps_threshold
+        self.window_ss_threshold = (
+            window_ss_threshold if window_ss_threshold else window_ps_threshold
+        )
+        self.window_size = window_size
+        self.sliding_size = sliding_size
+        self.min_utt_words = min_utt_words
+        self.remove_first_last_utt = remove_first_last_utt
+
+    def transform(
+        self, corpus: Corpus, selector: Callable[[Conversation], bool] = lambda convo: True
+    ):
+        """
+        Computes talk-time balance metrics for each conversation in the corpus.
+
+        Annotates the corpus with speaker group labels and if utterances `utt_group` metadata is missing, the data
+        is assumed to be labeled in `convo.meta['speaker_groups']`.
+        Each conversation is then annotated with its primary and secondary speaker groups, an overall conversation level
+        imbalance score, and a list of windowed imbalance score computed via sliding window analysis.
+
+        :param corpus: Corpus to transform
+        :param selector: (lambda) function selecting conversations to include in this accuracy calculation;
+
+        :return: The input corpus where selected data is annotated with talk-time sharing dynamics information
+        """
+        ### Annotate utterances with speaker group information
+        if "utt_group" not in corpus.random_utterance().meta.keys():
+            for convo in tqdm(
+                corpus.iter_conversations(),
+                desc="Annotating speaker groups based on `speaker_groups` from conversation metadata",
+            ):
+                if selector(convo):
+                    if "speaker_groups" not in convo.meta:
+                        raise ValueError(
+                            f"Missing 'speaker_groups' metadata in conversation {convo.id}, which is required for annotating utterances."
+                        )
+                    speaker_groups_dict = convo.meta["speaker_groups"]
+                    for utt in convo.iter_utterances():
+                        utt.meta["utt_group"] = speaker_groups_dict[utt.speaker.id]
+
+        ### Annotate conversations with Balance information
+        for convo in tqdm(corpus.iter_conversations(), desc="Annotating conversation balance"):
+            if selector(convo):
+                convo.meta["primary_speaker"] = _get_ps(
+                    corpus,
+                    convo,
+                    self.remove_first_last_utt,
+                    self.min_utt_words,
+                    self.primary_threshold,
+                )
+                if convo.meta["primary_speaker"] is not None:
+                    convo.meta["secondary_speaker"] = (
+                        "groupA" if convo.meta["primary_speaker"] == "groupB" else "groupB"
+                    )
+                else:
+                    convo.meta["secondary_speaker"] = None
+                convo.meta["balance_score"] = _convo_balance_score(
+                    corpus, convo.id, self.remove_first_last_utt, self.min_utt_words
+                )
+                convo.meta["balance_lst"] = _convo_balance_lst(
+                    corpus,
+                    convo.id,
+                    self.window_ps_threshold,
+                    self.window_ss_threshold,
+                    self.window_size,
+                    self.sliding_size,
+                    self.remove_first_last_utt,
+                    self.min_utt_words,
+                )
+
+    def fit_transform(
+        self, corpus: Corpus, selector: Callable[[Conversation], bool] = lambda convo: True
+    ):
+        """
+        Same as transform.
+
+        :param corpus: Corpus to transform
+        :param selector: (lambda) function selecting conversations to include in this accuracy calculation;
+        """
+        return self.transform(corpus, selector=selector)
diff --git a/convokit/balance/balance_example.ipynb b/convokit/balance/balance_example.ipynb
new file mode 100644
index 00000000..1302e74b
--- /dev/null
+++ b/convokit/balance/balance_example.ipynb
@@ -0,0 +1,2950 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Talk-Time Sharing Dynamics in CANDOR Corpus"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this demo, we demonstrate the use of the Balance transformer in analyzing the talk-time sharing dynamics in [CANDOR corpus](https://convokit.cornell.edu/documentation/candor.html). The proposed methods and analysis results are introduced in the paper: [**Time is On My Side: Dynamics of Talk-Time Sharing in Video-chat Conversations.**](https://www.cs.cornell.edu/~cristian/Time_Sharing_Dynamics.html) In the paper, we developed a computational framework to quantify how talk-time is distributed between speakers over the course of a conversation, capturing both conversation-level balance and the fine-grained dynamics that lead to it.\n",
+    "\n",
+    "In this demo, we apply the framework on video-chat conversations from the CANDOR corpus, and extend it to a new contexts---[the Supreme Court oral arguments](https://convokit.cornell.edu/documentation/supreme.html)---to explore its broader applicability. Our approach surfaces patterns in how speakers alternate dominance, engage in back-and-forths, or maintain relatively equal control of the floor. We show that even when conversations are similarly balanced overall, their temporal talk-time dynamics can lead to diverging speaker experiences. The framework can be adapted to a range of dialog settings, including multi-party or role-asymmetric interactions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "\n",
+    "import convokit\n",
+    "print(\"done importing convokit\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "### Importing the Balance Transformer from convokit\n",
+    "from convokit.balance import Balance, plot_single_conversation_balance, plot_multi_conversation_balance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from convokit import Corpus, download, FightingWords\n",
+    "from tqdm import tqdm\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from collections import Counter\n",
+    "from scipy.stats import wilcoxon, mannwhitneyu\n",
+    "from sklearn.metrics import cohen_kappa_score\n",
+    "import seaborn as sns\n",
+    "import re\n",
+    "\n",
+    "import random\n",
+    "random.seed(42)\n",
+    "plt.rcParams.update({'font.size': 14})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Table of Contents\n",
+    "1. [Introduction](#talk-time-sharing-dynamics-in-candor-corpus)\n",
+    "2. [Demo 1 – CANDOR Corpus](#demo-1-talk-time-sharing-dynamics-in-the-candor-corpus)\n",
+    "3. [Demo 2 – Supreme Court Oral Arguments](#demo-2-talk-time-sharing-dynamics-in-supreme-court-oral-argument-conversations)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Demo 1: Talk-Time Sharing Dynamics in the CANDOR Corpus\n",
+    "\n",
+    "The [CANDOR corpus](https://convokit.cornell.edu/documentation/candor.html) is a large dataset of video-chat dialogues, where participants were paired with strangers and asked to talk freely without specific guidelines. It includes rich metadata from post-conversation surveys, such as enjoyment ratings and comments. We use these metadata to analyze talk-time sharing dynamics and explore how they relate to participants’ subjective experiences."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "PATH_TO_CANDOR_CORPUS = \"<YOUR PATH TO CANDOR CORPUS>\"\n",
+    "corpus = Corpus(filename=PATH_TO_CANDOR_CORPUS)\n",
+    "# Filter out conversations that are not valid due to missing metadata or technical issues reported by the participants from survey.\n",
+    "invalid_convo = ['80d9e496-db7f-49e3-8789-06850e62ffa1','82af78ef-4d4f-4bd3-8d20-7daa70adff61','87e8b3ce-14da-43e6-bd8b-7c3c67030559','8d0c52af-1e6d-46ca-a709-28c7ba9734ce','3045ec04-252c-420e-8646-c6b0e150ca74','fe2ec1ed-027e-404d-94c7-8fc1587aa3bc','983a1ff0-e14f-408a-a807-2e1b1cbb2a00','f5de68ee-6513-406a-b0fc-49f20873faef','ceaafa07-24d8-4398-9b1a-b825938f23e0','446fe8dc-1619-4c44-a4bd-8cbb48a2bca1','29f8f496-079b-4a71-84ff-7100bbc28824','68a27e9e-2c9d-49ac-ba58-9751d402a84b','22579311-0848-472a-a1b7-9b663fbb4aab','ee19d0ea-462c-47ef-888d-ac3254113e37','601dd44f-db11-48d6-b150-d8959e05c97f','65ec7b23-af77-449e-9b11-e431f8a3b874','0a84a137-b947-441c-b94c-a03f4a5851ea','588c5b4b-5e92-426c-8acc-686628a7342f','6ce9f678-15c4-424c-bf3f-b4e2f47a8818','c0c54a77-1d33-41a4-8e13-92a4840e82b8','13f6956b-ff2a-4ad3-aed6-8fd3cfdb2cd4','ea29afa5-e18a-47a9-93bf-87bfbb94c1d5','53459a58-b890-4cad-83dc-1fb55dbd880e','92c66875-8a3c-44f6-9356-8537655417db','b91c719a-4d41-4e24-837e-5c6abfacc77a','115ba192-7e26-497b-85b2-adf378b33387','3049cb21-cec9-46b6-ace5-8b97f4fd6165','2a4d7a05-b514-4927-a797-3644b4046f43','da272ccd-9b89-4ae4-81d4-38ed452f36d1','6fdd1fc5-e185-45e4-810d-bd8fb8b82490','1e3c22d6-422c-4921-8892-e31e09f9a2f6','60454fcf-eceb-4faf-9347-8d796e1b5be8','d9266679-7d71-43d0-ab1a-3293b589569e','49694675-cacf-452d-a940-3c93987126ef','17dbcae3-0087-49c6-af7c-c92099e3377a','a806bdc5-250b-41e7-a8c7-9440c270f3fe','0278950b-a7e0-4e15-8a2b-1629ff1b17ba','ce044258-3886-4f26-a670-d32aeeec6df9','eb326986-325e-4f6b-b895-82a1f577c797','141ea746-d1f1-402d-9b0a-a4cdb0b1c4f0','32adb5d5-910d-4547-972a-f5d0b795c689','542a6af4-84f3-4681-80ce-fce29162efc1','fe4a5de5-3b9c-4b6f-8e70-403db8a1caec','bf57c9e7-7be9-4961-a7fb-59777c0dc751','5f3c5c14-1280-48c4-b6a5-97437ea68c94','b877a5bf-3384-4ea0-bf82-cef399a1b00d','a8855c03-359f-42d9-af04-e459f9547107','98666aa9-2a23-4a64-9379-48541d73d901','765f6cde-5291-4047-89c1-d71b1e3a413d','c4caca36-1ace-44de-844a-0933eface36a','debcfb81-d883-4fb5-8c4c-cc98468c96db','030c76ab-9e19-4b78-9a7a-86cd7ba8472a','20bc98a3-efaa-4657-8448-f731bdec47cb','ec4460de-5136-4a67-90f1-a8cde16266c0','d713d070-fe2c-4327-8952-e78f45d251a8','65b9bc57-6206-475d-91ec-c5696259c0d4']\n",
+    "corpus = corpus.filter_conversations_by(lambda convo: convo.id not in invalid_convo)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Pre-req: Annotate Speaker Group For each Conversation in the CANDOR dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "1594it [00:20, 79.30it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "for convo in tqdm(corpus.iter_conversations()):\n",
+    "    sp_lst = convo.get_speaker_ids()\n",
+    "    sp_A_id, sp_B_id = convo.meta['speaker_A'], sp_lst[0] if sp_lst[0] != convo.meta['speaker_A'] else sp_lst[1]\n",
+    "    convo.meta['speaker_group'] = {sp_A_id : 'groupA', sp_B_id : 'groupB', 'groupA' : sp_A_id, 'groupB' : sp_B_id}\n",
+    "    for utt in convo.iter_utterances():\n",
+    "        utt.meta['group'] = convo.meta['speaker_group'][utt.speaker.id]\n",
+    "        utt.meta['utt_group'] = convo.meta['speaker_group'][utt.speaker.id]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Apply Balance Transformer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Hyperparameters for the Balance Transformer, explained in the paper in detail.\n",
+    "# because the speakers never met, we consider them to be role neutral, so speakers are expected to take equal time speaking. Thus, primary speaker has to speak for more than half of time in the conversation total speaking time\n",
+    "primary_threshold = 0.50001 \n",
+    "# For each window, we apply more strict threshold for primary speaker of the window has to speak for more than 60% of time in window's total speaking time\n",
+    "window_ps_threshold = 0.6 \n",
+    "# window size for sliding window apporach, in minutes\n",
+    "window_size = 2.5 \n",
+    "# sliding window step size, in sec\n",
+    "sliding_size = 30  \n",
+    "# utterance with length under min_utt_words will be eliminated, here we don't remove any utterance.\n",
+    "min_utt_words = 0 \n",
+    "# remove first and last utterance in the conversation, because of video conference nature of the corpus, first and last utterance are usually not part of the conversation but noise.\n",
+    "remove_first_last_utt = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Annotating conversation balance: 1594it [01:47, 14.79it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Apply the Balance Transformer to the corpus\n",
+    "balance_transformer = Balance(primary_threshold=primary_threshold, \n",
+    "                              window_ps_threshold=window_ps_threshold, \n",
+    "                              window_size=window_size,\n",
+    "                              sliding_size=sliding_size,\n",
+    "                              min_utt_words=min_utt_words,\n",
+    "                              remove_first_last_utt=remove_first_last_utt)\n",
+    "balance_transformer.transform(corpus)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Helper Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Helper Functions for the demo\n",
+    "\n",
+    "def read_convo(corpus, convo_id):\n",
+    "    convo = corpus.get_conversation(convo_id)\n",
+    "    for utt in convo.iter_utterances():\n",
+    "        start = round(utt.meta['start'] / 60, 2)\n",
+    "        print(f\"{start} \\033[1m{utt.speaker.meta['group']}\\033[0m: {utt.text}\")\n",
+    "        \n",
+    "def get_convo_lst_high_enjoy_percent(corpus, convo_id_lst):\n",
+    "    enjoy = []\n",
+    "    for convo_id in convo_id_lst:\n",
+    "        convo = corpus.get_conversation(convo_id)\n",
+    "        enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "    if len(enjoy) == 0:\n",
+    "        return \"no convo\"\n",
+    "    return enjoy.count(9) / len(enjoy)\n",
+    "\n",
+    "def bootstrap_95(data):\n",
+    "    resample_times = 1000\n",
+    "    all_mean = []\n",
+    "\n",
+    "    for _ in range(resample_times):\n",
+    "        sample = random.choices(data, k=len(data))\n",
+    "        mean = np.mean(sample)\n",
+    "        all_mean.append(mean)\n",
+    "\n",
+    "    lower_bound = np.percentile(all_mean, 2.5)\n",
+    "    upper_bound = np.percentile(all_mean, 97.5)\n",
+    "\n",
+    "    return (lower_bound, upper_bound)\n",
+    "\n",
+    "def bootstrap_95_percentage(corpus, data):\n",
+    "    resample_times = 1000\n",
+    "    all_percentage = []\n",
+    "\n",
+    "    for _ in range(resample_times):\n",
+    "        sample = random.choices(data, k=len(data))\n",
+    "        single_time = get_convo_lst_high_enjoy_percent(corpus, sample)\n",
+    "        all_percentage.append(single_time)\n",
+    "\n",
+    "    lower_bound = np.percentile(all_percentage, 2.5)\n",
+    "    upper_bound = np.percentile(all_percentage, 97.5)\n",
+    "\n",
+    "    return (lower_bound*100, upper_bound*100)\n",
+    "\n",
+    "def percent_A_is_B(A, B):\n",
+    "    count1 = len([x for x in A if x in B])\n",
+    "    count2 = len(A)\n",
+    "    return round(count1/count2, 4)\n",
+    "\n",
+    "def plot_convo_type_vs_metadata(data_dict, meta_name_scale):\n",
+    "    x = list(data_dict.keys())\n",
+    "    y = [np.mean(data_dict[key]) for key in x]\n",
+    "    y_err = [bootstrap_95(data_dict[key]) for key in x]\n",
+    "\n",
+    "    lower_errors = [y[i] - err[0] for i, err in enumerate(y_err)]\n",
+    "    upper_errors = [err[1] - y[i] for i, err in enumerate(y_err)]\n",
+    "    asymmetric_error = [lower_errors, upper_errors]\n",
+    "\n",
+    "    x_label = [f\"{a} ({len(data_dict[a])})\" for a in x]\n",
+    "\n",
+    "    plt.errorbar(x, y, yerr=asymmetric_error, fmt='o', capsize=5, capthick=2, label='bootstrap 95% confidence')\n",
+    "    plt.xticks(x, x_label, rotation=45, ha='right', fontsize=10)\n",
+    "    plt.xlabel('Conversation Type')\n",
+    "    plt.ylabel(f'Average {meta_name_scale} Rating')\n",
+    "    plt.title(f'Average {meta_name_scale} Rating across Convo Types')\n",
+    "    plt.ylim(8, 18)\n",
+    "    plt.grid(True)\n",
+    "\n",
+    "    plt.legend()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overall Conversation Balance for convo_id 48622ac9-189b-47cd-8eb4-3e6d93ba462e is: 0.5718328104013037; groupA\n"
+     ]
+    }
+   ],
+   "source": [
+    "### A Test -- Expected output: \"Overall Conversation Balance for convo_id 48622ac9-189b-47cd-8eb4-3e6d93ba462e is:  0.5718328104013037; groupA\"\n",
+    "convo = corpus.get_conversation(\"48622ac9-189b-47cd-8eb4-3e6d93ba462e\")\n",
+    "print(f\"Overall Conversation Balance for convo_id {convo.id} is: {convo.meta['balance_score']}; {convo.meta['primary_speaker']}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overall Conversation Balance for convo_id 48622ac9-189b-47cd-8eb4-3e6d93ba462e is:  0.5718328104013037\n",
+      "groupA\n"
+     ]
+    }
+   ],
+   "source": [
+    "convo = corpus.random_conversation()\n",
+    "print(f\"Overall Conversation Balance for convo_id {convo.id} is: \", convo.meta['balance_score'])\n",
+    "print(convo.meta['primary_speaker'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualizations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Figure 1: We plot the Enjoyment Score Distribution from participants' reported \"how_enjoyable\" score\n",
+    "enjoyment_ps, enjoyment_ss = [], []\n",
+    "for convo in corpus.iter_conversations():\n",
+    "    if convo.meta['primary_speaker'] == None: continue\n",
+    "    enjoyment_ps.append(convo.meta['how_enjoyable'][convo.meta['speaker_group'][convo.meta['primary_speaker']]])\n",
+    "    enjoyment_ss.append(convo.meta['how_enjoyable'][convo.meta['speaker_group'][convo.meta['secondary_speaker']]])\n",
+    "\n",
+    "def plot_element_counts(data_list, x_name, y_name, title, note=\"\", sorted_by=None, y_up=None, y_down=None, x_up=None, x_down=None, plot_name=None):\n",
+    "    counts = Counter(data_list)\n",
+    "    if sorted_by is not None:\n",
+    "        sorted_items = [(element, counts[element]) for element in sorted_by if element in counts]\n",
+    "    else:\n",
+    "        sorted_items = sorted(counts.items())\n",
+    "    elements = [item[0] for item in sorted_items]\n",
+    "    occurrences = [item[1] for item in sorted_items]\n",
+    "    font_size = 14\n",
+    "    plt.figure(figsize=(8, 6))\n",
+    "    plt.bar(elements, occurrences)\n",
+    "    for i in range(len(elements)):\n",
+    "      plt.text(elements[i], occurrences[i]+5, str(occurrences[i]), ha='center', fontsize=font_size)\n",
+    "\n",
+    "    plt.xlabel(x_name, fontsize=font_size)\n",
+    "    plt.ylabel(y_name, fontsize=font_size)\n",
+    "    plt.title(title, fontsize=font_size)\n",
+    "    plt.xticks(elements, fontsize=font_size - 2)\n",
+    "    plt.yticks(fontsize=font_size - 2)\n",
+    "\n",
+    "    plt.text(0, -0.2, note, transform=plt.gca().transAxes, fontsize=font_size, ha='left', va='top')\n",
+    "    if y_up is not None and y_down is not None:\n",
+    "        plt.ylim(y_down, y_up)\n",
+    "    if x_up is not None and x_down is not None:\n",
+    "        plt.xlim(x_down, x_up)\n",
+    "    if plot_name is not None:\n",
+    "        plt.savefig(plot_name)\n",
+    "    plt.show()\n",
+    "\n",
+    "plot_element_counts(enjoyment_ps+enjoyment_ss, \"perceived enjoyment score\", \"number of speakers\", \"\", y_up=1000, y_down=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Figure 2: We plot the overall distribution on the level of imbalanceness across conversations\n",
+    "def check_balance_distribution(corpus, y_up=None):\n",
+    "    balance_score = []\n",
+    "    for convo in corpus.iter_conversations():\n",
+    "        if convo.meta['primary_speaker'] == None: continue\n",
+    "        balance_score.append(convo.meta['balance_score'])\n",
+    "\n",
+    "    font_size = 14\n",
+    "\n",
+    "    plt.figure(figsize=(8, 6))\n",
+    "    plt.hist(balance_score, bins=np.arange(0, 1.1, 0.05), edgecolor='black', alpha=0.7)\n",
+    "    plt.xlabel('overall imbalance', fontsize=font_size)\n",
+    "    plt.ylabel('number of conversations', fontsize=font_size)\n",
+    "    # plt.title('Distribution of Balance_Score with Preprocessing')\n",
+    "    plt.xticks(np.arange(0, 1.1, 0.05), fontsize=font_size-2)\n",
+    "    plt.yticks(fontsize=font_size - 2)\n",
+    "    plt.grid(axis='y', alpha=0.75)\n",
+    "    plt.ylim(0, 500)\n",
+    "    plt.xlim(0.5, 1.0)\n",
+    "\n",
+    "    plt.axvline(np.mean(balance_score), color='r', linestyle='--', linewidth=1, label='Mean')\n",
+    "    plt.axvline(np.percentile(balance_score, 25), color='g', linestyle='--', linewidth=1, label='25th percentile')\n",
+    "    plt.axvline(np.percentile(balance_score, 75), color='b', linestyle='--', linewidth=1, label='75th percentile')\n",
+    "\n",
+    "\n",
+    "    textstr = f'Mean: {np.mean(balance_score):.2f}\\nMedian: {np.median(balance_score):.2f}\\n25th percentile: {np.percentile(balance_score, 25):.2f}\\n75th percentile: {np.percentile(balance_score, 75):.2f}'\n",
+    "    props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n",
+    "    plt.text(0.95, 0.95, textstr, transform=plt.gca().transAxes, fontsize=font_size-2,\n",
+    "            verticalalignment='top', horizontalalignment='right', bbox=props)\n",
+    "    if y_up is not None:\n",
+    "        plt.ylim(0, y_up)\n",
+    "\n",
+    "    # plt.savefig(\"plots/balance-distribution.png\")\n",
+    "    plt.show()\n",
+    "\n",
+    "check_balance_distribution(corpus)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Categorize Based On Overall Conversation Balance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_convo_balance_type(corpus, convo_id):\n",
+    "    \"\"\"\n",
+    "    We categorize conversation into three types based on the balance score:\n",
+    "    - low_balance: balance score >= 0.65\n",
+    "    - mid_balance: balance score >= 0.55\n",
+    "    - high_balance: balance score >= 0.5\n",
+    "    The thresholds are chosen based on the distribution of balance scores, and \n",
+    "    can be changed to adapt to different datasets or research questions.\n",
+    "    \"\"\"\n",
+    "    convo = corpus.get_conversation(convo_id)\n",
+    "    if convo.meta[\"balance_score\"] >= 0.65:\n",
+    "        return 'low_balance'\n",
+    "    elif convo.meta[\"balance_score\"] >= 0.55:\n",
+    "        return 'mid_balance'\n",
+    "    elif convo.meta[\"balance_score\"] >= 0.5:\n",
+    "        return 'high_balance'\n",
+    "    else:\n",
+    "        return 'invalid'\n",
+    "\n",
+    "def annotate_conversation_balance_type(corpus):\n",
+    "    for convo in corpus.iter_conversations():\n",
+    "        convo.meta['balance_type'] = get_convo_balance_type(corpus, convo.id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annotate_conversation_balance_type(corpus)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "high_balance: 459, mid_balance: 750, low_balance: 385\n"
+     ]
+    }
+   ],
+   "source": [
+    "all_bt = [convo.meta['balance_type'] for convo in corpus.iter_conversations()]\n",
+    "print(f\"high_balance: {all_bt.count('high_balance')}, mid_balance: {all_bt.count('mid_balance')}, low_balance: {all_bt.count('low_balance')}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "low_balance_enjoy: 7.25, high_balance_enjoy: 7.53, mid_balance_enjoy: 7.42\n",
+      "High Balance vs. Low Balance P Value: 0.000444160452713879\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Add stats of speaker enjoyment score for each balance group, and show that mean is different using mann whitney u test (high vs low)\n",
+    "low_balance_enjoy = [sum(list(convo.meta['how_enjoyable'].values()))/2 for convo in corpus.iter_conversations() if convo.meta['balance_type'] == 'low_balance']\n",
+    "high_balance_enjoy = [sum(list(convo.meta['how_enjoyable'].values()))/2 for convo in corpus.iter_conversations() if convo.meta['balance_type'] == 'high_balance']\n",
+    "mid_balance_enjoy = [sum(list(convo.meta['how_enjoyable'].values()))/2 for convo in corpus.iter_conversations() if convo.meta['balance_type'] == 'mid_balance']\n",
+    "\n",
+    "print(f\"low_balance_enjoy: {round(np.mean(low_balance_enjoy), 2)}, high_balance_enjoy: {round(np.mean(high_balance_enjoy), 2)}, mid_balance_enjoy: {round(np.mean(mid_balance_enjoy), 2)}\")\n",
+    "u_statistic, p_value = mannwhitneyu(low_balance_enjoy, high_balance_enjoy, alternative='two-sided')\n",
+    "# print(\"U Statistic:\", u_statistic)\n",
+    "print(\"High Balance vs. Low Balance P Value:\", p_value)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Use FightingWords methods\n",
+    "# Plot fighting words adapted from https://gist.github.com/xandaschofield/3c4070b2f232b185ce6a09e47b4e7473\n",
+    "# from matplotlib import pyplot as plt\n",
+    "from sklearn.feature_extraction.text import CountVectorizer as CV\n",
+    "import string\n",
+    "\n",
+    "exclude = set(string.punctuation)\n",
+    "\n",
+    "# from https://github.com/jmhessel/FightingWords/blob/master/fighting_words_py3.py\n",
+    "def basic_sanitize(in_string):\n",
+    "    '''Returns a very roughly sanitized version of the input string.'''\n",
+    "    in_string = ''.join([ch for ch in in_string if ch not in exclude])\n",
+    "    in_string = in_string.lower()\n",
+    "    in_string = ' '.join(in_string.split())\n",
+    "    return in_string\n",
+    "\n",
+    "def bayes_compare_language(l1, l2, ngram = 1, prior=.01, cv = None):\n",
+    "    '''\n",
+    "    Arguments:\n",
+    "    - l1, l2; a list of strings from each language sample\n",
+    "    - ngram; an int describing up to what n gram you want to consider (1 is unigrams,\n",
+    "    2 is bigrams + unigrams, etc). Ignored if a custom CountVectorizer is passed.\n",
+    "    - prior; either a float describing a uniform prior, or a vector describing a prior\n",
+    "    over vocabulary items. If you're using a predefined vocabulary, make sure to specify that\n",
+    "    when you make your CountVectorizer object.\n",
+    "    - cv; a sklearn.feature_extraction.text.CountVectorizer object, if desired.\n",
+    "\n",
+    "    Returns:\n",
+    "    - A list of length |Vocab| where each entry is a (n-gram, zscore) tuple.'''\n",
+    "    if cv is None and type(prior) is not float:\n",
+    "        print(\"If using a non-uniform prior:\")\n",
+    "        print(\"Please also pass a count vectorizer with the vocabulary parameter set.\")\n",
+    "        quit()\n",
+    "    l1 = [basic_sanitize(l) for l in l1]\n",
+    "    l2 = [basic_sanitize(l) for l in l2]\n",
+    "    if cv is None:\n",
+    "        cv = CV(decode_error = 'ignore', min_df = 10, max_df = .5, ngram_range=(1,ngram),\n",
+    "                binary = False,\n",
+    "                max_features = 15000)\n",
+    "    counts_mat = cv.fit_transform(l1+l2).toarray()\n",
+    "    # Now sum over languages...\n",
+    "    vocab_size = len(cv.vocabulary_)\n",
+    "    print(\"Vocab size is {}\".format(vocab_size))\n",
+    "    if type(prior) is float:\n",
+    "        priors = np.array([prior for i in range(vocab_size)])\n",
+    "    else:\n",
+    "        priors = prior\n",
+    "    z_scores = np.empty(priors.shape[0])\n",
+    "    count_matrix = np.empty([2, vocab_size], dtype=np.float32)\n",
+    "    count_matrix[0, :] = np.sum(counts_mat[:len(l1), :], axis = 0)\n",
+    "    count_matrix[1, :] = np.sum(counts_mat[len(l1):, :], axis = 0)\n",
+    "    a0 = np.sum(priors)\n",
+    "    n1 = 1.*np.sum(count_matrix[0,:])\n",
+    "    n2 = 1.*np.sum(count_matrix[1,:])\n",
+    "    print(\"Comparing language...\")\n",
+    "    for i in range(vocab_size):\n",
+    "        #compute delta\n",
+    "        term1 = np.log((count_matrix[0,i] + priors[i])/(n1 + a0 - count_matrix[0,i] - priors[i]))\n",
+    "        term2 = np.log((count_matrix[1,i] + priors[i])/(n2 + a0 - count_matrix[1,i] - priors[i]))\n",
+    "        delta = term1 - term2\n",
+    "        #compute variance on delta\n",
+    "        var = 1./(count_matrix[0,i] + priors[i]) + 1./(count_matrix[1,i] + priors[i])\n",
+    "        #store final score\n",
+    "        z_scores[i] = delta/np.sqrt(var)\n",
+    "    index_to_term = {v:k for k,v in cv.vocabulary_.items()}\n",
+    "    sorted_indices = np.argsort(z_scores)\n",
+    "    return_list = []\n",
+    "    for i in sorted_indices:\n",
+    "        return_list.append((index_to_term[i], z_scores[i]))\n",
+    "    return return_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vocab size is 2476\n",
+      "Comparing language...\n",
+      "Fighting Words Comments between:\n",
+      "High Balance Conversations:  ['both', 'lot in common', 'were able', 'were able to', 'like we', 'lot in', 'about our', 'able', 'able to', 'we both']\n",
+      "Low Balance Conversations:  ['chat', 'he', 'partner', 'talked lot', 'listener', 'else', 'im', 'is', 'she', 'bring']\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fighting words between high and low balance groups - Table 2\n",
+    "# Switch the commands below to get the top k words for high balance and low balance for critical positive and negative\n",
+    "high_balance_comments = []\n",
+    "low_balance_comments = []\n",
+    "for convo in corpus.iter_conversations():\n",
+    "    if convo.meta['primary_speaker'] == None: continue\n",
+    "    if convo.meta['balance_type'] != None:\n",
+    "        if convo.meta['balance_type'] == \"high_balance\":\n",
+    "          high_balance_comments += list(convo.meta[\"critical_positive\"].values())\n",
+    "          # high_balance_comments += list(convo.meta[\"critical_negative\"].values())\n",
+    "        if convo.meta['balance_type'] == \"low_balance\":\n",
+    "          low_balance_comments += list(convo.meta[\"critical_positive\"].values())\n",
+    "          # low_balance_comments += list(convo.meta[\"critical_negative\"].values())\n",
+    "\n",
+    "z_scores = bayes_compare_language(high_balance_comments, low_balance_comments, ngram=3)  # notice that save_file function is commented above, no file will be saved unless changed\n",
+    "top_k = 10\n",
+    "top_k_class1 = list(reversed([(x[0], round(x[1],2)) for x in z_scores[-top_k:]]))\n",
+    "top_k_class2 = [(x[0], round(x[1],2)) for x in z_scores[:top_k]]\n",
+    "top_k_class1 = list(reversed([(x[0]) for x in z_scores[-top_k:]]))\n",
+    "top_k_class2 = [(x[0]) for x in z_scores[:top_k]]\n",
+    "print(f\"Fighting Words Comments between:\")\n",
+    "print(\"High Balance Conversations: \", top_k_class1)\n",
+    "print(\"Low Balance Conversations: \", top_k_class2)\n",
+    "print(\"\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "enjoyment_ps, enjoyment_ss = [], []\n",
+    "\n",
+    "balance_to_enjoyment = {}\n",
+    "\n",
+    "for convo in corpus.iter_conversations():\n",
+    "    if convo.meta['primary_speaker'] == None: continue\n",
+    "    enjoyment_ps.append(convo.meta['how_enjoyable'][convo.meta['speaker_group'][convo.meta['primary_speaker']]])\n",
+    "    enjoyment_ss.append(convo.meta['how_enjoyable'][convo.meta['speaker_group'][convo.meta['secondary_speaker']]])\n",
+    "\n",
+    "    cur_balance = convo.meta['balance_score']\n",
+    "    cur_balance = round((cur_balance * 100) / 5) * 5\n",
+    "    if cur_balance == None: continue\n",
+    "    if cur_balance not in balance_to_enjoyment.keys():\n",
+    "        balance_to_enjoyment.update({cur_balance : {\"ps\" : [], \"ss\" : []}})\n",
+    "    balance_to_enjoyment[cur_balance]['ps'].append(convo.meta['how_enjoyable'][convo.meta['speaker_group'][convo.meta['primary_speaker']]])\n",
+    "    balance_to_enjoyment[cur_balance]['ss'].append(convo.meta['how_enjoyable'][convo.meta['speaker_group'][convo.meta['secondary_speaker']]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "### Figure 3： We plot the percentage of speakers reporting maximum enjoyment (9) at each balance level\n",
+    "\n",
+    "selected = [9] # can be changed to [8, 9] or even more ratings\n",
+    "\n",
+    "def plot_percentage_speaker_high_enjoy_at_various_balance_level(balance_to_enjoyment, high_enjoy_score=selected, plot_name=None):\n",
+    "    balance_to_enjoyment_exp = {}\n",
+    "    for k, v in balance_to_enjoyment.items():\n",
+    "        balance_to_enjoyment_exp.update({k : {'ps' : 0, 'ss' : 0}})\n",
+    "        for kk, vv in v.items():\n",
+    "            balance_to_enjoyment_exp[k][kk] = percent_A_is_B(vv, high_enjoy_score)\n",
+    "\n",
+    "    x_values = [x for x in sorted(list(balance_to_enjoyment_exp.keys())) if x <  80] # below 85\n",
+    "    # x_values = [x for x in sorted(list(balance_to_enjoyment_exp.keys()))]\n",
+    "    ps_values = [balance_to_enjoyment_exp[x]['ps'] for x in x_values]\n",
+    "    ss_values = [balance_to_enjoyment_exp[x]['ss'] for x in x_values]\n",
+    "    x_length = [len(balance_to_enjoyment[x]['ps']) for x in x_values]\n",
+    "\n",
+    "    my_x_labels = [str(x/100) for x in x_values]\n",
+    "\n",
+    "    ps_values = [val * 100 for val in ps_values]\n",
+    "    ss_values = [val * 100 for val in ss_values]\n",
+    "\n",
+    "    font_size = 14\n",
+    "\n",
+    "    plt.figure(figsize=(10, 8))\n",
+    "    plt.plot(x_values, ps_values, label='Primary speaker', color='blue')  # Plot 'ps' values\n",
+    "    plt.plot(x_values, ss_values, label='Secondary speaker', color='red')  # Plot 'ss' values\n",
+    "    plt.legend(fontsize=font_size, loc =\"upper right\")\n",
+    "\n",
+    "    for i, label in enumerate(x_length):\n",
+    "        y_offset = max(ps_values[i], ss_values[i]) + 5  # dynamically calculate offset\n",
+    "        plt.text(x_values[i], y_offset, f\"N={label}\", ha='center', va='bottom', fontsize=font_size)\n",
+    "\n",
+    "    plt.xticks(ticks=x_values, labels=my_x_labels, fontsize=font_size - 2)\n",
+    "    # plt.title(f'Primary / Secondary Speaker High Enjoyment (9) percentage at each balance level')\n",
+    "    plt.xlabel('overall imbalance', fontsize=font_size)\n",
+    "    plt.ylabel('percentage of speakers reporting maximum enjoyment', fontsize=font_size)\n",
+    "    plt.yticks(fontsize=font_size-2)\n",
+    "    plt.ylim(0, 70)\n",
+    "    plt.legend()\n",
+    "    plt.grid(True)\n",
+    "\n",
+    "    if plot_name is not None:\n",
+    "        plt.savefig(plot_name)\n",
+    "\n",
+    "    # Show the plot\n",
+    "    plt.show()\n",
+    "\n",
+    "plot_percentage_speaker_high_enjoy_at_various_balance_level(balance_to_enjoyment, high_enjoy_score=selected)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vocab size is 1083\n",
+      "Comparing language...\n",
+      "Fighting Words of critical_negative Comments between:\n",
+      "Primary Speakers:  [('her', np.float64(4.53)), ('little', np.float64(3.73)), ('too much', np.float64(3.59)), ('we had', np.float64(3.25)), ('flow', np.float64(3.17)), ('talked too', np.float64(3.09)), ('should', np.float64(2.79)), ('she was', np.float64(2.66)), ('she is', np.float64(2.64)), ('shy', np.float64(2.51))]\n",
+      "Secondary Speakers:  [('different', np.float64(-3.23)), ('hard', np.float64(-3.07)), ('say', np.float64(-2.94)), ('went', np.float64(-2.77)), ('the conversation was', np.float64(-2.76)), ('talked lot', np.float64(-2.75)), ('life', np.float64(-2.69)), ('honestly', np.float64(-2.67)), ('didnt', np.float64(-2.64)), ('kept', np.float64(-2.64))]\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fighting words between Primary and Secondary Speaker - Table 3\n",
+    "n_gram = 3\n",
+    "comments_type = \"critical_negative\"  # or \"critical_positive\"\n",
+    "balance_type = \"low_balance\"  # or \"high_balance\", \"low_balance\", \"mid_balance\"; None is don't wanna filter by balance\n",
+    "\n",
+    "primary_sp_comments = []\n",
+    "secondary_sp_comments = []\n",
+    "for convo in corpus.iter_conversations():\n",
+    "    if convo.meta['primary_speaker'] == None: continue\n",
+    "    if balance_type != None:\n",
+    "        if convo.meta['balance_type'] != balance_type: continue\n",
+    "    primary_sp_comments.append(convo.meta[comments_type][convo.meta['speaker_group'][convo.meta['primary_speaker']]])\n",
+    "    secondary_sp_comments.append(convo.meta[comments_type][convo.meta['speaker_group'][convo.meta['secondary_speaker']]])\n",
+    "\n",
+    "z_scores = bayes_compare_language(primary_sp_comments, secondary_sp_comments, ngram = n_gram)  # notice that save_file function is commented above, no file will be saved unless changed\n",
+    "top_k = 10\n",
+    "top_k_class1 = list(reversed([(x[0], round(x[1],2)) for x in z_scores[-top_k:]]))\n",
+    "top_k_class2 = [(x[0], round(x[1],2)) for x in z_scores[:top_k]]\n",
+    "print(f\"Fighting Words of {comments_type} Comments between:\")\n",
+    "print(\"Primary Speakers: \", top_k_class1)\n",
+    "print(\"Secondary Speakers: \", top_k_class2)\n",
+    "print(\"\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Primary and secondary speakers enjoyment difference Statistics=381024.000, p=0.000431\n"
+     ]
+    }
+   ],
+   "source": [
+    "# We notice primary and secondary speakers enjoy conversations differently, we do Wilcoxon T-test to check if the difference in distribution of primary / secondary speakers' enjoyment ratings is significant.\n",
+    "# Statistical Test Showing Enjoyment Difference between Primary and Secondary Speaker\n",
+    "stat, p_value = wilcoxon(enjoyment_ps, enjoyment_ss, alternative=\"greater\")\n",
+    "print('Primary and secondary speakers enjoyment difference Statistics=%.3f, p=%.6f' % (stat, p_value))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "### Figure 4 - A Example plot of a individual conversation's talk-time sharing dynamics\n",
+    "plot_single_conversation_balance(corpus, \"a7b14ca1-0b36-42b9-ad4a-50f0eb094035\", window_ps_threshold, window_size, sliding_size, remove_first_last_utt, min_utt_words)\n",
+    "# convo = corpus.get_conversation(\"a7b14ca1-0b36-42b9-ad4a-50f0eb094035\")\n",
+    "# print(f\"red : {round(convo.meta['percent_red'], 2)}, blue : {round(convo.meta['percent_blue'], 2)}, gray : {round(convo.meta['percent_gray'], 2)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Classify Conversations into Triangle Categories"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def floor_lst_parts_percentages(lst):\n",
+    "    count_1 = lst.count(1)\n",
+    "    count_0 = lst.count(0)\n",
+    "    count_neg1 = lst.count(-1)\n",
+    "    total_elements = len(lst)\n",
+    "\n",
+    "    percent_1 = (count_1 / total_elements) * 100\n",
+    "    percent_0 = (count_0 / total_elements) * 100\n",
+    "    percent_neg1 = (count_neg1 / total_elements) * 100\n",
+    "\n",
+    "    return percent_1, percent_0, percent_neg1\n",
+    "\n",
+    "def annotate_convo_RGB_percent(corpus):\n",
+    "    for convo in corpus.iter_conversations():\n",
+    "        percent_1, percent_0, percent_neg1 = floor_lst_parts_percentages(convo.meta['balance_lst'])\n",
+    "        convo.meta['percent_blue'] = percent_1\n",
+    "        convo.meta['percent_gray'] = percent_0\n",
+    "        convo.meta['percent_red'] = percent_neg1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annotate_convo_RGB_percent(corpus)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A structured Space of Talk-Time Sharing Dynamics\n",
+    "\n",
+    "We identify three stereotypes: dominating throughout, back-and-forth, and alternate in dominating. The threshold are picked based on data distributions, and can be adapted to different settings and research questions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Triangle 1: (Blue) Dominating Throughout\n",
+    "\n",
+    "Here, we define dominating throughout type conversation as having more than 75% of windows as blue windows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_type_dominating_throughout(balance_lst, dominating_throughout_threshold=75):\n",
+    "    if balance_lst == []: return \"invalid\"\n",
+    "    count_ones = balance_lst.count(1)\n",
+    "    percent_ones = (count_ones / len(balance_lst)) * 100\n",
+    "    count_neg_ones = balance_lst.count(-1)\n",
+    "    percent_neg_ones = (count_neg_ones / len(balance_lst)) * 100\n",
+    "    return percent_ones >= dominating_throughout_threshold or percent_neg_ones >= dominating_throughout_threshold"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Number of Dominating Throughout Conversations: 295'"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type_dominating_through = [convo.id for convo in corpus.iter_conversations() if get_type_dominating_throughout(convo.meta['balance_lst'])]\n",
+    "f\"Number of Dominating Throughout Conversations: {len(type_dominating_through)}\" "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Triangle 2: (Gray) Back and Forth\n",
+    "\n",
+    "We define back and forth type conversation as having more than 60% of windows as gray windows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_type_back_and_forth(balance_lst, back_and_forth_threshold=60):\n",
+    "    if balance_lst == []: return \"invalid\"\n",
+    "    count_zeros = balance_lst.count(0)\n",
+    "    percent_zeros = (count_zeros / len(balance_lst)) * 100\n",
+    "    return percent_zeros >= back_and_forth_threshold"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Number of Dominating Throughout Conversations: 251'"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type_back_and_forth = [convo.id for convo in corpus.iter_conversations() if get_type_back_and_forth(convo.meta['balance_lst'])]\n",
+    "f\"Number of Dominating Throughout Conversations: {len(type_back_and_forth)}\" "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Triangle 3: (Red) Alternating Dominance\n",
+    "\n",
+    "We define alternating dominance as having more than 25% of windows as red windows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_type_alter_dominance(balance_lst, red_threshold=25):\n",
+    "    if balance_lst == []: return \"invalid\"\n",
+    "    count_neg1 = balance_lst.count(-1)\n",
+    "    total_elements = len(balance_lst)\n",
+    "    percent_neg1 = (count_neg1 / total_elements) * 100\n",
+    "    return percent_neg1 > red_threshold"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Number of Dominating Throughout Conversations: 96'"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type_interleave = [convo.id for convo in corpus.iter_conversations() if get_type_alter_dominance(convo.meta['balance_lst']) and not get_type_dominating_throughout(convo.meta['balance_lst'])]\n",
+    "f\"Number of Dominating Throughout Conversations: {len(type_interleave)}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Annotate Convo Triangle Types\n",
+    "def annotate_convo_triangle_types(corpus):\n",
+    "    count1, count2, count3, count4 = 0, 0, 0, 0\n",
+    "    three_types_dict = {'dominating_throughout' : [], 'back_and_forth' : [], 'alter_dominance' : [], 'no_label' : []}\n",
+    "    for convo in corpus.iter_conversations():\n",
+    "        balance_lst = convo.meta['balance_lst']\n",
+    "        if get_type_dominating_throughout(balance_lst):\n",
+    "            convo.meta['triangle_type'] = 'dominating_throughout'\n",
+    "            count1 += 1\n",
+    "            three_types_dict['dominating_throughout'].append(convo.id)\n",
+    "        elif get_type_back_and_forth(balance_lst):\n",
+    "            convo.meta['triangle_type'] = \"back_and_forth\"\n",
+    "            count2 += 1\n",
+    "            three_types_dict['back_and_forth'].append(convo.id)\n",
+    "        elif get_type_alter_dominance(balance_lst):\n",
+    "            convo.meta['triangle_type'] = 'alter_dominance'\n",
+    "            count3 += 1\n",
+    "            three_types_dict['alter_dominance'].append(convo.id)\n",
+    "        else:\n",
+    "            convo.meta['triangle_type'] = None\n",
+    "            count4 += 1\n",
+    "            three_types_dict['no_label'].append(convo.id)\n",
+    "    print(f\"Triangle Typology: dominating_throughout: {count1}, back_and_forth: {count2}, alter_dominance: {count3}, no_label: {count4}\")\n",
+    "    return three_types_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Triangle Typology: dominating_throughout: 295, back_and_forth: 251, alter_dominance: 96, no_label: 952\n"
+     ]
+    }
+   ],
+   "source": [
+    "three_types_dict = annotate_convo_triangle_types(corpus)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_convo_balance_for_convo_lst(corpus, convo_id_lst):\n",
+    "    return np.mean([corpus.get_conversation(convo_id).meta[f'balance_score'] for convo_id in convo_id_lst])\n",
+    "\n",
+    "def get_convo_avg_color_for_convo_lst(corpus, convo_id_lst, color):\n",
+    "    return np.mean([corpus.get_conversation(convo_id).meta[f'percent_{color}'] for convo_id in convo_id_lst])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Enjoyment score at different stereotypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "mean conversation level imbalance for dominating_throughout: 0.719\n",
+      "mean conversation level imbalance for back_and_forth: 0.536\n",
+      "mean conversation level imbalance for alter_dominance: 0.527\n",
+      "mean conversation level imbalance for no_label: 0.592\n",
+      "\n",
+      "average color percent for dominating_throughout: Blue: 87.455%, Red : 1.046%, Gray : 11.499%\n",
+      "average color percent for back_and_forth: Blue: 22.536%, Red : 6.699%, Gray : 70.765%\n",
+      "average color percent for alter_dominance: Blue: 36.138%, Red : 30.774%, Gray : 33.088%\n",
+      "average color percent for no_label: Blue: 50.178%, Red : 9.164%, Gray : 40.658%\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Overall Balance Across stereotypes\n",
+    "for k, v in three_types_dict.items():\n",
+    "    print(f\"mean conversation level imbalance for {k}: {round(get_convo_balance_for_convo_lst(corpus, v), 3)}\")\n",
+    "print()\n",
+    "for k, v in three_types_dict.items():\n",
+    "    print(f\"average color percent for {k}: Blue: {round(get_convo_avg_color_for_convo_lst(corpus, v, 'blue'), 3)}%, Red : {round(get_convo_avg_color_for_convo_lst(corpus, v, 'red'), 3)}%, Gray : {round(get_convo_avg_color_for_convo_lst(corpus, v, 'gray'), 3)}%\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "highly_balanced: percent: 31.8083%, mean convo-level imbalance score: 7.5316, N of convo = 459\n",
+      "highly_imbalanced: percent: 25.3247%, mean convo-level imbalance score: 7.2468, N of convo = 385\n",
+      "\n",
+      "U Statistic: 391418.0\n",
+      "P Value: 8.992704770891266e-05\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Enjoyment difference between high-balance / high-imbalance conversations\n",
+    "def get_speaker_max_enjoy_percent_convo_lst(corpus, convo_id_lst):\n",
+    "    # Here max enjoyment is 9\n",
+    "    enjoy = []\n",
+    "    for convo_id in convo_id_lst:\n",
+    "        convo = corpus.get_conversation(convo_id)\n",
+    "        enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "    if len(enjoy) == 0:\n",
+    "        return \"no convo\"\n",
+    "    return enjoy, round(enjoy.count(9) / len(enjoy), 6)*100, round(np.mean(enjoy), 4)\n",
+    "\n",
+    "highly_balanced = [convo.id for convo in corpus.iter_conversations() if convo.meta['balance_type'] == 'high_balance']\n",
+    "highly_imbalanced = [convo.id for convo in corpus.iter_conversations() if convo.meta['balance_type'] == 'low_balance']\n",
+    "\n",
+    "balance_enjoy, balance_percent, balance_mean = get_speaker_max_enjoy_percent_convo_lst(corpus, highly_balanced)\n",
+    "imbalance_enjoy, imbalance_percent, imbalance_mean = get_speaker_max_enjoy_percent_convo_lst(corpus, highly_imbalanced)\n",
+    "\n",
+    "print(f\"highly_balanced: percent: {balance_percent}%, mean convo-level imbalance score: {balance_mean}, N of convo = {len(highly_balanced)}\")\n",
+    "print(f\"highly_imbalanced: percent: {imbalance_percent}%, mean convo-level imbalance score: {imbalance_mean}, N of convo = {len(highly_imbalanced)}\\n\")\n",
+    "\n",
+    "u_statistic, p_value = mannwhitneyu(balance_enjoy, imbalance_enjoy, alternative='two-sided')\n",
+    "print(\"U Statistic:\", u_statistic)\n",
+    "print(\"P Value:\", p_value)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Overall balance distribution across two balanced categories"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "mean convo-level imbalance score across stereotypes:\n",
+      "\tinterleave: 0.527, backforth: 0.536, dominate: 0.72\n",
+      "\n",
+      "mean enjoyment score across stereotypes:\n",
+      "\tinterleave: 7.79, backforth: 7.26, dominate: 7.2\n",
+      "\n",
+      "mann whitney u-test between back-and-forth and alternating-dominance:\n",
+      "\tU Statistic: 58215.0\n",
+      "\tP Value: 1.2633561981776604e-05\n",
+      "\n",
+      "mann whitney u-test between back-and-forth and dominating-throughout:\n",
+      "\tU Statistic: 149013.5\n",
+      "\tP Value: 0.8554813347177187\n"
+     ]
+    }
+   ],
+   "source": [
+    "interleave_balance = [corpus.get_conversation(idx).meta['balance_score'] for idx in three_types_dict['alter_dominance']]\n",
+    "backforth_balance = [corpus.get_conversation(idx).meta['balance_score'] for idx in three_types_dict['back_and_forth']]\n",
+    "dominate_balance = [corpus.get_conversation(idx).meta['balance_score'] for idx in three_types_dict['dominating_throughout']]\n",
+    "\n",
+    "print(\"mean convo-level imbalance score across stereotypes:\")\n",
+    "print(f\"\\tinterleave: {round(np.mean(interleave_balance),3)}, backforth: {round(np.mean(backforth_balance), 3)}, dominate: {round(np.mean(dominate_balance), 2)}\\n\")\n",
+    "\n",
+    "interleave_enjoy = []\n",
+    "for idx in three_types_dict['alter_dominance']:\n",
+    "  convo = corpus.get_conversation(idx)\n",
+    "  interleave_enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "backforth_enjoy = []\n",
+    "for idx in three_types_dict['back_and_forth']:\n",
+    "  convo = corpus.get_conversation(idx)\n",
+    "  backforth_enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "dominate_enjoy = []\n",
+    "for idx in three_types_dict['dominating_throughout']:\n",
+    "  convo = corpus.get_conversation(idx)\n",
+    "  dominate_enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "\n",
+    "print(\"mean enjoyment score across stereotypes:\")\n",
+    "print(f\"\\tinterleave: {round(np.mean(interleave_enjoy), 2)}, backforth: {round(np.mean(backforth_enjoy), 2)}, dominate: {round(np.mean(dominate_enjoy), 1)}\\n\")\n",
+    "\n",
+    "print(\"mann whitney u-test between back-and-forth and alternating-dominance:\")\n",
+    "u_statistic, p_value = mannwhitneyu(interleave_enjoy, backforth_enjoy, alternative='two-sided')\n",
+    "print(\"\\tU Statistic:\", u_statistic)\n",
+    "print(\"\\tP Value:\", p_value)\n",
+    "\n",
+    "print(\"\\nmann whitney u-test between back-and-forth and dominating-throughout:\")\n",
+    "u_statistic, p_value = mannwhitneyu(backforth_enjoy, dominate_enjoy, alternative='two-sided')\n",
+    "print(\"\\tU Statistic:\", u_statistic)\n",
+    "print(\"\\tP Value:\", p_value)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAALPCAYAAACOgDpqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAp79JREFUeJzs3Qd8U9X7+PGnZZW9kQ1li8gGkT0EBEGWICh7ihNBBPyJgIAMQdwgsoeAiCzZey/ZKiCyZe/dMpr/6znf/41JmpY2TaFNPu/XK01y78nNSZqbm+eec54TYLPZbAIAAAAAiJHAmD0cAAAAAKAIrgAAAADACwiuAAAAAMALCK4AAAAAwAsIrgAAAADACwiuAAAAAMALCK4AAAAAwAsIrgAAAADACwiuAAAAAMALCK4AAAAAwB+Cq7lz50rNmjUlffr0EhQUJMHBwdKiRQs5deqUU7kbN25I9+7dJVeuXJIkSRLJnTu39OzZU27duvXE6g4AAADAfwTYbDabxEFarTfeeEPGjh0refPmldq1a0vKlCnlzJkzsm7dOpk+fbpUrFjRlL19+7a5vWfPHqlVq5aUKFFCdu/eLcuXL5cyZcrI+vXrTWAGAAAAALElocRRX3/9tQms3nzzTXM7QYIETusfPHhgvz18+HATWPXq1UuGDh1qX967d28ZNmyYjBo1Svr06fNY6w8AAADAv8TJlqu7d+9KtmzZJG3atHLo0CFJmDDiGFCrnz17dtMt8Ny5c5I8eXL7Om3Rypw5s2TKlEmOHDnymGoPAAAAwB/FyZYr7c539epVadeunTx8+FAWLFggf//9t6RJk0ZeeOEFyZcvn73s4cOHTVdB7TboGFgpvV+hQgVZtmyZGaOVI0eOJ/BqAAAAAPiDOBlc7dy501xrV8CiRYuawMoSGBgo77//vowYMcIeXKn8+fO73ZYu1+BKy0UUXIWGhpqLJSwsTK5cuWKSaAQEBHj1tQEAAACIP7Sn3M2bNyVr1qwmFol3wdWFCxfM9RdffCElS5aU7du3y9NPP22SVHTu3FlGjhxpklx07dpVrl+/bsqmTp3a7bZSpUplrq1y7gwZMkQGDBgQK68FAAAAQPynPeF0OFK8C6605UglTpxY5s2bZ6JEValSJZk9e7YUK1bMBFgaXHmDJrvQNO4WDcRy5swpx44dMxkK/dH9+/dlzZo1Uq1aNUmUKNGTrg7gM9i3gNjBvgXEDvYtMa1WOh1UVOKCOBlcWa1QpUuXtgdWliJFikiePHnkn3/+kWvXrtnLRtQypYkuHLfpjs6LpRdX6dKls7d8+eOOlCxZMtM10l93JCA2sG8BsYN9C4gd7Ftif91RGS4UJycRLliwoLnWBBbuWMs1q6A11soae+XqUWOyAAAAAMAb4mTLlTY7qgMHDriNnrXVSjMBZsyY0aRa19atTZs2mdTrrqnYdbk245EpEAAAAEBsipMtV5qsolatWiaIGjdunNM6nSRYuwM2atTIzH+lzXMdO3aUW7duycCBA53K6n1d3qlTp8f8CgAAAAD4mzjZcqW+//57KV++vAmMNKlFoUKFTLbA1atXS65cueTzzz+3l/3www9l/vz5MmzYMFNGMwzu2rXLzJdVpkwZ6dat2xN9LQAAAAB8X5xsubJar37//Xdp27atmffq66+/NuOn3nrrLZOaXbsDWrQr4Lp160wQpV0JNZPgwYMHpUePHrJq1SpJmjTpE30tAAAAAHxfnG25UjpOauLEiVEqq9kAR40aZS4AAAAA8LjF2ZYrAAAAAIhPCK4AAAAAwAsIrgAAAADACwiuAAAAAMALCK4AAAAAwAsIrgAAAADACwiuAAAAAMALCK4AAAAAwAsIrgAAAADACwiuAAAAAMALCK4AAAAA4EkFVydPnpQrV648stzVq1dNWQAAAADwdR4FV8HBwdKzZ89Hlvvwww8lT548njwFAAAAAPh+cGWz2cwlqmUBAAAAwNfF6pirS5cuSdKkSWPzKQAAAAAgTkgY1YLr1693un/u3LlwyywPHjyQQ4cOybJly+SZZ56JeS0BAAAAwFeCq6pVq0pAQID9vgZOeomsO6CW79GjR8xrCQAAAAC+Ely1bt3aHlxNnjxZ8ubNKxUqVHBbNnHixJI1a1apX7++lCxZ0nu1BQAAAID4HlxNmjTJfluDq4oVK8qECRNiq14AAAAA4JvBlaOwsDDv1wQAAAAA4rFYzRYIAAAAAP7Co5YrFRoaKjNmzDAZA8+ePWvuu6PjtFatWhWTOgIAAACAbwZXp0+flho1asjhw4cfOUmwY4ZBAAAAAPBVHgVXPXv2lL///lvKly8v3bt3lwIFCkjKlCm9XzsAAAAA8OXgSue3ypkzp6xcuVKCgoK8XysAAAAA8IeEFjq+6rnnniOwAgAAAICYBFfPPvusXLp0yZOHAgAAAIBP8ii46tWrl8kSuH37du/XCAAAAAD8ZcxVyZIlTSILzRio1zVr1pTs2bNLYKD7WE3HZwEAAACAL/MouMqdO7dJsa5p2AcNGmQuEdFyDx48iEkdAQAAAMA3g6vKlSszfxUAAAAAxDS4Wrt2rScPAwAAAACf5VFCCwAAAACAF1quXB0+fNikZk+fPr0UKFDAG5sEAAAAAP9oudKJhD/66CPJkCGDFCpUSCpWrChDhw61r582bZrJKrhnzx5v1RUAAAAAfCu4unv3rlStWlWGDRsmiRMnlrp165rMgY6qV68ue/fulZ9//tlbdQUAAAAA3wquhg8fLtu2bZP27dvL0aNHZeHCheHKZM2aVQoXLiwrV670Rj0BAAAAwPeCq1mzZpmJgUePHi1BQUERlitYsKCcOnUqJvUDAAAAAN8Nro4dOyalS5eWhAkjz4ehXQavXr3qad0AAAAAwLeDq6RJk0YpaNIgLG3atJ48BQAAAAD4fnBVvHhx+f333+XixYuRBla7d++WMmXKxKR+AAAAABAveBRcderUSW7evCktWrQw81u5unbtmkl2cf/+fencubM36gkAAAAAvjeJsAZVmiFw5syZkidPHilfvrxZvmnTJmnQoIGsW7dObty4Ia1bt5Z69ep5u84AAAAA4DuTCE+fPt3Mc6XZApcvX26WHT582ARdAQEBMnjwYJk4caI36woAAAAAvtVypTSA6tmzp3Tv3l127dolx48fl7CwMMmePbsZZ6WZAgEAAADAX3gcXFkSJEhggikSVwAAAADwZx53CwQAAAAAeKHlKjQ01CS00OQVZ8+eNfcj6j64atUqT58GAAAAAHw3uDp58qS88MILcuTIEbHZbJGW1eAKAAAAAHydR8HVu+++K//8849Ur15d3nvvPZOOPUWKFN6vHQAAAAD4cnCl3fzy588vS5culYQJY5wTAwAAAAD8M6GFplkvWbIkgRUAAAAAxCS4Kl++vOkWCAAAAACIQXA1YMAAOXDggPz444+ePBwAAAAAfI5H/fq0S+Dy5culZcuWMm3aNKlVq5Zky5ZNAgPdx2qtW7eOaT0BAAAAIE7zeNDUihUr5MKFC3L8+HHZuHGj2zKapl1TsRNcAQAAAPB1HgVXn3/+uekamCRJEmnUqBGp2AEAAAD4PY+Cq9GjR0uqVKlk27ZtUrBgQe/XCgAAAAD8IaHFuXPnpEqVKgRWAAAAABCT4Cpv3rwSFhbmyUMBAAAAwCd5FFy98cYbsmbNGpPMAgAAAADgYXD11ltvSefOnaVSpUoyadIkOX36tPdrBgAAAAC+ntAiQYIE9lTrHTp0iLSspmJ/8OCBZ7UDAAAAAF8OrnLkyGGCJgAAAABADIIrxloBAAAAgBfGXAEAAAAAvBBcTZ48WUJCQjx5KAAAAAD4JI+Cq3bt2knWrFnlnXfekb1793q/VgAAAADgD8FVx44dTQbA7777TkqWLCnlypWT8ePHy+3bt71fQwAAAADw1eBq7NixcvbsWXNdpkwZ2b59u5n3SluzdILh33//3fs1BQAAAABfTGiRPHly04K1detW2bdvn5lYOGHChCbgeu6556REiRIyZswYuXHjhndrDAAAAAC+mi2wSJEi8vXXX8uZM2dk2rRpUrlyZTMWSwMubc3SiYZ37tzpjacCAAAAAN9PxX7//n25efOmuSibzWaWTZw4UcqWLSuvvPKKXLt2zZtPCQAAAAC+E1xp10BtncqSJYu8+eabpptg48aNZfny5aZb4PTp0+XZZ5+VuXPnyrvvvuuNpwQAAACAOCWhpw+8evWqTJ06VX788Uf566+/TCtVjhw5pFevXmYsVubMme1lW7RoIU2bNjXjsBYvXuytugMAAABA/A6uWrZsKb/++quEhoZKQECA1KlTx2QJrFu3rgQGum8M02QXmllQJyAGAAAAAF/jUXD1008/mZap9u3bmxTsOXPmjNLjGjVqJLly5fLkKQEAAADA94Kr2bNnS4MGDUxrVHTUr1/fXAAAAADA13gUXDVp0sT7NQEAAAAAf0xooe7duydz5syRDRs2yOnTp82ybNmySaVKlUwAljhxYm/VEwAAAAB8M7jatGmTvPbaa/Lvv/+aTIGOfvjhB+ndu7fMmDFDypcv7416AgAAAIDvBVd///23yRB469YtKVWqlMkemDt3bpM58Pjx4yZF+86dO032wB07dkj+/Pm9X3MAAAAAiO/B1eDBg01gNWrUKHnvvffCrdeJgr/++mvp1q2bKTtp0iRv1BUAAAAA4iz3k1I9wqpVq8yEwO4CK8cAS8usXLkyJvUDAAAAAN8Nri5evCiFChV6ZDktc+nSJU+eAgAAAAB8P7hKnz69HDp0KEpjs9KlS+fJUwAAAACA7wdX1apVk927d8uYMWMiLPPjjz+apBbVq1ePSf0AAAAAwHcTWnz88ccyb948eeutt2T69OkmJbtmC1QnTpwwKdg3btwoyZIlk//7v//zdp0BAAAAwDeCq6effloWLFggr7/+upnvavPmzU7rdd6rp556ygReWtYTGqxpoOZOlSpVZO3atU7LQkNDZdiwYSYN/KlTp0x3xHr16smgQYMkU6ZMHtUBAAAAAGJ9EuEaNWrI0aNH5eeff5YNGzbImTNnzPKsWbNKpUqVpFmzZqblKiZSp05t0rm7slrJLGFhYdKgQQNZtmyZlCtXTpo0aSKHDx+WcePGmcyGW7dulYwZM8aoLgAAAAAQK8GV0uCpbdu25hIb0qRJI/37939kucmTJ5vAqkWLFqa1TCczVjomrGvXrqYb4w8//BArdQQAAAAAjxNaxDWaPEMNGTLEHlipLl26SJ48eUzAdffu3SdYQwAAAAC+LkotVydPnjTX2bJlkwQJEtjvR4UGO9rCpenbo0vHUU2aNMl0OUyVKpWUKVNGnnvuOacyISEhsm3bNilYsKDkypUr3HPXrFnTtFr9/vvvprtiRM+jF8uNGzfM9f37983FH1mv219fPxBb2LeA2MG+BcQO9i2J1muPUnClY5wCAwPlr7/+kgIFCpj7ji1EUR0/pVkFP//8c0maNGmUHnPu3Dlp166d0zINsDQbYd68ec39I0eOmDFX+fPnd7sNa7mOwYoouNIWrwEDBoRbvnz58hiPG4vvVqxY8aSrAPgk9i0gdrBvAbHDn/etO3fueDe4qly5sr0FyvF+VGmXvIMHD8ro0aPl4cOH5vpRNKjSYKhIkSKSIkUKMyHxF198YbIBajKN/fv3S8qUKeX69ev24M0dbfFSVjl3+vTpI927d3dqucqRI4fUqlXL/nh/jNB1J9KWv0SJEj3p6gA+g30LiB3sW0DsYN8Se682rwVXrmnPXe9Hxa1bt6RYsWIyd+7cKAVX/fr1c7pfvHhxmTJlirmtAZaOs3IMiGIiSZIk5uJKP0D++iGy8B4AsYN9C4gd7FtA7PDnfStRNF73Y0tooa1Pmib94sWLMdqOJqlQOr+WY4tVRC1TVqQZUcsWAAAAAMS7bIE679SVK1ditI0MGTKY69u3b5trzQao48F0TJU71vKIxmQBAAAAwBOf5+rYsWNmAuGzZ886ZdtzpGOz+vbta25rIouoJrOIiGYGdJxIWLdXtmxZM1HwiRMnnDIG2mw200c0efLkUrp06Rg9LwAAAAB4Pbi6d++edOzY0cwfZQUxEXEMrqJKk1/kzJkzXKY+Xd6rVy9zWzMPWjp37myCK01M4TiJsKZgP3r0qFkf06AOAAAAALweXH3yyScybdo0SZMmjbRs2dKkZ9fMfd4yc+ZMkxlQsxJqS5S2PGm2wMWLF5uMJRpE6TpLmzZtZNasWSZFu7amValSRf755x/59ddfJTg4WAYNGuS1ugEAAACA14Krn376yQRWu3fvDjdxrzdUq1ZNDhw4YLav3Q41t7yOtapbt668+eabJkW6Ix1zNX/+fBk6dKjJJDhq1ChJly6ddOjQwQRWGTNm9HodAQAAACDGwdWFCxekdu3asRJYKW150kt0aCp1Td/umsIdAAAAAOJstsDYCqoAAAAAwK+Cq/bt25uJhGM6ZxUAAAAA+HVw1bNnT6lTp44ZG7VmzZpIswUCAAAAgD/waMxVvnz5zLXOK/XCCy9IokSJJHPmzCaxhCtNi37kyJGY1xQAAAAAfC24On78eLh5r06ePOmtOgEAAACAfwRXYWFh3q8JAAAAAPjbmCsAAAAAgDOCKwAAAAB40sHV8uXLpVGjRpItWzYziW+HDh3s65YtWybdu3eXM2fOeKOeAAAAAOCbwdV7771n0rHPnz9fbt68Kffv33dKyZ4lSxb58ssvZdasWd6qKwAAAAD4VnA1ZcoU+eabb6RUqVKya9cuuXHjRrgyRYsWlRw5csjChQu9UU8AAAAA8L1sgaNHj5Y0adLIokWLJGPGjBGW0wBr//79MakfAAAAAPhuy9Uff/wh5cuXjzSwUqlTp5bz5897WjcAAAAA8P0xVwEBAY8so8kskiZN6ulTAAAAAIBvB1f58+c3Y600iUVENMnFnj175JlnnolJ/QAAAADAd4Orpk2bytmzZ6V3794RlunTp49cv35dmjdvHpP6AQAAAIDvJrTo1q2bzJw506Ra37x5szRo0MAsP3LkiIwaNUrmzp0rGzdulJIlS0qnTp28XWcAAAAA8I3gSsdRrVy5Utq2bStLliyR7du3m+UbNmwwF1WzZk2ZNm2aJE6c2Ls1BgAAAABfCa6UZgrUVOx79+6V5cuXy/HjxyUsLEyyZ89uAquyZct6t6YAAAAA4IvBlaVYsWLmAgAAAAD+zONU7AAAAACA/xBcAQAAAIAXEFwBAAAAgBcQXAEAAACAFxBcAQAAAIAXEFwBAAAAgBcQXAEAAACAFxBcAQAAAMCTnET44sWL8v3338u6devk7NmzEhoa6rZcQECAHDlyJCZ1BAAAAADfDK72798v1atXlytXrojNZvN+rQAAAADAH7oFvvfee3L58mVp2bKl7N27V27evClhYWERXgAAAADA13nUcrVt2zYpWrSoTJ482fs1AgAAAAB/ablKkSKFFC5c2Pu1AQAAAAB/Cq50vJV2BwQAAAAAxCC4GjRokMkW+PHHH8vDhw892QQAAAAA+BSPxlzlzZtXNm/eLA0aNJBZs2ZJ1apVJVu2bBIYGOg2FXvfvn29UVcAAAAA8K3g6v79+zJ48GA5ePCgScUe2TxWBFcAAAAA/IFHwZV2B9RMgU899ZS89tprkidPHpPkAgAAAAD8lUfB1fTp0yVjxowmqUWmTJm8XysAAAAA8IeEFlevXpVKlSoRWAEAAABATIKrZ555Rm7evOnJQwEAAADAJ3kUXPXo0UPWrFkju3fv9n6NAAAAAMBfxlw9//zz8vbbb5sU7O+//77UrFkzwlTsKmfOnDGtJwAAAAD4XnCVO3duk2Jd07APHDjQXCKi5R48eBCTOgIAABjjNhyVcRuOhVtuE5uEhCSQz/5cJwESEG59x0rB0rFSnsdUSwD+yqPgqnLlyiZoAgAAeJxuhjyQczdCIlgbINfvhUb4OACIk8HV2rVrvV8TAACAR0gZlFAypwoK12p1/sb/gqpMKZNIoJsTwPo4AIhtfNMAAIB4Q7v2uXbvu3PvgRT+ZJm5vaJbBUmdPOkTqh0Af+dRtkAAAAAAgBdarj799NMol9WxWX379vXkaQAAAADAt4Or/v3727MFumMlu9D1BFcAAAAA/IFHwdXEiRPdLg8LC5NTp07JihUrZNOmTfLWW29J6dKlY1pHAAAAAPDN4KpNmzaRrv/kk09k+PDhpvtg586dPa0bAAAAAMQbsZbQ4sMPP5Ts2bPLRx99FFtPAQAAAAD+kS3w2WeflY0bN8bmUwAAAACA7wdXR44ckQcPmBEdAAAAgO+LleDq6tWr0qNHD9mzZ4+ULVs2Np4CAAAAAOJ/Qos8eZxnRnd069YtuXz5sknDnjRpUhkyZEhM6gcAAAAAvhtcHT9+PMJ1iRIlkhw5ckiVKlWkV69eUrhw4ZjUDwAAAAB8N7jS+awAAAAAAI8poQUAAAAA+AuCKwAAAAB4Ut0CHcderV+/Xs6ePSuhoaFuywQEBEjfvn1j8jQAAAAA4JvBVUhIiHTq1El++uknc18zA0aE4AoAAACAP/AouNIsgNOnT5dMmTLJ66+/blKzp0iRwvu1AwAAAABfDq5mzZolGTJkMJMEZ86c2fu1AgAAAAB/SGihEwVXrlyZwAoAAAAAYhJcFSlSRG7cuOHJQwEAAADAJ3kUXPXo0UPWrl0ru3fv9n6NAAAAAMBfxlw1bdpU/v33X6lZs6a8/fbb5jpbtmwSGOg+VsuZM2dM6wkAAAAAvjnPVdGiRSVdunQycOBAc4ksFfuDBw88fRoAAAAA8N3g6rfffpPGjRuboEmzBubKlYtU7AAAAAD8mkfBVb9+/czEwRMnTpTWrVub1ikAAAAA8GceBVcHDhwwqdjbtGnj/RoBAAAAgL9kC9SugHoBAAAAAMQguHrllVdk/fr1EhIS4snDAQAAAMDneBRcDRo0SHLnzi0vv/yyHDlyxPu1AgAAAAB/GHNVr149SZAggaxatUoKFSpkAq2I5rnSZBdaDgAAAAB8mUfB1dq1a+23Hz58aFqvImrBIpMgAAAAAH/gUXB17Ngx79cEAAAAAPwtuNJJgwEAAAAAMUxoAQAAAABwRnAFAAAAAI8ruNIsgAkTJpS///7b3NdMgVG96OMAAAAAwNdFKfLJmTOnyfqXKFEicz9HjhxkAQQAAACA6AZXx48fj/Q+AAAAAPg7xlwBAAAAwJMKru7fvx/lsidPnvTkKQAAAB6LkJAQ6d69u1SuXFmyZs0qQUFBkjlzZqlQoYJMnDjR7e+ew4cPS7t27SR//vySNGlSyZYtm9SsWVMWLFgQ4fZ1WEX69OmlcePG8u+//7qty0cffWSe++rVq7HyWgHEweCqTJkycuDAgUeWmz59uhQrVky8ZdiwYWasl162bt0abv2NGzfMl5fOw5UkSRLJnTu39OzZU27duuW1OgAAAN+ivxNGjx5tfl+89NJL5rdEo0aN5PTp09K+fXupV6+ehIWF2ctv27bN/L6ZNm2aFC1aVN577z2pXbu27NixQxo0aCADBgxw2v4HH3wgX375pQnWWrRoIcuWLZOXX35ZHj586FRu37598vnnn8vXX38tadOmfWyvH4AX2TwQEBBgS5Ysme2bb75xu/769eu21157zRYYGGhLmjSpzRv2799vS5IkiS158uQ2rfaWLVuc1t+6dctWvHhxs65WrVq2Xr16mWu9X6ZMGdvdu3ej/Fxaf32cXvure/fu2ebNm2euAXgP+xbgfbdD79ty9frNXK7duhPtxz98+NAWGhoabvn9+/dtVatWNb8JfvvtN/vyOnXqmGW6Lzs6fvy4LWXKlOa3T0hIiH3bQUFBto4dO9rLTZkyJdxvmQcPHpjfK/Xr1492/YHYxHHLFq3YwKOWq6lTp5rMgXqmpm7dunLu3Dn7uvXr15uzODNmzJAiRYrI9u3bYxwAanN8mzZtpHjx4uZMkjvDhw+XPXv2SK9evcwZoaFDh5prva9nkkaNGhXjegAAAN+jU84kTpw43HKdTsb63fHPP//Ylx89etS0ctWpU8epvPacefbZZ+Xu3bv2XjOXLl0y3QJLlSplL1e6dOlwQye++uorOXjwoHz//fex8AoBPC4eBVevv/667N271zRvL1261DSN//LLL9K7d2+pUaOGnDp1St5//30T1GiAFVODBw+WP//8UyZMmGDmznJls9lk3LhxkiJFCunbt6/TOr2vy3U9AABAVGlXQP2doxx/z+ht/e2xZMkSp/IaLO3fv9/8LtKxVSpDhgxmDNfu3bvt5Xbt2mWf6sbKwvzJJ5/IkCFDJHv27I/ltQGIHR7P8KtnZ9atWyefffaZfPrpp/Lqq6+a5fqloIM/q1ev7pUK6heQBlf6HIULF3ZbRgeVnjlzxvR3Tp48udM6va9BoLZiadCng0kBAABc3bt3z/yu0cDp8uXLsmrVKtOapIkr9OSxZdCgQbJp0yZ55ZVXzNipAgUKyIULF+TXX3+VvHnzyqxZs5xaxXTclo7punnzpgm6Jk2aJCVKlDBj2FWXLl1MQPbmm28+kdcNIA4EV0qbxNOlS2eaza1MOvny5YswCIqu0NBQad26tekO+OGHH0ZYToMrpRl73NHlGlxpOXfBlT6PXhwTYyh9TdHJjOhLrNftr68fiC3sW4D33b//wOm2p/vX7du3nZJR6O8cTW6hwZTjNjWA2rBhg0lOoQGVRQMn/d2iLVKO5bVFSnvezJkzx3QZ1EBNhytoy9jkyZNl7dq1ZhjFtWvXzJALa5uaVVCTW7ieOAYeJ45bEq3X7nFwpX2IO3ToIL/99pvpdqd9hWfPni1r1qwxY67Gjh0rDRs2lJjQJnINiHbu3Om2O6Dl+vXr5jp16tRu16dKlcqpnCv90nPN7KOWL18uyZIlE3+2YsWKJ10FwCexbwHeE/rwv580q1evliQR/2R4pHnz5pmg58qVK2Z4ww8//GC6/+kwA+s3wd9//21+O2gvnpEjR5peO5o6ffHixSYY06ESrieFNaBybP3SzIAaoHXr1s2M69KugfoYbRHr3LmzCez0uS9evChvvPGG5y8I8BJ/Pm7duXMndoMr/ZLRJu7z58/L888/b1KRBgcHy9tvv20SSfTv31+aNGliymjQ5UmAsmXLFhkxYoTZljfGbUWmT58+5svQseVKW7hq1aplD8z8MULXnUjn7NDkJQC8g30L8L479x7Ih9tXm9s6LCF18iCvbFdboapUqSKvvfaaOdGrAZXuwzquXH/baIuT428c/d2jXQV1rqs0adJI+fLlI91+q1atTGA2fvx404NGH6snlnUMu3XSWFvNfvrpJ3MiG3gSOG6JvVdbrAVXOgeEtiRp4PPxxx+b/sRKz7JooKJBScuWLc2XhY7L0jM80fHgwQOTHVBbwKwvmMhYLVYRtUxZb0hELVs6J5ZeXOkHyF8/RBbeAyB2sG8B3pPIFvDf7UQJvbpvaVZkpa1Mul0dg3Xs2DHTZc/d7wptndLgShNbaGAWEW3l0h4/ul3t9qfZCPX3j2YVtOqvWQX1h60myvDmvKGAJ/z5uJUoGq/bo+BK+xrrBMFly5Z1u16/GDQrjrYGaZN2dGn6UmsclbvUqEpbzNTcuXPtY7ysx0R3TBYAAIA7mjDL8ceVJr1Q2l3PHWu5u5O2jr9zunbtai6urVuOY8Ct23ryGkD84FFwpfNJPWpwpaYd1bka6tevH+3t6xeSjudyR+fR0mBJs/NkzJhRcufObYKmrFmzmn7KOhjVsW56X5drt0UyBQIAAFd//fWX+T3hOoxBx1lYwwasFiwdqqBDBvS3hY7N1t46Fs1KrCeVNRiKrNXqo48+MuO6tJuh44lrDeC0RcuaW0tv60lmXQfAh4Or6GStcZ1gLyqSJk0a4bxUbdu2NcGVdj8sV66cfXnHjh1NuvaBAweacV8Wva9niPSLDAAAwNXPP/8sX3zxhVSsWNEEWRo8nT592owx15TslSpVMuOsrBPAn3/+uUmfrr9x6tWrJ4UKFZJz586ZLH/6m6NHjx4mPbs7W7dule+++84kzkiZMqV9uY6p0hPLY8aMsQ+e17FWOp6dbIGAn6Rij0s0w878+fNl2LBhpktiyZIlzRxZelZJ55HQbDwAAACuNEDS7n+bN282CbU0QNLxVDr2u3nz5iZRhU47Y9FsftojRpN26WMWLVpkgiP97aHrXn/9dbfPo+OnOnXqZBJXuOvZo4m8tNuhZhtUGmwNHz48Fl85gDgTXOkEezruSgMabUnSifF0mSttGj9y5IjENj2ro8kzNMmGziOhKeGzZMlizh7169fPtIYBAAC40sQReokOzZyml+jQbn+a6CKy3zKaDEwvAPwouNKzKpoxUOeScBdQWUFVROtiQmc114s7epZJJ+XTCwAAAAA8Tv/LoR5NOmHeqlWrTDO6tlrpPA0aTGlWmwMHDpjWIz370rNnTzNgEwAAAAB8nUctV7NmzZJ06dKZgZYaRFnzXGlzd8GCBc0EeNWqVTMXva99lQEAAADAl3nUcqUT3ekcV1b2Giu4evjwob2MZtapUKGCSccOAAAAAL7Oo+AqQYIETrOSW0GW64R62bJlk0OHDsW0jgAAAADgm8GVBk3//vuv/X6+fPnsczc42rdvn0lNCgAAAAC+zqPgSifv/eOPP0wCC8dZy3UuqaVLl5o0o++8845JbvHcc895t8YAAAAA4CvBVZMmTSQoKMhM0Gu1XGlgdfLkSZOivXjx4mb28WTJkjH5HQAAAAC/4FG2QA2gzp49Gy49e5kyZWTevHly9epVKVCggLz77ruSP39+b9UVAAAgnIdh/82rueP4Van2dJAkCAx4onUC4J88Cq4i0rx5c3MBAAB4HJb+cVb6LfjTfr/j1N2SJfUB6Ve/sLxYJMsTrRsA/+NRt0AAAIC4EFh1nbZLzt/43xhwy7nrIWa5rgeAeNVypeOstIugldzCncqVK8f0aQAAAJy6Ag5Y+Jf81yHwP7pMOwXq+pqFM9NFEEDcD67Gjx8vgwcPlhMnTjyyrOPkwgAAADG1/dgVOXs9JML1GmDpei33fN70j7VuAPyXR8HV999/b1Kt22w2KVGihOTJk4f5rAAAwGNz4WaIV8sBwBMLrkaNGiWJEyeWRYsWSfXq1b1SEQAAgKjKlDLIq+UA4IkltPj333+lWrVqBFYAAOCJKBucTrKkDjJjq9zR5bpeywFAnA6ucubMKUmTJvV+bQAAAKJAk1RounXlGmBZ93U9ySwAxPngqk2bNrJmzRq5cuWK92sEAAAQBTqP1eiWJSVTqiROyzOnDjLLmecKQLwIrnr16mXSq2vXwLVr15rEFgAAAI+bBlAru1ex3x/XqoRs7FWdwApA/ElokSBBAvnhhx+kRo0a5pIoUSLJnDmzBAaGj9UCAgLkyJEj3qgrAABAOI5d/8rkTktXQADxK7g6cOCAabW6ePGiabW6d++emUwYAAAAAPyVR90Ce/ToIRcuXDBjr/bu3Ss3b96UsLCwCC8AAAAA4Os8arnatGmTFC1aVCZMmOD9GgEAAACAv7Rc6QTChQv/L/0pAAAAAMDD4ErHW+3bt8/7tQEAAAAAfwquhg4dKufOnZOPP/5YHj586P1aAQAAAIA/jLmaNm2a1KtXT4YMGSKzZs2SqlWrSrZs2SJMxd63b19v1BUAAAAAfCu46t+/vwmaNA27zmEV2TxWBFcAAAAA/IFHwdXEiRO9XxMAAAAA8LfgSue3AgAAAADEMKEFAAAAAMAZwRUAAAAAeAHBFQAAAAB4AcEVAAAAAHgBwRUAAAAAeAHBFQAAAAB4AcEVAAAAAHgBwRUAAAAAPKlJhNevXx+lcokTJ5b06dNLvnz5JCAgwJOnAgAAAADfDa6qVq0arWApRYoU0qJFCxk8eLAJtgAAAADA13gUXLVu3VquXbsmCxYskMDAQClevLjkzJnTrDt16pTs3r1bbDab1KtXT+7evSt79uyRsWPHyurVq2Xbtm2SNm1ab78OAAAAAIh/Y64+//xz2bdvn9SuXVsOHDggv//+u/z666/msmPHDjl48KBZt3//fpk2bZocO3ZMmjdvLkeOHDGPBQAAAABf41Fw1adPHwkNDZW5c+dK/vz5w63XMVZz5swxZbRs8uTJZcyYMabFSlu7AAAAAMDXeBRcLVq0SCpXrixBQUERlkmaNKlUqlRJFi9ebO6nSpVKSpQoYVqxAAAAAMDXeBRcXb9+3Vwe5caNG07lMmTI4MnTAQAAAIBvBlfaFXDNmjVmvFVEdJ2WKVCggH3Z2bNnCbAAAAAA+CSPgqu33nrLjKfSroFDhgyRw4cPS0hIiLno7aFDh0qVKlXk3r17pqzSrIE7d+6UUqVKefs1AAAAAED8TMXeuXNn0zL11Vdfyccff2wurjQVe7du3aRTp07m/okTJ6Rly5bSpEmTmNcaAAAAAHwhuFKjRo2SV155RUaPHi2bN282Xf5UlixZpEKFCtKlSxepWLGivXyhQoVMWQAAAADwRR4HV0qDKL0AAAAAgL/zaMwVAAAAAMCLLVfqwYMHcvnyZZPgIiI5c+aM6dMAAAAAgG8GVytXrpRBgwbJ1q1b5f79+xGWCwgIMAEYAAAAAPgyj4Kr3377TRo1aiQPHz6UtGnTSnBwsKRMmdL7tQMAAAAAXw6uBgwYIGFhYSZj4Ntvvy0JEiTwfs0AAAAAwNeDqz///FOef/55ee+997xfIwAAAADwl2yBKVKkIEkFAAAAAMQ0uHrhhRfk999/9+ShAAAAAOCTPAquhg0bJjdu3JBevXqRCRAAAAAAPB1zNXHiRKlTp46MGDFC5syZI1WrVpXs2bNLYGCg21Tsffv29UZdAQAAAMC3gqv+/fuboMlms8nRo0fNJSIEVwAAAAD8gcctVwAAAACAGAZXbdq08eRhAAAAAOCzPEpoAQAAAABwRnAFAAAAAI+rW2D16tVNYorJkyebrIB6P6r0catWrYpJHQEAAADAN4KrtWvXmiDpzp079vtRpY8DAAAAAF8XpW6Bx44dM+nW8+TJY78f1UtkadoBAAAA+K6QkBDp3r27VK5cWbJmzSpBQUGSOXNmqVChgslAfv/+/XCPuXHjhnlMrly5JEmSJJI7d27p2bOn3Lp1K1zZq1evSrt27eSpp54y223fvr1Z5s5rr70mRYoUcfucj7XlSl9YZPcBAAAAwJUGRKNHj5ayZcvKSy+9JBkzZjTBz5IlS0wgNHPmTHM7MPB/bT63b9+WKlWqyJ49e6RWrVrSokUL2b17t4wYMULWrVsn69evNwGapVWrVrJ8+XJp3bq1mYN3ypQpcunSJVmwYIFTPRYvXiyzZs2STZs2SaJEiSROpWLXSufLl0/Kly8fabmtW7fK33//bV4sAAAAAP+SLl06uX79uiROnNhp+YMHD6RmzZomMNLgSgMvNXz4cBNY9erVS4YOHWov37t3bxk2bJiMGjVK+vTpY5adPXtWFi1aJIMGDZL/+7//M8u0leuTTz6Rc+fOmZYsK8Dr2rWrvPXWW1KuXLm4ly2wbdu2Mm7cuEeWGz9+vGmmAwAAAOB/AgMDwwVWKmHChNKoUSNz+59//jHX2vKkMUaKFCmkb9++TuX1vi53jEFOnTplrkuVKmVfVrp0aXN98uRJ+7KPPvrIbPuzzz6T2OZRy1VUhYWFkdACAAAAiOPGbTgq4zYcC7fcJjYJCUkgn/25TgIk/O/6jpWCpWOl/+VliG6csHTpUnNbx0Gpw4cPy5kzZ6R27dqSPHlyp/J6X8dpLVu2zARVOXLkMBel3QZffPFFc3vXrl3mOmfOnPaedN99953pJqjBWbwOrjSZRapUqWLzKQAAAADE0M2QB3LuRkgEawPk+r3QCB8XFffu3TMtR9qCdPnyZTNV08GDB00vtxo1atiDK5U/f36329DlGlxpOQ2ssmTJInXr1pV+/fqZuMMac1W/fn3TJVATV3Tq1EmaNWtm73YYZ4KrTz/91Om+9oV0XebYh/LQoUNmwJn2pQQAAAAQd6UMSiiZU/2XKMJqtTp/439BVaaUSSTQTY80fVxUg6sBAwbY72vvtg8++ECGDBliX6Zjs1Tq1KndbsNqtLHKqalTp8r7778v8+fPN9t8/fXX5YsvvjDrdNvaEqaB3Pnz56VLly6mtSxp0qQmmYaO70qQIIE8keCqf//+psIaEeq1Bld6iUymTJkeS99GAAAAAJ7Trn2u3fvu3HsghT9ZZm6v6FZBUidP6vH2U6RIYeII7Q6oAc/ChQvNWKgtW7aYTH6e9nbThBmTJ08Ot/zAgQMmDhkzZoyJSbSrobaU/fzzz+b5u3XrZtK3f/jhh/JEgivNQ6/0TdFIr2LFitKhQwe3ZXXQmuax12wcmpseAAAAAAIDAyV79uwme1+GDBlMl73BgwebTIBWi5Vjy5Tr/FeRtWxZNF7R7oCVKlUyifg0qNKshNOnT5eXX37ZlNm5c6fJPPjEgqs2bdrYb2t0WKdOHadlAAAAABBVOo+VWrt2rdNYK2vslatHjcmy6LxamuRi//795r4OV1LFixe3lylRooTJPKiB3KOCtVhPxZ4mTRo5ceKE1yoBAAAAwL+cOXPGXFuT+mrQpL3fdKJfnUzYkd7X5cHBwfYsge6cPn3azIOl47vy5HHu5hgaGhrutrczm3sUXOlEX5rlAwAAAAAi8tdff8mdO3fCLddl3bt3N7c1458V6HTs2NFM+jtw4ECn8npfl2t3v8i8+eabki9fPpPkwlKoUCFzrWO7LHpbAzlvZzb3KBW7Royu0SQAAAAAONIEEpq9T/M15M6d2wQz2rpkNdbouCjHQEjHQGnmPx2DpV37SpYsaeau0jFTZcqUMYkoInsuDZq2b9/ulAWwYMGCZh4sTdCnve/Onj0rK1eulBEjRoi3eRRctWjRwlTm3LlzJoc8AAAAALiqV6+e6f63efNmkxlQW590jFPRokWlefPmJlFewoQJnSYLXrdunQmE5syZI2vWrDHzWfXo0cPMZ6Vp1N25evWqvPvuu6Y1TMdTudKcEZpEQ5Na6DY0iHMM6p5ocKX9GLdt2yZVqlSRoUOHmjfN6isJAAAAAKp06dLmEh0afGkmP71EVdq0aU3DT0Q0HbsGa7HNo+BKm9Y0R/2pU6fklVdeMf0jtcJBQc4Tjyldd+TIEW/UFQAAAADiLI+Cq+PHj4fLJR9ZpAgAAAAAvs6j4EpbrQAAAAAAMUzFDgAAAADwQssVAADAkzBuw1EZt+GY0zKb2Oy3a365SQLdTArasVKwdKzkPKEoAMSp4Grfvn3y3XffyYYNG0y+epUtWzapXLmymcBLUywCAAB4y82QB3LuRkiE6y/cDI3wcQAQZ4Orr776Snr27CkPHz40CS0sBw8eNJcJEybI559/Lu+995636goAAPxcyqCEkjlV+OzE2noVEhJiMhcHSIDbxwFAbPPom2bFihVm0q1kyZLJG2+8Ia1atTIzLmvadc0kOHXqVBkzZoyZxKtIkSJSo0aNaG1fvxw/+ugj+f333+Wff/6RK1euSJo0aSRv3rzSsWNHadmyZbh5tW7cuGGfbEwzF+pkY02bNjWTjaVIkcKTlwkAAOIY7drnrnvf/fv3ZfHixVK3bhXm3gQQvxJafPHFF2Ym5eXLl8uIESOkWLFiZrKvVKlSma6A2mKl6wIDA2XkyJHR3r7O3Dx69GgTrL300ksmSGvUqJHpeqizOOukxY4ZC2/fvm0mNNaJxgoVKmQCP52LS+tWvXp1E6wBAAAAiLqHYf/1Tttx/KrTfXix5Wr79u0mmClfvnyEZZ5//nmpWrWqbNu2LdrbT5cunVy/fl0SJ07stPzBgwdSs2ZNE7gtWbLEBF5q+PDhsmfPHunVq5cMHTrUXr53794ybNgwE3T16dMn2vUAAAAA/NHSP85KvwV/2u93nLpbsqQ+IP3qF5YXi2R5onXzuZarO3fuSMaMGR9ZTsto2WhXKjAwXGCltLVMW7CUdhdUOt5r3Lhxputf3759ncrrfV2u6wEAAABELbDqOm2XnL/hnCDm3PUQs1zXw4vBVY4cOWTLli2mJSkiuk7LaFlv0a6AS5cuNbd1LJc6fPiwnDlzRipUqCDJkyd3Kq/3dfnRo0fl1KlTXqsHAAAA4Iu069+AhX85THDwH2uZrqeLoBe7BTZo0MCMpdLxT19//bVJNuGaXEKzBJ48eVJ69Oghnrp375589tlnpnXq8uXLsmrVKpOJsF27dvYkGRpcqfz587vdhi5ftmyZKRdRoBcaGmoujvW3BsfqxR9Zr9tfXz8QW9i3gNjBvgV4x7ZjV+Ts9YjzFWhIpeu3/HNBngtOJ/7gfjS+VzwKrnT80q+//irTp0+X+fPny4svvmiyBaoTJ06Y1iUNUPLkyROjsU4aXA0YMMB+XxNcfPDBBzJkyBD7Mh2bpTShhjuaZMOxnDu6PcfnsejYLs2I6M80MyQA72PfAmIH+xYQMzsv6VQGCR5ZbvmGbXL5gH+0Xt2JxjAnj4IrTTihEwd36dJFFi1aJLNnzw5XRpNN/PDDD5I2bVrxlI6X0lYr7Q6oXf8WLlxoUrRrd0NNt2oFTjGlAaBmJLRoYKitXLVq1fLac8THCF0PUJpAhJS2gPewbwGxg30L8I70x67IlMO/P7JcrUrP+U3L1Y3/36stKjyeUS9r1qwm2Dl27Jhs3LjRBD/W8ooVK0pwcLB4iya4yJ49u3Tt2lUyZMggzZo1k8GDB5tMgFaLVUQtU9abEVHLlkqSJIm5uNIvZ3//guY9AGIH+xYQO9i3gJh5Pl8myZI6yCSvcNcupe1amVMHmXIJAsNP2O2LovOdEuPpyjWI8mYg9SjamqTWrl3rNNbKGnvl6lFjsgAAAAD8jwZMmm5dswJq6OQYYFmhlK73l8AqumIcXKnz5887tVw99dRTElus57EiSA2a9Dk3bdpkJhN2zBio93W5Bn/ezFroS8ZtOCrjNhwLt9wmNgkJSSCf/blOAuy70n86VgqWjpXyPKZaAgAA4HHReaxGtyxp5rlyTMeuLVbMcxULqdiVjoXSTIEFChQwwU3p0qXNRW9rwPPVV1+ZsVKe+Ouvv9wOHNNl1tiounXr2pNcdOzYUW7duiUDBw50Kq/3dXmnTp08qoc/uBnyQM7dCAl30R3p+r0Ac+1uvT4OAAAAvkkDqJXdq9jvj2tVQjb2qk5gFRstV5q2vH79+iY1ugZZmrQiV65cZp2mXz9y5IgJgn777TdzcTeeKTI///yzfPHFF2bslmYh1KQSp0+fliVLlpiU7JUqVZL333/fXv7DDz80WQt1DNbu3bulZMmSsmvXLpPtr0yZMtKtWzdPXqZfSBmUUDKnCgrXamWdpciUMokEBgS4fRwAAAB8l2PXvzK509IVMAo8+oWsc0+tXLnSTOT7+eefS+3atZ3Wa1DTs2dPWb16tSnrLs15ZOrVq2e6/23evNlkBtTWJ01IUbRoUWnevLmZXythwv+qrl0B161bJ/3795c5c+bImjVrJEuWLGaOrX79+knSpEk9eZl+Qbv2uXbvu3PvgRT+ZJm5vaJbBUmdnPcPAAAAiJXgatq0aWbiYA1i0qdP7zbphLYeaZfBqVOnRju4sroYRocGX6NGjTIXAAAAAIgXY660ValGjRpuAyuLpkyvXr26nD17Nib1AwAAAADfDa6yZcsm9+7di9KEfprgAgAAAAB8nUfB1euvv26SWZw4cSLCMrpOy7z22msxqR8AAAAA+G5w9fHHH5suf5UrV5YJEyaY+aQsenvixIlSpUoV03Xwk08+8WZ9AQAAAMB3gquCBQvK/v375d9//zVzSGmqdB1jpRe9rfNOnTp1Svbt22fK5smTx37Jmzev918F4hRNm//ll1+axCY5c+aUxIkTS+bMmaVJkyaybdu2CB937Ngx83nStP6avl8no65WrZrMnj3bqVxISIhJ9a8TQ+u4v8aNG5vPojsfffSRee6rV696/XUCAAAAMc4WePz48XDLrly5Em5ZZN0G4bu++eYbM+eYBtIaYGXMmFEOHz4s8+bNM5effvpJXn31VafHrFixQho2bGhu6xxqGohrQKQBuqb9b9q0qb3sBx98IN9//700a9bMBPTaUvryyy/Ljh07JEGCBPZy+lidKmD69OlmLjYAAAAgzgVXYWFh3q8JfEbZsmVl7dq1pmuoow0bNpiuol27djWBlDW5tE48/corr5hEKRpIaWuXowcPHjh99saPHy8dOnSQH3/80Sx77rnnpHXr1ia4KleunFn28OFD04Jap04dE4QBAAAAcbJbIBAZ7abnGlipSpUqmW5+2iKl3UotOtH0jRs3ZMyYMeECK+U4YfSlS5dMt8BSpUrZl1lzommQZvnqq6/k4MGDpoULAAAAiLMtV4CnEiVK5BQw2Ww2M6ZKx05pkpSdO3fKunXrTAtV8eLFzbLAwP/OAWg3wKCgINm9e7d92a5du8y1FZhpt1VNpKJdE7Nnz/6YXyEAAAD8VYyCq+XLl8vo0aNl+/btpkWhZcuWpsuWWrZsmbno+BjmuoLVsqTd/rJkySLPPvusPYmFjtfT1qcuXbrI2LFjnR5TokQJWbBggT1I0kCrffv25nN38+ZNE5RNmjTJlCtTpowpo9spVqyYvPnmm0/gVQIAAMBfedwt8L333jPjWebPn29+5OqEwdoKYdEf0JoxbtasWd6qK+Ix/Xy0atVKQkNDTYuSlXjiwoUL5lpbojTRhSan0GDLyhyoy3U8lqMRI0bIu+++a1q4NFlFzZo1TQCm25wyZYoZ76XjsXRagLZt20qKFCnMRW87ThsAAAAAPPGWK/0BqxnhtLVBWxq0+5Zj1y1VtGhRkyp74cKF8v7773urvoiHtIufBjbr1683AZMGWY7rrAQUAwcONOWUZvfTz5Zm/NP07Rs3bpSKFSuadUmTJjWBu14cXbx40aRo79OnjxQuXNi0YGnwr9sJCAgwLVnJkiVjHBYAAICLcRuOyrgNx5yW2eS/hpOaX26SwICAcI/rWClYOlbK81jq6LPBlXbJSpMmjSxatMik2Y6IBliOiQvgfzR40m582iql3UY1aYWj1KlT229rOnVXmpZdg6vff//dHlxF1pqqc2Pp3FbamqoTXA8YMEBee+01s/7o0aPm/vDhw01LFgAAAP7nZsgDOXcjJML1F26GRvg4xDC4+uOPP0w2uMgCK+uH8/nz5z15CvhIYNWuXTvT0tmiRQszNsq1hVPnwtLufNpypQG7K2vZ3bt3I32uxYsXmy6omu5dJy0+cOCASeGuraoWHZel3ROPHDlixmQBAADgf1IGJZTMqYLCLdfWK83UrAnFAiTA7ePwH4/fDe1m9ShnzpwxXbjg34GVThg8depUpwl+Lbqjli9f3gRFf/31V7jWKV2mcufOHeFz3bp1y8ydpRfdliMd4+V6OyqfXQAAAH+iXfvcde/TE9N6Ertu3Sr2rM/wckKL/Pnzm/TX+mZHRLtl7dmzR5555hlPngI+0BVQA6umTZvKtGnT3AZWFg2KVP/+/Z2CIZ2nSlu7UqZMKS+++GKEj9dugPqcQ4YMcWoR0y8A/TKw6G1t1dJ1AAAAQJxoudIfzP/3f/8nvXv3lpEjR7oto0kFrl+/Ls2bN49pHRHPfPrppzJ58mQzrqlAgQIyaNCgcGUaNmxo77Knn5Fff/1VfvnlF9Ndr3bt2uazM2fOHNMMrUGaJrhwZ+vWrfLdd9/JvHnzTBBm0efu0KGDGeN1584ds0zHfb399tuSPHnyWHvtAAAA8F8eBVfdunWTmTNnmmxtmzdvlgYNGpjlOpZl1KhRMnfuXJPdrWTJkiY7HPyLTuJrddcbPHiw2zLazc8KrrSb3owZM0yXPp0n7YcffpAkSZKY+9oqpeP73NGWU/18aap2TXzhSlO237t3zwRtSoMtTWYBAAAAxIYAm+PkVNGgaa81bfaSJUvMj2PXzejcQ9od7FFJL+KiGzdumGQc2nqSKlUq8Td37j2Qwp8sM7f39q0uqZMzbg7wlv/6rtel7zrgRexbQOxg35JoxQYeJ7TQoElTse/du1eWL19uWit03Ev27NlNYFW2bFlPNw0AAAAA8Y5HwVXjxo0lS5YsZqyLjpEhrTUAAAAAf+dRtkBtGrx8+bL3awMAAAAA/hRcBQcHy+3bt71fGwAAAADwp+CqRYsWsm7dOjl37pz3awQAAAAA/hJc6RxWlSpVMimyNe16ZJMJAwAAAIA/8CihRcGCBU1mwFOnTpk5hjQVe6ZMmSQoKChcWV2n818BAAAAgC9LGJNJYi06xxVdBAEAAAD4M4+6BWqrVXQuiF8ehv03IfSO41ed7gMAAADwYnAF37X0j7Pywhfr7Pc7Tt0tFYetNssBAAAARIzgCnYaQHWdtkvO3wh1Wn7ueohZToAFAAAAeHnMFXyPdv0bsPAvcdcBUJcFiJj1NQtnlgSBeg9AZMZtOCrjNhwLt9wmNgkJSSCf/blOAsye5axjpWDpWCnPY6olAADwJoIrGNuPXZGz10MiXK8Blq7Xcs/nTf9Y6wbERzdDHsi5GxHtUwFy/V5ohI8DAADxE8EVjAs3Q7xaDvB3KYMSSuZUQeFaraxut5lSJpHAgAC3jwMAAPETR3EYmVIGebUc4O+0a59r97479x5I4U+WmdsrulWQ1MmTPqHaAQCA2EBCCxhlg9NJltRBbkaA/I8u1/VaDgAAAEB4BFcwNElFv/qFzW3XAMu6r+tJZgEAAAA8puBq6dKlMmLECJk1a5bcv3/f25tHLHqxSBYZ3bKkZEqVxGl55tRBZrmuBwAAAODFMVfff/+9CaCmTp0qFSpUsC9v1qyZzJkzx36/TJkysnbtWgkKYpxOfKEBVIV8GeTZ/svN/XGtSki1p7PQYgUAAADERsvV3Llz5c6dO/L88887tVj98ssvki1bNundu7eULVtWduzYIT/++KMnT4EnyDGQKpM7LYEVAAAAEFstV4cOHZIiRYpIYOB/sdnMmTMlICDABFgaWIWEhEiuXLlk2rRp8s4773jyNAAAAADg2y1XFy9elMyZMzstW7duneTIkcMEVkq7ApYvX16OHTvmnZoCAAAAgK8FV6lTp5ZLly7Z72sAdeLECalatapTueTJk8vt27djXksAAAAA8MXgKl++fLJ+/Xo5efKkuT927FjTJfDFF190Kvfvv/+Ga+ECAAAAAF/kUXDVtWtXM6aqaNGiUqpUKRk+fLhkzJhR6tWrZy9z9+5d+f3336Vw4f/NnQQAAAAAvsyj4Or111+XHj16SGhoqOzevdtkCJwxY4akSJHCXubnn382GQVr1KjhzfoCAAAAgG9NIvz555/LtWvX5Pz586Z7YLVq1ZzWV69e3QReHTt29EY9AcDvnT59Wr788kupVauW5MyZUxInTmy6Xjdp0kS2bdvmVFYncdd5B9u0aSNPP/20OfmVMmVKee6552T06NHy8OHDcNvXHgndu3c3yYnSp08vjRs3Nt273fnoo4/Mc1+9ejXWXi8AAH6Ril0PvmnTppW+ffua7oDu6MFZLwAA7/jmm29k2LBhkjdvXhNg6ffv4cOHZd68eeby008/yauvvmrKHjlyRF555RUTVGkPgpdfflmuX78uCxculDfffFMWL14sCxYsMONlLR988IGZJF4nhM+QIYNMnDjRPE7nLEyQIIG93L59+8wJtunTp5tjAQAAiEFw9e2330qDBg08eSgAwEM61cXatWulSpUqTss3bNhgAigdD9uwYUNJkiSJaaX67rvvTMuVZm61jBw50mR2/e2338y8hE2bNjXLw8LCZPz48dKhQwf75O/aytW6dWsTXJUrV84s0xYv7ZFQp04dE4QBAIAYdgvMnj27ORADAB4f7abnGlipSpUqma7Z2kVv//79ZpmOhdUWKsfASul97X1gzU9o0ek1tFugJimylC5d2lxbmWHVV199JQcPHjQtXAAAwAvBlZ4Z1YPyzZs3PXk4AMDLEiVKZK4TJkzoUVntBqiTv+tYWcuuXbvMtY7vUsePH5dPPvlEhgwZYk6yAQAAL3QLHDBggOmaUrduXfn666+lRIkSnmwGAOAF2rK0cuVKyZIlizz77LOPLD9hwgRzreO2LIGBgdK+fXuT7EJPnGlCi0mTJpnv9zJlypgyXbp0kWLFipkWMQAA4KXgSsdbaZ/+TZs2mW4jekDXM5t61tOVDpZetWqVJ08DAHgEzQrYqlUrMzWGJrtwTDzhjk76vmTJEpPRVU+QORoxYoRp1Zo9e7aZq7BmzZrmBJpuc8qUKeakmrZs3b59W95++20zZktp4gwd3+XaBREAAH/jUXClB1iLzWaTM2fOmIs7jpmoAADeo2Nf27ZtK+vXr5dOnTqZICsymsRCg6JcuXLJtGnTwq1PmjSpSfWuF0cXL14047T69OljJobXFqz58+ebQE2/47UlK1myZIzDAgD4PY+Cq2PHjnm/JgCAaAVW2o1P06+3bNlSxowZE2l5Tb2uLUxPPfWUrF692vQ4iKr33nvPPE7nttIug9qtULuHv/baa2b90aNHzf3hw4c7TSYPAIC/8Si40rOeAIAnF1i1a9fOdNVr0aKFGRulY6YismjRIjPRsCatWLNmjeTJkyfKz6VB2axZs0y6d520+MCBA/LgwQMpXry4vYyOy9LuiTq3lo7JAgDAX3mULRAA8OQDK50weOrUqZGOs7ICq3Tp0pnAKl++fFF+rlu3bpm5s/RSvnx5p3U6xsv1Nt3AAQD+LkbB1V9//SXvv/++VKhQQQoWLCgffvihfd3mzZvNQOgrV654o54A4PesroAaWOnkvzpuKrLAShNXaGCVNm1aE1jlz58/Ws+n3QD1OTX1uiVv3rwm6YW2aFn0trZq6ToAAPyZR90C1RdffCG9e/c23UOsM5Y6CaUjDbw0q6AOfgYAxMynn34qkydPNuOaChQoIIMGDXI7D6F22dOJfhs1amRalapWrSozZswIVzZ37twmIYY7W7duNRkA582bJylTprQv1+fu0KGDGeN1584ds0zHfWmiDLIFAgD8nUfBlXYz+eCDDyQ4OFhGjhwpFStWlEyZMjmV0S4kGTNmNBmlCK4AIOZ0El+ru97gwYPdltGASYOrc+fO2bvrzZw5023ZKlWquA2udPyUZh/UBBj169cPt15Ttt+7d8+eil2DLU1mAQCAv0voaauVnqFcsWJFpAOj9QB/6NChmNQPAPD/aeIKvUSFtlbpVBme0G5/+/fvj3C9fv+PHz/eXAAAQAzHXO3cuVPKlSv3yIxTmplKz54CAAAAgK/zKLjS7iCOffAjcuHCBUmY0ONhXQAAAADg28GVjrXau3fvIwOwffv2mUHXAAAAAODrPAquXn75ZTOwWsdeRUQHN1+8eFEaN24ck/oBAAAAQLzgUZ89nc9q+vTp0rNnT9m2bZtJ96vOnz8vc+fONRddry1cmp4XAAAAAHydR8GVTki5cuVKk6Z39uzZ9nS8S5cuNRfNUFW4cOFw86MAAAAAgK/yONuEjqXas2ePLFy4UJYvX266CYaFhUn27NmlZs2a0qRJE0mQIIF3awsAAAAAvhRc/fHHH1KkSBEJDAyUBg0amEtEdE4Wd5NUAgAAAID4e0KL2rVrm5aqRxk3bpx07NjRk6cAAJ/zMOy/SX13HL/qdB8AAPhpcKVZAGvVqmUSWERk7Nix0qVLF8mYMWNM6gcAPmHpH2flhS/W2e93nLpbKg5bbZYDAAA/7hY4ZcoUadmypbz44ouydu1aSZ06tdP6MWPGyFtvvSWZMmWSNWvWeKuuiAXjNhyVcRuOOS2zyX9n02t+uUkCAwLCPa5jpWDpWCnPY6kjEN9pANV12i6HPet/zl0PMctHtywpLxbJ8oRqBwAAnmhw1bx5c7l69aoJoOrXr28SWgQFBZl13333nbzzzjuSJUsWWb16tRQsWNBrlYX33Qx5IOduhES4/sLN0AgfB+DRtOvfgIV/hQuslC7TUxe6vmbhzJIgMPyJDAAA4AfZArt27SqXL1+WTz75xGQGXLBggXz77bfy/vvvS9asWU2LVr58+bxbW3hdyqCEkjnV/wJj19arkJAQEzQHmJ9/4R8H4NG2H7siZ69HfAJDAyxdr+Wez5v+sdYNAAB4V4x+IX/88ccmwPrqq6+kTJkysnfvXsmWLZvpCkhgFT9o1z533fvu378vixcvlrp1q0iiRImeSN0AX3DhZohXywEAgLgrxs0Po0aNkitXrsjUqVMlR44cJrDKk4exOACgMqUM8mo5AAAQz4Or9u3bR7reZrOZ1g1trRo0aJDTuoCAABk/fnzMagkA8VTZ4HSSJXWQSV7hbtyVdrrNnDrIlAMAAH4QXOlEwFHhLjMgwRUAf6ZJKvrVL2yyAmog5RhgWaMZdT3JLAAA8JPginTqAOA5TbOu6db7LfhTzt/4LwOntlhpYEUadgAA/Ci4qlKlSuzXBAB8mAZQFfJlkGf7Lzf3x7UqIdWezkKLFQAAPiTwSVcAAPyFYyBVJndaAisAAHwMwRUAAAAAPMng6s6dOyYzoM5vlSZNGkmQIIHbS8KETDYLAAAAwPd5FPlcv35dKlWqJH/++acJoBInTmzSsWfJkkXOnTtnbqtcuXJ5u74AAAAA4DstV0OHDpU//vhDOnfuLDdu3JBXXnnFpFw/ffq03L5926Ruz5w5szz33HNy9OhR79caAAAAAHwhuJo3b55kzZpVvv76awkKCjKBlUXvt27dWlauXClz586VkSNHerO+AAAAAOA7wdWJEyekZMmSkihRov9tJPB/m7l//769TOHChU0K96hOQAwAAAAAfhdcaeuUXiypUqUy1zreylG6dOnk2LFjMa0jAAAAAPhmcJUjRw45deqU/X6hQoXM9bp16+zLHjx4IDt27JD06dN7o54AAAAA4HvBlWYK3Ldvn9y8edPcr1+/vkm5/u6778qYMWNk4cKFJsnF8ePHTdfA6NLEGF9++aXUqlVLcubMabIRaoKMJk2ayLZt29w+RhNrdO/e3WQoTJIkieTOnVt69uwpt27d8uQlAgAAAEDsB1fNmzeXokWLyubNm819TW4xZMgQuXbtmrz11lvSsGFDWbBggTz11FMybNiwaG//m2++kffff99kGtQAq0ePHlKxYkWZP3++lC9fXmbNmuVUXjMUahA3atQo04qmjy1YsKCMGDFCqlevLiEhIZ68TAAAAACI3XmuNNDZsmWL0zJtNapQoYLJEHj16lUpUKCAtGvXzoy7iq6yZcvK2rVrw7V6bdiwQWrUqCFdu3Y1AZy2UKnhw4fLnj17pFevXiZNvKV3794muNOgq0+fPp68VAAAAACIveAqIjqvlV5iqnHjxhF2R6xWrZosX75c9u/fL6VLlzYTFo8bN05SpEghffv2dSqv97/77juznuAKAAAAQLwJrh4HK/27jvFShw8fljNnzkjt2rUlefLkTmX1vramLVu2zCTg0EQc7oSGhpqL4/gtK7W8Y3p5f2K9bn99/UBsuH//gdNt9i/AezhuAbGDfUui9dpjFFxpC9Lo0aNl+/btcunSJWnZsqWMHz/erNOARi8ffPCBGZPlDSdPnjSTE2fJkkWeffZZe3Cl8ufP7/YxulzroeUiCq50vNiAAQPcvr5kyZKJP1uxYsWTrgLgM0If/ve1u3r1akmS4EnXCPA9HLeA2OHP+9adO3diP7h677335NtvvzXd8rRLnkZ0etuiAZBm/NOARhNMxJRuv1WrVqaFScdRJUjwv18l169fN9epU6d2+zhrDi6rnDvaZVDHjDm2XGm9NZmG9Xh/o++37kQ1a9a0txYCiJk79x7Ih9tXm9uabCd18v/mCwQQMxy3gNjBviX2Xm2xFlxNmTLFZPTTMU9jx46V4sWLS2Cgc+JBzSaoAYqmZY9pcBUWFiZt27aV9evXS6dOnUyQ5U2aGMNKjuFIP0D++iGy8B4A3pPIFvDf7UQJ2beAWMBxC4gd/rxvJYrG6/YouNKugGnSpJFFixZJxowZIyynAZYmnohpYNW+fXv56aefTLdDnUfLkdViFVHLlBVpRtSyBQAAAABPbJ6rP/74w8w3FVlgZQU058+fj1FgpencJ0+eLC1atJBJkyaFayGzxlpZY69cPWpMFgAAAAA8seBKBQT8170lIprFL2nSpDEKrLQL4quvvipTp061j7NypEGTJszYtGmTmUzYkd7X5cHBwREmswAAAACAJxZcaUCza9euSNMS3rx500zs+8wzz3jcFVADq6ZNm8q0adPcBlZWkNexY0e5deuWDBw40Gmd3tflOk4LAAAAAGKTR2OuNOD5v//7P+ndu7eMHDkywgx8Og6qefPm0d7+p59+aroCahbCAgUKyKBBg8KVadiwoUmkoT788EOZP3++ySK4e/duKVmypAn+NJV6mTJlpFu3bh68SgAAAACI5eBKg5WZM2eaVOubN2+WBg0amOVHjhyRUaNGydy5c2Xjxo0myPGk1ej48ePmWludBg8e7LZM7ty57cGVTha8bt066d+/v8yZM0fWrFljUsH36NFD+vXr53HXRAAAAACI1eBKgxWdzFfToy9ZssRMIqw2bNhgLkpz4Wt3vsSJE0d7+5q4Qi/RockzNLDTCwAAAAA8bh5PIqyZAjUV+969e033O21t0rFS2bNnN4FV2bJlvVtTAAAAAPDF4MpSrFgxcwEAAAAAfxbj4Mpy9epVc62TC0clTTsA+LJxG47KuA3HnJbZxGa/XfPLTRLo5ruyY6Vg6Vgpz2OpIwAAiCPzXKkFCxZIrVq1TFa/DBkymEvKlCnNMs3eBwD+6mbIAzl3I8Tpcv5GqH39hZuh4dbrRR8HAAD8qOXKZrNJhw4dTLp0vW21WKlr166ZZBerVq2SVq1aycSJE2nJAuB3UgYllMypgsIt19arkJAQCQoKkgAJcPs4AAAQP3l0FP/qq69MNr+sWbNK3759pUWLFpIqVSr75MEzZswwc1VNnTrVpEtnnikA/ka79rnr3qeTry9evFjq1q0iiRIleiJ1AwAAcahb4NixYyVZsmQm7XqXLl3sgZXSboGdO3c26zRlu5YFAAAAAF/nUXB17NgxqVGjhgQHB0dYRtdpGS0LAAAAAL4u0NM5rqIyObB2edEkFwAAAADg6zwKrho1aiSrV6+2p19358qVK6ZMw4YNY1I/AAAAAPDd4GrQoEGSJ08eqV69ugmgXK1Zs0Zq1qwpefPmlc8++8wb9QQAAAAA38sW2KBBA9MtcOfOnSaISpcuneTKlcusO3nypFy+fNncLleunCnrSNOya5p2AAAAABB/D67Wrl1rv63zXGkwZQVUjrZs2RJuGXNeAQAAAPBFHgVXZAAEAAAAAC8EV1YXQAAAAABADBJaAAAAAAC8EFwdPnxYpkyZEq574NatW00SixQpUkjhwoXl119/9WTzAAAAAOAfwdXIkSOlffv2ZpJgy/nz56V27dqyfft2uXv3rhw8eFBeffVV2bVrlzfrCwAAAAC+E1xt3LhRihcvLtmzZ7cvmzBhgty8eVO6d+9ugitttQoLC5MvvvjCm/UFAAAAAN8Jrs6ePRsuqcXSpUslSZIk0r9/fzMHVsOGDeW5556Tbdu2eauuAAAAAOBbwVVISIgkSJDAfj80NFR27Nhhgikdb2UJDg6WM2fOeKemAAAAAOBrwZV2B9y3b5/9/sqVK03AVb16dady2j0wefLkMa8lAAAAAPhicKVBlGYM7NatmyxcuFB69eolAQEB0qBBA6dy+/fvlxw5cnirrgAAAADgW8FVnz59JE2aNPLNN9+YsVV//fWXNGvWTIoVK2Yv8+eff8qRI0ekQoUK3qwvAAAAAMRJCT15UM6cOWXv3r0ybtw4uXjxopQqVUratm3rVGb37t2mJUuDLgAAAADwdR4FV9a4K80MGJGWLVuaCwAAAAD4A4+6BQIAAAAAnBFcAQAAAIAXEFwBAAAAgBcQXAEAAACAFxBcAQAAAIAXEFwBAAAAwOMKrvLkySO9evWy358yZYps3rzZG88PAAAAAP4TXB0/ftxMFmzRCYN1AmEAAAAAQDSCq6RJk8q1a9eiUhQAAAAA/FLCqBQqVKiQrFixQiZPnizBwcFm2blz52T9+vVRepLKlSvHrJYAAAAA4AvB1QcffCCtWrWS9u3b25ctW7bMXKLi4cOHntcQAAAAAHwluGrRooXkz59fFi5cKKdOnZJJkyZJ3rx5pUKFCrFfQwAAAADwleBKlS5d2lyUBlcVK1aUCRMmxGbdAAAAAMD3gitHEydOlHz58nm/NgAAAADgT8FVmzZtvF8TAAAAAPD1VOwR2bdvn3Tp0kUKFy4sqVOnNhe9/cYbb5h1AAAAAOAvPA6uvvrqKzMGSycTPnjwoNy8edNc9PbYsWPNOi0DAAAAAP7Ao+BK57x6//33JXHixOZ69+7dcvXqVTPR8J49e6RHjx6SJEkS6d69u6xatcr7tQYAAAAAXwiuvvjiC0mYMKEsX75cRowYIcWKFTNdAlOlSiVFixaVzz//3KwLDAyUkSNHer/WAAAAAOALwdX27dulSpUqUr58+QjLPP/881K1alXZtm1bTOoHAAAAAL4bXN25c0cyZsz4yHJaRssCAAAAgK/zKLjKkSOHbNmyRR48eBBhGV2nZbQsAAAAAPg6j4KrBg0ayIkTJ6R9+/YmiYWrGzduSKdOneTkyZPSsGFDb9QTAAAAAHxvEuE+ffrIr7/+KtOnT5f58+fLiy++KLlz5zbrNOhaunSpCbDy5MljygIAAACAr/MouEqXLp1s2LDBTCC8aNEimT17drgyL730kvzwww+SNm1ab9QTAAAAAHwvuFJZs2aVhQsXyrFjx2Tjxo1y5swZ+/KKFStKcHCwN+sJAAAAAL4ZXFk0iCKQAgAAAODvPEpoAQAAAABwRnAFAAAAAF5AcAUAAAAAXkBwBQAAAABeQHAFAAAAAF5AcAUAAAAAXkBwBQAAAABPep6rBw8eyKJFi2T79u1y6dIlee6556R9+/ZmnU4qrMsKFy4sCRPGeDotAAAAAIjTPI56Nm7cKC1btpRTp06JzWaTgIAAuX//vj242rJlizRr1kxmz54tjRs39madAQAAAMA3ugX+9ddf8uKLL8rZs2flnXfekZ9//tkEWI7q168vyZIlkzlz5nirrgAAAADgWy1XAwcOlJCQEFm8eLHUqlXLbZnEiRNLyZIlZffu3TGtIwAAAAD4ZsvVmjVrpGzZshEGVpZs2bKZsVcAAAAA4Os8Cq6uXbsmOXLkeGS527dvm3FYAAAAAODrPAquMmXKJP/8888jyx04cCBKQRgAAAAA+GVwVb16ddmzZ4/pHhiRuXPnmgCsZs2aMakfAAAAAPhucNW7d2+TsKJhw4YyevRoOXfunH3d1atXZcKECdKhQwdJnjy5dO/e3Zv1BQAAAADfCa4KFSokM2bMkLCwMHn77bdN4gqd52ry5MmSIUMG6dSpk4SGhsr06dMlODjY+7UGAAAAAF8IrpS2Wv3xxx9mnisNtoKCgkxrVp48eaRLly6yb98+efnll71bWwAAAADwpXmuLLly5ZIvv/zSe7UBAAAAAH9ruQIAAAAA/IfgCgAAAACeVHCVIEGCKF10HJYmu6hXr57MnDnTG/UFAAAAAN8JrnRi4Jw5c4rNZrNfUqdObS6OyzJnzixXrlyRxYsXy+uvvy6NGzc2GQYBAAAAwNd4FFzp5MAlSpQwQdaPP/4oN27cMEGUXvT2uHHjTLILLXP9+nXZvHmzFClSRObPny8//PCD918FAAAAAMTH4Gro0KGyYsUK2bBhg5ksOEWKFPZ1ert9+/aydu1aWblypSlbrlw5mTt3rknVPnXqVG/WHwAAAADib3ClkwVXr17ddA2MiLZcaRkrmNL5r0qVKiV//fWX57UFAAAAAF8Krv79919JkiTJI8tpGS1r0WAsJCTEk6cEAAAAAN8LrjRRxZo1a+TmzZsRltGxV1pGy1ouX74s6dKl86ymAAAAAOBrwdWrr75qAqXatWvLli1bwq3funWr1KlTxyS4aN68uVmm2QP3798vBQsWjHmtAQAAACCOSejJgz755BNZt26dCaIqVqxoWqc0c6A6deqUnDt3zgRTmsiib9++ZvnevXtNqvZmzZp59xUAAAAAQHwNrpIlS2aCq+HDh5vU6qdPn5azZ8/a1+vEwW+88Yb07NnTZAhUxYsXlwMHDniv5gAAAAAQ34MrpUHTxx9/bC4nT560B1dZsmSJNIsgAAAAAPgij4MrRxpMEVABAAAA8GceJbQAAAAAAHix5Wrjxo0yf/58OXz4sEnLrkksXAUEBMiqVauive1p06bJhg0bZOfOnSbL4L1792TixInStm3bCFO/9+/fX+bMmWMSamj3xKZNm0q/fv0kRYoUHr0+AAAAAIjV4EqDqA4dOsjkyZPtAZUGUY7BlXVfrz2hY7lOnDghGTJkMIGS3o7I7du3pUqVKrJnzx6pVauWtGjRQnbv3i0jRowwiTfWr18vQUFBHtUDAAAAAGKtW+CYMWNk0qRJUqpUKVmxYoU0btzYLD906JAsWbLEtC4FBgaabIFHjx715Clk3Lhxcvz4cbl48aLJPBgZzVqogVWvXr1k2bJlMnToUHOt93fs2CGjRo3yqA4AAAAAEKvBlQZWyZMnN4FUjRo1JGXKlGZ5/vz5zcTCEyZMkBkzZpiWIw16PPHCCy9Irly5HllOW8c0ENOuf9acWha9r8t1PQAAAADEueBK56sqX768pE+f3ty3uv49fPjQXuaVV14xLVsaYMUmHe915swZqVChggn4HOl9Xa6tZzq5MQAAAADEqTFXYWFh9sDKmlRYXb161YyRsmhL1qJFiyS2gyvrudzR5dpFUMvlyJHDbZnQ0FBzcUyOoe7fv28u/sh63f76+oHYwr4FxA72LSB2sG9JtF67R8FVtmzZTGuRxeq+p0kkatasaV/+999/S8KEXplKK0LXr18316lTp3a7PlWqVE7l3BkyZIgMGDAg3PLly5fbA0d/pWPqAHgf+xYQO9i3gNjhz/vWnTt3olzWo8inZMmSJr26dgNMkCCBydCnySM+/PBDM9ZKgy9NeqFp1HVMVlzXp08f6d69u1PLlbZy6euygjN/jNB1J9JgOVGiRE+6OoDPYN8CYgf7FhA72LfE3qst1oKrl19+WWbNmmW6/OntYsWKSfPmzWXmzJnyzDPP/LfxhAll8ODBEpusFquIWqasNyOili2VJEkSc3GlHyB//RBZeA+A2MG+BcQO9i0gdvjzvpUoGq/bo+BK55HS9OuOXf50zquiRYvKvHnzzNirAgUKmJassmXLSmyyxlpZY6+iOyYLAAAAALzB4wFRri09GtH17t3bXB4nDZqyZs0qmzZtMpMJO2YM1Pu6PDg4OMJkFgAAAADwxFKxT5kyRTZv3vzIclu3bjVlY5Omge/YsaPcunVLBg4c6LRO7+vyTp06xWodAAAAAMCjlqu2bduai851FZnx48ebCYVbt24d7efQiX83btxobu/fv9++bO3ateZ2xYoVTVCltPvh/PnzZdiwYSZjoSbc2LVrl8n2V6ZMGenWrZsHrxIAAAAAoi5W86TrfFjWBMPRpYGVjuNypF389GKxgivtCrhu3Trp37+/zJkzR9asWSNZsmSRHj16SL9+/SRp0qQxfCUAAAAA8ASDq6NHj3qcynzSpEnmElWaDXDUqFHmAgAAAABxNrj69NNPne7v2bMn3DLLgwcP5NChQ7J+/XqnSYUBAAAAQPw9uNIud9rFz2azmWsNrvQSmUyZMslnn33mjXoCAAAAgG8EVxMnTjTXGly1b9/eJJTo0KGD27KJEyc26dHLlSvndnJeAAAAAPDb4KpNmzb225pook6dOk7LAAAAAMCfeZTQQrPxAQAAAABiOIkwYt/x48fN2Da91K5dO8JJmnW9zjnmLadPn5Yvv/xS6tata1Lda5r7zJkzS5MmTWTbtm0RPk7XNWjQQDJkyGC6gubPn18++eQTuXv3bqSvzd1Fx/cBvrp/ff3112aKiLx585ou1I/av6zxrhFd9LW4+uabb6Rdu3ZStGhRSZgwoSlnzREI+NM+Z00L8+2335o5MJMlS2ayGFeuXFkWLFgQ6eOOHTsmnTp1kly5cpnj2lNPPSXVqlWT2bNne7V+QHzYhxYtWiRly5aN0j7UP5rHrcOHD5scDbpNHVakx8YcOXKYeXIPHjwofpOK/a+//pLhw4ebjIBnz56Ve/fuuS2nb6JmD4TndDLk1atXS/Xq1WP9ufRHmU7GrD/8ihcvLiVKlDAp9efNm2cuP/30k7z66qtOj/n111/NsgQJEpgfifpjUecjGzhwoKn3qlWr3I69K1asmDRs2DDc8qpVq8bqawSe9P6l+4h2rdYfa3pQiWz/smg37Ny5c4dbniZNmnDL3n33XXOt8/1lzJhRzp07FwuvBoj7+5yOE2/WrJmZA1OPazpWPDQ0VObPn29OCOo++fbbb4d73IoVK+zHp/r160uePHnk6tWrsm/fPlm5cqU0bdo01usOxJV9qEWLFjJ37txo7UPROW717dtXZs2aJUWKFDHb1OBt//79MnXqVPnll19k6dKlJvCKN2we2Lx5sy1ZsmS2gIAAc0mfPr0td+7cEV7im+vXr9v0rdHrJ+XYsWOmDvr+BQYG2kqXLm0LCwtzKrNlyxZTpk2bNl573jlz5tjWrl1ru3fvnm3evHnmWq1fv96WKFEiW9q0aW0hISH28nfu3LFlzJjRrPv999/ty7Wub731lqnfkCFD3L42b9YbiC/718qVK532rcj2L9WvXz9TjzVr1kT5eX777Tfb2bNnze0uXbpE+/FAfNznXI9bavbs2WabFSpUMMcry8WLF225cuWyJUmSxNTN0YkTJ2ypUqWy5c+f39x2df/+fY/qB8TH45a1Dz399NNOv4sj24f6RfO4NXHiRNuuXbvCLZ8xY4bZTuHChW3xKTbwqFtgnz59THevbt26yaVLl8xFm88jusBzBQsWlFatWsnvv/8uP//8c6w/X+PGjaVKlSrhlleqVMl0h9Azd3o2wbJ582a5ePGiOcNXqlQppxbLQYMGmdtjxowxZz6AuOZJ7F/uzr5FtH956qWXXjKtY4C/73N6dl199NFHkjRpUvty7cL+/vvvmzPwVjZki3ZPunHjhjl25cyZM9w2tast4G/7kPZMiuo+FF3ajVF7Srlq3ry5FChQwPSW01gjvvAouNJ/qHYZ++KLLyRdunTerxWc6GTN2q3u448/lvv37z+xeiRKlCjcgcXqbhQcHOy22Tdt2rRy4sQJ07XQ1ZkzZ+S7774zB7Lx48fLkSNHYrX+QHzbvxxpF2ztUvj555+bLoS3bt16zDUE4t8+F9kxylqm3asseiJQx1SlT5/edLnauXOn+a0zYsQI0x1Qx54A/rgPaTf2qOxD3j5uPerYGBd5VFMdaFaoUCHv1wZu6Zmzd955x3y5//DDDxH2bVU6sbN+gKNKAyBtgXyUkydPmgOLjuF49tlnnc5cKHctlNevXzdn4tXff/9t+uq69mnXi2Nr1+uvv27OFmoiDcDf9y9HmgTDddtfffWVGfALxCextc89fPjQnLTThEzujlFPP/20U3nruKXHJ8dlV65ckdKlS0uXLl1k7NixTo/Rs+s6iD979uxRfLVA/D5uWfvQ+fPnw5V1tw9587i1fft2+fPPP6VMmTJuxxfHWZ70O6xfv76tWLFiNl8Vl8Zc1a5d29y/cuWKLU2aNLZMmTLZbt68GWHfWu23qsuietH+so/qu66XypUrm/JTpkxxKqd10b7pOl7Etb/su+++a3+en376yb78/Pnztr59+9p27txpu3btmnltOg7lueeeM2UbN27s1fcSiEv7l+u4kMj2L/Xrr7/aJkyYYDt69Kjt7t27pu7ffPONGZ+lY17nz58f6WtlzBX8aZ/TMcCOY64mT55slleqVMnsP5ZLly6ZsSu6LnHixPblVh0SJEhgS5EihXl+ravWv1OnTmadHqsAfzluWfuQjnu6cePGI/chbxy3lP4+LFSokBlfFheOX9GJDTwKrvbv329Lnjy57dtvv7X5orgYXKmhQ4eaZTpQMLYGLrr+ANTB9a+99pp5Hj2wuDNu3DizXgc1vv7667YePXrYnn/+ebOz6Y6h62bOnPnI57x9+7atYMGCprwGXoAv7l+OwdXDhw8fuX9FRE9I6EHq2WefjbQcwRX8ZZ9zl9BCk09Uq1bNbDdfvny2t99+2+wTTz31lK1o0aJmeVBQkL38pk2b7D8yR40aFe45rJOAGzZs8KiOQHw7buk+VLVq1SjvQ944bmnyGWu/HTx4sC0uiPWEFrt27TJzqGi6X01+oIkLJk2aJFOmTHF7gXfo+61dEUaOHCkXLlyI9efTvuU6x4emh27ZsqXprueOpuVcvHixPP/882bg4/fff2/6yGoK9nz58pkymTJleuTz6dwJOkhTaSp3wNf3r/bt2z9y/4pIjRo1TFdbTYChg++B+OZx7HM6TmPJkiVm3p3AwEDTzU+nD9F0z5ri2fX4lDp1avvtl19+Odz2NC27NfYc8Jd9aOHChSa5hA7feNQ+FNPjVkhIiNn2mjVrTAI9TUYT3yT0NKuHvsHa8rVhwwZz0fuudL0uZ0yAd2iWlgEDBphgRq+tQCQ2xoToDz+du0A/3Dq/gQbPemCKiM7ZoxdXWkd9nE7eGBVW397bt29H+TUA8XH/0km6p02bFqX9K7L95Z9//pE7d+6YeUEAf97n3I25UjrwX8d+uI7/sCbW1vFVFv3hp3M26rbcjfGwlmnGZMBfjlu6D2lwpQ0mVoKJiPahmBy3dL/SwErH43/44Ycm4Vl85FFw9cknn7gNphD7dEI2zVz0448/mpYidzuR7mBRpTPPu+5E1g8/Dax0okSdxE0PNtGlrU86C7ce6BzPBkZm27Zt5trdpHOAr+xf1okLnTDY0/1LT0DoQF9N/mKdlAD8fZ/TSbOj2go8ffp0c60/Gi1BQUFSvnx5c9JY0z9XrFjR6TG6THGMgj8dt6KzD3l63HIMrD744AOTZTDeeiwdFeOZuDrmyqIDAXVd3rx5vd63VseA6PZ0u+XLl3eadDEi7t6n06dPm/FWCRMmDDd+ShNfuE58Z02wqgMXdcCjDmQEfHH/atWqldlukyZNHjkZqQ4ePnToULjlul+2aNHCbKddu3aRboMxV/CXfc7dmKuIjlE6Maoeb8qUKWN78OCB0zpNwKT1qFGjhtOk3gcOHLAlS5bMljJlSpNMAPCH45aVvMLdBN3u9qEbHhy3NOlFzZo1zbru3bvb4ntsEH+SxsOpH7ieTdu4cWOszJ0wefJkSZEihWTLls00ybqeVdcJg3WeM8vXX39tujdpnbTf7alTp8zYK23y1fmrXLsE6qRzOqeVnmHRvsLa/ULH8enr0aZn7SIV1ZYuIL7tX9pSpWfH8+fPb59oO6L96/Lly2baC01Dq2mkdWJgTYeradv//fdfk7Zd5w9xNXToUDl48KC5vWXLFvsy3bes59AL4Ov7nHruueckR44cZh/SfU/TO2t3pjx58pg5rVyPcXoWXseU6HiSYsWKSe3atc3UInPmzDHjQbRrlM7hCPjLPlShQgWz7+ixR8fHR7YPXfbguPXGG2+YFistmzJlSjNG0t2QpPjSYhzj4Grv3r3mTdaZk5955hn7AFCdsVkvjAOIHdpcqh92b9NufEonetMdxh39cDsGV9qFYt26dWbAo85rpZMvalfAXr16uZ1xWwfv60Fq69at5nOj3aQ0kNOuiD169GAONfj8/qU/0DTYedT+pZO0v/nmm+Y7VpPG6P6lfez1gKUDmXVuE73vaunSpWafdLRs2TKn5yC4gj/sc0q732qwpMccnXBVJz7VyVd79uzp9jeKDnuYMWOGObbpCUKdR0hP/Ol9HVyvibwAf9qHrCEievL9UftQOg+OW9axUScsjqgLY9WqVeNNcBWgzVeePPDQoUMmY6A1Rsbq9zlhwgRze+LEiebH8qJFi+TFF1+U+EQzmGjLiZ6p8tfgUHce3Sk0SHIcvAggZti3gNjBvgXEDvYtiVZs4FEqdu32VblyZXMWSNOSDh8+3GQGdNSsWTNJnDixaaEAAAAAAF8X6Om4Ae3ONW7cOJPeUbtyudJMINq1xbFlCwAAAAB8lUfBlfbnL1q0qJkAMzLaN/L06dOe1g0AAAAAfDu40lmgCxYsGKU+mpoxDgAAAAB8nUfBlWaDO3ny5CPL/f3335IlSxZPngIAAAAAfD+40lSPO3bsMLM+R0TTAP/xxx8mdSIAAAAA+DqPgqsPPvjAZAds0KCBLFmyxEwC62j16tXSqlUrSZgwoXTr1s1bdQUAAAAA3wqudLbzr7/+Ws6cOSP16tWTNGnSmEn3NO26zlpes2ZNs+7bb781iS8AAAAAwNd5FFwpnX15w4YNZp4rDay0JevmzZsSGhoqtWvXNt0CO3fu7N3aAgAAAEAclTAmDy5XrpyZ50oDK533KiwsTDJkyCAJEiTwXg0BAAAAwNeDK4u2XGXMmNEbmwIAAAAA/+kW+M8//5gxV5oNMCK6TsscPXo0JvUDAAAAAN8Nrr788kvp0aOHpEqVKsIyKVOmlO7du5sACwAAAAB8nUfB1apVq6R48eKSM2fOCMvkypXLlFmxYkVM6gcAAAAAvhtcnTp1SvLkyfPIcnnz5pV///3Xk6cAAAAAAN8PrjQboKZcfxQt4zrBMAAAAAD4Io+CqwIFCsjGjRvlzp07EZbRdVomf/78MakfAAAAAPhucPXKK6/IlStXpGPHjnL79m23gVWnTp3k6tWrpiwAAAAA+DqP5rl65513ZOrUqTJr1ixZs2aNtGjRwoyvUkeOHJEZM2bIhQsXpGDBgtKtWzdv1xkAAAAAfCO4SpYsmaxcuVJatmwpq1evNqnZdSJhZbPZzHW1atVMAJY8eXLv1hgAAAAAfCW4UpkzZzYB1o4dO8y1ZhBUOXLkkBdeeEHKlCnjzXoCAAAAgO8FV40bN5YsWbLId999Z4IoAikAAAAA/s6jhBaLFy+Wy5cve782AAAAAOBPwVVwcLDbLIEAAAAA4K88Cq40O+C6devk3Llz3q8RAAAAAPhLcNWnTx+pVKmSVKlSRebOnSv379/3fs0AAAAAwNcTWuj8VWFhYSZDoE4SrGnYM2XKJEFBQeHK6jqd+woAAAAAfJlHwdXx48ed7uvcVnQRBAAAAODPPAqutNUKAAAAABDDMVcAAAAAAGcEVwAAAADwpIOr5cuXS6NGjSRbtmySJEkS6dChg33dsmXLpHv37nLmzBlv1BMAAAAAfDO4eu+996ROnToyf/58uXnzpknHroktLFmyZJEvv/xSZs2a5a26AgAAAIBvBVdTpkyRb775RkqVKiW7du2SGzduhCtTtGhRyZEjhyxcuNAb9QQAAAAA38sWOHr0aEmTJo0sWrRIMmbMGGE5DbD2798fk/oBAAAAgO+2XP3xxx9Svnz5SAMrlTp1ajl//ryndQMAAAAA3x9zFRAQ8MgymswiadKknj4FAAAAAPh2cJU/f34z1kqTWEREk1zs2bNHnnnmmZjUDwAAAAB8N7hq2rSpnD17Vnr37h1hmT59+sj169elefPmMakfAAAAAPhuQotu3brJzJkzTar1zZs3S4MGDczyI0eOyKhRo2Tu3LmyceNGKVmypHTq1MnbdQYAAAAA3wiudBzVypUrpW3btrJkyRLZvn27Wb5hwwZzUTVr1pRp06ZJ4sSJvVtjAAAAAPCV4EpppkBNxb53715Zvny5HD9+XMLCwiR79uwmsCpbtqx3awoAAAAAvhhcWYoVK2YuAAAAAODPYhxcWa5evWqudXLhqKRpBwAAAABf4vE8V2rBggVSq1YtSZEihWTIkMFcUqZMaZbNnz/fe7UEAAAAAF8Mrmw2m7Rv314aNWpkElvcuXNHUqdObS56W5c1btzYJLzQsgAAAADg6zwKrr766iuZNGmSZMmSRUaPHi3Xrl2TK1eumIvObTVmzBizburUqaYsAAAAAPg6j4KrsWPHSrJkyUza9S5dukiqVKns67RbYOfOnc06TdmuZQEAAADA13kUXB07dkxq1KghwcHBEZbRdVpGywIAAACArwv0dI6rqEwOnChRIpPkAgAAAAB8nUfBlSayWL16tT39ujs6/krLNGzYMCb1AwAAAADfDa4GDRokefLkkerVq5sAytWaNWukZs2akjdvXvnss8+8UU8AAAAA8L1JhBs0aGC6Be7cudMEUenSpZNcuXKZdSdPnpTLly+b2+XKlTNlHekEw6tWrfJG3QEAAAAgfgdXa9eutd/Weaw0mLICKkdbtmwJt0yDKwAAAADwNR4FV2QABAAAAAAvBFdWF0AAAAAAQAwSWgAAAAAAnBFcAQAAAIAXEFwBAAAAgBcQXAEAAACAFxBcAQAAAIAXEFwBAAAAgBcQXAEAAACAFxBcAQAAAIAXEFwBAAAAgBcQXAEAAACAFxBcAQAAAIAXEFwBAAAAgBf4VHC1Y8cOqVu3rqRJk0aSJ08u5cqVk59//vlJVwsAAACAH0goPmLNmjVSu3ZtCQoKkubNm0vKlCllzpw58uqrr8qpU6ekR48eT7qKAAAAAHyYT7RcPXjwQDp16iSBgYGyfv16GTt2rIwcOVL27t0rBQoUkI8++khOnDjxpKsJAAAAwIf5RHC1evVqOXLkiLz22mtSvHhx+/LUqVObwOrevXsyefLkJ1pHAAAAAL7NJ4KrtWvXmutatWqFW6ddBdW6desee70AAAAA+A+fGHN1+PBhc50/f/5w6zJnziwpUqSwl3EnNDTUXCzXr18311euXJH79+/HSp3jOn3dd+7ckcuXL0uiRImedHUAn8G+BcQO9i0gdrBvidy8edNc22w2/wiurGBIuwG6kypVKnsZd4YMGSIDBgwItzw4ONiLtQQAAAAQn4OsiOINnwquYqpPnz7SvXt3+/2wsDDTapU+fXoJCAgQf3Tjxg3JkSOHybSowSkA72DfAmIH+xYQO9i3xLRYaWCVNWvWR5b1ieDKiiAjap3SD0XatGkjfHySJEnMxZHOlYX/tfr5644ExCb2LSB2sG8BscPf963Uj2ix8qmEFtZYK3fjqs6dOye3bt1yOx4LAAAAALzFJ4KrKlWqmOvly5eHW7ds2TKnMgAAAAAQG3wiuKpRo4bkyZNHfvrpJ9mzZ499uXYT/OyzzyRx4sTSunXrJ1rH+Ea7Sfbr1y9cd0kAMcO+BcQO9i0gdrBvRU+ALSo5BeOBNWvWmDmtgoKCpHnz5pIyZUqZM2eOnDhxQkaMGCE9evR40lUEAAAA4MN8JrhS27dvN5H15s2bTU7+Z5991mQBfPXVV5901QAAAAD4OJ8KrgAAAADgSfGJMVcAAAAA8KQRXMWi48ePm0mI27ZtK3FB7ty5zSUu0fdG3yN9r+B71q5da/6//fv3px5PaH/RLtL6unU6Ch2MrI+fN2+ePG5aB31u/V8gfvKV/SgmOGbBH/A5jxmCK8SqSZMmmR1UrwE8fiNHjpQBAwaYWeU/+OADMy61UKFCPn8yCf594s5THLPgDzhRErsSxvL2EYesWrVK4pohQ4ZI7969JVu2bE+6KoBP+u233yRFihSyYsUKMy0FAM9xzALwKARXfiRv3rwS12TJksVcAMSOM2fOSPr06QmsAC/gmAXgUegW6AUPHz6UYcOGSb58+cw8W3qtZ7fCwsLclv/jjz+kWbNmkilTJjMGIjg4WLp16yaXL1+OsLuFTojctWtX86WePHlyqVy5suzatcv+46lly5Zme0mTJpVatWrJ4cOHI9xWROMgdBLm4sWLm23o87z33nty9+5dp/L37t2Tb775xswpliNHDlN/fd7GjRvL7t27ncpq96B27dqZ23qtz2NdIuvX69hc/fvvv0vNmjXNvGWpU6eWRo0aRdgH+Ndff5XSpUub+j/11FPSqVMnuXr1qk91WYnPNm7cKFWrVjX/yzRp0kiTJk3kn3/+CTdfXfv27aVgwYKmtUUv+j8dO3ZshNs9evSodO7c2exH1udRnycq3Xp0v6pSpYoEBgaaz3VURLeO+lnW+pw/f17atGkjGTJkMJ/RcuXKRTj+6M8//5R69erZP/d169Y13xvRYe3bx44dM/P9Wfue674wceJEee655+yvRW+7e+8c90ud7kK/Z/T/aHWh0vdfTZ482Wlfd/cao/Jdg8cjOt/pEXUF1c+X42fMXXej9evXS/369c3nX59DxwB+/PHHcufOnSh/zhTHLCByj/pO189ptWrVzG3tMu74OXf9rGpC8a+//tp0Jdd9J1euXOYxEf2+nT9/vtSoUUPSpk1rfg8XKVLEzDWrv5Mj6n67cOFCqVChgtlnfOVzT8uVF+gPuwkTJpgfF2+99ZaEhITIF198YQ4M7n5g6pe8fuG/8sor5oO0ZcsW+eqrr0z3na1bt5qDjyMtq1/Wul2ds0t/pP3888/ywgsvmOfQ7emBRQMs/bGqH9SXXnpJDhw4IAkSJIjSa/j2229l6dKl0qBBA6levbq5rTvUpUuXZPr06fZyV65cMYFgpUqVzA8+3YH0x+2CBQtkyZIl5gBapkwZU7Zhw4Zy7do1s7PpdvUgGB07duyQ4cOHmy+BLl26mAOhDsTfv3+/+aGpO65F3/8OHTpIqlSppHXr1uagtnjxYvO+6YD+RIkSReu54V36udYTDi+++KK88847JniYO3eubNiwwazLkyePKacnKfQzrIGH/ijRz49+FvX/f+jQITN+yHV/0s/6zZs3zX6gE4jrjxP9rOg+Fdn4n7Nnz5r6HDx4UGbMmBHl+fCiW0elZSpWrGg+l61atZILFy7IrFmzTJ137txpDkAW/WzrgebWrVvmB6D+CNU5/HRZsWLFovyea0CnvvzyS3Ot+63SH6qWd9991/zw1C5Ouv8onXxdf1ha76Er/c757LPPzH6p330nT540+7b+sNXyWkfd9y2uB8uoftfg8YjOd7or/SzpGD7Xz5jj50+NHj3aHBu1vAZYGtxoEDJ48GBzskIvri2r7j5njjhmAeFF5Ttd900NovREmJ5cdNxXHY8PqmfPnrJu3Tpzsk+PV/p51uBMf5fq/uuoT58+MnToUPPceuzSz7Qe43Ub27Ztk9mzZ4erry5bvny52f6bb74pN27cEJ+g81zBc2vWrNF5wmzFihWz3bp1y77833//tWXIkMGsa9OmjVn28OFDW968ec2ypUuXOm2nZ8+eZnn79u2dlufKlcssb9q0qe3+/fv25cOGDTPL06RJY3v//fdtYWFh9nVdu3Y16+bMmRNuW3px1K9fP1M2derUtoMHD9qX37lzx1agQAFbYGCg7fTp0/blISEh5rW5+uOPP2wpUqSwvfDCC07LJ06caLav1+7oe6Prjx07Fu491cvMmTOdyrdq1cosnzFjhn3Z1atXzXMnT57c9vfff9uX6/tVvXp1U971dePxcPxfjhkzxmmd3tfl9erVsy87evRouG3o/7FmzZq2BAkS2E6cOOH0WcyWLZv5jC5ZsiTc406dOhWuHvp5V4cOHbLlzp3bljJlStuKFSui9ZqiU0dlvf4333zTfAdYxo0bZ5Z36dLFqXyVKlXM8mnTpjkt79Onj31bjvvLo7jb79W6devMtp5++mnbtWvX7MuvXLli9n1dt379erf/ywkTJoTbntbJ8fvOVXS/a/B4ROc73XU/etRnTP3555+2hAkTmmPkpUuXnNYNGTLEbG/EiBFR/pxxzALci853ekT7suvnPDg42HbmzBn78osXL5rfnXrsDA0NtS9fvny5KV+7dm2n38L62/SNN94w63755Zdw+5nur9E9BscHdAuMoSlTppjrTz75xHTXs2jkrmdyHW3atEmOHDkiderUMWcAHOnj06VLZ7o56BkBV9qsmjDhfw2NLVq0MNcPHjyQQYMGOXVbsNbt3bs3yq9D66rdnCzaTUG3o02/embdos3C7gbyPvPMM+ZsnZ4F1LNu3qBdH11bE7Q7lnWG0KJnGfUsv56l0bP8Fn2/9L3Bk1egQAHT5cWR3tf/16JFi+TixYtmmdW1zJH+H9944w3TrUDPcDv+30+fPm1abLUFylX27Nnd1kU/O9qKdPv2bbM9bQGOjujU0aLfDdripd0PLdpFUB/n+FnWs/N6lrBo0aLy+uuvO23jo48+CndWMSb0rKXSs5B6htGiZ/a1NUK56x5YsmRJe9cpT0T1uwaPR2x/p//www/mOKVn03Xsn6MPP/xQMmbMaFqOo/s545gFeOc7PTJ9+/Z1GmOoPau0VVd7i2hPDceWZKXd45M7/BbW36bamqXX7vZz3VZ0j8HxAd0CY8gKYLTLgSvXZVb/bscmWIs1bkObR/UD++yzzzrtGDlz5nQqb33Y9Ys5WbJkbtfpWKyoKlWqVIQ/TrWbhKM9e/aYrg/aJevcuXPhDkzaLcMbA36jWifrf6A/mF1pX2PHoBRPhnZpcwwslN7X5To+UP+H+gWrX9h6IkG7HuiJCA2AHDl+prWrnNIxGVGlXRS0257+oFu2bJnTDxuLHnxc+51rdyGri1B06ugYXOo+7kg/lzrOIqqfZX281sFxDJM+1uqS5Sgq6XUj+z6y+uPrvu4qoi5isfFdg8cjNr/Ttduv0v3NXcZa7f6mXXOj+znjmAV45zvdG59p3c81qNLuru7oyQ93+3nZsmXFF7EHx5AOiNcfia7jpJT+cHJk9SV1XW6xvtxd+5xqn2xX1pdvZOuiczYusu04DkTUfvDav936Uas/TvVHnzUxqR40QkNDo/y83qiT9X5pP35XEf1v8HhF9Jm3lut+pC22elDQRC0lSpQwY5P0TLf+z63+4Y6fLX2Mik5KZD346Blj/exa47zcBVfaeuRIxw1pYBPdOkb2WVb6OMfPsvWa3H2W3b2PenDTwcWeBFe63+j+oYGmu+fRfdpd//eI/pfe3q/xeMT2d7qOeVKu4zMe5VGfM45ZgHe+073xmdb9XFuo3R2PLK4nIr1xPImrCK5iSJtetRuCnvly/UBr4gl3H1LX5RY9o+ZYLi7SA6QeiLQFwPWsm565iE5XRG+x3i9NEuDK+t8wJ8mTFdFn3lqu+5F2ldGgRbvKjBs3zqnczJkz7V0eLFYXOe0aGFVvv/22aVkaP368vPbaa2bgu+tZ4ogy+Kno1jG6rK4c7j7L7t5HDfr+N6zLs/1G9w/tkun6I0+fX7fr7rvIsQsy4r/Y/k63PkP6o06zgUWVtz5nHLPgLzz9TvfWc+s+q5/d6PDV4wljrmLIyt6lX9yuXJfpme6IfrxpRK/Zk7Tp1LEfeVyj3aB0bJjrQUrT6Vqp4R1Z2Qpj84y09T/QMW2utOuYnk3Bk6X/G9fUrXpfzyrrl6v+D/WzZfXBduVu/7K6E2hX2qjSs3o//vijGe+lGTd1XFN0Ph/RraOnn2XtvuRKW9yi26UjMpF9H1nLopMt7XHs63jy3+kR/e8j+r9rNzfH7oGPG8cs+IvofKd7+3Ou+7lOJ+RuGiB/RHAVQ9otSH366adOTZ56Nt01jbGOL9GJfDX968qVK53W6SBW/WDqgNy4PNmnznGgqa41lbZFd84PPvjAnpTAkR7U1KlTp2KtTvpDV7t5aGuE9eNX6QFKB2Piyfv7779NUONI7+tyTaWurb762XIXWGgXPdfHqpdfftn0/Z42bZoZz+EqohYtDeZ0kL2mStYAS/e5qP6YiW4do0vHVuqg+H379oVLS65pqb05JkkTaijtxuHYVUS7JlpdO6wyUaFjQ/W9jc19HU/+O90d/Z7XM9Y6XYgrTa+srcM6BYNrOnWln+lHzacVExyz4C+i853u7c+5poC3ErhcdjNnq/bM0umB/AXdAmNIBwlqRiOdtE2TUOi8N9oFQeew0XlwdO4qx7PmOp5DMwXqfBtNmzY1X/w6z5WeVdDAS7OqxGV6gNSWAj0LqBMh67wdWnf9IatjUVzPmDz//POmNU4H3esBzuo6qZNHeot2D9N5xXQuFB18qXMdWXOGaKaorFmzhkumgMdLP/P65av/E83SpT90dD42HVtgnYTQ+W+0m5sOPNc5YXTuJ03uovuQ7le//PKL0zb1f6vBkWYK1Ayceq1nhPWgoi08emY6oh9tGgTo3Dv6udBr7S6h3foeNZA8unX0xHfffWdOxOjcNzomxJrnSrONaZIcb7SQKQ3idH/WLG76OnRSZ30fdE6Uf//91/y/tExU6Y9FTUKg2df0pJPWW99fvW0FpYj/3+nu6Jgm7Xmh+6F+RvUEoX529KKfre+//166du1qemXosU+PdZoYRueb0hMTOh/dmDFj4sTr45iF+Co63+k6KbB+zvS4p585PVGpx0V9vGOmwajS46+eGBg4cKDky5fP3NfvfQ20dF5IPW5pI8LTTz8tfuFJ54L3BQ8ePDDzdeTJk8eWOHFic/3ZZ5/Z/vnnH7fzvuzbt8/2yiuvmHmwEiVKZOazeO+998z8Aa4imz9Et61z4kR1vpnI5rnSOQ9cRTTfh85VULJkSVuyZMnMa2jWrJntyJEjbuf/UIsWLbKVKVPGljRpUvtcIFGZM8Td/AuRzaUze/ZsW4kSJWxJkiSxZcqUydaxY0fb5cuXzXwiOscKHj/H/+WGDRvM51XndkmVKpWtUaNGtsOHD4ebQ6pJkya2jBkzms+Xfm503pjIPhO6n3Xo0MGWPXt2sz/p/75q1aq2KVOmuK2HI52D46233jLrGjdubLt3794jX1N06xjRfhrZ/r1//35b3bp1zWdX5xOpU6eOWRbRPhaZyL5DlM4lpK9BX4v1etzNL/SoeVGs+cO03joPSkBAgNN3iyffNXg8ovqdHtFn4ObNm7ZOnTrZsmTJYuZ6c1dm+/bttubNm9uyZs1q9lN9Hn3O3r172w4cOBDlzxnHLCByUf1O37p1qzk26THGdQ7FyI41ke2DOmdV/fr1zfFR9/PMmTPbnn/+edvAgQNtJ0+e9Jvv/AD986QDPCC26BkTPYOuZyy1NREAgLiKYxYQ/9HuDJ+g3Tdc0+nevXtX3n//ffs8RQAAxAUcswDfxZgr+ATtt6/psXUeE00KoIOrV69ebeYe0vEAr7766pOuIgAABscswHfRLRA+QdN/6mBKTe1tZYDSQZV6gNKsUDqIGQCAuIBjFuC7CK4AAAAAwAsYcwUAAAAAXkBwBQAAAABeQHD1GOgEiTo5mw5U9VX6+nRCRgBA/KfHK/1e1+NXXKCTd+sFAOI6gisv0Vne9UDUv3//J10ViJj/g/4/9P8CAAAAPA6kYgcAAHHaqlWrnnQVACBKCK4AAECcljdv3iddBQCIEroFeqkLWrVq1cztAQMGmO5o1sVxnJVmvf/666+lUKFCkiRJEsmVK5cpHxYW5rS9SZMmmcfq9cKFC6VChQqSMmVKp/7mOuFgt27dJDg42GwrU6ZM0qxZM/njjz/C1U/HQun2ojMe7M6dO/Lhhx9Kjhw5zHwbRYoUkR9//PGR3R/Pnz8vbdq0kQwZMkjSpEmlXLlyEXbNO3HihJlEMVu2bJI4cWLJnj27uX/y5Mlo9bd3fX16X99Xpf8X639Bf30AcPbw4UMZNmyYmWNJv+v1esiQIeGOSxY9xuixRo85euzRY5Aeiy5fvhzh9/b169ela9eukiVLFkmePLlUrlxZdu3aZcqcOXNGWrZsabanxwydVFfngIpoWxF1//7pp5+kePHiZhv6PO+9957cvXvXqfy9e/fkm2++kdq1a5tjm3XsbNy4sezevTvcczoei5cvXy7ly5eXZMmSSfr06c1xzt1rVnv37pXXX3/dHNP0ObQ+L774ojmeu5o/f77UqFFD0qZNaz/WjhgxwvxfAMRPtFx5gf6Y1+Bk8uTJUqVKFafEDmnSpLHf7tmzp5mVvV69eubLfd68eebgoF/4gwcPDrfd2bNnmy90Lf/mm2/KjRs3zHKdcPD555+XI0eOmOdq3ry5HDt2TH755RdZtGiRLFu2TCpWrOjx69EvdX3ONWvWyLPPPiuvvfaaXLlyRXr06BFp0opr166Z502dOrW0atVKLly4ILNmzTKvdefOneagYfn7779NWX0t9evXl2eeecYctCdMmGAOQBs3bpQCBQp4VH9rALa+13oAtA7Ijv8LAIBI586dzfeuBklvvfWWhISEyBdffGEmt3Wl38v6fa7HrFdeecV8t27ZskW++uor+e2332Tr1q3mxJojLVuzZk2zXZ0gV0/A/fzzz/LCCy+Y59DtafChAdY///xjvv9feuklOXDggCRIkCBKr+Hbb7+VpUuXSoMGDaR69ermtp7I1JOQ06dPt5fT45gGgpUqVZK6deuagObo0aOyYMECWbJkiaxfv17KlCkTbvu6Xo+teqzSAEvLTZkyxRyD9T1xNGfOHHPM1JOpWr5gwYLmWLht2zYZP368WWbp06ePDB061Jxg1ABPj50bNmwwvxW0vP4GABAP6STCiLk1a9boZMy2fv36hVvXpk0bsy44ONh25swZ+/KLFy/a0qRJY0uZMqUtNDTUvnzixImmfGBgoG3FihXhtteuXTuzvk+fPk7LFy1aZJbny5fP9vDhQ/vyKlWqmOXuWHU7duyYfdm4cePMsjp16tgePHhgX/7nn3/agoKC3L5OXaaXN9980+m5rW116dLFqXy1atXM8h9++MFp+XfffWeWV69e3Wl5rly5zMUdd69P66fL9P8CAIj4uFWsWDHbrVu37Mv//fdfW4YMGcw6PUYo/V7PmzevWbZ06VKn7fTs2dMsb9++vdNy/c7W5U2bNrXdv3/fvnzYsGFmuR7/3n//fVtYWJh9XdeuXc26OXPmPPIYYH3Pp06d2nbw4EH78jt37tgKFChgjqGnT5+2Lw8JCTGvzdUff/xhS5Eihe2FF15wWm4dixMmTGjbuHGjfbkeF6tWrWrWbdmyxb783LlztuTJk5vLrl27wj3PqVOn7LeXL19uHl+7dm2n917fizfeeMOs++WXX8JtA0DcR7fAx6hv377mDJ1Fz/DpmbabN2/KoUOHwpXXdXp2z/Us4IwZM0y3hI8//thpnZ6J0zOEevZv06ZNHtdz2rRp5lpb0xzPHBYuXFhat24d4eO0u4d2LwkM/O9jpS1HCRMmlB07dtiXabc/bRXT7XXq1MlpG2+88YbpNrl69Wo5deqUx68BABA5bX1Rn3zyifn+tmhLinarc6THFG2pqVOnjmltcqSPT5cunemap8coV9rNTY8DlhYtWpjrBw8eyKBBg5y6dVvrtGtdVGldtYXIol0DdTvatVF7TVi0i56+Nlfac0K7kGuL1P3798Ot15Yo7Z5v0eOiHtuU47FNe6/cvn3b9PIoUaJEuO1oN0HH1jY1duxYp/de3wttzdJrPdYDiH/oFvgYlSpVKsIvW+1S56ps2bLhlh08eNB0r9ADgfb9dqXLV6xYIXv27DFdHzyhBzX9snd3cNADjB4M3NFufClSpHBapgfUp556yun1ad2UdqF0HQumgZn2x9fXqeW0XzwAwPusAMbdscJ1mTUmyV3XcP3eL126tOnGricKtTu5Rbve5cyZ06m8dZIxf/784Y5j1jodixUbx1Y9rgwfPtx05zt37ly4YEq7EjqeBI3O9rdv326uddzYo2gXSj3OapdMdzRA1OMggPiH4OoxSpUqVbhl1tk8d4NXNShxZY27crdOWQcFq5wn9LERBTURPW9Er896jY6v73G8BgBA5DTRhJ7Qch0n5e772dPv7ciOe5Gtc9eCFNNjq47x0jFZVgCkwZ0GhnqST8dAa7AZGhrq8fb1/VTuWsdc6fgvbbmzki+5o61gAOIfgqs4zF2GP+tLXgcFu6Nn4hzLKaubnn6RO3bNcDwYuD6HJppwJ6LnjQ5PX4O77iYRvQYAQOQ0gYJ2ndPWmowZMzqtc/1+9uR7O67Rru4aPGnSCNekT9qSFJ2uiO5YSZNOnz79yOy0+j7pMV7fewC+hTFXXmKNTYrt9Kk6HknTtWo/b02X7spKe64paR27ZVhf+I70oOruYFKsWDFzxszqvufIXQap6LLqpv3b/5cL4z96X5e7ew2acUkDREdaT3dpex/X/wMA4iv9rlcabLhyXWZ1E3c3tYZ+D//++++mK5vj2Ke4RseM6dgw18BKj6VWaviYsLrya/fIR3nuuedMKnd3xy8A8RvBlZfoF7aK7SQMOh+UDtTVs106F4kjTT+radh1nhLHwbdWalmdq8ORptvVFO6udH4OpQkzHOc60f7fOmA3prT/vY4N+/PPP8P1N9fxXJqCV7tuOHZN1Neg3UQc0+pqIKapbN11nXhc/w8AiK90ygz16aefOn2P6ok4Ta/uSI8pOpGvpixfuXKl0zpNSqGBgh6b9BgVV+ncklevXjXHHouegPvggw8i7K0RHZrkQrsZjhw50u3JSccTnO+++665bt++vdv5srQlUI+FAOIfugV6sUUpa9asMnPmTJORSAe7apP/O++84/Xn0ox8OoeTHtC0JUnPgOk8Wzonhg4OnjhxolPGvnbt2pkBvDqnln7h6wFSzzLqvFKaVEK35UjLT5061czroWcrNTuU9g/X16bZCHUeEsfte2L06NHm7KFmC9TtaeZAPeDpfCLaPUXXO3r77bfN6+rYsaNJ2KFl9MyqDibWs6+uLXDW5MEfffSR2a52f9EuG7odAMD/vif1+16/WzUJRaNGjUy3OZ2fUCeA17mrLPqdryfoNFOgZqZt2rSpCVZ0nittzdLjima5i8v0eKytSnrs0YmQtReI1l2DHk3UEdGE91GlExJrBkade1JbsV5++WXTkqcnQ3XeKu0qqGO7lE4qrBmEBw4caE6I6n19PzXQ0oy/enzTY/zTTz/tpVcP4HGh5cpLtBvar7/+ag5Imj5VU9PqF6eeJfM2DSz0i1rPfGk3B01zqwFHw4YNzXLXLg86AFlTn+ss8Hpg+fHHH02goX3M3fUL19eyePFik05WDwpffvmlScOrZ+Os9LMx7VevBxwN8HTCX82w9Pnnn5uujnqg12vXCYR1AmJtmdOsTTpZsgZ/GpBpcOlucmBdpz8YdKD2N998Y/4X+j4BAP6jxwPtBaEnozQ9uLZMde/e3Xzvu9Jjix43dJoQPZbod6r2ftBU6LrcddxWXFOvXj1z/MiTJ4+ZckRTx+uJUT0GaWDjDRqg6nFYrzUjoR7b9ASinnx1nXpEWwz12K2ZGVetWmV6k2hAqwGungy1epEAiF8CdLKrJ10JxB/aVVAHBWvwpS1aAAAAAP6H4ApunT17NtxcH3/99ZdpmdOWLZ2DRAcvAwAAAPgfxlzBra5du5pxXNpvXDP1afdD7dqgSSXGjx9PYAUAAAC4oOUKbmlWvjFjxphsRTqPlGZA0ox9Og5LBzQDAAAAcEZwBQAAAABeQLZAAAAAAPACgisAAAAA8AKCKwAAAADwAoIrAAAAAPACgisAAAAA8AKCKwB+S+dyCwgIkKpVqzotnzRpklnev3//x1KPtm3bmudbu3at+Ap97/Q16Xvpj/R/qa9f/7cAAP9BcAUgXgdC8UHu3LlN3YG4zhcDfQv7IYDHIeFjeRYAQISGDBkivXv3lpw5cz7pqsBLypYtayZhT5069ZOuCgDgMSK4AoAnLEuWLOYC35EsWTIpVKjQk64GAOAxo1sggHgxfic4ONjcXrdunenaY10cx7Rs2LBB3n77bSlatKikTZtWkiZNan7gaqvQtWvXvFKXkSNHSmBgoNnuqVOnojTu5sSJE+a+Y721i9KjumI5dmP67rvvpEiRIuY16XsxfPhwsdlsZt2uXbukfv36ki5dOkmRIoU0aNDA/pyu9DEzZsyQ6tWrm/coKChInn76afMe37lzJ9rvx4IFC+T55583wUT69OmlSZMm8vfff4crFxoaKhkyZDDlIvpfbN682bzeKlWquB27tX//fnn55ZdNvZMnT27K6WNchYSEyPjx4837kCdPHvOepUmTRipXriwzZ850+9yO/4OVK1easilTppRMmTJJp06d5Pr166bchQsXpEuXLpItWzbz3mkLlbsudI8ac7V06VLzWp566ilJkiSJ5MiRQ+rVqydz5sxxKqf/x65du0qBAgXMe6f/42eeecbU4dChQxIV+j+fPn26VKxY0Tyf1luf74UXXjCfK4vWd/LkyeZ2tWrVnD6v2i3Xtf4vvfSSZMyY0dRf3+fu3bvL5cuXI31vly1bZrat/w9d5vhZiM42lX5eBw4caN8vtJXQ3f84KvuhbkPvR/Se6r6eIEECs+9Z+53j2Ex9nH72dR/Qz2aFChVk8eLFEf5PdHv6XZU3b17z/9D/q/7/3X2eAcQzNgCI4+bOnWtr0qSJ/qKxPfXUU7Y2bdrYLz/++KO93HPPPWcLCgqylS1b1pR/6aWXbFmyZDGPe+aZZ2w3b9502u6xY8fMuipVqjgtnzhxolner18/p+V9+vQxy0uXLm27ePHiI+t94MABU8fkyZObxznWu0ePHvZyel/Xr1mzxunxuXLlMsu7detmS5o0qa1u3bq2evXq2VKmTGmWf/LJJ7aNGzfakiVLZitZsqStWbNmtnz58pl1efPmtd25c8dpew8fPrS1aNHCrE+RIoWtatWqtkaNGtly5Mhhlun75vqYyIwePdo8LiAgwFa5cmXbq6++auqcOnVqW8uWLc06fS8t3bt3N8u+/fZbt9tr27atWT9t2jT7Mv0f6LK33nrLvM5nn33WPE+xYsXMcv1/79+/P9z7ruuyZs1qq1atmimv/+NEiRK5/b86/g/effddW4IECWwVK1a0vfLKK7bs2bPbPyP6P8+TJ495jbpN/bzpuiRJktj27dvntD39X1r/c1fW+xAYGGirUKGC+Z/o9tOkSWNel+XkyZO2dOnSmbL58+c3n+mGDRvaSpQoYd5zx/c2Mh988IG9njVr1jTPp+9LxowZzWtxfA/0c6Nla9eu7fR5dfy89+rVy5RJnDixqb++T1o/63N37tw5t+9tp06dTL3LlClja968ubm+du2aR9u8ceOGrVSpUma9vg4tX6dOHfMarf9jdPbDr7/+2qzT98qd/v37m/WDBg0K9z2hn3X9zAcHB5vXpfuCvk69TJgwIdy2Nm/ebEubNq15bMGCBW2NGze2VapUyZYwYULz2Zs5c2aU/q8A4iaCKwDxQkSBkKPFixfbf6xZQkJCbJ07dzaPHTBggEfBlQYl1jb0R6n+sIsOK0iKyKOCKw0S/vnnH6cfi/ojUoON3LlzmyDHEhoaaqtevbp5nOsPu+HDh5vlGlSdPXvW6TEdOnQw6/RHblQcP37cBDYasCxdutS+/N69e7bXX3/dbMs1uDp06JD5wekYQFiuX79uXo/+6Lx792644EovX331ldNjNOjU5a1atXJafunSJduKFStsYWFhTsuPHj1q3i8NavR/7+5/oOt+++03+3L9XxcpUsSsK1y4sPkhra/R8vHHH5t1rVu3jlJwNXXqVPv/dPfu3U7rNLBdvny5/b4Gz1r27bffDvd+nThxwukzERF9L/WzogG5vn5H9+/ft61fvz5Kn0XLzz//bNbre3L48GH7cn2vrfpq4Olum3pxFzh4sk19T9ztj7pvZMqUyaxbuHBhlPdD/d7Qz58Garo/ONL9P2fOnCbwOX36dLjvCev/r++nRZ9by+s2//33X6fPuZ7w0XWOJxHUjh07zOdfT3xcuHDBbT0BxH0EVwB8JriKiP5o1bPC2roT3eBKf2g1bdrU3NdWAw3WoiumwdW4cePCPUZbnHSdtrC4mj9/frgf9vrDL0OGDObsvWsrgPUeZc6c2fy40x+Tj2L96HUNKqzgRn9UugZXygr8tm/f7rYVzLHFwTG40tYMd8+j6xxbXx5FWzr1MdpS4e5/oMGTKw3qdF2qVKlsV65cCfejXANG1zpEFFw9/fTTEQYZrrp27WrKzps3z+ap8+fPm20UL148SuUfFVxZLYaurYVWMKTPo4GDY0uXtU1tSfbGNm/dumVacjUQ1mDKldUK9cILL0RrP2zfvr1Zr8GeoyVLlpjlL7/8stvvCQ2GXD8XSgNCXT9w4ED7slGjRpllji3Xjr744guzXq8BxE+MuQLgU06fPi1jxoyRbt26Sfv27c14Dx2zkjhxYjl8+HC0tnX79m0zDmL27NlmO7/88osZC/K41apVK9wyHY/yqHVnz561L9NxWZcuXZLy5cubcTeudMxKqVKl5OrVq1F6n3R8m2revHm4dTruxF291BtvvGGuf/zxR6fl1v3OnTu7fZy77enz6FgVx9fpaOPGjTJo0CDz/2/Xrp35H+r/UkX0GiN7P0uXLm3GeznScT6R1cHRmTNnTAZBHW/UrFmzR5bX/4f66KOP5LfffjNjyaJLx4xlz55d9uzZY8YeHj16VDyl48327t0r+fPnN2OUXOn4Ix1r9PDhQ9m5c2e49TrGzBvb1Ou7d+9KyZIl3SYNadWqlbnetGmThIWFRfn1xeSz6fq5UC1atHDaV9Ty5f+vvbMJqaKLw/i8UNsWtYkKgiiCFkKLyIKWYUWRRCFY0MJ2YiCFURlRYBlo6aJFIRl9CLVIREJ4g0pb9IFuIqRFEeSmNi1SVwm+/P5wLsdx5t6ZudP1431+cLtw597TmTNn5Dxzznmef+39yJEjkWXt2bPH3j98+JC43kKIxYXcAoUQy4abN2/aAPLPnz+5lNfV1RXMzMwEBw4cCO7duxeZkfP58+egvb193ufUIy+3OMwTwmBcUeoYJhIOZ0jw4sWLklk/iLCtW7eWFAqwcePGyOO+YYdPbW1tsHbtWjPV4HpRV4QfL4wxMGuIAoEQBaYTv379mvMZ5hMMXl++fBlb/8nJyVza2h2PM13wcQYoiLUkeUuIQQbjT58+NcMSjA927NgR7Nu3zx4c0I5JwKQCEXzjxg17cc0wA+Gz/fv3B0lxfQhhmqQPhYmKGshSput7cX0M8YropR/wsAARngTaFsGGocm3b9/MvOLnz5/B4OCg9T/aPYpS94Crr3++CMYk5yqEWHpIXAkhlgXv3r0Lzpw5Y4Oq7u5uCxtm8OlmmtatW5dodsGHgefIyIgNcHFxO3r06Lzv/Pjxo+CwFh4Y5yWucCfMcszHPcHfvHlzyYFd0sFoFlauXGnC4Nq1a+bqdurUqaCnp8eO4cpX7nnCuXPnTFghIK5cuWIzIgy4cXvjWtbU1BQc39L8P2nqkAfU98mTJybUBwYG7Jzev39vMyEIetz1mIksBc6QX758sdkvfoN73oMHD+yFwx0zsmn6EPcVbViMKMGBOMy7zDiyhgUze8UMFW6TzHpyb/Owhj7L9SgXd778LcFVMA7Z+AuxdJG4EkIsC/r7++29ra0tOHny5JxjLCFCBKWFp9gXL160ZT8s8WFwHV7Og4iLG6gvJtzMD4M2LKTLhVwu7Kext962bdu843FW8MDgFXHAcqv6+vqgr68vWLVqVVBXVxfk1RcYCGMTT7k+5SyLKxfsz10d6DNJBcD27dvtheX379+/7f3WrVu29DXp8jHagbbm5R5GHDt2zB4aYBnO7GzSPoSlfh59KGuZPCgp1seYscLinaWuUcv1ikH7nD17Nujt7bV2Rvhz3zc0NMT+Jq4e7nNXX3e+3DcIZrfsUwixvNCeKyHEkoA9U8AyvShY/hO3fIx9NlkF0M6dO+1pPwM1llExg5B33SsBS56Y1SMnLLyMLgtubwhL1sJQvttbEjcDwRIrhEFra6sNho8fP245TnlAX0BMhIVVXH0rBYNsMsUY+Lu9X2nhnK5fv27C7NOnT5nrUl1dXdib5JdTrK9ybyHOx8fHI7PMspClTEQJ9yN7r6L2zj169MjemaH1ZxuT3IfMJp04ccKW8rW0tFj5zKhFLWl00Nejsttc3hb5Yo69e/fOeRgkhFh+SFwJIZYEPNlmSdnXr19tc3sYQlaB5Tz+nisGbSwTKwf2AiGwWGKIEQF7MNLgnlwnDX39G1B3BovsNWL2LWoGBzOQhw8fJioPgwjKJJyWPSoO2r65udnMQJKYBzADU2pJYFroCwgsltT58H+9evUqWEiYsQDCcT9+/DjnGIYV7IlzcC2iBNTQ0JA9LHAzYcX4/v27zQiFA6L5v1xb+OWU6quXLl2ypW0sJ8QkIwx7z8KGEKVIWyYCiGV6/KaxsXFOX0OgsZwPTp8+nek+TNs3p6am7Hr6oo1rhJBHBHKvOAh/xmSEEPC7d+/OM9ygDIKWyxHOQogFZqHtCoUQIimHDh0qBAKTbUQ2k8tywpYbK3GOE+ZJoC5WzOQwYaUeZcOcNkT4zZs3ZmVO0KmfhVSKzs7OQgAyIaPU28+TKmXFHoWzKI8Kko07LyzWaTcX1koILvUhxJQ2jcugioMwYJcNRXYWZZEjRaCqy7qKC7qdmZkphBcTyhxHsfOMayPyg1z+EOGshOaSUUU9m5ubIy3Si1mQFwsEjqtDsd80NTXZMRdWTP1ov3CI8OHDhwshusQA8L3q6mq7TpxL2DI8CrK0KANrfMJt6+vrrVzynFzb+/ECo6OjVj4ZZnyPvsqL+8tx4cKFwnUn3oD7ixBfwo05J65/0rbNWqYfIkyuFd8nZJt6R1n6J7kPfXbv3m3f5W+Kn18V9XeCvu6HCHPf0YYc80POHW/fvrVYBI5zDxB+zHUhpoA+wOcEpwshliYSV0KIJQOZPYgDBjwMuMKD14mJCRukrF+/3gZZZAq1t7fbQD4PcQXDw8MmsAhmJf8mCQzOCJtlkIzYC2czVUpc+TlYZA4xKKU+vDNQbWlpmR0bG5tNA4NARBq5Q2RkMSAne6iUKAIypfjOnTt3chVX8Pz5cxMihOcyYEVov379Olb0VFJcuWtQU1Mzu3r1ahO6GzZsmD148ODss2fP5vS1xsZGy3las2aN9elNmzbZAJ7A2SQgQhAVCA+EL2VQFqKKzKXp6el5v3n8+LEJHK6pE6nh0GXqhqAhDJk+RJlVVVUW7suxtOIqbZku74pgcISzC0pGrPb19WW6D31cOPT58+dj6+v/nRgfH7e+zz1Au+3atWteiLEPId7cbzzUQPjyol6Ucf/+/dnJycmibSWEWLz8wz8LPXsmhBDi/wXL1LA2ZxkU+1uwVBdiMcCwiL1xLDHEZdHlnIVhuSVL/i5fvmzmF0IIAdpzJYQQouLcvn3bTABwdpSwEosJrOnZl4WDYpywEkKIOGTFLoQQoiJgTIC5CMGs2H8TvusMHoRYaMhcQ/CTB4aVPxlpQgiRFokrIYQQFQGnQtwcscQmt6mjoyPSOl+IhYC+uWLFimDLli3B1atXlUMlhMiE9lwJIYQQQgghRA5oz5UQQgghhBBC5IDElRBCCCGEEELkgMSVEEIIIYQQQuSAxJUQQgghhBBC5IDElRBCCCGEEELkgMSVEEIIIYQQQuSAxJUQQgghhBBC5IDElRBCCCGEEEIE5fMfIGQ2u/0oMokAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1000x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Figure 5: Enjoyment Percentage at Different stereotypes\n",
+    "cur_balance_type = None\n",
+    "meta_name = \"how_enjoyable\"\n",
+    "\n",
+    "four_types_dict_enjoy_percent = {'dominating_throughout' : [], 'back_and_forth' : [], 'alter_dominance' : [], 'no_label' : []}\n",
+    "\n",
+    "data = three_types_dict\n",
+    "\n",
+    "for idx, v in data.items():\n",
+    "  four_types_dict_enjoy_percent[idx] = v\n",
+    "\n",
+    "data_dict = four_types_dict_enjoy_percent\n",
+    "\n",
+    "x = list(data_dict.keys())\n",
+    "y = [round(get_convo_lst_high_enjoy_percent(corpus, data_dict[key]), 2)*100 for key in x]\n",
+    "num_of_convo = [len(data_dict[key]) for key in x]\n",
+    "y_err = [bootstrap_95_percentage(corpus, data_dict[key]) for key in x]\n",
+    "\n",
+    "lower_errors = [y[i] - err[0] for i, err in enumerate(y_err)]\n",
+    "upper_errors = [err[1] - y[i] for i, err in enumerate(y_err)]\n",
+    "asymmetric_error = [lower_errors, upper_errors]\n",
+    "\n",
+    "x_label = ['dominating\\nthroughout', 'back-and-forth', \"alternating\\ndominance\", \"other\"]\n",
+    "\n",
+    "def make_plot(x_label, y, asymmetric_error, plot_name=None):\n",
+    "    plt.figure(figsize=(10, 8))\n",
+    "    plt.errorbar(x_label, y, yerr=asymmetric_error, fmt='o', capsize=5, capthick=2)\n",
+    "    plt.xlabel('talk-time dynamics stereotype', fontsize=15)\n",
+    "    plt.ylabel(f'percentage of speakers reporting maximum enjoyment', fontsize=15)\n",
+    "    plt.xticks(fontsize=14)\n",
+    "    plt.yticks(fontsize=14)\n",
+    "    plt.ylim(0, 60)\n",
+    "    plt.xlim(-0.3, len(x_label)-0.7)\n",
+    "    for i, value in enumerate(y):\n",
+    "        plt.text(i+0.16, value + 1, f\"{str(int(round(value)))}%\", ha='center', va='bottom')\n",
+    "\n",
+    "    for i, value in enumerate(y):\n",
+    "        plt.text(i, 7, f\"N={str(num_of_convo[i])}\", ha='center', va='bottom')\n",
+    "    plt.grid(True)\n",
+    "\n",
+    "    if plot_name is not None:\n",
+    "        plt.savefig(plot_name)\n",
+    "    plt.show()\n",
+    "\n",
+    "make_plot(x_label, y, asymmetric_error)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of pairs found: 93\n",
+      "Balance p-value:\n",
+      "\tU Statistic: 1975.0\n",
+      "\tP Value: 0.4199255535954207\n",
+      "Enjoyment p-value:\n",
+      "\tU Statistic: 3837.0\n",
+      "\tP Value: 0.020640740356370518\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Controlled comparison between back-and-forth and alternating dominance stereotypical conversations that are paired by their conversation-level imbalance\n",
+    "def find_closest_pairs(list1, list2, x=0.005):\n",
+    "    list1final = []\n",
+    "    list2final = []\n",
+    "    for dict1 in list1:\n",
+    "      idx1, score1 = next(iter(dict1.items()))\n",
+    "      closest_dict = None\n",
+    "      min_diff = float('inf')\n",
+    "      for dict2 in list2:\n",
+    "          idx2, score2 = next(iter(dict2.items()))\n",
+    "          diff = abs(score1 - score2)\n",
+    "          if diff < min_diff:\n",
+    "              min_diff = diff\n",
+    "              closest_dict = dict2\n",
+    "      if min_diff > x: continue\n",
+    "      idxf, scoref = next(iter(closest_dict.items()))\n",
+    "      list1final.append(idx1)\n",
+    "      list2final.append(idxf)\n",
+    "      list2.remove(closest_dict)\n",
+    "\n",
+    "    return list1final, list2final\n",
+    "\n",
+    "interleave_balance = [{idx : corpus.get_conversation(idx).meta['balance_score']} for idx in three_types_dict['alter_dominance']]\n",
+    "backforth_balance = [{idx : corpus.get_conversation(idx).meta['balance_score']} for idx in three_types_dict['back_and_forth']]\n",
+    "# print(len(interleave_balance), len(backforth_balance))\n",
+    "# random.shuffle(interleave_balance)\n",
+    "# random.shuffle(backforth_balance)\n",
+    "control_interleave, control_backforth = find_closest_pairs(interleave_balance, backforth_balance)\n",
+    "print(f\"Number of pairs found: {len(control_interleave)}\")\n",
+    "control_interleave_balance = [corpus.get_conversation(idx).meta['balance_score'] for idx in control_interleave]\n",
+    "control_backforth_balance = [corpus.get_conversation(idx).meta['balance_score'] for idx in control_backforth]\n",
+    "u_statistic, p_value = wilcoxon(control_interleave_balance, control_backforth_balance, alternative='two-sided')\n",
+    "print(\"Balance p-value:\")\n",
+    "print(\"\\tU Statistic:\", u_statistic)\n",
+    "print(\"\\tP Value:\", p_value)\n",
+    "# print(len(control_interleave), len(control_backforth))\n",
+    "control_interleave_enjoy = []\n",
+    "for idx in control_interleave:\n",
+    "  convo = corpus.get_conversation(idx)\n",
+    "  control_interleave_enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "control_backforth_enjoy = []\n",
+    "for idx in control_backforth:\n",
+    "  convo = corpus.get_conversation(idx)\n",
+    "  control_backforth_enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "u_statistic, p_value = wilcoxon(control_interleave_enjoy, control_backforth_enjoy, alternative='two-sided')\n",
+    "print(\"Enjoyment p-value:\")\n",
+    "print(\"\\tU Statistic:\", u_statistic)\n",
+    "print(\"\\tP Value:\", p_value)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vocab size is 1029\n",
+      "Comparing language...\n",
+      "Fighting Words of critical_positive Comments between:\n",
+      "back_and_forth:  [('which', np.float64(3.54)), ('the conversation going', np.float64(2.82)), ('conversation going', np.float64(2.82)), ('topics', np.float64(2.74)), ('keep the', np.float64(2.4)), ('keep the conversation', np.float64(2.3)), ('games', np.float64(2.27)), ('going', np.float64(2.15)), ('well was', np.float64(2.1)), ('discussed', np.float64(2.1))]\n",
+      "alter_dominance:  [('stories', np.float64(-3.62)), ('to listen', np.float64(-2.98)), ('listen', np.float64(-2.96)), ('stranger', np.float64(-2.8)), ('life experiences', np.float64(-2.73)), ('the other', np.float64(-2.63)), ('myself', np.float64(-2.63)), ('his', np.float64(-2.61)), ('good conversation', np.float64(-2.54)), ('super', np.float64(-2.46))]\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fighting words between Back-and-Forth and Alternating Dominance - Table 4\n",
+    "\n",
+    "comments_type = \"critical_positive\"  # or \"critical_negative\"\n",
+    "balance_type = \"triangle\"  # or \"high/mid/low\", \"triangle\"\n",
+    "balance_type_1 = \"back_and_forth\"  # \"high_balance\", \"low_balance\", \"mid_balance\"; \"dominating_throughout\", \"back_and_forth\", \"alter_dominance\"\n",
+    "balance_type_2 = \"alter_dominance\"\n",
+    "speaker_type = None  # or \"primary_speaker\", \"secondary_speaker\"; None is don't wanna filter by speaker so both of them\n",
+    "\n",
+    "type1_comments = []\n",
+    "type2_comments = []\n",
+    "\n",
+    "meta_name = \"balance_type\" if balance_type == \"high/mid/low\" else \"triangle_type\"\n",
+    "for convo in corpus.iter_conversations():\n",
+    "    if convo.meta['primary_speaker'] == None: continue\n",
+    "    if convo.meta[meta_name] == balance_type_1:\n",
+    "        if speaker_type == None:\n",
+    "            type1_comments.append(convo.meta[comments_type][convo.meta['speaker_group'][convo.meta['primary_speaker']]])\n",
+    "            type1_comments.append(convo.meta[comments_type][convo.meta['speaker_group'][convo.meta['secondary_speaker']]])\n",
+    "        else:\n",
+    "            type1_comments.append(convo.meta[comments_type][convo.meta[speaker_type]])\n",
+    "    elif convo.meta[meta_name] == balance_type_2:\n",
+    "        if speaker_type == None:\n",
+    "            type2_comments.append(convo.meta[comments_type][convo.meta['speaker_group'][convo.meta['primary_speaker']]])\n",
+    "            type2_comments.append(convo.meta[comments_type][convo.meta['speaker_group'][convo.meta['secondary_speaker']]])\n",
+    "        else:\n",
+    "            type2_comments.append(convo.meta[comments_type][convo.meta[speaker_type]])\n",
+    "    else:\n",
+    "        continue\n",
+    "\n",
+    "z_scores = bayes_compare_language(type1_comments, type2_comments,ngram = n_gram)\n",
+    "top_k = 10\n",
+    "top_k_class1 = list(reversed([(x[0], round(x[1],2)) for x in z_scores[-top_k:]]))\n",
+    "top_k_class2 = [(x[0], round(x[1],2)) for x in z_scores[:top_k]]\n",
+    "print(f\"Fighting Words of {comments_type} Comments between:\")\n",
+    "print(f\"{balance_type_1}: \", top_k_class1)\n",
+    "print(f\"{balance_type_2}: \", top_k_class2)\n",
+    "print(\"\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Moving Along Axis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Fix Blue\n",
+    "We notice that, if we set a fixed value for the percentage of one color in the conversation (for example, blue), the rest of the conversation can be either red windows or gray windows, as they sum to 100%. Let's analyze how we fix the level of Blue windows in conversations, and see if there is anything different when the rest of the conversation is filled by red windows and gray windows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_convo_lst_enjoy_per(corpus, convo_id_lst):\n",
+    "    enjoy = []\n",
+    "    for convo_id in convo_id_lst:\n",
+    "        convo = corpus.get_conversation(convo_id)\n",
+    "        enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "    if len(enjoy) == 0:\n",
+    "        return \"no convo\"\n",
+    "    return enjoy.count(9) / len(enjoy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "blue_below_50 = [convo.id for convo in corpus.iter_conversations() if convo.meta['percent_blue'] < 50]\n",
+    "fix_red_level_groups = {\"0_10\" : [], \"10_20\" : [], \"20_30\" : [], \"30_40\" : [], \"40_50\" : []}\n",
+    "\n",
+    "def get_bin_red(percent_red):\n",
+    "    if 0 <= percent_red < 10:\n",
+    "        return \"0_10\"\n",
+    "    elif 10 <= percent_red < 20:\n",
+    "        return \"10_20\"\n",
+    "    elif 20 <= percent_red < 30:\n",
+    "        return \"20_30\"\n",
+    "    elif 30 <= percent_red < 40:\n",
+    "        return \"30_40\"\n",
+    "    elif 40 <= percent_red < 50:\n",
+    "        return \"40_50\"\n",
+    "    else:\n",
+    "        return None\n",
+    "\n",
+    "for convo_id in blue_below_50:\n",
+    "    # if convo_id in invalid_convo: continue\n",
+    "    convo = corpus.get_conversation(convo_id)\n",
+    "    bin_id = get_bin_red(convo.meta['percent_red'])\n",
+    "    if bin_id in fix_red_level_groups.keys():\n",
+    "        fix_red_level_groups[bin_id].append(convo.id)\n",
+    "\n",
+    "def get_avg_convo_percent_blue(corpus, convo_id_lst):\n",
+    "    percent_blues = []\n",
+    "    for convo_id in convo_id_lst:\n",
+    "        convo = corpus.get_conversation(convo_id)\n",
+    "        percent_blues.append(convo.meta['percent_blue'])\n",
+    "    if len(percent_blues) == 0:\n",
+    "        return \"no convo\"\n",
+    "    return round(sum(percent_blues) / len(percent_blues), 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = list(fix_red_level_groups.keys())\n",
+    "y = [round(get_convo_lst_enjoy_per(corpus, fix_red_level_groups[x[i]]),4)*100 for i in range(len(x))]\n",
+    "y_err = [bootstrap_95_percentage(corpus, fix_red_level_groups[key]) for key in x]\n",
+    "\n",
+    "lower_errors = [y[i] - err[0] for i, err in enumerate(y_err)]\n",
+    "upper_errors = [err[1] - y[i] for i, err in enumerate(y_err)]\n",
+    "asymmetric_error = [lower_errors, upper_errors]\n",
+    "\n",
+    "num_of_convo = [len(fix_red_level_groups[a]) for a in x]\n",
+    "\n",
+    "x_names = [\"0-10\", \"10-20\", \"20-30\", \"30-40\", \"40-50\"]\n",
+    "x = [x_names[i] for i in range(len(x))]\n",
+    "y = [round(y[i],2) for i in range(len(x))]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(11, 8))\n",
+    "plt.errorbar(x_names, y, yerr=asymmetric_error, fmt='^', capsize=5, capthick=2)\n",
+    "plt.xlabel('percentage of red windows (range)', fontsize=15)\n",
+    "plt.ylabel(f'percentage of maximum enjoyment ratings', fontsize=15)\n",
+    "plt.xticks(fontsize=14)\n",
+    "plt.yticks(fontsize=14)\n",
+    "for i, value in enumerate(y):\n",
+    "    plt.text(i+0.2, value + 1, f\"{str(int(round(value)))}%\", ha='center', va='bottom')\n",
+    "\n",
+    "for i, value in enumerate(y):\n",
+    "    plt.text(i, 10, f\"N={str(num_of_convo[i])}\", ha='center', va='bottom')\n",
+    "\n",
+    "plt.ylim(0, 70)\n",
+    "plt.xlim(-0.5, len(x_names) - 0.5)\n",
+    "plt.grid(True)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Fix Red"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "red_below_5 = [convo.id for convo in corpus.iter_conversations() if convo.meta['percent_red'] < 5]\n",
+    "\n",
+    "def get_bin_blue(percent_blue):\n",
+    "    if 30 <= percent_blue < 40:\n",
+    "        return \"30_40\"\n",
+    "    elif 40 <= percent_blue < 50:\n",
+    "        return \"40_50\"\n",
+    "    elif 50 <= percent_blue < 60:\n",
+    "        return \"50_60\"\n",
+    "    elif 60 <= percent_blue < 70:\n",
+    "        return \"60_70\"\n",
+    "    elif 70 <= percent_blue < 80:\n",
+    "        return \"70_80\"\n",
+    "    elif 80 <= percent_blue < 90:\n",
+    "        return \"80_90\"\n",
+    "    elif 90 <= percent_blue <= 100:\n",
+    "        return \"90_100\"\n",
+    "    else:\n",
+    "        return None\n",
+    "\n",
+    "def get_avg_convo_percent_red(corpus, convo_id_lst):\n",
+    "    percent_reds = []\n",
+    "    for convo_id in convo_id_lst:\n",
+    "        convo = corpus.get_conversation(convo_id)\n",
+    "        percent_reds.append(convo.meta['percent_red'])\n",
+    "    if len(percent_reds) == 0:\n",
+    "        return \"no convo\"\n",
+    "    return round(sum(percent_reds) / len(percent_reds), 2)\n",
+    "\n",
+    "fix_blue_level_groups = {\"40_50\" : [], \"50_60\" : [], \"60_70\" : [], \"70_80\" : [], \"80_90\" : [], \"90_100\" :[]}\n",
+    "\n",
+    "for convo_id in red_below_5:\n",
+    "    convo = corpus.get_conversation(convo_id)\n",
+    "    bin_id = get_bin_blue(convo.meta['percent_blue'])\n",
+    "    if bin_id in fix_blue_level_groups.keys():\n",
+    "        fix_blue_level_groups[bin_id].append(convo.id)\n",
+    "\n",
+    "def make_plot():\n",
+    "    cur_datadict = fix_blue_level_groups\n",
+    "\n",
+    "    x = list(cur_datadict.keys())\n",
+    "    y = [round(get_convo_lst_enjoy_per(corpus, cur_datadict[x[i]]),4)*100 for i in range(len(x))]\n",
+    "    y_err = [bootstrap_95_percentage(corpus, cur_datadict[key]) for key in x]\n",
+    "\n",
+    "    lower_errors = [y[i] - err[0] for i, err in enumerate(y_err)]\n",
+    "    upper_errors = [err[1] - y[i] for i, err in enumerate(y_err)]\n",
+    "    asymmetric_error = [lower_errors, upper_errors]\n",
+    "\n",
+    "    num_of_convo = [len(cur_datadict[a]) for a in x]\n",
+    "\n",
+    "    x_names = [\"40-50\", \"50-60\", \"60-70\", \"70-80\", \"80-90\", \"90-100\"]\n",
+    "    x = [x_names[i] for i in range(len(x))]\n",
+    "    y = [round(y[i],2) for i in range(len(x))]\n",
+    "\n",
+    "    plt.figure(figsize=(11, 8))\n",
+    "    plt.errorbar(x_names, y, yerr=asymmetric_error, fmt='^', capsize=5, capthick=2, color='red')\n",
+    "    plt.xlabel('percentage of blue windows (range)', fontsize=15)\n",
+    "    plt.ylabel(f'percentage of maximum enjoyment ratings', fontsize=15)\n",
+    "    plt.xticks(fontsize=14)\n",
+    "    plt.yticks(fontsize=14)\n",
+    "    for i, value in enumerate(y):\n",
+    "        plt.text(i+0.2, value + 1, f\"{str(int(round(value)))}%\", ha='center', va='bottom')\n",
+    "\n",
+    "    for i, value in enumerate(y):\n",
+    "        plt.text(i, 10, f\"N={str(num_of_convo[i])}\", ha='center', va='bottom')\n",
+    "\n",
+    "    plt.ylim(0, 70)\n",
+    "    plt.xlim(-0.5, len(x_names) - 0.5)\n",
+    "    plt.grid(True)\n",
+    "    plt.show()\n",
+    "\n",
+    "make_plot()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Fix gray"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "gray_below_40 = [convo.id for convo in corpus.iter_conversations() if convo.meta['percent_gray'] < 40]\n",
+    "\n",
+    "fix_red_level_groups = {\"0_10\" : [], \"10_20\" : [], \"20_30\" : [], \"30_40\" : [], \"40_50\" : []}\n",
+    "\n",
+    "for convo_id in gray_below_40:\n",
+    "    convo = corpus.get_conversation(convo_id)\n",
+    "    bin_id = get_bin_red(convo.meta['percent_red'])\n",
+    "    if bin_id in fix_red_level_groups.keys():\n",
+    "        fix_red_level_groups[bin_id].append(convo.id)\n",
+    "\n",
+    "def get_avg_convo_percent_gray(corpus, convo_id_lst):\n",
+    "    percent_grays = []\n",
+    "    for convo_id in convo_id_lst:\n",
+    "        convo = corpus.get_conversation(convo_id)\n",
+    "        percent_grays.append(convo.meta['percent_gray'])\n",
+    "    if len(percent_grays) == 0:\n",
+    "        return \"no convo\"\n",
+    "    return round(sum(percent_grays) / len(percent_grays), 2)\n",
+    "\n",
+    "def make_plot():\n",
+    "    cur_datadict = fix_red_level_groups\n",
+    "\n",
+    "    x = list(cur_datadict.keys())\n",
+    "    y = [round(get_convo_lst_enjoy_per(corpus, cur_datadict[x[i]]),4)*100 for i in range(len(x))]\n",
+    "    y_err = [bootstrap_95_percentage(corpus, cur_datadict[key]) for key in x]\n",
+    "\n",
+    "    lower_errors = [y[i] - err[0] for i, err in enumerate(y_err)]\n",
+    "    upper_errors = [err[1] - y[i] for i, err in enumerate(y_err)]\n",
+    "    asymmetric_error = [lower_errors, upper_errors]\n",
+    "\n",
+    "    num_of_convo = [len(cur_datadict[a]) for a in x]\n",
+    "\n",
+    "    x_names = [\"0-10\", \"10-20\", \"20-30\", \"30-40\", \"40-50\"]\n",
+    "    x = [x_names[i] for i in range(len(x))]\n",
+    "    y = [round(y[i],2) for i in range(len(x))]\n",
+    "\n",
+    "    plt.figure(figsize=(11, 8))\n",
+    "    plt.errorbar(x_names, y, yerr=asymmetric_error, fmt='^', capsize=5, capthick=2, color='gray')\n",
+    "    plt.xlabel('percentage of red windows (range)', fontsize=15)\n",
+    "    plt.ylabel(f'percentage of maximum enjoyment ratings', fontsize=15)\n",
+    "    plt.xticks(fontsize=14)\n",
+    "    plt.yticks(fontsize=14)\n",
+    "    for i, value in enumerate(y):\n",
+    "        plt.text(i+0.2, value + 1, f\"{str(int(round(value)))}%\", ha='center', va='bottom')\n",
+    "\n",
+    "    for i, value in enumerate(y):\n",
+    "        plt.text(i, 10, f\"N={str(num_of_convo[i])}\", ha='center', va='bottom')\n",
+    "\n",
+    "    plt.ylim(0, 70)\n",
+    "    plt.xlim(-0.5, len(x_names) - 0.5)\n",
+    "    plt.grid(True)\n",
+    "    plt.show()\n",
+    "\n",
+    "make_plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Flips\n",
+    "We analyze the changes in dominant speakers during the conversation, with our proposed methods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Annotate Number of Flips in each convo\n",
+    "def count_flips_sequence_ratio(sequence_lst):\n",
+    "    count_flips = 0\n",
+    "    total_pairs = 0\n",
+    "\n",
+    "    for i in range(len(sequence_lst) - 1):\n",
+    "        if (sequence_lst[i], sequence_lst[i + 1]) in [(1, -1), (-1, 1)]:\n",
+    "            count_flips += 1\n",
+    "        total_pairs += 1\n",
+    "\n",
+    "    ratio = count_flips / total_pairs if total_pairs > 0 else 0\n",
+    "    return ratio, count_flips\n",
+    "\n",
+    "def remove_short_zero_sequences(input_list, threshold=1000):\n",
+    "    result = []\n",
+    "    i = 0\n",
+    "    while i < len(input_list):\n",
+    "        if input_list[i] == 0:\n",
+    "            start = i\n",
+    "            while i < len(input_list) and input_list[i] == 0:\n",
+    "                i += 1\n",
+    "            if i - start > threshold:\n",
+    "                result.extend([0] * (i - start))\n",
+    "        else:\n",
+    "            result.append(input_list[i])\n",
+    "            i += 1\n",
+    "    return result\n",
+    "\n",
+    "def sequence_elements_and_counts(input_list):\n",
+    "    if not input_list:\n",
+    "        return [], []\n",
+    "\n",
+    "    elements = [input_list[0]]\n",
+    "    counts = [1]\n",
+    "\n",
+    "    for value in input_list[1:]:\n",
+    "        if value == elements[-1]:\n",
+    "            counts[-1] += 1\n",
+    "        else:\n",
+    "            elements.append(value)\n",
+    "            counts.append(1)\n",
+    "\n",
+    "    return elements, counts\n",
+    "\n",
+    "def remove_short_sequence(sequence_lst, count_lst, threshold=2):\n",
+    "    result_lst = []\n",
+    "    for i in range(len(sequence_lst)):\n",
+    "        count = count_lst[i]\n",
+    "        if count > threshold:\n",
+    "            if len(result_lst) > 0:\n",
+    "                if sequence_lst[i] != result_lst[-1]:\n",
+    "                    result_lst.append(sequence_lst[i])\n",
+    "            else:\n",
+    "                result_lst.append(sequence_lst[i])\n",
+    "    return result_lst\n",
+    "\n",
+    "def annotate_convo_flips(corpus):\n",
+    "    for convo in corpus.iter_conversations():\n",
+    "        floor_lst = convo.meta['balance_lst']\n",
+    "        floor_lst = remove_short_zero_sequences(floor_lst)\n",
+    "        floor_sequence, floor_count = sequence_elements_and_counts(floor_lst)\n",
+    "        flip_ratio, flip_count = count_flips_sequence_ratio(floor_sequence)\n",
+    "        convo.meta['flip_count'] = flip_count"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "annotate_convo_flips(corpus)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "flip_lst = [convo.meta['flip_count'] for convo in corpus.iter_conversations()]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Enjoyment Analysis - Paired test\n",
+    "\n",
+    "We match each single-flip conversation with one that has 3 or more flips, such that they have the same proportion of blue, red, and gray windows (with a tolerance of 2%). Then, we compare the enjoyment score between the pairs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def find_closest_pairs(list1, list2, x=0.01):\n",
+    "    list1final = []\n",
+    "    list2final = []\n",
+    "    for dict1 in list1:\n",
+    "      idx1, score1 = next(iter(dict1.items()))\n",
+    "      closest_dict = None\n",
+    "      min_diff = float('inf')\n",
+    "      for dict2 in list2:\n",
+    "          idx2, score2 = next(iter(dict2.items()))\n",
+    "          diff = abs(score1 - score2)\n",
+    "          if diff < min_diff:\n",
+    "              min_diff = diff\n",
+    "              closest_dict = dict2\n",
+    "      if min_diff > x: continue\n",
+    "      idxf, scoref = next(iter(closest_dict.items()))\n",
+    "      list1final.append(idx1)\n",
+    "      list2final.append(idxf)\n",
+    "      list2.remove(closest_dict)\n",
+    "\n",
+    "    return list1final, list2final"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tolerance = 2\n",
+    "def pair_elements_blue_red(list1, list2, tolerance=tolerance):\n",
+    "    pairs = []\n",
+    "    used_ids_in_list2 = set()\n",
+    "    for elem1 in list1:\n",
+    "        id1, (value1_1, value2_1) = next(iter(elem1.items()))\n",
+    "        best_match = None\n",
+    "        best_distance = float('inf')\n",
+    "        for elem2 in list2:\n",
+    "            id2, (value1_2, value2_2) = next(iter(elem2.items()))\n",
+    "            if id2 in used_ids_in_list2:\n",
+    "                continue\n",
+    "            distance1 = abs(value1_1 - value1_2)\n",
+    "            distance2 = abs(value2_1 - value2_2)\n",
+    "            if distance1 <= tolerance and distance2 <= tolerance:\n",
+    "                total_distance = distance1 + distance2\n",
+    "                if total_distance < best_distance:\n",
+    "                    best_distance = total_distance\n",
+    "                    best_match = id2\n",
+    "        if best_match is not None:\n",
+    "            pairs.append((id1, best_match))\n",
+    "            used_ids_in_list2.add(best_match)\n",
+    "\n",
+    "    return [x[0] for x in pairs], [x[1] for x in pairs]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "We found 90.0 pairs with toleration 2\n",
+      "\n",
+      "Balance score between two groups (mannwhitneyu):\n",
+      "\tU Statistic: 3866.0\n",
+      "\tP Value: 0.5995952992175173\n",
+      "\n",
+      "Enjoyable score between two groups (mannwhitneyu):\n",
+      "\tU Statistic: 14893.0\n",
+      "\tP Value: 0.1739577730491806\n",
+      "\n",
+      "Enjoy: with 1 flip 7.166666666666667\n",
+      "Enjoy: with 3+ flip 7.377777777777778\n",
+      "\n",
+      "with 1 flip higher enjoy: 0.3778%, with 3+ flip 0.5333%\n"
+     ]
+    }
+   ],
+   "source": [
+    "random.seed(42)\n",
+    "num_pairs_found = []\n",
+    "b_u_stats = []\n",
+    "b_p_values = []\n",
+    "en_u_stats = []\n",
+    "en_p_values = []\n",
+    "en_score_1 = []\n",
+    "en_score_3 = []\n",
+    "percent_1 = []\n",
+    "percent_3 = []\n",
+    "\n",
+    "# for i in range(500):\n",
+    "flip_1 = [{convo.id : [convo.meta['percent_blue'], convo.meta['percent_red']]} for convo in corpus.iter_conversations() if convo.meta['flip_count'] == 1]\n",
+    "flip_3 = [{convo.id : [convo.meta['percent_blue'], convo.meta['percent_red']]} for convo in corpus.iter_conversations() if convo.meta['flip_count'] >= 3]\n",
+    "flip_1 = random.sample(flip_1, len(flip_1))\n",
+    "flip_3 = random.sample(flip_3, len(flip_3))\n",
+    "# print(f\"Overall: {len(flip_1)} with 1 flip, {len(flip_3)} with 3+ flips\")\n",
+    "\n",
+    "control_flip_1, control_flip_3 = pair_elements_blue_red(flip_1, flip_3)\n",
+    "num_pairs_found.append(len(control_flip_1))\n",
+    "\n",
+    "\n",
+    "control_flip_1_balance = [corpus.get_conversation(idx).meta['balance_score'] for idx in control_flip_1]\n",
+    "control_flip_3_balance = [corpus.get_conversation(idx).meta['balance_score'] for idx in control_flip_3]\n",
+    "u_statistic, p_value = mannwhitneyu(control_flip_1_balance, control_flip_3_balance, alternative='two-sided')\n",
+    "b_u_stats.append(u_statistic)\n",
+    "b_p_values.append(p_value)\n",
+    "\n",
+    "\n",
+    "control_flip_1_enjoy = []\n",
+    "for idx in control_flip_1:\n",
+    "  convo = corpus.get_conversation(idx)\n",
+    "  control_flip_1_enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "control_flip_3_enjoy = []\n",
+    "for idx in control_flip_3:\n",
+    "  convo = corpus.get_conversation(idx)\n",
+    "  control_flip_3_enjoy += list(convo.meta['how_enjoyable'].values())\n",
+    "u_statistic, p_value = mannwhitneyu(control_flip_1_enjoy, control_flip_3_enjoy, alternative='two-sided')\n",
+    "en_u_stats.append(u_statistic)\n",
+    "en_p_values.append(p_value)\n",
+    "en_score_1.append(np.mean(control_flip_1_enjoy))\n",
+    "en_score_3.append(np.mean(control_flip_3_enjoy))\n",
+    "\n",
+    "count_1 = 0\n",
+    "count_3 = 0\n",
+    "for i in range(len(control_flip_1)):\n",
+    "  convo1 = corpus.get_conversation(control_flip_1[i])\n",
+    "  convo3 = corpus.get_conversation(control_flip_3[i])\n",
+    "  if sum(list(convo1.meta['how_enjoyable'].values())) > sum(list(convo3.meta['how_enjoyable'].values())):\n",
+    "    count_1 += 1\n",
+    "  elif sum(list(convo1.meta['how_enjoyable'].values())) < sum(list(convo3.meta['how_enjoyable'].values())):\n",
+    "    count_3 += 1\n",
+    "\n",
+    "percent_1.append(count_1 / len(control_flip_1))\n",
+    "percent_3.append(count_3 / len(control_flip_3))\n",
+    "\n",
+    "\n",
+    "print(f\"We found {np.mean(num_pairs_found)} pairs with toleration {tolerance}\\n\")\n",
+    "print(\"Balance score between two groups (mannwhitneyu):\")\n",
+    "print(\"\\tU Statistic:\", np.mean(b_u_stats))\n",
+    "print(\"\\tP Value:\", np.mean(b_p_values))\n",
+    "print(\"\\nEnjoyable score between two groups (mannwhitneyu):\")\n",
+    "print(\"\\tU Statistic:\", np.mean(en_u_stats))\n",
+    "print(\"\\tP Value:\", np.mean(en_p_values))\n",
+    "print(f\"\\nEnjoy: with 1 flip {np.mean(en_score_1)}\")\n",
+    "print(f\"Enjoy: with 3+ flip {np.mean(en_score_3)}\")\n",
+    "print(f\"\\nwith 1 flip higher enjoy: {round(np.mean(percent_1), 4)}%, with 3+ flip {round(np.mean(percent_3), 4)}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Capture Mixed Stereotype Conversations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_first_second_half_convo(corpus, convo_id):\n",
+    "    convo = corpus.get_conversation(convo_id)\n",
+    "    balance_lst = convo.meta['balance_lst']\n",
+    "    return balance_lst[:int(len(balance_lst)*0.6)], balance_lst[int(len(balance_lst)*0.4):]\n",
+    "\n",
+    "def get_type_dominating_throughout(balance_lst, dominating_throughout_threshold=75):\n",
+    "    if balance_lst == []: return \"invalid\"\n",
+    "    count_ones = balance_lst.count(1)\n",
+    "    percent_ones = (count_ones / len(balance_lst)) * 100\n",
+    "    count_neg_ones = balance_lst.count(-1)\n",
+    "    percent_neg_ones = (count_neg_ones / len(balance_lst)) * 100\n",
+    "    return percent_ones >= dominating_throughout_threshold or percent_neg_ones >= dominating_throughout_threshold\n",
+    "\n",
+    "def get_type_back_and_forth(balance_lst, back_and_forth_threshold=60):\n",
+    "    if balance_lst == []: return \"invalid\"\n",
+    "    count_zeros = balance_lst.count(0)\n",
+    "    percent_zeros = (count_zeros / len(balance_lst)) * 100\n",
+    "    return percent_zeros >= back_and_forth_threshold\n",
+    "\n",
+    "def get_type_alter_dominance(balance_lst, red_threshold=25):\n",
+    "    if balance_lst == []: return \"invalid\"\n",
+    "    count_neg1 = balance_lst.count(-1)\n",
+    "    total_elements = len(balance_lst)\n",
+    "    percent_neg1 = (count_neg1 / total_elements) * 100\n",
+    "    return percent_neg1 > red_threshold\n",
+    "\n",
+    "def get_lst_balance_type(lst):\n",
+    "    if get_type_alter_dominance(lst):\n",
+    "        return \"alter_dominance\"\n",
+    "    elif get_type_dominating_throughout(lst):\n",
+    "        return \"dominating_throughout\"\n",
+    "    elif get_type_back_and_forth(lst):\n",
+    "        return \"back_and_forth\"\n",
+    "    else:\n",
+    "        return None\n",
+    "    \n",
+    "def get_mixed_stereotype_conversation(corpus, convo_id):\n",
+    "    first, second = get_first_second_half_convo(corpus, convo_id)\n",
+    "    first_type = get_lst_balance_type(first)\n",
+    "    second_type = get_lst_balance_type(second)\n",
+    "    if first_type is None or second_type is None:\n",
+    "        return None\n",
+    "    if first_type != second_type:\n",
+    "        return [first_type, second_type]\n",
+    "    else:\n",
+    "        return [first_type]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "47"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mixed_convos = {}\n",
+    "count = 0\n",
+    "for convo in corpus.iter_conversations():\n",
+    "    convo_type = get_mixed_stereotype_conversation(corpus, convo.id)\n",
+    "    if convo_type is not None and len(convo_type) == 2:\n",
+    "        mixed_convos.update({convo.id : convo_type})\n",
+    "        count += 1\n",
+    "        convo.meta[\"mixed\"] = True\n",
+    "    else:\n",
+    "        convo.meta['mixed'] = False\n",
+    "count"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{('back_and_forth', 'dominating_throughout'): 11,\n",
+       " ('back_and_forth', 'alter_dominance'): 13,\n",
+       " ('alter_dominance', 'dominating_throughout'): 6,\n",
+       " ('alter_dominance', 'back_and_forth'): 13,\n",
+       " ('dominating_throughout', 'alter_dominance'): 4}"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def count_unique_values(input_dict):\n",
+    "    value_counts = Counter(tuple(v) for v in input_dict.values())\n",
+    "    return dict(value_counts)\n",
+    "\n",
+    "mixed_convos_plot_dict = {}\n",
+    "for k, v in mixed_convos.items():\n",
+    "    key = v[0]+v[1]\n",
+    "    if key not in mixed_convos_plot_dict.keys():\n",
+    "        mixed_convos_plot_dict.update({key : []})\n",
+    "    mixed_convos_plot_dict[key].append(k)\n",
+    "# for k, v in mixed_convos_plot_dict.items():\n",
+    "#     print(k, len(v))\n",
+    "\n",
+    "count_unique_values(mixed_convos)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "labels = [\"back_and_forthdominating_throughout\", \"back_and_forthalter_dominance\", \"alter_dominancedominating_throughout\", \"alter_dominanceback_and_forth\", \"dominating_throughoutalter_dominance\"]\n",
+    "names = [\"bf-dt\", \"bf-ad\", \"ad-dt\", \"ad-bf\", \"dt-ad\"]\n",
+    "# for i, label in enumerate(labels):\n",
+    "#     plot_multi_conversation_balance(corpus, mixed_convos_plot_dict[label])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "red : 18.75, blue : 66.67, gray : 14.58\n"
+     ]
+    }
+   ],
+   "source": [
+    "plot_single_conversation_balance(corpus, mixed_convos_plot_dict[\"alter_dominancedominating_throughout\"][0], window_ps_threshold, window_size, sliding_size, remove_first_last_utt, min_utt_words)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Demo 2: Talk-Time Sharing Dynamics in Supreme Court Oral Argument Conversations\n",
+    "\n",
+    "Here, we demonstrate the use of our proposed computational approach in a new distinct data setting: [the Supreme Court oral arguments](https://convokit.cornell.edu/documentation/supreme.html). The conversations are now not dyadic, and not role neutral. We show that with some simple changes, we can adapt our method to analyze the talk-time sharing dynamics in this new data setting."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset already exists at /Users/seanzhangkx/Desktop/Research/SupremeCourtData/supreme-corpus\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Download the data to your directory or load the data\n",
+    "SUPREME_DATA_PATH = \"<YOUR PATH TO SUPREME COURT ORAL ARGUMENTS DATA>\"\n",
+    "supreme_corpus = Corpus(filename=download(\"supreme-corpus\", data_dir=SUPREME_DATA_PATH))\n",
+    "# supreme_corpus = Corpus(filename=SUPREME_DATA_PATH)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Processing the data\n",
+    "\n",
+    "We used the Supreme Court Oral Arguments dataset, where each case are conversations between lawyers and judges, and the lawyers can be from petitioner side and respondent side. We treat all the lawyers from one side as a single speaker, as well as all of the justices. Utterance timestamps enabled us to compute talk-time dynamics. We applied asymmetric dominance thresholds and analyzed patterns against case outcomes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Annotate dataset\n",
+    "for utt in supreme_corpus.iter_utterances():\n",
+    "    utt.meta['start'] = utt.meta['start_times'][0]\n",
+    "    utt.meta['stop'] = utt.meta['stop_times'][-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Divided 4-5 : 1356, Divided middle : 2624, Unanimous : 2946, others : 878\n"
+     ]
+    }
+   ],
+   "source": [
+    "### We find differnent voting types at the end of the conversation for each case in the supreme court dataset.\n",
+    "def check_proportion(lst, threshold=2):\n",
+    "    count_0 = lst.count(0)\n",
+    "    count_1 = lst.count(1)\n",
+    "    if count_0 >= threshold and count_1 >= threshold:\n",
+    "        return True\n",
+    "    else:\n",
+    "        return False\n",
+    "\n",
+    "def check_all_agree(lst):\n",
+    "    return len(set(lst)) == 1\n",
+    "\n",
+    "convo_vote_agreement = {\"disagree\" : [], \"mixed\" : [], \"all_agree\" : [], \"others\" : []}\n",
+    "\n",
+    "for convo in supreme_corpus.iter_conversations():\n",
+    "    if convo.meta['votes_side'] is None: continue\n",
+    "    votes_side = convo.meta['votes_side']\n",
+    "    votes = list(votes_side.values())\n",
+    "    if check_proportion(votes, threshold=4):\n",
+    "        convo.meta['agreement_type'] = \"disagree\"\n",
+    "        convo_vote_agreement[\"disagree\"].append(convo.id)\n",
+    "    elif check_proportion(votes, threshold=2):\n",
+    "        convo.meta['agreement_type'] = \"mixed\"\n",
+    "        convo_vote_agreement[\"mixed\"].append(convo.id)\n",
+    "    elif check_all_agree(votes):\n",
+    "        convo.meta['agreement_type'] = \"all_agree\"\n",
+    "        convo_vote_agreement[\"all_agree\"].append(convo.id)\n",
+    "    else:\n",
+    "        convo.meta['agreement_type'] = \"others\"\n",
+    "        convo_vote_agreement[\"others\"].append(convo.id)\n",
+    "\n",
+    "print(f\"Divided 4-5 : {len(convo_vote_agreement['disagree'])}, Divided middle : {len(convo_vote_agreement['mixed'])}, Unanimous : {len(convo_vote_agreement['all_agree'])}, others : {len(convo_vote_agreement['others'])}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def find_valid_conversation(corpus, convo_lst):\n",
+    "    \"\"\"\n",
+    "    Find valid conversations based on the following criteria:\n",
+    "    1. Each side must have one and only one advocate.\n",
+    "    2. The conversation must have more than one utterance.\n",
+    "    3. The conversation must be at least 15 minutes long.\n",
+    "    4. Each utterance must have a valid start and stop time.\n",
+    "    \"\"\"\n",
+    "    valid_convo = []\n",
+    "    for convo_id in convo_lst:\n",
+    "        convo = corpus.get_conversation(convo_id)\n",
+    "        side1 = []\n",
+    "        side2 = []\n",
+    "        for utt in convo.iter_utterances():\n",
+    "            if utt.meta['side'] == 1:\n",
+    "                side1.append(utt.speaker.id)\n",
+    "            elif utt.meta['side'] == 0:\n",
+    "                side2.append(utt.speaker.id)\n",
+    "        # if more than 1 advocates speak for one side, filter out\n",
+    "        if len(set(side1)) > 1 or len(set(side2)) > 1:\n",
+    "            continue\n",
+    "        # if convo doesn't have advocates on each side, filter out\n",
+    "        elif len(set(side1)) == 0 or len(set(side2)) == 0:\n",
+    "            continue\n",
+    "            \n",
+    "        utt_lst = convo.get_utterance_ids()\n",
+    "        # if only one utt or convo less than 15 min, filter out\n",
+    "        if len(utt_lst) == 1:\n",
+    "            continue\n",
+    "        last_utt = corpus.get_utterance(utt_lst[-1])\n",
+    "        if last_utt.meta['stop'] == 0 or last_utt.meta['stop'] < 15*60:\n",
+    "            continue\n",
+    "        # if there is invalid utt, filter out\n",
+    "        valid = True\n",
+    "        for utt_id in utt_lst:\n",
+    "            utt = corpus.get_utterance(utt_id)\n",
+    "            if utt.meta['stop'] < utt.meta['start']:\n",
+    "                valid = False\n",
+    "                break\n",
+    "        if not valid:\n",
+    "            continue\n",
+    "        valid_convo.append(convo_id)\n",
+    "    return valid_convo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "disagree: 816\n",
+      "mixed: 1498\n",
+      "all_agree: 1760\n",
+      "others: 454\n"
+     ]
+    }
+   ],
+   "source": [
+    "for k, v in convo_vote_agreement.items():\n",
+    "    convo_vote_agreement[k] = find_valid_conversation(supreme_corpus, v)\n",
+    "\n",
+    "for k, v in convo_vote_agreement.items():\n",
+    "    for convo_id in v:\n",
+    "        convo = supreme_corpus.get_conversation(convo_id)\n",
+    "        convo.meta['valid'] = True\n",
+    "    print(f\"{k}: {len(v)}\")\n",
+    "\n",
+    "for convo in supreme_corpus.iter_conversations():\n",
+    "    if 'valid' not in convo.meta.keys():\n",
+    "        convo.meta['valid'] = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of Speakers: 5951\n",
+      "Number of Utterances: 996466\n",
+      "Number of Conversations: 4528\n"
+     ]
+    }
+   ],
+   "source": [
+    "supreme_corpus = supreme_corpus.filter_conversations_by(lambda convo: convo.meta['valid'])\n",
+    "supreme_corpus.print_summary_stats()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extract_convo_valid_utterances(corpus, convo):\n",
+    "    utt_lst = convo.get_utterance_ids()\n",
+    "    valid_utt = []\n",
+    "    for i, utt_id in enumerate(utt_lst):\n",
+    "        utt = corpus.get_utterance(utt_id)\n",
+    "        not_valid = True\n",
+    "        if utt.meta['speaker_type'] == 'J':\n",
+    "            not_valid = False\n",
+    "        elif utt.meta['speaker_type'] == 'A':\n",
+    "            if utt.meta['side'] == 0 or utt.meta['side'] == 1:\n",
+    "                not_valid = False\n",
+    "        if not_valid:\n",
+    "            duration = utt.meta['stop'] - utt.meta['start']\n",
+    "            for later_utt_id in utt_lst[i+1:]:\n",
+    "                later_utt = corpus.get_utterance(later_utt_id)\n",
+    "                later_utt.meta['start'] -= duration\n",
+    "                later_utt.meta['stop'] -= duration\n",
+    "        else:\n",
+    "            valid_utt.append(utt)\n",
+    "    return valid_utt\n",
+    "\n",
+    "valid_utt = []\n",
+    "for convo in supreme_corpus.iter_conversations():\n",
+    "    valid_utt += extract_convo_valid_utterances(supreme_corpus, convo)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of Speakers: 5825\n",
+      "Number of Utterances: 924745\n",
+      "Number of Conversations: 4528\n"
+     ]
+    }
+   ],
+   "source": [
+    "new_corpus = Corpus(utterances=valid_utt)\n",
+    "for convo in new_corpus.iter_conversations():\n",
+    "    convo.meta = supreme_corpus.get_conversation(convo.id).meta\n",
+    "supreme_corpus = new_corpus\n",
+    "supreme_corpus.print_summary_stats()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for utt in supreme_corpus.iter_utterances():\n",
+    "    if utt.meta['start'] < 0 or utt.meta['stop'] < 0 or utt.meta['stop'] - utt.meta['start'] < 0:\n",
+    "        assert False, f\"invalid utterance {utt.id}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def one_convo_to_three_convo(corpus, convo):\n",
+    "    \"\"\"\n",
+    "    Each conversation in the supreme court dataset is a mix of three conversations.\n",
+    "    Frist conversation is where the petitioner lawyer speaks, second conversation is where the respondent lawyer speaks,\n",
+    "    and the third conversation is where the petitioner lawyer make the rebuttal.\n",
+    "    this function will extract the three conversations from the original conversation.\n",
+    "    \"\"\"\n",
+    "    first_convo, second_convo, third_convo = [], [], []\n",
+    "    spoken_lawyers = []\n",
+    "    convo_num = 0\n",
+    "    for utt in convo.iter_utterances():\n",
+    "        if convo_num == 0:\n",
+    "            if utt.meta['speaker_type'] == 'A' and (utt.meta['side'] == 0 or utt.meta['side'] == 1):\n",
+    "                spoken_lawyers.append(utt.speaker.id)\n",
+    "                convo_num += 1\n",
+    "                first_convo.append(utt.id)\n",
+    "                \n",
+    "        elif convo_num == 1:\n",
+    "            if utt.speaker.id not in spoken_lawyers and utt.meta['speaker_type'] == 'A' and (utt.meta['side'] == 0 or utt.meta['side'] == 1):\n",
+    "                spoken_lawyers.append(utt.speaker.id)\n",
+    "                convo_num += 1\n",
+    "                second_convo.append(utt.id)\n",
+    "            else:\n",
+    "                first_convo.append(utt.id)\n",
+    "\n",
+    "        elif convo_num == 2:\n",
+    "            if utt.speaker.id == spoken_lawyers[0]:\n",
+    "                convo_num += 1\n",
+    "                third_convo.append(utt.id)\n",
+    "            else:\n",
+    "                second_convo.append(utt.id)\n",
+    "             \n",
+    "        elif convo_num == 3:\n",
+    "            third_convo.append(utt.id)\n",
+    "\n",
+    "    return first_convo, second_convo, third_convo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for convo in supreme_corpus.iter_conversations():\n",
+    "    one, two, three = one_convo_to_three_convo(supreme_corpus, convo)\n",
+    "    if two == [] and three == []:\n",
+    "        assert False, f\"bad conversation {convo.id}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of Speakers: 3143\n",
+      "Number of Utterances: 401499\n",
+      "Number of Conversations: 4528\n",
+      "Number of Speakers: 3398\n",
+      "Number of Utterances: 459722\n",
+      "Number of Conversations: 4528\n",
+      "Number of Speakers: 2797\n",
+      "Number of Utterances: 58583\n",
+      "Number of Conversations: 3878\n"
+     ]
+    }
+   ],
+   "source": [
+    "corpus_one_utt, corpus_two_utt, corpus_three_utt = [], [], []\n",
+    "for convo in supreme_corpus.iter_conversations():\n",
+    "    one, two, three = one_convo_to_three_convo(supreme_corpus, convo)\n",
+    "    corpus_one_utt += [supreme_corpus.get_utterance(utt_id) for utt_id in one]\n",
+    "    corpus_two_utt += [supreme_corpus.get_utterance(utt_id) for utt_id in two]\n",
+    "    corpus_three_utt += [supreme_corpus.get_utterance(utt_id) for utt_id in three]\n",
+    "\n",
+    "corpus_one = Corpus(utterances=corpus_one_utt)\n",
+    "corpus_two = Corpus(utterances=corpus_two_utt)\n",
+    "corpus_three = Corpus(utterances=corpus_three_utt)\n",
+    "for convo in corpus_one.iter_conversations():\n",
+    "    convo.meta = supreme_corpus.get_conversation(convo.id).meta\n",
+    "for convo in corpus_two.iter_conversations():\n",
+    "    convo.meta = supreme_corpus.get_conversation(convo.id).meta\n",
+    "for convo in corpus_three.iter_conversations():\n",
+    "    convo.meta = supreme_corpus.get_conversation(convo.id).meta\n",
+    "\n",
+    "corpus_one.print_summary_stats()\n",
+    "corpus_two.print_summary_stats()\n",
+    "corpus_three.print_summary_stats()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Analysis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Annotate the data with Talk-Time Sharing information"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def annotate_groups(corpus):\n",
+    "    # We will annotate the speaker groups in the corpus.\n",
+    "    # In our analysis, because lawyers are almost always the primary speaker, we \n",
+    "    # assign lawyers as groupA, and justices as groupB\n",
+    "    for convo in corpus.iter_conversations():\n",
+    "        for utt in convo.iter_utterances():\n",
+    "            if utt.meta['speaker_type'] == 'A':\n",
+    "                utt.meta['utt_group'] = 'groupA'\n",
+    "            elif utt.meta['speaker_type'] == 'J':\n",
+    "                utt.meta['utt_group'] = 'groupB'\n",
+    "            else:\n",
+    "                utt.meta['utt_group'] = 'no_data'\n",
+    "\n",
+    "\n",
+    "def annotate_utt_groups(corpus):\n",
+    "    annotate_groups(corpus)\n",
+    "\n",
+    "annotate_utt_groups(supreme_corpus)\n",
+    "annotate_utt_groups(corpus_one)\n",
+    "annotate_utt_groups(corpus_two)\n",
+    "annotate_utt_groups(corpus_three)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Annotate winning side of the conversation.\n",
+    "def annotate_win_or_lose(corpus):\n",
+    "    for convo in corpus.iter_conversations():\n",
+    "        win_side = convo.meta['win_side']\n",
+    "        lawyer_side = 0\n",
+    "        for utt in convo.iter_utterances():\n",
+    "            if utt.meta['speaker_type'] == 'A':\n",
+    "                lawyer_side = utt.meta['side']\n",
+    "                break\n",
+    "        convo.meta['win_or_lose'] = win_side == lawyer_side\n",
+    "\n",
+    "annotate_win_or_lose(corpus_one)\n",
+    "annotate_win_or_lose(corpus_two)\n",
+    "annotate_win_or_lose(corpus_three)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "primary_threshold = 0.5000001\n",
+    "# Because of the asymetric nature of the data, we need to set different thresholds for lawyer and Justice\n",
+    "window_ps_threshold = 0.8 # Attorney's threshold, because they speak more in general\n",
+    "window_ss_threshold = 0.4 # Justice's threshold, because they speak less in general\n",
+    "window_size = 2 # window size in minutes\n",
+    "sliding_size = 30  # sliding window size in sec\n",
+    "min_utt_words = 0\n",
+    "remove_first_last_utt = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Annotating conversation balance: 4528it [01:53, 39.87it/s]\n",
+      "Annotating conversation balance: 4528it [00:35, 126.60it/s]\n",
+      "Annotating conversation balance: 4528it [00:41, 107.82it/s]\n",
+      "Annotating conversation balance: 3878it [00:03, 983.80it/s] \n"
+     ]
+    }
+   ],
+   "source": [
+    "### Apply the Balance Transformer to the corpus\n",
+    "balance_transformer_supreme = Balance(primary_threshold=primary_threshold, \n",
+    "                              window_ps_threshold=window_ps_threshold, \n",
+    "                              window_ss_threshold=window_ss_threshold,\n",
+    "                              window_size=window_size,\n",
+    "                              sliding_size=sliding_size,\n",
+    "                              min_utt_words=min_utt_words,\n",
+    "                              remove_first_last_utt=remove_first_last_utt)\n",
+    "\n",
+    "balance_transformer_supreme.transform(supreme_corpus)\n",
+    "balance_transformer_supreme.transform(corpus_one)\n",
+    "balance_transformer_supreme.transform(corpus_two)\n",
+    "balance_transformer_supreme.transform(corpus_three)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "check_balance_distribution(supreme_corpus, y_up=1000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Define the stereotypes\n",
+    "\n",
+    "We defined stereotypes based on talk-time distribution, labeling a conversation as dominated throughout if more than 70% of windows were blue, alternating dominance if more than 40% were red, and back-and-forth if more than 40% were gray."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Triangle Typology: dominating_throughout: 1340, back_and_forth: 1137, alter_dominance: 759, no_label: 1292\n",
+      "Triangle Typology: dominating_throughout: 1087, back_and_forth: 1236, alter_dominance: 920, no_label: 1285\n",
+      "Triangle Typology: dominating_throughout: 2474, back_and_forth: 925, alter_dominance: 185, no_label: 294\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_type_dominating_throughout(balance_lst, dominating_throughout_threshold=70):\n",
+    "    if balance_lst == []: return \"invalid\"\n",
+    "    count_ones = balance_lst.count(1)\n",
+    "    percent_ones = (count_ones / len(balance_lst)) * 100\n",
+    "    count_neg_ones = balance_lst.count(-1)\n",
+    "    percent_neg_ones = (count_neg_ones / len(balance_lst)) * 100\n",
+    "    return percent_ones >= dominating_throughout_threshold or percent_neg_ones >= dominating_throughout_threshold\n",
+    "\n",
+    "def get_type_back_and_forth(balance_lst, back_and_forth_threshold=40):\n",
+    "    if balance_lst == []: return \"invalid\"\n",
+    "    count_zeros = balance_lst.count(0)\n",
+    "    percent_zeros = (count_zeros / len(balance_lst)) * 100\n",
+    "    return percent_zeros >= back_and_forth_threshold\n",
+    "\n",
+    "def red_percentage(balance_lst, threshold=40):\n",
+    "    count_neg1 = balance_lst.count(-1)\n",
+    "    total_elements = len(balance_lst)\n",
+    "    percent_neg1 = (count_neg1 / total_elements) * 100\n",
+    "    return percent_neg1 > threshold\n",
+    "\n",
+    "def get_type_alter_dominance(balance_lst, red_threshold=40):\n",
+    "    if balance_lst == []: return \"invalid\"\n",
+    "    if red_percentage(balance_lst, threshold=red_threshold):\n",
+    "        return True\n",
+    "    else:\n",
+    "        return False\n",
+    "\n",
+    "def annotate_triangle_typology(corpus):\n",
+    "    count1, count2, count3, count4 = 0, 0, 0, 0\n",
+    "    for convo in corpus.iter_conversations():\n",
+    "        balance_lst = convo.meta['balance_lst']\n",
+    "        if get_type_dominating_throughout(balance_lst):\n",
+    "            convo.meta['triangle_type'] = 'dominating_throughout'\n",
+    "            count1 += 1\n",
+    "        elif get_type_back_and_forth(balance_lst):\n",
+    "            convo.meta['triangle_type'] = \"back_and_forth\"\n",
+    "            count2 += 1\n",
+    "        elif get_type_alter_dominance(balance_lst):\n",
+    "            convo.meta['triangle_type'] = 'alter_dominance'\n",
+    "            count3 += 1\n",
+    "        else:\n",
+    "            convo.meta['triangle_type'] = 'no_label'\n",
+    "            count4 += 1\n",
+    "    \n",
+    "    print(f\"Triangle Typology: dominating_throughout: {count1}, back_and_forth: {count2}, alter_dominance: {count3}, no_label: {count4}\")\n",
+    "\n",
+    "annotate_triangle_typology(corpus_one)\n",
+    "annotate_triangle_typology(corpus_two)\n",
+    "annotate_triangle_typology(corpus_three)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analyzing the winning chance with Talk-Time Sharing Dynamics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Use corpus_one for first part of the conversation (petitioner lawyer), corpus_two for second part of the conversation (respondent lawyer), and corpus_three for third part of the conversation (rebuttal).\n",
+    "cur_corpus = corpus_one"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "convo_vote_agreement_type_balance = {\"disagree\" : [], \"mixed\" : [], \"all_agree\" : [], \"others\" : []}\n",
+    "convo_vote_agreement_type_triangle = {\"disagree\" : [], \"mixed\" : [], \"all_agree\" : [], \"others\" : []}\n",
+    "\n",
+    "for convo in cur_corpus.iter_conversations():\n",
+    "    convo_vote_agreement_type_balance[convo.meta['agreement_type']].append(convo.meta['balance_score'])\n",
+    "    convo_vote_agreement_type_triangle[convo.meta['agreement_type']].append(convo.meta['triangle_type'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def plot_convo_vote_agreement_type_balance(input):\n",
+    "    x_label = ['disagree', 'mixed', 'all_agree', 'others']\n",
+    "    group1_meta, group2_meta, group3_meta, group4_meta = input[x_label[0]], input[x_label[1]], input[x_label[2]], input[x_label[3]]\n",
+    "    group_length = [len(group1_meta), len(group2_meta), len(group3_meta), len(group4_meta)]\n",
+    "    y = [np.mean(group1_meta), np.mean(group2_meta), np.mean(group3_meta), np.mean(group4_meta)]\n",
+    "    y_err = [bootstrap_95(group1_meta), bootstrap_95(group2_meta), \n",
+    "             bootstrap_95(group3_meta), bootstrap_95(group4_meta)]\n",
+    "    lower_errors = [y[i] - err[0] for i, err in enumerate(y_err)]\n",
+    "    upper_errors = [err[1] - y[i] for i, err in enumerate(y_err)]\n",
+    "    asymmetric_error = [lower_errors, upper_errors]\n",
+    "    plt.figure(figsize=(10, 8))\n",
+    "    plt.errorbar(x_label, y, yerr=asymmetric_error, fmt='o', capsize=5, capthick=2)\n",
+    "    plt.xlabel('Overall Balance between Types', fontsize=15)\n",
+    "    plt.ylabel(f'Overall Balance', fontsize=15)\n",
+    "    plt.xticks(fontsize=14)\n",
+    "    plt.yticks(fontsize=14)\n",
+    "    plt.ylim(0.5, 0.9)\n",
+    "    plt.xlim(-0.3, len(x_label)-0.7)\n",
+    "    for i, value in enumerate(y):\n",
+    "        plt.text(i+0.16, value+0.01, f\"{str(round(value, 2))}\", ha='center', va='bottom')\n",
+    "    for i, value in enumerate(y):\n",
+    "        plt.text(i, value-0.1, f\"N={group_length[i]}\", ha='center', va='bottom')\n",
+    "    plt.grid(True)\n",
+    "    \n",
+    "    plt.show()\n",
+    "\n",
+    "plot_convo_vote_agreement_type_balance(convo_vote_agreement_type_balance)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def check_if_lawyer_win(corpus, convo_id):\n",
+    "    convo = corpus.get_conversation(convo_id)\n",
+    "    win_side = convo.meta['win_side']\n",
+    "    lawyer_side = -1\n",
+    "    for utt in convo.iter_utterances():\n",
+    "        if utt.meta['speaker_type'] == 'A':\n",
+    "            lawyer_side = utt.meta['side']\n",
+    "    if lawyer_side == -1:\n",
+    "        print(convo_id)\n",
+    "    return win_side == lawyer_side\n",
+    "\n",
+    "for convo in cur_corpus.iter_conversations():\n",
+    "    win = check_if_lawyer_win(cur_corpus, convo.id)\n",
+    "    convo.meta['lawyer_win'] = win"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "triangle_types = [\"dominating_throughout\", \"back_and_forth\", \"alter_dominance\", \"no_label\"]\n",
+    "case_agreement_types = ['disagree', 'all_agree']\n",
+    "cases_agreement_triangle_matrix = {}\n",
+    "for case in case_agreement_types:\n",
+    "    cases_agreement_triangle_matrix.update({case : {}})\n",
+    "    for convo_type in triangle_types:\n",
+    "        cases_agreement_triangle_matrix[case].update({convo_type : []})\n",
+    "\n",
+    "for convo in cur_corpus.iter_conversations():\n",
+    "    case = convo.meta['agreement_type']\n",
+    "    convo_type = convo.meta['triangle_type']\n",
+    "    if case == 'disagree' or case == 'all_agree':\n",
+    "        cases_agreement_triangle_matrix[case][convo_type].append(convo.id)\n",
+    "\n",
+    "cases_agreement_triangle_matrix_lawyer_win = {}\n",
+    "for case, type_dict in cases_agreement_triangle_matrix.items():\n",
+    "    cases_agreement_triangle_matrix_lawyer_win.update({case : {}})\n",
+    "    for convo_type, convo_id_lst in type_dict.items():\n",
+    "        cases_agreement_triangle_matrix_lawyer_win[case].update({convo_type : []})\n",
+    "        for convo_id in convo_id_lst:\n",
+    "            convo = cur_corpus.get_conversation(convo_id)\n",
+    "            cases_agreement_triangle_matrix_lawyer_win[case][convo_type].append(convo.meta['lawyer_win'])\n",
+    "\n",
+    "win_rates = {}\n",
+    "for case, type_dict in cases_agreement_triangle_matrix_lawyer_win.items():\n",
+    "    win_rates[case] = {}\n",
+    "    for convo_type, win_list in type_dict.items():\n",
+    "        if len(win_list) > 0:\n",
+    "            win_rate = sum(win_list) / len(win_list)\n",
+    "        else:\n",
+    "            win_rate = -1\n",
+    "        win_rates[case][convo_type] = win_rate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We applied our talk-time dynamics framework to Supreme Court Oral Arguments and found that conversational dynamics---the degree of dominance or balance between justices and lawyers and the stereotype of conversation—--correlate with case outcomes, such as whether the final decision was unanimous or divided."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "For divided decision conversations, lawyer win rate is 0.5845588235294118\n",
+      "For unanimous decision conversations, lawyer win rate is 0.6357954545454545\n"
+     ]
+    }
+   ],
+   "source": [
+    "win_case_disagree = [convo.meta['lawyer_win'] for convo in cur_corpus.iter_conversations() if convo.meta['agreement_type'] == 'disagree']\n",
+    "win_case_all_agree = [convo.meta['lawyer_win'] for convo in cur_corpus.iter_conversations() if convo.meta['agreement_type'] == 'all_agree']\n",
+    "\n",
+    "print(f\"For divided decision conversations, lawyer win rate is {win_case_disagree.count(True)/len(win_case_disagree)}\")\n",
+    "print(f\"For unanimous decision conversations, lawyer win rate is {win_case_all_agree.count(True)/len(win_case_all_agree)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtYAAAHeCAYAAAC/q0w2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAmXpJREFUeJzt3QV4FFcXBuCzCSQhjhMcgru7OxRocStaKFooVOlfipQWKFZooYaXAi1QoFC8OMXd3SE4ESRE9n++S2ezFtlkIRv2e59nWHZmsjuzMnvmzrnn6vR6vV6IiIiIiChJXJL250REREREBAysiYiIiIjsgIE1EREREZEdMLAmIiIiIrIDBtZERERERHbAwJqIiIiIyA4YWBMRERER2QEDayIiIiIiO2BgTURERERkB6nEiY0cOTK5N4GIiIgoSYYPHy6OIk3ODnZ7rKdXF0pK49SBNcw7UyC5N4HolehS8KzcqlcjuTeD6JUI2LhNhg+33w88EaUsy5Ytk+nTp8vBgwfl8ePHEhAQIJUqVZJvvvlGcuTIYbLupUuX5Ouvv5b169dLUFCQ+Pv7S5EiRaRfv37Spk0bm57X6QNrIiIiIrIPnS55s4z1er306dNHfv75ZwkMDJT27duLj4+P3Lx5U7Zu3SpXrlwxCaw3bNggb731lvp/s2bNJG/evPLw4UM5evSobNy4kYE1ERERESUPXTJ335s6daoKqtHajP+7urqaLI+MjDT8/+rVq9K6dWvJli2bCqJz5swZ67oJxcCaiIiIiFK8p0+fqv5zaHWeMmWKRVANqVLFhL5I/wgJCVFpI+ZBtfm6CcXAmoiIiIhSfCrI+vXrVRpH9+7dJSoqSv766y85e/asypmuV6+e5MuXzyRlZPHixZI+fXqpU6eOHDhwQKWKREdHS6lSpdQ8Fxfb94WBNRERERE5XGAdHh6uJmPu7u5qsgbBMaClukSJEiqo1iBIHjx4sEyYMMHQYfHBgwdSrlw56d27t0ofMVa6dGkVmGfPnt2mbWYdayIiIiKyC51OZ7dpzJgx4ufnZzJhXmzu3LmjbidNmqTW3bt3r4SGhsq2bdukQIECMnHiRPnhhx9M1j106JAsWLBAZs+erQJtBNy9evVS85F/bSsG1kRERETkcIYOHSrBwcEmE+bFBmkc4ObmJsuXL5fy5cuLt7e3VK9eXaV9oNUawbXxukgZ+fLLL6Vbt26SNm1ayZ07t2q9rlixouzZs0d27Nhh0zYzsCYiIiIiO3Gx24SUD19fX5MptjQQQCs1IL0ja9asJsuKFSumOjVeuHBBHj16ZFgXmjdvbvFYKL0H+/fvt2nvmWNNRERERCm+82LBggXVLTorWqPNR/UQ1LhGLjZarK2tb7yuLdhiTUREREQpXu3atdXtqVOnLJZFRETI+fPnxcvLSzJmzCgeHh5SpUoVtezkyZMW62vzkBpiCwbWRERERGS3FmudnSZboRW6QYMGKoCeMWOGybKxY8eqFJAWLVoY6lP37dtX3Y4YMcKk+sjp06dlzpw5asTGRo0a2bQNTAUhIiIiotdi5MXp06erlmhU9kAHxkKFCqkKH5s2bZJcuXLJ+PHjDetiuPM///xTlixZIiVLlpSGDRuqDpJLly6VZ8+eybx581SHRluwxZqIiIiIXguBgYGqwyGqfKCuNYY1P3funPTv31+V38uSJYthXZT0W7hwoSrPh1bsn376SY3CiMAcgXinTp1sfn62WBMRERFRiu+8qMmRI4eqS50QCKgxcAwme2BgTURERESvTWCdnJx774mIiIiI7IQt1kRERERkFzonb7FmYE1EREREdqETnTgz5z6tICIiIiKyE7ZYExEREZFd6JgKQkRERESUdDonD6yde++JiIiIiOyELdZEREREZBc6J2+xZmBNRERERHbiIs7MufeeiIiIiMhO2GJNRERERHahYyoIEREREVHS6Zw8sHbuvSciIiIishO2WBMRERGRXeicvM2WgTURERER2YWOqSBERERERJRUbLEmIiIiIrvQ6XTizBhYExEREZFd6JgKQkREREREScUWayIiIiKyC52Tt9kysCYiIiIiu9AxFYSIiIiIiJKKLdZEREREZBc6J2+xZmBNRERERHahc/JkCOfeeyIiIiIiO2GLNRERERHZh86522wZWBMRERGRXeicPLB27r0nIiIiIrITtlgTERERkV3odDpxZgysiYiIiMgudE6eDOHce09EREREZCdssSYiIiIiu9A5eedFBtZEREREZB86586xdu7TCiIiIiIiO2GLNRERERHZh4s4NQbWRERERGQfOqaCEBERERFRErHFmoiIiIjsQ+fcLdYMrImIiIjIPlzEqTn57hMRERHR62bZsmVSv359SZ8+vXh4eEiePHmkQ4cOcu3atVj/5uLFi+Lt7a2GZe/Tp0+inpct1kRERERkF/pkTgXR6/UqKP75558lMDBQ2rdvLz4+PnLz5k3ZunWrXLlyRXLkyGHxd9HR0dKtW7ckPz8DayIiIiKyD13yPv3UqVNVUN2vXz/1f1dXV5PlkZGRVv9u8uTJsmvXLhk/frwMHjw40c/PVBAiIiIiSvGePn0qI0eOlLx588qUKVMsgmpIlcqyTfn06dPy+eefy9ChQ6VUqVJJ2ga2WBMRERGRfbgkX5P1+vXr5eHDh9K9e3eJioqSv/76S86ePSv+/v5Sr149yZcvn8XfYL2uXbtK/vz5VXD977//JmkbGFgTERERkX3oki+wPnDggLpFS3WJEiVUUK1xcXFRKR4TJkww+ZsxY8bIwYMHZffu3eLm5pbkbWAqCBERERE5nPDwcAkJCTGZMC82d+7cUbeTJk0SPz8/2bt3r4SGhsq2bdukQIECMnHiRPnhhx8M6x85ckRGjRolH330kZQtW9Yu28zAmoiIiIjsQ2e/Ca3JCJCNJ8yLDSp7AFqely9fLuXLl1fl86pXry6LFy9WrdYIruH58+cqBQTpIcOHD7fb7jMVhIiIiIgcLsd66NChMmTIEJN57u7usa6PwBvKlSsnWbNmNVlWrFgx1anx/Pnz8ujRI9W58dixYyqnOq7HTNGBNXY4MVDI+8KFC3bfHiIiIiJKHu7u7jYFvQULFlS36KxojTYf1UMOHTqkWrgrVapkdd2ffvpJTW+++aZq/U6RgTV2EEGyMTTV37p1y1AiBSPo3L9/31CHMCAgwC7J5kRERESUcjsv1q5dW92eOnXKYllERIRqrfby8pKMGTOqURkzZMhgsR5iztWrV0uhQoWkatWqUrp0aZu2waEC68uXL5vcR1M9yqOgBMpXX30llStXVvkxCMDRdI+yKI8fP5aNGzcm2zYTERER0X+ScYAYjLTYoEEDVXZvxowZ0rNnT8OysWPHqrjy7bffVg21/fv3t/oYW7ZsUYF1zZo15ccff7R5GxwqsDb3ySefyLNnz2TPnj0mRb4RXFerVk0F1CVLllTrJWbniYiIiOj1MX36dKlSpYr06tVLpXCg5RlpH5s2bZJcuXKpkRVfJoeuCrJixQpp2rSp1ZFzAGccWI71iIiIiMgBOi+62GlKZKv1/v37pVu3bqquNYY1P3funGqhRvm9LFmyyMvk0C3WqFcYHBwc5zpYHt86RERERPR6p4JocuTIIbNnz5bEqFWrluj1enktW6yLFi0qixYtirXiB85AsBwlVIiIiIiIkpNDt1ijc2KLFi1Uj8x33nlH5VVnypRJjayzfft2mTVrluq8iPWIiIiIKHnpk7EqiCNw6MAatQPnzJkj7733nirkjTwZDZrpfX19VVN/8+bNk3U7iYiIiEjsOkBMSuTQgTV06dJFtVqjZyfGdEc+NUbWQTUQBN4IromIiIiIkpvDB9bg4+MjnTt3VhMREREROSidOLUUEVhDWFiYnD17VuVUV69ePbk3h4iIiIjM6Zw7snboqiDaaIxI+UibNq2UL1/eMFwl7Ny5U4oUKaJGySEiIiIiSk4OHVhfvXpVKlWqpIaWRHCNIc2NawtWrFhR7t27JwsXLkzW7SQiIiIiSfYBYpKbQwfWw4cPl4cPH8rWrVtlyZIlUr9+fYuRF5EWgpZrIiIiIkpmOjtOKZBDB9br1q1TFUEw5ntsMO77jRs3Xul2ERERERGlqM6LDx48kNy5c8e5DlJDwsPDX9k2EREREVEsdCm0qdkZAuvMmTOrYcvjcuzYMcmZM+cr2yYiIiIiioXOuQNrh04FQU71qlWr5OjRo1aXY1jzTZs2SZMmTV75thERERERpZjA+vPPP5c0adJIjRo15KuvvpLz58+r+WvWrJFhw4ZJo0aNJEOGDPLRRx8l96YSERERkYsdpxTIoVNBkF+NDozt27dXgbROp1M51U2bNlW3SAFBtZCAgIDk3lQiIiIi0jl3KohDB9ZarWrkWa9cuVL27NmjOjT6+vqq+aht7ebmltyb6FBqlAiQN6vlljIFMkgGXw8170HoM7l6O0z2nbkr89efkwehLzp75sjkJa1r5pViedJJ7iw+4uflJj6eqSU8IkruPHwqJ688ktW7r8q6fdfEqHy4zbKkSyPdGxeSGiWySNYMXuKi08nth0/k3xO3ZfaaM3LpVqjVvyuQw0/tT4m86aREYHrJkcnbdF8H/iU37j22+rd5Anzk/dbFpXKRzOLr5Sb3gp/JtiM3ZdLiY+r/5tK4u8rab5pI9ozeMnnxUfl+2YnE7zC9dKdmzpGgnbvjXS9dsSJScshAk3nRkZEStHOX3D1wWB7fuCERoWGi10dLqjRpJE3mTJKuaBHJVrumuPn52rxdIZcuy6Mz5yT4/AV5eueuRISESsTjx+LillrSZMwoaQsVlGx1akqaTBmt/v3mHn0S9DxFer8jmSuWN5l3e/deub5xs4Rdv4Fe3Wpfstasrp4PjRLm7h0+KsemTheX1Kml/MjPxTNLZpv3l16NTz+dLMuWbYp3vWrVysjMmSMN98+duyJ79x6XAwdOysWL1+X+/Ufy8GGIpE6dWrJmzSBlyxaVjh2bSKFCeRK1Xf/8s0e2bz8gJ09elDt37ktwcJg8fx4hXl5pJHv2LFKuXBFp166RBAbmsPr30dHRsnbtTvn7721y6tRFtX0REZHq73PkyCIVKxaXjh3fUP83t3LlFvn111Vy9uxliY7WS+7cWdVzYX+sfd43b94rffp8Ke7ubrJixVTJkydbovaZKMUH1lq9apTdw0TWeadJLVPfqyI1S2W1WObp4a0CxirFssjO40Hy4MyLwLpM/owyoEUxi/VTubpInoDUkifAV96olFO2H70lvcZvk4ioaJu3q26ZbPLtgCri6WH6UcNjY2pTK6+MmH1Aft98weJvezYpJK1q5rX5OXNn8ZY/RzVQAXVUdLTcffRMAtJ7Srs6+aRq8SzS/LN1Evz4ucnfDGlTQr1GZ689kp/+OmXzc1LKgCD38PhvJezqNctlYY8lIuyShFy4JNf/2Swl3n9P/AJtCzgOfzNZoqxUKYp6GqWeE9ONzVulYLe3JUvlimIvV9ask4uLl6n/u7q7iy51Knl8/Yac+22RPAkKkgKd2pusH/nsmZyd/2JgrVzNmjCofk0NHvyNnDt31WI+gtfz56+pacmS9TJ4cBfp1auVzY//668rZdeuIxbzEWAHB5+XEyfOy/z5q2TkyH7Spk1Di23o02eU7NhxyOLvQ0Iey4kTF9T022+rZfLkj6Vu3Zjvyy+/LJUJE+ao/3t6phEPD1c5c+ayjBr1ozqBGDast8njPX78VEaO/EH9v1+/dgyqXzadOLUUEVhT3FK7usi8z2pLycD0hnlodb54M0Ru3X8i6XzdVRCLFmlrQh4/l6t3wlQrtad7KikemE68PFIbllcvESCdG+aXWavP2LRdhXP5y/fvVxW3VK7qPloVDpy9K88jo6V8oYxqPqave1WQm/cfy/ajQbE+VuiTCHF3czE8Vlz6vVlUBdXQe+J22XzopnRukF9GdCungmf837hFuniedNKlYQEVhH82Y2+iTiAo+aT29hb/gvmtLvPOadpSdnnF36ZBtU4nfoF5xdXDXYLPXTAExZGPn8jpWXOl4lcjEr1dnlkDJE2GDBIeHCxhV2KCm+iICPXYPjlziFc2yxNhjU/uXOKRPp3VZe7p0hr+HxX+XO0XoCW83BefiUvqVHJo/GQJOX9RbmzaKjka1lPborn05woJf/BQvLJnk5yNGiR6H+nVS5vWVypUsGwQgcKFY2+IyJkzQAWUwcGhcuzYOYn67ziHWwSpaLWuXr1MorYpa9aMkiVLBvHz85agoPuq9VmDxx858kepVauCZMwY87n97be/LYLqokUDJX16fzl69Kw8evTiSmZ4+HMZOvRb2b59rmptfvr0mUybttCwT3/+OVnN79Llf3Lo0Cn1uN27vyXZs8ecLE6e/KvcunVPChTILe+80zJR+0gJp0+hIya+loH1qFGjEvV3uOyDHGxnNaBlUZOg+t/jQTL0l71y/W5MmoSri04qFskk1+/EzDt+6YF0GLVR9p+5J9FGuR7eaVLJ7E9qSZkCMZerKxXJbHNg/XnnMiaB8Ec/7pblOy6r/1colFHmf15HXF1e9E5A0Ft3yCqTv998+KbsOnlbjl54IBdvhciWb5upwDg+xf97LR6FhaugGpZtv6SeA4xfK6SljO5ZXrXSz1t/Vg6du2/TPlLy88oWIMX6m7ZQxebhadPPcMGunSRrjWrq/09u35Y9n41QaRTq/q0geR4aJm4+8X/mNEiryFq7xot0D6NA9sGJU3L02+9FHxWl7uujouXmth2Sv0PbWB8LjxFQLfbBsTSPb96U6OcvrsCkL1VCUnmmUf/PXL6cCqyxP6GXrxi2B+kq1//Zok4qCnZ9W1wScLJKjiN//pwyderQBK3r6uoqbdo0kK5dm0v+/LkM80+fviSdOw9VLcOaRYvW2BxYI4D98ssBFqka+/efkO7dh6m0EK11+uDBk9KwYVXDOrt3m1b76tOnrQwe3Fn9/8GDYGnUqI9q+Qbcnj17RYoXz69a4J8+fXECXKdOBfHx8VL/b9Kkmgqs0f/q+PHzhsAaQTqCbRcXFxk9eoCkTu1QYQ+9hhzqEzZihGXrkHGuFL4w5vMxz5kDa+QGd2lQwHD/7qOnMmDKTotUh6hovfx7/LbJvAs3Q+TCi7jTRNjTSPl791WTwPrZ8xcBQULlyuytgnENWsS1oBr2nr4r+07fNayDHO9KRTLJ7pN3DOus2WN5ud7eejQpqHLMb91/LBMWWV7SpNeLi6tpEOmbNybVwzNzZknl6SmRj/8LNnQ61ZJtC+Qqu6f1t5ifrmhhyVS+rMqD1jy5Zfp9fBWio6LkzNzfVLCdvV5tm1NdKGX5+efhkjlzTEOCBq3TyF3+8cc/DPOQQmGrmjVfNFaYK1euqMqrNm659jD7Lrm5mYYfpUoVNPw/XTo/FRhrgTVoAbQtIiOj5Isvpqlc7s6dm0nJkjHPQS+Rji3WDmPz5s0W8yZOnCjr16+Xzp07S/Xq1dWgMbdv35Zt27bJ/PnzpWHDhjJkyBBxVhULZzKkPcA/B29IrizeUr9sdsmW0UvCn0fJ2evBsmbPVQl68DRBj+nlkUqaVDQddGfrESsReBzKFTLtnHX0gmVL8JHz902C7/KFTAPrxMJzFcjuJ/7e7lK7dFbVat2iekwAceS/bcmWwUsGtSqu/v/F7P3y+Flkkp+bXr3wh4/k3II/5HlIiLi4uUmajBkkbZHCVoPGdMWLSahRWsaVv9dKvvatVV7yrW07YoJqEclYtrS4po5JiUoIa0G1xs3fz+S+1rIcm/tHjknw2fMS9fy5pPLyFO8c2SVj6VIWnSq9smZV+41W6/uHj0qe5k1VZ8nb+/a/WEGnE9//RrC9tn6jSoVxT59O8rR806Z9I8eAVIuvvvpFdfRDCgRai6tWLWU1aLQWVGsyZTJNM0pM4BqbgwdPyYULMQ0jvr5eUqpUIZN1qlcvK+vW/Wu4P3fuX6pVPUMGf9UpEq3qGuxbrlwBhhb7NGncVav1pk17ZcCADup1WL16h1qOlmm0bMPs2ctVcI9UFa01nF4BnTg1hwqsa9asaXJ/xowZsmXLFjlw4IAULVrUZFmXLl1k0KBBUqVKFVUdxPxvnQVaW43VLJlV2tfJZ7Hexx1KyoRFR2Xm6tNWq28MbFlMpUX4+7irnGOtsyHyoudvOCd/bos5yCVEYIDpj7+1oP72Q9N5gVltr8JgzQ8rTkiDctnVCcdPH1RXnRezpPNUy67fDZNf178YzfPLHuXUfqJ1ftNB204cyHGg+sb1jaYVEy4t+0v8CxWUIr26iXvamLzOXG80lLBr11TQCnf27FOTCZ1OtS4jTcRe9NHR8uCYaaUZVAiJy90Dlp26cAKRq2ljyd0spvKBq7ub5H7zDdV5Ea/Fvx98KrpUripPHLLVqSUeGdLL07v3DLnYBTt3kFQeL6oGUcpy9eotmTfvL5N5U6bMl4oVS8j48UPiDKbNq2QYq1SpRKK3CduD9A+kfty8eVd1JNT4+/vIhAkfqvxrYy1b1pUjR87I4sXr1X10gqxbt6fFY1epUkrGjRts+LynSeMh/ft3UHnheC1q1OguqVO7Glq3O3VqItmyZZJr14IMudgjRvRTlUaInC6wNjdlyhRVw9o8qNYUL15cLZ88ebL06NFDnFF6P9MfR1S/sAa5zp+9XVrCnkZYVODI4Ochjc1aqCEiMlomLT4qs1efsbncnnErOjwNt2wNfmI2L7bOlba6HBQmLb9YL4NbF1ct4ul9PSTowRPZevhFuT2kyTSrnEtVUMH/R809oP6uXtls0qhCDhWEo0MnygH+seWCPI9gZ8aU6NHpM6oCSLnh/1PBJ6Bluvh7feXS8pWqtdraBzt9iWIqcEX5PXu5uHSFPL4Rc/KGToaZq9heFUQfGSmXl69Uudp5WzQ3zM/VuKG4+/vLjX+2qHJ7+vDnqmOiVm4Pzv66QLVqZ6pQTtKXKC6RT57Kja3bDK3iyMHOXKmCpC3My+Up0Z49R6Vr1//JsmXfquAzLgsXrpHt2w+aBL9IlUiso0fPmbQ+a5DOgaAYqSHW8r9Hj35PdbgcM2aGysM2V7p0IRk4sJNF6zoqmOAEAhVHUG7v6dNIKVgwt6HcHowY8YNq1X7jjRoqZSU09LEsWrRWDhw4oeZj25o1q5WkEwqKhYtzN1k7dGCNkRYxGExc0qdPLxcuWJZqcxZuqSyHJvp71xUZ/eshiYiKUhUyejSJuQT3QbsSsmTrRZVzHZ/UqVzkkw6lpEnFHNJz/Dar9Z+TknL1Mr96qI098DvLAz34eqWWz7u86KQz9rdDar++6lneoqW/YYUcqhxgp9H/qLxzchwe6dNLziYNJW3hQuKZOZOk9vNVVS5ubd8pV9esj+mAGHRbbmzaIjkbv6h8Ef7woRz7/icJvXQ5Jk0iMI8KuEMuXpKop89Ua/aD4yelULfOkqVqpSRtJ/qAXPhjqVxbt9EwL7Wvj5QY1F9crdTgRys7UlCQxoJWZp2rq4Rdu64C8+BzL0aehaur10m2WjVMUk9Qvi+2En5Bu/aofUrl5SX5O7aVZw8eyqGxE+XZvXuGdR7JGfX65XmrmeRu/kaS9pvsK2vWTPLuu62lcuWSkitXVpUuERR0T5Ys2aBKz2n9jy5duqHK0/XsGXvlizlzVsjYsTMN95FWMW3a/0wqdtjL9eu3pVOnT006JmoQ6H7wwQTZunW/UVWQfJIuna/qfIh624cOnZYOHT6W999/Wz2GsebNa6nJmr/+2iI7dhxUJwz/+18v9VphO7A9xvD6IXDv39+0HCUlkc65A2uHHjAyY8aMavhy406LxtAhAcsxrHl8wsPDJSQkxGSKjEz5wVLYkxe9rjUoGff5rH1y59FTeRj6XMYuOCz3jQJitN6iDJ4xdGoM7LhQCry9SCr1WyYDp+6UK0Exg7YUz5tevvgvEE0otPga8zDrqALmta3NO1y+LEM7llat9LtVi/RFqVMmJn1m6daLUrrXEvl85j5Dqs3A//KwyXEg+Ats3UJ1CkQAilxoBNiYh9QHY/ePHTf8/+Qvs02CagweU/azj6XUB4Ok4lcjDfnLaBE+8+tv8uzBg0RvI8rqnfxppklQjTJ5pT8eIp4BlgNeQOmPB0v2urVUqT2UEUSruX+B/FJi8ACTHG1s34OTCau3jvrc5xctUf/P166VuPn6yvmFf7wIqnU6KT6wn1SbOkHSFi2s1kFrfthV2zuy0cuD4O+DD7qqtAikOSCnGAE25r39tulJkHGgagy/owio0Tqs/aYi93nGjJFWW5RtMWHCB3LmzEo5dGixrF49XQWqrq4x4QU6SZpv19df/2IyD63XKJ2H7dm48RdVGk/b7m+/na+qeyQEyvRhH+GTT3qo8n1fffWzCqqRf/3DD8Nk9+7fVF46TJ36m0k+N9FrHVh37NhRjh49Ks2aNZMjR0wrNhw+fFjNP378uHTqFH8u5JgxY8TPz89k2r59u6R0l2/H9JqG+8HhEvI4JthGyzQqchjz87Je6QDrIh8ZOcf9p7zoCKKpXz67KtmXUBduhZjcD0hneVk9c1pPiyolLxvK/GG0yWfPI+V/M1/kGDauEJMG892y4+r1W/jPebn536iODctnf+nbRfaTrohpJ6nwh8HqFkHyo9MxP85eWQNUYK5x9/dTrcWa6OcR8vBE4gYLQprFkcnfyZ29MYEDOh+W/d/H6nlthXxo4wom8PzRi/2Kz/nfl0hEaKhq3Uf5PgT89/7LMffLHygZSpVQQXyuJjEDeNw9aJnfTY6pcuUXAaLmzh3Lk0HkPg8ZMl515tOgQ9/Chd8kOag25unpoaqB4ESgUyfTq81r18b8pkRFRcnKlVuN/i6NKguo8fb2lLfeqm24j+DaPCc8NuPGzVTl+tC637JlPbXvmze/aCgpU6awKtGHWuC9erU2/M2GDbsSucdklc6OUwrk0IE1yu/VrVtXVq9eLWXKlFFDmQcGBqrbsmXLqtZqLB8+fHi8jzV06FAJDg42mVBlJKU7cOauRZqD+VUYf2/TS873Q+JP6bht1tkQOdqospFQ+0+bbheGJDdXMp/pvH2nk14RJL60mdE9K4iLi04NEINcbMiUNibox4A6GuRlmy+n5BcdGXfpx6dG6Q2QyvNFvmn4g0cJyE8ynfc8JObKTUIhzeLgmPEmQTyGVi/96YcmHSlt3a9n90wr66SKJ48WHp46o4ZvR5UQrTNmRFiYytUGD6OBZoy3LTyBQTu9fNZyj42Zpzf4+Jg2WISEhMk77wyX1au3mwzE8vvvEyRfPsu+NfZi3ony7t2Hhv/fvx9ssl/Wv4qmM/E38UFt7D///Ec8PNxk1Kj+ah5SSrTnwiA2GuP/WzsZoSRw0dlvSoEcOrD28PBQpfZmzZqlqn64ubnJ1atX1W2tWrXU/HXr1qn14uPu7q4CcuMJQ6WndCilp5WP01IuWtWIGX2rStHMatRFDfKJz1x7pEZYRHpHkVyWP/Qebq7yUfuSFqkdD0NNh2reOqWZXFjQwTAZu3I7THafjDng58jkLS2NSt6hZnX5gjEl+ZB6Yo9Se3Hp91ZRVXnk1JWH8suqmJbIkCcxKSjpfGI+S+l8X/zf+AoAJb/g8+fl4JgJqmqGeTAacumKXFm52mSeX/58FqMVAjoTIvDUYITEu/tNW2pRus/Yro8+k809+hgmc+g4ePCrb0w6KgbUqCbFB/WPNxA+t2CRnP11oXoM89rTl1euthiGXduv2KBl+sy8Ber/uZs3VR0mwRWdMv8LWjAAjuZ5aMxJRGov652g6dVD6bqOHT9RrarmQTZGUJw+fZHJvLJlixj+f+vWXfW3e/e+uEIBtWuXl/nzx1p0CLSmYMFmhqlOnXdMlm3cuEsNvILWYXMotbdgwYsKNBqkrmjQYozg13jI8WXL/jHcDwt7IsuXm1b6MR+ExhxapocPn67+j6ohGJVRa/3WgvSH/129AuPt9vVN+CBQRPFx+MgSX4hu3bqpiaz7ct4BWfRFPTV6IIzpVUHa1sqrqnqUKWgaGHy75Jjq1+XqqpOujQqqCcH2+evBEvo0QlXmKJwrrfh4mtbvXfDPeZPRGRNi9K8H5c8vGxhGXxzXu6K0rZ1XDWleoVAm1XKsGTHnRWUOY9iHtrUDDfcz+pu2HP8wpLo8j4gyDIzTd7Jp+oqxfNl85d1mhQ3DlkdGxezLv8eCDHW7O9bLp16jykUyq0Fr1PLjsQ+1TskDHfkwodMhhi1HnWd0XkRHP+NKH64eHpKjQT1D66x/oQIxLcl6vRye8K0a0tzF3c3QedG4kyHqXtvi0JgJEvk05moPtg+1sU/++CLn0xiGM0euuHEgHLRzt9zYvFWdBCBlBLvy+MYNi7SPDGVKqdSSuCAYf3r7tnp9MKS5aVpJbgm5cEkenTknj2/eUs91a2vM9wdpI+Q4Dhw4qSakWqCKBgJBdMhDbrBxHySUlMNoiJo+fb5UIxVqUqVyVdU4Pv10ssVzYFAWlKVLqOvX76hc5tGjf5bcubOqKhvIq0adbfPtwmiHxqkeuN+kSXXVuqz59NNvVZUPBN1a50UNcsqxflymTVskly/fUK9Pjx4tTF6TkiULyOHDZ2Tv3uMq6Ee6yh9/rDOsU7kyK4PYlUvKbGl2msCa4odhuD+Yvku+6V1J3N1cVcBa1qg1WKtH/eNfJ1XusDl05MMUG1QR+XZxTItHQp268kjem7JTJvevojoqYrswCIwxBP/DZ++XbUdvWfx9lvSeUjp/7B1Ti+aOaYFEfeq4fNWzgrindpXZa86oIdKNLd12SdrVCVSdNN9rWUza1wmUdL7uhmHREWiTAzG6RBwVHm5SLcMYOiIW7fuuSbpDoR5d5MjEqfL09n9XR/R6CT5vWVUIIzAW7dsrQekWxoyDam37rNWj1lIyTMXsF04SMFmTrnhRKdwz7oYGtJijOorOxeXFsOVmI04Gtm0lR8Z/K9GRkbJv+JeSytNL5WFrw6IjdYUcg3FGxJMnz1SAbQ2qenz77ScmKQ6ovGE+EuHGjbut/j06RSYGighg1MbYRm5Ei/HXXw9Uoz0a++STd+TCheuqlrUGAbU5BNVjx74f5/adO3dFZs78UwX2GGIdJxDGPv64h3Tr9rlq1W7e/D11YqK1WNeuXUGqVbOtcz7FTe/ccTUD69fFql1X5fD5+/JOk0JStXgWCUjnKS4uLwZhQb7z/I3nTALKJ88i5eOfdkvZ/BmkaJ50KrBOixxqHYY0j5Crt8Pk0Ll78tfOK3LsUuLzzzYeuCH1P1ylSv5VLxEg2TJ4qoFosF1oCZ699oxcvGl7HqstOtQJlHIFM8qNu49l0h9HLZajBb3T6E2q+kejCtlVp8pHYc9l14nbMnnxUZXWQo4DVTJKf/qB3D9yXEIuXpQnt++oyhcIktFyjZEI05csLlmrV7UY3RC1msuPGiZBO/6Ve4eOqLSLF38brSpwpMmSWdIVKyrZalVX1TNeJZTBS1ukkDw8eVqlfTy7/0Cinj0TXapUqmOlT57cqs50hpJxV6lBS+HpufNV5RC01vvmyWWxjn/+fFJ66EdyecUqdWIS+eSJpMmcWbJUriA5mzR6iXtJtipfvpj89ttY2bJlnwpCL1++aWjNRYCIPGmkd7RuXd+uoyfGp27diipQRUk8BNWPHoWoQN7NLbVq/c6bN7tUq1Za3nqrrip7Zw7zFi4cJ6tWbZN163aqERKRR41qXWhlRipHpUolpX37RnGmgeDzPmzYNJUmg9Z6bdRF8/SYBQvGyfffL5ADB06p7cydO5sq14cyhkT2pNPHVssuGaAUDqaTJ09KgQIF1P/NOzBYg3USUzpv5MiRMu9MgURuLVHK0qXgWblVr0ZybwbRKxGwcZsMH27a94Po9eU4sUzed1+U97SHiz+nvBMfh2qxrlGjhgqSPT09Te4TERERUQqgc+64zaEC6y1btsR5n4iIiIjIUTlUYE1EREREKZiLc7dYO3Qd686dO8uGDRtiHdKciIiIiBwssnSx05QCOfRm//bbb9KoUSPJnj27fPjhh2oYcyIiIiIiR+TQgfWBAwdk4MCBqk7mpEmT1DDmxYsXl/Hjx8uNG6ajkxERERGRA3Re1NlpSoEcOrAuXbq0TJ48WQXRf//9t7Rv314uXbokn3zyieTKlUvq1asnc+fOlTCLgRaIiIiIKFlyrF3sNKVADh1Ya1DPunHjxio15Pbt2zJ79mypXbu2qhrSo0cPyZIl9uLxRERERESvQooIrI15eXlJ165dZdmyZTJq1ChJlSqVPDUbRpiIiIiIXj29Tme3KSkQJ9avX1/Sp08vHh4ekidPHunQoYNcu3ZNLY+IiJClS5eqmLJw4cLi7e0tPj4+UrFiRfnhhx8kKirq9S+3h1zrdevWyfz582XFihUqoMYAMkgJISIiIiLnbrLV6/XSp08f+fnnnyUwMFClESNgvnnzpmzdulWuXLkiOXLkkAsXLkjr1q1VQF23bl1p3ry5BAcHy8qVK6Vfv36yevVq+euvv2weqDBFBNb79+9XwfSiRYvk7t276kVDJ0aU4+vYsaNkzZo1uTeRiIiIiJLZ1KlTVVCN4Bj/d3V1NVkeGRmpbhFsT5s2TbVYIxtCM3HiRKlVq5asWrVKlixZIm3atLHp+R06sB49erTKqz579qwKpgMCAmTIkCEqoC5RokRybx4RERERGXNJvk6HyGQYOXKk5M2bV6ZMmWIRVANSiCFbtmwq+DaHIBuxJhpu0cL9WgXWX3zxhdrBTp06qWAaTfXoyEhEREREDkiXfIH1+vXr5eHDh9K9e3eVI41UDjTO+vv7q7ThfPnyJehxUqdObRKEvzaB9bx586Rly5bi6emZ3JtCRERERA4+/gmgpRqZDQiqNWiYHTx4sEyYMEHiM2vWLHXboEEDsZVDN/++/fbbDKqJiIiInLCOdXh4uISEhJhMmBebO3fuqFsMKujn5yd79+6V0NBQ2bZtmxQoUEDlT6PiR1yQn71mzRqpU6eONGnSxPbdt/kviIiIiIis0dlvGjNmjAqQjSfMi6t6HLi5ucny5culfPnyqupH9erVZfHixarVGsF1bNBhccCAAWoQQhTNSAyHSgXBDmM6efKkOrPA/xNS5gTraL08iYiIiCjlGzp0qOpIaMzd3T3W9RF4Q7ly5SwqxhUrVkx1ajx//rw8evRI5V0bQ3k9lN/LnDmzbNq0SRXMSPGBdY0aNVSQrKV/aPeJiIiIyPHp7VgVBEF0XIG0uYIFC6pb86BZo81H9RDjdf7++29p1aqVZMiQQTZv3qwC8MRyqMAaQ5THdZ+IiIiIHJhL8jWI1q5dW92eOnXKYhlGWkRrNarNZcyY0SKoTpcunQqqE1o5JDbMsSYiIiKiFC8wMFBV8kAAPWPGDJNlY8eOVSkgLVq0MJTRQydFBNVp06ZVQXX+/PmTvA0O1WLdo0ePRP0d0kVmzpxp9+0hIiIiIhvokjeFd/r06VKlShXp1auX6sBYqFAhOXTokMqbRqfE8ePHq/VOnz6tgmxUGcFIiwsXLrR4rNy5c0u3bt1SbmA9Z86cWANnjLwY23wG1kREREQOwCX5W63379+vBhlcu3atGjQmS5Ys0r9/fzUvU6ZMar2goCBD6b5FixZZfayaNWu+usAalTu+//572bdvn2paxwg35hDwXrhwIcGPeenSJYuyKYMGDZLdu3erW5RLQW/N27dvq5qEGAO+cuXKMnny5MTuBhERERG9RnLkyCGzZ8+Ocx20UltrtE2qRAXWGDu9UaNGKtJHngqCXWvDPtq6wWiiN8+H2bNnjxw5csSk7Al6faJiCIasLF26tCxZskQ+/vjjxOwKEREREdmLzrmruSUqsP70009V3Wgkhnft2lUNHfkyIL2jbdu2sdYSzJYtm1r+yy+/MLAmIiIicuKqICk2sEYLcvv27RPd2TChrl+/Lh4eHnGug+VYj4iIiIgoxaWYowaglvz9MmXPnl2WLVsmz549s7r8yZMnajnWIyIiIiIHaLF2sdPkLIF1kyZNZPv27fKy9ezZUy5evChVq1aVFStWyP3799V83KKESrVq1eTy5cuqpAoRERERJS89KrbZaXKaVBDUAERQO3DgQNXBUBuC3N4++ugjOXv2rOrZ2bJlSzXPxcVFVQvROkeiAyPWIyIiIiJKcYE18qu9vb1l2rRpqvZ0gQIFxNfX12q5vX/++SfRG4cgGh0Yu3TpInPnzpWjR49KcHCw+Pn5ScmSJaVz586qXAoREREROQAXcWqJCqy3bNli+H9YWJgcPHjQ6noIrO0BBboxEREREZED06XMFI5kDay1VAwiIiIiInLAIc2JiIiIKAVzYYt1kj1+/FhCQkJUnjVK8RERERGRE3Jx7sA60Snmz58/l6+++kry58+vAmrUksYt7n/99ddqORERERGRs0hUi/XTp0+lbt26smfPHjWcOYJpDDseFBQkFy5ckGHDhsmqVatURZA0adLYf6uJiIiIyPHoxKklqsV63Lhxsnv3bmnbtq0KpE+fPi2bN2+WU6dOqQFd2rVrp5Z/88039t9iIiIiInJIehed3SanCax///13KVOmjCxcuFBy5MhhsgwpIQsWLJCyZcvKokWL7LWdRERERESvX2CNYcQbNGgQ5zr16tVT6xERERGRE9Wx1tlpcpYcawxhfvfu3TjXwfKXNdQ5ERERETkgl5QZECdri3WlSpVUmseJEyesLj958qRKF6lcuXJSt4+IiIiI6PVtsf7ss89k/fr1Ur58eXnnnXfUcOOZM2eW27dvq+HOZ8+eLRERETJ06FD7bzEREREROSadOLVEBdZVq1ZVHRR79eol06ZNk+nTpxuW6fV68fPzk7lz56r1iIiIiMg5uCR6hBQnH3mxTZs20qhRI1mxYoUcOnTIMPJi6dKl5c033xQfHx/7bikRERER0es6pDmC57fffltNREREROTcUmgxD8cIrImIiIiINDoG1vGbN2+eum3RooVqpdbuJ0SXLl0Sv3VERERERK9TYN2tWzfR6XSqzB4Ca+1+XNCJEeswsCYiIiJyDjonb7JOUGA9a9Ys9UIFBASo+yinR0RERERkTOfccXXCW6yNde3a9WVtDxERERFRisTOi0RERERkFzonb7FOVBnva9euyaZNm+TJkyeGedHR0TJu3Dg1KEy9evXk77//tud2EhEREZGD07nYb3KaFuthw4bJypUrJSgoyDDvq6++kuHDhxvub926Vf7991817DkRERERvf50bLG23c6dO1WrdOrUqQ0VQL7//nspVKiQXL16Vfbu3SteXl4yfvx4e28vEREREdHr02J9584dyZUrl+H+4cOH5e7duzJixAjJnj27mt566y3Vak1EREREzsHFyVusExVYI58ak2bLli2qHF+dOnUM87Jly2aSKkJERERErzedkwfWiUoFyZkzp0r30CxfvlzVuC5YsKBhHoJqf39/+2wlEREREdHr2GLdqlUr1VmxdevW4uHhITt27JABAwaYrHPy5EnJmzevvbaTiIiIiByczslbrBMVWH/44Yeyfv16+fPPP9X9EiVKqPxqzZUrV1SL9qeffmq/LSUiIiIih6Zz8sg6UYG1r6+v7N69W44fP67uFy5cWFxdXU3WQdBdrlw5+2wlEREREdHrPPJisWLFrM5HxRDjqiFERERE9PrTpdCBXeyFQ5oTERERkV3onDsTJGGBNcroIWdm7ty5qka1cVm9uOBv/vnnn6RuIxERERHR6xFYa3Wqnzx5YrifEM6ewE5ERETkTHQOEvotW7ZMpk+fLgcPHpTHjx+rstCVKlWSb775RnLkyGFYLyQkRBXgWLp0qSoVjfXatGkjw4cPF29v75cTWBsPBmPtPhERERGRLpkDa71eL3369JGff/5ZAgMDpX379uLj4yM3b95UI4Kjcp0WWCPgrlmzphpBvEGDBtKhQwc5dOiQTJgwQa27bds2VVbaFsyxJiIiIqLXwtSpU1VQ3a9fP/V/86p1kZGRhv+j9RpB9SeffCJjx441zEe56HHjxsnkyZNl6NChNj2/k/fdJCIiIiJ7cdHZb7LV06dPZeTIkWqAwilTplgE1ZAqVSpDy/aMGTNUusewYcNM1sF9zMdym/ff9s0WmThxomTIkEE1q1uD+RkzZlRnCkRERETkPKkgOjtNtsLghQ8fPpS33npLoqKi1JgqaIn+8ccf5fz58ybrnjt3TsWrVatWFS8vL5NluI/5Fy9elGvXrr38wHrx4sVSsmRJyZo1q9XlmF+qVClZtGhRYh6eiIiIiMgmBw4cULdoqcao4K1atVKpHH379pWCBQuqkcONA2vInz+/1cfS5mvrvdTAGk9StGjRONfBcls3hoiIiIhSLp0dW6zDw8NV1Q7jCfNic+fOHXU7adIk8fPzk71790poaKjqhFigQAGVcfHDDz+odYKDg9Ut1ottlHHj9V5qYI0cFvNmc3PoRRkWFpaYhyciIiKiFEjnorPbNGbMGBX4Gk+YFxutap2bm5ssX75cypcvr3Klq1evrrItXFxcVHD9MiWqKkjOnDnl33//jXOdXbt2qcFkiIiIiIhshTSOIUOGmMxzd3ePdX2t9blcuXIW6crFihVTnRqRa/3o0SPDurG1SKN13PgxX2qL9RtvvCE7duyQWbNmWV2OXpRY3qxZs8Q8PBERERE5eSqIu7u7SskwnuIKrJFHDf7+/laXa/OReRFfDnV8Odh2bbFGfb+FCxdKr169ZP78+VK/fn3Jli2b3LhxQ/XIRC4LzhRsrf1HRERERCmXLhkHiKldu7a6PXXqlMWyiIgI1VqNVGZUrsuSJYuKVXfu3KkGijFOccZ9zM+TJ4/JKI0vrcUaG7R582YpU6aMGt78f//7n3Tv3l3dYqQaNMFjOdYjIiIiInrZMNIiRlBEAG1egxpl95AC0qJFC1XLWqfTSc+ePVV/wC+//NJkXdzHfDQg2yrRIy+iuX3fvn1qQq9L5Kigib1ChQoqsCYiIiIi56JL5iHNp0+fLlWqVFFBMTowFipUSA1TvmnTJsmVK5eMHz/esO7HH38sK1asUKMsYh00GB88eFBlX6Dj4/vvv2/z8yd5SHM8MSYiIiIicm4uuuRvtd6/f7988cUXsnbtWhUkI+2jf//+al6mTJkM6yL9A5kWI0aMkKVLl6psi4CAAPnggw9k+PDhkiZNmlcfWJ88eVJOnz6t8lE6d+6c1IcjIiIiIko05EXPnj07Qeui6sfkyZPVZA+JyrEGpIBgdMXixYtLmzZtpFu3boZl6Lzo6ekpf/31l102koiIiIgcny4ZhzR3BIkKrE+cOCF16tSRS5cuyeDBg6Vx48Ymy1GIO0OGDKoYNxERERE5B52L/aaUKFGbjbwTbUz2CRMmWORYo6dl5cqVVas2EREREZEzSFRgjUTvVq1aSb58+eIcnfHWrVtJ2TYiIiIiSkF0Tp4KkqjOi6GhoSa9Kq3BqDZRUVGJ3S4iIiIiSmF0KTUiTs4Wa/S2PHbsWJzroA4gSp4QERERETmDRAXWTZs2VXUBN27caHX5H3/8Ibt375a33norqdtHRERERCmEjqkgtvvss89kyZIl0qRJE+natasEBQUZRrvZtWuXLFy4UHLnzi1Dhgyx9/YSERERkYPSpdCAOFkD64wZM6oOjBgQZubMmYb5AwYMULcVK1ZUwTWKbhMREREROYNEj7yYN29e2blzpxw+fFilfTx48EB8fX1VUM0hzomIiIicj87JW6x1er1eL05q5MiRyb0JREREREmijS/iCOqu2Wm3x/qncVVxmhbr18XYmaeTexOIXolP3ykk/1aqm9ybQfRKVNn9j8yWSsm9GUSvhOOE1ZSgwLpHjx6JrmVonINNRERERK8vFydPBUlQYD1nzpxYA2drmSTafAbWRERERM7DRee0GcYJD6wvXbpkcj86OloGDRqkOi3itnr16pI5c2a5ffu2bNu2TaZOnSqVK1eWyZMnv6ztJiIiIiJKeYF1rly5TO6PHTtW9uzZI0eOHJGAgADD/IIFC0qNGjWke/fuUrp0aVXr+uOPP7b/VhMRERGRw3Fx8lSQRI28iPSOtm3bmgTVxrJly6aW//LLL0ndPiIiIiJKQYGli52mlChR2339+nXx8PCIcx0sx3pERERERM4gUYF19uzZZdmyZfLs2TOry588eaKWYz0iIiIicp7Oiy52mpwmsO7Zs6dcvHhRqlatKitWrJD79++r+bhdvny5VKtWTS5fviy9evWy9/YSERERkQPnWLvYaUqJEjVAzEcffSRnz56V2bNnS8uWLdU8FxcXVS0EUGoPHRixHhERERGRM0hUYI0gGh0Yu3TpInPnzpWjR49KcHCw+Pn5ScmSJaVz585Sq1Yt+28tERERETksF3FuSRrSvGbNmmoiIiIiInJJoSkc9uLsJxZERERERMnfYk1EREREpNGl0Goe9sLAmoiIiIjswoWpIERERERElFRssSYiIiIiu3AR58bAmoiIiIjswsXJc6wTdWKxbds2uXr1apzrXLt2Ta1HREREROQMEhVY165dW+bMmRPnOvPmzVPrEREREZFzcOGQ5rbDkOXxwfDmOl0KfVWIiIiIyGYu4txe2v6fO3dODXFOREREROQMEtxi3aNHD5P7y5cvl8uXL1usFxUVZcivbty4sX22koiIiIgcnouTJyskOLA2zqlGisfhw4fVZA2Wly9fXiZPnmyfrSQiIiIih+fi5FVBEhxYX7p0yZBfnTdvXnn//fdl0KBBFuu5urpK2rRpxcvLy75bSkRERET0OgTWuXLlMvx/9uzZUrp0aZN5REREROTcXJw8FSRRnRe7d+8u48aNs//WEBEREVGKDixd7DSlRInablT7yJEjh/23hoiIiIhInKiONTomHjlyxP5bQ0REREQplouTd15MVIv1yJEjZdOmTWp0RSIiIiIiRxh5MXfu3Ko6nbWpVq1aFuvfvHlTFeMoUqSIKryROXNmqVatmvz666+qhPQrabHesGGD2jjkWn/33XeqBRsbYj7SIu4PGzYsMU9BRERERJSolGVUr7MWdBu7ePGiVKxYUe7fvy8NGzaUZs2aSUhIiBqrpUuXLqoRGQU7XnpgPWLECMP/Dxw4oCZrGFgTEREROQ8XB6gK4u/vbxKrxmbChAly7949+fbbb01KSI8ZM0ZKliypxnDB49hSBS9RgfXmzZsT82dERERE9BpzkZQDLdbQpEkTi8Ac6SALFixQgfdLD6xr1qyZmD8jIiIiInqpwsPDVWsz8qd9fX1VyjJSPswVK1ZM1q1bJ6tXrzZpsX706JHs3LlTsmTJonKvbZGowJqIiIiIyBGrggQFBal+gMYQXC9cuFACAwMN8z766CNZuXKlDB48WNauXSslSpQw5Fh7enrKsmXLJE2aNC8/sN62bVuC161Ro0ZinoKIiIiInDjHOjw8XE3G3N3d1RQbBNTVq1dXrdHe3t5y9uxZmTRpkqryUbduXTl27Jj4+PiodVF4Y9euXfL222/LmjVrVHANCKb79Omj8qxtlajAGhVBzCuAxCYxpUqIiIiIyLmNGTNGlXg2Nnz48Dg7JmK5sVKlShnKQyO4/uWXX2TIkCHq/vnz51UlEATg27dvV+siDWT+/Pny+eefqzQRzHd1dX25gfUXX3xhNbAODg6WgwcPqhbtN954Q8qVK5eYhyciIiIiJ++8OHToUEMQrImrtTouvXv3VoE1cqe1x+zWrZtcuXJFdWJEPjUgyP7000/l9u3bqlrIokWLpFOnTq+u3J41S5YsURtrfpZBRERERK8vFzumgsSX9mGLDBkyqNvHjx+r29DQUBVklylTxhBUG6tdu7YKrA8dOmRTYP1SqqK0bt1abRDONIiIiIiIktOePXtMBol5/vy5ukU5PWvu3r2rbm0N7F9aucHChQurhHAiIiIicg46nd5uk61Onz4tT548sTr/k08+Uf/v2LGjuk2fPr0ULFhQrl69KjNmzDBZH3nWGDwG0FDsEOX20HTu4pKSyoQTERERUUodeXHRokWqAggq0mFQFy8vL1UVBHWqIyIiVCaFcbW6yZMnS/PmzaVXr17qb0uXLi0PHz6Uv/76S7VYt2rVSurVq/fyA2tE99ZERkbKjRs3VFFujK/+1ltvJebhiYiIiIhsgtblU6dOqcZdVPNA6zVyqzGyYr9+/aRBgwYm6zdu3Fj+/fdfGT9+vOzYsUO2bt0qHh4eKusChTr69u1r2wYkNrBGfkpc5fb0er0qwI0zASIiIiJyDi7J+NwYGdzW0cExcMwff/xht21IVGDdpUsXq4E1Uj/Spk2rNvLNN99UUT8REREROQcXBxh5MTklKrBGqkdyunz5smzYsEEF7i1atFA1B4mIiIiIkpND9y78+uuvJU+ePCqRXLNlyxY1TCWGmkStbNQffPDgQbJuJxERERGJ6rxoryklSlJVEBTZXr58uRw+fFhCQkLE19dXDQeJTovoiZlUeGzkcyO9RINyKdHR0WrwmaCgIJk+fboq4D1q1KgkPx8RERERJZ5LCg2Ikz2wXrp0qbz77ruq1h86K2qQe+3v76/GYm/ZsmWSUz7atGljuH/z5k3Zt2+ffPDBB2oMdzhz5owsW7aMgTURERERpbxUEJQmad++vWqx7tmzpyxYsEA2b94sCxcuVLUAUd4Ey5M6QAxawRGka7Zt26YC92bNmhnmIRUktvJ/RERERPTquNpxcpoWa+Q+Y4hHjLFesmRJk2Xt2rVTtQKrVKmi1lu5cmWiNy5z5sxy5coVw310WMTzVqxY0TDv2bNncZb+IyIiIqJXw4VVQWyHlmgE0OZBtaZEiRLStm1bWbFiRZI2DmX78BirVq1SFUB+//13VfzbeNz2S5cuSdasWZP0PEREREREyZIKglQPtCbHBcutjddui88++0yN5oia2A0bNlSt05inCQ8PV+khxi3YRERERJQ8XFgVxHao1IG0DKR6xOaff/5R6yUF8qd3794tv/76q7qPVvAKFSoYlmPISrRgd+zYMUnPQ0RERERJ55JCA+JkDawR4H755ZfStWtXGTNmjEkqxq1bt2To0KFy4MABGTZsWJI3EOkmsaWcVKpUSVUEISIiIiJKkYE1akmvXbtWtSQj7zlfvnwq9eP27dty/vx5ef78uWpZxnpERERE5Bxc2WJtO09PT5XbPG7cOJk3b56cPHlSTZA3b17Vkv3xxx+bdDJMjITWpkZVEHu0jhMRERFR4rkwsE4cBM1ffPGFmkJDQw0jL/r4+Nht40aMGBFvQI3BaRhYExEREVGKHtJcg2DangG1BoPOWBMcHCwHDx6UqVOnSr169aR///52f24iIiIiso0L61jbDgPDYEhzpHtkyZLFYjk6MI4fP151ckQHw8SqWbNmrMuaN28unTp1UpVDWrVqlejnICIiIiL7cHHyVJBE1bGeNGmSGlHRWlANAQEBalCXyZMny8uUP39+adGihYwdO/alPg8RERER0UsJrPft2yfVqlWLc50aNWqoGtQvW6ZMmeTMmTMv/XmIiIiIKG6udpycJhXkzp07ki1btjjXQWs21nuZMPIiyv75+/u/1OchIiIiovi5OHkqSKICawSyV69ejXOdK1euiLe3tyQFSvlZg2HOb9y4IYsWLZLTp0/LwIEDk/Q8RERERETJElhrIx5eu3ZNcuTIYbEcQffy5culTp06Sdq4bt26qVJ65lBiD7CsQ4cOzLEmIiIicgAurApiuyFDhqjOi1WrVpXRo0dL/fr1VYdFVANZv369fP755/L06VP54IMPkrRxs2fPtjrfxcVF0qZNK2XLllXPS0RERETJz5WpILZDx0RUBkHg3L17d5PBWrTAd8qUKWq9pMAIjkREREREr/UAMYMGDZLatWvLjz/+qKqEYNAW5F5XqFBB+vTpI8WKFbPvlhIRERGRQ3Nhi3XilShRQqZPny4vGwakmTNnjhw+fNgwdHrp0qWlS5cu8Zb9IyIiIqJXw4WBtWMbPHiwGrrcuMMi/n/gwAGZOXOmajlHWgoRERERUYobIOZVmTt3rsrVxgiLv/32m9y8eVOV2kMnyQULFkiBAgXU8tjK8hERERHRq22xdrHTlBI5dGD9ww8/SPbs2WXPnj2qrB4GnUGLdebMmaV9+/ZqZEcMVPMq0lGIiIiIKG6uOr3dppTIoQPrEydOSKtWrcTPz8/qcszHcqxHRERERJScHD7HOj7WBpAhIiIiolfPRZybQ+9/0aJFZenSpRIWFmZ1eWhoqFqO9YiIiIgoebkwx9px9e7dW65fvy6VK1dWAfS9e/fUfNwuWbJEqlSpopb37ds3uTeViIiIiJycQ6eCYFTHQ4cOyffffy9t27Y1jOoYHR2t/o+ye++99x5HaCQiIiJyAC4ptKXZKQJrQA3rNm3aWB0gBgF19erVk3sTiYiIiEheVAVxZg4fWAOCZwbQREREROTIUkRgTURERESOj6kgKcDdu3fl5MmTauTFiIgIq+t06dLllW8XEREREcVwYWDtuJ4+fao6J/76669qKHNr0IERtawZWBMRERFRcnLowHrgwIEya9YsKVGihLRu3VoCAgIkVSqH3mQiIiIip+XCFmvHhdrV5cqVk127domrq2tybw4RERERxcHVyQNrhx4gJioqSmrVqsWgmoiIiIgcnkO3WJcvX17OnTuX3JuRotSvWVI6tKgmlcrll0wZ/NS8e/dD5eLV27Jz72n5ae56ufcg1OLv0qf1kV6d60nDWqUkME8W8fPxlEchj+XOvWA5ePSirFi7T1ZvPGjTthQukF1qVCosVcoXkgKBWSVTBl/1PM8jIuXazftqe36et0GOn75q8bfrfh8mNSoXSfBzjZ68RL6avNRwv1zJQPl0UAupXK6geHt6yM2gB2ofsF7Y42cWf581c1o5+M8E8fP1lHcGT5cFS7fbtK/kOD4oll8aZMsc73r77z2U/x04YTG/csZ06u8L+HmLn1tqeRYVLTceP5V/79yXFVdvqvu2QgNO0bS+UszfV4qk9ZUsadzFz81NvFO5ytP/Hh/bs/LaLXn03LKDdjp3N+mSL6eUz5BW/N1SS1hEpBx6ECzzzl+Rm0+eWX2+KZVKSkE/H1l3/bZMOsHj6OugZmAGeatEgJTN4S8ZvNzUvAdPIuTKgyey7+pDmbfvqrqvaVgok5TK5iclsvpJ8ay+4uuR2rBs9+UH0n7uPrtsV1ZfD+lcPodUy5tesvunES/3VBL8NELuhIbLoRuP5K9jQbL36kOTvymYyVtqBGaQkll9pWQ2P8mR1tNkebVvt8r1YMvPNuRN7ymDa+WTynnSiZ9Harn3+LlsOX9PJm06J3cfP7dYP01qV9nQr6ratkmbz8vUbRfsst9knUsy17HOnTu3XLlyxeqymjVrypYtWyzm37lzR8aMGSOrVq2Sa9euiZeXlxQoUED137N1dG+HDqy//PJLqVevntrRpk2bJvfmODRfnzQy7/uB0rB2KYtlXp4ekitHRqldtZhs3nFc7j04Y7K8RZMK8uP43uLrY3pgQ2COqVihnJI9a3qbA+tfpw2UogVzWMx3d08tRQpkV1P39rVl+De/y6QfV4q9VClfUNYs/Fzc3FJJRESk3HsYKrlzZpJB774h1SsXllpvfSEREVEmfzP5y+4qqN647SiDaieVWqeToSULSdXM6U3nu7hIIX8fNTXNkUU+O3BCrj1+atNj+6ROJRMrlLC+zOjx38yVVUYfPiWHHwQblvumTiVTKpaQTGk81P17z8Ilrbub1A7IKOUypJWBuw9bBNdv5syqguoH4c/l5zMXbdpWcjw+7qnku1YlpFb+jBbLPN1SqYCxat70suPifXnw5JFh2U/tSr/0betWIacMrV9A3FOZXlnO6O2upqIBvpLKxcUisO5VObe0LpXN5ufLnc5TlvespE4SoqL1cjcsXAJ8PaRDmexSPW96eeOnXRL8zPTk9MM6+dRrdOZOqPywg98HZ0iF8PPzk/fff99q0G0Ogw82aNBAHj58KG+88Ybq0xcWFianTp2SlStXvl6BdeXKlWX9+vXSvHlzKVOmjJQsWVKNumgOVUGGDRsmzip1alf5+7fPpFypfIZ54eERcubCTbl+675kTOcr+fJmkbR+3hZ/+1bjCjJ/+iA1VLzm1u2HcvbCTYmIjJIcWdNL/rwBSd7GC5eD5OyFW5LO30vKlgyUVP8dhHH71Wcd5ejJKyqo1Wzfc0ruP7RsWdda45o3Km+yzQeOxBwsh3/YVgXVkZFRUrXp/+TYqasy5n+d5P3eTaVM8bzSpnkVk+C5ecNy6vEeP3kmA4bOSPK+kuNA6+8xoyDV2IXQMJP7/YsEmgTVjyMi5VRwqGT0cJdc3i9OOhHcfl22qPT+95A8iTQ9OUuoKL1eLoY+lgfPnksWTzy2l0kAPqxUYemx44AE/9dy3TxnVkNQPe3UBfnr6i2pmDGtjCpTVK3fPk8OkxbpjB5u0jV/TvX/H09flLBEbic5htQuOvm1cznV8qwJj4yWi/cey82Qp5Le003ypPcSvzQxrdHWPHoaIf7xrGOrdyrlkmENC5nMu/7oqVy8/1hSuehUMJvTrCXamtDwSHFP5SJurvGHZAOq5zW0vPdadEg2nbsrXcrnlFFNCqvn61ohp0mLdPEAXzUPQfjQlSckItq5RwV0Fv7+/jJixIh418No3m+++ab6/4EDB1SxDGOxVaRLsYH1/fv3ZejQoeos4p9//lGTNc4eWA8d2NIkqN6887j0/fhnuXLtrmGeq6uLSq24fPWOYV46f2/54Zt3DQEqgvGB/5slvy7eqsoYarJlSafSOmyFwHbWwk3y/cw1cursdcP84oVzyro/hpkE+r3ermcSWI+etCTWx21ct7S81aSi4f7Js9dl7aZDhvtlS+ZVtwioMcFvS7erwBrKlww0BNbeXh4yaVQ3w3Mav2aU8l0JeyKjj5yOd73MadyloVH6CIJqBM93n4Wr+x8VLyD1smZS/0eQ2y5Pdpl9zvqlxtiERkTK0ss3ZPX1IEPQDHhcPL7GO3UqqZ0loyy/elPdR0qKZuONF9/fPXcfSmhEhPikTi0FzU6Y+xcOFM9UqWTPnQeyNeieTdtIjue9moEmQfXOi/flk5UnVACrcdXppFLutHLNaB4g7eHozWA1FcjoLYu6VbDbdgVm8JJP6hUwCdw/XnFc1p+J+Y3RWpgz+7hb/D0C4n8vPZAjN4PVScL2QTVUYBwfpLVoz4fHgD+P3FCBNZTM5mtSnWJMs6KqxXzu3qty8Lr1k2xy3qog06dPl6tXr8rMmTMtgmpITCU6hw6sUcN6x44d0qRJE2nfvj3L7VnhmcZd+nZraLgfdOeRdOrzrTwMfmyyXlRUtEoDMdarc33x94tpLfvq26Uy7w/L3KMbQQ/UZKsW3b5Rrd/mEOz+NHeDfDqwhWEecrATalCvN0zuT/n5b0msLz9pL9kC0svBYxdl6ozViX4cStlKp/MXF13Mr8Geuw8MQTX8fe2WIbAG5GDbElijdbvH9v0SEmHZ+rHx5h1pnD2zFEsbEzzl8Io/wLCmWub0UjlTenkSGSnfnTqfqMcgx4HcYKRaaJD20G/xEYtUB1wF2XnJ8hj9MnOJkcph3ML8xepTFkE1XH7wRE3mVp+8LS/bO5VyS7EAX7kZ/FS++efsS38+esERqoKEh4fLnDlz1MCCyHRAn72KFWMa5DS///67apxt1aqVnDlzRmVJYAyVQoUKSaNGjcTN7UVfBls4dJS6du1aVRUEOdZkXfVKhU2C4783HpDA3FmkaYOykit7RnkWHiEnz1yTP//eYxEcN61fxuQ+Ovd1bVdLypfOJ15p3OX23WDZ8u8JWbf5sEkLdkJZC6o1QXdMl4WEWh54rSlVLLfUrFLU5DkWLjPNid5/+IJaBy3jmBDId2pV3bB87+EXAUeF0vnUyQVa1vt9/ItE8xLhawdpEX0K5RF/Nzd5HhUtt54+k4P3H8qZYNM0EHQINBZmdvkPrc3mnQmzeXrIDSsdB62J1OutBtWaB+GmgdJjo+c/ExwqFTOmU/+vly2TIRUErdVwOvhFypRnKlfpV+jF1RoE/XefWXbiopSlYq60Jh0ON5y5o1qA6xfKKNn90kh4VLScvRMmf58IkqDQmBPBV6FugZh87yfPI1VnSKRcFM3iI6ldXeRWyDPZev6e7LkS++9AYhy5ESwFMnmrtJY6+TOqVuuWJWNytQ/feNEqnd3PQwbXClT/H7b6lDx+zpSolCg8PFxNxtzd3dUUl6CgIOnevbvJPATXCxculMDAF5+L58+fy7FjxyRjxozy3XffyfDhwyU6OqZzet68eWX58uVSvHjx1yewRjCHOtYUuzIlXvyQahrVLiXvdKxrsd7ooR3li3GLZMovL1p3XVx0UrJoTBL/8+eRsmHxF4ZKIhp0+ENrbofek+XqdftdVm5c1zSoRwCfmNbq6XPWWXREHDVxsawpV1DlWe9c9ZXqvBiQKa1aduDoRVmycpfK7f5+bC+VIoOOk0dOXE7yPpHjyeqZRlrkMu0g1S1/Ljl8/5F8c+ys3A9/bjVwzuaZJs772ryEBtZxcXd1kRLpTL93xp0XEUg3ypZZpaAgzQNpKOi8qG33oosv0qx6Fsgt6T3c5dSjEFl59VaSt4uSn5b2oKmdP6N0LGvZIRwpGWiRnbHLtvSkpFQBQcdETWS0XjYNqCbe7qYhRb9qeWXbhXsycOlRlbphD9N2XJSGhTOpE45f2pdWrfhZfF/0QUB6zLy919T/R79RRHXsXHUiSP45yxS/lFoVZMyYMTJy5EiTeQiA48qfRkBdvXp1KVasmHh7e8vZs2dl0qRJahTvunXrqmDax8dHHjx4oMo6I+141KhR8s0330jnzp0lIiJCfvrpJxk9erQ0a9ZMTp8+LR4eLz5jKT6wrlq1qhw5ciS5N8OhZUpv2pkTaQ3WIMgcO+xtCQl7KrMXblL5zalTpzJZbh5Ua9DhD50jKzT8VJ7aoRWs59v1TKqXoPzf9Nlr4/277AHppFXTSob7oWFPZcb8jRbr/bvvjNRrPUI+HdRSKpcrIBnS+qjccrTII90FgfiH/d9UrdkXr9xWudU40Wj3VlVpUreMZEzvK3fvh8iaTYdk0bIdbMl+DZVK7y/jyhWT/rsOS3h0tBx+8Eii9XpDOkjp9P7SIGsm2Xb7nmTycJeu+XNZPIaX0fcnsfBsg4vmM2kxP/4wWA7ej6nsgOB50J6jJuX2Qp9HqOB77vkrqhW+iL+PNM6eRSKio+XbE+cFn9jiaX2lbtZMkiWNh2rZPPEoWP6+FiSP2ZkxxUj/X0k9DapfWIOUjM8bFJKw8ChZdPD6K98u41Z1cyip93O70tJ2zl67PDfSSt6asVuG1MonlfKkU9sSFPJMNv9Xbg9pMs2LZVEVVFDyb+SaU+rv6hfMKI0LZ5Esvu4S8ixSdl66L38cvKG+G+S4OdZDhw6VIUOGmMyLr7UagbexUqVKybx589T/EVz/8ssv6jG11mkE1wMGDJAPPvjA8DcItJEa8scff8iSJUvk7bfffj0C6wkTJkiVKlXk+++/VztNllK7Wb6FaJH9eNSvqhX6k/fekvd6NjEsG/lxO5VHjUDaHNIxugz4TrbvPiUliuRU1UK0QD1fngDp0bGOTJsVfwAclwHvNJZxw2I+oKjE0a7XRJV2Ep/+PRqbnAzM/X2LPDLLJdfsO3xBWnUfb3VZnlyZZOh/+d2oAoK62ktnfSSN6piWpmrdrLK0e7OqtOz+jcpRp5ThztNwWXTxmmqVRovyw+fPVWUPdE5smye7IXjO4e0pzXIGyJLLN9R6627cVsEpYJ0PihdQU2wQxCZFKp1OPixeQJXN01x//FRGHbbsbImyeQiYrUHHtUFF8qltxn5fDnsiHfJml275TctKVcqUTt7IESAf7Dkq9/5rqSfHltpKsuqq47dk1LozEhEVLQNq5FV5xJqP6uSXxYduqJzrl7tdltU7kPrRf/EROXU7VKWwfNe6pCoTCBVypVWB7YYz9mk5vnj/iQxYGtPZ3ZivRypDpZKvN5xRda2/blrEoqW/UeHM0q50dmk/Z6+EMU3EYbknIO0joXr37q0C6507d6rAGiX5NKg+Zw7zEFjv37/fpsDaEcoNxgrN8uilOWjQIFWoG7UFe/ToYTG988478T4WcnRQVsV4SkwZFUcTGmraCxwB4HufzVS5xyhXN/Sr39QgLxq0xpYokstqTvOcRZtVPvWTp+Gy+8A5mfyTaW577WrFkrStYz9/W8YP72KoQvIwOEyadx6rWpjj4+OdRrp3qGO4j7zo7xLZ2fD7MT1Vp09UP0GHznc71zcE1eO+WyZZir0jY6cuU/cb1CopvbvUT9TzUPL49cJVlWOMAVTuPAtX5bVQ5xnzkFZhrELGFylCMO3kBVl/w3qHqsjoaHlkFow+MsuLtgXyob8uV9QkqEYJvo/2HjWpGJIQSA3J7eMl18KeyIIL1ySPt6d0yfeihf3AvYfSZtNu+eLgCRVsofW6b2HT9DFyXGHhpr9RKBn32d8n5U5YuDx8GiFfrz8r9x7H5J+i9bZwFp9Xvl3w085LcvD6I3kaEaUGa/njkGnLOepsvwr/a1BQpansuvRAfj90Q+WCa0H1ksM3pMS4f+R/q16kHqJj4/u1Yipqkf1arF3sNNlThgwZ1O3jxy8a5DAITLZs2Qzl+cxp89CZ0RYO3WKNHp2a8+fPq8ka9OhEqRRb83QwAo9I0ms0J6cLV0wDgTv3g01acRFoIw3COM0jrb+3PH4SriqIZMkU82E6e9E06EDdaWMoz5cYaB2fMamvqh+tuXr9rrzZdZycPncjQY+BgWQwgIsGnTGv3rA957tT6xpSp1pxdbLx6Zfz1bwW/5XuQ7nBMVOXqVsE2IN7N1WD2bzZqIJMn73O5ucix3Po/iN5K1dWk06Imgi9XiYePyfLrtyUKpnSS4Dnf3mbj5/I5lt3ZXTZouL/3/oIcM6b1cFOqAzubuqx8vh4mWzXqMOnbK6NjQ6UHfLmUGks3548r/ahWuYMhlb53y9dV50mUZ7v5MMQKZ7OTypkTKcGw8G65NgwoqKx+4+fqzQGDU6Wrj18Khm8Ylr07F2r2hqU9cPJJsrYaVC72hhK6BnzjyNdxF7QUt6mVDZ5FhElQ/8LnpsUjimjOWXrBfX6/XbguvSrnley+aVRLdej18ffuEOS4lts9+zZYzFITJ06dVQr9smTJ9V4KcYwz3z9FB9YX7p06aXm6YwfP172XEzZJan+3Wt62djf10udaBhX8UAgbezufy3Y/+47LS3fqBRr4IzBXEz/LsTm7UMw/PvPQ0wqeaAzJNI0ENgnBDoY9u/RyGTetz/bXikGw6mj1Rw+HjlPHjx6ERgFZH5xcoEWfgTVgGoqWB6QOa2aKGVAWkRcl8HRYmvMWiCLlmNMxor6+0oOr5gTuyMPHiVqaHMMNPNVmaKSMU1MIIRWcqR5JOby/aCi+VR+7eprQXL84YvvZ3qPmJMF45KB9/7rWe/m4iI+bqlVegk5tn1XH1mkOeCUyfiTYj4wDILvlw2t0iduhaqhyDX+aUzzri2268nL3S43V51K+cBJJcoMaiX+MhnV0Ea6igZ52QisjZdTynf69GnJmTOneHp6Wsz/5JNP1P87duxomN+nTx8VWI8dO1aN8K21UqOqyJQpU9QVdpTie20C61y5LDsM2TNP53WoiY3BUfYfPm8YICaNh5t0blPTUI+6VtWiJiMnIpf5+OkXvabn/bHVJLBu36Ka6kSI1mxUzejSrpbJc23acczk/rrfh6lBZzQFq7xnUjkEnQ2Xz/vUZFhzlAPs0v87lW6SUK3eqCQ5s8dcMt/67wk5dMz2k65xX7wtGdL5qHSX31f8a5gfHPLiAIyyhejEiM6KuNXKGMaWx02OBwEwRh1cevmmqkVtHKzm9/WWjoGmeZZaMKoFvQjMzYPqYml95ROzXGu0BJtb17Ca4f9BT59J1237TZaXSOsnw0sXVgPAaOadvyK/XXjxfbQVammXTOcv95+Fy4yzMd+HMKMKJ+joqA137vdfeT60bhuX8yPHdfZumCofpw0Q45HaVQ0Dvvjwiyt9VfKkk7zpYxpAUCHj9G3rI9baalHX8lIp94syj1Dt261yPTgmMMU2GAfWbUtnk9Ung1SFEC83V3mruOnYBBhu/WXqXz1QAjN4y6mgUPn535gqT8Yt/Ok83VQajfZ/QAdHsi9dMtaxXrRokaoAUqNGDRVDIt0DVUFWr16tqn2gkRXLNOjHh0ZX/A1Sj1EFBOutWLFC7ty5I19//bVKRbZFyo8sST4cMU82LhluGCb8h296Sbf2tVTnxcrlCpqsO3ryEkNrNgLMNf8cUiMZQpEC2eXYtsly5PhlKZQvm+TOGTMgxqWrt1VnQVssmfWRSVAdEREpUZHRMmNyX4t179wLkfc/n2X1cQa+a1pizzz3OyGQH96pVQ0Je/xMBn5mmja0acdxNcw68q7fbv3ipAS3OEnRRrKklAMDrWB6Ghmlhi1HVQ10Xszr42UyCAyCyz8vx6QilUznp8rZoZX31pNn8iwqSqWDGLdUA1JFjMvhJQQC3K/KFVWtxZqH4c8lj7eXfF7SdEhoOPIgWFZei71knp9baulV4MXlyemnL5pU+kBaSZs8L0ZKbZI9i5x8FKoGnCn2X0m/049CWQkhBRm19pT80b2CIe1iXPOi0q50NomI0kvZnKZ5od9ueVERRvNT21KGFlnzUnhFA3xl2TsxA2agmghykhMK63csm12KZHlRmapa3vSyeUA1OX/vsRTN4mvSEnzg2kPZfM40dQ/70L5MzIi+xuX71La3K61qz8Od0HDp/cfhWLclXwYv6VM1j0rR+nTlCRXca1D9442iLzoldyqXQyZvOS+Vc6dTw8ADRn8k+9Il43PXrl1bTp06JYcOHZLt27fLkydPVG41Bhrs16+fNGjQwOJvJk6cqGpVT5s2TaUg46p/6dKl5ccff5QWLWIGskuRgfW2bdvUbYUKFVTNQO1+QhifgTibPQfPSY9B0+TniX3Ew8NNXbowD6hRVmb8tBUW5em6DfxOlsz8SA00A6j3HFDHNPXhwuUgNYoi0iNsgbQUY6jo0bxReavrxjaUeLWKhaWsUa1utNDjhMAWHu6p5buvX3RwHTnhD4vcbIzc2LZ5FcmVI6P8NKG3jPi4raHuNbYrKSM70qulNwor0qRyNRnN0BjqV391+LTV6hgIwjGZQ+v3kkvXZZaNQ5mDu4uLSVANqEVdPcuLzjTmnkZFicTRkN23UB7xdUst/96+Lztum7YEHrj/SHbfeaCqgNTPllmV6EMrOQIzBCq/GLVuk+PDMNyD/zwmE94qJu6pXNXJYbmcpsdoXIWYvuOiyh02D55jGyYcFTtKZ48JzDGYiy0QvPZYcFDmvl1WCmZ60WEyR1pPNRnDcOq9f7c8ZqN0oPHzm8O2a4yHb7cGw5a7p3KRWbuvqCHSjaHDIgJ41AQfVDNQnQxordWorY1h3+n1UbNmzf/6z9mmW7duarIHhwqsMcoizhRwtoGmd+1+QqAOoTNbvHKXGlFwUM83pE71YpI9a3oVYKM6yM69p+XneRtk/xHL4W1DQp9Kw3ZfSoeW1aRDi2qqYkhaPy8JffxMTp29LivW7JWZCzbZlLphTxigxlhigtzP3m+lRqNEyoy1coHIra751jD54sO20rhOaZUugtcNdaxHTfjDkItNju/YwxBVTg7VPgr5+6rOfQhAdf+lSFwJe6JSRNbeuG2RX43yfMuv3FTpJBk83FQwikAUucloQV51LUj9fXIrm95fagdkkscRkfL9KetDVn95+JQqLYg61pnTuKt88BP3HqmKKedC+HlOaVaeCJJDN4KlZ+VcUj1vehWUIsC+HRou+64+lF/3XbMIKF8FjPbY9Kdd0rFcDmlSJLMUyOitWsaRfnEyKERt959Hbpq0INsbAuXyOdOq4HvCpnMWy59H6aXD3H2q+kfjwpkls4+7Cqj/vXRfJm4+L1ceJv93+nWjc4AhzZOTTp+YsapfEoykg0D6vffek3Tp0hnuJ4R5QfCEQJWQsTMta8YSvY4+faeQ/FvJclROotdRld3/yGyJ6UNC9Dq7PLyhOIqD9+x3lbdMBtPGtZTAoVqszYeojGvISiIiIiIiR+JQgTURERERpVw6ncMkQiQLBtZEREREZBc6cW6OOkCOwcaNG1WZlIwZM0rq1KnF1dXVYnod6lETERERUcrm0BHp0qVLpV27dqpUHAp9FypUiEE0ERERkYPSOXmTtUNHqaNGjZI0adKoEXAwnjsREREROS6dODeHTgU5c+aMtG/fnkE1ERERETk8h26xTp8+vXh6mo7iRERERESOycXJm6wdOrBu3bq16rwYGRnJ3GoiIiIiB6cT5+bQqSBff/21+Pv7qw6MV69eTe7NISIiIqJ4Oi/q7DSlRA7dDFy8eHGJiIiQ3bt3y/Lly1WQ7efnZ7Eehj2/cOFCsmwjEREREZHDB9Yos4cUkJw5cxrm6fWWI/pYm0dEREREr5ZOnJtDB9aXL19O7k0gIiIiogTSiXNz6BxrIiIiIqKUwqFbrImIiIgo5XBx8ibrFBFY79q1S5Xdu3nzpoSHh1vtvDhz5sxk2TYiIiIiesHJ42rHDqxRv7pDhw7y559/qg6KCKCNOypq9xlYExEREVFyc+gc64kTJ8rSpUule/fusn//fhVEv//++6oFe9y4car8Xps2bVhqj4iIiMgB6HR6u00pkUO3WP/2229SrFgxmTFjhmEegumKFSuqqUmTJlKhQgWpU6eO9O7dO1m3lYiIiMjZ6cS5OXSL9fnz56VWrVqG+0j5wIAxmqJFi0qzZs3khx9+SKYtJCIiIiJKAYG1m5ubeHp6Gu57e3vLnTt3TNbJlSuXnDt3Lhm2joiIiIiM6TikuePKkSOHXLt2zXC/UKFCsm3bNkOHRcBw5+nSpUvGrSQiIiIih2+xdfb9r1mzpiGQhnbt2smZM2ekadOmMm3aNFUxZMeOHdKoUaPk3lQiIiIicnIO3WLdo0cPiYqKkhs3bkj27Nnlvffeky1btsiqVatkzZo1ah10Xhw7dmxybyoRERGR09Ol0BQOpwisy5QpY9IxMXXq1PLXX3+p0nsosYf8agTWLi4O3fBORERE5BR04twcOrCOTbly5dREREREROQoUmRgTURERESOR+fkTdYOH1ifPHlSvv/+e9m3b588evRI5VybQ4UQjr5IRERElLx04twcOrDeunWrqvgRHh4uqVKlksyZM6tbc1rVECIiIiKi5OLQgfWnn34qkZGRakjzrl27iqura3JvEhERERHFwsXJm6wdOrA+cuSItG/fXpXdIyIiIiLHphPn5tB16ry8vCRTpkzJvRlERERERCm7xbpJkyayffv25N4MIiIiIkoAnc65+705dIv1+PHjVSWQgQMHypMnT5J7c4iIiIgonlQQnZ2mlMihW6yRX+3t7S3Tpk2TOXPmSIECBcTX19dqub1//vknWbaRiIiIiMjhA+stW7YY/h8WFiYHDx60uh4CayIiIiJKXjonD8kcOrCOjo5O7k0gIiIiogTSiXNz6BxrIiIiIqKUwqFbrEeNGpWg9ZAKMmzYsJe+PURERETkuC22uXPnlitXrlhdVrNmTZM0Y3MPHz6UYsWKyc2bN6Vhw4aydu3a1yuwHjFiRLwBNYYzZ2BNRERElPx0DpAL4ufnJ++//77VoDsuAwYMkODg4CQ9t0MH1ps3b7Y6HzuNjoxTp06VevXqSf/+/V/5thERERGR4/H394+3cdbc0qVLZcGCBfL999+rAPu1DKzRZB+b5s2bS6dOnaRMmTLSqlWrV7pdRERERGSNTlKau3fvSt++faVz587yxhtvvL6BdXzy588vLVq0kLFjx0q7du2Se3OIiIiInJrOAQLr8PBwNf4JcqUx/kn58uWlYsWKsa7fp08fcXV1lSlTprzeqSAJkSlTJjlz5kxybwYRERER2TlAxmTM3d1dTXEJCgqS7t27m8xDcL1w4UIJDAw0mT9//nz5888/Zfny5ZI2bdokB9bJ3XkzSfBio8cmcmmIiIiIKHnpdC52m8aMGaM6IhpPmBcXBNQYjfv27dvy+PFjOXTokErx2Ldvn9StW1dCQ0MN66JFe+DAgdKhQwd588037bL/Dt1iPW/ePKvzIyMj5caNG7Jo0SI5ffq0elGIiIiIKLnp7PZIQ4cOlSFDhpjMi6+1evjw4Sb3S5UqZYgnf/31V/nll18Mj9mzZ09JnTq1KoZhLw4dWHfr1s3qcOUosQdYhrMM5FgTERER0evDPQFpHwnVu3dvFVjv3LlTBdZz586VNWvWyOLFiyVDhgziFIH17Nmzrc53cXFReTBly5aVgICAV75dREREROSYnRet0YJnpIcAUkSgTZs2Vtdft26dasAtWbKkHD58WF6LwLpr167JvQlERERElGA6cUR79uwxGSSmcuXKEhYWZrEe5v3++++SPXt2Nfpizpw5bXoehw6siYiIiIgSAv3uEAh7enpazP/kk0/U/zt27KhuUabZWqnmy5cvq8C6aNGiMmPGDLEVA2siIiIisgudLvkKzqGoxaRJk6RGjRqSK1cu8fLykrNnz8rq1aslIiJCdYbEspeJgTURERERpfhUkNq1a8upU6dU/vT27dvlyZMnKre6SZMm0q9fP2nQoMFL3wYG1kRERESU4tWsWVNNSYEcbK36XGIwsCYiIiKi17oqyKvCwJqIiIiI7ELn5IF1ih7SnIiIiIjIUbDFmoiIiIjsxEWcGQNrIiIiIrILnY6pIERERERElERssSYiIiIiO9GJM2NgTURERER2oXPywJqpIEREREREdsAWayIiIiKyExdxZgysiYiIiMgudEwFISIiIiKipGKLNRERERHZhc7J61gzsCYiIiIiO9GJM2MqCBERERGRHbDFmoiIiIjsQufkbbYMrImIiIjITnTizJz7tIKIiIiIyE7YYk1EREREdqFjVRAiIiIiInvQiTNjKggRERERkR2wxZqIiIiI7ELn5G22DKyJiIiIyE504syc+7SCiIiIiMhO2GJNRERERHahc/IWawbWRERERGQXOicvt8dUECIiIiIiO2CLNRERERHZiYs4MwbWRERERGQXOifPsXbu0woiIiIiIjthizURERER2YlOnBkDayIiIiKyCx2rghARERERUVKxxZqIiIiI7MRFnBkDayIiIiKyC52T51g792kFEREREZGd6PR6vd5eD0YUn/DwcBkzZowMHTpU3N3dk3tziF4qft7JmfDzTsTAml6xkJAQ8fPzk+DgYPH19U3uzSF6qfh5J2fCzzsRU0GIiIiIiOyCgTURERERkR0wsCYiIiIisgMG1vRKoUPL8OHD2bGFnAI/7+RM+HknYudFIiIiIiK7YIs1EREREZEdMLAmIiIiIrIDBtYp1OXLl0Wn00m3bt3EEeTOnVtNjgSvDV4jvFb08m3ZskW93iNGjOB2JNPnNyIiQu13/vz5VZ4r/n758uXyqmEb8Nx4L8h+XpfPdlLwuE6OjoE1pVhz5sxRB1jcEpHIxIkTZeTIkZI1a1b58MMPVUeyQoUKvfYn9s7OERs2EovHdUrpUiX3BtDr4Z9//hFHg6F1P/30U8mWLVtybwrRK7Fq1Srx9vaWDRs2iJubW3JvDpHd8bhOjo6BNdlFYGCgOJqAgAA1ETmLmzdvSvr06RlU02uLx3VydEwFcXBRUVEybtw4yZcvn3h4eKhbnLFHR0dbXf/48ePStm1byZQpk8qxzJMnj7z//vty//79WC8fBgcHS9++fdXBysvLS2rUqCEHDx40/FC//fbb6vHSpEkjDRo0kHPnzsX6WLHlWS5YsEBKlSqlHgPPM2jQIHn69KnJ+s+fP5fvvvtOGjZsKDly5FDbj+dt2bKlHDp0yGRdXILu3r27+j9u8TzaFFcunnGO4v79+6V+/fri4+Mjfn5+0qJFi1jz9v78808pV66c2v7MmTNLr1695OHDh6/VJVh72rFjh9SqVUu9tv7+/tKqVSs5f/68yTqbN2+WHj16SMGCBVUrKya8xj///HOsj3vx4kV599131eda+3zgeRJy2Rif85o1a4qLi4v6nCWErduIzxa25/bt29K1a1fJkCGD+sxUqlQp1nzjEydOSNOmTQ2fwyZNmqjvsS2079qlS5fkypUrhu+C+Wdz9uzZUrFiRcO+4P/WXjvj78m///6rvvd4H7VL9Hj9Ye7cuSbfPWv7mJDvvjOz5bgXW0oO3nPj991aHva2bdukWbNm6jOJ50Ae/ueffy5PnjxJ8HsPPK4TxY0t1g4OQcSsWbPUD1n//v3l2bNnMmnSJHXAsxbM4OCFA1nr1q3VgWHXrl0yZcoUdYl49+7d6qBqDOviIITHbdeunQoI/vjjD6lXr556DjweDpgIrhEYrVy5Ut544w05deqUuLq6Jmgfvv/+e1m7dq28+eabUqdOHfX/qVOnyr179+S3334zrPfgwQN1ElC9enUVXKRNm1YFUn/99ZesWbNG/TCUL19erfvWW2/Jo0ePZMWKFepxcXC3xb59++Sbb76R2rVrS+/evdUBHp28jh07poIanMRo8Pq/88474uvrK126dFEH69WrV6vXDZ3FUqdObdNzv+7wOcPJX6NGjeS9995TgeOyZctk+/btalnevHnVejhhxGcKQSd+/PB+4rOB9+PMmTMqX9j8843PXmhoqPpctm/fXv0I4r3DZzyufN9bt26p7Tl9+rQsXLhQfdYTwtZtBKxTrVo19Tnp3Lmz3LlzR37//Xe1zQcOHJBixYoZ1sVnrWrVqhIWFqYCDQQ7e/fuVfNKliyZ4NccwTx8++236hbfI0BApBk4cKAKcHAJHZ9nWLp0qQpgtNfQHI4BX3/9tfqe4Fh09epV9V1DAIX1sY34LmrMg5GEfvedmS3HPXN4f5FHb/6+G38m4IcfflC/H1gfwTUCWwSgX331lTp5xGR+lcPae2+Mx3WiWGCAGHJMmzdvxuA9+pIlS+rDwsIM869fv67PkCGDWta1a1c1LyoqSh8YGKjmrV271uRxPvroIzW/R48eJvNz5cql5rdp00YfERFhmD9u3Dg139/fXz948GB9dHS0YVnfvn3VsqVLl1o8FiZjw4cPV+v6+fnpT58+bZj/5MkTfYECBfQuLi76GzduGOY/e/ZM7Zu548eP6729vfX16tUzmT979mz1+Li1Bq8Nll+6dMniNcW0aNEik/U7d+6s5i9cuNAw7+HDh+q5vby89GfPnjXMx+tVp04dtb75fjsr49f2xx9/NFmG+5jftGlTw7yLFy9aPAZe1/r16+tdXV31V65cMflsZMuWTX1m1qxZY/F3165ds9gOfP7gzJkz+ty5c+t9fHz0GzZssGmfbNlG0Pa/X79+6jupmTFjhprfu3dvk/Vr1qyp5s+fP99k/tChQw2PZfz5jY+17yFs3bpVPVbhwoX1jx49Msx/8OCB+i5i2bZt26y+l7NmzbJ4PGyT8fHHnK3ffWdmy3HP/LMd3/sOJ06c0KdKlUr9jty7d89k2ZgxY9TjTZgwIcHvPY/rRHFjKogDmzdvnrr94osvVIqGBi1OaDEytnPnTrlw4YI0btxYtYwZw9+nS5dOXbZDC7W5CRMmSKpUMRcvOnTooG4jIyNl9OjRJpfhtGVHjhxJ8H5gW3EpXYPLbngcpLOgBU+DS4TWOqQULVpUtUCgZQMtCfaAdBfzVktc8tdaPTRoOUFrIlo20JqoweuF14YsFShQQF1SNYb7eP3+/vtvuXv3rpqnpRMYw+vap08flQKFVjTj9+HGjRvqyglans1lz57d6rbgvUTr8ePHj9Xj4UqMLWzZRg2+q2jpRsqJBmkh+DvjzxZaALdu3SolSpSQTp06mTzGZ599ZtLanFRI2QBcKkfLnAath2jxBGspIWXKlDFcmk+MhH73ndnLPu799NNP6liOqxXIvzf28ccfS8aMGdVVHFvfex7XiaxjKogD04JXXEIzZz5Py1Uzvvyn0fJC169fry5fFy9e3OSHNWfOnCbrax1DcMDx9PS0ugy51wlVtmzZWAMhXPYzdvjwYXUpD5f9g4KCLA64uMxoj44rCd0m7T1AcGYO+anGJyT0AtIYjINKwH3MR34+XlMEuEjpwEkdLtXipBDBrzHjzxjSIwD5ngmF1BOkaiBwWLdunckPqAbBpHn+JS5Ha5egbdlG4xMLfOeM4XOCHM6Efrbw99gG45xl/K12yd9YQmoax3V8QHCjfffMxZaC8DK++87sZR73kH4F+A5Yq96ElAekSNn63vO4TmQdPz0ODJ2tEJCY50UDfqSNhYSEWJ2v0Q5a2noa5JeZ0w4qcS2zpYUhrsdBq59xTh9y9bQACoEQAgxtkAscDMPDwxP8vPbYJu31Qk6iudjeG2cX22dQm4/PNa6cIMhDJ9nSpUurXGS0puE9QKCLFlbj9xp/A7aU2EIwiVYpfJa0vG5rgTVajY0hTxhBra3bGNdnC/B3xp8tbZ+sfbasvY4IDFCjOjGBNT7H+LziJMPa8+A7Zn5ssLYNL+t75sxe9nEPOc6AfGpbxPfe87hOZB0DaweGS7a4rIazefMfRHQytHZAMZ+vQSuB8XqOCAd+HGDR0mjekoBWF1vST+xFe73QAc2c9t6wnqqp2D6D2nx8rnEpFgErLsXOmDHDZL1FixYZUhc0WloE0kESasCAAapFeebMmdKxY0fVocq8JSqukQFt3UZbaSkZ1j5b1l5HBPwv0rgT9znG5xVpOObBBJ4fj2vt2GCcBkYp87inva8IJlEpI6Hs9d7zuE7OhjnWDkyrCoADkjnzeWhRiy1QwOVr9ABHDpxxTpyjwaV25IKbH3xRDkor/2dMq0ryMlu+tPcAOezmkJ6A3EUyhdfKvBwk7qPlCj/WeE3xXgN6/puz9nmvUKGCukU6U0Kh5emXX35R+d2odIM8ZlveL1u3MbGfLVweN4eWdmupGYkV1/FBm2dLBYZX8d1zFrYe92J7P2J7L5DaYJwS8qrxuE7OhoG1A8OlZxg1apRJbida7cxLYyF/FYO0oHzRxo0bTZahMwbqWKNjiSMPHJErVy5VPg3l2TQ4uGJoZq3DmzEcrOHatWsvbZsQVOGyJVo9tUALcOAdNmzYS3velOzs2bMqoDWG+5iPcnm4+oL32lpQibQM87+F5s2bq1zJ+fPnq1xRc7G1ZCOQR+ctlN5CcI3vQEJ/NG3dRluhbwM6Wx09etSi9BzKnNkzBxmdJwGpJMYpH0hH0dJLtHUSAn0z8Nq+zO+es7D1uGcNjoVoZUXZVHP9+vVTV2pQ+tK8ZB7gcxZfveyk4HGdnA1TQRwYOhWhVzYGdUCHQ9TRxSU11MRFXV3UpjZunUO+KCqCoFZomzZt1AENdazRIoWge+zYseLIcOBHiyRaNjDIDWqOYtsRNCHX1by1rXLlyqoVHh26cODW0mUw6IG9IAUBdcNRxxUdY1A7Wat3it7uWbNmteio5+zwGUTNZLxG6PmPH1TUP0feonZCiFq6SG1AhybUl0VtZ3SsxWcan/MlS5aYPCZeawTGqAiCyje4RasTgkS07KL1K7bgAAEg6vjifcIt0h6QyhFfByVbtzExpk2bpk6KUUcX+aZaHWtUMEAHZXu0jAMCeHy/UBkC+4EBe/A6oI719evX1fuFdRIKQQk6t6GiAxoAsN14ffF/7YSEXs5xzxrkMOOqJL4b+NygAQXvJya839OnT1eDgOGKJX4f8HuAjrmoJ40TRdSA//HHHx1i/3hcp5SOnxwHh5YxDLaB4AAF+dEiPWTIEKvVAXDgwuU+nI3jQIZqBhiJDWWRMN9axyVHgtHnEKygoxlaJlEesFChQirQsPZjjZYNrI8qDHid0NLwMlobkEqwePFitV04ecGEExu8xgjsHDlvPTngtUH1AbSGYsAI/HCi0gZO8rROhAjMNm3apAI8BJH4bCMfGi23GMjCGvzg4tIxymdhwAdU/MD7jyAC34m44PuDIBaPjWASJbni64CbmG20FYIeXI7GiQIG2MBzYH8wL7YOl4mF9wKDYmTJkkWNHInvDDo1Y561wWHi8+uvv6pADica6ECJ7x6ON/Ryj3vW4LXHcQonfrjagfv47GqwDN8/fA/xW4DfDzwnWrkHDx5sMrBMcu8fj+uU0ulQzDq5N4IoJcKIfGipQysMriIQEVHKxuM6JRVbrInigcuR5uWgnj59qlp6wHhIZyIicnw8rtPLwhxronggBxEl11CDFR3OcPkUl1lRyxi5jeYjfRERkWPjcZ1eFqaCEMUDowUixw/l4rRe7Pny5VMHXvRsR2ccIiJKOXhcp5eFgTURERERkR0wx5qIiIiIyA4YWBMRERER2QED6xQOhf1RoxcdLl5X2D8MJEBE5CxwTMexD8d4R4DBkjARUdwYWKcAGGADB1gMwkDJD+8D3o+EjIhGREREzoPl9oiIiChOGE2ViOLHwJqIiIjiFBgYmNybQJQiMBUkBaQd1K5dW/1/5MiRKgVBm4zzqlE1cerUqVKoUCFxd3eXXLlyqfWjo6NNHm/OnDnqb3G7cuVKqVq1qvj4+JjkzqFQ/vvvvy958uRRj5UpUyY1vOvx48cttg+5z3g8W/K/nzx5Ih9//LHkyJFD1QotVqyY/PLLL/GmvNy+fVu6du0qGTJkkDRp0kilSpViTce4cuWKKv6fLVs2cXNzk+zZs6v7V69etSl30Hz/cB+vK+B90d4L5h4SUWJERUXJuHHjVA1lHA9xO2bMGItjtwbHYRyPcVzG8RnHaRyv79+/H+uxLTg4WPr27SsBAQHi5eUlNWrUkIMHD6p1bt68KW+//bZ6PBxXMWAKajzH9lixpcUtWLBASpUqpR4DzzNo0CA1kqGx58+fy3fffScNGzZUx3/t96Vly5Zy6NAhi+c0/r1av369VKlSRTw9PSV9+vTqt8DaPsORI0ekU6dO6riP58D2NGrUSP3mmVuxYoXUrVtX0qZNa/g9mjBhgnpfiBKDLdYODoEcAtO5c+dKzZo1TTrx+fv7G/7/0UcfqZGkmjZtqg5ay5cvVwc9HMi++uori8ddvHixOlBh/X79+klISIiaj0L5lStXlgsXLqjnat++vVy6dEmWLFkif//9t6xbt06qVauW6P3BwQrPuXnzZilevLh07NhRHjx4IB988EGcHRQfPXqkntfPz086d+4sd+7ckd9//13t64EDB9TBUHP27Fm1LvalWbNmUrRoUfVjNGvWLHVg3bFjhxQoUCBR2691JMJrjQO79kNj/F4QESXUu+++q45NCJD79+8vz549k0mTJqmBS8zh2IVjHo7rrVu3VsefXbt2yZQpU2TVqlWye/du1fBgDOvWr19fPS4GP0EDxR9//CH16tVTz4HHQ+CJ4Pr8+fPqGPnGG2/IqVOnxNXVNUH78P3338vatWvlzTffVKMW4v9o6EEjzW+//WZYD8d6nARUr15dmjRpooLZixcvyl9//SVr1qyRbdu2Sfny5S0eH8vx+4PjOYJrrDdv3jz1O4XXxNjSpUvV7woam7B+wYIF1e/Fnj17ZObMmWqeZujQoTJ27FjVAIPgHr8v27dvV7+nWB+/k0Q2wwAx5Ng2b96MQXz0w4cPt1jWtWtXtSxPnjz6mzdvGubfvXtX7+/vr/fx8dGHh4cb5s+ePVut7+Liot+wYYPF43Xv3l0tHzp0qMn8v//+W83Ply+fPioqyjC/Zs2aar412rZdunTJMG/GjBlqXuPGjfWRkZGG+SdOnNB7eHhY3U/Mw9SvXz+T59Yeq3fv3ibr165dW83/6aefTOZPmzZNza9Tp47J/Fy5cqnJGmv7h+3DPLwvRERJPbaXLFlSHxYWZph//fp1fYYMGdQyHEcBx77AwEA1b+3atSaP89FHH6n5PXr0MJmP4xrmt2nTRh8REWGYP27cODUfvxGDBw/WR0dHG5b17dtXLVu6dGm8x0ntWOjn56c/ffq0Yf6TJ0/0BQoUUL8zN27cMMx/9uyZ2jdzx48f13t7e+vr1atnMl/7vUqVKpV+x44dhvn47ahVq5ZatmvXLsP8oKAgvZeXl5oOHjxo8TzXrl0z/H/9+vXq7xs2bGjy2uO16NOnj1q2ZMkSi8cgig9TQV4TGJoVrQ4atFqg9SA0NFTOnDljsT6WocXCvGVj4cKF6jLb559/brIMrQto9UCLxs6dOxO9nfPnz1e3aEU3bg0pUqSIdOnSJda/w+VLXC51cYn5yKLFOFWqVLJv3z7DPKR6oDUcj9erVy+Tx+jTp49Kldm0aZNcu3Yt0ftARGQPaHWFL774Qh3jNGhBRSqFMRx30ULbuHFj1cpsDH+fLl06lY6B47g5pDbgWKnp0KGDuo2MjJTRo0ebpLtpy5BOkVDYVrQMa5AOgsdBOguuKGqQloF9M4erikitQ0t0RESExXK0QCNtUYPfDhz/wfj4jyu7jx8/VldAS5cubfE4SA0xbmWHn3/+2eS1x2uBVmzc4veQyFZMBXlNlC1bNtaDCNIozFWoUMFi3unTp9XlQhzgkMdmDvM3bNgghw8fVpfyEgMHaxzErB30cODEQc4apG54e3ubzMMPRebMmU32D9sGSJsxz/1GUI7cQuwn1kOOHxFRctGCV2vHU/N5Wg6ytZQ5HBvLlSun0vvQkII0Ow3SLXLmzGmyvtYIkz9/fotjvbYMudcv4/cHx95vvvlGpXAEBQVZBNJIHzFuJLLl8ffu3atukSceH6TN4LcIaTjW4OQAvxVEtmJg/Zrw9fW1mKe1UFjrhIGA1JyWZ21tGWgHO229xMDfxhbQxva8se2fto/G+/cq9oGIyB7QqRAn/OZ50daOYYk9tsX12xDXMmstx0n9/UFON3KwteAXgT1OCtAIgn5BONEIDw9P9OPj9QRrreLmkO+NFnutM7o1aP0mshUDaydlrZKHdvBC5xZr0LpgvB5oqRk4QBlfajQ+yJk/BzoVWhPb89oisftg7fJpbPtARGQP6CyHdAm00mbMmNFkmfkxLDHHNkeDFEAEzuggaN4JHi3ItqSfWKN1Ir9x40a8lZrwOuF3EK89kT0xxzoF0HKRX3b5H+Qfo9wQctZQEs+cVtoOJZWMLzNqBzJj+LGwdpAsWbKkagXQUjaMWesFbytt25Cr96LfYwzcx3xr+4Be4zg5MIbttFZ26lW9H0T0esPxEBBomjOfp6XPWSsximPV/v37VfqCca6zo0GOOHLBzYNq/N5o5f+SQktxREpMfCpWrKjK9Vk7xhMlBQPrFAAHInjZHe5Q7xkdTnAGjzqqxlA+CaX2UGPVuBOJVhoJdUaNoVwUyvSZQ21RQOdI4zqtyGVDx5OkQi4hcsFPnDhhkTuH/G2UkMKlSON0FOwDLnsal4VCEI5STNYuBb6q94OIXm8oHQqjRo0yOdagoQIl9IzhuItBWlCWbuPGjSbL0AERQSKO3ziOOyqMr/Dw4UN1fNaggeLDDz+M9UqmLdChEaklEydOtNp4Y9wANHDgQHXbo0cPq/WwcQUAvxdEtmIqSAqAluSsWbPKokWLVK9qdNrAJaz33nvP7s+Fyhuo0YwDNVqQcVaPOtqo54lOLrNnzzapzNG9e3fVEQU1s3Egw4EfLSeoG40OhHgsY1j/119/VTVJ0QKDHu7IdcO+oeoIaqgaP35i/PDDD6pFBFVB8HioEIIDOWqh4nIrlhsbMGCA2q+ePXuqzplYB61F6BSDFiXzlndtYJjPPvtMPS4u5+ISJB6HiCihcCzBMRHHH3Q4bNGihUqVQI1+DICF2tQaHBfRgIGKIKjS1KZNGxWooo41WrFx7EU1C0eG3yy0JuP4jEFucIUU246AF50yYxvwK6Ew2AwqrWD8BbReN2/eXLXgo7EIdamRHoJcbsCAMaim9eWXX6oGI9zH64kgG9Wv8BuA38HChQvbae/JacRbkI8cwu7du1VNZdSl1uo6oz60tVrRcdVb1uqC4jY2qIE9cOBAVbM0derUqp5q69at9ceOHbO6/uHDh/V169bVe3p66n19ffVvvvmm/ty5c7FuG2qGfvDBB/qsWbPq3d3d9UWKFNH//PPPqmYo1p88ebLJ+piHfbcmthrUly9fVjW5AwICVA1U3OI+5luzadMmfcWKFdX2pE+fXt+5c2f97du3Y63TPWfOHH3x4sXV+lgeWx1sIqK4oCbzmDFj9Hnz5tW7ubmp26+//lp//vx5kzrWmqNHj6rjMY7LOD7j2DNo0CB13DYXV43+2I6rOF5be9646lhbq+kf228NjvNlypRRvxfYh7Zt2+ovXLhg9fcirt+ruMZ3OHTokHrczJkzq9cIx3+MnbBq1SqLdTGeQ7NmzfQZM2ZU62bJkkVfuXJl/Zdffqm/evWq1deOKC46/JPcwT2Rlh6Czi2rV69WLdlEREREKQkDa3rlbt26ZVGn9OTJk+rSJzoGon4qOuEQERERpSTMsaZXrm/fvipvGzlwqMiBnuLIhUYHwpkzZzKoJiIiohSJLdb0yqH6xo8//qh6XKNONHpxozIHhqE1H6qXiIiIKKVgYE1EREREZAesY01EREREZAcMrImIiIiI7ICBNRERERGRHTCwJiIiIiKyAwbWRERERER2wMCa6CXr1q2b6HQ6Vbtbs2XLFjVvxIgRL/W58Zx4HmxDSobXCfuB181ZPzNEROT4GFgTmXlVQa+95M6dW01EyQHflVq1asnrgCc0RJRUHHmR6DWWLVs2NRCPn59fcm8K2WDMmDHy6aefqvePiIhSDgbWRK+x1KlTS6FChZJ7M8hGAQEBaiIiopSFqSBERpD+Ubt2bfX/kSNHqsvC2qRdHj579qx8/PHHUqZMGUmfPr14eHhIgQIFVAtjWFhYkp4fQ7zXrFlTXFxc5LvvvktQ/vSVK1fUZLytWhpLbDnWuHSP+eHh4fLZZ59Jzpw5JU2aNFK2bFnZuHGjYVv69+8vWbNmVftYuXJl2bt3r9VtuXPnjgwePFjy5csn7u7ukiFDBmnVqpUcP37cpv2/du2adOjQQdKlS6eGusdrsW3bNov1sI3Y/n79+ll9nAsXLqjXsGHDhhb7HBERoV4fpM9gW/HeTZ8+3eIxbt68KcOHD5dKlSpJpkyZ1Lr4Gzwn9je2NIKLFy/KhAkT1OPiNS1SpIgsWrRIrfP8+XP53//+px4Hr2mJEiVkzZo1NqUk4PV46623JHPmzGqbcuTIIS1btpQdO3YY1nn27JlMnDhRSpYsqa5WeHl5qeds27atHDlyRBJi8+bN0rhxY/X+43nwfNWrV5eff/7ZJGUKtm7davL5mzNnjsljrVixQurWrStp06ZV+12sWDH1GkVFRZmsh7/T/n7lypVStWpV8fHxMUl1wms4adIk9f3DfmE5tuuvv/6yuh/37t2T999/X/LkyaP2A+8lXgfzzyaeY+7cuer/WFfbF3xu8F3AcxUtWtTqc0RHR6u/x/49ffrUol/AzJkzpXjx4mrfcRUC35XQ0FCrj3X06FFp3769OrFyc3OTXLlyyXvvvSf379+P9z0jouTHFmsiI/gRRTCDH1gEdca5o/7+/ur2zz//VD+UCMCxHD+qu3fvlnHjxqkAA4EPWoptdevWLWnUqJGcPn1aFi5cKO3atYtzfWwPAr9vv/1W3UfwYLwfCYHnOHbsmDRv3lwFBL/99ps0bdpUdu7cKe+++64KYtq0aSN3796V33//XW3fpUuXTFJLEMTi+a5fvy4NGjRQQR8Cz6VLl8q6devkn3/+kYoVKyZo/xG837hxQwXECJyQxlK/fn3DyY4GQVpgYKAsWLBABWienp4my2fMmCF6vV569epl8TwI3HGCgKDR1dVV/vjjD3UCgffMeH28jwhO8VzYfiw/dOiQ/PDDD2q/Dh48aDXFZsiQIbJnzx5p1qyZenwE1R07dlRBF06WTp48KW+88YYKfrH9b775ptpP7E98pkyZooIyBOwtWrRQJ0R4vRBUL1myRKpVq6bW69q1q9ovBO7du3dXASVOWhAs79u3TwXccfn777/V9uMzhu1DkIfPAILyX3/9VX02EEji84cTUAR/xidvpUqVMvx/6NChMnbsWBVQ4gQAr9n27dvlo48+Uq/T4sWLLZ4f89avX68+iziRCQkJUfNxIojPIIJVPMc777yjTpSwvdhOvL4DBgwwPA62GZ8p7TOKgBWfX7xW+Bu8j9prhu8PAnrs46BBgwzfd+wnthl/O2vWLPn333+lSpUqJtu7YcMGdXKLzxHeG2M4CcB3AN81vO84KcR3FscM82MFTg4Q9OOkEPuDkyZ8Xr7//nu1rXi98DkiIgemJyITmzdv1uOrMXz4cKvLr1+/rg8PD7eYP3LkSPV38+fPN5nftWtXNf/SpUuxPseZM2f0uXPn1vv4+Og3bNhg0/bmypVLTdbgOfE82AZjNWvWVPOrVaumDwsLM8z//fff1Xx/f399mzZt9BEREYZl48aNU8smTpxo8lhVqlTRu7q66teuXWsyH/uE/SlevHiC9kN7nUaPHm0y/6efflLzMeF1M9+eOXPmmKyPbQ4ICNBnypRJ//z5c4t9rlixoj44ONgw//Tp0/pUqVLpCxYsaPI4t2/f1oeGhlps59y5c61up7b9BQoU0N+5c8cwf8+ePYbXNLbX+7333ov3M3P48GG9i4uLPmvWrCbzITo6Wn/jxg31/0ePHul1Op2+bNmy+sjISJP1cP/hw4f6+LRs2VI9P57T3L1790zuYz28ttasX79eLW/YsKHJfmN7+/Tpo5YtWbLEMH/27NlqHvbT2vfgs88+U8uHDRumHkMTEhKiL1eunN7Nzc3wOkD37t3V+kOHDjV5nL///lvNz5cvnz4qKirO1938fezWrZvFstatW1u8XvhuYx626ciRIyb73rFjR7VswoQJJq+rr6+vPlu2bPrLly+bPP7ChQvV+gMGDLD6OhOR42BgTWRjYB2b+/fvW/3hjS+w3rt3rz5jxoxq2r9/v83bm5TAeuvWrSbzEWSkTp1aLbty5YrJsqtXr6r5Xbp0Mcw7ePCgmtejRw+rzz9kyBC1/NixY3HuA05UPDw8VDD89OlTi23Knz+/RWCN4BVBC4JVY8uXL1frfvTRR1b3edOmTRbPry1DgBYfBEYIgGrVqmX1fUbgbS5v3rxWX28Euni9a9SoEe9npm/fvmrerFmz4tw+nDRgvapVq5oEn7bQAmucHMUnrsC6efPmVj9LxicArVq1sgisW7RoYbE+Pgdp06bVBwYGWt2vv/76S/3td999Z/KZSp8+vf7x48cW69evX1+tv23btgQF1lC6dGm9l5eXyYmZ9jksX768ybpaYN2zZ0+Lx0HgjJPRYsWKGeZNmjRJrT9v3jyrz12mTBl9hgwZrC4jIsfBVBAiGyGWmD17trpsjDxN5F8iHcQ4NzehcEkc6QYZM2ZUl3rz589vsQ6exzzXFukWxpfbE8v8MXAJGjmoT548UWkGxrTOdMb7h8vZcPv2bavlCZHWot0irzY2Z86cUakRderUUXmo5tuEXNtz586ZzMdrhtQCpFrg8bVOmkgDgZ49e1p9LuSRm8uePbu6ffTokcrZ1SDt56efflJpHw8fPjTJCY7tfbb2vuC1Q+61+TKkiuD1TshnRstvR7pNXHx9faVJkyayevVqlU6DVB6kQZQvXz7BKUpIe8C+I78caSxIh0EeM3LnbYHPB3KTkUJhDdImtM+IsQoVKlj9jOA9QM430k/MIe3D/DOHzxTSiMxThQDzkcJx+PBhtW8J0bt3b+nTp49K4cEtzJs3T6VMWUs7AmuPjdQZpHmcOHFC/S1yqbXvEtI9kLpiDvuCfHFMtr4PRPTqMLAmstHAgQNVziN+GJGbjKAJOayAH3zkgSYUcnbR4RHBUt68ea2ug8AaudvGkPdpj8AaQZi5VKlSxTofkNOqefDggbpFviqm2Dx+/DjO7cDJCSDItAYd52ILdBBYI5hGrjUCVHQGRH48Og9aE9e+GQfOOOH58MMPVQCP9wfBt5Y/ixzZ2N7nuB4/tmXGr2lcrxE6wyWkWghylL/++msVAKKzpPbcyLfGfGuBpjEE48uXL1f5wT/++KNMmzZNPTeCUbwuCf3s4fMRGRlpNRCO67Nh7f3WPmsIRjHF93haXnZsnx3tddTWSwicZOAzgc+bFlijvwU62iJ335rYnh/zccKMTozoBK3tH17ruGD/GFgTOS4G1kQ2QKc8/PChU9iuXbtMApSgoKA4Awhr0NEKwSB+nPGjjc6DWhCmceTRBrVA0bzTmK20ToDWqm1oLeLWoCUWLdVoNUTAiCsJCI5jaz1MKASDX375pQq+0KJpHPDjisU333wjrxo60+G50ckzvvrW+FyOHj1aTeish06LCJDR+RGdVNEKHx90nsOEwA+dWbVOu1oHW61zX3yfDwTkaGW1hVZtxPyxANVm0PkwIc8d12cH31fj9RICVzM6deqkXj98LhDkouMpro4guLYmtufHfOyndoVE2w50Jo7r6g4ROTaW2yMyg8vzYF4KDHA5H8FNvXr1LFr9kNZhK6Q5/PLLLyoQRBUH/GgjqLN1e61t66ugVfvASUZSoHUZKSD79+9Xl7yNIc0GlRhigwoVSANACytSDlA1AcFXUiAQRAsxKkqYt6JjG7WSaq+Slh6Bahm2QOm4Hj16qKseCP5iK0sXGwR+CKZRZg+VPxAQIl3B+DMc2+cPnw+UiTNP40mMwoULq+ATr39CWvhxwoXPFKqgILXJnHbCatz6Htd33/gqCeB7q6UdxXUiZ+24gAoiqNKC8n1IA7Hnd4mIkhcDayIzqKEM+OGzlhsJCPSM86pRag5lxRIDrVZoAcMPNoJrXFK2JbjG9iIQNA9IX1Wwh4AA5QFRjs8cXiPzNBZrkEqDMmNosUaqgTEEL6gdHhuUlkMAhTJ0OPHp3LmzRZ62rRBMI+0DudXGQRlyfFFTODkg9QCB3+eff64CM2M42dPytHGSYa1+OLYd6SsJeW1QBs5acKldUTB+DHz+8PmPLW0KENhbq8OMVmO0+CYEruT07dtX7TvSMawF19hvbRsRsOK7hO8GRrI0tnbtWtWnAXXXkb9vvC+xffc1pUuXVvnquLqElBtcvbKWE67B1RTUpjZ+r1A7Hq+vcYlCpOngJAapO9ZSXfA51PKwichxMRWEyEpLFzpIIXcXAR9yaxH8IqBCagBaQ1GjuVy5cqpTF1rwVq1apf5vrdNRQuDxUR8ZrX+4xY8vnt88LcQadPhDKx7qMqOjFAKKGjVqqOlVQFCN3Ft0eEPuMTrMISi9evWqan1DoJeQoB+1jlHvF4Ej6jIjgEHQhU54yHGOraUWwRByglFfGZKaBgJ4H1A/WRtkBTWdkYuL/G2cXOHz8aphgBG8vghW0dKJDqzYFgSnCIRRIxnLUdcarx22G0Ef0kYQ1GKQFgSjCErjg+dAoI4az8jnx+cT7wk6UKJDo1b7Wfv84YQQ24PnRfCPvgd4brR0Dxs2TKXVIIjFfWwztuf8+fOqNRfpKmiNTgikWuFkZ+rUqSqnH59xnARhn5FCgRrU+MxpVxm02vJ4DpwM4yQQec0IiHHFCalDeK+N9wW5+rgKgu85Ol5ie3GyZn6SgxraCfm8oSY7rnzg+4F8fXzG8X3F62h8koZl+C7hs4z3Dq8VjkU4GcI2Yz9QPxsnBUTkwJK7LAmRI9q9e7cqIYY6zFoNZa0EF2obf/DBB6rutLu7uyoF9+WXX6qaydZKjyWkjrUGZcT69++vlqHkmXEd5thge3r16qVqN6OEl/Hjxlduz9byfbGVVnvw4IH+888/V+XD0qRJo/f29lavC+r1/vnnn/qEQlm2du3aqZrPnp6e+urVq6sSdVrpMuNye8Y2btyolleqVCnWx45rn629R3jtv/rqK7UfeJ9z5syp3ne83tZeo7hKtdn6esf1WHgNmjZtqk+XLp0q85Y9e3ZVsm7nzp1qOepUjxgxQpXww2cC66D2daNGjfRr1qzRJ8SiRYv0bdu2VaXt8D74+fnpS5YsqWqHm9f2vnXrlloXpeBQfxrbjbJ5xlCTulmzZqqkJMoLZsmSRV+5cmX1vUEZR/Nye+Z/b16iELXNUU4QZQ+19wb798MPP5jUy4a7d+/qBw4cqF5jPDe2E3WnYysB+c0336j3XCs7ae3zjvJ9eF581mOrC278mf3ll1/0RYsWVX+D92TQoEGxlnZEXfV33nlHbS/eO5QYRC147ANKcxKRY9Phn+QO7omIkgKtjBjJD53rkHZA9DKhxRnpIGjJRqqHNSg/iRZ2dBxN6EioRJTyMceaiFI0pJmg/CE6LeJyO9HLNn78eHWLnG8iImPMsSaiFAk5v8g7RSc0dGhDB7X46jMTJRb6DKAuODoWIqdcy50mIjLGwJqIUqSNGzeqS+0YLAMVQRLSKY8osVBxBpV/ULIQnVlRfpCIyBxzrImIiIiI7IA51kREREREdsDAmoiIiIjIDhhYExERERHZAQNrIiIiIiI7YGBNRERERGQHDKyJiIiIiOyAgTURERERkR0wsCYiIiIisgMG1kREREREknT/B5kRg99/qPAVAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 800x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import math\n",
+    "plot_data_dict = {}\n",
+    "for case, type_dict in win_rates.items():\n",
+    "    if case == 'all_agree': case = 'unanimous'\n",
+    "    elif case == 'disagree': case = 'divided'\n",
+    "    for convo_type, win_rate in type_dict.items():\n",
+    "        if convo_type == 'dominating_throughout': convo_type = 'dominating\\nthroughout'\n",
+    "        elif convo_type == 'back_and_forth': convo_type = 'back-and-forth'\n",
+    "        elif convo_type == 'alter_dominance': convo_type = 'alternating\\ndominance'\n",
+    "        if convo_type == 'no_label': continue\n",
+    "        if case not in plot_data_dict:\n",
+    "            plot_data_dict[case] = {}\n",
+    "        plot_data_dict[case][convo_type] = win_rate * 100\n",
+    "\n",
+    "df = pd.DataFrame(plot_data_dict).T.fillna(0)\n",
+    "plt.figure(figsize=(8, 5))\n",
+    "ax = sns.heatmap(df, annot=True, fmt=\".2f\", cmap=\"YlGnBu\", cbar=True, linewidths=.5, linecolor='grey', annot_kws={\"size\": 16, \"weight\": \"bold\"})\n",
+    "for text in ax.texts:\n",
+    "    value = float(text.get_text())\n",
+    "    text.set_text(f'{value}%')\n",
+    "plt.xlabel('talk-time dynamics stereotype')\n",
+    "plt.ylabel('court decision')\n",
+    "plt.xticks(rotation=0)\n",
+    "plt.tight_layout()\n",
+    "# plt.savefig('heatmap_convo2.png', dpi=300, bbox_inches='tight')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "balance",
+   "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.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/convokit/balance/balance_util.py b/convokit/balance/balance_util.py
new file mode 100644
index 00000000..1fccee2c
--- /dev/null
+++ b/convokit/balance/balance_util.py
@@ -0,0 +1,404 @@
+import re
+import random
+import numpy as np
+import matplotlib.pyplot as plt
+from collections import Counter
+from convokit import Corpus
+
+random.seed(42)
+
+
+def _tokenize(text):
+    text = text.lower()
+    text = re.findall("[a-z]+", text)
+    return text
+
+
+def _longer_than_xwords(corpus, utt_id, min_utt_words, x=None):
+    """
+    Returns True if the utterance has at least x words (defaulting to min_utt_words);
+    otherwise, returns False.
+    """
+    if x is None:
+        x = min_utt_words
+    utt = corpus.get_utterance(utt_id)
+    return len(_tokenize(utt.text)) >= x
+
+
+def _rhythm_count_utt_time(corpus, utt_lst, min_utt_words):
+    """
+    Calculates total speaking time for each speaker group from a list of utterance IDs.
+
+    Filters out utterances shorter than min_utt_words and returns the cumulative speaking
+    time (in seconds) for groupA and groupB.
+    """
+    valid_utt = [utt_id for utt_id in utt_lst if _longer_than_xwords(corpus, utt_id, min_utt_words)]
+    if len(valid_utt) == 0:
+        return 0, 0
+    time_A, time_B = 0, 0
+    for utt_id in valid_utt:
+        utt = corpus.get_utterance(utt_id)
+        if utt.meta["utt_group"] == "groupA":
+            time_A += utt.meta["stop"] - utt.meta["start"]
+        elif utt.meta["utt_group"] == "groupB":
+            time_B += utt.meta["stop"] - utt.meta["start"]
+    return time_A, time_B
+
+
+def _get_ps(corpus, convo, remove_first_last_utt, min_utt_words, primary_threshold):
+    """
+    Determines the primary speaker group in a conversation based on speaking time of each speaker group.
+
+    Returns 'groupA' or 'groupB' if one group exceeds the primary_threshold proportion of total speaking time;
+    otherwise, returns None.
+    """
+    assert primary_threshold > 0.5, "Primary Threshold should greater than 0.5"
+    if remove_first_last_utt:
+        utt_lst = convo.get_utterance_ids()[1:-1]
+    else:
+        utt_lst = convo.get_utterance_ids()
+    time_A, time_B = _rhythm_count_utt_time(corpus, utt_lst, min_utt_words)
+    total_speaking_time = time_A + time_B
+    if time_A > (total_speaking_time * primary_threshold):
+        return "groupA"
+    elif time_B > (total_speaking_time * primary_threshold):
+        return "groupB"
+    else:
+        return None
+
+
+def _sliding_window(
+    corpus, convo_id, window_size, sliding_size, remove_first_last_utt, min_utt_words
+):
+    """
+    Computes sliding window segments of a conversation and calculates total speaking time
+    for each speaker group (groupA and groupB) within each window.
+
+    Returns a list of dictionaries, each containing the speaking time per group for a window.
+    """
+    convo = corpus.get_conversation(convo_id)
+    if remove_first_last_utt:
+        utt_lst = convo.get_utterance_ids()[1:-1]
+    else:
+        utt_lst = convo.get_utterance_ids()
+    utt_lst = [utt_id for utt_id in utt_lst if _longer_than_xwords(corpus, utt_id, min_utt_words)]
+    all_windows = []
+    cur_start_time = corpus.get_utterance(utt_lst[0]).meta["start"]
+    cur_end_time = cur_start_time + (
+        window_size * 60
+    )  # window_size is in minutes, converted to seconds
+    prev_window_last_utt_id = utt_lst[0]
+    convo_end_time = corpus.get_utterance(utt_lst[-1]).meta["stop"]
+
+    while prev_window_last_utt_id != utt_lst[-1] and cur_end_time < convo_end_time:
+        cur_window_groupA_speaking_time = 0
+        cur_window_groupB_speaking_time = 0
+
+        for i, utt_id in enumerate(utt_lst):
+            utt = corpus.get_utterance(utt_id)
+            # case 1: utterances in previous windows and not in current window at all
+            if utt.meta["stop"] < cur_start_time:
+                continue
+
+            # case 2: last utt of the current window
+            if utt.meta["stop"] > cur_end_time:
+                # the entire utt not in the window, meaning previous utt is in the window and this one is not
+                if utt.meta["start"] > cur_end_time:
+                    prev_window_last_utt_id = utt_lst[i - 1]
+                # special case: the utt span longer than the entire window
+                elif utt.meta["start"] < cur_start_time:
+                    if utt.meta["utt_group"] == "groupA":
+                        cur_window_groupA_speaking_time += cur_end_time - cur_start_time
+                    elif utt.meta["utt_group"] == "groupB":
+                        cur_window_groupB_speaking_time += cur_end_time - cur_start_time
+                    prev_window_last_utt_id = utt_id
+                # part of the utt in the window
+                else:
+                    if utt.meta["utt_group"] == "groupA":
+                        cur_window_groupA_speaking_time += cur_end_time - utt.meta["start"]
+                    elif utt.meta["utt_group"] == "groupB":
+                        cur_window_groupB_speaking_time += cur_end_time - utt.meta["start"]
+                    prev_window_last_utt_id = utt_id
+                # put window data in all_windows only at the terminating point: last utt of the window
+                all_windows.append(
+                    {
+                        "groupA": cur_window_groupA_speaking_time,
+                        "groupB": cur_window_groupB_speaking_time,
+                    }
+                )
+                break
+
+            # case 3: utterances in the window but not the last utterance of the window
+            if utt.meta["stop"] > cur_start_time:
+                # part of the utt in window
+                if utt.meta["start"] < cur_start_time and utt.meta["stop"] > utt.meta["start"]:
+                    if utt.meta["utt_group"] == "groupA":
+                        cur_window_groupA_speaking_time += utt.meta["stop"] - cur_start_time
+                    elif utt.meta["utt_group"] == "groupB":
+                        cur_window_groupB_speaking_time += utt.meta["stop"] - cur_start_time
+                # entire utt in window
+                else:
+                    if utt.meta["utt_group"] == "groupA":
+                        cur_window_groupA_speaking_time += utt.meta["stop"] - utt.meta["start"]
+                    elif utt.meta["utt_group"] == "groupB":
+                        cur_window_groupB_speaking_time += utt.meta["stop"] - utt.meta["start"]
+
+        # update window start end time
+        cur_start_time += sliding_size
+        cur_end_time += sliding_size
+
+    return all_windows
+
+
+def _convo_balance_score(corpus, convo_id, remove_first_last_utt, min_utt_words):
+    """
+    Computes the overall balance score of a conversation based on speaking time.
+
+    Returns the proportion of speaking time for the more dominant group (groupA or groupB), or None if total speaking time is zero.
+    """
+    convo = corpus.get_conversation(convo_id)
+    if remove_first_last_utt:
+        utt_lst = convo.get_utterance_ids()[1:-1]
+    else:
+        utt_lst = convo.get_utterance_ids()
+    timeA, timeB = _rhythm_count_utt_time(corpus, utt_lst, min_utt_words)
+    total_time = timeA + timeB
+    if total_time == 0:
+        return None
+    return timeA / total_time if timeA >= timeB else timeB / total_time
+
+
+def _convo_balance_lst(
+    corpus,
+    convo_id,
+    window_ps_threshold,
+    window_ss_threshold,
+    window_size,
+    sliding_size,
+    remove_first_last_utt,
+    min_utt_words,
+):
+    """
+    Generates a list representing local talk-time sharing dynamics across sliding windows in a conversation.
+
+    Each value in the list is 1 (primary speaker dominance), -1 (secondary speaker dominance), or 0 (balanced),
+    based on whether the dominant group exceeds the window_ps_threshold within that window.
+    """
+    groups = _sliding_window(
+        corpus, convo_id, window_size, sliding_size, remove_first_last_utt, min_utt_words
+    )
+    balance_lst = []
+    no_speaking_time_count = 0
+    all_window_count = 0
+    convo = corpus.get_conversation(convo_id)
+    for window in groups:
+        all_window_count += 1
+        window_ps_time = window[convo.meta["primary_speaker"]]
+        window_ss_time = window[convo.meta["secondary_speaker"]]
+        window_total_time = window_ps_time + window_ss_time
+        window_id = 0
+        if window_total_time == 0:
+            window_id = -100
+            no_speaking_time_count += 1
+            continue
+        elif window_ps_time / window_total_time > window_ps_threshold:
+            window_id = window_ps_time / window_total_time
+        elif window_ss_time / window_total_time > window_ss_threshold:
+            window_id = -1 * window_ss_time / window_total_time
+
+        if window_id == 0:
+            balance_lst.append(0)
+        elif window_id > 0:
+            balance_lst.append(1)
+        else:
+            balance_lst.append(-1)
+    return balance_lst
+
+
+def plot_color_blocks(data_dict, block_length=0.5, plot_name=None):
+    """
+    Visualizes conversation dynamics as a horizontal sequence of colored blocks.
+
+    Each block represents a window: blue for primary speaker dominance, red for secondary, and grey for balance.
+    Block opacity reflects the strength of dominance. Optionally saves the plot to a file.
+    """
+    convo_id = list(data_dict.keys())[0]
+    data = data_dict[convo_id]
+    fig, ax = plt.subplots(figsize=(10, 2))
+
+    # Plot each block, the higher absolute value of "value", darker the block
+    for i, value in enumerate(data):
+        if value > 0:  # plot blue
+            ax.add_patch(
+                plt.Rectangle((i * block_length, 0), block_length, 0.2, color=(0, 0, 1, value))
+            )
+        elif value < 0:  # plot orange
+            ax.add_patch(
+                plt.Rectangle((i * block_length, 0), block_length, 0.2, color=(1, 0, 0, -value))
+            )
+        elif value == 0:  # plot lightgrey
+            ax.add_patch(plt.Rectangle((i * block_length, 0), block_length, 0.2, color="lightgrey"))
+    ax.set_xlim(0, len(data) * block_length)
+    ax.set_ylim(0, 1)
+    ax.set_aspect("auto")
+    ax.axis("off")
+    # ax.text(0, 0.22, f"{convo_id}", fontsize=12, ha='left')
+    if plot_name is not None:
+        plt.savefig(plot_name)
+    plt.show()
+
+
+def plot_color_blocks_multi(data_lists, block_length=0.5, plot_name=None):
+    """
+    Plots multiple conversations' windowed talk-time sharing dynamics as side-by-side color block visualizations.
+    Each subplot represents one conversation.
+    """
+    num_lists = len(data_lists)
+    num_columns = 2
+    num_rows = (num_lists + 1) // num_columns
+
+    fig, axs = plt.subplots(num_rows, num_columns, figsize=(8, num_rows * 0.5))
+
+    axs = axs.flatten()
+
+    # Plot each list in its own subplot
+    for idx, data_dict in enumerate(data_lists):
+        # Plot each block, the higher absolute value of "value", darker the block
+        for convo_id, data in data_dict.items():
+            for i, value in enumerate(data):
+                if value > 0:  # plot blue
+                    axs[idx].add_patch(
+                        plt.Rectangle(
+                            (i * block_length, 0), block_length, 0.5, color=(0, 0, 1, value)
+                        )
+                    )
+                elif value < 0:  # plot red
+                    axs[idx].add_patch(
+                        plt.Rectangle(
+                            (i * block_length, 0), block_length, 0.5, color=(1, 0, 0, -value)
+                        )
+                    )
+                elif value == 0:  # plot lightgrey
+                    axs[idx].add_patch(
+                        plt.Rectangle((i * block_length, 0), block_length, 0.5, color="lightgrey")
+                    )
+                else:
+                    print("invalid other case")
+            axs[idx].set_xlim(0, len(data) * block_length)
+            axs[idx].set_ylim(0, 0.1)
+            axs[idx].set_aspect("auto")
+            axs[idx].axis("off")
+            # axs[idx].text(0, -0.02, f"{convo_id}", fontsize=7, ha='left')
+
+    if num_lists % num_columns:
+        axs[-1].axis("off")
+
+    plt.tight_layout()
+    if plot_name is not None:
+        plt.savefig(plot_name)
+    plt.show()
+
+
+def _plot_individual_conversation_floors(
+    corpus,
+    convo_id,
+    window_ps_threshold,
+    window_ss_threshold,
+    window_size,
+    sliding_size,
+    remove_first_last_utt,
+    min_utt_words,
+    plot_name=None,
+):
+    """
+    Visualizes turn-taking dominance in a single conversation using color-coded windowed balance scores.
+
+    Applies a sliding window over the conversation to compute talk-time balance between the primary and
+    secondary speaker groups, then plots the resulting sequence as colored blocks.
+    """
+    groups = _sliding_window(
+        corpus,
+        convo_id,
+        window_size=window_size,
+        sliding_size=sliding_size,
+        remove_first_last_utt=remove_first_last_utt,
+        min_utt_words=min_utt_words,
+    )
+    convo_plot_lst = []
+    score_lst = []
+    convo = corpus.get_conversation(convo_id)
+    ps = convo.meta["primary_speaker"]
+    ss = convo.meta["secondary_speaker"]
+    for window in groups:
+        window_ps_time = window[ps]
+        window_ss_time = window[ss]
+        window_total_time = window_ps_time + window_ss_time
+        window_id = 0
+        if window_total_time == 0:  # No Speaking Time in the window
+            window_id = -100
+            continue  # skipping no speaking time windows for now
+            # no_speaking_time_count += 1
+        elif window_ps_time / window_total_time > window_ps_threshold:
+            window_id = window_ps_time / window_total_time
+        elif window_ss_time / window_total_time > window_ss_threshold:
+            window_id = -1 * window_ss_time / window_total_time
+
+        convo_plot_lst.append(window_id)
+        score_lst.append(round(window_id, 2))
+    plot_color_blocks({convo_id: convo_plot_lst}, plot_name=plot_name)
+    try:
+        print(
+            f"red : {round(convo.meta['percent_red'], 2)}, blue : {round(convo.meta['percent_blue'], 2)}, gray : {round(convo.meta['percent_gray'], 2)}"
+        )
+    except:
+        pass
+
+
+def _plot_multi_conversation_floors(
+    corpus,
+    convo_id_lst,
+    window_ps_threshold,
+    window_ss_threshold,
+    window_size,
+    sliding_size,
+    remove_first_last_utt,
+    min_utt_words,
+    plot_name=None,
+):
+    """
+    Generates side-by-side visualizations of turn-taking dynamics across multiple conversations.
+
+    For each conversation, computes sliding window balance scores between primary and secondary speakers,
+    and plots the results as color-coded block sequences. Optionally saves the combined visualization.
+    """
+    result_lst = []
+    for convo_id in convo_id_lst:
+        groups = _sliding_window(
+            corpus,
+            convo_id,
+            window_size=window_size,
+            sliding_size=sliding_size,
+            remove_first_last_utt=remove_first_last_utt,
+            min_utt_words=min_utt_words,
+        )
+        convo = corpus.get_conversation(convo_id)
+        ps = convo.meta["primary_speaker"]
+        ss = convo.meta["secondary_speaker"]
+        convo_plot_lst = []
+        for window in groups:
+            window_ps_time = window[ps]
+            window_ss_time = window[ss]
+            window_total_time = window_ps_time + window_ss_time
+            window_id = 0
+            if window_total_time == 0:  # No Speaking Time in the window
+                window_id = -100
+                continue  # skipping no speaking time windows for now
+                # no_speaking_time_count += 1
+            elif window_ps_time / window_total_time > window_ps_threshold:
+                window_id = window_ps_time / window_total_time
+            elif window_ss_time / window_total_time > window_ss_threshold:
+                window_id = -1 * window_ss_time / window_total_time
+
+            convo_plot_lst.append(window_id)
+        result_lst.append({convo_id: convo_plot_lst})
+    plot_color_blocks_multi(result_lst, plot_name=plot_name)
diff --git a/docs/source/analysis.rst b/docs/source/analysis.rst
index 81c9400b..55c6c69f 100644
--- a/docs/source/analysis.rst
+++ b/docs/source/analysis.rst
@@ -16,4 +16,7 @@ These are the transformers related to generating some analysis of the Corpus.
    Pairer <pairer.rst>
    PairedPrediction <pairedprediction.rst>
    Ranker <ranker.rst>
-   SpeakerConvoDiversity <speakerConvoDiversity.rst>
\ No newline at end of file
+   SpeakerConvoDiversity <speakerConvoDiversity.rst>
+   Redirection <redirectionAndUtteranceLikelihood.rst>
+   UtteranceLikelihood <redirectionAndUtteranceLikelihood.rst>
+   TalkTimeSharingDynamics <balance.rst>
\ No newline at end of file
diff --git a/docs/source/balance.rst b/docs/source/balance.rst
new file mode 100644
index 00000000..5e500ce9
--- /dev/null
+++ b/docs/source/balance.rst
@@ -0,0 +1,25 @@
+Talk-Time Sharing Dynamics
+====================================
+
+The `Balance` transformer measures how talk-time is distributed 
+between speakers throughout a conversation—--capturing both the 
+overall conversation-level imbalance and the fine-grained dynamics 
+that lead to it. The method and analysis are presented in the paper: 
+`Time is On My Side: Dynamics of Talk-Time Sharing in Video-chat Conversations <https://www.cs.cornell.edu/~cristian/Time_Sharing_Dynamics.html>`_.
+
+Our approach surfaces patterns in how speakers alternate dominance, 
+engage in back-and-forths, or maintain relatively equal control of 
+the floor. We show that even when conversations are similarly balanced 
+overall, their temporal talk-time dynamics can lead to diverging speaker 
+experiences. This framework can be extended to a wide range of dialogue 
+settings, including multi-party and role-asymmetric interactions.  
+
+We present a demo, which applies the `Balance` transformer to 
+the `CANDOR corpus <https://convokit.cornell.edu/documentation/candor.html>`_,
+highlighting conversational patterns in video-chat settings. We then extend the 
+analysis to `Supreme Court oral arguments <https://convokit.cornell.edu/documentation/supreme.html>`_ 
+to demonstrate the method's adaptability across different conversational domains.
+The demo is publically available: `Talk-Time Sharing Dynamics in CANDOR Corpus and Supreme Court Oral Arguments <https://github.com/CornellNLP/ConvoKit/tree/master/convokit/balance/balance_example.ipynb>`_
+
+.. automodule:: convokit.balance.balance
+    :members:
diff --git a/setup.py b/setup.py
index 04506c8c..2e829bcf 100644
--- a/setup.py
+++ b/setup.py
@@ -28,6 +28,7 @@
         "convokit.prompt_types",
         "convokit.ranker",
         "convokit.redirection",
+        "convokit.balance",
         "convokit.text_processing",
         "convokit.speaker_convo_helpers",
         "convokit.speakerConvoDiversity",
@@ -72,8 +73,8 @@
         "transformers",
         "unsloth",
         "trl>=0.12.2",
-        "tensorflow>=2.18.0",
-        "tf-keras>=2.17.0,<3.0.0",
+        # "tensorflow>=2.18.0",
+        # "tf-keras>=2.17.0,<3.0.0",
     ],
     extras_require={
         "craft": ["torch>=0.12"],