diff --git a/commander/src/main/java/hse/java/commander/MainController.java b/commander/src/main/java/hse/java/commander/MainController.java
index 5de3b66d..bb4e07b1 100644
--- a/commander/src/main/java/hse/java/commander/MainController.java
+++ b/commander/src/main/java/hse/java/commander/MainController.java
@@ -1,45 +1,205 @@
-package hse.java.commander;
-
-import javafx.fxml.FXML;
-import javafx.scene.control.Button;
-import javafx.scene.control.ListView;
-
-import java.nio.file.Path;
-
-public class MainController {
-
-    @FXML
-    public ListView<String> left;
-
-    @FXML
-    public ListView<String> right;
-
-    @FXML
-    public Button move;
-
-    private Path leftDir;
-    private Path rightDir;
-
-    // for testing
-    public void setInitialDirs(Path leftStart, Path rightStart) {
-        this.leftDir = leftStart;
-        this.rightDir = rightStart;
-    }
-
-    public void initialize() {
-        move.setOnMouseClicked(event -> {
-
-        });
-        System.out.println(System.getProperty("user.home"));
-        left.getItems().add("Kek");
-
-        left.setOnMouseClicked(event -> {
-            if (event.getClickCount() == 2) {
-                int index = left.getSelectionModel().getSelectedIndex();
-                if (index >= 0) {
-                    left.getItems().set(index, "clicked");
-                }
-            }
-        });
-    }
-}
+package hse.java.commander;
+
+import java.io.IOException;
+import java.nio.file.*;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.IntBinaryOperator;
+import java.util.stream.Stream;
+
+import javafx.collections.ObservableList;
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.scene.control.*;
+import javafx.scene.layout.AnchorPane;
+
+public class MainController {
+
+    @FXML
+    public Button copy;
+    @FXML
+    public Button move;
+    @FXML
+    public Button delete;
+    boolean focused = false;
+
+    Path leftDir = null;
+    Path rightDir = null;
+    AnchorPane pane = new AnchorPane();
+    Label viewPathLeft = new Label("");
+    Label viewPathRight = new Label("");
+
+    @FXML
+    public ListView<Path> left;
+
+    @FXML
+    public ListView<Path> right;
+
+    private void updateView(ListView<Path> target, Path dir) {
+        target.getItems().clear();
+        Path parentDir = dir.getParent();
+        target.getItems().add(parentDir);
+
+        try (Stream<Path> paths = Files.list(dir)) {
+            paths.forEach(path -> target.getItems().add(path));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void customList(ListView<Path> target, Path dir) {
+        target.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
+
+        target.setCellFactory(p -> new ListCell<Path>() {
+            @Override
+            protected void updateItem(Path path, boolean empty) {
+                super.updateItem(path, empty);
+
+                if (empty || path == null) {
+                    setText(null);
+                    setGraphic(null);
+                    return;
+                }
+
+                Path currentDir = (target == left) ? leftDir : rightDir;
+
+                Path parent = currentDir == null ? null : currentDir.getParent();
+
+                if (path.equals(parent)) {
+                    setText("...");
+                } else {
+                    setText(path.getFileName().toString());
+                }
+
+            }
+        });
+    }
+
+    private void setCustomClick(ListView<Path> left1, ListView<Path> right1, boolean chanceFocus) {
+        left1.setOnMouseClicked(event -> {
+            right1.getSelectionModel().clearSelection();
+            focused = chanceFocus;
+            if (event.getClickCount() == 2) {
+                int index = left1.getSelectionModel().getSelectedIndex();
+                if (index >= 0 && Files.isDirectory(left1.getItems().get(index))) {
+                    if (!chanceFocus) {
+                        leftDir = left1.getItems().get(index);
+                    } else {
+                        rightDir = right.getItems().get(index);
+                    }
+                    left1.getItems().clear();
+                    updateView(left1, !chanceFocus ? leftDir : rightDir);
+                }
+            }
+        });
+    }
+
+    @FXML
+    public void setInitialDirs(Path leftStart, Path rightStart) {
+        this.leftDir = leftStart;
+        this.rightDir = rightStart;
+
+        updateView(left, leftDir);
+        updateView(right, rightDir);
+
+        customList(left, leftDir);
+        customList(right, rightDir);
+
+        setCustomClick(left, right, false);
+        setCustomClick(right, left, true);
+    }
+
+    private void clearSelect() {
+        left.getSelectionModel().clearSelection();
+        right.getSelectionModel().clearSelection();
+    }
+
+    public void handleMove(ActionEvent actionEvent) {
+        System.out.println(focused);
+
+        ListView<Path> nowSelected = !focused ? left : right;
+        ListView<Path> target = focused ? left : right;
+        Path targetDir = focused ? leftDir : rightDir;
+
+        ObservableList<Path> selectionItem = nowSelected.getSelectionModel().getSelectedItems();
+
+        for (Path sourcePath : List.copyOf(selectionItem))
+            try {
+                System.out.println("Перемещение: " + sourcePath + " : " + sourcePath.getFileName());
+                Files.move(sourcePath, targetDir.resolve(sourcePath.getFileName()));
+//                target.getItems().add(targetDir.resolve(sourcePath.getFileName()));
+//                nowSelected.getItems().remove(sourcePath);
+            } catch (IOException e) {
+                System.err.println("Ошибка перемещения");
+                e.printStackTrace();
+
+            }
+        updateView(left, leftDir);
+        updateView(right, rightDir);
+        clearSelect();
+    }
+
+    public void handleCopy(ActionEvent actionEvent) {
+        ListView<Path> nowSelected = !focused ? left : right;
+        ListView<Path> target = focused ? left : right;
+        Path targetDir = focused ? leftDir : rightDir;
+
+        ObservableList<Path> selectionItem = nowSelected.getSelectionModel().getSelectedItems();
+
+        for (Path sourcePath : List.copyOf(selectionItem)) {
+            try (Stream<Path> currentPath = Files.walk(sourcePath)) {
+                currentPath.forEach(source -> {
+                    try {
+                        Path relativePath = sourcePath.relativize(source);
+                        Path newPath = targetDir.resolve(sourcePath.getFileName()).resolve(relativePath);
+                        if (Files.isDirectory(source)) {
+                            Files.createDirectories(newPath);
+                        } else {
+                            Files.copy(source, newPath);
+                        }
+                        if (newPath.getParent().equals(targetDir)) {
+//                            target.getItems().add(newPath);
+                        }
+                    } catch (IOException e) {
+                        System.err.println("Ошибка копирования: " + source);
+                        e.printStackTrace();
+                    }
+                });
+            } catch (IOException e) {
+                System.err.println("Ошибка рекурсивного копирования!");
+            }
+        }
+        updateView(left, leftDir);
+        updateView(right, rightDir);
+        clearSelect();
+    }
+
+    public void handleDelete(ActionEvent actionEvent) {
+        ListView<Path> nowSelected = !focused ? left : right;
+        Path targetDir = !focused ? leftDir : rightDir;
+
+        ObservableList<Path> selectionItem = nowSelected.getSelectionModel().getSelectedItems();
+
+        for (Path sourcePath : List.copyOf(selectionItem)) {
+            try (Stream<Path> currentPath = Files.walk(sourcePath).sorted(Comparator.reverseOrder())) {
+                currentPath.forEach(source -> {
+                    try {
+                        Files.delete(source);
+                        if (source.getParent().equals(targetDir)) {
+//                            nowSelected.getItems().remove(source);
+                        }
+                    } catch (IOException e) {
+                        System.err.println("Ошибка копирования: " + source);
+                        e.printStackTrace();
+                    }
+                });
+            } catch (IOException e) {
+                System.err.println("Ошибка рекурсивного копирования!");
+            }
+        }
+        updateView(left, leftDir);
+        updateView(right, rightDir);
+        clearSelect();
+    }
+}
\ No newline at end of file
diff --git a/commander/src/main/resources/hse/java/commander/commander-ui.fxml b/commander/src/main/resources/hse/java/commander/commander-ui.fxml
index 724bbc8a..bdb85305 100644
--- a/commander/src/main/resources/hse/java/commander/commander-ui.fxml
+++ b/commander/src/main/resources/hse/java/commander/commander-ui.fxml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
+<?import javafx.geometry.*?>
 <?import javafx.scene.control.*?>
 <?import javafx.scene.layout.*?>
 
@@ -8,9 +9,15 @@
         <ListView fx:id="left" id="left" prefHeight="318.0" prefWidth="311.0" />
         <ListView fx:id="right" id="right" prefHeight="318.0" prefWidth="321.0" />
     </HBox>
-    <HBox spacing="10.0">
-        <Button fx:id="copy" mnemonicParsing="false" text="Copy" />
-        <Button fx:id="move" mnemonicParsing="false" text="Move" />
-        <Button fx:id="delete" mnemonicParsing="false" text="Delete" />
-    </HBox>
+
+    <ButtonBar prefHeight="52.0" prefWidth="580.0">
+        <buttons>
+            <Button fx:id="copy" mnemonicParsing="false" onAction="#handleCopy" text="Copy"/>
+            <Button fx:id="move" mnemonicParsing="false" onAction="#handleMove" text="Move"/>
+            <Button fx:id="delete" mnemonicParsing="false" onAction="#handleDelete" text="Delete"/>
+        </buttons>
+      <padding>
+         <Insets right="20.0" />
+      </padding>
+    </ButtonBar>
 </VBox>
diff --git a/commander/target/classes/hse/java/commander/commander-ui.fxml b/commander/target/classes/hse/java/commander/commander-ui.fxml
new file mode 100644
index 00000000..f3972079
--- /dev/null
+++ b/commander/target/classes/hse/java/commander/commander-ui.fxml
@@ -0,0 +1,14 @@
+git add commander/target/classes/hse/java/commander/commander-ui.fxml<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.*?>
+
+<VBox maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="421.0" prefWidth="627.0" xmlns="http://javafx.com/javafx/17.0.12" xmlns:fx="http://javafx.com/fxml/1" fx:controller="hse.java.commander.MainController">
+    <HBox prefHeight="370.0" prefWidth="627.0">
+
+        <ListView fx:id="left" prefHeight="318.0" prefWidth="311.0" />
+        <ListView fx:id="right" prefHeight="318.0" prefWidth="321.0" />
+
+    </HBox>
+   <Button fx:id="move" mnemonicParsing="false" text="Move" />
+</VBox>
diff --git a/src/main/java/hse/java/lectures/lecture3/practice/randomSet/RandomSet.java b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/RandomSet.java
index 8af477b5..52bbda16 100644
--- a/src/main/java/hse/java/lectures/lecture3/practice/randomSet/RandomSet.java
+++ b/src/main/java/hse/java/lectures/lecture3/practice/randomSet/RandomSet.java
@@ -1,21 +1,155 @@
 package hse.java.lectures.lecture3.practice.randomSet;
 
-public class RandomSet<T> {
+import java.util.Random;
+
+public class RandomSet<T extends Comparable<T>> {
+
+    private static class Node<V extends Comparable<V>> {
+        int priority;
+        V value;
+        int size = 1;
+        int index;
+        Node<V> left = null;
+        Node<V> right = null;
+    }
+
+    private final Random rand = new Random();
+
+    private Node<T> root = null;
+
+    private Object[] randomArray = new Object[1024];
+
+    private int size = 0;
+
+    private void add_array(T x) {
+        if (size * 2 > randomArray.length) {
+            int newLen = randomArray.length * 2;
+            Object[] newArr = new Object[newLen];
+            System.arraycopy(randomArray, 0, newArr, 0, randomArray.length);
+            randomArray = newArr;
+        }
+        randomArray[size] = x;
+        size += 1;
+    }
+
+    private int nodeSize(Node<T> n) {
+        return n == null ? 0 : n.size;
+    }
+
+    private Node<T> descent(Node<T> root, T value) {
+        if (root == null) {
+            return null;
+        }
+
+        if (root.value.compareTo(value) > 0) {
+            return descent(root.left, value);
+        }
+
+        if (root.value.compareTo(value) < 0) {
+            return descent(root.right, value);
+        }
+        return root;
+    }
+
+
+    private Node<T>[] split(Node<T> root, T x) {
+        if (root == null) {
+            return new Node[]{null, null};
+        } else if (x.compareTo(root.value) > 0) {
+            Node<T>[] res = split(root.right, x);
+            root.right = res[0];
+            root.size = 1 + nodeSize(res[0]) + nodeSize(res[1]);
+            return new Node[]{root, res[1]};
+        }
+        Node<T>[] res = split(root.left, x);
+        root.left = res[1];
+        root.size = 1 + nodeSize(res[0]) + nodeSize(res[1]);
+        return new Node[]{res[0], root};
+    }
+
+    private Node<T> merge(Node<T> left, Node<T> right) {
+        if (left == null) {
+            return right;
+        }
+
+        if (right == null) {
+            return left;
+        }
+
+        if (left.priority > right.priority) {
+            left.right = merge(left.right, right);
+            left.size = 1 + nodeSize(left.left) + nodeSize(left.right);
+            return left;
+        }
+        right.left = merge(left, right.left);
+        right.size = 1 + nodeSize(right.left) + nodeSize(right.right);
+        return right;
+    }
 
     public boolean insert(T value) {
-        throw new UnsupportedOperationException("Not implemented");
+        if (descent(root, value) != null) {
+            return false;
+        }
+        Node<T> new_node = new Node<T>();
+        new_node.value = value;
+        new_node.priority = rand.nextInt();
+        new_node.index = size;
+
+        add_array(value);
+
+        Node<T>[] res = split(root, value);
+        Node<T> l1 = merge(res[0], new_node);
+
+        root = merge(l1, res[1]);
+        return true;
+    }
+
+    private Node<T> removeMin(Node<T> node) {
+        if (node.left == null) {
+            return node.right;
+        }
+        node.left = removeMin(node.left);
+        node.size = 1 + nodeSize(node.left) + nodeSize(node.right);
+        return node;
     }
 
     public boolean remove(T value) {
-        throw new UnsupportedOperationException("Not implemented");
+        Node<T> target = descent(root, value);
+        if (target == null) {
+            return false;
+        }
+
+        Node<T>[] res = split(root, value);
+        Node<T> left = res[0];
+        Node<T> right = res[1];
+
+        right = removeMin(right);
+        root = merge(left, right);
+
+        int id_val = target.index;
+        int id_end = size - 1;
+
+
+        size -= 1;
+        if (id_val != id_end) {
+            randomArray[id_val] = randomArray[id_end];
+            Node<T> end_node = descent(root, (T) randomArray[id_val]);
+            end_node.index = id_val;
+        }
+        randomArray[id_end] = null;
+
+        return true;
     }
 
     public boolean contains(T value) {
-        throw new UnsupportedOperationException("Not implemented");
+        return descent(root, value) != null;
     }
 
     public T getRandom() {
-        throw new UnsupportedOperationException("Not implemented");
+        if (size == 0) {
+            throw new EmptySetException("Owch");
+        }
+        int n = rand.nextInt(size);
+        return (T) randomArray[n];
     }
-
 }
diff --git a/src/main/java/hse/java/lectures/lecture3/tasks/html/HtmlDocument.java b/src/main/java/hse/java/lectures/lecture3/tasks/html/HtmlDocument.java
index 1ddf27bf..8888876d 100644
--- a/src/main/java/hse/java/lectures/lecture3/tasks/html/HtmlDocument.java
+++ b/src/main/java/hse/java/lectures/lecture3/tasks/html/HtmlDocument.java
@@ -27,6 +27,83 @@ private String readFile(Path filePath) {
         }
     }
 
-    private void validate(String content){}
+    private void validate(String content) {
+        Deque<String> deque_part = new ArrayDeque<>();
+        int[] used = new int[3];
+        Set<String> set = Set.of("html", "head", "body", "div", "p");
+        boolean open_head = false;
+        boolean open_body = false;
 
+        for (int i = 0; i < content.length(); i++) {
+            int flag = 0;
+            StringBuilder str = new StringBuilder();
+            char c = content.charAt(i);
+            if (c == '<') {
+                i++;
+                if (content.charAt(i) == '/') {
+                    i += 1;
+                    flag = 1;
+                }
+                c = content.charAt(i);
+                while (c != '>' && c != ' ') {
+                    str.append(c);
+                    i++;
+                    c = content.charAt(i);
+                }
+                if (!set.contains(str.toString().toLowerCase())) {
+                    throw new UnsupportedTagException("Invalid command");
+                }
+            }
+            if (str.toString().isEmpty() && !set.contains(str.toString())) {
+                continue;
+            }
+            if (str.toString().equalsIgnoreCase("html")) {
+                if (used[0] >= 2) {
+                    throw new InvalidStructureException("Invalid struct");
+                }
+                used[0] += 1;
+            } else if (str.toString().equalsIgnoreCase("head")) {
+                open_head = true;
+                if(used[0] == 0 || used[2] > 0){
+                    throw new InvalidStructureException("Invalid struct");
+                }
+                if (used[1] >= 2) {
+                    throw new InvalidStructureException("Invalid struct");
+                }
+                used[1] += 1;
+            }else if (str.toString().equalsIgnoreCase("body")) {
+                open_body = true;
+                if (used[2] >= 2) {
+                    throw new InvalidStructureException("Invalid struct");
+                }
+                used[2] += 1;
+            }
+
+            if (flag == 0) {
+
+                if (c == ' ') {
+                    while (c != '>') {
+                        i++;
+                        c = content.charAt(i);
+                    }
+                }
+                deque_part.offerFirst(str.toString().toLowerCase());
+            } else {
+                if (deque_part.isEmpty()) {
+                    throw new UnexpectedClosingTagException("Unexpected tag");
+                }
+                if (deque_part.getFirst().contentEquals(str.toString().toLowerCase())) {
+                    deque_part.removeFirst();
+                } else {
+                    throw new MismatchedClosingTagException("Mismatched tag");
+                }
+            }
+            if(!open_head && !open_body && !str.toString().equalsIgnoreCase("html")){
+                throw new InvalidStructureException("Invalid struct");
+            }
+        }
+        if (!deque_part.isEmpty()) {
+            throw new UnclosedTagException("Unclosed tag");
+        }
+    }
 }
diff --git a/src/main/java/hse/java/lectures/lecture6/tasks/queue/BoundedBlockingQueue.java b/src/main/java/hse/java/lectures/lecture6/tasks/queue/BoundedBlockingQueue.java
index 5c686cff..f2c39210 100644
--- a/src/main/java/hse/java/lectures/lecture6/tasks/queue/BoundedBlockingQueue.java
+++ b/src/main/java/hse/java/lectures/lecture6/tasks/queue/BoundedBlockingQueue.java
@@ -1,25 +1,62 @@
 package hse.java.lectures.lecture6.tasks.queue;
 
+
+import java.util.ArrayDeque;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
 public class BoundedBlockingQueue<T> {
 
+    private final Object key = new Object();
+
+    int capacity = 0;
+
+    final Queue<T> queue = new ArrayDeque<>();
 
     public BoundedBlockingQueue(int capacity) {
+        synchronized (key) {
+            if (capacity <= 0) {
+                throw new IllegalArgumentException("Capacity <= 0");
+            }
+            this.capacity = capacity;
+        }
+    }
 
+    public void put(T item) throws InterruptedException {
+        synchronized (key) {
+            if (item == null) {
+                throw new NullPointerException("Item must be not null");
+            }
+            while(queue.size() >= capacity) {
+                key.wait();
+            }
+
+            queue.add(item);
+            key.notifyAll();
+        }
     }
 
-    public void put(T item) {
+    public T take() throws InterruptedException {
+        synchronized (key) {
+            while (queue.isEmpty()) {
+                key.wait();
+            }
+            T el = queue.poll();
+            key.notifyAll();
 
-    }
+            return el;
 
-    public T take() {
-        return null;
+        }
     }
 
     public int size() {
-        return 0;
+        synchronized (key) {
+            return queue.size();
+        }
     }
 
     public int capacity() {
-        return 0;
+        return capacity;
     }
 }
diff --git a/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/StreamWriter.java b/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/StreamWriter.java
index fedb5e66..393c5885 100644
--- a/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/StreamWriter.java
+++ b/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/StreamWriter.java
@@ -28,9 +28,11 @@ public void attachMonitor(StreamingMonitor monitor) {
     public void run() {
         // Writer threads are intentionally infinite for the task contract.
         while (true) {
-            output.print(message);
-            onTick.run();
+            try {
+                monitor.tick(id, onTick, output, message);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
         }
     }
-
 }
diff --git a/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/StreamingMonitor.java b/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/StreamingMonitor.java
index 68e8f279..446b5464 100644
--- a/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/StreamingMonitor.java
+++ b/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/StreamingMonitor.java
@@ -1,5 +1,41 @@
 package hse.java.lectures.lecture6.tasks.synchronizer;
 
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.With;
+
+import java.io.PrintStream;
+
+@Getter
 public class StreamingMonitor {
     // impl your sync here
+    private final Object key = new Object();
+    private final int N;
+    private final int ticksPerWriter;
+    private int cnt = 0;
+    private int nowId = 1;
+
+    public StreamingMonitor(int size, int ticksPerWriter) {
+        this.N = size;
+        this.ticksPerWriter = size * ticksPerWriter;
+    }
+
+    public boolean check(){
+        return cnt == ticksPerWriter;
+    }
+
+    public synchronized void tick(int idCome, Runnable onTick, PrintStream output, String message) throws InterruptedException {
+
+        while (idCome != nowId || cnt >= ticksPerWriter) {
+            wait();
+        }
+
+        nowId = Integer.max(1, (nowId + 1) % (N+1));
+        cnt += 1;
+
+        output.print(message);
+        onTick.run();
+
+        notifyAll();
+    }
 }
diff --git a/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/Synchronizer.java b/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/Synchronizer.java
index 3cb8aded..ee8c6a33 100644
--- a/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/Synchronizer.java
+++ b/src/main/java/hse/java/lectures/lecture6/tasks/synchronizer/Synchronizer.java
@@ -1,5 +1,6 @@
 package hse.java.lectures.lecture6.tasks.synchronizer;
 
+import javax.management.monitor.Monitor;
 import java.util.List;
 
 public class Synchronizer {
@@ -22,12 +23,20 @@ public Synchronizer(List<StreamWriter> tasks, int ticksPerWriter) {
      * in strict ascending id order.
      */
     public void execute() {
-        // add monitor and sync
+        StreamingMonitor streamingMonitor = new StreamingMonitor(tasks.size(), ticksPerWriter);
+
+        for (var stream : tasks){
+            stream.attachMonitor(streamingMonitor);
+        }
+
         for (StreamWriter writer : tasks) {
             Thread worker = new Thread(writer, "stream-writer-" + writer.getId());
             worker.setDaemon(true);
             worker.start();
         }
+        while (!streamingMonitor.check()){
+
+        }
     }
 
 }
diff --git a/src/main/java/hse/java/practice/task1/Edge.java b/src/main/java/hse/java/practice/task1/Edge.java
index d95ba56b..4b002213 100644
--- a/src/main/java/hse/java/practice/task1/Edge.java
+++ b/src/main/java/hse/java/practice/task1/Edge.java
@@ -1,6 +1,7 @@
 package hse.java.practice.task1;
 
 import java.util.Arrays;
+import java.util.Collections;
 
 public class Edge {
 
@@ -27,6 +28,35 @@ public CubeColor[][] getParts() {
         return parts;
     }
 
+    private void transpose() {
+        for (int i = 0; i < 3; i++) {
+            for (int j = i + 1; j < 3; j++) {
+                CubeColor temp = parts[i][j];
+                parts[i][j] = parts[j][i];
+                parts[j][i] = temp;
+            }
+        }
+    }
+
+    private void reverse() {
+        for (int i = 0; i < 3; i++) {
+            Collections.reverse(Arrays.asList(parts[i]));
+        }
+    }
+
+    public void rotate(RotateDirection direction) {
+        switch (direction) {
+            case CLOCKWISE -> {
+                transpose();
+                reverse();
+            }
+            case COUNTERCLOCKWISE -> {
+                reverse();
+                transpose();
+            }
+        }
+    }
+
     public void setParts(CubeColor[][] parts) {
         this.parts = parts;
     }
diff --git a/src/main/java/hse/java/practice/task1/RubiksCube.java b/src/main/java/hse/java/practice/task1/RubiksCube.java
index d986f9f0..9d7a35a0 100644
--- a/src/main/java/hse/java/practice/task1/RubiksCube.java
+++ b/src/main/java/hse/java/practice/task1/RubiksCube.java
@@ -1,5 +1,6 @@
 package hse.java.practice.task1;
 
+
 import java.util.Arrays;
 
 /**
@@ -25,35 +26,183 @@ public RubiksCube() {
             edges[i] = new Edge(colors[i]);
         }
     }
+    private void rotateUpRing(RotateDirection direction) {
+        int n;
+        if (direction == RotateDirection.CLOCKWISE) {
+            n = 3;
+        } else {
+            n = 1;
+        }
+        for (int j = 0; j < n; j++) {
+            CubeColor[] temp5 = Arrays.copyOf(edges[5].getParts()[0], 3);
+            edges[5].getParts()[0] = Arrays.copyOf(edges[3].getParts()[0], 3);
+            edges[3].getParts()[0] = Arrays.copyOf(edges[4].getParts()[0], 3);
+            edges[4].getParts()[0] = Arrays.copyOf(edges[2].getParts()[0], 3);
+            edges[2].getParts()[0] = temp5;
+        }
+    }
+
+    private void rotateDownRing(RotateDirection direction) {
+        int n;
+        if (direction == RotateDirection.CLOCKWISE) {
+            n = 1;
+        } else {
+            n = 3;
+        }
+        for (int j = 0; j < n; j++) {
+            CubeColor[] temp5 = Arrays.copyOf(edges[5].getParts()[2], 3);
+            edges[5].getParts()[2] = Arrays.copyOf(edges[3].getParts()[2], 3);
+            edges[3].getParts()[2] = Arrays.copyOf(edges[4].getParts()[2], 3);
+            edges[4].getParts()[2] = Arrays.copyOf(edges[2].getParts()[2], 3);
+            edges[2].getParts()[2] = temp5;
+        }
+    }
+
+    private void rotateRightRing(RotateDirection direction) {
+        int n;
+        if (direction == RotateDirection.CLOCKWISE) {
+            n = 1;
+        } else {
+            n = 3;
+        }
+        for (int j = 0; j < n; j++) {
+            CubeColor[] temp5 = new CubeColor[3];
+            for (int i = 0; i < 3; i++) {
+                temp5[i] = edges[5].getParts()[i][0];
+            }
+
+            for (int i = 0; i < 3; i++) {
+                edges[5].getParts()[i][0] = edges[0].getParts()[i][2];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[0].getParts()[i][2] = edges[4].getParts()[2 - i][2];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[4].getParts()[i][2] = edges[1].getParts()[i][2];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[1].getParts()[i][2] = temp5[2 - i];
+            }
+        }
+    }
+
+    private void rotateLeftRing(RotateDirection direction) {
+        int n;
+        if (direction == RotateDirection.CLOCKWISE) {
+            n = 1;
+        } else {
+            n = 3;
+        }
+        for (int j = 0; j < n; j++) {
+            CubeColor[] temp4 = new CubeColor[3];
+            for (int i = 0; i < 3; i++) {
+                temp4[i] = edges[4].getParts()[i][0];
+            }
+
+            for (int i = 0; i < 3; i++) {
+                edges[4].getParts()[i][0] = edges[0].getParts()[i][0];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[0].getParts()[i][0] = edges[5].getParts()[2 - i][2];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[5].getParts()[i][2] = edges[1].getParts()[i][0];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[1].getParts()[i][0] = temp4[2 - i];
+            }
+        }
+    }
+
+    private void rotateBackRing(RotateDirection direction) {
+        int n;
+        if (direction == RotateDirection.CLOCKWISE) {
+            n = 1;
+        } else {
+            n = 3;
+        }
+        for (int j = 0; j < n; j++) {
+            CubeColor[] temp2 = new CubeColor[3];
+            for (int i = 0; i < 3; i++) {
+                temp2[i] = edges[3].getParts()[i][2];
+            }
+
+            for (int i = 0; i < 3; i++) {
+                edges[3].getParts()[i][2] = edges[1].getParts()[2][2 - i];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[1].getParts()[2][i] = edges[2].getParts()[i][0];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[2].getParts()[i][0] = edges[0].getParts()[0][2 - i];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[0].getParts()[0][i] = temp2[i];
+            }
+        }
+    }
+
+    private void rotateFrontRing(RotateDirection direction){
+        int n;
+        if (direction == RotateDirection.CLOCKWISE) {
+            n = 1;
+        } else {
+            n = 3;
+        }
+        for (int j = 0; j < n; j++) {
+            CubeColor[] temp3 = new CubeColor[3];
+            for (int i = 0; i < 3; i++) {
+                temp3[i] = edges[3].getParts()[i][0];
+            }
+
+            for (int i = 0; i < 3; i++) {
+                edges[3].getParts()[i][0] = edges[0].getParts()[2][i];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[0].getParts()[2][i] = edges[2].getParts()[i][2];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[2].getParts()[i][2] = edges[1].getParts()[0][2 - i];
+            }
+            for (int i = 0; i < 3; i++) {
+                edges[1].getParts()[0][i] = temp3[2 - i];
+            }
+        }
+    }
 
     @Override
     public void up(RotateDirection direction) {
-
+        edges[0].rotate(direction);
+        rotateUpRing(direction);
     }
 
     @Override
     public void down(RotateDirection direction) {
-
+        edges[1].rotate(direction);
+        rotateDownRing(direction);
     }
 
     @Override
     public void left(RotateDirection direction) {
-
+        edges[2].rotate(direction);
+        rotateLeftRing(direction);
     }
 
     @Override
     public void right(RotateDirection direction) {
-
+        edges[3].rotate(direction);
+        rotateRightRing(direction);
     }
 
-    @Override
     public void front(RotateDirection direction) {
-
+        edges[4].rotate(direction);
+        rotateFrontRing(direction);
     }
 
     @Override
     public void back(RotateDirection direction) {
-
+        edges[5].rotate(direction);
+        rotateBackRing(direction);
     }
 
     public Edge[] getEdges() {
@@ -64,4 +213,4 @@ public Edge[] getEdges() {
     public String toString() {
         return Arrays.toString(edges);
     }
-}
+}
\ No newline at end of file
diff --git a/src/test/java/hse/java/lectures/lecture3/practice/randomSet/RandomSetBaseTest.java b/src/test/java/hse/java/lectures/lecture3/practice/randomSet/RandomSetBaseTest.java
index 38f6af46..18d0ba09 100644
--- a/src/test/java/hse/java/lectures/lecture3/practice/randomSet/RandomSetBaseTest.java
+++ b/src/test/java/hse/java/lectures/lecture3/practice/randomSet/RandomSetBaseTest.java
@@ -3,28 +3,115 @@
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 
+import java.util.Random;
+import java.util.Set;
+import java.util.HashSet;
+
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+
 import static org.junit.jupiter.api.Assertions.*;
 
 @Tag("randomset")
 class RandomSetBaseTest {
 
     @Test
-    void insertRemoveContains() {
-        RandomSet<Integer> set = new RandomSet<>();
+    void try_find_desync_by_random_tries() {
+        final int TRIES = 2000;       // количество попыток с разными seed'ами
+        final int OPS = 2000;         // операций в одной попытке
+        final int MAX_VAL = 500;      // диапазон значений
 
-        assertTrue(set.insert(10));
-        assertTrue(set.insert(20));
-        assertFalse(set.insert(10));
+        for (int seed = 0; seed < TRIES; seed++) {
+            Random rnd = new Random(seed);
+            RandomSet<Integer> set = new RandomSet<>();
+            Set<Integer> ref = new HashSet<>();
 
-        assertTrue(set.contains(10));
-        assertTrue(set.contains(20));
-        assertFalse(set.contains(30));
+            try {
+                for (int step = 0; step < OPS; step++) {
+                    int v = rnd.nextInt(MAX_VAL);
+                    boolean doInsert = rnd.nextInt(3) != 0; // чаще вставки
 
-        assertTrue(set.remove(10));
-        assertFalse(set.remove(10));
+                    if (doInsert) {
+                        boolean a = ref.add(v);
+                        boolean b = set.insert(v);
+                        if (a != b) {
+                            throw new IllegalStateException("insert mismatch at seed=" + seed + " step=" + step + " value=" + v);
+                        }
+                    } else {
+                        boolean a = ref.remove(v);
+                        boolean b = set.remove(v);
+                        if (a != b) {
+                            throw new IllegalStateException("remove mismatch at seed=" + seed + " step=" + step + " value=" + v);
+                        }
+                    }
 
-        assertFalse(set.contains(10));
-        assertTrue(set.contains(20));
+                    // периодически проверяем contains для всех элементов эталона
+                    if (step % 200 == 0) {
+                        for (int x : ref) {
+                            if (!set.contains(x)) {
+                                // вероятно возникла рассинхронизация: падаем и печатаем seed/step
+                                fail("Contains mismatch -> possible desync. seed=" + seed + " step=" + step + " missing=" + x);
+                            }
+                        }
+                    }
+                }
+            } catch (NullPointerException npe) {
+                // Нуль-указатель — признак той самой проблемы; сообщаем seed и шаг
+                fail("NullPointerException detected at seed=" + seed + " — reproduce by re-running with this seed. Exception: " + npe);
+            } catch (AssertionError | IllegalStateException e) {
+                // Любая другая несогласованность — тоже повод остановиться
+                fail("Invariant violation at seed=" + seed + ": " + e.getMessage());
+            }
+            // иначе — эта попытка прошла без проблем, пробуем следующий seed
+        }
+
+        // Если дошли сюда — за TRIES попыток не поймали рассинхронизацию
     }
 
+    @Test
+    void reflection_forces_NPE_in_remove() throws Exception {
+        RandomSet<Integer> set = new RandomSet<>();
+
+        // вставляем несколько элементов
+        set.insert(1); // index 0
+        set.insert(2); // index 1
+        set.insert(3); // index 2  <- последний элемент (id_end)
+
+        // убедимся, что целевой элемент (value=1) есть
+        if (!set.contains(1)) {
+            fail("precondition failed: target not present");
+        }
+
+        // достаём private fields через reflection
+        Field arrField = RandomSet.class.getDeclaredField("randomArray");
+        Field sizeField = RandomSet.class.getDeclaredField("size");
+        arrField.setAccessible(true);
+        sizeField.setAccessible(true);
+
+        Object[] arr = (Object[]) arrField.get(set);
+        int size = sizeField.getInt(set);
+        int idEnd = size - 1;
+
+        // Инвариант нарушаем: заменяем последний элемент в массиве
+        // на значение, которого нет в дереве. Это моделирует рассинхронизацию.
+        arr[idEnd] = Integer.valueOf(9999999);
+        arrField.set(set, arr);
+
+        // Теперь вызов remove(1) в текущей реализации должен попытаться
+        // найти movedNode по значению 9999999 в дереве и получить null,
+        // а затем при обращении к end_node.index упадёт NPE.
+        try {
+            set.remove(1);
+            fail("Expected remove(...) to throw NullPointerException (but it didn't)");
+        } catch (NullPointerException npe) {
+            // OK — это доказало уязвимость
+            System.out.println("Got NPE as expected: " + npe);
+        }
+    }
 }
+
diff --git a/src/test/java/hse/java/lectures/lecture6/SynchronizerTest.java b/src/test/java/hse/java/lectures/lecture6/SynchronizerBaseTest.java
similarity index 98%
rename from src/test/java/hse/java/lectures/lecture6/SynchronizerTest.java
rename to src/test/java/hse/java/lectures/lecture6/SynchronizerBaseTest.java
index 3b852d43..bfe62223 100644
--- a/src/test/java/hse/java/lectures/lecture6/SynchronizerTest.java
+++ b/src/test/java/hse/java/lectures/lecture6/SynchronizerBaseTest.java
@@ -16,7 +16,7 @@
 import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively;
 
 @Tag("synchronizer")
-public class SynchronizerTest {
+public class SynchronizerBaseTest {
 
     @Test
     void testPipeline() {