#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 LimeGreen

extern bool ShowStrongReversalPatterns = TRUE;
extern bool ShowWeakReversalPatterns = FALSE;
extern bool ShowContinuationPatterns = FALSE;
extern bool ShowUnclassified = FALSE;
extern int ViewBars = 350;
extern bool SoundAlert = TRUE;
extern bool EmailAlert = FALSE;
extern color SellColor = Red;
extern color BuyColor = LimeGreen;
extern color TextColor = Yellow;
double g_ibuf_116[];
double g_ibuf_120[];
datetime g_time_124;
bool gi_128 = FALSE;
string gs_unused_132 = "10.";
string gs_unused_140 = "20";
int gi_148 = -1;
int gi_152 = 0;
int gi_156 = 1;
int gi_160 = 2;
int gi_164 = 3;
int gi_unused_168 = 39;
int gia_172[];
int gia_176[];
string gs_mymmobj_180 = "MyMMObj";
int gi_188 = 0;
int gi_192 = 1;
int gi_196 = 2;
int gi_200 = 3;
int gi_204 = 4;
int gi_208 = 5;
int gi_212 = 6;
int gi_216 = 7;
int gi_220 = 8;
int gi_224 = 9;
int gi_228 = 10;
int gi_232 = 11;
int gi_236 = 12;
int gi_240 = 13;
int gi_244 = 14;
int gi_248 = 15;
int gi_252 = 16;
int gi_256 = 17;
int gi_260 = 18;
int gi_264 = 19;
int gi_268 = 20;
int gi_272 = 21;
int gi_276 = 22;
int gi_280 = 23;
int gi_284 = 24;
int gi_288 = 25;
int gi_292 = 26;
int gi_296 = 27;
int gi_300 = 28;
int gi_304 = 29;
int gi_308 = 30;
int gi_312 = 31;
int gi_316 = 32;
int gi_320 = 33;
int gi_324 = 34;
int gi_328 = 35;
int gi_332 = 36;
int gi_336 = 37;
int gi_340 = 38;
string gsa_344[39];
int gia_348[39];
int gia_352[39];
//------------------------------------------------------------------------------+
int initDefine() {
   gsa_344[gi_188] = "Молот";
   gia_352[gi_188] = 0;
   gsa_344[gi_304] = "Повешенный";
   gia_352[gi_304] = 0;
   gsa_344[gi_192] = "Модель поглощения";
   gia_352[gi_192] = 0;
   gsa_344[gi_196] = "Утрення звезда";
   gia_352[gi_196] = 0;
   gsa_344[gi_200] = "Вечерняя звезда";
   gia_352[gi_200] = 0;
   gsa_344[gi_212] = "Завеса из темных облаков";
   gia_352[gi_212] = 0;
   gsa_344[gi_216] = "Просвет в облаках";
   gia_352[gi_216] = 0;
   gsa_344[gi_204] = "Падающая звезда";
   gia_352[gi_204] = 0;
   gsa_344[gi_208] = "Перевернутый молот";
   gia_352[gi_208] = 0;
   gsa_344[gi_220] = "Харами";
   gia_352[gi_220] = 1;
   gsa_344[gi_224] = "Вершина Пинцет";
   gia_352[gi_224] = 1;
   gsa_344[gi_228] = "Основание Пинцет";
   gia_352[gi_228] = 1;
   gsa_344[gi_232] = "Захват за Пояс";
   gia_352[gi_232] = 1;
   gsa_344[gi_236] = "Две взлетевшие вороны";
   gia_352[gi_236] = 1;
   gsa_344[gi_244] = "Три вороны";
   gia_352[gi_244] = 1;
   gsa_344[gi_240] = "Удержание на Татами";
   gia_352[gi_240] = 2;
   gsa_344[gi_248] = "Контратака";
   gia_352[gi_248] = 3;
   gsa_344[gi_252] = "Разделение";
   gia_352[gi_252] = 2;
   gsa_344[gi_256] = "Доджи-надгробие";
   gia_352[gi_256] = 3;
   gsa_344[gi_260] = "Длинноногий Доджи";
   gia_352[gi_260] = 3;
   gsa_344[gi_264] = "Медвежий Доджи";
   gia_352[gi_264] = 0;
   gsa_344[gi_324] = "Бычий Доджи";
   gia_352[gi_324] = 0;
   gsa_344[gi_268] = "Разрыв Тасуки";
   gia_352[gi_268] = 2;
   gsa_344[gi_272] = "Смежные белые свечи";
   gia_352[gi_272] = 2;
   gsa_344[gi_276] = "Три метода";
   gia_352[gi_276] = 2;
   gsa_344[gi_280] = "Три реки, основание";
   gia_352[gi_280] = 3;
   gsa_344[gi_284] = "Окно вверх";
   gia_352[gi_284] = 3;
   gsa_344[gi_288] = "Окно Вниз";
   gia_352[gi_288] = 3;
   gsa_344[gi_292] = "Три белых солдата";
   gia_352[gi_292] = 3;
   gsa_344[gi_296] = "Отбитое наступление";
   gia_352[gi_296] = 1;
   gsa_344[gi_300] = "Торможение";
   gia_352[gi_300] = 3;
   gsa_344[gi_316] = "Доджи Поглощение";
   gia_352[gi_316] = 3;
   gsa_344[gi_320] = "Перевернутый Молот";
   gia_352[gi_320] = 3;
   gsa_344[gi_328] = "Верхний разрыв метода трех";
   gia_352[gi_328] = 2;
   gsa_344[gi_332] = "Нижний разрыв метода трех";
   gia_352[gi_332] = 2;
   gsa_344[gi_336] = "Тройной удар";
   gia_352[gi_336] = 1;
   gsa_344[gi_340] = "У линии шеи";
   gia_352[gi_340] = 1;
   gia_348[gi_316] = -150;
   gia_348[gi_188] = -100;
   gia_348[gi_304] = -100;
   gia_348[gi_192] = -100;
   gia_348[gi_196] = -100;
   gia_348[gi_200] = -100;
   gia_348[gi_212] = -100;
   gia_348[gi_216] = -100;
   gia_348[gi_204] = -90;
   gia_348[gi_208] = -90;
   gia_348[gi_220] = -80;
   gia_348[gi_224] = -50;
   gia_348[gi_228] = -50;
   gia_348[gi_232] = -80;
   gia_348[gi_236] = -80;
   gia_348[gi_244] = -90;
   gia_348[gi_240] = 0;
   gia_348[gi_248] = -80;
   gia_348[gi_252] = 0;
   gia_348[gi_256] = 0;
   gia_348[gi_260] = 0;
   gia_348[gi_264] = 0;
   gia_348[gi_324] = 0;
   gia_348[gi_268] = 0;
   gia_348[gi_272] = 0;
   gia_348[gi_276] = 0;
   gia_348[gi_280] = -90;
   gia_348[gi_284] = 100;
   gia_348[gi_288] = 100;
   gia_348[gi_292] = 100;
   gia_348[gi_296] = -80;
   gia_348[gi_300] = -80;
   return (0);
}
//------------------------------------------------------------------------------+
double GetUpperShadowHeight(int j) {
   return (MathAbs(High[j] - MathMax(Close[j], Open[j])));
}
//------------------------------------------------------------------------------+
double GetLowerShadowHeight(int j) {
   return (MathAbs(MathMin(Close[j], Open[j]) - Low[j]));
}
//------------------------------------------------------------------------------+
double GetBodyHeight(int j) {
   return (MathAbs(Close[j] - Open[j]));
}
//------------------------------------------------------------------------------+
double GetAllHeight(int j) {
   return (MathAbs(High[j] - Low[j]));
}
//------------------------------------------------------------------------------+
bool IsHigher(int j) {
   if (High[j] >= High[j + 1] + 2.0 * Point && High[j] >= High[j + 2] + 2.0 * Point && High[j] >= High[j + 3] + 2.0 * Point) return (TRUE);
   return (FALSE);
}
//------------------------------------------------------------------------------+
int IsBodyHigher(int j) {
   if (Close[j] > GetHighCloseOpen(j + 1) + 2.0 * Point && Close[j] > GetHighCloseOpen(j + 2) + 2.0 * Point) return (1);
   return (0);
}
//------------------------------------------------------------------------------+
bool IsLower(int j) {
   if (Low[j] + 2.0 * Point < Low[j + 1] && Low[j] + 2.0 * Point < Low[j + 2] && Low[j] + 2.0 * Point < Low[j + 3]) return (TRUE);
   return (FALSE);
}
//------------------------------------------------------------------------------+
int IsYing(int j) {
   if (Close[j] < Open[j]) return (1);
   return (0);
}
//------------------------------------------------------------------------------+
int IsYang(int j) {
   if (Close[j] > Open[j]) return (1);
   return (0);
}
//------------------------------------------------------------------------------+
int RemoveObjects() {
   for (int li_0 = GetFirstMyObjectandText(); li_0 > -1; li_0 = GetFirstMyObjectandText()) ObjectDelete(ObjectName(li_0));
   return (0);
}
//------------------------------------------------------------------------------+
int GetFirstMyObjectandText() {
   for (int li_ret_0 = 0; li_ret_0 < ObjectsTotal(); li_ret_0++)
      if (StringFind(ObjectName(li_ret_0), "My", 0) >= 0) return (li_ret_0);
   return (-1);
}
//------------------------------------------------------------------------------+
double GetLowCloseOpen(int j) {
   return (MathMin(Close[j], Open[j]));
}
//------------------------------------------------------------------------------+
double GetHighCloseOpen(int j) {
   return (MathMax(Close[j], Open[j]));
}
//------------------------------------------------------------------------------+
string GetNextObjectName(string as_0) {
   return (as_0 + DoubleToStr(ObjectsTotal(), 0));
}
//------------------------------------------------------------------------------+
int testBodyHeight(int j, int ai_4) {
   if (GetBodyHeight(j) >= ai_4 * Point) return (1);
   return (0);
}
//------------------------------------------------------------------------------+
int AlmostSameBodyHeight(int j, int ai_4) {
   if (MathAbs(GetBodyHeight(j) - GetBodyHeight(ai_4)) < 5.0 * Point) return (1);
   return (0);
}
//------------------------------------------------------------------------------+
void CreateTextObject(int a_datetime_0, double a_price_4, color a_color_12, string a_text_16) {
   string l_name_24 = GetNextObjectName(gs_mymmobj_180);
   ObjectCreate(l_name_24, OBJ_TEXT, 0, a_datetime_0, a_price_4);
   ObjectSetText(l_name_24, a_text_16, 7);
   ObjectSet(l_name_24, OBJPROP_COLOR, a_color_12);
}
//------------------------------------------------------------------------------+
int AddintoCFArray(int j, int ai_4) {
   int l_arr_size_8 = ArraySize(gia_172);
   ArrayResize(gia_172, l_arr_size_8 + 1);
   ArrayResize(gia_176, l_arr_size_8 + 1);
   gia_172[l_arr_size_8] = j;
   gia_176[l_arr_size_8] = ai_4;
   return (0);
}
//------------------------------------------------------------------------------+
bool IsHammer(int j) {
   if (GetAllHeight(j) >= 10.0 * Point && GetUpperShadowHeight(j) < GetAllHeight(j) / 5.0 && GetLowerShadowHeight(j) > 2.0 * GetBodyHeight(j) && GetUpperShadowHeight(j) > 2.0 * Point)
      if (IsHigher(j)) return (TRUE);
   return (FALSE);
}
//------------------------------------------------------------------------------+
bool IsHammerCFM(int j) {
   if (IsHammer(j + 1) && Open[j] < GetLowCloseOpen(j + 2) && Close[j] < GetLowCloseOpen(j + 2)) return (TRUE);
   return (FALSE);
}
//------------------------------------------------------------------------------+
bool IsHangMan(int j) {
   if (GetAllHeight(j) >= 10.0 * Point && GetUpperShadowHeight(j) < GetAllHeight(j) / 5.0 && GetLowerShadowHeight(j) > 2.0 * GetBodyHeight(j))
      if (IsHigher(j)) return (TRUE);
   return (FALSE);
}
//------------------------------------------------------------------------------+
bool IsHangManCFM(int j) {
   if (IsHangMan(j + 1) && Open[j] > GetHighCloseOpen(j + 2) && Close[j] > GetHighCloseOpen(j + 2)) return (TRUE);
   return (FALSE);
}
//------------------------------------------------------------------------------+
bool IsDoji(int j) {
   if (MathAbs(Open[j] - Close[j]) < 3.0 * Point) return (TRUE);
   return (FALSE);
}
//------------------------------------------------------------------------------+
bool IsInvertHammer(int j) {
   if (GetLowerShadowHeight(j) < GetAllHeight(j) / 5.0) {
      if (GetUpperShadowHeight(j) > 2.0 * GetBodyHeight(j))
         if (IsLower(j)) return (TRUE);
   }
   return (FALSE);
}
//------------------------------------------------------------------------------+
bool IsInvertHammerCFM(int ai_unused_0) {
   return (FALSE);
}
//------------------------------------------------------------------------------+
bool IsThree_Crows(int j) {
   if (IsHigher(j + 2) && High[j + 1] > High[j + 2] && IsYing(j + 2) && IsYing(j + 1) && IsYing(j) && Open[j + 1] < Open[j + 2] && Close[j +
      1] < Close[j + 2] && Open[j] < Open[j + 1] && Close[j] < Close[j + 1]) return (TRUE);
   return (FALSE);
}
//------------------------------------------------------------------------------+
bool IsThree_White_Soldiers(int j) {
   if (IsYang(j + 2) && IsYang(j + 1) && IsYang(j + 0) && Open[j + 1] > Open[j + 2] + GetBodyHeight(j + 2) / 2.0 && Open[j + 0] > Open[j + 1] +
      GetBodyHeight(j + 1) / 2.0 && Close[j + 1] > Close[j + 2] && Close[j + 0] > Close[j + 1] && High[j + 1] > High[j + 2] && High[j + 0] > High[j + 1] && testBodyHeight(j + 2, 20) && testBodyHeight(j + 1, 20) && testBodyHeight(j + 0, 20) && AlmostSameBodyHeight(j + 2, j + 1) && AlmostSameBodyHeight(j + 1, j + 0)) return (TRUE);
   return (FALSE);
}
//------------------------------------------------------------------------------+
int MMCFCondition(int j) {
   int l_count_4;
   if (!IsDoji(j + 2)) {
      if (IsYang(j + 2) != IsYang(j + 1)) {
         if (MathMax(Close[j + 1], Open[j + 1]) > MathMax(Close[j + 2], Open[j + 2]) && MathMin(Close[j + 1], Open[j + 1]) < MathMin(Close[j + 2], Open[j +
            2])) {
            if ((IsLower(j + 2) || IsLower(j + 1)) && IsYang(j + 1)) AddintoCFArray(gi_192, gi_152);
            if ((IsHigher(j + 2) || IsHigher(j + 1)) && IsYing(j + 1)) AddintoCFArray(gi_192, gi_156);
            if ((GetBodyHeight(j + 2) >= 15.0 * Point || IsLower(j + 1)) && IsYang(j + 1)) AddintoCFArray(gi_192, gi_152);
            if ((GetBodyHeight(j + 2) >= 15.0 * Point || IsHigher(j + 1)) && IsYing(j + 1)) AddintoCFArray(gi_192, gi_156);
         }
      }
   }
   if (IsDoji(j + 2)) {
      if (MathMax(Close[j + 1], Open[j + 1]) > MathMax(Close[j + 2], Open[j + 2]) && 
          MathMin(Close[j + 1], Open[j + 1]) < MathMin(Close[j + 2], Open[j + 2])) {
         
         if((IsLower(j + 2) || IsLower(j + 1)) && IsYang(j + 1)) 
            AddintoCFArray(gi_316, gi_152);
         if((IsHigher(j + 2) || IsHigher(j + 1)) && IsYing(j + 1)) 
            AddintoCFArray(gi_316, gi_156);
      }
   }
   if (IsYang(j + 2) && 
       IsYing(j + 1) && 
       IsHigher(j + 2) && 
       GetBodyHeight(j + 2) >= 20.0 * Point && 
       Open[j + 1] > High[j + 2] && 
       Close[j + 1] < Open[j + 2] + (Close[j + 2] - (Open[j + 2])) / 2.0 && 
       GetLowCloseOpen(j + 1) > GetLowCloseOpen(j + 2)) 
       
         AddintoCFArray(gi_212, gi_156);
         
   if (MathAbs(Close[j + 2] - (Open[j + 2])) > 5.0 * Point) {
      if (MathMax(Close[j + 1], Open[j + 1]) < MathMax(Close[j + 2], Open[j + 2]) && 
          MathMin(Close[j + 1], Open[j + 1]) > MathMin(Close[j + 2], Open[j + 2])) {
          
            if ((IsYang(j + 2) && 
                 IsHigher(j + 2)) || (IsYang(j + 2) && 
                 GetBodyHeight(j + 2) >= 15.0 * Point)) 
                 
                     AddintoCFArray(gi_220, gi_156);
                     
            if ((IsYing(j + 2) && 
                 IsLower(j + 2)) || (IsYing(j + 2) && 
                 GetBodyHeight(j + 2) >= 15.0 * Point)) 
                 
                     AddintoCFArray(gi_220, gi_152);
      }
   }
   if (IsHammer(j + 1)) AddintoCFArray(gi_188, gi_160);
   if (IsHangMan(j + 1)) AddintoCFArray(gi_304, gi_164);
   if (IsHammerCFM(j + 1)) AddintoCFArray(gi_308, gi_152);
   if (IsHangManCFM(j + 1)) AddintoCFArray(gi_312, gi_156);
   if (IsInvertHammer(j + 1)) AddintoCFArray(gi_208, gi_160);
   if (IsInvertHammerCFM(j + 1)) AddintoCFArray(gi_320, gi_152);
   if (IsYang(j + 1) && 
       IsYing(j + 2) && 
       GetBodyHeight(j + 2) >= 10.0 * Point && 
       Open[j + 1] < Low[j + 2] && 
       Close[j + 1] > Close[j + 2] + (Open[j +2] - (Close[j + 2])) / 2.0 && 
       GetHighCloseOpen(j + 1) < GetHighCloseOpen(j + 2)) 
       
         AddintoCFArray(gi_216, gi_152);
   if (IsYing(j + 3) && 
       IsYang(j + 1) && 
       IsLower(j + 3)) {
       
         if ((GetLowCloseOpen(j + 3) > GetHighCloseOpen(j + 2) || GetLowCloseOpen(j + 1) > GetHighCloseOpen(j + 2)) && 
             GetHighCloseOpen(j + 1) > GetLowCloseOpen(j + 3) && 
             GetBodyHeight(j + 2) <= 10.0 * Point && 
             GetBodyHeight(j + 3) >= 8.0 * Point && 
             GetBodyHeight(j + 1) >= 8.0 * Point) 
             
               AddintoCFArray(gi_196, gi_152);
   }
   if (IsYang(j + 3) && 
       IsYing(j + 1) && 
       IsHigher(j + 3)) {
       
         if ((GetHighCloseOpen(j + 3) < GetLowCloseOpen(j + 2) || GetHighCloseOpen(j + 1) < GetLowCloseOpen(j + 2)) && 
             GetLowCloseOpen(j + 1) < GetHighCloseOpen(j + 3) && 
             GetBodyHeight(j + 2) <= 10.0 * Point && 
             GetBodyHeight(j + 3) > 8.0 * Point && GetBodyHeight(j + 1) > 8.0 * Point) 
             
               AddintoCFArray(gi_200, gi_156);
   }
   if (GetLowerShadowHeight(j + 1) < GetAllHeight(j + 1) / 4.0) {
      if (GetUpperShadowHeight(j + 1) > 2.0 * GetBodyHeight(j + 1))
         if (IsHigher(j + 1) || 
             IsBodyHigher(j + 1) || 
             IsBodyHigher(j + 2)) 
             
                  AddintoCFArray(gi_204, gi_156);
   }
   if (GetAllHeight(j + 1) > 10.0 * Point && 
       IsYang(j + 2) && IsHigher(j + 2) && 
       (High[j + 2] == High[j + 1] || 
       High[j + 3] == High[j + 1] || 
       High[j + 4] == High[j + 1])) 
       
            AddintoCFArray(gi_224, gi_156);
            
   if (GetAllHeight(j + 1) > 10.0 * Point && 
       IsYing(j + 2) && 
       IsLower(j + 2) && 
       (Low[j + 2] == Low[j + 1] || 
       Low[j + 3] == Low[j + 1] || 
       Low[j + 4] == Low[j + 1])) 
       
            AddintoCFArray(gi_228, gi_152);
            
   if (GetBodyHeight(j + 1) >= 20.0 * Point && 
       IsYang(j + 1) && 
       GetLowerShadowHeight(j) == 0.0 && 
       IsLower(j + 1) && 
       GetBodyHeight(j + 1) > GetAllHeight(j +1) / 2.0) 
       
            AddintoCFArray(gi_232, gi_152);
            
   if (GetBodyHeight(j + 1) >= 20.0 * Point && 
       IsYing(j + 1) && 
       GetUpperShadowHeight(j) == 0.0 && 
       IsHigher(j + 1) && 
       GetBodyHeight(j + 1) > GetAllHeight(j +1) / 2.0) 
       
            AddintoCFArray(gi_232, gi_156);
            
   if (IsHigher(j + 3) && 
       IsYang(j + 3) && 
       IsYing(j + 2) && 
       IsYing(j + 1) && 
       Open[j + 2] > Open[j + 3] && 
       Open[j + 1] > Open[j + 2] && 
       Close[j +1] < Close[j + 2] && 
       GetLowCloseOpen(j + 1) > GetHighCloseOpen(j + 3) && 
       GetLowCloseOpen(j + 2) > GetHighCloseOpen(j + 3)) 
       
            AddintoCFArray(gi_236, gi_156);
            
   if (IsYang(j + 5) && 
       IsYing(j + 4) && 
       IsYing(j + 3) && 
       IsYing(j + 2) && 
       IsYang(j + 1) && 
       Close[j + 4] > Close[j + 5] + 2.0 * Point && 
       Open[j + 3] > Open[j + 4] && 
       Close[j + 3] < Close[j + 4] && 
       Open[j + 2] > Open[j + 3] && 
       Close[j + 2] < Close[j + 3] && 
       Open[j + 1] > Close[j + 2] &&
       GetBodyHeight(j + 5) >= 20.0 * Point && 
       GetBodyHeight(j + 1) >= 20.0 * Point) 
       
            AddintoCFArray(gi_240, gi_152);
            
   if (IsThree_Crows(j + 1))
      
         AddintoCFArray(gi_244, gi_156);
         
   if (GetBodyHeight(j + 1) > 5.0 * Point && 
       GetBodyHeight(j + 2) > 5.0 * Point) {
       
         if (IsHigher(j + 1) && 
             IsYang(j + 2) && 
             IsYing(j + 1) && 
             MathAbs(GetLowCloseOpen(j + 2) - GetHighCloseOpen(j + 1)) <= 2.0 * Point) 
             
                  AddintoCFArray(gi_248, gi_156);
                  
         if (IsLower(j + 1) && 
             IsYing(j + 2) && 
             IsYang(j + 1) && 
             MathAbs(GetLowCloseOpen(j + 1) - GetHighCloseOpen(j + 2)) <= 2.0 * Point) 
             
                  AddintoCFArray(gi_248, gi_152);
   }
   if (GetBodyHeight(j + 1) > 5.0 * Point && GetBodyHeight(j + 2) > 5.0 * Point) {
      
      if (IsYang(j + 2) && 
          IsYing(j + 1) && 
          MathAbs(Open[j + 1] - (Open[j + 2])) <= 2.0 * Point) 
          
               AddintoCFArray(gi_252, gi_156);
               
      if (IsYing(j + 2) && 
          IsYang(j + 1) && 
          MathAbs(Open[j + 1] - (Open[j + 2])) <= 2.0 * Point) 
          
               AddintoCFArray(gi_252, gi_152);
   }
   if (Close[j + 1] == Open[j + 1] && 
       Close[j + 1] == Low[j + 1]) 
       
            AddintoCFArray(gi_256, gi_156);
            
   if (MathAbs(Close[j + 1] - (Open[j + 1])) < 3.0 * Point && 
       GetAllHeight(j + 1) > 20.0 * Point && 
       High[j + 1] > High[j + 2]) 
       
            AddintoCFArray(gi_260, gi_156);
            
   if (GetBodyHeight(j + 2) > 20.0 * Point && 
      (IsHigher(j + 2) || IsHigher(j + 1)) && 
       IsYang(j + 2) && 
       MathAbs(Close[j + 1] - (Open[j + 1])) < 2.0 * Point &&
       MathAbs(High[j + 1] - MathMax(Close[j + 1], Open[j + 1])) > 2.0 * Point && 
       MathAbs(Low[j + 1] - MathMin(Close[j + 1], Open[j + 1])) > 2.0 * Point) 
       
            AddintoCFArray(gi_264, gi_156);
            
   if (GetBodyHeight(j + 2) > 20.0 * Point && 
       (IsLower(j + 2) || IsLower(j + 1)) && 
       IsYing(j + 2) && 
       MathAbs(Close[j + 1] - (Open[j + 1])) < 2.0 * Point &&
       MathAbs(High[j + 1] - MathMax(Close[j + 1], Open[j + 1])) > 2.0 * Point && 
       MathAbs(Low[j + 1] - MathMin(Close[j + 1], Open[j + 1])) > 2.0 * Point) 
       
            AddintoCFArray(gi_324, gi_152);
            
   if ((IsHigher(j + 3) || IsHigher(j + 2)) && 
      (IsYang(j + 3) && IsYang(j + 2) && IsYing(j + 1)) && 
      Low[j + 2] - (High[j + 3]) >= 2.0 * Point && 
      Low[j +1] - (High[j + 3]) >= 2.0 * Point && 
      (Open[j + 1] > Open[j + 2] && Open[j + 1] < Close[j + 2]) && 
      Close[j + 1] < Close[j + 2] && 
      MathAbs(GetBodyHeight(j +1) - GetBodyHeight(j + 2)) < 5.0 * Point) 
      
            AddintoCFArray(gi_268, gi_152);
            
   if ((IsLower(j + 3) || IsLower(j + 2)) && 
       (IsYing(j + 3) && 
       IsYing(j + 2) && 
       IsYang(j + 1)) && 
       Low[j + 3] - (High[j + 2]) >= 2.0 * Point && 
       Low[j + 3] - (High[j + 1]) >= 2.0 * Point && 
       (Open[j + 1] > Close[j + 2] &&
        Open[j + 1] < Open[j + 2]) && 
        Close[j + 1] > Open[j + 2] && 
        MathAbs(GetBodyHeight(j +1) - GetBodyHeight(j + 2)) < 5.0 * Point) 
        
            AddintoCFArray(gi_268, gi_156);
            
   if (IsHigher(j + 3) && 
      (IsYang(j + 3) && 
      IsYang(j + 2) && 
      IsYang(j + 1)) && 
      Low[j + 2] - (High[j + 3]) >= 2.0 * Point && 
      MathAbs(Open[j + 1] > Open[j + 2]) < 2.0 * Point && 
      MathAbs(GetBodyHeight(j + 1) > GetBodyHeight(j + 2)) < 4.0 * Point) 
      
            AddintoCFArray(gi_272, gi_152);
            
   if (IsLower(j + 3) && 
      (IsYing(j + 3) && 
      IsYang(j + 2) && 
      IsYang(j + 1)) && 
      Low[j + 2] - (High[j + 3]) >= 2.0 * Point && 
      MathAbs(Open[j + 1] > Open[j +2]) < 2.0 * Point && 
      MathAbs(GetBodyHeight(j + 1) > GetBodyHeight(j + 2)) < 4.0 * Point) 
      
            AddintoCFArray(gi_272, gi_156);
            
   if (IsHigher(j + 5) && 
       IsYang(j + 5) && 
       IsYang(j + 1) && 
       IsYing(j + 2) && 
       IsYing(j + 3) && 
       IsYing(j + 4) && 
       GetBodyHeight(j + 5) > 20.0 * Point &&
       GetBodyHeight(j + 1) > 20.0 * Point && 
       Open[j + 1] > Open[j + 5] && 
       Close[j + 1] > Close[j + 5] && 
       Open[j + 2] > Open[j + 5] && 
       Close[j + 2] < Close[j + 5] && 
       Open[j + 3] > Open[j + 5] && 
       Close[j + 3] < Close[j + 5] && 
       Open[j + 4] > Open[j + 5] && 
       Close[j + 4] < Close[j + 5]) 
       
            AddintoCFArray(gi_276, gi_152);
            
   if (IsLower(j + 5) && IsYing(j + 5) && IsYing(j + 1) && IsYang(j + 2) && IsYang(j + 3) && IsYang(j + 4) && GetBodyHeight(j + 5) > 20.0 * Point &&
      GetBodyHeight(j + 1) > 20.0 * Point && Open[j + 1] < Open[j + 5] && Close[j + 1] < Close[j + 5] && Open[j + 2] < Open[j + 5] && Close[j + 2] > Close[j + 5] && Open[j + 3] < Open[j + 5] && Close[j + 3] > Close[j + 5] && Open[j + 4] < Open[j + 5] && Close[j + 4] > Close[j + 5]) AddintoCFArray(gi_276, gi_156);
   if (IsYing(j + 3) && IsYing(j + 2) && IsLower(j + 3) && IsLower(j + 2) && GetBodyHeight(j + 3) > 20.0 * Point && GetAllHeight(j + 3) - GetBodyHeight(j +
      3) < 10.0 * Point && GetBodyHeight(j + 2) < 10.0 * Point && GetLowerShadowHeight(j + 2) > GetBodyHeight(j + 2) && GetUpperShadowHeight(j + 2) <= 2.0 * Point &&
      GetBodyHeight(j + 1) < 10.0 * Point && GetLowerShadowHeight(j + 1) <= 2.0 * Point && GetUpperShadowHeight(j + 1) <= 2.0 * Point) AddintoCFArray(gi_280, gi_152);
   if (IsYang(j + 1) && Low[j + 1] > Low[j + 2] + 2.0 * Point) {
      for (int li_8 = 4; li_8 <= 11; li_8++) {
         if (GetBodyHeight(j + 2 + li_8) > 40.0 * Point) {
            l_count_4 = 0;
            for (int li_12 = li_8 + 1; li_12 > 0; li_12--) {
               if (High[li_12 + j + 2] < Close[j + 2 + li_8] && Low[li_12 + j + 2] > Open[j + 2 + li_8]) continue;
               l_count_4++;
            }
            if (l_count_4 == 0) AddintoCFArray(gi_284, gi_152);
         }
      }
   }
   if (IsThree_White_Soldiers(j + 1)) AddintoCFArray(gi_292, gi_152);
   if (IsYang(j + 3) && IsYang(j + 2) && 
       IsYang(j + 1) && Open[j + 2] > Open[j + 3] + GetBodyHeight(j + 3) / 2.0 && 
       Open[j + 1] > Open[j + 2] + GetBodyHeight(j + 2) / 2.0 && 
       Close[j + 2] > Close[j + 3] && 
       Close[j + 1] > Close[j + 2] && 
       High[j + 2] > High[j + 3] && 
       High[j + 1] > High[j + 2] && 
       testBodyHeight(j + 3, 20) && 
       GetBodyHeight(j + 3) > GetBodyHeight(j + 2) && 
       GetBodyHeight(j + 2) > GetBodyHeight(j + 1) && 
       Open[0] < Open[1])
       
             AddintoCFArray(gi_296, gi_156);
             
   if (IsYang(j + 3) && 
       IsYang(j + 2) && 
       IsYang(j + 1) && 
       Open[j + 2] > Open[j + 3] + GetBodyHeight(j + 3) / 2.0 && 
       Open[j + 1] > Open[j + 2] + GetBodyHeight(j + 2) / 2.0 && 
       Close[j + 2] > Close[j + 3] && 
       Close[j + 1] > Close[j + 2] && 
       High[j + 2] > High[j + 3] && 
       High[j + 1] > High[j + 2] && 
       testBodyHeight(j + 2, 20) && 
       GetBodyHeight(j + 3) < 10.0 * Point && 
       GetBodyHeight(j + 1) < 10.0 * Point && Open[0] < Open[1]) 
       
            AddintoCFArray(gi_300, gi_156);
            
   if (IsYang(j + 3) && 
       IsYang(j + 2) && 
       IsYing(j + 1) && 
       IsHigher(j + 3) && 
       Low[j + 2] > High[j + 3] + 2.0 * Point && 
       Open[j + 1] > Open[j +2] && 
       Open[j + 1] < Close[j + 2] && 
       Close[j + 1] > Open[j + 3] + (Close[j + 1]) < Close[j + 3]) 
       
            AddintoCFArray(gi_328, gi_152);
            
   if (IsYing(j + 3) && 
       IsYing(j + 2) && 
       IsYang(j + 1) && 
       IsLower(j + 3) && 
       High[j + 2] < Low[j + 3] - 2.0 * Point && 
       Open[j + 1] > Close[j +2] && 
       Open[j + 1] < Open[j + 2] && 
       Close[j + 1] > Close[j + 3] + (Close[j + 1]) < Open[j + 3]) 
       
            AddintoCFArray(gi_332, gi_156);
            
   if (IsYang(j + 1) && 
       IsThree_Crows(j + 2) && 
       High[j + 1] > iHighest(NULL, 0, MODE_HIGH, 3, 2) && 
       Low[j + 1] < iLowest(NULL, 0, MODE_LOW, 3, 2)) 
       
            AddintoCFArray(gi_336, gi_156);
            
   if (IsYing(j + 1) && 
       IsThree_White_Soldiers(j + 2) && 
       High[j + 1] > iHighest(NULL, 0, MODE_HIGH, 3, 2) && 
       Low[j + 1] < iLowest(NULL, 0, MODE_LOW, 3, 2)) 
       
            AddintoCFArray(gi_336, gi_152);
            
   if (IsYing(j + 2) && 
       IsYang(j + 1) && 
       testBodyHeight(j + 1, 20) && 
       testBodyHeight(j + 2, 20) && 
       Close[j + 1] < Open[j + 2] - (Open[j + 2] - (Close[j +2])) / 2.0 && 
       Open[j + 1] < GetLowCloseOpen(j + 2)) 
       
            AddintoCFArray(gi_340, gi_156);
            
   return (gi_148);
}
//------------------------------------------------------------------------------+
int init() {
   gi_128 = TRUE;
   SetIndexStyle(0, DRAW_ARROW, STYLE_SOLID, 1);
   SetIndexArrow(0, 226);
   SetIndexBuffer(0, g_ibuf_120);
   SetIndexEmptyValue(0, 0.0);
   SetIndexLabel(0,"Dn");
   
   SetIndexStyle(1, DRAW_ARROW, STYLE_SOLID, 1);
   SetIndexArrow(1, 225);
   SetIndexBuffer(1, g_ibuf_116);   
   SetIndexEmptyValue(1, 0.0);
   SetIndexLabel(1,"Up");
   
   initDefine();
   return (0);
}
//------------------------------------------------------------------------------+
int deinit() {
   RemoveObjects();
   return (0);
}
//------------------------------------------------------------------------------+
int start() {
   RemoveObjects();
   if (gi_128 == FALSE) return (0);
   for (int l_count_0 = 0; l_count_0 <= ViewBars; l_count_0++) getCFResult(l_count_0);
   return (0);
}
//------------------------------------------------------------------------------+
int getCFResult(int j) {
   int li_4;
   double ld_8;
   string ls_16;
   int n = gi_148;
   int l_arr_size_28 = 0;
   ArrayResize(gia_172, 0);
   ArrayResize(gia_176, 0);
   MMCFCondition(j);
   l_arr_size_28 = ArraySize(gia_172);
   for (int m = 0; m < l_arr_size_28; m++) {
      n = gia_176[m];
      li_4 = gia_172[m];
      if (m == 0) ld_8 = 15.0 * Point;
      else ld_8 = 15.0 * Point + m * 8;
      if ((n == gi_164 || n == gi_156) && 
         (ShowStrongReversalPatterns == TRUE && gia_352[li_4] == 0) || 
         (ShowWeakReversalPatterns == TRUE && gia_352[li_4] == 1) ||
         (ShowContinuationPatterns == TRUE && gia_352[li_4] == 2) || 
         (ShowUnclassified == TRUE && gia_352[li_4] == 3)) {
         
            g_ibuf_120[j + 1] = High[j + 1] + 8.0 * Point;
            //CreateTextObject(Time[j + 1], High[j + 1] + ld_8, TextColor, gsa_344[li_4]);
            ls_16 = gsa_344[li_4];
      }
      if ((n == gi_160 || n == gi_152) && 
          (ShowStrongReversalPatterns == TRUE && gia_352[li_4] == 0) || 
          (ShowWeakReversalPatterns == TRUE && gia_352[li_4] == 1) ||
         (ShowContinuationPatterns == TRUE && gia_352[li_4] == 2) || 
         (ShowUnclassified == TRUE && gia_352[li_4] == 3)) {
         
            g_ibuf_116[j + 1] = Low[j + 1] - 8.0 * Point;
            //CreateTextObject(Time[j + 1], Low[j + 1] - ld_8, TextColor, gsa_344[li_4]);
            ls_16 = gsa_344[li_4];
      }
   }
   if (n != gi_148 && j < 1) {
      if (g_time_124 != Time[0]) {
         Print(TimeToStr(Time[0]), Period(), ls_16, " in ", Symbol());
         if (EmailAlert) SendMail(Period() + ls_16 + " in " + Symbol(), "");
         if (SoundAlert) PlaySound("alert2.wav");
         g_time_124 = Time[0];
      }
   }
   return (n);
}
//------------------------------------------------------------------------------+