diff --git a/src/inport/ConversionUtils/Solver.java b/src/inport/ConversionUtils/Solver.java
index a82ef2b5421a70fb27bc7ea598bb8b50bad2547a..0c92c201ce3c719ba6452a083870392298cf8dda 100644
--- a/src/inport/ConversionUtils/Solver.java
+++ b/src/inport/ConversionUtils/Solver.java
@@ -40,7 +40,7 @@ public class Solver {
 
     private TaskCase task;
     private final String constraintName;
-    private final BiConsumer<TaskCase, String> converterToMinizincFormat;
+    private final BiConsumer<TaskCase, String> converterToMiniZincFormat;
     private final BiConsumer<TaskCase, String> interpreter;
     private String tempDir = "temp_data";
     private int timeLimitS;
@@ -71,12 +71,18 @@ public class Solver {
     public String getFlatZincSolver() {
         return flatZincSolver;
     }
+    public BiConsumer<TaskCase, String> getConverterToMiniZincFormat() {
+        return converterToMiniZincFormat;
+    }
+    public String getConstraintName() {
+        return constraintName;
+    }
 
     public Solver(String constraintName,
-           BiConsumer<TaskCase, String> converterToMinizincFormat,
+           BiConsumer<TaskCase, String> converterToMiniZincFormat,
            BiConsumer<TaskCase, String> interpreter) {
         this.constraintName = constraintName;
-        this.converterToMinizincFormat = converterToMinizincFormat;
+        this.converterToMiniZincFormat = converterToMiniZincFormat;
         this.interpreter = interpreter;
     }
 
@@ -122,7 +128,7 @@ public class Solver {
                     res.write(line + "\n");
                 }
             }
-            converterToMinizincFormat.accept(task, minizincData);
+            converterToMiniZincFormat.accept(task, minizincData);
 
             ProcessBuilder pb;
             boolean isResultsInOutput;
diff --git a/src/inport/Main.java b/src/inport/Main.java
index f84bda0f066372ca0a2a0703bd14ebe70a7ce1c9..80309079909382400c112f750643691cfdd2232c 100644
--- a/src/inport/Main.java
+++ b/src/inport/Main.java
@@ -9,6 +9,7 @@ import static inport.Testing.*;
 
 import inport.ConversionUtils.*;
 
+import org.kohsuke.args4j.Argument;
 import org.kohsuke.args4j.CmdLineException;
 import org.kohsuke.args4j.CmdLineParser;
 import org.kohsuke.args4j.Option;
@@ -66,13 +67,13 @@ public class Main {
         }
     }
 
-    private void solve(Collection<String> args) {
+    private static void solve(Collection<String> args) {
         try {
             class Arguments {
                 @Option(name = "-fzs", aliases = "--flat_zinc_solver", usage = "Путь к исполняемому файлу flatZinc solver-а.", forbids = {"-s"})
                 private String flatZincSolver = "";
 
-                @Option(name = "-p", usage = "Путь к задаче.", required = true)
+                @Argument(usage = "Путь к задаче.", required = true)
                 private String pathToTask = "";
 
                 @Option(name = "-ct", usage = "Тип сведения, один из " + ConversionType.legalValues + ".")
@@ -83,7 +84,6 @@ public class Main {
                 private String solverName = Solver.SolverName.Chuffed.text;
             }
 
-
             Arguments arguments = new Arguments();
             CmdLineParser parser = new CmdLineParser(arguments);
 
@@ -137,30 +137,198 @@ public class Main {
         }
     }
 
-    private void doMain(final String[] args) throws IOException {
-        final CmdLineParser parser = new CmdLineParser(this);
+    private static void tippToMzn(Collection<String> args) {
+        try {
+            class Arguments {
+                @Argument(usage = "Путь к задаче.", required = true)
+                private String pathToTask = "";
+
+                @Option(name = "-ct", usage = "Тип сведения, один из " + ConversionType.legalValues + ".")
+                private String conversionType = ConversionType.WithoutSplitting.text;
+
+                @Option(name = "-o", usage = "Директория, в которую будет записан ответ.")
+                private String outDir = ".";
+            }
+
+            Arguments arguments = new Arguments();
+            CmdLineParser parser = new CmdLineParser(arguments);
+
+            if (args.isEmpty()) {
+                parser.printUsage(System.out);
+                return;
+            }
+            parser.parseArgument(args);
+
+            ConversionType type = ConversionType.fromString(arguments.conversionType);
+            if (type.equals(ConversionType.Undefined)) {
+                System.out.println(undefinedTypeErrorMess(arguments.conversionType));
+                return;
+            }
+
+            TaskCase task = new TaskCase();
+            task.deserialize(arguments.pathToTask);
+
+            String constraints = arguments.outDir + "/conversion.mzn";
+            String minizincData = arguments.outDir + "/minizinc_data.dzn";
+
+            Solver solver = type.solversGetter.get();
+
+            solver.getConverterToMiniZincFormat().accept(task, minizincData);
+
+            try (FileWriter res = new FileWriter(constraints)) {
+                BufferedReader reader = new BufferedReader(new InputStreamReader(Main.class.getResourceAsStream("/constraints/" + solver.getConstraintName())));
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    res.write(line + "\n");
+                }
+            }
+        } catch (CmdLineException ex) {
+            System.out.println("Illegal arguments: " + ex.getLocalizedMessage());
+        } catch (IOException ex) {
+            System.out.println("Error : " + ex.getMessage());
+        }
+    }
+
+    private static void debug(Collection<String> args) {
+        class Arguments {
+            @Option(name = "-fzs", aliases = "--flat_zinc_solver", usage = "Путь к исполняемому файлу flatZinc solver-а.", forbids = {"-s"})
+            private String flatZincSolver = "";
+
+            @Option(name = "-ct", usage = "Тип сведения, один из " + ConversionType.legalValues + ".")
+            private String conversionType = ConversionType.WithoutSplitting.text;
+
+            @Option(name = "-s", aliases = "--solver", usage = "Тип solver-а из предопределённого списка : " + Solver.SolverName.legalValues + ".",
+                    forbids = {"-fzs"})
+            private String solverName = Solver.SolverName.Chuffed.text;
+        }
+
+        Arguments arguments = new Arguments();
+        CmdLineParser parser = new CmdLineParser(arguments);
+
+        if (args.isEmpty()) {
+            parser.printUsage(System.out);
+            return;
+        }
+        try {
+            parser.parseArgument(args);
+
+            ConversionType t = ConversionType.fromString(arguments.conversionType);
+
+            if (t.equals(ConversionType.Undefined)) {
+                System.out.println(undefinedTypeErrorMess(arguments.conversionType));
+                return;
+            }
+            Solver s = t.solversGetter.get();
+
+            if (arguments.flatZincSolver.isEmpty()) {
+                s.setSolverName(arguments.solverName);
+            } else {
+                s.setFlatZincSolver(arguments.flatZincSolver);
+            }
+            debug(s, DEFAULT_TIME_LIMIT_S);
+        } catch (CmdLineException ex) {
+            System.out.println("Illegal arguments: " + ex.getLocalizedMessage());
+        }
+    }
+
+    private static void resolveResults(Collection<String> args) {
+        class Arguments {
+            @Argument(usage = "Путь к решению.", required = true, index = 0)
+            private String pathToSolution = "";
+
+            @Argument(usage = "Путь к задаче.", required = true, index = 1)
+            private String pathToTask = "";
+        }
+
+        Arguments arguments = new Arguments();
+        CmdLineParser parser = new CmdLineParser(arguments);
+
+        if (args.isEmpty()) {
+            parser.printUsage(System.out);
+            return;
+        }
+        try {
+            parser.parseArgument(args);
+
+            TaskCase task = new TaskCase();
+            task.deserialize(arguments.pathToTask);
+
+            MZnResultsResolver.resolveMiniZincResults(task, arguments.pathToSolution);
+
+            task.deserialize(arguments.pathToTask);
+        } catch (CmdLineException ex) {
+            System.out.println("Illegal arguments: " + ex.getLocalizedMessage());
+        } catch (IOException ex) {
+            System.out.println("Error : " + ex.getMessage());
+        }
+    }
+
+    private static void testing(Collection<String> args) {
+        class Arguments {
+            @Option(name = "-fzs", aliases = "--flat_zinc_solver", usage = "Путь к исполняемому файлу flatZinc solver-а.", forbids = {"-s"})
+            private String flatZincSolver = "";
+
+            @Option(name = "-ct", usage = "Тип сведения, один из " + ConversionType.legalValues + ".")
+            private String conversionType = ConversionType.WithoutSplitting.text;
+
+            @Option(name = "-s", aliases = "--solver", usage = "Тип solver-а из предопределённого списка : " + Solver.SolverName.legalValues + ".",
+                    forbids = {"-fzs"})
+            private String solverName = Solver.SolverName.Chuffed.text;
+
+            @Option(name = "-d", aliases = "--test_dir", usage = "Директория, задачи из которых необходимо протестировать.")
+            private String testDir = "tests/with_typing";
+        }
+
+        Arguments arguments = new Arguments();
+        CmdLineParser parser = new CmdLineParser(arguments);
+
+        if (args.isEmpty()) {
+            parser.printUsage(System.out);
+            return;
+        }
+        try {
+            parser.parseArgument(args);
+            ConversionType t = ConversionType.fromString(arguments.conversionType);
+
+            if (t.equals(ConversionType.Undefined)) {
+                System.out.println(undefinedTypeErrorMess(arguments.conversionType));
+                return;
+            }
+            Solver s = t.solversGetter.get();
+
+            if (arguments.flatZincSolver.isEmpty()) {
+                s.setSolverName(arguments.solverName);
+            } else {
+                s.setFlatZincSolver(arguments.flatZincSolver);
+            }
+            testGroup(arguments.testDir, "", s, DEFAULT_TIME_LIMIT_S);
+        } catch (CmdLineException ex) {
+            System.out.println("Illegal arguments: " + ex.getLocalizedMessage());
+        }
+    }
 
+    private void doMain(final String[] args) throws IOException {
         Map<String, MainCommandsData> mainCommands = new TreeMap<>();
 
         Consumer<Boolean> c = (Boolean b) -> {};
 
         mainCommands.put("solve",
-                new MainCommandsData(false, "Решение задачи.", this::solve));
+                new MainCommandsData(false, "Решение задачи.", Main::solve));
 
         mainCommands.put("tippToMzn",
                 new MainCommandsData(
                         false
                         , "Сводит задачу к формату MiniZinc-а используя заданное сведение. " +
                           "Производит два файла - conversion.mzn и minizinc_data.dzn ."
-                        , (Collection<String> a) ->
-                {
-//                    try {
-//                        // TODO реализовать
-//                    } catch (IOException ex) {
-//                        throw new UncheckedIOException(ex);
-//                    }
-                }));
+                        , Main::tippToMzn));
+
+        mainCommands.put("debug", new MainCommandsData(true, "", Main::debug));
 
+        mainCommands.put("resolve_results",
+                new MainCommandsData(false, "Интерпретирует результат решения, как из MiniZinc-а, так и из FlatZinc-а.", Main::resolveResults));
+
+        mainCommands.put("testing",
+                new MainCommandsData(false, "Тестирует все задачи в заданной директории с помошью одного solver-а.", Main::testing));
 
         if (args.length < 1) {
             System.out.println("usage: java -jar Conversion.jar <command> [<args>]");
@@ -196,87 +364,16 @@ public class Main {
         String type = args[0];
         // TODO переделать
         switch (type) {
-            case "solve" : {
-
-                break;
-            }
-            case "to_MiniZinc_0" : {
-                String input = args[1];
-                String output = args[2];
-                TaskCase task = new TaskCase();
-
-                task.deserialize(input);
-                Task.portToMiniZinc_0(task, output);
-                break;
-            }
-            case "to_MiniZinc_1" : {
-                String input = args[1];
-                String output = args[2];
-                TaskCase task = new TaskCase();
-                task.deserialize(input);
-                Task.portToMiniZinc_1(task, output);
-                break;
-            }
-            case "resolve_result" : {
-                String input = args[1];
-                String fileWIthResult = args[2];
-                String output = args[3];
-
-                try {
-                    TaskCase task = new TaskCase();
-                    task.deserialize(input);
-
-                    MZnResultsResolver.resolveMiniZincResults(task, fileWIthResult);
-
-                    task.serialize(output);
-                } catch (ParserException ex) {
-                    System.out.println(ex.getMessage());
-                }
-                break;
-            }
-            case "debug" : {
-                ConversionType t = (args.length == 1) ? ConversionType.WithoutSplitting
-                        : ConversionType.fromString(args[1]);
-                if (t.equals(ConversionType.Undefined)) {
-                    System.out.println(undefinedTypeErrorMess(args[1]));
-                    return;
-                }
-                Solver s = t.solversGetter.get();
-
-                System.out.println(args[1] + " " + t.text + " " + s.getFlatZincSolver());
-
-                s.setFlatZincSolver(flatZincSolver);
-                debug(s, DEFAULT_TIME_LIMIT_S);
-                break;
-            }
             case "debug read-write" : {
                 debugReadWrite();
                 break;
             }
-            case "testing" :
-                ConversionType t = (args.length == 1) ? ConversionType.WithoutSplitting
-                        : ConversionType.fromString(args[1]);
-                if (t.equals(ConversionType.Undefined)) {
-                    System.out.println(undefinedTypeErrorMess(args[1]));
-                    return;
-                }
-                testGroup("with_typing", t.solversGetter.get(), DEFAULT_TIME_LIMIT_S);
-                break;
-            case "test_experiment":
-                testGroup("experiments", getTask_2_Solver(), DEFAULT_TIME_LIMIT_S);
-                break;
             case "different_parameters":
                 testingWithDiffParameters(
                         "tests/with_typing/Case2.tipp",
                         1, 30,
                         16, 35,
                         1.1, 30);
-
-//                    testingWithDiffParameters(
-//                            "tests/with_typing/TaskT.tipp",
-//                            10, 10,
-//                            32, 32,
-//                            1.1, 10);
                 break;
             default:
                 System.out.println("Unknown type \"" + type + "\"");
@@ -377,8 +474,6 @@ public class Main {
             String line;
 
             while (((line = br.readLine()) != null)) {
-                System.out.println("line : " + line);
-
                 line = line.trim();
                 if (line.equals("")) {
                     continue;
@@ -393,8 +488,6 @@ public class Main {
                     break;
                 }
 
-                System.out.println(name);
-
                 ArrayList<ArrayList<String>> array = MZnResultsResolver.parse2dArray(pos, line, task);
                 if (array != null) {
                     int maxSize = 0;
diff --git a/src/inport/Testing.java b/src/inport/Testing.java
index 24bc35841483b269a5d913ed66d59dfa29399289..22883597622f6a6707266c36e85b76f479d3f68c 100644
--- a/src/inport/Testing.java
+++ b/src/inport/Testing.java
@@ -57,7 +57,11 @@ public class Testing {
     }
 
     public static void testGroup(String group, Solver solver, int timeLimitS) {
-        File testDir = new File("tests/" + group + "/");
+        testGroup("tests", group, solver, timeLimitS);
+    }
+
+    public static void testGroup(String topDir, String group, Solver solver, int timeLimitS) {
+        File testDir = new File(topDir + "/" + group + "/");
         System.out.println(testDir.toString() + " :");
 
         solver.setTimeLimitS(timeLimitS);