pwease

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mat filter=lfs diff=lfs merge=lfs -text

C90DFEBC.json

@@ -0,0 +1,6 @@
+{
+  "affiliated": true,
+  "ref_number": "C90DFEBC",
+  "headphone_type": "In-ear",
+  "sex": "Female"
+}

app.py

@@ -0,0 +1,53 @@
+import json
+import os
+
+from pages.common import *
+
+hide_sidebar()
+# Initialize session state for page navigation
+st.session_state.page = 1  # Start at page 1
+st.session_state.user_data = {}  # Dictionary to store user responses
+st.session_state.inc_int = 0
+st.session_state.question_idx = 0
+st.session_state.example_idx = 0
+st.session_state.user_pref_idx = 0
+
+PLOT_PATH = "scatter_data"
+st.session_state.plots = {
+    int(ppath.split(".")[0]): json.load(open(os.path.join(PLOT_PATH, ppath), "r"))
+    for ppath in os.listdir(PLOT_PATH)
+}
+
+st.session_state.questions = json.load(open("spatial_questions.json", "r"))
+st.session_state.num_questions = len(
+    [1 for q in st.session_state.questions if q["ttype"] == "question"]
+)
+
+# Page 1 - Collect Input
+st.write(
+    """# Data Sonification Using Spatial Audio
+         """
+)
+st.image("./assets/images/tamu_logo.png", width=150)
+
+st.write(
+    """1. Our Research group is exploring the use of simulated spatial audio
+         for data representation.
+         """
+)
+st.write(
+    """2. In this study, you will listen to some audio files, and decide the chart that 
+         corresponds with the audio."""
+)
+st.write(
+    f"""3. This test contains {st.session_state.num_questions} questions and shouldn't take longer than 20 minutes."""
+)
+
+
+affiliated = st.checkbox("I am affiliated with the research team")
+
+if st.button("Continue", type="primary"):
+    # Save responses in session state and move to next page
+    st.session_state.user_data["affiliated"] = affiliated
+    st.session_state.user_data["ref_number"] = get_new_ref()
+    next_page()

cipic_hrtf_database/female/15.mat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8e90491fec297bc831c7c18363d2e6de7d669961c7b06843ff8d25be45e4ae1
+size 4030520

cipic_hrtf_database/female/18.mat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87001e762209aab9b74c3065dcbf2ef1e0f4245a74289547355a10f7e5fea706
+size 4030520

cipic_hrtf_database/female/60.mat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a0af86c1d65a66c8e054257eb197617ab2bd6319edc9dcdd285cf8541f8813a
+size 4030520

cipic_hrtf_database/male/147.mat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f55a06d302d90e25b465ca44d882ac1530ed5575d6e32d90a7c7fbc6bc7535d
+size 4030520

cipic_hrtf_database/male/152.mat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fd30b133af36a419a14a148c2da01b92900a69c2861fe6aa1ca3f07247651d8
+size 4030520

cipic_hrtf_database/male/27.mat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ef1f7c4c38d9915b4dc0f678864f59fb569401143b68dd9d78abc701e5d465e
+size 4030520

density.json

@@ -0,0 +1,35 @@
+[
+  {
+    "description": "Test if they can distinguish different densities",
+    "ttype": "question",
+    "plots": [
+      25,
+      29,
+      24,
+      26
+    ],
+    "answer": 26
+  },
+  {
+    "description": "Test if they can distinguish different densities",
+    "ttype": "question",
+    "plots": [
+      25,
+      22,
+      31,
+      24
+    ],
+    "answer": 31
+  },
+  {
+    "description": "Test if they can distinguish different densities",
+    "ttype": "question",
+    "plots": [
+      32,
+      26,
+      27,
+      33
+    ],
+    "answer": 33
+  }
+]

horizontal_gaps_vs_spatial.ipynb

@@ -0,0 +1,252 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Time Dimension Gaps vs Spatial Experiment\n",
+    "\n",
+    "The goal of this experiment is to judge the efficiency of encoding the x-axis as a `spatial` dimension versus `time` dimension.\n",
+    "\n",
+    "By `time` dimension we mean leaving gaps (silences) behind sequential data points that correlate linearly in duration to the eucledian distance between the points.\n",
+    "\n",
+    "## Methodology\n",
+    "\n",
+    "- A set of graphs are sonified using `TOPH` in two distinct ways. The y-axis can either be `constant` or encoded using `pitch`.\n",
+    "\n",
+    "- The core idea is to encode the same graph (in y-dimension) with varying gaps between the points in the x-axis, and make the user choose from a random sampling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "    from toph.audio.playable import Chain,SineWave, Silence, Wave\n",
+    "    from toph.audio.effect import SimplePanner\n",
+    "    from toph.audio.stage import AudioStage\n",
+    "\n",
+    "    import matplotlib.pyplot as plt\n",
+    "\n",
+    "    AUDIO_PATH = \"assets/ding.wav\"\n",
+    "\n",
+    "    def ax_gen(domain, range_):\n",
+    "\n",
+    "        do_scale = max(domain) - min(domain)\n",
+    "        ra_scale = max(range_) - min(range_)\n",
+    "\n",
+    "        def foo(dp):\n",
+    "\n",
+    "            dx = dp - min(domain) \n",
+    "            sdx = dx / do_scale \n",
+    "            return min(range_) + sdx * ra_scale \n",
+    "\n",
+    "        return foo\n",
+    "\n",
+    "    def sonify(xs, ys, x_mode, y_mode, gaps=0.5, save=None):\n",
+    "        \"\"\"\n",
+    "        \"\"\"\n",
+    "        with AudioStage() as stage:\n",
+    "\n",
+    "            #TODO: replace with linear axis when implemented\n",
+    "\n",
+    "            lin_ax = ax_gen(\n",
+    "                domain=(min(xs), max(xs)),\n",
+    "                range_=(-1. , +1.)\n",
+    "            )\n",
+    "\n",
+    "            pitch_ax = ax_gen(\n",
+    "                domain=(min(ys), max(ys)),\n",
+    "                range_=(110, 880)\n",
+    "            )\n",
+    "\n",
+    "            x_deltas = [xs[idx+1] - xs[idx] for idx in range(len(xs) - 1)]\n",
+    "            x_deltas.append(0.)\n",
+    "\n",
+    "            gap_ax = ax_gen(\n",
+    "                domain=(min(x_deltas), max(x_deltas)),\n",
+    "                range_=(0.25 , 1.25)\n",
+    "            ) \n",
+    "\n",
+    "            marks = []\n",
+    "\n",
+    "            for idx, (x , y) in enumerate(zip(xs, ys)):\n",
+    "                \n",
+    "                audio_src = Wave(AUDIO_PATH) if y_mode == \"static\" else SineWave(vol = 0.85, f = pitch_ax(y), secs=0.5)\n",
+    "                if x_mode == \"spatial\":\n",
+    "\n",
+    "                    marks.extend([\n",
+    "                            audio_src.add_effect(SimplePanner(dir = lin_ax(x))),\n",
+    "                            Silence(secs = gaps)\n",
+    "                    ])\n",
+    "\n",
+    "                elif x_mode == \"gaps\":\n",
+    "\n",
+    "                    marks.append(audio_src)\n",
+    "                    if x_deltas[idx] > 0.:\n",
+    "                        marks.append(\n",
+    "                            Silence(secs = gap_ax(x_deltas[idx]))\n",
+    "                            )\n",
+    "\n",
+    "            if save:\n",
+    "                stage.save(Chain(*marks), save)\n",
+    "\n",
+    "            else:\n",
+    "                stage.play(Chain(*marks))\n",
+    "\n",
+    "    def plot_four(datasets, idxs, y_mode, show_correct = None):\n",
+    "        fig, axes = plt.subplots(2, 2, figsize=(8, 8))\n",
+    "\n",
+    "        for i, ax in enumerate(axes.flat):\n",
+    "            ax.scatter(datasets[idxs[i]][\"x\"], datasets[idxs[i]][\"y\"] if y_mode == \"pitch\" else [0] * len(datasets[idxs[i]][\"x\"]))\n",
+    "            ax.set_title(f\"Plot {i + 1}\")\n",
+    "            ax.grid(True)\n",
+    "\n",
+    "            if show_correct is not None:\n",
+    "                for spine in ax.spines.values():\n",
+    "                    if idxs[i] == show_correct:\n",
+    "                            spine.set_linewidth(2)\n",
+    "                            spine.set_color(\"green\")\n",
+    "                    else:\n",
+    "                            spine.set_color(\"red\")\n",
+    "\n",
+    "\n",
+    "        plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datasets = [\n",
+    "    {\n",
+    "        \"x\":[0, 40, 50, 55, 90],\n",
+    "        \"y\":[10, 15, 20, 15, 10]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\":[0, 20, 40, 60, 80],\n",
+    "        \"y\":[10, 15, 20, 15, 10]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\":[0, 20, 60, 120, 240, 360],\n",
+    "        \"y\":[20, 15, 20, 15, 10, 5]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 5, 15, 45, 135 , 405],\n",
+    "        \"y\": [12, 14, 19, 14, 11, 8]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 20, 40, 60, 80, 100],\n",
+    "        \"y\": [15, 20, 25, 20, 15, 10]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 60, 65, 70, 72, 74],\n",
+    "        \"y\": [10, 18, 16, 20, 15, 12]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 2, 4, 8, 10, 90],\n",
+    "        \"y\": [8, 12, 18, 22, 18, 10]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 25, 50, 75, 100, 125],\n",
+    "        \"y\": [20, 18, 22, 18, 14, 10]\n",
+    "    }\n",
+    "]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ALSA lib pcm.c:2666:(snd_pcm_open_noupdate) Unknown PCM dsnoop:0\n",
+      "ALSA lib pcm_dmix.c:999:(snd_pcm_dmix_open) unable to open slave\n",
+      "ALSA lib pcm_oss.c:397:(_snd_pcm_oss_open) Cannot open device /dev/dsp\n",
+      "ALSA lib pcm_oss.c:397:(_snd_pcm_oss_open) Cannot open device /dev/dsp\n",
+      "ALSA lib confmisc.c:160:(snd_config_get_card) Invalid field card\n",
+      "ALSA lib pcm_usb_stream.c:482:(_snd_pcm_usb_stream_open) Invalid card 'card'\n",
+      "ALSA lib confmisc.c:160:(snd_config_get_card) Invalid field card\n",
+      "ALSA lib pcm_usb_stream.c:482:(_snd_pcm_usb_stream_open) Invalid card 'card'\n",
+      "ALSA lib pcm_dmix.c:999:(snd_pcm_dmix_open) unable to open slave\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAAMWCAYAAACHiaukAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbx0lEQVR4nO3dfVzUdb7//yfIlWRIeMFEYVinQtOyIHGq83M3USzbsjxucrM0c3VrpTRaj9qFZm1LtV2oRXpqt6xVj66dcsvMdQ5etCWKorVexbabZUcbyAwwTRjh8/uDL7NNDjjwnmEG5nG/3bzVfD7v92fen9cMn9ftORcQYVmWJQAAAABopchgLwAAAABA+0aoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAPxo48aNioiI0MaNG4O9FABAiKFHoCMjVAA+WLx4sSIiItz/4uLidNFFFykvL0/l5eV+uY81a9bokUce8Xl8SUmJfvWrXykjI0PR0dGKiIjwyzoAAC0Taj2ivr5eixcv1o033qjU1FSdccYZ6tevn37zm9/oxIkTflkP8GOECqAFHn30Uf3xj3/UCy+8oKuuukoLFy6U3W7X8ePHjY+9Zs0azZ07t0Xjf//73ysiIkLnn3++8f0DAMyESo84fvy4JkyYoK+//lp33XWX5s2bp4EDB2rOnDm67rrrZFmW8XqAH4sK9gKA9uS6665TZmamJOkXv/iFunXrpmeffVZ//vOflZub26ZrufvuuzVjxgx17txZeXl5+vvf/96m9w8A8BQqPSImJkYffvihrrrqKve2SZMmKS0tTXPmzFFRUZGys7PbbD0ID7xTARi49tprJUn79+9vdtzKlSuVkZGhzp07q3v37rrtttt08OBB9/477rhDhYWFkuTxFnpzkpOT1blzZ8MzAAAESrB6RExMjEegaHTzzTdLkvbt29ficwFOh3cqAAP//Oc/JUndunVrcszixYs1YcIEXXnllSooKFB5ebnmz5+vDz/8UDt37lRiYqJ++ctf6tChQ3I4HPrjH//YVssHAARQqPUIp9MpSerevXurjwE0hVABtEBVVZUOHz6sEydO6MMPP9Sjjz6qzp0764YbbvA63uVyacaMGerXr5/ef/99xcXFSZKuueYa3XDDDXruuec0d+5c2e12XXTRRXI4HLrtttva8pQAAH4S6j3iqaeeUkJCgq677rpWHwNoCh9/AlogOztbPXr0UGpqqsaMGaMuXbrorbfe0jnnnON1/Pbt21VRUaFf/epX7mYhSSNGjFB6errefffdtlo6ACDAQrlH/Pa3v9X//u//6oknnlBiYqLfjgs04p0KoAUKCwt10UUXKSoqSsnJybr44osVGdl0Nv/iiy8kSRdffPEp+9LT0/XBBx8EbK0AgLYVqj1ixYoVeuihhzRx4kTdfffdfjkm8GOECqAFBg4c6P7NHgAA/FAo9giHw6Fx48ZpxIgRWrRoUbCXgw6Mjz8BAXTeeedJksrKyk7ZV1ZW5t4viT9eBwBhJtA9YuvWrbr55puVmZmpP/3pT4qK4rVkBA6hAgigzMxM9ezZU4sWLVJNTY17+3vvvad9+/ZpxIgR7m1nnHGGJKmysrKtlwkACIJA9ojG+WlpaVq9ejW/ghwBR2QFAig6OlpPPvmkJkyYoMGDBys3N9f96wLT0tJ03333ucdmZGRIku69917l5OSoU6dOGjNmTJPH/uKLL9y/WnD79u2SpN/85jeSGl79uv322wN1WgAAPwhUjzh69KhycnL07bffavr06ad84fuCCy6Q3W4P3IkhPFkATuvVV1+1JFnbtm1rdtyGDRssSdaGDRs8tq9YscK6/PLLrdjYWCspKckaO3as9X//938eY06ePGndc889Vo8ePayIiAjrdD+ejffl7d/gwYNbc5oAgFYItR6xf//+JvuDJGv8+PGtPVWgSRGWZVltnGMAAAAAdCB8pwIAAACAEUIFAAAAACOECgAAAABGCBUAAAAAjBAqAAAAABghVAAAAAAwEpZ//K6+vl6HDh3SmWee2ao/ew8AHYllWTp69KhSUlIUGRnerzXRHwDAk689IixDxaFDh5SamhrsZQBASPnyyy917rnnBnsZQUV/AADvTtcjwjJUnHnmmZIaipOQkNCiuS6XS+vWrdOwYcMUHR0diOV1CNTJN9TJN9TJN62tU3V1tVJTU93XxnBGfzBHHRpQhwbUof3XwNceEZahovEt7YSEhFY1jfj4eCUkJLTLJ0ZboU6+oU6+oU6+Ma0TH/ehP/gDdWhAHRpQh45Tg9P1iPD+8CwAAAAAY4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABgJOChorCwUGlpaYqLi1NWVpZKSkqaHb9y5Uqlp6crLi5O/fv315o1a5oce9dddykiIkLz5s3z86oBAG2BHgEAHUNAQ8WKFSuUn5+vOXPmaMeOHbrsssuUk5OjiooKr+M3b96s3NxcTZw4UTt37tTIkSM1cuRI7d69+5Sxb731lrZs2aKUlJRAngIAIEDoEQDQcQQ0VDz77LOaNGmSJkyYoL59+2rRokWKj4/XK6+84nX8/PnzNXz4cE2fPl19+vTRY489piuuuEIvvPCCx7iDBw/qnnvu0dKlSxUdHR3IUwAABAg9AgA6joCFitraWpWWlio7O/tfdxYZqezsbBUXF3udU1xc7DFeknJycjzG19fX6/bbb9f06dN1ySWXBGbxAICAokcAQMcSFagDHz58WHV1dUpOTvbYnpycrE8++cTrHKfT6XW80+l0337yyScVFRWle++91+e11NTUqKamxn27urpakuRyueRyuXw+TuOcH/4X3lEn31An31An37S2TsGoa6j0CPqD/1GHBtShAXVo/zXwdd0BCxWBUFpaqvnz52vHjh2KiIjweV5BQYHmzp17yvZ169YpPj6+VWtxOBytmhduqJNvqJNvqJNvWlqn48ePB2glbas1PYL+EDjUoQF1aEAd2m8NfO0RAQsV3bt3V6dOnVReXu6xvby8XDabzescm83W7Pi//vWvqqioUK9evdz76+rqdP/992vevHn6/PPPvR531qxZys/Pd9+urq5Wamqqhg0bpoSEhBadl8vlksPh0NChQ/msbjOok2+ok2+ok29aW6fGV+fbUqj0CPqD/1GHBtShAXVo/zXwtUcELFTExMQoIyNDRUVFGjlypKSGz7oWFRUpLy/P6xy73a6ioiJNmzbNvc3hcMhut0uSbr/9dq+fp7399ts1YcKEJtcSGxur2NjYU7ZHR0e3+sE1mRtOqJNvqJNvqJNvWlqnYNQ0VHoE/SFwqEMD6tCAOrTfGvi65oB+/Ck/P1/jx49XZmamBg4cqHnz5unYsWPui/u4ceN0zjnnqKCgQJI0depUDR48WM8884xGjBih5cuXa/v27XrppZckSd26dVO3bt087iM6Olo2m00XX3xxIE8FAOBn9AgA6DgCGipuvfVWff3115o9e7acTqcGDBigtWvXur9od+DAAUVG/usXUF111VVatmyZHnroIT3wwAO68MILtWrVKvXr1y+QywQABAE9AgA6joB/UTsvL6/Jt7I3btx4yrbRo0dr9OjRPh+/qe9RAABCHz0CADqGgP7xOwAAAAAdH6ECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADASMBDRWFhodLS0hQXF6esrCyVlJQ0O37lypVKT09XXFyc+vfvrzVr1rj3uVwuzZgxQ/3799cZZ5yhlJQUjRs3TocOHQr0aQAAAoAeAQAdQ0BDxYoVK5Sfn685c+Zox44duuyyy5STk6OKigqv4zdv3qzc3FxNnDhRO3fu1MiRIzVy5Ejt3r1bknT8+HHt2LFDDz/8sHbs2KE333xTZWVluvHGGwN5GgCAAKBHAEDHEdBQ8eyzz2rSpEmaMGGC+vbtq0WLFik+Pl6vvPKK1/Hz58/X8OHDNX36dPXp00ePPfaYrrjiCr3wwguSpK5du8rhcOjnP/+5Lr74Yg0aNEgvvPCCSktLdeDAgUCeCgDAz+gRANBxBCxU1NbWqrS0VNnZ2f+6s8hIZWdnq7i42Ouc4uJij/GSlJOT0+R4SaqqqlJERIQSExP9sm4AQODRIwCgY4kK1IEPHz6suro6JScne2xPTk7WJ5984nWO0+n0Ot7pdHodf+LECc2YMUO5ublKSEhoci01NTWqqalx366urpbU8Plbl8vl0/k0ahzf0nnhhjr5hjr5hjr5prV1CkZdQ6VH0B/8jzo0oA4NqEP7r4Gv6w5YqAg0l8uln//857IsSwsXLmx2bEFBgebOnXvK9nXr1ik+Pr5V9+9wOFo1L9xQJ99QJ99QJ9+0tE7Hjx8P0EqCx9ceQX8IHOrQgDo0oA7ttwa+9oiAhYru3burU6dOKi8v99heXl4um83mdY7NZvNpfGOz+OKLL7R+/fpm36WQpFmzZik/P999u7q6WqmpqRo2bNhp5/6Yy+WSw+HQ0KFDFR0d3aK54YQ6+YY6+YY6+aa1dWp8db4thUqPoD/4H3VoQB0aUIf2XwNfe0TAQkVMTIwyMjJUVFSkkSNHSpLq6+tVVFSkvLw8r3PsdruKioo0bdo09zaHwyG73e6+3dgsPv30U23YsEHdunU77VpiY2MVGxt7yvbo6OhWP7gmc8MJdfINdfINdfJNS+sUjJqGSo+gPwQOdWhAHRpQh/ZbA1/XHNCPP+Xn52v8+PHKzMzUwIEDNW/ePB07dkwTJkyQJI0bN07nnHOOCgoKJElTp07V4MGD9cwzz2jEiBFavny5tm/frpdeeklSQ7P4j//4D+3YsUOrV69WXV2d+7O0SUlJiomJCeTpAAD8iB4BAB1HQEPFrbfeqq+//lqzZ8+W0+nUgAEDtHbtWvcX7Q4cOKDIyH/9AqqrrrpKy5Yt00MPPaQHHnhAF154oVatWqV+/fpJkg4ePKi3335bkjRgwACP+9qwYYN+8pOfBPJ0AAB+RI8AgI4j4F/UzsvLa/Kt7I0bN56ybfTo0Ro9erTX8WlpabIsy5/LAwAEET0CADqGgP7xOwAAAAAdH6ECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKGiBerqLZXsPyJJKtl/RHX1VpBXFJqok2+ok2+ok2+oU3BRf/xQKDwf6uotFf/zG/35o4Mq/uc3LV6D6XyEjrZ6LAMeKgoLC5WWlqa4uDhlZWWppKSk2fErV65Uenq64uLi1L9/f61Zs8Zjv2VZmj17ts4++2x17txZ2dnZ+vTTTwN5CpKktbu/0jVPrtedr22TJN352jZd8+R6rd39VcDvuz2hTr6hTr6hTr5pz3XqCD2iPdcf/hcKz4fGNeS+vEVTl3+k3Je3tGgNpvMROtrysQxoqFixYoXy8/M1Z84c7dixQ5dddplycnJUUVHhdfzmzZuVm5uriRMnaufOnRo5cqRGjhyp3bt3u8c89dRTWrBggRYtWqStW7fqjDPOUE5Ojk6cOBGw81i7+yvdvWSHvqryvA9n1QndvWQHP2T/D3XyDXXyDXXyTXuuU0foEe25/vC/UHg+mK4hFM4B/tHWj2VAQ8Wzzz6rSZMmacKECerbt68WLVqk+Ph4vfLKK17Hz58/X8OHD9f06dPVp08fPfbYY7riiiv0wgsvSGp4BWrevHl66KGHdNNNN+nSSy/V66+/rkOHDmnVqlUBOYe6ektz39krb28UNW6b+87esH9bkDr5hjr5hjr5pr3Xqb33iPZef/hXKDwfTNcQCucA/wjGYxnltyP9SG1trUpLSzVr1iz3tsjISGVnZ6u4uNjrnOLiYuXn53tsy8nJcTeD/fv3y+l0Kjs7272/a9euysrKUnFxscaMGeP1uDU1NaqpqXHfrq6uliS5XC65XK5mz6Nk/xEd+e57xXZquB0baXn8V5KOfPe9tvyjQgN7JzV7rI6MOvmGOvmGOvnGX3U63XUwEEKlR9Af/K+xbsF4XgVTKDwffrwGb5pbg+l8b8L1+fBDwaiBPx9LX9cdsFBx+PBh1dXVKTk52WN7cnKyPvnkE69znE6n1/FOp9O9v3FbU2O8KSgo0Ny5c0/Zvm7dOsXHx5/2XJ4aeOq2xzLrPW4f3rdFa/ad9lAdGnXyDXXyDXXyjT/qdPz4cT+v6vRCpUfQHwLH4XAEewltLhSeD97W8GPNrcF0flPC8fnwY21dA389lr72iICFilAya9Ysj1e3qqurlZqaqmHDhikhIaHZuSX7j7i/bCU1vOLwWGa9Ht4eqZr6CPf2V8ZfGVavRP0YdfINdfINdfKNv+rU+Op8OKI/+J/L5ZLD4dDQoUMVHR0d7OW0mVB4Pvx4DU1pag2m870J1+fDDwWjBv58LH3tEQELFd27d1enTp1UXl7usb28vFw2m83rHJvN1uz4xv+Wl5fr7LPP9hgzYMCAJtcSGxur2NjYU7ZHR0ef9sEd9G89ldSls5xVJzw+l1ZTH6GaughFSLJ1jdOgf+upTpERTR2mw6NOvqFOvqFOvvFXnYLR6EOlR9AfAseXGnYkofB8aGoNjU63BtP5zQm354M3bVkDfz6Wvq45YF/UjomJUUZGhoqKitzb6uvrVVRUJLvd7nWO3W73GC81vFXUOL53796y2WweY6qrq7V169Ymj2mqU2SE5vysr6SGB+CHGm/P+VnfsGwYP0SdfEOdfEOdfNOe69QRekR7rj/8LxSeD6ZrCIVzgH8E47EM6G9/ys/P18svv6zXXntN+/bt0913361jx45pwoQJkqRx48Z5fElv6tSpWrt2rZ555hl98skneuSRR7R9+3bl5eVJkiIiIjRt2jT95je/0dtvv61du3Zp3LhxSklJ0ciRIwN2HsP7na2Ft10hW9c4j+22rnFaeNsVGt7v7CZmhhfq5Bvq5Bvq5Jv2XKeO0CPac/3hf6HwfDBdQyicA/yjzR9LK8Cef/55q1evXlZMTIw1cOBAa8uWLe59gwcPtsaPH+8x/k9/+pN10UUXWTExMdYll1xivfvuux776+vrrYcffthKTk62YmNjrSFDhlhlZWUtWlNVVZUlyaqqqmrRvJN19dYHZU5r1apV1gdlTutkXX2L5ocL6uQb6uQb6uQbkzq19proD6HWI+gP5mpra61Vq1ZZtbW1wV5K0ITC8+FkXb21+R+HrVU7/8/a/I/DLV6D6fxGPB+CXwPTx9LX62KEZVlh98uGq6ur1bVrV1VVVZ32i3g/5nK5tGbNGl1//fVh/9nA5lAn31An31An37S2TibXxI6G/mCOOjSgDg2oQ/uvga/XxYB+/AkAAABAx0eoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMBKwUHHkyBGNHTtWCQkJSkxM1MSJE/Xdd981O+fEiROaMmWKunXrpi5dumjUqFEqLy937//444+Vm5ur1NRUde7cWX369NH8+fMDdQoAgAChRwBAxxKwUDF27Fjt2bNHDodDq1ev1vvvv6/Jkyc3O+e+++7TO++8o5UrV2rTpk06dOiQbrnlFvf+0tJS9ezZU0uWLNGePXv04IMPatasWXrhhRcCdRoAgACgRwBAxxIViIPu27dPa9eu1bZt25SZmSlJev7553X99dfr6aefVkpKyilzqqqq9Ic//EHLli3TtddeK0l69dVX1adPH23ZskWDBg3SnXfe6THn/PPPV3Fxsd58803l5eUF4lQAAH5GjwCAjicgoaK4uFiJiYnuZiFJ2dnZioyM1NatW3XzzTefMqe0tFQul0vZ2dnubenp6erVq5eKi4s1aNAgr/dVVVWlpKSkZtdTU1Ojmpoa9+3q6mpJksvlksvlatG5NY5v6bxwQ518Q518Q51809o6tXVdQ6lH0B/8jzo0oA4NqEP7r4Gv6w5IqHA6nerZs6fnHUVFKSkpSU6ns8k5MTExSkxM9NienJzc5JzNmzdrxYoVevfdd5tdT0FBgebOnXvK9nXr1ik+Pr7ZuU1xOBytmhduqJNvqJNvqJNvWlqn48ePB2gl3oVSj6A/BA51aEAdGlCH9lsDX3tEi0LFzJkz9eSTTzY7Zt++fS05ZKvt3r1bN910k+bMmaNhw4Y1O3bWrFnKz893366urlZqaqqGDRumhISEFt2vy+WSw+HQ0KFDFR0d3aq1hwPq5Bvq5Bvq5JvW1qnx1XlT7bFH0B/8jzo0oA4NqEP7r4GvPaJFoeL+++/XHXfc0eyY888/XzabTRUVFR7bT548qSNHjshms3mdZ7PZVFtbq8rKSo9XosrLy0+Zs3fvXg0ZMkSTJ0/WQw89dNp1x8bGKjY29pTt0dHRrX5wTeaGE+rkG+rkG+rkm5bWyV81bY89gv4QONShAXVoQB3abw18XXOLQkWPHj3Uo0eP046z2+2qrKxUaWmpMjIyJEnr169XfX29srKyvM7JyMhQdHS0ioqKNGrUKElSWVmZDhw4ILvd7h63Z88eXXvttRo/frwef/zxliwfABBA9AgACF8B+ZWyffr00fDhwzVp0iSVlJToww8/VF5ensaMGeP+rR4HDx5Uenq6SkpKJEldu3bVxIkTlZ+frw0bNqi0tFQTJkyQ3W53fwFv9+7d+ulPf6phw4YpPz9fTqdTTqdTX3/9dSBOAwAQAPQIAOh4AvJFbUlaunSp8vLyNGTIEEVGRmrUqFFasGCBe7/L5VJZWZnHlz+ee+4599iamhrl5OToxRdfdO9/44039PXXX2vJkiVasmSJe/t5552nzz//PFCnAgDwM3oEAHQsAQsVSUlJWrZsWZP709LSZFmWx7a4uDgVFhaqsLDQ65xHHnlEjzzyiD+XCQAIAnoEAHQsAfuL2gAAAADCA6ECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADASMBCxZEjRzR27FglJCQoMTFREydO1HfffdfsnBMnTmjKlCnq1q2bunTpolGjRqm8vNzr2G+++UbnnnuuIiIiVFlZGYAzAAAECj0CADqWgIWKsWPHas+ePXI4HFq9erXef/99TZ48udk59913n9555x2tXLlSmzZt0qFDh3TLLbd4HTtx4kRdeumlgVg6ACDA6BEA0LEEJFTs27dPa9eu1e9//3tlZWXpmmuu0fPPP6/ly5fr0KFDXudUVVXpD3/4g5599llde+21ysjI0KuvvqrNmzdry5YtHmMXLlyoyspK/frXvw7E8gEAAUSPAICOJyChori4WImJicrMzHRvy87OVmRkpLZu3ep1TmlpqVwul7Kzs93b0tPT1atXLxUXF7u37d27V48++qhef/11RUbylRAAaG/oEQDQ8UQF4qBOp1M9e/b0vKOoKCUlJcnpdDY5JyYmRomJiR7bk5OT3XNqamqUm5ur3/3ud+rVq5c+++wzn9ZTU1Ojmpoa9+3q6mpJksvlksvl8vW03HN++F94R518Q518Q51809o6tXVdQ6lH0B/8jzo0oA4NqEP7r4Gv625RqJg5c6aefPLJZsfs27evJYdskVmzZqlPnz667bbbWjSvoKBAc+fOPWX7unXrFB8f36q1OByOVs0LN9TJN9TJN9TJNy2t0/Hjx/1yv+2xR9AfAoc6NKAODahD+62Brz2iRaHi/vvv1x133NHsmPPPP182m00VFRUe20+ePKkjR47IZrN5nWez2VRbW6vKykqPV6LKy8vdc9avX69du3bpjTfekCRZliVJ6t69ux588EGvjUFqaDT5+fnu29XV1UpNTdWwYcOUkJDQ7Pn8mMvlksPh0NChQxUdHd2iueGEOvmGOvmGOvmmtXVqfHXeVHvsEfQH/6MODahDA+rQ/mvga49oUajo0aOHevTocdpxdrtdlZWVKi0tVUZGhqSGi319fb2ysrK8zsnIyFB0dLSKioo0atQoSVJZWZkOHDggu90uSfqf//kfff/99+4527Zt05133qm//vWvuuCCC5pcT2xsrGJjY0/ZHh0d3eoH12RuOKFOvqFOvqFOvmlpnfxV0/bYI+gPgUMdGlCHBtSh/dbA1zUH5DsVffr00fDhwzVp0iQtWrRILpdLeXl5GjNmjFJSUiRJBw8e1JAhQ/T6669r4MCB6tq1qyZOnKj8/HwlJSUpISFB99xzj+x2uwYNGiRJpzSFw4cPu+/vx5+zBQCEJnoEAHQ8AQkVkrR06VLl5eVpyJAhioyM1KhRo7RgwQL3fpfLpbKyMo/PaT333HPusTU1NcrJydGLL74YqCUCAIKEHgEAHUvAQkVSUpKWLVvW5P60tDT3510bxcXFqbCwUIWFhT7dx09+8pNTjgEACH30CADoWPgl3gAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAICRqGAvIBgsy5IkVVdXt3iuy+XS8ePHVV1drejoaH8vrcOgTr6hTr6hTr5pbZ0ar4WN18ZwRn8wRx0aUIcG1KH918DXHhGWoeLo0aOSpNTU1CCvBABCx9GjR9W1a9dgLyOo6A8A4N3pekSEFYYvTdXX1+vQoUM688wzFRER0aK51dXVSk1N1ZdffqmEhIQArbD9o06+oU6+oU6+aW2dLMvS0aNHlZKSosjI8P5ULP3BHHVoQB0aUIf2XwNfe0RYvlMRGRmpc8891+gYCQkJ7fKJ0daok2+ok2+ok29aU6dwf4eiEf3Bf6hDA+rQgDq07xr40iPC+yUpAAAAAMYIFQAAAACMECpaKDY2VnPmzFFsbGywlxLSqJNvqJNvqJNvqFNwUf8G1KEBdWhAHcKnBmH5RW0AAAAA/sM7FQAAAACMECoAAAAAGCFUAAAAADBCqGiBwsJCpaWlKS4uTllZWSopKQn2koKqoKBAV155pc4880z17NlTI0eOVFlZmceYEydOaMqUKerWrZu6dOmiUaNGqby8PEgrDg1PPPGEIiIiNG3aNPc26tTg4MGDuu2229StWzd17txZ/fv31/bt2937LcvS7NmzdfbZZ6tz587Kzs7Wp59+GsQVt726ujo9/PDD6t27tzp37qwLLrhAjz32mH749TjqFBzh1CO4/nsXztd3rt9cn2XBJ8uXL7diYmKsV155xdqzZ481adIkKzEx0SovLw/20oImJyfHevXVV63du3dbH330kXX99ddbvXr1sr777jv3mLvuustKTU21ioqKrO3bt1uDBg2yrrrqqiCuOrhKSkqstLQ069JLL7WmTp3q3k6dLOvIkSPWeeedZ91xxx3W1q1brc8++8z6y1/+Yv3jH/9wj3niiSesrl27WqtWrbI+/vhj68Ybb7R69+5tff/990Fcedt6/PHHrW7dulmrV6+29u/fb61cudLq0qWLNX/+fPcY6tT2wq1HcP0/VThf37l+Nwj36zOhwkcDBw60pkyZ4r5dV1dnpaSkWAUFBUFcVWipqKiwJFmbNm2yLMuyKisrrejoaGvlypXuMfv27bMkWcXFxcFaZtAcPXrUuvDCCy2Hw2ENHjzY3XSoU4MZM2ZY11xzTZP76+vrLZvNZv3ud79zb6usrLRiY2Ot//7v/26LJYaEESNGWHfeeafHtltuucUaO3asZVnUKVjCvUeE+/U/3K/vXL8bhPv1mY8/+aC2tlalpaXKzs52b4uMjFR2draKi4uDuLLQUlVVJUlKSkqSJJWWlsrlcnnULT09Xb169QrLuk2ZMkUjRozwqIdEnRq9/fbbyszM1OjRo9WzZ09dfvnlevnll9379+/fL6fT6VGnrl27KisrK6zqdNVVV6moqEh///vfJUkff/yxPvjgA1133XWSqFMw0CO4/of79Z3rd4Nwvz5HBXsB7cHhw4dVV1en5ORkj+3Jycn65JNPgrSq0FJfX69p06bp6quvVr9+/SRJTqdTMTExSkxM9BibnJwsp9MZhFUGz/Lly7Vjxw5t27btlH3UqcFnn32mhQsXKj8/Xw888IC2bdume++9VzExMRo/fry7Ft5+DsOpTjNnzlR1dbXS09PVqVMn1dXV6fHHH9fYsWMliToFQbj3iHC//nN95/rdKNyvz4QK+MWUKVO0e/duffDBB8FeSsj58ssvNXXqVDkcDsXFxQV7OSGrvr5emZmZ+u1vfytJuvzyy7V7924tWrRI48ePD/LqQsef/vQnLV26VMuWLdMll1yijz76SNOmTVNKSgp1QlCE8/Wf63sDrt8Nwv36zMeffNC9e3d16tTplN/WUF5eLpvNFqRVhY68vDytXr1aGzZs0LnnnuvebrPZVFtbq8rKSo/x4Va30tJSVVRU6IorrlBUVJSioqK0adMmLViwQFFRUUpOTqZOks4++2z17dvXY1ufPn104MABSXLXItx/DqdPn66ZM2dqzJgx6t+/v26//Xbdd999KigokESdgiGce0S4X/+5vjfg+t0g3K/PhAofxMTEKCMjQ0VFRe5t9fX1Kioqkt1uD+LKgsuyLOXl5emtt97S+vXr1bt3b4/9GRkZio6O9qhbWVmZDhw4EFZ1GzJkiHbt2qWPPvrI/S8zM1Njx451/z91kq6++upTfiXl3//+d5133nmSpN69e8tms3nUqbq6Wlu3bg2rOh0/flyRkZ6X7k6dOqm+vl4SdQqGcOwRXP8bcH1vwPW7Qdhfn4P9TfH2Yvny5VZsbKy1ePFia+/evdbkyZOtxMREy+l0BntpQXP33XdbXbt2tTZu3Gh99dVX7n/Hjx93j7nrrrusXr16WevXr7e2b99u2e12y263B3HVoeGHvx3EsqiTZTX8OsaoqCjr8ccftz799FNr6dKlVnx8vLVkyRL3mCeeeMJKTEy0/vznP1t/+9vfrJtuuqnD/Co+X40fP94655xz3L+y8M0337S6d+9u/ed//qd7DHVqe+HWI7j+Ny0cr+9cvxuE+/WZUNECzz//vNWrVy8rJibGGjhwoLVly5ZgLymoJHn99+qrr7rHfP/999avfvUr66yzzrLi4+Otm2++2frqq6+Ct+gQ8eOmQ50avPPOO1a/fv2s2NhYKz093XrppZc89tfX11sPP/ywlZycbMXGxlpDhgyxysrKgrTa4KiurramTp1q9erVy4qLi7POP/9868EHH7RqamrcY6hTcIRTj+D637Rwvb5z/eb6HGFZP/gzfwAAAADQQnynAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgXgRxs3blRERIQ2btwY7KUAAEIMPQIdGaEC8MHixYsVERHh/hcXF6eLLrpIeXl5Ki8v98t9rFmzRo888ojP419++WUNHjxYycnJio2NVe/evTVhwgR9/vnnflkPAMA3odgjfsjlcqlv376KiIjQ008/7Zf1AD8WFewFAO3Jo48+qt69e+vEiRP64IMPtHDhQq1Zs0a7d+9WfHy80bHXrFmjwsJCn5vGzp071bt3b914440666yztH//fr388stavXq1Pv74Y6WkpBitBwDQMqHUI37o+eef14EDB4zuHzgdQgXQAtddd50yMzMlSb/4xS/UrVs3Pfvss/rzn/+s3NzcNl3Liy++eMq2kSNHKjMzU6+//rpmzpzZpusBgHAXSj2iUUVFhR599FHNmDFDs2fPDsoaEB74+BNg4Nprr5Uk7d+/v9lxK1euVEZGhjp37qzu3bvrtttu08GDB93777jjDhUWFkqSx1voLZWWliZJqqysbPFcAIB/hUKPmDlzpi6++GLddtttrTwLwDe8UwEY+Oc//ylJ6tatW5NjFi9erAkTJujKK69UQUGBysvLNX/+fH344YfauXOnEhMT9ctf/lKHDh2Sw+HQH//4xxat4ZtvvlFdXZ0OHDigRx99VJI0ZMiQ1p8UAMAvgt0jSkpK9Nprr+mDDz5o1QtVQEsQKoAWqKqq0uHDh3XixAl9+OGHevTRR9W5c2fdcMMNXse7XC7NmDFD/fr10/vvv6+4uDhJ0jXXXKMbbrhBzz33nObOnSu73a6LLrpIDoejxa8mnXPOOaqpqZHU0LgWLFigoUOHmp0oAKDFQqlHWJale+65R7feeqvsdju/xAMBR6gAWiA7O9vj9nnnnaelS5fqnHPO8Tp++/btqqio0COPPOJuFpI0YsQIpaen691339XcuXON1vTee+/pxIkT2rdvn5YsWaJjx44ZHQ8A0Dqh1CMWL16sXbt26Y033mjVfKClCBVACxQWFuqiiy5SVFSUkpOTdfHFFysysumvJn3xxReSpIsvvviUfenp6frggw+M1/TTn/5UUsMXBG+66Sb169dPXbp0UV5envGxAQC+C5UeUV1drVmzZmn69OlKTU1t1TGAliJUAC0wcOBA92/2CEUXXHCBLr/8ci1dupRQAQBtLFR6xNNPP63a2lrdeuut7o89/d///Z8k6dtvv9Xnn3+ulJQUxcTEBHGV6Gj47U9AAJ133nmSpLKyslP2lZWVufdL8tuX6L7//ntVVVX55VgAgMAJVI84cOCAvv32W11yySXq3bu3evfurX//93+XJP32t79V7969tXfvXsPVA54IFUAAZWZmqmfPnlq0aJH7y9RSw/cg9u3bpxEjRri3nXHGGZJ8+3WwJ0+e1LfffnvK9pKSEu3atSskXikDADQvUD3i3nvv1VtvveXx77/+678kNfx62rfeeku9e/f278kg7PHxJyCAoqOj9eSTT2rChAkaPHiwcnNz3b8uMC0tTffdd597bEZGhqSGZpCTk6NOnTppzJgxXo/73XffKTU1VbfeeqsuueQSnXHGGdq1a5deffVVde3aVQ8//HCbnB8AoPUC1SOuuOIKXXHFFR7bGj8Gdckll2jkyJEBOR+EN0IFEGB33HGH4uPj9cQTT2jGjBk644wzdPPNN+vJJ59UYmKie9wtt9yie+65R8uXL9eSJUtkWVaTDSM+Pl6/+MUvtGHDBr3xxhv6/vvvlZKSotzcXD300EPuP4IHAAhtgegRQDBEWJZlBXsRAAAAANovvlMBAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADASln/8rr6+XocOHdKZZ56piIiIYC8HAILKsiwdPXpUKSkpiowM79ea6A8A4MnXHhGWoeLQoUNKTU0N9jIAIKR8+eWXOvfcc4O9jKCiPwCAd6frEWEZKs4880xJDcVJSEho0VyXy6V169Zp2LBhio6ODsTyOjTqZ4b6maF+3lVXVys1NdV9bQxn9Ifgo47+Qy39I9zr6GuPCMtQ0fiWdkJCQquaRnx8vBISEsLyiWWK+pmhfmaoX/P4uA/9IRRQR/+hlv5BHRucrkeE94dnAQAAABgjVAAAAAAwQqgAAAAAYIRQAQAAAMAIoQIAAACAEUIFAAAAACOECgAAAABGCBUAAAAAjBAqAAAAABghVAAAAAAwQqgAAAAAYIRQAQAAAMAIoQIAAACAEUIFAAAAACOECgAAAABGCBUAAAAAjBAqAAAAABghVAAAAAAwQqgAAAAAYIRQAQAAAMAIoQIAAACAEUIFAAAAACOECgAAAABGCBUAAAAAjBAqAAAAABghVAAAAAAwQqgAAAAAYIRQAQAAAMAIoQIAAACAEUIFAAAAACOECgAAAABGCBUAAAAAjBAqAAAAABghVAAAAAAwQqgAAAAAYIRQAQAAAMAIoQIAAACAEUIFAAAAACMBDxWFhYVKS0tTXFycsrKyVFJS0uz4lStXKj09XXFxcerfv7/WrFnT5Ni77rpLERERmjdvnp9XDQBoC/QIAOgYAhoqVqxYofz8fM2ZM0c7duzQZZddppycHFVUVHgdv3nzZuXm5mrixInauXOnRo4cqZEjR2r37t2njH3rrbe0ZcsWpaSkBPIUAAABQo8AgI4joKHi2Wef1aRJkzRhwgT17dtXixYtUnx8vF555RWv4+fPn6/hw4dr+vTp6tOnjx577DFdccUVeuGFFzzGHTx4UPfcc4+WLl2q6OjoQJ4CACBA6BEA0HFEBerAtbW1Ki0t1axZs9zbIiMjlZ2dreLiYq9ziouLlZ+f77EtJydHq1atct+ur6/X7bffrunTp+uSSy7xaS01NTWqqalx366urpYkuVwuuVwuX0/JPeeH/0XLUD8z1M8M9fMuGPUIlR5Bfwg91NF/qKV/hHsdfT3vgIWKw4cPq66uTsnJyR7bk5OT9cknn3id43Q6vY53Op3u208++aSioqJ07733+ryWgoICzZ0795Tt69atU3x8vM/H+SGHw9GqeWhA/cxQPzPUz9Px48fb/D5DpUfQH0IXdfQfaukf4VpHX3tEwEJFIJSWlmr+/PnasWOHIiIifJ43a9Ysj1e3qqurlZqaqmHDhikhIaFFa3C5XHI4HBo6dChvq7cC9TND/cxQP+8aX51v71rTI+gPoYc6+g+19I9wr6OvPSJgoaJ79+7q1KmTysvLPbaXl5fLZrN5nWOz2Zod/9e//lUVFRXq1auXe39dXZ3uv/9+zZs3T59//rnX48bGxio2NvaU7dHR0a1+cpjMBfUzRf3MUD9PwahFqPQI+kPooo7+Qy39I1zr6Os5B+yL2jExMcrIyFBRUZF7W319vYqKimS3273OsdvtHuOlhreaGsfffvvt+tvf/qaPPvrI/S8lJUXTp0/XX/7yl0CdCgDAz+gRANCxBPTjT/n5+Ro/frwyMzM1cOBAzZs3T8eOHdOECRMkSePGjdM555yjgoICSdLUqVM1ePBgPfPMMxoxYoSWL1+u7du366WXXpIkdevWTd26dfO4j+joaNlsNl188cWBPBUAgJ/RIwCg4whoqLj11lv19ddfa/bs2XI6nRowYIDWrl3r/qLdgQMHFBn5rzdLrrrqKi1btkwPPfSQHnjgAV144YVatWqV+vXrF8hlAgCCgB4BAB1HwL+onZeXp7y8PK/7Nm7ceMq20aNHa/To0T4fv6nvUQAAQh89AgA6hoD+8TsAAAAAHR+hAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwEjAQ0VhYaHS0tIUFxenrKwslZSUNDt+5cqVSk9PV1xcnPr37681a9a497lcLs2YMUP9+/fXGWecoZSUFI0bN06HDh0K9GkAAAKAHgEAHUNAQ8WKFSuUn5+vOXPmaMeOHbrsssuUk5OjiooKr+M3b96s3NxcTZw4UTt37tTIkSM1cuRI7d69W5J0/Phx7dixQw8//LB27NihN998U2VlZbrxxhsDeRoAgACgRwBAB2IF0MCBA60pU6a4b9fV1VkpKSlWQUGB1/E///nPrREjRnhsy8rKsn75y182eR8lJSWWJOuLL77weV1VVVWWJKuqqsrnOY1qa2utVatWWbW1tS2eC+pnivqZoX7emVwTTYRij6A/BB919B9q6R/hXkdfr4tRgQortbW1Ki0t1axZs9zbIiMjlZ2dreLiYq9ziouLlZ+f77EtJydHq1atavJ+qqqqFBERocTExCbH1NTUqKamxn27urpaUsNb5S6Xy4ez+ZfG8S2dhwbUzwz1M0P9vAtGPUKlR9AfQg919B9q6R/hXkdfzztgoeLw4cOqq6tTcnKyx/bk5GR98sknXuc4nU6v451Op9fxJ06c0IwZM5Sbm6uEhIQm11JQUKC5c+eesn3dunWKj48/3al45XA4WjUPDaifGepnhvp5On78eJvfZ6j0CPpD6KKO/kMt/SNc6+hrjwhYqAg0l8uln//857IsSwsXLmx27KxZszxe3aqurlZqaqqGDRvWbBhp6n4dDoeGDh2q6OjoVq09nFE/M9TPDPXzrvHV+Y7E1x5Bfwg91NF/qKV/hHsdfe0RAQsV3bt3V6dOnVReXu6xvby8XDabzescm83m0/jGZvHFF19o/fr1p73wx8bGKjY29pTt0dHRrX5ymMwF9TNF/cxQP0/BqEWo9Aj6Q+iijv5DLf0jXOvo6zkH7Lc/xcTEKCMjQ0VFRe5t9fX1Kioqkt1u9zrHbrd7jJca3mr64fjGZvHpp5/qf//3f9WtW7fAnAAAIGDoEQDQsQT040/5+fkaP368MjMzNXDgQM2bN0/Hjh3ThAkTJEnjxo3TOeeco4KCAknS1KlTNXjwYD3zzDMaMWKEli9fru3bt+ull16S1NAs/uM//kM7duzQ6tWrVVdX5/4sbVJSkmJiYgJ5OgAAP6JHAEDHEdBQceutt+rrr7/W7Nmz5XQ6NWDAAK1du9b9RbsDBw4oMvJfb5ZcddVVWrZsmR566CE98MADuvDCC7Vq1Sr169dPknTw4EG9/fbbkqQBAwZ43NeGDRv0k5/8JJCnAwDwI3oEAHQcAf+idl5envLy8rzu27hx4ynbRo8erdGjR3sdn5aWJsuy/Lk8AEAQ0SMAoGMI6F/UBgAAANDxESoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMBDxUFBYWKi0tTXFxccrKylJJSUmz41euXKn09HTFxcWpf//+WrNmjcd+y7I0e/ZsnX322ercubOys7P16aefBvIU3OrqLZXsPyJJKtl/RHX1VpvcLwBz/v75rau3VPzPb/Tnjw6q+J/fBPx4pvtDVUfpEf54foXCYxgKazDVEc6ho+CxCA1t9ThEBeSo/8+KFSuUn5+vRYsWKSsrS/PmzVNOTo7KysrUs2fPU8Zv3rxZubm5Kigo0A033KBly5Zp5MiR2rFjh/r16ydJeuqpp7RgwQK99tpr6t27tx5++GHl5ORo7969iouLC9i5rN39lea+s1dHvvteTw2U7nxtm5K6dNacn/XV8H5nB+x+AZjz989v4/G+qjrh3nZ217iAHc90f6jqKD3CH8+vUHgMQ2ENpjrCOXQUPBahoS0fhwjLsgIWG7OysnTllVfqhRdekCTV19crNTVV99xzj2bOnHnK+FtvvVXHjh3T6tWr3dsGDRqkAQMGaNGiRbIsSykpKbr//vv161//WpJUVVWl5ORkLV68WGPGjPFpXdXV1eratauqqqqUkJBw2vFrd3+lu5fskCUptpOlpwbW6T9LOqm2LkKStPC2K/gB8ZHL5dKaNWt0/fXXKzo6OtjLaXeoX8v5++f3h8f7oYj/919/H2/y/9dbL72/v9X7fVlPS6+J/hKKPSIY/cHfz6nWCIU1NGrtdS6UziFUBKtndLTHor32Xn89Dr5eFwP28afa2lqVlpYqOzv7X3cWGans7GwVFxd7nVNcXOwxXpJycnLc4/fv3y+n0+kxpmvXrsrKymrymKbq6i3NfWfvKQ+IJPe2ue/s5S09IAT5++e3rY9nSXr5r6cGBl/3t3Q9bakj9Ah/PB9CoceEwhpMdYRz6Ch4LEJDMB6HgH386fDhw6qrq1NycrLH9uTkZH3yySde5zidTq/jnU6ne3/jtqbGeFNTU6Oamhr37erqakkNydPlcjV7HiX7j+jId98rtlPD7dhIy+O/knTku++15R8VGtg7qdljQe56n67u8I76tYy/f35/fDxv/H08U76sJxjPp1DpEcHuD/5+TrVGKKzhh1pznQu1cwgVwegZHfGxaI+915+Pg6/nHdDvVISKgoICzZ0795Tt69atU3x8/GnnPzXw1G2PZdZ73D68b4vW7Gv1EsOOw+EI9hLaNernO3///Ho73o/5+3imTree48ePB34RISoU+oO/n1OtEQpr+LGWXudC8RxCRVv3jI76WLS33uuvx8HXHhGwUNG9e3d16tRJ5eXlHtvLy8tls9m8zrHZbM2Ob/xveXm5zj77bI8xAwYMaHIts2bNUn5+vvt2dXW1UlNTNWzYsNN+ZrZk/xHd+do29+3YSEuPZdbr4e2RqqmPcG9/ZfyV7SZxB5PL5ZLD4dDQoUPb1ecSQwX1axl///z++HhN8ffxTJ1uPY2vzrelUOkRwe4P/n5OtUYorOGHWnOdC7VzCBXB6Bkd8bFoj73Xn4+Drz0iYKEiJiZGGRkZKioq0siRIyU1fAmvqKhIeXl5XufY7XYVFRVp2rRp7m0Oh0N2u12S1Lt3b9lsNhUVFbkbRHV1tbZu3aq77767ybXExsYqNjb2lO3R0dGnfXIM+reeSurSWc6qEx6fS6upj1BNXYQiJNm6xmnQv/VUp8iIpg6DH/Gl9mga9fONv39+mzpeI38fT5IiIyTLUqv2+7qeYDyXQqVHBLs/+Ps51RqhsAZvWnKdC9VzCBVt2TM68mPRnnqvPx8HX885oH+nIj8/Xy+//LJee+017du3T3fffbeOHTumCRMmSJLGjRunWbNmucdPnTpVa9eu1TPPPKNPPvlEjzzyiLZv3+5uMBEREZo2bZp+85vf6O2339auXbs0btw4paSkuJuSv3WKjNCcn/VtuP8f7Wu8PednfdvdDwYQDvz989vWx4uQNOnfe7d6f0vX09bae4/wx/MhFHpMKKzBVEc4h46CxyI0BONxCGiouPXWW/X0009r9uzZGjBggD766COtXbvW/SW6AwcO6KuvvnKPv+qqq7Rs2TK99NJLuuyyy/TGG29o1apV7t8/Lkn/+Z//qXvuuUeTJ0/WlVdeqe+++05r164N6N+oGN7vbC287QrZunreh61rXLv7tWhAuPH3z29bH2/W9X2N9ofy9akj9Ah/PB9CoceEwhpMdYRz6Ch4LEJDWz8OAf07FaGqtb+Tva7e0pZ/VOjwvi3q3mdQu3zrLtja6+96DhXUr/X8/fPb+BeUK46eUM8z4zSwd1JAj2e6vznB+jsVoSiY/cHfz6nWCIU1mF7nQuEcQkWwe0ZHeSyCXUdTpo+Dr9fFsPjtT/7SKTJCA3snac0+tdsfDCBc+fvnt1NkhOwXdPPT6k5/PNP9CCx/PL9C4TEMhTWY6gjn0FHwWISGtnocAvrxJwAAAAAdH6ECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGAkYKHiyJEjGjt2rBISEpSYmKiJEyfqu+++a3bOiRMnNGXKFHXr1k1dunTRqFGjVF5e7t7/8ccfKzc3V6mpqercubP69Omj+fPnB+oUAAABQo8AgI4lYKFi7Nix2rNnjxwOh1avXq33339fkydPbnbOfffdp3feeUcrV67Upk2bdOjQId1yyy3u/aWlperZs6eWLFmiPXv26MEHH9SsWbP0wgsvBOo0AAABQI8AgI4lKhAH3bdvn9auXatt27YpMzNTkvT888/r+uuv19NPP62UlJRT5lRVVekPf/iDli1bpmuvvVaS9Oqrr6pPnz7asmWLBg0apDvvvNNjzvnnn6/i4mK9+eabysvLC8SpAAD8jB4BAB1PQN6pKC4uVmJiortZSFJ2drYiIyO1detWr3NKS0vlcrmUnZ3t3paenq5evXqpuLi4yfuqqqpSUlKS/xYPAAgoegQAdDwBeafC6XSqZ8+enncUFaWkpCQ5nc4m58TExCgxMdFje3JycpNzNm/erBUrVujdd99tdj01NTWqqalx366urpYkuVwuuVyu052Oh8bxLZ2HBtTPDPUzQ/28a+t6hFKPoD+EHuroP9TSP8K9jr6ed4tCxcyZM/Xkk082O2bfvn0tOWSr7d69WzfddJPmzJmjYcOGNTu2oKBAc+fOPWX7unXrFB8f36r7dzgcrZqHBtTPDPUzQ/08HT9+3C/HaY89gv4Quqij/1BL/wjXOvraI1oUKu6//37dcccdzY45//zzZbPZVFFR4bH95MmTOnLkiGw2m9d5NptNtbW1qqys9Hglqry8/JQ5e/fu1ZAhQzR58mQ99NBDp133rFmzlJ+f775dXV2t1NRUDRs2TAkJCaed/0Mul0sOh0NDhw5VdHR0i+aC+pmifmaon3eNr86bao89gv4Qeqij/1BL/wj3OvraI1oUKnr06KEePXqcdpzdbldlZaVKS0uVkZEhSVq/fr3q6+uVlZXldU5GRoaio6NVVFSkUaNGSZLKysp04MAB2e1297g9e/bo2muv1fjx4/X444/7tO7Y2FjFxsaesj06OrrVTw6TuaB+pqifGernyV+1aI89gv4Quqij/1BL/wjXOvp6zgH5onafPn00fPhwTZo0SSUlJfrwww+Vl5enMWPGuH+rx8GDB5Wenq6SkhJJUteuXTVx4kTl5+drw4YNKi0t1YQJE2S32zVo0CBJDW9n//SnP9WwYcOUn58vp9Mpp9Opr7/+OhCnAQAIAHoEAHQ8AfmitiQtXbpUeXl5GjJkiCIjIzVq1CgtWLDAvd/lcqmsrMzjc1rPPfece2xNTY1ycnL04osvuve/8cYb+vrrr7VkyRItWbLEvf28887T559/HqhTAQD4GT0CADqWgIWKpKQkLVu2rMn9aWlpsizLY1tcXJwKCwtVWFjodc4jjzyiRx55xJ/LBAAEAT0CADqWgP1FbQAAAADhgVABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwEjAQsWRI0c0duxYJSQkKDExURMnTtR3333X7JwTJ05oypQp6tatm7p06aJRo0apvLzc69hvvvlG5557riIiIlRZWRmAMwAABAo9AgA6loCFirFjx2rPnj1yOBxavXq13n//fU2ePLnZOffdd5/eeecdrVy5Ups2bdKhQ4d0yy23eB07ceJEXXrppYFYOgAgwOgRANCxBCRU7Nu3T2vXrtXvf/97ZWVl6ZprrtHzzz+v5cuX69ChQ17nVFVV6Q9/+IOeffZZXXvttcrIyNCrr76qzZs3a8uWLR5jFy5cqMrKSv36178OxPIBAAFEjwCAjicqEActLi5WYmKiMjMz3duys7MVGRmprVu36uabbz5lTmlpqVwul7Kzs93b0tPT1atXLxUXF2vQoEGSpL179+rRRx/V1q1b9dlnn/m0npqaGtXU1LhvV1dXS5JcLpdcLleLzq1xfEvnoQH1M0P9zFA/79q6HqHUI+gPoYc6+g+19I9wr6Ov5x2QUOF0OtWzZ0/PO4qKUlJSkpxOZ5NzYmJilJiY6LE9OTnZPaempka5ubn63e9+p169evkcKgoKCjR37txTtq9bt07x8fE+HePHHA5Hq+ahAfUzQ/3MUD9Px48fb9P7C6UeQX8IXdTRf6ilf4RrHX3tES0KFTNnztSTTz7Z7Jh9+/a15JAtMmvWLPXp00e33XZbi+fl5+e7b1dXVys1NVXDhg1TQkJCi47lcrnkcDg0dOhQRUdHt2guqJ8p6meG+nnX+Oq8qfbYI+gPoYc6+g+19I9wr6OvPaJFoeL+++/XHXfc0eyY888/XzabTRUVFR7bT548qSNHjshms3mdZ7PZVFtbq8rKSo9XosrLy91z1q9fr127dumNN96QJFmWJUnq3r27HnzwQa+vNklSbGysYmNjT9keHR3d6ieHyVxQP1PUzwz18+SvWrTHHkF/CF3U0X+opX+Eax19PecWhYoePXqoR48epx1nt9tVWVmp0tJSZWRkSGq42NfX1ysrK8vrnIyMDEVHR6uoqEijRo2SJJWVlenAgQOy2+2SpP/5n//R999/756zbds23XnnnfrrX/+qCy64oCWnAgDwM3oEAISvgHynok+fPho+fLgmTZqkRYsWyeVyKS8vT2PGjFFKSook6eDBgxoyZIhef/11DRw4UF27dtXEiROVn5+vpKQkJSQk6J577pHdbnd/Ae/HTeHw4cPu+/vx52wBAKGJHgEAHU9AQoUkLV26VHl5eRoyZIgiIyM1atQoLViwwL3f5XKprKzM48sfzz33nHtsTU2NcnJy9OKLLwZqiQCAIKFHAEDHErBQkZSUpGXLljW5Py0tzf1510ZxcXEqLCxUYWGhT/fxk5/85JRjAABCHz0CADqWgP1FbQAAAADhgVABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEYIFQAAAACMECoAAAAAGCFUAAAAADBCqAAAAABghFABAAAAwAihAgAAAIARQgUAAAAAI4QKAAAAAEaigr2AYLAsS5JUXV3d4rkul0vHjx9XdXW1oqOj/b20Do/6maF+Zqifd43XwsZrYzijPwQfdfQfaukf4V5HX3tEWIaKo0ePSpJSU1ODvBIACB1Hjx5V165dg72MoKI/AIB3p+sREVYYvjRVX1+vQ4cO6cwzz1RERESL5lZXVys1NVVffvmlEhISArTCjov6maF+Zqifd5Zl6ejRo0pJSVFkZHh/Kpb+EHzU0X+opX+Eex197RFh+U5FZGSkzj33XKNjJCQkhOUTy1+onxnqZ4b6nSrc36FoRH8IHdTRf6ilf4RzHX3pEeH9khQAAAAAY4QKAAAAAEYIFS0UGxurOXPmKDY2NthLaZeonxnqZ4b6IZB4fvkHdfQfaukf1NE3YflFbQAAAAD+wzsVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUNEChYWFSktLU1xcnLKyslRSUhLsJYWkgoICXXnllTrzzDPVs2dPjRw5UmVlZR5jTpw4oSlTpqhbt27q0qWLRo0apfLy8iCtOLQ98cQTioiI0LRp09zbqF/zDh48qNtuu03dunVT586d1b9/f23fvt2937IszZ49W2effbY6d+6s7Oxsffrpp0FcMToCekTz3n//ff3sZz9TSkqKIiIitGrVKo/9vvxcHjlyRGPHjlVCQoISExM1ceJEfffdd214FsHnrx574MABjRgxQvHx8erZs6emT5+ukydPtuWpBNXChQt16aWXuv+gnd1u13vvvefeTw1bjlDhoxUrVig/P19z5szRjh07dNlllyknJ0cVFRXBXlrI2bRpk6ZMmaItW7bI4XDI5XJp2LBhOnbsmHvMfffdp3feeUcrV67Upk2bdOjQId1yyy1BXHVo2rZtm/7rv/5Ll156qcd26te0b7/9VldffbWio6P13nvvae/evXrmmWd01llnucc89dRTWrBggRYtWqStW7fqjDPOUE5Ojk6cOBHElaM9o0ec3rFjx3TZZZepsLDQ635ffi7Hjh2rPXv2yOFwaPXq1Xr//fc1efLktjqFkOCPHltXV6cRI0aotrZWmzdv1muvvabFixdr9uzZwTiloDj33HP1xBNPqLS0VNu3b9e1116rm266SXv27JFEDVvFgk8GDhxoTZkyxX27rq7OSklJsQoKCoK4qvahoqLCkmRt2rTJsizLqqystKKjo62VK1e6x+zbt8+SZBUXFwdrmSHn6NGj1oUXXmg5HA5r8ODB1tSpUy3Lon6nM2PGDOuaa65pcn99fb1ls9ms3/3ud+5tlZWVVmxsrPXf//3fbbFEdED0iJaRZL311lvu2778XO7du9eSZG3bts095r333rMiIiKsgwcPttnaQ01reuyaNWusyMhIy+l0uscsXLjQSkhIsGpqatr2BELIWWedZf3+97+nhq3EOxU+qK2tVWlpqbKzs93bIiMjlZ2dreLi4iCurH2oqqqSJCUlJUmSSktL5XK5POqZnp6uXr16Uc8fmDJlikaMGOFRJ4n6nc7bb7+tzMxMjR49Wj179tTll1+ul19+2b1///79cjqdHvXr2rWrsrKyqB9ahR5hzpefy+LiYiUmJiozM9M9Jjs7W5GRkdq6dWubrzlUtKbHFhcXq3///kpOTnaPycnJUXV1tfuV+nBSV1en5cuX69ixY7Lb7dSwlQgVPjh8+LDq6uo8njiSlJycLKfTGaRVtQ/19fWaNm2arr76avXr10+S5HQ6FRMTo8TERI+x1PNfli9frh07dqigoOCUfdSveZ999pkWLlyoCy+8UH/5y1909913695779Vrr70mSe4a8fMMf6FHmPPl59LpdKpnz54e+6OiopSUlBS2dW5tj3U6nV5r3bgvXOzatUtdunRRbGys7rrrLr311lvq27cvNWylqGAvAB3blClTtHv3bn3wwQfBXkq78eWXX2rq1KlyOByKi4sL9nLanfr6emVmZuq3v/2tJOnyyy/X7t27tWjRIo0fPz7IqwMA/6HHmrn44ov10UcfqaqqSm+88YbGjx+vTZs2BXtZ7RbvVPige/fu6tSp0ynf+i8vL5fNZgvSqkJfXl6eVq9erQ0bNujcc891b7fZbKqtrVVlZaXHeOrZoLS0VBUVFbriiisUFRWlqKgobdq0SQsWLFBUVJSSk5OpXzPOPvts9e3b12Nbnz59dODAAUly14ifZ/gLPcKcLz+XNpvtlC++nzx5UkeOHAnLOpv0WJvN5rXWjfvCRUxMjP7t3/5NGRkZKigo0GWXXab58+dTw1YiVPggJiZGGRkZKioqcm+rr69XUVGR7HZ7EFcWmizLUl5ent566y2tX79evXv39tifkZGh6Ohoj3qWlZXpwIED1FPSkCFDtGvXLn300Ufuf5mZmRo7dqz7/6lf066++upTfr3i3//+d5133nmSpN69e8tms3nUr7q6Wlu3bqV+aBV6hDlffi7tdrsqKytVWlrqHrN+/XrV19crKyurzdccLP7osXa7Xbt27fIIaQ6HQwkJCae8KBNO6uvrVVNTQw1bK9jfFG8vli9fbsXGxlqLFy+29u7da02ePNlKTEz0+NY/Gtx9991W165drY0bN1pfffWV+9/x48fdY+666y6rV69e1vr1663t27dbdrvdstvtQVx1aPvhb3+yLOrXnJKSEisqKsp6/PHHrU8//dRaunSpFR8fby1ZssQ95oknnrASExOtP//5z9bf/vY366abbrJ69+5tff/990FcOdozesTpHT161Nq5c6e1c+dOS5L17LPPWjt37rS++OILy7J8+7kcPny4dfnll1tbt261PvjgA+vCCy+0cnNzg3VKQeGPHnvy5EmrX79+1rBhw6yPPvrIWrt2rdWjRw9r1qxZwTiloJg5c6a1adMma//+/dbf/vY3a+bMmVZERIS1bt06y7KoYWsQKlrg+eeft3r16mXFxMRYAwcOtLZs2RLsJYUkSV7/vfrqq+4x33//vfWrX/3KOuuss6z4+Hjr5ptvtr766qvgLTrE/ThUUL/mvfPOO1a/fv2s2NhYKz093XrppZc89tfX11sPP/ywlZycbMXGxlpDhgyxysrKgrRadBT0iOZt2LDBa28YP368ZVm+/Vx+8803Vm5urtWlSxcrISHBmjBhgnX06NEgnE3w+KvHfv7559Z1111nde7c2erevbt1//33Wy6Xq43PJnjuvPNO67zzzrNiYmKsHj16WEOGDHEHCsuihq0RYVmW1dbvjgAAAADoOPhOBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAYIVQAAAAAMEKoAAAAAGCEUAEAAADACKECAAAAgBFCBQAAAAAjhAoAAAAARggVAAAAAIwQKgAAAAAY+f8BPRU9jXrhFMwAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 800x800 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import random\n",
+    "\n",
+    "sonify_idxs = random.sample(range(len(datasets)), 4) \n",
+    "\n",
+    "correct_one = sonify_idxs[random.randint(0, len(sonify_idxs) - 1)]\n",
+    "x_mode = \"spatial\" # gaps , spatial\n",
+    "y_mode = \"static\" # static , pitch\n",
+    "\n",
+    "sonify(datasets[correct_one][\"x\"],\n",
+    "        datasets[correct_one][\"y\"],\n",
+    "        x_mode=x_mode,\n",
+    "        y_mode=y_mode,\n",
+    "        save=\"test_audio.wav\"\n",
+    "        )\n",
+    "\n",
+    "plot_four(datasets, sonify_idxs, y_mode)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_four(datasets , sonify_idxs, y_mode, correct_one)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "tenv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

hrtf_vs_pitch.ipynb

@@ -0,0 +1,259 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Elevation vs Pitch Experiment\n",
+    "\n",
+    "The goal in this experiment is to compare the effectiveness of the `elevation` channel in spatial audio and the `pitch` channel.\n",
+    "\n",
+    "## Methodology\n",
+    "\n",
+    "- A set of graphs are sonified using `TOPH` in two distinct ways. The x-axis is always represent by the `azimuth` or left / right channel in the `SpatialPanner`.\n",
+    "- The y-axis is either represented by the `pitch` or the `elevation`.\n",
+    "\n",
+    "The user's are asked to identify the chart that coresponded with the sonification they heard from a set.\n",
+    "\n",
+    "The coresponding chart can be presented as a visual chart for non-BVI individuals, and screen reader descriptions for BVI individuals.\n",
+    "\n",
+    "I chose to implement the former below;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "    from toph.audio.playable import Chain,SineWave, Silence, Wave\n",
+    "    from toph.audio.spatial import SpatialPanner\n",
+    "    from toph.audio.stage import AudioStage\n",
+    "    from toph.axis.spatial import LinearSpatialAxis\n",
+    "\n",
+    "    import matplotlib.pyplot as plt\n",
+    "\n",
+    "    AUDIO_PATH = \"assets/ding.wav\"\n",
+    "\n",
+    "    def ax_gen(domain, range_):\n",
+    "\n",
+    "        do_scale = max(domain) - min(domain)\n",
+    "        ra_scale = max(range_) - min(range_)\n",
+    "\n",
+    "        def foo(dp):\n",
+    "\n",
+    "            dx = dp - min(domain) \n",
+    "            sdx = dx / do_scale \n",
+    "            return min(range_) + sdx * ra_scale \n",
+    "\n",
+    "        return foo\n",
+    "\n",
+    "    def sonify(xs, ys, mode, gaps=0.5, save=None):\n",
+    "        \"\"\"\n",
+    "        \"\"\"\n",
+    "        with AudioStage() as stage:\n",
+    "\n",
+    "            space_ax = LinearSpatialAxis(\n",
+    "                domain=((min(xs), max(xs)), (min(ys), max(ys))),\n",
+    "                range_=((-50.0, 50.0), (-45.0, 90.0)),\n",
+    "            )\n",
+    "\n",
+    "            #TODO: replace with linear axis when implemented\n",
+    "            lin_ax = ax_gen(\n",
+    "                domain=(min(ys), max(ys)),\n",
+    "                range_=(110, 880)\n",
+    "            )\n",
+    "\n",
+    "            marks = []\n",
+    "\n",
+    "            for x , y in zip(xs, ys):\n",
+    "                \n",
+    "                if mode == \"full_spatial\":\n",
+    "\n",
+    "                    r, az, el = space_ax((x, y)) \n",
+    "\n",
+    "                    marks.extend([\n",
+    "                            Wave(AUDIO_PATH).add_effect(SpatialPanner(az, el, r)),\n",
+    "                            Silence(secs = gaps)\n",
+    "                    ])\n",
+    "\n",
+    "                elif mode == \"pitch\":\n",
+    "\n",
+    "                    # keep the y as 0 to get a good r\n",
+    "                    r, az, el = space_ax((x, 0.))\n",
+    "                    freq = lin_ax(y)\n",
+    "\n",
+    "                    print(r, az, el, freq)\n",
+    "                    marks.extend([\n",
+    "                            SineWave(vol = 0.85, f = freq, secs=0.5).add_effect(SpatialPanner(az, 0. , r)),\n",
+    "                            Silence(secs = gaps)\n",
+    "                    ])\n",
+    "\n",
+    "                elif mode == \"both\":\n",
+    "                    # keep the y as 0 to get a good r\n",
+    "                    r, az, el = space_ax((x, y))\n",
+    "                    freq = lin_ax(y)\n",
+    "\n",
+    "                    marks.extend([\n",
+    "                            SineWave(vol = 0.85, f = freq, secs=0.5).add_effect(SpatialPanner(az, el , r)),\n",
+    "                            Silence(secs = gaps)\n",
+    "                    ])\n",
+    "\n",
+    "            if save:\n",
+    "                stage.save(Chain(*marks), save)\n",
+    "\n",
+    "            else:\n",
+    "                stage.play(Chain(*marks))\n",
+    "\n",
+    "    def plot_four(datasets, idxs, show_correct = None):\n",
+    "        fig, axes = plt.subplots(2, 2, figsize=(8, 8))\n",
+    "\n",
+    "        for i, ax in enumerate(axes.flat):\n",
+    "            ax.scatter(datasets[idxs[i]][\"x\"], datasets[idxs[i]][\"y\"])\n",
+    "            ax.set_title(f\"Plot {i + 1}\")\n",
+    "            ax.grid(True)\n",
+    "\n",
+    "            if show_correct is not None:\n",
+    "                for spine in ax.spines.values():\n",
+    "                    if idxs[i] == show_correct:\n",
+    "                            spine.set_linewidth(2)\n",
+    "                            spine.set_color(\"green\")\n",
+    "                    else:\n",
+    "                            spine.set_color(\"red\")\n",
+    "\n",
+    "\n",
+    "        plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datasets = [\n",
+    "    {\n",
+    "        \"x\":[0, 10, 30, 40, 90],\n",
+    "        \"y\":[10, 15, 20, 15, 10]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\":[0, 10, 20, 30, 40],\n",
+    "        \"y\":[10, 15, 20, 15, 10]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\":[0, 10, 20, 40, 80, 160],\n",
+    "        \"y\":[20, 15, 20, 15, 10, 5]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 5, 15, 30, 45, 60],\n",
+    "        \"y\": [12, 14, 19, 14, 11, 8]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 20, 40, 60, 80, 100],\n",
+    "        \"y\": [15, 20, 25, 20, 15, 10]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 15, 35, 55, 75, 95],\n",
+    "        \"y\": [10, 18, 16, 20, 15, 12]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 12, 25, 50, 75, 100],\n",
+    "        \"y\": [8, 12, 18, 22, 18, 10]\n",
+    "    },\n",
+    "    {\n",
+    "        \"x\": [0, 25, 50, 75, 100, 125],\n",
+    "        \"y\": [20, 18, 22, 18, 14, 10]\n",
+    "    }\n",
+    "]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ALSA lib pcm.c:2666:(snd_pcm_open_noupdate) Unknown PCM dsnoop:0\n",
+      "ALSA lib pcm_dmix.c:999:(snd_pcm_dmix_open) unable to open slave\n",
+      "ALSA lib pcm_oss.c:397:(_snd_pcm_oss_open) Cannot open device /dev/dsp\n",
+      "ALSA lib pcm_oss.c:397:(_snd_pcm_oss_open) Cannot open device /dev/dsp\n",
+      "ALSA lib confmisc.c:160:(snd_config_get_card) Invalid field card\n",
+      "ALSA lib pcm_usb_stream.c:482:(_snd_pcm_usb_stream_open) Invalid card 'card'\n",
+      "ALSA lib confmisc.c:160:(snd_config_get_card) Invalid field card\n",
+      "ALSA lib pcm_usb_stream.c:482:(_snd_pcm_usb_stream_open) Invalid card 'card'\n",
+      "ALSA lib pcm_dmix.c:999:(snd_pcm_dmix_open) unable to open slave\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import random\n",
+    "\n",
+    "sonify_idxs = random.sample(range(len(datasets)), 4) \n",
+    "\n",
+    "correct_one = sonify_idxs[random.randint(0, len(sonify_idxs) - 1)]\n",
+    "mode = \"both\" # full_spatial , pitch , both\n",
+    "sonify(datasets[correct_one][\"x\"],\n",
+    "        datasets[correct_one][\"y\"],\n",
+    "        mode=mode,\n",
+    "        save=\"test_audio.wav\"\n",
+    "        )\n",
+    "\n",
+    "plot_four(datasets, sonify_idxs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_four(datasets , sonify_idxs, correct_one)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "tenv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

hrtf_vs_pitch_sonifier.py

@@ -0,0 +1,105 @@
+import matplotlib.pyplot as plt
+
+from toph.audio.effect import SimplePanner
+from toph.audio.playable import Chain, Silence, SineWave, Wave
+from toph.audio.stage import AudioStage
+
+AUDIO_PATH = "assets/ding.wav"
+
+
+def ax_gen(domain, range_):
+
+    do_scale = max(domain) - min(domain)
+    ra_scale = max(range_) - min(range_)
+
+    def foo(dp):
+
+        dx = dp - min(domain)
+        sdx = dx / do_scale
+        return min(range_) + sdx * ra_scale
+
+    return foo
+
+
+def sonify(xs, ys, x_mode, y_mode, gaps=0.5, save=None):
+    """ """
+    with AudioStage(frame_rate=48000) as stage:
+
+        # TODO: replace with linear axis when implemented
+
+        lin_ax = ax_gen(domain=(min(xs), max(xs)), range_=(-1.0, +1.0))
+
+        pitch_ax = ax_gen(domain=(min(ys), max(ys)), range_=(110, 880))
+
+        x_deltas = [xs[idx + 1] - xs[idx] for idx in range(len(xs) - 1)]
+        x_deltas.append(0.0)
+
+        gap_ax = ax_gen(domain=(min(x_deltas), max(x_deltas)), range_=(0.25, 1.25))
+
+        marks = []
+
+        for idx, (x, y) in enumerate(zip(xs, ys)):
+
+            audio_src = (
+                Wave(AUDIO_PATH)
+                if y_mode == "static"
+                else SineWave(vol=0.85, f=pitch_ax(y), secs=0.5)
+            )
+            if x_mode == "spatial":
+
+                marks.extend(
+                    [
+                        audio_src.add_effect(SimplePanner(dir=lin_ax(x))),
+                        Silence(secs=gaps),
+                    ]
+                )
+
+            elif x_mode == "gaps":
+
+                marks.append(audio_src)
+                if x_deltas[idx] > 0.0:
+                    marks.append(Silence(secs=gap_ax(x_deltas[idx])))
+
+        if save:
+            stage.save(Chain(*marks), save)
+
+        else:
+            stage.play(Chain(*marks))
+
+
+def plot_four(datasets, idxs, y_mode, show_correct=None):
+    fig, axes = plt.subplots(2, 2, figsize=(8, 8))
+
+    for i, ax in enumerate(axes.flat):
+        ax.scatter(
+            datasets[idxs[i]]["x"],
+            (
+                datasets[idxs[i]]["y"]
+                if y_mode == "pitch"
+                else [0] * len(datasets[idxs[i]]["x"])
+            ),
+        )
+        ax.set_title(f"Plot {i + 1}")
+        ax.grid(True)
+
+        if show_correct is not None:
+            for spine in ax.spines.values():
+                if idxs[i] == show_correct:
+                    spine.set_linewidth(2)
+                    spine.set_color("green")
+                else:
+                    spine.set_color("red")
+
+    plt.tight_layout()
+
+
+datasets = [
+    {"x": [0, 10, 30, 40, 90], "y": [10, 15, 20, 15, 10]},
+    {"x": [0, 10, 20, 30, 40], "y": [10, 15, 20, 15, 10]},
+    {"x": [0, 10, 20, 40, 80, 160], "y": [20, 15, 20, 15, 10, 5]},
+    {"x": [0, 5, 15, 30, 45, 60], "y": [12, 14, 19, 14, 11, 8]},
+    {"x": [0, 20, 40, 60, 80, 100], "y": [15, 20, 25, 20, 15, 10]},
+    {"x": [0, 15, 35, 55, 75, 95], "y": [10, 18, 16, 20, 15, 12]},
+    {"x": [0, 12, 25, 50, 75, 100], "y": [8, 12, 18, 22, 18, 10]},
+    {"x": [0, 25, 50, 75, 100, 125], "y": [20, 18, 22, 18, 14, 10]},
+]

packages.txt

@@ -0,0 +1,2 @@
+libportaudio2
+portaudio19-dev

pages/common.py

@@ -0,0 +1,36 @@
+import uuid
+
+import streamlit as st
+from streamlit_extras.switch_page_button import switch_page
+
+
+# hide sidebar
+def hide_sidebar():
+    st.set_page_config(initial_sidebar_state="collapsed")
+
+    st.markdown(
+        """
+    <style>
+        [data-testid="stSidebarCollapsedControl"] {
+            display: none
+        }
+    </style>
+    """,
+        unsafe_allow_html=True,
+    )
+
+
+# Define a function to move to the next page
+pages = {2: "headphones", 3: "hrtf_selection", 4: "questions"}
+
+
+def next_page():
+    st.session_state.page += 1
+    switch_page(pages.get(st.session_state.page, "final"))
+
+
+def get_new_ref():
+    return str(uuid.uuid4()).upper().split("-")[0]
+
+
+AUDIO_PATH = "assets/snare3.wav"

pages/contribute.py

@@ -0,0 +1,16 @@
+from pages.common import *
+
+hide_sidebar()
+# Page 1 - Collect Input
+st.write("### Page 2: Additional Information")
+st.write("Name:", st.session_state.user_data.get("name"))
+st.write("Age:", st.session_state.user_data.get("age"))
+
+occupation = st.text_input("Enter your occupation:")
+
+if st.button("Submit Page 2"):
+    # Save additional response and move to next page
+    st.session_state.user_data["occupation"] = occupation
+    next_page()
+
+# Page 3 - Final Page

pages/db.py

@@ -0,0 +1,25 @@
+import json
+
+import gspread
+from oauth2client.service_account import ServiceAccountCredentials
+
+# Define the scope and authenticate with the service account
+scope = [
+    "https://spreadsheets.google.com/feeds",
+    "https://www.googleapis.com/auth/drive",
+]
+json_key = json.loads(os.getenv("GKEY"),strict=False)
+credentials = ServiceAccountCredentials.from_json_keyfile_dict(json_key, scope)
+client = gspread.authorize(credentials)
+
+# Open the Google Sheet by name
+spreadsheet = client.open("Team 7 Data")
+worksheet = spreadsheet.sheet1  # Access the first sheet
+
+
+# Function to insert the JSON string into the first column
+def submit_json_to_sheets(json_data):
+    # Convert JSON data to string format
+    json_string = json.dumps(json_data)
+    # Append the JSON string as a new row with one cell in the first column
+    worksheet.append_row([json_string])

pages/final.py

@@ -0,0 +1,6 @@
+from pages.common import *
+
+hide_sidebar()
+
+st.write("# Thank you for completing our study!")
+st.write("Your data has been submitted!")

pages/headphones.py

@@ -0,0 +1,35 @@
+from pages.common import *
+
+hide_sidebar()
+
+st.write(
+    """- Thank you for joining our study. We just need to ask a few preliminary questions
+         to find the best **settings** for you!"""
+)
+
+st.write(
+    f"""- If you run into any issues or have any questions for the research team,
+         your reference number is **{st.session_state.user_data['ref_number']}**"""
+)
+
+st.write("# Headphones")
+
+st.write("For this part of study, we are mainly focusing on `in-ear` headpones")
+st.write("However, if you only have `over-the-ear` ones we still accept submissions.")
+
+st.write("**For reference:**")
+
+st.image("assets/images/headphone_types.png", width=400)
+
+
+headphones = st.selectbox("Headphone Type:", ("In-ear", "Over-the-ear"))
+
+age = st.number_input("Age:", min_value=9, max_value=99)
+sex = st.selectbox("Sex:", ("Male", "Female"))
+
+if st.button("Continue", type="primary"):
+    # Save responses in session state and move to next page
+    st.session_state.user_data["headphone_type"] = headphones
+    st.session_state.user_data["sex"] = sex
+    st.session_state.user_data["age"] = age
+    next_page()

pages/hrtf_selection.py

@@ -0,0 +1,95 @@
+import os
+
+from pages.common import *
+
+hide_sidebar()
+
+
+st.write(
+    """This is a study about using **Directional Audio** in data encoding. To simulate directional audio using headphones, we must find the appropriate **settings** for you."""
+)
+st.write(
+    """Listen to different settings by clicking the buttons. You should hear a sound coming from `behind` -> `above` -> `front and below`"""
+)
+
+st.write("""Pick the option that sounds the best to you""")
+
+sex = st.session_state.user_data["sex"]
+CIPIC_SUB_DIR = os.path.join("cipic_hrtf_database", sex.lower())
+
+
+import base64
+from io import BytesIO
+
+from scipy.io import wavfile
+
+import toph.audio.spatial
+from toph.audio.playable import Chain, Silence, SineWave, Wave
+from toph.audio.spatial import SpatialPanner
+from toph.audio.stage import AudioStage
+from toph.axis.spatial import LinearSpatialAxis
+
+
+def play_test_sequence(cipic_path):
+
+    with AudioStage() as stage:
+
+        toph.audio.spatial.CIPIC_BASE_PATH = cipic_path
+
+        seq = Chain(
+            Wave(AUDIO_PATH).add_effect(SpatialPanner(0.0, 180.0, 2.0)),
+            Silence(0.3),
+            Wave(AUDIO_PATH).add_effect(SpatialPanner(0.0, 90.0, 2.0)),
+            Silence(0.3),
+            Wave(AUDIO_PATH).add_effect(SpatialPanner(0.0, -44.0, 2.0)),
+            Silence(0.3),
+        )
+
+        arr = stage.get_ndarray(seq)
+        v_file = BytesIO()
+        wavfile.write(
+            v_file,
+            rate=stage.frame_rate,
+            # todo: handle formats other than int16, make it better
+            data=arr,
+        )
+        v_file.seek(0)
+        b64 = base64.b64encode(v_file.read()).decode()
+
+        md = f"""
+            <audio style='display: none' controls autoplay="true">
+            <source src="data:audio/wav;base64,{b64}" type="audio/wav">
+            Audio
+            </audio>
+            """
+
+        st.session_state.inc_int += 1
+        print(st.session_state.inc_int)
+
+        if st.session_state.inc_int % 2:
+            st.write(".")
+
+        st.markdown(
+            md,
+            unsafe_allow_html=True,
+        )
+
+        if st.session_state.inc_int % 2 == 0:
+            st.write(".")
+
+
+hrtfs = os.listdir(CIPIC_SUB_DIR)
+cols = st.columns(len(hrtfs))
+
+for idx, hrtf in enumerate(hrtfs):
+
+    hrtf_id = hrtf.split(".")[0]
+    btn = cols[idx].button(hrtf_id)
+
+    if btn:
+        play_test_sequence(os.path.join(CIPIC_SUB_DIR, hrtf))
+        st.session_state.user_data["hrtf_id"] = hrtf_id
+        st.write(f"Current selection: {hrtf_id}")
+
+if st.button("Continue", type="primary"):
+    next_page()

pages/questions.py

@@ -0,0 +1,134 @@
+from pages.common import *
+
+hide_sidebar()
+
+import os
+
+import matplotlib.pyplot as plt
+from pages.sonification_utils import (SONIFICATION_FUNCTIONS, get_audio_comp,
+                                      plot_four)
+
+last_example = getattr(st.session_state, "last_example", {})
+cur_q = st.session_state.question_idx
+cur_e = st.session_state.example_idx
+cur_u = st.session_state.user_pref_idx
+
+total = st.session_state.num_questions
+
+
+if cur_q + cur_e + cur_u < len(st.session_state.questions):
+    cur_data = st.session_state.questions[cur_q + cur_e + cur_u]
+else:  # questions are over submit and redirect to final screen
+    from pages.db import submit_json_to_sheets
+
+    submit_json_to_sheets(st.session_state.user_data)
+    next_page()
+
+prog = min((cur_q + 1) / total, 1.0)
+st.progress(prog, text=f"{cur_q}/{total}")
+
+
+print(st.session_state.user_data)
+
+if cur_data["ttype"] == "Example":
+
+    st.session_state.last_example = cur_data
+    st.write("# Example")
+    st.write(cur_data["explanation"])
+    # render the plot
+    plot_data = st.session_state.plots[cur_data["plot"]]
+
+    son_fn = SONIFICATION_FUNCTIONS[cur_data["sonify"]]
+
+    son_arr = son_fn(plot_data["x"], plot_data["y"], **cur_data["args"])
+
+    aud_comp = get_audio_comp(son_arr, 44100)
+
+    st.markdown(
+        aud_comp,
+        unsafe_allow_html=True,
+    )
+
+    # plot the example
+    fig, ax = plt.subplots()
+    ax.scatter(plot_data["x"], plot_data["y"], s=100)
+    ax.set_xlim([-0.2, 9.2])
+    ax.set_ylim([-0.05, 1.05])
+
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+    st.pyplot(fig)
+
+    btn_text = "Skip"
+
+    if st.button("Start", type="primary"):
+        st.session_state.example_idx += 1
+        switch_page("questions")
+
+elif cur_data["ttype"] == "user_preference":
+    st.write("# Preference Question")
+    st.write(cur_data["explanation"])
+
+    cols = st.columns(len(cur_data["options"]))
+
+    for idx, col in enumerate(cols):
+
+        if col.button(cur_data["options"][idx], type="primary"):
+            st.session_state.user_data[f"UserPref_{idx}"] = cur_data["options"][idx]
+            st.session_state.user_pref_idx += 1
+            switch_page("questions")
+
+
+else:
+    st.write("# Question")
+
+    fig = plot_four(
+        st.session_state.plots, cur_data["plots"], xlim=[-0.5, 9.5], ylim=[-0.05, 1.05]
+    )
+
+    st.pyplot(fig)
+
+    plot_data = st.session_state.plots[cur_data["answer"]]
+    # sonify the answer
+    son_fn = SONIFICATION_FUNCTIONS[last_example["sonify"]]
+    son_arr = son_fn(plot_data["x"], plot_data["y"], **last_example["args"])
+    aud_comp = get_audio_comp(son_arr, 44100, visible=False, autoplay=True)
+
+    play_count_idx = f"Q{cur_q}_PlayCount"
+
+    if play_count_idx not in st.session_state.user_data:
+        st.session_state.user_data[play_count_idx] = 0
+
+    if play_btn := st.button(
+        f"Play Audio (Only Once)", disabled=st.session_state.user_data[play_count_idx]
+    ):
+
+        st.session_state.inc_int += 1
+
+        if st.session_state.inc_int % 2:
+            st.write(".")
+
+        st.markdown(
+            aud_comp,
+            unsafe_allow_html=True,
+        )
+
+        if st.session_state.inc_int % 2 == 0:
+            st.write(".")
+
+    # answer stuff
+    if st.session_state.user_data[play_count_idx]:
+
+        cols = st.columns(4)
+        answer_idx = f"Q{cur_q}_Answer"
+        correct_idx = f"Q{cur_q}_Correct"
+        for idx, col in enumerate(cols):
+            if col.button(f"{idx+1}", type="primary"):
+                st.session_state.question_idx += 1
+                cplot = cur_data["plots"][idx]
+                st.session_state.user_data[answer_idx] = cplot
+                st.session_state.user_data[correct_idx] = cplot == cur_data["answer"]
+                switch_page("questions")
+
+    st.session_state.user_data[play_count_idx] += 1

pages/sonification_utils.py

@@ -0,0 +1,174 @@
+import base64
+from io import BytesIO
+
+import matplotlib.pyplot as plt
+from pages.common import AUDIO_PATH
+from scipy.io import wavfile
+
+from toph.audio.effect import SimplePanner
+from toph.audio.playable import Chain, Silence, SineWave, Wave
+from toph.audio.spatial import SpatialPanner
+from toph.audio.stage import AudioStage
+from toph.axis.spatial import LinearSpatialAxis
+
+
+def ax_gen(domain, range_):
+
+    do_scale = max(domain) - min(domain)
+    ra_scale = max(range_) - min(range_)
+
+    def foo(dp):
+
+        dx = dp - min(domain)
+        sdx = dx / do_scale
+        return min(range_) + sdx * ra_scale
+
+    return foo
+
+
+def sonify_y_ax(xs, ys, mode, gaps=0.5):
+    """ """
+    with AudioStage() as stage:
+
+        space_ax = LinearSpatialAxis(
+            domain=((min(xs), max(xs)), (min(ys), max(ys))),
+            range_=((-50.0, 50.0), (-45.0, 90.0)),
+        )
+
+        # TODO: replace with linear axis when implemented
+        lin_ax = ax_gen(domain=(min(ys), max(ys)), range_=(110, 880))
+
+        simple_lr_ax = ax_gen(domain=(min(xs), max(xs)), range_=(-0.98, +0.99))
+
+        marks = []
+
+        for x, y in zip(xs, ys):
+
+            if mode == "full_spatial":
+
+                r, az, el = space_ax((x, y))
+
+                marks.extend(
+                    [
+                        Wave(AUDIO_PATH).add_effect(SpatialPanner(az, el, r)),
+                        Silence(secs=gaps),
+                    ]
+                )
+
+            elif mode == "pitch":
+
+                # keep the y as 0 to get a good r
+                az = simple_lr_ax(x)
+                freq = lin_ax(y)
+
+                print(az, freq)
+                marks.extend(
+                    [
+                        SineWave(vol=0.25, f=freq, secs=0.5).add_effect(
+                            SimplePanner(dir=az)
+                        ),
+                        Silence(secs=gaps),
+                    ]
+                )
+
+            elif mode == "both":
+                # keep the y as 0 to get a good r
+                r, az, el = space_ax((x, y))
+                freq = lin_ax(y)
+
+                marks.extend(
+                    [
+                        SineWave(vol=0.85, f=freq, secs=0.5).add_effect(
+                            SpatialPanner(az, el, r)
+                        ),
+                        Silence(secs=gaps),
+                    ]
+                )
+
+        return stage.get_ndarray(Chain(*marks))
+
+
+def sonify_x_ax(xs, ys, x_mode, y_mode, gaps=0.5):
+    """ """
+    with AudioStage(frame_rate=48000) as stage:
+
+        # TODO: replace with linear axis when implemented
+
+        lin_ax = ax_gen(domain=(min(xs), max(xs)), range_=(-1.0, +1.0))
+
+        pitch_ax = ax_gen(domain=(min(ys), max(ys)), range_=(110, 880))
+
+        x_deltas = [xs[idx + 1] - xs[idx] for idx in range(len(xs) - 1)]
+        x_deltas.append(0.0)
+
+        gap_ax = ax_gen(domain=(min(x_deltas), max(x_deltas)), range_=(0.25, 1.25))
+
+        marks = []
+
+        for idx, (x, y) in enumerate(zip(xs, ys)):
+
+            audio_src = (
+                Wave(AUDIO_PATH)
+                if y_mode == "static"
+                else SineWave(vol=0.85, f=pitch_ax(y), secs=0.5)
+            )
+            if x_mode == "spatial":
+
+                marks.extend(
+                    [
+                        audio_src.add_effect(SimplePanner(dir=lin_ax(x))),
+                        Silence(secs=gaps),
+                    ]
+                )
+
+            elif x_mode == "gaps":
+
+                marks.append(audio_src)
+                if x_deltas[idx] > 0.0:
+                    marks.append(Silence(secs=gap_ax(x_deltas[idx])))
+
+        return stage.get_ndarray(Chain(*marks))
+
+
+def get_audio_comp(arr, frame_rate, visible=True, autoplay=False) -> str:
+    """Takes an audio array
+    returns an audio component
+    """
+    v_file = BytesIO()
+    wavfile.write(
+        v_file,
+        rate=frame_rate,
+        # todo: handle formats other than int16, make it better
+        data=arr,
+    )
+    v_file.seek(0)
+    b64 = base64.b64encode(v_file.read()).decode()
+
+    md = f"""<audio {"style='display: none'" if not visible else ''} controls {'autoplay="true"' if autoplay else ''}>
+        """
+    src = f"""<source src="data:audio/wav;base64,{b64}" type="audio/wav">"""
+
+    return md + src + "</audio>"
+
+
+SONIFICATION_FUNCTIONS = {"sonify_y_ax": sonify_y_ax, "sonify_x_ax": sonify_x_ax}
+
+
+def plot_four(datasets, idxs, xlim=None, ylim=None, s=75):
+    fig, axes = plt.subplots(2, 2, figsize=(8, 8))
+
+    for i, ax in enumerate(axes.flat):
+        ax.scatter(datasets[idxs[i]]["x"], datasets[idxs[i]]["y"], s=100)
+        ax.set_title(f"Option {i + 1}")
+        ax.grid(True)
+
+        if xlim:
+            ax.set_xlim(xlim)
+        if ylim:
+            ax.set_ylim(ylim)
+
+        ax.set_xticks([])
+        ax.set_yticks([])
+
+    plt.tight_layout()
+    return fig

requirements.txt

@@ -0,0 +1,6 @@
+git+https://github.com/CristiFati/pyaudio
+streamlit
+gspread
+oauth2client
+git+https://github.com/UlascanErsoy/Team-7---Multimodal-Accessibility@main#subdirectory=toph
+streamlit_extras

run_experiment.py

@@ -0,0 +1,48 @@
+from hrtf_vs_pitch_sonifier import *
+
+normal_color = 'black'
+hover_color = 'blue'
+
+# Store original colors to reset them after hover
+fig, axes = plt.subplots(2, 2, figsize=(8, 8))
+
+def is_inside_axes(event, ax):
+    return ax.get_position().contains(event.x, event.y)
+
+# Event handler for mouse movement
+def on_hover(event):
+    for ax in axes:
+        # Check if the cursor is inside the current subplot
+        if is_inside_axes(event, ax):
+            # Change color if inside
+            for spine in ax.spines.values():
+                spine.set_color(hover_color)
+        else:
+            # Reset to normal color if outside
+            for spine in ax.spines.values():
+                spine.set_color(normal_color)
+    
+    fig.canvas.draw_idle()  # Update the figure
+
+def run_test(datasets, idxs, y_mode, show_correct = None):
+    fig.canvas.mpl_connect('motion_notify_event', on_hover)
+
+    for i, ax in enumerate(axes.flat):
+        ax.scatter(datasets[idxs[i]]["x"], datasets[idxs[i]]["y"] if y_mode == "pitch" else [0] * len(datasets[idxs[i]]["x"]))
+        ax.set_title(f"Plot {i + 1}")
+        ax.grid(True)
+
+        if show_correct is not None:
+            for spine in ax.spines.values():
+                if idxs[i] == show_correct:
+                        spine.set_linewidth(2)
+                        spine.set_color("green")
+                else:
+                        spine.set_color("red")
+
+    plt.tight_layout()
+    plt.show()
+
+y_mode = "static"
+
+run_test(datasets, [0, 2, 3, 5], y_mode)

scatter_data/0.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    1.0,
+    0.47174803327853765,
+    0.2222194727796593,
+    0.1043505268463764,
+    0.04867317918065452,
+    0.02237306239803448,
+    0.00994976689674215,
+    0.0040814176271137355,
+    0.0013094057123391094,
+    0.0
+  ],
+  "description": "exp decrease (scale = 0.75)"
+}

scatter_data/1.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    1.0,
+    0.7527397438033054,
+    0.5601732626548834,
+    0.41020233634318737,
+    0.2934048614936946,
+    0.20244289662014694,
+    0.13160164714691436,
+    0.07643042658340408,
+    0.033463036805537104,
+    0.0
+  ],
+  "description": "exp decrease (scale = 0.25)"
+}

scatter_data/10.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    0.0,
+    0.5282519667214622,
+    0.7777805272203405,
+    0.8956494731536235,
+    0.9513268208193454,
+    0.9776269376019654,
+    0.9900502331032578,
+    0.9959185823728862,
+    0.9986905942876608,
+    1.0
+  ],
+  "description": "inv exp increase (scale = 0.75)"
+}

scatter_data/11.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    0.0,
+    0.24726025619669456,
+    0.4398267373451166,
+    0.5897976636568126,
+    0.7065951385063054,
+    0.7975571033798531,
+    0.8683983528530855,
+    0.9235695734165958,
+    0.9665369631944629,
+    1.0
+  ],
+  "description": "inv exp increase (scale = 0.25)"
+}

scatter_data/12.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    0.0,
+    0.033463036805537076,
+    0.07643042658340408,
+    0.13160164714691436,
+    0.2024428966201469,
+    0.2934048614936946,
+    0.4102023363431873,
+    0.5601732626548833,
+    0.7527397438033053,
+    1.0
+  ],
+  "description": "exp increase (scale = 0.25)"
+}

scatter_data/13.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    0.0,
+    0.0013094057123391096,
+    0.004081417627113735,
+    0.009949766896742152,
+    0.022373062398034483,
+    0.048673179180654516,
+    0.1043505268463764,
+    0.2222194727796593,
+    0.47174803327853765,
+    1.0
+  ],
+  "description": "exp increase (scale = 0.75)"
+}

scatter_data/14.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    0.0,
+    0.2,
+    0.2,
+    0.4,
+    0.4,
+    0.6,
+    0.6,
+    0.8,
+    0.8,
+    1.0
+  ],
+  "description": "Step increase (stepsize = 2)"
+}

scatter_data/15.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    0.0,
+    0.3333333333333333,
+    0.3333333333333333,
+    0.3333333333333333,
+    0.6666666666666666,
+    0.6666666666666666,
+    0.6666666666666666,
+    1.0,
+    1.0,
+    1.0
+  ],
+  "description": "Step increase (stepsize = 3)"
+}

scatter_data/16.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    1.0,
+    0.6666666666666666,
+    0.6666666666666666,
+    0.6666666666666666,
+    0.33333333333333337,
+    0.33333333333333337,
+    0.33333333333333337,
+    0.0,
+    0.0,
+    0.0
+  ],
+  "description": "Step decrease (stepsize = 3)"
+}

scatter_data/17.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    1.0,
+    0.8,
+    0.8,
+    0.6,
+    0.6,
+    0.4,
+    0.4,
+    0.19999999999999996,
+    0.19999999999999996,
+    0.0
+  ],
+  "description": "Step decrease (stepsize = 2)"
+}

scatter_data/2.json

@@ -0,0 +1,27 @@
+{
+  "x": [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+  ],
+  "y": [
+    1.0,
+    0.888888888888889,
+    0.7777777777777778,
+    0.6666666666666666,
+    0.5555555555555556,
+    0.4444444444444445,
+    0.33333333333333326,
+    0.22222222222222215,
+    0.11111111111111108,
+    0.0
+  ],
+  "description": "linear decrease"
+}