diff --git a/PoGo.NecroBot.CLI/Program.cs b/PoGo.NecroBot.CLI/Program.cs
index c9b5aef43..60fc489fb 100644
--- a/PoGo.NecroBot.CLI/Program.cs
+++ b/PoGo.NecroBot.CLI/Program.cs
@@ -246,7 +246,7 @@ private static void Main(string[] args)
             if (settings.TelegramConfig.UseTelegramAPI)
                 _session.Telegram = new TelegramService(settings.TelegramConfig.TelegramAPIKey, _session);
 
-            if (_session.LogicSettings.UseSnipeLocationServer)
+            if (_session.LogicSettings.UseSnipeLocationServer || _session.LogicSettings.HumanWalkingSnipeUsePogoLocationFeeder)
                 SnipePokemonTask.AsyncStart(_session);
 
             settings.checkProxy(_session.Translation);
diff --git a/PoGo.NecroBot.CLI/SniperEventListener.cs b/PoGo.NecroBot.CLI/SniperEventListener.cs
index b27d54f9a..c1c670ff2 100644
--- a/PoGo.NecroBot.CLI/SniperEventListener.cs
+++ b/PoGo.NecroBot.CLI/SniperEventListener.cs
@@ -2,10 +2,14 @@
 
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using PoGo.NecroBot.Logic.Common;
 using PoGo.NecroBot.Logic.Event;
+using PoGo.NecroBot.Logic.Logging;
 using PoGo.NecroBot.Logic.State;
-using PoGo.NecroBot.Logic.Tasks;
-
+using POGOProtos.Enums;
+using POGOProtos.Inventory.Item;
+using POGOProtos.Networking.Responses;
 #endregion
 
 namespace PoGo.NecroBot.CLI
@@ -16,22 +20,28 @@ internal class SniperEventListener
         private static void HandleEvent(PokemonCaptureEvent pokemonCaptureEvent, ISession session)
         {
             //remove pokemon from list
-            HumanWalkSnipeTask.UpdateCatchPokemon(pokemonCaptureEvent.Latitude, pokemonCaptureEvent.Longitude,
-                pokemonCaptureEvent.Id);
+            Logic.Tasks.HumanWalkSnipeTask.UpdateCatchPokemon(pokemonCaptureEvent.Latitude, pokemonCaptureEvent.Longitude, pokemonCaptureEvent.Id);
         }
 
+        public static void HandleEvent(SnipePokemonFoundEvent ev, ISession session)
+        {
+            Logic.Tasks.HumanWalkSnipeTask.AddSnipePokemon("Local Feeder",
+                ev.PokemonFound.Id,
+                ev.PokemonFound.Latitude,
+                ev.PokemonFound.Longitude,
+                ev.PokemonFound.ExpirationTimestamp,
+                ev.PokemonFound.IV, 
+                session
+                );
+        }
         internal void Listen(IEvent evt, ISession session)
         {
             dynamic eve = evt;
 
             try
-            {
-                HandleEvent(eve, session);
-            }
-            catch (Exception)
-            {
-                // ignored
-            }
+            { HandleEvent(eve, session); }
+            catch
+            { }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/PoGo.NecroBot.GUI/PoGo.NecroBot.GUI.csproj b/PoGo.NecroBot.GUI/PoGo.NecroBot.GUI.csproj
index d00b1b3e4..96af667c3 100644
--- a/PoGo.NecroBot.GUI/PoGo.NecroBot.GUI.csproj
+++ b/PoGo.NecroBot.GUI/PoGo.NecroBot.GUI.csproj
@@ -155,6 +155,8 @@
     <When Condition="('$(SolutionName)'!='Awesomium.NET') And ('$(SolutionName)'!='Awesomium.Windows')" />
   </Choose>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+    <PostBuildEvent>
+    </PostBuildEvent>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/PoGo.NecroBot.Logic/Event/HumanWalkSnipeEvent.cs b/PoGo.NecroBot.Logic/Event/HumanWalkSnipeEvent.cs
index c450b42d0..549b40286 100644
--- a/PoGo.NecroBot.Logic/Event/HumanWalkSnipeEvent.cs
+++ b/PoGo.NecroBot.Logic/Event/HumanWalkSnipeEvent.cs
@@ -29,7 +29,7 @@ public class HumanWalkSnipeEvent : IEvent
     {
         public double Latitude { get; set; }
         public double Longitude { get; set; }
-
+        public string Rarity { get; set; }
         public double Distance { get; set; }
 
         public double WalkTimes { get; set; }
diff --git a/PoGo.NecroBot.Logic/Event/SnipePokemonFoundEvent.cs b/PoGo.NecroBot.Logic/Event/SnipePokemonFoundEvent.cs
new file mode 100644
index 000000000..a41680e72
--- /dev/null
+++ b/PoGo.NecroBot.Logic/Event/SnipePokemonFoundEvent.cs
@@ -0,0 +1,13 @@
+using PoGo.NecroBot.Logic.Tasks;
+
+namespace PoGo.NecroBot.Logic.Event
+{
+    public class SnipePokemonFoundEvent : IEvent
+    {
+        public SniperInfo PokemonFound { get; set; }
+        public override string ToString()
+        {
+            return PokemonFound.Id.ToString();
+        }
+    }
+}
\ No newline at end of file
diff --git a/PoGo.NecroBot.Logic/Interfaces/Configuration/ILogicSettings.cs b/PoGo.NecroBot.Logic/Interfaces/Configuration/ILogicSettings.cs
index fb8a06e28..c0a5b150a 100644
--- a/PoGo.NecroBot.Logic/Interfaces/Configuration/ILogicSettings.cs
+++ b/PoGo.NecroBot.Logic/Interfaces/Configuration/ILogicSettings.cs
@@ -123,6 +123,8 @@ public interface ILogicSettings
         bool RandomizeRecycle { get; }
         int RandomRecycleValue { get; }
         int TotalAmountOfPokeballsToKeep { get; }
+        int MaxPokeballsToKeep { get; }
+
         int TotalAmountOfPotionsToKeep { get; }
         int TotalAmountOfRevivesToKeep { get; }
         int TotalAmountOfBerriesToKeep { get; }
@@ -181,11 +183,14 @@ public interface ILogicSettings
         bool HumanWalkingSnipeIncludeDefaultLocation { get; }
         bool HumanWalkingSnipeUsePokeRadar { get; }
         bool HumanWalkingSnipeUseSkiplagged { get; }
+        bool HumanWalkingSnipeUseFastPokemap { get; }
         bool HumanWalkingSnipeUseSnipePokemonList { get; }
         Dictionary<PokemonId, HumanWalkSnipeFilter> HumanWalkSnipeFilters { get; }
         double HumanWalkingSnipeMaxSpeedUpSpeed { get; }
         int HumanWalkingSnipeDelayTimeAtDestination { get; }
         bool HumanWalkingSnipeAllowSpeedUp { get; }
+        bool HumanWalkingSnipeUsePogoLocationFeeder { get; }
+
         int EvolveActionDelay { get; }
         int TransferActionDelay { get; }
         int RecycleActionDelay { get; }
diff --git a/PoGo.NecroBot.Logic/Model/Settings/HumanWalkSnipeConfig.cs b/PoGo.NecroBot.Logic/Model/Settings/HumanWalkSnipeConfig.cs
index 966bb6c12..2b1b625f6 100644
--- a/PoGo.NecroBot.Logic/Model/Settings/HumanWalkSnipeConfig.cs
+++ b/PoGo.NecroBot.Logic/Model/Settings/HumanWalkSnipeConfig.cs
@@ -85,5 +85,7 @@ public class HumanWalkSnipeConfig
         [Range(0, 999999)]
         [JsonProperty(Required = Required.DisallowNull, DefaultValueHandling = DefaultValueHandling.Populate)]
         public int DelayTimeAtDestination = 10000;//  10 sec
+         public bool UseFastPokemap = true;
+        public bool UsePogoLocationFeeder = false;
     }
 }
diff --git a/PoGo.NecroBot.Logic/Model/Settings/HumanWalkSnipeFilter.cs b/PoGo.NecroBot.Logic/Model/Settings/HumanWalkSnipeFilter.cs
index 93253b656..ff7cce8d3 100644
--- a/PoGo.NecroBot.Logic/Model/Settings/HumanWalkSnipeFilter.cs
+++ b/PoGo.NecroBot.Logic/Model/Settings/HumanWalkSnipeFilter.cs
@@ -47,7 +47,7 @@ public class HumanWalkSnipeFilter
         [JsonProperty(Required = Required.DisallowNull, DefaultValueHandling = DefaultValueHandling.Populate, Order = 8)]
         public int DelayTimeAtDestination { get; set; }
 
-        public HumanWalkSnipeFilter(double maxDistance, double maxWalkTimes, int priority, bool catchPokemon, bool spinPokestop, bool allowSpeedUp, double speedUpSpeed, double delay = 10)
+        public HumanWalkSnipeFilter(double maxDistance, double maxWalkTimes, int priority, bool catchPokemon, bool spinPokestop, bool allowSpeedUp, double speedUpSpeed, int delay = 10)
         {
             this.MaxDistance = maxDistance;
             this.MaxWalkTimes = maxWalkTimes;
@@ -56,6 +56,7 @@ public HumanWalkSnipeFilter(double maxDistance, double maxWalkTimes, int priorit
             this.SpinPokestopWhileWalking = spinPokestop;
             this.AllowSpeedUp = allowSpeedUp;
             this.MaxSpeedUpSpeed = speedUpSpeed;
+            this.DelayTimeAtDestination = delay;
         }
 
         internal static Dictionary<PokemonId, HumanWalkSnipeFilter> Default()
diff --git a/PoGo.NecroBot.Logic/Model/Settings/ItemRecycleConfig.cs b/PoGo.NecroBot.Logic/Model/Settings/ItemRecycleConfig.cs
index 21faa24d1..8bcc70fd4 100644
--- a/PoGo.NecroBot.Logic/Model/Settings/ItemRecycleConfig.cs
+++ b/PoGo.NecroBot.Logic/Model/Settings/ItemRecycleConfig.cs
@@ -45,5 +45,10 @@ public class ItemRecycleConfig
         [Range(0, 999)]
         [JsonProperty(Required = Required.DisallowNull, DefaultValueHandling = DefaultValueHandling.Populate, Order = 9)]
         public int TotalAmountOfBerriesToKeep = 50;
+
+        [Range(0, 999)]
+        [DefaultValue(50)]
+        [JsonProperty(Required = Required.DisallowNull, DefaultValueHandling = DefaultValueHandling.Populate, Order = 9)]
+        public int MaxPokeballsToKeep = 50;
     }
 }
\ No newline at end of file
diff --git a/PoGo.NecroBot.Logic/Model/Settings/LogicSettings.cs b/PoGo.NecroBot.Logic/Model/Settings/LogicSettings.cs
index 41ded3fa7..94d2d756b 100644
--- a/PoGo.NecroBot.Logic/Model/Settings/LogicSettings.cs
+++ b/PoGo.NecroBot.Logic/Model/Settings/LogicSettings.cs
@@ -166,6 +166,7 @@ public LogicSettings(GlobalSettings settings)
         public bool SnipePokemonNotInPokedex => _settings.SnipeConfig.SnipePokemonNotInPokedex;
         public bool RandomizeRecycle => _settings.RecycleConfig.RandomizeRecycle;
         public int RandomRecycleValue => _settings.RecycleConfig.RandomRecycleValue;
+        public int MaxPokeballsToKeep => _settings.RecycleConfig.MaxPokeballsToKeep;
         public int TotalAmountOfPokeballsToKeep => _settings.RecycleConfig.TotalAmountOfPokeballsToKeep;
         public int TotalAmountOfPotionsToKeep => _settings.RecycleConfig.TotalAmountOfPotionsToKeep;
         public int TotalAmountOfRevivesToKeep => _settings.RecycleConfig.TotalAmountOfRevivesToKeep;
@@ -176,7 +177,6 @@ public LogicSettings(GlobalSettings settings)
         public int ResumeTrack => _settings.LocationConfig.ResumeTrack;
         public int ResumeTrackSeg => _settings.LocationConfig.ResumeTrackSeg;
         public int ResumeTrackPt => _settings.LocationConfig.ResumeTrackPt;
-
         public bool HumanWalkingSnipeDisplayList => _settings.HumanWalkSnipeConfig.DisplayPokemonList;
         public double HumanWalkingSnipeMaxDistance => _settings.HumanWalkSnipeConfig.MaxDistance;
         public double HumanWalkingSnipeMaxEstimateTime => _settings.HumanWalkSnipeConfig.MaxEstimateTime;
@@ -188,6 +188,7 @@ public LogicSettings(GlobalSettings settings)
         public int HumanWalkingSnipeCatchEmAllMinBalls => _settings.HumanWalkSnipeConfig.CatchEmAllMinBalls;
         public bool EnableHumanWalkingSnipe => _settings.HumanWalkSnipeConfig.Enable;
         public Dictionary<PokemonId, HumanWalkSnipeFilter> HumanWalkSnipeFilters => _settings.HumanWalkSnipeFilters;
+        public bool HumanWalkingSnipeUseFastPokemap => _settings.HumanWalkSnipeConfig.UseFastPokemap;
         public bool HumanWalkingSnipeUsePokeRadar => _settings.HumanWalkSnipeConfig.UsePokeRadar;
         public bool HumanWalkingSnipeUseSkiplagged => _settings.HumanWalkSnipeConfig.UseSkiplagged;
         public bool HumanWalkingSnipeUseSnipePokemonList => _settings.HumanWalkSnipeConfig.UseSnipePokemonList;
@@ -196,5 +197,6 @@ public LogicSettings(GlobalSettings settings)
         public double HumanWalkingSnipeMaxSpeedUpSpeed => _settings.HumanWalkSnipeConfig.MaxSpeedUpSpeed;
         public bool HumanWalkingSnipeAllowSpeedUp => _settings.HumanWalkSnipeConfig.AllowSpeedUp;
         public int HumanWalkingSnipeDelayTimeAtDestination => _settings.HumanWalkSnipeConfig.DelayTimeAtDestination;
+        public bool HumanWalkingSnipeUsePogoLocationFeeder => _settings.HumanWalkSnipeConfig.UsePogoLocationFeeder;
     }
 }
diff --git a/PoGo.NecroBot.Logic/PoGo.NecroBot.Logic.csproj b/PoGo.NecroBot.Logic/PoGo.NecroBot.Logic.csproj
index a9181c02b..1097ab53d 100644
--- a/PoGo.NecroBot.Logic/PoGo.NecroBot.Logic.csproj
+++ b/PoGo.NecroBot.Logic/PoGo.NecroBot.Logic.csproj
@@ -149,6 +149,7 @@
     <Compile Include="Event\KillSwitchEvent.cs" />
     <Compile Include="Event\LogEvent.cs" />
     <Compile Include="Event\NoPokeballEvent.cs" />
+    <Compile Include="Event\SnipePokemonFoundEvent.cs" />
     <Compile Include="Event\SnipeEvent.cs" />
     <Compile Include="Event\SnipeModeEvent.cs" />
     <Compile Include="Event\PokemonListEvent.cs" />
@@ -324,6 +325,7 @@
       <SubType>Designer</SubType>
     </None>
     <None Include="packages.config" />
+    <Compile Include="Tasks\HumanWalkSnipeTask.FastPokemap.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\FeroxRev\PokemonGo.RocketAPI\PokemonGo.RocketAPI.csproj">
diff --git a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.FastPokemap.cs b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.FastPokemap.cs
new file mode 100644
index 000000000..eed33e17c
--- /dev/null
+++ b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.FastPokemap.cs
@@ -0,0 +1,148 @@
+using Newtonsoft.Json;
+using PoGo.NecroBot.Logic.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using POGOProtos.Enums;
+
+namespace PoGo.NecroBot.Logic.Tasks
+{
+    public partial class HumanWalkSnipeTask
+    {
+        private static string ip;
+
+        private static Task taskDataLive;
+        public class FastPokemapItem
+        {
+            public class Lnglat
+            {
+                public string type { get; set; }
+                public List<double> coordinates { get; set; }
+            }
+
+            public string _id { get; set; }
+            public string pokemon_id { get; set; }
+            public string encounter_id { get; set; }
+            public string spawn_id { get; set; }
+            public DateTime expireAt { get; set; }
+            public int __v { get; set; }
+            public Lnglat lnglat { get; set; }
+        }
+
+        private static string GetIP()
+        {
+
+            if (string.IsNullOrEmpty(ip))
+            {
+                var client = new HttpClient();
+                var task = client.GetStringAsync("http://checkip.dyndns.org");
+                task.Wait();
+                ip = task.Result.Split(':')[1].Trim();
+            }
+            return ip;
+
+        }
+		private static void EnsureDataLive()
+        {
+            int liveUpdateCount = 6;
+
+            if (taskDataLive != null && !taskDataLive.IsCompleted) return;
+            taskDataLive = Task.Run(async  () =>  
+            {
+					while(liveUpdateCount>0)
+                {
+                    liveUpdateCount--;
+                    var lat = _session.Client.CurrentLatitude;
+                    var lng = _session.Client.CurrentLongitude;
+                    var api = $"https://api.fastpokemap.se/?key=allow-all&ts=0&lat={lat}&lng={lng}";
+                    await DownloadContent(api);
+                    await Task.Delay(10000);
+                }
+            });
+        }
+        private static SnipePokemonInfo Map(FastPokemapItem result)
+        {
+            return new SnipePokemonInfo()
+            {
+                Latitude = result.lnglat.coordinates[1],
+                Longitude = result.lnglat.coordinates[0],
+                Id = GetId(result.pokemon_id),
+                ExpiredTime = result.expireAt.ToLocalTime(),
+                Source = "Fastpokemap"
+            };
+        }
+
+        public static int GetId(string name)
+        {
+
+            var t = name[0];
+            var realName = new StringBuilder(name.ToLower());
+            realName[0] = t;
+            try
+            {
+                var p = (PokemonId)Enum.Parse(typeof(PokemonId), realName.ToString());
+                return (int)p;
+            }
+            catch (Exception)
+            {
+
+            }
+            return 0;
+
+        }
+        private static async Task<string> DownloadContent(string url)
+        {
+            HttpClient client = new HttpClient();
+
+            var request = new HttpRequestMessage()
+            {
+                RequestUri = new Uri(url),
+                Method = HttpMethod.Get,
+            };
+            request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
+            request.Headers.Add("origin", "https://fastpokemap.se");
+            request.Headers.Add("authority", "cache.fastpokemap.se");
+
+            string result = "";
+            try {
+                var task = await client.SendAsync(request);
+                 result = await task.Content.ReadAsStringAsync();
+            }
+			catch(Exception ex) { }
+
+            return result;
+
+        }
+        private static async Task<List<SnipePokemonInfo>> FetchFromFastPokemap(double lat, double lng)
+        {
+            List<SnipePokemonInfo> results = new List<SnipePokemonInfo>();
+             if (!_setting.HumanWalkingSnipeUseFastPokemap) return results;
+            try
+            {
+                EnsureDataLive();
+                string url = $"https://cache.fastpokemap.se/?key=allow-all&ts=0&compute={GetIP()}&lat={lat}&lng={lng}";
+                
+                var json = await DownloadContent(url);
+                var data = JsonConvert.DeserializeObject<List<FastPokemapItem>>(json);
+                foreach (var item in data)
+                {
+                    var pItem = Map(item);
+                    if (pItem != null && pItem.Id > 0)
+                    {
+                        results.Add(pItem);
+                    }
+                }
+
+            }
+            catch (Exception)
+            {
+                Logger.Write("Error loading data fastpokemap", LogLevel.Error, ConsoleColor.DarkRed);
+            }
+            return results;
+        }
+
+    }
+}
diff --git a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.PokeZZ.cs b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.PokeZZ.cs
index ab99a24ed..fb40b492b 100644
--- a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.PokeZZ.cs
+++ b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.PokeZZ.cs
@@ -1,4 +1,5 @@
-using PoGo.NecroBot.Logic.Utils;
+using PoGo.NecroBot.Logic.Logging;
+using PoGo.NecroBot.Logic.Utils;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -43,6 +44,7 @@ private static async Task<List<SnipePokemonInfo>> FetchFromPokeZZ(double lat, do
             }
             catch (Exception )
             {
+                Logger.Write("Error loading data from Pokezz", LogLevel.Error, ConsoleColor.DarkRed);
 
             }
 
diff --git a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokecrew.cs b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokecrew.cs
index a03d25375..85319b55a 100644
--- a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokecrew.cs
+++ b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokecrew.cs
@@ -6,13 +6,12 @@
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
+using POGOProtos.Enums;
 
 namespace PoGo.NecroBot.Logic.Tasks
 {
     public partial class HumanWalkSnipeTask
     {
-
-
         public class PokecrewWrap
         {
             public class PokecrewItem
@@ -41,8 +40,7 @@ private static SnipePokemonInfo Map(PokecrewWrap.PokecrewItem result)
                 Source = "Pokecrew"
             };
         }
-
-        private static async Task<List<SnipePokemonInfo>> FetchFromPokecrew(double lat, double lng)
+         private static async Task<List<SnipePokemonInfo>> FetchFromPokecrew(double lat, double lng)
         {
             List<SnipePokemonInfo> results = new List<SnipePokemonInfo>();
             // if (!_setting.HumanWalkingSnipeUsePokeRadar) return results;
diff --git a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokeradar.cs b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokeradar.cs
index e9c6db53a..35b34ea2b 100644
--- a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokeradar.cs
+++ b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokeradar.cs
@@ -41,7 +41,7 @@ private static async Task<List<SnipePokemonInfo>> FetchFromPokeradar(double lat,
             }
             catch (Exception )
             {
-                Logger.Write("Error loading data", LogLevel.Error, ConsoleColor.DarkRed);
+                Logger.Write("Error loading data pokeradar", LogLevel.Error, ConsoleColor.DarkRed);
             }
             return results;
         }
diff --git a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokesnipers.cs b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokesnipers.cs
index 42242ecce..9e1e39bf7 100644
--- a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokesnipers.cs
+++ b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Pokesnipers.cs
@@ -71,7 +71,7 @@ private static async Task<List<SnipePokemonInfo>> FetchFromPokesnipers(double la
             }
             catch (Exception)
             {
-                Logger.Write("Error loading data", LogLevel.Error, ConsoleColor.DarkRed);
+                Logger.Write("Error loading data from pokesnipers", LogLevel.Error, ConsoleColor.DarkRed);
             }
             return results;
         }
diff --git a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Skiplagged.cs b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Skiplagged.cs
index a6f6f2d08..0888212b1 100644
--- a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Skiplagged.cs
+++ b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.Skiplagged.cs
@@ -84,7 +84,9 @@ private static async Task<List<SnipePokemonInfo>> FetchFromSkiplagged(double lat
                 results = GetJsonList(json);
             }
             catch (Exception )
-            {}
+            {
+                Logger.Write("Error loading data from skiplagged", LogLevel.Error, ConsoleColor.DarkRed);
+            }
             return results;
         }
 
diff --git a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.cs b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.cs
index 89291bac8..64c72d21b 100644
--- a/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.cs
+++ b/PoGo.NecroBot.Logic/Tasks/HumanWalkSnipeTask.cs
@@ -24,7 +24,7 @@
 namespace PoGo.NecroBot.Logic.Tasks
 {
     //need refactor this class, move list snipping pokemon to session and split function out to smaller class.
-    public partial class  HumanWalkSnipeTask
+    public partial class HumanWalkSnipeTask
     {
         public class SnipePokemonInfo
         {
@@ -53,6 +53,7 @@ public string UniqueId
                 }
             }
             public string Source { get; set; }
+            public double IV { get; internal set; }
         }
 
         private static List<SnipePokemonInfo> rarePokemons = new List<SnipePokemonInfo>();
@@ -63,6 +64,27 @@ public string UniqueId
         static bool prioritySnipeFlag = false;
         private static DateTime lastUpdated = DateTime.Now.AddMinutes(-10);
 
+        public static async void AddSnipePokemon(string source, PokemonId id, double latitude, double longitude, DateTime expirationTimestamp, double iV = 0, ISession session = null)
+        {
+            if (session != null)
+            {
+                InitSession(session);
+            }
+            if (_session == null || _session == null) return;
+
+            PostProcessDataFetched(new List<SnipePokemonInfo> {
+                new SnipePokemonInfo()
+                {
+                    Latitude =latitude,
+                    Longitude = longitude,
+                    Id = (int) id,
+                    ExpiredTime = expirationTimestamp,
+                    Source = source,
+                    IV = iV
+                }
+            },false);
+        }
+
         public static async Task<bool> CheckPokeballsToSnipe(int minPokeballs, ISession session,
             CancellationToken cancellationToken)
         {
@@ -100,14 +122,10 @@ public static Task ExecuteFetchData(ISession session)
 
         private static void InitSession(ISession session)
         {
-            if (_session == null)
-            {
-                _session = session;
-                _setting = _session.LogicSettings;
-                pokemonToBeSnipedIds = _setting.HumanWalkingSnipeUseSnipePokemonList ? _setting.PokemonToSnipe.Pokemon : new List<PokemonId>();
-                pokemonToBeSnipedIds.AddRange(_setting.HumanWalkSnipeFilters.Where(x => !pokemonToBeSnipedIds.Any(t => t == x.Key)).Select(x => x.Key).ToList());      //this will combine with pokemon snipe filter
-
-            }
+            _session = session;
+            _setting = _session.LogicSettings;
+            pokemonToBeSnipedIds = _setting.HumanWalkingSnipeUseSnipePokemonList ? _setting.PokemonToSnipe.Pokemon : new List<PokemonId>();
+            pokemonToBeSnipedIds.AddRange(_setting.HumanWalkSnipeFilters.Where(x => !pokemonToBeSnipedIds.Any(t => t == x.Key)).Select(x => x.Key).ToList());      //this will combine with pokemon snipe filter
         }
 
         public static List<SnipePokemonInfo> ApplyFilter(List<SnipePokemonInfo> source)
@@ -167,7 +185,8 @@ public static async Task Execute(ISession session, CancellationToken cancellatio
                         Pokemons = ApplyFilter(rarePokemons),
                         SpinPokeStop = pokemon.Setting.SpinPokestopWhileWalking,
                         WalkSpeedApplied = pokemon.Setting.AllowSpeedUp ? pokemon.Setting.MaxSpeedUpSpeed : _session.LogicSettings.WalkingSpeedInKilometerPerHour,
-                        Type = HumanWalkSnipeEventTypes.StartWalking
+                        Type = HumanWalkSnipeEventTypes.StartWalking,
+                        Rarity = PokemonGradeHelper.GetPokemonGrade(pokemon.PokemonId).ToString()
                     });
 
                     await session.Navigation.Move(new GeoCoordinate(pokemon.Latitude, pokemon.Longitude,
@@ -194,13 +213,14 @@ await session.Navigation.Move(new GeoCoordinate(pokemon.Latitude, pokemon.Longit
                         Latitude = pokemon.Latitude,
                         Longitude = pokemon.Longitude,
                         PauseDuration = pokemon.Setting.DelayTimeAtDestination / 1000,
-                        Type = HumanWalkSnipeEventTypes.DestinationReached
+                        Type = HumanWalkSnipeEventTypes.DestinationReached,
+                        UniqueId = pokemon.UniqueId
                     });
                     //await CatchNearbyPokemonsTask.Execute(session, cancellationToken, pokemon.PokemonId,false);
                     //await CatchIncensePokemonsTask.Execute(session, cancellationToken);
 
                     await Task.Delay(pokemon.Setting.DelayTimeAtDestination);
-                   // if (!pokemon.IsVisited)
+                    // if (!pokemon.IsVisited)
                     {
                         await CatchNearbyPokemonsTask.Execute(session, cancellationToken, pokemon.PokemonId, false);
                         await CatchIncensePokemonsTask.Execute(session, cancellationToken);
@@ -223,7 +243,7 @@ static void CalculateDistanceAndEstTime(SnipePokemonInfo p)
             var speedInMetersPerSecond = speed / 3.6;
 
             p.Distance = CalculateDistanceInMeters(_session.Client.CurrentLatitude, _session.Client.CurrentLongitude, p.Latitude, p.Longitude);
-            p.EstimatedTime = p.Distance / speedInMetersPerSecond + p.Setting.DelayTimeAtDestination /1000  + 15; //margin 30 second
+            p.EstimatedTime = p.Distance / speedInMetersPerSecond + p.Setting.DelayTimeAtDestination / 1000 + 15; //margin 30 second
 
         }
 
@@ -277,6 +297,7 @@ private static void FetchData(double lat, double lng, bool silent = false)
 
             List<Task<List<SnipePokemonInfo>>> allTasks = new List<Task<List<SnipePokemonInfo>>>()
             {
+                FetchFromFastPokemap(lat, lng),
                 //FetchFromPokeWatcher(lat, lng),
                 FetchFromPokeradar(lat, lng),
                 FetchFromSkiplagged(lat, lng)     ,
@@ -289,6 +310,8 @@ private static void FetchData(double lat, double lng, bool silent = false)
             {
                 allTasks.Add(FetchFromPokeradar(_session.Settings.DefaultLatitude, _session.Settings.DefaultLongitude));
                 allTasks.Add(FetchFromSkiplagged(_session.Settings.DefaultLatitude, _session.Settings.DefaultLongitude));
+                allTasks.Add(FetchFromFastPokemap(_session.Settings.DefaultLatitude, _session.Settings.DefaultLongitude));
+
             }
 
             Task.WaitAll(allTasks.ToArray());
@@ -346,7 +369,7 @@ private static void PostProcessDataFetched(IEnumerable<SnipePokemonInfo> pokemon
                 item.Setting = Clone<HumanWalkSnipeFilter>(config);
 
                 CalculateDistanceAndEstTime(item);
-                                           
+
                 if (item.Distance < 10000)  //only add if distance <10km
                 {
                     rarePokemons.Add(item);
@@ -359,7 +382,7 @@ private static void PostProcessDataFetched(IEnumerable<SnipePokemonInfo> pokemon
             var grouped = rarePokemons.GroupBy(p => p.PokemonId);
             foreach (var g in grouped)
             {
-                if(g.Count() > 5)
+                if (g.Count() > 5)
                 {
                     //caculate distance to betweek pokemon
                 }
@@ -408,7 +431,7 @@ public static DateTime UnixTimeStampToDateTime(double unixTimeStamp)
             dtDateTime = dtDateTime.AddSeconds(unixTimeStamp).ToLocalTime();
             return dtDateTime;
         }
-       
+
         public static Task PriorityPokemon(ISession session, string id)
         {
             return Task.Run(() =>
@@ -454,9 +477,9 @@ public static void UpdateCatchPokemon(double latitude, double longitude, Pokemon
             bool exist = false;
             rarePokemons.ForEach((p) =>
             {
-            if (LocationUtils.CalculateDistanceInMeters(latitude, longitude, p.Latitude, p.Longitude) <30.0 &&
-                    p.PokemonId == id &&
-                    !p.IsVisited)
+                if (LocationUtils.CalculateDistanceInMeters(latitude, longitude, p.Latitude, p.Longitude) < 30.0 &&
+                        p.PokemonId == id &&
+                        !p.IsVisited)
                 {
                     p.IsVisited = true;
                     exist = true;
@@ -474,7 +497,7 @@ public static void UpdateCatchPokemon(double latitude, double longitude, Pokemon
 
             //in some case, we caught the pokemon before data refresh, we need add a fake pokemon to list to avoid it add back and waste time 
 
-            if(!exist && pokemonToBeSnipedIds.Any(p => p == id))
+            if (!exist && pokemonToBeSnipedIds.Any(p => p == id))
             {
                 rarePokemons.Add(new SnipePokemonInfo()
                 {
diff --git a/PoGo.NecroBot.Logic/Tasks/RecycleItemsTask.cs b/PoGo.NecroBot.Logic/Tasks/RecycleItemsTask.cs
index ef81a7998..7b0654e4e 100644
--- a/PoGo.NecroBot.Logic/Tasks/RecycleItemsTask.cs
+++ b/PoGo.NecroBot.Logic/Tasks/RecycleItemsTask.cs
@@ -111,12 +111,16 @@ await session.Inventory.GetItemAmountByType(ItemId.ItemIncenseCool) +
             await session.Inventory.RefreshCachedInventory();
         }
 
-        private static async Task RecycleItems(ISession session, CancellationToken cancellationToken, int itemCount, ItemId item)
+        private static async Task RecycleItems(ISession session, CancellationToken cancellationToken, int itemCount, ItemId item, int maxItemToKeep=1000)
         {
             int itemsToRecycle = 0;
             int itemsToKeep = itemCount - _diff;
             if (itemsToKeep < 0)
                 itemsToKeep = 0;
+
+            if(maxItemToKeep>0) {
+                itemsToKeep = Math.Min(itemsToKeep, maxItemToKeep);
+            }
             itemsToRecycle = itemCount - itemsToKeep;
             if (itemsToRecycle != 0)
             {
@@ -151,7 +155,7 @@ private static async Task OptimizedRecycleBalls(ISession session, CancellationTo
                 
                 if (_diff > 0)
                 {
-                    await RecycleItems(session, cancellationToken, pokeBallsCount, ItemId.ItemPokeBall);
+                    await RecycleItems(session, cancellationToken, pokeBallsCount, ItemId.ItemPokeBall, session.LogicSettings.MaxPokeballsToKeep);
                 }
                 if (_diff > 0)
                 {
diff --git a/PoGo.NecroBot.Logic/Tasks/SnipePokemonTask.cs b/PoGo.NecroBot.Logic/Tasks/SnipePokemonTask.cs
index 27003e548..cf8a40797 100644
--- a/PoGo.NecroBot.Logic/Tasks/SnipePokemonTask.cs
+++ b/PoGo.NecroBot.Logic/Tasks/SnipePokemonTask.cs
@@ -212,7 +212,7 @@ private static bool CheckSnipeConditions(ISession session)
 
         public static async Task Execute(ISession session, CancellationToken cancellationToken)
         {
-            if (_lastSnipe.AddMilliseconds(session.LogicSettings.MinDelayBetweenSnipes) > DateTime.Now)
+            if (_lastSnipe.AddMilliseconds(session.LogicSettings.MinDelayBetweenSnipes) > DateTime.Now || !session.LogicSettings.UseSnipeLocationServer)
                 return;
 
             LocsVisited.RemoveAll(q => DateTime.Now > q.TimeStampAdded.AddMinutes(15));
@@ -917,6 +917,7 @@ public static async Task Start(Session session, CancellationToken cancellationTo
                             SnipeLocations.RemoveAll(x => _lastSnipe > x.TimeStampAdded);
                             SnipeLocations.RemoveAll(x => DateTime.Now > x.TimeStampAdded.AddMinutes(15));
                             SnipeLocations.Add(info);
+                            session.EventDispatcher.Send(new SnipePokemonFoundEvent() { PokemonFound = info });
                         }
                         catch (System.IO.IOException)
                         {