diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index d31cf9d..8c7c275 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -6,6 +6,7 @@
       <GradleProjectSettings>
         <option name="distributionType" value="LOCAL" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleHome" value="$PROJECT_DIR$/../../../../../Gradle/gradle-8.13" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 5cd9a10..f16dea7 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="FrameworkDetectionExcludesConfiguration">
+    <file type="web" url="file://$PROJECT_DIR$" />
+  </component>
   <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="21" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
diff --git a/src/main/java/Banking/BankAccount.java b/src/main/java/Banking/BankAccount.java
index 801bbfa..7349e59 100644
--- a/src/main/java/Banking/BankAccount.java
+++ b/src/main/java/Banking/BankAccount.java
@@ -13,12 +13,17 @@ public BankAccount(int id, int initialBalance) {
         this.balance = initialBalance;
     }
 
-    public int getId(){
-        return  id;
+    public int getId() {
+        return id;
     }
+
     public int getBalance() {
-        // TODO: Consider locking (if needed)
-        return balance;
+        lock.lock();
+        try {
+            return balance;
+        } finally {
+            lock.unlock();
+        }
     }
 
     public Lock getLock() {
@@ -26,16 +31,39 @@ public Lock getLock() {
     }
 
     public void deposit(int amount) {
-        // TODO: Safely add to balance.
+        lock.lock();
+        try {
+            balance += amount;
+        } finally {
+            lock.unlock();
+        }
     }
 
     public void withdraw(int amount) {
-        // TODO: Safely withdraw from balance.
+        lock.lock();
+        try {
+            balance -= amount;
+        } finally {
+            lock.unlock();
+        }
     }
 
     public void transfer(BankAccount target, int amount) {
-        // TODO: Safely make the changes
-        // HINT: Both accounts need to be locked, while the changes are being made
-        // HINT: Be cautious of potential deadlocks.
+        // Acquire locks in consistent order to prevent deadlock
+        BankAccount first = this.id < target.id ? this : target;
+        BankAccount second = this.id < target.id ? target : this;
+
+        first.lock.lock();
+        try {
+            second.lock.lock();
+            try {
+                this.balance -= amount;
+                target.balance += amount;
+            } finally {
+                second.lock.unlock();
+            }
+        } finally {
+            first.lock.unlock();
+        }
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/Banking/BankingMain.java b/src/main/java/Banking/BankingMain.java
index 0e52f8f..41b2198 100644
--- a/src/main/java/Banking/BankingMain.java
+++ b/src/main/java/Banking/BankingMain.java
@@ -2,38 +2,99 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 
 public class BankingMain {
+    private static final int INITIAL_BALANCE = 20000;
+    private static final int NUM_ACCOUNTS = 4;
+    private static final long TIMEOUT_MINUTES = 2;
 
     public List<BankAccount> calculate() throws InterruptedException {
+        System.out.println("Initializing banking system with " + NUM_ACCOUNTS + " accounts...");
+
+        List<BankAccount> accounts = initializeAccounts();
+        Thread[] threads = createAndStartThreads(accounts);
+
+        waitForThreadsCompletion(threads);
+
+        System.out.println("\nAll transactions processed successfully!");
+        System.out.println("Total transactions processed: " + TransactionProcessor.getTransactionCount());
+
+        return accounts;
+    }
+
+    private List<BankAccount> initializeAccounts() {
         List<BankAccount> accounts = new ArrayList<>();
-        accounts.add(new BankAccount(1,20000));
-        accounts.add(new BankAccount(2,20000));
-        accounts.add(new BankAccount(3,20000));
-        accounts.add(new BankAccount(4,20000));
-
-        Thread[] threads = new Thread[4];
-        for(int i = 1; i <= 4; i++){
-            String fileName = i + ".txt";
-            threads[i - 1] = new Thread(new TransactionProcessor(accounts.get(i - 1), fileName, accounts));
+        for (int i = 1; i <= NUM_ACCOUNTS; i++) {
+            accounts.add(new BankAccount(i, INITIAL_BALANCE));
+            System.out.printf("Account %d initialized with balance: %,d%n", i, INITIAL_BALANCE);
         }
+        return accounts;
+    }
 
-        for(Thread thread : threads){
-            thread.start();
+    private Thread[] createAndStartThreads(List<BankAccount> accounts) {
+        Thread[] threads = new Thread[NUM_ACCOUNTS];
+        for (int i = 0; i < NUM_ACCOUNTS; i++) {
+            String fileName = (i + 1) + ".txt";
+            threads[i] = new Thread(new TransactionProcessor(accounts.get(i), fileName, accounts));
+            threads[i].setName("TransactionProcessor-" + (i + 1));
+            threads[i].start();
+            System.out.println("Started thread for " + threads[i].getName());
         }
+        return threads;
+    }
+
+    private void waitForThreadsCompletion(Thread[] threads) throws InterruptedException {
+        long startTime = System.currentTimeMillis();
 
-        for(Thread thread : threads){
-            thread.join();
+        for (Thread thread : threads) {
+            thread.join(TimeUnit.MINUTES.toMillis(TIMEOUT_MINUTES));
+
+            if (thread.isAlive()) {
+                System.err.println("Warning: Thread " + thread.getName() + " did not complete within timeout!");
+            }
         }
 
+        long duration = System.currentTimeMillis() - startTime;
+        System.out.printf("\nProcessing completed in %.2f seconds%n", duration / 1000.0);
+    }
 
-        return accounts;
+    public static void main(String[] args) {
+        try {
+            BankingMain main = new BankingMain();
+            System.out.println("\nStarting banking simulation...\n");
+
+            List<BankAccount> accounts = main.calculate();
+
+            System.out.println("\nFinal Account Balances:");
+            for (BankAccount account : accounts) {
+                System.out.printf("Account %d: %,d%n",
+                        account.getId(), account.getBalance());
+            }
+
+            verifyTotalBalance(accounts, NUM_ACCOUNTS * INITIAL_BALANCE);
+
+        } catch (InterruptedException e) {
+            System.err.println("Banking simulation was interrupted: " + e.getMessage());
+            Thread.currentThread().interrupt();
+        } catch (Exception e) {
+            System.err.println("Error in banking simulation: " + e.getMessage());
+            e.printStackTrace();
+        }
     }
-    public static void main(String[] args) throws InterruptedException {
-        BankingMain main = new BankingMain();
-        List<BankAccount> accounts = main.calculate();
-        for(BankAccount account : accounts){
-            System.out.println("Final balance of Account Number "  + account.getId() + " : " + account.getBalance());
+
+    private static void verifyTotalBalance(List<BankAccount> accounts, int expectedTotal) {
+        int actualTotal = accounts.stream()
+                .mapToInt(BankAccount::getBalance)
+                .sum();
+
+        System.out.printf("\nBalance Verification:%nExpected Total: %,d%nActual Total: %,d%n",
+                expectedTotal, actualTotal);
+
+        if (actualTotal != expectedTotal) {
+            System.err.println("WARNING: Balance discrepancy detected!");
+        } else {
+            System.out.println("Balance verification successful!");
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/Banking/TransactionProcessor.java b/src/main/java/Banking/TransactionProcessor.java
index 0842dc0..a4aaf15 100644
--- a/src/main/java/Banking/TransactionProcessor.java
+++ b/src/main/java/Banking/TransactionProcessor.java
@@ -4,11 +4,16 @@
 import java.io.InputStreamReader;
 import java.util.List;
 import java.util.Objects;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 public class TransactionProcessor implements Runnable {
     private final BankAccount account;
     private final String fileName;
     private final List<BankAccount> allAccounts;
+    private final Lock logLock = new ReentrantLock();
+    private static int transactionCounter = 0;
+    private static final Lock counterLock = new ReentrantLock();
 
     public TransactionProcessor(BankAccount account, String fileName, List<BankAccount> allAccounts) {
         this.account = account;
@@ -18,37 +23,103 @@ public TransactionProcessor(BankAccount account, String fileName, List<BankAccou
 
     @Override
     public void run() {
-        InputStreamReader is = new InputStreamReader(
+        logWithLock("Starting processing for account " + account.getId());
+
+        try (InputStreamReader is = new InputStreamReader(
                 Objects.requireNonNull(getClass().getClassLoader().getResourceAsStream(fileName)));
-        try (BufferedReader reader = new BufferedReader(is)) {
+             BufferedReader reader = new BufferedReader(is)) {
+
             String line;
             while ((line = reader.readLine()) != null) {
-                String[] parts = line.trim().split("\\s+");
-                if (parts.length == 0) continue;
-
-                switch (parts[0]) {
-                    case "Deposit":
-                        int depositAmount = Integer.parseInt(parts[1]);
-                        account.deposit(depositAmount);
-                        break;
-
-                    case "Withdraw":
-                        int withdrawAmount = Integer.parseInt(parts[1]);
-                        account.withdraw(withdrawAmount);
-                        break;
-
-                    case "Transfer":
-                        int targetIndex = Integer.parseInt(parts[1])-1;
-                        int transferAmount = Integer.parseInt(parts[2]);
-
-                        BankAccount target = allAccounts.get(targetIndex);
-                        account.transfer(target, transferAmount);
-                        break;
-                }
+                processTransactionLine(line.trim());
             }
+
         } catch (Exception e) {
+            logWithLock("Error processing file " + fileName + ": " + e.getMessage());
             e.printStackTrace();
+        } finally {
+            logWithLock("Completed processing for account " + account.getId());
         }
     }
-}
 
+    private void processTransactionLine(String line) {
+        if (line.isEmpty()) return;
+
+        String[] parts = line.split("\\s+");
+        String transactionType = parts[0];
+
+        try {
+            switch (transactionType) {
+                case "Deposit":
+                    int depositAmount = Integer.parseInt(parts[1]);
+                    account.deposit(depositAmount);
+                    logTransaction(transactionType, depositAmount);
+                    break;
+
+                case "Withdraw":
+                    int withdrawAmount = Integer.parseInt(parts[1]);
+                    account.withdraw(withdrawAmount);
+                    logTransaction(transactionType, withdrawAmount);
+                    break;
+
+                case "Transfer":
+                    int targetIndex = Integer.parseInt(parts[1]) - 1;
+                    int transferAmount = Integer.parseInt(parts[2]);
+                    BankAccount target = allAccounts.get(targetIndex);
+                    account.transfer(target, transferAmount);
+                    logTransfer(transferAmount, target);
+                    break;
+
+                default:
+                    logWithLock("Unknown transaction type: " + transactionType);
+            }
+
+            incrementTransactionCounter();
+
+        } catch (NumberFormatException e) {
+            logWithLock("Invalid number format in transaction: " + line);
+        } catch (IndexOutOfBoundsException e) {
+            logWithLock("Invalid target account in transfer: " + line);
+        } catch (Exception e) {
+            logWithLock("Error processing transaction: " + line + " - " + e.getMessage());
+        }
+    }
+
+    private void logTransaction(String type, int amount) {
+        logWithLock(String.format("Processed %s of %d for account %d. New balance: %d",
+                type, amount, account.getId(), account.getBalance()));
+    }
+
+    private void logTransfer(int amount, BankAccount target) {
+        logWithLock(String.format("Transfer %d from account %d to %d. Balances: %d -> %d",
+                amount, account.getId(), target.getId(),
+                account.getBalance(), target.getBalance()));
+    }
+
+    private void logWithLock(String message) {
+        logLock.lock();
+        try {
+            System.out.println("[Thread-" + Thread.currentThread().getId() + "] " + message);
+        } finally {
+            logLock.unlock();
+        }
+    }
+
+    private void incrementTransactionCounter() {
+        counterLock.lock();
+        try {
+            transactionCounter++;
+        } finally {
+            counterLock.unlock();
+        }
+    }
+
+    public static int getTransactionCount() {
+        counterLock.lock();
+        try {
+            return transactionCounter;
+        } finally {
+            counterLock.unlock();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/MonteCarloPI/MonteCarloPi.java b/src/main/java/MonteCarloPI/MonteCarloPi.java
index 861fe73..cc5505f 100644
--- a/src/main/java/MonteCarloPI/MonteCarloPi.java
+++ b/src/main/java/MonteCarloPI/MonteCarloPi.java
@@ -1,15 +1,14 @@
 package MonteCarloPI;
 
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.Random;
 
 public class MonteCarloPi {
-
     static final long NUM_POINTS = 50_000_000L;
     static final int NUM_THREADS = Runtime.getRuntime().availableProcessors();
-    public static void main(String[] args) throws InterruptedException, ExecutionException
-    {
+
+    public static void main(String[] args) throws InterruptedException, ExecutionException {
         // Without Threads
         System.out.println("Single threaded calculation started: ");
         long startTime = System.nanoTime();
@@ -19,37 +18,66 @@ public static void main(String[] args) throws InterruptedException, ExecutionExc
         System.out.println("Time taken (single threads): " + (endTime - startTime) / 1_000_000 + " ms");
 
         // With Threads
-        System.out.printf("Multi threaded calculation started: (your device has %d logical threads)\n",NUM_THREADS);
+        System.out.printf("Multi threaded calculation started: (your device has %d logical threads)\n", NUM_THREADS);
         startTime = System.nanoTime();
         double piWithThreads = estimatePiWithThreads(NUM_POINTS, NUM_THREADS);
         endTime = System.nanoTime();
         System.out.println("Monte Carlo Pi Approximation (Multi-threaded): " + piWithThreads);
         System.out.println("Time taken (Multi-threaded): " + (endTime - startTime) / 1_000_000 + " ms");
-
-        // TODO: After completing the implementation, reflect on the questions in the description of this task in the README file
-        //       and include your answers in your report file.
     }
 
     // Monte Carlo Pi Approximation without threads
-    public static double estimatePiWithoutThreads(long numPoints)
-    {
-        // TODO: Implement this method to calculate Pi using a single thread
-        return 0;
+    public static double estimatePiWithoutThreads(long numPoints) {
+        Random rand = new Random();
+        long pointsInsideCircle = 0;
+
+        for (long i = 0; i < numPoints; i++) {
+            double x = rand.nextDouble() * 2 - 1; // [-1, 1]
+            double y = rand.nextDouble() * 2 - 1; // [-1, 1]
+
+            if (x * x + y * y <= 1) {
+                pointsInsideCircle++;
+            }
+        }
+
+        return 4.0 * pointsInsideCircle / numPoints;
     }
 
     // Monte Carlo Pi Approximation with threads
-    public static double estimatePiWithThreads(long numPoints, int numThreads) throws InterruptedException, ExecutionException
-    {
-        // TODO: Implement this method to calculate Pi using multiple threads
+    public static double estimatePiWithThreads(long numPoints, int numThreads)
+            throws InterruptedException, ExecutionException {
 
         ExecutorService executor = Executors.newFixedThreadPool(numThreads);
+        AtomicLong totalPointsInsideCircle = new AtomicLong(0);
+        long pointsPerThread = numPoints / numThreads;
+
+        // Submit tasks to executor
+        for (int i = 0; i < numThreads; i++) {
+            final long threadPoints = (i == numThreads - 1) ?
+                    numPoints - (pointsPerThread * (numThreads - 1)) :
+                    pointsPerThread;
+
+            executor.submit(() -> {
+                Random rand = new Random();
+                long localPointsInside = 0;
+
+                for (long j = 0; j < threadPoints; j++) {
+                    double x = rand.nextDouble() * 2 - 1;
+                    double y = rand.nextDouble() * 2 - 1;
+
+                    if (x * x + y * y <= 1) {
+                        localPointsInside++;
+                    }
+                }
+
+                totalPointsInsideCircle.addAndGet(localPointsInside);
+            });
+        }
 
-        // HINT: You may need to create a variable to *safely* keep track of points that fall inside the circle
-        // HINT: Each thread should generate and process a subset of the total points
+        // Shutdown executor and wait for termination
+        executor.shutdown();
+        executor.awaitTermination(1, TimeUnit.MINUTES);
 
-        // TODO: After submitting all tasks, shut down the executor to prevent new tasks
-        // TODO: wait for the executor to be fully terminated
-        // TODO: Calculate and return the final estimation of Pi
-        return 0;
+        return 4.0 * totalPointsInsideCircle.get() / numPoints;
     }
 }
\ No newline at end of file