diff --git a/Calculator.java b/Calculator.java
new file mode 100644
index 000000000..c31501dbd
--- /dev/null
+++ b/Calculator.java
@@ -0,0 +1,201 @@
+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 bab3d8d97..7d22a55cb 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,6 +14,8 @@
  * @since 04.10.16
  */
 public interface KeyValueStorage<K, V> extends Closeable {
+    void isFileClosed();
+
     /**
      * Возвращает значение для данного ключа, если оно есть в хранилище.
      * Иначе возвращает null.
diff --git a/homework-g595-zueva/pom.xml b/homework-g595-zueva/pom.xml
new file mode 100644
index 000000000..1b4a8b250
--- /dev/null
+++ b/homework-g595-zueva/pom.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>mipt-java-2016</artifactId>
+        <groupId>ru.mipt.java2016</groupId>
+        <version>1.0.0</version>
+    </parent>
+    <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>
+            <version>1.0.0</version>
+            <scope>test</scope>
+        </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
new file mode 100644
index 000000000..e20b3293f
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/g595/zueva/task1/AzazaCalculator.java
@@ -0,0 +1,171 @@
+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
new file mode 100644
index 000000000..dd0a4a8e8
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/My_KV_Storage.java
@@ -0,0 +1,123 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task2;
+
+/*сreated by Nadya*/
+
+import org.apache.commons.io.IOExceptionWithCause;
+import ru.mipt.java2016.homework.base.task2.KeyValueStorage;
+import ru.mipt.java2016.homework.g595.zueva.task2.task2.Serializer;
+import java.util.Iterator;
+import java.util.Map;
+import java.io.*;
+import java.util.HashMap;
+
+
+public class My_KV_Storage<K, V> implements KeyValueStorage<K, V> {
+    private static final String VALIDATION_STRING;
+
+    static {
+        VALIDATION_STRING = "My strange storage";
+    }
+
+    public String FileName;
+    public HashMap<K, V> CurrentStorage;
+    public Serializer<K> keySerializer;
+    public Serializer<V> valueSerializer;
+    public boolean ifOpen = false;
+
+    /*Конструктор класс хранилища*/
+    public My_KV_Storage(String newFileName,
+                         Serializer newKeySerialisation,
+                         Serializer newValueSerialisation) throws Exception {
+        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 Exception("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 Exception("Cannot read from file");
+        }
+    }
+    @Override
+    public void close() throws IOExceptionWithCause {
+        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) {
+            throw new IllegalStateException("Failed to save and close storage");
+        }
+    }
+    @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/Serializer1.java
new file mode 100644
index 000000000..ee9e7ae26
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Serializer1.java
@@ -0,0 +1,15 @@
+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 Nadya on 31.10.2016.
+ */
+interface Serializer<T> {
+    void writeToStream(DataOutputStream out, T value) throws Exception;
+
+    T readFromStream(DataInputStream in) throws Exception;
+}
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
new file mode 100644
index 000000000..a4caff4b8
--- /dev/null
+++ b/homework-g595-zueva/src/main/java/ru/mipt/java2016/homework/g595/zueva/task2/task2/Specified_serializers.java
@@ -0,0 +1,79 @@
+package ru.mipt.java2016.homework.g595.zueva.task2.task2;
+
+/**
+ * Created by Nadya 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 Exception {
+        out.writeInt(value);
+    }
+
+    public Integer readFromStream(DataInputStream in) throws Exception {
+        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 Exception {
+            out.writeDouble(value);
+        }
+
+        @Override
+        public Double readFromStream(DataInputStream in) throws Exception {
+            return in.readDouble();
+        }
+    }
+
+    public static class SerializerStudentKey implements Serializer<StudentKey> {
+
+        public void writeToStream(DataOutputStream out, StudentKey value) throws Exception {
+            out.writeInt(value.getGroupId());
+            out.writeUTF(value.getName());
+        }
+
+        public StudentKey readFromStream(DataInputStream in) throws Exception {
+            return new StudentKey(in.readInt(), in.readUTF());
+        }
+    }
+
+    public static class SerializerStudent implements Serializer<Student> {
+
+        public void writeToStream(DataOutputStream out, Student value) throws Exception {
+            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 Exception {
+            return new Student(in.readInt(), in.readUTF(), in.readUTF(),
+                    new Date(in.readLong()), in.readBoolean(), in.readDouble());
+        }
+    }
+}
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
new file mode 100644
index 000000000..d0fec2ee9
--- /dev/null
+++ b/homework-g595-zueva/src/test/java/ru/mipt/java2016/g595/zueva/task1/AzazaCalculatorTest.java
@@ -0,0 +1,11 @@
+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
new file mode 100644
index 000000000..4db352dcd
--- /dev/null
+++ b/homework-g595-zueva/src/test/java/ru/mipt/java2016/homework/g595/zueva/task2/My_KV_StorageTest.java
@@ -0,0 +1,55 @@
+package ru.mipt.java2016.homework.g595.zueva.task2;
+
+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 ru.mipt.java2016.homework.g595.zueva.task2.task2.Specified_serializers;
+import ru.mipt.java2016.homework.g595.zueva.task2.task2.My_KV_Storage;
+import java.io.IOException;
+import java.io.*;
+
+/**
+ * Created by maria on 26.10.16.
+ */
+public class My_KV_StorageTest extends AbstractSingleFileStorageTest {
+
+    @Override
+    protected KeyValueStorage<String, String> buildStringsStorage(String path) {
+        My_KV_Storage result = null;
+        Specified_serializers.SerializerString a;
+        Specified_serializers.SerializerString b;
+        try {
+            result = new My_KV_Storage(path, new Specified_serializers.SerializerString(),
+                    new Specified_serializers.SerializerString());
+        } catch (Exception except) {
+            System.out.println(except.getMessage());
+        }
+        return result;
+    }
+
+
+    @Override
+    protected KeyValueStorage<Integer, Double> buildNumbersStorage(String path) {
+        My_KV_Storage<Integer, Double> result = null;
+        try {
+            result = new My_KV_Storage(path, new Specified_serializers.SerialiserInt(),
+                    new Specified_serializers.SerializerDouble());
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    protected KeyValueStorage<StudentKey, Student> buildPojoStorage(String path) {
+        My_KV_Storage result = null;
+        try {
+            result = new My_KV_Storage(path, new Specified_serializers.SerializerStudentKey(),
+                    new Specified_serializers.SerializerStudent());
+        } catch (Exception ex) {
+            System.out.println(ex.getMessage());
+        }
+        return result;
+    }
+}
diff --git a/homework-tests/src/main/java/ru/mipt/java2016/homework/tests/task1/AbstractCalculatorTest.java b/homework-tests/src/main/java/ru/mipt/java2016/homework/tests/task1/AbstractCalculatorTest.java
index 6d06e3186..b27d7c5c0 100644
--- a/homework-tests/src/main/java/ru/mipt/java2016/homework/tests/task1/AbstractCalculatorTest.java
+++ b/homework-tests/src/main/java/ru/mipt/java2016/homework/tests/task1/AbstractCalculatorTest.java
@@ -155,8 +155,4 @@ public void testUnaryMultiply() throws ParsingException {
     public void testBadNumber() throws ParsingException {
         tryFail("1.2.3");
     }
-/*<<<<<<< HEAD
-=======
-
->>>>>>> upstream/master*/
 }
\ No newline at end of file
diff --git a/java/io/annotations.xml b/java/io/annotations.xml
new file mode 100644
index 000000000..b088ffd48
--- /dev/null
+++ b/java/io/annotations.xml
@@ -0,0 +1,5 @@
+<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 0b1bce4c9..30e70c2d4 100644
--- a/pom.xml
+++ b/pom.xml
@@ -14,20 +14,16 @@
     <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-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>
@@ -42,9 +38,7 @@
         <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>
@@ -54,39 +48,30 @@
         <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-g597-smirnova</module>
-        <module>homework-g596-grebenshchikova</module>
-        <module>homework-g597-kochukov</module>
-        <module>workshop-materials</module>
+        <module>homework-g595-zueva</module>
 
     </modules>
 
@@ -215,7 +200,7 @@
                                     <property name="ignoreSetter" value="true"/>
                                     <property name="ignoreConstructorParameter" value="true"/>
                                 </module>
-                                <module name="IllegalThrows"/>
+                                <module name="IllegalCatch"/>
                                 <module name="IllegalInstantiation"/>
                                 <module name="InnerAssignment"/>
                                 <module name="MissingSwitchDefault"/>
@@ -267,4 +252,4 @@
         </pluginRepository>
     </pluginRepositories>
 
-</project>
+</project>
\ No newline at end of file