diff --git a/KLHZ.Trader.Core.Math/Declisions/Services/Cache/PriceHistoryCacheUnit2.cs b/KLHZ.Trader.Core.Math/Declisions/Services/Cache/PriceHistoryCacheUnit2.cs
index f1af6fe..5578ad5 100644
--- a/KLHZ.Trader.Core.Math/Declisions/Services/Cache/PriceHistoryCacheUnit2.cs
+++ b/KLHZ.Trader.Core.Math/Declisions/Services/Cache/PriceHistoryCacheUnit2.cs
@@ -5,8 +5,8 @@ namespace KLHZ.Trader.Core.Math.Declisions.Services.Cache
 {
     public class PriceHistoryCacheUnit2 : IPriceHistoryCacheUnit
     {
-        public const int CacheMaxLength = 500;
-        private const int _arrayMaxLength = 1500;
+        public const int CacheMaxLength = 1500;
+        private const int _arrayMaxLength = 5000;
 
         public string Figi { get; init; }
 
diff --git a/KLHZ.Trader.Core/Exchange/Services/Trader.cs b/KLHZ.Trader.Core/Exchange/Services/Trader.cs
index afbf2f4..36a0f9e 100644
--- a/KLHZ.Trader.Core/Exchange/Services/Trader.cs
+++ b/KLHZ.Trader.Core/Exchange/Services/Trader.cs
@@ -95,7 +95,7 @@ namespace KLHZ.Trader.Core.Exchange.Services
                         await ProcessDeferredLongCloses(message, currentTime);
                         if (message.Figi == "FUTIMOEXF000")
                         {
-                            var windowMaxSize = 100;
+                            var windowMaxSize = 1000;
 
                             var data = await _tradeDataProvider.GetData(message.Figi, windowMaxSize);
                             var state = ExchangeScheduler.GetCurrentState(message.Time);
@@ -182,26 +182,80 @@ namespace KLHZ.Trader.Core.Exchange.Services
 
                     if (max - min < 15 && fullData.prices.Last() - fullData.prices.First() < 4)
                     {
-                        var trade = new DeferredTrade()
+                        if (!message.IsHistoricalData && BotModeSwitcher.CanPurchase())
                         {
-                            Figi = message.Figi,
-                            Price = message.Value,
-                            Time = message.Time.AddSeconds(15)
-                        };
-                        DeferredLongOpens[message.Figi] = trade;
+                            var accounts = _tradeDataProvider.Accounts
+                                .Where(a => !a.Value.Assets.ContainsKey(message.Figi))
+                                .ToArray();
+                            foreach (var acc in accounts)
+                            {
+                                if (IsBuyAllowed(acc.Value, message.Value, 1, _accountCashPartFutures, _accountCashPart))
+                                {
+                                    if (RandomNumberGenerator.GetInt32(100) > 50)
+                                    {
+                                        await _dataBus.Broadcast(new TradeCommand()
+                                        {
+                                            AccountId = acc.Value.AccountId,
+                                            Figi = message.Figi,
+                                            CommandType = Contracts.Messaging.Dtos.Enums.TradeCommandType.MarketBuy,
+                                            Count = 1,
+                                            RecomendPrice = null,
+                                        });
+                                    }
+
+                                    await LogDeclision(DeclisionTradeAction.OpenLong, message);
+                                }
+                            }
+                        }
+                        else
+                        {
+                            await LogDeclision(DeclisionTradeAction.OpenLong, message);
+                        }
                     }
                 }
             }
 
             if ((res & TradingEvent.UptrendEnd) == TradingEvent.UptrendEnd)
             {
-                var trade = new DeferredTrade()
+                var assetType = _tradeDataProvider.GetAssetTypeByFigi(message.Figi);
+                if (!message.IsHistoricalData && BotModeSwitcher.CanSell())
                 {
-                    Figi = message.Figi,
-                    Price = message.Value,
-                    Time = message.Time.AddSeconds(15)
-                };
-                DeferredLongCloses[message.Figi] = trade;
+                    var assetsForClose = _tradeDataProvider.Accounts
+                        .SelectMany(a => a.Value.Assets.Values)
+                        .Where(a => a.Figi == message.Figi && a.Count > 0)
+                        .ToArray();
+                    foreach (var asset in assetsForClose)
+                    {
+                        var profit = 0m;
+
+                        if (assetType == AssetType.Common && asset.Count > 0)
+                        {
+                            profit = TradingCalculator.CaclProfit(asset.BoughtPrice, message.Value,
+                                GetComission(assetType), 1, false);
+                        }
+                        if (assetType == AssetType.Futures)
+                        {
+                            profit = TradingCalculator.CaclProfit(asset.BoughtPrice, message.Value,
+                                GetComission(assetType), GetLeverage(message.Figi, asset.Count < 0), asset.Count < 0);
+                        }
+                        if (profit > 0)
+                        {
+                            await _dataBus.Broadcast(new TradeCommand()
+                            {
+                                AccountId = asset.AccountId,
+                                Figi = message.Figi,
+                                CommandType = Contracts.Messaging.Dtos.Enums.TradeCommandType.MarketSell,
+                                Count = (long)asset.Count,
+                                RecomendPrice = null,
+                            });
+                            await LogDeclision(DeclisionTradeAction.CloseLong, message, profit);
+                        }
+                    }
+                }
+                else
+                {
+                    await LogDeclision(DeclisionTradeAction.CloseLong, message);
+                }
             }
         }
 
diff --git a/KLHZ.Trader.Core/Exchange/Services/TraderDataProvider.cs b/KLHZ.Trader.Core/Exchange/Services/TraderDataProvider.cs
index b383fd9..9a8cb14 100644
--- a/KLHZ.Trader.Core/Exchange/Services/TraderDataProvider.cs
+++ b/KLHZ.Trader.Core/Exchange/Services/TraderDataProvider.cs
@@ -392,7 +392,7 @@ namespace KLHZ.Trader.Core.Exchange.Services
                     {
                         buffer2.Add(dec);
                     }
-                    if ((buffer1.Count + buffer2.Count) > 10000 || _forSave.Reader.Count == 0)
+                    if ((buffer1.Count + buffer2.Count) > 50000 || _forSave.Reader.Count == 0)
                     {
                         using var context = await _dbContextFactory.CreateDbContextAsync();
                         context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
diff --git a/KLHZ.Trader.Service/Controllers/PlayController.cs b/KLHZ.Trader.Service/Controllers/PlayController.cs
index c371c56..f5028b2 100644
--- a/KLHZ.Trader.Service/Controllers/PlayController.cs
+++ b/KLHZ.Trader.Service/Controllers/PlayController.cs
@@ -1,6 +1,7 @@
 using KLHZ.Trader.Core.Contracts.Messaging.Dtos;
 using KLHZ.Trader.Core.Contracts.Messaging.Interfaces;
 using KLHZ.Trader.Core.DataLayer;
+using KLHZ.Trader.Core.DataLayer.Entities.Prices;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 
@@ -24,7 +25,7 @@ namespace KLHZ.Trader.Service.Controllers
         {
             try
             {
-                var time = DateTime.UtcNow.AddHours(-4);
+                var time = DateTime.UtcNow.AddDays(-40);
                 using var context1 = await _dbContextFactory.CreateDbContextAsync();
                 context1.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
                 var data = await context1.PriceChanges
@@ -50,5 +51,34 @@ namespace KLHZ.Trader.Service.Controllers
 
             }
         }
+
+        [HttpGet]
+        public async Task LoadTradesToHistory(string figi)
+        {
+            try
+            {
+                using var context1 = await _dbContextFactory.CreateDbContextAsync();
+                context1.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
+                var data = await context1.InstrumentTrades
+                    .Where(c => c.Figi == figi)
+                    .OrderBy(c => c.BoughtAt)
+                    .Select(c => new PriceChange()
+                    {
+                        Figi = figi,
+                        Ticker = c.Ticker,
+                        Time = c.BoughtAt,
+                        Value = c.Price,
+                        IsHistoricalData = true
+                    })
+                    .ToArrayAsync();
+                await context1.PriceChanges.Where(p => p.Figi == figi).ExecuteDeleteAsync();
+                await context1.PriceChanges.AddRangeAsync(data);
+                await context1.SaveChangesAsync();
+            }
+            catch (Exception ex)
+            {
+
+            }
+        }
     }
 }