From 5428e163bd6c20592422a4d266024af3443664e6 Mon Sep 17 00:00:00 2001
From: tsantosh7 <tsantosh7@gmail.com>
Date: Sat, 1 Jun 2024 02:30:40 +0100
Subject: [PATCH 1/2] added scripts to download xml files and convert to jsonl

---
 .../england_wales/00_download_judgements.py   | 76 +++++++++++++++++++
 scripts/england_wales/01_extract_jsonl.py     | 59 ++++++++++++++
 .../england_wales/02_extract_jsonl_refined.py | 63 +++++++++++++++
 3 files changed, 198 insertions(+)
 create mode 100644 scripts/england_wales/00_download_judgements.py
 create mode 100644 scripts/england_wales/01_extract_jsonl.py
 create mode 100644 scripts/england_wales/02_extract_jsonl_refined.py

diff --git a/scripts/england_wales/00_download_judgements.py b/scripts/england_wales/00_download_judgements.py
new file mode 100644
index 0000000..d33bb85
--- /dev/null
+++ b/scripts/england_wales/00_download_judgements.py
@@ -0,0 +1,76 @@
+import requests
+from bs4 import BeautifulSoup
+import pandas as pd
+from multiprocessing import Pool
+import os
+import time
+from tqdm import tqdm
+
+# Define the base URL
+base_url = "https://caselaw.nationalarchives.gov.uk/judgments/advanced_search?query=&court=ewca%2Fcrim&order=date&per_page=50&page="
+num_pages = 124
+output_folder = "dump"
+csv_file = 'judgments.csv'
+
+# Ensure the output directory exists
+os.makedirs(output_folder, exist_ok=True)
+
+
+# Scrape data from a single page
+def scrape_page(page_number):
+    url = base_url + str(page_number)
+    response = requests.get(url)
+    soup = BeautifulSoup(response.text, 'html.parser')
+    results = []
+
+    for li in soup.select('ul.judgment-listing__list > li'):
+        title_tag = li.find('a')
+        date_tag = li.find('time')
+
+        if title_tag and date_tag:
+            href = title_tag['href']
+            title = title_tag.text.strip()
+            date = date_tag.text.strip()
+            link = "https://caselaw.nationalarchives.gov.uk" + href
+            results.append((title, link, date))
+
+    return results
+
+
+# Download XML files
+def download_xml(data):
+    title, link, date, sno = data
+    date_formatted = pd.to_datetime(date).strftime('%Y_%m_%d')
+    xml_url = link + "/data.xml"
+    file_name = f"{date_formatted}-{sno}.xml"
+    file_path = os.path.join(output_folder, file_name)
+
+    response = requests.get(xml_url)
+    with open(file_path, 'wb') as file:
+        file.write(response.content)
+
+    time.sleep(1)  # Pause to avoid blocking IP address
+
+
+# Initialize CSV file
+if not os.path.exists(csv_file):
+    pd.DataFrame(columns=['Title', 'Link', 'Date', 'SNo']).to_csv(csv_file, index=False)
+
+# Scrape all pages and process data incrementally
+sno = 1
+for page in tqdm(range(1, num_pages + 1), desc="Scraping pages"):
+    results = scrape_page(page)
+
+    # Add serial number to each result
+    results_with_sno = [(title, link, date, sno + i) for i, (title, link, date) in enumerate(results)]
+    sno += len(results)
+
+    # Save results to CSV incrementally
+    df = pd.DataFrame(results_with_sno, columns=['Title', 'Link', 'Date', 'SNo'])
+    df.to_csv(csv_file, mode='a', header=False, index=False)
+
+    # Download XML files
+    with Pool() as pool:
+        pool.map(download_xml, results_with_sno)
+
+print("Scraping and downloading completed successfully!")
diff --git a/scripts/england_wales/01_extract_jsonl.py b/scripts/england_wales/01_extract_jsonl.py
new file mode 100644
index 0000000..735498a
--- /dev/null
+++ b/scripts/england_wales/01_extract_jsonl.py
@@ -0,0 +1,59 @@
+import os
+import json
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+
+def extract_information_from_xml(xml_content):
+    soup = BeautifulSoup(xml_content, 'lxml')
+
+    # Extract required fields
+    _id = soup.find('uk:hash').text
+    signature = soup.find('neutralcitation').text if soup.find('neutralcitation') else None
+    hearing_date = soup.find('hearingdate').text if soup.find('hearingdate') else None
+    date = hearing_date.strip() if hearing_date else None
+    publication_date = soup.find('frbrwork').find('frbrdate')['date']
+    court_type = soup.find('courttype').text if soup.find('courttype') else None
+
+    # Get the excerpt
+    header_text = soup.header.get_text(separator=' ', strip=True)
+    excerpt = header_text[:500]
+
+    # Get the full content of the judgment body as XML string
+    judgment_body = soup.find('judgmentbody')
+    content = str(judgment_body) if judgment_body else None
+
+    # Get the judges list
+    judges = [judge.get_text() for judge in soup.find_all('judge')]
+
+    # Get case numbers
+    case_numbers = [case_number.get_text() for case_number in soup.find_all('p', class_='CoverText') if
+                    'Case Nos:' in case_number.text]
+    case_numbers = [num.strip() for sublist in case_numbers for num in sublist.replace('Case Nos:', '').split()]
+
+    return {
+        "_id": _id,
+        "signature": signature,
+        "date": date,
+        "publicationDate": publication_date,
+        "type": court_type,
+        "excerpt": excerpt,
+        "content": content,
+        "judges": judges,
+        "caseNumbers": case_numbers
+    }
+
+
+def process_directory(directory_path, output_file):
+    with open(output_file, 'w') as jsonl_file:
+        xml_files = [f for f in os.listdir(directory_path) if f.endswith('.xml')]
+        for filename in tqdm(xml_files, desc="Processing XML files"):
+            file_path = os.path.join(directory_path, filename)
+            with open(file_path, 'r', encoding='utf-8') as xml_file:
+                xml_content = xml_file.read()
+                judgment_data = extract_information_from_xml(xml_content)
+                jsonl_file.write(json.dumps(judgment_data) + '\n')
+
+directory_path = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/dump/'
+output_file = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/englad_wales_data.jsonl'
+
+process_directory(directory_path, output_file)
diff --git a/scripts/england_wales/02_extract_jsonl_refined.py b/scripts/england_wales/02_extract_jsonl_refined.py
new file mode 100644
index 0000000..6008656
--- /dev/null
+++ b/scripts/england_wales/02_extract_jsonl_refined.py
@@ -0,0 +1,63 @@
+import os
+import json
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+
+
+def extract_information_from_xml(xml_content):
+    soup = BeautifulSoup(xml_content, 'html.parser')
+
+    # Extract required fields
+    _id = soup.find('uk:hash').text
+    signature = soup.find('neutralcitation').text if soup.find('neutralcitation') else None
+    hearing_date = soup.find('hearingdate').text if soup.find('hearingdate') else None
+    date = hearing_date.strip() if hearing_date else None
+    publication_date = soup.find('frbrwork').find('frbrdate')['date']
+    court_type = soup.find('courttype').text if soup.find('courttype') else None
+
+    # Get the excerpt
+    header_text = soup.header.get_text(separator=' ', strip=True)
+    excerpt = header_text[:500]
+
+    # Get the full content of the header and judgment body as text
+    header_content = soup.header.get_text(separator='\n', strip=True)
+    judgment_body_content = soup.find('judgmentbody').get_text(separator='\n', strip=True) if soup.find(
+        'judgmentbody') else ""
+    content = header_content + "\n" + judgment_body_content
+
+    # Get the judges list
+    judges = [judge.get_text() for judge in soup.find_all('judge')]
+
+    # Get case numbers
+    case_numbers = [case_number.get_text() for case_number in soup.find_all('p', class_='CoverText') if
+                    'Case Nos:' in case_number.text]
+    case_numbers = [num.strip() for sublist in case_numbers for num in sublist.replace('Case Nos:', '').split()]
+
+    return {
+        "_id": _id,
+        "signature": signature,
+        "date": date,
+        "publicationDate": publication_date,
+        "type": court_type,
+        "excerpt": excerpt,
+        "content": content,
+        "judges": judges,
+        "caseNumbers": case_numbers
+    }
+
+
+def process_directory(directory_path, output_file):
+    with open(output_file, 'w') as jsonl_file:
+        xml_files = [f for f in os.listdir(directory_path) if f.endswith('.xml')]
+        for filename in tqdm(xml_files, desc="Processing XML files"):
+            file_path = os.path.join(directory_path, filename)
+            with open(file_path, 'r', encoding='utf-8') as xml_file:
+                xml_content = xml_file.read()
+                judgment_data = extract_information_from_xml(xml_content)
+                jsonl_file.write(json.dumps(judgment_data) + '\n')
+
+
+directory_path = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/dump/'
+output_file = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/englad_wales_data_refined.jsonl'
+
+process_directory(directory_path, output_file)

From b43904d77a3cc92e8ce8ed69bedf361be5553728 Mon Sep 17 00:00:00 2001
From: tsantosh7 <tsantosh7@gmail.com>
Date: Sun, 2 Jun 2024 15:44:42 +0100
Subject: [PATCH 2/2] extracted jsons and analysed data

---
 .../01_Analyze_En_Judgements_Texts.ipynb      | 745 ++++++++++++++++++
 .../england-wales/02_Analyse_En_Dataset.ipynb | 480 +++++++++++
 scripts/england_wales/01_extract_jsonl.py     |  59 --
 .../england_wales/01_extract_jsonl_refined.py | 216 +++++
 .../england_wales/02_extract_jsonl_refined.py |  63 --
 5 files changed, 1441 insertions(+), 122 deletions(-)
 create mode 100644 nbs/Data/england-wales/01_Analyze_En_Judgements_Texts.ipynb
 create mode 100644 nbs/Data/england-wales/02_Analyse_En_Dataset.ipynb
 delete mode 100644 scripts/england_wales/01_extract_jsonl.py
 create mode 100644 scripts/england_wales/01_extract_jsonl_refined.py
 delete mode 100644 scripts/england_wales/02_extract_jsonl_refined.py

diff --git a/nbs/Data/england-wales/01_Analyze_En_Judgements_Texts.ipynb b/nbs/Data/england-wales/01_Analyze_En_Judgements_Texts.ipynb
new file mode 100644
index 0000000..55ff4ad
--- /dev/null
+++ b/nbs/Data/england-wales/01_Analyze_En_Judgements_Texts.ipynb
@@ -0,0 +1,745 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9e365555",
+   "metadata": {},
+   "source": [
+    "# Analyze Text of England and Wales Judgements\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6b666da3-f393-4d88-8036-e818937d2305",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import json\n",
+    "import string\n",
+    "from datasets import Dataset, DatasetDict, load_dataset, load_from_disk\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "27d73a94-5cd3-4820-938c-a827b8c34bd0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "path_ = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/'\n",
+    "jsonl_file = path_+'england_wales_data_refined_7.jsonl'\n",
+    "dataset_path = path_+'en_judgements_dataset'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c2851986-f950-4a21-b3e1-7ce58f6fa4a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "0ce2fe916d004bd099ef2a3b7a509d83",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Saving the dataset (0/1 shards):   0%|          | 0/6154 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = []\n",
+    "with open(jsonl_file, 'r') as file:\n",
+    "    for line in file:\n",
+    "        data.append(json.loads(line))\n",
+    "\n",
+    "dataset = Dataset.from_json(jsonl_file)\n",
+    "dataset_dict = DatasetDict({\"train\": dataset})\n",
+    "\n",
+    "# Save the dataset to disk\n",
+    "dataset.save_to_disk(dataset_path)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c1f37c21-de73-48ee-8cc3-8f4f2d4ce735",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the dataset from disk\n",
+    "ds = load_from_disk(dataset_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "c49a038b-3bd5-4124-89c2-a019c364fd22",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c66e3830c6334ae883d21f92242ce8b4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map (num_proc=8):   0%|          | 0/6154 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "def tagger(item):\n",
+    "    text = item[\"content\"]\n",
+    "    dummy_tokens = text.split()\n",
+    "\n",
+    "    item[\"chars\"] = len(text)\n",
+    "    item[\"num_dummy_tokens\"] = len(dummy_tokens)\n",
+    "    item[\"num_non_ws_tokens\"] = sum(\n",
+    "        1 for tok in dummy_tokens if any(char not in string.punctuation for char in tok.strip())\n",
+    "    )\n",
+    "\n",
+    "    return item\n",
+    "\n",
+    "\n",
+    "ds = ds.map(tagger, num_proc=8)\n",
+    "ds.cleanup_cache_files()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4314d158-2396-4a1c-9538-456be68c3441",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>_id</th>\n",
+       "      <th>type</th>\n",
+       "      <th>appeal_type</th>\n",
+       "      <th>appeal_outcome</th>\n",
+       "      <th>chars</th>\n",
+       "      <th>num_dummy_tokens</th>\n",
+       "      <th>num_non_ws_tokens</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>ab0224364e4cf6562c82f8861d5268d4fa22b2ec45e0f7...</td>\n",
+       "      <td>crown_court</td>\n",
+       "      <td>&lt;NA&gt;</td>\n",
+       "      <td>&lt;NA&gt;</td>\n",
+       "      <td>12444</td>\n",
+       "      <td>2229</td>\n",
+       "      <td>2155</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>d4630d93258ea51ecff4bc4015443b4eecf8d9b2e5b7c5...</td>\n",
+       "      <td>supreme_court</td>\n",
+       "      <td>conviction</td>\n",
+       "      <td>&lt;NA&gt;</td>\n",
+       "      <td>20977</td>\n",
+       "      <td>3681</td>\n",
+       "      <td>3586</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>37183a714b626cfe98081ac0250c804f992f340281f6d2...</td>\n",
+       "      <td>crown_court</td>\n",
+       "      <td>&lt;NA&gt;</td>\n",
+       "      <td>&lt;NA&gt;</td>\n",
+       "      <td>40570</td>\n",
+       "      <td>7199</td>\n",
+       "      <td>7097</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>b41933b19505ab8767ce30faf8db9524f737ec5ac2c17e...</td>\n",
+       "      <td>crown_court</td>\n",
+       "      <td>&lt;NA&gt;</td>\n",
+       "      <td>&lt;NA&gt;</td>\n",
+       "      <td>19459</td>\n",
+       "      <td>3515</td>\n",
+       "      <td>3432</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>418382a2a6c0c32d3d2bd4cb7b39e1ba259dc6bf56a78e...</td>\n",
+       "      <td>crown_court</td>\n",
+       "      <td>&lt;NA&gt;</td>\n",
+       "      <td>allowed</td>\n",
+       "      <td>10352</td>\n",
+       "      <td>1879</td>\n",
+       "      <td>1793</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                 _id           type  \\\n",
+       "0  ab0224364e4cf6562c82f8861d5268d4fa22b2ec45e0f7...    crown_court   \n",
+       "1  d4630d93258ea51ecff4bc4015443b4eecf8d9b2e5b7c5...  supreme_court   \n",
+       "2  37183a714b626cfe98081ac0250c804f992f340281f6d2...    crown_court   \n",
+       "3  b41933b19505ab8767ce30faf8db9524f737ec5ac2c17e...    crown_court   \n",
+       "4  418382a2a6c0c32d3d2bd4cb7b39e1ba259dc6bf56a78e...    crown_court   \n",
+       "\n",
+       "  appeal_type appeal_outcome  chars  num_dummy_tokens  num_non_ws_tokens  \n",
+       "0        <NA>           <NA>  12444              2229               2155  \n",
+       "1  conviction           <NA>  20977              3681               3586  \n",
+       "2        <NA>           <NA>  40570              7199               7097  \n",
+       "3        <NA>           <NA>  19459              3515               3432  \n",
+       "4        <NA>        allowed  10352              1879               1793  "
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "stats = (\n",
+    "    ds.select_columns([\"_id\", \"type\", \"appeal_type\", \"appeal_outcome\", \"chars\", \"num_dummy_tokens\", \"num_non_ws_tokens\"])\n",
+    "    .to_pandas()\n",
+    "    .convert_dtypes(dtype_backend=\"pyarrow\")\n",
+    ")\n",
+    "stats[\"type\"] = stats[\"type\"].astype(\"category\")\n",
+    "stats.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "c6bb139f-4340-45b4-a277-43da9d31a8f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Text(0.5, 1.0, '#tokens distribution')]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "ax = sns.histplot(\n",
+    "    x=stats[\"num_non_ws_tokens\"],\n",
+    "    log_scale=True,\n",
+    "    bins=50,\n",
+    ")\n",
+    "ax.set(title=\"#tokens distribution\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "e2d55b29-5e3a-4b80-827f-9a12e9ff4b97",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwEAAAG4CAYAAAAdReuBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABWn0lEQVR4nO3deVwVZf//8fcBZAdxwR0l10ABcyt3XLrd13IlEfVrWZla4nZ3u+edmpp0qy1WoolL3i6ZlRupFZpruCShWagpZWqCaKLC+f3hz3N7BOSAKMK8no/HeTw8M9dc85kZivM+c12DyWw2mwUAAADAMOzyuwAAAAAADxchAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAA5EhkZKRMJpMSEhIsy4KDgxUcHPxA9ztp0iSZTCarZb6+vgoLC3ug+wUKI0IAAKBQM5lMNr22b9+e36UiDxw9elSTJk2yCigAMnLI7wIAAHiQPvnkE6v3S5Ys0ZYtWzIs9/Pze5hlFTqbN2/Ol/3Gx8fLzu5/32kePXpUkydPVnBwsHx9ffOlJqAgIAQAAAq15557zur9999/ry1btmRYjv9JT0/X9evX5ezsbPM2jo6OD7CirDk5OeXLfoGCjuFAAABD69+/v0qWLKkbN25kWPePf/xDNWrUsLw3mUwaOnSooqKiVKNGDTk7O6tu3br65ptvMmx75swZDRw4UKVLl5aTk5Nq1qypjz/+OEO7//znP6pZs6ZcXV1VrFgx1atXT8uWLcu27mvXrmnSpEmqXr26nJ2dVbZsWXXv3l0nTpywtJk1a5YaNWqkEiVKyMXFRXXr1tV///vfDH3deVw1a9aUk5OTNm7cKEn68ccf1bJlS7m4uKhChQp64403lJ6enqGPu+cEbN++XSaTSZ9++qmmTZumChUqyNnZWa1atdLPP/9ste23336rHj16qGLFinJycpKPj49effVV/f3339mehzvnBERGRqpHjx6SpBYtWlgN9crJdQaMgDsBAABD69evn5YsWaJNmzapY8eOluW///67vv76a02cONGq/Y4dO7Ry5UoNGzZMTk5OWrBggdq2bas9e/aoVq1akqQ//vhDTz31lOXDtbe3t7766isNGjRIycnJGjFihCRp4cKFGjZsmJ599lkNHz5c165d06FDh7R792717ds3y5rT0tLUsWNHRUdHq3fv3ho+fLguX76sLVu26MiRI6pSpYokKSIiQp07d1ZISIiuX7+uFStWqEePHtqwYYM6dOhg1efXX3+tTz/9VEOHDlXJkiXl6+ur33//XS1atNDNmzc1duxYubm56YMPPpCLi4vN53f69Omys7NTeHi4kpKSNHPmTIWEhGj37t2WNqtWrdLVq1f14osvqkSJEtqzZ4/+85//6LffftOqVats3lezZs00bNgwvfPOO/rnP/9pGeLl5+eX4+sMFHpmAAAM5OWXXzbf+esvLS3NXKFCBXOvXr2s2s2ZM8dsMpnMv/zyi2WZJLMk8759+yzLTp48aXZ2djZ369bNsmzQoEHmsmXLms+fP2/VZ+/evc1FixY1X7161Ww2m81dunQx16xZM8fH8PHHH5slmefMmZNhXXp6uuXft/dz2/Xr1821atUyt2zZ0mq5JLOdnZ35xx9/tFo+YsQIsyTz7t27LcvOnTtnLlq0qFmS+ddff7Usb968ubl58+aW99u2bTNLMvv5+ZlTU1MtyyMiIsySzIcPH86yTrPZbH7zzTfNJpPJfPLkScuyiRMnmu/+6FKpUiVz//79Le9XrVpllmTetm2bVbucXGfACBgOBAAwNDs7O4WEhGj9+vW6fPmyZXlUVJQaNWqkxx57zKp9w4YNVbduXcv7ihUrqkuXLtq0aZPS0tJkNpu1evVqderUSWazWefPn7e82rRpo6SkJB04cECS5OXlpd9++0179+7NUc2rV69WyZIl9corr2RYd+cjNO/8xv6vv/5SUlKSmjZtatn/nZo3by5/f3+rZV9++aWeeuopNWjQwLLM29tbISEhNtc6YMAAq/kCTZs2lST98ssvmdZ55coVnT9/Xo0aNZLZbNYPP/xg877uJafXGSjsCAEAAMMLDQ3V33//rbVr10q69cSZ/fv3q1+/fhnaVqtWLcOy6tWr6+rVq/rzzz/1559/6tKlS/rggw/k7e1t9RowYIAk6dy5c5KkMWPGyN3dXQ0aNFC1atX08ssvKyYmJtt6T5w4oRo1asjB4d6jejds2KCnnnpKzs7OKl68uLy9vfXuu+8qKSkpQ9vMPgSfPHky0+PNyfj5ihUrWr0vVqyYpFuh5LZTp04pLCxMxYsXl7u7u7y9vdW8eXNJyrTW3MrJdQYKO+YEAAAMz9/fX3Xr1tXSpUsVGhqqpUuXytHRUT179sxxX7cnzT733HPq379/pm0CAwMl3RqrHh8frw0bNmjjxo1avXq1FixYoAkTJmjy5Mm5PyDdmmzbuXNnNWvWTAsWLFDZsmVVpEgRLVq0KNOJxzkZ558T9vb2mS43m82Sbs1vePrpp3Xx4kWNGTNGjz/+uNzc3HTmzBmFhYVlOgk5t/LyOgMFHSEAAADd+pb4tddeU2JiopYtW6YOHTpYvrW+0/HjxzMsO3bsmFxdXeXt7S1J8vDwUFpamlq3bp3tft3c3NSrVy/16tVL169fV/fu3TVt2jSNGzcuy0d0VqlSRbt379aNGzdUpEiRTNusXr1azs7O2rRpk9VjNBctWpRtTbdVqlQp0+ONj4+3uY/sHD58WMeOHdPixYsVGhpqWb5ly5Zc9Xf3XxS+m63XGSjsGA4EAICkPn36yGQyafjw4frll1+y/DsCu3btshpTf/r0aX322Wf6xz/+IXt7e9nb2+uZZ57R6tWrdeTIkQzb//nnn5Z/X7hwwWqdo6Oj/P39ZTabM32U5W3PPPOMzp8/r3nz5mVYd/sbdnt7e5lMJqWlpVnWJSQkaN26dVn2e7f27dvr+++/1549e6zqj4qKsrmP7Ny+U3C77tv/joiIyFV/bm5ukqRLly5lut7W6wwUdtwJAABAtya8tm3bVqtWrZKXl1eGR2jeVqtWLbVp08bqEaGSrIbvTJ8+Xdu2bdOTTz6pwYMHy9/fXxcvXtSBAwe0detWXbx4UdKt59OXKVNGjRs3VunSpRUXF6d58+apQ4cO8vDwyLLW0NBQLVmyRK+99pr27Nmjpk2b6sqVK9q6dateeukldenSRR06dNCcOXPUtm1b9e3bV+fOndP8+fNVtWpVHTp0yKZzMnr0aH3yySdq27athg8fbnlEaKVKlWzuIzuPP/64qlSpovDwcJ05c0aenp5avXq11ZyBnKhdu7bs7e01Y8YMJSUlycnJSS1btlSpUqUk2X6dgcKOOwEAAPx/t4ej9OzZM8u/RNu8eXPNnTtXn3zyiSZMmKDixYvrq6++sozzl6TSpUtrz549GjBggNasWaOhQ4cqIiJCFy9e1IwZMyztXnjhBaWkpGjOnDl6+eWXtW7dOg0bNkxLly69Z5329vb68ssv9frrr2v37t0aMWKE5syZI09PTwUEBEiSWrZsqY8++ki///67RowYoeXLl2vGjBnq1q2bzeejbNmy2rZtmwIDAzV9+nTNnTtXoaGhGj58uM19ZKdIkSL6/PPPVbt2bb355puaPHmyqlWrpiVLluSqvzJlyui9997TuXPnNGjQIPXp00dHjx61amPLdQYKO5P5zvtvAAAY2GeffaauXbvqm2++sTzK8k4mk0kvv/xypsNwUHBkd50BI+BOAAAA/9/ChQtVuXJlNWnSJL9LwQPEdQaYEwAAgFasWKFDhw7piy++UERERLZPmEHBxHUG/ocQAAAwvD59+sjd3V2DBg3SSy+9lN/l4AHhOgP/w5wAAAAAwGCYEwAAAAAYDCEAAAAAMBjmBADIID09XWfPnpWHhwcT5wAAKCDMZrMuX76scuXKyc7u3t/1EwIAZHD27Fn5+PjkdxkAACAXTp8+rQoVKtyzDSEAQAYeHh6Sbv1PxNPTM5+rAQAAtkhOTpaPj4/l9/i9EAIAZHB7CJCnpychAACAAsaWobxMDAYAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGIxDfhcA4NFVa+Im2Tm55nm/CdM75HmfAADAdtwJAAAAAAyGEAAAAAAYDCEAAAAAMBhCAAAAAGAwhAAAAADAYAgBAAAAgMEQAgAAAACDIQTgkRIcHKwRI0ZIknx9fTV37txcbZuXbQEAAAob/lgYHll79+6Vm5ubze3XrFmjIkWK5Hnbgs5kMmnt2rXq2rVrfpcCAAAeEYQAPLK8vb1z1L548eIPpG1Bdf36dTk6OuZ3GQAA4BHEcCDkmytXrig0NFTu7u4qW7asZs+ebbX+zuFAffv2Va9evazW37hxQyVLltSSJUskZRzis2DBAlWrVk3Ozs4qXbq0nn32Wcu6u9v+9ddfCg0NVbFixeTq6qp27drp+PHjlvWRkZHy8vLSpk2b5OfnJ3d3d7Vt21aJiYk2H+/HH3+smjVrysnJSWXLltXQoUMt606dOqUuXbrI3d1dnp6e6tmzp/744w/L+rCwsAzf5I8YMULBwcFWxzR06FCNGDFCJUuWVJs2beTr6ytJ6tatm0wmk+U9AAAwNkIA8s2oUaO0Y8cOffbZZ9q8ebO2b9+uAwcOZNo2JCREn3/+uVJSUizLNm3apKtXr6pbt24Z2u/bt0/Dhg3TlClTFB8fr40bN6pZs2ZZ1hIWFqZ9+/Zp/fr12rVrl8xms9q3b68bN25Y2ly9elWzZs3SJ598om+++UanTp1SeHi4Tcf67rvv6uWXX9bzzz+vw4cPa/369apataokKT09XV26dNHFixe1Y8cObdmyRb/88kuG0GOLxYsXy9HRUTExMXrvvfe0d+9eSdKiRYuUmJhoeX+31NRUJScnW70AAEDhxXAg5IuUlBR99NFHWrp0qVq1aiXp1gfYChUqZNq+TZs2cnNz09q1a9WvXz9J0rJly9S5c2d5eHhkaH/q1Cm5ubmpY8eO8vDwUKVKlfTEE09k2vfx48e1fv16xcTEqFGjRpKkqKgo+fj4aN26derRo4ekW3ce3nvvPVWpUkWSNHToUE2ZMsWm433jjTc0cuRIDR8+3LKsfv36kqTo6GgdPnxYv/76q3x8fCRJS5YsUc2aNbV3715LO1tUq1ZNM2fOzLDcy8tLZcqUyXK7N998U5MnT7Z5PwAAoGDjTgDyxYkTJ3T9+nU9+eSTlmXFixdXjRo1Mm3v4OCgnj17KioqStKtoUSfffaZQkJCMm3/9NNPq1KlSqpcubL69eunqKgoXb16NdO2cXFxcnBwsKqlRIkSqlGjhuLi4izLXF1dLQFAksqWLatz585le6znzp3T2bNnLWEns/37+PhYAoAk+fv7y8vLy2r/tqhbt26O2t82btw4JSUlWV6nT5/OVT8AAKBgIASgwAgJCVF0dLTOnTundevWycXFRW3bts20rYeHhw4cOKDly5erbNmymjBhgoKCgnTp0qVc7//upwmZTCaZzeZst3Nxccn1Pm+zs7PLsK87hyrdlpOnKd3JyclJnp6eVi8AAFB4EQKQL6pUqaIiRYpo9+7dlmV//fWXjh07luU2jRo1ko+Pj1auXKmoqCj16NHjno/5dHBwUOvWrTVz5kwdOnRICQkJ+vrrrzO08/Pz082bN61quXDhguLj4+Xv75/LI/wfDw8P+fr6Kjo6OtP1fn5+On36tNW370ePHtWlS5cs+/f29s4wCTk2Ntam/RcpUkRpaWm5Kx4AABRKzAlAvnB3d9egQYM0atQolShRQqVKldLrr78uO7t759K+ffvqvffe07Fjx7Rt27Ys223YsEG//PKLmjVrpmLFiunLL79Uenp6psONqlWrpi5dumjw4MF6//335eHhobFjx6p8+fLq0qXLfR+rJE2aNElDhgxRqVKl1K5dO12+fFkxMTF65ZVX1Lp1awUEBCgkJERz587VzZs39dJLL6l58+aqV6+eJKlly5Z66623tGTJEjVs2FBLly7VkSNHspzncKfbAaRx48ZycnJSsWLF8uSYAABAwcWdAOSbt956S02bNlWnTp3UunVrNWnSJNsx7SEhITp69KjKly+vxo0bZ9nOy8tLa9asUcuWLeXn56f33ntPy5cvV82aNTNtv2jRItWtW1cdO3ZUw4YNZTab9eWXX+bZHxTr37+/5s6dqwULFqhmzZrq2LGj5RGkJpNJn332mYoVK6ZmzZqpdevWqly5slauXGnZvk2bNho/frxGjx6t+vXr6/LlywoNDbVp37Nnz9aWLVvk4+NjU2gAAACFn8lsy6BmAIaSnJysokWLymfEp7Jzcs3z/hOmd8jzPgEAMLrbv7+TkpKynd/HnQAAAADAYAgBQB5wd3fP8vXtt9/md3kAAABWmBgM5IF7PamnfPnyD68QAAAAGxACgDxQtWrV/C4BAADAZgwHAgAAAAyGEAAAAAAYDCEAAAAAMBjmBADI0pHJbbJ9zjAAACh4uBMAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGIxDfhcA4NFVa+Im2Tm55nm/CdM75HmfAADAdtwJAAAAAAyGEAAAAAAYDCEAAAAAMBhCAAAAAGAwhAAAAADAYAgBAAAAgMEQAgAAAACDIQQYXEJCgkwmk2JjY23exmQyad26dbnePqd8fX01d+7c++pj0qRJql27dp7Uc9v27dtlMpl06dKlPO0XAADgQeOPhRmcj4+PEhMTVbJkSZu3SUxMVLFixR5gVdb27t0rNze3++ojPDxcr7zySh5VVLAEBwerdu3a9x2kAABA4UEIMDh7e3uVKVMmR9vktH1uXb9+XY6OjvL29r7vvtzd3eXu7p4HVRUct88fAADA3RgOZBDp6emaOXOmqlatKicnJ1WsWFHTpk2zGs6Tnp6uChUq6N1337Xa9ocffpCdnZ1OnjwpyXo4UE79+OOP6tixozw9PeXh4aGmTZvqxIkTkqSwsDB17dpV06ZNU7ly5VSjRg1JGYcDmUwmvf/+++rYsaNcXV3l5+enXbt26eeff1ZwcLDc3NzUqFEjS79SxuFAt/c1a9YslS1bViVKlNDLL7+sGzduWNp88sknqlevnjw8PFSmTBn17dtX586dy9VxS1JMTIyCg4Pl6uqqYsWKqU2bNvrrr78kSampqRo2bJhKlSolZ2dnNWnSRHv37rVsGxkZKS8vL6v+1q1bJ5PJlOEYP/zwQz322GNydnZWWFiYduzYoYiICJlMJplMJiUkJOT6GAAAQOFACDCIcePGafr06Ro/fryOHj2qZcuWqXTp0lZt7Ozs1KdPHy1btsxqeVRUlBo3bqxKlSrdVw1nzpxRs2bN5OTkpK+//lr79+/XwIEDdfPmTUub6OhoxcfHa8uWLdqwYUOWfU2dOlWhoaGKjY3V448/rr59++qFF17QuHHjtG/fPpnNZg0dOvSe9Wzbtk0nTpzQtm3btHjxYkVGRioyMtKy/saNG5o6daoOHjyodevWKSEhQWFhYbk69tjYWLVq1Ur+/v7atWuXvvvuO3Xq1ElpaWmSpNGjR2v16tVavHixDhw4oKpVq6pNmza6ePFijvbz888/a/Xq1VqzZo1iY2MVERGhhg0bavDgwUpMTFRiYqJ8fHwybJeamqrk5GSrFwAAKLwYDmQAly9fVkREhObNm6f+/ftLkqpUqaImTZpk+FY4JCREs2fP1qlTp1SxYkWlp6drxYoV+te//nXfdcyfP19FixbVihUrVKRIEUlS9erVrdq4ubnpww8/zHYYy4ABA9SzZ09J0pgxY9SwYUONHz9ebdq0kSQNHz5cAwYMuGcfxYoV07x582Rvb6/HH39cHTp0UHR0tAYPHixJGjhwoKVt5cqV9c4776h+/fpKSUnJ8dCimTNnql69elqwYIFlWc2aNSVJV65c0bvvvqvIyEi1a9dOkrRw4UJt2bJFH330kUaNGmXzfq5fv64lS5ZYDaFydHSUq6vrPYdxvfnmm5o8eXKOjgkAABRc3AkwgLi4OKWmpqpVq1bZtq1du7b8/PwsdwN27Nihc+fOqUePHvddR2xsrJo2bWoJAJkJCAiwaRx7YGCg5d+372gEBARYLbt27do9v9GuWbOm7O3tLe/Lli1rNdxn//796tSpkypWrCgPDw81b95cknTq1Kls67vb7TsBmTlx4oRu3Lihxo0bW5YVKVJEDRo0UFxcXI72U6lSpVzNoRg3bpySkpIsr9OnT+e4DwAAUHAQAgzAxcUlR+1DQkIsIWDZsmVq27atSpQo8VDqsPUpQHcGidvj4jNblp6eblMft7e53f7KlStq06aNPD09FRUVpb1792rt2rWSbn3bnlM5vQZ3s7Ozk9lstlp25/yF23L7FCUnJyd5enpavQAAQOFFCDCAatWqycXFRdHR0Ta179u3r44cOaL9+/frv//9r0JCQvKkjsDAQH377beZfnh91Pz000+6cOGCpk+frqZNm+rxxx+/r0nBgYGBWZ7/KlWqyNHRUTExMZZlN27c0N69e+Xv7y9J8vb21uXLl3XlyhVLG1v/NoOjo6Nl7gEAAIBECDAEZ2dnjRkzRqNHj9aSJUt04sQJff/99/roo48ybe/r66tGjRpp0KBBSktLU+fOnfOkjqFDhyo5OVm9e/fWvn37dPz4cX3yySeKj4/Pk/7zUsWKFeXo6Kj//Oc/+uWXX7R+/XpNnTo11/2NGzdOe/fu1UsvvaRDhw7pp59+0rvvvqvz58/Lzc1NL774okaNGqWNGzfq6NGjGjx4sK5evapBgwZJkp588km5urrqn//8p06cOKFly5ZZTWK+F19fX+3evVsJCQk6f/78Pe+OAAAAYyAEGMT48eM1cuRITZgwQX5+furVq9c9v9kOCQnRwYMH1a1bt/seynJbiRIl9PXXXyslJUXNmzdX3bp1tXDhwnvOEcgv3t7eioyM1KpVq+Tv76/p06dr1qxZue6vevXq2rx5sw4ePKgGDRqoYcOG+uyzz+TgcGtu/vTp0/XMM8+oX79+qlOnjn7++Wdt2rTJ8kfZihcvrqVLl+rLL79UQECAli9frkmTJtm07/DwcNnb28vf31/e3t65mtMAAAAKF5P57oHGAAwvOTlZRYsWlc+IT2Xn5Jrn/SdM75DnfQIAYHS3f38nJSVlO7+POwEAAACAwRACkGeGDBkid3f3TF9DhgzJ7/IeqHbt2mV57P/+97/zuzwAAAAr/LEw5JkpU6YoPDw803WF/ZGTH374of7+++9M1xUvXvwhVwMAAHBvhADkmVKlSqlUqVL5XUa+KF++fH6XAAAAYDOGAwEAAAAGQwgAAAAADIbhQACydGRym0I/nwMAACPiTgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAc8rsAAI+uWhM3yc7JNb/LeOASpnfI7xIAAHiouBMAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAaTryEgODhYI0aMyHK9yWTSunXrbO5v+/btMplMunTp0n3XVlhld85tERkZKS8vr4e+37yUm2MAAAAoLB7pOwGJiYlq165dfpfxUPj6+mru3Ln5XYZNevXqpWPHjuVomzVr1mjq1Kk2tc3rwJDZuc3NMRRECQkJMplMio2Nze9SAADAI+SR/ovBZcqUye8SHrjr16/L0dExv8vIERcXF7m4uORom+LFi+dpDWazWWlpaXJwyN2PcG6OoaC5fv16fpcAAAAeUfl+JyA9PV2jR49W8eLFVaZMGU2aNMmy7u7hQDt37lTt2rXl7OysevXqad26dZl+y7l//37Vq1dPrq6uatSokeLj422u5/PPP1f9+vXl7OyskiVLqlu3bpZ1f/31l0JDQ1WsWDG5urqqXbt2On78uGX9pEmTVLt2bav+5s6dK19fX8v7sLAwde3aVdOmTVO5cuVUo0YNBQcH6+TJk3r11VdlMplkMpmyrfPChQvq06ePypcvL1dXVwUEBGj58uVWba5cuaLQ0FC5u7urbNmymj17doZ+fH199cYbb1jaVapUSevXr9eff/6pLl26yN3dXYGBgdq3b59lm7uH0tw+7k8++US+vr4qWrSoevfurcuXL1va3P3t/oIFC1StWjU5OzurdOnSevbZZy3nZ8eOHYqIiLCci4SEBMtQr6+++kp169aVk5OTvvvuO504cUJdunRR6dKl5e7urvr162vr1q1W+83s3N55DMeOHZPJZNJPP/1kdW7efvttValSxfL+yJEjateundzd3VW6dGn169dP58+fz/ZaSbd+zmfOnKmqVavKyclJFStW1LRp0yzrDx8+rJYtW8rFxUUlSpTQ888/r5SUlCzPnyR17dpVYWFhlve+vr6aOnWqQkND5enpqeeff16PPfaYJOmJJ56QyWRScHCwTfUCAIDCLd9DwOLFi+Xm5qbdu3dr5syZmjJlirZs2ZKhXXJysjp16qSAgAAdOHBAU6dO1ZgxYzLt8/XXX9fs2bO1b98+OTg4aODAgTbV8sUXX6hbt25q3769fvjhB0VHR6tBgwaW9WFhYdq3b5/Wr1+vXbt2yWw2q3379rpx40aOjjk6Olrx8fHasmWLNmzYoDVr1qhChQqaMmWKEhMTlZiYmG0f165dU926dfXFF1/oyJEjev7559WvXz/t2bPH0mbUqFHasWOHPvvsM23evFnbt2/XgQMHMvT19ttvq3Hjxvrhhx/UoUMH9evXT6GhoXruued04MABValSRaGhoTKbzVnWc+LECa1bt04bNmzQhg0btGPHDk2fPj3Ttvv27dOwYcM0ZcoUxcfHa+PGjWrWrJkkKSIiQg0bNtTgwYMt58LHx8ey7dixYzV9+nTFxcUpMDBQKSkpat++vaKjo/XDDz+obdu26tSpk06dOiVJNp3b6tWrq169eoqKirJaHhUVpb59+0qSLl26pJYtW+qJJ57Qvn37tHHjRv3xxx/q2bNnlufkTuPGjdP06dM1fvx4HT16VMuWLVPp0qUl3Qprbdq0UbFixbR3716tWrVKW7du1dChQ23q+06zZs1SUFCQfvjhB40fP97y87B161YlJiZqzZo1mW6Xmpqq5ORkqxcAACi88n04UGBgoCZOnChJqlatmubNm6fo6Gg9/fTTVu2WLVsmk8mkhQsXytnZWf7+/jpz5owGDx6coc9p06apefPmkm59aOzQoYOuXbsmZ2fne9Yybdo09e7dW5MnT7YsCwoKkiQdP35c69evV0xMjBo1aiTp1odEHx8frVu3Tj169LD5mN3c3PThhx9aDQOyt7eXh4eHzUOgypcvr/DwcMv7V155RZs2bdKnn36qBg0aKCUlRR999JGWLl2qVq1aSboVuCpUqJChr/bt2+uFF16QJE2YMEHvvvuu6tevbzmmMWPGqGHDhvrjjz+yrC89PV2RkZHy8PCQJPXr10/R0dFW33bfdurUKbm5ualjx47y8PBQpUqV9MQTT0iSihYtKkdHR7m6uma6rylTplj9bBQvXtxyjSRp6tSpWrt2rdavX6+hQ4eqePHiNp3bkJAQzZs3zzJv4dixY9q/f7+WLl0qSZo3b56eeOIJ/fvf/7Zs8/HHH8vHx0fHjh1T9erVs+z78uXLioiI0Lx589S/f39JUpUqVdSkSRNJt362r127piVLlsjNzc2yv06dOmnGjBmWsGCLli1bauTIkZb39vb2kqQSJUrc8/jffPNNq597AABQuOX7nYDAwECr92XLltW5c+cytIuPj1dgYKDVB/k7v6XPqs+yZctKUqZ93i02NtbygflucXFxcnBw0JNPPmlZVqJECdWoUUNxcXHZ9n2ngICA+54HkJaWpqlTpyogIEDFixeXu7u7Nm3aZPkG/MSJE7p+/bpVvcWLF1eNGjUy9HXn+br9gTMgICDDsnudQ19fX0sAkLK+jpL09NNPq1KlSqpcubL69eunqKgoXb161ZbDVr169azep6SkKDw8XH5+fvLy8pK7u7vi4uIs58FWvXv3VkJCgr7//ntJtwJenTp19Pjjj0uSDh48qG3btsnd3d3yur3uxIkT9+w7Li5Oqamp9/zZCgoKsgQASWrcuLHS09NzNJRNynh+bDVu3DglJSVZXqdPn85VPwAAoGDI9zsBRYoUsXpvMpmUnp6eZ33eHgNuS5/3O1HUzs4uw5CZzIYK3flhL7feeustRUREaO7cuQoICJCbm5tGjBiRq8mgmZ2vnJ7DnFxHDw8PHThwQNu3b9fmzZs1YcIETZo0SXv37s32sZ13n7vw8HBt2bJFs2bNUtWqVeXi4qJnn302x+ehTJkyatmypZYtW6annnpKy5Yt04svvmhZn5KSYvlm/m63g2ZW8mIC8oP+2XJycpKTk1OutgUAAAVPvt8JsFWNGjV0+PBhpaamWpbt3bs3T/cRGBio6OjoTNf5+fnp5s2b2r17t2XZhQsXFB8fL39/f0mSt7e3fv/9d6sPa7Y+mtHR0VFpaWk21xoTE6MuXbroueeeU1BQkCpXrmz1yMsqVaqoSJEiVvX+9ddfj8xjMR0cHNS6dWvNnDlThw4dUkJCgr7++mtJOTsXMTExCgsLU7du3RQQEKAyZcooISHBqo2t/YWEhGjlypXatWuXfvnlF/Xu3duyrk6dOvrxxx/l6+urqlWrWr2y++BdrVo1ubi43PNn6+DBg7py5YrVcdnZ2Vnu3Hh7e1vNZ0hLS9ORI0eyPabbd5xy8rMFAAAKvwITAvr27av09HQ9//zziouL06ZNmzRr1ixJsulpOraYOHGili9frokTJyouLk6HDx+2fPNbrVo1denSRYMHD9Z3332ngwcP6rnnnlP58uXVpUsXSbee4PLnn39q5syZOnHihObPn6+vvvrKpn37+vrqm2++0ZkzZ2x64ky1atW0ZcsW7dy5U3FxcXrhhRf0xx9/WNa7u7tr0KBBGjVqlL7++msdOXJEYWFhsrPL/0u+YcMGvfPOO4qNjdXJkye1ZMkSpaenWz7w+vr6avfu3UpISND58+fveQeiWrVqWrNmjWJjY3Xw4EHLz8mdbD233bt31+XLl/Xiiy+qRYsWKleunGXdyy+/rIsXL6pPnz7au3evTpw4oU2bNmnAgAHZfsB2dnbWmDFjNHr0aC1ZskQnTpzQ999/r48++kjSrfDh7Oys/v3768iRI9q2bZteeeUV9evXzzIUq2XLlvriiy/0xRdf6KefftKLL75o0x/FK1WqlFxcXCwTmZOSkrLdBgAAFH75/4nQRp6envr8888VGxur2rVr6/XXX9eECRMkKdsJv7YKDg7WqlWrtH79etWuXVstW7a0etrOokWLVLduXXXs2FENGzaU2WzWl19+aRkK4+fnpwULFmj+/PkKCgrSnj17rCbv3suUKVOUkJCgKlWqyNvbO9v2//rXv1SnTh21adNGwcHBKlOmjLp27WrV5q233lLTpk3VqVMntW7dWk2aNFHdunVtPyEPiJeXl9asWaOWLVvKz89P7733npYvX66aNWtKujXEx97eXv7+/vL29r7n+P45c+aoWLFiatSokTp16qQ2bdqoTp06Vm1sPbceHh7q1KmTDh48qJCQEKt15cqVU0xMjNLS0vSPf/xDAQEBGjFihLy8vGwKVuPHj9fIkSM1YcIE+fn5qVevXpY5E66urtq0aZMuXryo+vXr69lnn1WrVq00b948y/YDBw5U//79FRoaqubNm6ty5cpq0aJFtvt1cHDQO++8o/fff1/lypWzBFYAAGBsJvO9nvv4iIuKitKAAQOUlJRU6P/wE/AwJScnq2jRovIZ8ansnFzzu5wHLmF6h/wuAQCA+3b793dSUpI8PT3v2TbfJwbnxJIlS1S5cmWVL19eBw8e1JgxY9SzZ08CAAAAAJADBWY4kCT9/vvveu655+Tn56dXX31VPXr00AcffGDz9jVr1rR6xOOdr7v/UFR+u/2XaTN73fmseuS/U6dOZXmt3N3dc/y4UgAAgAetQA8HyqmTJ09m+dd9S5cubfWc+/x25swZ/f3335muK168uIoXL/6QK0JWbt68meGJRHfy9fWVg0OBuunGcCAAAAqgQjsc6H5VqlQpv0uwWfny5fO7BNjIwcFBVatWze8yAAAAbFaghgMBAAAAuH+EAAAAAMBgDDUcCEDOHJncJtsxhQAAoODhTgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAccrPRzZs3tX37dp04cUJ9+/aVh4eHzp49K09PT7m7u+d1jQDySa2Jm2Tn5JrfZeAhSZjeIb9LAAA8JDkOASdPnlTbtm116tQppaam6umnn5aHh4dmzJih1NRUvffeew+iTgAAAAB5JMfDgYYPH6569erpr7/+kouLi2V5t27dFB0dnafFAQAAAMh7Ob4T8O2332rnzp1ydHS0Wu7r66szZ87kWWEAAAAAHowc3wlIT09XWlpahuW//fabPDw88qQoAAAAAA9OjkPAP/7xD82dO9fy3mQyKSUlRRMnTlT79u3zsjYAAAAAD0COhwPNnj1bbdq0kb+/v65du6a+ffvq+PHjKlmypJYvX/4gagQAAACQh3IcAipUqKCDBw9qxYoVOnTokFJSUjRo0CCFhIRYTRQGAAAA8GjK1R8Lc3Bw0HPPPaeZM2dqwYIF+r//+z/DBYDg4GCNGDEiy/Umk0nr1q2zub/t27fLZDLp0qVL911bQRQZGSkvLy/L+0mTJql27dq53j6v2gIAABRGuQoB8fHxGjp0qFq1aqVWrVpp6NCh+umnn/K6tgItMTFR7dq1y+8yHgpfX1+reSJ5ITw8PEePnO3Vq5eOHTuW520LurCwMHXt2jW/ywAAAI+YHIeA1atXq1atWtq/f7+CgoIUFBSkAwcOKCAgQKtXr34QNRZIZcqUkZOTU36X8UBdv379gfXt7u6uEiVK2NzexcVFpUqVyvO2BVVaWprS09PzuwwAAPCIynEIGD16tMaNG6ddu3Zpzpw5mjNnjnbu3Kl//vOfGj169IOo8ZGVnp6u0aNHq3jx4ipTpowmTZpkWXf3cKCdO3eqdu3acnZ2Vr169bRu3TqZTCbFxsZa9bl//37Vq1dPrq6uatSokeLj422u5/PPP1f9+vXl7OyskiVLqlu3bpZ1f/31l0JDQ1WsWDG5urqqXbt2On78uGV9ZsNv5s6dK19fX8v7298qT5s2TeXKlVONGjUUHByskydP6tVXX5XJZJLJZLKp1sjISFWsWFGurq7q1q2bLly4YLX+zno2b94sZ2fnDEOlhg8frpYtW1r6u3OIz8GDB9WiRQt5eHjI09NTdevW1b59+zJtK0nvvvuuqlSpIkdHR9WoUUOffPKJ1XqTyaQPP/xQ3bp1k6urq6pVq6b169fbdKyS9OOPP6pjx47y9PSUh4eHmjZtqhMnTki69XM0ZcoUVahQQU5OTqpdu7Y2btxo2TazoWKxsbEymUxKSEiwOqb169fL399fTk5OGjhwoBYvXqzPPvvMcm22b99uc80AAKDwynEISExMVGhoaIblzz33nBITE/OkqIJi8eLFcnNz0+7duzVz5kxNmTJFW7ZsydAuOTlZnTp1UkBAgA4cOKCpU6dqzJgxmfb5+uuva/bs2dq3b58cHBw0cOBAm2r54osv1K1bN7Vv314//PCDoqOj1aBBA8v6sLAw7du3T+vXr9euXbtkNpvVvn173bhxI0fHHB0drfj4eG3ZskUbNmzQmjVrVKFCBU2ZMkWJiYk2/Qzs3r1bgwYN0tChQxUbG6sWLVrojTfeyLJ9q1at5OXlZXWnKS0tTStXrlRISEim24SEhKhChQrau3ev9u/fr7Fjx6pIkSKZtl27dq2GDx+ukSNH6siRI3rhhRc0YMAAbdu2zard5MmT1bNnTx06dEjt27dXSEiILl68mO3xnjlzRs2aNZOTk5O+/vpr7d+/XwMHDtTNmzclSREREZo9e7ZmzZqlQ4cOqU2bNurcubNVSLPF1atXNWPGDH344Yf68ccf9c4776hnz55q27at5do0atQo021TU1OVnJxs9QIAAIVXjp8OFBwcrG+//VZVq1a1Wv7dd9+padOmeVZYQRAYGKiJEydKkqpVq6Z58+YpOjpaTz/9tFW7ZcuWyWQyaeHChXJ2dpa/v7/OnDmjwYMHZ+hz2rRpat68uSRp7Nix6tChg65duyZnZ+d71jJt2jT17t1bkydPtiwLCgqSJB0/flzr169XTEyM5UNgVFSUfHx8tG7dOvXo0cPmY3Zzc9OHH35o9Rej7e3t5eHhoTJlytjUR0REhNq2bWu5c1S9enXt3LnT6tvvO9nb26t3795atmyZBg0aJOlWGLl06ZKeeeaZTLc5deqURo0apccff1zSreuTlVmzZiksLEwvvfSSJOm1117T999/r1mzZqlFixaWdmFhYerTp48k6d///rfeeecd7dmzR23btr3n8c6fP19FixbVihUrLEGkevXqVvsfM2aMevfuLUmaMWOGtm3bprlz52r+/Pn37PtON27c0IIFCyzXXbo19Ck1NTXba/Pmm29a/ewAAIDCLcd3Ajp37qwxY8Zo6NChWrp0qZYuXaqhQ4dq7Nix6tatm9avX295FXaBgYFW78uWLatz585laBcfH6/AwECrD/J3fkufVZ9ly5aVpEz7vFtsbKxatWqV6bq4uDg5ODjoySeftCwrUaKEatSoobi4uGz7vlNAQIBVAMiNuLg4q1okqWHDhvfcJiQkRNu3b9fZs2cl3QoxHTp0yPIpP6+99pr+7//+T61bt9b06dMtQ2+yqqdx48ZWyxo3bpzh3Nx5bdzc3OTp6WnztWnatGmmdyKSk5N19uxZm/afHUdHxww/k7YaN26ckpKSLK/Tp0/nqh8AAFAw5PhOwO1vSxcsWKAFCxZkuk66NYY6LS3tPst7tN39oc5kMt33ZMw7+7w9vt6WPu/3Ea12dnYym81WyzIbKuTm5nZf+8mt+vXrq0qVKlqxYoVefPFFrV27VpGRkVm2nzRpkvr27asvvvhCX331lSZOnKgVK1ZYzZPIqdxe77y4NpKsrk9m18bFxcXmORl3c3JyKvQT2QEAwP/k+E5Aenq6Ta/CHgByokaNGjp8+LBSU1Mty/bu3Zun+wgMDMzykZp+fn66efOmdu/ebVl24cIFxcfHy9/fX5Lk7e2t33//3eqD5t2TlrPi6OiYo+vt5+dnVYskff/999luFxISoqioKH3++eeys7NThw4d7tm+evXqevXVV7V582Z1795dixYtyrKemJgYq2UxMTGWc3O/AgMD9e2332b6wd3T01PlypW75/69vb0lyWq+xYO6NgAAwBhyHAJ++eWXB1FHoda3b1+lp6fr+eefV1xcnDZt2qRZs2ZJUq6/ub3bxIkTtXz5ck2cOFFxcXE6fPiwZsyYIenWePguXbpo8ODB+u6773Tw4EE999xzKl++vLp06SLp1lyPP//8UzNnztSJEyc0f/58ffXVVzbt29fXV998843OnDmj8+fPZ9t+2LBh2rhxo2bNmqXjx49r3rx5Wc4HuFNISIgOHDigadOm6dlnn83ym+u///5bQ4cO1fbt23Xy5EnFxMRo79698vPzy7T9qFGjFBkZqXfffVfHjx/XnDlztGbNGoWHh2dbky2GDh2q5ORk9e7dW/v27dPx48f1ySefWJ78NGrUKM2YMUMrV65UfHy8xo4dq9jYWA0fPlySVLVqVfn4+GjSpEk6fvy4vvjiC82ePdumffv6+urQoUOKj4/X+fPnczwRHAAAFE45DgFVq1ZVixYttHTpUl27du1B1FToeHp66vPPP1dsbKxq166t119/XRMmTJCkbCf82io4OFirVq3S+vXrVbt2bbVs2VJ79uyxrF+0aJHq1q2rjh07qmHDhjKbzfryyy8tQ1z8/Py0YMECzZ8/X0FBQdqzZ4/NH4KnTJmihIQEValSxfKt9b089dRTWrhwoSIiIhQUFKTNmzfrX//6V7bbVa1aVQ0aNNChQ4eyfCqQdGsi8YULFxQaGqrq1aurZ8+eateuXZYTX7t27aqIiAjNmjVLNWvW1Pvvv69FixYpODg425psUaJECX399ddKSUlR8+bNVbduXS1cuNBy7ocNG6bXXntNI0eOVEBAgDZu3Kj169dbJjMXKVJEy5cv108//aTAwEDNmDHjnk9TutPgwYNVo0YN1atXT97e3hnuOAAAAGMyme8eCJ6N2NhYLVq0SMuXL9f169fVq1cvDRo0KMuJrshcVFSUBgwYoKSkpPseMw7kteTkZBUtWlQ+Iz6VnZNrfpeDhyRh+r2H2AEAHm23f38nJSXJ09Pznm1zfCegdu3aioiI0NmzZ/Xxxx8rMTFRTZo0Ua1atTRnzhz9+eefuS68MFuyZIm+++47/frrr1q3bp3GjBmjnj17EgAAAADw0OU4BNzm4OCg7t27a9WqVZoxY4Z+/vlnhYeHy8fHR6GhoYb7w2HZ+f333/Xcc8/Jz89Pr776qnr06KEPPvjA5u1r1qwpd3f3TF9RUVEPsPKca9euXZa1/vvf/87v8vLckCFDsjzeIUOG5Hd5AAAAGeR4ONBt+/bt08cff6wVK1bIzc1N/fv316BBg/Tbb79p8uTJSk5OthqTjvtz8uTJLCd1li5dWh4eHg+5oqydOXNGf//9d6brihcvruLFiz/kih6sc+fOZfkXdj09PVWqVKmHXNH9YziQMTEcCAAKtpwMB8rx3wmYM2eOFi1apPj4eLVv315LlixR+/btLc8yf+yxxxQZGSlfX99cFY/MVapUKb9LsFn58uXzu4SHqlSpUgXygz4AADCuHIeAMWPGaMqUKQoLC7P8RdvbTp06pYoVK6pUqVL66KOP8qxIAAAAAHknx3MC0tLSNGjQoAwB4MKFC3rsscck3foDRf3798+bCgEAAADkqRzfCZAy/wNXKSkpefbMewCPhiOT22Q7phAAABQ8NoeA1157TdKtADB+/Hi5uv5vsmBaWpp2796t2rVr53mBAAAAAPKWzSHghx9+kCSZzWYdPnxYjo6OlnWOjo4KCgqy+S/MAgAAAMg/NoeAbdu2SZIGDBigiIgIhggAAAAABVSO5wQsWrToQdQBAAAA4CHJ9V8MBgAAAFAwEQIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGIxDfhcA4NFVa+Im2Tm55ncZKCQSpnfI7xIAAP8fdwIAAAAAgyEEAAAAAAZDCAAAAAAMhhAAAAAAGAwhAAAAADAYQgAAAABgMIQAAAAAwGAIAQAAAIDBEAIASZGRkfLy8srRNr6+vpo7d+4DqQcAAOBBIgTAcDL78N6rVy8dO3Ysfwp6gHITbgAAQOHnkN8FAA/L9evX5ejomOk6FxcXubi4POSKHqwbN27kdwkAAOARxZ0APBKCg4P1yiuvaMSIESpWrJhKly6thQsX6sqVKxowYIA8PDxUtWpVffXVV5KktLQ0DRo0SI899phcXFxUo0YNRUREWPUZFhamrl27atq0aSpXrpxq1Kih4OBgnTx5Uq+++qpMJpNMJpOkjN+YnzhxQl26dFHp0qXl7u6u+vXra+vWrbk+vkuXLumFF15Q6dKl5ezsrFq1amnDhg2W9atXr1bNmjXl5OQkX19fzZ4922p7k8mkdevWWS3z8vJSZGSkJCkhIUEmk0krV65U8+bN5ezsrKioKA0YMEBJSUmWY500aVKujwEAABQe3AnAI2Px4sUaPXq09uzZo5UrV+rFF1/U2rVr1a1bN/3zn//U22+/rX79+unUqVMqUqSIKlSooFWrVqlEiRLauXOnnn/+eZUtW1Y9e/a09BkdHS1PT09t2bJFklS2bFkFBQXp+eef1+DBg7OsJSUlRe3bt9e0adPk5OSkJUuWqFOnToqPj1fFihVzdFzp6elq166dLl++rKVLl6pKlSo6evSo7O3tJUn79+9Xz549NWnSJPXq1Us7d+7USy+9pBIlSigsLCxH+xo7dqxmz56tJ554QnZ2dpo7d64mTJig+Ph4SZK7u3um26Wmpio1NdXyPjk5OUf7BQAABQshAI+MoKAg/etf/5IkjRs3TtOnT1fJkiUtH9YnTJigd999V4cOHdJTTz2lyZMnW7Z97LHHtGvXLn366adWIcDNzU0ffvih1TAge3t7eXh4qEyZMvesJSgoyPJ+6tSpWrt2rdavX6+hQ4fm6Li2bt2qPXv2KC4uTtWrV5ckVa5c2bJ+zpw5atWqlcaPHy9Jql69uo4ePaq33norxyFgxIgR6t69u+V90aJFZTKZ7nmskvTmm29anU8AAFC4MRwIj4zAwEDLv+3t7VWiRAkFBARYlpUuXVqSdO7cOUnS/PnzVbduXXl7e8vd3V0ffPCBTp06ZdVnQEBAlvMA7iUlJUXh4eHy8/OTl5eX3N3dFRcXl6F/W8TGxqpChQqWAHC3uLg4NW7c2GpZ48aNdfz4caWlpeVoX/Xq1ctxfdKt0JWUlGR5nT59Olf9AACAgoE7AXhkFClSxOq9yWSyWnZ7/H56erpWrFih8PBwzZ49Ww0bNpSHh4feeust7d6926oPNze3XNUSHh6uLVu2aNasWapatapcXFz07LPP6vr16znuKy8mHJtMJpnNZqtlmU38ze3xOjk5ycnJKVfbAgCAgocQgAIpJiZGjRo10ksvvWRZduLECZu2dXR0zPYb9piYGIWFhalbt26Sbt0ZSEhIyFWtgYGB+u2333Ts2LFM7wb4+fkpJiYmw/6rV69umTfg7e2txMREy/rjx4/r6tWr2e7blmMFAADGw3AgFEjVqlXTvn37tGnTJh07dkzjx4/X3r17bdrW19dX33zzjc6cOaPz589n2f+aNWsUGxurgwcPqm/fvkpPT89Vrc2bN1ezZs30zDPPaMuWLfr111/11VdfaePGjZKkkSNHKjo6WlOnTtWxY8e0ePFizZs3T+Hh4ZY+WrZsqXnz5umHH37Qvn37NGTIkAx3TrI61pSUFEVHR+v8+fM2BQcAAFD4EQJQIL3wwgvq3r27evXqpSeffFIXLlywuitwL1OmTFFCQoKqVKkib2/vTNvMmTNHxYoVU6NGjdSpUye1adNGderUyXW9q1evVv369dWnTx/5+/tr9OjRlm/o69Spo08//VQrVqxQrVq1NGHCBE2ZMsVqUvDs2bPl4+Ojpk2bqm/fvgoPD5erq2u2+23UqJGGDBmiXr16ydvbWzNnzsz1MQAAgMLDZL57oDEAw0tOTlbRokXlM+JT2TllHzYAWyRM75DfJQBAoXb793dSUpI8PT3v2ZY7AQAAAIDBEAKA+xQVFSV3d/dMXzVr1szv8gAAADLg6UDAfercubOefPLJTNfZMnkXAADgYSMEAPfJw8NDHh4e+V0GAACAzRgOBAAAABgMIQAAAAAwGIYDAcjSkcltsn3EGAAAKHi4EwAAAAAYDCEAAAAAMBhCAAAAAGAwhAAAAADAYAgBAAAAgMEQAgAAAACDIQQAAAAABkMIAAAAAAyGEAAAAAAYDCEAAAAAMBhCAAAAAGAwhAAAAADAYAgBAAAAgMEQAgAAAACDIQQAAAAABkMIAAAAAAyGEAAAAAAYDCEAAAAAMBhCAAAAAGAwhAAAAADAYAgBAAAAgMEQAgAAAACDIQQAAAAABkMIAAAAAAyGEAAAAAAYjEN+FwDg0VVr4ibZObnmdxkAgCwkTO+Q3yWggOJOAAAAAGAwhAAAAADAYAgBAAAAgMEQAgAAAACDIQQAAAAABkMIAAAAAAyGEAAAAAAYDCEAAAAAMBhCAFDIRUZGysvLK7/LAAAAjxBCAAqVGzdu5HcJjxTOBwAAyAwhAA/Uf//7XwUEBMjFxUUlSpRQ69atdeXKFQUHB2vEiBFWbbt27aqwsDDLe19fX02dOlV9+vSRm5ubypcvr/nz51ttYzKZ9O6776pz585yc3PTtGnTJEmfffaZ6tSpI2dnZ1WuXFmTJ0/WzZs3rbZ7//331bFjR7m6usrPz0+7du3Szz//rODgYLm5ualRo0Y6ceKE1f6y6/deLl26pBdeeEGlS5eWs7OzatWqpQ0bNljWr169WjVr1pSTk5N8fX01e/bsDMe6bt06q2VeXl6KjIyUJCUkJMhkMmnlypVq3ry5nJ2dFRUVpQEDBigpKUkmk0kmk0mTJk2yqV4AAFB4EQLwwCQmJqpPnz4aOHCg4uLitH37dnXv3l1ms9nmPt566y0FBQXphx9+0NixYzV8+HBt2bLFqs2kSZPUrVs3HT58WAMHDtS3336r0NBQDR8+XEePHtX777+vyMhIS0C4berUqQoNDVVsbKwef/xx9e3bVy+88ILGjRunffv2yWw2a+jQoZb2tvabmfT0dLVr104xMTFaunSpjh49qunTp8ve3l6StH//fvXs2VO9e/fW4cOHNWnSJI0fP97yAT8nbp+nuLg4tWjRQnPnzpWnp6cSExOVmJio8PDwDNukpqYqOTnZ6gUAAAovh/wuAIVXYmKibt68qe7du6tSpUqSpICAgBz10bhxY40dO1aSVL16dcXExOjtt9/W008/bWnTt29fDRgwwPJ+4MCBGjt2rPr37y9Jqly5sqZOnarRo0dr4sSJlnYDBgxQz549JUljxoxRw4YNNX78eLVp00aSNHz4cKt+J0+ebFO/mdm6dav27NmjuLg4Va9e3bL9bXPmzFGrVq00fvx4y7EePXpUb731ltXdEVuMGDFC3bt3t7wvWrSoTCaTypQpk+U2b775piZPnpyj/QAAgIKLOwF4YIKCgtSqVSsFBASoR48eWrhwof76668c9dGwYcMM7+Pi4qyW1atXz+r9wYMHNWXKFLm7u1tegwcPVmJioq5evWppFxgYaPl36dKlJVmHlNKlS+vatWuWb8Vt7TczsbGxqlChgiUA3C0uLk6NGze2Wta4cWMdP35caWlp9+z7bnefD1uMGzdOSUlJltfp06dz3AcAACg4uBOAB8be3l5btmzRzp07tXnzZv3nP//R66+/rt27d8vOzi7DsKDcTmJ1c3Ozep+SkqLJkydbfRt+m7Ozs+XfRYoUsfzbZDJluSw9PT1H/WbGxcUlu8PIlslksumc3X0+bOHk5CQnJ6dc1wYAAAoWQgAeKJPJpMaNG6tx48aaMGGCKlWqpLVr18rb21uJiYmWdmlpaTpy5IhatGhhtf3333+f4b2fn98991mnTh3Fx8eratWqeXcg99lvYGCgfvvtNx07dizTuwF+fn6KiYmxWhYTE6Pq1atb5g3cfc6OHz+e7R0ISXJ0dMzx3QQAAFC4EQLwwOzevVvR0dH6xz/+oVKlSmn37t36888/5efnJzc3N7322mv64osvVKVKFc2ZM0eXLl3K0EdMTIxmzpyprl27asuWLVq1apW++OKLe+53woQJ6tixoypWrKhnn31WdnZ2OnjwoI4cOaI33ngj18dzP/02b95czZo10zPPPKM5c+aoatWq+umnn2QymdS2bVuNHDlS9evX19SpU9WrVy/t2rVL8+bN04IFCyx9tGzZUvPmzVPDhg2VlpamMWPGWN25yIqvr69SUlIUHR2toKAgubq6ytXVNdfnAQAAFHzMCcAD4+npqW+++Ubt27dX9erV9a9//UuzZ89Wu3btNHDgQPXv31+hoaFq3ry5KleunOEugCSNHDlS+/bt0xNPPKE33nhDc+bMsUzczUqbNm20YcMGbd68WfXr19dTTz2lt99+2zI5Obfut9/Vq1erfv366tOnj/z9/TV69GjLN/R16tTRp59+qhUrVqhWrVqaMGGCpkyZYjUpePbs2fLx8VHTpk3Vt29fhYeH2/RhvlGjRhoyZIh69eolb29vzZw5M1fHDwAACg+TOSfPawQeIl9fX40YMSLD3xPAg5ecnKyiRYvKZ8SnsnPirgEAPKoSpnfI7xLwCLn9+zspKUmenp73bMudAAAAAMBgCAFAHoiKirJ6dOidr5o1a+Z3eQAAAFaYGIxHVkJCQn6XYLPOnTvrySefzHSdLZN3AQAAHiZCAJAHPDw85OHhkd9lAAAA2IThQAAAAIDBEAIAAAAAgyEEAAAAAAbDnAAAWToyuU22zxkGAAAFD3cCAAAAAIMhBAAAAAAGQwgAAAAADIYQAAAAABgMIQAAAAAwGEIAAAAAYDCEAAAAAMBgCAEAAACAwRACAAAAAIMhBAAAAAAGQwgAAAAADIYQAAAAABgMIQAAAAAwGEIAAAAAYDCEAAAAAMBgCAEAAACAwRACAAAAAIMhBAAAAAAGQwgAAAAADIYQAAAAABgMIQAAAAAwGEIAAAAAYDCEAAAAAMBgCAEAAACAwRACAAAAAINxyO8CADy6ak3cJDsn1/wuAwCAQidheod83T93AgAAAACDIQQAAAAABkMIAAAAAAyGEAAAAAAYDCEAAAAAMBhCAAAAAGAwhAAAAADAYAgBAAAAgMEQAoBCLjIyUl5eXvldBgAAeIQQAlAo3bhxI79LeCRwHgAAQGYIASgw0tPTNXPmTFWtWlVOTk6qWLGipk2bpoSEBJlMJq1cuVLNmzeXs7OzoqKilJ6erilTpqhChQpycnJS7dq1tXHjRkt/zz77rIYOHWp5P2LECJlMJv3000+SpOvXr8vNzU1bt26VJAUHB2vYsGEaPXq0ihcvrjJlymjSpEk213/p0iW98MILKl26tJydnVWrVi1t2LDBsn716tWqWbOmnJyc5Ovrq9mzZ1ttbzKZtG7dOqtlXl5eioyMlKQsz8OAAQOUlJQkk8kkk8mUo5oBAEDh5JDfBQC2GjdunBYuXKi3335bTZo0UWJiouUDuySNHTtWs2fP1hNPPCFnZ2dFRERo9uzZev/99/XEE0/o448/VufOnfXjjz+qWrVqat68ud5//33L9jt27FDJkiW1fft2Pf7449q7d69u3LihRo0aWdosXrxYr732mnbv3q1du3YpLCxMjRs31tNPP33P2tPT09WuXTtdvnxZS5cuVZUqVXT06FHZ29tLkvbv36+ePXtq0qRJ6tWrl3bu3KmXXnpJJUqUUFhYWI7O053nwc7OTnPnztWECRMUHx8vSXJ3d8+wTWpqqlJTUy3vk5OTc7RPAABQsBACUCBcvnxZERERmjdvnvr37y9JqlKlipo0aaKEhARJt77J7969u2WbWbNmacyYMerdu7ckacaMGdq2bZvmzp2r+fPnKzg4WMOHD9eff/4pBwcHHT16VOPHj9f27ds1ZMgQbd++XfXr15erq6ulz8DAQE2cOFGSVK1aNc2bN0/R0dHZhoCtW7dqz549iouLU/Xq1SVJlStXtqyfM2eOWrVqpfHjx0uSqlevrqNHj+qtt97KcQi4+zwULVpUJpNJZcqUyXKbN998U5MnT87RfgAAQMHFcCAUCHFxcUpNTVWrVq2ybFOvXj3Lv5OTk3X27Fk1btzYqk3jxo0VFxcnSapVq5aKFy+uHTt26Ntvv9UTTzyhjh07aseOHZJu3RkIDg622j4wMNDqfdmyZXXu3Lls64+NjVWFChUsASCz48us1uPHjystLS3b/u9053mw1bhx45SUlGR5nT59Osd9AACAgoM7ASgQXFxcsm3j5uaWoz5NJpOaNWum7du3y8nJScHBwQoMDFRqaqqOHDminTt3Kjw83GqbIkWKZOgjPT09T+q3pV6z2Wy1LLOJvzk9D5Lk5OQkJyenXNcGAAAKFu4EoECoVq2aXFxcFB0dbVN7T09PlStXTjExMVbLY2Ji5O/vb3nfvHlzbd++Xdu3b1dwcLDs7OzUrFkzvfXWW0pNTc3w7XxuBQYG6rffftOxY8cyXe/n55dprdWrV7fMG/D29lZiYqJl/fHjx3X16tVs9+3o6JjjuwkAAKBw404ACgRnZ2eNGTNGo0ePlqOjoxo3bqw///xTP/74Y5ZDhEaNGqWJEyeqSpUqql27thYtWqTY2FhFRUVZ2gQHB+vVV1+Vo6OjmjRpYlkWHh6u+vXr5+pb9cw0b95czZo10zPPPKM5c+aoatWq+umnn2QymdS2bVuNHDlS9evX19SpU9WrVy/t2rVL8+bN04IFCyx9tGzZUvPmzVPDhg2VlpamMWPGZLgzkRlfX1+lpKQoOjpaQUFBcnV1tZrnAAAAjIcQgAJj/PjxcnBw0IQJE3T27FmVLVtWQ4YMybL9sGHDlJSUpJEjR+rcuXPy9/fX+vXrVa1aNUubgIAAeXl5qXr16pan5gQHBystLS3DfID7tXr1aoWHh6tPnz66cuWKqlatqunTp0uS6tSpo08//VQTJkzQ1KlTVbZsWU2ZMsVqUvDs2bM1YMAANW3aVOXKlVNERIT279+f7X4bNWqkIUOGqFevXrpw4YImTpzIY0IBADA4k/nuQcYADC85OVlFixaVz4hPZefEXQMAAPJawvQOed7n7d/fSUlJ8vT0vGdb5gQAAAAABkMIAPJAVFSU3N3dM33VrFkzv8sDAACwwpwAIA907txZTz75ZKbrbJm8CwAA8DARAoA84OHhIQ8Pj/wuAwAAwCYMBwIAAAAMhhAAAAAAGAzDgQBk6cjkNtk+YgwAABQ83AkAAAAADIYQAAAAABgMIQAAAAAwGEIAAAAAYDCEAAAAAMBgCAEAAACAwRACAAAAAIMhBAAAAAAGQwgAAAAADIYQAAAAABgMIQAAAAAwGEIAAAAAYDAO+V0AgEeP2WyWJCUnJ+dzJQAAwFa3f2/f/j1+L4QAABlcvnxZkuTj45PPlQAAgJy6fPmyihYtes82JrMtUQGAoaSnp+vs2bPy8PCQyWSSJNWvX1979+7NtH1W6zJbnpycLB8fH50+fVqenp55X3wu3OvY8qvfnGxra9vs2nGNH16fOd3Wlvb328bWa/woXl+Ja5zdev4bzts+H8T1taVddtd4z549unz5ssqVKyc7u3uP+udOAIAM7OzsVKFCBatl9vb2Wf4yyGrdvbbx9PR8ZH653KvO/Oo3J9va2ja7dlzjh9dnTre1pf39tsnpNX6Urq/ENc5uPf8N522fD+L62tIuu2tctGjRbO8A3MbEYAA2efnll3O87l7bPEoeVJ33029OtrW1bXbtuMYPr8+cbmtL+/ttwzXO2z7z4xpzfR9enw/i+trSLjfXOCsMBwLwUCUnJ6to0aJKSkp6ZL5hQt7iGhduXN/Cj2tsDNwJAPBQOTk5aeLEiXJycsrvUvCAcI0LN65v4cc1NgbuBAAAAAAGw50AAAAAwGAIAQAAAIDBEAIAAAAAgyEEAAAAAAZDCADwyNiwYYNq1KihatWq6cMPP8zvcvAAdOvWTcWKFdOzzz6b36XgATh9+rSCg4Pl7++vwMBArVq1Kr9LQh66dOmS6tWrp9q1a6tWrVpauHBhfpeE+8DTgQA8Em7evCl/f39t27ZNRYsWVd26dbVz506VKFEiv0tDHtq+fbsuX76sxYsX67///W9+l4M8lpiYqD/++EO1a9fW77//rrp16+rYsWNyc3PL79KQB9LS0pSamipXV1dduXJFtWrV0r59+/j/dAHFnQAAj4Q9e/aoZs2aKl++vNzd3dWuXTtt3rw5v8tCHgsODpaHh0d+l4EHpGzZsqpdu7YkqUyZMipZsqQuXryYv0Uhz9jb28vV1VWSlJqaKrPZLL5LLrgIAQDyxDfffKNOnTqpXLlyMplMWrduXYY28+fPl6+vr5ydnfXkk09qz549lnVnz55V+fLlLe/Lly+vM2fOPIzSYaP7vcZ49OXlNd6/f7/S0tLk4+PzgKuGrfLi+l66dElBQUGqUKGCRo0apZIlSz6k6pHXCAEA8sSVK1cUFBSk+fPnZ7p+5cqVeu211zRx4kQdOHBAQUFBatOmjc6dO/eQK0VucY0Lv7y6xhcvXlRoaKg++OCDh1E2bJQX19fLy0sHDx7Ur7/+qmXLlumPP/54WOUjr5kBII9JMq9du9ZqWYMGDcwvv/yy5X1aWpq5XLly5jfffNNsNpvNMTEx5q5du1rWDx8+3BwVFfVQ6kXO5eYa37Zt2zbzM8888zDKxH3I7TW+du2auWnTpuYlS5Y8rFKRC/fz3/BtL774onnVqlUPskw8QNwJAPDAXb9+Xfv371fr1q0ty+zs7NS6dWvt2rVLktSgQQMdOXJEZ86cUUpKir766iu1adMmv0pGDtlyjVGw2XKNzWazwsLC1LJlS/Xr1y+/SkUu2HJ9//jjD12+fFmSlJSUpG+++UY1atTIl3px/xzyuwAAhd/58+eVlpam0qVLWy0vXbq0fvrpJ0mSg4ODZs+erRYtWig9PV2jR4/miRMFiC3XWJJat26tgwcP6sqVK6pQoYJWrVqlhg0bPuxykQu2XOOYmBitXLlSgYGBlvHmn3zyiQICAh52ucghW67vyZMn9fzzz1smBL/yyitc2wKMEADgkdG5c2d17tw5v8vAA7R169b8LgEPUJMmTZSenp7fZeABadCggWJjY/O7DOQRhgMBeOBKliwpe3v7DBPI/vjjD5UpUyafqkJe4hoXflzjwo3razyEAAAPnKOjo+rWravo6GjLsvT0dEVHRzMUpJDgGhd+XOPCjetrPAwHApAnUlJS9PPPP1ve//rrr4qNjVXx4sVVsWJFvfbaa+rfv7/q1aunBg0aaO7cubpy5YoGDBiQj1UjJ7jGhR/XuHDj+sJKPj+dCEAhsW3bNrOkDK/+/ftb2vznP/8xV6xY0ezo6Ghu0KCB+fvvv8+/gpFjXOPCj2tcuHF9cSeT2czfewYAAACMhDkBAAAAgMEQAgAAAACDIQQAAAAABkMIAAAAAAyGEAAAAAAYDCEAAAAAMBhCAAAAAGAwhAAAAADAYAgBAAAAgMEQAgAAAACDIQQAAAAABkMIAAAAAAyGEAAAAAAYzP8Dk2iDr7TDJkYAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "court_type_card_order = stats[\"type\"].value_counts().index.tolist()\n",
+    "court_type_data = stats[\"type\"].value_counts().plot.barh(logx=True, title=\"Types cardinality\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "e1051c95-4339-4a5e-bb1a-559ea811c5ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "appeal_type_card_order = stats[\"appeal_type\"].value_counts().index.tolist()\n",
+    "appeal_type_data = stats[\"appeal_type\"].value_counts().plot.barh(logx=True, title=\"Types cardinality\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "c4a68318-5880-4d5f-9690-80235ed0bfe4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "appeal_outcome_card_order = stats[\"appeal_outcome\"].value_counts().index.tolist()\n",
+    "appeal_outcome_data = stats[\"appeal_outcome\"].value_counts().plot.barh(logx=True, title=\"Types cardinality\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "ef0ec395-bd03-47bf-84b2-7adf338595f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Per type text length ditribution'}, xlabel='num_non_ws_tokens', ylabel='type'>"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x1200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "# sns.displot(data=stats, x=\"num_non_ws_tokens\", col=\"type\", col_wrap=3, log_scale=(True, False), facet_kws=dict(sharey=False, sharex=False), kind=\"hist\", bins=25)\n",
+    "\n",
+    "_, ax = plt.subplots(figsize=(8, 12))\n",
+    "ax.set(title=\"Per type text length ditribution\")\n",
+    "sns.boxenplot(data=stats, y=\"type\", x=\"num_non_ws_tokens\", order=court_type_card_order, log_scale=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "06f8c2b2-8f87-4876-b58c-a164c3412c31",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Per type text length ditribution'}, xlabel='num_non_ws_tokens', ylabel='appeal_type'>"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x1200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "# sns.displot(data=stats, x=\"num_non_ws_tokens\", col=\"type\", col_wrap=3, log_scale=(True, False), facet_kws=dict(sharey=False, sharex=False), kind=\"hist\", bins=25)\n",
+    "\n",
+    "_, ax = plt.subplots(figsize=(8, 12))\n",
+    "ax.set(title=\"Per type text length ditribution\")\n",
+    "sns.boxenplot(data=stats, y=\"appeal_type\", x=\"num_non_ws_tokens\", order=appeal_type_card_order, log_scale=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "1de5e68f-8ae4-4a67-bdd1-c84146d2475e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Per type text length ditribution'}, xlabel='num_non_ws_tokens', ylabel='appeal_outcome'>"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x1200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "# sns.displot(data=stats, x=\"num_non_ws_tokens\", col=\"type\", col_wrap=3, log_scale=(True, False), facet_kws=dict(sharey=False, sharex=False), kind=\"hist\", bins=25)\n",
+    "\n",
+    "_, ax = plt.subplots(figsize=(8, 12))\n",
+    "ax.set(title=\"Per type text length ditribution\")\n",
+    "sns.boxenplot(data=stats, y=\"appeal_outcome\", x=\"num_non_ws_tokens\", order=appeal_outcome_card_order, log_scale=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ea06ef3f-c12d-4da6-9fc6-45f1809dabad",
+   "metadata": {},
+   "source": [
+    "# Tokenize\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "08c70fdc-0b03-4983-8da9-8d065161d3e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "None of PyTorch, TensorFlow >= 2.0, or Flax have been found. Models won't be available and only tokenizers, configuration and file/data utilities can be used.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "0af8c3ba-aa89-4e1a-bfcb-65b618c4559e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9f849bfbaab840c7883c4e321f589d87",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/418 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5297a78772234c64b5cd8cd2d0487652",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "sentencepiece.bpe.model:   0%|          | 0.00/5.07M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "21d0b02b129f4ff7ae3f5456b37b88ba",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json:   0%|          | 0.00/17.1M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "10995797e0d3480a9878ddd487467276",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "special_tokens_map.json:   0%|          | 0.00/280 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c9bec5acc69949b088e7432531210249",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map (num_proc=44):   0%|          | 0/6154 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (1625 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (7729 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (4093 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (968 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (2180 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (1937 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (2857 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (8490 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (17735 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (22812 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3021 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (2964 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (1604 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (2726 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3342 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3668 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (4760 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (14217 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (1346 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (5781 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (12451 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (11813 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (6959 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (2493 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3168 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (12022 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3316 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (6039 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (5440 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (14833 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3606 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (4197 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3538 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (4618 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3974 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (14842 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3610 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (6583 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (2124 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (9074 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (11635 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (7935 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (4170 > 512). Running this sequence through the model will result in indexing errors\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (3503 > 512). Running this sequence through the model will result in indexing errors\n"
+     ]
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"intfloat/multilingual-e5-large\")\n",
+    "ds = ds.map(\n",
+    "    lambda examples: tokenizer(examples[\"content\"], padding=False, truncation=False),\n",
+    "    batched=True,\n",
+    "    num_proc=44,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "6f822fae-f91c-4ee1-a114-97a021bf1e81",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | eval: false\n",
+    "tokenized = []\n",
+    "for item in ds:\n",
+    "    tokenized.append({\"num_tokens\": len(item[\"input_ids\"])})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "3c059b5a-5c25-4381-aad7-d69ef0b90320",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_tokens = [item['num_tokens'] for item in tokenized]\n",
+    "filtered_tokens = [token for token in num_tokens if token <= 40000]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "cdac696f-056a-4b12-a48e-ac8f8dac9eeb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: ylabel='Count'>"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "sns.histplot(filtered_tokens, bins=100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "c890ee73",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot the box plot\n",
+    "plt.figure(figsize=(6, 6))\n",
+    "sns.boxplot(filtered_tokens)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08572d7e-8b02-4b5b-a078-24d88beb1378",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (ml4legal)",
+   "language": "python",
+   "name": "myenv"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/nbs/Data/england-wales/02_Analyse_En_Dataset.ipynb b/nbs/Data/england-wales/02_Analyse_En_Dataset.ipynb
new file mode 100644
index 0000000..8e6748b
--- /dev/null
+++ b/nbs/Data/england-wales/02_Analyse_En_Dataset.ipynb
@@ -0,0 +1,480 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a98d226c",
+   "metadata": {},
+   "source": [
+    "# Analyse Polish Dataset\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "initial_id",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | eval: false\n",
+    "import polars as pl\n",
+    "from datasets import Dataset, DatasetDict, load_dataset, load_from_disk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "c8a2c7d4858169a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | eval: false\n",
+    "path_ = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/'\n",
+    "dataset_path = path_+'en_judgements_dataset'\n",
+    "ds = load_from_disk(dataset_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "dd788638-6a7d-4f31-bfed-8845eb4cfbd0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Dataset({\n",
+       "    features: ['_id', 'citation', 'signature', 'date', 'publicationDate', 'type', 'excerpt', 'content', 'judges', 'caseNumbers', 'citation_references', 'legislation', 'file_name', 'appeal_type', 'appeal_outcome', 'xml_uri', 'uri'],\n",
+       "    num_rows: 6154\n",
+       "})"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ds"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "167b28d4-1e8a-4bf3-a2f3-bea277fb448f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = ds.to_pandas()\n",
+    "pl_df = pl.DataFrame(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "9e3c70ac",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "shape: (5, 17)\n",
+      "┌───────────┬───────────┬───────────┬───────────┬───┬───────────┬───────────┬───────────┬──────────┐\n",
+      "│ _id       ┆ citation  ┆ signature ┆ date      ┆ … ┆ appeal_ty ┆ appeal_ou ┆ xml_uri   ┆ uri      │\n",
+      "│ ---       ┆ ---       ┆ ---       ┆ ---       ┆   ┆ pe        ┆ tcome     ┆ ---       ┆ ---      │\n",
+      "│ str       ┆ str       ┆ str       ┆ datetime[ ┆   ┆ ---       ┆ ---       ┆ str       ┆ str      │\n",
+      "│           ┆           ┆           ┆ ns]       ┆   ┆ cat       ┆ cat       ┆           ┆          │\n",
+      "╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪══════════╡\n",
+      "│ ab0224364 ┆ [2008]    ┆ EWCA_Crim ┆ null      ┆ … ┆ null      ┆ null      ┆ https://c ┆ https:// │\n",
+      "│ e4cf6562c ┆ EWCA Crim ┆ _2952     ┆           ┆   ┆           ┆           ┆ aselaw.na ┆ caselaw. │\n",
+      "│ 82f8861d5 ┆ 2952      ┆           ┆           ┆   ┆           ┆           ┆ tionalarc ┆ national │\n",
+      "│ 268…      ┆           ┆           ┆           ┆   ┆           ┆           ┆ hiv…      ┆ archiv…  │\n",
+      "│ d4630d932 ┆ [2006]    ┆ EWCA_Crim ┆ null      ┆ … ┆ convictio ┆ null      ┆ https://c ┆ https:// │\n",
+      "│ 58ea51ecf ┆ EWCA Crim ┆ _3187     ┆           ┆   ┆ n         ┆           ┆ aselaw.na ┆ caselaw. │\n",
+      "│ f4bc40154 ┆ 3187      ┆           ┆           ┆   ┆           ┆           ┆ tionalarc ┆ national │\n",
+      "│ 43b…      ┆           ┆           ┆           ┆   ┆           ┆           ┆ hiv…      ┆ archiv…  │\n",
+      "│ 37183a714 ┆ [2012]    ┆ EWCA_Crim ┆ null      ┆ … ┆ null      ┆ null      ┆ https://c ┆ https:// │\n",
+      "│ b626cfe98 ┆ EWCA Crim ┆ _1840     ┆           ┆   ┆           ┆           ┆ aselaw.na ┆ caselaw. │\n",
+      "│ 081ac0250 ┆ 1840      ┆           ┆           ┆   ┆           ┆           ┆ tionalarc ┆ national │\n",
+      "│ c80…      ┆           ┆           ┆           ┆   ┆           ┆           ┆ hiv…      ┆ archiv…  │\n",
+      "│ b41933b19 ┆ [2014]    ┆ EWCA_Crim ┆ null      ┆ … ┆ null      ┆ null      ┆ https://c ┆ https:// │\n",
+      "│ 505ab8767 ┆ EWCA Crim ┆ _1730     ┆           ┆   ┆           ┆           ┆ aselaw.na ┆ caselaw. │\n",
+      "│ ce30faf8d ┆ 1730      ┆           ┆           ┆   ┆           ┆           ┆ tionalarc ┆ national │\n",
+      "│ b95…      ┆           ┆           ┆           ┆   ┆           ┆           ┆ hiv…      ┆ archiv…  │\n",
+      "│ 418382a2a ┆ [2018]    ┆ EWCA_Crim ┆ null      ┆ … ┆ null      ┆ allowed   ┆ https://c ┆ https:// │\n",
+      "│ 6c0c32d3d ┆ EWCA Crim ┆ _2189     ┆           ┆   ┆           ┆           ┆ aselaw.na ┆ caselaw. │\n",
+      "│ 2bd4cb7b3 ┆ 2189      ┆           ┆           ┆   ┆           ┆           ┆ tionalarc ┆ national │\n",
+      "│ 9e1…      ┆           ┆           ┆           ┆   ┆           ┆           ┆ hiv…      ┆ archiv…  │\n",
+      "└───────────┴───────────┴───────────┴───────────┴───┴───────────┴───────────┴───────────┴──────────┘\n"
+     ]
+    }
+   ],
+   "source": [
+    "pl_df = pl_df.with_columns([\n",
+    "    pl.col(\"date\").cast(pl.Utf8),\n",
+    "    pl.col(\"publicationDate\").cast(pl.Utf8),\n",
+    "])\n",
+    "\n",
+    "# Define date format\n",
+    "dt_fmt = \"%Y-%m-%d %H:%M:%S%.f %Z\"\n",
+    "\n",
+    "# Perform column transformations\n",
+    "pl_df = pl_df.with_columns([\n",
+    "    pl.col(\"date\").str.strptime(pl.Datetime, format=dt_fmt),\n",
+    "    pl.col(\"publicationDate\").str.strptime(pl.Datetime, format=dt_fmt),\n",
+    "    pl.col(\"type\").cast(pl.Categorical),\n",
+    "    pl.col(\"appeal_type\").cast(pl.Categorical),\n",
+    "    pl.col(\"appeal_outcome\").cast(pl.Categorical)\n",
+    "])\n",
+    "\n",
+    "# Display the first few rows of the transformed DataFrame\n",
+    "print(pl_df.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "35e65fe2dd9a4bce",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><style>\n",
+       ".dataframe > thead > tr,\n",
+       ".dataframe > tbody > tr {\n",
+       "  text-align: right;\n",
+       "  white-space: pre-wrap;\n",
+       "}\n",
+       "</style>\n",
+       "<small>shape: (9, 18)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>statistic</th><th>_id</th><th>citation</th><th>signature</th><th>date</th><th>publicationDate</th><th>type</th><th>excerpt</th><th>content</th><th>judges</th><th>caseNumbers</th><th>citation_references</th><th>legislation</th><th>file_name</th><th>appeal_type</th><th>appeal_outcome</th><th>xml_uri</th><th>uri</th></tr><tr><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>str</td><td>str</td><td>str</td><td>str</td><td>str</td></tr></thead><tbody><tr><td>&quot;count&quot;</td><td>&quot;6154&quot;</td><td>&quot;6154&quot;</td><td>&quot;6154&quot;</td><td>&quot;0&quot;</td><td>&quot;6154&quot;</td><td>&quot;6154&quot;</td><td>&quot;6058&quot;</td><td>&quot;6154&quot;</td><td>6115.0</td><td>4934.0</td><td>1392.0</td><td>1826.0</td><td>&quot;6154&quot;</td><td>&quot;834&quot;</td><td>&quot;1368&quot;</td><td>&quot;6154&quot;</td><td>&quot;6154&quot;</td></tr><tr><td>&quot;null_count&quot;</td><td>&quot;0&quot;</td><td>&quot;0&quot;</td><td>&quot;0&quot;</td><td>&quot;6154&quot;</td><td>&quot;0&quot;</td><td>&quot;0&quot;</td><td>&quot;96&quot;</td><td>&quot;0&quot;</td><td>39.0</td><td>1220.0</td><td>4762.0</td><td>4328.0</td><td>&quot;0&quot;</td><td>&quot;5320&quot;</td><td>&quot;4786&quot;</td><td>&quot;0&quot;</td><td>&quot;0&quot;</td></tr><tr><td>&quot;mean&quot;</td><td>null</td><td>null</td><td>null</td><td>null</td><td>&quot;2013-10-13 09:46:09.320766&quot;</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td></tr><tr><td>&quot;std&quot;</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td></tr><tr><td>&quot;min&quot;</td><td>&quot;001d3b389f60bfd101c581fe8f1a9a…</td><td>&quot;[2003] EWCA Crim 1&quot;</td><td>&quot;EWCA_(Crim)_1478&quot;</td><td>null</td><td>&quot;2003-01-04 00:00:00&quot;</td><td>null</td><td>&quot;********REPORTING RESTRICTIONS…</td><td>&quot;\n",
+       "2020] EWCA Crim 570\n",
+       "No: 20190…</td><td>null</td><td>null</td><td>null</td><td>null</td><td>&quot;2003_01_04-1.xml&quot;</td><td>null</td><td>null</td><td>&quot;https://caselaw.nationalarchiv…</td><td>&quot;https://caselaw.nationalarchiv…</td></tr><tr><td>&quot;25%&quot;</td><td>null</td><td>null</td><td>null</td><td>null</td><td>&quot;2008-06-11 00:00:00&quot;</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td></tr><tr><td>&quot;50%&quot;</td><td>null</td><td>null</td><td>null</td><td>null</td><td>&quot;2012-11-29 00:00:00&quot;</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td></tr><tr><td>&quot;75%&quot;</td><td>null</td><td>null</td><td>null</td><td>null</td><td>&quot;2019-06-07 00:00:00&quot;</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td><td>null</td></tr><tr><td>&quot;max&quot;</td><td>&quot;ffffb6552ad89849b5d2767708b5c2…</td><td>&quot;[2024] EWCA Crim 99&quot;</td><td>&quot;Ewca_Crim_664&quot;</td><td>null</td><td>&quot;2024-05-22 00:00:00&quot;</td><td>null</td><td>&quot;…WARNING: reporting restrictio…</td><td>&quot;…WARNING: reporting restrictio…</td><td>null</td><td>null</td><td>null</td><td>null</td><td>&quot;2024_05_22-6154.xml&quot;</td><td>null</td><td>null</td><td>&quot;https://caselaw.nationalarchiv…</td><td>&quot;https://caselaw.nationalarchiv…</td></tr></tbody></table></div>"
+      ],
+      "text/plain": [
+       "shape: (9, 18)\n",
+       "┌───────────┬───────────┬───────────┬───────────┬───┬───────────┬───────────┬───────────┬──────────┐\n",
+       "│ statistic ┆ _id       ┆ citation  ┆ signature ┆ … ┆ appeal_ty ┆ appeal_ou ┆ xml_uri   ┆ uri      │\n",
+       "│ ---       ┆ ---       ┆ ---       ┆ ---       ┆   ┆ pe        ┆ tcome     ┆ ---       ┆ ---      │\n",
+       "│ str       ┆ str       ┆ str       ┆ str       ┆   ┆ ---       ┆ ---       ┆ str       ┆ str      │\n",
+       "│           ┆           ┆           ┆           ┆   ┆ str       ┆ str       ┆           ┆          │\n",
+       "╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪══════════╡\n",
+       "│ count     ┆ 6154      ┆ 6154      ┆ 6154      ┆ … ┆ 834       ┆ 1368      ┆ 6154      ┆ 6154     │\n",
+       "│ null_coun ┆ 0         ┆ 0         ┆ 0         ┆ … ┆ 5320      ┆ 4786      ┆ 0         ┆ 0        │\n",
+       "│ t         ┆           ┆           ┆           ┆   ┆           ┆           ┆           ┆          │\n",
+       "│ mean      ┆ null      ┆ null      ┆ null      ┆ … ┆ null      ┆ null      ┆ null      ┆ null     │\n",
+       "│ std       ┆ null      ┆ null      ┆ null      ┆ … ┆ null      ┆ null      ┆ null      ┆ null     │\n",
+       "│ min       ┆ 001d3b389 ┆ [2003]    ┆ EWCA_(Cri ┆ … ┆ null      ┆ null      ┆ https://c ┆ https:// │\n",
+       "│           ┆ f60bfd101 ┆ EWCA Crim ┆ m)_1478   ┆   ┆           ┆           ┆ aselaw.na ┆ caselaw. │\n",
+       "│           ┆ c581fe8f1 ┆ 1         ┆           ┆   ┆           ┆           ┆ tionalarc ┆ national │\n",
+       "│           ┆ a9a…      ┆           ┆           ┆   ┆           ┆           ┆ hiv…      ┆ archiv…  │\n",
+       "│ 25%       ┆ null      ┆ null      ┆ null      ┆ … ┆ null      ┆ null      ┆ null      ┆ null     │\n",
+       "│ 50%       ┆ null      ┆ null      ┆ null      ┆ … ┆ null      ┆ null      ┆ null      ┆ null     │\n",
+       "│ 75%       ┆ null      ┆ null      ┆ null      ┆ … ┆ null      ┆ null      ┆ null      ┆ null     │\n",
+       "│ max       ┆ ffffb6552 ┆ [2024]    ┆ Ewca_Crim ┆ … ┆ null      ┆ null      ┆ https://c ┆ https:// │\n",
+       "│           ┆ ad89849b5 ┆ EWCA Crim ┆ _664      ┆   ┆           ┆           ┆ aselaw.na ┆ caselaw. │\n",
+       "│           ┆ d2767708b ┆ 99        ┆           ┆   ┆           ┆           ┆ tionalarc ┆ national │\n",
+       "│           ┆ 5c2…      ┆           ┆           ┆   ┆           ┆           ┆ hiv…      ┆ archiv…  │\n",
+       "└───────────┴───────────┴───────────┴───────────┴───┴───────────┴───────────┴───────────┴──────────┘"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "pl_df.describe()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "ab23ff37327a377a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><style>\n",
+       ".dataframe > thead > tr,\n",
+       ".dataframe > tbody > tr {\n",
+       "  text-align: right;\n",
+       "  white-space: pre-wrap;\n",
+       "}\n",
+       "</style>\n",
+       "<small>shape: (7, 2)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>type</th><th>count</th></tr><tr><td>cat</td><td>u32</td></tr></thead><tbody><tr><td>&quot;crown_court&quot;</td><td>5472</td></tr><tr><td>&quot;supreme_court&quot;</td><td>660</td></tr><tr><td>&quot;martial_court&quot;</td><td>11</td></tr><tr><td>&quot;high_court_administrative_cour…</td><td>2</td></tr><tr><td>&quot;high_court_division_court&quot;</td><td>7</td></tr><tr><td>&quot;civil_criminal_court&quot;</td><td>1</td></tr><tr><td>&quot;division_court&quot;</td><td>1</td></tr></tbody></table></div>"
+      ],
+      "text/plain": [
+       "shape: (7, 2)\n",
+       "┌─────────────────────────────────┬───────┐\n",
+       "│ type                            ┆ count │\n",
+       "│ ---                             ┆ ---   │\n",
+       "│ cat                             ┆ u32   │\n",
+       "╞═════════════════════════════════╪═══════╡\n",
+       "│ crown_court                     ┆ 5472  │\n",
+       "│ supreme_court                   ┆ 660   │\n",
+       "│ martial_court                   ┆ 11    │\n",
+       "│ high_court_administrative_cour… ┆ 2     │\n",
+       "│ high_court_division_court       ┆ 7     │\n",
+       "│ civil_criminal_court            ┆ 1     │\n",
+       "│ division_court                  ┆ 1     │\n",
+       "└─────────────────────────────────┴───────┘"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "pl_df[\"type\"].value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "11883338-0a71-48ff-8699-6a4dd8cc085d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><style>\n",
+       ".dataframe > thead > tr,\n",
+       ".dataframe > tbody > tr {\n",
+       "  text-align: right;\n",
+       "  white-space: pre-wrap;\n",
+       "}\n",
+       "</style>\n",
+       "<small>shape: (3, 2)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>appeal_type</th><th>count</th></tr><tr><td>cat</td><td>u32</td></tr></thead><tbody><tr><td>&quot;conviction&quot;</td><td>496</td></tr><tr><td>&quot;sentence&quot;</td><td>338</td></tr><tr><td>null</td><td>5320</td></tr></tbody></table></div>"
+      ],
+      "text/plain": [
+       "shape: (3, 2)\n",
+       "┌─────────────┬───────┐\n",
+       "│ appeal_type ┆ count │\n",
+       "│ ---         ┆ ---   │\n",
+       "│ cat         ┆ u32   │\n",
+       "╞═════════════╪═══════╡\n",
+       "│ conviction  ┆ 496   │\n",
+       "│ sentence    ┆ 338   │\n",
+       "│ null        ┆ 5320  │\n",
+       "└─────────────┴───────┘"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pl_df[\"appeal_type\"].value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "0cdfb0a9-c761-44c5-8fa0-17508df966e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><style>\n",
+       ".dataframe > thead > tr,\n",
+       ".dataframe > tbody > tr {\n",
+       "  text-align: right;\n",
+       "  white-space: pre-wrap;\n",
+       "}\n",
+       "</style>\n",
+       "<small>shape: (5, 2)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>appeal_outcome</th><th>count</th></tr><tr><td>cat</td><td>u32</td></tr></thead><tbody><tr><td>&quot;allowed&quot;</td><td>697</td></tr><tr><td>&quot;refused&quot;</td><td>65</td></tr><tr><td>&quot;dismissed&quot;</td><td>586</td></tr><tr><td>null</td><td>4786</td></tr><tr><td>&quot;granted&quot;</td><td>20</td></tr></tbody></table></div>"
+      ],
+      "text/plain": [
+       "shape: (5, 2)\n",
+       "┌────────────────┬───────┐\n",
+       "│ appeal_outcome ┆ count │\n",
+       "│ ---            ┆ ---   │\n",
+       "│ cat            ┆ u32   │\n",
+       "╞════════════════╪═══════╡\n",
+       "│ allowed        ┆ 697   │\n",
+       "│ refused        ┆ 65    │\n",
+       "│ dismissed      ┆ 586   │\n",
+       "│ null           ┆ 4786  │\n",
+       "│ granted        ┆ 20    │\n",
+       "└────────────────┴───────┘"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pl_df[\"appeal_outcome\"].value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "11446c299cdf1700",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Missing content: 0.0\n",
+      "Missing excerpt: 0.015599610009749756\n"
+     ]
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "print(f\"Missing content: {pl_df['content'].null_count() / len(pl_df)}\")\n",
+    "print(f\"Missing excerpt: {pl_df['excerpt'].null_count() / len(pl_df)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "891ffbad",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Excerpt #chars distribution'}, ylabel='Frequency'>"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# | eval: false\n",
+    "pl_df[\"excerpt\"].str.strip_chars().str.len_chars().to_pandas().plot.hist(\n",
+    "    bins=50, log=True, title=\"Excerpt #chars distribution\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "82355195-bcd0-47fe-9cea-8feb680dd650",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div><style>\n",
+       ".dataframe > thead > tr,\n",
+       ".dataframe > tbody > tr {\n",
+       "  text-align: right;\n",
+       "  white-space: pre-wrap;\n",
+       "}\n",
+       "</style>\n",
+       "<small>shape: (6_154,)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>excerpt</th></tr><tr><td>str</td></tr></thead><tbody><tr><td>&quot;No. 2008/03296/A9 2008/03350/A…</td></tr><tr><td>&quot;Neutral Citation Number: [2006…</td></tr><tr><td>&quot;Neutral Citation Number: [2012…</td></tr><tr><td>&quot;Neutral Citation Number: [2014…</td></tr><tr><td>&quot;No: 201802356 A2 Neutral Citat…</td></tr><tr><td>&hellip;</td></tr><tr><td>&quot;Neutral Citation Number: [2018…</td></tr><tr><td>&quot;Case No: 2002/04091/D1 Neutral…</td></tr><tr><td>&quot;Neutral Citation Number: [2010…</td></tr><tr><td>&quot;Case No: 200305991 D2 Neutral …</td></tr><tr><td>&quot;2017/05382/B1 Neutral Citation…</td></tr></tbody></table></div>"
+      ],
+      "text/plain": [
+       "shape: (6_154,)\n",
+       "Series: 'excerpt' [str]\n",
+       "[\n",
+       "\t\"No. 2008/03296/A9 2008/03350/A…\n",
+       "\t\"Neutral Citation Number: [2006…\n",
+       "\t\"Neutral Citation Number: [2012…\n",
+       "\t\"Neutral Citation Number: [2014…\n",
+       "\t\"No: 201802356 A2 Neutral Citat…\n",
+       "\t…\n",
+       "\t\"Neutral Citation Number: [2018…\n",
+       "\t\"Case No: 2002/04091/D1 Neutral…\n",
+       "\t\"Neutral Citation Number: [2010…\n",
+       "\t\"Case No: 200305991 D2 Neutral …\n",
+       "\t\"2017/05382/B1 Neutral Citation…\n",
+       "]"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pl_df[\"excerpt\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "bb009db3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0       500.0\n",
+       "1       500.0\n",
+       "2       499.0\n",
+       "3       500.0\n",
+       "4       499.0\n",
+       "        ...  \n",
+       "6149    499.0\n",
+       "6150    500.0\n",
+       "6151    500.0\n",
+       "6152    499.0\n",
+       "6153    499.0\n",
+       "Name: excerpt, Length: 6154, dtype: float64"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pl_df[\"excerpt\"].str.strip_chars().str.len_chars().to_pandas()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b8d0b77-9a61-481f-ba4b-ac738250df3e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/scripts/england_wales/01_extract_jsonl.py b/scripts/england_wales/01_extract_jsonl.py
deleted file mode 100644
index 735498a..0000000
--- a/scripts/england_wales/01_extract_jsonl.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import os
-import json
-from bs4 import BeautifulSoup
-from tqdm import tqdm
-
-def extract_information_from_xml(xml_content):
-    soup = BeautifulSoup(xml_content, 'lxml')
-
-    # Extract required fields
-    _id = soup.find('uk:hash').text
-    signature = soup.find('neutralcitation').text if soup.find('neutralcitation') else None
-    hearing_date = soup.find('hearingdate').text if soup.find('hearingdate') else None
-    date = hearing_date.strip() if hearing_date else None
-    publication_date = soup.find('frbrwork').find('frbrdate')['date']
-    court_type = soup.find('courttype').text if soup.find('courttype') else None
-
-    # Get the excerpt
-    header_text = soup.header.get_text(separator=' ', strip=True)
-    excerpt = header_text[:500]
-
-    # Get the full content of the judgment body as XML string
-    judgment_body = soup.find('judgmentbody')
-    content = str(judgment_body) if judgment_body else None
-
-    # Get the judges list
-    judges = [judge.get_text() for judge in soup.find_all('judge')]
-
-    # Get case numbers
-    case_numbers = [case_number.get_text() for case_number in soup.find_all('p', class_='CoverText') if
-                    'Case Nos:' in case_number.text]
-    case_numbers = [num.strip() for sublist in case_numbers for num in sublist.replace('Case Nos:', '').split()]
-
-    return {
-        "_id": _id,
-        "signature": signature,
-        "date": date,
-        "publicationDate": publication_date,
-        "type": court_type,
-        "excerpt": excerpt,
-        "content": content,
-        "judges": judges,
-        "caseNumbers": case_numbers
-    }
-
-
-def process_directory(directory_path, output_file):
-    with open(output_file, 'w') as jsonl_file:
-        xml_files = [f for f in os.listdir(directory_path) if f.endswith('.xml')]
-        for filename in tqdm(xml_files, desc="Processing XML files"):
-            file_path = os.path.join(directory_path, filename)
-            with open(file_path, 'r', encoding='utf-8') as xml_file:
-                xml_content = xml_file.read()
-                judgment_data = extract_information_from_xml(xml_content)
-                jsonl_file.write(json.dumps(judgment_data) + '\n')
-
-directory_path = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/dump/'
-output_file = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/englad_wales_data.jsonl'
-
-process_directory(directory_path, output_file)
diff --git a/scripts/england_wales/01_extract_jsonl_refined.py b/scripts/england_wales/01_extract_jsonl_refined.py
new file mode 100644
index 0000000..a1389ce
--- /dev/null
+++ b/scripts/england_wales/01_extract_jsonl_refined.py
@@ -0,0 +1,216 @@
+import os
+import json
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+import re
+from multiprocessing import Pool
+
+def extract_appeal_type(text):
+    patterns = [
+        (r'appeal\s+against\s+\S+\s+sentence\s+or\s+\S+\s+conviction', 'conviction_sentence'),
+        (r'appeal\s+against\s+\S+\s+conviction\s+or\s+\S+\s+sentence', 'conviction_sentence'),
+        (r'appeal\s+against\s+\S+\s+conviction', 'conviction'),
+        (r'appeal\s+against\s+\S+\s+sentence', 'sentence')
+    ]
+
+    for pattern, appeal_type in patterns:
+        if re.search(pattern, text, re.IGNORECASE):
+            return appeal_type
+    return None
+
+
+def extract_appeal_outcome(text):
+    outcome_patterns = {
+        'granted': r'appeal\s+is\s+granted',
+        'dismissed': r'appeal\s+is\s+dismissed',
+        'refused': r'appeal\s+is\s+refused',
+        'allowed': r'appeal\s+is\s+allowed'
+    }
+
+    for outcome, pattern in outcome_patterns.items():
+        if re.search(pattern, text, re.IGNORECASE):
+            return outcome
+    return None
+
+def extract_and_clean_judges(paragraphs):
+    judges = []
+    for para in paragraphs:
+        text = para.get_text(strip=True)
+        if re.search(r'\bJustice\b|\bJudge\b|\bSIR\b|\bHonour\b|\bHHJ\b', text, re.IGNORECASE):
+            # Remove text within parentheses
+            cleaned_text = re.sub(r'\([^)]*\)', '', text).strip()
+            # Remove dashes and any text following them
+            cleaned_text = re.sub(r'-.*', '', cleaned_text).strip()
+            # Check for specific keywords and ensure it's not empty or unwanted text
+            if cleaned_text and 'Royal Courts of Justice' not in cleaned_text and cleaned_text != "THE LORD CHIEF JUSTICE OF ENGLAND AND WALES":
+                judges.append(cleaned_text)
+    return judges
+
+def categorize_court(court_name):
+    if 'SUPREME_COURT' in court_name:
+        return 'supreme_court'
+    elif "HIGH_COURT" in court_name and "ADMINISTRATIVE_COURT" in court_name:
+        return 'high_court_administrative_court'
+    elif 'HIGH_COURT' in court_name and 'DIVISIONAL_COURT' in court_name:
+        return 'high_court_division_court'
+    elif 'HIGH_COURT' in court_name:
+        return 'high_court'
+    elif 'CIVIL_AND_CRIMINAL' in court_name:
+        return 'civil_criminal_court'
+    elif 'MARTIAL' in court_name:
+        return 'martial_court'
+    elif 'DIVISIONAL_COURT' in court_name:
+        return 'division_court'
+    else:
+        return 'crown_court'
+
+def extract_information_from_xml(xml_content, file_name):
+    soup = BeautifulSoup(xml_content, 'xml')  # Using 'xml' parser for handling namespaces
+
+    # Extract required fields
+    _id = soup.find('uk:hash').text if soup.find('uk:hash') else None
+    citation = soup.find('uk:cite').text if soup.find('uk:cite') else None
+    signature = citation.split('] ')[1] if citation else None  # Removing the year part
+    if signature:
+        signature = signature.replace(' ', '_')
+    hearing_date = soup.find('hearingdate').text if soup.find('hearingdate') else None
+    date = hearing_date.strip() if hearing_date else None
+    publication_date = soup.find('FRBRdate', {'name': 'judgment'})['date'] if soup.find('FRBRdate',
+                                                                                        {'name': 'judgment'}) else None
+
+    court_type_tags = soup.find_all('courtType')
+    # Use a set to collect unique court types
+    unique_court_types = set(
+        re.sub(r'\([^)]*\)', '', tag.get_text(strip=True)).replace(' ', '_') for tag in court_type_tags)
+
+    # Join the unique court types
+    court_type_ = "_".join(unique_court_types)
+    court_type_ = re.sub(r'_+', '_', court_type_).strip('_')
+
+    # Categorize the combined court types
+    court_type = categorize_court(court_type_)
+
+    # Get the excerpt
+    header_text = soup.header.get_text(separator=' ', strip=True) if soup.header else ""
+    excerpt = header_text[:500]
+
+    # Get the full content of the header and judgment body as text
+    header_content = soup.header.get_text(separator='\n', strip=True) if soup.header else ""
+    judgment_body_content = soup.find('judgmentBody').get_text(separator='\n', strip=True) if soup.find(
+        'judgmentBody') else ""
+    content = header_content + "\n" + judgment_body_content
+
+    # Get the judges list
+    # Get the judges list from TLCPerson elements
+    judges = [judge['showAs'] for judge in soup.find_all('TLCPerson') if 'showAs' in judge.attrs and re.search(r'\bJustice\b|\bJudge\b|\bSIR\b|\bHonour\b|\bHHJ\b', judge['showAs'], re.IGNORECASE)]
+    # Filter judges using regex criteria
+    judges = [judge for judge in judges if
+              re.search(r'\bJustice\b|\bJudge\b|\bSIR\b|\bHonour\b|\bHHJ\b', judge, re.IGNORECASE)]
+
+    # If no judges found, get text from <judge> elements
+    if not judges:
+        judges = [judge.get_text(strip=True) for judge in soup.find_all('judge')]
+
+    # If no judges found, use regex to extract them from header content
+    if not judges and soup.header:
+        # Extract all <p> tags
+        paragraphs = soup.header.find_all('p')
+        judges = extract_and_clean_judges(paragraphs)
+
+    # If still no judges found, look for text in <p> tags with style="text-align:center"
+    if not judges:
+        centered_paragraphs = soup.find_all('p', style=lambda x: x and 'text-align:center' in x)
+        judges.extend(extract_and_clean_judges(centered_paragraphs))
+
+    # If still no judges found, look for text in <p> tags with style="text-align:right"
+    if not judges:
+        right_aligned_paragraphs = soup.find_all('p', style=lambda x: x and 'text-align:right' in x)
+        judges.extend(extract_and_clean_judges(right_aligned_paragraphs))
+
+    # Filter judges using regex criteria
+    judges = [judge for judge in judges if
+              re.search(r'\bJustice\b|\bJudge\b|\bSIR\b|\bHonour\b|\bHHJ\b', judge, re.IGNORECASE)]
+
+    # Extract URIs
+    xml_uri = soup.find('FRBRManifestation').find('FRBRuri')['value'] if soup.find('FRBRManifestation') and soup.find('FRBRManifestation').find('FRBRuri') else None
+    uri = soup.find('FRBRWork').find('FRBRuri')['value'] if soup.find('FRBRWork') and soup.find('FRBRWork').find('FRBRuri') else None
+
+    # Extract legislation texts
+    legislation_tags = soup.find_all('ref', {'uk:type': 'legislation'})
+    legislation_texts = set(tag.get_text() for tag in legislation_tags)
+    legislation_list = list(legislation_texts)  # Convert set to list to remove duplicates
+
+    # Extract case references
+    case_tags = soup.find_all('ref', {'uk:type': 'case'})
+    case_references = set(tag.get_text() for tag in case_tags)
+    case_references_list = list(case_references)  # Convert set to list to remove duplicates
+
+    # Extract case numbers
+    case_numbers = set()
+    docket_number_tags = soup.find_all('docketNumber')
+    for tag in docket_number_tags:
+        case_numbers.add(tag.get_text())
+
+    # Extract case numbers from <p class="CoverText"> tags containing "Case No:"
+    cover_text_tags = soup.find_all('p', class_='CoverText')
+    case_no_pattern = re.compile(r'Case No:\s*(.*)')
+    for tag in cover_text_tags:
+        match = case_no_pattern.search(tag.get_text())
+        if match:
+            case_numbers.update([num.strip() for num in match.group(1).split(',')])
+
+    # If no case numbers found, look for text in <p> tags with style="text-align:right"
+    if not case_numbers:
+        right_aligned_paragraphs = soup.find_all('p', style=lambda x: x and 'text-align:right' in x)
+        case_no_pattern = re.compile(r'\b\d{4}/\d{4}/\w+\b|\d{6}')
+        for tag in right_aligned_paragraphs:
+            matches = case_no_pattern.findall(tag.get_text())
+            case_numbers.update(matches)
+
+    # Extract appeal type
+    appeal_type = extract_appeal_type(content)
+
+    # Extract appeal outcome
+    appeal_outcome = extract_appeal_outcome(content)
+
+    def null_if_empty(value):
+        return value if value else None
+
+    return {
+        "_id": null_if_empty(_id),
+        "citation": null_if_empty(citation),
+        "signature": null_if_empty(signature),
+        "date": null_if_empty(date),
+        "publicationDate": null_if_empty(publication_date),
+        "type": null_if_empty(court_type),
+        "excerpt": null_if_empty(excerpt),
+        "content": null_if_empty(content),
+        "judges": null_if_empty(judges),
+        "caseNumbers": null_if_empty(list(case_numbers)),
+        "citation_references": null_if_empty(case_references_list),
+        "legislation": null_if_empty(legislation_list),
+        "file_name": null_if_empty(file_name),
+        "appeal_type": null_if_empty(appeal_type),
+        "appeal_outcome": null_if_empty(appeal_outcome),
+        "xml_uri": null_if_empty(xml_uri),
+        "uri": null_if_empty(uri)
+    }
+
+def process_file(file_path):
+    with open(file_path, 'r', encoding='utf-8') as xml_file:
+        xml_content = xml_file.read()
+        file_name = os.path.basename(file_path)
+        return extract_information_from_xml(xml_content, file_name)
+
+def process_directory(directory_path, output_file):
+    xml_files = [os.path.join(directory_path, f) for f in os.listdir(directory_path) if f.endswith('.xml')]
+
+    with Pool() as pool, open(output_file, 'w') as jsonl_file:
+        for judgment_data in tqdm(pool.imap(process_file, xml_files), total=len(xml_files),
+                                  desc="Processing XML files"):
+            jsonl_file.write(json.dumps(judgment_data) + '\n')
+
+directory_path = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/dump/'
+output_file = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/england_wales_data_refined_7.jsonl'
+
+process_directory(directory_path, output_file)
diff --git a/scripts/england_wales/02_extract_jsonl_refined.py b/scripts/england_wales/02_extract_jsonl_refined.py
deleted file mode 100644
index 6008656..0000000
--- a/scripts/england_wales/02_extract_jsonl_refined.py
+++ /dev/null
@@ -1,63 +0,0 @@
-import os
-import json
-from bs4 import BeautifulSoup
-from tqdm import tqdm
-
-
-def extract_information_from_xml(xml_content):
-    soup = BeautifulSoup(xml_content, 'html.parser')
-
-    # Extract required fields
-    _id = soup.find('uk:hash').text
-    signature = soup.find('neutralcitation').text if soup.find('neutralcitation') else None
-    hearing_date = soup.find('hearingdate').text if soup.find('hearingdate') else None
-    date = hearing_date.strip() if hearing_date else None
-    publication_date = soup.find('frbrwork').find('frbrdate')['date']
-    court_type = soup.find('courttype').text if soup.find('courttype') else None
-
-    # Get the excerpt
-    header_text = soup.header.get_text(separator=' ', strip=True)
-    excerpt = header_text[:500]
-
-    # Get the full content of the header and judgment body as text
-    header_content = soup.header.get_text(separator='\n', strip=True)
-    judgment_body_content = soup.find('judgmentbody').get_text(separator='\n', strip=True) if soup.find(
-        'judgmentbody') else ""
-    content = header_content + "\n" + judgment_body_content
-
-    # Get the judges list
-    judges = [judge.get_text() for judge in soup.find_all('judge')]
-
-    # Get case numbers
-    case_numbers = [case_number.get_text() for case_number in soup.find_all('p', class_='CoverText') if
-                    'Case Nos:' in case_number.text]
-    case_numbers = [num.strip() for sublist in case_numbers for num in sublist.replace('Case Nos:', '').split()]
-
-    return {
-        "_id": _id,
-        "signature": signature,
-        "date": date,
-        "publicationDate": publication_date,
-        "type": court_type,
-        "excerpt": excerpt,
-        "content": content,
-        "judges": judges,
-        "caseNumbers": case_numbers
-    }
-
-
-def process_directory(directory_path, output_file):
-    with open(output_file, 'w') as jsonl_file:
-        xml_files = [f for f in os.listdir(directory_path) if f.endswith('.xml')]
-        for filename in tqdm(xml_files, desc="Processing XML files"):
-            file_path = os.path.join(directory_path, filename)
-            with open(file_path, 'r', encoding='utf-8') as xml_file:
-                xml_content = xml_file.read()
-                judgment_data = extract_information_from_xml(xml_content)
-                jsonl_file.write(json.dumps(judgment_data) + '\n')
-
-
-directory_path = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/dump/'
-output_file = '/home/stirunag/work/github/ML4-legal-documents/judgements_xml/englad_wales_data_refined.jsonl'
-
-process_directory(directory_path, output_file)