diff --git a/Calculator.java b/Calculator.java
deleted file mode 100644
index c31501dbd..000000000
--- a/Calculator.java
+++ /dev/null
@@ -1,201 +0,0 @@
-package my_calc;
-
-/**
- * Created by Nadya Zueva
- * при написании использована статья на e-maxx
- */
-
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.util.ArrayDeque;
-import java.util.Deque;
-import java.util.StringTokenizer;
-import java.util.*;
-import java.io.*;
-import java.util.Iterator;
-
-public interface Calculator {
-    public static void main(String[] args) throws Exception {
-        System.out.println("Enter string:\n");
-        BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
-        String string;
-
-        try {
-            string = read.readLine();
-            string = to_polish(string);
-        //    System.out.println(string);
-            System.out.println(count(string));
-        } catch (Exception error) {
-            System.out.println(error.getMessage());
-        }
-    }
-
-    public static float calculate(String s) throws Parsing Exception {
-        String buffer;
-        float num_1 = 0;
-        float num_2 = 0;
-
-        //Stack<Float> stack = new ArrayStack<Float>();
-        Deque<Float> stack = new ArrayDeque<Float>();
-        StringTokenizer tok = new StringTokenizer(s);
-        while (tok.hasMoreTokens()) {
-            try {
-                buffer = tok.nextToken().trim();
-                if (oper(buffer.charAt(0))&& buffer.length() == 1) {
-                    num_1 = stack.pop(); num_2 = stack.pop();
-                    switch (buffer.charAt(0)) {
-                        case '+': {
-                            num_2 = num_2 + num_1;
-                            break;
-                        }
-                        case '-': {
-                            num_2 = num_2 - num_1;
-                            break;
-                        }
-                        case '*': {
-                            num_2 = num_2 * num_1;
-                            break;
-                        }
-                        case '/': {
-                            num_2 = (Float)num_2 / num_1;
-                            break;
-                        }
-
-                        default:
-                            throw new Exception("\nIndefinite operator\n");
-                    }
-                    stack.push(num_2);
-                } else {
-                    num_2 = Float.parseFloat(buffer);
-                    stack.push(num_2);
-                }
-            } catch (Exception error) {
-                throw new Exception("\nIndefinite symbol\n");
-            }
-        }
-
-
-        return stack.pop();
-    }
-
-
-    //является ли символ оператором
-    public static boolean oper(char a) {
-        if (a == '+' || a == '-' || a == '*' || a == '/') {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-        /*является ли символ скобкой
-        public static boolean brack(char a) {
-            if (a == '(' || a == ')') {
-                return true;
-            }
-            else {
-                return false;
-            }
-        }*/
-//является ли числом
-       /* public static boolean numb(char a) {
-            switch (a) {
-                case '0': {
-                    return true;
-                }
-                case '1': {
-                    return true;
-                }
-                case '2': {
-                    return true;
-                }
-                case '3': {
-                    return true;
-                }
-                case '4': {
-                    return true;
-                }
-                case '5': {
-                    return true;
-                }
-                case '6': {
-                    return true;
-                }
-                case '7': {
-                    return true;
-                }
-                case '8': {
-                    return true;
-                }
-                case '9': {
-                    return true;
-                }
-            }
-            return false;
-        }*/
-
-    //приоритет операции
-    public static short priority(char a) {
-        switch (a) {
-            case '*':
-                return 2;
-            case '/':
-                return 2;
-            case '+':
-                return 1;
-            case '-':
-                return 1;
-            default:
-                return -1;
-        }
-    }
-
-    public static String to_polish(String input_string) throws Exception {
-
-        char c;
-        char t;
-        StringBuilder buffer = new StringBuilder("");
-        StringBuilder output = new StringBuilder("");
-
-        for (int i = 0; i < input_string.length(); ++i) {
-            c = input_string.charAt(i);
-            if (oper(c)) {
-               // System.out.println("@");
-                while (buffer.length() > 0) {
-                    t = buffer.substring(buffer.length() - 1).charAt(0);
-                    if (oper(t) && (priority(c) <= priority(t))) {
-                        output.append(" ").append(t).append(" ");
-                        buffer.setLength(buffer.length() - 1);
-                    } else {
-                        output.append(" ");
-                        break;
-                    }
-                }
-                output.append(" ");
-                buffer.append(c);
-            } else if ('(' == c) {
-                buffer.append(c);
-            } else if (')' == c) {
-                t = buffer.substring(buffer.length() - 1).charAt(0);
-                while ('(' != t) {
-                   // System.out.println("&");
-                    output.append(" ").append(t);
-                    buffer.setLength(buffer.length() - 1);
-                    t = buffer.substring(buffer.length() - 1).charAt(0);
-                }
-                buffer.setLength(buffer.length() - 1);
-            } else {
-
-                output.append(c);
-            }
-        }
-
-        while (buffer.length() > 0) {
-            output.append(" ").append(buffer.substring(buffer.length() - 1));
-            buffer.setLength(buffer.length() - 1);
-        }
-
-        return output.toString();
-    }
-}
-
diff --git a/homework-base/src/main/java/ru/mipt/java2016/homework/base/task2/KeyValueStorage.java b/homework-base/src/main/java/ru/mipt/java2016/homework/base/task2/KeyValueStorage.java
index 7d22a55cb..15a524c40 100644
--- a/homework-base/src/main/java/ru/mipt/java2016/homework/base/task2/KeyValueStorage.java
+++ b/homework-base/src/main/java/ru/mipt/java2016/homework/base/task2/KeyValueStorage.java
@@ -14,7 +14,6 @@
  * @since 04.10.16
  */
 public interface KeyValueStorage<K, V> extends Closeable {
-    void isFileClosed();
 
     /**
      * Возвращает значение для данного ключа, если оно есть в хранилище.
diff --git a/homework-g595-zueva/pom.xml b/homework-g595-zueva/pom.xml
index 1b4a8b250..ebbfe1909 100644
--- a/homework-g595-zueva/pom.xml
+++ b/homework-g595-zueva/pom.xml
@@ -10,12 +10,14 @@
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>homework-g595-zueva</artifactId>
+
     <dependencies>
         <dependency>
             <groupId>ru.mipt.java2016</groupId>
             <artifactId>homework-base</artifactId>
             <version>1.0.0</version>
         </dependency>
+
         <dependency>
             <groupId>ru.mipt.java2016</groupId>
             <artifactId>homework-tests</artifactId>
@@ -24,5 +26,4 @@
         </dependency>
     </dependencies>
 
-
 </project>
\ No newline at end of file
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/g595/zueva/task1/AzazaCalculator.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/g595/zueva/task1/AzazaCalculator.java
deleted file mode 100644
index e20b3293f..000000000
--- a/homework-g595-zueva/src/main/java/ru/mipt/java2016/g595/zueva/task1/AzazaCalculator.java
+++ /dev/null
@@ -1,171 +0,0 @@
-package ru.mipt.java2016.g595.zueva.task1;
-
-import ru.mipt.java2016.homework.base.task1.Calculator;
-import ru.mipt.java2016.homework.base.task1.ParsingException;
-
-import java.util.ArrayDeque;
-import java.util.Deque;
-import java.util.StringTokenizer;
-
-class AzazaCalculator implements Calculator {
-
-    static final AzazaCalculator INSTANCE = new AzazaCalculator();
-
-    @Override
-    public double calculate(String s) throws ParsingException {
-        /*if (s == null) {
-            throw new ParsingException("null");
-        }
-        if (s == ""){
-            throw new ParsingException("empty string");
-        }
-        if (s == " "){
-            throw new ParsingException("empty string");
-        }
-        for(int i = 1; i < s.length() - 1; ++i){
-            if(s.charAt(i) == ' ' || s.charAt(i) == '\n' ||  s.charAt(i) == '\t'){
-                s = s.substring(0, i - 1) + s.substring(i + 1, s.length() - 1);
-            }
-        }
-        if(s.charAt(0) == ' ' || s.charAt(0) == '\n' ||  s.charAt(0) == '\t'){
-            s = s.substring(1,s.length() - 1);
-        }
-        if(s.charAt(s.length() - 1) == ' ' || s.charAt(s.length() - 1) == '\n' ||  s.charAt(s.length()  - 1) == '\t'){
-            s = s.substring(0, s.length() - 2);
-        }
-        for(int i = 0; i < s.length(); ++i) {
-            if(!(s.charAt(i) == '+' || s.charAt(i) == '-' || s.charAt(i) == '*' ||s.charAt(i) == '/' || s.charAt(i) == '('
-                    ||s.charAt(i) == ')'||s.charAt(i) == '.'||s.charAt(i) == '1' || s.charAt(i) == '2' || s.charAt(i) == '0' ||
-                    s.charAt(i) == '3' || s.charAt(i) == '4' || s.charAt(i) == '5' || s.charAt(i) == '6' || s.charAt(i) == '7' ||
-                    s.charAt(i) == '8' || s.charAt(i) == '9')){
-                throw new ParsingException("Bad symbol");
-            }
-        }
-        for(int i = 0; i < s.length() - 1; ++i){
-            if(s.charAt(i) == '/' && s.charAt(i + 1) == '0') {
-                return Double.POSITIVE_INFINITY;
-            }
-        }
-        for(int i =0; i < s.length() - 2; ++i) {
-            if(s.charAt(i) == '/' && s.charAt(i + 2) == '0' && s.charAt(i + 1) == '-') {
-                return Double.NEGATIVE_INFINITY;
-            }
-        }*/
-        s = to_polish(s);
-        String buffer;
-        double num_1 = 0;
-        double num_2 = 0;
-        Deque<Double> stack = new ArrayDeque<>();
-        StringTokenizer tok = new StringTokenizer(s);
-        while (tok.hasMoreTokens()) try {
-            buffer = tok.nextToken().trim();
-            if (oper(buffer.charAt(0)) && buffer.length() == 1) {
-                System.out.println(buffer.charAt(0));
-                num_1 = stack.pop();
-                num_2 = stack.pop();
-                switch (buffer.charAt(0)) {
-                    case '+': {
-                        num_2 = num_2 + num_1;
-                        break;
-                    }
-                    case '-': {
-                        num_2 = num_2 - num_1;
-                        break;
-                    }
-                    case '*': {
-                        num_2 = num_2 * num_1;
-                        break;
-                    }
-                    case '/': {
-                        num_2 = num_2 / num_1;
-                        break;
-                    }
-
-                    default:
-                        throw new Exception("\nIndefinite operator\n");
-                }
-                stack.push(num_2);
-            } else {
-                num_2 = Float.parseFloat(buffer);
-                stack.push(num_2);
-            }
-        } catch (Exception error) {
-            throw new ParsingException("\nIndefinite symbol\n");
-
-        }
-
-
-        return stack.pop();
-    }
-
-    public static boolean oper(char a) {
-        if (a == '+' || a == '-' || a == '*' || a == '/') {
-            return true;
-        } else {
-            return false;
-        }
-    }
-    public static short priority(char a) {
-        switch (a) {
-            case '*':
-                return 2;
-            case '/':
-                return 2;
-            case '+':
-                return 1;
-            case '-':
-                return 1;
-            default:
-                return -1;
-        }
-    }
-
-    public static String to_polish(String input_string)  {
-
-        char c;
-        char t;
-        StringBuilder buffer = new StringBuilder("");
-        StringBuilder output = new StringBuilder("");
-
-        for (int i = 0; i < input_string.length(); ++i) {
-            c = input_string.charAt(i);
-            if (oper(c)) {
-                // System.out.println("@");
-                while (buffer.length() > 0) {
-                    t = buffer.substring(buffer.length() - 1).charAt(0);
-                    if (oper(t) && (priority(c) <= priority(t))) {
-                        output.append(" ").append(t).append(" ");
-                        buffer.setLength(buffer.length() - 1);
-                    } else {
-                        output.append(" ");
-                        break;
-                    }
-                }
-                output.append(" ");
-                buffer.append(c);
-            } else if ('(' == c) {
-                buffer.append(c);
-            } else if (')' == c) {
-                t = buffer.substring(buffer.length() - 1).charAt(0);
-                while ('(' != t) {
-                    // System.out.println("&");
-                    output.append(" ").append(t);
-                    buffer.setLength(buffer.length() - 1);
-                    t = buffer.substring(buffer.length() - 1).charAt(0);
-                }
-                buffer.setLength(buffer.length() - 1);
-            } else {
-
-                output.append(c);
-            }
-        }
-
-        while (buffer.length() > 0) {
-            output.append(" ").append(buffer.substring(buffer.length() - 1));
-            buffer.setLength(buffer.length() - 1);
-        }
-
-        return output.toString();
-    }
-}
-
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/My_KV_Storage.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/My_KV_Storage.java
deleted file mode 100644
index 40f2e4f95..000000000
--- a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/My_KV_Storage.java
+++ /dev/null
@@ -1,131 +0,0 @@
-package ru.mipt.java2016.homework.g595.zueva.task2;
-
-/*сreated by nestyme*/
-
-import org.apache.commons.io.IOExceptionWithCause;
-import ru.mipt.java2016.homework.base.task2.KeyValueStorage;
-import ru.mipt.java2016.homework.g595.zueva.task2.Serializer;
-import java.util.Iterator;
-import java.util.Map;
-import java.io.*;
-import java.util.HashMap;
-
-
-public class MyKVStorage<K, V> implements KeyValueStorage<K, V> {
-    private static final String VALIDATION_STRING;
-
-    static {
-        VALIDATION_STRING = "My strange storage";
-    }
-
-    private String FileName;
-    public HashMap<K, V> CurrentStorage;
-    public Serializer<K> keySerializer;
-    public Serializer<V> valueSerializer;
-    public boolean ifOpen = false;
-
-    /*Конструктор класс хранилища*/
-
-    public MyKVStorage(String newFileName,
-                       Serializer newKeySerialisation,
-                       Serializer newValueSerialisation) throws IOException {
-        keySerializer = newKeySerialisation;
-        valueSerializer = newValueSerialisation;
-        FileName = newFileName + "/note.txt";
-        CurrentStorage = new HashMap<K, V>();
-        ifOpen = true;
-
-        /*проверка, возможно ли открыть и создать файл*/
-
-        File destination = new File(FileName);
-        if (!destination.exists()) {
-            destination.createNewFile();
-
-            try (DataOutputStream out = new DataOutputStream(new FileOutputStream(FileName))) {
-
-                out.writeUTF(VALIDATION_STRING);
-                out.writeInt(0b0);
-
-            } catch (Exception e) {
-                throw new IllegalStateException("Cannot write to file");
-            }
-        }
-        /* Существует ли наша валидирующая строка в файле && проверка, возможно ли читать из файла*/
-        try (DataInputStream in = new DataInputStream(new FileInputStream(FileName))) {
-            if (!in.readUTF().equals(VALIDATION_STRING)) {
-                throw new IllegalStateException("Unknown validation");
-            }
-            int quantity = in.readInt();
-            for (int i = 0; i < quantity; ++i) {
-
-                K keyToInsert = keySerializer.readFromStream(in);
-                V valueToInsert = valueSerializer.readFromStream(in);
-                CurrentStorage.put(keyToInsert, valueToInsert);
-            }
-        } catch (Exception exception) {
-            throw new IllegalStateException("Cannot read from file");
-        }
-    }
-    @Override
-    public void close() throws IOException {
-        isFileClosed();
-        try
-                (DataOutputStream out = new DataOutputStream(new FileOutputStream(FileName))) {
-            out.writeUTF(VALIDATION_STRING);
-            out.writeInt(CurrentStorage.size());
-            for (Map.Entry<K, V> i : CurrentStorage.entrySet()) {
-
-                keySerializer.writeToStream(out, i.getKey());
-                valueSerializer.writeToStream(out, i.getValue());
-
-            }
-            ifOpen = false;
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-    @Override
-    public V read(K key) {
-        isFileClosed();
-        return CurrentStorage.get(key);
-    }
-
-    @Override
-    public boolean exists(K key) {
-        isFileClosed();
-        return CurrentStorage.keySet().contains(key);
-    }
-
-    @Override
-    public void write(K key, V value) {
-        isFileClosed();
-        CurrentStorage.put(key, value);
-    }
-
-    @Override
-    public void delete(K key) {
-        isFileClosed();
-        CurrentStorage.remove(key);
-    }
-
-    @Override
-    public Iterator<K> readKeys() {
-        isFileClosed();
-        return CurrentStorage.keySet().iterator();
-    }
-
-    @Override
-    public int size() {
-        isFileClosed();
-        return CurrentStorage.size();
-    }
-
-
-    public void isFileClosed() {
-        if (!ifOpen) {
-            throw new IllegalStateException("Storage had been already closed");
-        }
-    }
-}
-
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializer1.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/SerializerStorage.java
similarity index 72%
rename from homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializer1.java
rename to homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/SerializerStorage.java
index d30d3a839..6aac27f72 100644
--- a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializer1.java
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/SerializerStorage.java
@@ -1,14 +1,13 @@
-package ru.mipt.java2016.homework.g595.zueva.task2;
+package ru.mipt.java2016.homework.g595.zueva.task2.task2;
 
 import java.io.DataInputStream;
-import java.io.DataOutput;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
 /**
  * Created by nestyme on 31.10.2016.
  */
-interface Serializer<T> {
+interface SerializerStorage<T> {
     void writeToStream(DataOutputStream out, T value)throws IOException;
 
     T readFromStream(DataInputStream in) throws IOException;
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializers.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializers.java
new file mode 100644
index 000000000..7508d7281
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializers.java
@@ -0,0 +1,52 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task2;
+
+/**
+ * Created by nestyme on 30.10.2016.
+ */
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+
+public class Serializers {
+
+    public static class SerialiserInt implements SerializerStorage<Integer> {
+
+
+        public void writeToStream(DataOutputStream out, Integer value) throws IOException {
+
+            out.writeInt(value);
+
+        }
+
+        public Integer readFromStream(DataInputStream in) throws IOException {
+
+            return in.readInt();
+        }
+    }
+
+
+    public static class SerializerStorageString implements SerializerStorage<String> {
+
+        public void writeToStream(DataOutputStream out, String value) throws IOException {
+            out.writeUTF(value);
+        }
+
+        public String readFromStream(DataInputStream in) throws IOException {
+            return in.readUTF();
+        }
+    }
+
+    public static class SerializerStorageDouble implements SerializerStorage<Double> {
+
+        public void writeToStream(DataOutputStream out, Double value) throws IOException {
+            out.writeDouble(value);
+        }
+
+        @Override
+        public Double readFromStream(DataInputStream in) throws IOException {
+            return in.readDouble();
+        }
+    }
+}
\ No newline at end of file
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Specified_serializers.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Specified_serializers.java
deleted file mode 100644
index 51824c589..000000000
--- a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Specified_serializers.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package ru.mipt.java2016.homework.g595.zueva.task2;
-
-/**
- * Created by nestyme on 30.10.2016.
- */
-import ru.mipt.java2016.homework.tests.task2.Student;
-import ru.mipt.java2016.homework.tests.task2.StudentKey;
-
-import java.io.*;
-import java.util.Date;
-
-public class Specified_serializers{
-
-    public static class SerialiserInt implements Serializer<Integer> {
-
-
-        public void writeToStream(DataOutputStream out, Integer value) throws IOException {
-
-            out.writeInt(value);
-
-        }
-
-        public Integer readFromStream(DataInputStream in) throws IOException {
-
-            return in.readInt();
-        }
-    }
-
-
-    public static class SerializerString implements Serializer<String> {
-
-        public void writeToStream(DataOutputStream out, String value) throws IOException {
-            out.writeUTF(value);
-        }
-
-        public String readFromStream(DataInputStream in) throws IOException {
-            return in.readUTF();
-        }
-    }
-
-    public static class SerializerDouble implements Serializer<Double> {
-
-        public void writeToStream(DataOutputStream out, Double value) throws IOException {
-            out.writeDouble(value);
-        }
-
-        @Override
-        public Double readFromStream(DataInputStream in) throws IOException {
-            return in.readDouble();
-        }
-    }
-
-    public static class SerializerStudentKey implements Serializer<StudentKey> {
-
-        public void writeToStream(DataOutputStream out, StudentKey value) throws IOException {
-            out.writeInt(value.getGroupId());
-            out.writeUTF(value.getName());
-        }
-
-        public StudentKey readFromStream(DataInputStream in) throws IOException {
-            return new StudentKey(in.readInt(), in.readUTF());
-        }
-    }
-
-    public static class SerializerStudent implements Serializer<Student> {
-
-        public void writeToStream(DataOutputStream out, Student value) throws IOException {
-            out.writeInt(value.getGroupId());
-            out.writeUTF(value.getName());
-            out.writeUTF(value.getHometown());
-            out.writeLong(value.getBirthDate().getTime());
-            out.writeBoolean(value.isHasDormitory());
-            out.writeDouble(value.getAverageScore());
-
-        }
-
-        public Student readFromStream(DataInputStream in) throws IOException {
-            return new Student(in.readInt(), in.readUTF(), in.readUTF(),
-                               new Date(in.readLong()), in.readBoolean(),
-                               in.readDouble());
-        }
-    }
-}
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/FRFile.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/FRFile.java
new file mode 100644
index 000000000..77d82ee81
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/FRFile.java
@@ -0,0 +1,81 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+import java.io.*;
+import java.nio.*;
+/**
+ * Created by someb on 17.12.2016.
+ */
+public class FRFile {
+    private ByteBuffer mybuffer = ByteBuffer.allocate(Long.SIZE / 8);
+    private File myfile;
+    private BufferedInputStream in;
+    private BufferedOutputStream out;
+
+     private boolean ifEmpty = false;
+
+             public FRFile(String fileDirectory, String fileName) throws IOException {
+                File directory = new File(fileDirectory);
+                if (directory.exists()) {
+                        myfile = new File(fileDirectory, fileName);
+                    myfile.createNewFile();
+                        in = new BufferedInputStream(new FileInputStream(myfile));
+                    } else {
+                        throw new IOException("Cannot found directory");
+                    }
+            }
+
+             public long ReadFileOffst() throws IOException {
+                if (in.read(mybuffer.array(), 0, Long.SIZE / 8) != Long.SIZE / 8) {
+                        throw new IOException("Can`t continue reading");
+                    }
+                return mybuffer.getLong(0);
+            }
+    public int readKey() throws IOException {
+        if (in.read(mybuffer.array(), 0, Integer.SIZE / 8) != Integer.SIZE / 8) {
+            throw new IOException("Can`t continue reading");
+        }
+        return mybuffer.getInt(0);
+    }
+
+    public void writeBytes(ByteBuffer bytesToWrite) throws IOException {
+        out.write(bytesToWrite.array());
+    }
+
+             public void writeFileOffst(long value) throws IOException {
+                mybuffer.putLong(0, value);
+                out.write(mybuffer.array());
+            }
+
+             public ByteBuffer byteReading(int size) throws IOException {
+                ByteBuffer bytesRead = ByteBuffer.allocate(size);
+                in.read(bytesRead.array(), 0, size);
+                return bytesRead;
+            }
+
+
+             public void SizeWr(int size) throws IOException {
+                mybuffer.putInt(0, size);
+                out.write(mybuffer.array(), 0, Integer.SIZE / 8);
+            }
+
+             public void Clean() throws IOException {
+                ifEmpty = true;
+                in.close();
+                myfile.delete();
+                myfile.createNewFile();
+                out = new BufferedOutputStream(new FileOutputStream(myfile));
+            }
+
+             public void close() throws IOException {
+                if (ifEmpty) {
+                        mybuffer.putInt(0, Integer.MIN_VALUE);
+                        out.write(mybuffer.array(), 0, Integer.SIZE / 8);
+                        out.close();
+                    } else {
+                        in.close();
+                    }
+            }
+
+             public boolean checkIsEmpty() throws IOException {
+                return in.available() == 0;
+            }
+}
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/MyOptKVStorage.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/MyOptKVStorage.java
new file mode 100644
index 000000000..ae1ff7ea3
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/MyOptKVStorage.java
@@ -0,0 +1,96 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+
+/**
+ * Created by someb on 17.12.2016.
+ */
+import java.io.*;
+ import java.nio.ByteBuffer;
+
+public class MyOptKVStorage {
+     private BufferedInputStream input;
+     private BufferedOutputStream output;
+     private File storageInstance;
+     private File bufferStorageInstance;
+     private RandomAccessFile randomAccessFile;
+     private ByteBuffer byteBuffer = ByteBuffer.allocate(Integer.SIZE / 8);
+
+             public MyOptKVStorage(String fileDirectory, String fileName) throws IOException {
+                File directory = new File(fileDirectory);
+                if (directory.exists()) {
+                        storageInstance = new File(fileDirectory, fileName);
+                        bufferStorageInstance = new File(fileDirectory, "buffer.db");
+                        storageInstance.createNewFile();
+                        randomAccessFile = new RandomAccessFile(storageInstance, "rw");
+                        /* ! 'true' because we rather write to the end of the file */
+                                output = new BufferedOutputStream(new FileOutputStream(storageInstance, true));
+                    } else {
+                        throw new IllegalStateException("There is no such directory");
+                    }
+            }
+
+             public void writeSizeToStream(int size) throws IOException {
+                byteBuffer.putInt(0, size);
+                output.write(byteBuffer.array());
+            }
+
+             public void writeBytesToStream(ByteBuffer bytesToWrite) throws IOException {
+                output.write(bytesToWrite.array());
+            }
+
+             public void flushStream() throws IOException {
+                output.flush();
+            }
+
+             public int readKey(long offset) throws IOException {
+                randomAccessFile.seek(offset);
+                return randomAccessFile.readInt();
+            }
+
+             public ByteBuffer readBytes(int size) throws IOException {
+                ByteBuffer value = ByteBuffer.allocate(size);
+                randomAccessFile.readFully(value.array());
+                return value;
+            }
+
+             public int readKeyFromStream() throws IOException {
+                if (input.read(byteBuffer.array(), 0, Integer.SIZE / 8) != Integer.SIZE / 8) {
+                        throw new IOException("Error during reading");
+                    }
+                return byteBuffer.getInt(0);
+            }
+
+             public ByteBuffer readValueFromStream(int size) throws IOException {
+                ByteBuffer value = ByteBuffer.allocate(size);
+                if (input.read(value.array(), 0, size) != size) {
+                        throw new IOException("Error during reading");
+                    }
+                return value;
+            }
+
+             public long getLength() throws IOException {
+                return randomAccessFile.length();
+            }
+
+             public void close() throws IOException {
+                byteBuffer.putInt(0, Integer.MIN_VALUE);
+                output.write(byteBuffer.array());
+                output.close();
+                randomAccessFile.close();
+            }
+
+             public void beginUpdate() throws IOException {
+                output.close();
+                randomAccessFile.close();
+                bufferStorageInstance.createNewFile();
+                input = new BufferedInputStream(new FileInputStream(storageInstance));
+                output = new BufferedOutputStream(new FileOutputStream(bufferStorageInstance));
+            }
+
+             public void endUpdate() throws IOException {
+               output.close();
+                input.close();
+                bufferStorageInstance.renameTo(storageInstance);
+                randomAccessFile = new RandomAccessFile(storageInstance, "rw");
+                output = new BufferedOutputStream(new FileOutputStream(storageInstance, true));
+            }
+ }
\ No newline at end of file
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptDoubleSerializer.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptDoubleSerializer.java
new file mode 100644
index 000000000..7481cb5a7
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptDoubleSerializer.java
@@ -0,0 +1,24 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+
+
+import java.nio.ByteBuffer;
+
+         public class OptDoubleSerializer implements OptKVStorageSerializer<Double> {
+
+            @Override
+    public ByteBuffer srlzToStr(Double value) {
+                ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value));
+                serialized.putDouble(value);
+                return serialized;
+            }
+
+             @Override
+     public Double desrlzFrStr(ByteBuffer input) {
+                return input.getDouble();
+            }
+
+             @Override
+     public int SrlzSize(Double value) {
+                return Double.SIZE / 8;
+            }
+ }
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptIntegerSerializer.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptIntegerSerializer.java
new file mode 100644
index 000000000..d2a324584
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptIntegerSerializer.java
@@ -0,0 +1,20 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+import java.nio.ByteBuffer;
+public class OptIntegerSerializer implements OptKVStorageSerializer<Integer> {
+       @Override
+     public ByteBuffer srlzToStr(Integer value) {
+                ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value));
+                serialized.putInt(value);
+                return serialized;
+            }
+
+             @Override
+     public Integer desrlzFrStr(ByteBuffer input) {
+                return input.getInt();
+            }
+
+             @Override
+     public int SrlzSize(Integer value) {
+               return Integer.SIZE / 8;
+            }
+}
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorage.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorage.java
new file mode 100644
index 000000000..e1d5441df
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorage.java
@@ -0,0 +1,297 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+
+import ru.mipt.java2016.homework.base.task2.KeyValueStorage;
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * find in the cache firstly.
+ */
+public class OptKVStorage<K,V> implements KeyValueStorage<K,V> {
+    private static final String STORAGE_NAME = "somestorage.db";
+    private String FileIn;
+    private final HashMap<K, Long> offsetTable  = new HashMap<K, Long>();
+    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+    private Lock writeLock = readWriteLock.writeLock();
+    private Lock readLock = readWriteLock.readLock();
+    private static final String REFERENCE_FILE_NAME = "ref.db";
+    private static final String LOCK_FILE_NAME = "locking.db";
+    private File LockingMyFile;
+    private MyOptKVStorage storage;
+    private FRFile RefFile;
+    private OptKVStorageSerializer<K> KeySerializer;
+    private OptKVStorageSerializer<V> ValueSerializer;
+    private boolean ifOpen = false;
+    private long StorSize;
+    private long recordLength;
+    private long deletedField = 0;
+    private boolean updated = false;
+    private LinkedHashMap<K, V> cache;
+    private static final int CACHE_SIZE = 1000;
+
+    public OptKVStorage(String fileDirectoryInit, OptKVStorageSerializer keySerializerInit,
+                        OptKVStorageSerializer valueSerializerInit) throws IOException {
+        ifOpen = true;
+        KeySerializer = keySerializerInit;
+        ValueSerializer = valueSerializerInit;
+        FileIn = fileDirectoryInit;
+        RefFile = new FRFile(FileIn, REFERENCE_FILE_NAME);
+        storage = new MyOptKVStorage(FileIn, STORAGE_NAME);
+        StorSize = storage.getLength();
+        recordLength = StorSize - 1;
+        cache = new LinkedHashMap<K, V>();
+        String lockFilePath = FileIn + File.separator + LOCK_FILE_NAME;
+        LockingMyFile = new File(lockFilePath);
+        if (!LockingMyFile.exists()) {
+            try {
+                LockingMyFile.createNewFile();
+            } catch (Exception e) {
+                throw new IOException("Failed to create lock file");
+            }
+        } else {
+            throw new IOException("Somebody is working w/ db right now.");
+        }
+        startWorkWithOffsetTable();
+    }
+    @Override
+    public V read(K key) {
+        V value;
+        writeLock.lock();
+        try {
+            checkIfClosed();
+            if (cache.containsKey(key)) {
+                return cache.get(key);
+            }
+            if (!exists(key)) {
+                value = null;
+            } else {
+                value = readValue(key);
+            }
+        } catch (IOException e) {
+            value = null;
+        } finally {
+            writeLock.unlock();
+        }
+        return value;
+    }
+
+    /* ! First we look for key in cache, than we try to find it in the storage */
+    @Override
+    public boolean exists(K key) {
+        readLock.lock();
+        try {
+            checkIfClosed();
+            if (cache.containsKey(key)) {
+                return true;
+            }
+            return offsetTable.keySet().contains(key);
+        } finally {
+            readLock.unlock();
+        }
+    }
+
+    /* ! First we look for key in cache, if we succeed we upgrade the value
++    * otherwise we put key - value to cache; we put key - value to storage */
+    @Override
+    public void write(K key, V value) {
+        writeLock.lock();
+        try {
+            checkIfClosed();
+            if (cache.containsKey(key)) {
+                cache.put(key, value);
+                balanceCache();
+            } else {
+                writeField(key, value);
+                cache.put(key, value);
+                balanceCache();
+                updated = true;
+            }
+        } catch (IOException e) {
+            throw new IllegalStateException("Error during writing");
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    /* ! delete key - value from storage and from cache if needed */
+    @Override
+    public void delete(K key) {
+        writeLock.lock();
+        try {
+            checkIfClosed();
+            if (cache.containsKey(key)) {
+                cache.remove(key);
+            }
+            offsetTable.remove(key);
+            ++deletedField;
+            updated = true;
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public Iterator<K> readKeys() {
+        readLock.lock();
+        try {
+            checkIfClosed();
+            return offsetTable.keySet().iterator();
+        } finally {
+            readLock.unlock();
+        }
+    }
+
+    @Override
+    public int size() {
+        readLock.lock();
+        try {
+            checkIfClosed();
+            return offsetTable.size();
+        } finally {
+            readLock.unlock();
+        }
+    }
+
+    /* ! close files and write changes to the disk */
+    @Override
+    public void close() throws IOException {
+        writeLock.lock();
+        try {
+            checkIfClosed();
+            updateStorageFile();
+            storage.close();
+            if (updated) {
+                endWorkWithOffsetTable();
+                updated = false;
+            }
+            if (LockingMyFile.exists()) {
+                try {
+                    LockingMyFile.delete();
+                } catch (Exception e) {
+                    throw new IOException("Failed to delete lock file");
+                }
+            }
+            RefFile.close();
+            ifOpen = false;
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    private void startWorkWithOffsetTable() throws IOException {
+        if (!RefFile.checkIsEmpty()) {
+            int counter = RefFile.readKey();
+            while (counter > 0) {
+                K key = KeySerializer.desrlzFrStr(RefFile.byteReading(counter));
+                long offset = RefFile.ReadFileOffst();
+                offsetTable.put(key, offset);
+                counter = RefFile.readKey();
+            }
+        }
+    }
+
+    private void endWorkWithOffsetTable() throws IOException {
+        RefFile.Clean();
+        for (HashMap.Entry<K, Long> iterator : offsetTable.entrySet()) {
+            RefFile.SizeWr(KeySerializer.SrlzSize(iterator.getKey()));
+            RefFile.writeBytes(KeySerializer.srlzToStr(iterator.getKey()));
+            RefFile.writeFileOffst(iterator.getValue());
+        }
+        offsetTable.clear();
+        if (LockingMyFile.exists()) {
+            try {
+                LockingMyFile.delete();
+            } catch (Exception e) {
+                throw new IOException("Failed to delete lock file");
+            }
+        }
+    }
+
+    private void checkFreeSpace(long offset) throws IOException {
+        if (offset > recordLength) {
+            storage.flushStream();
+            recordLength = StorSize - 1;
+        }
+    }
+
+    private V readValue(K key) throws IOException {
+        long offset = offsetTable.get(key);
+        checkFreeSpace(offset);
+        int serializedKey = storage.readKey(offset);
+        return ValueSerializer.desrlzFrStr(storage.readBytes(serializedKey));
+    }
+
+    private void writeOffsetField(K key) throws IOException {
+        offsetTable.put(key, KeySerializer.SrlzSize(key) + Integer.SIZE / 8 + StorSize);
+    }
+
+    private void writeKey(K key) throws IOException {
+        storage.writeSizeToStream(KeySerializer.SrlzSize(key));
+        storage.writeBytesToStream(KeySerializer.srlzToStr(key));
+    }
+
+    private void writeValue(V value) throws IOException {
+        storage.writeSizeToStream(ValueSerializer.SrlzSize(value));
+        storage.writeBytesToStream(ValueSerializer.srlzToStr(value));
+    }
+
+    private void updateStorageLength(K key, V value) throws IOException {
+        StorSize = StorSize + Integer.SIZE / 8 + KeySerializer.SrlzSize(key) +
+                Integer.SIZE / 8 + ValueSerializer.SrlzSize(value);
+    }
+
+    private void writeField(K key, V value) throws IOException {
+        writeOffsetField(key);
+        writeKey(key);
+        writeValue(value);
+        updateStorageLength(key, value);
+    }
+
+    private void updateStorageFile() throws IOException {
+        if (deletedField > 4 * offsetTable.size()) {
+            storage.beginUpdate();
+            StorSize = 0;
+            long oldFileOffset = 0;
+            int keySize = storage.readKeyFromStream();
+            while (keySize > 0) {
+                ByteBuffer serializedKey = storage.readValueFromStream(keySize);
+                K key = KeySerializer.desrlzFrStr(serializedKey);
+                int valueSize = storage.readKeyFromStream();
+                ByteBuffer value = storage.readValueFromStream(valueSize);
+                if (offsetTable.containsKey(key) && offsetTable.get(key).equals(oldFileOffset)) {
+                    writeField(key, ValueSerializer.desrlzFrStr(value));
+                }
+                oldFileOffset = oldFileOffset + Integer.SIZE / 8 + Integer.SIZE / 8 + keySize + valueSize;
+                keySize = storage.readKeyFromStream();
+            }
+            storage.endUpdate();
+        }
+    }
+
+    private void checkIfClosed() {
+        if (!ifOpen) {
+            throw new IllegalStateException("Impossible to work with closed storage");
+        }
+    }
+
+    /* ! method for controlling cache size */
+    private void balanceCache() {
+        if (cache.size() > CACHE_SIZE) {
+            Iterator<Map.Entry<K, V>> iterator = cache.entrySet().iterator();
+            iterator.next();
+            iterator.remove();
+        }
+    }
+}
+
+
+
+
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorageSerializer.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorageSerializer.java
new file mode 100644
index 000000000..4b715d75d
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptKVStorageSerializer.java
@@ -0,0 +1,10 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+
+import java.nio.ByteBuffer;
+public interface OptKVStorageSerializer<K> {
+        int SrlzSize(K value);
+
+             ByteBuffer srlzToStr(K value);
+
+             K desrlzFrStr(ByteBuffer input);
+}
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializer.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializer.java
new file mode 100644
index 000000000..5b360171c
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializer.java
@@ -0,0 +1,18 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+import java.nio.ByteBuffer;
+public class OptStrSerializer implements OptKVStorageSerializer<String> {
+        @Override
+     public ByteBuffer srlzToStr(String value) {
+                return ByteBuffer.wrap(value.getBytes());
+            }
+
+             @Override
+     public String desrlzFrStr(ByteBuffer input) {
+                return new String(input.array());
+            }
+
+             @Override
+     public int SrlzSize(String value) {
+                return value.length();
+            }
+}
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializerStudentStudentKey.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializerStudentStudentKey.java
new file mode 100644
index 000000000..a11300328
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/OptStrSerializerStudentStudentKey.java
@@ -0,0 +1,30 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+
+import java.nio.ByteBuffer;
+public class OptStrSerializerStudentStudentKey implements OptKVStorageSerializer<String> {
+    @Override
+     public int SrlzSize(String value) {
+               return 2 * (value.length() + 1);
+            }
+
+             @Override
+     public ByteBuffer srlzToStr(String value) {
+                ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value));
+                for (char c : value.toCharArray()) {
+                        serialized.putChar(c);
+                    }
+                serialized.putChar('\0');
+                return serialized;
+            }
+
+             @Override
+     public String desrlzFrStr(ByteBuffer input) {
+                StringBuilder deserialized = new StringBuilder();
+                char c = input.getChar();
+                while (c != '\0') {
+                        deserialized.append(c);
+                        c = input.getChar();
+                    }
+                return deserialized.toString();
+            }
+}
diff --git a/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/testing.java b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/testing.java
new file mode 100644
index 000000000..8f56b4452
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task3/testing.java
@@ -0,0 +1,26 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task3;
+import java.io.IOException;
+public class testing {
+
+    public static void main(String[] args) {
+        OptKVStorage<Integer, Integer> fst =
+                null;
+        try {
+            fst = new OptKVStorage("/home/king", new OptIntegerSerializer(), new OptIntegerSerializer());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        fst.write(5, 5);
+        OptKVStorage snd =
+                null;
+        try {
+            snd = new OptKVStorage("/something", new OptIntegerSerializer(), new OptIntegerSerializer());
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        snd.write(6, 6);
+        snd.write(5, 6);
+        System.out.println(fst.read(5));
+        System.out.println(snd.read(6));
+    }
+}
diff --git a/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStorageTest.java b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStorageTest.java
new file mode 100644
index 000000000..5ee1a3fe0
--- /dev/null
+++ b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStorageTest.java
@@ -0,0 +1,39 @@
+package ru.mipt.java.homework.g595.zueva.task3;
+
+import ru.mipt.java2016.homework.base.task2.KeyValueStorage;
+import ru.mipt.java2016.homework.tests.task2.Student;
+import ru.mipt.java2016.homework.tests.task2.StudentKey;
+import ru.mipt.java2016.homework.base.task2.MalformedDataException;
+import ru.mipt.java2016.homework.tests.task3.KeyValueStoragePerformanceTest;
+/**
+ * Created by someb on 17.12.2016.
+ */
+public class FastKeyValueStorageTest extends KeyValueStoragePerformanceTest{
+    @Override
+    protected KeyValueStorage<String, String> buildStringsStorage(String path) throws MalformedDataException {
+        try {
+            return new FastKeyValueStorageImpl(path, new FastStringSerializer(), new FastStringSerializer());
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    @Override
+    protected KeyValueStorage<Integer, Double> buildNumbersStorage(String path) throws MalformedDataException {
+        try {
+            return new FastKeyValueStorageImpl(path, new FastIntegerSerializer(), new FastDoubleSerializer());
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    @Override
+    protected KeyValueStorage<StudentKey, Student> buildPojoStorage(String path) throws MalformedDataException {
+        try {
+            return new FastKeyValueStorageImpl(path, new FastStudentKeySerializer(), new FastStudentSerializer());
+        } catch (IOException e) {
+            return null;
+        }
+    }
+}
+}
diff --git a/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentKeySerializer.java b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentKeySerializer.java
new file mode 100644
index 000000000..4f9921a11
--- /dev/null
+++ b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentKeySerializer.java
@@ -0,0 +1,44 @@
+package ru.mipt.java.homework.g595.zueva.task3;
+
+import ru.mipt.java2016.homework.g595.zueva.task2.task3.OptKVStorageSerializer;
+import ru.mipt.java2016.homework.tests.task2.Student;
+import ru.mipt.java2016.homework.tests.task2.StudentKey;
+
+import java.nio.ByteBuffer;
+import java.util.Date;
+public class FastKeyValueStudentKeySerializer implements OptKVStorageSerializer<Student> {
+    @Override
+     public ByteBuffer srlzToStr(Student value) {
+                ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value));
+                FastStudentKeySerializer studentKeySerializer = new FastStudentKeySerializer();
+                serialized.put(studentKeySerializer.serializeToStream(new StudentKey(value.getGroupId(),
+                                value.getName())).array());
+                FastStringSerializerForStudentKeyAndStudent fastStringSerializerForStudentKeyAndStudent =
+                                new FastStringSerializerForStudentKeyAndStudent();
+                serialized.put(fastStringSerializerForStudentKeyAndStudent.serializeToStream(value.getHometown()).array());
+                serialized.putLong(value.getBirthDate().getTime());
+                if (value.isHasDormitory()) {
+                        serialized.put((byte) 1);
+                    } else {
+                        serialized.put((byte) 0);
+                    }
+                serialized.putDouble(value.getAverageScore());
+                return serialized;
+            }
+
+             @Override
+     public Student desrlzFrStr(ByteBuffer input) {
+                FastStringSerializerForStudentKeyAndStudent fastStringSerializerForStudentKeyAndStudent =
+                                new FastStringSerializerForStudentKeyAndStudent();
+                return new Student(input.getInt(),
+                                fastStringSerializerForStudentKeyAndStudent.deserializeFromStream(input),
+                                fastStringSerializerForStudentKeyAndStudent.deserializeFromStream(input),
+                                new Date(input.getLong()), (input.get() == 1), input.getDouble());
+            }
+
+             @Override
+     public int SrlzSize(Student value) {
+                return Integer.SIZE / 8 + 2 * (value.getName().length() + 1) +
+                                2 * (value.getHometown().length() + 1) + Long.SIZE / 8 + 1 + Double.SIZE / 8;
+            }
+}
diff --git a/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentSerializer.java b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentSerializer.java
new file mode 100644
index 000000000..33ba83c29
--- /dev/null
+++ b/homework-g595-zueva/src/test/java/ru/mipt/java/homework/g595/zueva/task3/FastKeyValueStudentSerializer.java
@@ -0,0 +1,35 @@
+package ru.mipt.java.homework.g595.zueva.task3;
+
+import ru.mipt.java2016.homework.g595.zueva.task2.task3.OptKVStorageSerializer;
+import ru.mipt.java2016.homework.g595.zueva.task2.task3.OptStrSerializerStudentStudentKey;
+import ru.mipt.java2016.homework.tests.task2.Student;
+import ru.mipt.java2016.homework.tests.task2.StudentKey;
+
+import java.nio.ByteBuffer;
+
+public class FastKeyValueStudentSerializer implements OptKVStorageSerializer<Student> {
+    @Override
+    public StudentKey desrlzFrStr(ByteBuffer input) {
+        OptStrSerializerStudentStudentKey fastStringSerializerForStudentKeyAndStudent =
+                new OptStrSerializerStudentStudentKey();
+        return new StudentKey(input.getInt(), fastStringSerializerForStudentKeyAndStudent.desrlzFrStr(input));
+    }
+    @Override
+    public int SrlzSize(Student value) {
+        return Integer.SIZE / 8 + 2 * (value.getName().length() + 1);
+    }
+
+    @Override
+    public ByteBuffer srlzToStr(Student value) {
+        ByteBuffer serialized = ByteBuffer.allocate(SrlzSize(value));
+        serialized.putInt(value.getGroupId());
+        OptStrSerializerStudentStudentKey fastStringSerializerForStudentKeyAndStudent =
+                new OptStrSerializerStudentStudentKey();
+        serialized.put(fastStringSerializerForStudentKeyAndStudent.srlzToStr(value.getName()).array());
+        return serialized;
+    }
+
+
+
+
+}
diff --git a/homework-g595-zueva/src/test/java/ru/mipt/java2016/g595/zueva/task1/AzazaCalculatorTest.java b/homework-g595-zueva/src/test/java/ru/mipt/java2016/g595/zueva/task1/AzazaCalculatorTest.java
deleted file mode 100644
index d0fec2ee9..000000000
--- a/homework-g595-zueva/src/test/java/ru/mipt/java2016/g595/zueva/task1/AzazaCalculatorTest.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package ru.mipt.java2016.g595.zueva.task1;
-
-
-import ru.mipt.java2016.homework.tests.task1.AbstractCalculatorTest;
-
-public class AzazaCalculatorTest  extends AbstractCalculatorTest {
-    @Override
-    public AzazaCalculator calc() {
-        return AzazaCalculator.INSTANCE;
-    }
-}
diff --git a/homework-g595-zueva/src/test/java/ru/mipt/java2016/homework/g595/zueva/task2/My_KV_StorageTest.java b/homework-g595-zueva/src/test/java/ru/mipt/java2016/homework/g595/zueva/task2/My_KV_StorageTest.java
deleted file mode 100644
index 21a722fff..000000000
--- a/homework-g595-zueva/src/test/java/ru/mipt/java2016/homework/g595/zueva/task2/My_KV_StorageTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package ru.mipt.java2016.homework.g595.zueva.task2;
-/*created by nestyme on 31.10.16*/
-import ru.mipt.java2016.homework.base.task2.KeyValueStorage;
-import ru.mipt.java2016.homework.tests.task2.AbstractSingleFileStorageTest;
-import ru.mipt.java2016.homework.tests.task2.Student;
-import ru.mipt.java2016.homework.tests.task2.StudentKey;
-
-import java.io.IOException;
-
-
-public class My_KV_StorageTest extends AbstractSingleFileStorageTest {
-
-    @Override
-    public KeyValueStorage<Integer, Double> buildNumbersStorage(String path) {
-        MyKVStorage<Integer, Double> answer1 = null;
-        try {
-            answer1 = new MyKVStorage(path, new Specified_serializers.SerialiserInt(),
-                    new Specified_serializers.SerializerDouble());
-        } catch (IOException exception) {
-            System.out.println(exception.getMessage());
-        }
-        return answer1;
-    }
-
-    @Override
-    public KeyValueStorage<StudentKey, Student> buildPojoStorage(String path) {
-        MyKVStorage answer2 = null;
-        try {
-            answer2 = new MyKVStorage(path, new Specified_serializers.SerializerStudentKey(),
-                    new Specified_serializers.SerializerStudent());
-        } catch (IOException exception) {
-            System.out.println(exception.getMessage());
-        }
-        return answer2;
-    }
-
-    @Override
-    public KeyValueStorage<String, String> buildStringsStorage(String path) {
-        Specified_serializers.SerializerString a;
-        Specified_serializers.SerializerString b;
-        MyKVStorage answer3 = null;
-        try {
-            answer3 = new MyKVStorage(path, new Specified_serializers.SerializerString(),
-                    new Specified_serializers.SerializerString());
-        } catch (IOException exception) {
-            System.out.println(exception.getMessage());
-        }
-        return answer3;
-    }
-}
-
-
diff --git a/java/io/annotations.xml b/java/io/annotations.xml
deleted file mode 100644
index b088ffd48..000000000
--- a/java/io/annotations.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<root>
-    <item name='java.io.IOException'>
-        <annotation name='java.lang.Deprecated'/>
-    </item>
-</root>
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 30e70c2d4..6d417c92d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -14,16 +14,21 @@
     <modules>
         <module>homework-base</module>
         <module>homework-tests</module>
+        <module>homework-g597-povarnitsyn</module>
         <module>homework-g596-kupriyanov</module>
         <module>homework-g595-kryloff</module>
+        <module>homework-g595-zueva</module>
         <module>homework-g596-kravets</module>
         <module>homework-g596-litvinov</module>
+        <module>homework-g594-kozlov</module>
+        <module>homework-g596-proskurina</module>
         <module>homework-g000-lavrentyev</module>
         <module>homework-g594-borodin</module>
-        <module>homework-g594-shevkunov</module>
         <module>homework-g597-vasilyev</module>
-        <module>homework-g594-kozlov</module>
         <module>homework-g594-stepanov</module>
+        <module>homework-g599a-kazakova</module>
+        <module>homework-g597-markov</module>
+        <module>homework-g594-shevkunov</module>
         <module>homework-g595-kireev</module>
         <module>homework-g595-novikov</module>
         <module>homework-g597-mashurin</module>
@@ -38,7 +43,9 @@
         <module>homework-g595-romanenko</module>
         <module>homework-g595-gusarova</module>
         <module>homework-g596-fattakhetdinov</module>
+        <module>homework-g596-lapa</module>
         <module>homework-g597-moiseev</module>
+        <module>homework-g594-plahtinskiy</module>
         <module>homework-g597-shirokova</module>
         <module>homework-g595-belyh</module>
         <module>homework-g594-vishnyakova</module>
@@ -48,30 +55,41 @@
         <module>homework-g594-glebov</module>
         <module>homework-g594-petrov</module>
         <module>homework-g597-kozlov</module>
+        <module>homework-g597-komarov</module>
         <module>homework-g597-dmitrieva</module>
+        <module>homework-g596-ivanova</module>
         <module>homework-g595-popovkin</module>
         <module>homework-g594-anukhin</module>
         <module>homework-g597-kasimova</module>
-        <module>homework-g596-ivanova</module>
         <module>homework-g595-turumtaev</module>
         <module>homework-g595-ulyanin</module>
         <module>homework-g595-iksanov</module>
         <module>homework-g595-nosareva</module>
         <module>homework-g595-proskurin</module>
         <module>homework-g594-sharuev</module>
+        <module>homework-g596-bystrov</module>
         <module>homework-g594-rubanenko</module>
         <module>homework-g594-islamov</module>
         <module>homework-g595-rodin</module>
+        <module>homework-g597-nasretdinov</module>
         <module>homework-g595-murzin</module>
+        <module>homework-g594-nevstruev</module>
         <module>homework-g595-yakusheva</module>
+        <module>homework-g596-stepanova</module>
         <module>homework-g597-spirin</module>
+        <module>homework-g597-kirilenko</module>
         <module>homework-g597-bogdanov</module>
         <module>homework-g596-egorov</module>
         <module>homework-g597-zakharkin</module>
         <module>homework-g597-grishutin</module>
         <module>homework-g595-tkachenko</module>
         <module>homework-g597-miller</module>
-        <module>homework-g595-zueva</module>
+        <module>homework-g596-pockonechny</module>
+        <module>homework-g597-smirnova</module>
+        <module>homework-g596-grebenshchikova</module>
+        <module>homework-g597-kochukov</module>
+        <module>homework-g597-sigareva</module>
+        <module>workshop-materials</module>
 
     </modules>
 
@@ -200,7 +218,7 @@
                                     <property name="ignoreSetter" value="true"/>
                                     <property name="ignoreConstructorParameter" value="true"/>
                                 </module>
-                                <module name="IllegalCatch"/>
+                                <module name="IllegalThrows"/>
                                 <module name="IllegalInstantiation"/>
                                 <module name="InnerAssignment"/>
                                 <module name="MissingSwitchDefault"/>