diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
new file mode 100644
index 0000000..b5f9181
--- /dev/null
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -0,0 +1,8 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="JavadocDeclaration" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ADDITIONAL_TAGS" value="RunTimeComplexity" />
+    </inspection_tool>
+  </profile>
+</component>
\ No newline at end of file
diff --git a/src/13a.png b/src/13a.png
new file mode 100644
index 0000000..c1e2ed4
Binary files /dev/null and b/src/13a.png differ
diff --git a/src/13b b/src/13b
new file mode 100644
index 0000000..b9e07e5
--- /dev/null
+++ b/src/13b
@@ -0,0 +1,5 @@
+(1) ab
+(2) abbb
+(3) bbbb
+(4) כאשר המילה מתחילה בb, השפה מקבלת את כל המילים שבהם מספר הb זוגי וגם אין את האות a
+(4) כאשר המילה מתחילה בa, השפה מקבלת את כל המילים באורך זוגי
\ No newline at end of file
diff --git a/src/15a.png b/src/15a.png
new file mode 100644
index 0000000..5b28aae
Binary files /dev/null and b/src/15a.png differ
diff --git a/src/15b.png b/src/15b.png
new file mode 100644
index 0000000..9db88ec
Binary files /dev/null and b/src/15b.png differ
diff --git a/src/15c.png b/src/15c.png
new file mode 100644
index 0000000..ea23d63
Binary files /dev/null and b/src/15c.png differ
diff --git a/src/16.png b/src/16.png
new file mode 100644
index 0000000..48bddd3
Binary files /dev/null and b/src/16.png differ
diff --git a/src/16c b/src/16c
new file mode 100644
index 0000000..4e47c55
--- /dev/null
+++ b/src/16c
@@ -0,0 +1 @@
+המכונה בודקת אם יש יותר a או b, המכונה הופכת את סימן השאלה לA או B בהתאם, מספר האותיות שנשאר אחרי סיום המכונה הוא ההפרש בין המספרים. אם ההפרש הוא 0 יהיה רק B באמצע
\ No newline at end of file
diff --git a/src/1a.png b/src/1a.png
new file mode 100644
index 0000000..2f36206
Binary files /dev/null and b/src/1a.png differ
diff --git a/src/1bc b/src/1bc
new file mode 100644
index 0000000..8364745
--- /dev/null
+++ b/src/1bc
@@ -0,0 +1,3 @@
+(B) karamba(1, b, 0, 2)
+(C) הפעולה מחזירה את סכום במערך בין המיקומים s וe שגדולים מk
+(D) O(n) כשn הוא הטווח
\ No newline at end of file
diff --git a/src/H25.java b/src/H25.java
new file mode 100644
index 0000000..9c8b7a3
--- /dev/null
+++ b/src/H25.java
@@ -0,0 +1,111 @@
+import utils.BinNode;
+import utils.Queue;
+import classes.*;
+
+public class H25 extends Main {
+
+    public static RealSet clone(RealSet rs) {
+        RealSet temp = new RealSet();
+        for (int i = 0; i < rs.size(); i++) {
+            temp.insert(rs.findBiggest());
+            rs.remove(rs.findBiggest());
+        }
+        RealSet clone = new RealSet();
+        for (int i = 0; i < temp.size(); i++) {
+            double biggest = temp.findBiggest();
+            rs.insert(biggest);
+            clone.insert(biggest);
+            temp.remove(biggest);
+        }
+        return clone;
+    }
+
+    public static RealSet buildNeg(RealSet rs) {
+        RealSet findIfThereIsNegative = clone(rs);
+        boolean isThereNegative = false;
+        for (int i = 0; i < findIfThereIsNegative.size(); i++) {
+            double biggest = findIfThereIsNegative.findBiggest();
+            if (biggest < 0) {
+                isThereNegative = true;
+            }
+            findIfThereIsNegative.remove(biggest);
+        }
+        if (!isThereNegative) {
+            return new RealSet();
+        }
+
+        RealSet clone = clone(rs);
+        while (clone.findBiggest() > 0) {
+            clone.remove(clone.findBiggest());
+        }
+        return clone;
+    }
+
+    public static <T> void inOrder(BinNode<T> root) {
+        if (root != null) {
+            inOrder(root.getLeft());
+            System.out.print(root);
+            inOrder(root.getRight());
+        }
+    }
+
+    public static Queue<Integer> q2A(BinNode<Queue<Integer>> root) {
+        return q2A(root, new Queue<>());
+    }
+
+    /**
+     * @RunTimeComplexity O(n) when n is the number of nodes in the tree
+     */
+    public static Queue<Integer> q2A(BinNode<Queue<Integer>> root, Queue<Integer> queue) {
+        if (root != null) {
+            q2A(root.getLeft(), queue);
+            if (root.getValue().isEmpty()) {
+                queue.insert(0);
+            } else if (lengthQueue(root.getValue()) == 1) {
+                queue.insert(root.getValue().remove());
+            } else if (lengthQueue(root.getValue()) == 2) {
+                queue.insert(root.getValue().remove() + root.getValue().remove());
+            } else {
+                queue.insert(
+                        root.getValue().remove() +
+                                root.getValue().remove() +
+                                root.getValue().remove()
+                );
+            }
+            q2A(root.getRight(), queue);
+        }
+        return queue;
+    }
+
+    public static boolean game(Card[] cards) {
+        Deck deck = new Deck();
+        for (Card card : cards) {
+            deck.insert(card);
+        }
+        boolean shouldFinishGame = false;
+        while (!shouldFinishGame) {
+            int shape = (int) (Math.random() * 4);
+            if (!deck.move(shape)) {
+                shouldFinishGame = true;
+            }
+        }
+        return deck.sum() % 100 == 0;
+    }
+
+    public static void main(String[] args) {
+        Queue<Integer> q1 = buildQueue(8, 4, 9, 7);
+        Queue<Integer> q2 = buildQueue(1, 8, 1, 2);
+        Queue<Integer> q3 = buildQueue(3, 1);
+        Queue<Integer> q4 = new Queue<>();
+        Queue<Integer> q5 = buildQueue(2, 9, 4, 1);
+
+        BinNode<Queue<Integer>> root = new BinNode<>(q1);
+        root.setRight(new BinNode<>(q2));
+        root.getRight().setLeft(new BinNode<>(q3));
+        root.getRight().setRight(new BinNode<>(q4));
+        root.getRight().getRight().setLeft(new BinNode<>(q5));
+
+        System.out.println(q2A(root));
+    }
+
+}
diff --git a/src/classes/Card.java b/src/classes/Card.java
new file mode 100644
index 0000000..9036a5d
--- /dev/null
+++ b/src/classes/Card.java
@@ -0,0 +1,4 @@
+package classes;
+
+public record Card(int value, int shape) {
+}
\ No newline at end of file
diff --git a/src/classes/Deck.java b/src/classes/Deck.java
new file mode 100644
index 0000000..ba1be24
--- /dev/null
+++ b/src/classes/Deck.java
@@ -0,0 +1,56 @@
+package classes;
+
+import utils.HelpCommands;
+import utils.Node;
+
+public class Deck {
+
+    private final Node<Card> deck1;
+    private final Node<Card> deck2;
+    private final Node<Card> deck3;
+    private final Node<Card> deck4;
+
+    private final Node<Card> deck5;
+
+    public Deck() {
+        deck1 = new Node<>(new Card(-1, -1));
+        deck2 = new Node<>(new Card(-1, -1));
+        deck3 = new Node<>(new Card(-1, -1));
+        deck4 = new Node<>(new Card(-1, -1));
+
+        deck5 = new Node<>(new Card(-1, -1));
+    }
+
+    private Node<Card> getDeckByShape(int shape){
+        return switch (shape){
+            case 1 -> deck1;
+            case 2 -> deck2;
+            case 3 -> deck3;
+            case 4 -> deck4;
+            default -> throw new IllegalStateException("Unexpected value: " + shape);
+        };
+    }
+
+    public void insert(Card card){
+        HelpCommands.setLast(getDeckByShape(card.shape()), card);
+    }
+
+    public boolean move(int shape){
+        if (HelpCommands.lenNodes(getDeckByShape(shape)) < 2) {
+            return false;
+        }
+        HelpCommands.setLast(deck5, HelpCommands.getLast(getDeckByShape(shape)));
+        return true;
+    }
+
+    public int sum(){
+        int sum = 0;
+        Node<Card> p = deck5;
+        while (p != null) {
+            sum += p.getValue().value();
+            p = p.getNext();
+        }
+        return sum;
+    }
+
+}
diff --git a/src/classes/RealSet.java b/src/classes/RealSet.java
new file mode 100644
index 0000000..ba2f0b9
--- /dev/null
+++ b/src/classes/RealSet.java
@@ -0,0 +1,43 @@
+package classes;
+
+import utils.HelpCommands;
+import utils.Node;
+
+public class RealSet {
+
+    private Node<Double> node;
+
+    public RealSet() {
+    }
+
+    public int size(){
+        return HelpCommands.lenNodes(node);
+    }
+
+    public void insert(double num){
+        if (node == null) {
+            node = new Node<>(num);
+        } else {
+            HelpCommands.setLast(node, num);
+        }
+    }
+
+    public void insert(double... numbers){
+        for (double num : numbers){
+            HelpCommands.setLast(node, num);
+        }
+    }
+
+    public void remove(double num){
+        node = HelpCommands.removeValue(node, num);
+    }
+
+    public double findBiggest(){
+        return HelpCommands.findMax(node, true);
+    }
+
+    @Override
+    public String toString() {
+        return node.toString();
+    }
+}
diff --git a/src/ex14.png b/src/ex14.png
new file mode 100644
index 0000000..85ee785
Binary files /dev/null and b/src/ex14.png differ
diff --git a/src/utils/HelpCommands.java b/src/utils/HelpCommands.java
index 1440b72..9b36473 100644
--- a/src/utils/HelpCommands.java
+++ b/src/utils/HelpCommands.java
@@ -285,6 +285,14 @@ public static Queue<Integer> buildQueue(int n, int max) {
         return queue;
     }
 
+    public static <T> Queue<T> buildQueue(T... values) {
+        Queue<T> queue = new Queue<>();
+        for (T value : values){
+            queue.insert(value);
+        }
+        return queue;
+    }
+
     /**
      * @param queue
      * @return the length of the queue
@@ -477,6 +485,15 @@ public static int findMax(Node<Integer> node) {
         return max;
     }
 
+    public static double findMax(Node<Double> node, boolean idk) {
+        double max = node.getValue();
+        while (node.getNext() != null) {
+            max = Math.max(max, node.getNext().getValue());
+            node = node.getNext();
+        }
+        return max;
+    }
+
     /**
      * @param node the node
      * @return the length of the node
@@ -571,12 +588,12 @@ public static <T> Node<T> removeValue(Node<T> node, T value) {
             node = node.getNext();
         }
         Node<T> p = node;
-        for (int i = 0; i < lenNodes(node); i++) {
-            if (p.getNext().getValue() == value) {
+        while (p.getNext() != null){
+            if (p.getNext().getValue().equals(value)) {
                 p.setNext(p.getNext().getNext());
-            } else {
-                p = p.getNext();
+                return node;
             }
+            p = p.getNext();
         }
         return node;
     }
@@ -592,6 +609,20 @@ public static <T> Node<T> setFirst(Node<T> node, T value) {
         return ret;
     }
 
+    public static <T> void setLast(Node<T> node, T value){
+        while (node.getNext() != null) {
+            node = node.getNext();
+        }
+        node.setNext(new Node<>(value));
+    }
+
+    public static <T> T getLast(Node<T> node){
+        while (node.getNext() != null) {
+            node = node.getNext();
+        }
+        return node.getValue();
+    }
+
     /**
      * @param fst the node to reverse
      * @return a reversed form of the given node