diff --git a/hts/BuySellChecker.py b/hts/BuySellChecker.py
index 1429df2..f0159f4 100644
--- a/hts/BuySellChecker.py
+++ b/hts/BuySellChecker.py
@@ -1,4 +1,5 @@
 import math
+from datetime import datetime
 import pandas as pd
 from stockpredictor.analysis.Common import Common
 from stockpredictor.analysis.Stochastic import Stochastic
@@ -25,7 +26,13 @@ class BuySellChecker:
     def getPriceAndWeight1(self, data, i):
         buy, weight, sell = -1, -1, -1
 
-        if i >= 3:
+        START_TIME_INDEX = 0
+        for c in range(370, len(data.index)):
+            if data.index[c].strftime("%H:%M:%S") == "09:01:00":
+                START_TIME_INDEX = c
+                break
+
+        if i >= START_TIME_INDEX:
             ################
             ### sell 분석 ###
             ################
@@ -78,89 +85,165 @@ class BuySellChecker:
     def getPriceAndWeight2(self, data, i):
         buy, weight, sell = -1, -1, -1
 
-        ################
-        ### sell 분석 ###
-        ################
-        # 1. 볼린져밴드 상단이 최고와 종가 사이 아래에 있는 경우 매도한다.
-        if (data["high"][i] - data["close"][i]) / 2 + data["close"][i] > data["upper"][i]:
-            sell = data["high"][i]
+        START_TIME_INDEX = 0
+        for c in range(370, len(data.index)):
+            if data.index[c].strftime("%H:%M:%S") == "09:01:00":
+                START_TIME_INDEX = c
+                break
 
-        if data["slow_k"][i] >= 85:
-            if data["slow_d"][i - 1] < data["slow_k"][i - 1] and data["slow_k"][i] < data["slow_d"][i]:
+        if i >= START_TIME_INDEX:
+            ################
+            ### sell 분석 ###
+            ################
+            # 1. 볼린져밴드 상단이 최고와 종가 사이 아래에 있는 경우 매도한다.
+            if (data["high"][i] - data["close"][i]) / 2 + data["close"][i] > data["upper"][i]:
                 sell = data["high"][i]
 
-        # 3. 2시 이후에는 최고가가 볼린져밴드 상단 위에 있으면 매도한다.
-        if i > 300 and data["high"][i] > data["upper"][i]:
-            sell = data["high"][i]
+            if data["slow_k"][i] >= 85:
+                if data["slow_d"][i - 1] < data["slow_k"][i - 1] and data["slow_k"][i] < data["slow_d"][i]:
+                    sell = data["high"][i]
 
-        ##########################
-        ### STOCHASTIC buy 분석 ###
-        ##########################
-        if i < 40:
-            pre_slow = data["slow_k"][i - 1] / data["slow_d"][i - 1] - 1
-            now_slow = data["slow_k"][i] / data["slow_d"][i] - 1
-            if pre_slow < 0 and 0 < now_slow:
-                if data["slow_k"][i] <= 35:
-                    if (data["close"][i] - data["lower"][i]) / (data["upper"][i] - data["lower"][i]) < 0.35:
-                        if data["slow_k"][i - 1] < data["slow_d"][i - 1] and data["slow_d"][i] < data["slow_k"][i]:
-                            if  data['avg10'][i] < data['avg5'][i]:
-                                if data["open"][i] < data["close"][i]:
-                                    buy = data["close"][i]
-                                else:
-                                    buy = data["low"][i]
-        else:
-            pre_slow = data["slow_k"][i - 1] / data["slow_d"][i - 1] - 1
-            now_slow = data["slow_k"][i] / data["slow_d"][i] - 1
-            if pre_slow < 0 and pre_slow < now_slow and -0.15 < now_slow:
-                if data["slow_k"][i] <= 30:
-                    if (data["close"][i] - data["lower"][i]) / (data["upper"][i] - data["lower"][i]) < 0.35:
-                        if data["slow_k"][i - 1] < data["slow_d"][i - 1] and data["slow_d"][i] < data["slow_k"][i]:
-                            if  data['avg10'][i] < data['avg5'][i]:
-                                if data["close"][i] < data["avg5"][i]:
-                                    buy = data["close"][i]
-                                else:
-                                    buy = data["low"][i]
+            # 3. 2시 이후에는 최고가가 볼린져밴드 상단 위에 있으면 매도한다.
+            if i > 300 and data["high"][i] > data["upper"][i]:
+                sell = data["high"][i]
 
-        #############################
-        ### STOCHASTIC weight 분석 ###
-        #############################
-        if data["slow_k"][i] in (0, 1, 2, 3):
-            weight = 1
-        if data["slow_k"][i] in (4, 5, 6, 7, 8):
-            weight = 1
-        elif data["slow_k"][i] in (9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20):
-            weight = 1
-        elif data["slow_k"][i] in (21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35):
-            weight = 1
+            ##########################
+            ### STOCHASTIC buy 분석 ###
+            ##########################
+            if i < 40:
+                pre_slow = data["slow_k"][i - 1] / data["slow_d"][i - 1] - 1
+                now_slow = data["slow_k"][i] / data["slow_d"][i] - 1
+                if pre_slow < 0 and 0 < now_slow:
+                    if data["slow_k"][i] <= 35:
+                        if (data["close"][i] - data["lower"][i]) / (data["upper"][i] - data["lower"][i]) < 0.35:
+                            if data["slow_k"][i - 1] < data["slow_d"][i - 1] and data["slow_d"][i] < data["slow_k"][i]:
+                                if  data['avg10'][i] < data['avg5'][i]:
+                                    if data["open"][i] < data["close"][i]:
+                                        buy = data["close"][i]
+                                    else:
+                                        buy = data["low"][i]
+            else:
+                pre_slow = data["slow_k"][i - 1] / data["slow_d"][i - 1] - 1
+                now_slow = data["slow_k"][i] / data["slow_d"][i] - 1
+                if pre_slow < 0 and pre_slow < now_slow and -0.15 < now_slow:
+                    if data["slow_k"][i] <= 30:
+                        if (data["close"][i] - data["lower"][i]) / (data["upper"][i] - data["lower"][i]) < 0.35:
+                            if data["slow_k"][i - 1] < data["slow_d"][i - 1] and data["slow_d"][i] < data["slow_k"][i]:
+                                if  data['avg10'][i] < data['avg5'][i]:
+                                    if data["close"][i] < data["avg5"][i]:
+                                        buy = data["close"][i]
+                                    else:
+                                        buy = data["low"][i]
+
+            #############################
+            ### STOCHASTIC weight 분석 ###
+            #############################
+            if data["slow_k"][i] in (0, 1, 2, 3):
+                weight = 1
+            if data["slow_k"][i] in (4, 5, 6, 7, 8):
+                weight = 1
+            elif data["slow_k"][i] in (9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20):
+                weight = 1
+            elif data["slow_k"][i] in (21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35):
+                weight = 1
 
         return buy, weight, sell
 
-    # 곱버스에 해당함
-    def getPriceAndWeight3(self, data, i):
-        buy, weight, sell = -1, -1, -1
+    def getBuyCheck(self, data, i, buy, weight):
+        if data['close'][i]<data['avg3'][i]<data['avg5'][i]<data['avg10'][i]<data['avg20'][i]<data['avg30'][i]:
+            buy, weight, sell = -1, -1, -1
+        return buy, weight
 
-        # 381: 어제 날짜 데이터 개수
-        if i >= 381:
+    # 곱버스에 해당함
+    def getBuyPriceAndWeight1(self, data, i):
+        buy, weight = -1, -1
+
+        START_TIME_INDEX = 0
+        for c in range(370, len(data.index)):
+            if data.index[c].strftime("%H:%M:%S") == "09:01:00":
+                START_TIME_INDEX = c
+                break
+
+        if i >= START_TIME_INDEX:
             # 매수 분석
 
+            # 장 초기 (시작 3분 이내) 양봉 2개에 3분차에 장대 양봉이면 매수.
+            if i < 381 + 4:
+                if data["open"][i] == data["low"][i] and data["close"][i] == data["high"][i]:
+                    if  data["close"][i-2] <= data["open"][i-1]:
+                        if data["open"][i-2] < data["close"][i-2] and data["open"][i-1] < data["close"][i-1]:
+                            buy = data["high"][i]
+                            weight = 1
+                            return self.getBuyCheck(data, i, buy, weight)
+
+            # 장 초기 (시작 7분 이내), 볼린져 하단에서 시작하여 이병선을 모두 상승하여 마감한 경우 low 값에서 매수한다.
+            if i < 381 + 8:
+                if data["open"][i] == data["low"][i] and data["close"][i] == data["high"][i]:
+                    if data["close"][i] > max(data["avg3"][i], data["avg5"][i], data["avg10"][i], data["avg20"][i], data["avg30"][i]):
+                        buy = data["low"][i]
+                        weight = 5
+                        return self.getBuyCheck(data, i, buy, weight)
+
+            # 만약 30원 이상 장대 양봉이 나온 경우, 다음이나 다다음 중간 값에서 매수를 한다.
+            if (data["close"][i] - data["low"][i]) >= 30:
+                middle = int((data["close"][i] + data["low"][i])/2)
+                buy = middle
+                weight = 1
+                return self.getBuyCheck(data, i, buy, weight)
+
+
+            # 이동선을 이용한 매매
+            # 3분선과 10분선이 30분 이상 내려오다가 3분선이 10분선을 넘어 서는 순간 매수
+            if int(data["avg3"][i]) > int(data["avg10"][i]):
+                valid = True
+                same_count = 0
+                for c in range(1, 30):
+                    if int(data["avg3"][i-c]) == int(data["avg10"][i-c]):
+                        same_count += 1
+                    if int(data["avg3"][i-c]) > int(data["avg10"][i-c]):
+                        valid = False
+                        break
+                if valid and same_count < 2:
+                    buy = data["close"][i] - 5
+                    weight = 1
+                    return self.getBuyCheck(data, i, buy, weight)
+
 
             # 이동선을 이용한 매매
             # 3분선과 5분선이 10분 이상 내려오다가 3분선이 5분선을 넘어 서는 순간 매수
             if int(data["avg3"][i]) > int(data["avg5"][i]):
                 valid = True
                 same_count = 0
-                for c in range(1, 10):
+                for c in range(1, 11):
                     if int(data["avg3"][i-c]) == int(data["avg5"][i-c]):
                         same_count += 1
                     if int(data["avg3"][i-c]) > int(data["avg5"][i-c]):
                         valid = False
                         break
-                    if int(data["avg3"][i-c]) > int(data["avg3"][i-c-1]) or int(data["avg5"][i-c]) > int(data["avg5"][i-c-1]):
-                        valid = False
-                        break
-                if valid and same_count < 3:
-                    buy = data["close"][i] - 5
-                    weight = 3
+                if valid and same_count < 2:
+                    if data['macd'][i] < -5:
+                        buy = data["close"][i] - 5
+                        weight = 1
+                        return self.getBuyCheck(data, i, buy, weight)
+
+            # 다이버젼스
+            # slow_k가 20 이하에서 이전 최저점의 slow_k보다 지금 최저점의 slow_k가 더 높은 경우
+            if data["slow_k"][i] < 20:
+                if data["close"][i] > data["close"][i - 1]:
+                    p_slow_k = 100
+                    p_close = 0
+                    top = False
+                    for c in range(1, 60):
+                        if not top and data["close"][i-c] > min(data["open"][i-c], data["close"][i-c]):
+                            top = True
+                        if top and data["close"][i-c] > min(data["open"][i-c], data["close"][i-c]):
+                            p_slow_k = data["slow_k"][i-c]
+                            p_close = data["close"][i-c]
+                            break
+                    if data["close"][i] < p_close and data["slow_k"][i] > p_slow_k:
+                        buy = data["close"][i]
+                        weight = 1
+                        return self.getBuyCheck(data, i, buy, weight)
 
 
             # 이동선을 이용한 매매
@@ -196,67 +279,300 @@ class BuySellChecker:
                         if data['avg3'][i-index1-1] < data['avg10'][i-index1-1]:
                             if data["slow_k"][i] < 40:
                                 buy = data["close"][i]
-                                weight = 3
-
-            # 만약 30원 이상 장대 양봉이 나온 경우, 다음이나 다다음 중간 값에서 매수를 한다.
-            if (data["close"][i] - data["low"][i]) >= 30:
-                middle = int((data["close"][i] + data["low"][i])/2)
-                buy = middle
+                                weight = 5
+                                return self.getBuyCheck(data, i, buy, weight)
 
 
-            # 장 초기 (시작 7분 이내), 볼린져 하단에서 시작하여 이병선을 모두 상승하여 마감한 경우 low 값에서 매수한다.
-            if i < 381 + 8:
-                if data["open"][i] == data["low"][i]:
-                    if data["close"][i] > max(data["avg3"][i], data["avg5"][i], data["avg10"][i], data["avg20"][i], data["avg30"][i]):
-                        buy = data["low"][i]
-
-            """
-            ## macd를 이용한 매매
-            #if data["macdo"][i] < 0 and data["macd"][i] < -5:
-            #    if data["macd"][i-3] > data["macd"][i-2] and data["macd"][i-2] > data["macd"][i-1] and data["macd"][i-1] < data["macd"][i]:
-            #        buy = data["close"][i] - 5
-            """
-            # 표준편차를 이용한 매매
-            """
-            #mean = (data["avg3"][i] + data["avg5"][i] + data["avg10"][i] + data["avg20"][i] + data["avg30"][i])/5
-            #vsum = (data["avg3"][i] - mean) ** 2 + (data["avg5"][i] - mean) ** 2 + (data["avg10"][i] - mean) ** 2 + (data["avg20"][i] - mean) ** 2 + (data["avg30"][i] - mean) ** 2
-            #variance = vsum / 5
-            #std = math.sqrt(variance)
-            #if std < 1:
-            #    sell = data["close"][i] - 5
-            """
-
-            """
-            # 매도 분석
-            # 3일 선이 10분 전부터 게속 10분선 위에 있다가 아래로 내려오면 매도함
-            valid = False
-            if data["avg3"][i] < data["avg5"][i]:
-                if (data["avg3"][i-1] > data["avg5"][i-1] and data["avg3"][i-2] > data["avg5"][i-2] and
-                    data["avg3"][i-3] > data["avg5"][i-3] and data["avg3"][i-4] > data["avg5"][i-4] and
-                    data["avg3"][i-5] > data["avg5"][i-5] and data["avg3"][i-6] > data["avg5"][i-6] and
-                    data["avg3"][i-7] > data["avg5"][i-7] and data["avg3"][i-8] > data["avg5"][i-8] and
-                    data["avg3"][i-9] > data["avg5"][i-8] and data["avg3"][i-10] > data["avg5"][i-10]):
+            # 10분 이상 10분 선 아래 3분선이 있다가 10분선 위로 올라 올때 장대장봉임
+            # 해당 기간 clsoe 값이 10분 선 아래 있을 때,
+            if data["avg10"][i] < data["avg3"][i] and data["low"][i] == data["open"][i] < data["close"][i] == data["high"][i]:
+                if (data["avg3"][i-1] <= data["avg10"][i-1]) and ((data["avg10"][i-1] and data["avg3"][i-1]) < data["close"][i-1]):
                     valid = True
-            if valid:
-                sell = data["close"][i]
-            """
+                    for c in range(2, 11):
+                        if data["avg10"][i-c] < data["avg3"][i-c] or data["avg10"][i-c] < data["close"][i-c]:
+                            valid = False
+                            break
+                    if valid:
+                        buy = int((data["open"][i] + data["close"][i])/2)
+                        weight = 1
+                        return self.getBuyCheck(data, i, buy, weight)
+
+
+            # 이동선을 이용한 매매
+            # 20분선이 30분선에 돌파 후 지지하는지 확인하고 해당 시점이 양봉이면 매수함
+            if data['avg20'][i] > data['avg30'][i]:
+                diff1 = data['avg20'][i] - data['avg30'][i]
+                diff2 = data['avg20'][i-1] - data['avg30'][i-1]
+                diff3 = data['avg20'][i-2] - data['avg30'][i-2]
+                diff4 = data['avg20'][i-3] - data['avg30'][i-3]
+                diff5 = data['avg20'][i-4] - data['avg30'][i-4]
+                if 0 < diff3 < diff2 < diff1:
+                    if data['high'][i-2] <= data['high'][i-1] <= data['high'][i]:
+                        if data['open'][i - 2] <= data['close'][i - 2] and data['open'][i-1] <= data['close'][i-1] and data['open'][i] <= data['close'][i]:
+                            if diff5 < diff4 < 0:
+                                if data["rsi"][i] < 30:
+                                    buy = (data["open"][i]+data["close"][i])/2
+                                    weight = 2
+                                    return self.getBuyCheck(data, i, buy, weight)
+
+
+            # macd를 이용한 매수
+            if data.index[i].strftime("%H:%M") < "10:00":
+                if data["macd"][i] < -15 and data["macd"][i-1] < min(data["macd"][i-7], data["macd"][i-6], data["macd"][i-5], data["macd"][i-4], data["macd"][i-3], data["macd"][i-2], data["macd"][i]):
+                        buy = (data["open"][i]+data["close"][i])/2
+                        weight = 1
+                        return buy, weight
+
+            # slow_k를 이용한 매수
+            if data.index[i].strftime("%H:%M") < "09:20":
+                if data["slow_k"][i] < 10 and data["slow_k"][i-1] < min(data["slow_k"][i-4], data["slow_k"][i-3], data["slow_k"][i-2], data["slow_k"][i]):
+                        buy = (data["open"][i]+data["close"][i])/2
+                        weight = 1
+                        return buy, weight
+            else:
+                if data["slow_k"][i] < 10 and data["slow_k"][i-1] < min(data["slow_k"][i-7], data["slow_k"][i-6], data["slow_k"][i-5], data["slow_k"][i-4], data["slow_k"][i-3], data["slow_k"][i-2], data["slow_k"][i]):
+                        buy = (data["open"][i]+data["close"][i])/2
+                        weight = 1
+                        return self.getBuyCheck(data, i, buy, weight)
+
+            # 볼린저 밴드가 하락에서 상승으로 전환할 때,
+            # 지금 양봉 close가 upper를 돌파했다. (이전 거래량 보다 많음)
+            # 20분 이내로 양봉 close가 upper를 돌파 한 것이 있어야 한다.
+            # 지금 양봉의 close가 이전 양봉의 close보다 높아야 한다.
+            # 이 사이에 종가가 20분봉 위에 있어야 한다.
+            if data.index[i].strftime("%H:%M") > "09:15":
+                if (data['open'][i] < data['close'][i]==data['high'][i]) and (data['upper'][i] < data['close'][i]) and (data['volume'][i-1] < data['volume'][i]):
+                    if data['open'][i-1] < data['close'][i-1] and data['open'][i-2] < data['close'][i-2]:
+                        if data['close'][i-1] < data['upper'][i-1] and data['close'][i-2] < data['upper'][i-2] and data['close'][i-2] < data['upper'][i-2]:
+                            index = -1
+                            for c in range(6, 21):
+                                if data['open'][i-c] < data['close'][i-c] and data['upper'][i-c] < data['close'][i-c]:
+                                    index = c
+                                    break
+                            if index != -1:
+                                valid = True
+                                for c in range(2, index+1):
+                                    if data['open'][i-c] < data['avg20'][i-c] and data['close'][i-c] < data['avg20'][i-c]:
+                                        valid = False
+                                        break
+                                if valid:
+                                    buy = data["close"][i]
+                                    weight = 2
+                                    return self.getBuyCheck(data, i, buy, weight)
+
+        return buy, weight
+
+
+    def getSellPriceAndWeight1(self, data, i):
+        sell, weight = -1, -1
+
+        START_TIME_INDEX = 0
+        for c in range(370, len(data.index)):
+            if data.index[c].strftime("%H:%M:%S") == "09:01:00":
+                START_TIME_INDEX = c
+                break
+
+        if i >= START_TIME_INDEX:
+            # 매도 분석
+
+            # 3분 선이 40분 전부터 게속 20분선 위에 있다가 아래로 내려오면 매도함
+            if data["avg3"][i] < data["avg20"][i]:
+                valid = True
+                for c in range(1, 41):
+                    if data["avg3"][i-c] < data["avg20"][i-c]:
+                        valid = False
+                        break
+                if valid:
+                    sell = int((data["open"][i] + data["close"][i])/2)
+                    return sell, weight
+
+            # 3분 선이 60분 전부터 게속 30분선 위에 있다가 아래로 내려오면 매도함
+            if data["avg3"][i] < data["avg30"][i]:
+                valid = True
+                for c in range(1, 61):
+                    if data["avg3"][i-c] < data["avg30"][i-c]:
+                        valid = False
+                        break
+                if valid:
+                    sell = int((data["open"][i] + data["close"][i])/2)
+                    return sell, weight
+
+            # 5분 선이 20분 전부터 게속 10분선 위에 있다가 아래로 내려오면 매도함
+            if data["avg5"][i] < data["avg10"][i]:
+                valid = True
+                for c in range(1, 21):
+                    if data["avg5"][i-c] < data["avg10"][i-c]:
+                        valid = False
+                        break
+                if valid:
+                    sell = int((data["open"][i] + data["close"][i])/2)
+                    return sell, weight
+
+
+            # rsi와 rsis가 75이상에서 slow_k가 slow_d 아래롸 내려온 경우
+            if data["rsi"][i] >= 70 and data["rsis"][i] >= 70:
+                if data["rsi"][i-1] > data["rsis"][i-1] and data["rsi"][i] < data["rsis"][i]:
+                    sell = int((data["open"][i] + data["close"][i]) / 2)
+                    return sell, weight
 
             # slow_k와 slow_d가 90이상에서 slow_k가 slow_d 아래롸 내려온 경우
-            if data["rsi"][i] >= 75 and data["rsis"][i] >= 75:
+            if data["slow_k"][i] >= 90 and data["slow_d"][i] >= 90:
+                if data["slow_k"][i-1] > data["slow_d"][i-1] and data["slow_k"][i] < data["slow_d"][i]:
+                    sell = int((data["open"][i] + data["close"][i]) / 2)
+
+                    if data.index[i].strftime("%H:%M") < "12:00" and data['rsis'][i] < 70:
+                        return -1, -1
+
+                    return sell, weight
+
+        return sell, weight
+
+
+
+
+    # 레버리지에 해당함
+    def getBuyPriceAndWeight2(self, data, i):
+        buy, weight = -1, -1
+
+        START_TIME_INDEX = 0
+        for c in range(370, len(data.index)):
+            if data.index[c].strftime("%H:%M:%S") == "09:01:00":
+                START_TIME_INDEX = c
+                break
+
+        if i >= START_TIME_INDEX:
+            # 매수 분석
+
+            # 이동선을 이용한 매매
+            # 3분선과 10분선이 20분 이상 내려오다가 3분선이 10분선을 넘어 서는 순간 매수
+            if int(data["avg3"][i]) > int(data["avg10"][i]):
+                if data["slow_k"][i] < 10:
+                    valid = True
+                    same_count = 0
+                    for c in range(1, 21):
+                        if int(data["avg3"][i-c]) == int(data["avg10"][i-c]):
+                            same_count += 1
+                        if int(data["avg3"][i-c]) > int(data["avg10"][i-c]):
+                            valid = False
+                            break
+                    if valid and same_count < 2:
+                        buy = data["close"][i] - 5
+                        weight = 1
+                        return self.getBuyCheck(data, i, buy, weight)
+
+            # slow_k를 이용한 매수
+            if data["slow_k"][i-2] < 5 and data["slow_k"][i-1] < 5 and data["slow_k"][i] < 7:
+                if data["slow_k"][i-2] < data["slow_k"][i] < data["slow_k"][i-1]:
+                    buy = (data["open"][i]+data["close"][i])/2
+                    weight = 1
+                    return buy, weight
+
+
+            # macd를 이용한 매수
+            if data["macd"][i-2] < -45 and data["macd"][i-1] < -45 and data["macd"][i] < -45:
+                if data["macd"][i-1] < min (data["macd"][i-2], data["macd"][i]):
+                    buy = (data["open"][i]+data["close"][i])/2
+                    weight = 1
+                    return self.getBuyCheck(data, i, buy, weight)
+
+
+            # slow_k를 이용한 매수
+            if data["slow_k"][i-2] < 15 and data["slow_k"][i-1] < 12 and data["slow_k"][i] < 12:
+                if data["slow_k"][i-2] < data["slow_k"][i] < data["slow_k"][i-1]:
+                    if data["macd"][i - 1] < -25:
+                        buy = (data["open"][i]+data["close"][i])/2
+                        weight = 1
+                        return self.getBuyCheck(data, i, buy, weight)
+
+
+
+        return buy, weight
+
+
+    def getSellPriceAndWeight2(self, data, i):
+        sell, weight = -1, -1
+
+        START_TIME_INDEX = 0
+        for c in range(370, len(data.index)):
+            if data.index[c].strftime("%H:%M:%S") == "09:01:00":
+                START_TIME_INDEX = c
+                break
+
+        if i >= START_TIME_INDEX:
+            # 매도 분석
+
+            #4분전에 upper 돌파 후 4음봉이면 매도
+            if data["open"][i-3] > data["upper"][i-3]:
+                if data["open"][i - 2] > data["close"][i - 2]:
+                    if data["open"][i - 1] > data["close"][i - 1]:
+                        if data["open"][i] > data["close"][i]:
+                            sell = int((data["open"][i] + data["close"][i]) / 2)
+                            return sell, weight
+
+            if data.index[i].strftime("%H:%M") == "10:55":
+                print (1)
+            # 3분 선이 15분 전부터 게속 5분선 위에 있다가 아래로 내려오면 매도함
+            if data["avg3"][i] <= data["avg5"][i]:
+                valid = True
+                for c in range(1, 16):
+                    if data["avg3"][i-c] < data["avg5"][i-c] and abs(data["avg3"][i-c] - data["avg5"][i-c]) > 5:
+                        valid = False
+                        break
+                if valid:
+                    sell = int((data["open"][i] + data["close"][i])/2)
+                    return sell, weight
+
+            # 3분 선이 40분 전부터 게속 20분선 위에 있다가 아래로 내려오면 매도함
+            if data["avg3"][i] < data["avg20"][i]:
+                valid = True
+                for c in range(1, 41):
+                    if data["avg3"][i-c] < data["avg20"][i-c]:
+                        valid = False
+                        break
+                if valid:
+                    sell = int((data["open"][i] + data["close"][i])/2)
+                    return sell, weight
+
+            # 3분 선이 60분 전부터 게속 30분선 위에 있다가 아래로 내려오면 매도함
+            if data["avg3"][i] < data["avg30"][i]:
+                valid = True
+                for c in range(1, 61):
+                    if data["avg3"][i-c] < data["avg30"][i-c]:
+                        valid = False
+                        break
+                if valid:
+                    sell = int((data["open"][i] + data["close"][i])/2)
+                    return sell, weight
+
+            # 5분 선이 20분 전부터 게속 10분선 위에 있다가 아래로 내려오면 매도함
+            if data["avg5"][i] < data["avg10"][i]:
+                valid = True
+                for c in range(1, 21):
+                    if data["avg5"][i-c] < data["avg10"][i-c]:
+                        valid = False
+                        break
+                if valid:
+                    sell = int((data["open"][i] + data["close"][i])/2)
+                    return sell, weight
+
+
+            # rsi와 rsis가 75이상에서 slow_k가 slow_d 아래롸 내려온 경우
+            if data["rsi"][i] >= 70 and data["rsis"][i] >= 70:
                 if data["rsi"][i-1] > data["rsis"][i-1] and data["rsi"][i] < data["rsis"][i]:
-                    sell = data["close"][i] - 5
+                    sell = int((data["open"][i] + data["close"][i]) / 2)
+                    return sell, weight
 
+            # slow_k와 slow_d가 90이상에서 slow_k가 slow_d 아래롸 내려온 경우
+            if data["slow_k"][i] >= 90 and data["slow_d"][i] >= 90:
+                if data["slow_k"][i-1] > data["slow_d"][i-1] and data["slow_k"][i] < data["slow_d"][i]:
+                    sell = int((data["open"][i] + data["close"][i]) / 2)
 
-            #if data["slow_d"][i] > 90 and data["rsi"][i] > 65:
-            #    if data["upper"][i] <= data["high"][i]:
-            #        sell = data["close"][i] - 5
+                    if data.index[i].strftime("%H:%M") < "12:00" and data['rsis'][i] < 70:
+                        return -1, -1
 
-            #if data['avg3'][i-1] > data['avg10'][i-1] and data['avg3'][i] <= data['avg10'][i]:
-            #    if abs(data['avg3'][i - 1] - data['avg30'][i - 1]) > 10:
-            #        sell = data["close"][i]
-
-        return buy, weight, sell
+                    return sell, weight
 
+        return sell, weight
 
     def analyze(self, result):
         open = result["open"]
@@ -351,9 +667,11 @@ class BuySellChecker:
 
         for i in range(size):
             if stock_code == "252670":
-                buy, weight, sell = self.getPriceAndWeight3(data, i)
+                sell, weight = self.getSellPriceAndWeight1(data, i)
+                buy, weight = self.getBuyPriceAndWeight1(data, i)
             else:
-                buy, weight, sell = self.getPriceAndWeight4(data, i)
+                sell, weight = self.getSellPriceAndWeight2(data, i)
+                buy, weight = self.getBuyPriceAndWeight2(data, i)
 
             bsLine['buy'][i] = buy
             bsLine['weight'][i] = weight
diff --git a/hts/HTS_122630.py b/hts/HTS_122630.py
index 4d43b33..489d278 100644
--- a/hts/HTS_122630.py
+++ b/hts/HTS_122630.py
@@ -33,7 +33,9 @@ class HTS_122630 (HTS):
         bsLine['sell'] = [-1 for i in range(size)]
 
         last_index = size - 1
-        buy, weight, sell = self.buySellChecker.getPriceAndWeight3(data, last_index)
+        #buy, weight, sell = self.buySellChecker.getPriceAndWeight3(data, last_index)
+        sell, weight = self.buySellChecker.getSellPriceAndWeight1(data, last_index)
+        buy, weight = self.buySellChecker.getBuyPriceAndWeight1(data, last_index)
         return buy, weight, sell
 
     def getSellingPrice(self, final_price):
diff --git a/hts/HTS_252670.py b/hts/HTS_252670.py
index 6f77c4f..505b948 100644
--- a/hts/HTS_252670.py
+++ b/hts/HTS_252670.py
@@ -33,7 +33,9 @@ class HTS_252670 (HTS):
         bsLine['sell'] = [-1 for i in range(size)]
 
         last_index = size - 1
-        buy, weight, sell = self.buySellChecker.getPriceAndWeight3(data, last_index)
+        #buy, weight, sell = self.buySellChecker.getPriceAndWeight3(data, last_index)
+        sell, weight = self.buySellChecker.getSellPriceAndWeight1(data, last_index)
+        buy, weight = self.buySellChecker.getBuyPriceAndWeight1(data, last_index)
         return buy, weight, sell
 
     def getSellingPrice(self, final_price):
diff --git a/hts/Simulation.py b/hts/Simulation.py
index b2761a6..b57b563 100644
--- a/hts/Simulation.py
+++ b/hts/Simulation.py
@@ -1,5 +1,5 @@
 from math import nan
-from datetime import datetime, timedelta
+from datetime import datetime
 import csv
 import pandas as pd
 import plotly.graph_objects as go
@@ -93,11 +93,11 @@ class Simulation:
         sell_check = go.Scatter(x=data['date'], y=sell_line, mode='markers', name="sell", marker=dict(size=14, color=sell_colors, line_width=0))
         upper = go.Scatter(x=data['date'], y=data["upper"], name="upper", line_color='#000000')
         lower = go.Scatter(x=data['date'], y=data["lower"], name="lower", line_color='#000000')
-        avg3 = go.Scatter(x=data['date'], y=data["avg3"], name="avg3", line_color='#000000')
-        avg5 = go.Scatter(x=data['date'], y=data["avg5"], name="avg5", line_color='#085F1B')
+        avg3 = go.Scatter(x=data['date'], y=data["avg3"], name="avg3", line_color='#1469F4')
+        avg5 = go.Scatter(x=data['date'], y=data["avg5"], name="avg5", line_color='#089B5B')
         avg10 = go.Scatter(x=data['date'], y=data["avg10"], name="avg10", line_color='#ff00ff')
-        avg20 = go.Scatter(x=data['date'], y=data["avg20"], name="avg20", line_color='#1469F4')
-        avg30 = go.Scatter(x=data['date'], y=data["avg30"], name="avg30", line_color='#FFA500')
+        avg20 = go.Scatter(x=data['date'], y=data["avg20"], name="avg20", line_color='#8F8203')
+        avg30 = go.Scatter(x=data['date'], y=data["avg30"], name="avg30", line_color='#000000')
         #avg60 = go.Scatter(x=data['date'], y=data["avg60"], name="avg60", line_color='#008000')
 
         candle_stick = go.Candlestick(x=data['date'], open=data['open'], high=data['high'], low=data['low'], close=data['close'], increasing_line_color='red', decreasing_line_color='blue')
@@ -164,8 +164,8 @@ class Simulation:
         today = days[1]
 
         # 데이터를 가지고 온다.
-        self.getCSV("./data/" + self.stock_code + "_" + last_day + ".csv", last_day, result)
-        self.getCSV("./data/" + self.stock_code + "_" + today + ".csv", today, result)
+        self.getCSV("./backup/" + self.stock_code + "_" + last_day + ".csv", last_day, result)
+        self.getCSV("./backup/" + self.stock_code + "_" + today + ".csv", today, result)
 
         # 분석을 통해서 볼린저밴드 상/하단을 계산한다.
         data = self.buySellChecker.analyze(result)
@@ -180,44 +180,41 @@ class Simulation:
 
 if __name__ == "__main__":
 
+    """
+    # to check bying
     stock_codes = {
         # 122630
         "252670": [
-            ('20210901', '20210902'),
-            ('20210902', '20210903'),
-            ('20210906', '20210907'),
-            ('20210907', '20210908'),
-            ('20210907', '20210908'),
-            ('20210908', '20210909'),
-            ('20210909', '20210910'),
-            ('20210910', '20210913'),
-            ('20210913', '20210914'),
-            ('20210914', '20210915'),
-            ('20210915', '20210916'),
-            ('20210916', '20210917'),
-            ('20210923', '20210924'),
-            ('20210927', '20210928'),
-            ('20210928', '20210929'),
-            ('20210929', '20210930'),
-            ('20210930', '20211001'),
-            ('20211005', '20211006'),
-            ('20211006', '20211007'),
-            ('20211007', '20211008'),
-            ('20211008', '20211009'),
-            ('20211009', '20211011'),
-            ('20211011', '20211012'),
-            ('20211012', '20211013'),
-            ('20211013', '20211014'),
-            ('20211014', '20211015'),
+            ('20220627', '20220628'),
+            ('20220701', '20220704'),
+        ],
+    }
+    """
 
+
+    stock_codes = {
+        # 252670
+        # 122630
+        "122630": [
+            ('20220617', '20220620'),
             ('20220620', '20220621'),
             ('20220621', '20220622'),
             ('20220622', '20220623'),
             ('20220623', '20220624'),
+            ('20220624', '20220627'),
+            ('20220627', '20220628'),
+            ('20220628', '20220629'),
+            ('20220629', '20220630'),
+            ('20220630', '20220701'),
+            ('20220701', '20220704'),
+            ('20220704', '20220705'),
+            ('20220705', '20220706'),
+            ('20220706', '20220707'),
             ('20220707', '20220708')
         ],
     }
 
+
     for stock_code in stock_codes:
         simulation = Simulation(stock_code)