Upload 25 files

.env

@@ -0,0 +1 @@
+TOGETHER_API_KEY=tgp_v1_ZtXpkMMiL0mcxIemzOwQgXn53Oc5Z7UvEwkusgTqtXQ

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+classification_report.png filter=lfs diff=lfs merge=lfs -text
+confusion_matrix.png filter=lfs diff=lfs merge=lfs -text
+precision_recall_curve.png filter=lfs diff=lfs merge=lfs -text
+ui.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.pyc
+.env
+.env.local
+.env.*.local
+.vscode/
+.idea/
+.DS_Store
+
+# Model files
+saved_model/
+*.pth
+intent_classifier.pth
+
+

complexity_Score_finetuned.py

@@ -0,0 +1,273 @@
+<<<<<<< HEAD
+import torch
+import random
+import numpy as np
+from tqdm import tqdm
+from datasets import load_dataset
+from transformers import DistilBertTokenizerFast, DistilBertForSequenceClassification
+from torch.utils.data import DataLoader
+from transformers import AdamW
+from sklearn.metrics import r2_score, f1_score, mean_absolute_error
+
+# Set random seed for reproducibility
+torch.manual_seed(42)
+np.random.seed(42)
+random.seed(42)
+
+# Load DEITA-Complexity dataset
+dataset = load_dataset("hkust-nlp/deita-complexity-scorer-data")
+val_data = dataset["validation"]
+
+# Initialize tokenizer
+tokenizer = DistilBertTokenizerFast.from_pretrained("distilbert-base-uncased")
+
+# Preprocessing function
+def preprocess_function(examples):
+    return tokenizer(examples["input"], truncation=True, padding="max_length", max_length=128)
+
+# Tokenize validation dataset
+val_encodings = val_data.map(preprocess_function, batched=True)
+
+# Inspect the structure of val_encodings
+print("Validation Encodings Structure:")
+print(val_encodings)
+
+# Convert dataset to PyTorch format
+class ComplexityDataset(torch.utils.data.Dataset):
+    def __init__(self, encodings):
+        self.encodings = encodings
+
+    def __len__(self):
+        return len(self.encodings['input_ids'])
+
+    def __getitem__(self, idx):
+        # Create a dictionary for the inputs
+        item = {
+            "input_ids": torch.tensor(self.encodings['input_ids'][idx]),
+            "attention_mask": torch.tensor(self.encodings['attention_mask'][idx]),
+            # Convert target to float if it's a string
+            "labels": torch.tensor(float(self.encodings['target'][idx]), dtype=torch.float)  # Ensure 'target' is numeric
+        }
+        return item
+
+val_dataset = ComplexityDataset(val_encodings)
+
+# Load pre-trained DistilBERT model
+model = DistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased", num_labels=1)
+
+# Freeze first 4 transformer layers
+for layer in model.distilbert.transformer.layer[:4]:
+    for param in layer.parameters():
+        param.requires_grad = False
+
+# Define optimizer
+optimizer = AdamW(model.parameters(), lr=2e-5)
+
+# Use GPU if available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model.to(device)
+
+# DataLoader for batching
+val_loader = DataLoader(val_dataset, batch_size=8, shuffle=False)
+
+# Evaluation function
+def evaluate_model(model, val_loader):
+    model.eval()
+    val_loss = 0.0
+    total_mae = 0.0
+    all_predictions = []
+    all_labels = []
+
+    with torch.no_grad():
+        for batch in tqdm(val_loader, desc="Evaluating", leave=False):
+            batch = {key: val.to(device) for key, val in batch.items()}
+            outputs = model(**batch)
+            loss = torch.nn.functional.mse_loss(outputs.logits.squeeze(), batch["labels"])
+
+            val_loss += loss.item()
+            total_mae += torch.nn.functional.l1_loss(outputs.logits.squeeze(), batch["labels"], reduction="sum").item()
+
+            all_predictions.extend(outputs.logits.squeeze().cpu().numpy())
+            all_labels.extend(batch["labels"].cpu().numpy())
+
+    avg_val_loss = val_loss / len(val_loader)
+    avg_val_mae = total_mae / len(val_loader.dataset)
+
+    # Calculate additional metrics
+    r2 = r2_score(all_labels, all_predictions)
+    f1 = f1_score(np.round(all_labels), np.round(all_predictions), average='weighted')
+
+    return avg_val_loss, avg_val_mae, r2, f1, all_predictions, all_labels
+
+# Evaluate the model
+val_loss, val_mae, r2, f1, predictions, labels = evaluate_model(model, val_loader)
+
+print(f"Validation Loss = {val_loss:.4f}, Validation MAE = {val_mae:.4f}, R² Score = {r2:.4f}, F1 Score = {f1:.4f}")
+
+# Testing the model (inference on the validation set)
+def test_model(model, val_loader):
+    model.eval()
+    all_predictions = []
+    all_labels = []
+
+    with torch.no_grad():
+        for batch in tqdm(val_loader, desc="Testing", leave=False):
+            batch = {key: val.to(device) for key, val in batch.items()}
+            outputs = model(**batch)
+
+            all_predictions.extend(outputs.logits.squeeze().cpu().numpy())
+            all_labels.extend(batch["labels"].cpu().numpy())
+
+    return np.array(all_predictions), np.array(all_labels)
+
+# Get predictions and labels from the test function
+test_predictions, test_labels = test_model(model, val_loader)
+
+# You can also calculate the evaluation metrics on the test predictions
+test_r2 = r2_score(test_labels, test_predictions)
+test_f1 = f1_score(np.round(test_labels), np.round(test_predictions), average='weighted')
+
+print(f"Test R² Score = {test_r2:.4f}, Test F1 Score = {test_f1:.4f}")
+
+# Save the fine-tuned model
+model.save_pretrained("fine_tuned_deita_model")
+tokenizer.save_pretrained("fine_tuned_deita_model")
+
+print("✅ Evaluation and testing complete! Model saved at 'fine_tuned_deita_model'.")
+=======
+import torch
+import random
+import numpy as np
+from tqdm import tqdm
+from datasets import load_dataset
+from transformers import DistilBertTokenizerFast, DistilBertForSequenceClassification
+from torch.utils.data import DataLoader
+from transformers import AdamW
+from sklearn.metrics import r2_score, f1_score, mean_absolute_error
+
+# Set random seed for reproducibility
+torch.manual_seed(42)
+np.random.seed(42)
+random.seed(42)
+
+# Load DEITA-Complexity dataset
+dataset = load_dataset("hkust-nlp/deita-complexity-scorer-data")
+val_data = dataset["validation"]
+
+# Initialize tokenizer
+tokenizer = DistilBertTokenizerFast.from_pretrained("distilbert-base-uncased")
+
+# Preprocessing function
+def preprocess_function(examples):
+    return tokenizer(examples["input"], truncation=True, padding="max_length", max_length=128)
+
+# Tokenize validation dataset
+val_encodings = val_data.map(preprocess_function, batched=True)
+
+# Inspect the structure of val_encodings
+print("Validation Encodings Structure:")
+print(val_encodings)
+
+# Convert dataset to PyTorch format
+class ComplexityDataset(torch.utils.data.Dataset):
+    def __init__(self, encodings):
+        self.encodings = encodings
+
+    def __len__(self):
+        return len(self.encodings['input_ids'])
+
+    def __getitem__(self, idx):
+        # Create a dictionary for the inputs
+        item = {
+            "input_ids": torch.tensor(self.encodings['input_ids'][idx]),
+            "attention_mask": torch.tensor(self.encodings['attention_mask'][idx]),
+            # Convert target to float if it's a string
+            "labels": torch.tensor(float(self.encodings['target'][idx]), dtype=torch.float)  # Ensure 'target' is numeric
+        }
+        return item
+
+val_dataset = ComplexityDataset(val_encodings)
+
+# Load pre-trained DistilBERT model
+model = DistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased", num_labels=1)
+
+# Freeze first 4 transformer layers
+for layer in model.distilbert.transformer.layer[:4]:
+    for param in layer.parameters():
+        param.requires_grad = False
+
+# Define optimizer
+optimizer = AdamW(model.parameters(), lr=2e-5)
+
+# Use GPU if available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model.to(device)
+
+# DataLoader for batching
+val_loader = DataLoader(val_dataset, batch_size=8, shuffle=False)
+
+# Evaluation function
+def evaluate_model(model, val_loader):
+    model.eval()
+    val_loss = 0.0
+    total_mae = 0.0
+    all_predictions = []
+    all_labels = []
+
+    with torch.no_grad():
+        for batch in tqdm(val_loader, desc="Evaluating", leave=False):
+            batch = {key: val.to(device) for key, val in batch.items()}
+            outputs = model(**batch)
+            loss = torch.nn.functional.mse_loss(outputs.logits.squeeze(), batch["labels"])
+
+            val_loss += loss.item()
+            total_mae += torch.nn.functional.l1_loss(outputs.logits.squeeze(), batch["labels"], reduction="sum").item()
+
+            all_predictions.extend(outputs.logits.squeeze().cpu().numpy())
+            all_labels.extend(batch["labels"].cpu().numpy())
+
+    avg_val_loss = val_loss / len(val_loader)
+    avg_val_mae = total_mae / len(val_loader.dataset)
+
+    # Calculate additional metrics
+    r2 = r2_score(all_labels, all_predictions)
+    f1 = f1_score(np.round(all_labels), np.round(all_predictions), average='weighted')
+
+    return avg_val_loss, avg_val_mae, r2, f1, all_predictions, all_labels
+
+# Evaluate the model
+val_loss, val_mae, r2, f1, predictions, labels = evaluate_model(model, val_loader)
+
+print(f"Validation Loss = {val_loss:.4f}, Validation MAE = {val_mae:.4f}, R² Score = {r2:.4f}, F1 Score = {f1:.4f}")
+
+# Testing the model (inference on the validation set)
+def test_model(model, val_loader):
+    model.eval()
+    all_predictions = []
+    all_labels = []
+
+    with torch.no_grad():
+        for batch in tqdm(val_loader, desc="Testing", leave=False):
+            batch = {key: val.to(device) for key, val in batch.items()}
+            outputs = model(**batch)
+
+            all_predictions.extend(outputs.logits.squeeze().cpu().numpy())
+            all_labels.extend(batch["labels"].cpu().numpy())
+
+    return np.array(all_predictions), np.array(all_labels)
+
+# Get predictions and labels from the test function
+test_predictions, test_labels = test_model(model, val_loader)
+
+# You can also calculate the evaluation metrics on the test predictions
+test_r2 = r2_score(test_labels, test_predictions)
+test_f1 = f1_score(np.round(test_labels), np.round(test_predictions), average='weighted')
+
+print(f"Test R² Score = {test_r2:.4f}, Test F1 Score = {test_f1:.4f}")
+
+# Save the fine-tuned model
+model.save_pretrained("fine_tuned_deita_model")
+tokenizer.save_pretrained("fine_tuned_deita_model")
+
+print("✅ Evaluation and testing complete! Model saved at 'fine_tuned_deita_model'.")
+>>>>>>> b1313c5d084e410cadf261f2fafd8929cb149a4f

complexity_score.py

@@ -0,0 +1,41 @@
+<<<<<<< HEAD
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+
+# Load the tokenizer and model
+tokenizer = AutoTokenizer.from_pretrained("thethinkmachine/Maxwell-Task-Complexity-Scorer-v0.2")
+model = AutoModelForSequenceClassification.from_pretrained("thethinkmachine/Maxwell-Task-Complexity-Scorer-v0.2")
+
+# Example task
+task_description = "find a new theory"
+
+# Tokenize the input
+inputs = tokenizer(task_description, return_tensors="pt")
+
+# Perform inference
+with torch.no_grad():
+    outputs = model(**inputs)
+    complexity_score = torch.sigmoid(outputs.logits).item()
+
+print(f"Task Complexity Score: {complexity_score:.4f}")
+=======
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+
+# Load the tokenizer and model
+tokenizer = AutoTokenizer.from_pretrained("thethinkmachine/Maxwell-Task-Complexity-Scorer-v0.2")
+model = AutoModelForSequenceClassification.from_pretrained("thethinkmachine/Maxwell-Task-Complexity-Scorer-v0.2")
+
+# Example task
+task_description = "find a new theory"
+
+# Tokenize the input
+inputs = tokenizer(task_description, return_tensors="pt")
+
+# Perform inference
+with torch.no_grad():
+    outputs = model(**inputs)
+    complexity_score = torch.sigmoid(outputs.logits).item()
+
+print(f"Task Complexity Score: {complexity_score:.4f}")
+>>>>>>> b1313c5d084e410cadf261f2fafd8929cb149a4f

download_models.py

@@ -0,0 +1,19 @@
+import os
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+def download_base_models():
+    # Create models directory
+    os.makedirs("pretrained_models", exist_ok=True)
+    
+    print("Downloading BERT base model...")
+    # Download and save BERT base model
+    tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+    model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
+    
+    # Save models locally
+    tokenizer.save_pretrained("pretrained_models/bert-base-uncased")
+    model.save_pretrained("pretrained_models/bert-base-uncased")
+    print("Base models downloaded successfully!")
+
+if __name__ == "__main__":
+    download_base_models()

emotions.py

@@ -0,0 +1,235 @@
+<<<<<<< HEAD
+import pandas as pd
+import torch
+from datasets import load_dataset, Dataset
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
+import numpy as np
+from sklearn.metrics import accuracy_score, f1_score, roc_auc_score, classification_report
+
+# Load dataset
+dataset = load_dataset("go_emotions")
+
+# Print dataset columns
+print("Dataset Columns Before Preprocessing:", dataset["train"].column_names)
+
+# Ensure labels exist
+if "labels" not in dataset["train"].column_names:
+    raise KeyError("Column 'labels' is missing! Check dataset structure.")
+
+# Load tokenizer
+model_checkpoint = "distilbert-base-uncased"
+
+tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
+
+# Preprocessing function (Take only the first label for single-label classification)
+def preprocess_data(batch):
+    encoding = tokenizer(batch["text"], padding="max_length", truncation=True)
+    
+    # Take only the first label (for single-label classification)
+    encoding["labels"] = batch["labels"][0] if batch["labels"] else 0  # Default to 0 if empty
+    return encoding
+
+# Tokenize dataset
+encoded_dataset = dataset.map(preprocess_data, batched=False, remove_columns=["text"])
+
+# Set format for PyTorch
+encoded_dataset.set_format("torch")
+
+# Load model for single-label classification (28 classes)
+num_labels = 28  # Change based on dataset labels
+model = AutoModelForSequenceClassification.from_pretrained(model_checkpoint, num_labels=num_labels)
+
+# Training arguments
+args = TrainingArguments(
+    output_dir="./results",
+    eval_strategy="epoch",
+    save_strategy="epoch",
+    save_total_limit=1,
+    logging_strategy="no",
+    per_device_train_batch_size=32,  # Increase batch size
+    per_device_eval_batch_size=32,  
+    num_train_epochs=2,  # Reduce epochs
+    weight_decay=0.01,
+    load_best_model_at_end=True,
+    fp16=True,  # Mixed precision for speedup
+    gradient_accumulation_steps=2,  # Helps with large batch sizes
+)
+
+
+# Compute metrics function
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    
+    # Convert logits to class predictions
+    predictions = np.argmax(logits, axis=-1)
+
+    accuracy = accuracy_score(labels, predictions)
+    f1 = f1_score(labels, predictions, average="weighted")
+    
+    return {"accuracy": accuracy, "f1": f1}
+
+# Initialize Trainer
+trainer = Trainer(
+    model=model,
+    args=args,
+    train_dataset=encoded_dataset["train"],
+    eval_dataset=encoded_dataset["validation"],
+    compute_metrics=compute_metrics
+)
+
+# Train model
+trainer.train()
+print("Training completed!")
+
+# Save model and tokenizer
+model.save_pretrained("./saved_model")
+tokenizer.save_pretrained("./saved_model")
+print("Model and tokenizer saved!")
+
+# ====== Evaluation on Test Set ======
+print("\nEvaluating model on test set...")
+
+# Get test dataset
+test_dataset = encoded_dataset["test"]
+
+# Make predictions
+predictions = trainer.predict(test_dataset)
+logits = predictions.predictions
+
+# Convert logits to class predictions
+y_pred = np.argmax(logits, axis=-1)
+y_true = test_dataset["labels"].numpy()
+
+# Compute accuracy and F1-score
+accuracy = accuracy_score(y_true, y_pred)
+f1 = f1_score(y_true, y_pred, average="weighted")
+
+# Print evaluation results
+print("\nEvaluation Results:")
+print(f"Test Accuracy: {accuracy:.4f}")
+print(f"Test F1 Score: {f1:.4f}")
+
+# Print classification report
+print("\nClassification Report:\n", classification_report(y_true, y_pred))
+
+# Save test results
+pd.DataFrame({"true_labels": y_true.tolist(), "predicted_labels": y_pred.tolist()}).to_csv("test_results.csv", index=False)
+print("Test results saved to 'test_results.csv'!")
+=======
+import pandas as pd
+import torch
+from datasets import load_dataset, Dataset
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
+import numpy as np
+from sklearn.metrics import accuracy_score, f1_score, roc_auc_score, classification_report
+
+# Load dataset
+dataset = load_dataset("go_emotions")
+
+# Print dataset columns
+print("Dataset Columns Before Preprocessing:", dataset["train"].column_names)
+
+# Ensure labels exist
+if "labels" not in dataset["train"].column_names:
+    raise KeyError("Column 'labels' is missing! Check dataset structure.")
+
+# Load tokenizer
+model_checkpoint = "distilbert-base-uncased"
+
+tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
+
+# Preprocessing function (Take only the first label for single-label classification)
+def preprocess_data(batch):
+    encoding = tokenizer(batch["text"], padding="max_length", truncation=True)
+    
+    # Take only the first label (for single-label classification)
+    encoding["labels"] = batch["labels"][0] if batch["labels"] else 0  # Default to 0 if empty
+    return encoding
+
+# Tokenize dataset
+encoded_dataset = dataset.map(preprocess_data, batched=False, remove_columns=["text"])
+
+# Set format for PyTorch
+encoded_dataset.set_format("torch")
+
+# Load model for single-label classification (28 classes)
+num_labels = 28  # Change based on dataset labels
+model = AutoModelForSequenceClassification.from_pretrained(model_checkpoint, num_labels=num_labels)
+
+# Training arguments
+args = TrainingArguments(
+    output_dir="./results",
+    eval_strategy="epoch",
+    save_strategy="epoch",
+    save_total_limit=1,
+    logging_strategy="no",
+    per_device_train_batch_size=32,  # Increase batch size
+    per_device_eval_batch_size=32,  
+    num_train_epochs=2,  # Reduce epochs
+    weight_decay=0.01,
+    load_best_model_at_end=True,
+    fp16=True,  # Mixed precision for speedup
+    gradient_accumulation_steps=2,  # Helps with large batch sizes
+)
+
+
+# Compute metrics function
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    
+    # Convert logits to class predictions
+    predictions = np.argmax(logits, axis=-1)
+
+    accuracy = accuracy_score(labels, predictions)
+    f1 = f1_score(labels, predictions, average="weighted")
+    
+    return {"accuracy": accuracy, "f1": f1}
+
+# Initialize Trainer
+trainer = Trainer(
+    model=model,
+    args=args,
+    train_dataset=encoded_dataset["train"],
+    eval_dataset=encoded_dataset["validation"],
+    compute_metrics=compute_metrics
+)
+
+# Train model
+trainer.train()
+print("Training completed!")
+
+# Save model and tokenizer
+model.save_pretrained("./saved_model")
+tokenizer.save_pretrained("./saved_model")
+print("Model and tokenizer saved!")
+
+# ====== Evaluation on Test Set ======
+print("\nEvaluating model on test set...")
+
+# Get test dataset
+test_dataset = encoded_dataset["test"]
+
+# Make predictions
+predictions = trainer.predict(test_dataset)
+logits = predictions.predictions
+
+# Convert logits to class predictions
+y_pred = np.argmax(logits, axis=-1)
+y_true = test_dataset["labels"].numpy()
+
+# Compute accuracy and F1-score
+accuracy = accuracy_score(y_true, y_pred)
+f1 = f1_score(y_true, y_pred, average="weighted")
+
+# Print evaluation results
+print("\nEvaluation Results:")
+print(f"Test Accuracy: {accuracy:.4f}")
+print(f"Test F1 Score: {f1:.4f}")
+
+# Print classification report
+print("\nClassification Report:\n", classification_report(y_true, y_pred))
+
+# Save test results
+pd.DataFrame({"true_labels": y_true.tolist(), "predicted_labels": y_pred.tolist()}).to_csv("test_results.csv", index=False)
+print("Test results saved to 'test_results.csv'!")
+>>>>>>> b1313c5d084e410cadf261f2fafd8929cb149a4f

emotions.txt

@@ -0,0 +1,140 @@
+<<<<<<< HEAD
+PS C:\Users\NAVYA\Documents\moodify> python emotions.py
+2025-02-26 20:38:46.440320: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
+2025-02-26 20:38:47.658979: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
+WARNING:tensorflow:From C:\Users\NAVYA\AppData\Local\Programs\Python\Python311\Lib\site-packages\tf_keras\src\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.
+
+Dataset Columns Before Preprocessing: ['text', 'labels', 'id']
+Map: 100%|█████████████████████████████████████████████████████████████████████████████████████| 43410/43410 [00:22<00:00, 1958.97 examples/s] 
+Map: 100%|███████████████████████████████████████████████████████████████████████████████████████| 5426/5426 [00:03<00:00, 1796.32 examples/s] 
+Map: 100%|███████████████████████████████████████████████████████████████████████████████████████| 5427/5427 [00:02<00:00, 1936.32 examples/s] 
+Some weights of DistilBertForSequenceClassification were not initialized from the model checkpoint at distilbert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight', 'pre_classifier.bias', 'pre_classifier.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+{'eval_loss': 1.414624571800232, 'eval_accuracy': 0.5748249170659786, 'eval_f1': 0.55625264544128, 'eval_runtime': 37.1848, 'eval_samples_per_second': 145.92, 'eval_steps_per_second': 4.572, 'epoch': 1.0}
+{'eval_loss': 1.3568519353866577, 'eval_accuracy': 0.5895687430888316, 'eval_f1': 0.5727110766843768, 'eval_runtime': 38.7582, 'eval_samples_per_second': 139.996, 'eval_steps_per_second': 4.386, 'epoch': 2.0}                                                                              
+{'train_runtime': 6368.0108, 'train_samples_per_second': 13.634, 'train_steps_per_second': 0.213, 'train_loss': 1.50392983585684, 'epoch': 2.0}
+100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1356/1356 [1:46:08<00:00,  4.70s/it]
+Training completed!
+Model and tokenizer saved!
+
+Evaluating model on test set...
+100%|███████████████████████████████████████████████████████████████████████████████████████████████████████| 170/170 [00:38<00:00,  4.43it/s]
+
+Evaluation Results:
+Test Accuracy: 0.5779
+Test F1 Score: 0.5608
+C:\Users\NAVYA\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\metrics\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
+  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
+C:\Users\NAVYA\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\metrics\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
+  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
+C:\Users\NAVYA\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\metrics\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
+  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
+
+Classification Report:
+               precision    recall  f1-score   support
+
+           0       0.65      0.74      0.69       504
+           1       0.73      0.86      0.79       252
+           2       0.47      0.47      0.47       197
+           3       0.32      0.20      0.25       286
+           4       0.54      0.35      0.42       318
+           5       0.46      0.40      0.43       114
+           6       0.47      0.39      0.43       139
+           7       0.43      0.61      0.51       233
+           8       0.60      0.42      0.49        74
+           9       0.38      0.22      0.28       127
+          10       0.42      0.37      0.39       220
+          11       0.48      0.40      0.44        84
+          12       0.71      0.40      0.51        30
+          13       0.48      0.39      0.43        84
+          14       0.59      0.70      0.64        74
+          15       0.84      0.83      0.83       288
+          16       0.00      0.00      0.00         6
+          17       0.52      0.56      0.54       116
+          18       0.65      0.82      0.72       169
+          19       0.00      0.00      0.00        16
+          20       0.56      0.49      0.52       120
+          21       0.00      0.00      0.00         8
+          22       0.47      0.08      0.14       109
+          23       0.00      0.00      0.00         7
+          24       0.57      0.74      0.64        46
+          25       0.55      0.47      0.51       108
+          26       0.42      0.48      0.44        92
+          27       0.60      0.71      0.65      1606
+
+    accuracy                           0.58      5427
+   macro avg       0.46      0.43      0.44      5427
+weighted avg       0.56      0.58      0.56      5427
+
+Test results saved to 'test_results.csv'!
+=======
+PS C:\Users\NAVYA\Documents\moodify> python emotions.py
+2025-02-26 20:38:46.440320: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
+2025-02-26 20:38:47.658979: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
+WARNING:tensorflow:From C:\Users\NAVYA\AppData\Local\Programs\Python\Python311\Lib\site-packages\tf_keras\src\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.
+
+Dataset Columns Before Preprocessing: ['text', 'labels', 'id']
+Map: 100%|█████████████████████████████████████████████████████████████████████████████████████| 43410/43410 [00:22<00:00, 1958.97 examples/s] 
+Map: 100%|███████████████████████████████████████████████████████████████████████████████████████| 5426/5426 [00:03<00:00, 1796.32 examples/s] 
+Map: 100%|███████████████████████████████████████████████████████████████████████████████████████| 5427/5427 [00:02<00:00, 1936.32 examples/s] 
+Some weights of DistilBertForSequenceClassification were not initialized from the model checkpoint at distilbert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight', 'pre_classifier.bias', 'pre_classifier.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+{'eval_loss': 1.414624571800232, 'eval_accuracy': 0.5748249170659786, 'eval_f1': 0.55625264544128, 'eval_runtime': 37.1848, 'eval_samples_per_second': 145.92, 'eval_steps_per_second': 4.572, 'epoch': 1.0}
+{'eval_loss': 1.3568519353866577, 'eval_accuracy': 0.5895687430888316, 'eval_f1': 0.5727110766843768, 'eval_runtime': 38.7582, 'eval_samples_per_second': 139.996, 'eval_steps_per_second': 4.386, 'epoch': 2.0}                                                                              
+{'train_runtime': 6368.0108, 'train_samples_per_second': 13.634, 'train_steps_per_second': 0.213, 'train_loss': 1.50392983585684, 'epoch': 2.0}
+100%|███████████████████████████████████████████████████████████████████████████████████████████████████| 1356/1356 [1:46:08<00:00,  4.70s/it]
+Training completed!
+Model and tokenizer saved!
+
+Evaluating model on test set...
+100%|██████████████████████████████████���████████████████████████████████████████████████████████████████████| 170/170 [00:38<00:00,  4.43it/s]
+
+Evaluation Results:
+Test Accuracy: 0.5779
+Test F1 Score: 0.5608
+C:\Users\NAVYA\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\metrics\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
+  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
+C:\Users\NAVYA\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\metrics\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
+  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
+C:\Users\NAVYA\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\metrics\_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
+  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
+
+Classification Report:
+               precision    recall  f1-score   support
+
+           0       0.65      0.74      0.69       504
+           1       0.73      0.86      0.79       252
+           2       0.47      0.47      0.47       197
+           3       0.32      0.20      0.25       286
+           4       0.54      0.35      0.42       318
+           5       0.46      0.40      0.43       114
+           6       0.47      0.39      0.43       139
+           7       0.43      0.61      0.51       233
+           8       0.60      0.42      0.49        74
+           9       0.38      0.22      0.28       127
+          10       0.42      0.37      0.39       220
+          11       0.48      0.40      0.44        84
+          12       0.71      0.40      0.51        30
+          13       0.48      0.39      0.43        84
+          14       0.59      0.70      0.64        74
+          15       0.84      0.83      0.83       288
+          16       0.00      0.00      0.00         6
+          17       0.52      0.56      0.54       116
+          18       0.65      0.82      0.72       169
+          19       0.00      0.00      0.00        16
+          20       0.56      0.49      0.52       120
+          21       0.00      0.00      0.00         8
+          22       0.47      0.08      0.14       109
+          23       0.00      0.00      0.00         7
+          24       0.57      0.74      0.64        46
+          25       0.55      0.47      0.51       108
+          26       0.42      0.48      0.44        92
+          27       0.60      0.71      0.65      1606
+
+    accuracy                           0.58      5427
+   macro avg       0.46      0.43      0.44      5427
+weighted avg       0.56      0.58      0.56      5427
+
+Test results saved to 'test_results.csv'!
+>>>>>>> b1313c5d084e410cadf261f2fafd8929cb149a4f
+PS C:\Users\NAVYA\Doc

intent_classifier.py

@@ -0,0 +1,102 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from transformers import BertTokenizer, BertForSequenceClassification
+from datasets import load_dataset
+from tqdm import tqdm
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+# Check for CUDA
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(device)
+
+# Load CLINC-OOS Dataset (Correct Config)
+dataset = load_dataset("clinc_oos", "plus")
+
+# Tokenizer
+tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+
+# Preprocess Dataset
+class IntentDataset(Dataset):
+    def __init__(self, dataset_split):
+        self.texts = dataset_split["text"]
+        self.labels = dataset_split["intent"]
+        self.label_map = {label: i for i, label in enumerate(set(self.labels))}  # Create label mapping
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, idx):
+        inputs = tokenizer(self.texts[idx], padding="max_length", truncation=True, max_length=64, return_tensors="pt")
+        label = self.labels[idx]
+        if label not in self.label_map:
+            raise ValueError(f"Unexpected label {label} found in dataset")  # Debugging step
+        return {key: val.squeeze(0) for key, val in inputs.items()}, torch.tensor(self.label_map[label])
+
+# Create Dataloaders
+batch_size = 16
+train_dataset = IntentDataset(dataset["train"])
+test_dataset = IntentDataset(dataset["test"])
+train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+test_loader = DataLoader(test_dataset, batch_size=batch_size)
+
+# Load Pretrained BERT Model
+num_labels = len(set(dataset["train"]["intent"]))
+model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=num_labels).to(device)
+
+# Loss & Optimizer
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.AdamW(model.parameters(), lr=2e-5)
+
+# Training Loop
+num_epochs = 3
+for epoch in range(num_epochs):
+    model.train()
+    total_loss = 0
+    correct = 0
+    total = 0
+
+    for batch in tqdm(train_loader, desc=f"Epoch {epoch+1}/{num_epochs} Training"):
+        inputs, labels = batch
+        inputs = {key: val.to(device) for key, val in inputs.items()}
+        labels = labels.to(device)
+
+        optimizer.zero_grad()
+        outputs = model(**inputs).logits
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        total_loss += loss.item()
+        correct += (outputs.argmax(dim=1) == labels).sum().item()
+        total += labels.size(0)
+
+    train_accuracy = correct / total
+    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {total_loss:.4f}, Train Accuracy: {train_accuracy:.4f}")
+
+# Evaluation on Test Set
+model.eval()
+all_preds, all_labels = [], []
+
+with torch.no_grad():
+    for batch in tqdm(test_loader, desc="Testing"):
+        inputs, labels = batch
+        inputs = {key: val.to(device) for key, val in inputs.items()}
+        labels = labels.to(device)
+
+        outputs = model(**inputs).logits
+        preds = outputs.argmax(dim=1)
+
+        all_preds.extend(preds.cpu().numpy())
+        all_labels.extend(labels.cpu().numpy())
+
+# Compute Metrics
+accuracy = accuracy_score(all_labels, all_preds)
+precision, recall, f1, _ = precision_recall_fscore_support(all_labels, all_preds, average="weighted")
+
+print(f"Test Accuracy: {accuracy:.4f}")
+print(f"Precision: {precision:.4f}, Recall: {recall:.4f}, F1-score: {f1:.4f}")
+
+# Save Model
+torch.save(model.state_dict(), "intent_classifier.pth")

intent_graphs.py

@@ -0,0 +1,88 @@
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import confusion_matrix, classification_report, precision_recall_curve
+from sklearn.preprocessing import label_binarize
+from transformers import BertTokenizer, BertForSequenceClassification
+from datasets import load_dataset
+
+# Check for CUDA
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load dataset
+dataset = load_dataset("clinc_oos", "plus")
+label_names = dataset["train"].features["intent"].names  # Ensure correct order
+
+# Load model
+num_labels = len(label_names)
+model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=num_labels)
+model.load_state_dict(torch.load("intent_classifier.pth", map_location=device))
+model.to(device)
+model.eval()
+
+# Load tokenizer
+tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+
+# Prepare data
+true_labels = []
+pred_labels = []
+all_probs = []
+
+for example in dataset["test"]:
+    sentence = example["text"]
+    true_label = example["intent"]
+
+    # Tokenize
+    inputs = tokenizer(sentence, return_tensors="pt", padding="max_length", truncation=True, max_length=128)
+    inputs = {key: val.to(device) for key, val in inputs.items()}
+
+    # Predict
+    with torch.no_grad():
+        outputs = model(**inputs)
+        probs = torch.nn.functional.softmax(outputs.logits, dim=1).cpu().numpy()[0]
+        predicted_class = np.argmax(probs)
+
+    # Store results
+    true_labels.append(true_label)
+    pred_labels.append(predicted_class)
+    all_probs.append(probs)
+
+# Convert to numpy arrays
+true_labels = np.array(true_labels)
+pred_labels = np.array(pred_labels)
+all_probs = np.array(all_probs)
+
+# Compute confusion matrix
+conf_matrix = confusion_matrix(true_labels, pred_labels)
+
+# Plot confusion matrix
+plt.figure(figsize=(12, 10))
+sns.heatmap(conf_matrix, annot=False, fmt="d", cmap="Blues")
+plt.xlabel("Predicted Label")
+plt.ylabel("True Label")
+plt.title("Confusion Matrix for Intent Classification")
+plt.savefig("confusion_matrix.png", dpi=300, bbox_inches="tight")
+plt.close()
+
+print("Confusion matrix saved as confusion_matrix.png")
+
+# --- Multi-Class Precision-Recall Curve ---
+# Binarize true labels for multi-class PR calculation
+true_labels_bin = label_binarize(true_labels, classes=np.arange(num_labels))
+
+# Plot Precision-Recall Curve for multiple classes
+plt.figure(figsize=(10, 8))
+for i in range(num_labels):
+    precision, recall, _ = precision_recall_curve(true_labels_bin[:, i], all_probs[:, i])
+    plt.plot(recall, precision, lw=1, alpha=0.7, label=f"Class {i}: {label_names[i]}")
+
+plt.xlabel("Recall")
+plt.ylabel("Precision")
+plt.title("Multi-Class Precision-Recall Curve")
+plt.legend(loc="best", fontsize=6, ncol=2, frameon=True)
+plt.grid(True)
+plt.savefig("precision_recall_curve.png", dpi=300, bbox_inches="tight")
+plt.close()
+
+print("Precision-Recall curve saved as precision_recall_curve.png")

intent_train.txt

@@ -0,0 +1,25 @@
+PS C:\Users\NAVYA\Documents\moodify> python intent_classifier.py
+2025-02-26 00:12:11.737923: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
+2025-02-26 00:12:13.232626: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
+cuda
+train-00000-of-00001.parquet: 100%|████████████████████████████████████████████████████████████████████████| 312k/312k [00:00<00:00, 2.83MB/s]
+C:\Users\NAVYA\AppData\Local\Programs\Python\Python311\Lib\site-packages\huggingface_hub\file_download.py:142: UserWarning: `huggingface_hub` cache-system uses symlinks by default to efficiently store duplicated files but your machine does not support them in C:\Users\NAVYA\.cache\huggingface\hub\datasets--clinc_oos. Caching files will still work but in a degraded version that might require more space on your disk. This warning can be disabled by setting the `HF_HUB_DISABLE_SYMLINKS_WARNING` environment variable. For more details, see https://huggingface.co/docs/huggingface_hub/how-to-cache#limitations.
+To support symlinks on Windows, you either need to activate Developer Mode or to run Python as an administrator. In order to activate developer mode, see this article: https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development
+  warnings.warn(message)
+validation-00000-of-00001.parquet: 100%|█████████████████████████████████████████████████████████████████| 77.8k/77.8k [00:00<00:00, 4.63MB/s]
+test-00000-of-00001.parquet: 100%|█████████████████████████████████████████████████████████████████████████| 136k/136k [00:00<00:00, 4.81MB/s]
+Generating train split: 100%|████████████████████████████████████████████████████████████████| 15250/15250 [00:00<00:00, 210143.07 examples/s] 
+Generating validation split: 100%|█████████████████████████████████████████████████████████████| 3100/3100 [00:00<00:00, 233598.79 examples/s] 
+Generating test split: 100%|███████████████████████████████████████████████████████████████████| 5500/5500 [00:00<00:00, 288149.49 examples/s]
+Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight']
+You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
+Epoch 1/3 Training: 100%|███████████████████████████████████████████████████████████████████████████████████| 954/954 [04:26<00:00,  3.57it/s]
+Epoch 1/3, Loss: 3449.6031, Train Accuracy: 0.4677
+Epoch 2/3 Training: 100%|███████████████████████████████████████████████████████████████████████████████████| 954/954 [04:25<00:00,  3.60it/s] 
+Epoch 2/3, Loss: 1115.7661, Train Accuracy: 0.9301
+Epoch 3/3 Training: 100%|███████████████████████████████████████████████████████████████████████████████████| 954/954 [04:24<00:00,  3.61it/s] 
+Epoch 3/3, Loss: 324.9103, Train Accuracy: 0.9817
+Testing: 100%|██████████████████████████████████████████████████████████████████████████████████████████████| 344/344 [00:27<00:00, 12.57it/s] 
+Test Accuracy: 0.8800
+Precision: 0.8978, Recall: 0.8800, F1-score: 0.8741
+PS C:\Users\NAVYA\Documents\moodify> 

model.py

@@ -0,0 +1,140 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+from transformers import BertTokenizer, BertModel
+from datasets import load_dataset
+from sklearn.model_selection import train_test_split
+from torch.utils.data import Dataset, DataLoader
+from tqdm import tqdm
+from sklearn.metrics import accuracy_score, f1_score
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+dataset = load_dataset("go_emotions")
+
+# Extract text and labels
+texts = dataset["train"]["text"][:20000]  # Increased dataset size
+labels = dataset["train"]["labels"][:20000]  # Increased dataset size
+
+# Convert labels to categorical
+def fix_labels(labels):
+    labels = [max(label) if label else 0 for label in labels]  # Convert multi-label to single-label
+    return torch.tensor(labels, dtype=torch.long)
+
+labels = fix_labels(labels)
+
+# Split dataset
+train_texts, val_texts, train_labels, val_labels = train_test_split(texts, labels, test_size=0.2, random_state=42)
+
+# Tokenizer
+tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+
+# Tokenize text
+def tokenize(texts):
+    return tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
+
+train_encodings = tokenize(train_texts)
+val_encodings = tokenize(val_texts)
+train_encodings = {key: val.to(device) for key, val in train_encodings.items()}
+val_encodings = {key: val.to(device) for key, val in val_encodings.items()}
+
+class EmotionDataset(Dataset):
+    def __init__(self, encodings, labels):
+        self.encodings = encodings
+        self.labels = labels
+
+    def __len__(self):
+        return len(self.labels)
+
+    def __getitem__(self, idx):
+        item = {key: val[idx] for key, val in self.encodings.items()}
+        item["labels"] = self.labels[idx]
+        return item
+
+train_dataset = EmotionDataset(train_encodings, train_labels)
+val_dataset = EmotionDataset(val_encodings, val_labels)
+
+train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
+val_loader = DataLoader(val_dataset, batch_size=16)
+
+class BertGRUClassifier(nn.Module):
+    def __init__(self, bert_model="bert-base-uncased", hidden_dim=128, num_classes=28):
+        super(BertGRUClassifier, self).__init__()
+        self.bert = BertModel.from_pretrained(bert_model)
+        self.gru = nn.GRU(self.bert.config.hidden_size, hidden_dim, batch_first=True)
+        self.dropout = nn.Dropout(0.3)  # Added dropout layer
+        self.fc = nn.Linear(hidden_dim, num_classes)
+
+    def forward(self, input_ids, attention_mask):
+        with torch.no_grad():
+            bert_output = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        gru_output, _ = self.gru(bert_output.last_hidden_state)
+        output = self.fc(self.dropout(gru_output[:, -1, :]))  # Apply dropout
+        return output
+
+model = BertGRUClassifier()
+model.to(device)
+
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=2e-5)
+scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.1)  # Added learning rate scheduler
+
+def evaluate_model(model, data_loader):
+    model.eval()
+    predictions, true_labels = [], []
+
+    with torch.no_grad():
+        for batch in data_loader:
+            input_ids = batch["input_ids"].to(device)
+            attention_mask = batch["attention_mask"].to(device)
+            labels = batch["labels"].to(device)
+
+            outputs = model(input_ids, attention_mask)
+            preds = torch.argmax(outputs, dim=1).cpu().numpy()
+            predictions.extend(preds)
+            true_labels.extend(labels.cpu().numpy())
+
+    acc = accuracy_score(true_labels, predictions)
+    f1 = f1_score(true_labels, predictions, average='weighted')
+    return acc, f1
+
+def train_model(model, train_loader, val_loader, epochs=10):  # Increased number of epochs
+    for epoch in range(epochs):
+        model.train()
+        total_loss = 0
+
+        for batch in tqdm(train_loader, desc=f"Epoch {epoch + 1}/{epochs}"):
+            input_ids = batch["input_ids"].to(device)
+            attention_mask = batch["attention_mask"].to(device)
+            labels = batch["labels"].to(device)
+
+            optimizer.zero_grad()
+            outputs = model(input_ids, attention_mask)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+            total_loss += loss.item()
+
+        scheduler.step()  # Step the scheduler
+
+        train_acc, train_f1 = evaluate_model(model, train_loader)
+        val_acc, val_f1 = evaluate_model(model, val_loader)
+        print(f"Epoch {epoch + 1}, Loss: {total_loss / len(train_loader)}, Train Acc: {train_acc:.4f}, Train F1: {train_f1:.4f}, Val Acc: {val_acc:.4f}, Val F1: {val_f1:.4f}")
+
+        # Save the model after each epoch
+        torch.save(model.state_dict(), f"model_epoch_{epoch + 1}.pth")
+
+train_model(model, train_loader, val_loader)
+
+# Assuming you have a test dataset
+test_texts = dataset["test"]["text"]
+test_labels = fix_labels(dataset["test"]["labels"])
+test_encodings = tokenize(test_texts)
+test_encodings = {key: val.to(device) for key, val in test_encodings.items()}
+test_dataset = EmotionDataset(test_encodings, test_labels)
+test_loader = DataLoader(test_dataset, batch_size=16)
+
+test_acc, test_f1 = evaluate_model(model, test_loader)
+print(f"Test Accuracy: {test_acc:.4f}, Test F1 Score: {test_f1:.4f}")

mood_classifier.py

@@ -0,0 +1,92 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from transformers import BertTokenizer, BertForSequenceClassification
+from datasets import load_dataset
+from torch.utils.data import DataLoader, Dataset, random_split
+from tqdm import tqdm
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load GoEmotions dataset
+dataset = load_dataset("go_emotions", split="train")
+dataset = dataset.map(lambda x: {"label": x["labels"][0]})  # Convert multi-label to single-label
+
+labels = list(set(dataset["label"]))  # Unique labels
+num_labels = len(labels)
+
+tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+
+class MoodDataset(Dataset):
+    def __init__(self, texts, labels):
+        self.texts = texts
+        self.labels = labels
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, idx):
+        inputs = tokenizer(self.texts[idx], return_tensors="pt", padding="max_length", truncation=True, max_length=128)
+        return {key: val.squeeze(0) for key, val in inputs.items()}, torch.tensor(labels.index(self.labels[idx]))
+
+dataset = MoodDataset(dataset["text"], dataset["label"])
+train_size = int(0.8 * len(dataset))
+train_set, test_set = random_split(dataset, [train_size, len(dataset) - train_size])
+
+train_loader = DataLoader(train_set, batch_size=32, shuffle=True)
+test_loader = DataLoader(test_set, batch_size=32)
+
+model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=num_labels).to(device)
+optimizer = optim.AdamW(model.parameters(), lr=2e-5)
+criterion = nn.CrossEntropyLoss()
+
+num_epochs = 3
+for epoch in range(num_epochs):
+    model.train()
+    epoch_loss, correct, total = 0, 0, 0
+    preds, labels_list = [], []
+
+    for batch in tqdm(train_loader, desc=f"Epoch {epoch+1}/{num_epochs} Training"):
+        optimizer.zero_grad()
+        inputs = {key: val.to(device) for key, val in batch[0].items()}
+        labels = batch[1].to(device)
+
+        outputs = model(**inputs).logits
+        loss = criterion(outputs, labels)
+
+        loss.backward()
+        optimizer.step()
+
+        epoch_loss += loss.item()
+        correct += (outputs.argmax(dim=1) == labels).sum().item()
+        total += labels.size(0)
+
+        preds.extend(outputs.argmax(dim=1).cpu().numpy())
+        labels_list.extend(labels.cpu().numpy())
+
+    train_acc = accuracy_score(labels_list, preds)
+    precision, recall, f1, _ = precision_recall_fscore_support(labels_list, preds, average="weighted")
+
+    print(f"Epoch {epoch+1}: Loss: {epoch_loss:.4f}, Train Acc: {train_acc:.4f}, Precision: {precision:.4f}, Recall: {recall:.4f}, F1: {f1:.4f}")
+
+# **Evaluate on Test Set**
+model.eval()
+test_preds, test_labels = [], []
+
+with torch.no_grad():
+    for batch in tqdm(test_loader, desc="Evaluating on Test Set"):
+        inputs = {key: val.to(device) for key, val in batch[0].items()}
+        labels = batch[1].to(device)
+
+        outputs = model(**inputs).logits
+        test_preds.extend(outputs.argmax(dim=1).cpu().numpy())
+        test_labels.extend(labels.cpu().numpy())
+
+test_acc = accuracy_score(test_labels, test_preds)
+precision, recall, f1, _ = precision_recall_fscore_support(test_labels, test_preds, average="weighted")
+
+print(f"Test Accuracy: {test_acc:.4f}, Precision: {precision:.4f}, Recall: {recall:.4f}, F1-score: {f1:.4f}")
+
+# Save model
+model.save_pretrained("mood_classifier")

predict_emotions.py

@@ -0,0 +1,48 @@
+import torch
+from transformers import BertTokenizer, DistilBertForSequenceClassification
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load the trained model and tokenizer
+try:
+    model = DistilBertForSequenceClassification.from_pretrained("./saved_model")
+    tokenizer = BertTokenizer.from_pretrained("./saved_model")
+except Exception as e:
+    print(f"Error loading model or tokenizer: {e}")
+    exit()
+
+model.to(device)
+model.eval()
+
+# Define the sentences
+sentences = [
+    "I am so happy today!",
+    "This is the worst day ever.",
+    "I feel so loved and appreciated.",
+    "I am really angry right now.",
+    "I am so done cant take this anymore",
+    "i have to finish this report by tomorrow but so tired",
+    "let's do it",
+    "i have got this,, yayyyy",
+    "energetic",
+    "worst tired lazy",
+    "I am feeling very sad and lonely."
+]
+
+# Define the label names
+label_names = ["admiration", "amusement", "anger", "annoyance", "approval", "caring", "confusion", "curiosity", "desire", "disappointment", "disapproval", "disgust", "embarrassment", "excitement", "fear", "gratitude", "grief", "joy", "love", "nervousness", "optimism", "pride", "realization", "relief", "remorse", "sadness", "surprise", "neutral"]
+
+def predict_emotion(sentence):
+    inputs = tokenizer(sentence, return_tensors="pt", padding="max_length", truncation=True, max_length=128)
+    inputs = {key: val.to(device) for key, val in inputs.items() if key != "token_type_ids"}
+
+    with torch.no_grad():
+        outputs = model(**inputs)
+        predicted_class = torch.argmax(outputs.logits, dim=1).cpu().numpy()[0]
+
+    return predicted_class, label_names[predicted_class]
+
+# Predict emotions for the sentences
+for sentence in sentences:
+    predicted_emotion, predicted_label_name = predict_emotion(sentence)
+    print(f"Predicted emotion for '{sentence}': {predicted_emotion} ({predicted_label_name})")

predict_intent.py

@@ -0,0 +1,48 @@
+import torch
+from transformers import BertTokenizer, BertForSequenceClassification
+from datasets import load_dataset
+from collections import Counter
+
+# Check for CUDA
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load dataset and get correct label names
+dataset = load_dataset("clinc_oos", "plus")
+label_names = dataset["train"].features["intent"].names  # Ensure correct order
+
+# Debugging check
+print(f"Total labels: {len(label_names)}")  # Should print 151
+print("Sample labels:", label_names[:10])  # Print first 10 labels
+
+# Load the trained model
+num_labels = len(label_names)  # Should be 151
+model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=num_labels)
+model.load_state_dict(torch.load("intent_classifier.pth", map_location=device))
+model.to(device)
+model.eval()
+
+# Load tokenizer
+tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+
+def predict_intent(sentence):
+    inputs = tokenizer(sentence, return_tensors="pt", padding="max_length", truncation=True, max_length=128)
+    inputs = {key: val.to(device) for key, val in inputs.items()}
+
+    with torch.no_grad():
+        outputs = model(**inputs)
+        predicted_class = torch.argmax(outputs.logits, dim=1).cpu().numpy()[0]
+
+    if predicted_class >= len(label_names):  # Prevent out-of-range errors
+        print(f"Warning: Predicted class {predicted_class} is out of range!")
+        return predicted_class, "Unknown Label"
+
+    return predicted_class, label_names[predicted_class]
+
+# Example usage
+sentence = "I need to attend a meeting but so tired but important"
+predicted_intent, predicted_label_name = predict_intent(sentence)
+print(f"Predicted intent for '{sentence}': {predicted_intent} ({predicted_label_name})")
+
+# # Fix: Count labels correctly from dataset["train"]
+# label_counts = Counter([label_names[label] for label in dataset["train"]["intent"]])  
+# print("Label distribution:", label_counts)  # Print top 10 most common labels

requirements.txt

@@ -1,3 +1,13 @@
-altair
-pandas
-streamlit
+together
+python-dotenv
+torch
+transformers==4.35.2
+tokenizers==0.15.0
+gdown
+streamlit
+pandas
+
+transformers==4.35.2
+tokenizers==0.15.0
+
+

task.py

@@ -0,0 +1,558 @@
+import streamlit as st
+import torch
+import os
+from dotenv import load_dotenv
+from together import Together
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, BertTokenizer,DistilBertTokenizer, BertForSequenceClassification, DistilBertForSequenceClassification
+from datetime import datetime, timedelta
+import pandas as pd
+from task_css import get_custom_css  # Import the custom CSS function
+import gdown
+
+# Set environment variable for offline mode
+os.environ["TRANSFORMERS_OFFLINE"] = "1"
+
+# Load environment variables
+load_dotenv()
+
+# Together AI Client with API key from environment variable
+client = Together(api_key=os.getenv("TOGETHER_API_KEY", ""))
+
+# Set device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load Intent Model
+intent_model_path = "intent_classifier.pth"
+# Extract file ID from Google Drive URL
+file_id = "1_GDGvV3MVvBguIsjMyDLg3RxUV_gnFAY"
+num_intent_labels = 151  # Moved this up before model creation
+
+# Load Emotion Model
+emotions_model_path = "./saved_model"
+emotions_folder_id = "1gYWkbC_XBw_GZjsfwXvubHFil4BCq_gH"
+
+# Add new pretrained model ID
+pretrained_folder_id = "13t_EB2LFhRIwb3dkKDtA0O5NXXZBoG-j"
+
+# Initialize Session State
+if "is_ready" not in st.session_state:
+    st.session_state.is_ready = False
+    st.session_state.models = {}  # Initialize models dict immediately
+    st.session_state.tasks = []
+    st.session_state.task_counter = 0
+    st.session_state.overall_emotion = None
+    st.session_state.overall_emotion_label = "Neutral"
+
+# Page Configuration first
+st.set_page_config(
+    page_title="🚀 AI Productivity Assistant", 
+    layout="wide", 
+    page_icon="🎯"
+)
+
+# Custom CSS for enhanced styling
+st.markdown(get_custom_css(), unsafe_allow_html=True)
+
+# Show loading screen if models aren't ready
+if not st.session_state.is_ready:
+    st.markdown(
+        """
+        <div class="loading-container" style="text-align: center; padding: 50px;">
+            <div class="loading-spinner"></div>
+            <h2>Setting up your AI assistant...</h2>
+            <p>This may take a minute. We're downloading the required models.</p>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+    
+    # Load models here
+    try:
+        # First download pretrained models
+        if not os.path.exists("pretrained_models"):
+            with st.status("Downloading base models...", expanded=True) as status:
+                os.makedirs("pretrained_models", exist_ok=True)
+                gdown.download_folder(
+                    f"https://drive.google.com/drive/folders/{pretrained_folder_id}",
+                    output="pretrained_models",
+                    quiet=False
+                )
+                status.update(label="Base models downloaded!", state="complete")
+
+        # Intent Model Loading
+        if not os.path.exists(intent_model_path):
+            with st.status("Downloading intent model...", expanded=True) as status:
+                output = gdown.download(
+                    f"https://drive.google.com/uc?id={file_id}",
+                    intent_model_path,
+                    quiet=False
+                )
+                status.update(label="Intent model downloaded!", state="complete")
+
+        # Emotion Model Loading
+        if not os.path.exists(emotions_model_path):
+            with st.status("Downloading emotion model...", expanded=True) as status:
+                os.makedirs(emotions_model_path, exist_ok=True)
+                gdown.download_folder(
+                    f"https://drive.google.com/drive/folders/{emotions_folder_id}",
+                    output=emotions_model_path,
+                    quiet=False
+                )
+                status.update(label="Emotion model downloaded!", state="complete")
+
+        # Load and store intent model
+        intent_model = AutoModelForSequenceClassification.from_pretrained(
+            "pretrained_models/bert-base-uncased",
+            num_labels=num_intent_labels,
+            ignore_mismatched_sizes=True,  # Add this parameter
+            local_files_only=True
+        )
+        intent_model.load_state_dict(
+            torch.load(intent_model_path, map_location=device, weights_only=True)
+        )
+        st.session_state.models["intent_model"] = intent_model.to(device).eval()
+        st.session_state.models["intent_tokenizer"] = AutoTokenizer.from_pretrained(
+            "pretrained_models/bert-base-uncased",
+            local_files_only=True
+        )
+
+        # Load and store emotion model
+        emotions_model = AutoModelForSequenceClassification.from_pretrained(
+            emotions_model_path,
+            ignore_mismatched_sizes=True,  # Add this parameter
+            local_files_only=True
+        )
+        st.session_state.models["emotions_model"] = emotions_model.to(device).eval()
+        st.session_state.models["emotions_tokenizer"] = AutoTokenizer.from_pretrained(
+            emotions_model_path,
+            local_files_only=True
+        )
+
+        # Set ready state
+        st.session_state.is_ready = True
+        st.rerun()
+        
+    except Exception as e:
+        st.error(f"Error loading models: {str(e)}")
+        st.stop()
+
+# Only show main app if models are ready
+if st.session_state.is_ready:
+    # Title with custom styling
+    st.markdown('<div class="main-header">🎯 MoodifyTask: AI Task Prioritization & Wellness Assistant</div>', unsafe_allow_html=True)
+
+    # Emotion Labels
+    emotion_label_names = [
+        "admiration", "amusement", "anger", "annoyance", "approval",
+        "caring", "confusion", "curiosity", "desire", "disappointment",
+        "disapproval", "disgust", "embarrassment", "excitement", "fear",
+        "gratitude", "grief", "joy", "love", "nervousness",
+        "optimism", "pride", "realization", "relief", "remorse",
+        "sadness", "surprise", "neutral"
+    ]
+
+    # Emotion Categories
+    positive_emotions = ["admiration", "amusement", "approval", "caring", "curiosity", "excitement", "gratitude", "joy", "love", "optimism", "pride", "relief", "surprise"]
+    negative_emotions = ["anger", "annoyance", "disappointment", "disapproval", "disgust", "embarrassment", "fear", "grief", "nervousness", "remorse", "sadness"]
+    neutral_emotions = ["realization", "neutral"]
+
+    # Predict Intent
+    def predict_intent(sentence):
+        inputs = st.session_state.models["intent_tokenizer"](
+            sentence, return_tensors="pt", padding="max_length", truncation=True, max_length=128
+        )
+        inputs = {key: val.to(device) for key, val in inputs.items()}
+        with torch.no_grad():
+            outputs = st.session_state.models["intent_model"](**inputs)
+            predicted_class = torch.argmax(outputs.logits, dim=1).cpu().numpy()[0]
+        
+        # Mapping Intent IDs to Priorities (0-150)
+        PRIORITY_MAPPING = {
+            5: [8, 35, 42, 74, 97, 110, 118, 120, 124, 136],  # freeze_account, report_lost_card, flight_status, report_fraud, credit_limit, lost_luggage, dispute_charge, overdraft, cancel_reservation, emergency
+            4: [14, 15, 19, 20, 39, 47, 48, 49, 50, 69, 70, 71, 72],  # bill_balance, bill_due, exchange_rate, credit_score, interest_rate, insurance, medical_expenses, appointment_schedule, meeting_schedule, dentist_appointment, doctor_appointment, prescription_refill, pharmacy_hours
+            3: [33, 34, 41, 51, 56, 57, 62, 66, 77, 78, 85],  # hotel_reservation, car_rental, restaurant_reservation, tracking_package, check_in, check_out, traffic_update, directions, smart_home_on, smart_home_off, weather_forecast
+            2: [0, 1, 3, 6, 9, 13, 16, 17, 21, 25, 27, 28, 36, 40, 45, 52, 61],  # restaurant_reviews, shopping_list, what_song, schedule_meeting, translate, play_music, book_hotel, book_flight, gas_prices, exchange_rate, movie_showtimes, recipe, cancel_flight, book_reservation, order_food, car_services, joke
+            1: [2, 4, 5, 7, 10, 11, 12, 18, 22, 23, 24, 26, 30, 31, 32, 37, 38, 43, 44, 46, 53, 54, 55, 58, 59, 60, 63, 64, 65, 67, 68, 73]  
+            # tell_joke, fun_fact, trivia, horoscope, dog_fact, cat_fact, define_word, stock_price, sports_update, lottery_results, currency_conversion, holiday_list, language_learning, random_fact, poem, quote, daily_horoscope, joke_request, music_recommendation, podcast_recommendation, celebrity_gossip, movie_recommendation, TV_show_recommendation, book_recommendation, game_recommendation, radio_recommendation, trivia_game, riddle, name_meaning, birthday_reminder, anniversary_reminder, affirmations
+        }
+
+        # Find the priority based on predicted_class
+        predicted_intent_score = next((priority for priority, ids in PRIORITY_MAPPING.items() if predicted_class in ids), 1)  # Default to 1 if not found
+
+        return predicted_intent_score
+
+    # Emotion to Numeric Score Mapping
+    EMOTION_MAPPING = {
+        "admiration": 4, "amusement": 3, "anger": 5, "annoyance": 4, "approval": 3,
+        "caring": 4, "confusion": 3, "curiosity": 3, "desire": 4, "disappointment": 4,
+        "disapproval": 4, "disgust": 5, "embarrassment": 4, "excitement": 5, "fear": 5,
+        "gratitude": 3, "grief": 5, "joy": 5, "love": 5, "nervousness": 4,
+        "optimism": 4, "pride": 4, "realization": 3, "relief": 3, "remorse": 4,
+        "sadness": 5, "surprise": 3, "neutral": 3
+    }
+
+    # Function to get numeric emotion score
+    def get_emotion_score(emotion):
+        return EMOTION_MAPPING.get(emotion.lower(), 3)  # Default to 3 if not found
+    # Predict Emotion
+    def predict_emotion(sentence):
+        if not sentence.strip():
+            return 3, "neutral"
+        # Ensure the input is a full sentence
+        if len(sentence.split()) == 1:  
+            sentence = f"I feel {sentence}"
+        inputs = st.session_state.models["emotions_tokenizer"](
+            sentence, return_tensors="pt", padding="max_length", truncation=True, max_length=128
+        )
+        inputs = {key: val.to(device) for key, val in inputs.items() if key != "token_type_ids"}
+
+        with torch.no_grad():
+            outputs = st.session_state.models["emotions_model"](**inputs)
+            predicted_class = torch.argmax(outputs.logits, dim=1).cpu().numpy()[0]
+
+        detected_emotion = emotion_label_names[predicted_class]
+
+        # Manually adjust for stress/pressure-related words
+        stress_keywords = ["stress", "stressed", "overwhelmed", "pressure", "tense", "burnout"]
+        if any(word in sentence.lower() for word in stress_keywords):
+            if detected_emotion not in ["sadness", "nervousness"]:
+                detected_emotion = "nervousness"  # Change to "sadness" if you prefer
+
+        emotion_score = get_emotion_score(detected_emotion)
+        if emotion_score is None:
+            emotion_score = 3  # Default neutral score
+
+        return emotion_score, detected_emotion
+
+
+    # Get Emotion Category
+    def get_emotion_category(emotion):
+        if emotion in positive_emotions:
+            return "positive"
+        elif emotion in negative_emotions:
+            return "negative"
+        else:
+            return "neutral"
+        
+
+    def normalize_priority(priority, min_value=0, max_value=10):
+        return (priority - min_value) / (max_value - min_value)  # Normalize between 0-1
+
+    # Calculate Task Priority
+    def calculate_priority_score(predicted_intent_score,emotion_score, emotion,  time_remaining, complexity, emotion_category):
+        """
+        Calculate an adaptive priority score for tasks based on intent, emotion, time urgency, and complexity.
+        """
+        emotion_score = emotion_score if emotion_score is not None else 3
+        # Normalize time urgency (scale 0 to 1 based on 7 days)
+        time_score = max(0, min(1, 1 - (time_remaining.total_seconds() / (7 * 24 * 3600))))
+
+        # Set emotion-based adjustments
+        stress_emotions = ["nervousness", "sadness", "fear"]
+        frustration_emotions = ["anger", "frustration","disappointment","annoyance"]
+        anxiety_emotions = ["anxiety", "uncertainty"]
+        
+
+        if emotion_category == "negative":
+            if emotion in stress_emotions:
+                # Prioritize **easy, quick** tasks to reduce cognitive load
+                priority = (predicted_intent_score * 0.15) + (emotion_score * 0.1) + (time_score * 0.3) + ((10 - complexity) * 0.45)
+            
+            elif emotion in frustration_emotions:
+                # Prioritize **engaging** tasks (not too easy) but keep urgency in mind
+                priority = (predicted_intent_score * 0.2) + (emotion_score * 0.15) + (time_score * 0.25) + (complexity * 0.4)
+            
+            elif emotion in anxiety_emotions:
+                # Prioritize **urgent, low-complexity** tasks
+                priority = (predicted_intent_score * 0.2) + (emotion_score * 0.1) + (time_score * 0.4) + ((10 - complexity) * 0.3)
+            
+            else:
+                # Default for negative emotions: balance urgency and ease
+                priority = (predicted_intent_score * 0.2) + (emotion_score * 0.1) + (time_score * 0.3) + ((10 - complexity) * 0.4)
+
+        elif emotion_category == "positive":
+            # If the user is in a **good mood**, favor challenging, high-impact tasks
+            priority = (predicted_intent_score * 0.35) + (emotion_score * 0.2) + (time_score * 0.25) + (complexity * 0.2)
+
+        else:  # Neutral emotion
+            # Keep a balance between difficulty and urgency
+            priority = (predicted_intent_score * 0.3) + (emotion_score * 0.2) + (time_score * 0.2) + (complexity * 0.3)
+
+        return normalize_priority(priority)  # Ensure no negative priority values
+
+
+
+
+    # AI-Generated Plan Based on Start Time
+    from datetime import datetime
+
+    def get_llama_suggestion(emotion, tasks, selected_datetime):
+        """Generate AI plan based on full datetime instead of just time"""
+        # Sort tasks by priority (higher priority first)
+        sorted_tasks = sorted(tasks, key=lambda x: x["priority_score"], reverse=True)
+
+        # Filter tasks based on selected datetime
+        filtered_tasks = [
+            task for task in sorted_tasks 
+            if task["due_date_time"] >= selected_datetime
+        ]
+
+        if not filtered_tasks:
+            well_being_prompts = {
+                "nervousness": "Suggest mindfulness exercises and short relaxation techniques.",
+                "sadness": "Suggest comforting activities like journaling or light exercise.",
+                "anger": "Suggest ways to channel frustration productively.",
+                "joy": "Suggest ways to maintain productivity while feeling good.",
+                "neutral": "Suggest general relaxation activities like listening to music."
+            }
+            well_being_prompt = f"""
+            The user is feeling {emotion}.
+            They have no tasks scheduled after {selected_datetime.strftime('%B %d, %I:%M %p')}.
+            {well_being_prompts.get(emotion, 'Provide general well-being tips.')}
+            """
+            try:
+                response = client.chat.completions.create(
+                    messages=[{"role": "user", "content": well_being_prompt}],
+                    model="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+                    temperature=0.7,
+                )
+                return response.choices[0].message.content
+            except Exception as e:
+                return f"Error generating well-being tips: {e}"
+
+        # Prepare the prompt with more detailed datetime information
+        task_details = "\n".join([
+            f"- {task['description']} (Priority: {task['priority_score']:.2f}, Complexity: {task['complexity']}, Due: {task['due_date_time'].strftime('%B %d, %I:%M %p')})"
+            for task in filtered_tasks
+        ])
+
+        prompt = f"""
+        The user is feeling {emotion}. 
+        They need a structured productivity plan starting from {selected_datetime.strftime('%B %d, %I:%M %p')}, not the current time.
+        
+        Their prioritized tasks (due on or after the selected time), sorted by priority score:
+        {task_details}
+
+        Please provide:
+        1. A detailed schedule with specific times for each task
+        2. Strategic breaks based on task complexity and emotional state
+        3. Wellness activities that complement their current emotion
+        4. Tips for managing tasks effectively given their emotional state
+        5. Suggestions for handling high-priority tasks first while maintaining well-being
+        """
+
+        try:
+            response = client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                model="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+                temperature=0.7,
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"Error generating AI plan: {e}"
+
+
+    # Layout with improved spacing
+    col1, col2 = st.columns([1, 1], gap="medium")
+
+    with col1:
+        # st.markdown('<div class="emotion-analysis">', unsafe_allow_html=True)
+        st.markdown('<h3>🌟 Mood Analysis</h3>', unsafe_allow_html=True)
+        emotion_sentence = st.text_area(
+            "Describe how you're feeling today:", 
+            value="", 
+            height=150, 
+            help="Your emotional state helps us prioritize tasks more effectively"
+        )
+
+        if emotion_sentence:
+            emotion_score, emotion_label = predict_emotion(emotion_sentence)
+            st.session_state.overall_emotion = emotion_score
+            st.session_state.overall_emotion_label = emotion_label
+            
+            st.markdown(f'<div class="emotion-badge">Detected Emotion: {emotion_label}</div>', unsafe_allow_html=True)
+            
+            # Emotion-based task reprioritization
+            for task in st.session_state.tasks:
+                task["priority_score"] = calculate_priority_score(
+                    task["predicted_intent_score"],
+                    emotion_score,
+                    emotion_label,
+                    task["time_remaining"],
+                    task["complexity"],
+                    get_emotion_category(emotion_label)
+                )
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    with col2:
+        # st.markdown('<div class="task-input">', unsafe_allow_html=True)
+        st.markdown('<h3>📅 Add New Task</h3>', unsafe_allow_html=True)
+        with st.form("task_form", clear_on_submit=True):
+            task_description = st.text_input("Task Description", help="Be specific about what needs to be done")
+            col_date, col_time = st.columns(2)
+            
+            with col_date:
+                due_date = st.date_input("Due Date")
+            
+            with col_time:
+                due_time = st.time_input("Due Time")
+            
+            complexity = st.slider(
+                "Task Complexity (1-10)", 
+                1, 10, 5, 
+                help="Higher complexity may affect task priority"
+            )
+            
+            submitted = st.form_submit_button("➕ Add Task")
+            
+            if submitted and task_description and due_date and due_time:
+                due_date_time = datetime.combine(due_date, due_time)
+                time_remaining = due_date_time - datetime.now()
+                predicted_intent_score = predict_intent(task_description)
+                
+                task = {
+                    "id": st.session_state.task_counter,  # Add unique ID
+                    "description": task_description,
+                    "due_date_time": due_date_time,
+                    "time_remaining": time_remaining,
+                    "complexity": complexity,
+                    "predicted_intent_score": predicted_intent_score,
+                    "predicted_emotion": st.session_state.overall_emotion,
+                    "predicted_label_name": st.session_state.overall_emotion_label,
+                    "priority_score": calculate_priority_score(
+                        predicted_intent_score, 
+                        st.session_state.overall_emotion, 
+                        st.session_state.overall_emotion_label, 
+                        time_remaining, 
+                        complexity, 
+                        get_emotion_category(st.session_state.overall_emotion_label)
+                    ),
+                    "completed": False
+                }
+
+                st.session_state.tasks.append(task)
+                st.session_state.task_counter += 1  # Increment counter
+                st.success("✅ Task Added Successfully!")
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Task List with Improved Visualization
+    if st.session_state.tasks:
+        st.markdown('<h3>📌 Task Priority List</h3>', unsafe_allow_html=True)
+        
+        # Sort tasks by priority
+        sorted_tasks = sorted(st.session_state.tasks, key=lambda x: x["priority_score"], reverse=True)
+        
+        # Create task overview cards
+        st.markdown('<div class="task-overview">', unsafe_allow_html=True)
+        col1, col2 = st.columns(2)
+        with col1:
+            st.markdown(f'<div class="metric-card"><div class="metric-value">{len(sorted_tasks)}</div><div class="metric-label">Total Tasks</div></div>', unsafe_allow_html=True)
+        # with col2:
+        #     high_priority = len([t for t in sorted_tasks if t["priority_score"] > 0.7])
+        #     st.markdown(f'<div class="metric-card"><div class="metric-value">{high_priority}</div><div class="metric-label">High Priority</div></div>', unsafe_allow_html=True)
+        with col2:
+            today = datetime.now()
+            due_today = len([t for t in sorted_tasks if t["due_date_time"].date() == today.date()])
+            st.markdown(f'<div class="metric-card"><div class="metric-value">{due_today}</div><div class="metric-label">Due Today</div></div>', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+        
+        # Display tasks with priority-based styling
+        for idx, task in enumerate(sorted_tasks):
+            priority_class = "high-priority" if task["priority_score"] > 0.7 else "medium-priority"
+            
+            # Create a single row for task and buttons
+            task_container = st.container()
+            with task_container:
+                cols = st.columns([0.8, 0.1, 0.1])
+                
+                # Task content in first column
+                with cols[0]:
+                    st.markdown(f"""
+                        <div class="priority-task {priority_class}">
+                            <div class="task-content">
+                                <div class="task-header">
+                                    <span class="task-title">{task["description"]}</span>
+                                    <span class="priority-score">Priority: {task["priority_score"]:.2f}</span>
+                                </div>
+                                <div class="task-details">
+                                    <span class="task-stat">Due: {task["due_date_time"].strftime("%d %b, %I:%M %p")}</span>
+                                    <span class="task-stat">Complexity: {task["complexity"]}</span>
+                                </div>
+                            </div>
+                        </div>
+                    """, unsafe_allow_html=True)
+                st.session_state.editing_task_id = None
+                # Edit button
+                with cols[1]:
+                    if st.button("✏️", key=f"edit_{idx}", help="Edit task"):
+                        st.session_state.editing_task_id = idx
+                
+                # Delete button
+                with cols[2]:
+                    if st.button("🗑️", key=f"delete_{idx}", help="Delete task"):
+                        st.session_state.tasks.pop(idx)
+                        st.success("Task deleted!")
+                        st.rerun()
+                
+                # Show edit form below the task if being edited
+                if st.session_state.editing_task_id == idx:
+                    with st.form(key=f"edit_form_{idx}"):
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            new_description = st.text_input("Description", value=task["description"])
+                            new_complexity = st.slider("Complexity", 1, 10, value=task["complexity"])
+                        with col2:
+                            new_due_date = st.date_input("Due Date", value=task["due_date_time"].date())
+                            new_due_time = st.time_input("Due Time", value=task["due_date_time"].time())
+                        
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            if st.form_submit_button("💾 Save"):
+                                # Update task
+                                task["description"] = new_description
+                                task["due_date_time"] = datetime.combine(new_due_date, new_due_time)
+                                task["time_remaining"] = task["due_date_time"] - datetime.now()
+                                task["complexity"] = new_complexity
+                                
+                                # Recalculate priority
+                                task["priority_score"] = calculate_priority_score(
+                                    task["predicted_intent_score"],
+                                    task["predicted_emotion"],
+                                    task["predicted_label_name"],
+                                    task["time_remaining"],
+                                    task["complexity"],
+                                    get_emotion_category(task["predicted_label_name"])
+                                )
+                                st.session_state.editing_task_id = None
+                                st.success("Task updated!")
+                                st.rerun()
+                        
+                        with col2:
+                            if st.form_submit_button("❌ Cancel"):
+                                st.session_state.editing_task_id = None
+                                st.rerun()
+
+    # AI Plan Section
+    if st.session_state.tasks:
+        st.markdown('<div class="custom-card">', unsafe_allow_html=True)
+        st.markdown('<h3>⏰ AI Task Planning</h3>', unsafe_allow_html=True)
+        
+        col_date, col_time = st.columns(2)
+        
+        with col_date:
+            plan_date = st.date_input("Select Plan Date", datetime.now().date())
+        
+        with col_time:
+            plan_time = st.time_input("Select Plan Start Time", datetime.now().time())
+        
+        selected_datetime = datetime.combine(plan_date, plan_time)
+
+        if st.button("📅 Generate AI Plan"):
+            suggestion = get_llama_suggestion(
+                st.session_state.overall_emotion_label, 
+                st.session_state.tasks, 
+                selected_datetime  # Pass full datetime object
+            )
+            st.markdown(f'<div class="info-box">{suggestion}</div>', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+

task_css.py

@@ -0,0 +1,458 @@
+def get_custom_css():
+    return """
+    <style>
+    :root {
+        /* Refined Color Palette */
+        --primary-blue: #3B82F6;        /* Vibrant Blue */
+        --primary-dark: #1E40AF;        /* Deeper Blue */
+        --accent-teal: #0EA5E9;         /* Bright Teal */
+        --background-light: #F9FAFB;    /* Soft White */
+        --text-dark: #1E293B;           /* Deep Navy */
+        --text-medium: #475569;         /* Medium Slate */
+        --accent-orange: #F97316;       /* Warm Orange */
+        --success-green: #10B981;       /* Emerald Green */
+        --warning-yellow: #FBBF24;      /* Amber Yellow */
+        --error-red: #EF4444;           /* Cherry Red */
+        
+        /* Refined Gradients */
+        --gradient-primary: linear-gradient(135deg, var(--primary-blue), var(--primary-dark));
+        --gradient-accent: linear-gradient(135deg, var(--accent-teal), #38BDF8);
+        --gradient-warm: linear-gradient(135deg, var(--accent-orange), #FB923C);
+    }
+
+    /* Global Reset with Professional Typography */
+    body, .stApp {
+        font-family: 'Inter', system-ui, -apple-system, sans-serif;
+        background-color: var(--background-light) !important;
+        color: var(--text-dark);
+        line-height: 1.6;
+        letter-spacing: -0.011em;
+    }
+
+    /* App Container with Refined Depth */
+    [data-testid="stAppViewContainer"] {
+        background-color: var(--background-light) !important;
+        max-width: 1100px;
+        margin: 0 auto;
+        padding: 2.5rem;
+        border-radius: 16px;
+        box-shadow: 
+            0 20px 25px -5px rgba(59, 130, 246, 0.1),
+            0 10px 10px -5px rgba(59, 130, 246, 0.04),
+            inset 0 1px 0 rgba(255, 255, 255, 0.8);
+        transition: all 0.3s ease;
+    }
+
+    /* Professional Header */
+    .main-header {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        margin-bottom: 2rem;
+        color: var(--primary-blue);
+        font-size: 2rem;
+        font-weight: 700;
+        letter-spacing: -0.03em;
+    }
+
+    .main-header::before {
+        
+        margin-right: 15px;
+        font-size: 2.2rem;
+        transition: transform 0.3s ease;
+    }
+
+    .main-title:hover::before {
+        transform: scale(1.1) rotate(5deg);
+    }
+
+    /* Professional Card Sections */
+    .emotion-analysis, .task-input {
+        background-color: white;
+        border-radius: 12px;
+        padding: 1.8rem;
+        box-shadow: 
+            0 4px 6px -1px rgba(59, 130, 246, 0.1),
+            0 2px 4px -1px rgba(59, 130, 246, 0.06);
+        margin-bottom: 1.5rem;
+        transition: all 0.2s ease;
+        border-top: 3px solid var(--primary-blue);
+    }
+
+    .emotion-analysis:hover, .task-input:hover {
+        transform: translateY(-3px);
+        box-shadow: 
+            0 10px 15px -3px rgba(59, 130, 246, 0.1),
+            0 4px 6px -2px rgba(59, 130, 246, 0.05);
+    }
+
+    /* Section Headers */
+    .stMarkdown h3 {
+        color: var(--primary-blue);
+        font-weight: 600;
+        font-size: 1.3rem;
+        margin-bottom: 1rem;
+        letter-spacing: -0.01em;
+        border-bottom: 1px solid rgba(59, 130, 246, 0.2);
+        padding-bottom: 0.5rem;
+    }
+
+    /* Polished Input Elements */
+    .stTextArea textarea, 
+    .stTextInput>div>div>input {
+        border: 1px solid rgba(59, 130, 246, 0.3) !important;
+        border-radius: 8px !important;
+        padding: 12px 14px !important;
+        background-color: white !important;
+        color: var(--text-dark) !important;
+        font-weight: 400;
+        transition: all 0.2s ease !important;
+        box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05) !important;
+    }
+
+    .stTextArea textarea:focus, 
+    .stTextInput>div>div>input:focus {
+        border-color: var(--primary-blue) !important;
+        box-shadow: 
+            0 0 0 3px rgba(59, 130, 246, 0.15) !important,
+            0 1px 2px rgba(0, 0, 0, 0.05) !important;
+        outline: none !important;
+    }
+
+    /* Contextual Badges */
+    .emotion-badge {
+        background: var(--gradient-accent);
+        color: white !important;
+        border-radius: 6px;
+        padding: 8px 12px;
+        font-weight: 600;
+        display: inline-block;
+        margin-top: 10px;
+        box-shadow: 0 2px 4px rgba(14, 165, 233, 0.2);
+    }
+
+    .warning-badge {
+        background: var(--gradient-warm);
+        color: white !important;
+        border-radius: 6px;
+        padding: 8px 12px;
+        font-weight: 600;
+        display: inline-block;
+        box-shadow: 0 2px 4px rgba(249, 115, 22, 0.2);
+    }
+
+    /* Professional Button */
+    .stButton>button {
+        background: var(--gradient-primary) !important;
+        color: white !important;
+        border: none !important;
+        border-radius: 8px !important;
+        padding: 10px 20px !important;
+        font-weight: 600;
+        font-size: 0.9rem;
+        letter-spacing: 0.02em;
+        transition: all 0.2s ease !important;
+        box-shadow: 
+            0 4px 6px -1px rgba(59, 130, 246, 0.2),
+            0 2px 4px -1px rgba(59, 130, 246, 0.1);
+    }
+
+    .stButton>button:hover {
+        transform: translateY(-2px);
+        box-shadow: 
+            0 6px 10px -1px rgba(59, 130, 246, 0.25),
+            0 4px 6px -1px rgba(59, 130, 246, 0.15);
+    }
+
+    .stButton>button:active {
+        transform: translateY(0);
+        box-shadow: 
+            0 2px 4px -1px rgba(59, 130, 246, 0.2),
+            0 1px 2px -1px rgba(59, 130, 246, 0.1);
+    }
+
+    /* Improved Slider */
+    .stSlider {
+        margin-top: 12px;
+    }
+
+    .stSlider > div > div > div {
+        background-color: #CBD5E1 !important;
+        height: 6px !important;
+        border-radius: 3px !important;
+    }
+
+    .stSlider > div > div > div > div {
+        background: var(--primary-blue) !important;
+        box-shadow: 0 0 0 2px white, 0 0 0 3px rgba(59, 130, 246, 0.2) !important;
+        width: 18px !important;
+        height: 18px !important;
+        border-radius: 50% !important;
+        transition: transform 0.2s ease !important;
+    }
+
+    .stSlider > div > div > div > div:hover {
+        transform: scale(1.15) !important;
+    }
+
+    /* Progress Bar */
+    .stProgress > div > div > div {
+        background-color: var(--primary-blue) !important;
+        border-radius: 4px !important;
+    }
+
+    /* Select Boxes */
+    .stSelectbox label {
+        color: var(--text-medium) !important;
+        font-weight: 500 !important;
+    }
+
+    .stSelectbox > div > div > div {
+        background-color: white !important;
+        border: 1px solid rgba(59, 130, 246, 0.3) !important;
+        border-radius: 8px !important;
+        padding: 4px 8px !important;
+    }
+
+    /* Checkbox */
+    .stCheckbox label {
+        color: var(--text-medium) !important;
+        font-size: 0.95rem !important;
+    }
+
+    /* Tabs */
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2px;
+        background-color: rgba(59, 130, 246, 0.1) !important;
+        border-radius: 8px !important;
+        padding: 2px !important;
+    }
+
+    .stTabs [data-baseweb="tab"] {
+        background-color: transparent !important;
+        border-radius: 6px !important;
+        padding: 8px 16px !important;
+        border: none !important;
+        color: var(--text-medium) !important;
+        font-weight: 500 !important;
+        transition: all 0.2s ease !important;
+    }
+
+    .stTabs [aria-selected="true"] {
+        background-color: white !important;
+        color: var(--primary-blue) !important;
+        font-weight: 600 !important;
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    }
+
+    /* Info Boxes */
+    .info-box {
+        background-color: rgba(14, 165, 233, 0.1);
+        border-left: 3px solid var(--accent-teal);
+        border-radius: 6px;
+        padding: 15px;
+        margin: 15px 0;
+        color: var(--text-dark);
+    }
+    
+    .success-box {
+        background-color: rgba(16, 185, 129, 0.1);
+        border-left: 3px solid var(--success-green);
+        border-radius: 6px;
+        padding: 15px;
+        margin: 15px 0;
+    }
+    
+    .warning-box {
+        background-color: rgba(251, 191, 36, 0.1);
+        border-left: 3px solid var(--warning-yellow);
+        border-radius: 6px;
+        padding: 15px;
+        margin: 15px 0;
+    }
+    
+    .error-box {
+        background-color: rgba(239, 68, 68, 0.1);
+        border-left: 3px solid var(--error-red);
+        border-radius: 6px;
+        padding: 15px;
+        margin: 15px 0;
+    }
+
+    /* Data Elements */
+    .metric-card {
+        background-color: white;
+        border-radius: 10px;
+        padding: 20px;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
+        border-top: 3px solid var(--primary-blue);
+    }
+    
+    .metric-value {
+        font-size: 2rem;
+        font-weight: 700;
+        color: var(--primary-blue);
+    }
+    
+    .metric-label {
+        font-size: 0.9rem;
+        color: var(--text-medium);
+        margin-top: 5px;
+    }
+
+    /* Action Menu */
+    .action-menu {
+        position: relative;
+        display: inline-block;
+    }
+
+    .action-menu-content {
+        display: none;
+        position: absolute;
+        right: 0;
+        background-color: white;
+        min-width: 120px;
+        box-shadow: 0 8px 16px rgba(0, 0, 0, 0.2);
+        z-index: 1;
+        border-radius: 8px;
+        overflow: hidden;
+    }
+
+    .action-menu-content a {
+        color: var(--text-dark);
+        padding: 12px 16px;
+        text-decoration: none;
+        display: block;
+        transition: background-color 0.2s ease;
+    }
+
+    .action-menu-content a:hover {
+        background-color: var(--primary-blue);
+        color: white;
+    }
+
+    .action-menu:hover .action-menu-content {
+        display: block;
+    }
+
+    .action-menu .three-dots {
+        cursor: pointer;
+        font-size: 1.5rem;
+        color: var(--text-medium);
+    }
+
+    /* Task Content Styling */
+    .task-content {
+        flex: 1;
+        padding-right: 20px;
+    }
+
+    .task-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 8px;
+    }
+
+    .task-title {
+        font-weight: 600;
+        color: var(--text-dark);
+        font-size: 1rem;
+    }
+
+    .priority-score {
+        background: var(--gradient-primary);
+        color: white;
+        padding: 4px 8px;
+        border-radius: 4px;
+        font-size: 0.85rem;
+        font-weight: 600;
+    }
+
+    .task-details {
+        display: flex;
+        gap: 16px;
+    }
+
+    .task-stat {
+        color: var(--text-medium);
+        font-size: 0.9rem;
+    }
+
+    /* Priority Task List */
+    .priority-task {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        padding: 15px;
+        border-radius: 8px;
+        margin-bottom: 8px;
+        background-color: white;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+    }
+
+    .high-priority {
+        border-left: 4px solid var(--error-red);
+    }
+
+    .medium-priority {
+        border-left: 4px solid var(--warning-yellow);
+    }
+
+    /* Responsive Design */
+    @media (max-width: 768px) {
+        [data-testid="stAppViewContainer"] {
+            padding: 1.2rem;
+            border-radius: 12px;
+        }
+        
+        .main-title {
+            font-size: 1.8rem;
+        }
+        
+        .emotion-analysis, .task-input {
+            padding: 1.2rem;
+        }
+        
+        .metric-value {
+            font-size: 1.6rem;
+        }
+    }
+
+    /* Loading Spinner */
+    .loading-container {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        height: 60vh;
+    }
+    
+    .loading-spinner {
+        width: 50px;
+        height: 50px;
+        border: 5px solid #f3f3f3;
+        border-top: 5px solid var(--primary-blue);
+        border-radius: 50%;
+        animation: spin 1s linear infinite;
+        margin-bottom: 20px;
+    }
+    
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+    
+    /* Status Messages */
+    .status-message {
+        background: white;
+        padding: 10px 15px;
+        border-radius: 8px;
+        margin: 5px 0;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    </style>
+    """

task_prioritizer.py

@@ -0,0 +1,105 @@
+import torch
+from transformers import BertTokenizer, BertForSequenceClassification, DistilBertForSequenceClassification
+from datetime import datetime
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load the intent classifier model and tokenizer
+num_intent_labels = 151  # Set the correct number of labels for the intent classifier
+intent_model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=num_intent_labels)
+intent_model.load_state_dict(torch.load("intent_classifier.pth"))
+intent_tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+intent_model.to(device)
+intent_model.eval()
+
+# Load the emotions model and tokenizer
+emotions_model = DistilBertForSequenceClassification.from_pretrained("./saved_model")
+emotions_tokenizer = BertTokenizer.from_pretrained("./saved_model")
+emotions_model.to(device)
+emotions_model.eval()
+
+# Define the label names for emotions
+emotion_label_names = ["admiration", "amusement", "anger", "annoyance", "approval", "caring", "confusion", "curiosity", "desire", "disappointment", "disapproval", "disgust", "embarrassment", "excitement", "fear", "gratitude", "grief", "joy", "love", "nervousness", "optimism", "pride", "realization", "relief", "remorse", "sadness", "surprise", "neutral"]
+
+def predict_intent(sentence):
+    inputs = intent_tokenizer(sentence, return_tensors="pt", padding="max_length", truncation=True, max_length=128)
+    inputs = {key: val.to(device) for key, val in inputs.items()}
+
+    with torch.no_grad():
+        outputs = intent_model(**inputs)
+        predicted_class = torch.argmax(outputs.logits, dim=1).cpu().numpy()[0]
+
+    return predicted_class
+
+def predict_emotion(sentence):
+    inputs = emotions_tokenizer(sentence, return_tensors="pt", padding="max_length", truncation=True, max_length=128)
+    inputs = {key: val.to(device) for key, val in inputs.items() if key != "token_type_ids"}
+
+    with torch.no_grad():
+        outputs = emotions_model(**inputs)
+        predicted_class = torch.argmax(outputs.logits, dim=1).cpu().numpy()[0]
+
+    return predicted_class, emotion_label_names[predicted_class]
+
+def calculate_priority_score(intent, emotion, time_remaining):
+    # Example priority score calculation
+    intent_weight = 0.4
+    emotion_weight = 0.3
+    time_weight = 0.3
+
+    # Normalize time_remaining to a score between 0 and 1
+    time_score = max(0, min(1, 1 - (time_remaining.total_seconds() / (24 * 3600))))
+
+    # Calculate priority score
+    priority_score = (intent * intent_weight) + (emotion * emotion_weight) + (time_score * time_weight)
+    return priority_score
+
+def prioritize_task(task_description, due_date_time, predicted_emotion, predicted_label_name):
+    predicted_intent = predict_intent(task_description)
+    
+    # Calculate time remaining until the due date and time
+    due_date_time = datetime.strptime(due_date_time, "%Y-%m-%d %H:%M:%S")
+    time_remaining = due_date_time - datetime.now()
+    
+    priority_score = calculate_priority_score(predicted_intent, predicted_emotion, time_remaining)
+    
+    return {
+        "description": task_description,
+        "due_date_time": due_date_time,
+        "time_remaining": time_remaining,
+        "predicted_intent": predicted_intent,
+        "predicted_emotion": predicted_emotion,
+        "predicted_label_name": predicted_label_name,
+        "priority_score": priority_score
+    }
+
+# Example tasks
+tasks = [
+    {"description": "Finish the report by tomorrow.", "due_date_time": "2025-03-02 09:00:00"},
+    {"description": "meeting", "due_date_time": "2025-03-02 12:00:00"},
+    {"description": "listen to music.", "due_date_time": "2025-03-02 15:00:00"},
+    {"description": "daily linkedin queens game.", "due_date_time": "2025-03-02 18:00:00"},
+    {"description": "prepare ppt", "due_date_time": "2025-03-02 21:00:00"}
+]
+
+# Overall emotion sentence
+emotion_sentence = "I am feeling very tired and stressed now"
+predicted_emotion, predicted_label_name = predict_emotion(emotion_sentence)
+
+# Prioritize tasks
+prioritized_tasks = []
+for task in tasks:
+    prioritized_tasks.append(prioritize_task(task["description"], task["due_date_time"], predicted_emotion, predicted_label_name))
+
+# Reorder tasks based on priority score (descending order)
+prioritized_tasks.sort(key=lambda x: x["priority_score"], reverse=True)
+
+# Print prioritized tasks
+for task in prioritized_tasks:
+    print(f"Task Description: '{task['description']}'")
+    print(f"Due Date and Time: {task['due_date_time']}")
+    print(f"Time Remaining: {task['time_remaining']}")
+    print(f"Predicted Intent: {task['predicted_intent']}")
+    print(f"Predicted Emotion: {task['predicted_emotion']} ({task['predicted_label_name']})")
+    print(f"Priority Score: {task['priority_score']:.4f}")
+    print()

task_ui.py

@@ -0,0 +1,326 @@
+def get_custom_css():
+    return """
+    <style>
+    :root {
+        /* Refined Color Palette */
+        --primary-blue: #3B82F6;        /* Vibrant Blue */
+        --primary-dark: #1E40AF;        /* Deeper Blue */
+        --accent-teal: #0EA5E9;         /* Bright Teal */
+        --background-light: #F9FAFB;    /* Soft White */
+        --text-dark: #1E293B;           /* Deep Navy */
+        --text-medium: #475569;         /* Medium Slate */
+        --accent-orange: #F97316;       /* Warm Orange */
+        --success-green: #10B981;       /* Emerald Green */
+        --warning-yellow: #FBBF24;      /* Amber Yellow */
+        --error-red: #EF4444;           /* Cherry Red */
+        
+        /* Refined Gradients */
+        --gradient-primary: linear-gradient(135deg, var(--primary-blue), var(--primary-dark));
+        --gradient-accent: linear-gradient(135deg, var(--accent-teal), #38BDF8);
+        --gradient-warm: linear-gradient(135deg, var(--accent-orange), #FB923C);
+    }
+
+    /* Global Reset with Professional Typography */
+    body, .stApp {
+        font-family: 'Inter', system-ui, -apple-system, sans-serif;
+        background-color: var(--background-light) !important;
+        color: var(--text-dark);
+        line-height: 1.6;
+        letter-spacing: -0.011em;
+    }
+
+    /* App Container with Refined Depth */
+    [data-testid="stAppViewContainer"] {
+        background-color: var(--background-light) !important;
+        max-width: 1100px;
+        margin: 0 auto;
+        padding: 2.5rem;
+        border-radius: 16px;
+        box-shadow: 
+            0 20px 25px -5px rgba(59, 130, 246, 0.1),
+            0 10px 10px -5px rgba(59, 130, 246, 0.04),
+            inset 0 1px 0 rgba(255, 255, 255, 0.8);
+        transition: all 0.3s ease;
+    }
+
+    /* Professional Header */
+    .main-title {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        margin-bottom: 2rem;
+        color: var(--primary-blue);
+        font-size: 2.5rem;
+        font-weight: 700;
+        letter-spacing: -0.03em;
+    }
+
+    .main-title::before {
+        
+        margin-right: 15px;
+        font-size: 2.2rem;
+        transition: transform 0.3s ease;
+    }
+
+    .main-title:hover::before {
+        transform: scale(1.1) rotate(5deg);
+    }
+
+    /* Professional Card Sections */
+    .emotion-analysis, .task-input {
+        background-color: white;
+        border-radius: 12px;
+        padding: 1.8rem;
+        box-shadow: 
+            0 4px 6px -1px rgba(59, 130, 246, 0.1),
+            0 2px 4px -1px rgba(59, 130, 246, 0.06);
+        margin-bottom: 1.5rem;
+        transition: all 0.2s ease;
+        border-top: 3px solid var(--primary-blue);
+    }
+
+    .emotion-analysis:hover, .task-input:hover {
+        transform: translateY(-3px);
+        box-shadow: 
+            0 10px 15px -3px rgba(59, 130, 246, 0.1),
+            0 4px 6px -2px rgba(59, 130, 246, 0.05);
+    }
+
+    /* Section Headers */
+    .stMarkdown h3 {
+        color: var(--primary-blue);
+        font-weight: 600;
+        font-size: 1.3rem;
+        margin-bottom: 1rem;
+        letter-spacing: -0.01em;
+        border-bottom: 1px solid rgba(59, 130, 246, 0.2);
+        padding-bottom: 0.5rem;
+    }
+
+    /* Polished Input Elements */
+    .stTextArea textarea, 
+    .stTextInput>div>div>input {
+        border: 1px solid rgba(59, 130, 246, 0.3) !important;
+        border-radius: 8px !important;
+        padding: 12px 14px !important;
+        background-color: white !important;
+        color: var(--text-dark) !important;
+        font-weight: 400;
+        transition: all 0.2s ease !important;
+        box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05) !important;
+    }
+
+    .stTextArea textarea:focus, 
+    .stTextInput>div>div>input:focus {
+        border-color: var(--primary-blue) !important;
+        box-shadow: 
+            0 0 0 3px rgba(59, 130, 246, 0.15) !important,
+            0 1px 2px rgba(0, 0, 0, 0.05) !important;
+        outline: none !important;
+    }
+
+    /* Contextual Badges */
+    .emotion-badge {
+        background: var(--gradient-accent);
+        color: white !important;
+        border-radius: 6px;
+        padding: 8px 12px;
+        font-weight: 600;
+        display: inline-block;
+        margin-top: 10px;
+        box-shadow: 0 2px 4px rgba(14, 165, 233, 0.2);
+    }
+
+    .warning-badge {
+        background: var(--gradient-warm);
+        color: white !important;
+        border-radius: 6px;
+        padding: 8px 12px;
+        font-weight: 600;
+        display: inline-block;
+        box-shadow: 0 2px 4px rgba(249, 115, 22, 0.2);
+    }
+
+    /* Professional Button */
+    .stButton>button {
+        background: var(--gradient-primary) !important;
+        color: white !important;
+        border: none !important;
+        border-radius: 8px !important;
+        padding: 10px 20px !important;
+        font-weight: 600;
+        font-size: 0.9rem;
+        letter-spacing: 0.02em;
+        transition: all 0.2s ease !important;
+        box-shadow: 
+            0 4px 6px -1px rgba(59, 130, 246, 0.2),
+            0 2px 4px -1px rgba(59, 130, 246, 0.1);
+    }
+
+    .stButton>button:hover {
+        transform: translateY(-2px);
+        box-shadow: 
+            0 6px 10px -1px rgba(59, 130, 246, 0.25),
+            0 4px 6px -1px rgba(59, 130, 246, 0.15);
+    }
+
+    .stButton>button:active {
+        transform: translateY(0);
+        box-shadow: 
+            0 2px 4px -1px rgba(59, 130, 246, 0.2),
+            0 1px 2px -1px rgba(59, 130, 246, 0.1);
+    }
+
+    /* Improved Slider */
+    .stSlider {
+        margin-top: 12px;
+    }
+
+    .stSlider > div > div > div {
+        background-color: #CBD5E1 !important;
+        height: 6px !important;
+        border-radius: 3px !important;
+    }
+
+    .stSlider > div > div > div > div {
+        background: var(--primary-blue) !important;
+        box-shadow: 0 0 0 2px white, 0 0 0 3px rgba(59, 130, 246, 0.2) !important;
+        width: 18px !important;
+        height: 18px !important;
+        border-radius: 50% !important;
+        transition: transform 0.2s ease !important;
+    }
+
+    .stSlider > div > div > div > div:hover {
+        transform: scale(1.15) !important;
+    }
+
+    /* Progress Bar */
+    .stProgress > div > div > div {
+        background-color: var(--primary-blue) !important;
+        border-radius: 4px !important;
+    }
+
+    /* Select Boxes */
+    .stSelectbox label {
+        color: var(--text-medium) !important;
+        font-weight: 500 !important;
+    }
+
+    .stSelectbox > div > div > div {
+        background-color: white !important;
+        border: 1px solid rgba(59, 130, 246, 0.3) !important;
+        border-radius: 8px !important;
+        padding: 4px 8px !important;
+    }
+
+    /* Checkbox */
+    .stCheckbox label {
+        color: var(--text-medium) !important;
+        font-size: 0.95rem !important;
+    }
+
+    /* Tabs */
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2px;
+        background-color: rgba(59, 130, 246, 0.1) !important;
+        border-radius: 8px !important;
+        padding: 2px !important;
+    }
+
+    .stTabs [data-baseweb="tab"] {
+        background-color: transparent !important;
+        border-radius: 6px !important;
+        padding: 8px 16px !important;
+        border: none !important;
+        color: var(--text-medium) !important;
+        font-weight: 500 !important;
+        transition: all 0.2s ease !important;
+    }
+
+    .stTabs [aria-selected="true"] {
+        background-color: white !important;
+        color: var(--primary-blue) !important;
+        font-weight: 600 !important;
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    }
+
+    /* Info Boxes */
+    .info-box {
+        background-color: rgba(14, 165, 233, 0.1);
+        border-left: 3px solid var(--accent-teal);
+        border-radius: 6px;
+        padding: 15px;
+        margin: 15px 0;
+        color: var(--text-dark);
+    }
+    
+    .success-box {
+        background-color: rgba(16, 185, 129, 0.1);
+        border-left: 3px solid var(--success-green);
+        border-radius: 6px;
+        padding: 15px;
+        margin: 15px 0;
+    }
+    
+    .warning-box {
+        background-color: rgba(251, 191, 36, 0.1);
+        border-left: 3px solid var(--warning-yellow);
+        border-radius: 6px;
+        padding: 15px;
+        margin: 15px 0;
+    }
+    
+    .error-box {
+        background-color: rgba(239, 68, 68, 0.1);
+        border-left: 3px solid var(--error-red);
+        border-radius: 6px;
+        padding: 15px;
+        margin: 15px 0;
+    }
+
+    /* Data Elements */
+    .metric-card {
+        background-color: white;
+        border-radius: 10px;
+        padding: 20px;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.05);
+        border-top: 3px solid var(--primary-blue);
+    }
+    
+    .metric-value {
+        font-size: 2rem;
+        font-weight: 700;
+        color: var(--primary-blue);
+    }
+    
+    .metric-label {
+        font-size: 0.9rem;
+        color: var(--text-medium);
+        margin-top: 5px;
+    }
+
+    /* Responsive Design */
+    @media (max-width: 768px) {
+        [data-testid="stAppViewContainer"] {
+            padding: 1.2rem;
+            border-radius: 12px;
+        }
+        
+        .main-title {
+            font-size: 1.8rem;
+        }
+        
+        .emotion-analysis, .task-input {
+            padding: 1.2rem;
+        }
+        
+        .metric-value {
+            font-size: 1.6rem;
+        }
+    }
+    </style>
+    """

test_results.csv

@@ -0,0 +1,5428 @@
+true_labels,predicted_labels
+25,24
+0,0
+13,0
+15,15
+27,27
+15,15
+15,15
+15,0
+24,24
+25,9
+3,27
+1,1
+8,8
+0,0
+14,14
+10,10
+14,11
+25,27
+1,1
+15,15
+1,3
+24,7
+27,27
+27,27
+6,27
+27,27
+0,18
+27,27
+27,4
+7,7
+27,27
+27,7
+27,27
+20,20
+4,27
+27,27
+27,27
+27,27
+27,27
+0,1
+10,27
+5,27
+27,27
+27,27
+17,0
+27,10
+1,1
+1,1
+27,10
+4,27
+27,27
+3,1
+10,27
+27,27
+14,14
+27,4
+8,27
+27,27
+24,24
+15,15
+27,6
+18,0
+18,18
+27,8
+15,15
+25,24
+14,5
+6,7
+9,27
+3,3
+3,10
+27,27
+27,27
+0,1
+5,5
+10,3
+0,0
+14,27
+4,4
+2,3
+0,27
+20,27
+15,15
+7,7
+3,27
+6,7
+10,10
+27,27
+0,18
+15,15
+7,17
+10,5
+27,27
+22,4
+26,26
+27,27
+14,14
+13,17
+27,27
+5,0
+3,27
+6,6
+27,27
+9,0
+2,27
+4,27
+10,10
+3,27
+2,3
+27,27
+0,0
+27,27
+5,27
+17,18
+27,27
+0,0
+27,27
+20,20
+5,5
+27,27
+26,26
+27,27
+1,1
+4,4
+7,7
+8,2
+0,27
+4,10
+1,1
+3,27
+7,7
+27,14
+3,27
+22,0
+20,27
+27,27
+14,14
+10,11
+2,2
+27,8
+27,27
+10,10
+18,18
+6,4
+1,1
+11,11
+17,17
+27,7
+20,27
+27,27
+27,27
+27,27
+3,3
+12,1
+15,15
+27,27
+27,0
+27,26
+27,27
+27,5
+27,27
+10,27
+27,27
+24,24
+27,7
+2,2
+7,7
+27,27
+2,2
+15,15
+27,27
+7,7
+1,1
+9,8
+4,15
+1,1
+26,14
+5,24
+0,0
+27,0
+25,25
+6,6
+24,27
+27,27
+22,22
+27,27
+15,15
+26,3
+27,27
+3,3
+15,15
+10,3
+19,14
+0,0
+17,1
+5,5
+26,26
+27,27
+27,27
+3,9
+22,27
+27,27
+11,3
+27,27
+27,27
+27,27
+27,27
+22,27
+17,17
+20,20
+27,27
+14,27
+17,0
+15,15
+27,27
+27,27
+18,18
+0,0
+15,15
+21,0
+3,3
+5,27
+27,0
+10,24
+27,4
+27,27
+11,2
+27,27
+3,27
+27,27
+4,4
+3,3
+27,27
+27,27
+0,0
+27,27
+27,26
+27,27
+27,27
+27,27
+27,27
+12,12
+18,18
+27,27
+3,27
+27,27
+11,2
+0,0
+27,27
+25,27
+14,14
+27,27
+9,10
+6,6
+27,8
+25,25
+2,3
+27,4
+27,27
+2,3
+10,10
+7,7
+27,27
+14,14
+8,8
+22,27
+9,9
+11,11
+15,15
+4,4
+15,15
+11,9
+24,24
+1,1
+8,14
+27,27
+27,27
+27,27
+0,0
+14,25
+1,1
+27,27
+11,11
+5,27
+27,27
+0,17
+0,0
+11,2
+27,27
+27,27
+7,7
+26,7
+27,27
+20,26
+15,15
+6,6
+27,27
+5,27
+27,27
+27,27
+7,7
+6,18
+27,27
+27,5
+9,27
+27,11
+26,27
+7,12
+22,27
+7,7
+18,18
+27,7
+27,27
+27,27
+0,0
+3,7
+5,5
+27,27
+27,27
+11,11
+15,15
+0,0
+27,27
+27,27
+10,10
+0,4
+1,1
+10,10
+26,26
+15,15
+27,27
+0,0
+2,11
+27,2
+27,27
+8,20
+14,14
+8,18
+0,0
+4,18
+15,15
+8,17
+1,0
+15,15
+10,9
+27,27
+2,2
+27,2
+27,7
+1,1
+1,1
+27,27
+13,27
+25,26
+0,0
+27,27
+3,27
+6,7
+27,27
+27,27
+5,27
+15,15
+5,20
+3,27
+8,8
+13,15
+27,27
+7,27
+10,10
+9,2
+5,27
+2,2
+27,27
+2,27
+1,1
+27,10
+26,3
+27,26
+25,26
+27,27
+15,15
+10,27
+27,27
+2,2
+0,0
+1,1
+1,1
+25,25
+3,7
+27,27
+17,17
+3,2
+27,0
+27,2
+13,13
+10,27
+15,17
+27,27
+27,27
+4,27
+7,17
+4,10
+4,27
+2,3
+4,27
+27,7
+0,27
+17,27
+3,27
+27,27
+10,10
+11,11
+13,0
+5,18
+27,27
+27,27
+27,8
+4,27
+6,7
+4,2
+24,24
+20,20
+6,6
+3,27
+27,27
+13,13
+27,27
+0,0
+27,27
+27,27
+0,0
+27,27
+24,24
+27,27
+0,0
+9,25
+10,27
+27,27
+24,24
+27,27
+27,27
+10,11
+8,27
+3,10
+0,0
+7,6
+12,12
+4,20
+4,6
+22,27
+26,26
+8,25
+20,20
+15,15
+8,8
+27,27
+4,4
+20,20
+27,27
+18,7
+27,7
+4,7
+27,27
+3,3
+2,3
+18,18
+7,7
+10,27
+1,1
+2,2
+4,27
+15,15
+5,27
+0,1
+27,27
+7,7
+27,27
+15,15
+15,15
+7,26
+0,18
+10,27
+10,6
+17,1
+3,3
+27,27
+27,27
+27,27
+27,8
+10,10
+7,27
+27,27
+18,0
+27,27
+2,2
+27,27
+22,27
+7,7
+27,27
+4,4
+18,18
+5,15
+9,9
+3,14
+2,2
+2,2
+27,27
+14,14
+6,15
+10,7
+27,27
+20,27
+10,10
+27,27
+27,27
+0,20
+6,7
+27,27
+27,22
+27,27
+15,15
+27,27
+27,27
+15,15
+3,27
+27,27
+0,0
+2,2
+18,18
+27,27
+27,27
+17,0
+25,25
+7,7
+5,5
+27,27
+0,0
+4,27
+2,2
+3,27
+27,27
+2,27
+27,27
+8,27
+20,27
+0,0
+0,15
+17,14
+22,27
+0,0
+25,26
+11,3
+1,0
+27,27
+10,2
+7,7
+27,4
+4,18
+15,15
+5,8
+9,14
+15,15
+3,7
+25,25
+15,15
+15,15
+10,11
+27,7
+10,10
+11,11
+27,27
+2,2
+25,27
+27,27
+22,27
+2,2
+4,0
+10,27
+0,0
+1,1
+10,27
+20,20
+6,6
+18,18
+0,27
+4,17
+3,27
+11,11
+4,27
+18,18
+27,27
+27,27
+27,27
+1,0
+27,27
+3,27
+20,20
+3,27
+27,27
+15,15
+0,27
+27,27
+24,25
+0,0
+15,15
+2,27
+27,27
+3,2
+7,7
+27,27
+27,14
+27,27
+15,15
+15,15
+27,27
+15,15
+27,27
+12,12
+15,15
+20,27
+6,6
+13,13
+9,27
+10,10
+27,27
+0,0
+2,27
+0,0
+0,0
+10,10
+20,27
+11,2
+14,14
+0,0
+3,2
+4,4
+0,0
+6,9
+9,3
+25,27
+15,20
+14,14
+10,10
+27,3
+27,0
+27,27
+7,7
+27,27
+20,20
+13,13
+27,27
+27,4
+0,27
+10,10
+6,27
+27,27
+25,14
+4,4
+14,14
+27,27
+18,18
+25,3
+9,9
+3,27
+27,27
+27,27
+27,27
+27,27
+15,15
+2,2
+22,1
+0,0
+2,11
+3,27
+18,18
+0,0
+7,26
+18,18
+3,27
+10,10
+4,27
+4,4
+0,1
+17,17
+27,27
+3,3
+25,5
+27,24
+15,15
+18,18
+5,15
+0,0
+27,27
+3,27
+15,15
+4,4
+27,18
+7,7
+11,11
+0,8
+0,27
+15,15
+22,27
+10,10
+11,27
+27,27
+27,7
+27,0
+23,25
+22,27
+2,2
+27,3
+27,27
+27,27
+22,26
+14,14
+18,18
+7,14
+0,0
+0,0
+27,27
+7,7
+4,4
+17,17
+7,7
+27,27
+0,27
+27,27
+27,27
+0,0
+1,1
+27,3
+15,15
+7,6
+27,7
+27,27
+25,24
+0,0
+1,1
+27,3
+27,0
+27,18
+1,1
+27,27
+17,17
+0,0
+27,27
+27,6
+0,0
+27,27
+27,27
+2,15
+7,7
+15,0
+3,3
+17,1
+0,27
+27,27
+27,4
+17,1
+27,27
+27,27
+27,27
+27,0
+15,0
+19,25
+0,0
+9,6
+27,27
+9,9
+4,4
+27,27
+16,27
+27,3
+27,0
+15,0
+0,0
+27,27
+27,27
+2,2
+27,27
+27,2
+20,20
+17,20
+17,17
+11,3
+27,27
+25,8
+20,20
+15,15
+0,0
+13,0
+27,9
+7,27
+26,26
+27,1
+25,27
+27,2
+22,27
+10,10
+3,27
+2,2
+15,15
+4,27
+5,27
+27,27
+27,1
+3,3
+3,27
+15,15
+10,10
+27,27
+27,27
+27,27
+8,27
+0,27
+5,5
+8,8
+1,1
+27,27
+17,17
+5,5
+3,27
+12,27
+11,1
+23,0
+10,10
+27,27
+27,27
+6,6
+27,27
+7,7
+0,0
+0,0
+1,1
+14,14
+17,5
+1,1
+8,8
+24,24
+22,27
+0,15
+26,26
+11,11
+0,27
+4,27
+5,5
+0,0
+27,27
+1,1
+15,7
+5,14
+15,15
+11,1
+27,27
+2,27
+23,4
+15,15
+15,15
+17,25
+27,20
+3,27
+27,27
+27,27
+23,27
+15,15
+27,0
+27,27
+27,25
+20,8
+15,15
+0,13
+27,27
+27,24
+27,27
+27,27
+0,0
+15,15
+25,25
+27,27
+4,5
+15,15
+15,15
+27,26
+7,6
+17,17
+1,1
+13,27
+6,6
+15,15
+3,3
+27,26
+22,27
+27,27
+27,27
+27,27
+27,27
+10,27
+20,20
+2,27
+27,27
+27,1
+0,0
+6,7
+14,27
+27,27
+1,0
+4,4
+4,27
+15,15
+27,10
+12,9
+10,27
+7,26
+1,1
+26,26
+18,18
+7,7
+25,24
+27,27
+18,18
+9,27
+1,0
+15,15
+27,27
+2,27
+27,27
+27,7
+4,0
+20,20
+27,13
+27,27
+0,0
+9,27
+15,15
+27,10
+10,9
+22,26
+25,27
+15,15
+19,14
+4,4
+27,27
+5,17
+2,2
+5,18
+8,8
+27,27
+15,15
+0,0
+27,27
+11,9
+2,3
+25,24
+3,27
+27,27
+27,27
+0,0
+4,4
+13,17
+3,27
+7,7
+4,4
+1,1
+5,5
+1,1
+3,27
+4,7
+25,27
+27,27
+27,25
+5,5
+12,12
+1,1
+4,4
+0,0
+1,1
+0,27
+27,27
+27,27
+8,27
+27,27
+13,13
+2,1
+27,27
+1,10
+27,27
+7,7
+20,20
+27,4
+27,4
+20,20
+14,14
+3,27
+2,27
+10,10
+15,15
+27,7
+0,0
+0,0
+18,18
+27,10
+4,27
+4,0
+7,27
+18,18
+14,3
+1,1
+4,27
+18,18
+15,15
+15,15
+27,27
+11,3
+4,27
+26,7
+27,27
+27,27
+1,7
+15,0
+27,27
+27,27
+15,15
+4,4
+27,27
+27,7
+7,7
+27,27
+27,27
+10,27
+18,4
+7,7
+27,27
+27,10
+2,7
+9,20
+1,1
+20,4
+27,27
+27,27
+27,27
+15,15
+7,5
+0,0
+18,18
+27,7
+24,17
+3,10
+2,3
+0,17
+27,15
+4,4
+3,27
+20,27
+27,27
+27,27
+6,7
+27,27
+3,27
+4,27
+1,27
+0,15
+3,27
+14,1
+10,27
+24,24
+0,27
+27,27
+10,10
+15,15
+3,10
+20,20
+27,27
+0,0
+27,6
+2,27
+27,27
+27,27
+17,18
+6,27
+27,27
+0,0
+18,18
+26,6
+2,7
+27,27
+27,27
+25,25
+3,3
+1,1
+26,26
+27,27
+27,27
+3,27
+0,0
+27,27
+15,15
+17,17
+4,4
+25,27
+27,27
+10,6
+15,15
+27,27
+0,17
+27,6
+11,14
+4,0
+0,0
+18,27
+27,27
+18,8
+5,5
+27,27
+10,27
+27,27
+17,17
+2,14
+0,0
+0,0
+27,27
+17,27
+27,27
+0,0
+3,27
+27,27
+27,27
+7,27
+3,3
+18,18
+13,13
+1,1
+3,4
+0,0
+11,27
+27,27
+1,1
+0,0
+13,27
+26,26
+27,27
+20,20
+27,27
+17,18
+0,0
+5,17
+4,27
+27,27
+26,27
+27,27
+17,0
+0,17
+25,27
+17,17
+6,7
+27,27
+27,27
+27,27
+0,0
+27,7
+15,15
+27,27
+0,0
+15,15
+27,27
+27,27
+27,27
+26,26
+1,17
+4,3
+12,27
+11,3
+27,27
+27,27
+0,18
+15,15
+1,1
+22,27
+22,24
+27,27
+3,20
+1,1
+3,27
+27,27
+4,0
+0,18
+1,7
+2,7
+9,14
+4,4
+1,1
+26,26
+27,27
+27,27
+4,27
+2,2
+27,0
+3,9
+1,1
+0,0
+0,0
+0,0
+0,0
+6,6
+4,27
+0,0
+7,7
+27,27
+27,27
+1,27
+22,27
+27,27
+10,27
+7,7
+27,27
+27,4
+27,0
+7,7
+27,3
+15,15
+18,18
+27,27
+19,27
+26,26
+27,27
+27,27
+11,11
+27,27
+24,1
+27,27
+10,27
+27,27
+27,27
+25,25
+18,10
+4,27
+20,8
+4,0
+27,27
+5,25
+27,0
+0,0
+27,27
+27,22
+22,22
+27,27
+7,7
+7,18
+10,27
+17,17
+5,5
+9,27
+27,10
+7,7
+27,6
+27,0
+2,26
+27,27
+0,0
+10,2
+1,1
+27,7
+27,27
+27,22
+0,0
+0,0
+18,27
+3,27
+11,26
+2,27
+25,11
+27,27
+27,27
+22,27
+3,3
+8,8
+7,6
+15,15
+6,7
+10,10
+0,0
+0,0
+0,18
+7,7
+17,27
+0,0
+1,1
+27,7
+8,27
+27,27
+20,20
+4,4
+11,11
+3,27
+19,9
+5,5
+27,27
+27,6
+4,27
+27,7
+27,7
+0,0
+7,27
+5,5
+27,27
+27,27
+4,1
+13,26
+3,11
+6,6
+8,18
+27,27
+27,27
+27,27
+14,14
+27,27
+6,3
+27,27
+26,27
+0,6
+3,27
+3,3
+0,0
+27,26
+5,5
+0,0
+27,25
+14,3
+4,10
+13,13
+4,4
+27,27
+4,4
+22,1
+27,3
+5,5
+2,2
+27,27
+27,27
+11,11
+15,15
+18,27
+0,0
+27,7
+4,27
+15,15
+27,27
+25,26
+3,3
+3,27
+18,18
+27,27
+3,27
+15,15
+20,20
+27,27
+10,6
+27,27
+12,11
+10,4
+13,13
+5,15
+3,10
+2,3
+0,0
+17,17
+3,2
+7,27
+25,25
+0,0
+27,27
+15,15
+9,27
+10,10
+11,11
+27,7
+27,27
+4,27
+27,27
+24,24
+6,7
+9,10
+7,1
+27,27
+27,7
+0,0
+6,27
+18,18
+27,27
+25,25
+27,2
+7,7
+7,27
+27,27
+27,27
+15,15
+5,27
+1,1
+27,6
+13,13
+7,20
+6,7
+15,15
+27,27
+27,7
+26,27
+1,1
+4,27
+13,7
+22,27
+27,27
+10,1
+18,18
+10,10
+26,0
+13,13
+4,27
+3,0
+27,9
+15,0
+8,8
+27,12
+3,2
+18,18
+0,0
+8,8
+1,26
+27,27
+10,27
+0,0
+0,0
+2,2
+4,27
+10,11
+7,7
+27,27
+0,0
+25,25
+26,2
+9,9
+27,7
+7,26
+27,27
+20,20
+27,27
+0,17
+3,27
+2,2
+27,27
+0,27
+7,7
+12,12
+5,5
+3,7
+2,2
+17,17
+15,0
+4,27
+0,0
+27,4
+27,27
+3,3
+9,9
+27,4
+27,27
+15,0
+7,7
+27,13
+18,18
+14,14
+27,7
+1,1
+18,18
+7,7
+10,10
+0,0
+4,0
+15,15
+15,15
+6,6
+4,4
+5,27
+27,0
+1,1
+27,27
+3,27
+27,10
+0,0
+17,17
+15,15
+0,5
+0,0
+27,3
+7,7
+4,4
+9,10
+10,24
+17,0
+11,11
+24,25
+2,2
+27,2
+27,27
+2,2
+10,27
+9,9
+2,3
+1,1
+19,27
+10,27
+10,18
+0,0
+10,10
+13,13
+25,4
+17,17
+1,1
+18,18
+22,27
+10,10
+15,1
+13,27
+14,27
+27,27
+27,27
+3,27
+26,26
+27,27
+3,5
+7,7
+0,0
+18,18
+3,27
+27,27
+27,27
+15,15
+9,2
+22,26
+18,18
+0,0
+0,0
+20,5
+22,27
+10,10
+27,27
+3,27
+19,14
+27,27
+22,27
+27,27
+22,27
+27,27
+5,5
+3,0
+27,27
+7,27
+18,18
+27,27
+15,15
+18,18
+6,7
+0,0
+17,17
+0,27
+0,0
+27,27
+27,13
+3,2
+4,27
+0,0
+18,18
+27,27
+1,1
+27,27
+15,15
+6,6
+27,27
+22,27
+18,18
+7,27
+15,15
+27,27
+10,10
+2,3
+27,3
+18,18
+0,17
+9,25
+0,26
+27,3
+15,15
+1,1
+27,27
+27,27
+10,15
+27,6
+27,2
+1,1
+25,0
+15,15
+15,15
+0,0
+4,4
+11,3
+27,27
+0,0
+27,27
+27,7
+10,10
+25,25
+4,27
+7,27
+2,27
+3,7
+0,0
+15,15
+27,4
+27,1
+1,1
+15,15
+0,5
+7,26
+18,18
+10,27
+10,25
+1,1
+10,27
+15,15
+13,7
+13,27
+27,27
+4,27
+27,27
+27,27
+0,1
+27,11
+27,7
+4,4
+0,0
+18,18
+9,9
+4,18
+24,24
+2,18
+15,15
+0,0
+26,27
+0,27
+27,3
+27,27
+0,0
+27,27
+10,27
+6,6
+26,26
+7,7
+17,17
+10,25
+27,27
+27,27
+18,18
+1,1
+27,27
+13,17
+27,27
+0,18
+27,7
+13,20
+22,4
+27,27
+27,27
+27,1
+0,0
+11,11
+27,25
+13,17
+1,1
+27,14
+11,11
+0,0
+4,4
+25,25
+8,8
+18,18
+1,1
+7,26
+6,27
+27,7
+18,18
+18,18
+27,4
+22,26
+0,26
+22,27
+18,18
+3,0
+27,27
+0,25
+3,27
+3,0
+11,10
+27,1
+18,4
+27,27
+0,0
+27,27
+4,27
+27,13
+27,27
+27,27
+20,5
+0,0
+27,3
+27,27
+27,27
+3,3
+7,27
+20,20
+3,27
+20,0
+13,17
+27,27
+3,27
+27,27
+4,27
+4,27
+5,27
+0,4
+7,7
+7,7
+0,27
+25,12
+0,0
+27,10
+10,10
+27,27
+24,24
+9,9
+24,24
+4,4
+6,10
+17,17
+0,0
+2,2
+27,27
+27,27
+10,10
+4,27
+3,10
+25,25
+27,27
+0,0
+27,27
+19,7
+27,27
+26,3
+27,27
+18,4
+27,27
+27,27
+3,27
+27,27
+27,27
+1,27
+27,27
+0,18
+2,2
+18,18
+20,27
+26,26
+0,0
+27,27
+3,7
+27,27
+15,15
+10,27
+6,6
+1,1
+21,0
+27,5
+27,0
+25,9
+11,14
+27,27
+27,4
+1,1
+20,20
+0,15
+27,27
+4,4
+27,14
+25,27
+22,27
+0,13
+0,0
+18,18
+27,27
+27,27
+27,27
+9,27
+27,10
+17,1
+0,1
+4,3
+3,3
+17,17
+5,5
+27,27
+27,4
+0,0
+4,4
+27,7
+15,4
+7,25
+1,1
+7,6
+7,18
+1,27
+1,1
+0,0
+1,1
+1,1
+10,27
+0,0
+2,2
+10,10
+10,0
+27,9
+1,1
+27,0
+27,27
+22,27
+7,7
+0,0
+27,11
+26,26
+9,6
+14,14
+18,18
+27,7
+1,1
+27,27
+7,27
+18,0
+27,27
+27,27
+27,0
+20,20
+7,27
+0,0
+27,27
+18,0
+5,27
+18,18
+3,24
+10,1
+6,27
+27,4
+27,10
+20,20
+25,25
+27,27
+27,3
+13,13
+2,2
+26,0
+10,11
+10,27
+25,27
+3,27
+27,27
+3,10
+0,0
+10,10
+13,27
+6,6
+0,0
+1,1
+27,27
+3,2
+27,10
+3,2
+1,1
+17,17
+7,27
+24,24
+15,15
+3,3
+0,27
+20,8
+27,7
+2,3
+27,27
+27,10
+15,15
+9,27
+27,27
+27,27
+15,15
+13,27
+27,27
+20,27
+27,27
+27,27
+15,15
+27,27
+6,6
+27,27
+3,27
+6,24
+22,11
+27,27
+27,4
+7,7
+25,10
+27,6
+27,27
+27,27
+27,27
+0,4
+4,4
+27,27
+10,10
+1,8
+2,27
+3,11
+0,20
+27,2
+5,0
+15,0
+27,27
+1,1
+9,27
+9,27
+15,15
+27,27
+27,5
+0,0
+15,0
+25,25
+0,0
+3,1
+27,27
+20,20
+0,4
+5,27
+10,10
+15,15
+1,1
+18,18
+6,7
+0,18
+1,1
+27,27
+4,27
+15,0
+27,27
+9,27
+1,1
+20,20
+20,20
+15,15
+1,1
+27,27
+6,6
+3,3
+4,27
+27,27
+1,1
+15,7
+10,27
+27,27
+5,5
+27,27
+27,1
+10,10
+22,27
+15,17
+2,2
+1,1
+27,6
+27,27
+5,5
+27,27
+18,18
+27,6
+27,27
+15,15
+20,20
+9,2
+27,27
+0,0
+4,27
+0,0
+27,6
+1,1
+27,27
+0,0
+27,27
+10,0
+27,27
+4,4
+11,11
+17,17
+10,10
+22,27
+15,15
+5,27
+27,27
+27,27
+7,27
+1,27
+0,0
+7,7
+0,0
+11,11
+18,18
+1,1
+0,0
+0,0
+4,27
+3,11
+15,15
+22,10
+15,15
+22,6
+18,18
+27,27
+27,27
+15,15
+4,4
+20,20
+20,20
+4,4
+10,27
+27,27
+17,17
+3,3
+27,27
+1,1
+9,18
+27,4
+27,7
+6,6
+2,2
+11,27
+10,2
+27,27
+4,9
+0,0
+15,2
+26,26
+1,1
+14,10
+4,18
+22,27
+24,24
+4,4
+10,1
+27,7
+4,27
+0,0
+4,4
+27,4
+10,6
+27,10
+27,27
+21,11
+10,27
+17,17
+27,27
+27,27
+7,7
+11,11
+3,2
+27,27
+18,18
+27,27
+27,3
+27,27
+4,3
+3,10
+4,7
+27,27
+0,27
+2,27
+27,27
+17,27
+27,27
+2,7
+2,27
+13,13
+3,27
+26,27
+27,18
+27,27
+0,0
+18,18
+0,0
+27,27
+25,25
+10,27
+15,15
+27,27
+12,27
+27,8
+3,3
+9,10
+2,2
+27,4
+12,22
+2,27
+12,22
+0,4
+1,1
+8,27
+4,4
+3,27
+17,26
+22,27
+22,26
+9,3
+1,1
+27,0
+0,27
+27,7
+27,27
+17,17
+3,3
+27,6
+15,15
+7,7
+10,10
+27,27
+3,3
+4,4
+18,0
+27,27
+15,15
+22,27
+27,27
+25,25
+0,17
+2,18
+27,27
+3,14
+2,27
+20,15
+0,0
+12,12
+0,18
+9,27
+17,0
+2,2
+27,0
+14,27
+27,27
+27,27
+15,15
+27,27
+18,18
+27,5
+7,7
+0,0
+14,14
+27,27
+0,18
+1,15
+27,3
+27,1
+7,20
+18,18
+27,2
+6,6
+5,5
+1,1
+27,27
+27,7
+0,0
+27,27
+8,8
+24,15
+0,0
+0,13
+17,17
+6,7
+27,27
+14,14
+10,7
+6,6
+4,27
+20,20
+27,17
+27,0
+0,0
+0,18
+10,27
+26,10
+27,27
+27,27
+18,0
+3,3
+0,0
+1,1
+7,27
+22,27
+12,12
+27,25
+27,27
+18,18
+11,27
+20,17
+4,27
+22,4
+27,27
+15,15
+3,27
+11,20
+0,0
+1,1
+7,7
+1,1
+27,27
+27,27
+3,27
+25,0
+2,0
+1,1
+1,1
+27,27
+4,14
+27,27
+0,0
+26,0
+3,2
+18,18
+10,27
+27,27
+4,4
+27,27
+25,27
+0,0
+15,17
+18,18
+1,1
+27,27
+0,0
+27,20
+27,27
+0,11
+27,8
+2,25
+25,25
+0,0
+18,18
+1,1
+3,3
+27,27
+27,4
+4,27
+27,27
+27,27
+27,27
+14,14
+7,7
+27,27
+27,27
+22,27
+27,27
+27,27
+27,27
+27,27
+7,7
+10,27
+24,24
+27,15
+10,3
+4,10
+3,2
+7,7
+27,0
+0,1
+27,27
+5,27
+11,10
+22,27
+17,13
+9,11
+18,18
+10,27
+25,24
+27,27
+15,15
+17,1
+27,7
+17,17
+15,15
+27,9
+0,4
+4,27
+17,17
+10,10
+7,7
+27,27
+18,18
+7,27
+15,0
+2,27
+4,27
+4,27
+15,15
+17,17
+22,0
+2,11
+22,27
+27,27
+27,27
+9,27
+19,9
+2,2
+2,2
+27,27
+14,27
+27,27
+15,15
+6,7
+1,1
+2,3
+1,1
+20,27
+27,27
+2,3
+0,0
+19,25
+15,15
+22,0
+17,27
+1,1
+27,27
+22,26
+22,22
+10,9
+15,15
+3,1
+3,2
+8,8
+20,20
+0,3
+4,0
+15,27
+2,27
+6,7
+15,15
+4,27
+27,3
+3,27
+6,6
+10,10
+25,24
+27,25
+7,7
+27,27
+18,18
+3,1
+27,5
+24,24
+27,27
+2,27
+27,27
+20,20
+27,11
+27,27
+0,0
+7,0
+2,1
+4,10
+11,27
+4,4
+7,13
+10,10
+7,7
+15,15
+27,27
+22,27
+4,4
+25,25
+0,0
+27,7
+9,10
+27,27
+7,7
+7,27
+2,3
+18,18
+0,0
+18,18
+6,7
+2,27
+26,26
+27,3
+14,14
+8,27
+27,27
+27,7
+27,10
+10,10
+27,27
+25,6
+0,0
+10,13
+0,27
+0,0
+27,27
+4,27
+27,9
+0,0
+7,7
+1,1
+13,13
+13,15
+0,0
+20,27
+9,1
+22,22
+1,1
+4,18
+24,24
+27,27
+27,27
+17,17
+3,27
+8,27
+3,10
+27,27
+22,7
+10,27
+27,27
+10,10
+9,24
+27,27
+1,1
+27,27
+27,27
+27,3
+7,7
+15,15
+17,27
+27,27
+27,27
+27,10
+8,20
+1,6
+27,13
+7,7
+27,27
+27,27
+1,1
+4,27
+4,27
+10,3
+0,0
+15,15
+20,5
+15,15
+6,7
+27,3
+9,27
+27,27
+3,3
+8,8
+18,18
+27,7
+27,9
+7,7
+27,27
+17,4
+10,1
+3,10
+0,17
+1,1
+27,10
+1,1
+4,5
+10,6
+5,5
+27,27
+3,10
+1,1
+20,5
+27,1
+13,0
+27,27
+10,6
+4,4
+2,2
+24,24
+7,7
+15,15
+27,27
+1,1
+0,0
+27,27
+17,17
+9,27
+1,1
+27,10
+0,0
+18,7
+27,27
+4,27
+17,0
+4,27
+27,3
+17,17
+7,6
+4,18
+27,10
+6,7
+27,2
+22,27
+18,0
+3,2
+25,24
+27,27
+27,27
+0,0
+27,27
+0,0
+18,18
+27,27
+27,27
+1,1
+15,20
+27,27
+2,2
+22,18
+7,7
+27,27
+27,2
+27,27
+15,15
+5,1
+0,0
+3,10
+3,27
+15,2
+27,27
+2,2
+17,1
+27,27
+27,27
+8,8
+27,27
+26,27
+27,27
+13,27
+15,15
+4,4
+27,27
+9,27
+4,0
+0,0
+27,27
+0,0
+3,27
+9,27
+27,9
+27,3
+27,27
+27,27
+7,14
+3,27
+27,27
+14,14
+27,3
+27,27
+4,4
+0,15
+12,12
+7,7
+1,1
+3,3
+20,20
+11,2
+27,27
+27,27
+27,27
+20,7
+27,26
+22,27
+1,1
+27,27
+1,1
+27,27
+0,0
+4,5
+4,4
+27,2
+27,27
+7,7
+0,0
+14,14
+4,27
+4,26
+15,15
+22,13
+1,1
+27,27
+5,20
+4,13
+10,10
+27,4
+6,27
+3,4
+17,17
+3,2
+7,7
+2,2
+27,27
+4,27
+1,1
+0,9
+0,0
+17,17
+5,5
+20,5
+27,10
+26,26
+27,27
+0,0
+7,7
+15,15
+8,8
+27,27
+11,3
+7,7
+27,10
+5,20
+10,18
+0,0
+0,0
+27,27
+0,9
+0,0
+18,18
+27,27
+27,4
+27,27
+27,27
+27,3
+0,18
+27,27
+27,27
+27,27
+22,0
+4,27
+4,27
+18,18
+27,27
+14,14
+27,27
+0,0
+5,27
+27,27
+3,27
+13,7
+9,27
+7,27
+4,4
+2,10
+0,0
+2,3
+1,1
+27,27
+10,27
+18,27
+27,10
+3,3
+27,27
+27,27
+27,27
+4,4
+27,27
+18,18
+15,3
+5,5
+1,1
+22,27
+18,18
+6,6
+6,27
+27,27
+7,15
+27,27
+14,14
+3,11
+11,14
+27,27
+18,18
+27,0
+1,1
+10,10
+27,0
+27,0
+27,27
+15,15
+27,27
+22,26
+27,27
+8,18
+27,27
+0,0
+0,0
+0,0
+7,7
+1,1
+3,10
+0,0
+18,18
+27,27
+0,0
+27,0
+7,7
+15,15
+27,27
+3,14
+27,27
+27,6
+27,27
+11,11
+4,0
+27,4
+6,10
+4,0
+0,0
+1,1
+4,27
+2,26
+10,27
+5,5
+0,0
+0,0
+0,0
+18,18
+18,18
+7,27
+27,27
+15,15
+27,27
+4,27
+27,27
+20,13
+27,9
+27,5
+15,15
+0,0
+27,25
+27,20
+13,13
+13,17
+1,1
+26,13
+25,7
+27,27
+0,20
+27,5
+14,14
+17,17
+27,13
+10,27
+22,10
+0,0
+6,27
+4,27
+3,3
+27,27
+12,12
+27,27
+25,9
+27,27
+27,27
+4,4
+20,27
+17,17
+0,0
+0,18
+15,15
+7,13
+27,27
+24,24
+27,27
+11,14
+27,10
+27,27
+0,0
+0,18
+13,0
+20,5
+0,0
+8,8
+27,27
+7,7
+0,0
+4,10
+27,7
+27,27
+1,1
+7,7
+3,27
+27,27
+1,1
+27,27
+5,18
+5,5
+3,27
+27,27
+4,4
+1,1
+0,0
+27,27
+4,4
+13,13
+11,9
+3,9
+2,7
+26,27
+9,9
+27,27
+27,7
+27,27
+27,27
+27,27
+9,9
+0,1
+1,27
+26,6
+0,0
+0,0
+27,22
+20,20
+27,27
+15,15
+25,25
+27,27
+27,27
+2,11
+0,4
+7,27
+3,2
+27,27
+15,0
+15,15
+27,27
+25,26
+8,8
+6,6
+27,27
+4,3
+0,0
+0,0
+0,0
+27,27
+3,3
+27,27
+27,10
+27,11
+3,7
+15,15
+0,0
+27,27
+18,18
+18,18
+0,0
+23,17
+3,3
+15,15
+15,15
+4,27
+15,17
+27,27
+26,27
+2,27
+13,0
+5,27
+9,9
+9,7
+15,15
+27,0
+27,22
+27,27
+4,10
+2,2
+13,7
+5,5
+10,27
+27,27
+2,2
+22,26
+13,13
+9,27
+22,27
+27,27
+7,7
+27,18
+27,27
+22,27
+3,27
+0,3
+3,27
+27,7
+26,26
+27,27
+15,0
+27,27
+27,10
+4,27
+4,4
+13,27
+26,27
+2,3
+22,6
+2,2
+27,27
+20,5
+1,1
+27,0
+3,26
+25,25
+9,9
+27,27
+0,0
+3,27
+1,1
+10,3
+15,15
+11,11
+7,27
+27,27
+1,1
+18,18
+18,18
+4,5
+4,4
+4,0
+4,4
+11,11
+27,27
+4,7
+0,0
+22,11
+18,18
+3,27
+0,0
+2,2
+18,18
+18,18
+18,0
+27,27
+2,2
+0,4
+27,27
+15,15
+15,15
+0,0
+7,7
+2,2
+0,0
+1,1
+7,7
+10,27
+4,0
+27,27
+0,0
+27,27
+6,7
+22,4
+27,27
+27,27
+6,5
+15,15
+0,15
+4,4
+10,10
+3,2
+15,15
+27,27
+27,27
+10,27
+6,27
+0,0
+25,24
+7,26
+2,27
+3,3
+8,8
+9,9
+3,27
+27,27
+11,27
+1,1
+15,15
+27,27
+27,27
+2,11
+7,7
+27,27
+16,27
+0,0
+3,2
+27,10
+18,18
+27,27
+11,27
+27,27
+20,27
+2,25
+17,17
+27,22
+15,15
+15,15
+0,0
+6,6
+4,4
+27,9
+27,0
+10,10
+6,6
+4,4
+9,3
+20,27
+0,0
+1,1
+27,27
+12,12
+9,0
+18,18
+0,0
+2,2
+3,18
+6,15
+1,1
+4,4
+15,15
+3,2
+2,3
+1,1
+26,2
+3,2
+27,27
+5,27
+5,27
+0,0
+15,15
+11,27
+7,27
+27,6
+18,18
+22,4
+4,15
+27,27
+5,27
+27,0
+27,27
+27,2
+2,2
+27,27
+3,10
+27,27
+4,27
+27,4
+13,13
+17,1
+27,27
+18,18
+10,3
+3,3
+5,27
+27,27
+27,27
+27,27
+4,27
+13,13
+1,1
+9,27
+27,27
+27,27
+5,27
+3,27
+27,7
+17,17
+4,27
+27,27
+7,7
+27,4
+15,15
+15,15
+15,15
+12,27
+27,27
+27,27
+22,1
+15,15
+9,27
+7,7
+15,15
+20,5
+27,27
+9,9
+15,15
+27,4
+27,27
+15,17
+10,27
+27,5
+27,1
+7,7
+12,27
+9,27
+27,27
+7,7
+15,15
+27,14
+0,0
+27,27
+16,27
+1,1
+27,3
+0,0
+7,27
+27,27
+26,0
+10,27
+18,18
+7,27
+27,27
+2,2
+6,6
+2,7
+27,27
+3,2
+27,27
+27,27
+15,13
+2,2
+18,18
+26,27
+27,27
+7,7
+7,27
+27,27
+1,27
+15,15
+27,27
+26,26
+27,27
+27,27
+9,13
+26,26
+7,7
+10,10
+15,0
+27,27
+27,27
+15,15
+7,7
+27,18
+20,27
+0,0
+27,10
+4,0
+27,20
+27,27
+5,17
+27,6
+7,7
+7,7
+4,4
+27,5
+0,27
+27,27
+18,18
+27,10
+27,27
+5,5
+27,27
+14,14
+15,13
+0,0
+27,27
+15,15
+15,15
+27,27
+27,27
+0,0
+27,27
+27,27
+27,7
+10,10
+3,10
+27,27
+27,0
+7,7
+8,17
+27,7
+5,5
+3,2
+15,15
+27,27
+27,27
+9,18
+2,2
+3,27
+18,1
+0,0
+17,1
+17,17
+0,0
+27,27
+11,1
+27,7
+27,27
+27,27
+27,27
+8,8
+1,1
+5,5
+15,15
+3,3
+17,17
+15,15
+27,27
+27,0
+2,2
+22,26
+3,7
+9,27
+5,5
+3,27
+27,27
+3,27
+7,26
+3,3
+4,4
+18,18
+26,27
+27,27
+0,1
+9,25
+27,27
+1,4
+25,25
+0,0
+18,18
+12,3
+10,10
+1,1
+27,27
+10,7
+6,27
+3,27
+27,27
+8,2
+3,2
+27,9
+27,27
+0,0
+0,0
+0,0
+20,17
+4,10
+7,7
+27,27
+15,15
+27,27
+1,1
+27,27
+20,27
+0,0
+1,1
+27,13
+27,27
+15,0
+11,27
+8,27
+0,0
+4,10
+27,13
+0,0
+0,0
+27,27
+13,15
+1,2
+8,8
+9,27
+27,7
+0,0
+3,11
+2,27
+9,2
+0,0
+27,27
+27,27
+0,0
+4,4
+0,0
+18,18
+27,18
+2,27
+0,0
+27,27
+19,6
+10,10
+27,27
+1,1
+4,9
+11,11
+0,0
+0,0
+27,27
+4,7
+27,7
+26,2
+6,26
+0,13
+27,27
+27,17
+22,27
+4,4
+1,1
+13,26
+3,3
+18,18
+4,27
+27,27
+27,27
+2,2
+2,26
+14,27
+20,27
+20,20
+14,14
+7,7
+27,27
+0,0
+27,27
+12,2
+27,27
+3,10
+3,27
+27,27
+24,24
+6,7
+27,27
+17,17
+4,4
+7,6
+25,25
+27,27
+15,13
+0,0
+4,0
+27,7
+15,15
+27,0
+27,27
+1,1
+27,10
+16,24
+2,27
+27,27
+1,1
+4,20
+27,27
+3,3
+3,27
+15,15
+2,3
+1,1
+7,26
+27,27
+27,27
+0,0
+7,7
+27,27
+4,0
+27,27
+4,0
+17,17
+0,0
+27,27
+8,8
+14,14
+27,27
+27,7
+3,27
+15,15
+20,5
+10,27
+10,27
+0,0
+27,27
+0,0
+27,5
+13,0
+0,0
+26,27
+15,15
+4,27
+27,27
+0,0
+6,27
+27,17
+14,2
+4,27
+25,25
+13,27
+27,4
+27,27
+14,9
+27,4
+4,4
+27,27
+18,18
+7,7
+27,27
+27,27
+27,27
+27,27
+10,10
+3,14
+10,27
+25,2
+11,11
+1,0
+1,1
+20,20
+7,7
+6,7
+13,27
+27,27
+2,2
+2,2
+2,2
+26,26
+13,4
+4,4
+7,27
+27,27
+1,1
+10,1
+6,27
+27,27
+27,27
+27,3
+4,27
+4,4
+6,4
+27,2
+1,1
+0,0
+27,27
+27,27
+9,20
+6,6
+21,0
+27,27
+2,3
+15,0
+3,27
+27,27
+27,27
+3,3
+0,0
+22,27
+27,4
+6,6
+27,27
+22,27
+1,1
+2,2
+1,1
+15,15
+7,14
+27,27
+20,20
+27,27
+0,20
+17,8
+0,15
+18,25
+27,27
+15,0
+27,27
+27,17
+25,25
+4,4
+27,5
+27,27
+2,2
+27,27
+2,2
+5,27
+5,4
+23,0
+22,4
+27,27
+0,18
+27,3
+3,3
+27,15
+27,27
+20,27
+27,10
+1,27
+0,0
+1,1
+0,0
+27,6
+9,9
+27,27
+7,7
+2,2
+27,27
+26,26
+26,7
+7,27
+27,27
+9,9
+2,3
+27,27
+22,22
+2,2
+27,27
+26,26
+1,1
+18,18
+1,0
+0,0
+27,27
+11,11
+17,17
+27,27
+3,3
+27,27
+2,2
+7,7
+26,26
+18,18
+27,27
+2,2
+27,27
+27,27
+20,20
+27,27
+0,0
+3,6
+27,6
+27,27
+27,7
+0,27
+0,0
+1,1
+4,20
+20,20
+27,27
+27,4
+0,0
+20,5
+4,27
+27,27
+26,26
+20,20
+4,2
+27,27
+27,27
+3,17
+19,5
+0,0
+27,1
+4,27
+7,7
+13,0
+14,7
+27,27
+27,27
+15,7
+27,27
+27,27
+27,7
+27,27
+11,11
+0,18
+15,15
+6,7
+6,6
+27,27
+27,27
+0,0
+24,24
+7,7
+4,27
+15,15
+27,27
+1,1
+3,27
+27,0
+11,27
+4,27
+27,27
+11,11
+7,7
+0,0
+1,1
+10,27
+3,2
+15,15
+13,27
+17,0
+26,27
+20,20
+27,27
+27,27
+20,27
+1,27
+4,4
+3,27
+7,7
+22,27
+26,26
+27,27
+23,4
+15,15
+7,7
+7,7
+27,27
+8,27
+4,27
+27,25
+20,26
+6,27
+2,27
+27,27
+14,14
+22,22
+27,27
+22,25
+0,15
+18,18
+27,7
+3,3
+27,27
+27,4
+18,0
+13,27
+24,9
+10,27
+27,27
+10,27
+18,18
+15,0
+0,0
+27,6
+0,0
+27,27
+20,27
+27,10
+3,9
+27,27
+27,27
+25,25
+3,3
+27,0
+15,15
+4,27
+1,1
+27,27
+1,1
+11,27
+15,15
+27,7
+0,13
+6,7
+4,20
+17,17
+27,10
+0,0
+9,27
+8,18
+22,26
+0,0
+0,0
+27,2
+11,11
+27,27
+11,3
+8,25
+10,1
+2,27
+4,4
+6,7
+4,27
+27,2
+24,20
+20,1
+27,27
+27,27
+15,15
+15,20
+10,10
+27,27
+2,3
+10,27
+8,8
+0,0
+22,0
+18,18
+0,0
+0,0
+0,0
+0,0
+20,5
+27,27
+0,0
+5,0
+3,4
+2,2
+9,27
+4,4
+8,0
+27,27
+9,3
+27,27
+5,27
+18,18
+4,17
+2,2
+27,27
+9,27
+14,14
+27,27
+26,26
+3,9
+15,0
+7,7
+0,0
+15,15
+4,4
+2,27
+27,3
+15,15
+18,18
+1,1
+4,27
+0,0
+27,27
+18,18
+27,7
+10,27
+15,15
+20,27
+2,2
+2,2
+0,0
+27,27
+2,27
+4,4
+27,11
+26,7
+1,1
+27,27
+6,7
+1,1
+10,0
+0,0
+2,3
+7,7
+26,26
+13,4
+27,27
+9,27
+15,15
+1,1
+27,27
+24,24
+8,17
+7,27
+22,11
+18,18
+1,1
+10,27
+3,10
+6,7
+4,4
+27,5
+27,9
+27,7
+4,4
+27,18
+15,15
+3,27
+27,0
+0,0
+1,1
+0,20
+27,27
+3,4
+1,1
+4,18
+4,4
+10,25
+15,15
+17,15
+27,4
+20,20
+15,0
+1,1
+4,27
+27,27
+4,27
+22,27
+15,15
+3,15
+17,18
+9,3
+27,27
+27,4
+27,0
+17,17
+26,27
+9,27
+27,10
+27,27
+9,6
+19,14
+0,0
+15,0
+4,6
+1,1
+5,27
+1,1
+27,27
+27,5
+4,17
+7,6
+27,27
+27,27
+10,10
+15,15
+27,27
+22,27
+12,12
+4,27
+17,17
+10,27
+14,14
+10,27
+20,20
+27,27
+25,0
+8,13
+27,27
+27,27
+6,7
+2,3
+17,18
+7,27
+18,27
+0,27
+8,8
+27,27
+18,18
+4,4
+10,6
+8,8
+7,7
+11,11
+0,0
+27,27
+27,27
+15,15
+7,27
+11,3
+27,27
+2,2
+27,27
+26,27
+27,27
+17,17
+3,27
+18,18
+7,27
+27,6
+17,17
+3,11
+18,18
+27,4
+1,1
+7,6
+3,3
+10,27
+20,20
+22,10
+0,0
+27,27
+0,0
+27,27
+27,5
+1,1
+22,22
+27,27
+3,3
+0,0
+15,15
+27,10
+27,27
+27,27
+22,27
+27,10
+27,27
+4,5
+15,15
+3,27
+7,7
+27,3
+4,27
+6,6
+0,0
+6,7
+14,11
+5,27
+27,0
+27,27
+7,27
+27,10
+15,15
+22,22
+15,15
+27,27
+2,2
+22,6
+27,9
+4,3
+0,0
+1,17
+10,27
+4,27
+0,0
+27,27
+27,27
+27,27
+6,6
+3,27
+22,1
+27,27
+27,7
+0,0
+27,27
+2,27
+4,4
+9,27
+3,27
+14,14
+6,0
+27,10
+10,10
+20,15
+27,27
+1,1
+15,1
+10,10
+27,18
+0,0
+10,10
+1,1
+27,27
+17,4
+27,1
+13,17
+27,27
+27,27
+2,2
+5,27
+27,27
+27,27
+2,3
+5,5
+27,27
+1,1
+9,27
+2,2
+4,27
+11,10
+27,27
+27,27
+27,7
+0,0
+18,18
+1,1
+0,0
+25,25
+7,2
+27,27
+5,27
+17,18
+20,27
+27,27
+27,27
+27,2
+26,26
+18,18
+27,0
+10,27
+27,27
+16,26
+27,27
+10,6
+0,0
+27,27
+26,26
+2,27
+17,17
+13,13
+5,10
+10,10
+4,4
+0,0
+27,27
+7,7
+14,27
+9,9
+1,0
+9,3
+27,7
+1,1
+27,6
+27,27
+18,18
+27,27
+6,7
+8,8
+14,14
+2,2
+3,2
+5,5
+0,0
+15,17
+27,27
+1,1
+3,18
+27,27
+15,15
+20,0
+27,27
+4,27
+3,27
+1,1
+18,18
+8,20
+15,15
+24,1
+9,15
+27,10
+8,18
+2,2
+1,27
+27,27
+10,27
+7,27
+10,27
+3,7
+25,25
+18,18
+27,27
+7,7
+10,10
+4,5
+4,4
+7,27
+27,4
+27,27
+27,3
+27,27
+0,0
+0,0
+27,27
+9,6
+4,0
+26,26
+16,27
+10,26
+17,17
+27,27
+0,1
+17,17
+0,0
+26,26
+27,27
+27,27
+2,27
+5,17
+1,1
+2,3
+9,15
+0,0
+18,27
+5,27
+5,20
+24,24
+0,0
+27,27
+14,14
+6,6
+7,7
+17,17
+27,27
+9,27
+18,18
+1,1
+10,10
+1,1
+27,27
+2,27
+6,7
+27,17
+27,27
+8,27
+27,3
+4,4
+17,17
+4,26
+7,27
+3,27
+1,1
+7,7
+10,10
+4,4
+27,2
+27,27
+10,10
+3,4
+1,1
+18,18
+6,3
+27,27
+3,18
+27,27
+10,10
+24,24
+4,27
+24,24
+27,7
+24,24
+25,25
+27,5
+8,17
+18,18
+27,25
+6,7
+9,27
+10,24
+2,10
+27,27
+27,2
+27,27
+27,27
+27,27
+10,27
+24,24
+2,11
+27,27
+7,7
+27,27
+1,1
+27,27
+27,27
+2,7
+20,15
+0,0
+27,27
+0,3
+2,27
+3,10
+0,13
+25,25
+13,13
+27,27
+27,27
+22,26
+12,26
+1,1
+26,7
+27,27
+0,17
+27,27
+27,27
+15,15
+0,0
+17,17
+27,1
+2,7
+1,1
+21,18
+7,7
+27,27
+4,4
+27,27
+27,27
+7,7
+27,27
+27,0
+27,0
+27,27
+14,14
+9,3
+18,18
+15,15
+4,4
+27,27
+15,15
+27,27
+10,0
+7,7
+20,20
+9,27
+4,27
+13,27
+15,15
+27,27
+6,27
+3,27
+11,2
+27,1
+0,0
+9,9
+27,10
+18,18
+1,1
+4,27
+27,27
+7,7
+2,6
+27,27
+27,0
+15,15
+7,27
+20,20
+27,27
+27,27
+27,27
+27,27
+10,27
+10,10
+27,27
+25,25
+27,27
+0,18
+27,2
+13,13
+15,15
+6,7
+1,2
+20,20
+9,0
+27,27
+10,3
+4,0
+15,15
+15,10
+7,7
+15,15
+9,3
+0,0
+0,0
+0,27
+27,27
+27,27
+17,27
+13,27
+2,11
+27,27
+27,27
+0,0
+9,27
+7,7
+27,27
+4,4
+27,27
+1,1
+27,27
+4,1
+25,27
+18,18
+20,20
+27,27
+27,27
+27,27
+7,27
+24,24
+0,0
+9,9
+17,27
+17,17
+4,27
+3,27
+22,9
+11,11
+0,0
+27,27
+7,7
+27,27
+7,7
+5,5
+9,3
+27,10
+25,27
+6,6
+27,27
+27,27
+27,27
+5,20
+27,27
+8,8
+27,3
+4,4
+27,27
+27,27
+10,11
+0,0
+10,27
+18,18
+27,26
+3,7
+18,7
+4,27
+0,0
+6,7
+6,6
+5,27
+0,18
+27,27
+27,27
+24,24
+2,2
+27,27
+7,7
+27,27
+27,1
+10,20
+27,7
+1,1
+0,0
+0,0
+27,27
+3,27
+6,6
+5,4
+0,0
+1,1
+27,27
+3,27
+5,5
+27,27
+26,26
+0,0
+7,7
+10,18
+19,27
+15,15
+6,6
+3,3
+0,0
+2,1
+1,1
+17,0
+8,20
+10,10
+0,0
+4,0
+3,18
+6,7
+3,2
+3,27
+27,27
+4,27
+7,27
+3,27
+11,3
+27,27
+18,18
+18,18
+4,4
+27,10
+27,27
+25,9
+25,25
+27,4
+3,3
+9,9
+1,27
+4,24
+4,4
+3,27
+27,27
+4,27
+18,18
+4,4
+27,27
+0,18
+27,27
+4,4
+5,4
+26,27
+1,1
+1,1
+27,27
+8,18
+0,0
+27,1
+17,0
+20,8
+7,27
+27,2
+27,27
+14,14
+27,27
+5,5
+3,2
+27,2
+15,15
+4,4
+17,7
+4,1
+14,14
+27,27
+2,27
+17,18
+1,1
+27,27
+4,27
+27,7
+0,0
+27,2
+27,27
+25,25
+27,14
+27,0
+4,27
+27,27
+1,1
+11,11
+27,27
+27,9
+6,6
+9,27
+18,18
+25,27
+13,13
+27,7
+27,26
+0,0
+17,17
+5,5
+4,4
+27,10
+22,27
+17,0
+1,1
+27,0
+15,15
+15,15
+27,27
+11,4
+27,27
+15,15
+27,17
+8,13
+5,15
+0,0
+27,27
+0,0
+11,1
+15,15
+27,27
+27,27
+9,10
+6,6
+27,27
+14,14
+15,0
+4,4
+3,3
+25,25
+10,0
+27,27
+27,27
+27,27
+27,27
+26,27
+27,27
+9,8
+3,3
+7,7
+5,5
+27,27
+27,4
+6,6
+14,14
+22,13
+10,9
+7,25
+22,12
+27,27
+27,27
+27,27
+14,27
+27,10
+6,7
+27,4
+27,5
+0,0
+25,25
+27,27
+15,15
+27,27
+3,2
+3,27
+20,20
+15,15
+6,6
+27,27
+27,27
+10,10
+15,15
+27,27
+27,27
+6,6
+7,7
+17,27
+0,7
+2,27
+27,27
+15,15
+27,27
+2,2
+14,14
+0,0
+4,27
+27,27
+19,7
+27,4
+22,27
+25,24
+10,27
+5,5
+27,27
+13,13
+27,2
+9,9
+27,27
+2,27
+27,27
+27,0
+0,13
+9,26
+0,0
+10,10
+20,27
+7,0
+27,27
+27,7
+6,6
+6,27
+0,4
+27,27
+25,25
+27,27
+27,27
+14,14
+27,27
+27,27
+6,9
+27,27
+4,15
+18,18
+7,26
+9,3
+0,0
+25,0
+24,24
+10,10
+1,1
+3,7
+27,27
+27,27
+27,27
+27,27
+26,26
+6,6
+4,27
+27,27
+27,27
+2,27
+7,7
+1,17
+4,27
+5,4
+27,2
+27,27
+4,4
+0,0
+1,1
+0,0
+7,20
+2,2
+3,2
+27,27
+6,27
+27,3
+4,4
+27,0
+27,27
+27,10
+14,11
+27,27
+27,27
+27,27
+27,0
+26,26
+25,27
+0,0
+0,0
+18,20
+0,15
+6,6
+27,27
+27,17
+1,1
+27,27
+4,4
+15,15
+7,26
+12,3
+27,5
+27,27
+27,6
+9,9
+15,15
+27,0
+24,27
+27,27
+0,0
+3,27
+27,27
+3,27
+10,27
+27,7
+4,27
+0,0
+0,17
+27,27
+21,0
+20,15
+13,13
+10,2
+15,20
+1,1
+0,0
+4,27
+10,18
+9,0
+10,10
+13,7
+27,27
+1,1
+26,0
+25,25
+10,10
+0,0
+2,2
+6,7
+0,0
+3,6
+27,7
+27,7
+27,5
+27,26
+27,27
+22,27
+7,0
+27,27
+4,10
+13,13
+18,18
+3,0
+0,0
+24,24
+4,27
+10,2
+4,5
+27,27
+26,26
+27,27
+2,2
+5,27
+27,27
+17,17
+27,27
+14,14
+3,3
+17,0
+27,27
+0,9
+17,27
+26,27
+0,0
+27,7
+2,2
+18,1
+15,13
+25,7
+27,27
+0,27
+27,0
+7,7
+4,20
+13,0
+0,0
+27,27
+27,27
+27,27
+2,2
+11,4
+20,20
+2,2
+5,27
+15,15
+14,14
+0,0
+13,13
+20,20
+2,3
+18,18
+27,27
+5,5
+1,1
+2,2
+27,15
+3,3
+27,0
+27,27
+26,3
+0,0
+11,3
+4,27
+19,24
+26,26
+1,1
+3,18
+7,7
+18,2
+27,27
+27,4
+0,0
+3,27
+0,0
+27,27
+27,0
+1,1
+27,0
+10,27
+21,0
+27,10
+12,12
+18,18
+9,27
+6,6
+27,27
+10,27
+10,6
+27,10
+27,27
+27,7
+27,27
+0,0
+3,27
+7,7
+14,14
+4,27
+27,27
+15,15
+27,27
+10,10
+18,18
+27,27
+14,14
+7,7
+7,7
+0,0
+6,6
+0,0
+27,27
+1,1
+7,7
+13,27
+15,15
+3,27
+27,27
+27,27
+27,27
+2,2
+17,17
+7,7
+1,1
+27,27
+20,20
+25,10
+20,20
+27,1
+17,13
+27,27
+0,5
+27,27
+15,0
+27,5
+25,24
+0,5
+10,27
+9,25
+2,10
+6,27
+27,1
+9,3
+27,27
+27,3
+8,8
+27,17
+0,0
+15,15
+27,0
+6,27
+20,27
+6,7
+27,27
+9,9
+4,0
+14,14
+6,6
+27,27
+26,25
+11,11
+27,27
+27,27
+7,3
+27,2
+2,27
+27,27
+20,17
+25,2
+10,10
+27,27
+0,0
+17,17
+24,24
+14,14
+1,1
+27,27
+27,27
+9,9
+14,14
+3,27
+27,27
+6,0
+27,27
+0,0
+27,27
+15,15
+14,14
+10,10
+4,27
+27,7
+17,17
+1,1
+27,27
+8,2
+2,2
+11,2
+27,4
+10,27
+18,18
+4,26
+25,25
+27,13
+27,27
+26,3
+27,27
+27,7
+0,0
+27,27
+27,27
+27,27
+7,7
+3,0
+2,2
+27,27
+27,27
+27,27
+1,1
+27,27
+3,3
+27,27
+0,18
+12,3
+3,7
+0,14
+27,27
+17,17
+27,27
+4,27
+27,3
+13,13
+27,27
+27,27
+7,27
+4,27
+27,27
+15,15
+1,1
+1,1
+27,26
+27,4
+7,7
+26,27
+15,15
+9,27
+27,27
+0,0
+4,27
+27,27
+27,27
+27,27
+6,7
+6,6
+27,4
+0,27
+8,20
+27,22
+0,0
+26,7
+26,26
+20,20
+27,27
+27,27
+27,27
+3,2
+27,10
+1,17
+24,24
+15,15
+10,27
+10,11
+27,22
+4,4
+14,13
+4,27
+27,27
+22,27
+18,18
+27,27
+27,27
+27,27
+27,27
+0,0
+27,18
+27,27
+3,27
+27,0
+27,27
+13,4
+27,27
+27,27
+10,27
+5,27
+27,27
+1,1
+4,0
+17,17
+15,15
+0,0
+27,27
+3,3
+0,0
+7,7
+6,26
+27,27
+15,15
+15,5
+0,17
+7,7
+27,27
+3,27
+1,1
+27,10
+20,27
+15,15
+27,27
+4,4
+0,27
+20,8
+4,27
+27,27
+3,14
+2,15
+27,27
+27,27
+15,15
+20,20
+11,27
+4,4
+8,7
+2,2
+27,27
+3,7
+6,6
+27,7
+2,2
+27,24
+1,1
+1,1
+4,4
+27,27
+5,5
+3,2
+27,27
+27,27
+13,8
+4,27
+27,27
+15,15
+27,27
+27,27
+4,4
+4,27
+22,1
+20,27
+8,8
+7,7
+22,27
+0,0
+0,27
+1,1
+4,4
+3,12
+27,10
+9,25
+18,7
+1,1
+26,2
+0,0
+0,18
+25,27
+11,7
+4,27
+25,25
+8,8
+3,2
+3,2
+27,10
+15,15
+27,10
+6,6
+14,14
+27,27
+18,18
+9,25
+0,18
+14,14
+27,5
+15,15
+27,0
+0,0
+4,27
+22,9
+25,25
+27,27
+27,27
+26,27
+13,13
+12,27
+12,27
+27,27
+0,0
+18,18
+7,27
+12,24
+5,5
+3,2
+18,18
+25,25
+9,27
+15,15
+4,27
+0,0
+4,20
+15,15
+18,18
+27,7
+10,27
+27,26
+3,25
+17,17
+0,0
+0,17
+9,27
+4,10
+27,27
+27,27
+1,1
+13,13
+27,7
+27,5
+0,17
+3,27
+3,9
+3,27
+8,20
+11,11
+27,27
+9,27
+0,0
+5,5
+6,7
+27,27
+27,27
+5,20
+3,2
+27,27
+4,27
+27,27
+10,27
+3,3
+20,0
+6,27
+27,27
+0,0
+7,7
+27,27
+18,1
+6,27
+13,15
+27,27
+0,0
+27,7
+18,18
+20,27
+1,0
+25,25
+27,4
+27,0
+27,27
+25,25
+25,25
+0,0
+3,2
+6,7
+3,27
+0,0
+0,0
+5,17
+2,2
+27,27
+15,15
+5,5
+4,27
+27,27
+2,26
+25,6
+3,3
+27,27
+0,0
+13,13
+27,10
+27,27
+27,27
+24,14
+27,13
+27,27
+27,27
+0,0
+1,1
+15,15
+4,4
+7,7
+2,2
+27,20
+18,0
+13,13
+6,27
+27,4
+27,27
+0,0
+6,10
+27,27
+7,7
+13,0
+4,4
+4,4
+1,1
+11,11
+27,27
+9,25
+27,27
+0,0
+15,15
+7,7
+0,27
+0,27
+25,25
+1,1
+27,1
+0,0
+27,27
+21,17
+5,5
+27,27
+6,7
+27,4
+4,9
+27,27
+27,27
+0,0
+27,27
+27,27
+27,27
+9,9
+27,27
+10,27
+8,20
+7,7
+7,7
+26,26
+10,10
+10,27
+15,15
+4,10
+26,26
+2,0
+1,1
+0,0
+27,27
+27,27
+1,1
+6,6
+0,0
+4,27
+25,25
+2,2
+0,18
+4,27
+27,27
+27,27
+0,0
+27,0
+4,27
+0,0
+20,27
+27,27
+4,4
+6,6
+0,0
+1,1
+27,27
+27,27
+27,4
+6,6
+20,20
+0,0
+7,7
+7,6
+0,15
+27,7
+9,25
+3,4
+27,27
+27,15
+27,27
+7,7
+3,15
+17,20
+27,27
+4,4
+26,26
+27,27
+0,0
+6,27
+27,3
+2,27
+27,27
+27,27
+0,1
+27,27
+3,27
+25,25
+10,2
+13,13
+0,0
+27,27
+18,18
+27,27
+27,27
+3,2
+27,5
+15,15
+7,7
+27,27
+3,27
+22,27
+3,27
+20,20
+10,27
+7,15
+9,25
+4,4
+27,27
+1,1
+27,27
+3,2
+27,27
+4,17
+0,0
+27,27
+4,27
+2,3
+0,0
+1,1
+0,4
+10,10
+25,25
+27,27
+27,27
+25,25
+11,2
+3,27
+25,25
+0,27
+22,27
+5,27
+8,27
+0,0
+27,27
+5,3
+0,0
+25,7
+27,7
+27,27
+27,2
+27,27
+8,8
+2,3
+27,7
+17,17
+27,13
+27,27
+9,20
+4,4
+15,15
+15,15
+9,3
+27,27
+13,7
+3,1
+10,10
+20,20
+5,0
+1,27
+27,27
+6,7
+27,27
+7,7
+4,4
+22,22
+10,10
+2,2
+8,27
+2,2
+0,0
+27,27
+7,27
+3,3
+27,27
+13,14
+0,0
+9,27
+8,5
+27,27
+6,3
+27,10
+1,1
+4,27
+18,18
+26,0
+22,27
+9,9
+27,27
+0,0
+1,1
+0,15
+27,27
+8,27
+15,15
+3,14
+9,9
+27,6
+3,0
+10,10
+7,25
+4,27
+18,18
+15,15
+27,27
+1,1
+27,14
+27,27
+15,15
+4,4
+27,27
+0,0
+27,27