diff --git a/core/src/main/java/ru/trader/analysis/Route.java b/core/src/main/java/ru/trader/analysis/Route.java
index e116558..2c88daf 100644
--- a/core/src/main/java/ru/trader/analysis/Route.java
+++ b/core/src/main/java/ru/trader/analysis/Route.java
@@ -16,6 +16,7 @@ public class Route implements Comparable<Route> {
     private double score = 0;
     private double fuel = 0;
     private int lands = 0;
+    private int refills = 0;
 
     public Route(RouteEntry root) {
         entries = new ArrayList<>();
@@ -35,6 +36,10 @@ public class Route implements Comparable<Route> {
         return entries.get(index);
     }
 
+    public boolean isEmpty(){
+        return entries.isEmpty();
+    }
+
     void setBalance(double balance){
         this.balance = balance;
     }
@@ -55,6 +60,10 @@ public class Route implements Comparable<Route> {
         return lands;
     }
 
+    public int getRefills() {
+        return refills;
+    }
+
     public void add(RouteEntry entry){
         LOG.trace("Add entry {} to route {}", entry, this);
         entries.add(entry);
@@ -100,9 +109,19 @@ public class Route implements Comparable<Route> {
         updateStats();
     }
 
+    public void dropTo(Vendor vendor){
+        for (ListIterator<RouteEntry> iterator = entries.listIterator(entries.size()); iterator.hasPrevious(); ) {
+            RouteEntry entry = iterator.previous();
+            if (entry.is(vendor)){
+                break;
+            }
+            iterator.remove();
+        }
+    }
+
     void updateStats(){
-        LOG.trace("Update stats, old: profit={}, distance={}, lands={}, fuel={}, score={}", profit, distance, lands, fuel, score);
-        profit = 0; distance = 0; lands = 0; fuel = 0;
+        LOG.trace("Update stats, old: profit={}, distance={}, lands={}, fuel={}, refills={}, score={}", profit, distance, lands, fuel, refills, score);
+        profit = 0; distance = 0; lands = 0; fuel = 0; refills = 0;
         if (entries.isEmpty()) return;
         RouteEntry entry = entries.get(0);
         for (int i = 1; i < entries.size(); i++) {
@@ -114,6 +133,9 @@ public class Route implements Comparable<Route> {
             if (entry.isLand()){
                 lands++;
             }
+            if (entry.isRefill()){
+                refills++;
+            }
             entry = next;
         }
         LOG.trace("new stats profit={}, distance={}, lands={}, fuel={}, score={}", profit, distance, lands, fuel, score);
diff --git a/core/src/main/java/ru/trader/analysis/RouteEntry.java b/core/src/main/java/ru/trader/analysis/RouteEntry.java
index 48d502c..79c323a 100644
--- a/core/src/main/java/ru/trader/analysis/RouteEntry.java
+++ b/core/src/main/java/ru/trader/analysis/RouteEntry.java
@@ -51,11 +51,11 @@ public class RouteEntry {
         this.score = score;
     }
 
-    public void add(Order order){
+    void add(Order order){
         orders.add(order);
     }
 
-    public void addAll(Collection<Order> orders){
+    void addAll(Collection<Order> orders){
         this.orders.addAll(orders);
     }
 
@@ -63,7 +63,7 @@ public class RouteEntry {
         return orders;
     }
 
-    public void clearOrders(){
+    void clearOrders(){
         orders.clear();
     }
 
@@ -75,7 +75,7 @@ public class RouteEntry {
         return land || refill || !orders.isEmpty();
     }
 
-    public void setLand(boolean land) {
+    void setLand(boolean land) {
         this.land = land;
     }
 
diff --git a/core/src/main/java/ru/trader/analysis/RouteSearcher.java b/core/src/main/java/ru/trader/analysis/RouteSearcher.java
index 1acdbfe..754160d 100644
--- a/core/src/main/java/ru/trader/analysis/RouteSearcher.java
+++ b/core/src/main/java/ru/trader/analysis/RouteSearcher.java
@@ -106,40 +106,63 @@ public class RouteSearcher {
         public List<Route> get() {
             return routes;
         }
+    }
 
-        private Route toRoute(List<Edge<Vendor>> edges){
-            List<RouteEntry> entries = new ArrayList<>(edges.size()+1);
-            Vendor buyer = null;
-            VendorsGraph.VendorsEdge vEdge = null;
-            for (Edge<Vendor> e : edges) {
-                vEdge = (VendorsGraph.VendorsEdge) e;
-                List<ConnectibleEdge<Vendor>> transitEdges = vEdge.getPath().getEntries();
-                for (int k = 0; k < transitEdges.size(); k++) {
-                    ConnectibleEdge<Vendor> edge = transitEdges.get(k);
-                    Vendor vendor = edge.getSource().getEntry();
-                    RouteEntry entry = new RouteEntry(vendor, edge.isRefill(), edge.getFuelCost(), 0);
-                    if (buyer != null && vendor.equals(buyer)) {
-                        entry.setLand(true);
-                        buyer = null;
-                    }
-                    if (k == 0) {
-                        entry.setScore(vEdge.getWeight());
-                        List<Order> orders = vEdge.getOrders();
-                        if (!orders.isEmpty()) {
-                            buyer = orders.get(0).getBuyer();
-                            entry.addAll(orders);
-                        }
-                    }
-                    entries.add(entry);
+    public static Route toRoute(List<Edge<Vendor>> edges){
+        List<RouteEntry> entries = new ArrayList<>(edges.size()+1);
+        Vendor buyer = null;
+        VendorsGraph.VendorsEdge vEdge = null;
+        for (Edge<Vendor> e : edges) {
+            vEdge = (VendorsGraph.VendorsEdge) e;
+            List<ConnectibleEdge<Vendor>> transitEdges = vEdge.getPath().getEntries();
+            for (int k = 0; k < transitEdges.size(); k++) {
+                ConnectibleEdge<Vendor> edge = transitEdges.get(k);
+                Vendor vendor = edge.getSource().getEntry();
+                RouteEntry entry = new RouteEntry(vendor, edge.isRefill(), edge.getFuelCost(), 0);
+                if (buyer != null && vendor.equals(buyer)) {
+                    entry.setLand(true);
+                    buyer = null;
+                }
+                if (k == 0) {
+                    entry.setScore(vEdge.getWeight());
+                    List<Order> orders = vEdge.getOrders();
+                    if (!orders.isEmpty()) {
+                        buyer = orders.get(0).getBuyer();
+                        entry.addAll(orders);
+                    }
                 }
-            }
-            if (vEdge != null) {
-                RouteEntry entry = new RouteEntry(vEdge.getTarget().getEntry(), false, 0, 0);
-                if (buyer != null) entry.setLand(true);
                 entries.add(entry);
             }
-            return new Route(entries);
         }
+        if (vEdge != null) {
+            RouteEntry entry = new RouteEntry(vEdge.getTarget().getEntry(), false, 0, 0);
+            if (buyer != null) entry.setLand(true);
+            entries.add(entry);
+        }
+        return new Route(entries);
+    }
 
+    public static Route toRoute(Order order, List<Edge<Place>> edges){
+        Route route = toRoute(order.getSeller(), order.getBuyer(), edges);
+        if (route.isEmpty()) return route;
+        route.get(0).add(order);
+        route.updateStats();
+        return route;
+    }
+
+    public static Route toRoute(Vendor from, Vendor to, List<Edge<Place>> edges){
+        List<RouteEntry> entries = new ArrayList<>(edges.size()+1);
+        for (int i = 0; i < edges.size(); i++) {
+            ConnectibleEdge<Place> edge = (ConnectibleEdge<Place>) edges.get(i);
+            Vendor vendor = i == 0 ? from : edge.getSource().getEntry().asTransit();
+            RouteEntry entry = new RouteEntry(vendor, edge.isRefill(), edge.getFuelCost(), 0);
+            entries.add(entry);
+            if (i == edges.size()-1){
+                entry = new RouteEntry(to, false, 0, 0);
+                entry.setLand(true);
+                entries.add(entry);
+            }
+        }
+        return new Route(entries);
     }
 }
diff --git a/core/src/main/java/ru/trader/core/MarketAnalyzer.java b/core/src/main/java/ru/trader/core/MarketAnalyzer.java
index 79f7315..5dba6bb 100644
--- a/core/src/main/java/ru/trader/core/MarketAnalyzer.java
+++ b/core/src/main/java/ru/trader/core/MarketAnalyzer.java
@@ -35,6 +35,10 @@ public class MarketAnalyzer {
         this.callback = callback;
     }
 
+    public Profile getProfile() {
+        return profile;
+    }
+
     public List<Offer> getOffers(OFFER_TYPE offerType, Item item, MarketFilter filter){
         return market.getOffers(offerType, item).filter(o -> !filter.isFiltered(o.getVendor())).collect(Collectors.toList());
     }
@@ -173,8 +177,12 @@ public class MarketAnalyzer {
         return searcher.getPaths(from, to, getPlaces());
     }
 
-    public List<Edge<Place>> getPath(Place from, Place to){
-        return searcher.getPath(from, to, getPlaces());
+    public Route getPath(Vendor from, Vendor to){
+        return RouteSearcher.toRoute(from, to, searcher.getPath(from.getPlace(), to.getPlace(), getPlaces()));
+    }
+
+    public Route getPath(Order order){
+        return RouteSearcher.toRoute(order, searcher.getPath(order.getSeller().getPlace(), order.getBuyer().getPlace(), getPlaces()));
     }
 
     public Collection<Route> getTopRoutes(int limit){
@@ -182,7 +190,9 @@ public class MarketAnalyzer {
         LimitedQueue<Route> top = new LimitedQueue<>(limit);
         Collection<Vendor> vendors = getVendors();
         callback.setMax(vendors.size());
-        for (Vendor vendor : vendors) {
+        Iterator<Vendor> iterator = market.getMarkets(false).iterator();
+        while (iterator.hasNext()){
+            Vendor vendor = iterator.next();
             if (callback.isCancel()) break;
             Collection<Route> paths = searcher.getRoutes(vendor, vendor, vendors, 3);
             top.addAll(paths);