diff options
| author | adamjanovsky | 2023-10-01 20:47:17 +0200 |
|---|---|---|
| committer | adamjanovsky | 2023-10-01 20:47:17 +0200 |
| commit | 70330b2202f7f4abd99b36b7a3090e3edee6bb1b (patch) | |
| tree | cad522f67328f6c6639de51de40cf8eaba8a524d | |
| parent | ee00fb283d8c1685abdddcbf4e097ea6ca911f09 (diff) | |
| download | sec-certs-70330b2202f7f4abd99b36b7a3090e3edee6bb1b.tar.gz sec-certs-70330b2202f7f4abd99b36b7a3090e3edee6bb1b.tar.zst sec-certs-70330b2202f7f4abd99b36b7a3090e3edee6bb1b.zip | |
work in progress reference analysis
| -rw-r--r-- | notebooks/cc/references.ipynb | 2011 |
1 files changed, 1824 insertions, 187 deletions
diff --git a/notebooks/cc/references.ipynb b/notebooks/cc/references.ipynb index 02c1f14f..b031af06 100644 --- a/notebooks/cc/references.ipynb +++ b/notebooks/cc/references.ipynb @@ -12,15 +12,12 @@ "source": [ "# References\n", "\n", - "This notebook contains analysis of certificate references in Common Criteria certificates.\n", - "\n", - "The notebook has two parts, an analysis part and a network visualization part.\n", - "But first some common initialization and data loading." + "This notebook contains analysis of certificate references in Common Criteria certificates." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "pycharm": { "name": "#%%\n" @@ -40,13 +37,14 @@ "import pandas as pd\n", "import seaborn as sns\n", "import numpy as np\n", - "import sys\n", "from tqdm import tqdm\n", "from pathlib import Path\n", - "\n", - "\n", - "sys.path.insert(0, \"./../\")\n", - "from fixed_sankey_plot import sankey\n", + "from typing import Literal\n", + "import warnings\n", + "from notebooks.fixed_sankey_plot import sankey\n", + "from typing import Iterable\n", + "# Surpress user warnings\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", "\n", "%matplotlib inline\n", "\n", @@ -64,10 +62,10 @@ "plt.rcParams['xtick.major.size'] = 5\n", "plt.rcParams['xtick.major.width'] = 0.5\n", "plt.rcParams['xtick.major.pad'] = 0\n", - "plt.rcParams[\"pgf.texsystem\"] = \"pdflatex\"\n", - "plt.rcParams[\"font.family\"] = \"serif\"\n", - "plt.rcParams[\"text.usetex\"] = True\n", - "plt.rcParams[\"pgf.rcfonts\"] = False\n", + "# plt.rcParams[\"pgf.texsystem\"] = \"pdflatex\"\n", + "# plt.rcParams[\"font.family\"] = \"serif\"\n", + "# plt.rcParams[\"text.usetex\"] = True\n", + "# plt.rcParams[\"pgf.rcfonts\"] = False\n", "plt.rcParams[\"axes.titlesize\"] = 8\n", "plt.rcParams[\"legend.handletextpad\"] = 0.3\n", "plt.rcParams['lines.markersize'] = 4\n", @@ -81,62 +79,218 @@ "#plt.rcParams['figure.figsize'] = (10, 6)\n", "\n", "RESULTS_DIR = Path(\"./results/references\")\n", - "RESULTS_DIR.mkdir(exist_ok=True, parents=True)" + "RESULTS_DIR.mkdir(exist_ok=True, parents=True)\n", + "\n", + "# The snippet below stores references to unknown certificate IDs for further analysis if required.\n", + "\n", + "# def ref_lookup(kw_attr):\n", + "# def func(cert):\n", + "# kws = getattr(cert.pdf_data, kw_attr)\n", + "# if not kws:\n", + "# return set()\n", + "# res = set()\n", + "# for scheme, matches in kws[\"cc_cert_id\"].items():\n", + "# for match in matches:\n", + "# try:\n", + "# canonical = CertificateId(scheme, match).canonical\n", + "# res.add(canonical)\n", + "# except Exception:\n", + "# res.add(match)\n", + "# return res\n", + "\n", + "# return func\n", + "\n", + "# report_finder = ReferenceFinder()\n", + "# report_finder.fit(dset.certs, lambda cert: cert.heuristics.cert_id, ref_lookup(\"report_keywords\"))\n", + "# report_unknown_references = report_finder.unknown_references\n", + "\n", + "# st_finder = ReferenceFinder()\n", + "# st_finder.fit(dset.certs, lambda cert: cert.heuristics.cert_id, ref_lookup(\"st_keywords\"))\n", + "# st_unknown_references = st_finder.unknown_references\n", + "\n", + "# # References are stored in `report_unknown_references` and `st_unknown_references` for further analysis\n", + "# Resolve all TODOs in this notebook\n", + "\n", + "SMARTCARD_CATEGORY = \"ICs, Smart Cards and Smart Card-Related Devices and Systems\"" ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], + "cell_type": "markdown", + "metadata": {}, "source": [ - "# Initialize\n", - "dset = CCDataset.from_web_latest()" + "## Common processing functions" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ - "df = dset.to_pandas()\n", - "df_id_rich = df.loc[df.cert_id.notnull()].copy()" + "def len_if_exists(x) -> int:\n", + " return len(x) if pd.notnull(x) else 0\n", + "\n", + "\n", + "def compute_reference_numbers(df__: pd.DataFrame) -> pd.DataFrame:\n", + " \"\"\"\n", + " Creates new columns with number of references for each certificate.\n", + " \"\"\"\n", + " return (\n", + " df__.copy().assign(\n", + " n_refs=lambda df_: df_.directly_referencing.map(len_if_exists),\n", + " n_trans_refs=lambda df_: df_.indirectly_referencing.map(len_if_exists),\n", + " n_in_refs=lambda df_: df_.directly_referenced_by.map(len_if_exists),\n", + " n_in_trans_refs=lambda df_: df_.indirectly_referenced_by.map(len_if_exists),\n", + " ),\n", + " )\n", + "\n", + "\n", + "def preprocess_cc_df(cc_df: pd.DataFrame) -> pd.DataFrame:\n", + " \"\"\"\n", + " Pre-processing run on the CC dataset for the sake of this notebook.\n", + " # TODO: Move this to .to_pandas() function\n", + " \"\"\"\n", + " return (\n", + " cc_df.loc[cc_df.cert_id.notnull()]\n", + " .copy()\n", + " .rename(\n", + " columns={\n", + " \"directly_referencing\": \"refs\",\n", + " \"indirectly_referencing\": \"trans_refs\",\n", + " \"directly_referenced_by\": \"in_refs\",\n", + " \"indirectly_referenced_by\": \"in_trans_refs\",\n", + " }\n", + " )\n", + " .assign(\n", + " longer_than_5_years=lambda df_: df_.not_valid_after - df_.not_valid_before > pd.Timedelta(days=5 * 365),\n", + " not_valid_after=lambda df_: df_.not_valid_after.where(\n", + " ~df_.longer_than_5_years, df_.not_valid_before + pd.Timedelta(days=5 * 365)\n", + " ),\n", + " )\n", + " .drop_duplicates(subset=[\"cert_id\"], keep=\"first\") # TODO: Investigate high number of duplicates and resolve\n", + " )\n", + "\n", + "\n", + "def compute_references(cc_df: pd.DataFrame, annotated_refs: pd.DataFrame, label: str | Iterable[str]) -> pd.DataFrame:\n", + " \"\"\"\n", + " Limits the columns with references to a given label.\n", + " \"\"\"\n", + " sub_edges = [(u, v) for u, v, d in graph.edges(data=True) if d.get(\"reference_label\") == label]\n", + " subgraph = graph.edge_subgraph(sub_edges)\n", + "\n", + " df = (\n", + " cc_df.copy()\n", + " .assign(\n", + " refs=lambda df_: df_.apply(\n", + " lambda row: set(subgraph.successors(row.cert_id)) if row.cert_id in subgraph else np.nan,\n", + " axis=1,\n", + " ),\n", + " trans_refs=lambda df_: df_.apply(\n", + " lambda row: set(nx.descendants(subgraph, row.cert_id)) if row.cert_id in subgraph else np.nan, axis=1\n", + " ),\n", + " in_refs=lambda df_: df_.apply(\n", + " lambda row: set(subgraph.predecessors(row.cert_id)) if row.cert_id in subgraph else np.nan,\n", + " axis=1,\n", + " ),\n", + " in_trans_refs=lambda df_: df_.apply(\n", + " lambda row: set(nx.ancestors(subgraph, row.cert_id)) if row.cert_id in subgraph else np.nan, axis=1\n", + " ),\n", + " )\n", + " .assign(\n", + " refs=lambda df_: df_.refs.map(lambda x: x if x else np.nan),\n", + " trans_refs=lambda df_: df_.trans_refs.map(lambda x: x if x else np.nan),\n", + " in_refs=lambda df_: df_.in_refs.map(lambda x: x if x else np.nan),\n", + " in_trans_refs=lambda df_: df_.in_trans_refs.map(lambda x: x if x else np.nan),\n", + " )\n", + " )\n", + "\n", + " return df\n", + "\n", + "\n", + "def preprocess_refs_df(csv_path: str | Path, cc_df: pd.DataFrame) -> pd.DataFrame:\n", + " return (\n", + " pd.read_csv(csv_path)\n", + " .pipe(lambda df_: df_.loc[df_.dgst.isin(cc_df.index)])\n", + " .assign(cert_id=lambda df_: df_.dgst.map(cc_df.cert_id.to_dict()))\n", + " )\n", + "\n", + "def get_reference_graph_from_refs_df(refs_df: pd.DataFrame) -> nx.DiGraph:\n", + " return nx.from_pandas_edgelist(\n", + " refs_df,\n", + " source=\"cert_id\",\n", + " target=\"reference\",\n", + " create_using=nx.DiGraph,\n", + " edge_attr=[\"reference_label\"],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load data" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ - "# Retrospectivaly limit the validity of each certificate to 5 years to account for the policy change. Draw plots with it.\n", - "df_id_rich[\"longer_than_5_years\"] = df_id_rich[\"not_valid_after\"] - df_id_rich[\"not_valid_before\"] > pd.Timedelta(days=5 * 365)\n", - "df_id_rich.loc[df_id_rich[\"longer_than_5_years\"], \"not_valid_after\"] = df_id_rich.loc[df_id_rich[\"longer_than_5_years\"], \"not_valid_before\"] + pd.Timedelta(days=5 * 365)" + "dset = CCDataset.from_json(\"/var/tmp/xjanovsk/certs/sec-certs/dataset/cc_final_run_may_23/dataset.json\")\n", + "cc_df = preprocess_cc_df(dset.to_pandas())\n", + "refs_df = preprocess_refs_df(\"/var/tmp/xjanovsk/certs/sec-certs/dataset/reference_prediction/predictions.csv\", cc_df)\n", + "\n", + "\n", + "\n", + "# Load labeled reference graph as networkx directed graph\n", + "graph = nx.from_pandas_edgelist(\n", + " annotated_references,\n", + " source=\"cert_id\",\n", + " target=\"canonical_reference_keyword\",\n", + " edge_attr=\"reference_label\",\n", + " create_using=nx.DiGraph,\n", + ")\n", + "comp_edges = [(u, v) for u, v, d in graph.edges(data=True) if d.get(\"reference_label\") == \"COMPONENT_USED\"]\n", + "comp_subgraph = graph.edge_subgraph(comp_edges)\n", + "\n", + "# TODO: Replace references in df_id_rich by those obtained from the graph. They are more precise. Those from\n", + "# df_id_rich contain only report_references\n", + "\n", + "# all_nodes = comp_subgraph.nodes()\n", + "\n", + "# for x in tqdm(all_nodes):\n", + "# desc = nx.descendants(comp_subgraph, x)\n", + "\n", + "# TODO: Examine cycles in component subgraph\n", + "# nx.simple_cycles(comp_subgraph))" ] }, { - "attachments": {}, "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, + "metadata": {}, "source": [ - "## Reference analysis\n" + "## Common processing functions" ] }, { - "attachments": {}, - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 11, "metadata": {}, + "outputs": [], "source": [ - "### References to certificate with unknown IDs" + "test = preprocess_cc_df(dset.to_pandas())" + ] + }, + { + "cell_type": "code", + "execution_count": 233, + "metadata": {}, + "outputs": [], + "source": [ + "test = limit_references_to_label(df_id_rich, graph, \"COMPONENT_USED\")\n", + "# test[\"n_refs\"] = test.refs.map(len_if_exists)\n", + "# test[\"n_trans_refs\"] = test.trans_refs.map(len_if_exists)" ] }, { @@ -145,32 +299,12 @@ "metadata": {}, "outputs": [], "source": [ - "def ref_lookup(kw_attr):\n", - " def func(cert):\n", - " kws = getattr(cert.pdf_data, kw_attr)\n", - " if not kws:\n", - " return set()\n", - " res = set()\n", - " for scheme, matches in kws[\"cc_cert_id\"].items():\n", - " for match in matches:\n", - " try:\n", - " canonical = CertificateId(scheme, match).canonical\n", - " res.add(canonical)\n", - " except Exception:\n", - " res.add(match)\n", - " return res\n", - "\n", - " return func\n", - "\n", - "report_finder = ReferenceFinder()\n", - "report_finder.fit(dset.certs, lambda cert: cert.heuristics.cert_id, ref_lookup(\"report_keywords\"))\n", - "report_unknown_references = report_finder.unknown_references\n", - "\n", - "st_finder = ReferenceFinder()\n", - "st_finder.fit(dset.certs, lambda cert: cert.heuristics.cert_id, ref_lookup(\"st_keywords\"))\n", - "st_unknown_references = st_finder.unknown_references\n", - "\n", - "# References are stored in `report_unknown_references` and `st_unknown_references` for further analysis" + "# Understand which columns I need and limit myself to those columns\n", + "# Every analytical cell should be isolated in a function that takes a single input: The dataframe of certificates to work on.\n", + "# - The number of those references is computed in the function itself\n", + "# - Each analytical method should have some tests at the end\n", + "# - If some LaTeX output accompanies the computaiton, the function should return it as a string\n", + "# - Those are stored in a dictionary that keeps expanding" ] }, { @@ -178,47 +312,67 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Count numbers of reference-rich certificates\n", - "\n", - "- From the numbers follows that whenever a certificate is directly referencing some else, it also indirectly references some else\n", - "- We have more outgoing references than ingoing references, which kinda makes sense. You don't have to be aware that some other cert references you" + "### Count numbers of reference-rich certificates" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of smartcard certificates that reference some other certificate: 1219 (71.33%)\n", + "Number of non-smartcard certificates that reference some other certificate: 334 (9.36%)\n", + "Total number of referencing certificates: 1553 (29.42%)\n" + ] }, - "scrolled": true - }, - "outputs": [], + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 2000x500 with 4 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "df[\"has_outgoing_direct_references\"] = df.directly_referencing.notnull()\n", - "df[\"has_incoming_direct_references\"] = df.directly_referenced_by.notnull()\n", - "df[\"has_outgoing_indirect_references\"] = df.indirectly_referencing.notnull()\n", - "df[\"has_incoming_indirect_references\"] = df.indirectly_referenced_by.notnull()\n", + "def compute_basic_reference_graph_stats(df__: pd.DataFrame, graph: nx.DiGraph) -> dict[str, str]:\n", + " df = df__.copy().assign(\n", + " has_refs = lambda df_: df_.directly_referencing.notnull()\n", + " ).pipe(compute_reference_numbers)\n", "\n", - "df_id_rich[\"has_outgoing_direct_references\"] = df_id_rich.directly_referencing.notnull()\n", - "df_id_rich[\"has_incoming_direct_references\"] = df_id_rich.directly_referenced_by.notnull()\n", - "df_id_rich[\"has_outgoing_indirect_references\"] = df_id_rich.indirectly_referencing.notnull()\n", - "df_id_rich[\"has_incoming_indirect_references\"] = df_id_rich.indirectly_referenced_by.notnull()\n", + " n_ref_smartcards = df.loc[(df.has_refs) & (df.category == SMARTCARD_CATEGORY)].shape[0]\n", + " n_ref_others = df.loc[(df.has_refs) & (df.category != SMARTCARD_CATEGORY)].shape[0]\n", + " \n", + " print(f\"Number of smartcard certificates that reference some other certificate: {n_ref_smartcards} ({100 * n_ref_smartcards / df.loc[df.category == SMARTCARD_CATEGORY].shape[0]:.2f}%)\")\n", + " print(f\"Number of non-smartcard certificates that reference some other certificate: {n_ref_others} ({100 * n_ref_others / df.loc[df.category != SMARTCARD_CATEGORY].shape[0]:.2f}%)\")\n", + " print(f\"Total number of referencing certificates: {n_ref_smartcards + n_ref_others} ({100 * (n_ref_smartcards + n_ref_others) / df.shape[0]:.2f}%)\")\n", "\n", - "archived_cert_id_list = set(df_id_rich[df_id_rich.status == \"archived\"].cert_id)\n", + " df_melted = df[[\"n_refs\", \"n_trans_refs\", \"n_in_refs\", \"n_in_trans_refs\"]].melt()\n", + " df_melted[\"incoming\"] = df_melted.variable.map(lambda x: True if x.endswith(\"by\") else False)\n", + " sns.catplot(data=df_melted, kind=\"boxen\", x=\"variable\", y=\"value\", col=\"variable\", sharex=False, sharey=False)\n", + " plt.savefig(RESULTS_DIR / \"boxen_plot_references.pdf\", bbox_inches=\"tight\")\n", "\n", - "def len_if_exists(x) -> int:\n", - " return len(x) if pd.notnull(x) else 0\n", + " plt.show()\n", "\n", - "df_id_rich[\"n_references\"] = df_id_rich.directly_referencing.map(len_if_exists)\n", - "df_id_rich[\"n_trans_references\"] = df_id_rich.indirectly_referencing.map(len_if_exists)\n", - "df_id_rich[\"n_referenced_by\"] = df_id_rich.directly_referenced_by.map(len_if_exists)\n", - "df_id_rich[\"n_trans_referenced_by\"] = df_id_rich.indirectly_referenced_by.map(len_if_exists)\n", + " return {}\n", "\n", - "n_ref_smartcards = df_id_rich.loc[(df_id_rich.directly_referencing.notnull()) & (df_id_rich.category == \"ICs, Smart Cards and Smart Card-Related Devices and Systems\")].shape[0]\n", - "n_ref_others = df_id_rich.loc[(df_id_rich.directly_referencing.notnull()) & (df_id_rich.category != \"ICs, Smart Cards and Smart Card-Related Devices and Systems\")].shape[0]\n", - "print(f\"Number of smartcard certificates that reference some other certificate: {n_ref_smartcards}\")\n", - "print(f\"Number of non-smartcard certificates that reference some other certificate: {n_ref_others}\")" + "compute_basic_reference_graph_stats(df_id_rich, graph)" ] }, { @@ -226,7 +380,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Distribution of references and certificate reach" + "## Evolution of certificate reach for top-10 certificates" ] }, { @@ -235,27 +389,39 @@ "metadata": {}, "outputs": [], "source": [ - "df_melted = df_id_rich[[\"n_references\", \"n_trans_references\", \"n_referenced_by\", \"n_trans_referenced_by\"]].melt()\n", - "df_melted[\"incoming\"] = df_melted.variable.map(lambda x: False if x.endswith(\"by\") else True)\n", - "sns.catplot(data=df_melted, kind=\"violin\", x=\"variable\", y=\"value\", col=\"incoming\", sharex=False, sharey=False)\n", - "plt.savefig(RESULTS_DIR / \"violin_n_references.pdf\", bbox_inches=\"tight\")\n", - "plt.show()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evolution of certificate reach for top-10 certificates" + "def compute_certs_top_reach(df__: pd.DataFrame, graph: nx.DiGraph) -> dict:\n", + " return {}" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "dgst\n", + "9be76c10474e0c80 178\n", + "13c393fa406a72cb 120\n", + "2d835bff00514238 101\n", + "3984580c5700b85f 88\n", + "d12cc4580cb099f8 85\n", + "a4d0e44f4527180f 84\n", + "ab88698a0c6ee1bb 83\n", + "5e06be752f7bf01a 83\n", + "5cdef03a3004a6ff 83\n", + "8aca11dd8e33c964 80\n", + "Name: n_trans_referenced_by, dtype: int64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ + "# TODO: Display cert_id, not digest\n", "top_10 = df_id_rich.n_trans_referenced_by.sort_values(ascending=False).head(10)\n", "top_10_cert_ids = df_id_rich.loc[top_10.index].cert_id\n", "top_10" @@ -263,9 +429,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10/10 [01:29<00:00, 8.97s/it]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def find_reach_over_time(df: pd.DataFrame, cert_id: str, date_range: pd.DatetimeIndex) -> pd.Series:\n", " df_copy = df.copy()\n", @@ -303,9 +487,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAGsCAYAAAACOtdmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACwEUlEQVR4nOzdd3gU1dfA8e+mV0glAVKAkNCrUqX3EjqCIPijCNIEEZWqIIKAyKsUFUEBBenSi3RERelVegmEACEkgfSyu/P+ETJk2Q0ETLIhOZ/n4Xl2Zu7MnA2wOXvn3ns0iqIoCCGEEEKYmYW5AxDiRcTFxVGtWjXGjRtn7lDyrHXr1jFkyJBcveeDBw9444036NChA999991/utbJkydp164dHTt25I8//simCM1jz549fP7552a7/9y5c0lOTla3Z8+ezaZNmwBISUnhnXfeoV27dnz66aesWLGCH3744YXvdf78ebZu3fqfYxYFk5W5AxDiRWzfvp0KFSqwa9cuxo8fj6OjY7ZcV6/XA2BhIfk6PP/P4+DBgzg6OrJy5cpnttVqtVhZZf4RtH79eoKDg3nnnXeyFmwWr2sOTZs2pWnTprl+3/Sfxbx58/jf//6Hra0tACNGjFDbnD9/npCQEHbs2JEt9zx//jy7d++mbdu22XI9UbBo5PGNeBl1796dIUOGsHLlSpo0acLrr7/Od999R0REBJ988gkA8fHxNG7cmN9++w03Nzd+/PFHtm/fjk6nw83NjcmTJ1O8eHHmzp3LpUuXSEhI4M6dOyxevJglS5Zw+PBhtFotTk5OfPbZZ5QqVQqA3bt3M2vWLKytralfvz5r167l119/xcfHh5CQED7//HMiIyNJSUmhe/fu9OrVyyj+uXPncvXqVZKSkrh58yYeHh7MmTMHFxcX1q1bx+7du/n2228B2LdvH4sWLWLp0qUcOnSIzz77jFdeeYXjx48DMHPmTJYsWcK///6LnZ0d8+bNw8vLi3Xr1rFhwwYcHBy4efMmrq6uzJgxAx8fH4Dn+nl4eXmpset0Or788ku196JWrVqMHj2ao0ePMm7cOGJjY/Hx8WH06NHUrVtXPe/WrVt07NiR7t27c/DgQTp06EDbtm2ZMmUKYWFhJCcn06RJE0aOHMmCBQv44YcfsLW1xc3NjaVLlxIVFZXpz7ZMmTIMHTqU33//nZo1azJ06FCmT5/OhQsXSE5OpmrVqnz88cfY2NjQu3dvKlasyKlTp7h37x5169Zl8uTJAMTGxjJ9+nROnTqFhYUFFSpUYNq0aaSmpjJ79mz++ecfUlNTKVGiBJMnT6Zw4cKsWbOGxYsXY21tjV6vZ8qUKVSpUsXg7zvj32n63+Grr77K8ePH0el0TJ8+nUqVKhn9O3mReMaMGYNGo+HmzZtERkZSs2ZNVq1aRVBQEBYWFixatIiZM2dStmxZ6tWrx+DBgwkPD6dkyZL07duX0NBQYmJiGD9+PAALFixg8+bNaDQa7Ozs+Omnn4iLi+P9998nPj6e5ORkatWqxYQJE4iOjqZLly7qv4EqVaowefJkTp8+zZdffklcXBx6vZ533nmH1q1bExUVxQcffEBERAQAFStWZNq0ac/1WSDyGUWIl8zly5eV+vXrK1qtVtm9e7fSvXt3RVEU5fbt20rt2rWV5ORkRVEUZe3atcqwYcMURVGUTZs2KePHj1e0Wq2iKIqyfv16ZcCAAYqiKMqcOXOU1157TYmIiFDvERkZqb7esmWL0q9fP0VRFOX+/ftKzZo1lStXrqj3CAoKUkJDQxWtVqt06tRJPZaQkKAEBwcrp06dMnoPc+bMURo3bqxERUUpiqIo7733njJ//nxFURTl119/VQYPHqy23bt3r9KrVy9FURTln3/+UcqVK6ecOXNGURRF+eqrrwzimTRpkjJ9+nT1OhUqVFCPLViwQOnbt+8L/Twy+uWXX5RevXopycnJSmpqqvL2228r33//vcnYMwoNDVWCgoKU9evXq/v69eunHDp0SFEURUlNTVX69eunbNu2TVEURRk9erSyePFiRVGUZ/5sg4KClLlz56rXnTBhgnofvV6vjBs3Tlm4cKGiKIrSq1cvZciQIUpqaqqSmJioNG7cWDl+/LiiKIoyZswYZeLEiYpOp1MU5fG/g++++06ZN2+eev158+YpkyZNUhRFUapXr66Eh4criqIoKSkpSlxcnNF7z/hzSf87PHnypKIoirJ8+XL139eTXiSe0aNHK+3atVNiY2PV40FBQcrDhw/V7Yw/23/++Udp3769emzOnDnKlClTFEVRlHXr1ildunRRYmJiFEVRlAcPHiharVZJSkpS36dWq1UGDhyobNmyxei9KoqiPHz4UOnQoYP6M4qMjFQaNmyo3L17V1m8eLHy8ccfq22jo6NN/hxEwZG3+jiFyIK1a9fSsWNHLC0tadiwIRMnTuTq1asEBARQvnx59uzZQ+vWrVm/fj39+/cH0no3zpw5Q+fOnYHHjyXSNWzYEA8PD3X7r7/+YtmyZcTHx6PX63n48CGQNs4hKCiIgIAAADp16sTEiRMBuH79OleuXOH9999XrxMfH8/Vq1epXLmy0fuoV68erq6uAFStWpVLly5l6f37+flRsWJFIO2bpb+/vxpP5cqV2bVrl9q2WrVq6rHu3bsze/ZsdDrdc/88Mvr777/p1KkTNjY2AHTr1o1ffvmFgQMHPjN2a2tr2rdvD0BCQgJ///039+/fV48nJCRw/fp1o/Oy8rPt2rWremz37t2cPHmSxYsXA5CUlISlpaV6vE2bNlhZWWFlZUW5cuW4efMm1apVY9++faxZs0Z9XOXm5qZeLzY2lp07dwKQmppK8eLFAahTpw4fffQRjRs3pkGDBpQsWfKZPwc/Pz+1N6VatWosWrTIZLsXiQegVatWODk5PTOOZ9m3bx9vvPEGzs7OABQuXBhIG4fy5ZdfcuzYMRRFISoqisDAQJOPbE6cOEFoaCgDBgww2H/t2jWqVKnCkiVLmD59Oq+++ioNGjT4zzGLl5skJeKlkpqaysaNG7GysmLLli0AJCYmsnbtWkaPHk2XLl1Yt24dFStW5MaNG9SvXx8ARVF455136N69u8nrOjg4qK9v377NZ599xtq1a/Hz8+PChQsmH8E8SVEUChcuzMaNG7P0XtKf7wNYWlqi0+nU1xmThIwDFE2dl3HbwsJCvc6zYs3qz+NZNBpNltva2dmpv2CVR0+OV69ebfAeTMnKzzZjzIqiMGfOnEwThMx+9k+7/8cff0y9evWMjs2dO5ezZ89y+PBhBg4cyHvvvffM8RQv8neW1Xjg+f7+XsTixYuJjIxkzZo12NraMm3aNKN/p+kURSEwMDDTcUYbNmzg4MGD7Nq1i9mzZ7NhwwaDBFIULDKaT7xU9u7di6+vL3/88Qd79+5l7969rF69mo0bN5KamkqzZs04c+YM33//Pe3bt1cHPDZr1oyVK1fy4MEDIC25OXfunMl7xMbGYmVlhaenJ4qi8Msvv6jH0ns0rl27BsCmTZtITU0FoGTJkjg5OfHrr7+q7W/cuKHeM6v8/f25ePEiSUlJaLVaNfl6ESdPnuTq1asArFmzhlq1amFpaflcP48n1alThw0bNpCSkoJWq2XNmjW89tprzx2bo6MjtWrVYsGCBeq+8PBw7t69a9T2eX+2zZo1Y+HChWi1WgAePnzIjRs3nhlTkyZN+PHHH9WkMCoqSr3ekiVLSExMBNIS4cuXL6PVarl58yaVKlWif//+tGzZktOnT2ftB5AFzxtPZhwdHYmNjX2h+69cuVI9NyYmBp1OR0xMDJ6entja2hIREcFvv/2mnuPk5GRwr2rVqnHr1i0OHjyo7jt//jwpKSmEhobi4OBAmzZt+PjjjwkJCSEhIeG54xT5h/SUiJfK2rVradeuncG+gIAAvLy82LdvHy1atKB169YsX76cbdu2qW3at2/PgwcPeOutt4C0wZpdunShfPnyRvcoU6YMbdq0oW3btri4uNCsWTP1mLu7O1OmTGHo0KHY2NhQt25dHBwcKFSoEFZWVnz//fd8/vnnLFmyBL1ej6urK7NmzXqu91i1alUaNGhAcHAwnp6eVK9e/YV/0VWrVo0vv/ySmzdv4uLiwowZM5775/Gk7t27Exoaqj76qVmzJv/73/9eKL4vv/ySadOmERwcjEajwd7ensmTJ+Pt7W3Q7nl/tmPHjmXWrFl07NgRjUaDlZUVH374If7+/k+NZ9y4cXz++ee0a9cOKysrKlWqxJQpUxgwYAApKSl069ZNbTtgwAD8/f0ZN24cDx8+xNLSEjc3t2wdqPm88QQGBpq8Tr9+/ejXrx92dnaZPioypWPHjty7d4833ngDS0tLHBwcWLx4MW+99RbDhw+nbdu2FClSxGBAc506dVi0aBHt2rWjWrVqTJ48me+//54ZM2Ywffp0tFotRYsW5dtvv+Xw4cMsWbJE7S366KOP1EdFomCS2TdCPKe4uDj1eX36TJzt27ebOSohhHj5SU+JEM9p2bJlbNu2Db1ej5OTE19++aW5QxJCiHxBekqEEEIIkSfIQFchhBBC5AmSlAghhBAiT5CkRAghhBB5giQlQgghhMgTJCkRQgghRJ6Q61OCf/31V8aNG8c333xjsChVun379jFjxgz0ej1BQUFMnz79mTUc2rZti6+vb06FLIQQQogcEBoaytatW9XtXE1Kbt26xZo1a6hatarJ4/Hx8YwfP56lS5cSEBDA5MmT+eabbxg9evRTr+vr68v8+fNzIGIhhBBC5JRBgwYZbOfa4xu9Xs+ECROYMGGCWl30SQcOHKBcuXJqVdOePXsaZFBCCCGEyL9yradk8eLFVK9eXS25bsqdO3cMym8XL16ciIgItFotv/32W6aFycLDw03u1+l0arE0IfIia2trqYgqhBCP5EpScunSJXbu3MmyZcte+BrBwcEEBwebPPZk9w+k1Se5desWsmCtyMs0Gg0+Pj7PHDclhBAFQa4kJUePHiUsLIyWLVsCEBERwZUrV7h37x49e/ZU2xUtWpS//vpL3Q4LC8PT01MtP59VOp2OW7du4eDggKenJxqNJnveiBDZSFEUIiIiuHXrFoGBgdJjIoQo8HIlKenZs6dB8tG7d2/+97//Gc2+qV+/PpMnT+bq1asEBASwfPly2rZt+9z3S01NRVEUPD09sbe3/8/xC5FTPD09CQkJITU1VZISIUSBZ/YqwbNnz6ZIkSL06NEDJycnpkyZwtChQ9HpdAQGBjJjxowXvrb0kIi8Tv6NCiHEY2ZJSpYuXaq+HjFihMGxpk2b0rRp09wOSQghhBBmJiu6FiDh4eHMnTuX8+fPmzsUIYQQwogkJQXIvXv3mDdvniQlQggh8iRJSkSeoygKSUlJ5g5DCCFELpOk5CURHh7OuHHjqFevHhUrVqRJkyZMnDiRlJQUHjx4wIwZM2jXrh3VqlWjevXqvP3221y4cEE9/9ChQ3Tt2hWAsWPHUqZMGcqUKcO6devUNqdOnaJ///688sorVKlShV69enHs2DGjWA4dOkTnzp2pVKkSzZo1Y+XKlcydO5cyZcoYtNNqtWqNo/SY/+///o+UlBSDdk2aNOGdd97hjz/+oHPnzlSuXJmVK1fSq1cv2rdvb/Ln0bJlS/r37//CP08hhBB5j9ln34hnCw8Pp2vXrsTGxtKtWzdKlSpFeHg4O3bsICkpidDQUHbv3k2rVq3w8fHh/v37rFq1il69erF161a8vLwICAhg+PDhzJkzh+7du/PKK68AUL16dQD+/vtvBgwYQMWKFRk2bBgajYZ169bxv//9j+XLl1O5cmUAzp07x9tvv42npyfvvvsuer2eb775Bjc3N6O4J0yYwPr162nZsiV9+/bl9OnTfP/991y9epVvvvnGoO3169cZNWoU3bt3p1u3bpQsWRJHR0cmTJjApUuXCAoKUtuePn2akJAQBg8enFM/ciGEEOag5APvvPOOwXZiYqJy7tw5JTEx0UwRZa+PPvpIKVu2rHL69GmjY3q9XklOTlZ0Op3B/tDQUKVixYrKvHnz1H2nT59WgoKClF9//dXoGi1atFD69eun6PV6dX9iYqLSpEkTpW/fvuq+d955R6lSpYpy9+5ddV9ISIhSvnx5JSgoSN13/vx5JSgoSBk/frzBvaZPn64EBQUpf//9t7qvcePGSlBQkHLgwAGDtjExMUqlSpWUmTNnGuz/7LPPlKpVqyrx8fHGP6yXTH77tyqEEM/jyd/f8vgmj9Pr9ezevZvGjRtTqVIlo+MajQYbGxssLNL+KnU6HdHR0Tg4OFCyZEnOnTv3zHucP3+ekJAQ2rVrR3R0NFFRUURFRZGQkECdOnU4cuQIer0enU7H33//TdOmTfHy8lLP9/f3p379+gbX/P333wHo27evwf5+/foZHE/n4+NjdA1nZ2eaNm3K1q1b1XIBOp2O7du307RpUxwcHJ753oQoaCLiI7kSGWLuMIR4IfL4Jo+LiooiLi6OwMDATNvo9Xp+/vlnli9fzq1bt9DpdOoxFxeXZ94jJCQEgNGjR2faJjY2luTkZJKSkvD39zc6/uS+sLAwLCws8PPzM9jv6elJoUKFCAsLM9jv4+Nj8r4dO3Zk27ZtHD16lBo1anDw4EHu379Phw4dnvm+hChoElISGbplAgClXP2Y3mKsmSMS4vlIUpIPzJ8/n9mzZ9OlSxdGjBhB4cKFsbCw4PPPP89SQcL0Nh999BHlypUz2cbBwYHk5OTnji2rK5ba2dmZ3F+vXj08PDzYtGkTNWrUYNOmTXh6elK3bt3njkWI/CguJZ7Zf/9IjeJV+OHYSnX/teibpGhTsLa0lpWDxUtDkpI8zs3NDScnJy5fvpxpmx07dlCrVi0+//xzg/0xMTG4urqq25l9MPn6+gLg5OT01F/27u7u2NracuPGDaNjT+4rXrw4er2eGzduEBAQoO6/f/8+MTExFC9ePNP7ZGRpaUlwcDDr16/ngw8+YPfu3XTr1k3qxAjxyLx/lnDq7nlO3TVef2jV2c1svribac3HEOBm3MMpRF4jY0ryOAsLC5o1a8a+ffs4c+aM0XFFUbC0tDTqEdm+fTvh4eEG+9KLE8bExBjsr1ixIn5+fixatIj4+Hije0RFRQFpCULdunXZs2ePwbVv3LjBH3/8YXBOw4YNAfjpp58M9i9evNjgeFZ06NCBhw8f8sknn5CQkJDpNGEhCqKY5LhMj22+uBuAz/bPNjoWn5LAwZtHSdI+fw+oEDlFekpeAu+//z5//fUXvXv3plu3bgQEBBAREcFvv/3G8uXLadSoEd988w1jx46lWrVqXLp0ic2bN6s9IOn8/PwoVKgQK1euxNHREQcHBypXroyvry9TpkxhwIABBAcH07lzZ7y8vAgPD+fQoUM4OTkxf/58AIYNG8aff/5Jjx496NGjB3q9nmXLlhEYGGiwUmzZsmXp1KkTq1atIiYmhho1anDmzBnWr19Ps2bNqF27dpbff/ny5QkKCuK3334jICCAChUqZM8PVoiXnF6v50pUiMG+HpU6sPLMJhQef1GxtbQxOnflmU3suPI7zQLq06fa69hYWud0uEI8kyQlLwEvLy9Wr17N7Nmz2bx5M3FxcXh5edGgQQPs7OwYNGgQiYmJbN68mW3btlG+fHm+//57Zs2aZXAda2trpk+fzv/93/8xadIktFot06ZNw9fXl1q1arFq1Sq+/fZbli1bRkJCAp6enlSuXJnu3bur16hYsSILFy7kiy++YPbs2RQtWpThw4dz7do1rl27ZnC/KVOm4OPjw/r169m9ezceHh688847DBs27Ll/Bh06dGDmzJkywFWIDP66edRon7uDKzaW1iTrHi9S6ObgYtDmQVIMO66kzYDbffUP/g49xqKOX8rYE2F2kpS8JIoVK8aMGTMyPT569Gij2TMZqzGne1oV5nLlyjF37txnxlKnTh3Wr19vsG/IkCF4e3sb7LOysmLYsGHPTEL27t37zHtaW6cN1mvXrt0z2wpRENyLj2TuocVG+3V6XdoSAboMO58Y7/7NoSUG2/EpCdyLv4+Xk2f2ByrEc5AxJeK5PVmXJiQkhAMHDlCzZs0cuZ+iKKxdu5YaNWpQrFixHLmHEC+bdf9uM9juWqEtlb3K8ZrfqySmGv4f1eq1BttJWsNSDwALjv6S/UEK8Zykp0Q8t2bNmtGpUyd8fX0JCwtj5cqVWFtb8/bbb2frfRISEti7dy+HDh3i0qVLfPvtt9l6fSFeZpYWj2egudoXplvFYHU7wM2fq1GPZ8Qlah8nKam6VC7ev6puF3F05158JGfCL3IlMoTS7iVyNnAhnkKSEvHc6tevz9atW4mIiMDGxoaqVavy/vvvU6JEiWy9T1RUFKNGjaJQoUIMGjQo08dOQhRE+67/rb5uHdjY4NhnTT5g59UD2Fhas+Docu7FR6LT67C0sOTtjR+p7ap6l6eWTzW+f9RLEpX4IFdiFyIzkpSI5zZt2rRcuY+Pjw8XL17MlXsJ8TJJ0iarj2RqFq9Kx3ItDY5bWVrRJqgJydoUFhxdDkBsSjwudoUMHu1o9TqaBtRTk5Kz4Rep6VM1d96EECZIUiKEEC+ZVF2q+vqtal0zbWdrZYOlhSU6vQ6dXsfy0xsMjqdkuA7Ab1f241O4KOFxETQLqE9R5yLZGrcQzyIDXYUQ4iUT+vCO+trTwe2pba0s0r57hsXcZcP5HQbHkh8tnPa/qo8Tmx+OrWDzxd3MP7Isu8IVIsukp0QIIV7A8tMb1F/yzQPqM+DVnk9trygKC44ux9rSin7Vuz+17bPM+WeR+vpZa4tYWViSTFqy8SSfwkUBaBPUBJ2iZ9mpdeqx8xGXSdImc/jWSaoXq4iTjeN/ilmIrJCkRAghXkDGXoddV/+gf/U30tYHMUGv6Hlj9VB1+7fL+5nZcjz+LqarYz/L8wxItdKkzdK5Gxeh7vu82WhO3DlLk1KvAWmJTfuyzQ2SEoC3fn0PAP/CxZnQaDiF7Qq9ULxCZJU8vsmDDh06xIULF7L1muPHj+fQoUMvdO6CBQvo3r07q1atytaYhHhZJT2xDgjAG2uG0m3VYNad2250bN+1g0b7lp40TACStSnsu3aQ6MSHT733zQdh6utCtk7PjFX/xMpp/au/QWn3ErxeMRh3B1eDY5klSTcehjFg42j+CT3+zPsJ8V/k+6REURSSkrXZ8ufJonc5QafTcfjw4f8860Sn0z27URbbr1+/nuXLlxssN59d9xXiZaIoCr+cWs+YXdPVffZWdgZtVp7ZROwTRfJ2XTUsWAlwOvw8iqKgKArJ2hR2XjnAd0eWstDEY5aMZv/9o/p6QfvMV3lO92RNGw/HzMegvFurz1Ov9X8HFz7zfkL8F/n68Y2iKIye9yfnQ6Ky5XrlSrgxY1g9NBoNly9fZsKECdjY2GBra8sPP/zA3LlzuXbtGomJidy9e5fBgwezZs0awsPD+fLLLylTpgwzZ87k9OnTxMXF8cYbb9C9e3cOHTrEggULcHR0pHDhwvz111/Y2tqydu1alixZwo4dO1iyZAm2trbUr1+fgQMHMnr0aG7fvk1cXBzDhg2jadOmrFu3jv3796PVaqlRowbe3t7Mnz8fHx8fo8rAALdu3WLEiBGUKlUKKysr+vTpw7Rp09Dr9bi6ujJjxgwWL15MWFgYffr0YcSIEej1eubMmYNGo6FkyZJ8+umnhIWFPfM6dnZ2NGrUiAYNGnDhwgVeeeUVRo8eTUpKChMnTuTGjRtYWloyfvx4AgICmDRpEjdv3kSr1TJ27FgqV67MjBkzOH78ODY2NvTo0YM2bdpky9+rEFl1/M5ZNl7YabDvx44zmbBnJteib6r74lISsLG04cL9K1QqUlY9Vr1oRRys7fnz5hEAtl7ayx83DnE9OlQ992jYqafGUNq9JKExaQNdM3tclFFkQrTBtvNTxob4uRRnfrtp3Iq5w5nwC6TqUvF2LsKi49JLKnJHvk5KctKff/5J586d6d69O3q9Xt1fpEgRxo4dy4IFC9iwYQM//PADu3fvZs2aNUyYMIGhQ4fi4OBASkoK7dq1o3PnzgDcu3ePdevWYW1tzdy5c/Hz86NDhw5ER0fz3XffsWrVKhwcHNSeiIkTJ+Lg4EB0dDS9e/dWFxZLSEhg4cKF6PV62rRpw6+//oqtrW2mhezCwsL46aefcHJy4s0332TmzJkUK1aMn376ibVr1zJ48GDWrVvH0qVLURSFTp06sXTpUpydnfn888/Zv38/gYGBz7xOr169iIyM5N1338XDw4PWrVszdOhQNm7ciIeHh7r2iU6nY/Xq1fj7+zN16lTu37/PsGHDWLlyJQcOHGDjxo1YWVkZ/MyFyC2mCuBZWVoxvcVYlhxfzbbL+wBQUJiyfzYXI69RIsMjkYE13qSwrbOalPx8cq3J+6TqUrE2UbV326W97Lue9iionn/Wyjr0q97dIKko7Vbiqe3dHFxwc3Chsnc5dZ8kJSK35OukRKPRMGNYPZJTsueRgq2NpTrSvXPnzsyfP59Ro0ZRpkwZBg4cCKQVtYO0yr4ZXz98mPaceMWKFezevRtLS0siIyOJikrrxalYsSLW1sYfQqGhoQQFBeHg4ACApaUler2eefPmceLECaysrAgLe/yMuWrVqmg0GqKjo3F3d8fJKe2Zc/ny5U2+p8DAQLXNlStX1KJ+ycnJ1KlTx6BtdHQ0YWFhDBkyBID4+HhKlixJYGBglq7j5eWFp2dawS9vb28ePnzI5cuXad68uXoPS0tLLl26xIkTJ/jjj7Qu77i4tK7wUaNGMW7cOCwsLOjfvz+BgYEm35MQOSU2OTbTY29V7aomJXdj73ExMq1qdsiDW2obV7vCaDQaWpRuwM4rBzK91rmIy1TxNvw/ezcugiUn1qjbWa3n27J0QyoUCSI8LoLS7iWz1LvypBktxjF65+cGS9sLkRPydVICaYmJnW32v00bGxv1F2+fPn1o2LCher+M906nKAoPHz5k3bp1bNq0Ca1WS6tWrdRxKhk/KKytrdUeET8/Py5dukRSUhJ2dnbo9XouXLjAxYsXWbFiBVFRUQa/1NOv4+rqSmRkJPHx8dja2mY6cNbS8vGHTGBgILNmzaJIkbQFk1JSDIt2ubq64uvry/z583F0TOsCTk1NJTw8PEvXeXLqoqIoBAYGcvjwYV57LW0WgF6vp3Tp0vj7+9OnTx/1fEVRqFu3Lk2aNOHo0aPMmTMnSxWNhcguiqJw6u55AOr6vcrx22d4vcLjejMWFhY42TgSlxLP9D9M12lK/z/w9is9ePuVHiRrU/jt8n6sLCw5c+8ix2+fAWDq72n/tmv7VKdjuRb4ufhw7t5lg2v9ceMw79bu+8y4NRoNvoWL4Vv4xYtZFnF0B9IqEGfWiyNyTlTCAxxs7LGzsjV3KDku3yclOWXLli2sX78ejUaDh4cHJUuWfOY5hQoVIiAggJ49e1KqVClcXFxMtqtbt676aOTrr79m0KBB9O7dGzs7O+rXr0/v3r3RarX06tWLsmXLUqiQ8TQ9S0tLhg8fTs+ePfHx8cHLy+uZ8X3yySeMHTuW1NS0VR7feecdNVmAtA+3MWPGMHjwYBRFwcLCgrFjx6o9JFm9Tkavv/46EydOpEePHlhbWzN27Fi6devGZ599Ru/evYG0XqT333+fAQMGAGm9L0OHDjV5PSFywm+X9xs8wmhfpjnv1elv1K5q0Qr8eeOwyWvU9q1utM/WyoYO5VoA0LZMUz7b/zVnwh8Pcv/n1nH+uZU246Vn5Y7/5S38Jxl/GSZpkyUpyUXhcRG8u/UT/F18mNlyvLnDyXEaJTemlOSwQYMGMX/+fHU7KSmJ69evU7JkSezs7J5yphDmJf9W874n1xgBWNntGyw0xo9Btl7cw08ZxonYWdmS9GjV1OLO3nzVZuJT73UlMoRxu03PqGkWUJ/dGWbxdK3Q1qAycE7rtmowAG9W7qQmUiLnrT67hbX/bgXgq9YTKV7I28wRZa8nf3/n+ynBQgjxXySkJhps1/OvaTIhgbT1PNINqtGLz5p+oG5X9CrzzHuVdi9Bh7It8HBwY3CN3lQrWlE9lp6Q9Kn2Ol+3nsjrFdo+1/vILr+cXm+W+76MrkeHGsyselJ4XARz/l7ElciQTNs42Tior0du/5SfT5geHJ1fSFIihBBPcS/uvsH2G5XaZ9q2RUADACp7laNJqdfwd/Hh+/bT6V/9DXpUNj0D7klvVunEt+2m0rhUXT6sN8joeAkXX4oV8n7m8vLZrYxHAAC+hYrm6n1fVim6VEbv/JzROz8nPiXBZJv5R5bx580jrDiz4anXyWjLpT0mF+/LLyQpEUKIpzhx518A3OxdWN39O3XQpyml3Uswv/00xjZ4/LjH1b4wLQMb4mBt/9z3trKwNKqTU76IeWadpRftS8jHvxCzU/qgZYDFJ1abbPPvvUsABuOIMkrRpnDExLo1X2eofZTfSFIihBBPceBGWnmG8kWCstTezd4lW6fOtgpspL7uWsF8Cwa62KcNqH+QbLwQozB2+NZJ9fWBkEP8eeOIwfEne0+GbB7P6UezuyAtYen16wguR143uvbx22fYe+2v7A04j8i12Tf9+vUjIiICCwsLHB0dmTBhgtHaGYcOHWLAgAEGM1lWrVolAwCFEGYREn2L+49WRK1Y5NljQnLK/PbTOHzrJI1L1jVbDHaWaTNwdHodsclxOGeh7k5BpdXr1AXy0s35ZxH1/Guo209Wbb6fEMWU3+ewuvt3ABy6dcLgeLOA+qToUjgQkpYkzz+yjLKepSnm/OyZlS+TXOsp+frrr9m8eTMbN26kb9++jBkzxmS7kiVLsnHjRvXPy5aQ7N69m9u3b6vbGdcQyWkbN26ka9euzJs3L9fuKcTLKiY5jpsPwkh94pl9uo92TOWjnVPV437/YZ2P/8rN3oVWgY2wtbIxWwwZpwH33/ChrKr8FPcTnl3axNTqwBlp9YaLfnYo25wijh4G+z7bP/v5g3skJimWxcdXs/H8TrqtGsxn+78mIj7yha+XXXKtpyTjWhqxsbG5Pkgrt+zevRsXFxeKFftvH2A6nc5gQbJn7QfYtGkTX331Fb6+vi98fSEKgvC4CN7b/ik6vQ6fQkWp71+Tcp6lKetZGoC4lHiDlVjBuLBdQWNtYfjrIkGbiNNT6ugUZFaax5+t/au/wY/HV2KZYcbW6rNbTJ5X1KmI+jpF93jxyu/bT8fVvjA8UfE5KvHBC8f4w/GVBlWfz4RfZOiWCWpPjbnk6uJpH330EYcOpXU9LViwwGSbmzdv0qlTJywsLOjcuTNvvvnmf7qnoigoqcn/6RrpNNa2ajKlKAoTJ07k8uXLKIrCuHHjcHBw4I8//uDChQv4+fkxZ84cUlNT+eSTTwyK0KWmpposODdmzBhsbGwIDw+nX79+1KpVS71348aNadiwIXfu3GHSpElMnDhRXeV1+vTp7Nmzh1OnTvHBBx/Qt29fSpYsabIo3rOu4+bmRvPmzWnRogWnTp3C09OTr776CoCZM2dy9OhRbGxsGDhwIPXr12fWrFmcOHGC1NRUBg0aROPGjVmyZAlbt27Fzs6OZs2a8b///S9bfv5CZJdz9y6je/RN9FbMHVac2YingxvftJsKYLIiuDl7KfKCJ5enj09JkKQkEzrlcS9Hbd9q/Hh8JTpFj6IoaDQa1p/brh7/qN4gvjr4A6l6LXfi7jHtwDd88NpAdZpwv+rdHyUkYPVEYqgoCstOreONiu2xsjT961yr0xKbEq9eA+DknXMGCUlGf944YvCYKbflalLyxRdfALB+/Xq+/PJLFi40LINdoUIFDhw4gLOzM3fv3mXAgAG4urrSpk0btmzZwpYtprPL8PBwk/sVReH2z+NJvmV6ZPPzsvUpS7G3pqDRaNizZw+pqamsWLGC0NBQRo4cydq1a6lfvz5du3bl1VdfBTBZhG7z5s0mC84BFC9enMmTJxvdOyIigoEDB1KsWDFGjhzJkCFDqFq1Krt372bhwoWMHj2aTZs2MXPmTLy9vTMtipeV6+h0OoKDg/nwww/p168fly5d4s6dO9y9e5eVK1ei0WjQ6XQcOHCAhw8fsmzZMhITE+nevTuNGjVi06ZN/Pzzzzg5OUkXr8iT0mvUZBSREMWWi7up4/uKwaMKL0cPyngEGHWdF3Rf/rWAac3HYCX1cIzolLTPPQdre4NEQqfXgUaT9keBCQ2HU9m7XNq08Q0foqBw4s5Z3lw73OR1m5R6jT9CDlO+SCC7Hq1bs+nCLh4kxTCsVh+DttejQ7kTG862S/u4FHkNjUbD6xXaUsjWiR+Orcw09ifHvuQ2sywz36lTJyZOnEh0dDSurq7q/ozLlXt7exMcHMyxY8do06YNwcHBBAebXr1w0CDjufyP5cxjomvXrlG9etqy0b6+vsTEmB6RbqoIXWYF5wCqVatm8jpFihRRHwldunSJWbNmAaDVavH39zdqn1lRvKxcx9LSUi0mWLRoUR48eMClS5eoVauW2lOUXjjvyJEj6nLwKSkpREdHM27cOKZOnUpqaipvvPGGmqAJkVdktm7Ezyd/Zfvl/UxrNlrdN6ft5Hz7uPm/uPHgFj3XDOOr1hMJj7tPhSJBBb43KZ3+UVJiqbEwmImlVXQkpSSpvXTpC+o52TqypPP/8b91I42uVcrVT33tYldIXRXY09Gd5ac3AGmze4bUeAsLCwvuxd1nwdHlnA4/b3AdRVEyfWz0JJ1eZ7bii7mSlMTExJCYmKjWX0kfd/Fk7Zd79+7h4eGBhYUFcXFx7Nu3j65du77wfTUaDcXempIjj29KlSrFnj17eP311wkNDcXZ2RkwLKaXHkNGiqKYLDiXLrMKnhnHf5QuXZp33nlHnb30ZOE8yLwo3vNeJz3moKAgNm/eTLdu3YC0wnmBgYG89tprTJgwQT3fxsYGe3t7Xn31Ve7evcuQIUNYt26dyesKYS7pz+unNR+Dt5MnfdePUo9FxEeiz/DsXhKSx96r8zZf//2Dwb6R2z8FoE1QEzwc3KjkVQZ/Fx9zhJdnpPcQW2gsDHpKtHotV6JC1O2MKwPbW5ue1OHh6GZyf8dyLdWkBOCNNUPxdHAjIguDbAGcbZ34uOEI7K1teXfrJwbHrkeHUtq9RJauk91yJSmJjY1lxIgRJCcno9FocHNz4/vvv0ej0TB+/HiaNGlC06ZN2blzJytWrMDS0hKdTkerVq3o0qXLf7q3RqNBY5P9M3iaNGnC/v376dGjB3q9no8//hiARo0aMWfOHAICAkw+hgFMFpxL79XIijFjxvDpp5+SkJD2ba9Lly506GC4WmRWiuJl5TrpGjZsyKFDh+jevTu2trYMGDCAhg0bcvz4cfV9eHt7M3PmTD766COio6NJTk6mZ8+eWX5fQuSGX06tJyY5rXfS2cbR5C+DCxFXAElInlTX7xVc7Qsxce//GR3bdmkvABWKBDGxsfE3/oIkvafEwsLCYIDrwqMr+Dv0WKbnNfCvpa6LA+Bk44ibvUum7Uu6+HL9weNl7DNLSJxtnUjRppCcYfBsxSJlKOGaljwOqtELSJtmDDBu9wxmt/mU8LgIZv71PSgKg2v2pp5/zUxjyS5SkE8IM5J/q7krSZvMW7++p27Pbz8NN3sXtdjckyw0Fqzs9k0uRffyyOznlc7cMzjM7WrUDcbumo6Hgxvftpua6c/ryZ+TXtET+vA2P59cy734KL5uPfGpj1FSdKmcu3eJzw8YLwPxSaP3mLz/awAalazDoFd78caaxysNf9FivJqUpHva32sd31cYWfftTI+/KCnIJ4QosH44+njBKjd7F/Vb6ISGpgcWpn/jFYamNP3Q3CHkaeljRiwe9bSV88xaaQALjQX+Lj583Og95rad/MxxHTaW1lQtWsHksYpeZVjedS4/dpzJkJpp400yljp4MiEBjEoaZDT4UW9KTpOkRAhRYFyNugGkzYqY336aur+ydzlWd/+OXlU6mSu0l0qQRylmt/mUT5u8T7syzQyO5edpwhvP73zq45d04Y+KON57tBhZq8CGRm16Vu6YbXGlF0tM526fNoHEytLKYOXdyU1G0bBEbb5r97nJ67QKbIS3k6fR/p86f4VdJmNesptZZt8IIYQ5pH/z7Futm8njrQIbcy06lIPPWG1TQFHnIhR1LkI5z0B6V+3ClcgQxu2ekemAzZfdlcgQfjm9HoA63V95atu5hxYbbNf2qc7gGr1ZeXYTdla2jKjdj5IZZtX8V580GkF0UgwR8ZFsvrAr0x4PP5fiDK319HWjMvamTG8+hlJuxrM7c5IkJUKIAiN92Gp6cbkn2Vha816d/vSq3ImRv02mrEep3AvuJZe+XklEfCT/hB6ntm91M0eUfc7du8SkfV+98PkajYbGperSuFTO1C6ytrSmiKM7RRzdqZDFwpGZSdI+nq2a2wkJyOMbIUQBon200uaTK2M+ycPRjYUdZjC2wbDcCCtfyPgz/b+DC4lLiTdjNNlr6cmsL2uQccHI9+sOyIlwctTtWNOLkeYWSUqEEAWCVq/jfnzalElLzbMXhrKzsjVYR0I8nbdzEYPtuOR4Qh/ezqT1yyU8/r7BdljM3UzbZqxH82qxyjkVUr4l/+PyoEOHDnHhwoVsveb48ePVukPpYmJi2LBhQ7beJ6NRo9IWpLp16xZ79uxR9y9YsICLF7Nn6f+nWbBgAd27d2fVqlU5fi+Rt52PuEzPNcPUdRpkafTsZ2VhSavSjdTt4dsmMuq3z1h2ynQvg6Io7LxyQF0TJi97stdn4/mdmbYdsmW8+jqzejQic/k+KVEUhSRtcrb8yY0lXXQ6HYcPH/7Pv7QzriqbmaclJVk5/1nSl7APCwtj79696v6BAwdSpkyZ/3x9eHqc69evZ/ny5XTvnvk0t6xcR7zcFEUxWuwrSZtkpmjyt36vGP9f23Rhl8m2O678zg/HVvDJ3lncfBCW06Flq2RdSq78PiiI8nUapygKn+z5kouR17LlemU8ApjcZBQajYbLly8zYcIEbGxssLW15YcffmDu3Llcu3aNxMRE7t69y+DBg1mzZg3h4eF8+eWXlClThpkzZ3L69Gni4uJ444036N69O4cOHWLBggU4OjpSuHBh/vrrL2xtbVm7di1Llixhx44dLFmyBFtbW+rXr8/AgQMZPXo0t2/fJi4ujmHDhtG0aVPWrVvH/v370Wq11KhRA29vb+bPn4+Pj4/J2jxLlizh33//pXfv3vTv358zZ84QFhbGgwcPCA4O5vz58yZj/fbbb3FxceHatWsMGTKE1q1bm6wM3Lx5c3bt2sXixYs5e/YsvXv3ZvTo0SxbtoyuXbty/vx59Hq9WkW4U6dOLFu2jFu3bpmscJzu1q1bjBgxglKlSmFlZUWfPn2M2i9evJiwsDD69OnDiBEj0Ov1zJkzB41GQ8mSJfn0008JCwt75nXs7Oxo1KgRDRo0MKj0nJKSwsSJE7lx4waWlpaMHz+egIAAk9WfZ8yYwfHjx7GxsaFHjx60adMmW/49iqy5GxdhtK+QrbMZIikYvJ08DX7mrQIbGRy/G3uP4dsmGuz7YMcU3nn1TZoG1MuNEP+zv0OPceLOWUbXH/KfB5bmNY1K1GF/yN90KNvCLPfP10kJkFaNMQf8+eefdO7cme7duxsMbCpSpAhjx45lwYIFbNiwgR9++IHdu3ezZs0aJkyYwNChQ3FwcCAlJYV27drRuXNnIK3uz7p167C2tmbu3Ln4+fnRoUMHoqOj+e6771i1ahUODg7qN/qJEyfi4OBAdHQ0vXv3pmnTpgAkJCSwcOFC9Ho9bdq04ddff8XW1tbk8vF9+vThypUrLFmyBIAzZ85gY2Ojrq7XpEkTk7HGxsayaNEi7t+/z+DBg2nduvVTKwP37duXTZs2MXXqVIP9bdu2ZfDgwfzvf//j5MmTBAYG4ujoyOTJk01WOM4oLCyMn376CScnJ5MVkQcPHsy6detYunQpiqLQqVMnli5dirOzM59//jn79+8nMDDwmdfp1auXyUrPGzduxMPDg2nT0ta60Ol0rF692mT15wMHDrBx40asrKykarIZJKYmqq+nNx9LVGI0fi7FzRhR/tagRC3WnN2K8qh+0JPjcqb9YXqF3O+P/kKDErUMKjTnBVciQ0zuT9Imc+ruOaOkxNHanvjURDqXb50L0WW/ga/2pGnAa5R2K2GW++frpESj0TC5ySiD9f7/C1tLG7UWRufOnZk/fz6jRo2iTJkyDBw4EECtruvl5WXw+uHDhwCsWLGC3bt3Y2lpSWRkJFFRaQPvKlasiLW18X/G0NBQgoKCcHBwANIK6un1eubNm8eJEyewsrIiLOxx12fVqlXRaDRER0fj7u6uVl5OL7r3LBmrFGcWa9myZbG0tMTLy4vY2FiAF6oM7Obmhru7O5cvX2bjxo106pS2cFVmFY4zCgwMVN/bs9pHR0cTFhbGkCFDAIiPj6dkyZIEBgZm6TqmKj1fvnyZ5s2bq/dIr5psqvrzqFGjGDduHBYWFvTv35/AwKyt7iiyR4pOC6R9gy/l5kcpsm99CGGsa4W2dCrXil/PbWftv1u5Hh3Knqt/0rBEbawsrbgTe09tW6N4FY6EnVK3j4Sdpq7f09cAyU0XIq7wyd5Z6nbL0g3ZceV3dTtFa/y7xcW+MPGpiVTyKpsrMWY3K0sro8XYcvX+ZrtzLtFoNNhZ2Wb7dW1sbNRfYH369KFhw4bq/TLeO52iKDx8+JB169axadMmtFotrVq1Up9LZqwOnLHSsJ+fH5cuXSIpKQk7Ozv0ej0XLlzg4sWLrFixgqioKINfjunXcXV1JTIykvj4eGxtbU0OnH2yonHG858Wq6kiZRUqVMi0MrCp+6Tr2LEja9as4cSJE2pRw8wqHGeUsdrxs9q7urri6+vL/PnzcXRMW20yNTWV8PDwLF3HVKXnwMBADh8+rBY51Ov1Jqs/K4pC3bp1adKkCUePHmXOnDnMnTvX5M9C5AytPq0oZV77Bp6fWVpYYm+V9sj1fMRlzkdcJlGbTHCZpvgWLkbow9v4FCrKh/UGEZ+SoFZptrOyMWfYKr1ez9Hbp/nyr+8N9pd09TXYTtVrjc5VP9OlmOMLyfdJSU7ZsmUL69evR6PR4OHhQcmSJZ95TqFChQgICKBnz56UKlUKFxcXk+3q1q2rPmL4+uuvGTRoEL1798bOzo769evTu3dvtFotvXr1omzZshQqZLwQlKWlJcOHD6dnz574+Pjg5eVl1MbT0xNbW1veffddo2q+WY013dMqAwcFBXHz5k2GDx/O0KFDDY41atSISZMm0aVLFzUhykqF44ye1V6j0TBmzBgGDx6MoihYWFgwduxYtYckq9fJ6PXXX2fixIn06NEDa2trxo4da7L68/vvv8+AAWlrFSQnJxu9f5Hzbj6almqB/JLITV5OHgbbNx7cMij4lr7qqKONAwGu/lyNvpGr8WXmxoNbfLhjqsljtk8kTaaSkvR6SZr8P48kR0iVYCHMSP6t5ryMvwgLevXa3KQoCm/9+l6mj88XdfpSrZMzbtcMrkSFMLr+EF4pVsmobUJqIvEpCXg6uudozDcfhPHBjimZHu9f/Q1+PL5S3Q50K8HU5mk95jq9Dp1ex6jfPiM8/j5Tmn5IkKwI/ExP/v6WnhIhRL51+NZJ9XXrwMbmC6QA0mg0/NT5K+YdWsKfN48YHMuYkKS3BVAyqco8cONoUnSpzAueQpH/kJik6FKxecpjvJVnNhlsO9s6EZscp257PVGs7nJUCBvO7yAmOY4tF3dja2mjXl8W3nsx8lMTQuRb16Jvqq97VGpvxkgKJgsLC2yfGNP3dZtJRpWE0x+tXY8O5dTdc0az1FJ0aY9Uz927ZLA/VZdKVOID5vy9iG8P/YxWn/l6Qzuv/E6vtcPZcH5Hpm0yrkD7Ub3B/NDhC4MCg1W8yzGk5ltUL1pR3bf89Aa2XNwNpK1fEvtooTUZU/JipKdECJFvpa/c2qxUvVwrvS4MxSTHqq9nthxPMWfj8W2Rj5ZmX/PvVgDeq9Ofun7GM/hSnngU9Oba4Qbb1YtVNCoEqCgKv13ez+ITq4G0JCI4qKnJ1VaLFy6qLilf1bu82tuz5+qfeDi6odFoaFSyDnX9XqXXE/d+0rPqKwnTpKdECJFvpX9zll8Q5pNxES5/Fx+Tbe4nRBlsh8fdN9nu9N3HswhTH/WeZHT2nuFK2Dq9jh5rhqkJSbrDGaYhZ5Q+xXd47b4GSUvTgHpU8X68rIKNpTWru3+Hu4OryesA+BQumukxkTlJSoQQ+Vb6TIiMU+5F7gryKMXnzUbzQ8eZmbZ5crxPsi7ZZLvDYSeJTkxb8+nJXhKAnVcOGGyHPLil/hvIaOujxy3q/bQp/HB0hZrUOFjbZxprRrNbT8LTwY0AN3+D/a9XaCtjSl6QfH0QQuRbOrWnRArwmVNp9xJPPd6n2us0LlmXL/+az734SPZcO8gblYxXoQZ4Z9MYo32FbZ15+Ogx0fCtn3A3LoK3qnbl+O0zJq9xOSqExNQktHotv13ej7WlNTuvPk5oXOwKZ+l92VjZMKftZCw0FnRfPUTd/3rF4CydL4xJKpfNdu/eze3bjwdLZVzY7L/4+eefs+U6pkydOpWoqCijAn3r1q3jr7/+yrH7ptu4cSNdu3Zl3rx5OX4vUbDo0ntK5FtrnqbRaCjh6kOTUmnrAj1MiiE+JSHL539Q7x31dXrdnZ9PruXfDANjpzT9EO8Ms2f+t24k/Td8yJp/t7L89AZ1f5B7KaNF0p7G0sISjUZDl/JpNa3q+dfM8rnCWL7/n6ooCrqkpGz5k5UlXZ5MSl7UkyugLl26NEvtXsT48eNxc3MzSko6d+781EXLnsfT4ty0aRNfffUVw4YN+0/XEQXP/fgoRu/8nN+v/2PyePosDkuN9JS8DGoWr6q+XnR8FR/umMr9+KinPk5Z3nUung6mpwmn199Z0GEGQR6lmNDw6YNTAT5r+oHJVaufpVvFYL4Nnsrw2n2f+1zxWL5+fKMoCmfGjCf2wsVnN84C53JlqTRtChqNJq0c+sSJXL58GUVRGDduHA4ODvzxxx9cuHABPz8/5syZQ2pqKp988olBhdnU1FST1WTHjBmDjY0N4eHh9OvXj1q1agGwePFiwsPD6d27N+3bt8fS0tKgGjDAvn37iI+Pp2HDhgwfPpxbt24xfPhwSpUqxdWrV+nQoQN9+vRh69atLF68GHt7e6pWrcqoUaPo3bs3M2fONFk12M/PD2dnZ/755x/GjRsHQP/+/Zk0aRJWVlZMnDhRXQJ/+vTpuLm5GfzMGjduTMOGDblz5w6TJk0yar9nzx5OnTrFBx98QN++fSlZsqTJSr3Puo6bmxvNmzenRYsWnDp1Ck9PT7766isAZs6cydGjR7GxsWHgwIHUr1+fWbNmceLECVJTUxk0aBCNGzc2WelY5G3ptVW+OfwTDUrUUn+ZaHVaLty/wrHbpwGwlDElL4WMg0P/uHEYgO+PLlOTi08ajSAmOZ5UXSplPErh7ZxWEsLV/umPW5wfTUEu4uTB8Nr9mPPPIpPtelXp9EIJCaT19ng4uj27oXiqfJ2UADlWJXjPnj2kpqayYsUKQkNDGTlyJGvXrqV+/fp07dpVLUhnqsLs5s2bTVaTBShevDiTJ082uFffvn1Zvny52luybt06tRqwRqMhISGBvn37oigKPXr0oGvXrkBa5eFffvkFCwsLWrduTZ8+fdi8eTMzZ86kZMmSRmsBmKoaDNCgQQO++uortFotkZGRpKSk4Ovry8iRIxkyZAhVq1Zl9+7dLFy4UK0HlC4iIoKBAwdSrFixTNtv2rSJmTNn4u3tnWml3qxcR6fTERwczIcffki/fv24dOkSd+7c4e7du6xcuRKNRoNOp+PAgQM8fPiQZcuWkZiYSPfu3WnUqNFTKx2LvKmQnbP6OkWXqi4DvuXSHoMu+SSt6YGTIu+pVrQCJ+78q26funtefe3h4EZFE4XuNBoNS7vMZtCmMcSnJrKo45ccvX2aK1EhdK3QFssMY4rq+dfAysKS/zu4EIBO5Vqx/vxv2Fra0DaoaQ6+M5EV+Top0Wg0VJo2BX1y9nwgWdjaqln0tWvXqF49bT68r68vMTExJs8xVWE2s2qyYFil92nSqwED7Ny5kzVr1qDRaAgNDeXOnTt4eXkREBCAvX1at2d64blRo0axaNEiEhISaN26Nc2aNXvmvaysrKhduzZ//vknV65coX37tEWoLl26xKxZaRU0tVot/v7+RucWKVKEYsWKZbl9ZpV6s3IdS0tLtTJz0aJFefDgAZcuXaJWrcffoNOr+R45ckStUZOSkkJ0dPQLVToW5uWaYUBikjZJTUouRV43aPdkeXmRd3Us19IgKclIq2T++NbWyobFnf9P3W5Usg6NShpXGAeo7Vud/tXfQKOBFqUb0qOy6UG1Ivfl66QE0hITyxyoKVKqVCn27NnD66+/TmhoKM7Oad/YnqyIa6rCrKlqsukym7r45P6M27Nnz2b79u3Y2NjQo0ePp1bz9fHx4bPPPiMlJYUWLVoYJCXPqua7cOFCwsLCWLx4MQClS5fmnXfeoXz58kbvI13GKrxZaZ9Zpd7nvQ6k/ayDgoLYvHkz3bp1A9LGGAQGBvLaa68xYcIE9XwbGxvs7e0zrXQs8iZdhumeAzamJbOdy7fmaIZ1KEbU6Ue1DCtwirytjHuAyf2WGguTC6+9qJaBDbPtWiL75PukJKc0adKE/fv306NHD/R6PR9//DGQVvV2zpw5BAQEGD2GSWeqmuyTjz2eVLVqVYYOHUqbNm2MjjVv3pwePXpQqlQpHBwcnnqdL774gkuXLqHVaunevbvBsadVDa5QoQIhISGUKlVKra47ZswYPv30UxIS0kbJd+nShQ4dMv/GkZX2WanU+zz3bdiwIYcOHaJ79+7Y2toyYMAAGjZsyPHjx9Wfv7e3NzNnznxqpWORN+lMLCu+7tx29fXw2v14za9GboYk/iNTX8zerNyJDuVamGgt8hupEiyEGcm/1Ren0+sYuGmMQcG0Jy3tMtuo3LzI+w6EHGLx8VW0DGxEbHIc/V95Q6Z151NSJVgIkS+cDj//1IRkbIOhkpC8pBqUqEWDErXMHYYwA0lKhBAvpbhk48W1ulZoSwkXH0q5+sn0TCFeQvk6KckHT6ZEPif/Rl/ckxVjAYLcS1K1aAUzRCOEyA75MimxtrZGo9EQERGBp6fnCy+GI0ROUhSFiIgINBoN1tbW5g7npZPyqEpsbd/qBLmXIiQ6lMre5cwclRDiv8iXSYmlpSU+Pj7cunWLkJAQc4cjRKY0Gg0+Pj4GU55F1qQnJTaW1gSXkUWvhMgP8mVSAuDk5ERgYKA6tVSIvMja2loSkhew4vRG1p//DQAbSxnMKkR+kW+TEkjrMZEPfCHyl5ikWDUhAdNjS4QQL6dcS0r69etHREQEFhYWODo6MmHCBHVFzozWrFnDwoUL0ev11K5dm4kTJ8rzdiGEauGxFQbbNYpXMVMkQojslmur0Xz99dds3ryZjRs30rdvX8aMGWPUJjQ0lNmzZ/PLL7+wa9cu7t+/z+rVq3MrRCFEHnc+4jKHbp1QtzVoqFikjBkjEkJkp1xLSgoVKqS+jo2NNTkjZseOHTRp0kSdMdOjRw+2bNmSWyEKIfK4iXsfF1zrU+11VnX/Fkebp5dWEEK8PHJ1TMlHH33EoUOHAFiwYIHR8Tt37lC8eHF1u3jx4ty5cyfX4hNC5E2JqUn8HvKPwb46vq+YKRohRE7J1aTkiy++AGD9+vV8+eWXLFy4MMvnbtmyJdNek/Dw8GyJTwiRN22+uJu1/25Vtyc0HI6rfWEzRiSEyAlmmX3TqVMnJk6cSHR0NK6urur+okWLcvPmTXU7LCyMokWLAhAcHExwcLDJ6w0aNChnAxZC5LoHiQ9J0qXg7eTJ/fgog2NB7iXNFJUQIiflypiSmJgYg96M3bt34+LigouLi0G7li1bsnfvXiIiIlAUhRUrVtC2bdvcCFEIkYdodVre/+0zhm/9hGtRN9kf8jcAdla2zGnzKXbWUlFZiPwoV3pKYmNjGTFiBMnJyWg0Gtzc3Pj+++/RaDSMHz+eJk2a0LRpU3x9fRk+fDg9evQAoGbNmnTv3j03QhRC5CFxqQnEpcQDMGbXNHX/26/0wNu5iLnCEkLksFxJSooXL87atWtNHps6darBdrdu3ejWrVtuhCWEyKNSdaZXYvYp5J3LkQghcpNRUnL79m1u377Nq6++qu67cOECixYtIiUlheDgYJo1a5arQQoh8j+dXsf/HVxISVdfynsGGh3vXaULpdz8zRCZECK3GCUlU6ZMISEhgSVLlgBw//593nrrLVJTU3F0dGTHjh3Mnj2bFi1a5HasQoh8bMeV3zkSdoojYaeMjtlYWtO01GtmiEoIkZuMBrqePn2aunXrqtsbNmwgKSmJjRs3cuDAAerUqcOiRYtyNUghRP5yOfI6B0IO8SApRt0Xkxxnsu3K17/hhw5f4GBjn1vhCSHMxCgpefjwIe7u7ur2/v37qVGjBn5+flhYWNC8eXOuXbuWq0EKIfKPB4kPmbBnJvMOLWHsrunq/nXnthu1reRVFgsLC5ltI0QBYfT4xs3Njdu3bwNpU3lPnjzJBx98oB7X6XRotdrci1AIka88SIpFURQAIhOi2X31T14tXlk93qTUa/Sr3p2oxAd4OXqYK0whhBkYJSV169Zl6dKlODk5cejQIRRFoWnTpurxK1euqAuaCSHE89IreoPtBUd/ISDDANZelTthY2mNt5NnbocmhDAzo6Rk1KhRXL9+nRkzZmBtbc1HH32Er68vACkpKWzfvp127drleqBCiPzhyaQEIEWXAoCXowdOto65HZIQIo8wSko8PDxYuXIlsbGx2NraYmNjox7T6/X89NNPeHvLWgFCiBeTnpQ4WNuTkJoIwOcH5gEQHn/fbHEJIcwv08XTnJ2djfbZ2dlRtmzZHA1ICJG/6R+NJ3G0cVCTksTUJHOGJITII0zWvrl9+zaffPIJLVu2pEaNGhw5cgSAqKgopkyZwrlz53I1SCFE/pHeU2JjYW10rImsRSJEgWbUU3LlyhXefPNN9Ho9lStX5ubNm+psGzc3N44dO0ZCQgKff/55rgcrhHj56RUdABYaDSVdfLn+IBSA/2v9CcWcvcwZmhDCzIySkpkzZ+Ls7Mzq1asBDBZSA2jYsCHbtxuvJyCEEFmR/vjGQmPB9BZj+e3yfsoXCcSnkMzqE6KgM3p8c+TIEXr06IGbmxsajcbohGLFihEeHp4rwQkh8p/0xzcWGgs0Gg2tgxrj7+Jj5qiEEHmBUVKiKAp2dpmvnhgVFWUwI0cIIZ5HxqRECCEyMvpUKF++PL///rvJxlqtlq1bt1KlSpUcD0wIkT8ladPWJLEw0RMrhCjYjJKSgQMH8scffzBx4kQuX74MQGRkJAcPHqRfv35cu3aNgQMH5nqgQoj84dy9SwBoHw14FUKIdEYDXRs2bMi0adP4/PPP1cGuH374IYqi4OTkxIwZM6hRo0auByqEyB/Si+tZWWS6TJIQooAy+anQsWNHWrRowcGDBwkJCUGv1+Pn50e9evVwcnLK7RiFEPmIXp/WQ1LOM9DMkQgh8ppMv6o4ODjQrFmz3IxFCFEA6B4NdLWUga5CiCcYfSocPHiQ//u//8v0hK+++oq///47R4MSQuRfukdjSSwtJCkRQhgy+lT49ttvuXPnTqYnhIeH89133+VoUEKI/Ovx4mmWZo5ECJHXGCUlly5deuqU30qVKnHx4sUcDUoIkX+ljymRxzdCiCcZfSqkpKSQmpqa6QkpKSkkJUlFTyHE87sXd5/IxAeAPL4RQhgzGugaGBjIrl276Nu3r1FjRVHYuXMnAQEBuRKcECJ/SEpNYuRvk4lMiFb3yeMbIcSTjL6q9OrVi+PHjzN8+HAuXryIVqtFq9Vy4cIFRowYwcmTJ+ndu7c5YhVCvKRuPAwzSEhAHt8IIYwZ9ZR06NCB0NBQvv32W3bt2oXFoy5WvV6PRqNh8ODBdOrUKdcDFUK8vNLr3WTkZONohkiEEHmZyXVKhg0bRvv27dm1axehoaEA+Pn50axZM/z8/HI1QCHEyy99xo2jjQMdyrbAwdqOWr7VzByVECKvyXTxND8/P/r375+bsQgh8qn0nhI3exc6lmtp5miEEHnVU4tPxMfHExMTg/LoW05GxYoVy7GghBD5S3pSYiHjSIQQT2GUlCQnJzNv3jzWrl3LgwcPMj3x/PnzORmXECIfeZyUaMwciRAiLzNKSiZNmsSGDRto1qwZr7zyCoULFzZHXEKIfOTxKq7SUyKEyJxRUrJr1y5ef/11Jk+ebI54hBD5kDy+EUJkhdEnhEajoXz58uaIRQiRT0lSIoTICqNPiKZNm3Lw4EFzxCKEyKckKRFCZIXRJ8SQIUO4desWH3/8MWfPniUqKooHDx4Y/RFCiKySga5CiKwwGlPSokULAM6dO8fatWszPfF5Zt8kJyczcuRIrl69iq2tLe7u7kyaNAl/f3+Ddrdu3aJ58+YEBQWp++bOnSsLtgnxktPrZaCrEOLZjJKSoUOHosmBbzPdu3enQYMGaDQali1bxoQJE1i6dKlRO0dHRzZu3Jjt9xdCmM+R26cASUqEEE9nlJS8++672X4TW1tbGjZsqG5XqVKFRYsWZft9hBB5y62YO9hYWPNP6HEA7K3szByRECIve+qKrgCxsbE4ODhgaZl9ZcZ//vlnmjRpYvJYYmIiXbp0Qa/X07RpUwYPHoylpSVbtmxhy5YtJs8JDw/PttiEENkjNjmOj3Z8jpKhGF/n8q3NGJEQIq8zmZScOXOGr7/+mqNHj5KamsqPP/5InTp1iIqKYvz48fTp04datWq90A3nz5/PzZs3WbJkidGxIkWKcODAAdzd3Xnw4AEjR45k0aJFDBgwgODgYIKDg01ec9CgQS8UixAi50TER6HVaw32+blIeQohROaMHvAeP36cnj17cuPGDdq3b49e//hbjpubG3FxcaxateqFbvbjjz+yc+dOFi5ciL29vdFxGxsb3N3dAXBxcaFLly4cO3bshe4lhDCv/SF/G+2TMSVCiKcx+oT46quvCAgIYNu2bYwcOdLohFq1anHq1KnnvtHixYvZunUrixcvplChQibbREZGkpqaCkBKSgo7d+6kXLlyz30vIYT5JaYmmTsEIcRLxujxzZkzZ3j//fexsbExOQvHy8uL+/fvP9dN7t69y/Tp0/H19eWtt94C0npF1qxZw+zZsylSpAg9evTg2LFjzJkzBwsLC3Q6HbVr12bw4MEv+NaEEOZyPTqU30P+MdjXt1o3M0UjhHhZGCUlVlZWBo9snhQeHo6Dg8Nz3cTb25uLFy+aPDZixAj1dYsWLdR1UoQQL69z9y6prz+qN4hKXuWwtbIxY0RCiJeB0eObKlWqsGPHDpONExISWLduHTVq1MjxwIQQL69kXQoADfxr8WrxKpKQCCGyxCgpGT58OGfPnmXgwIEcOHAAgIsXL7JmzRo6d+5MVFQUQ4YMyfVAhRB5l6Io6uvE1CRWntkEyMBWIcTzMdlTsmDBAm7cuMHo0aMBmD59Oh9//DF6vZ4FCxZQtmzZXA9UCJE3pWhTeP+3yXx3OG2F5pN3/1WPhcXeNVdYQoiXkMGYEkVRiI+Pp3r16uzYsYPz588TEhKCoij4+vpSsWLFHFmCXgjx8tp4YSdhMXcJi7lL7yqd+fvmcfVYcJmmZoxMCPGyMUhKUlNTqVmzJiNHjmTAgAGUK1dOpuQKIZ7K0uLxas8XI6/xz620pKSqd3nq+L5irrCEEC8hg8c3NjY2eHh4YGMjg9KEEFmTcdXWbw//rL6WJeWFEM/LaExJp06d2LhxIykpKeaIRwjxkohLjudu7D32Xjuo7otNjlNfB3mUMkdYQoiXmNE6JWXKlGHPnj0EBwfTqVMnihcvjp2dcWVPWU9EiIJt6NYJma7aWtf3FZl5I4R4bkZJyfvvv6++nj17tsmTNBoN58+fz7mohBB52u3Y8KcuIx/oXjIXoxFC5BdGScnPP/9sqp0QQgCg1+t5b9skg33v1urL3EOL1e2izkVyOSohRH5glJTUrFnTHHEIIV4S6au1phteuy/1/GsaJCVlPUrndlhCiHwg04e+KSkpnDhxgt27dxMVFZWbMQkh8iCdXgdAZEK0um/gq29Szz/ti8wnjdLqWNX1exUHG/vcD1AI8dIz6imBtEc48+bNIzY2FoBFixZRp04doqKiaN26NR9++CFdu3bN1UCFEOYz/8gy9l77C3srOxK1j8eSNAuop76u6FWWVd2+lQUWhRAvzKin5Ndff+Xzzz+nfv36TJ061aCmhZubG7Vr12bbtm25GqQQwrz2XvsLwCAhMUUSEiHEf2GUlCxevJimTZsya9YsGjdubHRChQoVuHz5cq4EJ4QwvxRdqsn9FYuUyeVIhBD5ndHjmxs3btC7d+9MT3BxceHBgwc5GZMQIg85E35BfT29+Vi2XtpD84AGBLqXMF9QQoh8ySgpKVSoENHR0abaAnDlyhU8PT1zNCghRN6x/NR69XUpNz/erd3XjNEIIfIzo8c3DRo0YPXq1cTExBg1vnz5MmvWrKFJkya5EpwQwvxCY+6YOwQhRAFh1FPy3nvv0a1bN4KDg2ncuDEajYYNGzbw66+/snPnTjw9PRkyZIg5YhVCmFFwmWbmDkEIkc8Z9ZR4eXmxbt066tevz/bt21EUhY0bN7Jv3z7atm3L6tWrcXNzM0esQggzcLZxBKBxyTpmjkQIkd9Z7dmzh4oVK+Ll5aXudHd3Z+rUqUydOpWoqCj0ej1ubm5YWEiBLSEKkoSURGJT4gGwtzIuzCmEENnJYtiwYRw+fFjd0bRpU/bs2aNuu7m54eHhIQmJEAXQ3usH1deONg5mjEQIURBYOTo6GgxqDQsLIyEhwYwhCSHMIVmbgoVGQ6peS1jMXa5Hh7L67GYAijoVwd5aekqEEDnLqnLlysyfP5/IyEicnZ0B+P3337l//36mJ2k0Gvr06ZNLIQohclpEfCRDt0zI9Hg9/xq5GI0QoqCymjhxIqNHj+bbb78F0hKOLVu2sGXLlkxPkqREiPzlQMihpx5P1WtzKRIhREFm5e/vz8qVK0lOTiYyMpImTZowbtw4mjZtau7YhBA5JCrxARZocLEvDICVxePVASY0HE5Zz9JYW1gx668FHLtzhjq+r5grVCFEAaJ+Etna2lKsWDGGDRtG7dq1KV68uDnjEkLkkHtx9xm29WNsLK2Z324aTraOxD2aYdMqsBGVvcupbd9/bQBJ2mQcrO3NFa4QogAxmlIzbNgwgoKCALh37x4XLlyQga9C5CMjf5sMpBXau/4gFEVROHn3HABOj9YkSWehsZCERAiRa0zO8929ezetWrWiYcOGdOrUiVOnTgEQFRVFx44d2b17d64GKYTIHknaZFIzVP1dcOQXTtw5y40HtwCws7IxV2hCCGGclOzdu5d3330XV1dXhg4diqIo6jE3Nze8vLz49ddfczVIIUT22HvtL4Pt8Pj7HA07rW7rM/x/F0KI3GaUlHzzzTe8+uqrrFixgjfffNPohKpVq3L+/PlcCU4Ikb3Sx45ktPvan+rrxNSk3AxHCCEMGCUlly9fpnXr1pme4OHhQWRkZI4GJYTIGSmPHt04ZjJOpH6JmrkZjhBCGDBKSuzt7UlMTMz0hNDQUFxcXHIyJiFEDknRpiUlQR6ljI6t7PYNPoWK5nZIQgihMkpKatWqxYYNG9BqjRdLioiIYPXq1dSrVy9XghNCZK/zEZcBKOMRQLWiFdT9ExoOx0Ij9a2EEOZl9eSOESNG8MYbb9C1a1datWqFRqPhzz//5J9//mHVqlUoisLQoUOf6ybJycmMHDmSq1evYmtri7u7O5MmTcLf39+o7b59+5gxYwZ6vZ6goCCmT5+Ok5PTi79DIYTKzcGVGw/DSNGlMLbBMHOHI4QQBoy+GgUEBLBixQpcXFyYPXs2iqLw448/8v333xMUFMTy5cvx8fF57ht1796d3377jU2bNtG0aVMmTDCusxEfH8/48eP55ptv2LlzJ0WKFOGbb755sXcmhABAURQeJD5EURRO3DkLQElXPzNHJYQQxgx6SlJTU7l69SouLi4sWbKEhw8fcuPGDRRFwdfXFzc3txe6ia2tLQ0bNlS3q1SpwqJFi4zaHThwgHLlyhEQEABAz5496devH6NHj36h+wohYP3531h5ZpPBPnd7VzNFI4QQmTPoKbGwsKBLly7s3LkTgMKFC1O5cmWqVKnywgmJKT///DNNmjQx2n/nzh2D5e2LFy9ORESEyfEtQoiseTIhsbG0JsDN+NGpEEKYm0FPiaWlJcWKFSMlJSXHbjh//nxu3rzJkiVLnuu8p1UuDg8Pz4bIhMh/krTJBtuudoWZ2vwjNBqNmSISQojMGQ107dWrF7/88gtdu3bN9qm/P/74Izt37mTJkiXY2xuvk1C0aFH++uvxipNhYWF4enpiZWVFcHAwwcHBJq87aNCgbI1TiPzibuw9g+0elTvg4ZB9vZ5CCJGdjJISvV6PjY0NzZs3p2XLlhQvXhw7OzuDNhqNhj59+jzXjRYvXszWrVtZvHgxhQoVMtmmfv36TJ48matXrxIQEMDy5ctp27btc91HCPGYVq8z2C7jEWCmSIQQ4tmMkpIZM2aor9euXWvypOdNSu7evcv06dPx9fXlrbfeAsDGxoY1a9Ywe/ZsihQpQo8ePXBycmLKlCkMHToUnU5HYGCgQTxCiOeTMSkZUacfRZ2LmDEaIYR4OqOkZM+ePdl+E29vby5evGjy2IgRIwy2mzZtStOmTbM9BiEKIq0+bZC4b6GivOZXw8zRCCHE0xklJRlnvwghXm7pPSVWFkb/1YUQIs+RdaWFyMfSe0qsLCzNHIkQQjybJCVC5GPpSYmlJCVCiJeAJCVC5GPy+EYI8TKRpESIfGL56Q28u+Vjbj28o+6TxzdCiJeJxc8//8z169fNHYcQ4j/acH4H4fH3+fXcNnWfTnpKhBAvEYtp06Zx9uxZdUe5cuXYvHmzGUMSQvwXf908yt24CAB+Ob0BgFR9qhkjEkKIrLEoVKgQkZGR6g5FUcwYjhAiOwzf+gl6vZ64lHgATt09b+aIhBDi2axq1arF3LlzOX/+PM7OzgBs2LCBU6dOPfXECRMm5EZ8QogsiE58aLTvjTVDzRCJEEK8OKuJEyfy+eef89dffxEZGYlGo+Gvv/4yKIz3JI1GI0mJEHnEgZBDzDu0RN12sLYnITXRoM0bldrnclRCCPH8rNzd3Zk1a5a6o2zZssycOZN27dqZMSwhRFb9HXpMfd2ydENaBzbi+6PL8XL0oGP5ljhY2+NiZ7oIphBC5CVGQ/KnTZtGtWrVzBGLEOI5KIrCrqsHOHb7DAA9K3ekQ9kWaDQaPm3yvpmjE0KI52eUlHTq1El9feXKFcLCwoC0mjilS5fOvciEEE91LuIyPxxbqW77Fi6GRqMxY0RCCPHfmFy8YPfu3UyfPl1NSNL5+PgwZswYqeIrhBkpioJGo2Hl6Y0G+z0cXM0UkRBCZA+jpOT3339n+PDhFCtWjJEjRxIQEADA1atXWb16Ne+++y7z58+nQYMGuR6sEAXZ0bBTfHPoJ+JTEynh4kPIg1vqMQ0a/F18zBidEEL8d0ZJybfffkuZMmX45ZdfcHBwUPc3bdqUXr160bNnT7755htJSoTIZUtPrSP+0ayajAlJ9WKV6F2ls7nCEkKIbGNU++bixYt07NjRICFJ5+DgQKdOnbh48WKuBCdEQaEoCrce3iEhJZGbD8IIiU5LOu7GRXDo1gk+3fcVd2LvAVCzeFUqeZUBwN3elTH1h1C8kLfZYhdCiOxi1FNia2vLw4fGCzGle/jwIba2tjkalBAFyb5rB/nuyFIACtk6EZMcB8CPHWcyfOsnRu0H1eiFg409Z8Mv4u1cJFdjFUKInGTUU1KrVi1+/vlnTpw4YdT41KlTLF26lDp16uRKcELkd3/dPKImJICakAD03/ChUftBNXrjZOuIhcaCyt7lKOLonitxCiFEbjDqKfnwww9544036NmzJ5UrV6ZkyZIAXL9+ndOnT+Pu7s4HH3yQ64EKkR/9e+9yltu+5vcqTUrVzcFohBDCvIx6Snx9fdm0aRO9e/fm4cOHbNu2jW3btvHw4UPeeustNm7ciI+PjPIX4r86d+8Su6/+keX29lZ2ORiNEEKYn8l1Stzd3Rk3bhzjxo3L7XiEKDC+OfSTwXYRR3ccrR2oWrQC/i7FuRR5nUO3ThCZEA2AT+Gi5ghTCCFyjcmkRAiR89Kn93Ys15I3KrXHQmPYcVnX71Vc7Aqx/PQGihfypnVgY3OEKYQQuUaSEiHMRK/oAWhS6jWjhCRdx3ItaVLqNZxtHGUJeSFEvidJiRBmoigKQKYJSbpCtk65EY4QQpjd0z8NhRA5Jr2nxALpARFCCJCkRAiz0ZPWUyKPZYQQIo1BUpKYmEjnzp1ZsWKFueIRosBQe0qe8fhGCCEKCoNPQ3t7e27duiXf3ITIBeljSuT/mxBCpDH6ila/fn3+/PNPc8QiRIGR3ksC0lMihBDpjD4NhwwZQkhICB9++CFHjx4lPDycBw8eGP0RQry49F4SkIGuQgiRzmhKcNu2bQG4cuUKW7ZsyfTE8+fP51xUQuRz0lMihBDGjJKSoUOHyjNuIbJRQmoif988Ro3iVShk5wwY9pTI/zchhEhjlJS8++675ohDiHzrt8v7WXlmE98f/YXv2n2Ou4OrQU+JJCVCCJHmmf3GsbGx6HS63IhFiHzpfMQV9fWOK79z80EYk/fPVvfJ4xshhEhj8tPwzJkz9O/fnypVqlCrVi0OHz4MQFRUFIMHD+bQoUPPfaMpU6bQpEkTypQpk+l4lEOHDlG5cmU6dOig/klKSnruewmRl7jaF1Zfbzi/gw92TOFKVIi6Twa6CiFEGqOk5Pjx4/Ts2ZMbN27Qvn179PrH3cxubm7ExcWxatWq575Ry5YtWb58OcWLF39qu5IlS7Jx40b1j52d3XPfS4i8JFmb8tTj0lMihBBpjD4Nv/rqKwICAti2bRsjR440OqFWrVqcOnXquW9Uo0YNvL29XyxKIV5iSdpkAAbV6E3n8q0NjvkVLi5jSoQQ4hGjga5nzpzh/fffx8bGxuSHpZeXF/fv38+xgG7evEmnTp2wsLCgc+fOvPnmmzl2LyFyQ/KjpMTOyoY3KrXn5sPbPEh8yMBXe+JTqKgkJUII8YhRUmJlZWXwyOZJ4eHhODg45EgwFSpU4MCBAzg7O3P37l0GDBiAq6srbdq0YcuWLZmumxIeHp4j8QiRHdIf39hZ2QLwUb1B5gxHCCHyLKOkpEqVKuzYsYM+ffoYNU5ISGDdunXUqFEjR4JxcnJSX3t7exMcHMyxY8do06YNwcHBBAcHmzxv0CD5kBd5V/rjG9tHSYkQQgjTjMaUDB8+nLNnzzJw4EAOHDgAwMWLF1mzZg2dO3cmKiqKIUOG5Egw9+7dU3tp4uLi2LdvH+XKlcuRewmRW8Ji7wJga2lj5kiEECJvM9lTsmDBAiZNmsTo0aMBmD59OgB+fn4sWLCAsmXLPveNPvnkE/bv38/9+/fp378/jo6O7Nq1i/Hjx9OkSROaNm3Kzp07WbFiBZaWluh0Olq1akWXLl3+41sUwny0+sdr/DhYy0wyIYR4GqOkBKBOnTrs2LGDc+fOcePGDRRFwdfXl4oVK77woLzJkyeb3D916lT1da9evejVq9cLXV+I3BSXHI+9tR2WFpZPbZeSYTqwp6N7ToclCqCbd2PYcySUGuW9WPbbBf69FglAuRJuhEXEYW9rxZxRjXCwszY4T6dX+PfafaJjkqlR3svouBDmYDIpSVe+fHnKly+fW7EI8VK4Fx/JsC0TKOXqx/QWY5/aNkWfqr62snjqfzchnsvR8+FMXXwIrS6tjtK6/VcMjp8PiQIgJj6F9/7vd75+vyHdx2/L9Hpebg6806kS1ct6YWkhM8KEeZj8lExJSWH16tX8/vvvhIWFAVC8eHEaNmzI66+/jq2tDNgTBdeh0BMAXIu++cy2Wp0WAGsLK5n6K7LVpz/8k+W2dyLjGfPNn09tEx6VwOQfH6/WbWdjyei3avBqOS8URZF/vyJXGCUld+/epW/fvly/fh1PT0/8/f0BuHDhAn/88QfLli1jyZIlshCaKLAssvDhfOvhHf68eZh1534DIFWvzemwRAFw4uI9rt+OoYy/q8H+UsUK42BvRWEnW0b1fAVrq7Q5DFqdnk4fbQbg+u0Yk9ecNuQ1xn77l9H+pBSdUeLTrVkQvVvL5AORc4ySkk8//ZTbt2/z9ddf06pVK4Nj27dvZ8yYMXz66ad89913uRakEHnJk+NIYpLjcLZxJCzmLktPraN4IW+2XNxtpuhEfnX8wj0mLvzb5LHkVB2zRzUy2m9laUHTGr7sORKq7vt+TFO83R1JTNbiaJ82jmTzrA4A3I2M5/2vDxCbYLo0wurdl7C00ND4FV+Kejj+x3ckhDGjpOSff/6hT58+RgkJQOvWrTl37hzLli3LleCEyIsy1qrptmowAPX8axKfksCJO2c5ceeseryMRwCFbZ1pFdgw1+MUL495a06y458bALzeNJDuzcsQG59CbEIKw2ftx9fLmdDwWKPzrCwtcHGyYUjXyplee1CnypQv6c7GA1dpXz+AYp5p60GlJyQZebs7svyztFIIOr3C2av3+efsHc5dj+Ja2EMAVuy8yIqdFwFwdbZl8SctszwGJTFZS3KKjr1Hb/JKOS+uhz2kZPHC+HsXytL5Iv8zSkocHR1xc3PL9AQPDw8cHSVDFgWXg7W90b4/bxw22tehbAverNIpN0ISZhByJ4bpPx3h/sNEJvStSdWgIpm21ekV9h29yexVJ9V9reuWYHDnyvSfuouI6ER1/5o9l1mz57LB+RkTklLFC3Mt7CGdG5Wmb7sKz4zTztaKFrX8aVHL/zneHVhaaKgS6EmVQE8A/jp9m+k/HTFoEx2bTMcPN6nbtjaWtKtXio4NA4iITiQqNomA4oU5HxLF/mO3OPTvXbXt4i3n1NdDu1ahVZ0SzxWfyJ+MkpLOnTuzfv16unXrhr294YdvfHw869atk7VDRIGWPqTE3sqOrhXasvTUrwbHJzcZRZBHKan+m4/FJaTw7pf71O2Pv/+bXq3Ksuy3C1hZWrD+i3YG7X/cdJbNf1wz2Lf9YAjbD4Y8130rl/Zg6uDXXjju/6JupaIUdXfkTmR8pm2SU3Ss3XuZtXsvZ9rGlG/WnuJ8SBQje1T/r2GKl5zVzp07DXaUK1eO/fv307p1azp27KgOdA0JCWHjxo0ULlyYMmXKmCNWIfKE3y7/DkCQR0nalW3G8jMb0D1aJE2j0eDv4iMJST6k0yus3HmRm+ExPIwzHnOx7LcLQPrg0k2MevMVZvx8NMvXXzmlDVduPWDD71epGuRJQPHCRDxIpFwJNy7eiMbb3YEy/pn3Yuc0jUbDlyMaEB2bhE8RZ5JTtOw7GsqPm/8lVZt5vbQnVS7twekraUVdX6tSjL9O3QZg79FQ2tQtYdb3KMzPavjw4Wg0GhQlba57xtfz5883OuHu3buMGjWKNm3a5GqgQuQFd2PvcfH+VQCcbNIeY46uN4SDoUfxcvSgc/nWMnUyn3kQm8zYb//k1r04o2MOdlaM7FGd7349RVRMsrpfq1NMJiQ/T2yJayE7omOT+PvMHRztrHFxsqVyoAcajeHjkoy83fPGI/NCjjYUckwrl+BgZ03beqVoW6+Uenzv0VBW7LxApQAP2jcI4Kvlx7l2O20sysf9a1GzvPGszdDwWIZ8sReAh/GmB9hmJi4hhbHf/kXInRiqBnky6e3aWFrKF4KXmdXPP/9s7hiEeGkkpCapr3tU7ghA1aLlqVpUFhnMbzYduMqBE2FcvBmdaZtyJdyoXbEotSsW5UFsMpdCo/ksw1ofGbkVssO1UFqpAVdnO9rULZkjcZtTk1d9afKqr7r99fsNSU7VYWeT+cKBvl7OBPq6cDn0QaZt9h+/xcHTtxnatQo378YyZfEhEpIMp9mfvBTBzF+OMeatnCkYK3KHVc2aNc0dgxAvDb2S1k3t7uBKEVk2Pt9KSEpl4cazRvtb1vanf/uKKIrC1r+uU7tiUfWYi7MtNct7s3lWB/69FsnmP69RxNWB4NdKcvRCOM1r+uXmW8gTNBrNUxOSdBaPZu8oesXk8Vm/HAPg7zN3nnqd+w8SURSFiOhEPF3tpdfyJSTrXgvxHNKTEhkzkr+lL92errinI3NGNcbG+vEaNa83Dcr0/Aql3KlQ6nHSmh97RbJT+oKEOr1CQlLqc9XhGdylMr5FnBn33V9cvBFN+w/SZgMF+bnw5fAGrNt3hV92XMDRzpoHcckMe70qLWs/30wkrU7P6cv3CfJzwclBqn3nJJNJydGjR/n111+5desWDx8+VMeYpNNoNGzatMnUqULka/pH/xcsJSnJ1zJ+5q2b0Q4rS418685B6XV6pv10BI0GPhtYlypBxmNrABpUK86QLlUM1llJSjZeMfnSzQdqggLwIC5tzM+8NSd5tVwR3AsbT+3PzMINZ9h2MAQba0uWTmopxQtzkNEn6+LFi+nduzfbt28nLi6OwoUL4+LiYvCncOHC5ohVCLOTnpKCIeP3MGsrC0lIcljl0h7qa0WBCd8fZNHmf5n84z+0G7VRPTZnVCM+7PWq0cJvdrZWLBzXDC83hyzdb/CMvVmOLS4xlW2Ppm6npOqYtDDrNYfE8zPqKfnxxx+pXr068+fPx9nZ2RwxCZFnSVJSMKT3lEix3NwxvHs1dh26wc3wWHXcyPonqh4DxCemGu1L5+3uyA/jm6vbuw/fZPaqEzSoVpxBnSvj7GDDjJ+P8Oep2yQmaxnyxR5Cw+No36AUb7Ysi4OdNbEJKXyz9hR/nbpNi1r+FPVw5Ket5wzuk96r8ywJSWmxSq/K8zFKShITE2nXrp0kJEKYIEnJyy8+MZUd/9zg523nsLG2wMvNkQbVirP97xAiohPp1bosPOopkR6S3OHl5kCvR4X+dvxzg3lrTqrHLC006B4NgM04pudZmtX0o9kTg4vf7/kKfz5aFyU0PG2K96YD19h04JrR+TsP3TDYLuvvyoUbmc/EyigpRUv38dsM9o39Xw3qVi6W5fgLKqNP1lq1anHp0iVzxCJEnqdXv0HLL6uX0YWQKN6YsI3FW/5Fp1dITNYRcieGn7edV5d6X7b9groQmi6T2SAi57Ss7c+oN18BoEvj0myY2Z7+7SvSpm4JAn1d/tO1ra0s+Lhfrec+b1Dnynzcv7a6vey3809t//26M0b7pv10hFSt7rnvXdAY9ZR8/PHH9OvXjx9//JEuXbrg4uJihrCEyJukp+TloygK2/8O4W5kgslHAiLvaVTdh0bVfdTtjg0Dsu3aNSt4s3RSK2ysLXCws+b0lQgWbjhLyJ0Y3ArZ4lPEmUkD6nDzbtrKvdXLptU0ypigrtp1iW1/XWdsn5pUCvAwuH58Yiq7j9w0ee/Oo7fwYa9XaFAt7b1FPkwkPjEVPylIqDJKSooWLUr37t354osv+PLLL7G1tcXCwvADWKPRcOzYsVwLUoi8QpKSl8+G36+yaPO/BvvavlaSt9qUw9baksiHSazbf4X9x0Lp0iSQn7elfQt2L2yXrb8MRd7h4myrvq5c2pO5HzQ2ahPg42KwbWmh4f/ea8D7Xx8AIDYhlbV7LhslJWO++VN9/XG/WtSs4M26fZfVAoQzlx1j5jLj35+WFhoGdKxE29cK9vRxo6Rk9uzZzJ8/Hy8vLypWrChjS4TIQJKSl8ulm9FGCQnAW23KqQMQi7g5MKhzZQZ1rgw8ff0RUbAF+rrybreqzF19EoDjF++xZs8lbK0tKeRkS7UgT0LuxKjta1ZIW1a/c+NAyvi7GSQsT9LpFeavO82d+/H0CS6PVQFdLt8oKVm5ciUNGzbk22+/NeohEaKg23RhFyBjSl4GZ6/eZ+riw+r2vA8aU8zTEdBgbSWfbeLFtKjlT4VS7gyavgdA7Vl7Up+2hqUnKpRyZ/0X7fhs0SGOX7gHwKwRDRg1+4BBu40HrnL43F0ql/bg4o1oGlb3oVOj0lhoCsbAa6OkJDU1lUaNGklCIoQJWn3aIk3WljLNLy+IfJjItCVHCPApzOAuVYC0mjVPLhHfrVkQ/kXlub3IHsU9nZj5bn0+nPtHpm3a1S9ltM/K0oJPB9QhJVWnziTaMLM98YmpRD5MZORXv6PTK9y5H8+d+/EAhGw9ZzAt+fWmgfRuXS7fJihGSUmjRo04evQob7zxhjniESJPS32UlHQs19LMkQiAuatPcvFmNBdvRqsLXD3J39uZlrWeb1lxIZ6lbAk3Ns/qoG7/uvcyS7aeI9DXhQ97vfrU6csZj1laaNTqy4s/acHEBX9z/XZMpueu2XOZNXsuM2tEA4L8XLPnzeQhRknJsGHDGDlyJJMmTaJr164UK1bMZK+JzMoRBZFW96inxELKRpnbvagEjj3qBjelV6uytK1XCid76dUSOa9Lk0C6NAn8T9dwdbZjzqjGhEXEcf32Q4p7OjF81n6TbUfNPsDQrlVoUctfLWiYHxh9srZq1QqA8+fPs2rVqkxPPH/+6fO0hciP0ntKrCQpMZvrtx/yzdpTXMxkIavink7M/aCxjBsRL63ink4U93QCMOiNiU1IoefH29Xtb9aeYu/RUL54t36ux5hTjD5Zhw4dmm+fVQnxX6WqY0okKcluer3Cv9ciiYlPYc3eSxT3dGJo1yoGy3RHxyYZfXMs4+/KR71eJT4plZLFpC6XyL+cHWzYPKsD8YmpfDTvD27ejeV8SBQDPt/FF8Pq41rIztwh/mdGn6zvvvuuOeIQ4qWQqkurZyGPb/6bDb9f5eDp2wT6ufC/NuW5cTdGXf8h3dVbDzlwIkzdzrjcOECrOiUo7eNCi1p+8kVKFCiO9tZ882ET3pr0G9GxydyNTOCtT3dQxt8Vt0J2DO9WFScHGwD+vRbJ1VsPeK1KMZJSdHi5ObBq1yX+OBnG/73XIM/V5pFPViGySFEUElLTliKX2Tcv7nZEHD9uSpsdcz4kymTdEVMyJiRtXyuprisiREE1a0RDxn77J+FRCQDqI830oobuhe2IfJgEYDQjDTCqz9O7dTk6Ny5t1jVSjJKSefPmPfMkjUbD0KFDcyQgIfKqZG2y+trRJmsl0oWxqJikpx4f9noVKpRyJyY+hWMX7rF6d1otrrfalOPGnViKeTrSo0WZ3AhViDzN09WeH8Y3Z92+KyzeYrxIYHpCklVLt59n6fbztKufVjnZ0QyDxJ8rKdFoNCiKIkmJKJCSdCnqa3url//Zrbmkf4sL9HUhNDyWpJS0ImVrpwdj+8Q0yvIl3Xm9SSBanV7tjhZCGOrcuDSdG5fmQWwya/de5tLNaLQ6PUkpOrzdHahftTiFHG04ePoOOw/doGqQJ92aBTHu279MXm/zH9fwdnOgfYPcL7NglJRcuHDBqJFerycsLIzly5dz5MgRFi5cmCvBCZGXpGjTkhJbSxsZw/AComKSWLjhjFo63tJCw9j/1eTPU2H0bl3OKCFJZ2crT5mFyAoXZ1ve7lAx0+OvlPXi3W5V1e30mT1DvthLaHgsTV71Ze/RUABi4lNMXSLHZel/u4WFBb6+vowePZpRo0YxZcoUZs2aldOxCZGnJD16fGNrJd/Ys+rWvVju3I/nathDfvnN8AtPy9r+VC9bRK3CKoQwj28/aqK+1mhgz5FQVu2+hKWlBWX9XfEvWgi3XJrZ89xfQWrUqMGXX36ZE7EIkaelPJp5Y2spScmz6HR6ftlxgTV7Lps8XtTdkfrVfEweE0KYj4bHvcDLdzz+IvF2h4p0yIXHOc+dlJw9e1bq4ogCKb2nxEZ6Sp5Kp9Mzfv5B/r0WaXRs4tu1qRLoKQubCZFHnbxkepXke49m+OQ0o6Rkw4YNJhvGxMRw9OhRdu7cyeuvv57TcQmR5/x7L20WiJ2lrZkjyVtStXom//APPl5O9AmuQNcxWwyOVwvyJPReHEO6VObVcl5milIIkRX2dtbwaNbOhpntuRb2ABsrS/y8nXPl/kZJyZgxYzJt7OrqysCBA19o5s2UKVPYu3cvYWFhbNiwgXLlyplst2bNGhYuXIher6d27dpMnDgRa2tZE0KY36FbJ4DHq7qKNJ/9+A8nL0dw8nKEUSGxyQPrUK2MjBkR4mUxtGsVlm4/zzudKmFpoSHQN3eL/hklJXv27DFqpNFoKFSoEE5OTi98o5YtW/L222/Ts2fPTNuEhoYye/Zs1q9fj4eHB4MHD2b16tW8+eabL3xfIbKLlUXa7JDmAS93nYnQ8FiW/XYeC42Gj3q/mqWZRAlJqQYrP+p0epZsPceG368atMv4yGbTl+1llpIQL5kKpdyZPrSe2e5vlJQUL148R25Uo0aNZ7bZsWMHTZo0wdPTE4AePXowf/58SUpEnpDeQ+JTuKiZI3lxf52+zfSfjqjbGs0xPur9aqbt9XqFEf+3n5A7MVQvU4QWtfxxsrdm6pLDJCZn3mPUqLqPJCRCiOeWpxYAuHPnjkFSVLx4ce7cSVtoacuWLWzZssXkeeHh4bkSnyjYtLpHxfhewro3iqJwOfSBQUIC8MfJMJwcrClfwo3Vey4RGh73aOqfgqJAdOzjVWyPX7zH8YvGg+AsLDTM+6AxQ77Yq+6rU+nlTdyEEOZjBdCuXbvnOkmj0bBp06YcCSgzwcHBBAcHmzw2aNCgXI1FFExafdrKo+mPcV4Wd+7HM3DaboN9LWr5s/PQDQC2Hwxh+8EQ9Vhmy8CX9nXhSugDg33ffNgYP+9CAAzqXJn5604D4OuVO4PihBD5ixWAi4tLlhrfv3+f69ev51i3bNGiRbl586a6HRYWRtGi8o1L5A2RiWnFrqxeop6S2IQUo4SkU6PS9A0uz8lL97gXnWh0zsS3a+NWyA6NBpZsOceVWw+YPrQevl7OKIrC1VsP+fvsHZq+6ksxz8fjzBpWK87FG1EUdXeUpEQI8UKsAJYuXfrURhERESxcuJBVq1ZhaWlJ+/btcySYli1b0qNHD9599108PDxYsWIFbdu2zZF7CfE8HiQ+VF+72buYL5DndPXWA4PtL4bVp1xJNwAWjmtOfFIqigI37sRwOfQB7RuUMqgQ+unAOmq9K0jrJS3t60JpXxejezk52PB+z1dy7L0IIfK/p37lu3//PgsWLGD16tVotVratWvH4MGD8fPze+4bffLJJ+zfv5/79+/Tv39/HB0d2bVrF+PHj6dJkyY0bdoUX19fhg8fTo8ePQCoWbMm3bt3f7F3JkQ2uhVzR33tZOtoxkgyN+PnI/x56jZl/F3p164C/t6FWLr9vHq8YoA7gX4u6raFhQbnR0XuKpX2oFJpD5PXlQGrQojcYjIpSe8ZyZiMDBkyBF9f3xe+0eTJk03unzp1qsF2t27d6Nat2wvfR4iccDs2bTB1Xnt0o9PpuRr2kEWb/1Wn4168Ec3oeX8atZ02xHzT/IQQIisMPmEjIiJYsGABa9asQavV0r59ewYPHvyfkhEh8oNz99JquFT2Nr3oX25JStZy424M8Ula/jwZxq7DN599ElC/as5M9RdCiOxkBXDv3j01GdHpdHTo0IFBgwZJMiLEIxfvXwPA1a6wWe4fn5jKueuRTP7xUKZtqpcpwputymJtZcHmP65RMcCdOpWKcelGNGX8c3dVRiGEeBFWAM2bNyclJYVy5crxzjvv4OPjQ0xMDP/++2+mJ1aoUCHXghTC3NLHVbxavHKu31un0/PGhG1PbeNob83w7lVxL2wPwPDu1dRjVYI8czQ+IYTILlYAyclpCySdO3eO995776knpI/EP3/+/FPbCZGfJD+qEFzE0T3H76XXK0DaQNR1+65wIkPVzrL+rnRqVJo6lYpy8UY0RdwcsLTQYGdrha31y7V+ihBCPMkKYNq0aeaOQ4g8affVP1l1djOxKfEA2Fplb4XgVK2OzX9co0TRwthYW+Dt7si0nw5z6eYDxvWpyeItj3sr7W2tmDm8gbpdtoRbtsYihBDmZgXQqVMnc8chRJ609dIeHiY9rnxrl41JyfGL95j1yzFi4lNMHv98yWGD7TZ1S2TbvYUQIi+yeHYTIQqmVF0qYTF31e0SLj442Thk2/XnrDqRaUJiSqdGpbPt3kIIkRflrUUXhMhDlp5ap76e3nwsJVx9sNBkXx4fn5ia6bGa5b3p174ChRxtCLkTQ6lihXG0t862ewshRF4kSYkQmfjt8n71tat94WxNSAC0urQBrYsmtCD0XizFPZ3wcnNAp1ewtHi8imqlANMrrQohRH4jj2+EMCE68SFFnYoAUMzZC1f7/7Y+SWKyluRUnbqtKApanR4AKysN1csUwcst7dFQxoRECCEKEukpEeIJt2PDGbn9UxQlrSfjrapdjNro9QoWWUwe9h4N5asVxwGoGuSJn7czxdwf18+xtpTvBkIIAZKUiALucuR1joSdMtj3981jakICYGNpY3A8NiGFYTP3UbOCN0O7ViEpWYudreF/pQMnbnHhRjT3ohI49O/jwbInL0Vw8lKEQVsrSUqEEAKQpEQUcP93cCGRCdFPbeNgbWewvedIKFExSfz2dwglihZi/rrT1Krgzfi+NVm+4yLHLoRzOfSB0XWa1/TjwMkwklN0BvutrCQpEUIIkKREFFBr/93GxvM7SNalTcltFlAfG8u02S3bLu1V2zUrVY8SLoY1oDI+tZm/7jQAh/69S/sPNhnd5/WmgXi6OvBKmSIUcXPg3W5ViYpJ4oulRzl3PYrino4yhkQIIR6RpEQUOMnaFFaf3axu+xUuztuvvKHOrulZqQP7Q/7mlWKVcXcwLmRnqhckIw8Xe15vGkjDaj5G03g1Gg3uhe2ZPrQeYRFxeLjYq3V1hBCioJOkRBQ4idok9fWkxu9TzrO0QWJgY2VDi9INTZ4bEZ3I/uO31O3+7SuSkJSK7lG9mtoVvQn0fXZFXo1Gg08R5xd9C0IIkS9JUiIKnPTieraWNpQvEvhc5z6Ie5zQzBrRgCC/ZycgQgghskZG2IkCJ1mbNo7E1srmGS2NpWrT1hYp6u4oCYkQQmQzSUpEgZOQmtbb8SLF9R4veCb/dYQQIrvJJ6soUOJS4vlk75cA2L5IUqJNGzsiC54JIUT2k09WUaDcfBCmvq7iXf65z4+OTetlsZaeEiGEyHbyySoKlFS9FgAvJ0+Ty8c/y96joQDY2lhma1xCCCEkKREFTKouLSlxtnF8RkvT7kUnAFC5tFTuFUKI7CZJiShQtI96Sqwtn382fHRMEncjE9BoILheqewOTQghCjxZp0QUCCnaFP4OPc6ZexcAsLJ4/scvi7f8C4Cfl7PRSq1CCCH+O0lKRIGwP+Rvfji2Ut22t7J/7mvcjUx7dOPp6pBtcQkhhHhMkhJRIDxIigXA28mTIPdStAlq/NzXuHgjCoDOjUtna2xCCCHSSFIiCgSdXgdAtaIV6Vu923Off+NuDI/K21DY8flXghVCCPFsMtBVFAg6JS0psXyBsSQA565Hqa99vaSQnhBC5ARJSkSBoH3UU/IiA1xTtTpi49Pq5TSs5mNQUVgIIUT2kcc3okBIf3xjqTFMSvR6RV2lNSNba0ucHGxYt+8yi7ecU/fb2cqiaUIIkVMkKREFQmxKPACWFo87By/djGbU7APPdR23QnbZGpcQQuQkRVG49OVXRP79DzWW/Ih1obz9+Fke34h879L9axy8eRR43FMyZ9UJo4TEylKDlaXpRzNebg5UL1uErk0CczZYIYTIRolhYdz/8y8UnY4L02agKIq5Q3oq6SkR+d62y/vU1442aeuT/HX6trpvZI9qNHnVT91OSEql+/htBtf4bnRTKcInhHgpJIXfI/HWLUKW/EzCzVB1f8y581yY9gWB7w3HyuHpazUpimKW8XO5lpSEhIQwZswYoqOjcXJyYvr06QQGGn7rPHToEAMGDKBkyZLqvlWrVmFnJ13m4sVV8AxSe0rq+dUkISmVhKS05eZXTmljtDqrg501yz5txZ8nwyjsbEudSsWwtJDBrUKI3KXo9WgePXJOuHWL5HsRuFSrijY2DitnJxStVm2rsbIiOTycsx9PIvleRKbXjDp0mEM9egHgFBhIhUkfY+X0uBZY5KHDXJ49D1182iNv97p1KNH3LeyKFMmJt2gk15KSTz75hG7dutG5c2d+++03xowZw6+//mrUrmTJkmzcuDG3whIFQHqy/2rxKjjY2LP/WNo3B0c7q0yXiy/sZEtbqW8jhMhF2vh47mzZlta7YaHh/oE/AbBydkIbG2fQVmNpiaLTPfOadkW98W7dCo96dTnab6DBsbjLlzn05ltPPT/y4N9EHvybch+Pw+3VV57zHT2/XElKIiMjOXv2LIsWLQKgZcuWfPbZZ9y4cQN/f//cCEEUYPpHz1Cv3XrIoOl7CItI+8/t7vL8S80LIUR2S46M4viQd9EnGc8EBIwSEuCZCUn1b+diX7yYwb7aq37hn+5vvlCMEft/zz9JyZ07d/D09MTKKu12Go2GokWLcvv2baOk5ObNm3Tq1AkLCws6d+7Mm2++2A9QiMfSkpKI6ERSIh7/5+7Zoqy5AhJCFGAPz5wlOSKC25u2EH89JEvnFO/SibD1G3HwKU7JAf1JffCA6GMnKFyxPLaeniSG3UbR6bDxcMe9Tm2T40Es7eyos3YlsZcu41wmiMRbt4i9cImr331v0K7i1MkUrlgBSEuYov45hHud2v/5fWdFnhroWqFCBQ4cOICzszN3795lwIABuLq60qZNG7Zs2cKWLVtMnhceHp7LkYqXiT7DaPPKpT1o/IovNcp7UdjJ1oxRCSHyq8Tbt7k8ex6xFy6q+2qv+gVLOztSY2I4O2Fipuc6lylDxamfYmFt/Gi5xFu9DLY9G9RXX7tUrZKl2CysrSlcoTwAjiVK4FiiBF7NmxLxx5+4VquKdeHCBu1t3d0o2rZ1lq6dHXIlKSlatCgRERFotVqsrKxQFIU7d+5QrJhh15KTk5P62tvbm+DgYI4dO0abNm0IDg4mODjY5PUHDRqUo/GL/EFRNJTyKUyzmn7PbiyEEI8kR0Zx9bv5xF68TPkJY3EKCuTByVPEX72Gc9kyaq9CuuNDR4Beb7DvWY9NNFZWVP92DnZeXtke/7NoLC0p0qhhrt/XlFxJStzd3alQoQKbNm2ic+fO7NixAy8vL6NHN/fu3cPDwwMLCwvi4uLYt28fXbt2zY0QxUtGURRWnd3MrZg7BvstsKBZQD0qe5cDYM4/i/nzxuG0Y44xWFnKtF4hRNbFh4RwatRodabL6Y/GYu3qQmr0A7VNla++xKlUSRRFIXznLqOExBQ7by/Kjv0IB39/UqKi0CcnmyUhyWty7fHNp59+ytixY/n+++9xdHRk2rRpAIwfP54mTZrQtGlTdu7cyYoVK7C0tESn09GqVSu6dOmSWyGKl8jNh2GsO7fd5LF/bh1nQfvpONk4qgkJAFprSUqEEM8lPuSGwdRbwCAhATg18gOKBrfhzhbD9Y1qLPkBG1dXku9HcrR/2swXaxcX7LyKUDS4DY4lSgBg6+6eY/G/bHItKSlVqhSrVq0y2j916lT1da9evejVq5dRGyGedDs2bRyRm70LncunPe8Mj4tg88XdAHywYwrONk4G56Rcq4y1vyQlQoisU7Rps1xcX6mOdeHCPDh9hpT793GpXg1Lezsi//obwCghKffxOGxcXQGw9XCn1oqlJN2+g1PpgNx9Ay+ZPDXQVYis2n31DwAK2znTonQDdX9YbDjHb58hJjmOmOS0mTa2OPHgcD1ACuoJIZ6PokvrJdFYWRI4YpjhMUXhXPxnPDh5ymC/qTU9rBwcJCHJAvnaKF5KVhZpI9P9XXwM9n9Q13BxoOpFK9K5aH91u2E1w/ZCCJEZfWoqV79Nny5rPMVWo9EQMHQQtkWK4P+/3ry28Vde2/hrrqznkV9JT4l4KWn1qQBU9jJca8TK0oolnf+PS/ev42pfCH8XH7b+dR2AOpWKyjRgIcQzxV6+Qvy1axkSEoi/ft1kW7siRXh14Xe5FVq+J0mJeClp9WnPea0sjP8JO1jbU7Vo2jz8FTsusHxn2loBN+/G5F6AQog8TdHpSImKIin8Htr4eKKPncDWw52bv6ww2d6zYQOT+0X2kqREvJRSHo2Gn7XsBMQ8rvir0Wjo0qQ03ZuVQafTqwkJgIuzFHYUoiBSdDqiDh/Bztsbx5Il0KekcHzo8KcWrktn6ehI0PsjcH2lei5EKiQpES+dK5EhXI0OASAlVUGfYlgDYtn2CzjZ23DjjmHPyKie8pxXiIIm9uIlTn80Vt22cnbCrmjRZyYk9j7FcSxVisDhQ02uripyhiQl4qUSmxzHx3tmqtsezs5MHdoMgMRkLcNn7Qdg/rrTahtHOytWTm2bq3GK/O/64p94cOIk5caPkUWv8rCMCQmkFbeLi70MgJWzMzV/XoTGwoL46yHoU1Kwdiksf59mJEmJeKk8SIpBp6Stlqi964ezpgje7o7q8YXjmjHg893qtpWlhhnD6htdR4hnURQFbWwcFrY2WNo+HiCtT0nhxrLl3N64GYBjA4fg4O9Hwo2baKytCRw+DOeg0ui1OnSJiQDYFy+OlUPuVqVOunuXlAcPCd+xk8i/D+HfuydF27YxaKM8WnlUY5E/J2KmREWrr4t36YRHvbqcGvmhus//rV7qe3csWSK3wxMmSFIiXirJ2hQArPWOJN4sj2/1QgbHvd0d+b/3GnDw9B08Xe1pXaeEyWqZQjzL2QkTiTn7LwCur1TDvW4drsz91mTbhBs3AVBSU7k066tMr+lctgylBr6NU0Cp7A84g/Dde4xivbbgR279up5C5cuhS0om+shRg+Our1Sn3ISxuZ6gKHo9cZev4FiyBBY2Nv/5egk3b6KNT8C5bBnirl1T96cXs3tt469EHPgD60KFslzETuQeSUpEnnYv7v/bu+84qcp78eOfc2bOlG2zvS9FqRLBAogao4IGVCzRQCQxUZKfseTmJiENY2Kiiddy87pqjIliEBIviSXm2hVRrGCLhSIWWMr2OrNlZqef5/fHwMCwswsss7vD+n2/XrycOeWZ53mc2fM9TzttrK99j+ju2TatPe7YDhVbBG3mMaW9zhlflcf4qrwhy6MYeZRS8YAEwPPeB3je+yDhmJxjJmOGQni3Vce3aVZrryXJdZsNMxQLprs/+ZQNS35K/kkzKZg1k+xJE7EXFqbkYryHd/v2PoOnULubttfXJd3nee99fNt3DOkCX0opmte8GJ96e8rj/4zfRCjTRJkmuvXgL1P+xiY++P6Peu/YL9Da9+m6Ir1IUCLS2h/fXsknbdW9tuvR2B9xq3VkNjuL4WUGg/HXY7+zmLY31hENBOjZVYPF6eTE+/+MkZ0NxC6e/oZG7EWFWOx2Ojdt5rM77qLi4q9Qdu480DRC7W7a33yLHX95AAD32+/gfnvvc5mKz5rD6MsWxZclP5DaRx+j5n//Ttn8c/Ft3wG6Ts4xkyk4eRYbfvzz+HF7VhZVpom3enuvtTecFeWUnjOXHX9ZAUC4s3PglXaIfDt38eEPliRs6/7kU3ImT0IpxfpLvgamSeZRY/Ft30HpOfNwTf0Cjc88h7++nunL/oxus6GUItDURPWf7qNz46aknzX221cMQYlEKmhKKTXcmThcV199Nffee+9wZ0Ok2ObmT7nplTsBKMsuZkrRBAAa2ny8/6Yd5cvlN1fO4sRJMihNpEY0GKT5hRfZ9eCqeGCy7917pKcH3WY7pLv3fQXb3bS98QY7Vz6Y9EmyZeedg724mOLZZ2Dk5CRJIWbdhQd+UKnhcnHCn/6ANSvxGVCB5mZ2/vV/yTvheErOmg3Aput+SdeWjwGYseIvsRYfM4otN/cQShebetu0eg05U44hc/SohH1Rv59wVzf2okI0XeeD7/+QnprahGPGfmcx7W+/g6OkhJaX1h7SZ+9r9Lcuw15YSKC5mdJ5X+63LsXw2v/6LS0lIm1tbd+7guJtZ1+Hw3DQ1uFn8UMvxLfnZKau2VscGVpffZ3aR/6Jo6yUkjmzyZ48CVuuKyVpN69ew47lKxK27TsmyZqRcVjp2wvyqbjwAiouvAClFN2ffMqmpdfH9zc+E3vy9c4VfyXz6KPInTaVygVfPbhBsroeD3Rc06Yy5Te/Sjo+xFFSwqSf/ThhW+ZRY+NBybuL/1/CPktmJjP/uvygpsU2v/Qy2++7H4Bjfv1LOjdtJuTpoGfXrliLzm62ggJC7e29zt9T9/t2nR2qZM+dEUcOCUpEWlJK8Y9NTwBwzrjZoKwEQhFaPD3xY/5jwTTGVeYOUw7FUOj8aAs9NTX07KpFt9swsrPZ9eAqAPx1dQmDNQ2XC3txEZrFwpjFl5M9fhya5dAewBhobk54P+OvDxx+IfqgaRo5kydx6hOP0b11G55/v4cZDlP/2P8B4Kvejq96O/X/epySL59F9oTxtKx9hawJ4+NpVH1tAeGuLsrmn4uzrAx/fQNGXm68a+lgjbniW3Ru2hwfsLuvqM9H0+o15M+Yji0/j5Dbjb2wMF633u07aF+3Hs8HG/BV7+1q3XLj7/r8vP0DkqIzTqf1lVcTttmLiyk89WTGXPEtfDt30vziWiouuhDdZrDtj3+K7T/lZD797/8hGgwy6tKFlM0/d8TOJPq8kO4bkZaava18/5kbAAjtnEy0ZXTC/lGl2dzz09nDkTUxRPwNDbx/zfcPO53i2Wfib2wk5HaTP3MGjU89E983/kc/wF9bS/bkSWRPnMA7l10BwKjLvk7VggN3kQyG5hdfwvP+BwQamvp83soeJ/3jf1M61TjS4yfU3o7hctH10RY+ufX2Po/NGD2KjNGjaXvt9QOm65o2FYvDgevYL9C0+gWsGZn01NVhLyxg6u23EO7q4r0rr4kfv2+XmRjZpPtGHBE8/r0D7qKtVb32T5dxJCPexzffFn/tKCsl3NGJ4coh0NRM3okncMwN16OiUT77n7toeyM2o8TIyyPs8SSk07L25fjrfQMSgK133JX0s/ddl2SolZw1h5Kz5sSWRv/3ezQ8+XTS7oz8k2akfO0Ta4YTa0bsSdoFJ5/E5F9eR92j/yLQ0kzY05FwbM+umoSWlfyTZlJ85hnYS4rIqKrCu62aqN+Pa+qxCWNwys/vvZChxeHglH89gm9XDZmjR0lA8jkmQYlIS//12h8BMHuyQOksu+4s8rJjFwpN17Abh9YsL44ssRktsWcajf/B9ymefUZ8X8TrxeKMXYw1i4WJP13CxJ8mzuIId3Wz/b77CbS0kHX0UTQ9t/qQPr/g5FmHV4AU0CwWCk6aScFJM2lb9yaB5lgwtv8A0sGUP2M6+TOmAxBsbaX7s610f/Ipnvc/xF9XB0DBqScz8cc/6tVVljN5Uq/0+qNZLGQdNTY1GRdHLAlKRNpRShGMhAGIdhRx+XnHUFaYeYCzxJFORWNr0WgWC5Hu7vigzcIvfTHhuP1nkyRj5GQnBCpHX/1deurqCbW3kzttasKx0WCQjg83YC8qIqOyIqVrhqRK4aknD3cWsBcVYS8qovDUUxj7ndg2MxIZ8EwkIZKRb5NIG+FomP/7+Hnc/k4Uu6dLNo/jkjPHDW/GxKAId3UT8fmwZjhpfG41dY/8ExWNxtae2B2QWLOzU3bRy6isIKOyotd2i91OwUkzU/IZnzcSkIhUk2+U6FfUjLKzow4NGJ1biUW38FL1G9R3N5PvdHHu+NnoKRrtvnrbq/zzo2fj71XEyp0/nCP9y2lMmSY9tXX46+qJ+Hy0vvIqGaNGodttRHt6CHk8OErLCLa2kjl2DOHOTsKeDoJt7Xi3bk2a5p7VTwHyTjh+qIoihEgDEpSIuFA0zJ1vLqfF20bYDHPO+DPZ0rKVt+reB8DQrXxx9Exe3rE+fs7fPnyMUa7Eu8+oijKlaAJnjD2ZcQVj+v3McDTMmurX6Q76eGzL3oAkXDcesyuf8q8d2tRGMTQ6P9rC5l/8Kum+ro+2JN3ufuvtftN0lJdTdu48rNnZuKYcg24zsMqiV0J8rkhQIuK2tu/g3/Ub4u8feP/hhP1hM5IQkOxR01nfa1t9VxMvVL/GRZPnJv0spRSTisbxQcNmXqh+LWFfqHoqemclp0wpxZBl5NNKx4cbqP+/J+j4cEPS/Zph4CguIm/GdCJd3QRaWuja/BGGy0XE56P0nHnY8vOwZmUR8XrJnzkDW24uEZ8Xe3GxtIoJkWLKjNL23DKiPV04xxxLzvRz0DQNMxxE0y2gWwBFqKWGcFsdobY6go3V6DY7Rn45lowcrK4iMieeNCT5laBExPWE/PHXFmUjqu1tRo+6S1CmTm6WnQ5viGhrJSgN9MSlsjVbAD2nHWthbObE4x/3PevhiU9eSHhvBh2onmzOmjCL//iqNNsPJ6UUjU8/Q+emzRSfeSbb7vkzRq4Lf21dwnHjvv89Ck89OT4bZqCsWTKQWYiDpZRKGsArpQi17KLjjUdB0wm7Gwk1713rpuezd2h/Yfl+Z2nAgZcrc82cT8HZiw8z5wcmQckIsN29i7veeoCecKDf40xlMrVkEuPyxyTdv6EuthpjtCsf/yczsBTWo9mCmP5MTE/sabytB5GfaFsF0fZSLK52DKuOvt+PRxkBTEcHhsVCMByFqIXQzikoXy4AixYd2lRCMXDdn22l8elnsebkYORkY+S6aHjy6YTgw/32uwCxGTG7ZY0fT+k5X6ZkjixgJ0Y+ZUYJe5rQNB1rXulBt+gppTADXgB0mwPNYqCUAjOCGfQT6WhBRcMYRaPwbnqVqNcDFiuRzhZUOITv41jLtDWnkEhXG5bMXNB0oj1d6IYNMxhb4dqS6cIM9KCi4YGULv7KklNItKst/j7r2NPx79hI1NeJJadgAGkfOglKRoD3GjbR2N1yUMeuq/k362r+3f9BEQPQiLZVxjfNP3Usxu61QSy6xpknVlJZnN0rvo5GTTZua+PGv7yF2VlMfz8R/z6vT51WztRxhVSVZFPgSu2CUJ9nwda22ODSri7a3lhPyO0m2uPHlp8Hukb7ujcPOi3NauWYX/8SZ1kp9qKiQcx1egg0bKN99V+wFY3CKKzE4szCkpWHJcNFsHEb3i3rsLoKsZcejSUrj0hnC0Z+Obo9A6urCEumC023oFnkz2wySimCDduwFY9CN4ZvsboDCXuaaPjr9UR9HfFt+Wd+g1BbfSyI0HXyvvhV7BUTQZmgFF3vPU/H209hBntQwZ6+Ez9Ikd2Bwr55MIOR+Ouob7+nO1usOMrH45p5PkZRJUZuMZrFwPfpOwTqP0XTdDInnoQ1vwwVCRP1ejDyStDtyZ/tpJSJpg1NV7r8WkYAc/eTAk4ZNZ2LJ89LekxX0Mva7ev6Tae1w89H1R6qLMdyx39fwPNv7aS9M0BlcRZnnth7VdVkLLqF6ZNL+Oet82ls8yU9JhyJ8tH2dmLNhuC0WzjtuAoyHAd+4Jc4OPVPPEnH+x/2OfZjf7nHTcPidNC56SMiPT1gmoy54luUzT8X3TD6bC4eqZRSNP79RlSwh2BD8llCe3g3vtJ/YroFzWpgyXBhyczFNeMcMsad2OcF4FCZkRCmrxPdmY1ucxDpduPfuZHOt57CmltEpLMNlMJWPAqrqxjNsGHJdGErrCTq7USzOdCsVqw5hRi5h7dSshnsoeXJP5B1zKlkTTktYV/E60GFArFgzbDTvfFl2p75c3y/UVBO5ZV3DEoQp5RJsKEa3ebAmlOAbs8g2LidsLseFY2gohEwo0S62vFt/TeabsFRNZmwuxH/9g96ped+eVXCe39172MGyl52NEZRFUZ+OdFuN8o0yZwwHTQd/67NWLPzY8GvM5tQy05UJIw1pxDNakO3ObBk5GDklyVNO3PiTDIn9p7+bs3K7TdPQxWQgAQlI0KzJ3bxf+3dVtY+1ncriFIFHF3pYmxZ8ieqRtw+wjvayRlfhK5rnHvKwFdXtBsWxpT1PXNifFXegNMe6cxIhIbHn0QzDHKOmUzWuKMPOiBoefkVtt55d5/7K796Mcbux9Fruga6TsaoKlxTpvSb7nAEJEopfFveINSyC81wEGrZhdVViHfzG7tbLLLQLAa24jFkjDsBI68UFQmh2TOwOAY2RiXq76brvdV4P3o9fodrKxkbu4D7u4l0tRH1etAsBkZ+GaH2enR7BhFPE0DsQuLvxvTv7erCjKJCUSKhAJGOZlrqP41t161oVgMjtxhLdgGappF17OlYnNnoGTnojgysOUVJ69796kN4N7+GZjUIt+3uatN0rK4iIh17HyoYatmZ9HVfck+9BHvp0UQD3eg2J1ZXEdacQqzZ+fFjVCSMZt17A6GUSaSzFX/1B7S/+FdUJETPZ+/S9twyzGAPmtWGZnNg9nT1+9nh9gb8OzaQMe7E3emqWPeEUqhImGDDVnS7E3QdS2YetoLypOlEutqJej1Ycgoxgz7qli0BM5L02P7sOxYDIHPSLOyVkwg1bQfdgm5zYAZ8u7s3OnqdbxRUUHD2YhyVE9GsNkJtdYSad2AvHw/KxJJdgG61gQbhjhZ0IxYw9Sfj6MSxdo7ykbeGkwQlI0CzO9ZniYIDPV6xuq6T6rrOfo/JzUnfptSRJhoMoqImnRs28smtt6MZBrrVStTvTzjOXlSIbnfEl/a25edjKyxAt9kINDSiWS0YOTl4t1UnnDfuP64h2NqGb8dOsidPovLii4aqaAdkhoNoVgNN01GRMBGvG92WgTIjqEiIpkduIdxam/TcqNcdf92z9d90rPtnwn6rqwjHqCkYuSXozkyCTdsJNe/CVjwKNAvejWvJnHwKeactBKXQbHbMnm5an7mHUMve57nojiwq/9/vD1yWSAjNYqBpGkopwu5GdKuBZrXF7sQjQYKN2+l852nC7sbYOAMzggpFCLXsgpZdsbJsey8hXd2ZjTWnEN2egWaxEmqtQUXDmH5v70woMyEgAcg5cR5GflmsJUCZRDrb6Kn+gEhnC5rVhlFQAcqM5QHoWPdY0vIZBRWE2xNn2WVMPAkz4CPYsA2VZDzbnvEOKhJCRWKD5jWrLf46maaH/wtrbjGYZrzLoj+6MwsUmAEvuj0DMxSIdaEcAufRx6NZrKhIhEh3O+HW2P9/x5hjd1/0NdAt5Jw4F2tW8pup7k2voBl2bAWVu1uicnt1SdlLxmAvGZP0fFtB70X9Pq8kKBkB9nTfjC51ccO3k0/BDUdM1m9sIBLtP2qxWnROOy75HYhIrUBTE+9d9b2EbSocJhreOxJHs8b+WAZbE/9Ah9xuQm53wrZgy95hyJN/9Qvyjj+u1/NIUkVFw/h3bibS0UywsZpg0w7QdGJXCBMwMUMBoj3dOMdOJdrtRjNsRL0eot4OzEgIorG7V81wJL2o7aEZdjLGTyfsbiTS2YqjYgKW7HwcVZOIdLkJ1n1CsHFbQr96pLMV76ZXeqW1792v7+P18YGEyThGHUPJxT85qPrQrXuXptc0LeldvJFfTtaU2JL5UX83Khwi2tNFsGk7/h0bUJEwZsBLqK0u3qpg+rsJ7dvqsp/sE76MGfCRO+tCdGcWYXcTmq5jFFbFukn6aOFS0XCspWb3/rCnic63nyJQ+zFmwIc1twQz2BOvr/0DEoCeT/dbd0bTcYyeghnwYclwoRk2NN1C5uRT9ulyyIoHKWF3I5rVhq14NN5Nr9D6VOx5V5GOvsfHWXOLE/bvG5yZycZu6FY0PTY4tfI7t6NZDILNO/FXv4/uzCb7uLNS0gqYfewZh52GiJGgZAQwd98ZGBYLedmOPo+76PSR19R3pFCmCZqGv7YW3eHA4nD2CkgAiuecSfaECYR9XgpOmoGR46Jz02Z0ux3dZiPS3Y3F6cSalUWovZ2Iz4dus2MvKiTY2krE58NeVETOhNF4t7yBioTR7U6cY46NzSBoq0OFQ2g2B7rNgfuVfxBuq0Uz7Og2B3pGDkQjhD1NRDpb0Z3ZaFYb0e52NMOBJdNF1Ovp9253f70uXvvXTZKARDPsaFYb2cfNoWD2Nw9cv0rF75D9OzYS9XoIuxuIdHuI+joI1n8Wv2gZ+eWE3bEp67ozK35h0x1ZGAXl6DYnRfOvxZpTeNBlPFQWZzY4wZpTgL10LDnHzdlblmgEFQmDrhNuqyPS2RbLr8UC0Qj+mi1EPE1kTJhJwZxvJaR7sGNCNEvi+C0jr5TCeVf2Ok5FI7GAz9tBT/UHqEiISHc7zrHT0HQLZjiIo3w8zrHH9kqzz8827GDYsVTsXRgxe+qZ2Csm4N/+IWg69rKj0XRrbPyHIxM0DRWNoBt2zJCfzrefwuoqwlYylkhH8+5ZLSbWzFwsOQWxWSrKjK3DsZ/+WizE8JOgZARQu1tKPk8DEdOZb+cu3O+8i263YXE66fhwQ7+zXFzHVGHPVShfHZbul/FvWIeKhGje+ghGQRlGQQVRTUezGIRaa9ANO0ZhFbrNgc3mJNiyk55mE92RidneSNeWejpWJ2neH4B9x0aocIBIx94AQrPasJePi91Zu4qwl43DXj4ONA1N0zGDPQSbd4JSsVkKmkbGhBlYs/PR7RmxgZ5KEe3pJNrTjb10bGyswj538AdL0zTQYheg/fvdD6qcwZ7YgM8hHNDXF81ijQ/2tJcdjb3s6IT9uadcPKR5cVTGpuhnThrcJyfbCir67cbYE2DoNmes2223PgMMTZ4kfiSSoGQE2NNSoqfBH9Sh0vbKc9Q++k8sdhuGKwdHaQm5x88gb+Zp/Z63/Z7baX/7A0KdIXRDw8i24ygpIHvyJJwVVWSNm0y0x0vtPx7EUVqCo6KSSFcXGWOOxjlqLM6K0eiGgWmamIEeov4eQm0tOEoraH1tHa2vvoZ3a3W/ediXxQ4ZWbUQAXZ3Qe9phVDRMKGWmoQxDnsEaj8+qPRtxaMSztcMR2xAaDSEGQqiG3aiAS8lF/2IaNCH6etCszkAhRkMYC87CtAI1H6MkV+2e3S/C92ZjSUzJ+md6L4O5kJmyUw+8HoopWomjBDi8EhQMgLsGVOy/yJl6cpb/TGf3XoL0UAYi9OG7rChwtHdT4g1sBcXYrhy0A0Dw5WLs2oUeSedTtfm92l84l8YuS5aXv1wnxRbgG00PLsOa9YfseVmYQZCOEoLCXd146vxYM20olt1Qp17ux3MsCLoDhB019P5ce8+czbuBPZ0PayJ/UcDi00nGjzwYDp7LqAgGoJoEPInxd5bbLF0zDBYM0DPyMFeMoawp4mCOVdgyXJhBv1YMnOJdLYSbKqODaK0WDHDQVSwB83mRIUDRL0d6I5MjIJyzIAvNtBP08g+9gyMvFI0q0GovYFIRzO2olEHHN3fF0fF+AGdJ4QQh0KCkhFAcWS1lDQ/9yT+lt1rmHT1Hpvgq/UkOWtZ0rScJVnYSwrxbq0l4o8S8UaIeDsACLTtbSGI+BKnBOZMKCPzqLEYeXl0b9mCv76ZiC9IxB/de5AGmhYbqqBZQUWJBRkHCEgyS2P/Cs9eFPvs7naiXe3kn3UF0a623TM1rJh+L47KiVhdfS9EZi8dm3RdgUNhKyjvc/qkEEKkEwlKRoC9LSVHRlAS9cfGJWgWyDtuPF1btqMAFTZxTRlD1B9AmSaRHj/+xq5ej2WwFzrRDQNrhoMpt9yBxR4b3Nu5+X3c61+jY8Mmeuo6yCh3YS8uINDQTP5JJ2IrLML7ySdkTZhI+cXfSJq3sLebUFszzlFHoes6prk74NN1zHAYf/0uAvU1RP09GK5cdMMga9JUoj1eAvW7cJRXYc3K7rs7QIIDIYTo05AFJTt37mTp0qV4PB6ysrK49dZbGT++d5Pwo48+yv33349pmsyaNYtf//rXGIas9NmfeFCiHxndN2Yo1jriOmY0k2+49YDHhzs9hNythNrbcFaOxlGafDCc6wsn4PrCCYeVNyMrGyNr76wAXd8b6OmGQeaYcWSO6T2LyeJwYssf+UuvCyHEYBqyW+sbbriBhQsXsnr1aq688kqWLl3a65ja2lruuusuVq1axZo1a2hra+ORRx4ZqiwesdSega5D97/zkAWaG/nkv65nyw0/ofuz2NoHus12gLNiDFcemWMnkDf9lD4DEiGEEEe+IWkpaW9vZ/PmzTzwwAMAzJ07l9/+9rfs2rWL0aNHx49bvXo1s2fPpmj3w74WLVrEvffeyze+kbypfdDzvW4tPbU7e22v6fTQ7EvNlMtUKPc34TICVLGZWt8Dw52dpBqfeYFwV+Lj+Yzs7D6OFkII8Xk0JEFJY2MjRUVFWK2xj9M0jbKyMhoaGhKCksbGRioq9t4JV1RU0NjYOBRZ7KX70818cvs9fe4/vMdWpdbevHRRs+6zYczJwcmbNhbdbqdy0RXDnRUhhBBp5IgZ6Pr000/z9NNPJ93X3NycdPvhyBgzjpyJ5YTcvZ8T06TChPYffTnMdDRKsGKk8bRgi9PG+B8vTTomQwghhBiSoKSsrIzW1lYikQhWqzX2WPDGRsrLy3sdV1OzdxpnfX09ZWWxRzDPnz+f+fPnJ03/6quvTnmeLXYHx97e99NWhRBCCJFaQzIysqCggClTpvDkk08CsbEjJSUlCV03EBtrsnbtWlpbW1FK8Y9//IPzzjtvKLIohBBCiGE2ZNM1brzxRh5++GHmzp3LsmXLuOWWWwC4/vrreemllwCoqqriP//zP1m0aBFnn302+fn5fO1rXxuqLAohhBBiGA3ZmJKjjjqKhx9+uNf2m2++OeH9woULWbhwYa/jhBBCCDGype/CFkIIIYT4XJGgRAghhBBpQYISIYQQQqQFCUqEEEIIkRYkKBFCCCFEWpCgRAghhBBpQYISIYQQQqQFCUqEEEIIkRYkKBFCCCFEWpCgRAghhBBpQYISIYQQQqQFCUqEEEIIkRaG7IF8g6m2tparr756uLMxIM3NzZSUlAx3NtKa1NGBSR0dmNTRgUkdHZjU0cE52Hqqra1N3KDEsLrqqquGOwtpT+rowKSODkzq6MCkjg5M6ujgDLSepPtGCCGEEGlBghIhhBBCpAUJSoQQQgiRFiQoEUIIIURakKBECCGEEGlBgpIUCgaDXHvttcydO5cLLriAxYsXs2vXLgDa29v5zne+w5e//GXmz5/Pu+++C8D8+fP73NffeUeqwaijPd58800mT57MypUrh7JIKTcYdbRx40YWLlzIRRddxDnnnMP9998/LGVLlYHW0b333svcuXOZNGkSL774YkKa1113XTy9Sy+9lI0bNw55uVJpMOpIKcXdd9/N3LlzOf/88/nmN7855OVKpYHWUX/fFb/fz5IlSzj77LOZO3cuzz///LCULVUGUkcAXq/3gL+n6upqpk2bxs0337x3Y2onAX2+BQIB9corryjTNJVSSj344IPqsssuU0optXTpUvWHP/xBKaXUhg0b1GmnnaZCodBh7TsSDUYdKaVUV1eXuuSSS9RVV12lVqxYMYQlSr3BqKMLLrhAvfjii0oppTwej5o1a5baunXrkJYrlQZaRxs2bFA1NTXqsssuU2vWrElI88UXX1ThcFgppdTatWvVmWeeOVTFGRSDUUcrV65U3/ve91QwGFRKKdXS0jJUxRkUA62j/r4rd999t/r5z3+ulFKqpqZGzZo1S7nd7iErU6oNRh0ppVQoFFKLFi1SS5YsUb/73e/i26WlJIXsdjunn346mqYBMG3aNOrr6wF4/vnnufTSSwGYOnUqxcXF8ahyoPuORINRRwA33XQT11xzDbm5uUNYmsExGHWkaRrd3d1A7E7OMAxcLteQliuVBlpHU6dOpaqqKmmac+bMwWq1xtNrbm4mEokMdlEGzWDU0fLly/nxj3+MzWYDoKioaLCLMagGWkf9fVeee+65+HlVVVXMnDmzV4vTkWQw6gjgnnvuYd68eYwZMybh8yQoGUR/+9vfmD17Nh6Ph3A4nPADrqiooKGhYcD7RorDrSOI/TB0XWfOnDlDnv+hkIo6uuWWW7jrrrs444wzmDt3LkuWLDniLyj7Opg6OtT0vvSlL8X/qI4Eh1tHXq+X9vZ2XnrpJRYsWMCCBQt49tlnBzvbQ2ogdbT/d6WhoYHy8vIDnnekSkUdbdiwgQ8//DBp99/I+cWlmXvvvZeamhpWrlxJIBAY7uykpVTUUWtrK3/+85958MEHU5y79JCq79GyZctYsmQJ559/PrW1tVx22WV84QtfYNy4cSnM7fBI9W/tiSee4LnnnmPVqlUpyF16SEUdRSIRIpEIgUCARx99lLq6Oi699FKOOuooJk2alOIcD72B1NFI/K70JxV15Pf7ufHGG7nrrrvirS/7kqBkECxfvpwXXniBlStX4nQ6cTqdWK1WWltb41FlfX095eXl5OXlDWjfkS5VdfTRRx/R2trKRRddBIDH42Ht2rV4PB5+9KMfDVfxUiJVdeR2u1mzZg133HEHEGtSnjZtGu+///4RH5QcSh0djGeffZZ77rmHlStXUlhYOJhZHzKpqqPc3FwyMjK48MILAaisrOSEE05g06ZNR3xQMpA66uu7Ul5eTkNDA8XFxfHzvvjFLw5tgQZBquqopqaGhoYGLr/8cgC6urowTZOuri5uu+026b5JtRUrVvDMM8+wYsUKcnJy4tvnzZvHQw89BMRmQjQ3NzNjxozD2nekSmUdnXHGGaxfv561a9eydu1a5s6dy7XXXnvEBySprCOXy0VGRgZvvvkmAG63m40bNzJ+/PghLlVqDaSO+vPss89y5513smLFihER+EPq62j+/Pm89tprAHR0dLBp0yYmTpw4OJkfIgOpo/6+K/ueV1tbyzvvvHPEdy2nso4mTpzIW2+9Ff+bffnll3PJJZdw2223AaAppdQQlm1Ea2pq4vTTT6eqqorMzEwAbDYbjz76KG1tbfzsZz+jrq4OwzD41a9+xaxZswAGvO9INBh1tK+lS5cyadIkrrjiiqEsVkoNRh2tX7+e3//+9/Em+AULFrB48eJhK+PhGmgd/elPf+Khhx7C7XaTmZmJ3W7n8ccfJz8/nylTplBYWJgwWHrlypXk5eUNRxEP22DUkcfj4brrrqOurg6ARYsW8Y1vfGPYyni4BlpH/X1Xenp6+MUvfsHmzZuxWCz84Ac/4Nxzzx2O4qXEYNTRvu6++266urq4/vrrAQlKhBBCCJEmpPtGCCGEEGlBghIhhBBCpAUJSoQQQgiRFiQoEUIIIURakKBECCGEEGlBghIhhBBCpAUJSoQQw2bp0qXMnj17uLMhhEgTssy8ECKlDnaFz7/97W+DnBMhxJFGFk8TQqTUE0880ev9unXruP322xO2n3rqqbhcLpRS2Gy2ocyiECJNSVAihBhUN910E6tWreLTTz8d7qwIIdKcjCkRQgyb/ceU1NXVMXHiRJYvX86qVauYM2cO06ZN49vf/jaNjY0opbjnnnv40pe+xNSpU7nmmmvo6Ojole6rr77K17/+dY477jiOP/54vvvd77J169YhLJkQYiAkKBFCpJ2nnnqKv//973zzm99k8eLFvPPOO/zwhz/kzjvv5PXXX+fKK69k4cKFvPzyy/Gni+7x+OOPc9VVV5GRkcFPfvITrr32WrZt28bXv/71+IPkhBDpSQa6CiHSTnNzMy+88ALZ2dkAmKbJfffdRyAQ4LHHHsNqjf3p8ng8PPXUU9x4443YbDZ8Ph8333wzCxYs4Le//W08va985SvMmzeP++67L2G7ECK9SEuJECLtzJs3Lx6QAEydOhWACy64IB6Q7NkeDodpbm4GYP369XR1dXHeeefhdrvj/3RdZ9q0abz99ttDWxAhxCGRlhIhRNopKytLeL8nQOlre2dnJ1VVVezcuROAyy+/PGm6WVlZKc6pECKVJCgRQqQdi8WSdLuuJ2/c3TOJcM9/b7/9doqKig46XSFEepCgRAgxYlRVVQFQUFDAKaecMsy5EUIcKhlTIoQYMU477TSysrK47777CIfDvfa73e5hyJUQ4mBJS4kQYsTIysriN7/5DT/72c+4+OKLOffcc8nPz6ehoYFXX32VE044gRtuuGG4symE6IMEJUKIEeX888+nuLiYZcuWsXz5ckKhECUlJUyfPp2LL754uLMnhOiHLDMvhBBCiLQgY0qEEEIIkRYkKBFCCCFEWpCgRAghhBBpQYISIYQQQqSF/w+el1e0f4BGJQAAAABJRU5ErkJggg==", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def compute_avg_references(df: pd.DataFrame, smartcards: bool, variable: str, date_range: pd.DateTimeIndex) -> dict:\n", " \"\"\"\n", @@ -392,9 +597,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 9018/9018 [01:26<00:00, 104.17it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "date_range = pd.date_range(df_id_rich.not_valid_before.min(), df_id_rich.not_valid_before.max())\n", "dct_active_all = {}\n", @@ -476,9 +709,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "df_ratios = df_summary_references.copy()\n", "df_ratios[\"ref. rich certificates\"] = df_ratios[\"ref. rich certificates\"] / df_ratios[\"active certificates\"]\n", @@ -507,9 +751,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 9018/9018 [02:22<00:00, 63.49it/s] \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "date_range = pd.date_range(df_id_rich.not_valid_before.min(), df_id_rich.not_valid_before.max())\n", "dct_direct_others = {}\n", @@ -564,7 +826,9 @@ " ylabel=\"Number of certificates\",\n", ")\n", "plt.savefig(RESULTS_DIR / \"lienplot_active_certs_referencing_archived.pdf\", bbox_inches=\"tight\")\n", - "plt.show()\n" + "plt.show()\n", + "\n", + "# TODO: This analytical function should return command displaying current state of affairs: up-to-date number of now active certs that reference some archived one\n" ] }, { @@ -577,9 +841,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 9018/9018 [02:19<00:00, 64.54it/s] \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "date_range = pd.date_range(df_id_rich.not_valid_before.min(), df_id_rich.not_valid_before.max())\n", "vulnerable_cert_ids = set(df_id_rich.loc[df_id_rich.related_cves.notnull()].cert_id.tolist())\n", @@ -647,7 +929,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": { "pycharm": { "name": "#%%\n" @@ -685,13 +967,61 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'LatexManager' object has no attribute 'latex'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:290\u001b[0m, in \u001b[0;36mLatexManager.__init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 290\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_setup_latex_process(expect_reply\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m)\n\u001b[1;32m 291\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mFileNotFoundError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:321\u001b[0m, in \u001b[0;36mLatexManager._setup_latex_process\u001b[0;34m(self, expect_reply)\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_setup_latex_process\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39m, expect_reply\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m):\n\u001b[1;32m 317\u001b[0m \u001b[39m# Open LaTeX process for real work; register it for deletion. On\u001b[39;00m\n\u001b[1;32m 318\u001b[0m \u001b[39m# Windows, we must ensure that the subprocess has quit before being\u001b[39;00m\n\u001b[1;32m 319\u001b[0m \u001b[39m# able to delete the tmpdir in which it runs; in order to do so, we\u001b[39;00m\n\u001b[1;32m 320\u001b[0m \u001b[39m# must first `kill()` it, and then `communicate()` with it.\u001b[39;00m\n\u001b[0;32m--> 321\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlatex \u001b[39m=\u001b[39m subprocess\u001b[39m.\u001b[39;49mPopen(\n\u001b[1;32m 322\u001b[0m [mpl\u001b[39m.\u001b[39;49mrcParams[\u001b[39m\"\u001b[39;49m\u001b[39mpgf.texsystem\u001b[39;49m\u001b[39m\"\u001b[39;49m], \u001b[39m\"\u001b[39;49m\u001b[39m-halt-on-error\u001b[39;49m\u001b[39m\"\u001b[39;49m],\n\u001b[1;32m 323\u001b[0m stdin\u001b[39m=\u001b[39;49msubprocess\u001b[39m.\u001b[39;49mPIPE, stdout\u001b[39m=\u001b[39;49msubprocess\u001b[39m.\u001b[39;49mPIPE,\n\u001b[1;32m 324\u001b[0m encoding\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mutf-8\u001b[39;49m\u001b[39m\"\u001b[39;49m, cwd\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtmpdir)\n\u001b[1;32m 326\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfinalize_latex\u001b[39m(latex):\n", + "File \u001b[0;32m/var/tmp/xjanovsk/.pyenv/versions/3.10.13/lib/python3.10/subprocess.py:971\u001b[0m, in \u001b[0;36mPopen.__init__\u001b[0;34m(self, args, bufsize, executable, stdin, stdout, stderr, preexec_fn, close_fds, shell, cwd, env, universal_newlines, startupinfo, creationflags, restore_signals, start_new_session, pass_fds, user, group, extra_groups, encoding, errors, text, umask, pipesize)\u001b[0m\n\u001b[1;32m 968\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstderr \u001b[39m=\u001b[39m io\u001b[39m.\u001b[39mTextIOWrapper(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstderr,\n\u001b[1;32m 969\u001b[0m encoding\u001b[39m=\u001b[39mencoding, errors\u001b[39m=\u001b[39merrors)\n\u001b[0;32m--> 971\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_execute_child(args, executable, preexec_fn, close_fds,\n\u001b[1;32m 972\u001b[0m pass_fds, cwd, env,\n\u001b[1;32m 973\u001b[0m startupinfo, creationflags, shell,\n\u001b[1;32m 974\u001b[0m p2cread, p2cwrite,\n\u001b[1;32m 975\u001b[0m c2pread, c2pwrite,\n\u001b[1;32m 976\u001b[0m errread, errwrite,\n\u001b[1;32m 977\u001b[0m restore_signals,\n\u001b[1;32m 978\u001b[0m gid, gids, uid, umask,\n\u001b[1;32m 979\u001b[0m start_new_session)\n\u001b[1;32m 980\u001b[0m \u001b[39mexcept\u001b[39;00m:\n\u001b[1;32m 981\u001b[0m \u001b[39m# Cleanup if the child failed starting.\u001b[39;00m\n", + "File \u001b[0;32m/var/tmp/xjanovsk/.pyenv/versions/3.10.13/lib/python3.10/subprocess.py:1863\u001b[0m, in \u001b[0;36mPopen._execute_child\u001b[0;34m(self, args, executable, preexec_fn, close_fds, pass_fds, cwd, env, startupinfo, creationflags, shell, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite, restore_signals, gid, gids, uid, umask, start_new_session)\u001b[0m\n\u001b[1;32m 1862\u001b[0m err_msg \u001b[39m=\u001b[39m os\u001b[39m.\u001b[39mstrerror(errno_num)\n\u001b[0;32m-> 1863\u001b[0m \u001b[39mraise\u001b[39;00m child_exception_type(errno_num, err_msg, err_filename)\n\u001b[1;32m 1864\u001b[0m \u001b[39mraise\u001b[39;00m child_exception_type(err_msg)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'xelatex'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb Cell 27\u001b[0m line \u001b[0;36m2\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Baura/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb#X36sdnNjb2RlLXJlbW90ZQ%3D%3D?line=17'>18</a>\u001b[0m sankey(exploded\u001b[39m.\u001b[39mcategory, exploded\u001b[39m.\u001b[39mref_category, colorDict\u001b[39m=\u001b[39mcolor_dict, leftLabels\u001b[39m=\u001b[39m\u001b[39mlist\u001b[39m(exploded\u001b[39m.\u001b[39mcategory\u001b[39m.\u001b[39munique()), rightLabels\u001b[39m=\u001b[39m\u001b[39mlist\u001b[39m(exploded\u001b[39m.\u001b[39mref_category\u001b[39m.\u001b[39munique()), fontsize\u001b[39m=\u001b[39m\u001b[39m12\u001b[39m, ax\u001b[39m=\u001b[39maxes)\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Baura/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb#X36sdnNjb2RlLXJlbW90ZQ%3D%3D?line=19'>20</a>\u001b[0m figure\u001b[39m.\u001b[39msavefig(\u001b[39mstr\u001b[39m(RESULTS_DIR \u001b[39m/\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mcategory_references.pdf\u001b[39m\u001b[39m\"\u001b[39m), bbox_inches\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mtight\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> <a href='vscode-notebook-cell://ssh-remote%2Baura/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb#X36sdnNjb2RlLXJlbW90ZQ%3D%3D?line=20'>21</a>\u001b[0m figure\u001b[39m.\u001b[39;49msavefig(\u001b[39mstr\u001b[39;49m(RESULTS_DIR \u001b[39m/\u001b[39;49m \u001b[39m\"\u001b[39;49m\u001b[39mcategory_references.pgf\u001b[39;49m\u001b[39m\"\u001b[39;49m), bbox_inches\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mtight\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Baura/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb#X36sdnNjb2RlLXJlbW90ZQ%3D%3D?line=21'>22</a>\u001b[0m plt\u001b[39m.\u001b[39mclose(figure)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/figure.py:3343\u001b[0m, in \u001b[0;36mFigure.savefig\u001b[0;34m(self, fname, transparent, **kwargs)\u001b[0m\n\u001b[1;32m 3339\u001b[0m \u001b[39mfor\u001b[39;00m ax \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxes:\n\u001b[1;32m 3340\u001b[0m stack\u001b[39m.\u001b[39menter_context(\n\u001b[1;32m 3341\u001b[0m ax\u001b[39m.\u001b[39mpatch\u001b[39m.\u001b[39m_cm_set(facecolor\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mnone\u001b[39m\u001b[39m'\u001b[39m, edgecolor\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mnone\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[0;32m-> 3343\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcanvas\u001b[39m.\u001b[39;49mprint_figure(fname, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backend_bases.py:2342\u001b[0m, in \u001b[0;36mFigureCanvasBase.print_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m 2336\u001b[0m renderer \u001b[39m=\u001b[39m _get_renderer(\n\u001b[1;32m 2337\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfigure,\n\u001b[1;32m 2338\u001b[0m functools\u001b[39m.\u001b[39mpartial(\n\u001b[1;32m 2339\u001b[0m print_method, orientation\u001b[39m=\u001b[39morientation)\n\u001b[1;32m 2340\u001b[0m )\n\u001b[1;32m 2341\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mgetattr\u001b[39m(renderer, \u001b[39m\"\u001b[39m\u001b[39m_draw_disabled\u001b[39m\u001b[39m\"\u001b[39m, nullcontext)():\n\u001b[0;32m-> 2342\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49mdraw(renderer)\n\u001b[1;32m 2344\u001b[0m \u001b[39mif\u001b[39;00m bbox_inches:\n\u001b[1;32m 2345\u001b[0m \u001b[39mif\u001b[39;00m bbox_inches \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mtight\u001b[39m\u001b[39m\"\u001b[39m:\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/artist.py:95\u001b[0m, in \u001b[0;36m_finalize_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[39m@wraps\u001b[39m(draw)\n\u001b[1;32m 94\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdraw_wrapper\u001b[39m(artist, renderer, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m---> 95\u001b[0m result \u001b[39m=\u001b[39m draw(artist, renderer, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 96\u001b[0m \u001b[39mif\u001b[39;00m renderer\u001b[39m.\u001b[39m_rasterizing:\n\u001b[1;32m 97\u001b[0m renderer\u001b[39m.\u001b[39mstop_rasterizing()\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 70\u001b[0m renderer\u001b[39m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m \u001b[39mreturn\u001b[39;00m draw(artist, renderer)\n\u001b[1;32m 73\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 74\u001b[0m \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/figure.py:3134\u001b[0m, in \u001b[0;36mFigure.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 3132\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxes \u001b[39mand\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_layout_engine() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 3133\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 3134\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_layout_engine()\u001b[39m.\u001b[39;49mexecute(\u001b[39mself\u001b[39;49m)\n\u001b[1;32m 3135\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mValueError\u001b[39;00m:\n\u001b[1;32m 3136\u001b[0m \u001b[39mpass\u001b[39;00m\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/layout_engine.py:178\u001b[0m, in \u001b[0;36mTightLayoutEngine.execute\u001b[0;34m(self, fig)\u001b[0m\n\u001b[1;32m 176\u001b[0m renderer \u001b[39m=\u001b[39m fig\u001b[39m.\u001b[39m_get_renderer()\n\u001b[1;32m 177\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mgetattr\u001b[39m(renderer, \u001b[39m\"\u001b[39m\u001b[39m_draw_disabled\u001b[39m\u001b[39m\"\u001b[39m, nullcontext)():\n\u001b[0;32m--> 178\u001b[0m kwargs \u001b[39m=\u001b[39m get_tight_layout_figure(\n\u001b[1;32m 179\u001b[0m fig, fig\u001b[39m.\u001b[39;49maxes, get_subplotspec_list(fig\u001b[39m.\u001b[39;49maxes), renderer,\n\u001b[1;32m 180\u001b[0m pad\u001b[39m=\u001b[39;49minfo[\u001b[39m'\u001b[39;49m\u001b[39mpad\u001b[39;49m\u001b[39m'\u001b[39;49m], h_pad\u001b[39m=\u001b[39;49minfo[\u001b[39m'\u001b[39;49m\u001b[39mh_pad\u001b[39;49m\u001b[39m'\u001b[39;49m], w_pad\u001b[39m=\u001b[39;49minfo[\u001b[39m'\u001b[39;49m\u001b[39mw_pad\u001b[39;49m\u001b[39m'\u001b[39;49m],\n\u001b[1;32m 181\u001b[0m rect\u001b[39m=\u001b[39;49minfo[\u001b[39m'\u001b[39;49m\u001b[39mrect\u001b[39;49m\u001b[39m'\u001b[39;49m])\n\u001b[1;32m 182\u001b[0m \u001b[39mif\u001b[39;00m kwargs:\n\u001b[1;32m 183\u001b[0m fig\u001b[39m.\u001b[39msubplots_adjust(\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/_tight_layout.py:266\u001b[0m, in \u001b[0;36mget_tight_layout_figure\u001b[0;34m(fig, axes_list, subplotspec_list, renderer, pad, h_pad, w_pad, rect)\u001b[0m\n\u001b[1;32m 261\u001b[0m \u001b[39mreturn\u001b[39;00m {}\n\u001b[1;32m 262\u001b[0m span_pairs\u001b[39m.\u001b[39mappend((\n\u001b[1;32m 263\u001b[0m \u001b[39mslice\u001b[39m(ss\u001b[39m.\u001b[39mrowspan\u001b[39m.\u001b[39mstart \u001b[39m*\u001b[39m div_row, ss\u001b[39m.\u001b[39mrowspan\u001b[39m.\u001b[39mstop \u001b[39m*\u001b[39m div_row),\n\u001b[1;32m 264\u001b[0m \u001b[39mslice\u001b[39m(ss\u001b[39m.\u001b[39mcolspan\u001b[39m.\u001b[39mstart \u001b[39m*\u001b[39m div_col, ss\u001b[39m.\u001b[39mcolspan\u001b[39m.\u001b[39mstop \u001b[39m*\u001b[39m div_col)))\n\u001b[0;32m--> 266\u001b[0m kwargs \u001b[39m=\u001b[39m _auto_adjust_subplotpars(fig, renderer,\n\u001b[1;32m 267\u001b[0m shape\u001b[39m=\u001b[39;49m(max_nrows, max_ncols),\n\u001b[1;32m 268\u001b[0m span_pairs\u001b[39m=\u001b[39;49mspan_pairs,\n\u001b[1;32m 269\u001b[0m subplot_list\u001b[39m=\u001b[39;49msubplot_list,\n\u001b[1;32m 270\u001b[0m ax_bbox_list\u001b[39m=\u001b[39;49max_bbox_list,\n\u001b[1;32m 271\u001b[0m pad\u001b[39m=\u001b[39;49mpad, h_pad\u001b[39m=\u001b[39;49mh_pad, w_pad\u001b[39m=\u001b[39;49mw_pad)\n\u001b[1;32m 273\u001b[0m \u001b[39m# kwargs can be none if tight_layout fails...\u001b[39;00m\n\u001b[1;32m 274\u001b[0m \u001b[39mif\u001b[39;00m rect \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m kwargs \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 275\u001b[0m \u001b[39m# if rect is given, the whole subplots area (including\u001b[39;00m\n\u001b[1;32m 276\u001b[0m \u001b[39m# labels) will fit into the rect instead of the\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 280\u001b[0m \u001b[39m# auto_adjust_subplotpars twice, where the second run\u001b[39;00m\n\u001b[1;32m 281\u001b[0m \u001b[39m# with adjusted rect parameters.\u001b[39;00m\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/_tight_layout.py:82\u001b[0m, in \u001b[0;36m_auto_adjust_subplotpars\u001b[0;34m(fig, renderer, shape, span_pairs, subplot_list, ax_bbox_list, pad, h_pad, w_pad, rect)\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[39mfor\u001b[39;00m ax \u001b[39min\u001b[39;00m subplots:\n\u001b[1;32m 81\u001b[0m \u001b[39mif\u001b[39;00m ax\u001b[39m.\u001b[39mget_visible():\n\u001b[0;32m---> 82\u001b[0m bb \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m [martist\u001b[39m.\u001b[39;49m_get_tightbbox_for_layout_only(ax, renderer)]\n\u001b[1;32m 84\u001b[0m tight_bbox_raw \u001b[39m=\u001b[39m Bbox\u001b[39m.\u001b[39munion(bb)\n\u001b[1;32m 85\u001b[0m tight_bbox \u001b[39m=\u001b[39m fig\u001b[39m.\u001b[39mtransFigure\u001b[39m.\u001b[39minverted()\u001b[39m.\u001b[39mtransform_bbox(tight_bbox_raw)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/artist.py:1415\u001b[0m, in \u001b[0;36m_get_tightbbox_for_layout_only\u001b[0;34m(obj, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1409\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 1410\u001b[0m \u001b[39mMatplotlib's `.Axes.get_tightbbox` and `.Axis.get_tightbbox` support a\u001b[39;00m\n\u001b[1;32m 1411\u001b[0m \u001b[39m*for_layout_only* kwarg; this helper tries to use the kwarg but skips it\u001b[39;00m\n\u001b[1;32m 1412\u001b[0m \u001b[39mwhen encountering third-party subclasses that do not support it.\u001b[39;00m\n\u001b[1;32m 1413\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 1414\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 1415\u001b[0m \u001b[39mreturn\u001b[39;00m obj\u001b[39m.\u001b[39;49mget_tightbbox(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49m{\u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs, \u001b[39m\"\u001b[39;49m\u001b[39mfor_layout_only\u001b[39;49m\u001b[39m\"\u001b[39;49m: \u001b[39mTrue\u001b[39;49;00m})\n\u001b[1;32m 1416\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mTypeError\u001b[39;00m:\n\u001b[1;32m 1417\u001b[0m \u001b[39mreturn\u001b[39;00m obj\u001b[39m.\u001b[39mget_tightbbox(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/axes/_base.py:4408\u001b[0m, in \u001b[0;36m_AxesBase.get_tightbbox\u001b[0;34m(self, renderer, call_axes_locator, bbox_extra_artists, for_layout_only)\u001b[0m\n\u001b[1;32m 4405\u001b[0m bbox_artists \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_default_bbox_extra_artists()\n\u001b[1;32m 4407\u001b[0m \u001b[39mfor\u001b[39;00m a \u001b[39min\u001b[39;00m bbox_artists:\n\u001b[0;32m-> 4408\u001b[0m bbox \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39;49mget_tightbbox(renderer)\n\u001b[1;32m 4409\u001b[0m \u001b[39mif\u001b[39;00m (bbox \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 4410\u001b[0m \u001b[39mand\u001b[39;00m \u001b[39m0\u001b[39m \u001b[39m<\u001b[39m bbox\u001b[39m.\u001b[39mwidth \u001b[39m<\u001b[39m np\u001b[39m.\u001b[39minf\n\u001b[1;32m 4411\u001b[0m \u001b[39mand\u001b[39;00m \u001b[39m0\u001b[39m \u001b[39m<\u001b[39m bbox\u001b[39m.\u001b[39mheight \u001b[39m<\u001b[39m np\u001b[39m.\u001b[39minf):\n\u001b[1;32m 4412\u001b[0m bb\u001b[39m.\u001b[39mappend(bbox)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/artist.py:367\u001b[0m, in \u001b[0;36mArtist.get_tightbbox\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 352\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_tightbbox\u001b[39m(\u001b[39mself\u001b[39m, renderer\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m 353\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 354\u001b[0m \u001b[39m Like `.Artist.get_window_extent`, but includes any clipping.\u001b[39;00m\n\u001b[1;32m 355\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[39m The enclosing bounding box (in figure pixel coordinates).\u001b[39;00m\n\u001b[1;32m 366\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 367\u001b[0m bbox \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_window_extent(renderer)\n\u001b[1;32m 368\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_clip_on():\n\u001b[1;32m 369\u001b[0m clip_box \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_clip_box()\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/text.py:959\u001b[0m, in \u001b[0;36mText.get_window_extent\u001b[0;34m(self, renderer, dpi)\u001b[0m\n\u001b[1;32m 954\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 955\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mCannot get window extent of text w/o renderer. You likely \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 956\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mwant to call \u001b[39m\u001b[39m'\u001b[39m\u001b[39mfigure.draw_without_rendering()\u001b[39m\u001b[39m'\u001b[39m\u001b[39m first.\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 958\u001b[0m \u001b[39mwith\u001b[39;00m cbook\u001b[39m.\u001b[39m_setattr_cm(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfigure, dpi\u001b[39m=\u001b[39mdpi):\n\u001b[0;32m--> 959\u001b[0m bbox, info, descent \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_get_layout(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_renderer)\n\u001b[1;32m 960\u001b[0m x, y \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_unitless_position()\n\u001b[1;32m 961\u001b[0m x, y \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_transform()\u001b[39m.\u001b[39mtransform((x, y))\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/text.py:378\u001b[0m, in \u001b[0;36mText._get_layout\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 375\u001b[0m ys \u001b[39m=\u001b[39m []\n\u001b[1;32m 377\u001b[0m \u001b[39m# Full vertical extent of font, including ascenders and descenders:\u001b[39;00m\n\u001b[0;32m--> 378\u001b[0m _, lp_h, lp_d \u001b[39m=\u001b[39m _get_text_metrics_with_cache(\n\u001b[1;32m 379\u001b[0m renderer, \u001b[39m\"\u001b[39;49m\u001b[39mlp\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fontproperties,\n\u001b[1;32m 380\u001b[0m ismath\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mTeX\u001b[39;49m\u001b[39m\"\u001b[39;49m \u001b[39mif\u001b[39;49;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_usetex() \u001b[39melse\u001b[39;49;00m \u001b[39mFalse\u001b[39;49;00m, dpi\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49mdpi)\n\u001b[1;32m 381\u001b[0m min_dy \u001b[39m=\u001b[39m (lp_h \u001b[39m-\u001b[39m lp_d) \u001b[39m*\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_linespacing\n\u001b[1;32m 383\u001b[0m \u001b[39mfor\u001b[39;00m i, line \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(lines):\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/text.py:97\u001b[0m, in \u001b[0;36m_get_text_metrics_with_cache\u001b[0;34m(renderer, text, fontprop, ismath, dpi)\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Call ``renderer.get_text_width_height_descent``, caching the results.\"\"\"\u001b[39;00m\n\u001b[1;32m 95\u001b[0m \u001b[39m# Cached based on a copy of fontprop so that later in-place mutations of\u001b[39;00m\n\u001b[1;32m 96\u001b[0m \u001b[39m# the passed-in argument do not mess up the cache.\u001b[39;00m\n\u001b[0;32m---> 97\u001b[0m \u001b[39mreturn\u001b[39;00m _get_text_metrics_with_cache_impl(\n\u001b[1;32m 98\u001b[0m weakref\u001b[39m.\u001b[39;49mref(renderer), text, fontprop\u001b[39m.\u001b[39;49mcopy(), ismath, dpi)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/text.py:105\u001b[0m, in \u001b[0;36m_get_text_metrics_with_cache_impl\u001b[0;34m(renderer_ref, text, fontprop, ismath, dpi)\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mlru_cache(\u001b[39m4096\u001b[39m)\n\u001b[1;32m 102\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_get_text_metrics_with_cache_impl\u001b[39m(\n\u001b[1;32m 103\u001b[0m renderer_ref, text, fontprop, ismath, dpi):\n\u001b[1;32m 104\u001b[0m \u001b[39m# dpi is unused, but participates in cache invalidation (via the renderer).\u001b[39;00m\n\u001b[0;32m--> 105\u001b[0m \u001b[39mreturn\u001b[39;00m renderer_ref()\u001b[39m.\u001b[39;49mget_text_width_height_descent(text, fontprop, ismath)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:749\u001b[0m, in \u001b[0;36mRendererPgf.get_text_width_height_descent\u001b[0;34m(self, s, prop, ismath)\u001b[0m\n\u001b[1;32m 746\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_text_width_height_descent\u001b[39m(\u001b[39mself\u001b[39m, s, prop, ismath):\n\u001b[1;32m 747\u001b[0m \u001b[39m# docstring inherited\u001b[39;00m\n\u001b[1;32m 748\u001b[0m \u001b[39m# get text metrics in units of latex pt, convert to display units\u001b[39;00m\n\u001b[0;32m--> 749\u001b[0m w, h, d \u001b[39m=\u001b[39m (LatexManager\u001b[39m.\u001b[39;49m_get_cached_or_new()\n\u001b[1;32m 750\u001b[0m \u001b[39m.\u001b[39mget_width_height_descent(s, prop))\n\u001b[1;32m 751\u001b[0m \u001b[39m# TODO: this should be latex_pt_to_in instead of mpl_pt_to_in\u001b[39;00m\n\u001b[1;32m 752\u001b[0m \u001b[39m# but having a little bit more space around the text looks better,\u001b[39;00m\n\u001b[1;32m 753\u001b[0m \u001b[39m# plus the bounding box reported by LaTeX is VERY narrow\u001b[39;00m\n\u001b[1;32m 754\u001b[0m f \u001b[39m=\u001b[39m mpl_pt_to_in \u001b[39m*\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdpi\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:251\u001b[0m, in \u001b[0;36mLatexManager._get_cached_or_new\u001b[0;34m(cls)\u001b[0m\n\u001b[1;32m 245\u001b[0m \u001b[39m@classmethod\u001b[39m\n\u001b[1;32m 246\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_get_cached_or_new\u001b[39m(\u001b[39mcls\u001b[39m):\n\u001b[1;32m 247\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 248\u001b[0m \u001b[39m Return the previous LatexManager if the header and tex system did not\u001b[39;00m\n\u001b[1;32m 249\u001b[0m \u001b[39m change, or a new instance otherwise.\u001b[39;00m\n\u001b[1;32m 250\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 251\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mcls\u001b[39;49m\u001b[39m.\u001b[39;49m_get_cached_or_new_impl(\u001b[39mcls\u001b[39;49m\u001b[39m.\u001b[39;49m_build_latex_header())\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:256\u001b[0m, in \u001b[0;36mLatexManager._get_cached_or_new_impl\u001b[0;34m(cls, header)\u001b[0m\n\u001b[1;32m 253\u001b[0m \u001b[39m@classmethod\u001b[39m\n\u001b[1;32m 254\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mlru_cache(\u001b[39m1\u001b[39m)\n\u001b[1;32m 255\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_get_cached_or_new_impl\u001b[39m(\u001b[39mcls\u001b[39m, header): \u001b[39m# Helper for _get_cached_or_new.\u001b[39;00m\n\u001b[0;32m--> 256\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mcls\u001b[39;49m()\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:293\u001b[0m, in \u001b[0;36mLatexManager.__init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 290\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_setup_latex_process(expect_reply\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m 291\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mFileNotFoundError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[1;32m 292\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[0;32m--> 293\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mlatex\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\u001b[39m!r}\u001b[39;00m\u001b[39m not found. Install it or change \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 294\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mrcParams[\u001b[39m\u001b[39m'\u001b[39m\u001b[39mpgf.texsystem\u001b[39m\u001b[39m'\u001b[39m\u001b[39m] to an available TeX \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 295\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mimplementation.\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m 296\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mOSError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[1;32m 297\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 298\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mError starting process \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlatex\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\u001b[39m!r}\u001b[39;00m\u001b[39m\"\u001b[39m) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'LatexManager' object has no attribute 'latex'" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 2400x1000 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "cert_id_to_category_mapping = dict(zip(df.cert_id, df.category))\n", "cert_id_to_category_mapping[np.NaN] = \"No references\"\n", @@ -727,7 +1057,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": { "pycharm": { "name": "#%%\n" @@ -765,13 +1095,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of certificates that reference some archived certificate: 971\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1400x800 with 2 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def references_archived_cert(references):\n", " if pd.isnull(references):\n", @@ -812,13 +1160,61 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'LatexManager' object has no attribute 'latex'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:290\u001b[0m, in \u001b[0;36mLatexManager.__init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m--> 290\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_setup_latex_process(expect_reply\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m)\n\u001b[1;32m 291\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mFileNotFoundError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:321\u001b[0m, in \u001b[0;36mLatexManager._setup_latex_process\u001b[0;34m(self, expect_reply)\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_setup_latex_process\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39m, expect_reply\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m):\n\u001b[1;32m 317\u001b[0m \u001b[39m# Open LaTeX process for real work; register it for deletion. On\u001b[39;00m\n\u001b[1;32m 318\u001b[0m \u001b[39m# Windows, we must ensure that the subprocess has quit before being\u001b[39;00m\n\u001b[1;32m 319\u001b[0m \u001b[39m# able to delete the tmpdir in which it runs; in order to do so, we\u001b[39;00m\n\u001b[1;32m 320\u001b[0m \u001b[39m# must first `kill()` it, and then `communicate()` with it.\u001b[39;00m\n\u001b[0;32m--> 321\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlatex \u001b[39m=\u001b[39m subprocess\u001b[39m.\u001b[39;49mPopen(\n\u001b[1;32m 322\u001b[0m [mpl\u001b[39m.\u001b[39;49mrcParams[\u001b[39m\"\u001b[39;49m\u001b[39mpgf.texsystem\u001b[39;49m\u001b[39m\"\u001b[39;49m], \u001b[39m\"\u001b[39;49m\u001b[39m-halt-on-error\u001b[39;49m\u001b[39m\"\u001b[39;49m],\n\u001b[1;32m 323\u001b[0m stdin\u001b[39m=\u001b[39;49msubprocess\u001b[39m.\u001b[39;49mPIPE, stdout\u001b[39m=\u001b[39;49msubprocess\u001b[39m.\u001b[39;49mPIPE,\n\u001b[1;32m 324\u001b[0m encoding\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mutf-8\u001b[39;49m\u001b[39m\"\u001b[39;49m, cwd\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtmpdir)\n\u001b[1;32m 326\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfinalize_latex\u001b[39m(latex):\n", + "File \u001b[0;32m/var/tmp/xjanovsk/.pyenv/versions/3.10.13/lib/python3.10/subprocess.py:971\u001b[0m, in \u001b[0;36mPopen.__init__\u001b[0;34m(self, args, bufsize, executable, stdin, stdout, stderr, preexec_fn, close_fds, shell, cwd, env, universal_newlines, startupinfo, creationflags, restore_signals, start_new_session, pass_fds, user, group, extra_groups, encoding, errors, text, umask, pipesize)\u001b[0m\n\u001b[1;32m 968\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstderr \u001b[39m=\u001b[39m io\u001b[39m.\u001b[39mTextIOWrapper(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstderr,\n\u001b[1;32m 969\u001b[0m encoding\u001b[39m=\u001b[39mencoding, errors\u001b[39m=\u001b[39merrors)\n\u001b[0;32m--> 971\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_execute_child(args, executable, preexec_fn, close_fds,\n\u001b[1;32m 972\u001b[0m pass_fds, cwd, env,\n\u001b[1;32m 973\u001b[0m startupinfo, creationflags, shell,\n\u001b[1;32m 974\u001b[0m p2cread, p2cwrite,\n\u001b[1;32m 975\u001b[0m c2pread, c2pwrite,\n\u001b[1;32m 976\u001b[0m errread, errwrite,\n\u001b[1;32m 977\u001b[0m restore_signals,\n\u001b[1;32m 978\u001b[0m gid, gids, uid, umask,\n\u001b[1;32m 979\u001b[0m start_new_session)\n\u001b[1;32m 980\u001b[0m \u001b[39mexcept\u001b[39;00m:\n\u001b[1;32m 981\u001b[0m \u001b[39m# Cleanup if the child failed starting.\u001b[39;00m\n", + "File \u001b[0;32m/var/tmp/xjanovsk/.pyenv/versions/3.10.13/lib/python3.10/subprocess.py:1863\u001b[0m, in \u001b[0;36mPopen._execute_child\u001b[0;34m(self, args, executable, preexec_fn, close_fds, pass_fds, cwd, env, startupinfo, creationflags, shell, p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite, restore_signals, gid, gids, uid, umask, start_new_session)\u001b[0m\n\u001b[1;32m 1862\u001b[0m err_msg \u001b[39m=\u001b[39m os\u001b[39m.\u001b[39mstrerror(errno_num)\n\u001b[0;32m-> 1863\u001b[0m \u001b[39mraise\u001b[39;00m child_exception_type(errno_num, err_msg, err_filename)\n\u001b[1;32m 1864\u001b[0m \u001b[39mraise\u001b[39;00m child_exception_type(err_msg)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'xelatex'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb Cell 33\u001b[0m line \u001b[0;36m2\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Baura/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb#X45sdnNjb2RlLXJlbW90ZQ%3D%3D?line=16'>17</a>\u001b[0m sankey(exploded\u001b[39m.\u001b[39mscheme, exploded\u001b[39m.\u001b[39mref_scheme, colorDict\u001b[39m=\u001b[39mcolor_dict, leftLabels\u001b[39m=\u001b[39m\u001b[39mlist\u001b[39m(exploded\u001b[39m.\u001b[39mscheme\u001b[39m.\u001b[39munique()), rightLabels\u001b[39m=\u001b[39m\u001b[39mlist\u001b[39m(exploded\u001b[39m.\u001b[39mref_scheme\u001b[39m.\u001b[39munique()), fontsize\u001b[39m=\u001b[39m\u001b[39m7\u001b[39m, ax\u001b[39m=\u001b[39maxes)\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Baura/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb#X45sdnNjb2RlLXJlbW90ZQ%3D%3D?line=18'>19</a>\u001b[0m figure\u001b[39m.\u001b[39msavefig(\u001b[39mstr\u001b[39m(RESULTS_DIR \u001b[39m/\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mscheme_references.pdf\u001b[39m\u001b[39m\"\u001b[39m), bbox_inches\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mtight\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> <a href='vscode-notebook-cell://ssh-remote%2Baura/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb#X45sdnNjb2RlLXJlbW90ZQ%3D%3D?line=19'>20</a>\u001b[0m figure\u001b[39m.\u001b[39;49msavefig(\u001b[39mstr\u001b[39;49m(RESULTS_DIR \u001b[39m/\u001b[39;49m \u001b[39m\"\u001b[39;49m\u001b[39mscheme_references.pgf\u001b[39;49m\u001b[39m\"\u001b[39;49m), bbox_inches\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mtight\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Baura/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb#X45sdnNjb2RlLXJlbW90ZQ%3D%3D?line=20'>21</a>\u001b[0m plt\u001b[39m.\u001b[39mshow()\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Baura/var/tmp/xjanovsk/certs/sec-certs/notebooks/cc/references.ipynb#X45sdnNjb2RlLXJlbW90ZQ%3D%3D?line=21'>22</a>\u001b[0m plt\u001b[39m.\u001b[39mclose(figure)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/figure.py:3343\u001b[0m, in \u001b[0;36mFigure.savefig\u001b[0;34m(self, fname, transparent, **kwargs)\u001b[0m\n\u001b[1;32m 3339\u001b[0m \u001b[39mfor\u001b[39;00m ax \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxes:\n\u001b[1;32m 3340\u001b[0m stack\u001b[39m.\u001b[39menter_context(\n\u001b[1;32m 3341\u001b[0m ax\u001b[39m.\u001b[39mpatch\u001b[39m.\u001b[39m_cm_set(facecolor\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mnone\u001b[39m\u001b[39m'\u001b[39m, edgecolor\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mnone\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[0;32m-> 3343\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcanvas\u001b[39m.\u001b[39;49mprint_figure(fname, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backend_bases.py:2342\u001b[0m, in \u001b[0;36mFigureCanvasBase.print_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m 2336\u001b[0m renderer \u001b[39m=\u001b[39m _get_renderer(\n\u001b[1;32m 2337\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfigure,\n\u001b[1;32m 2338\u001b[0m functools\u001b[39m.\u001b[39mpartial(\n\u001b[1;32m 2339\u001b[0m print_method, orientation\u001b[39m=\u001b[39morientation)\n\u001b[1;32m 2340\u001b[0m )\n\u001b[1;32m 2341\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mgetattr\u001b[39m(renderer, \u001b[39m\"\u001b[39m\u001b[39m_draw_disabled\u001b[39m\u001b[39m\"\u001b[39m, nullcontext)():\n\u001b[0;32m-> 2342\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49mdraw(renderer)\n\u001b[1;32m 2344\u001b[0m \u001b[39mif\u001b[39;00m bbox_inches:\n\u001b[1;32m 2345\u001b[0m \u001b[39mif\u001b[39;00m bbox_inches \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mtight\u001b[39m\u001b[39m\"\u001b[39m:\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/artist.py:95\u001b[0m, in \u001b[0;36m_finalize_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[39m@wraps\u001b[39m(draw)\n\u001b[1;32m 94\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdraw_wrapper\u001b[39m(artist, renderer, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m---> 95\u001b[0m result \u001b[39m=\u001b[39m draw(artist, renderer, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 96\u001b[0m \u001b[39mif\u001b[39;00m renderer\u001b[39m.\u001b[39m_rasterizing:\n\u001b[1;32m 97\u001b[0m renderer\u001b[39m.\u001b[39mstop_rasterizing()\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 70\u001b[0m renderer\u001b[39m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m \u001b[39mreturn\u001b[39;00m draw(artist, renderer)\n\u001b[1;32m 73\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[1;32m 74\u001b[0m \u001b[39mif\u001b[39;00m artist\u001b[39m.\u001b[39mget_agg_filter() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/figure.py:3134\u001b[0m, in \u001b[0;36mFigure.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 3132\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxes \u001b[39mand\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_layout_engine() \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 3133\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 3134\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_layout_engine()\u001b[39m.\u001b[39;49mexecute(\u001b[39mself\u001b[39;49m)\n\u001b[1;32m 3135\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mValueError\u001b[39;00m:\n\u001b[1;32m 3136\u001b[0m \u001b[39mpass\u001b[39;00m\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/layout_engine.py:178\u001b[0m, in \u001b[0;36mTightLayoutEngine.execute\u001b[0;34m(self, fig)\u001b[0m\n\u001b[1;32m 176\u001b[0m renderer \u001b[39m=\u001b[39m fig\u001b[39m.\u001b[39m_get_renderer()\n\u001b[1;32m 177\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mgetattr\u001b[39m(renderer, \u001b[39m\"\u001b[39m\u001b[39m_draw_disabled\u001b[39m\u001b[39m\"\u001b[39m, nullcontext)():\n\u001b[0;32m--> 178\u001b[0m kwargs \u001b[39m=\u001b[39m get_tight_layout_figure(\n\u001b[1;32m 179\u001b[0m fig, fig\u001b[39m.\u001b[39;49maxes, get_subplotspec_list(fig\u001b[39m.\u001b[39;49maxes), renderer,\n\u001b[1;32m 180\u001b[0m pad\u001b[39m=\u001b[39;49minfo[\u001b[39m'\u001b[39;49m\u001b[39mpad\u001b[39;49m\u001b[39m'\u001b[39;49m], h_pad\u001b[39m=\u001b[39;49minfo[\u001b[39m'\u001b[39;49m\u001b[39mh_pad\u001b[39;49m\u001b[39m'\u001b[39;49m], w_pad\u001b[39m=\u001b[39;49minfo[\u001b[39m'\u001b[39;49m\u001b[39mw_pad\u001b[39;49m\u001b[39m'\u001b[39;49m],\n\u001b[1;32m 181\u001b[0m rect\u001b[39m=\u001b[39;49minfo[\u001b[39m'\u001b[39;49m\u001b[39mrect\u001b[39;49m\u001b[39m'\u001b[39;49m])\n\u001b[1;32m 182\u001b[0m \u001b[39mif\u001b[39;00m kwargs:\n\u001b[1;32m 183\u001b[0m fig\u001b[39m.\u001b[39msubplots_adjust(\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/_tight_layout.py:266\u001b[0m, in \u001b[0;36mget_tight_layout_figure\u001b[0;34m(fig, axes_list, subplotspec_list, renderer, pad, h_pad, w_pad, rect)\u001b[0m\n\u001b[1;32m 261\u001b[0m \u001b[39mreturn\u001b[39;00m {}\n\u001b[1;32m 262\u001b[0m span_pairs\u001b[39m.\u001b[39mappend((\n\u001b[1;32m 263\u001b[0m \u001b[39mslice\u001b[39m(ss\u001b[39m.\u001b[39mrowspan\u001b[39m.\u001b[39mstart \u001b[39m*\u001b[39m div_row, ss\u001b[39m.\u001b[39mrowspan\u001b[39m.\u001b[39mstop \u001b[39m*\u001b[39m div_row),\n\u001b[1;32m 264\u001b[0m \u001b[39mslice\u001b[39m(ss\u001b[39m.\u001b[39mcolspan\u001b[39m.\u001b[39mstart \u001b[39m*\u001b[39m div_col, ss\u001b[39m.\u001b[39mcolspan\u001b[39m.\u001b[39mstop \u001b[39m*\u001b[39m div_col)))\n\u001b[0;32m--> 266\u001b[0m kwargs \u001b[39m=\u001b[39m _auto_adjust_subplotpars(fig, renderer,\n\u001b[1;32m 267\u001b[0m shape\u001b[39m=\u001b[39;49m(max_nrows, max_ncols),\n\u001b[1;32m 268\u001b[0m span_pairs\u001b[39m=\u001b[39;49mspan_pairs,\n\u001b[1;32m 269\u001b[0m subplot_list\u001b[39m=\u001b[39;49msubplot_list,\n\u001b[1;32m 270\u001b[0m ax_bbox_list\u001b[39m=\u001b[39;49max_bbox_list,\n\u001b[1;32m 271\u001b[0m pad\u001b[39m=\u001b[39;49mpad, h_pad\u001b[39m=\u001b[39;49mh_pad, w_pad\u001b[39m=\u001b[39;49mw_pad)\n\u001b[1;32m 273\u001b[0m \u001b[39m# kwargs can be none if tight_layout fails...\u001b[39;00m\n\u001b[1;32m 274\u001b[0m \u001b[39mif\u001b[39;00m rect \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m kwargs \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 275\u001b[0m \u001b[39m# if rect is given, the whole subplots area (including\u001b[39;00m\n\u001b[1;32m 276\u001b[0m \u001b[39m# labels) will fit into the rect instead of the\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 280\u001b[0m \u001b[39m# auto_adjust_subplotpars twice, where the second run\u001b[39;00m\n\u001b[1;32m 281\u001b[0m \u001b[39m# with adjusted rect parameters.\u001b[39;00m\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/_tight_layout.py:82\u001b[0m, in \u001b[0;36m_auto_adjust_subplotpars\u001b[0;34m(fig, renderer, shape, span_pairs, subplot_list, ax_bbox_list, pad, h_pad, w_pad, rect)\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[39mfor\u001b[39;00m ax \u001b[39min\u001b[39;00m subplots:\n\u001b[1;32m 81\u001b[0m \u001b[39mif\u001b[39;00m ax\u001b[39m.\u001b[39mget_visible():\n\u001b[0;32m---> 82\u001b[0m bb \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m [martist\u001b[39m.\u001b[39;49m_get_tightbbox_for_layout_only(ax, renderer)]\n\u001b[1;32m 84\u001b[0m tight_bbox_raw \u001b[39m=\u001b[39m Bbox\u001b[39m.\u001b[39munion(bb)\n\u001b[1;32m 85\u001b[0m tight_bbox \u001b[39m=\u001b[39m fig\u001b[39m.\u001b[39mtransFigure\u001b[39m.\u001b[39minverted()\u001b[39m.\u001b[39mtransform_bbox(tight_bbox_raw)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/artist.py:1415\u001b[0m, in \u001b[0;36m_get_tightbbox_for_layout_only\u001b[0;34m(obj, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1409\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 1410\u001b[0m \u001b[39mMatplotlib's `.Axes.get_tightbbox` and `.Axis.get_tightbbox` support a\u001b[39;00m\n\u001b[1;32m 1411\u001b[0m \u001b[39m*for_layout_only* kwarg; this helper tries to use the kwarg but skips it\u001b[39;00m\n\u001b[1;32m 1412\u001b[0m \u001b[39mwhen encountering third-party subclasses that do not support it.\u001b[39;00m\n\u001b[1;32m 1413\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 1414\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 1415\u001b[0m \u001b[39mreturn\u001b[39;00m obj\u001b[39m.\u001b[39;49mget_tightbbox(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49m{\u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs, \u001b[39m\"\u001b[39;49m\u001b[39mfor_layout_only\u001b[39;49m\u001b[39m\"\u001b[39;49m: \u001b[39mTrue\u001b[39;49;00m})\n\u001b[1;32m 1416\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mTypeError\u001b[39;00m:\n\u001b[1;32m 1417\u001b[0m \u001b[39mreturn\u001b[39;00m obj\u001b[39m.\u001b[39mget_tightbbox(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/axes/_base.py:4408\u001b[0m, in \u001b[0;36m_AxesBase.get_tightbbox\u001b[0;34m(self, renderer, call_axes_locator, bbox_extra_artists, for_layout_only)\u001b[0m\n\u001b[1;32m 4405\u001b[0m bbox_artists \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_default_bbox_extra_artists()\n\u001b[1;32m 4407\u001b[0m \u001b[39mfor\u001b[39;00m a \u001b[39min\u001b[39;00m bbox_artists:\n\u001b[0;32m-> 4408\u001b[0m bbox \u001b[39m=\u001b[39m a\u001b[39m.\u001b[39;49mget_tightbbox(renderer)\n\u001b[1;32m 4409\u001b[0m \u001b[39mif\u001b[39;00m (bbox \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m 4410\u001b[0m \u001b[39mand\u001b[39;00m \u001b[39m0\u001b[39m \u001b[39m<\u001b[39m bbox\u001b[39m.\u001b[39mwidth \u001b[39m<\u001b[39m np\u001b[39m.\u001b[39minf\n\u001b[1;32m 4411\u001b[0m \u001b[39mand\u001b[39;00m \u001b[39m0\u001b[39m \u001b[39m<\u001b[39m bbox\u001b[39m.\u001b[39mheight \u001b[39m<\u001b[39m np\u001b[39m.\u001b[39minf):\n\u001b[1;32m 4412\u001b[0m bb\u001b[39m.\u001b[39mappend(bbox)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/artist.py:367\u001b[0m, in \u001b[0;36mArtist.get_tightbbox\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 352\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_tightbbox\u001b[39m(\u001b[39mself\u001b[39m, renderer\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m 353\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 354\u001b[0m \u001b[39m Like `.Artist.get_window_extent`, but includes any clipping.\u001b[39;00m\n\u001b[1;32m 355\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[39m The enclosing bounding box (in figure pixel coordinates).\u001b[39;00m\n\u001b[1;32m 366\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 367\u001b[0m bbox \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_window_extent(renderer)\n\u001b[1;32m 368\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_clip_on():\n\u001b[1;32m 369\u001b[0m clip_box \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_clip_box()\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/text.py:959\u001b[0m, in \u001b[0;36mText.get_window_extent\u001b[0;34m(self, renderer, dpi)\u001b[0m\n\u001b[1;32m 954\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 955\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mCannot get window extent of text w/o renderer. You likely \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 956\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mwant to call \u001b[39m\u001b[39m'\u001b[39m\u001b[39mfigure.draw_without_rendering()\u001b[39m\u001b[39m'\u001b[39m\u001b[39m first.\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 958\u001b[0m \u001b[39mwith\u001b[39;00m cbook\u001b[39m.\u001b[39m_setattr_cm(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfigure, dpi\u001b[39m=\u001b[39mdpi):\n\u001b[0;32m--> 959\u001b[0m bbox, info, descent \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_get_layout(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_renderer)\n\u001b[1;32m 960\u001b[0m x, y \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_unitless_position()\n\u001b[1;32m 961\u001b[0m x, y \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mget_transform()\u001b[39m.\u001b[39mtransform((x, y))\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/text.py:378\u001b[0m, in \u001b[0;36mText._get_layout\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 375\u001b[0m ys \u001b[39m=\u001b[39m []\n\u001b[1;32m 377\u001b[0m \u001b[39m# Full vertical extent of font, including ascenders and descenders:\u001b[39;00m\n\u001b[0;32m--> 378\u001b[0m _, lp_h, lp_d \u001b[39m=\u001b[39m _get_text_metrics_with_cache(\n\u001b[1;32m 379\u001b[0m renderer, \u001b[39m\"\u001b[39;49m\u001b[39mlp\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fontproperties,\n\u001b[1;32m 380\u001b[0m ismath\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mTeX\u001b[39;49m\u001b[39m\"\u001b[39;49m \u001b[39mif\u001b[39;49;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_usetex() \u001b[39melse\u001b[39;49;00m \u001b[39mFalse\u001b[39;49;00m, dpi\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49mdpi)\n\u001b[1;32m 381\u001b[0m min_dy \u001b[39m=\u001b[39m (lp_h \u001b[39m-\u001b[39m lp_d) \u001b[39m*\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_linespacing\n\u001b[1;32m 383\u001b[0m \u001b[39mfor\u001b[39;00m i, line \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(lines):\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/text.py:97\u001b[0m, in \u001b[0;36m_get_text_metrics_with_cache\u001b[0;34m(renderer, text, fontprop, ismath, dpi)\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Call ``renderer.get_text_width_height_descent``, caching the results.\"\"\"\u001b[39;00m\n\u001b[1;32m 95\u001b[0m \u001b[39m# Cached based on a copy of fontprop so that later in-place mutations of\u001b[39;00m\n\u001b[1;32m 96\u001b[0m \u001b[39m# the passed-in argument do not mess up the cache.\u001b[39;00m\n\u001b[0;32m---> 97\u001b[0m \u001b[39mreturn\u001b[39;00m _get_text_metrics_with_cache_impl(\n\u001b[1;32m 98\u001b[0m weakref\u001b[39m.\u001b[39;49mref(renderer), text, fontprop\u001b[39m.\u001b[39;49mcopy(), ismath, dpi)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/text.py:105\u001b[0m, in \u001b[0;36m_get_text_metrics_with_cache_impl\u001b[0;34m(renderer_ref, text, fontprop, ismath, dpi)\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mlru_cache(\u001b[39m4096\u001b[39m)\n\u001b[1;32m 102\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_get_text_metrics_with_cache_impl\u001b[39m(\n\u001b[1;32m 103\u001b[0m renderer_ref, text, fontprop, ismath, dpi):\n\u001b[1;32m 104\u001b[0m \u001b[39m# dpi is unused, but participates in cache invalidation (via the renderer).\u001b[39;00m\n\u001b[0;32m--> 105\u001b[0m \u001b[39mreturn\u001b[39;00m renderer_ref()\u001b[39m.\u001b[39;49mget_text_width_height_descent(text, fontprop, ismath)\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:749\u001b[0m, in \u001b[0;36mRendererPgf.get_text_width_height_descent\u001b[0;34m(self, s, prop, ismath)\u001b[0m\n\u001b[1;32m 746\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_text_width_height_descent\u001b[39m(\u001b[39mself\u001b[39m, s, prop, ismath):\n\u001b[1;32m 747\u001b[0m \u001b[39m# docstring inherited\u001b[39;00m\n\u001b[1;32m 748\u001b[0m \u001b[39m# get text metrics in units of latex pt, convert to display units\u001b[39;00m\n\u001b[0;32m--> 749\u001b[0m w, h, d \u001b[39m=\u001b[39m (LatexManager\u001b[39m.\u001b[39;49m_get_cached_or_new()\n\u001b[1;32m 750\u001b[0m \u001b[39m.\u001b[39mget_width_height_descent(s, prop))\n\u001b[1;32m 751\u001b[0m \u001b[39m# TODO: this should be latex_pt_to_in instead of mpl_pt_to_in\u001b[39;00m\n\u001b[1;32m 752\u001b[0m \u001b[39m# but having a little bit more space around the text looks better,\u001b[39;00m\n\u001b[1;32m 753\u001b[0m \u001b[39m# plus the bounding box reported by LaTeX is VERY narrow\u001b[39;00m\n\u001b[1;32m 754\u001b[0m f \u001b[39m=\u001b[39m mpl_pt_to_in \u001b[39m*\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdpi\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:251\u001b[0m, in \u001b[0;36mLatexManager._get_cached_or_new\u001b[0;34m(cls)\u001b[0m\n\u001b[1;32m 245\u001b[0m \u001b[39m@classmethod\u001b[39m\n\u001b[1;32m 246\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_get_cached_or_new\u001b[39m(\u001b[39mcls\u001b[39m):\n\u001b[1;32m 247\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 248\u001b[0m \u001b[39m Return the previous LatexManager if the header and tex system did not\u001b[39;00m\n\u001b[1;32m 249\u001b[0m \u001b[39m change, or a new instance otherwise.\u001b[39;00m\n\u001b[1;32m 250\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 251\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mcls\u001b[39;49m\u001b[39m.\u001b[39;49m_get_cached_or_new_impl(\u001b[39mcls\u001b[39;49m\u001b[39m.\u001b[39;49m_build_latex_header())\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:256\u001b[0m, in \u001b[0;36mLatexManager._get_cached_or_new_impl\u001b[0;34m(cls, header)\u001b[0m\n\u001b[1;32m 253\u001b[0m \u001b[39m@classmethod\u001b[39m\n\u001b[1;32m 254\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mlru_cache(\u001b[39m1\u001b[39m)\n\u001b[1;32m 255\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_get_cached_or_new_impl\u001b[39m(\u001b[39mcls\u001b[39m, header): \u001b[39m# Helper for _get_cached_or_new.\u001b[39;00m\n\u001b[0;32m--> 256\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mcls\u001b[39;49m()\n", + "File \u001b[0;32m/var/tmp/xjanovsk/certs/sec-certs/venv/lib/python3.10/site-packages/matplotlib/backends/backend_pgf.py:293\u001b[0m, in \u001b[0;36mLatexManager.__init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 290\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_setup_latex_process(expect_reply\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m 291\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mFileNotFoundError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[1;32m 292\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[0;32m--> 293\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mlatex\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\u001b[39m!r}\u001b[39;00m\u001b[39m not found. Install it or change \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 294\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mrcParams[\u001b[39m\u001b[39m'\u001b[39m\u001b[39mpgf.texsystem\u001b[39m\u001b[39m'\u001b[39m\u001b[39m] to an available TeX \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 295\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mimplementation.\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m 296\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mOSError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[1;32m 297\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 298\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mError starting process \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlatex\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\u001b[39m!r}\u001b[39;00m\u001b[39m\"\u001b[39m) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'LatexManager' object has no attribute 'latex'" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 400x400 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "cert_id_to_scheme_mapping = dict(zip(df.cert_id, df.scheme))\n", "\n", @@ -854,13 +1250,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Certificates in dataset: 5356\n", + "Certificates with extracted IDs: 5202\n" + ] + } + ], "source": [ "certs_with_ids = {cert.heuristics.cert_id: cert for cert in dset if cert.heuristics.cert_id}\n", "\n", @@ -882,13 +1287,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "References in certificate reports: 2393\n" + ] + } + ], "source": [ "refs_cr = nx.DiGraph()\n", "for cert_id, cert in certs_with_ids.items():\n", @@ -915,13 +1328,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "References in security targets: 981\n" + ] + } + ], "source": [ "refs_st = nx.DiGraph()\n", "for cert_id, cert in certs_with_ids.items():\n", @@ -935,6 +1356,13 @@ ] }, { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { "attachments": {}, "cell_type": "markdown", "metadata": {}, @@ -944,11 +1372,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Combined references (not double counted): 2644\n" + ] + } + ], "source": [ "refs = nx.DiGraph()\n", "for cert_id, cert in certs_with_ids.items():\n", @@ -983,7 +1419,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -992,11 +1428,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Certificate with id ANSSI-CC-2019/02:\n", + " - is in a component with 21 certificates and 22 references.\n", + " - references ['ANSSI-CC-2018/13', 'ANSSI-CC-2019/01']\n", + " - is referenced by ['ANSSI-CC-2019/60']\n", + " - its page is at https://seccerts.org/cc/102bbdfcd696d7a9/\n" + ] + } + ], "source": [ "cert = certs_with_ids.get(cert_id)\n", "if cert is None:\n", @@ -1016,9 +1464,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "nx.draw(view, pos=nx.planar_layout(view), with_labels=True)" ] @@ -1040,9 +1499,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Density = 9.772467823854003e-05\n", + "Transitivity = 0.29055619930475085\n" + ] + } + ], "source": [ "print(f\"Density = {nx.density(refs)}\")\n", "print(f\"Transitivity = {nx.transitivity(refs)}\")" @@ -1050,13 +1518,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Degree centrality <Popularity> (top 20):\n", + "\tBSI-DSZ-CC-0555-2009 = 0.008652182272639877\n", + "\tBSI-DSZ-CC-0410-2007 = 0.008652182272639877\n", + "\tANSSI-CC-2010/02 = 0.008267640838300326\n", + "\tBSI-DSZ-CC-0829-2012 = 0.006152662949432801\n", + "\tBSI-DSZ-CC-0837-V2-2014 = 0.005960392232263026\n", + "\tBSI-DSZ-CC-0813-2012 = 0.005768121515093251\n", + "\tBSI-DSZ-CC-1059-2018 = 0.005191309363583926\n", + "\tBSI-DSZ-CC-0891-V2-2016 = 0.004614497212074601\n", + "\tBSI-DSZ-CC-1040-2019 = 0.004422226494904826\n", + "\tBSI-DSZ-CC-0782-V2-2015 = 0.004422226494904826\n", + "\tBSI-DSZ-CC-0645-2010 = 0.0042299557777350505\n", + "\tBSI-DSZ-CC-0266-2005 = 0.0038454143433955005\n", + "\tBSI-DSZ-CC-1110-V2-2019 = 0.0036531436262257255\n", + "\tBSI-DSZ-CC-0322-2005 = 0.0036531436262257255\n", + "\tBSI-DSZ-CC-0973-V2-2016 = 0.0034608729090559506\n", + "\tBSI-DSZ-CC-0978-2016 = 0.0034608729090559506\n", + "\tANSSI-CC-2015/36 = 0.0034608729090559506\n", + "\tBSI-DSZ-CC-0782-2012 = 0.0034608729090559506\n", + "\tANSSI-CC-2011/07 = 0.0034608729090559506\n", + "\tBSI-DSZ-CC-0633-2010 = 0.0032686021918861756\n" + ] + } + ], "source": [ "print(\"Degree centrality <Popularity> (top 20):\")\n", "degree_centrality_vals = [(node, val) for node, val in nx.degree_centrality(refs).items()]\n", @@ -1067,13 +1563,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eigenvector centrality <Influence> (top 20):\n", + "\tBSI-DSZ-CC-0404-2007 = 0.3499791663317535\n", + "\tBSI-DSZ-CC-0410-2007 = 0.32813666818090936\n", + "\tBSI-DSZ-CC-0858-2013 = 0.3093379867591983\n", + "\tBSI-DSZ-CC-0555-2009 = 0.30933783786642705\n", + "\tBSI-DSZ-CC-0674-2011 = 0.2900032285711939\n", + "\tBSI-DSZ-CC-0709-2010 = 0.2706698443806617\n", + "\tBSI-DSZ-CC-0750-V2-2014 = 0.23200295215903557\n", + "\tBSI-DSZ-CC-0633-2010 = 0.232002713129964\n", + "\tBSI-DSZ-CC-0710-2010 = 0.2320025242053116\n", + "\tNSCIB-CC-13-37760-CR2 = 0.17400201974056526\n", + "\tBSI-DSZ-CC-0675-2011 = 0.17400191049227\n", + "\tBSI-DSZ-CC-0730-2011 = 0.17400189318816653\n", + "\tBSI-DSZ-CC-0913-2014 = 0.13050141989302394\n", + "\tBSI-DSZ-CC-0911-2014 = 0.13050141989302394\n", + "\tBSI-DSZ-CC-0912-2014 = 0.13050141989302394\n", + "\tBSI-DSZ-CC-0798-2012 = 0.13050141989302394\n", + "\tBSI-DSZ-CC-0797-2012 = 0.13050141989302394\n", + "\tBSI-DSZ-CC-0799-2012 = 0.13050141989302394\n", + "\tBSI-DSZ-CC-0914-2014 = 0.13050141989302394\n", + "\tBSI-DSZ-CC-0804-2012 = 0.13050141989302394\n" + ] + } + ], "source": [ "print(\"Eigenvector centrality <Influence> (top 20):\")\n", "eigenvector_centrality_vals = [(node, val) for node, val in nx.eigenvector_centrality(refs).items()]\n", @@ -1084,13 +1608,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Closeness centrality <Centralness> (top 20):\n", + "\tBSI-DSZ-CC-0782-2012 = 0.009347591315113738\n", + "\tBSI-DSZ-CC-0555-2009 = 0.008892079681218678\n", + "\tBSI-DSZ-CC-0410-2007 = 0.008823246660710044\n", + "\tANSSI-CC-2010/02 = 0.00824502075392741\n", + "\tBSI-DSZ-CC-0758-2012 = 0.007682862668377188\n", + "\tBSI-DSZ-CC-0813-2012 = 0.007430047714077973\n", + "\tBSI-DSZ-CC-0728-2011 = 0.006864608765368054\n", + "\tBSI-DSZ-CC-0266-2005 = 0.006540607405315179\n", + "\tBSI-DSZ-CC-0404-2007 = 0.006461234002841855\n", + "\tBSI-DSZ-CC-0640-2010 = 0.0060273309263888\n", + "\tBSI-DSZ-CC-0837-V2-2014 = 0.005907210970067131\n", + "\tBSI-DSZ-CC-0973-V2-2016 = 0.005867954387469865\n", + "\tBSI-DSZ-CC-0891-V2-2016 = 0.00582055898341228\n", + "\tBSI-DSZ-CC-0891-2015 = 0.005802455571730712\n", + "\tANSSI-CC-2009/26 = 0.005636395619500341\n", + "\tBSI-DSZ-CC-0829-2012 = 0.0056259212971864385\n", + "\tBSI-DSZ-CC-0322-2005 = 0.005590322787387868\n", + "\tBSI-DSZ-CC-0973-2016 = 0.005492559434615112\n", + "\tANSSI-CC-2009/05 = 0.005405275998255349\n", + "\tANSSI-CC-2009/06 = 0.005158411332129022\n" + ] + } + ], "source": [ "print(\"Closeness centrality <Centralness> (top 20):\")\n", "closeness_centrality_vals = [(node, val) for node, val in nx.closeness_centrality(refs).items()]\n", @@ -1101,13 +1653,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Betweenness centrality <Bridge> (top 20):\n", + "\tANSSI-CC-2010/02 = 1.4309378373981335e-05\n", + "\tBSI-DSZ-CC-1110-V2-2019 = 1.2497596616035378e-05\n", + "\tBSI-DSZ-CC-1110-2019 = 1.1055566237262065e-05\n", + "\tBSI-DSZ-CC-0945-V2-2018 = 9.798411548075075e-06\n", + "\tBSI-DSZ-CC-0945-V3-2018 = 9.539585582654223e-06\n", + "\tBSI-DSZ-CC-0891-2015 = 8.689157410557141e-06\n", + "\tBSI-DSZ-CC-0891-V2-2016 = 8.522769289929452e-06\n", + "\tANSSI-CC-2009/51 = 7.6292034569289e-06\n", + "\tBSI-DSZ-CC-1110-V3-2020 = 7.542928135121944e-06\n", + "\tBSI-DSZ-CC-0782-2012 = 7.542928135121944e-06\n", + "\tBSI-DSZ-CC-0829-2012 = 6.211823170100425e-06\n", + "\tBSI-DSZ-CC-1110-V4-2021 = 5.250469584251549e-06\n", + "\tBSI-DSZ-CC-0266-2005 = 4.58491710174079e-06\n", + "\tBSI-DSZ-CC-0891-V3-2018 = 3.919364619230029e-06\n", + "\tBSI-DSZ-CC-0945-2017 = 3.4756629642228564e-06\n", + "\tBSI-DSZ-CC-0782-V2-2015 = 2.7854603897672535e-06\n", + "\tBSI-DSZ-CC-1059-2018 = 2.5143093783739813e-06\n", + "\tANSSI-CC-2014/86 = 2.4187902720877152e-06\n", + "\tBSI-DSZ-CC-0973-V2-2016 = 2.403383964622188e-06\n", + "\tBSI-DSZ-CC-0223-2003 = 2.403383964622188e-06\n" + ] + } + ], "source": [ "print(\"Betweenness centrality <Bridge> (top 20):\")\n", "betweenness_centrality_vals = [(node, val) for node, val in nx.betweenness_centrality(refs).items()]\n", @@ -1118,13 +1698,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of weakly connected subgraphs: 206\n", + "Size of the largest weakly connected subgraphs: [1018, 45, 39, 33, 24, 23, 21, 19, 16, 15]\n" + ] + } + ], "source": [ "component_lengths = list(filter(lambda comp_len: comp_len > 1, map(len, nx.weakly_connected_components(refs))))\n", "component_lengths.sort(reverse=True)\n", @@ -1135,13 +1724,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "25\n" + ] + } + ], "source": [ "big_boy = refs.subgraph(max(nx.weakly_connected_components(refs), key=len))\n", "communities = list(nx_comm.greedy_modularity_communities(big_boy))\n", @@ -1150,14 +1747,1039 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": { "pycharm": { "name": "#%%\n" }, "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\tANSSI-CC-2014/86\n", + "\tANSSI-CC-2015/01\n", + "\tANSSI-CC-2015/02\n", + "\tANSSI-CC-2015/03\n", + "\tANSSI-CC-2015/04\n", + "\tANSSI-CC-2015/08\n", + "\tANSSI-CC-2015/15\n", + "\tANSSI-CC-2015/30\n", + "\tANSSI-CC-2015/37\n", + "\tANSSI-CC-2015/38\n", + "\tANSSI-CC-2015/39\n", + "\tANSSI-CC-2015/40\n", + "\tANSSI-CC-2015/41\n", + "\tANSSI-CC-2015/62\n", + "\tANSSI-CC-2015/63\n", + "\tANSSI-CC-2015/64\n", + "\tANSSI-CC-2015/65\n", + "\tANSSI-CC-2015/76\n", + "\tANSSI-CC-2015/77\n", + "\tANSSI-CC-2015/78\n", + "\tANSSI-CC-2015/79\n", + "\tANSSI-CC-2016/03\n", + "\tANSSI-CC-2016/04\n", + "\tANSSI-CC-2016/17\n", + "\tANSSI-CC-2016/18\n", + "\tANSSI-CC-2016/19\n", + "\tANSSI-CC-2016/20\n", + "\tANSSI-CC-2016/21\n", + "\tANSSI-CC-2016/26\n", + "\tANSSI-CC-2016/27\n", + "\tANSSI-CC-2016/28\n", + "\tANSSI-CC-2016/29\n", + "\tANSSI-CC-2016/30\n", + "\tANSSI-CC-2016/34\n", + "\tANSSI-CC-2016/35\n", + "\tANSSI-CC-2016/36\n", + "\tANSSI-CC-2016/37\n", + "\tANSSI-CC-2016/38\n", + "\tANSSI-CC-2016/39\n", + "\tANSSI-CC-2016/40\n", + "\tANSSI-CC-2016/41\n", + "\tANSSI-CC-2016/45\n", + "\tANSSI-CC-2016/46\n", + "\tANSSI-CC-2016/47\n", + "\tANSSI-CC-2016/48\n", + "\tANSSI-CC-2016/49\n", + "\tANSSI-CC-2016/50\n", + "\tANSSI-CC-2016/51\n", + "\tANSSI-CC-2016/52\n", + "\tANSSI-CC-2016/63\n", + "\tBSI-DSZ-CC-0666-2012\n", + "\tBSI-DSZ-CC-0808-2013\n", + "\tBSI-DSZ-CC-0808-V2-2016\n", + "\tBSI-DSZ-CC-0808-V3-2017\n", + "\tBSI-DSZ-CC-0809-2013\n", + "\tBSI-DSZ-CC-0809-V2-2016\n", + "\tBSI-DSZ-CC-0809-V3-2017\n", + "\tBSI-DSZ-CC-0817-2013\n", + "\tBSI-DSZ-CC-0817-V2-2016\n", + "\tBSI-DSZ-CC-0831-2018\n", + "\tBSI-DSZ-CC-0831-V2-2020\n", + "\tBSI-DSZ-CC-0831-V3-2021\n", + "\tBSI-DSZ-CC-0831-V4-2021\n", + "\tBSI-DSZ-CC-0831-V5-2022\n", + "\tBSI-DSZ-CC-0837-2013\n", + "\tBSI-DSZ-CC-0837-V2-2014\n", + "\tBSI-DSZ-CC-0845-2012\n", + "\tBSI-DSZ-CC-0845-V2-2013\n", + "\tBSI-DSZ-CC-0861-2014\n", + "\tBSI-DSZ-CC-0870-2014\n", + "\tBSI-DSZ-CC-0885-2013\n", + "\tBSI-DSZ-CC-0886-2013\n", + "\tBSI-DSZ-CC-0892-2014\n", + "\tBSI-DSZ-CC-0892-V2-2015\n", + "\tBSI-DSZ-CC-0893-2014\n", + "\tBSI-DSZ-CC-0918-2020\n", + "\tBSI-DSZ-CC-0918-V2-2021\n", + "\tBSI-DSZ-CC-0918-V3-2022\n", + "\tBSI-DSZ-CC-0918-V4-2022\n", + "\tBSI-DSZ-CC-0919-2019\n", + "\tBSI-DSZ-CC-0919-V2-2021\n", + "\tBSI-DSZ-CC-0957-2015\n", + "\tBSI-DSZ-CC-0957-V2-2016\n", + "\tBSI-DSZ-CC-0978-2016\n", + "\tBSI-DSZ-CC-0978-V2-2017\n", + "\tBSI-DSZ-CC-0978-V3-2019\n", + "\tBSI-DSZ-CC-1035-2017\n", + "\tNSCIB-CC-11-31801-CR3\n", + "\tNSCIB-CC-11-31801-CR4\n", + "\tNSCIB-CC-12-36243\n", + "\tNSCIB-CC-12-36243-CR2\n", + "\tNSCIB-CC-13-37582-CR2\n", + "\t2012-8-INF-1198\n", + "\t2012-9-INF-1200\n", + "\t21.0.01/TSE-CCCS-29\n", + "\tANSSI-CC-2008/01\n", + "\tANSSI-CC-2008/02\n", + "\tANSSI-CC-2008/13\n", + "\tANSSI-CC-2008/14\n", + "\tANSSI-CC-2008/28\n", + "\tANSSI-CC-2008/45\n", + "\tANSSI-CC-2009/03\n", + "\tANSSI-CC-2009/07\n", + "\tANSSI-CC-2009/08\n", + "\tANSSI-CC-2009/19\n", + "\tANSSI-CC-2009/20\n", + "\tANSSI-CC-2009/56\n", + "\tANSSI-CC-2010/52\n", + "\tANSSI-CC-2010/59\n", + "\tANSSI-CC-2011/05\n", + "\tANSSI-CC-2011/21\n", + "\tANSSI-CC-2011/27\n", + "\tANSSI-CC-2011/28\n", + "\tANSSI-CC-2011/73\n", + "\tANSSI-CC-2011/76\n", + "\tANSSI-CC-2012/28\n", + "\tANSSI-CC-2012/36\n", + "\tANSSI-CC-2012/45\n", + "\tANSSI-CC-2012/46\n", + "\tANSSI-CC-2012/66\n", + "\tANSSI-CC-2012/67\n", + "\tANSSI-CC-2013/08\n", + "\tBSI-DSZ-CC-0391-2009\n", + "\tBSI-DSZ-CC-0404-2007\n", + "\tBSI-DSZ-CC-0410-2007\n", + "\tBSI-DSZ-CC-0411-2007\n", + "\tBSI-DSZ-CC-0417-2008\n", + "\tBSI-DSZ-CC-0439-2008\n", + "\tBSI-DSZ-CC-0440-2008\n", + "\tBSI-DSZ-CC-0446-2007\n", + "\tBSI-DSZ-CC-0451-2007\n", + "\tBSI-DSZ-CC-0463-2008\n", + "\tBSI-DSZ-CC-0479-2008\n", + "\tBSI-DSZ-CC-0483-2008\n", + "\tBSI-DSZ-CC-0506-2008\n", + "\tBSI-DSZ-CC-0515-2009\n", + "\tBSI-DSZ-CC-0518-2008\n", + "\tBSI-DSZ-CC-0521-2008\n", + "\tBSI-DSZ-CC-0522-2008\n", + "\tBSI-DSZ-CC-0527-2008\n", + "\tBSI-DSZ-CC-0532-2008\n", + "\tBSI-DSZ-CC-0537-2009\n", + "\tBSI-DSZ-CC-0548-2008\n", + "\tBSI-DSZ-CC-0555-2009\n", + "\tBSI-DSZ-CC-0567-2009\n", + "\tBSI-DSZ-CC-0571-2008\n", + "\tBSI-DSZ-CC-0575-2009\n", + "\tBSI-DSZ-CC-0581-2009\n", + "\tBSI-DSZ-CC-0582-2009\n", + "\tBSI-DSZ-CC-0602-2009\n", + "\tBSI-DSZ-CC-0603-2010\n", + "\tBSI-DSZ-CC-0604-2010\n", + "\tBSI-DSZ-CC-0608-2010\n", + "\tBSI-DSZ-CC-0609-2010\n", + "\tBSI-DSZ-CC-0625-2010\n", + "\tBSI-DSZ-CC-0633-2010\n", + "\tBSI-DSZ-CC-0634-2009\n", + "\tBSI-DSZ-CC-0635-2010\n", + "\tBSI-DSZ-CC-0642-2011\n", + "\tBSI-DSZ-CC-0643-2010\n", + "\tBSI-DSZ-CC-0658-2010\n", + "\tBSI-DSZ-CC-0673-2010\n", + "\tBSI-DSZ-CC-0674-2011\n", + "\tBSI-DSZ-CC-0675-2011\n", + "\tBSI-DSZ-CC-0680-2010\n", + "\tBSI-DSZ-CC-0694-2012\n", + "\tBSI-DSZ-CC-0700-2011\n", + "\tBSI-DSZ-CC-0700-V2-2013\n", + "\tBSI-DSZ-CC-0702-2011\n", + "\tBSI-DSZ-CC-0703-2011\n", + "\tBSI-DSZ-CC-0704-2010\n", + "\tBSI-DSZ-CC-0709-2010\n", + "\tBSI-DSZ-CC-0710-2010\n", + "\tBSI-DSZ-CC-0730-2011\n", + "\tBSI-DSZ-CC-0745-2012\n", + "\tBSI-DSZ-CC-0746-2012\n", + "\tBSI-DSZ-CC-0747-2011\n", + "\tBSI-DSZ-CC-0748-2011\n", + "\tBSI-DSZ-CC-0784-2013\n", + "\tBSI-DSZ-CC-0797-2012\n", + "\tBSI-DSZ-CC-0798-2012\n", + "\tBSI-DSZ-CC-0799-2012\n", + "\tBSI-DSZ-CC-0804-2012\n", + "\tBSI-DSZ-CC-0812-2012\n", + "\tANSSI-CC-2012/31\n", + "\tANSSI-CC-2012/32\n", + "\tANSSI-CC-2012/38\n", + "\tANSSI-CC-2012/40\n", + "\tANSSI-CC-2012/41\n", + "\tANSSI-CC-2012/44\n", + "\tANSSI-CC-2012/50\n", + "\tANSSI-CC-2012/51\n", + "\tANSSI-CC-2012/85\n", + "\tANSSI-CC-2013/10\n", + "\tANSSI-CC-2013/11\n", + "\tANSSI-CC-2013/32\n", + "\tANSSI-CC-2013/33\n", + "\tANSSI-CC-2013/34\n", + "\tANSSI-CC-2013/35\n", + "\tANSSI-CC-2013/39\n", + "\tANSSI-CC-2013/40\n", + "\tANSSI-CC-2013/42\n", + "\tANSSI-CC-2013/55\n", + "\tANSSI-CC-2013/64\n", + "\tANSSI-CC-2014/06\n", + "\tANSSI-CC-2014/07\n", + "\tANSSI-CC-2014/08\n", + "\tANSSI-CC-2014/09\n", + "\tANSSI-CC-2014/11\n", + "\tANSSI-CC-2014/12\n", + "\tANSSI-CC-2014/13\n", + "\tANSSI-CC-2014/14\n", + "\tANSSI-CC-2014/48\n", + "\tANSSI-CC-2014/49\n", + "\tANSSI-CC-2014/50\n", + "\tANSSI-CC-2014/61\n", + "\tANSSI-CC-2014/62\n", + "\tANSSI-CC-2015/09\n", + "\tANSSI-CC-2015/25\n", + "\tANSSI-CC-2016/73\n", + "\tANSSI-CC-2016/74\n", + "\tANSSI-CC-2016/75\n", + "\tBSI-DSZ-CC-0606-2010\n", + "\tBSI-DSZ-CC-0640-2010\n", + "\tBSI-DSZ-CC-0677-2010\n", + "\tBSI-DSZ-CC-0695-2011\n", + "\tBSI-DSZ-CC-0722-2011\n", + "\tBSI-DSZ-CC-0727-2011\n", + "\tBSI-DSZ-CC-0728-2011\n", + "\tBSI-DSZ-CC-0729-2011\n", + "\tBSI-DSZ-CC-0732-2011\n", + "\tBSI-DSZ-CC-0733-2011\n", + "\tBSI-DSZ-CC-0751-2013\n", + "\tBSI-DSZ-CC-0754-2012\n", + "\tBSI-DSZ-CC-0760-2013\n", + "\tBSI-DSZ-CC-0761-2013\n", + "\tBSI-DSZ-CC-0762-2012\n", + "\tBSI-DSZ-CC-0763-2012\n", + "\tBSI-DSZ-CC-0764-2012\n", + "\tBSI-DSZ-CC-0767-2011\n", + "\tBSI-DSZ-CC-0769-2012\n", + "\tBSI-DSZ-CC-0813-2012\n", + "\tBSI-DSZ-CC-0818-2013\n", + "\tBSI-DSZ-CC-0819-2012\n", + "\tBSI-DSZ-CC-0829-2012\n", + "\tBSI-DSZ-CC-0829-V2-2015\n", + "\tBSI-DSZ-CC-0835-2013\n", + "\tBSI-DSZ-CC-0835-V2-2017\n", + "\tBSI-DSZ-CC-0836-2013\n", + "\tBSI-DSZ-CC-0836-V2-2017\n", + "\tBSI-DSZ-CC-0848-2012\n", + "\tBSI-DSZ-CC-0850-2013\n", + "\tBSI-DSZ-CC-0851-2013\n", + "\tBSI-DSZ-CC-0880-2013\n", + "\tBSI-DSZ-CC-0898-2014\n", + "\tBSI-DSZ-CC-0922-2014\n", + "\tBSI-DSZ-CC-0924-2014\n", + "\tBSI-DSZ-CC-0941-2016\n", + "\tBSI-DSZ-CC-0949-2017\n", + "\tBSI-DSZ-CC-0952-2014\n", + "\tBSI-DSZ-CC-0952-V2-2016\n", + "\tBSI-DSZ-CC-0999-2016\n", + "\tCRP290\n", + "\tOCSI/CERT/CCL/02/2020/RC\n", + "\tOCSI/CERT/SYS/06/2017/RC\n", + "\tANSSI-CC-2009/05\n", + "\tANSSI-CC-2009/06\n", + "\tANSSI-CC-2009/26\n", + "\tANSSI-CC-2009/27\n", + "\tANSSI-CC-2009/28\n", + "\tANSSI-CC-2009/50\n", + "\tANSSI-CC-2009/51\n", + "\tANSSI-CC-2009/60\n", + "\tANSSI-CC-2009/61\n", + "\tANSSI-CC-2009/62\n", + "\tANSSI-CC-2010/01\n", + "\tANSSI-CC-2010/02\n", + "\tANSSI-CC-2010/03\n", + "\tANSSI-CC-2010/04\n", + "\tANSSI-CC-2010/17\n", + "\tANSSI-CC-2010/18\n", + "\tANSSI-CC-2010/19\n", + "\tANSSI-CC-2010/20\n", + "\tANSSI-CC-2010/21\n", + "\tANSSI-CC-2010/22\n", + "\tANSSI-CC-2010/28\n", + "\tANSSI-CC-2010/29\n", + "\tANSSI-CC-2010/30\n", + "\tANSSI-CC-2010/31\n", + "\tANSSI-CC-2010/32\n", + "\tANSSI-CC-2010/33\n", + "\tANSSI-CC-2010/34\n", + "\tANSSI-CC-2010/35\n", + "\tANSSI-CC-2010/56\n", + "\tANSSI-CC-2010/57\n", + "\tANSSI-CC-2011/06\n", + "\tANSSI-CC-2011/49\n", + "\tANSSI-CC-2011/50\n", + "\tANSSI-CC-2011/58\n", + "\tANSSI-CC-2011/59\n", + "\tANSSI-CC-2011/61\n", + "\tANSSI-CC-2011/62\n", + "\tANSSI-CC-2011/63\n", + "\tANSSI-CC-2011/70\n", + "\tANSSI-CC-2011/74\n", + "\tANSSI-CC-2011/75\n", + "\tANSSI-CC-2011/81\n", + "\tANSSI-CC-2012/68\n", + "\tANSSI-CC-2012/69\n", + "\tANSSI-CC-2012/77\n", + "\tANSSI-CC-2012/82\n", + "\tANSSI-CC-2012/83\n", + "\tANSSI-CC-2013/04\n", + "\tANSSI-CC-2013/05\n", + "\tANSSI-CC-2013/54\n", + "\tANSSI-CC-2014/25\n", + "\tANSSI-CC-2014/26\n", + "\tANSSI-CC-2014/73\n", + "\tANSSI-CC-2014/74\n", + "\tANSSI-CC-2014/92\n", + "\tANSSI-CC-2014/93\n", + "\tANSSI-CC-2015/07\n", + "\tANSSI-CC-2015/16\n", + "\tANSSI-CC-2015/17\n", + "\tANSSI-CC-2016/07\n", + "\tANSSI-CC-2019/05\n", + "\tBSI-DSZ-CC-0664-2011\n", + "\tBSI-DSZ-CC-0671-2011\n", + "\tBSI-DSZ-CC-0877-2013\n", + "\tCertification Report 2012/83\n", + "\tKECS-ISIS-0419-2012\n", + "\tNSCIB-CC-09-26151\n", + "\tNSCIB-CC-11-32973\n", + "\t2006-1-INF-311\n", + "\tANSSI-CC-2002/07\n", + "\tANSSI-CC-2002/12\n", + "\tANSSI-CC-2003/14\n", + "\tANSSI-CC-2005/52\n", + "\tANSSI-CC-2006/08\n", + "\tANSSI-CC-2007/20\n", + "\tANSSI-CC-2009/17\n", + "\tANSSI-CC-2010/06\n", + "\tANSSI-CC-2011/10\n", + "\tANSSI-CC-2011/12\n", + "\tANSSI-CC-2011/13\n", + "\tANSSI-CC-2011/16\n", + "\tANSSI-CC-2011/79\n", + "\tANSSI-CC-2011/80\n", + "\tBSI-DSZ-CC-0169-2002\n", + "\tBSI-DSZ-CC-0223-2003\n", + "\tBSI-DSZ-CC-0242-2004\n", + "\tBSI-DSZ-CC-0266-2005\n", + "\tBSI-DSZ-CC-0281-2005\n", + "\tBSI-DSZ-CC-0315-2005\n", + "\tBSI-DSZ-CC-0316-2005\n", + "\tBSI-DSZ-CC-0322-2005\n", + "\tBSI-DSZ-CC-0337-2005\n", + "\tBSI-DSZ-CC-0338-2005\n", + "\tBSI-DSZ-CC-0340-2005\n", + "\tBSI-DSZ-CC-0344-2005\n", + "\tBSI-DSZ-CC-0345-2006\n", + "\tBSI-DSZ-CC-0354-2006\n", + "\tBSI-DSZ-CC-0399-2007\n", + "\tBSI-DSZ-CC-0401-2006\n", + "\tBSI-DSZ-CC-0406-2007\n", + "\tBSI-DSZ-CC-0407-2008\n", + "\tBSI-DSZ-CC-0425-2009\n", + "\tBSI-DSZ-CC-0430-2008\n", + "\tBSI-DSZ-CC-0431-2007\n", + "\tBSI-DSZ-CC-0437-2008\n", + "\tBSI-DSZ-CC-0447-2008\n", + "\tBSI-DSZ-CC-0456-2009\n", + "\tBSI-DSZ-CC-0457-2008\n", + "\tBSI-DSZ-CC-0470-2008\n", + "\tBSI-DSZ-CC-0476-2007\n", + "\tBSI-DSZ-CC-0482-2008\n", + "\tBSI-DSZ-CC-0495-2009\n", + "\tBSI-DSZ-CC-0498-2009\n", + "\tBSI-DSZ-CC-0523-2008\n", + "\tBSI-DSZ-CC-0528-2008\n", + "\tBSI-DSZ-CC-0533-2009\n", + "\tBSI-DSZ-CC-0538-2008\n", + "\tBSI-DSZ-CC-0554-2009\n", + "\tBSI-DSZ-CC-0568-2008\n", + "\tBSI-DSZ-CC-0572-2008\n", + "\tBSI-DSZ-CC-0576-2009\n", + "\tBSI-DSZ-CC-0593-2009\n", + "\tBSI-DSZ-CC-0626-2009\n", + "\tBSI-DSZ-CC-0627-2009\n", + "\tBSI-DSZ-CC-0628-2009\n", + "\tBSI-DSZ-CC-0629-2010\n", + "\tBSI-DSZ-CC-0630-2010\n", + "\tBSI-DSZ-CC-0648-2010\n", + "\tBSI-DSZ-CC-0663-2009\n", + "\tBSI-DSZ-CC-0665-2010\n", + "\tBSI-DSZ-CC-0667-2010\n", + "\tBSI-DSZ-CC-0668-2010\n", + "\tC0229\n", + "\tKECS-ISIS-0118-2008\n", + "\t2017-17-INF-3169\n", + "\t2017-18-INF-3170\n", + "\t2017-19-INF-3171\n", + "\tANSSI-CC-2017/47\n", + "\tANSSI-CC-2017/48\n", + "\tANSSI-CC-2017/49\n", + "\tANSSI-CC-2017/68\n", + "\tANSSI-CC-2017/69\n", + "\tANSSI-CC-2017/70\n", + "\tANSSI-CC-2017/71\n", + "\tANSSI-CC-2017/72\n", + "\tANSSI-CC-2018/03\n", + "\tANSSI-CC-2018/04\n", + "\tANSSI-CC-2018/05\n", + "\tANSSI-CC-2018/06\n", + "\tANSSI-CC-2018/09\n", + "\tANSSI-CC-2018/10\n", + "\tANSSI-CC-2018/15\n", + "\tANSSI-CC-2018/16\n", + "\tANSSI-CC-2018/17\n", + "\tANSSI-CC-2018/18\n", + "\tANSSI-CC-2019/09\n", + "\tANSSI-CC-2020/42\n", + "\tANSSI-CC-2020/43\n", + "\tANSSI-CC-2020/44\n", + "\tANSSI-CC-2020/45\n", + "\tBSI-DSZ-CC-0869-2015\n", + "\tBSI-DSZ-CC-0869-V2-2019\n", + "\tBSI-DSZ-CC-0891-V3-2018\n", + "\tBSI-DSZ-CC-0891-V4-2019\n", + "\tBSI-DSZ-CC-0891-V5-2021\n", + "\tBSI-DSZ-CC-0891-V6-2021\n", + "\tBSI-DSZ-CC-0955-2016\n", + "\tBSI-DSZ-CC-0955-V2-2016\n", + "\tBSI-DSZ-CC-0973-2016\n", + "\tBSI-DSZ-CC-0973-V2-2016\n", + "\tBSI-DSZ-CC-0995-2018\n", + "\tBSI-DSZ-CC-0996-2018\n", + "\tBSI-DSZ-CC-1001-2018\n", + "\tBSI-DSZ-CC-1022-2018\n", + "\tBSI-DSZ-CC-1023-2018\n", + "\tBSI-DSZ-CC-1024-2018\n", + "\tBSI-DSZ-CC-1033-2019\n", + "\tBSI-DSZ-CC-1033-V2-2021\n", + "\tBSI-DSZ-CC-1034-2019\n", + "\tBSI-DSZ-CC-1034-V2-2021\n", + "\tBSI-DSZ-CC-1036-2019\n", + "\tBSI-DSZ-CC-1072-2018\n", + "\tBSI-DSZ-CC-1072-V2-2019\n", + "\tBSI-DSZ-CC-1072-V3-2019\n", + "\tBSI-DSZ-CC-1072-V4-2021\n", + "\tBSI-DSZ-CC-1072-V5-2022\n", + "\tBSI-DSZ-CC-1105-2020\n", + "\tBSI-DSZ-CC-1112-2020\n", + "\tBSI-DSZ-CC-1112-V2-2021\n", + "\tC0648\n", + "\tC0649\n", + "\tCRP296\n", + "\tCRP301\n", + "\tNSCIB-CC-0112113-CR\n", + "\tNSCIB-CC-127667-CR2\n", + "\tNSCIB-CC-127667-CR3\n", + "\tNSCIB-CC-146301-CR2\n", + "\tNSCIB-CC-66030-CR6\n", + "\tNSCIB-CC-87206-CR2\n", + "\tANSSI-CC-2020/09\n", + "\tANSSI-CC-2020/10\n", + "\tANSSI-CC-2020/11\n", + "\tANSSI-CC-2020/72\n", + "\tANSSI-CC-2020/73\n", + "\tANSSI-CC-2020/74\n", + "\tANSSI-CC-2020/75\n", + "\tANSSI-CC-2020/76\n", + "\tANSSI-CC-2021/18\n", + "\tANSSI-CC-2021/19\n", + "\tANSSI-CC-2021/19v2\n", + "\tANSSI-CC-2021/20\n", + "\tANSSI-CC-2021/20v2\n", + "\tANSSI-CC-2021/57\n", + "\tBSI-DSZ-CC-1040-2019\n", + "\tBSI-DSZ-CC-1119-2023\n", + "\tBSI-DSZ-CC-1120-2020\n", + "\tBSI-DSZ-CC-1120-V2-2021\n", + "\tBSI-DSZ-CC-1136-2021\n", + "\tBSI-DSZ-CC-1136-V2-2022\n", + "\tBSI-DSZ-CC-1136-V3-2022\n", + "\tBSI-DSZ-CC-1147-2020\n", + "\tBSI-DSZ-CC-1147-V2-2023\n", + "\tBSI-DSZ-CC-1148-2020\n", + "\tBSI-DSZ-CC-1148-V2-2023\n", + "\tBSI-DSZ-CC-1170-2023\n", + "\tNSCIB-CC-0061438-CR\n", + "\tNSCIB-CC-0061439-CR\n", + "\tNSCIB-CC-0061440-CR\n", + "\tNSCIB-CC-0075446-CR2\n", + "\tNSCIB-CC-0095534-CR3\n", + "\tNSCIB-CC-0108259-CR\n", + "\tNSCIB-CC-0108263-CR\n", + "\tNSCIB-CC-0229284-CR\n", + "\tNSCIB-CC-0229285-CR\n", + "\tNSCIB-CC-0229286-CR\n", + "\tNSCIB-CC-0229287-CR\n", + "\tNSCIB-CC-0237686-CR\n", + "\tNSCIB-CC-0237686-CR2\n", + "\tNSCIB-CC-0237694-CR\n", + "\tNSCIB-CC-0237694-CR2\n", + "\tNSCIB-CC-0237695-CR\n", + "\tNSCIB-CC-0237695-CR2\n", + "\tNSCIB-CC-0245762-CR\n", + "\tNSCIB-CC-0245767-CR\n", + "\tNSCIB-CC-0245771-CR\n", + "\tNSCIB-CC-180212-CR5\n", + "\tOCSI/CERT/CCL/05/2021/RC\n", + "\tOCSI/CERT/CCL/06/2021/RC\n", + "\tOCSI/CERT/CCL/07/2021/RC\n", + "\tOCSI/CERT/CCL/08/2022/RC\n", + "\tOCSI/CERT/CCL/09/2022/RC\n", + "\tOCSI/CERT/CCL/10/2022/RC\n", + "\tOCSI/CERT/CCL/11/2022/RC\n", + "\tOCSI/CERT/SYS/05/2016/RC\n", + "\tOCSI/CERT/SYS/06/2016/RC\n", + "\tOCSI/CERT/SYS/07/2016/RC\n", + "\tOCSI/CERT/SYS/08/2016/RC\n", + "\t21.0.01/TSE-CCCS-23\n", + "\t21.0.03/TSE-CCCS-49\n", + "\t21.0.03/TSE-CCCS-51\n", + "\tANSSI-CC-2014/53\n", + "\tANSSI-CC-2014/54\n", + "\tANSSI-CC-2015/45\n", + "\tANSSI-CC-2016/64\n", + "\tANSSI-CC-2016/66\n", + "\tANSSI-CC-2016/67\n", + "\tANSSI-CC-2016/70\n", + "\tANSSI-CC-2016/80\n", + "\tANSSI-CC-2016/81\n", + "\tANSSI-CC-2017/05\n", + "\tANSSI-CC-2017/06\n", + "\tANSSI-CC-2017/08\n", + "\tANSSI-CC-2017/09\n", + "\tANSSI-CC-2017/59\n", + "\tANSSI-CC-2017/65\n", + "\tANSSI-CC-2017/66\n", + "\tANSSI-CC-2017/74\n", + "\tANSSI-CC-2018/22\n", + "\tANSSI-CC-2018/27\n", + "\tANSSI-CC-2018/44-S01\n", + "\tANSSI-CC-2018/45\n", + "\tBSI-DSZ-CC-0758-2012\n", + "\tBSI-DSZ-CC-0782-2012\n", + "\tBSI-DSZ-CC-0782-V2-2015\n", + "\tBSI-DSZ-CC-0782-V3-2017\n", + "\tBSI-DSZ-CC-0782-V4-2018\n", + "\tBSI-DSZ-CC-0782-V5-2020\n", + "\tBSI-DSZ-CC-0833-2013\n", + "\tBSI-DSZ-CC-0879-2014\n", + "\tBSI-DSZ-CC-0879-V2-2015\n", + "\tBSI-DSZ-CC-0889-2013\n", + "\tBSI-DSZ-CC-0921-2014\n", + "\tBSI-DSZ-CC-0938-2016\n", + "\tBSI-DSZ-CC-0956-2016\n", + "\tBSI-DSZ-CC-0967-2016\n", + "\tBSI-DSZ-CC-0968-2016\n", + "\tBSI-DSZ-CC-0985-2018\n", + "\tBSI-DSZ-CC-0987-2019\n", + "\tBSI-DSZ-CC-1088-2022\n", + "\tCRP278\n", + "\tCRP279\n", + "\tKECS-ISIS-0579-2015\n", + "\tKECS-ISIS-0676-2015\n", + "\tKECS-ISIS-0677-2015\n", + "\tKECS-ISIS-1113-2021\n", + "\tKECS-ISIS-1139-2021\n", + "\tKECS-ISIS-1140-2021\n", + "\tNSCIB-CC-15-77633\n", + "\tNSCIB-CC-195748-CR\n", + "\tNSCIB-CC-196231-CR\n", + "\tSERTIT-079\n", + "\tSERTIT-091\n", + "\tANSSI-CC-2019/55\n", + "\tANSSI-CC-2019/56\n", + "\tANSSI-CC-2019/57\n", + "\tANSSI-CC-2019/58\n", + "\tANSSI-CC-2020/07\n", + "\tANSSI-CC-2020/08\n", + "\tANSSI-CC-2020/55\n", + "\tANSSI-CC-2020/56\n", + "\tANSSI-CC-2020/57\n", + "\tANSSI-CC-2020/58\n", + "\tANSSI-CC-2020/59\n", + "\tANSSI-CC-2020/60\n", + "\tANSSI-CC-2020/61\n", + "\tANSSI-CC-2020/62\n", + "\tANSSI-CC-2020/63\n", + "\tANSSI-CC-2020/64\n", + "\tANSSI-CC-2020/87\n", + "\tANSSI-CC-2020/88\n", + "\tBSI-DSZ-CC-0596-V2-2018\n", + "\tBSI-DSZ-CC-0596-V3-2023\n", + "\tBSI-DSZ-CC-0904-2015\n", + "\tBSI-DSZ-CC-0904-V2-2021\n", + "\tBSI-DSZ-CC-0916-2015\n", + "\tBSI-DSZ-CC-0928-2018\n", + "\tBSI-DSZ-CC-0928-V2-2019\n", + "\tBSI-DSZ-CC-0945-V2-2018\n", + "\tBSI-DSZ-CC-0945-V3-2018\n", + "\tBSI-DSZ-CC-0950-2017\n", + "\tBSI-DSZ-CC-0950-V2-2018\n", + "\tBSI-DSZ-CC-0976-2015\n", + "\tBSI-DSZ-CC-0976-V2-2018\n", + "\tBSI-DSZ-CC-0976-V3-2019\n", + "\tBSI-DSZ-CC-0976-V4-2021\n", + "\tBSI-DSZ-CC-1067-2020\n", + "\tBSI-DSZ-CC-1067-V2-2022\n", + "\tBSI-DSZ-CC-1067-V3-2022\n", + "\tBSI-DSZ-CC-1068-2020\n", + "\tBSI-DSZ-CC-1068-V2-2022\n", + "\tBSI-DSZ-CC-1068-V3-2022\n", + "\tBSI-DSZ-CC-1076-2020\n", + "\tBSI-DSZ-CC-1077-2020\n", + "\tBSI-DSZ-CC-1098-2020\n", + "\tBSI-DSZ-CC-1110-2019\n", + "\tBSI-DSZ-CC-1110-V2-2019\n", + "\tBSI-DSZ-CC-1110-V3-2020\n", + "\tKECS-ISIS-1031-2020\n", + "\tNSCIB-CC-0075541-CR2\n", + "\tNSCIB-CC-0286907-CR\n", + "\tNSCIB-CC-200270-CR\n", + "\tNSCIB-CC-200689-CR\n", + "\tNSCIB-CC-200716-CR2\n", + "\tNSCIB-CC-200736-CR\n", + "\tNSCIB-CC-200833-CR\n", + "\t2011-12-INF-1089\n", + "\t2011-13-INF-1092\n", + "\t2011-14-INF-1095\n", + "\t2011-15-INF-1098\n", + "\tANSSI-CC-2006/30\n", + "\tANSSI-CC-2007/04\n", + "\tANSSI-CC-2007/22\n", + "\tANSSI-CC-2008/03\n", + "\tANSSI-CC-2008/05\n", + "\tANSSI-CC-2008/10\n", + "\tANSSI-CC-2008/12\n", + "\tANSSI-CC-2008/16\n", + "\tANSSI-CC-2008/22\n", + "\tANSSI-CC-2009/04\n", + "\tANSSI-CC-2009/10\n", + "\tANSSI-CC-2009/11\n", + "\tANSSI-CC-2009/22\n", + "\tANSSI-CC-2009/23\n", + "\tANSSI-CC-2009/36\n", + "\tANSSI-CC-2009/41\n", + "\tANSSI-CC-2009/46\n", + "\tANSSI-CC-2009/47\n", + "\tANSSI-CC-2009/59\n", + "\tANSSI-CC-2010/05\n", + "\tANSSI-CC-2010/11\n", + "\tANSSI-CC-2010/12\n", + "\tANSSI-CC-2010/25\n", + "\tANSSI-CC-2010/26\n", + "\tANSSI-CC-2010/27\n", + "\tANSSI-CC-2010/36\n", + "\tANSSI-CC-2010/37\n", + "\tANSSI-CC-2010/38\n", + "\tANSSI-CC-2010/39\n", + "\tANSSI-CC-2010/40\n", + "\tANSSI-CC-2010/58\n", + "\tANSSI-CC-2010/60\n", + "\tANSSI-CC-2011/01\n", + "\tANSSI-CC-2011/03\n", + "\tANSSI-CC-2011/45\n", + "\tANSSI-CC-2011/64\n", + "\tANSSI-CC-2012/10\n", + "\tANSSI-CC-2012/23\n", + "\tANSSI-CC-2012/30\n", + "\tANSSI-CC-2012/43\n", + "\tANSSI-CC-2012/71\n", + "\tANSSI-CC-2013/70\n", + "\tANSSI-CC-2016/69\n", + "\tBSI-DSZ-CC-0421-2008\n", + "\tBSI-DSZ-CC-0449-2009\n", + "\tCRP272\n", + "\t2016-30-INF-2094\n", + "\t2016-31-INF-2102\n", + "\t2016-32-INF-2110\n", + "\tANSSI-CC-2017/07\n", + "\tANSSI-CC-2017/19\n", + "\tANSSI-CC-2017/20\n", + "\tANSSI-CC-2017/21\n", + "\tANSSI-CC-2017/22\n", + "\tANSSI-CC-2017/54\n", + "\tANSSI-CC-2017/76\n", + "\tANSSI-CC-2017/81\n", + "\tANSSI-CC-2017/82\n", + "\tANSSI-CC-2017/83\n", + "\tANSSI-CC-2018/11\n", + "\tANSSI-CC-2018/21\n", + "\tANSSI-CC-2018/24\n", + "\tANSSI-CC-2018/35\n", + "\tANSSI-CC-2018/36\n", + "\tANSSI-CC-2018/37\n", + "\tANSSI-CC-2018/38\n", + "\tANSSI-CC-2018/50\n", + "\tANSSI-CC-2020/33\n", + "\tBSI-DSZ-CC-0726-2012\n", + "\tBSI-DSZ-CC-0891-2015\n", + "\tBSI-DSZ-CC-0891-V2-2016\n", + "\tBSI-DSZ-CC-0945-2017\n", + "\tBSI-DSZ-CC-0961-2017\n", + "\tBSI-DSZ-CC-0961-V2-2018\n", + "\tBSI-DSZ-CC-0961-V3-2018\n", + "\tBSI-DSZ-CC-0961-V4-2019\n", + "\tBSI-DSZ-CC-0961-V5-2020\n", + "\tBSI-DSZ-CC-0961-V6-2022\n", + "\tBSI-DSZ-CC-0980-2017\n", + "\tBSI-DSZ-CC-1003-2018\n", + "\tBSI-DSZ-CC-1055-2018\n", + "\tBSI-DSZ-CC-1117-2019\n", + "\tNSCIB-CC-16-95781\n", + "\tANSSI-CC-2019/28\n", + "\tANSSI-CC-2019/32\n", + "\tANSSI-CC-2019/33\n", + "\tANSSI-CC-2019/34\n", + "\tANSSI-CC-2019/35\n", + "\tANSSI-CC-2019/36\n", + "\tANSSI-CC-2019/41\n", + "\tANSSI-CC-2019/43\n", + "\tANSSI-CC-2019/47\n", + "\tANSSI-CC-2019/48\n", + "\tANSSI-CC-2019/49\n", + "\tANSSI-CC-2019/50\n", + "\tANSSI-CC-2020/26\n", + "\tANSSI-CC-2020/35\n", + "\tANSSI-CC-2020/36\n", + "\tANSSI-CC-2020/37\n", + "\tANSSI-CC-2020/38\n", + "\tANSSI-CC-2020/50\n", + "\tANSSI-CC-2020/51\n", + "\tANSSI-CC-2020/52\n", + "\tANSSI-CC-2020/53\n", + "\tANSSI-CC-2022/33\n", + "\tBSI-DSZ-CC-1059-2018\n", + "\tBSI-DSZ-CC-1059-V2-2019\n", + "\tBSI-DSZ-CC-1059-V3-2019\n", + "\tBSI-DSZ-CC-1059-V4-2021\n", + "\tBSI-DSZ-CC-1059-V5-2022\n", + "\tBSI-DSZ-CC-1078-2019\n", + "\tBSI-DSZ-CC-1103-2019\n", + "\tBSI-DSZ-CC-1118-2020\n", + "\tBSI-DSZ-CC-1121-2019\n", + "\tBSI-DSZ-CC-1121-V2-2021\n", + "\tNSCIB-CC-180045-CR2\n", + "\tNSCIB-CC-180351-CR2\n", + "\tNSCIB-CC-67206-CR6\n", + "\tNSCIB-CC-98209-CR5\n", + "\tANSSI-CC-2012/24\n", + "\tANSSI-CC-2012/76\n", + "\tANSSI-CC-2012/80\n", + "\tANSSI-CC-2013/29\n", + "\tANSSI-CC-2013/30\n", + "\tANSSI-CC-2013/31\n", + "\tBSI-DSZ-CC-0645-2010\n", + "\tBSI-DSZ-CC-0682-2010\n", + "\tBSI-DSZ-CC-0717-2011\n", + "\tBSI-DSZ-CC-0731-2011\n", + "\tBSI-DSZ-CC-0741-2011\n", + "\tBSI-DSZ-CC-0742-2011\n", + "\tBSI-DSZ-CC-0743-2011\n", + "\tBSI-DSZ-CC-0744-2011\n", + "\tBSI-DSZ-CC-0750-2011\n", + "\tBSI-DSZ-CC-0750-V2-2014\n", + "\tBSI-DSZ-CC-0783-2013\n", + "\tBSI-DSZ-CC-0800-2012\n", + "\tBSI-DSZ-CC-0858-2013\n", + "\tBSI-DSZ-CC-0858-V2-2015\n", + "\tBSI-DSZ-CC-0866-2013\n", + "\tBSI-DSZ-CC-0866-V2-2014\n", + "\tBSI-DSZ-CC-0867-2014\n", + "\tBSI-DSZ-CC-0911-2014\n", + "\tBSI-DSZ-CC-0912-2014\n", + "\tBSI-DSZ-CC-0913-2014\n", + "\tBSI-DSZ-CC-0914-2014\n", + "\tCertification Report 2012/80\n", + "\tNSCIB-CC-13-37760-CR2\n", + "\tOCSI/CERT/SYS/02/2016/RC\n", + "\tOCSI/CERT/SYS/03/2016/RC\n", + "\tOCSI/CERT/SYS/04/2015/RC\n", + "\tOCSI/CERT/SYS/05/2015/RC\n", + "\tANSSI-CC-2011/07\n", + "\tANSSI-CC-2011/17\n", + "\tANSSI-CC-2011/24\n", + "\tANSSI-CC-2011/77\n", + "\tANSSI-CC-2012/06\n", + "\tANSSI-CC-2012/11\n", + "\tANSSI-CC-2012/29\n", + "\tANSSI-CC-2012/39\n", + "\tANSSI-CC-2012/48\n", + "\tANSSI-CC-2012/49\n", + "\tANSSI-CC-2012/75\n", + "\tANSSI-CC-2012/79\n", + "\tANSSI-CC-2012/84\n", + "\tANSSI-CC-2013/07\n", + "\tANSSI-CC-2013/13\n", + "\tANSSI-CC-2013/18\n", + "\tANSSI-CC-2013/19\n", + "\tANSSI-CC-2013/27\n", + "\tANSSI-CC-2013/28\n", + "\tANSSI-CC-2013/43\n", + "\tANSSI-CC-2013/44\n", + "\tANSSI-CC-2013/45\n", + "\tANSSI-CC-2013/56\n", + "\tANSSI-CC-2013/57\n", + "\tANSSI-CC-2013/60\n", + "\tANSSI-CC-2013/65\n", + "\tANSSI-CC-2014/56\n", + "\tANSSI-CC-2014/81\n", + "\tANSSI-CC-2014/82\n", + "\tANSSI-CC-2014/83\n", + "\tANSSI-CC-2014/88\n", + "\tANSSI-CC-2014/96\n", + "\tCertification Report 2012/79\n", + "\tANSSI-CC-2007/08\n", + "\tANSSI-CC-2007/19\n", + "\tANSSI-CC-2008/37\n", + "\tANSSI-CC-2016/60\n", + "\tANSSI-CC-2019/38\n", + "\tBSI-DSZ-CC-0269-2006\n", + "\tBSI-DSZ-CC-0376-2006\n", + "\tBSI-DSZ-CC-0395-2007\n", + "\tBSI-DSZ-CC-0559-2012\n", + "\tBSI-DSZ-CC-0632-2011\n", + "\tBSI-DSZ-CC-0791-2012\n", + "\tBSI-DSZ-CC-0827-2013\n", + "\tBSI-DSZ-CC-0827-V2-2014\n", + "\tBSI-DSZ-CC-0827-V3-2015\n", + "\tBSI-DSZ-CC-0827-V4-2016\n", + "\tBSI-DSZ-CC-0827-V5-2017\n", + "\tBSI-DSZ-CC-0827-V6-2017\n", + "\tBSI-DSZ-CC-0827-V7-2018\n", + "\tBSI-DSZ-CC-0827-V8-2020\n", + "\tBSI-DSZ-CC-0878-2013\n", + "\tBSI-DSZ-CC-0936-2015\n", + "\tBSI-DSZ-CC-0946-2014\n", + "\tBSI-DSZ-CC-0946-V2-2015\n", + "\tBSI-DSZ-CC-0946-V3-2017\n", + "\tBSI-DSZ-CC-1015-2017\n", + "\tBSI-DSZ-CC-1015-V2-2020\n", + "\tBSI-DSZ-CC-1069-2018\n", + "\tBSI-DSZ-CC-1158-2020\n", + "\tCSEC2014007\n", + "\tCSEC2017020\n", + "\tANSSI-CC-2015/44\n", + "\tANSSI-CC-2015/74\n", + "\tANSSI-CC-2015/75\n", + "\tANSSI-CC-2017/34\n", + "\tANSSI-CC-2017/35\n", + "\tANSSI-CC-2017/43\n", + "\tANSSI-CC-2017/62\n", + "\tANSSI-CC-2017/63\n", + "\tANSSI-CC-2017/64\n", + "\tANSSI-CC-2020/46\n", + "\tANSSI-CC-2020/47\n", + "\tANSSI-CC-2020/48\n", + "\tBSI-DSZ-CC-0897-2013\n", + "\tBSI-DSZ-CC-0897-V2-2014\n", + "\tNSCIB-CC-13-37581-CR2\n", + "\tNSCIB-CC-16-99111\n", + "\tNSCIB-CC-16-99111-CR2\n", + "\tOCSI/CERT/SYS/02/2018/RC\n", + "\tOCSI/CERT/SYS/03/2018/RC\n", + "\tOCSI/CERT/SYS/04/2018/RC\n", + "\tOCSI/CERT/SYS/09/2016/RC\n", + "\tOCSI/CERT/SYS/10/2016/RC\n", + "\tOCSI/CERT/SYS/11/2016/RC\n", + "\tANSSI-CC-2007/18\n", + "\tANSSI-CC-2009/49\n", + "\tBSI-DSZ-CC-0220-2004\n", + "\tBSI-DSZ-CC-0231-2004\n", + "\tBSI-DSZ-CC-0232-2004\n", + "\tBSI-DSZ-CC-0244-2004\n", + "\tBSI-DSZ-CC-0293-2005\n", + "\tBSI-DSZ-CC-0296-2006\n", + "\tBSI-DSZ-CC-0311-2005\n", + "\tBSI-DSZ-CC-0346-2006\n", + "\tBSI-DSZ-CC-0347-2006\n", + "\tBSI-DSZ-CC-0358-2006\n", + "\tBSI-DSZ-CC-0360-2006\n", + "\tBSI-DSZ-CC-0361-2006\n", + "\tBSI-DSZ-CC-0368-2006\n", + "\tBSI-DSZ-CC-0390-2007\n", + "\tBSI-DSZ-CC-0392-2007\n", + "\tBSI-DSZ-CC-0465-2008\n", + "\tBSI-DSZ-CC-0550-2008\n", + "\tBSI-DSZ-CC-0583-2009\n", + "\tBSI-DSZ-CC-0584-2009\n", + "\tBSI-DSZ-CC-0612-2010\n", + "\tBSI-DSZ-CC-0661-2011\n", + "\tANSSI-CC-2019/04\n", + "\tBSI-DSZ-CC-0868-2014\n", + "\tBSI-DSZ-CC-0879-V3-2018\n", + "\tBSI-DSZ-CC-0879-V4-2020\n", + "\tBSI-DSZ-CC-0879-V5-2022\n", + "\tBSI-DSZ-CC-0951-2015\n", + "\tBSI-DSZ-CC-0951-V2-2017\n", + "\tBSI-DSZ-CC-0951-V3-2018\n", + "\tBSI-DSZ-CC-0951-V4-2019\n", + "\tBSI-DSZ-CC-0951-V5-2021\n", + "\tBSI-DSZ-CC-1028-2017\n", + "\tBSI-DSZ-CC-1032-2018\n", + "\tBSI-DSZ-CC-1071-2019\n", + "\tBSI-DSZ-CC-1071-V2-2019\n", + "\tBSI-DSZ-CC-1071-V3-2020\n", + "\tBSI-DSZ-CC-1071-V4-2020\n", + "\tBSI-DSZ-CC-1071-V5-2021\n", + "\tBSI-DSZ-CC-1084-2019\n", + "\tBSI-DSZ-CC-1090-2018\n", + "\tBSI-DSZ-CC-1091-2018\n", + "\tBSI-DSZ-CC-1092-2020\n", + "\tANSSI-CC-2002/05\n", + "\tANSSI-CC-2005/42\n", + "\tANSSI-CC-2006/13\n", + "\tANSSI-CC-2006/23\n", + "\tANSSI-CC-2006/28\n", + "\tANSSI-CC-2007/02\n", + "\tANSSI-CC-2007/16\n", + "\tBSI-DSZ-CC-0227-2004\n", + "\tBSI-DSZ-CC-0294-2006\n", + "\tBSI-DSZ-CC-0312-2005\n", + "\tBSI-DSZ-CC-0313-2006\n", + "\tBSI-DSZ-CC-0348-2006\n", + "\tBSI-DSZ-CC-0349-2006\n", + "\tBSI-DSZ-CC-0362-2006\n", + "\tBSI-DSZ-CC-0375-2007\n", + "\tBSI-DSZ-CC-0384-2007\n", + "\tBSI-DSZ-CC-0426-2007\n", + "\tBSI-DSZ-CC-0429-2007\n", + "\tBSI-DSZ-CC-0445-2007\n", + "\tBSI-DSZ-CC-0467-2008\n", + "\tBSI-DSZ-CC-0507-2008\n", + "\tANSSI-CC-2016/58\n", + "\tANSSI-CC-2017/44\n", + "\tANSSI-CC-2017/61\n", + "\tANSSI-CC-2019/08\n", + "\tANSSI-CC-2019/12\n", + "\tANSSI-CC-2019/13\n", + "\tANSSI-CC-2019/16\n", + "\tANSSI-CC-2019/17\n", + "\tBSI-DSZ-CC-1064-2020\n", + "\tBSI-DSZ-CC-1065-2020\n", + "\tBSI-DSZ-CC-1073-2019\n", + "\tBSI-DSZ-CC-1073-V2-2020\n", + "\tBSI-DSZ-CC-1074-2019\n", + "\tBSI-DSZ-CC-1074-V2-2020\n", + "\tNSCIB-CC-0122197-CR\n", + "\tNSCIB-CC-0145426-CR\n", + "\tNSCIB-CC-0145427-CR\n", + "\tNSCIB-CC-222356-CR2\n", + "\tANSSI-CC-2022/07\n", + "\tANSSI-CC-2022/08\n", + "\tANSSI-CC-2022/19\n", + "\tANSSI-CC-2022/20\n", + "\tANSSI-CC-2022/64\n", + "\tANSSI-CC-2022/65\n", + "\tANSSI-CC-2022/67\n", + "\tANSSI-CC-2022/68\n", + "\tBSI-DSZ-CC-1110-V4-2021\n", + "\tBSI-DSZ-CC-1110-V5-2022\n", + "\tBSI-DSZ-CC-1162-2021\n", + "\tBSI-DSZ-CC-1172-2022\n", + "\tNSCIB-CC-0286910-CR2\n", + "\tNSCIB-CC-0299277-CR\n", + "\tNSCIB-CC-0299278-CR\n", + "\tNSCIB-CC-175887-CR3\n", + "\tANSSI-CC-2014/01\n", + "\tANSSI-CC-2014/02\n", + "\tANSSI-CC-2014/03\n", + "\tBSI-DSZ-CC-0633-V2-2014\n", + "\tBSI-DSZ-CC-0707-2012\n", + "\tBSI-DSZ-CC-0821-2014\n", + "\tBSI-DSZ-CC-0825-2017\n", + "\tBSI-DSZ-CC-0857-2013\n", + "\tBSI-DSZ-CC-0857-V2-2015\n", + "\tBSI-DSZ-CC-0860-2013\n", + "\tBSI-DSZ-CC-0864-2012\n", + "\tNSCIB-CC-13-37761-CR2\n", + "\tNSCIB-CC-13-37762\n", + "\tNSCIB-CC-15-67351\n", + "\tANSSI-CC-2020/65\n", + "\tANSSI-CC-2020/70\n", + "\tANSSI-CC-2021/38\n", + "\tANSSI-CC-2021/39\n", + "\tANSSI-CC-2021/41\n", + "\tBSI-DSZ-CC-1079-2018\n", + "\tBSI-DSZ-CC-1079-V2-2020\n", + "\tBSI-DSZ-CC-1079-V3-2021\n", + "\tNSCIB-CC-0031318-CR3\n", + "\tNSCIB-CC-0189569-CR\n", + "\tNSCIB-CC-0189587-CR\n", + "\tNSCIB-CC-0189590-CR\n", + "\tNSCIB-CC-0189594-CR\n", + "\tANSSI-CC-2008/17\n", + "\tANSSI-CC-2009/43\n", + "\tANSSI-CC-2012/09\n", + "\tBSI-DSZ-CC-0400-2007\n", + "\tBSI-DSZ-CC-0438-2007\n", + "\tBSI-DSZ-CC-0452-2007\n", + "\tBSI-DSZ-CC-0501-2008\n", + "\tBSI-DSZ-CC-0624-2010\n", + "\tKECS-ISIS-0222-2010\n", + "\tKECS-ISIS-0272-2010\n", + "\tKECS-ISIS-0378-2012\n", + "\tANSSI-CC-2009/37\n", + "\tANSSI-CC-2009/38\n", + "\tANSSI-CC-2009/39\n", + "\tANSSI-CC-2009/40\n", + "\tANSSI-CC-2009/63\n", + "\tANSSI-CC-2012/65\n", + "\tANSSI-CC-2013/01\n", + "\tANSSI-CC-2013/06\n", + "\tANSSI-CC-2013/09\n" + ] + } + ], "source": [ "for com in communities:\n", " for i in sorted(com):\n", @@ -1174,32 +2796,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\\newcommand{\\numCcAllDirectReferencing}{1553}\n", + "\\newcommand{\\numCcAllNotDirectReferencing}{3803}\n", + "\\newcommand{\\numCcWithIdDirectReferencing}{1553}\n", + "\\newcommand{\\numCcWithIdNotDirectReferencing}{3726}\n", + "\\newcommand{\\numCCActiveDirectReferencing}{526}\n", + "\\newcommand{\\numCCActiveDirectReferencingArchived}{175}\n", + "\n", + "\\newcommand{\\numCCDirectRefsSameCategory}{2215}\n", + "\\newcommand{\\numCCDirectRefsOtherCategory}{201}\n", + "\\newcommand{\\numCCDirectRefs}{2416}\n", + "\\newcommand{\\numCCDirectRefsFromSmartcards}{1969}\n", + "\n", + "\\newcommand{\\numCCUSReferencing}{4}\n", + "\\newcommand{\\numCCUS}{1010}\n" + ] + } + ], "source": [ - "def contains_archived_cert_reference(referencing):\n", - " if pd.isnull(referencing):\n", - " return False\n", - " return bool(archived_cert_id_list.intersection(referencing))\n", - "\n", - "\n", - "print(f\"\\\\newcommand{{\\\\numCcAllDirectReferencing}}{{{df.has_outgoing_direct_references.sum()}}}\")\n", - "print(f\"\\\\newcommand{{\\\\numCcAllNotDirectReferencing}}{{{len(df) - df.has_outgoing_direct_references.sum()}}}\")\n", - "print(f\"\\\\newcommand{{\\\\numCcWithIdDirectReferencing}}{{{df_id_rich.has_outgoing_direct_references.sum()}}}\")\n", - "print(f\"\\\\newcommand{{\\\\numCcWithIdNotDirectReferencing}}{{{len(df_id_rich) - df_id_rich.has_outgoing_direct_references.sum()}}}\")\n", - "print(f\"\\\\newcommand{{\\\\numCCActiveDirectReferencing}}{{{df_id_rich.loc[df_id_rich.status == 'active'].has_outgoing_direct_references.sum()}}}\")\n", - "print(f\"\\\\newcommand{{\\\\numCCActiveDirectReferencingArchived}}{{{df_id_rich[df_id_rich.status == 'active'].directly_referencing.apply(contains_archived_cert_reference).sum()}}}\")\n", + "# TODO: These are old commands that belonged to first paper. Replace them with code that can produce the similar numbers.\n", + "# print(f\"\\\\newcommand{{\\\\numCcAllDirectReferencing}}{{{df.has_outgoing_direct_references.sum()}}}\")\n", + "# print(f\"\\\\newcommand{{\\\\numCcAllNotDirectReferencing}}{{{len(df) - df.has_outgoing_direct_references.sum()}}}\")\n", + "# print(f\"\\\\newcommand{{\\\\numCcWithIdDirectReferencing}}{{{df_id_rich.has_outgoing_direct_references.sum()}}}\")\n", + "# print(f\"\\\\newcommand{{\\\\numCcWithIdNotDirectReferencing}}{{{len(df_id_rich) - df_id_rich.has_outgoing_direct_references.sum()}}}\")\n", + "# print(f\"\\\\newcommand{{\\\\numCCActiveDirectReferencing}}{{{df_id_rich.loc[df_id_rich.status == 'active'].has_outgoing_direct_references.sum()}}}\")\n", "\n", - "print(\"\")\n", - "print(f\"\\\\newcommand{{\\\\numCCDirectRefsSameCategory}}{{{(exploded_with_refs.category == exploded_with_refs.ref_category).sum()}}}\")\n", - "print(f\"\\\\newcommand{{\\\\numCCDirectRefsOtherCategory}}{{{(exploded_with_refs.category != exploded_with_refs.ref_category).sum()}}}\")\n", - "print(f\"\\\\newcommand{{\\\\numCCDirectRefs}}{{{len(exploded_with_refs)}}}\")\n", - "print(f\"\\\\newcommand{{\\\\numCCDirectRefsFromSmartcards}}{{{(exploded_with_refs.category == 'ICs, Smart Cards and Smart Card-Related Devices and Systems').sum()}}}\")\n", + "# print(\"\")\n", + "# print(f\"\\\\newcommand{{\\\\numCCDirectRefsSameCategory}}{{{(exploded_with_refs.category == exploded_with_refs.ref_category).sum()}}}\")\n", + "# print(f\"\\\\newcommand{{\\\\numCCDirectRefsOtherCategory}}{{{(exploded_with_refs.category != exploded_with_refs.ref_category).sum()}}}\")\n", + "# print(f\"\\\\newcommand{{\\\\numCCDirectRefs}}{{{len(exploded_with_refs)}}}\")\n", + "# print(f\"\\\\newcommand{{\\\\numCCDirectRefsFromSmartcards}}{{{(exploded_with_refs.category == 'ICs, Smart Cards and Smart Card-Related Devices and Systems').sum()}}}\")\n", "\n", - "print(\"\")\n", - "print(f\"\\\\newcommand{{\\\\numCCUSReferencing}}{{{len(df_id_rich.loc[(df_id_rich.scheme == 'US') & (df_id_rich.directly_referencing.notnull())])}}}\")\n", - "print(f\"\\\\newcommand{{\\\\numCCUS}}{{{len(df_id_rich.loc[(df_id_rich.scheme == 'US')])}}}\")" + "# print(\"\")\n", + "# print(f\"\\\\newcommand{{\\\\numCCUSReferencing}}{{{len(df_id_rich.loc[(df_id_rich.scheme == 'US') & (df_id_rich.directly_referencing.notnull())])}}}\")\n", + "# print(f\"\\\\newcommand{{\\\\numCCUS}}{{{len(df_id_rich.loc[(df_id_rich.scheme == 'US')])}}}\")" ] } ], @@ -1219,7 +2856,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.10.13" }, "vscode": { "interpreter": { |