diff --git a/HumorDataset.py b/HumorDataset.py
index 05c278b..f802d03 100644
--- a/HumorDataset.py
+++ b/HumorDataset.py
@@ -5,6 +5,40 @@ import torch
 import numpy as np
 from nltk.tokenize import word_tokenize
 
+class TextRegDataset(torch.utils.data.Dataset):
+    def __init__(self, texts, labels, word_index, max_len=50):
+
+        self.original_indices = labels.index.to_list()
+
+        self.texts = texts.reset_index(drop=True)
+        self.labels = labels.reset_index(drop=True)
+        self.word_index = word_index
+        self.max_len = max_len
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, idx):
+        texts = self.texts[idx]
+        tokens = word_tokenize(texts.lower())
+
+        label = self.labels[idx]
+        
+        # Tokenize and convert to indices
+        input_ids = [self.word_index.get(word, self.word_index['<UNK>']) for word in tokens]
+
+        # Pad or truncate to max_len
+        if len(input_ids) < self.max_len:
+            input_ids += [self.word_index['<PAD>']] * (self.max_len - len(input_ids))
+        else:
+            input_ids = input_ids[:self.max_len]
+        
+        # Convert to PyTorch tensors
+        input_ids = torch.tensor(input_ids, dtype=torch.long)
+        label = torch.tensor(label, dtype=torch.float)
+        
+        return input_ids, label
+    
 class TextDataset(torch.utils.data.Dataset):
     def __init__(self, texts, labels, word_index, max_len=50):
 
diff --git a/TEST_CNN_2.py b/TEST_CNN_2.py
index f0f52d3..ea1a7fb 100644
--- a/TEST_CNN_2.py
+++ b/TEST_CNN_2.py
@@ -5,7 +5,7 @@ from torch.utils.data import DataLoader
 from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
 from tqdm import tqdm  # Fortschrittsbalken-Bibliothek
 from dataset_generator import create_embedding_matrix, split_data
-from HumorDataset import TextDataset
+from HumorDataset import TextRegDataset
 import numpy as np
 import pandas as pd
 import os
@@ -20,7 +20,7 @@ params = {
     "learning_rate": 0.001,
     "epochs": 25,
     "glove_path": 'data/glove.6B.100d.txt',  # Pfad zu GloVe
-    "max_len": 50,
+    "max_len": 280,
     "test_size": 0.1,
     "val_size": 0.1,
     "patience": 5,
@@ -171,9 +171,9 @@ visualize_data_distribution(y)
 data_split = split_data(X, y, test_size=params["test_size"], val_size=params["val_size"])
 
 # Dataset und DataLoader
-train_dataset = TextDataset(data_split['train']['X'], data_split['train']['y'], word_index, max_len=params["max_len"])
-val_dataset = TextDataset(data_split['val']['X'], data_split['val']['y'], word_index, max_len=params["max_len"])
-test_dataset = TextDataset(data_split['test']['X'], data_split['test']['y'], word_index, max_len=params["max_len"])
+train_dataset = TextRegDataset(data_split['train']['X'], data_split['train']['y'], word_index, max_len=params["max_len"])
+val_dataset = TextRegDataset(data_split['val']['X'], data_split['val']['y'], word_index, max_len=params["max_len"])
+test_dataset = TextRegDataset(data_split['test']['X'], data_split['test']['y'], word_index, max_len=params["max_len"])
 
 train_loader = DataLoader(train_dataset, batch_size=params["batch_size"], shuffle=True)
 val_loader = DataLoader(val_dataset, batch_size=params["batch_size"], shuffle=False)
@@ -187,7 +187,10 @@ model = EnhancedCNNRegressor(
     num_filters=params["num_filters"],
     embedding_matrix=embedding_matrix,
     dropout=params["dropout"]
-).to(device)
+)
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = model.to(device)
 
 criterion = nn.MSELoss()
 optimizer = optim.Adam(model.parameters(), lr=params["learning_rate"], weight_decay=params["weight_decay"])
@@ -340,3 +343,15 @@ test_rmse = np.sqrt(mean_squared_error(test_labels, test_preds))
 test_mae = mean_absolute_error(test_labels, test_preds)
 test_r2 = r2_score(test_labels, test_preds)
 print(f"Test RMSE: {test_rmse:.4f}, Test MAE: {test_mae:.4f}, Test R²: {test_r2:.4f}")
+
+
+# plot distribution of predicted values and true values
+plt.figure(figsize=(10, 6))
+plt.hist(test_labels, bins=20, color='skyblue', edgecolor='black', alpha=0.7, label='True Values')
+plt.hist(test_preds, bins=20, color='salmon', edgecolor='black', alpha=0.7, label='Predicted Values')
+plt.title('Distribution of Predicted and True Values')
+plt.xlabel('Score')
+plt.ylabel('Frequency')
+plt.legend()
+plt.grid(axis='y', linestyle='--', alpha=0.7)
+plt.show()
\ No newline at end of file
diff --git a/bert_no_ernie.py b/bert_no_ernie.py
index bd9797c..7114fe7 100644
--- a/bert_no_ernie.py
+++ b/bert_no_ernie.py
@@ -4,7 +4,7 @@ import torch.nn as nn
 import torch.optim as optim
 from torch.utils.data import Dataset, DataLoader
 # scikit-learn Imports
-# from sklearn.metrics import accuracy_score, confusion_matrix
+from sklearn.metrics import accuracy_score, confusion_matrix, f1_score
 from sklearn.model_selection import train_test_split
 # Bert imports
 from transformers import BertForSequenceClassification, AutoTokenizer
@@ -25,8 +25,8 @@ class SimpleHumorDataset(Dataset):
         super(SimpleHumorDataset,self).__init__()
         self.tokenizer = tokenizer
         self.max_length = max_length
-        self.text = dataframe['text'].to_list()
-        self.labels = dataframe['is_humor'].to_list()
+        self.text = dataframe['text'].to_numpy()
+        self.labels = dataframe['is_humor'].to_numpy()
     
     def __getitem__(self,idx:int):
         text = self.text[idx]    
@@ -52,41 +52,58 @@ class SimpleHumorDataset(Dataset):
         return len(self.labels)
 
 class CustomBert(nn.Module):
-    def __init__(self):
+    def __init__(self,dropout):
         super().__init__()
         #Bert + Custom Layers (Not a tuple any longer -- idk why)
         self.bfsc = BertForSequenceClassification.from_pretrained("bert-base-uncased")
+        self.dropout = nn.Dropout(dropout)
         self.classifier = nn.Linear(2,2)
-        self.sm = nn.Softmax(dim=1)
+        # self.sm = nn.Softmax(dim=1)
          
     def forward(self, input_ids, attention_mask):
         seq_out = self.bfsc(input_ids, attention_mask = attention_mask)
-        x = self.classifier(seq_out.logits)
-        return self.sm(x)
+        return self.classifier(self.dropout(seq_out[0]))
+        
     
-def training_loop(model:CustomBert,criterion:nn.CrossEntropyLoss,optimizer:optim.AdamW,train_loader:DataLoader):
-    model.train()
-    total_loss = 0
+    def freeze_bert_params(self):
+        for param in self.bfsc.named_parameters():
+            param[1].requires_grad_(False)
 
-    for train_batch in train_loader:
+    def unfreeze_bert_params(self):
+        for param in self.bfsc.named_parameters():
+            param[1].requires_grad_(True)
+    
+def training_loop(model:CustomBert,criterion:nn.CrossEntropyLoss,optimizer:optim.AdamW,train_loader:DataLoader,freeze_bert:bool):
+    model.train()
+    if freeze_bert:
+        model.freeze_bert_params()
+    
+    total_loss = 0
+    len_train_loader = len(train_loader)
+    for index,train_batch in enumerate(train_loader):
         # Set Gradient to Zero
         optimizer.zero_grad()
         # Unpack batch values and "push" it to GPU
         input_ids, att_mask, labels = train_batch.values()
+        # print(f"{input_ids.shape}, {att_mask.shape}, {labels.shape}")
+        # print(f"Iteration {index} of {len_train_loader}")
         input_ids, att_mask, labels = input_ids.to(DEVICE),att_mask.to(DEVICE),labels.to(DEVICE)
         # Feed Model with Data
         outputs = model(input_ids, attention_mask=att_mask)
+        # print(f"{model.bfsc.}")
+        # print(f"{outputs.shape}")
         loss = criterion(outputs,labels)
         loss.backward()
         optimizer.step()
         total_loss+=loss.item()
-    print(f"Total Loss is {(total_loss/len(train_loader)):.4f}")  
+    print(f"Training Loss is {(total_loss/len(train_loader)):.4f}")  
     return (total_loss/len(train_loader))       
 
 def eval_loop(model:CustomBert,criterion:nn.CrossEntropyLoss,validation_loader:DataLoader):
     model.eval()
     total, correct = 0.0, 0.0
     total_loss = 0.0
+    best_loss = 10.0
     with torch.no_grad():
         for val_batch in validation_loader:
             input_ids, att_mask ,labels = val_batch.values()
@@ -97,23 +114,50 @@ def eval_loop(model:CustomBert,criterion:nn.CrossEntropyLoss,validation_loader:D
             predictions = torch.argmax(outputs,1)
             total += labels.size(0)
             correct += (predictions == labels).sum().item()
-    print(f"Total Loss: {total_loss/len(validation_loader)} ### Test Accuracy {correct/total*100}%")
+            if total_loss/len(validation_loader) < best_loss:
+                best_loss = total_loss/len(validation_loader)
+                torch.save(model,"best_bert_model")
+    print(f"Validation Loss: {total_loss/len(validation_loader):.4f} ### Test Accuracy {correct/total*100:.4f}%")
     return total_loss/len(validation_loader)
 
+def test_loop(model:CustomBert, criterion:nn.CrossEntropyLoss, test_loader:DataLoader):
+    for batch in test_loader:
+        input_ids, att_mask, labels = batch.values()
+        input_ids, att_mask, labels = input_ids.to(DEVICE), att_mask.to(DEVICE), labels.to(DEVICE)
+        with torch.no_grad():
+            output = model(input_ids,att_mask)
+            output.detach().cpu().numpy()
+            labels.detach().cpu().numpy()
+            pred_flat = np.argmax(output,1).flatten()
+            print(accuracy_score(labels,pred_flat))
+
+def performance_metrics(true_labels,predictions):
+    confusion_matrix(true_labels,predictions)
+    accuracy_score(true_labels,predictions)
+    f1_score(true_labels,predictions)
+    pass
+
 
 if __name__ == "__main__":
-    torch.manual_seed(501)
+    
     # HYPERPARAMETERS
     # Set Max Epoch Amount
-    EPOCH = 1
+    EPOCH = 10
     # DROPOUT-PROBABILITY
     DROPOUT = 0.1
     # BATCHSIZE
-    BATCH_SIZE = 8
+    BATCH_SIZE = 16
     #LEARNING RATE
     LEARNING_RATE = 1e-5
+    # RANDOM SEED
+    RNDM_SEED = 501
+
+    torch.manual_seed(RNDM_SEED)
+    np.random.seed(RNDM_SEED)
+    torch.cuda.seed_all(RNDM_SEED)
+
     # Initialize Bert Model with dropout probability and Num End Layers
-    mybert = CustomBert()
+    mybert = CustomBert(DROPOUT)
     print("Bert Initialized")
     mybert.to(DEVICE)
 
@@ -122,27 +166,26 @@ if __name__ == "__main__":
     df = pd.read_csv("./data/hack.csv",encoding="latin1")
     print("Raw Data read")
 
-
     # Initialize BertTokenizer from Pretrained 
     tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased",do_lower_case=True)
     print("Tokenizer Initialized")
 
-    # print(tokenizer(df['text'][0],padding=True,truncation=True,max_length=256))
     #Split DataFrame into Train and Test Sets
     train,test = train_test_split(df,random_state=501,test_size=.2)
     print("Splitted Data in Train and Test Sets")
+    test,val = train_test_split(test,random_state=501,test_size=.5)
 
     # val = []
     # Create Custom Datasets for Train and Test
     train_data = SimpleHumorDataset(tokenizer,train)
-    # val_data = SimpleHumorDataset(tokenizer,val)
+    val_data = SimpleHumorDataset(tokenizer,val)
     test_data = SimpleHumorDataset(tokenizer,test)
     print("Custom Datasets created") 
 
 
    # Initialize Dataloader with Train and Test Sets
     train_loader = DataLoader(dataset=train_data,batch_size=BATCH_SIZE,shuffle=True)
-    # val_loader = DataLoader(dataset=val_data,batch_size=BATCH_SIZE,shuffle=True)
+    validation_loader = DataLoader(dataset=val_data,batch_size=BATCH_SIZE,shuffle=True)
     test_loader = DataLoader(dataset=test_data,batch_size=BATCH_SIZE,shuffle=False)
     print("DataLoaders created")
 
@@ -153,20 +196,23 @@ if __name__ == "__main__":
     # Set Scheduler for dynamically Learning Rate adjustment
     loss_values = np.zeros(EPOCH)
     eval_values = np.zeros(EPOCH)
-    start = time.time()
+    freeze = False
+    
     for epoch in range(EPOCH):
-        
+        start = time.time()
         print(f"For {epoch+1} the Scores are: ")
-        loss_values[epoch] = training_loop(mybert,optimizer=optimizer_adamW,criterion=criterion_cross_entropy,train_loader=train_loader)
+        loss_values[epoch] = training_loop(mybert,optimizer=optimizer_adamW,criterion=criterion_cross_entropy,train_loader=train_loader,freeze_bert=freeze)
         eval_values[epoch] = eval_loop(mybert,criterion=criterion_cross_entropy,validation_loader=test_loader)
-    end = time.time()
-    print((end-start),"seconds per epoch needed")
+        end = time.time()
+        print((end-start),"seconds per epoch needed")
     # Visualize Training Loss 
-    plt.plot(loss_values)
-    plt.plot(eval_values)
-    plt.hlines(np.mean(loss_values),xmin=0,xmax=EPOCH,colors='red',linestyles="dotted",label="Average Loss")
-    plt.hlines(np.mean(eval_values),xmin=0,xmax=EPOCH,colors='green',linestyles="dashed",label="Average Val Loss")
-    plt.title("Test Loss")
-    plt.xlabel("Num Epochs")
-    plt.ylabel("Total Loss of Epoch")
-    plt.show()
\ No newline at end of file
+    # plt.plot(loss_values)
+    # plt.plot(eval_values)
+    # plt.hlines(np.mean(loss_values),xmin=0,xmax=EPOCH,colors='red',linestyles="dotted",label="Average Loss")
+    # plt.hlines(np.mean(eval_values),xmin=0,xmax=EPOCH,colors='green',linestyles="dashed",label="Average Val Loss")
+    # plt.title("Test Loss")
+    # plt.xlabel("Num Epochs")
+    # plt.ylabel("Total Loss of Epoch")
+    # plt.show()
+    for epoch in range(EPOCH):
+        test_loop(mybert,criterion_cross_entropy,validation_loader)
\ No newline at end of file
diff --git a/data_explore_hack_reg.ipynb b/data_explore_hack_reg.ipynb
new file mode 100644
index 0000000..d21e8e7
--- /dev/null
+++ b/data_explore_hack_reg.ipynb
@@ -0,0 +1,911 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[nltk_data] Downloading package punkt to\n",
+      "[nltk_data]     C:\\Users\\klara\\AppData\\Roaming\\nltk_data...\n",
+      "[nltk_data]   Package punkt is already up-to-date!\n",
+      "[nltk_data] Downloading package stopwords to\n",
+      "[nltk_data]     C:\\Users\\klara\\AppData\\Roaming\\nltk_data...\n",
+      "[nltk_data]   Package stopwords is already up-to-date!\n",
+      "[nltk_data] Downloading package wordnet to\n",
+      "[nltk_data]     C:\\Users\\klara\\AppData\\Roaming\\nltk_data...\n",
+      "[nltk_data]   Package wordnet is already up-to-date!\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Wichtige Bibliotheken importieren\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import textstat\n",
+    "import nltk\n",
+    "from nltk.corpus import stopwords\n",
+    "from nltk.tokenize import word_tokenize\n",
+    "from nltk.stem import WordNetLemmatizer\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.linear_model import LinearRegression\n",
+    "from sklearn.metrics import mean_squared_error, r2_score\n",
+    "\n",
+    "# NLTK-Modelle herunterladen\n",
+    "nltk.download('punkt')\n",
+    "nltk.download('stopwords')\n",
+    "nltk.download('wordnet')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(8000, 6)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load the data from csv\n",
+    "df = pd.read_csv('data/hack.csv')\n",
+    "\n",
+    "print(df.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "df = df.dropna(subset=['humor_rating'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "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>text</th>\n",
+       "      <th>tokenized_text</th>\n",
+       "      <th>standardized_text</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>TENNESSEE: We're the best state. Nobody even c...</td>\n",
+       "      <td>[TENNESSEE, :, We, 're, the, best, state, ., N...</td>\n",
+       "      <td>[TENNESSEE, :, 're, best, state, ., Nobody, ev...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>A man inserted an advertisement in the classif...</td>\n",
+       "      <td>[A, man, inserted, an, advertisement, in, the,...</td>\n",
+       "      <td>[man, inserted, advertisement, classified, ``,...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>How many men does it take to open a can of bee...</td>\n",
+       "      <td>[How, many, men, does, it, take, to, open, a, ...</td>\n",
+       "      <td>[many, men, take, open, beer, ?, None, ., open...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Told my mom I hit 1200 Twitter followers. She ...</td>\n",
+       "      <td>[Told, my, mom, I, hit, 1200, Twitter, followe...</td>\n",
+       "      <td>[Told, mom, hit, 1200, Twitter, follower, ., p...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Roses are dead. Love is fake. Weddings are bas...</td>\n",
+       "      <td>[Roses, are, dead, ., Love, is, fake, ., Weddi...</td>\n",
+       "      <td>[Roses, dead, ., Love, fake, ., Weddings, basi...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                text  \\\n",
+       "0  TENNESSEE: We're the best state. Nobody even c...   \n",
+       "1  A man inserted an advertisement in the classif...   \n",
+       "2  How many men does it take to open a can of bee...   \n",
+       "3  Told my mom I hit 1200 Twitter followers. She ...   \n",
+       "4  Roses are dead. Love is fake. Weddings are bas...   \n",
+       "\n",
+       "                                      tokenized_text  \\\n",
+       "0  [TENNESSEE, :, We, 're, the, best, state, ., N...   \n",
+       "1  [A, man, inserted, an, advertisement, in, the,...   \n",
+       "2  [How, many, men, does, it, take, to, open, a, ...   \n",
+       "3  [Told, my, mom, I, hit, 1200, Twitter, followe...   \n",
+       "4  [Roses, are, dead, ., Love, is, fake, ., Weddi...   \n",
+       "\n",
+       "                                   standardized_text  \n",
+       "0  [TENNESSEE, :, 're, best, state, ., Nobody, ev...  \n",
+       "1  [man, inserted, advertisement, classified, ``,...  \n",
+       "2  [many, men, take, open, beer, ?, None, ., open...  \n",
+       "3  [Told, mom, hit, 1200, Twitter, follower, ., p...  \n",
+       "4  [Roses, dead, ., Love, fake, ., Weddings, basi...  "
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "stop_words = set(stopwords.words('english'))\n",
+    "lemmatizer = WordNetLemmatizer()\n",
+    "\n",
+    "\n",
+    "def preprocess_text(text):\n",
+    "    tokens = word_tokenize(text)\n",
+    "    tokens = [lemmatizer.lemmatize(word) for word in tokens if word.lower() not in stop_words]\n",
+    "    return tokens\n",
+    "\n",
+    "\n",
+    "df['tokenized_text'] = df['text'].apply(word_tokenize)\n",
+    "\n",
+    "\n",
+    "df['standardized_text'] = df['text'].apply(preprocess_text)\n",
+    "\n",
+    "\n",
+    "df[['text', 'tokenized_text', 'standardized_text']].head()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "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>text</th>\n",
+       "      <th>text_length</th>\n",
+       "      <th>word_count</th>\n",
+       "      <th>avg_word_length</th>\n",
+       "      <th>punctuation_count</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>TENNESSEE: We're the best state. Nobody even c...</td>\n",
+       "      <td>114</td>\n",
+       "      <td>17</td>\n",
+       "      <td>5.764706</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>A man inserted an advertisement in the classif...</td>\n",
+       "      <td>189</td>\n",
+       "      <td>32</td>\n",
+       "      <td>4.937500</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>How many men does it take to open a can of bee...</td>\n",
+       "      <td>112</td>\n",
+       "      <td>26</td>\n",
+       "      <td>3.346154</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Told my mom I hit 1200 Twitter followers. She ...</td>\n",
+       "      <td>139</td>\n",
+       "      <td>26</td>\n",
+       "      <td>4.384615</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Roses are dead. Love is fake. Weddings are bas...</td>\n",
+       "      <td>72</td>\n",
+       "      <td>12</td>\n",
+       "      <td>5.083333</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                text  text_length  word_count  \\\n",
+       "0  TENNESSEE: We're the best state. Nobody even c...          114          17   \n",
+       "1  A man inserted an advertisement in the classif...          189          32   \n",
+       "2  How many men does it take to open a can of bee...          112          26   \n",
+       "3  Told my mom I hit 1200 Twitter followers. She ...          139          26   \n",
+       "4  Roses are dead. Love is fake. Weddings are bas...           72          12   \n",
+       "\n",
+       "   avg_word_length  punctuation_count  \n",
+       "0         5.764706                  5  \n",
+       "1         4.937500                  4  \n",
+       "2         3.346154                  3  \n",
+       "3         4.384615                  3  \n",
+       "4         5.083333                  3  "
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "df['text_length'] = df['text'].apply(len)\n",
+    "df['word_count'] = df['text'].apply(lambda x: len(x.split()))\n",
+    "df['avg_word_length'] = df['text'].apply(lambda x: np.mean([len(word) for word in x.split()]))\n",
+    "df['punctuation_count'] = df['text'].apply(lambda x: len([c for c in x if c in ['.', ',', '!', '?']]))\n",
+    "\n",
+    "\n",
+    "df[['text', 'text_length', 'word_count', 'avg_word_length', 'punctuation_count']].head()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "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>text</th>\n",
+       "      <th>stopword_ratio</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>TENNESSEE: We're the best state. Nobody even c...</td>\n",
+       "      <td>0.160000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>A man inserted an advertisement in the classif...</td>\n",
+       "      <td>0.317073</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>How many men does it take to open a can of bee...</td>\n",
+       "      <td>0.551724</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Told my mom I hit 1200 Twitter followers. She ...</td>\n",
+       "      <td>0.366667</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Roses are dead. Love is fake. Weddings are bas...</td>\n",
+       "      <td>0.266667</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                text  stopword_ratio\n",
+       "0  TENNESSEE: We're the best state. Nobody even c...        0.160000\n",
+       "1  A man inserted an advertisement in the classif...        0.317073\n",
+       "2  How many men does it take to open a can of bee...        0.551724\n",
+       "3  Told my mom I hit 1200 Twitter followers. She ...        0.366667\n",
+       "4  Roses are dead. Love is fake. Weddings are bas...        0.266667"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "def remove_stopwords(tokens):\n",
+    "    return [word for word in tokens if word.lower() not in stop_words]\n",
+    "\n",
+    "def calculate_stopword_ratio(tokens):\n",
+    "    non_stopwords = remove_stopwords(tokens)\n",
+    "    return 1 - (len(non_stopwords) / len(tokens)) if len(tokens) > 0 else 0\n",
+    "\n",
+    "df['stopword_ratio'] = df['tokenized_text'].apply(calculate_stopword_ratio)\n",
+    "\n",
+    "df[['text', 'stopword_ratio']].head()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "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>text</th>\n",
+       "      <th>richness</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>TENNESSEE: We're the best state. Nobody even c...</td>\n",
+       "      <td>0.809524</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>A man inserted an advertisement in the classif...</td>\n",
+       "      <td>0.857143</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>How many men does it take to open a can of bee...</td>\n",
+       "      <td>0.846154</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Told my mom I hit 1200 Twitter followers. She ...</td>\n",
+       "      <td>0.947368</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Roses are dead. Love is fake. Weddings are bas...</td>\n",
+       "      <td>0.818182</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                text  richness\n",
+       "0  TENNESSEE: We're the best state. Nobody even c...  0.809524\n",
+       "1  A man inserted an advertisement in the classif...  0.857143\n",
+       "2  How many men does it take to open a can of bee...  0.846154\n",
+       "3  Told my mom I hit 1200 Twitter followers. She ...  0.947368\n",
+       "4  Roses are dead. Love is fake. Weddings are bas...  0.818182"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "def calculate_richness(tokens):\n",
+    "    return len(set(tokens)) / len(tokens) if len(tokens) > 0 else 0\n",
+    "\n",
+    "df['richness'] = df['standardized_text'].apply(calculate_richness)\n",
+    "\n",
+    "df[['text', 'richness']].head()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "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>text</th>\n",
+       "      <th>richness</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>TENNESSEE: We're the best state. Nobody even c...</td>\n",
+       "      <td>0.809524</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>A man inserted an advertisement in the classif...</td>\n",
+       "      <td>0.857143</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>How many men does it take to open a can of bee...</td>\n",
+       "      <td>0.846154</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Told my mom I hit 1200 Twitter followers. She ...</td>\n",
+       "      <td>0.947368</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Roses are dead. Love is fake. Weddings are bas...</td>\n",
+       "      <td>0.818182</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                text  richness\n",
+       "0  TENNESSEE: We're the best state. Nobody even c...  0.809524\n",
+       "1  A man inserted an advertisement in the classif...  0.857143\n",
+       "2  How many men does it take to open a can of bee...  0.846154\n",
+       "3  Told my mom I hit 1200 Twitter followers. She ...  0.947368\n",
+       "4  Roses are dead. Love is fake. Weddings are bas...  0.818182"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "def calculate_richness(tokens):\n",
+    "    return len(set(tokens)) / len(tokens) if len(tokens) > 0 else 0\n",
+    "\n",
+    "df['richness'] = df['standardized_text'].apply(calculate_richness)\n",
+    "\n",
+    "df[['text', 'richness']].head()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "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>text</th>\n",
+       "      <th>readability</th>\n",
+       "      <th>difficult_words</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>TENNESSEE: We're the best state. Nobody even c...</td>\n",
+       "      <td>8.5</td>\n",
+       "      <td>0.117647</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>A man inserted an advertisement in the classif...</td>\n",
+       "      <td>7.2</td>\n",
+       "      <td>0.250000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>How many men does it take to open a can of bee...</td>\n",
+       "      <td>0.8</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Told my mom I hit 1200 Twitter followers. She ...</td>\n",
+       "      <td>5.7</td>\n",
+       "      <td>0.230769</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Roses are dead. Love is fake. Weddings are bas...</td>\n",
+       "      <td>4.5</td>\n",
+       "      <td>0.333333</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                text  readability  \\\n",
+       "0  TENNESSEE: We're the best state. Nobody even c...          8.5   \n",
+       "1  A man inserted an advertisement in the classif...          7.2   \n",
+       "2  How many men does it take to open a can of bee...          0.8   \n",
+       "3  Told my mom I hit 1200 Twitter followers. She ...          5.7   \n",
+       "4  Roses are dead. Love is fake. Weddings are bas...          4.5   \n",
+       "\n",
+       "   difficult_words  \n",
+       "0         0.117647  \n",
+       "1         0.250000  \n",
+       "2         0.000000  \n",
+       "3         0.230769  \n",
+       "4         0.333333  "
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "def get_readability(text):\n",
+    "    return textstat.automated_readability_index(text)\n",
+    "\n",
+    "def get_difficult_words(text):\n",
+    "    return textstat.difficult_words(text) / len(text.split())\n",
+    "\n",
+    "df['readability'] = df['text'].apply(get_readability)\n",
+    "df['difficult_words'] = df['text'].apply(get_difficult_words)\n",
+    "\n",
+    "\n",
+    "df[['text', 'readability', 'difficult_words']].head()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.hist(df['text_length'], bins=20, alpha=0.7)\n",
+    "plt.title('Text Length Distribution')\n",
+    "plt.xlabel('Text Length')\n",
+    "plt.ylabel('Count')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.hist(df['word_count'], bins=20, alpha=0.7)\n",
+    "plt.title('Word Count Distribution')\n",
+    "plt.xlabel('Word Count')\n",
+    "plt.ylabel('Count')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHHCAYAAABeLEexAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPh5JREFUeJzt3QmcTnX///HPjGHsuzGU/ZZ9C0lKiYy13IlEbmriruxbcRchpZQlsqTbVulW3UVRkVBkHWRnUEJk1I0ZS8Z2/o/P9/c41/+6rhljaWaua+b7ej4ex8x1zplzvtcyznu+2wlxHMcRAAAAi4UGugAAAACBRiACAADWIxABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIQlO677z6zZFbfffedhISEyH//+990O+fw4cPNOQPx/qX38+3atauULl06Xc6FzIFABCtMmTLF/Gdcr169QBclqFSuXFlq1KiRZP38+fPN63Xvvfcm2TZz5kyz7ZtvvpFgoBe9Vq1aSbD68MMPZcKECal+3NmzZ5v3wV2yZ88uxYsXl6ioKJk4caKcPn06Vc5z9OhRE6S2bNkiwSaYy4aMh0AEK8ydO9dcODds2CD79+8PdHGCxt133y07duyQ+Ph4n/WrV6+WsLAwiYmJkYsXLybZliVLFqlfv346lzZjSqtA5Bo5cqS8//77MnXqVOnVq5dZ17dvX6lWrZps27bNZ98XX3xR/vzzzxsOHSNGjLjh0KGBOa1Dc0ple/fddyU2NjZNz4/MhUCETO/AgQOyZs0aGTdunBQpUsSEo/R25coVOX/+vARjINKy6evjH3rat29vLp6bNm3y2fbDDz9I9erVJU+ePH/p3GfPnv1LP4//07x5c3n88cfliSeekCFDhsiSJUvk22+/lePHj8uDDz7oE4A05GpNUlo6d+6c+ZotWzazBErWrFklPDw8YOdHxkMgQqanAahAgQLSsmVLeeSRR3wCkdZ+FCxY0FxM/CUkJJiLx8CBAz3rEhMT5aWXXpK//e1v5j/bEiVKyHPPPWfWe9MmjJ49e5pzValSxey7ePFis+3NN9+Uu+66SwoVKiQ5cuSQ2rVrJ9uvQi9kvXv3lsKFC5vwoRe3I0eOmGNrM4E3Xf/kk09K0aJFzbn0nNq0dT2ByA1ALg1umzdvlocffljKli3rs+3333+XvXv3en5O/fjjj+ainDdvXsmdO7c0btxY1q1bl2zzzvfffy/PPvusREREyK233urZPn36dClXrpx5Pe644w5ZtWqVpLYPPvjAvNZ6Dn3PO3ToIIcPH/bZR/u8VK1aVXbt2iWNGjWSnDlzyi233CJjxoxJcryDBw+a9yRXrlzm+fTr18+EEX2e2l/GPd6XX35p9nWbtvz7tWggfeWVV8zroZ83ff3+ai3m/fffL0OHDjXn1eedUh+ipUuXmvczf/785v2rUKGC/Otf/zLb9HnUrVvXfK+/I+5z0PfT+/XS0NywYUPzerk/e7U+YJcvXzb7REZGmtdOX0P/90FfI+0D5M/7mNcqW3J9iDSEDxgwwPze6u+JPlf9fXQcJ9nf3wULFpjn5/5Oub/DyJzCAl0AIK1pKNGLu/61+thjj5mmBW0K0v9M9a/Iv//97/LZZ5/JO++84/MXrf5nqEFHL5zuhUv/89Yaku7du0ulSpVk+/btMn78eBMSdH9vy5cvl48//tj8x6qhxv3P+a233jLH6dSpk1y4cEHmzZsn7dq1k0WLFpnQ5tL/0PXnO3fuLHfeeacJE97bXXFxcWa7+5+41oJ9/fXXEh0dbUKdNp9cjQYe7Xeiz8mlr42WS0ObLhqI9CKi3JokNxDt3LlT7rnnHhOGNBjq66mvo160tLz+fbY0DGn5hg0b5qkhmjFjhvzzn/8059Ky/vzzz+b10dCiF67UoIFDA4LWej311FMm2E2aNMlcxDXQaRhwnTx5Upo1a2Y+M7q/htXnn3/eNEFp8FNadg0dv/32m/Tp08dc3LVpbMWKFT7nfeGFF0xz5K+//mo+J0pDh7fXXntNQkNDTfDWfTV86Wdj/fr1f+k56+dGg4c2W3Xr1i3ZffT90/5XWuOnTW964dcw5oZg/Yzren2/9DOv77XS98r1v//9z7wu+nuiNVUayq/1XuhnVV9TrcXS5sQmTZqYZi8Nq9fresrmTUOPfq70PdLfjZo1a5oAO2jQIPMHhfv+uPR3Qv9f0M+s/kGi/bLatm0rhw4dMn/MIBNygExs48aN+qefs3TpUvP4ypUrzq233ur06dPHs8+SJUvMPgsXLvT52RYtWjhly5b1PH7//fed0NBQZ9WqVT77TZs2zfz86tWrPev0se67c+fOJGU6d+6cz+MLFy44VatWde6//37Puk2bNplj9O3b12ffrl27mvUvvfSSZ110dLRTrFgx548//vDZt0OHDk6+fPmSnM9fu3btnBw5cphyqNGjRztlypQx30+ZMsWJiIjw7Dtw4EBz/iNHjpjHbdq0cbJly+b89NNPnn2OHj3q5MmTx2nYsKFn3axZs8zP3X333c6lS5d8nrsev2bNmk5iYqJn/fTp083+9957r3MtpUqVclq2bHnV7b/88ouTJUsW55VXXvFZv337dicsLMxnvZ5Pz/vee+951mm5IiMjnbZt23rWjR071uy3YMECz7o///zTqVixolm/YsUKz3otm5bRn+6j+1aqVMnnub/11ltmvZYvJe5rGhMTc9V99P2vVauW57F+brz/2x8/frx5/Pvvv1/1GHp83UfP5899vfR3ILlt3u+f+3xvueUWJyEhwbP+448/Nuv1ebv09erSpcs1j5lS2fTnvV93fa9031GjRvns98gjjzghISHO/v37Pet0P/1ce6/bunWrWT9p0qSrvFLI6GgyQ6avHdK/WLX5Q+lfpo8++qipldGqe6V/6WsNzkcffeRTS6BNCbqv65NPPjF/lVasWFH++OMPz6I/r/xrB3SElo7i8uf9V7CeR2sF9K9bbaZyuVXz+tepN7fTrEv/7/7000+ldevW5nvvculoIz2293GTo7U93n2FtHbA/Su7QYMG5q/4ffv2ebaVKVPG1Crp66e1D23atDE1Ta5ixYpJx44dzV/YWkPlTWsqtEO2a+PGjeb4Tz/9tE/tnNaO5cuXT1KD/pWvtXta2+P9+mitTvny5ZO8b1qDozUdLi2XNuNpzZX3+6NNaVrj4NLmrqvVxKREm3u8n7tb0+F9vpulzyWl0WZuzdjnn39uXqObobVKyTU5X80//vEPn/5n2oytn5mvvvpK0pIeXz972gztTWs/9XdHa1W9aa2VNuO6tBZNa0JT431BcCIQIdPSC7YGHw1D2rFamwJ00WYcbWZatmyZp6OpVoXrRcHtC6QXUe1f5B2INBRoE4M2+Xgvt912m9muF3ZvGhySo01j2sSlF1BtFtJjaDOe90gv7fuhzSj+x9C+S9606efUqVOmD45/udyLlH+5UupHpBcGbRbTIKS0/4ReBHSb9i3S0OTur+fWDrTaD8OfBke9wPr3DfF/Pvo8lQYTb9r05h2y/gp93/R56Tn8X6Pdu3cneX20L49/Pxvtg6bh1bvcerH038///bkeJUuWTHIu5X2+m3XmzJkUO7/r51vfa21G1D8ctNlLm2lvJBxpMLyRztP+77W+hvq6/fLLL5KW9D3TIO//euhn1d2e0vuS3OcAmQt9iJBpaR8e7eOhoUiX5GqPmjZtar7XC4H2fdG/ErXGQy8KWhPkPUePXiS0H4mOVkuOf3+X5PpDaGdhrVXQvis6N5L+ZawX/1mzZpk+KDfKvXBpjUaXLl2S3Uf/sk2JPke9SGiNTosWLeTEiROeGiINZRogdZsGAO1b5N2h+kbdSB+R1KKvkV509b31rp1y+ffpSW4f5d/xNrWk1fm035KG7JRCmr4fK1euNLVk2vlba760plRrPbX272pl8z9Garva5JH6R871lCk1pPfnAIFHIEKmpYFHR/9Mnjw5yTatAdLJB6dNm2b+Q9eAouFELwZ6wdcwpR1ivWkg2Lp1qxkFdLOz/WrzltYMaWdO7yHBGoi8lSpVylzItWbL+y9q/9FHWsuhYUYvFFrFf7P/8WuNldYCafDRGiENfi4NR/q6uBdWNxDpuXVUUXJzvezZs8eEqWt1itbn6dbiuE2PSmvn9LknN2nkjdL3TS9iWjvl1ub9VVpuHYmmx/X+LCQ3Oiy9Zob2p3MTKW06TYm+T/qZ1kXD/quvvmo++xqS9DOV2uV3m19d+hrq6+Yd3LUmRms+/WktjnfN4Y2UTd8znY5AmxC9a4n0s+puh91oMkOmpH1iNPToCBrto+C/6Ggs/Y/xiy++8FwUdP3ChQvNheTSpUs+zWVK+6DoaBSd8C25813PvDoaPvQ/cbf/ktKmAv8Rau5FTGuRvOnIKP/jaXOfBi2dYNGfNmtdDw05uq8GM60R0tfDOxBp6NEmRR1d4zYx6Lm1hk3Xezd3aHOk1nbpMTVcpaROnTomWGkw1donlw6dTu6CeDN0tJiWVSfw8//rXh/rKKkbpe+Pfhbcz4/SJsXkPhs6tNx/4su0poH+5ZdfNiFQR6xdjdYG+tPRV8ptPtbyq9R6P9577z2ffk06ik9rct0RfG6I1akbvD8T2tTs3wR7I2XT2k/9vXv77bd91uvoMv2d9D4/7EQNETIlvVDpf7renV69aY2IO0mjG3z0qwYOnWdIa0jcC7/3MGZtStMOwPrXs/a90P9g9S9MXa+1PnqBT4kOm9e/wnVYt3Y81v4rWoOltS/eswrrfDkadHRIsl6w3WH3Orzf/y9jHbat5dEgo516tSO3Xui0M7X+RZzcRc+fW+uzdu3aJHMcuUP69QKlnbe9zz1q1CjPPDbaAVz7Y2nTo15Mk5u7x582F+oxdNi91hDpe6A1QxrMbqQPkdYw6HH81apVy7zmuk0nLdTgpk2iWkOg59FaQh2y7T3X1PXQ8uqFVadx0GH3WruonyV30kPv10jfS61h69+/v5nqQZvo9HVMLdoUqJ9BDfEaRjUM6XuiNR76e5DSRIw6bF2bzPQ10v3186ghXPtRuZ8JDSfa+VpDq75uGkL0s3a1PnLXov3m9Njax03Lq59x/fx7d0jXPk0alPT3RP8Q+emnn8x8St6dnG+0bPqaa39Crf3Sz4HWPmqzoAZ6ne7B/9iwUKCHuQFpoXXr1k727Nmds2fPXnUfHcKeNWtWz3B1HZJfokSJZIfmeg8Tf/31150qVao44eHhToECBZzatWs7I0aMcOLj4z376TF69OiR7DFmzJjhlC9f3vy8DtPWIcP+w6GVll2PUbBgQSd37txmiHtsbKzZ77XXXvPZNy4uzuyr5dfnpMPEGzdubIavXw89lw5B12N/8803SbZXr17dbNPn7m/z5s1OVFSUKWPOnDmdRo0aOWvWrLmhIeI6vF+H+utrUqdOHWflypVJhlhfjQ6t1mMnt+iUBK5PP/3UDPvPlSuXWfS119dMX1OXnk/f22sN4VY///yzGVKvUxYUKVLEGTBggDmHnnfdunWe/c6cOeN07NjRyZ8/v9nmHscdhv7JJ5/4HPfAgQNXHUqe3GvqLjpMXN/3Bx54wAxh9x7a7vL/nC1btsx56KGHnOLFi5uf16+PPfaYs3fvXp+f+/zzz53KlSt7PiNu2a72eqU07P4///mPM2TIEDPdgr52+hoePHgwyc/r1AY6RF8/Ew0aNDBTaCT3mbha2ZJ7z06fPu3069fPPE/9PdHfwzfeeMP87nu72u/v1aYDQOYQov8EOpQBuD46eZ3Weuhfyyk1hSAwtLZDZ6zWDs06+gpAxkEfIiBIJXcTTr3gav8e7QSO4Hp/tA+RNhdqJ3jCEJDx0IcICFLaB0fn/dF+D9o3R/uK6KJ9XlLrlhb4a521da4a7YSsnaa11k778gTi5sEA/jqazIAgpR1jdWSUDu/WCfb04qsdu7VTqAYkBJbW1v373/82HXS1c712Ztf7ufmPTgSQMRCIAACA9ehDBAAArEcgAgAA1qMjwnXQWygcPXrUTPwVqGn4AQDAjdFeQTpJr97Y13sG/uQQiK6DhiFG9QAAkDHpbV90BvaUEIiug3sjQH1Br3VvJgAAEBwSEhJMhYb3DX2vhkB0HdxmMg1DBCIAADKW6+nuQqdqAABgPQIRAACwHoEIAABYj0AEAACsRyACAADWIxABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIAANYjEAEAAOsRiAAAgPXCAl0AwF/07Jg0Oe6MrnXT5LgAgIyPGiIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIAANYjEAEAAOsRiAAAgPUIRAAAwHoEIgAAYD0CEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgPQIRAACwXkAD0cqVK6V169ZSvHhxCQkJkQULFlx136efftrsM2HCBJ/1J06ckE6dOknevHklf/78Eh0dLWfOnPHZZ9u2bXLPPfdI9uzZpUSJEjJmzJg0e04AACDjCWggOnv2rNSoUUMmT56c4n7z58+XdevWmeDkT8PQzp07ZenSpbJo0SITsrp37+7ZnpCQIE2bNpVSpUrJpk2b5I033pDhw4fL9OnT0+Q5AQCAjCcskCdv3ry5WVJy5MgR6dWrlyxZskRatmzps2337t2yePFiiYmJkTp16ph1kyZNkhYtWsibb75pAtTcuXPlwoULMnPmTMmWLZtUqVJFtmzZIuPGjfMJTgAAwF5B3YfoypUr0rlzZxk0aJAJMv7Wrl1rmsncMKSaNGkioaGhsn79es8+DRs2NGHIFRUVJbGxsXLy5Mlkz5uYmGhqlrwXAACQeQV1IHr99dclLCxMevfunez2Y8eOSUREhM863b9gwYJmm7tP0aJFffZxH7v7+Bs9erTky5fPs2i/IwAAkHkFbSDS/j5vvfWWzJ4923SmTk9DhgyR+Ph4z3L48OF0PT8AAEhfQRuIVq1aJcePH5eSJUuaWh9dDh48KAMGDJDSpUubfSIjI80+3i5dumRGnuk2d5+4uDiffdzH7j7+wsPDzag17wUAAGReQRuItO+QDpfXDtDuop2ktT+RdrBW9evXl1OnTpnaJNfy5ctN36N69ep59tGRZxcvXvTsoyPSKlSoIAUKFAjAMwMAAMEmoKPMdL6g/fv3ex4fOHDABB/tA6Q1Q4UKFfLZP2vWrKZWR8OMqlSpkjRr1ky6desm06ZNM6GnZ8+e0qFDB88Q/Y4dO8qIESPM/ETPP/+87NixwzTFjR8/Pp2fLQAACFYBDUQbN26URo0aeR7379/ffO3SpYvpO3Q9dFi9hqDGjRub0WVt27aViRMnerZrp+hvvvlGevToIbVr15bChQvLsGHDGHIPAAA8QhzHcf7/QyRHh91rsNIO1vQnSnvRs2PS5LgzutZNk+MCADL+9Tto+xABAACkFwIRAACwHoEIAABYj0AEAACsRyACAADWIxABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIAANYjEAEAAOsRiAAAgPUIRAAAwHoEIgAAYD0CEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgPQIRAACwHoEIAABYj0AEAACsRyACAADWIxABAADrhQW6AEB6iZ4dk2bHntG1bpodGwCQ9qghAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgvYAGopUrV0rr1q2lePHiEhISIgsWLPBsu3jxojz//PNSrVo1yZUrl9nnH//4hxw9etTnGCdOnJBOnTpJ3rx5JX/+/BIdHS1nzpzx2Wfbtm1yzz33SPbs2aVEiRIyZsyYdHuOAAAg+AU0EJ09e1Zq1KghkydPTrLt3LlzsnnzZhk6dKj5+tlnn0lsbKw8+OCDPvtpGNq5c6csXbpUFi1aZEJW9+7dPdsTEhKkadOmUqpUKdm0aZO88cYbMnz4cJk+fXq6PEcAABD8QhzHcSQIaA3R/PnzpU2bNlfdJyYmRu644w45ePCglCxZUnbv3i2VK1c26+vUqWP2Wbx4sbRo0UJ+/fVXU6s0depUeeGFF+TYsWOSLVs2s8/gwYNNbdSePXuuq2waqvLlyyfx8fGmJgoZd76gtMI8RAAQfG7k+p2h+hDpE9LgpE1jau3ateZ7NwypJk2aSGhoqKxfv96zT8OGDT1hSEVFRZnappMnTyZ7nsTERPMiei8AACDzyjCB6Pz586ZP0WOPPeZJeVrrExER4bNfWFiYFCxY0Gxz9ylatKjPPu5jdx9/o0ePNonSXbTfEQAAyLwyRCDSDtbt27cXbd3TJrC0NmTIEFMb5S6HDx9O83MCAIDACcsoYUj7DS1fvtynDTAyMlKOHz/us/+lS5fMyDPd5u4TFxfns4/72N3HX3h4uFkAAIAdQjNCGNq3b598++23UqhQIZ/t9evXl1OnTpnRYy4NTVeuXJF69ep59tGRZ3osl45Iq1ChghQoUCAdnw0AAAhWAQ1EOl/Qli1bzKIOHDhgvj906JAJMI888ohs3LhR5s6dK5cvXzZ9fnS5cOGC2b9SpUrSrFkz6datm2zYsEFWr14tPXv2lA4dOpgRZqpjx46mQ7XOT6TD8z/66CN56623pH///oF86gAAIIgEdNj9d999J40aNUqyvkuXLmauoDJlyiT7cytWrJD77rvPfK/NYxqCFi5caEaXtW3bViZOnCi5c+f2mZixR48eZnh+4cKFpVevXqaD9vVi2H36Ytg9ACA13Mj1O6B9iDTUpJTHrier6YiyDz/8MMV9qlevLqtWrbqpMgIAgMwvqPsQAQAApAcCEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgPQIRAACwHoEIAABYj0AEAACsRyACAADWIxABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIAANYjEAEAAOsRiAAAgPUIRAAAwHoEIgAAYD0CEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgPQIRAACwHoEIAABYj0AEAACsF9BAtHLlSmndurUUL15cQkJCZMGCBT7bHceRYcOGSbFixSRHjhzSpEkT2bdvn88+J06ckE6dOknevHklf/78Eh0dLWfOnPHZZ9u2bXLPPfdI9uzZpUSJEjJmzJh0eX4AACBjCGggOnv2rNSoUUMmT56c7HYNLhMnTpRp06bJ+vXrJVeuXBIVFSXnz5/37KNhaOfOnbJ06VJZtGiRCVndu3f3bE9ISJCmTZtKqVKlZNOmTfLGG2/I8OHDZfr06enyHAEAQPALC+TJmzdvbpbkaO3QhAkT5MUXX5SHHnrIrHvvvfekaNGipiapQ4cOsnv3blm8eLHExMRInTp1zD6TJk2SFi1ayJtvvmlqnubOnSsXLlyQmTNnSrZs2aRKlSqyZcsWGTdunE9wAgAA9graPkQHDhyQY8eOmWYyV758+aRevXqydu1a81i/ajOZG4aU7h8aGmpqlNx9GjZsaMKQS2uZYmNj5eTJk8meOzEx0dQseS8AACDzCtpApGFIaY2QN33sbtOvERERPtvDwsKkYMGCPvskdwzvc/gbPXq0CV/uov2OAABA5hW0gSiQhgwZIvHx8Z7l8OHDgS4SAACwMRBFRkaar3FxcT7r9bG7Tb8eP37cZ/ulS5fMyDPvfZI7hvc5/IWHh5tRa94LAADIvII2EJUpU8YElmXLlnnWaV8e7RtUv35981i/njp1yowecy1fvlyuXLli+hq5++jIs4sXL3r20RFpFSpUkAIFCqTrcwIAAMEpoKPMdL6g/fv3+3Sk1hFg2geoZMmS0rdvXxk1apSUL1/eBKShQ4eakWNt2rQx+1eqVEmaNWsm3bp1M0PzNfT07NnTjEDT/VTHjh1lxIgRZn6i559/Xnbs2CFvvfWWjB8/PmDPOzOInh0T6CIAAJA5AtHGjRulUaNGnsf9+/c3X7t06SKzZ8+W5557zsxVpMPjtSbo7rvvNsPsdYJFlw6r1xDUuHFjM7qsbdu2Zu4il3aK/uabb6RHjx5Su3ZtKVy4sJnskSH3AADAFeLohD9IkTbVabDSDtb0J/o/1BD5mtG1bqCLAAD4C9fvoO1DBAAAkF4IRAAAwHoEIgAAYD0CEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgPQIRAACwHoEIAABYj0AEAACsRyACAADWIxABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIAANYjEAEAAOsRiAAAgPVuKhCVLVtW/ve//yVZf+rUKbMNAAAg0weiX375RS5fvpxkfWJiohw5ciQ1ygUAAJBuwm5k5y+++MLz/ZIlSyRfvnyexxqQli1bJqVLl07dEgIAAARTIGrTpo35GhISIl26dPHZljVrVhOGxo4dm7olBAAACKZAdOXKFfO1TJkyEhMTI4ULF06rcgEAAARnIHIdOHAg9UsCAACQkQKR0v5Cuhw/ftxTc+SaOXNmapQNAAAgeAPRiBEjZOTIkVKnTh0pVqyY6VMEAABgVSCaNm2azJ49Wzp37pz6JQIAAMgI8xBduHBB7rrrrtQvDQAAQEYJRE899ZR8+OGHqV8aAACAjBKIzp8/L+PGjZN7771XevXqJf379/dZUotO9jh06FAzzD9HjhxSrlw5efnll8VxHM8++v2wYcNMXybdp0mTJrJv3z6f45w4cUI6deokefPmlfz580t0dLScOXMm1coJAAAs7EO0bds2qVmzpvl+x44dPttSs4P166+/LlOnTpU5c+ZIlSpVZOPGjfLEE0+YGbJ79+5t9hkzZoxMnDjR7KPBSQNUVFSU7Nq1S7Jnz2720TD022+/ydKlS+XixYvmGN27d6eWCwAAGCGOd3VLkGnVqpUULVpUZsyY4VnXtm1bUxP0wQcfmNqh4sWLy4ABA2TgwIFme3x8vPkZ7fTdoUMH2b17t1SuXNlMJKmj4tTixYulRYsW8uuvv5qfv5aEhAQTwvTYWssEkejZMYEuQlCZ0bVuoIsAAPgL1++bajJLL9pxW+c62rt3r3m8detW+eGHH6R58+aeCSKPHTtmmslc+sTr1asna9euNY/1qzaTuWFI6f6hoaGyfv36ZM+rN6nVF9F7AQAAmddNNZk1atQoxaax5cuXS2oYPHiwCSMVK1aULFmymD5Fr7zyimkCUxqGlNYIedPH7jb9GhER4bM9LCxMChYs6NnH3+jRo81cSwAAwA43FYjc/kMu7ZezZcsW05/I/6avf8XHH38sc+fONX19tA+RnqNv376mmSs1z+NvyJAhPp3DNZSVKFEizc4HAAAyYCAaP358suuHDx+eqqO3Bg0aZGqJtC+Qqlatmhw8eNDU4GggioyMNOvj4uLMKDOXPnZDm+6jtxfxdunSJTPyzP15f+Hh4WYBAAB2SNU+RI8//niq3sfs3Llzpq+PN206c++dpqPKNNRoPyPv2hztG1S/fn3zWL+eOnVKNm3a5NOkp8fQvkYAAAA3fXPX5GgHZneoe2po3bq16TNUsmRJ02T2448/mvmPnnzySbNd+zFpE9qoUaOkfPnynmH32qTWpk0bs0+lSpWkWbNm0q1bN3PLEW3e69mzp6l1up4RZgAAIPO7qUD08MMP+zzW4e86z4/OE6SBJLVMmjTJHO/ZZ581zV4aYP75z3+aiRhdzz33nJw9e9bMK6Q1QXfffbcZVu8dzLQfkoagxo0bmxonHbqvcxcBAADc9DxEOrGhNw0ZRYoUkfvvv1+aNm2a6V5Z5iFKinmIfDEPEQBk7Ov3TdUQzZo162bLBgAAkLn6EGlHZZ0JWmkfn1q1aqVWuQAAAII7EGl/Hu2U/N1335lZoJX239EJG+fNm2eazwAAADL1sHu9w/3p06dl586dZj4fXXRSRm2rc2+6CgAAkKlriHQU17fffmuGtLv0BqqTJ0/OlJ2qAQBA5nZTNUQ6qWHWrFmTrNd17qSJAAAAmToQ6fD6Pn36yNGjRz3rjhw5Iv369TNz/QAAAGT6QPT222+b/kKlS5eWcuXKmUVnidZ1OpkiAABApu9DpHd+37x5s+lHtGfPHrNO+xM1adIktcsHAAAQXDVEelNU7TytNUF6H7EHHnjAjDjTpW7dumYuolWrVqVdaQEAAAIdiCZMmGBukprc9Nc6NbbeZ0xvvgoAAJBpA9HWrVvNneOvRofc6+zVAAAAmTYQxcXFJTvc3hUWFia///57apQLAAAgOAPRLbfcYmakvppt27ZJsWLFUqNcAAAAwRmIWrRoIUOHDpXz588n2fbnn3/KSy+9JK1atUrN8gEAAATXsPsXX3xRPvvsM7ntttukZ8+eUqFCBbNeh97rbTsuX74sL7zwQlqVFQAAIPCBqGjRorJmzRp55plnZMiQIeI4jlmvQ/CjoqJMKNJ9AAAAMvXEjKVKlZKvvvpKTp48Kfv37zehqHz58lKgQIG0KSEAAEAwzlStNADpZIwAAABW3ssMAAAgMyEQAQAA6xGIAACA9QhEAADAegQiAABgPQIRAACwHoEIAABYj0AEAACsRyACAADWIxABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKwXFugCAJlB9OyYNDnujK510+S4AIAMVkN05MgRefzxx6VQoUKSI0cOqVatmmzcuNGz3XEcGTZsmBQrVsxsb9Kkiezbt8/nGCdOnJBOnTpJ3rx5JX/+/BIdHS1nzpwJwLMBAADBKKgD0cmTJ6VBgwaSNWtW+frrr2XXrl0yduxYKVCggGefMWPGyMSJE2XatGmyfv16yZUrl0RFRcn58+c9+2gY2rlzpyxdulQWLVokK1eulO7duwfoWQEAgGAT4mgVS5AaPHiwrF69WlatWpXsdi168eLFZcCAATJw4ECzLj4+XooWLSqzZ8+WDh06yO7du6Vy5coSExMjderUMfssXrxYWrRoIb/++qv5+WtJSEiQfPnymWNrLRPSrokIvmgyA4CbdyPX76CuIfriiy9MiGnXrp1ERERIrVq15N133/VsP3DggBw7dsw0k7n0iderV0/Wrl1rHutXbSZzw5DS/UNDQ02NUnISExPNi+i9AACAzCuoA9HPP/8sU6dOlfLly8uSJUvkmWeekd69e8ucOXPMdg1DSmuEvOljd5t+1TDlLSwsTAoWLOjZx9/o0aNNsHKXEiVKpNEzBAAAwSCoA9GVK1fk9ttvl1dffdXUDmm/n27dupn+QmlpyJAhpnrNXQ4fPpym5wMAAIEV1IFIR45p/x9vlSpVkkOHDpnvIyMjzde4uDifffSxu02/Hj9+3Gf7pUuXzMgzdx9/4eHhpq3RewEAAJlXUAciHWEWGxvrs27v3r1SqlQp832ZMmVMqFm2bJlnu/b30b5B9evXN4/166lTp2TTpk2efZYvX25qn7SvEQAAQFBPzNivXz+56667TJNZ+/btZcOGDTJ9+nSzqJCQEOnbt6+MGjXK9DPSgDR06FAzcqxNmzaeGqVmzZp5mtouXrwoPXv2NCPQrmeEGQAAyPyCOhDVrVtX5s+fb/r0jBw50gSeCRMmmHmFXM8995ycPXvW9C/SmqC7777bDKvPnj27Z5+5c+eaENS4cWMzuqxt27Zm7iIAAICgn4coWDAPUVLMQ5Q+mIcIAG5eppmHCAAAID0QiAAAgPUIRAAAwHoEIgAAYD0CEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgPQIRAACwHoEIAABYj0AEAACsRyACAADWIxABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIAANYjEAEAAOsRiAAAgPUIRAAAwHoEIgAAYD0CEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgvQwViF577TUJCQmRvn37etadP39eevToIYUKFZLcuXNL27ZtJS4uzufnDh06JC1btpScOXNKRESEDBo0SC5duhSAZwAAAIJRhglEMTEx8s4770j16tV91vfr108WLlwon3zyiXz//fdy9OhRefjhhz3bL1++bMLQhQsXZM2aNTJnzhyZPXu2DBs2LADPAgAABKMMEYjOnDkjnTp1knfffVcKFCjgWR8fHy8zZsyQcePGyf333y+1a9eWWbNmmeCzbt06s88333wju3btkg8++EBq1qwpzZs3l5dfflkmT55sQhIAAECGCETaJKa1PE2aNPFZv2nTJrl48aLP+ooVK0rJkiVl7dq15rF+rVatmhQtWtSzT1RUlCQkJMjOnTuTPV9iYqLZ7r0AAIDMK0yC3Lx582Tz5s2myczfsWPHJFu2bJI/f36f9Rp+dJu7j3cYcre725IzevRoGTFiRCo+CwAAEMyCuobo8OHD0qdPH5k7d65kz5493c47ZMgQ0xznLloOAACQeQV1INImsePHj8vtt98uYWFhZtGO0xMnTjTfa02P9gM6deqUz8/pKLPIyEjzvX71H3XmPnb38RceHi558+b1WQAAQOYV1IGocePGsn37dtmyZYtnqVOnjulg7X6fNWtWWbZsmednYmNjzTD7+vXrm8f6VY+hwcq1dOlSE3IqV64ckOcFAACCS1D3IcqTJ49UrVrVZ12uXLnMnEPu+ujoaOnfv78ULFjQhJxevXqZEHTnnXea7U2bNjXBp3PnzjJmzBjTb+jFF180HbW1JggAACCoA9H1GD9+vISGhpoJGXV0mI4gmzJlimd7lixZZNGiRfLMM8+YoKSBqkuXLjJy5MiAlhsAAASPEMdxnEAXItjpsPt8+fKZDtb0J/o/0bOTjvpD6pvRtW6giwAAVly/g7oPEQAAQHogEAEAAOsRiAAAgPUIRAAAwHoEIgAAYD0CEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgPQIRAACwHoEIAABYj0AEAACsRyACAADWIxABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIAANYjEAEAAOsRiAAAgPXCAl0AAFcXPTsmzY49o2vdNDs2AGQ01BABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKwX1IFo9OjRUrduXcmTJ49ERERImzZtJDY21mef8+fPS48ePaRQoUKSO3duadu2rcTFxfnsc+jQIWnZsqXkzJnTHGfQoEFy6dKldH42AAAgWAV1IPr+++9N2Fm3bp0sXbpULl68KE2bNpWzZ8969unXr58sXLhQPvnkE7P/0aNH5eGHH/Zsv3z5sglDFy5ckDVr1sicOXNk9uzZMmzYsAA9KwAAEGxCHMdxJIP4/fffTQ2PBp+GDRtKfHy8FClSRD788EN55JFHzD579uyRSpUqydq1a+XOO++Ur7/+Wlq1amWCUtGiRc0+06ZNk+eff94cL1u2bNc8b0JCguTLl8+cL2/evGn+PG2fQRnpg5mqAWR2CTdw/Q7qGiJ/+oRUwYIFzddNmzaZWqMmTZp49qlYsaKULFnSBCKlX6tVq+YJQyoqKsq8SDt37kz35wAAAIJPhrmX2ZUrV6Rv377SoEEDqVq1qll37NgxU8OTP39+n301/Og2dx/vMORud7clJzEx0SwuDU8AACDzyjA1RNqXaMeOHTJv3rx06cytVWzuUqJEiTQ/JwAACJwMEYh69uwpixYtkhUrVsitt97qWR8ZGWk6S586dcpnfx1lptvcffxHnbmP3X38DRkyxDTPucvhw4fT4FkBAIBgEdSBSPt7axiaP3++LF++XMqUKeOzvXbt2pI1a1ZZtmyZZ50Oy9dh9vXr1zeP9ev27dvl+PHjnn10xJp2rqpcuXKy5w0PDzfbvRcAAJB5hQV7M5mOIPv888/NXERunx9txsqRI4f5Gh0dLf379zcdrTW49OrVy4QgHWGmdJi+Bp/OnTvLmDFjzDFefPFFc2wNPpkZI8EAAMgEgWjq1Knm63333eezftasWdK1a1fz/fjx4yU0NNRMyKgdoXUE2ZQpUzz7ZsmSxTS3PfPMMyYo5cqVS7p06SIjR45M52cDAACCVYaahyhQMuo8RNQQISXMQwQgs0vIrPMQAQAApAUCEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAADAegQiAABgPQIRAACwHoEIAABYj0AEAACsRyACAADWIxABAADrEYgAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIAANYjEAEAAOsRiAAAgPXCAl0AAIERPTsmTY47o2vdNDkuAKQlaogAAID1CEQAAMB6BCIAAGA9AhEAALAegQgAAFiPQAQAAKxHIAIAANYjEAEAAOsRiAAAgPUIRAAAwHrcugNAhrgliOK2IADSCjVEAADAelYFosmTJ0vp0qUle/bsUq9ePdmwYUOgiwQAAIKANU1mH330kfTv31+mTZtmwtCECRMkKipKYmNjJSIiItM2MQCZSVr9rtAUByDEcRxHLKAhqG7duvL222+bx1euXJESJUpIr169ZPDgwSn+bEJCguTLl0/i4+Mlb968qV42AhGQeRG2gMC5keu3FU1mFy5ckE2bNkmTJk0860JDQ83jtWvXBrRsAAAg8KxoMvvjjz/k8uXLUrRoUZ/1+njPnj1J9k9MTDSLS5OlmzTTwoU/z6TJcQEEXuepKySjmdypdqCLgCDVY+6mDPW5c6/b19MYZkUgulGjR4+WESNGJFmvTWwAkNl98GygSwAbfZCGn7vTp0+bpjOxPRAVLlxYsmTJInFxcT7r9XFkZGSS/YcMGWI6YLu0v9GJEyekUKFCEhISki5ltpkmeg2fhw8fTpM+W0gdvE8ZA+9TxsD7lDa0ZkjDUPHixa+5rxWBKFu2bFK7dm1ZtmyZtGnTxhNy9HHPnj2T7B8eHm4Wb/nz50+38uL/6H8K/McQ/HifMgbep4yB9yn1XatmyKpApLTGp0uXLlKnTh254447zLD7s2fPyhNPPBHoogEAgACzJhA9+uij8vvvv8uwYcPk2LFjUrNmTVm8eHGSjtYAAMA+1gQipc1jyTWRIbhoc+VLL72UpNkSwYX3KWPgfcoYeJ8Cz5qJGQEAAKyemBEAACAlBCIAAGA9AhEAALAegQgAAFiPQISg9Nprr5lZwfv27RvooiAZR44ckccff9zM3p4jRw6pVq2abNy4MdDFghe9f+PQoUOlTJky5j0qV66cvPzyy9d1TyeknZUrV0rr1q3NzMn6f9yCBQt8tuv7o9PDFCtWzLxvehPyffv2Bay8NiEQIejExMTIO++8I9WrVw90UZCMkydPSoMGDSRr1qzy9ddfy65du2Ts2LFSoECBQBcNXl5//XWZOnWqvP3227J7927zeMyYMTJp0qRAF81qOiFwjRo1ZPLkyclu1/do4sSJMm3aNFm/fr3kypVLoqKi5Pz58+leVtsw7B5B5cyZM3L77bfLlClTZNSoUWYCTZ1VHMFj8ODBsnr1alm1alWgi4IUtGrVykw8O2PGDM+6tm3bmlqHDz74IKBlw//RGqL58+d7bimll2OtORowYIAMHDjQrIuPjzfv4+zZs6VDhw4BLnHmRg0RgkqPHj2kZcuWppoYwemLL74wt8Bp166dRERESK1ateTdd98NdLHg56677jL3a9y7d695vHXrVvnhhx+kefPmgS4aruLAgQPmTgre///pfbjq1asna9euDWjZbGDVTNUIbvPmzZPNmzebJjMEr59//tk0xej9Af/1r3+Z96t3797mJsp6v0AET02e3kG9YsWKkiVLFtOn6JVXXpFOnToFumi4Cg1Dyv+WUvrY3Ya0QyBCUDh8+LD06dNHli5dKtmzZw90cZCCK1eumBqiV1991TzWGqIdO3aYPg8EouDx8ccfy9y5c+XDDz+UKlWqyJYtW8wgBW2S4X0CkqLJDEFh06ZNcvz4cdN/KCwszCzff/+96Vyo3+tftwgOOvqlcuXKPusqVaokhw4dCliZkNSgQYNMLZH2O9FRgJ07d5Z+/frJ6NGjA100XEVkZKT5GhcX57NeH7vbkHYIRAgKjRs3lu3bt5u/Yt1FayG0el+/1yp/BAcdYRYbG+uzTvuplCpVKmBlQlLnzp2T0FDf/+L190hr+BCcdIoEDT7a98ulzZ462qx+/foBLZsNaDJDUMiTJ49UrVrVZ50ON9V5bvzXI7C0lkE77GqTWfv27WXDhg0yffp0syB46Fw32meoZMmSpsnsxx9/lHHjxsmTTz4Z6KKJ7SNp9+/f79ORWv/oK1iwoHmvtFlTR9iWL1/eBCSdS0qbOd2RaEhDOuweCEb33nuv06dPn0AXA8lYuHChU7VqVSc8PNypWLGiM3369EAXCX4SEhLM70/JkiWd7NmzO2XLlnVeeOEFJzExMdBFs9qKFSt0qpskS5cuXcz2K1euOEOHDnWKFi1qfr8aN27sxMbGBrrYVmAeIgAAYD36EAEAAOsRiAAAgPUIRAAAwHoEIgAAYD0CEQAAsB6BCAAAWI9ABAAArEcgAgA/w4cPl5o1a0pG9Msvv0hISIiZ/RjA9SMQAbimtWvXmvtgtWzZMs3PtWfPHnNBX7dunc/6O++8U7Jnzy7nz5/3rNPvdd2MGTPExtDRtWtXbukApBICEYBr0sDRq1cvWblypRw9ejRNz1WxYkVzg8vvvvvOs+706dOyefNmKVKkiE9Q0qCWmJgo999//02d6+LFi6lSZgAZH4EIwDVvRvnRRx/JM888Y2qIZs+e7dnWsWNHefTRR5OEjMKFC8t7773nCTOdOnUyN+stVqyYjB8/Xu677z5zE8uradSokU8g+uGHH+S2224zNyz1Xq/flypVytwEU02dOlXKlSsn2bJlkwoVKsj777/vc1yt1dF9HnzwQVMevfmpeu2116Ro0aLmJsPR0dE+tVA3Q+8oP3r0aFOuHDlySI0aNeS///2vT7m1LHpX8zp16kjOnDnNDXNjY2N9jqM3+YyIiDDleuqpp2Tw4MGepjxt1pszZ458/vnn5li6eL82P//8s3kd9dh6fg2PAFIQ6JupAQhuM2bMcOrUqeO5qWu5cuXMDSjVokWLnBw5cjinT5/27K/76Dq9uah66qmnnFKlSjnffvuts337dufvf/+7kydPnhRv3Ks3i82VK5dz8eJF83jQoEFOjx49nHnz5jkNGzb07HfPPfc4Xbt2Nd9/9tlnTtasWZ3Jkyebm2GOHTvWyZIli7N8+XLP/vpfXkREhDNz5kznp59+cg4ePOh89NFH5iaa//73v509e/aYG6Bq+WrUqHHV8h04cMAc68cff0x2+6hRo8xNbxcvXmzOM2vWLHOO7777zucGn/Xq1TPrdu7caZ7LXXfd5TnGBx98YG7KqmXV5zNixAgnb968nnLpa96+fXunWbNmzm+//WYWvXGrWzY9v74/+rOPPPKIeQ/c1xNAUgQiACnSi/SECRPM93pBLVy4sLmgez9+7733PPs/9thjzqOPPmq+11CkIeWTTz7xbD916pSTM2fOFAPRvn37zEV9zZo15nHdunWdjz/+2Dl69KgJFn/++adz7tw58/2cOXM85ezWrZvPcdq1a+e0aNHC81iP2bdvX5996tev7zz77LM+6zSo3GwgOn/+vHl+btld0dHR5rXxDkQaEl1ffvmlWafPzS2DhkBvDRo08CmX3iH9oYceSrZsGvBcGrh03e7du6/6nADb0WQG4Kq0CWfDhg3y2GOPmcdhYWGmicztxKyP27dvL3PnzjWPz549a5pwtInMbbbRJrQ77rjDc8x8+fKZ5qyU/O1vf5Nbb73VNAElJCTIjz/+KPfee69pcitZsqRp/nH7D2mzkNq9e7c0aNDA5zj6WNd70yYqb7q9Xr16Puvq168vN2v//v1y7tw5eeCBByR37tyeRZsQf/rpJ599q1ev7vlen5s6fvy457X3ft2U/+OUpHRsAEmFJbMOAAwNPpcuXZLixYt71mlFS3h4uLz99tsm3Gj40bCiF9ulS5eaPjPNmjX7y+fWfkYrVqwwF/by5cubvjRKz6XrtRwanEqUKHFDx9W+Q2nd50p9+eWXcsstt/hs09fNW9asWT3fax8gt/9RakjLYwOZETVEAJKlQUhrNcaOHWuGl7vL1q1bTUD6z3/+Y/bTzsAaSrTjtdYUtWvXznMxLlu2rPk+JibGc9z4+HjZu3fvNc+vNT9r1qwxIUvDkathw4am5kgXt3ZIVapUSVavXu1zDH1cuXLlFM+jP7d+/Xqfdf5D/m+Enk+Dz6FDh0xg815uJLxpLZr366b8H2vn8cuXL990WQH8f9QQAUjWokWL5OTJk2bUldYEeWvbtq2pPXr66ac9o82mTZtmgo7W3rh0dFSXLl1k0KBBUrBgQVPL89JLL0loaKin1uJqNOxoE9zMmTPl3Xff9azXGiIdcaWeffZZz3o9hzbf1apVS5o0aSILFy6Uzz77TL799tsUz9OnTx8zn482pWkTm4a6nTt3mjB3Lf6jwlSVKlVk4MCB0q9fP1Mjc/fdd5sQqOEsb9685vW4HjrNQbdu3Uy5NHRq4Ny2bZtPuUqXLi1Lliwx5ShUqFCS9wnADQh0JyYAwalVq1Y+HZK9rV+/3nTS3bp1q3m8a9cu81hHMrkj0Fzasbpjx46mo3FkZKQzbtw454477nAGDx58zTLo8fS4OoLKW+nSpc167WTtbcqUKU7ZsmVNR+7bbrvNp7O30p+ZP39+kvO88sorpnN47ty5TUfl55577ro6VSe3HD582LwG2hG9QoUKpixFihRxoqKinO+//96nU/XJkyc9x9QO2rpOj+0aOXKkp1xPPvmk07t3b+fOO+/0bD9+/LjzwAMPmO36s3rc5Dp863nc7QCSF6L/3EiAAoC/Qmt9tG+NNsVp7ROun3bU1kkr/edXAvDX0WQGIE3pCDG9HYeOkNKmo5EjR5r1Dz30UKCLFtR0pJo2Q0ZFRZnbpmifLW3+0z5VAFIfgQhAmnvzzTdNPxftBFy7dm1ZtWqVmc0aV6d9rL766iszm7bOnK2drD/99FPTPwpA6qPJDAAAWI9h9wAAwHoEIgAAYD0CEQAAsB6BCAAAWI9ABAAArEcgAgAA1iMQAQAA6xGIAACA9QhEAABAbPf/APPUDvwIz97bAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.hist(df['avg_word_length'], bins=20, alpha=0.7)\n",
+    "plt.title('Average Word Length Distribution')\n",
+    "plt.xlabel('Avg Word Length')\n",
+    "plt.ylabel('Count')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.hist(df['punctuation_count'], bins=20, alpha=0.7)\n",
+    "plt.title('Punctuation Count Distribution')\n",
+    "plt.xlabel('Punctuation Count')\n",
+    "plt.ylabel('Count')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.hist(df['richness'], bins=20, alpha=0.7)\n",
+    "plt.title('Richness Distribution')\n",
+    "plt.xlabel('Richness')\n",
+    "plt.ylabel('Count')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.hist(df['readability'], bins=20, alpha=0.7)\n",
+    "plt.title('Readability Distribution')\n",
+    "plt.xlabel('Readability')\n",
+    "plt.ylabel('Count')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "correlation = df['avg_word_length'].corr(df['humor_rating'])\n",
+    "\n",
+    "\n",
+    "plt.figure(figsize=(6, 6))\n",
+    "\n",
+    "sc = plt.scatter(df['avg_word_length'], df['humor_rating'], alpha=0.5, c=df['humor_rating'], cmap='viridis')\n",
+    "\n",
+    "\n",
+    "plt.title(f'Avg Word Length vs Humor Rating (Correlation: {correlation:.2f})')\n",
+    "plt.xlabel('Avg Word Length')\n",
+    "plt.ylabel('Humor Rating')\n",
+    "\n",
+    "plt.colorbar(sc, label='Humor Rating')\n",
+    "\n",
+    "\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "id                   0.020462\n",
+      "is_humor                  NaN\n",
+      "humor_rating         1.000000\n",
+      "humor_controversy    0.173650\n",
+      "offense_rating      -0.308529\n",
+      "text_length          0.073611\n",
+      "word_count           0.093041\n",
+      "avg_word_length     -0.090018\n",
+      "punctuation_count    0.057945\n",
+      "stopword_ratio       0.105719\n",
+      "richness            -0.065616\n",
+      "readability         -0.060221\n",
+      "difficult_words     -0.099532\n",
+      "Name: humor_rating, dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "numeric_df = df.select_dtypes(include=[np.number])\n",
+    "print(numeric_df.corr()['humor_rating'])\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}