//+------------------------------------------------------------------+
//|                                      HarmonicPatternFinderV2.mq5 |
//|                                  Copyright 2016, André S. Enger. |
//|                                          andre_enger@hotmail.com |
//|                                  Contribs                        |
//|                                         David Gadelha            |
//|                                               dgadelha@gmail.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, Andre S. Enger."
#property link      "andre_enger@hotmail.com"
#property version   "2.0"
#property description "Indicator to display existent and emerging harmonic chart patterns."

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots 1

#property indicator_label1  "Zig Zag"
#property indicator_type1   DRAW_ZIGZAG
#property indicator_color1  clrNONE
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- Describes patterns
struct PATTERN_DESCRIPTOR
  {
   double            ab2xa_min;
   double            ab2xa_max;
   double            bc2ab_min;
   double            bc2ab_max;
   double            cd2bc_min;
   double            cd2bc_max;
   double            ad2xa_min;
   double            ad2xa_max;
   double            cd2xc_min;
   double            cd2xc_max;
   double            xc2xa_min;
   double            xc2xa_max;
   double            cd2ab_min;
   double            cd2ab_max;
  };
//--- Identifies drawn patterns
struct PATTERN_INSTANCE
  {
   int               patternIndex;
   int               patternBufferIndex;
   bool              bullish;
   bool              overlapping;
   datetime          XDateTime;
   datetime          ADateTime;
   datetime          BDateTime;
   datetime          CDateTime;
   datetime          DDateTime;
   double            X;
   double            A;
   double            B;
   double            C;
   double            D;
   double            PRZ;
  };
//--- Number keys of patterns
enum PATTERN_INDEX
  {
   TRENDLIKE1_ABCD=0,
   TRENDLIKE2_ABCD,
   PERFECT_ABCD,
   IDEAL1_ABCD,
   IDEAL2_ABCD,
   RANGELIKE_ABCD,
   ALT127_TRENDLIKE1_ABCD,
   ALT127_TRENDLIKE2_ABCD,
   ALT127_PERFECT_ABCD,
   ALT127_IDEAL1_ABCD,
   ALT127_IDEAL2_ABCD,
   ALT127_RANGELIKE_ABCD,
   REC_TRENDLIKE1_ABCD,
   REC_TRENDLIKE2_ABCD,
   REC_PERFECT_ABCD,
   REC_IDEAL1_ABCD,
   REC_IDEAL2_ABCD,
   REC_RANGELIKE_ABCD,
   GARTLEY,
   BAT,
   ALTBAT,
   FIVEO,
   BUTTERFLY,
   CRAB,
   DEEPCRAB,
   THREEDRIVES,
   CYPHER,
   SHARK,
   NENSTAR,
   BLACKSWAN,
   WHITESWAN,
   ONE2ONE,
   NEWCYPHER,
   NAVARRO200,
   LEONARDO,
   KANE,
   GARFLY,
   MAXBAT,
   MAXGARTLEY,
   MAXBUTTERFLY,
   GARTLEY113,
   BUTTERFLY113,
   ANTI_GARTLEY,
   ANTI_BAT,
   ANTI_ALTBAT,
   ANTI_FIVEO,
   ANTI_BUTTERFLY,
   ANTI_CRAB,
   ANTI_DEEPCRAB,
   ANTI_THREEDRIVES,
   ANTI_CYPHER,
   ANTI_SHARK,
   ANTI_NENSTAR,
   ANTI_BLACKSWAN,
   ANTI_WHITESWAN,
   ANTI_ONE2ONE,
   ANTI_NEWCYPHER,
   ANTI_NAVARRO200,
   ANTI_LEONARDO,
   ANTI_KANE,
   ANTI_GARFLY,
   ANTI_MAXBAT,
   ANTI_MAXGARTLEY,
   ANTI_MAXBUTTERFLY,
   ANTI_GARTLEY113,
   ANTI_BUTTERFLY113,
  };
//--- ZigZag selection
enum ZIGZAGTYPE
  {
   FASTZZ,//Fast ZZ
   ALEXSTAL,//Alexstal ZZ
   SWINGCHART //Swing ZZ
  };

//--- Constants and macros
#define SIZE_PATTERN_BUFFER 10
#define NUM_PATTERNS 66
#define NON_EXISTENT_DATETIME D'19.07.1980 12:30:27'

const string _identifier="HPF";

//--- User Inputs
input string indicatorSettings="-=Indicator Settings=-"; //-=Indicator Settings=-
input ZIGZAGTYPE zztype=ALEXSTAL;   //ZigZag type
input int zzperiod=12;              //AlexStal ZZ period
input int zzamplitude=10;           //AlexStal ZZ amplitude
input int zzminmotion=0;            //AlexStal ZZ minimum motion 
input int SwingSize=200;            //Fast ZZ sensitivity in points
input int BarsAnalyzed=200;         //Max. bars per pattern
input int History=1000;             //Max. history bars to process
input int MaxSamePoints=2;          //Max. shared points per pattern
input double SlackRange=0.01;       //Max. slack for fib ratios (range)
input double SlackUnary=0.1;        //Max. slack for fib ratios (unary)
input string indicatorColors="-=Display Settings=-"; //-=Display Settings=-
input color ClrBull=clrLightSkyBlue;               //Color for bullish patterns (5 points)
input color ClrBear=clrSalmon;                     //Color for bearish patterns (5 points)
input color ClrBull4P=clrBlue;                     //Color for bullish patterns (4 points)
input color ClrBear4P=clrRed;                      //Color for bearish patterns (4 points)
input color ClrBullProjection=clrSeaGreen;         //Color for projected bullish patterns
input color ClrBearProjection=clrDarkOrange;       //Color for projected bearish patterns
input color ClrRatio=clrGray;                      //Color for patterns ratios
input bool Fill_Patterns=false;                    //Fill 5 point patterns found
input bool Show_descriptions=true;                 //Show pattern descriptions
input bool Show_PRZ=true;                          //Show potential reversal zone (PRZ)
input bool EmergingPatterns=true;                  //Show emerging patterns
input bool OneAheadProjection=false;               //Show "one-ahead" projections
input bool showPatternNames=false;                 //Show comment box
input int l_width=2;                               //Pattern line width (5 points)
input int l_width4p=2;                             //Patterns line width (4 points)
input int l_width_proj=2;                          //Emerging patterns line width
input int Font_size=08;                            //Font size
input ENUM_LINE_STYLE Style_5P=STYLE_SOLID;        //Style for 5 points patterns
input ENUM_LINE_STYLE Style_4P=STYLE_DASH;         //Style for 4 points patterns
input ENUM_LINE_STYLE Style_Proj=STYLE_DASHDOTDOT; //Style for projections
input ENUM_LINE_STYLE Style_Ratio=STYLE_DOT;       //Style for ratio lines
input ENUM_LINE_STYLE Style_PRZ=STYLE_DASHDOT;     //Style for PRZ
input string indicatorPatternsQuick="-=Patterns Quick=-"; //-=Patterns Quick=-
input bool Show_abcd=true;          //Display AB=CD patterns
input bool Show_alt127_abcd=true;   //Display 1.27 AB=CD patterns
input bool Show_rec_abcd=true;      //Display Rec. AB=CD patterns
input bool Show_patterns=true;      //Display normal 5-point patterns
input bool Show_antipatterns=false; //Display anti 5-point patterns
input string indicatorPatternsIndividual="-=Patterns Individual=-"; //-=Patterns Individual=-
input bool Show_trendlike1_abcd=true;        //Display Trendlike AB=CD #1
input bool Show_trendlike2_abcd=true;        //Display Trendlike AB=CD #2
input bool Show_perfect_abcd=true;           //Display Perfect AB=CD
input bool Show_ideal1_abcd=true;            //Display Ideal AB=CD #1
input bool Show_ideal2_abcd=true;            //Display Ideal AB=CD #2
input bool Show_rangelike_abcd=true;         //Display Rangelike AB=CD
input bool Show_alt127_trendlike1_abcd=true; //Display Trendlike 1.27 AB=CD #1
input bool Show_alt127_trendlike2_abcd=true; //Display Trendlike 1.27 AB=CD #2
input bool Show_alt127_perfect_abcd=true;    //Display Perfect 1.27 AB=CD
input bool Show_alt127_ideal1_abcd=true;     //Display Ideal 1.27 AB=CD #1
input bool Show_alt127_ideal2_abcd=true;     //Display Ideal 1.27 AB=CD #2
input bool Show_alt127_rangelike_abcd=true;  //Display Rangelike 1.27 AB=CD
input bool Show_rec_trendlike1_abcd=true;    //Display Rec. Trendlike AB=CD #1
input bool Show_rec_trendlike2_abcd=true;    //Display Rec. Trendlike AB=CD #2
input bool Show_rec_perfect_abcd=true;       //Display Rec. Perfect AB=CD
input bool Show_rec_ideal1_abcd=true;        //Display Rec. Ideal AB=CD #1
input bool Show_rec_ideal2_abcd=true;        //Display Rec. Ideal AB=CD #2
input bool Show_rec_rangelike_abcd=true;     //Display Rec. Rangelike AB=CD
input bool Show_gartley=true;                //Display Gartley
input bool Show_bat=true;                    //Display Bat
input bool Show_altbat=true;                 //Display Alt. Bat
input bool Show_fiveo=true;                  //Display 5-0
input bool Show_butterfly=true;              //Display Butterfly
input bool Show_crab=true;                   //Display Crab
input bool Show_deepcrab=true;               //Display Deepcrab
input bool Show_threedrives=true;            //Display Three Drives
input bool Show_cypher=true;                 //Display Cypher
input bool Show_shark=true;                  //Display Shark
input bool Show_nenstar=true;                //Display Nen Star
input bool Show_blackswan=true;              //Display Black Swan
input bool Show_whiteswan=true;              //Display White Swan
input bool Show_one2one=true;                //Display One2One
input bool Show_newCypher=true;              //Display New Cypher
input bool Show_navarro200=true;             //Display Navarro 200
input bool Show_leonardo=true;               //Display Leonardo
input bool Show_kane=true;                   //Display Kane
input bool Show_garfly=true;                 //Display Garfly
input bool Show_maxbat=true;                 //Display Max. Bat
input bool Show_maxgartley=true;             //Display Max. Gartley
input bool Show_maxbutterfly=true;           //Display Max. Butterfly
input bool Show_gartley113=true;             //Display Gartley 113
input bool Show_butterfly113=true;           //Display Butterfly 113
input bool Show_antigartley=true;            //Display Anti Gartley
input bool Show_antibat=true;                //Display Anti Bat
input bool Show_antialtbat=true;             //Display Anti Alt. Bat
input bool Show_antifiveo=true;              //Display Anti 5-0
input bool Show_antibutterfly=true;          //Display Anti Butterfly
input bool Show_anticrab=true;               //Display Anti Crab
input bool Show_antideepcrab=true;           //Display Anti Deepcrab
input bool Show_antithreedrives=true;        //Display Anti Three Drives
input bool Show_anticypher=true;             //Display Anti Cypher
input bool Show_antishark=true;              //Display Anti Shark
input bool Show_antinenstar=true;            //Display Anti Nen Star
input bool Show_antiblackswan=true;          //Display Anti Black Swan
input bool Show_antiwhiteswan=true;          //Display Anti White Swan
input bool Show_antione2one=true;            //Display Anti One2One
input bool Show_antinewCypher=true;          //Display Anti New Cypher
input bool Show_antinavarro200=true;         //Display Anti Navarro 200
input bool Show_antileonardo=true;           //Display Anti Leonardo
input bool Show_antikane=true;               //Display Anti Kane
input bool Show_antigarfly=true;             //Display Anti Garfly
input bool Show_antimaxbat=true;             //Display Anti Max. Bat
input bool Show_antimaxgartley=true;         //Display Anti Max. Gartley
input bool Show_antimaxbutterfly=true;       //Display Anti Max. Butterfly
input bool Show_antigartley113=true;         //Display Anti Gartley 113
input bool Show_antibutterfly113=true;       //Display Anti Butterfly 113
//--- Indicator buffer arrays
double peaks[],troughs[];

//--- Globals
bool _lastDirection;
double _lastPeakValue;
double _lastTroughValue;
int _lastPeak;
int _lastTrough;
int _patternInstanceCounter;
int _maxPatternInstances;
int _projectionInstanceCounter;
int _maxProjectionInstances;
int _drawnProjectionInstanceCounter;
int _maxDrawnProjectionInstances;
int _zzHandle;
PATTERN_INSTANCE _patternInstances[];
PATTERN_INSTANCE _projectionInstances[];
PATTERN_INSTANCE _drawnProjectionInstances[];
PATTERN_DESCRIPTOR _patterns[];
string _patternNames[];
int _patternCounter[];
datetime _patternX[][SIZE_PATTERN_BUFFER];
datetime _patternA[][SIZE_PATTERN_BUFFER];
datetime _patternB[][SIZE_PATTERN_BUFFER];
datetime _patternC[][SIZE_PATTERN_BUFFER];
datetime _patternD[][SIZE_PATTERN_BUFFER];
string com1="",com2="",com3="",com4="",com5="",com6="",com7="",com8="",com9="";
int _timeOfInit;
//+------------------------------------------------------------------+
//| Indicator initialization function                                |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,peaks,INDICATOR_DATA);
   SetIndexBuffer(1,troughs,INDICATOR_DATA);
   IndicatorSetInteger(INDICATOR_DIGITS,Digits());
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
//--- memory
   switch(zztype)
     {
      case FASTZZ:
         _zzHandle=iCustom(NULL,0,"Downloads\\fastzz",SwingSize);
         break;
      case ALEXSTAL:
         _zzHandle=iCustom(NULL,0,"Downloads\\alexstal_zigzagprof",zzperiod,zzamplitude,zzminmotion,true);
         break;
      case SWINGCHART:
         default:
         _zzHandle=iCustom(NULL,0,"Downloads\\swingchart");
     }
   if(_zzHandle==INVALID_HANDLE)
     {
      printf("Error obtaining handle");
      return(INIT_FAILED);
     }
   MathSrand(GetTickCount());
   _timeOfInit=MathRand();
   for(int i=ObjectsTotal(0,0,-1)-1; i>=0; i--)
     {
      string name=ObjectName(0,i,0,-1);
      if(StringFind(name,"U "+_identifier)!=-1 || StringFind(name,"D "+_identifier)!=-1)
         ObjectDelete(0,name);
     }
   return PopulatePatterns();
  }
//+------------------------------------------------------------------+
//| Indicator deinitialization function                              |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   OnReinit();
   Comment("");
   ArrayFree(_patterns);
   ArrayFree(_patternInstances);
   ArrayFree(_projectionInstances);
   ArrayFree(_drawnProjectionInstances);
   ArrayFree(_patternNames);
   ArrayFree(_patternCounter);
   ArrayFree(_patternX);
   ArrayFree(_patternA);
   ArrayFree(_patternB);
   ArrayFree(_patternC);
   ArrayFree(_patternD);
  }
//+------------------------------------------------------------------+
//| Indicator reinitialization function                              |
//+------------------------------------------------------------------+
void OnReinit()
  {
//----
   _lastPeak=0;
   _lastTrough=0;
   _lastPeakValue=0;
   _lastTroughValue=0;
   _patternInstanceCounter=0;
   _drawnProjectionInstanceCounter=0;
   ArrayFill(_patternCounter,0,NUM_PATTERNS,0);
   for(int i=0; i<NUM_PATTERNS; i++)
     {
      for(int j=0; j<SIZE_PATTERN_BUFFER; j++)
        {
         _patternX[i][j]=0;
         _patternA[i][j]=0;
         _patternB[i][j]=0;
         _patternC[i][j]=0;
         _patternD[i][j]=0;
        }
     }
   for(int i=ObjectsTotal(0,0,-1)-1; i>=0; i--)
     {
      string name=ObjectName(0,i,0,-1);
      if(StringFind(name,"U "+_identifier+StringFormat("%x",_timeOfInit))!=-1 || StringFind(name,"D "+_identifier+StringFormat("%x",_timeOfInit))!=-1)
         ObjectDelete(0,name);
     }
  }
//+------------------------------------------------------------------+
//| Indicator iteration function                                     |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   int start=0;
   if(prev_calculated>rates_total || prev_calculated<=0)
      OnReinit();
   else
      start=prev_calculated-1;
   start=MathMax(1,start);
//--- copy data
   if(BarsCalculated(_zzHandle)<rates_total)
     {
      printf("ZigZag not calculated: "+IntegerToString(GetLastError()));
      return 0;
     }
   if(CopyBuffer(_zzHandle,0,0,rates_total,peaks)<=0)
     {
      printf("ZigZag peaks not copied: "+IntegerToString(GetLastError()));
      return 0;
     }
   if(CopyBuffer(_zzHandle,1,0,rates_total,troughs)<=0)
     {
      printf("ZigZag troughs not copied: "+IntegerToString(GetLastError()));
      return 0;
     }
//--- main loop
   for(int bar=start; bar<rates_total && !IsStopped(); bar++)
     {
      //--- Efficency checks
      if(bar<rates_total-History)
         continue;
      int lastPeak=FirstNonZeroFrom(bar,peaks);
      int lastTrough=FirstNonZeroFrom(bar,troughs);
      if(lastPeak==-1 || lastTrough==-1)
         continue;
      double lastPeakValue=peaks[lastPeak];
      double lastTroughValue=troughs[lastTrough];
      if(lastPeakValue==_lastPeakValue && lastTroughValue==_lastTroughValue)
         continue;
      //--- ZZ assessment
      bool endsInTrough=lastTrough>lastPeak;
      if(lastTrough==lastPeak)
        {
         int zzDirection=ZigZagDirection(lastPeak);
         if(zzDirection==0) continue;
         else if(zzDirection==-1) endsInTrough=true;
         else if(zzDirection==1) endsInTrough=false;
        }
      //--- Remove old projections
      UndisplayProjections();
      //--- Remove old patterns (on ZZ swing continuation) or store them (on new ZZ direction)
      if(_lastDirection==endsInTrough && !(_lastPeak<lastPeak && _lastTrough<lastTrough))
         UndisplayPatterns();
      else for(int i=0; i<_patternInstanceCounter; i++)
        {
         PATTERN_INSTANCE instance=_patternInstances[i];
         int k=instance.patternIndex;
         bool bullish=instance.bullish;
         datetime XDateTime=instance.XDateTime;
         datetime ADateTime=instance.ADateTime;
         datetime BDateTime=instance.BDateTime;
         datetime CDateTime=instance.CDateTime;
         datetime DDateTime=instance.DDateTime;
         StoreOverlaps(k,XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
        }
      if(Show_PRZ)
         UndisplayPRZs();
      _patternInstanceCounter=0;
      //--- Save most recent peaks/troughs and direction
      _lastPeak=lastPeak;
      _lastTrough=lastTrough;
      _lastPeakValue=lastPeakValue;
      _lastTroughValue=lastTroughValue;
      _lastDirection=endsInTrough;
      //--- Check each pattern for matches
      for(int patternIndex=0; patternIndex<NUM_PATTERNS && !IsStopped(); patternIndex++)
        {
         //--- Check if pattern should be displayed
         if(patternIndex==TRENDLIKE1_ABCD && (!Show_trendlike1_abcd || !Show_abcd)) continue;
         if(patternIndex==TRENDLIKE2_ABCD && (!Show_trendlike2_abcd || !Show_abcd)) continue;
         if(patternIndex==PERFECT_ABCD && (!Show_perfect_abcd || !Show_abcd)) continue;
         if(patternIndex==IDEAL1_ABCD && (!Show_ideal1_abcd || !Show_abcd)) continue;
         if(patternIndex==IDEAL2_ABCD && (!Show_ideal2_abcd || !Show_abcd)) continue;
         if(patternIndex==RANGELIKE_ABCD && (!Show_rangelike_abcd || !Show_abcd)) continue;
         if(patternIndex==ALT127_TRENDLIKE1_ABCD && (!Show_alt127_trendlike1_abcd || !Show_alt127_abcd)) continue;
         if(patternIndex==ALT127_TRENDLIKE2_ABCD && (!Show_alt127_trendlike2_abcd || !Show_alt127_abcd)) continue;
         if(patternIndex==ALT127_PERFECT_ABCD && (!Show_alt127_perfect_abcd || !Show_alt127_abcd)) continue;
         if(patternIndex==ALT127_IDEAL1_ABCD && (!Show_alt127_ideal1_abcd || !Show_alt127_abcd)) continue;
         if(patternIndex==ALT127_IDEAL2_ABCD && (!Show_alt127_ideal2_abcd || !Show_alt127_abcd)) continue;
         if(patternIndex==ALT127_RANGELIKE_ABCD && (!Show_alt127_rangelike_abcd || !Show_alt127_abcd)) continue;
         if(patternIndex==REC_TRENDLIKE1_ABCD && (!Show_rec_trendlike1_abcd || !Show_rec_abcd)) continue;
         if(patternIndex==REC_TRENDLIKE2_ABCD && (!Show_rec_trendlike2_abcd || !Show_rec_abcd)) continue;
         if(patternIndex==REC_PERFECT_ABCD && (!Show_rec_perfect_abcd || !Show_rec_abcd)) continue;
         if(patternIndex==REC_IDEAL1_ABCD && (!Show_rec_ideal1_abcd || !Show_rec_abcd)) continue;
         if(patternIndex==REC_IDEAL2_ABCD && (!Show_rec_ideal2_abcd || !Show_rec_abcd)) continue;
         if(patternIndex==REC_RANGELIKE_ABCD && (!Show_rec_rangelike_abcd || !Show_rec_abcd)) continue;
         if(patternIndex==GARTLEY && (!Show_gartley || !Show_patterns)) continue;
         if(patternIndex==BAT && (!Show_bat || !Show_patterns)) continue;
         if(patternIndex==ALTBAT && (!Show_altbat || !Show_patterns)) continue;
         if(patternIndex==FIVEO && (!Show_fiveo || !Show_patterns)) continue;
         if(patternIndex==BUTTERFLY && (!Show_butterfly || !Show_patterns)) continue;
         if(patternIndex==CRAB && (!Show_crab || !Show_patterns)) continue;
         if(patternIndex==DEEPCRAB && (!Show_deepcrab || !Show_patterns)) continue;
         if(patternIndex==THREEDRIVES && (!Show_threedrives || !Show_patterns)) continue;
         if(patternIndex==CYPHER && (!Show_cypher || !Show_patterns)) continue;
         if(patternIndex==SHARK && (!Show_shark || !Show_patterns)) continue;
         if(patternIndex==NENSTAR && (!Show_nenstar || !Show_patterns)) continue;
         if(patternIndex==BLACKSWAN && (!Show_blackswan || !Show_patterns)) continue;
         if(patternIndex==WHITESWAN && (!Show_whiteswan || !Show_patterns)) continue;
         if(patternIndex==ONE2ONE && (!Show_one2one || !Show_patterns)) continue;
         if(patternIndex==NEWCYPHER && (!Show_newCypher || !Show_patterns)) continue;
         if(patternIndex==NAVARRO200 && (!Show_navarro200 || !Show_patterns)) continue;
         if(patternIndex==LEONARDO && (!Show_leonardo || !Show_patterns)) continue;
         if(patternIndex==KANE && (!Show_kane || !Show_patterns)) continue;
         if(patternIndex==GARFLY && (!Show_garfly || !Show_patterns)) continue;
         if(patternIndex==MAXBAT && (!Show_maxbat || !Show_patterns)) continue;
         if(patternIndex==MAXGARTLEY && (!Show_maxgartley || !Show_patterns)) continue;
         if(patternIndex==MAXBUTTERFLY && (!Show_maxbutterfly || !Show_patterns)) continue;
         if(patternIndex==GARTLEY113 && (!Show_gartley113 || !Show_patterns)) continue;
         if(patternIndex==BUTTERFLY113 && (!Show_butterfly113 || !Show_patterns)) continue;
         if(patternIndex==ANTI_GARTLEY && (!Show_antigartley || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_BAT && (!Show_antibat || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_ALTBAT && (!Show_antialtbat || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_FIVEO && (!Show_antifiveo || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_BUTTERFLY && (!Show_antibutterfly || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_CRAB && (!Show_anticrab || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_DEEPCRAB && (!Show_antideepcrab || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_THREEDRIVES && (!Show_antithreedrives || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_CYPHER && (!Show_anticypher || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_SHARK && (!Show_antishark || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_NENSTAR && (!Show_antinenstar || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_BLACKSWAN && (!Show_antiblackswan || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_WHITESWAN && (!Show_antiwhiteswan || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_ONE2ONE && (!Show_antione2one || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_NEWCYPHER && (!Show_antinewCypher || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_NAVARRO200 && (!Show_antinavarro200 || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_LEONARDO && (!Show_antileonardo || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_KANE && (!Show_antikane || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_GARFLY && (!Show_antigarfly || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_MAXBAT && (!Show_antimaxbat || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_MAXGARTLEY && (!Show_antimaxgartley || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_MAXBUTTERFLY && (!Show_antimaxbutterfly || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_GARTLEY113 && (!Show_antigartley113 || !Show_antipatterns)) continue;
         if(patternIndex==ANTI_BUTTERFLY113 && (!Show_antibutterfly113 || !Show_antipatterns)) continue;
         PATTERN_DESCRIPTOR pattern=_patterns[patternIndex];
         //--- What constraints does the pattern have?
         bool ab2xaConstraint=pattern.ab2xa_max!=0 && pattern.ab2xa_min!=0;
         bool ad2xaConstraint=pattern.ad2xa_max!=0 && pattern.ad2xa_min!=0;
         bool bc2abConstraint=pattern.bc2ab_max!=0 && pattern.bc2ab_min!=0;
         bool cd2bcConstraint=pattern.cd2bc_max!=0 && pattern.cd2bc_min!=0;
         bool cd2xcConstraint=pattern.cd2xc_max!=0 && pattern.cd2xc_min!=0;
         bool xc2xaConstraint=pattern.xc2xa_max!=0 && pattern.xc2xa_min!=0;
         bool cd2abConstraint=pattern.cd2ab_max!=0 && pattern.cd2ab_min!=0;
         //--- Which constraints are unary vs range?
         double ab2xaSlack=pattern.ab2xa_max==pattern.ab2xa_min ? SlackUnary : SlackRange;
         double ad2xaSlack=pattern.ad2xa_max==pattern.ad2xa_min ? SlackUnary : SlackRange;
         double bc2abSlack=pattern.bc2ab_max==pattern.bc2ab_min ? SlackUnary : SlackRange;
         double cd2bcSlack=pattern.cd2bc_max==pattern.cd2bc_min ? SlackUnary : SlackRange;
         double cd2xcSlack=pattern.cd2xc_max==pattern.cd2xc_min ? SlackUnary : SlackRange;
         double xc2xaSlack=pattern.xc2xa_max==pattern.xc2xa_min ? SlackUnary : SlackRange;
         double cd2abSlack=pattern.cd2ab_max==pattern.cd2ab_min ? SlackUnary : SlackRange;
         //--- Start searching from current bar - 'BarsAnalyzed'
         _projectionInstanceCounter=0;
         bool xFirstRun=true;
         for(int XIndex=bar-BarsAnalyzed; XIndex<=bar && !IsStopped(); XIndex++)
           {
            if(XIndex<=0)
               continue;
            bool isPeak=IsProperValue(peaks[XIndex]);
            bool isTrough=IsProperValue(troughs[XIndex]);
            if(!isPeak && !isTrough)
               continue;
            bool startsInTrough=isTrough;
            bool xVerticalZZ=isPeak && isTrough;
            bool xZZDirection=!startsInTrough;
            if(xVerticalZZ)
              {
               if(xFirstRun)
                  startsInTrough=!startsInTrough;
               int zzDirection=ZigZagDirection(XIndex);
               if(zzDirection==0) continue;
               else if(zzDirection==-1) xZZDirection=false;
               else if(zzDirection==1) xZZDirection=true;
              }
            double X=startsInTrough ? troughs[XIndex]: peaks[XIndex];
            double extremeA=startsInTrough ? DBL_MIN : DBL_MAX;
            //--- Skip first AIndex if vertical zz at X and opposite extremum is before X 
            int aSkip=0;
            if(xVerticalZZ && ((xZZDirection && !startsInTrough) || (!xZZDirection && startsInTrough))) aSkip=1;
            for(int AIndex=XIndex+aSkip; AIndex<=bar && !IsStopped(); AIndex++)
              {
               //--- Ensure that X is the extremum on [X, A], i.e. there is no lower low (higher high)
               int extremeIndexXA=XIndex==AIndex ? AIndex : AIndex-1;
               if((startsInTrough && IsProperValue(troughs[extremeIndexXA]) && troughs[extremeIndexXA]<X)
                  || (!startsInTrough && IsProperValue(peaks[extremeIndexXA]) && peaks[extremeIndexXA]>X))
                  break;
               if((XIndex!=AIndex && IsProperValue(troughs[AIndex]) && IsProperValue(peaks[AIndex]))
                  && ((startsInTrough && ZigZagDirection(AIndex)==1 && troughs[AIndex]<X)
                  || (!startsInTrough && ZigZagDirection(AIndex)==-1 && peaks[AIndex]>X)))
                  break;
               //--- Only check increasing (decreasing) A's
               double A=startsInTrough ? peaks[AIndex]: troughs[AIndex];
               if(!IsProperValue(A) || (startsInTrough && A<extremeA) || (!startsInTrough && A>extremeA))
                  continue;
               extremeA=A;
               //--- For ratios
               double XA=MathAbs(A-X);
               if(XA==0)
                  continue;
               //--- Find B index
               double extremeB=startsInTrough ? DBL_MAX : DBL_MIN;
               //--- Skip first BIndex if vertical zz at X and both X and A is on it
               int bSkip=0;
               if(XIndex==AIndex) bSkip=1;
               for(int BIndex=AIndex+bSkip; BIndex<=bar && !IsStopped(); BIndex++)
                 {
                  //--- Ensure that A is the extremum on [A, B], i.e. there is no higher high (lower low)
                  int extremeIndexAB=AIndex==BIndex ? BIndex : BIndex-1;
                  if((!startsInTrough && IsProperValue(troughs[extremeIndexAB]) && troughs[extremeIndexAB]<A)
                     || (startsInTrough && IsProperValue(peaks[extremeIndexAB]) && peaks[extremeIndexAB]>A))
                     break;
                  if((AIndex!=BIndex && IsProperValue(troughs[BIndex]) && IsProperValue(peaks[BIndex]))
                     && ((!startsInTrough && ZigZagDirection(BIndex)==1  &&  troughs[BIndex]<A)
                     || (startsInTrough  &&  ZigZagDirection(BIndex)==-1  &&  peaks[BIndex]>A)))
                     break;
                  //--- Only check decreasing (increasing) B's
                  double B=startsInTrough ? troughs[BIndex]: peaks[BIndex];
                  if(!IsProperValue(B) || (startsInTrough && B>extremeB) || (!startsInTrough && B<extremeB))
                     continue;
                  extremeB=B;
                  //--- Second check for vertical ZZ at AB leg and B comes before A
                  if(AIndex==BIndex)
                    {
                     int zzDirection=ZigZagDirection(AIndex);
                     if(zzDirection==0) continue;
                     else if(zzDirection==-1 && !startsInTrough) continue;
                     else if(zzDirection==1 && startsInTrough) continue;
                    }
                  //--- Ratios
                  double AB=MathAbs(A-B);
                  if(AB==0)
                     continue;
                  double ab2xaRatio=AB/XA;
                  //--- Possible analytical continue: B does not extend far enough evidenced by 'ab2xaRatio' being too short
                  bool ab2xaContinue=ab2xaConstraint;
                  ab2xaContinue&=ab2xaRatio<pattern.ab2xa_min-ab2xaSlack;
                  if(ab2xaContinue)
                     continue;
                  //--- Possible analytical cutoff: B extends too far evidenced by 'ab2xaRatio' being too large
                  bool ab2xaCutoff=ab2xaConstraint;
                  ab2xaCutoff&=ab2xaRatio>pattern.ab2xa_max+ab2xaSlack;
                  if(ab2xaCutoff)
                     break;
                  //--- Find C
                  double extremeC=startsInTrough ? DBL_MIN : DBL_MAX;
                  //--- Skip first CIndex if vertical zz at B and both A and B is on it
                  int cSkip=0;
                  if(AIndex==BIndex) cSkip = 1;
                  for(int CIndex=BIndex+cSkip; CIndex<=bar && !IsStopped(); CIndex++)
                    {
                     //--- Ensure that B is the extremum on [B, C], i.e. there is no lower low (higher high)
                     int extremeIndexBC=BIndex==CIndex ? CIndex : CIndex-1;
                     if((startsInTrough && IsProperValue(troughs[extremeIndexBC]) && troughs[extremeIndexBC]<B)
                        || (!startsInTrough && IsProperValue(peaks[extremeIndexBC]) && peaks[extremeIndexBC]>B))
                        break;
                     if((BIndex!=CIndex && IsProperValue(troughs[CIndex]) && IsProperValue(peaks[CIndex]))
                        && ((startsInTrough && ZigZagDirection(CIndex)==1 && troughs[CIndex]<B)
                        || (!startsInTrough && ZigZagDirection(CIndex)==-1 && peaks[CIndex]>B)))
                        break;
                     //--- Only check increasing (decreasing) C's
                     double C=startsInTrough ? peaks[CIndex]: troughs[CIndex];
                     if(!IsProperValue(C))
                        continue;
                     if((startsInTrough && C<extremeC) || (!startsInTrough && C>extremeC))
                        continue;
                     extremeC=C;
                     //--- Second check for vertical ZZ at BC leg and C comes before B
                     if(BIndex==CIndex)
                       {
                        int zzDirection=ZigZagDirection(BIndex);
                        if(zzDirection==0) continue;
                        else if(zzDirection==-1 && startsInTrough) continue;
                        else if(zzDirection==1 && !startsInTrough) continue;
                       }
                     //--- Ratios
                     double BC=MathAbs(C-B);
                     double XC=MathAbs(X-C);
                     if(BC==0) continue;
                     if(XC==0) continue;
                     double bc2abRatio=BC/AB;
                     double xc2xaRatio=XC/XA;
                     //--- Analytical continue: C not far enough by short 'bc2abRatio' or 'xc2xaRatio'
                     bool bc2abContinue=bc2abConstraint;
                     bool xc2xaContinue=xc2xaConstraint;
                     bc2abContinue&=bc2abRatio<pattern.bc2ab_min-bc2abSlack;
                     xc2xaContinue&=xc2xaRatio<pattern.xc2xa_min-xc2xaSlack;
                     if(bc2abContinue || xc2xaContinue)
                        continue;
                     //--- Analytical cutoff: C too far by long 'bc2abRatio' or 'xc2xaRatio'
                     bool bc2abCutoff=bc2abConstraint;
                     bool xc2xaCutoff=xc2xaConstraint;
                     bc2abCutoff&=bc2abRatio>pattern.bc2ab_max+bc2abSlack;
                     xc2xaCutoff&=xc2xaRatio>pattern.xc2xa_max+xc2xaSlack;
                     if(bc2abCutoff || xc2xaCutoff)
                        break;
                     //--- Check if C is the extreme until end-of-search, only then it should be used to project
                     bool lastExtremeC=true;
                     for(int i=CIndex+1; i<=bar; i++)
                       {
                        if((startsInTrough && IsProperValue(peaks[i]) && peaks[i]>C)
                           || (!startsInTrough && IsProperValue(troughs[i]) && troughs[i]<C))
                          {
                           lastExtremeC=false;
                           break;
                          }
                       }
                     //--- Find D
                     double extremeD=startsInTrough ? DBL_MAX : DBL_MIN;
                     //--- Skip first DIndex if vertical zz at C and both B and C is on it
                     int dSkip=0;
                     if(BIndex==CIndex) dSkip = 1;
                     for(int DIndex=CIndex+dSkip; DIndex<=bar && !IsStopped(); DIndex++)
                       {
                        //--- Ensure that C is the extremum on [C, D], i.e. there is no higher high (lower low)
                        int extremeIndexCD=CIndex==DIndex ? DIndex : DIndex-1;
                        if((!startsInTrough && IsProperValue(troughs[extremeIndexCD]) && troughs[extremeIndexCD]<C)
                           || (startsInTrough && IsProperValue(peaks[extremeIndexCD]) && peaks[extremeIndexCD]>C))
                           break;
                        if((CIndex!=DIndex && IsProperValue(troughs[DIndex]) && IsProperValue(peaks[DIndex]))
                           && ((!startsInTrough && ZigZagDirection(DIndex)==1  &&  troughs[DIndex]<C)
                           || (startsInTrough  &&  ZigZagDirection(DIndex)==-1  &&  peaks[DIndex]>C)))
                           break;
                        //--- If CIndex is last, use imaginary D for projections
                        bool imaginaryD=((startsInTrough && CIndex==lastPeak && lastTrough<=lastPeak)
                                         || (!startsInTrough && CIndex==lastTrough && lastPeak<=lastTrough));
                        if(imaginaryD && lastPeak==lastTrough)
                           imaginaryD &=(startsInTrough && ZigZagDirection(lastPeak)==1)
                                        || (!startsInTrough && ZigZagDirection(lastPeak)==-1);
                        //--- Only check decreasing (increasing) D's
                        double D=startsInTrough ? troughs[DIndex]: peaks[DIndex];
                        if(!imaginaryD && (!IsProperValue(D) || (startsInTrough && D>extremeD) || (!startsInTrough && D<extremeD)))
                           continue;
                        extremeD=D;
                        //--- Second check for vertical ZZ at CD leg and D comes before C
                        if(!imaginaryD && CIndex==DIndex)
                          {
                           int zzDirection=ZigZagDirection(CIndex);
                           if(zzDirection==0) continue;
                           else if(zzDirection==-1 && !startsInTrough) continue;
                           else if(zzDirection==1 && startsInTrough) continue;
                          }
                        //--- Check if D is the extreme until end-of-search, only then it should be used to project
                        bool lastExtremeD=true;
                        if(!imaginaryD)
                          {
                           for(int i=DIndex+1; i<=bar; i++)
                             {
                              if((!startsInTrough && IsProperValue(peaks[i]) && peaks[i]>D)
                                 || (startsInTrough && IsProperValue(troughs[i]) && troughs[i]<D))
                                {
                                 lastExtremeD=false;
                                 break;
                                }
                             }
                          }
                        //--- Check if potential pattern is on active swing (rightmost on chart)
                        bool activeSwing=((endsInTrough && startsInTrough && DIndex==lastTrough) || (!endsInTrough && !startsInTrough && DIndex==lastPeak));
                        //--- Analytical solution to harmonic window
                        double nearD_cd2bc;
                        double nearD_ad2xa;
                        double nearD_cd2xc;
                        double nearD_cd2ab;
                        double farD_cd2bc;
                        double farD_ad2xa;
                        double farD_cd2xc;
                        double farD_cd2ab;
                        if(startsInTrough)
                          {
                           nearD_cd2bc=C-(pattern.cd2bc_min-cd2bcSlack)*BC;
                           nearD_ad2xa=A-(pattern.ad2xa_min-ad2xaSlack)*XA;
                           nearD_cd2xc=C-(pattern.cd2xc_min-cd2xcSlack)*XC;
                           nearD_cd2ab=C-(pattern.cd2ab_min-cd2abSlack)*AB;
                           farD_cd2bc=C-(pattern.cd2bc_max+cd2bcSlack)*BC;
                           farD_ad2xa=A-(pattern.ad2xa_max+ad2xaSlack)*XA;
                           farD_cd2xc=C-(pattern.cd2xc_max+cd2xcSlack)*XC;
                           farD_cd2ab=C-(pattern.cd2ab_max+cd2abSlack)*AB;
                          }
                        else
                          {
                           nearD_cd2bc=C+(pattern.cd2bc_min-cd2bcSlack)*BC;
                           nearD_ad2xa=A+(pattern.ad2xa_min-ad2xaSlack)*XA;
                           nearD_cd2xc=C+(pattern.cd2xc_min-cd2xcSlack)*XC;
                           nearD_cd2ab=C+(pattern.cd2ab_min-cd2abSlack)*AB;
                           farD_cd2bc=C+(pattern.cd2bc_max+cd2bcSlack)*BC;
                           farD_ad2xa=A+(pattern.ad2xa_max+ad2xaSlack)*XA;
                           farD_cd2xc=C+(pattern.cd2xc_max+cd2xcSlack)*XC;
                           farD_cd2ab=C+(pattern.cd2ab_max+cd2abSlack)*AB;
                          }
                        double nearD=startsInTrough ? DBL_MAX : DBL_MIN;
                        double farD=startsInTrough ? DBL_MIN : DBL_MAX;
                        if(cd2bcConstraint)
                          {
                           nearD=startsInTrough ? MathMin(nearD,nearD_cd2bc) : MathMax(nearD,nearD_cd2bc);
                           farD=startsInTrough ? MathMax(farD,farD_cd2bc) : MathMin(farD,farD_cd2bc);
                          }
                        if(ad2xaConstraint)
                          {
                           nearD=startsInTrough ? MathMin(nearD,nearD_ad2xa) : MathMax(nearD,nearD_ad2xa);
                           farD=startsInTrough ? MathMax(farD,farD_ad2xa) : MathMin(farD,farD_ad2xa);
                          }
                        if(cd2xcConstraint)
                          {
                           nearD=startsInTrough ? MathMin(nearD,nearD_cd2xc) : MathMax(nearD,nearD_cd2xc);
                           farD=startsInTrough ? MathMax(farD,farD_cd2xc) : MathMin(farD,farD_cd2xc);
                          }
                        if(cd2abConstraint)
                          {
                           nearD=startsInTrough ? MathMin(nearD,nearD_cd2ab) : MathMax(nearD,nearD_cd2ab);
                           farD=startsInTrough ? MathMax(farD,farD_cd2ab) : MathMin(farD,farD_cd2ab);
                          }
                        //--- Imaginary D only used when no further D's can exist
                        if(imaginaryD && !OneAheadProjection)
                           break;
                        //--- Continue/Pattern undershot
                        else if(imaginaryD || (startsInTrough && D>nearD) || (!startsInTrough && D<nearD))
                          {
                           //--- The XABC are such that no D can satisfy the pattern
                           if((startsInTrough && farD>nearD) || (!startsInTrough && farD<nearD))
                              break;
                           //--- In these two cases, a match or overshot pattern can occur later
                           if(!lastExtremeC || !lastExtremeD)
                              continue;
                           if(!EmergingPatterns)
                              break;
                           //--- 4-point
                           if(Is4PointPattern(patternIndex))
                              StoreProjection(patternIndex,startsInTrough,0,0,time[AIndex],A,time[BIndex],B,time[CIndex],C,time[bar],nearD,farD);
                           //--- 5-point
                           else
                              StoreProjection(patternIndex,startsInTrough,time[XIndex],X,time[AIndex],A,time[BIndex],B,time[CIndex],C,time[bar],nearD,farD);
                           break;
                          }
                        //--- Cutoff
                        else if((startsInTrough && D<farD) || (!startsInTrough && D>farD))
                           break;
                        //--- Match
                        else
                          {
                           //--- Invalidate if overlapping
                           if(Overlaps(patternIndex,time[XIndex],time[AIndex],time[BIndex],time[CIndex],time[DIndex]))
                              continue;
                           //--- 4-point
                           if(Is4PointPattern(patternIndex))
                             {
                              DisplayPattern(patternIndex,startsInTrough,time[AIndex],A,time[BIndex],B,time[CIndex],C,time[DIndex],D);
                              if(activeSwing)
                                {
                                 StorePattern(patternIndex,startsInTrough,0,time[AIndex],time[BIndex],time[CIndex],time[DIndex]);
                                 if(Show_PRZ)
                                    DisplayPRZ(patternIndex,startsInTrough,time[AIndex],A,time[BIndex],time[CIndex],C,time[DIndex],D,farD);
                                }
                              else
                                 StoreOverlaps(patternIndex,0,time[AIndex],time[BIndex],time[CIndex],time[DIndex]);
                             }
                           //--- 5-point
                           else
                             {
                              DisplayPattern(patternIndex,startsInTrough,time[XIndex],X,time[AIndex],A,time[BIndex],B,time[CIndex],C,time[DIndex],D);
                              if(activeSwing)
                                {
                                 StorePattern(patternIndex,startsInTrough,time[XIndex],time[AIndex],time[BIndex],time[CIndex],time[DIndex]);
                                 if(Show_PRZ)
                                    DisplayPRZ(patternIndex,startsInTrough,time[XIndex],X,time[AIndex],A,time[BIndex],time[CIndex],C,time[DIndex],D,farD);
                                }
                              else
                                 StoreOverlaps(patternIndex,time[XIndex],time[AIndex],time[BIndex],time[CIndex],time[DIndex]);
                             }
                          }
                       } //--- End DIndex-loop
                    } //--- End CIndex-loop
                 } //--- End BIndex-loop
              } //--- End AIndex-loop
            //--- Run same XIndex twice if ZigZag is vertical
            if(xVerticalZZ)
              {
               if(xFirstRun)
                 {
                  XIndex--;
                  xFirstRun=false;
                 }
               else
                  xFirstRun=true;
              }
           } //--- End XIndex-loop
         //--- Sort projections
         for(int i=1; i<_projectionInstanceCounter; i++)
           {
            _projectionInstances[i].overlapping=false;
            int j=i;
            while(j>0 && _projectionInstances[j-1].D>_projectionInstances[j].D)
              {
               PATTERN_INSTANCE tmp=_projectionInstances[j];
               _projectionInstances[j]=_projectionInstances[j-1];
               _projectionInstances[j-1]=tmp;
               j--;
              }
           }
         _projectionInstances[0].overlapping=false;
         //--- Display projections
         bool forward=true;
         int i=0;
         while(_projectionInstanceCounter!=0)
           {
            bool bullish=_projectionInstances[i].bullish;
            if((forward && !bullish) || (!forward && bullish))
              {
               datetime XDateTime=_projectionInstances[i].XDateTime;
               datetime ADateTime=_projectionInstances[i].ADateTime;
               datetime BDateTime=_projectionInstances[i].BDateTime;
               datetime CDateTime=_projectionInstances[i].CDateTime;
               datetime DDateTime=_projectionInstances[i].DDateTime;
               double X=_projectionInstances[i].X;
               double A=_projectionInstances[i].A;
               double B=_projectionInstances[i].B;
               double C=_projectionInstances[i].C;
               double D=_projectionInstances[i].D;
               double farD=_projectionInstances[i].PRZ;
               //--- Invalidate projection if overlapping other patterns
               if(Overlaps(patternIndex,XDateTime,ADateTime,BDateTime,CDateTime,NON_EXISTENT_DATETIME))
                  _projectionInstances[i].overlapping=true;
               //--- Invalidate projection if overlapping other projections
               int j=i;
               while(true)
                 {
                  //--- Loop condition
                  if(forward)
                    {
                     if(j==0) break;
                     else j--;
                    }
                  else
                    {
                     if(j==_projectionInstanceCounter-1) break;
                     else j++;
                    }
                  //--- Overlap check
                  if(!_projectionInstances[j].overlapping && _projectionInstances[j].bullish==bullish)
                    {
                     datetime XDateTimeActive=_projectionInstances[j].XDateTime;
                     datetime ADateTimeActive=_projectionInstances[j].ADateTime;
                     datetime BDateTimeActive=_projectionInstances[j].BDateTime;
                     datetime CDateTimeActive=_projectionInstances[j].CDateTime;
                     datetime DDateTimeActive=_projectionInstances[j].DDateTime;
                     int numMatches=0;
                     if(!Is4PointPattern(patternIndex) && XDateTime==XDateTimeActive) numMatches++;
                     if(ADateTime==ADateTimeActive) numMatches++;
                     if(BDateTime==BDateTimeActive) numMatches++;
                     if(CDateTime==CDateTimeActive) numMatches++;
                     //if(DDateTime==DDateTimeActive) numMatches++;
                     if(numMatches>MaxSamePoints)
                       {
                        _projectionInstances[i].overlapping=true;
                        break;
                       }
                    }
                 }
               //--- Display projection
               if(!_projectionInstances[i].overlapping)
                 {
                  if(Is4PointPattern(patternIndex))
                     DisplayProjection(patternIndex,bullish,ADateTime,A,BDateTime,B,CDateTime,C,DDateTime,D);
                  else
                     DisplayProjection(patternIndex,bullish,XDateTime,X,ADateTime,A,BDateTime,B,CDateTime,C,DDateTime,D);
                  _drawnProjectionInstances[_drawnProjectionInstanceCounter]=_projectionInstances[i];
                  _drawnProjectionInstanceCounter++;
                  if(_drawnProjectionInstanceCounter>=_maxDrawnProjectionInstances)
                    {
                     _maxDrawnProjectionInstances*=2;
                     if(ArrayResize(_drawnProjectionInstances,_maxDrawnProjectionInstances)<_maxDrawnProjectionInstances)
                        printf("Error allocating array");
                    }
                 }
              }
            //--- Loop condition
            if(forward)
              {
               if(i==_projectionInstanceCounter-1) forward=false;
               else i++;
              }
            else
              {
               if(i==0) break;
               else i--;
              }
           }
        }
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Helper method determines 4 point patterns                        |
//+------------------------------------------------------------------+
bool Is4PointPattern(int patternIndex)
  {
   if(patternIndex == TRENDLIKE1_ABCD) return true;
   if(patternIndex == TRENDLIKE2_ABCD) return true;
   if(patternIndex == PERFECT_ABCD) return true;
   if(patternIndex == IDEAL1_ABCD) return true;
   if(patternIndex == IDEAL2_ABCD) return true;
   if(patternIndex == RANGELIKE_ABCD) return true;
   if(patternIndex == ALT127_TRENDLIKE1_ABCD) return true;
   if(patternIndex == ALT127_TRENDLIKE2_ABCD) return true;
   if(patternIndex == ALT127_PERFECT_ABCD) return true;
   if(patternIndex == ALT127_IDEAL1_ABCD) return true;
   if(patternIndex == ALT127_IDEAL2_ABCD) return true;
   if(patternIndex == ALT127_RANGELIKE_ABCD) return true;
   if(patternIndex == REC_TRENDLIKE1_ABCD) return true;
   if(patternIndex == REC_TRENDLIKE2_ABCD) return true;
   if(patternIndex == REC_PERFECT_ABCD) return true;
   if(patternIndex == REC_IDEAL1_ABCD) return true;
   if(patternIndex == REC_IDEAL2_ABCD) return true;
   if(patternIndex == REC_RANGELIKE_ABCD) return true;
   return false;
  }
//+------------------------------------------------------------------+
//| Helper method finds ZigZag direction in before index             |
//+------------------------------------------------------------------+
int ZigZagDirection(int index)
  {
   int lastPeakBefore=FirstNonZeroFrom(index-1,peaks);
   int lastTroughBefore=FirstNonZeroFrom(index-1,troughs);
   while(lastPeakBefore==lastTroughBefore)
     {
      lastPeakBefore=FirstNonZeroFrom(lastPeakBefore-1,peaks);
      lastTroughBefore=FirstNonZeroFrom(lastTroughBefore-1,troughs);
      if(lastPeakBefore==-1 || lastTroughBefore==-1) return 0;
     }
   if(lastPeakBefore==-1 || lastTroughBefore==-1) return 0;
   else if(lastPeakBefore<lastTroughBefore) return -1;
   else return 1;
  }
//+------------------------------------------------------------------+
//| Helper method finds first proper value from start                |
//+------------------------------------------------------------------+
int FirstNonZeroFrom(int start,double &array[])
  {
   for(int j=start; j>=0; j--)
      if(IsProperValue(array[j]))
         return j;
   return -1;
  }
//+------------------------------------------------------------------+
//| Helper method determines proper value                            |
//+------------------------------------------------------------------+
bool IsProperValue(double value)
  {
   return (value!=0 && value!=EMPTY_VALUE);
  }
//+------------------------------------------------------------------+
//| Comment                                                          |
//+------------------------------------------------------------------+
void ShowComment(string sComment)
  {
   if(sComment!="")
     {
      com9=com8; //--- discards last comment line
      com8=com7; //--- and shifts
      com7=com6;
      com6=com5;
      com5=com4;
      com4=com3;
      com3=com2;
      com2=com1;
      com1=sComment;
     }
   Comment("HarmonicPatternFinderV2 © 2016","\n","\n",com1,"\n",com2,"\n",com3,"\n",com4,"\n",com5,"\n",com6,"\n",com7,"\n",com8,"\n",com9,"\n");
  }
//+------------------------------------------------------------------+
//| Helper method checks if pattern overlaps                         |
//+------------------------------------------------------------------+
bool Overlaps(int k,datetime XDateTime,datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
  {
   bool overlaps=false;
//--- Check old patterns in fixed size ring buffer
   for(int i=0; i<SIZE_PATTERN_BUFFER; i++)
     {
      int numMatches=0;
      if(!Is4PointPattern(k) && XDateTime==_patternX[k][i]) numMatches++;
      if(ADateTime==_patternA[k][i]) numMatches++;
      if(BDateTime==_patternB[k][i]) numMatches++;
      if(CDateTime==_patternC[k][i]) numMatches++;
      if(DDateTime==_patternD[k][i]) numMatches++;
      if(numMatches>MaxSamePoints)
         return true;
     }
//--- Check active patterns in unlimited size array
   for(int i=0; i<_patternInstanceCounter; i++)
     {
      PATTERN_INSTANCE instance=_patternInstances[i];
      int patternIndexActive=_patternInstances[i].patternIndex;
      if(patternIndexActive!=k)
         continue;
      bool bullish=instance.bullish;
      datetime XDateTimeActive=instance.XDateTime;
      datetime ADateTimeActive=instance.ADateTime;
      datetime BDateTimeActive=instance.BDateTime;
      datetime CDateTimeActive=instance.CDateTime;
      datetime DDateTimeActive=instance.DDateTime;
      int numMatches=0;
      if(!Is4PointPattern(k) && XDateTime==XDateTimeActive) numMatches++;
      if(ADateTime==ADateTimeActive) numMatches++;
      if(BDateTime==BDateTimeActive) numMatches++;
      if(CDateTime==CDateTimeActive) numMatches++;
      if(DDateTime==DDateTimeActive) numMatches++;
      if(numMatches>MaxSamePoints)
         return true;
     }
   return false;
  }
//+------------------------------------------------------------------+
//| Helper method stores if pattern overlaps                         |
//+------------------------------------------------------------------+
void StoreOverlaps(int k,datetime XDateTime,datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
  {
   int index=_patternCounter[k];
   _patternCounter[k]=(index+1)%SIZE_PATTERN_BUFFER;
   _patternX[k][index]=XDateTime;
   _patternA[k][index]=ADateTime;
   _patternB[k][index]=BDateTime;
   _patternC[k][index]=CDateTime;
   _patternD[k][index]=DDateTime;
  }
//+------------------------------------------------------------------+
//| Helper method stores patterns                                    |
//+------------------------------------------------------------------+
void StorePattern(int k,bool bullish,datetime XDateTime,datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
  {
   _patternInstances[_patternInstanceCounter].patternIndex=k;
   _patternInstances[_patternInstanceCounter].bullish=bullish;
   _patternInstances[_patternInstanceCounter].XDateTime=XDateTime;
   _patternInstances[_patternInstanceCounter].ADateTime=ADateTime;
   _patternInstances[_patternInstanceCounter].BDateTime=BDateTime;
   _patternInstances[_patternInstanceCounter].CDateTime=CDateTime;
   _patternInstances[_patternInstanceCounter].DDateTime=DDateTime;
   _patternInstanceCounter++;
   if(_patternInstanceCounter>=_maxPatternInstances)
     {
      _maxPatternInstances*=2;
      if(ArrayResize(_patternInstances,_maxPatternInstances)<_maxPatternInstances)
         printf("Error allocating array");
     }
  }
//+------------------------------------------------------------------+
//| Helper method stores projections                                 |
//+------------------------------------------------------------------+
void StoreProjection(int k,bool bullish,
                     datetime XDateTime,double X,
                     datetime ADateTime,double A,
                     datetime BDateTime,double B,
                     datetime CDateTime,double C,
                     datetime DDateTime,double D,
                     double farD)
  {
   _projectionInstances[_projectionInstanceCounter].patternIndex=k;
   _projectionInstances[_projectionInstanceCounter].bullish=bullish;
   _projectionInstances[_projectionInstanceCounter].XDateTime=XDateTime;
   _projectionInstances[_projectionInstanceCounter].ADateTime=ADateTime;
   _projectionInstances[_projectionInstanceCounter].BDateTime=BDateTime;
   _projectionInstances[_projectionInstanceCounter].CDateTime=CDateTime;
   _projectionInstances[_projectionInstanceCounter].DDateTime=DDateTime;
   _projectionInstances[_projectionInstanceCounter].X=X;
   _projectionInstances[_projectionInstanceCounter].A=A;
   _projectionInstances[_projectionInstanceCounter].B=B;
   _projectionInstances[_projectionInstanceCounter].C=C;
   _projectionInstances[_projectionInstanceCounter].D=D;
   _projectionInstances[_projectionInstanceCounter].PRZ=farD;
   _projectionInstanceCounter++;
   if(_projectionInstanceCounter>=_maxProjectionInstances)
     {
      _maxProjectionInstances*=2;
      if(ArrayResize(_projectionInstances,_maxProjectionInstances)<_maxProjectionInstances)
         printf("Error allocating array");
     }
  }
//+------------------------------------------------------------------+
//| Helper method displays 4-point PRZ                               |
//+------------------------------------------------------------------+
void DisplayPRZ(int k,bool bullish,
                datetime ADateTime,double A,
                datetime BDateTime,
                datetime CDateTime,double C,
                datetime DDateTime,double D,
                double farD)
  {
   string unique=UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime);
   string prefix=(bullish ? "Bullish " : "Bearish ");
   string prefixName=(bullish ? "U "+_identifier : "D "+_identifier);
   string name=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PRZ"+unique;
   ObjectCreate(0,name,OBJ_TREND,0,DDateTime-1,farD,DDateTime,farD);
   ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,true);
   ObjectSetInteger(0,name,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
   ObjectSetInteger(0,name,OBJPROP_STYLE,Style_PRZ);
   ObjectSetString(0,name,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PRZ stop "+DoubleToString(farD));
  }
//+------------------------------------------------------------------+
//| Helper method displays 5-point PRZ                               |
//+------------------------------------------------------------------+
void DisplayPRZ(int k,bool bullish,
                datetime XDateTime,double X,
                datetime ADateTime,double A,
                datetime BDateTime,
                datetime CDateTime,double C,
                datetime DDateTime,double D,
                double farD)
  {
   string unique=UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
   string prefix=(bullish ? "Bullish " : "Bearish ");
   string prefixName=(bullish ? "U "+_identifier : "D "+_identifier);
   string name=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PRZ"+unique;
   ObjectCreate(0,name,OBJ_TREND,0,DDateTime-1,farD,DDateTime,farD);
   ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,true);
   ObjectSetInteger(0,name,OBJPROP_COLOR,bullish ? ClrBull: ClrBear);
   ObjectSetInteger(0,name,OBJPROP_STYLE,Style_PRZ);
   ObjectSetString(0,name,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PRZ stop "+DoubleToString(farD));
  }
//+------------------------------------------------------------------+
//| Helper method displays 4-point patterns                          |
//+------------------------------------------------------------------+
void DisplayPattern(int k,bool bullish,
                    datetime ADateTime,double A,
                    datetime BDateTime,double B,
                    datetime CDateTime,double C,
                    datetime DDateTime,double D)
  {
   string unique=UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime);
   string prefix=(bullish ? "Bullish " : "Bearish ");
   string prefixName=(bullish ? "U "+_identifier : "D "+_identifier);
   string name0=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
   string name1=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
   string name2=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
   string pointA=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
   string pointB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
   string pointC=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
   string pointD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
//--- Create lines on the chart
   ObjectCreate(0,name0,OBJ_TREND,0,ADateTime,A,BDateTime,B);
   ObjectCreate(0,name1,OBJ_TREND,0,BDateTime,B,CDateTime,C);
   ObjectCreate(0,name2,OBJ_ARROWED_LINE,0,CDateTime,C,DDateTime,D);
   ObjectSetInteger(0,name0,OBJPROP_COLOR, bullish ? ClrBull4P : ClrBear4P);
   ObjectSetInteger(0,name1,OBJPROP_COLOR, bullish ? ClrBull4P : ClrBear4P);
   ObjectSetInteger(0,name2,OBJPROP_COLOR, bullish ? ClrBull4P : ClrBear4P);
   ObjectSetInteger(0,name0,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name1,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name2,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name0,OBJPROP_WIDTH,l_width4p);
   ObjectSetInteger(0,name1,OBJPROP_WIDTH,l_width4p);
   ObjectSetInteger(0,name2,OBJPROP_WIDTH,l_width4p);
   ObjectSetInteger(0,name0,OBJPROP_STYLE,Style_4P);
   ObjectSetInteger(0,name1,OBJPROP_STYLE,Style_4P);
   ObjectSetInteger(0,name2,OBJPROP_STYLE,Style_4P);
   ObjectSetString(0,name0,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" AB");
   ObjectSetString(0,name1,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BC");
   ObjectSetString(0,name2,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" CD");
   if(Show_descriptions)
     {
      int numOverlapping=0;
      for(int i=0; i<NUM_PATTERNS; i++)
        {
         for(int j=0; j<SIZE_PATTERN_BUFFER; j++)
           {
            if(ADateTime==_patternX[i][j]) numOverlapping++;
            if(Is4PointPattern(i) && ADateTime==_patternA[i][j]) numOverlapping++;
           }
        }
      for(int i=0; i<_patternInstanceCounter; i++)
        {
         PATTERN_INSTANCE instance=_patternInstances[i];
         int patternIndexActive=_patternInstances[i].patternIndex;
         datetime XDateTimeActive=instance.XDateTime;
         datetime ADateTimeActive=instance.ADateTime;
         if(ADateTime==XDateTimeActive) numOverlapping++;
         if(Is4PointPattern(patternIndexActive) && ADateTime==ADateTimeActive) numOverlapping++;
        }
      int x1=0;
      int y1=0;
      int x2=0;
      int y2=0;
      ChartTimePriceToXY(0,0,ADateTime,A,x1,y1);
      ChartTimePriceToXY(0,0,ADateTime,A+1,x2,y2);
      double pixelsPerPrice=MathAbs(y1-y2);
      double change=pixelsPerPrice!=0 ? numOverlapping*(Font_size)/pixelsPerPrice : 0;
      double price=(bullish ? A+change : A-change);
      ObjectCreate(0,pointA,OBJ_TEXT,0,ADateTime,price);
      ObjectCreate(0,pointB,OBJ_TEXT,0,BDateTime,B);
      ObjectCreate(0,pointC,OBJ_TEXT,0,CDateTime,C);
      ObjectCreate(0,pointD,OBJ_TEXT,0,DDateTime,D);
      ObjectSetString(0,pointA,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PA");
      ObjectSetString(0,pointB,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PB");
      ObjectSetString(0,pointC,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PC");
      ObjectSetString(0,pointD,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PD");
      ObjectSetString(0,pointA,OBJPROP_TEXT,"A "+prefix+_patternNames[k]);
      ObjectSetString(0,pointA,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointA,OBJPROP_FONTSIZE,08);
      ObjectSetInteger(0,pointA,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
      ObjectSetString(0,pointB,OBJPROP_TEXT,"B");
      ObjectSetString(0,pointB,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointB,OBJPROP_FONTSIZE,08);
      ObjectSetInteger(0,pointB,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
      ObjectSetString(0,pointC,OBJPROP_TEXT,"C");
      ObjectSetString(0,pointC,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointC,OBJPROP_FONTSIZE,08);
      ObjectSetInteger(0,pointC,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
      ObjectSetString(0,pointD,OBJPROP_TEXT,"D");
      ObjectSetString(0,pointD,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointD,OBJPROP_FONTSIZE,08);
      ObjectSetInteger(0,pointD,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
     }
   if(showPatternNames)
      ShowComment(prefix+_patternNames[k]+" @ "+TimeToString(DDateTime));
  }
//+------------------------------------------------------------------+
//| Helper method displays 5-point patterns                          |
//+------------------------------------------------------------------+
void DisplayPattern(int k,bool bullish,
                    datetime XDateTime,double X,
                    datetime ADateTime,double A,
                    datetime BDateTime,double B,
                    datetime CDateTime,double C,
                    datetime DDateTime,double D)
  {
   string unique=UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
   string prefix=(bullish ? "Bullish " : "Bearish ");
   string prefixName=(bullish ? "U "+_identifier : "D "+_identifier);
   string name0=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XA"+unique;
   string name1=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
   string name2=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
   string name3=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
   string name4=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAB"+unique;
   string name5=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAD"+unique;
   string name6=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" ABC"+unique;
   string name7=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BCD"+unique;
   string triangle_XB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XB"+unique;
   string triangle_BD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BD"+unique;
   string pointX=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PX"+unique;
   string pointA=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
   string pointB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
   string pointC=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
   string pointD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
   string xab=IntegerToString((int) MathRound(100*MathAbs(A-B)/MathAbs(X-A)));
   string xad=IntegerToString((int) MathRound(100*MathAbs(D-A)/MathAbs(X-A)));
   string abc=IntegerToString((int) MathRound(100*MathAbs(C-B)/MathAbs(B-A)));
   if(k==CYPHER || k==NENSTAR || k==NEWCYPHER)
      abc=IntegerToString((int) MathRound(100*MathAbs(X-C)/MathAbs(X-A)));
   string bcd=IntegerToString((int) MathRound(100*MathAbs(C-D)/MathAbs(B-C)));
   ObjectCreate(0,name0,OBJ_TREND,0,XDateTime,X,ADateTime,A);
   ObjectCreate(0,name1,OBJ_TREND,0,ADateTime,A,BDateTime,B);
   ObjectCreate(0,name2,OBJ_TREND,0,BDateTime,B,CDateTime,C);
   ObjectCreate(0,name3,(!Fill_Patterns || (k==THREEDRIVES) || (k==FIVEO)) ? OBJ_ARROWED_LINE : OBJ_TREND,0,CDateTime,C,DDateTime,D);  //Arrowed lines if not triangles
   ObjectCreate(0,name4,OBJ_TREND,0,XDateTime,X,BDateTime,B);
//--- Point labels
   if(Show_descriptions)
     {
      int numOverlapping=0;
      for(int i=0; i<NUM_PATTERNS; i++)
        {
         for(int j=0; j<SIZE_PATTERN_BUFFER; j++)
           {
            if(XDateTime==_patternX[i][j]) numOverlapping++;
            if(Is4PointPattern(i) && XDateTime==_patternA[i][j]) numOverlapping++;
           }
        }
      for(int i=0; i<_patternInstanceCounter; i++)
        {
         PATTERN_INSTANCE instance=_patternInstances[i];
         int patternIndexActive=_patternInstances[i].patternIndex;
         datetime XDateTimeActive=instance.XDateTime;
         datetime ADateTimeActive=instance.ADateTime;
         if(XDateTime==XDateTimeActive) numOverlapping++;
         if(Is4PointPattern(patternIndexActive) && XDateTime==ADateTimeActive) numOverlapping++;
        }
      int x1=0;
      int y1=0;
      int x2=0;
      int y2=0;
      ChartTimePriceToXY(0,0,XDateTime,X,x1,y1);
      ChartTimePriceToXY(0,0,XDateTime,X+1,x2,y2);
      double pixelsPerPrice=MathAbs(y1-y2);
      double change=pixelsPerPrice!=0 ? numOverlapping*(Font_size)/pixelsPerPrice : 0;
      double price=(bullish ? X-change : X+change);
      ObjectCreate(0,pointX,OBJ_TEXT,0,XDateTime,price);
      ObjectCreate(0,pointA,OBJ_TEXT,0,ADateTime,A);
      ObjectCreate(0,pointB,OBJ_TEXT,0,BDateTime,B);
      ObjectCreate(0,pointC,OBJ_TEXT,0,CDateTime,C);
      ObjectCreate(0,pointD,OBJ_TEXT,0,DDateTime,D);
      ObjectSetString(0,pointX,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PX");
      ObjectSetString(0,pointA,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PA");
      ObjectSetString(0,pointB,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PB");
      ObjectSetString(0,pointC,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PC");
      ObjectSetString(0,pointD,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PD");
      ObjectSetString(0,pointX,OBJPROP_TEXT,"X "+prefix+_patternNames[k]);
      ObjectSetString(0,pointX,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointX,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointX,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
      ObjectSetString(0,pointA,OBJPROP_TEXT,"A");
      ObjectSetString(0,pointA,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointA,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointA,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
      ObjectSetString(0,pointB,OBJPROP_TEXT,"B");
      ObjectSetString(0,pointB,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointB,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointB,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
      ObjectSetString(0,pointC,OBJPROP_TEXT,"C");
      ObjectSetString(0,pointC,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointC,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointC,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
      ObjectSetString(0,pointD,OBJPROP_TEXT,"D");
      ObjectSetString(0,pointD,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointD,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointD,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
     }
//--- No X-D for 5-0
   if(k!=FIVEO) ObjectCreate(0,name5,OBJ_TREND,0,XDateTime,X,DDateTime,D);
   ObjectCreate(0,name6,OBJ_TREND,0,ADateTime,A,CDateTime,C);
   ObjectCreate(0,name7,OBJ_TREND,0,BDateTime,B,DDateTime,D);
   ObjectSetInteger(0,name0,OBJPROP_COLOR, bullish ? ClrBull : ClrBear);
   ObjectSetInteger(0,name1,OBJPROP_COLOR, bullish ? ClrBull : ClrBear);
   ObjectSetInteger(0,name2,OBJPROP_COLOR, bullish ? ClrBull : ClrBear);
   ObjectSetInteger(0,name3,OBJPROP_COLOR, bullish ? ClrBull : ClrBear);
   ObjectSetInteger(0,name0,OBJPROP_STYLE,Style_5P);
   ObjectSetInteger(0,name1,OBJPROP_STYLE,Style_5P);
   ObjectSetInteger(0,name3,OBJPROP_STYLE,Style_5P);
   ObjectSetInteger(0,name4,OBJPROP_COLOR,ClrRatio);
   if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_COLOR,ClrRatio);
   ObjectSetInteger(0,name6,OBJPROP_COLOR,ClrRatio);
   ObjectSetInteger(0,name7,OBJPROP_COLOR,ClrRatio);
   ObjectSetInteger(0,name4,OBJPROP_STYLE,Style_Ratio);
   if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_STYLE,Style_Ratio);
   ObjectSetInteger(0,name6,OBJPROP_STYLE,Style_Ratio);
   ObjectSetInteger(0,name7,OBJPROP_STYLE,Style_Ratio);
   ObjectSetInteger(0,name0,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name1,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name2,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name3,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name4,OBJPROP_SELECTABLE,true);
   if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name6,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name7,OBJPROP_SELECTABLE,true);
   ObjectSetString(0,name0,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XA");
   ObjectSetString(0,name1,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" AB");
   ObjectSetString(0,name2,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BC");
   ObjectSetString(0,name3,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" CD");
   ObjectSetString(0,name4,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XAB="+xab);
   if(k!=FIVEO) ObjectSetString(0,name5,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XAD="+xad);
   ObjectSetString(0,name6,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" ABC="+abc);
   ObjectSetString(0,name7,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BCD="+bcd);
   ObjectSetInteger(0,name0,OBJPROP_WIDTH,l_width);
   ObjectSetInteger(0,name1,OBJPROP_WIDTH,l_width);
   ObjectSetInteger(0,name2,OBJPROP_WIDTH,l_width);
   ObjectSetInteger(0,name3,OBJPROP_WIDTH,l_width);
   if(Fill_Patterns && (k!=FIVEO && k!=THREEDRIVES))
     {
      ObjectCreate(0,triangle_XB,OBJ_TRIANGLE,0,XDateTime,X,ADateTime,A,BDateTime,B);
      ObjectCreate(0,triangle_BD,OBJ_TRIANGLE,0,BDateTime,B,CDateTime,C,DDateTime,D);
      ObjectSetInteger(0,triangle_XB,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
      ObjectSetInteger(0,triangle_XB,OBJPROP_STYLE,STYLE_SOLID);
      ObjectSetInteger(0,triangle_XB,OBJPROP_FILL,true);
      ObjectSetInteger(0,triangle_XB,OBJPROP_BACK,true);
      ObjectSetInteger(0,triangle_XB,OBJPROP_SELECTABLE,true);
      ObjectSetInteger(0,triangle_XB,OBJPROP_SELECTED,false);
      ObjectSetInteger(0,triangle_BD,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
      ObjectSetInteger(0,triangle_BD,OBJPROP_STYLE,STYLE_SOLID);
      ObjectSetInteger(0,triangle_BD,OBJPROP_FILL,true);
      ObjectSetInteger(0,triangle_BD,OBJPROP_BACK,true);
      ObjectSetInteger(0,triangle_BD,OBJPROP_SELECTABLE,true);
      ObjectSetInteger(0,triangle_BD,OBJPROP_SELECTED,false);
     }
   if(showPatternNames)
      ShowComment(prefix+_patternNames[k]+" @ "+TimeToString(DDateTime));

  }
//+------------------------------------------------------------------+
//| Helper method displays 4-point projections                       |
//+------------------------------------------------------------------+
void DisplayProjection(int k,bool bullish,
                       datetime ADateTime,double A,
                       datetime BDateTime,double B,
                       datetime CDateTime,double C,
                       datetime DDateTime,double D)
  {
   string unique=UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime);
   string prefix=(bullish ? "Projected Bullish " : "Projected Bearish ");
   string prefixName=(bullish ? "PU "+_identifier : "PD "+_identifier);
   string name0=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
   string name1=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
   string name2=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
   string pointA=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
   string pointB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
   string pointC=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
   string pointD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
   ObjectCreate(0,name0,OBJ_TREND,0,ADateTime,A,BDateTime,B);
   ObjectCreate(0,name1,OBJ_TREND,0,BDateTime,B,CDateTime,C);
   ObjectCreate(0,name2,OBJ_TREND,0,CDateTime,C,DDateTime,D);
   ObjectSetInteger(0,name0,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
   ObjectSetInteger(0,name1,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
   ObjectSetInteger(0,name2,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
   ObjectSetInteger(0,name0,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name1,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name2,OBJPROP_SELECTABLE,true);
   ObjectSetString(0,name0,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" AB");
   ObjectSetString(0,name1,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BC");
   ObjectSetString(0,name2,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" CD");
   ObjectSetInteger(0,name0,OBJPROP_WIDTH,l_width_proj);
   ObjectSetInteger(0,name1,OBJPROP_WIDTH,l_width_proj);
   ObjectSetInteger(0,name2,OBJPROP_WIDTH,l_width_proj);
   ObjectSetInteger(0,name0,OBJPROP_STYLE,Style_Proj);
   ObjectSetInteger(0,name1,OBJPROP_STYLE,Style_Proj);
   ObjectSetInteger(0,name2,OBJPROP_STYLE,Style_Proj);
   if(Show_descriptions)
     {
      ObjectCreate(0,pointA,OBJ_TEXT,0,ADateTime,A);
      ObjectCreate(0,pointB,OBJ_TEXT,0,BDateTime,B);
      ObjectCreate(0,pointC,OBJ_TEXT,0,CDateTime,C);
      ObjectCreate(0,pointD,OBJ_TEXT,0,DDateTime,D);
      ObjectSetString(0,pointA,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PA");
      ObjectSetString(0,pointB,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PB");
      ObjectSetString(0,pointC,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PC");
      ObjectSetString(0,pointD,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PD");
      ObjectSetString(0,pointA,OBJPROP_TEXT,"A");
      ObjectSetString(0,pointA,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointA,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointA,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
      ObjectSetString(0,pointB,OBJPROP_TEXT,"B");
      ObjectSetString(0,pointB,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointB,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointB,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
      ObjectSetString(0,pointC,OBJPROP_TEXT,"C");
      ObjectSetString(0,pointC,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointC,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointC,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
      ObjectSetString(0,pointD,OBJPROP_TEXT," D "+prefix+_patternNames[k]);
      ObjectSetString(0,pointD,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointD,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointD,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
     }
  }
//+------------------------------------------------------------------+
//| Helper method displays 5-point projections                       |
//+------------------------------------------------------------------+
void DisplayProjection(int k,bool bullish,
                       datetime XDateTime,double X,
                       datetime ADateTime,double A,
                       datetime BDateTime,double B,
                       datetime CDateTime,double C,
                       datetime DDateTime,double D)
  {
   string unique=UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
   string prefix=(bullish ? "Projected Bullish " : "Projected Bearish ");
   string prefixName=(bullish ? "PU "+_identifier : "PD "+_identifier);
   string name0=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XA"+unique;
   string name1=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
   string name2=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
   string name3=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
   string name4=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAB"+unique;
   string name5=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAD"+unique;
   string name6=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" ABC"+unique;
   string name7=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BCD"+unique;
   string pointX=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PX"+unique;
   string pointA=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
   string pointB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
   string pointC=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
   string pointD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
   string xab=IntegerToString((int) MathRound(100*MathAbs(A-B)/MathAbs(X-A)));
   string xad=IntegerToString((int) MathRound(100*MathAbs(D-A)/MathAbs(X-A)));
   string abc=IntegerToString((int) MathRound(100*MathAbs(C-B)/MathAbs(B-A)));
//--- Cypher and Nen Start have the A-C top as XC/XA instead of CB/BA
   if(k==CYPHER || k==NENSTAR || k==NEWCYPHER)
      abc=IntegerToString((int) MathRound(100*MathAbs(X-C)/MathAbs(X-A)));
   string bcd=IntegerToString((int) MathRound(100*MathAbs(C-D)/MathAbs(B-C)));
   ObjectCreate(0,name0,OBJ_TREND,0,XDateTime,X,ADateTime,A);
   ObjectCreate(0,name1,OBJ_TREND,0,ADateTime,A,BDateTime,B);
   ObjectCreate(0,name2,OBJ_TREND,0,BDateTime,B,CDateTime,C);
   ObjectCreate(0,name3,OBJ_TREND,0,CDateTime,C,DDateTime,D);
   ObjectCreate(0,name4,OBJ_TREND,0,XDateTime,X,BDateTime,B);
   if(k!=FIVEO) ObjectCreate(0,name5,OBJ_TREND,0,XDateTime,X,DDateTime,D);
   ObjectCreate(0,name6,OBJ_TREND,0,ADateTime,A,CDateTime,C);
   ObjectCreate(0,name7,OBJ_TREND,0,BDateTime,B,DDateTime,D);
   ObjectSetInteger(0,name0,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
   ObjectSetInteger(0,name1,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
   ObjectSetInteger(0,name2,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
   ObjectSetInteger(0,name3,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
   ObjectSetInteger(0,name4,OBJPROP_COLOR,ClrRatio);
   if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_COLOR,ClrRatio);
   ObjectSetInteger(0,name6,OBJPROP_COLOR,ClrRatio);
   ObjectSetInteger(0,name7,OBJPROP_COLOR,ClrRatio);
   ObjectSetInteger(0,name0,OBJPROP_STYLE,Style_Proj);
   ObjectSetInteger(0,name1,OBJPROP_STYLE,Style_Proj);
   ObjectSetInteger(0,name2,OBJPROP_STYLE,Style_Proj);
   ObjectSetInteger(0,name3,OBJPROP_STYLE,Style_Proj);
   ObjectSetInteger(0,name4,OBJPROP_STYLE,Style_Ratio);
   ObjectSetInteger(0,name5,OBJPROP_STYLE,Style_Ratio);
   ObjectSetInteger(0,name6,OBJPROP_STYLE,Style_Ratio);
   ObjectSetInteger(0,name7,OBJPROP_STYLE,Style_Ratio);
   ObjectSetInteger(0,name0,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name1,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name2,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name3,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name4,OBJPROP_SELECTABLE,true);
   if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name6,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,name7,OBJPROP_SELECTABLE,true);
   ObjectSetString(0,name0,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XA");
   ObjectSetString(0,name1,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" AB");
   ObjectSetString(0,name2,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BC");
   ObjectSetString(0,name3,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" CD");
   ObjectSetString(0,name4,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XAB="+xab);
   if(k!=FIVEO) ObjectSetString(0,name5,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XAD="+xad);
   ObjectSetString(0,name6,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" ABC="+abc);
   ObjectSetString(0,name7,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BCD="+bcd);
   if(Show_descriptions)
     {
      ObjectCreate(0,pointX,OBJ_TEXT,0,XDateTime,X);
      ObjectCreate(0,pointA,OBJ_TEXT,0,ADateTime,A);
      ObjectCreate(0,pointB,OBJ_TEXT,0,BDateTime,B);
      ObjectCreate(0,pointC,OBJ_TEXT,0,CDateTime,C);
      ObjectCreate(0,pointD,OBJ_TEXT,0,DDateTime,D);
      ObjectSetString(0,pointX,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PX");
      ObjectSetString(0,pointA,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PA");
      ObjectSetString(0,pointB,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PB");
      ObjectSetString(0,pointC,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PC");
      ObjectSetString(0,pointD,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PD");
      ObjectSetInteger(0,name0,OBJPROP_WIDTH,l_width_proj);
      ObjectSetInteger(0,name1,OBJPROP_WIDTH,l_width_proj);
      ObjectSetInteger(0,name2,OBJPROP_WIDTH,l_width_proj);
      ObjectSetInteger(0,name3,OBJPROP_WIDTH,l_width_proj);
      ObjectSetString(0,pointX,OBJPROP_TEXT,"X");
      ObjectSetString(0,pointX,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointX,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointX,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
      ObjectSetString(0,pointA,OBJPROP_TEXT,"A");
      ObjectSetString(0,pointA,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointA,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointA,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
      ObjectSetString(0,pointB,OBJPROP_TEXT,"B");
      ObjectSetString(0,pointB,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointB,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointB,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
      ObjectSetString(0,pointC,OBJPROP_TEXT,"C");
      ObjectSetString(0,pointC,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointC,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointC,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
      ObjectSetString(0,pointD,OBJPROP_TEXT," D "+prefix+_patternNames[k]);
      ObjectSetString(0,pointD,OBJPROP_FONT,"Arial");
      ObjectSetInteger(0,pointD,OBJPROP_FONTSIZE,Font_size);
      ObjectSetInteger(0,pointD,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
     }
  }
//+------------------------------------------------------------------+
//| Helper method undisplays projections                             |
//+------------------------------------------------------------------+
void UndisplayProjections()
  {
   for(int i=0; i<_drawnProjectionInstanceCounter; i++)
     {
      PATTERN_INSTANCE instance=_drawnProjectionInstances[i];
      int k=instance.patternIndex;
      bool bullish=instance.bullish;
      datetime XDateTime=instance.XDateTime;
      datetime ADateTime=instance.ADateTime;
      datetime BDateTime=instance.BDateTime;
      datetime CDateTime=instance.CDateTime;
      datetime DDateTime=instance.DDateTime;
      //--- Delete pattern from chart
      string unique=Is4PointPattern(k)?UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime) : UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
      string prefix=(bullish ? "PU "+_identifier : "PD "+_identifier);
      string name0=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XA"+unique;
      string name1=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
      string name2=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
      string name3=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
      string name4=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAB"+unique;
      string name5=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAD"+unique;
      string name6=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" ABC"+unique;
      string name7=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BCD"+unique;
      string pointX=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PX"+unique;
      string pointA=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
      string pointB=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
      string pointC=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
      string pointD=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
      ObjectDelete(0,name0);
      ObjectDelete(0,name1);
      ObjectDelete(0,name2);
      ObjectDelete(0,name3);
      ObjectDelete(0,name4);
      ObjectDelete(0,name5);
      ObjectDelete(0,name6);
      ObjectDelete(0,name7);
      ObjectDelete(0,pointX);
      ObjectDelete(0,pointA);
      ObjectDelete(0,pointB);
      ObjectDelete(0,pointC);
      ObjectDelete(0,pointD);
     }
   _drawnProjectionInstanceCounter=0;
  }
//+------------------------------------------------------------------+
//| Helper method undisplays recently drawn patterns                 |
//+------------------------------------------------------------------+
void UndisplayPatterns()
  {
   for(int i=0; i<_patternInstanceCounter; i++)
     {
      PATTERN_INSTANCE instance=_patternInstances[i];
      int k=instance.patternIndex;
      bool bullish=instance.bullish;
      datetime XDateTime=instance.XDateTime;
      datetime ADateTime=instance.ADateTime;
      datetime BDateTime=instance.BDateTime;
      datetime CDateTime=instance.CDateTime;
      datetime DDateTime=instance.DDateTime;
      //--- Delete pattern from chart
      string unique=Is4PointPattern(k)?UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime) : UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
      string prefix=(bullish ? "U "+_identifier : "D "+_identifier);
      string name0=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XA"+unique;
      string name1=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
      string name2=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
      string name3=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
      string name4=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAB"+unique;
      string name5=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAD"+unique;
      string name6=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" ABC"+unique;
      string name7=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BCD"+unique;
      string triangle_XB=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XB"+unique;
      string triangle_BD=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BD"+unique;
      string pointX=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PX"+unique;
      string pointA=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
      string pointB=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
      string pointC=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
      string pointD=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
      ObjectDelete(0,name0);
      ObjectDelete(0,name1);
      ObjectDelete(0,name2);
      ObjectDelete(0,name3);
      ObjectDelete(0,name4);
      ObjectDelete(0,name5);
      ObjectDelete(0,name6);
      ObjectDelete(0,name7);
      ObjectDelete(0,triangle_XB);
      ObjectDelete(0,triangle_BD);
      ObjectDelete(0,pointX);
      ObjectDelete(0,pointA);
      ObjectDelete(0,pointB);
      ObjectDelete(0,pointC);
      ObjectDelete(0,pointD);
     }
  }
//+------------------------------------------------------------------+
//| Helper method undisplays recently drawn PRZ                      |
//+------------------------------------------------------------------+
void UndisplayPRZs()
  {
   for(int i=0; i<_patternInstanceCounter; i++)
     {
      PATTERN_INSTANCE instance=_patternInstances[i];
      int k=instance.patternIndex;
      bool bullish=instance.bullish;
      datetime XDateTime=instance.XDateTime;
      datetime ADateTime=instance.ADateTime;
      datetime BDateTime=instance.BDateTime;
      datetime CDateTime=instance.CDateTime;
      datetime DDateTime=instance.DDateTime;
      //--- Delete pattern from chart
      string unique=Is4PointPattern(k)?UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime) : UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
      string prefix=(bullish ? "U "+_identifier : "D "+_identifier);
      string linePRZ=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PRZ"+unique;
      ObjectDelete(0,linePRZ);
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Helper method populates pattern arrays                           |
//+------------------------------------------------------------------+
int PopulatePatterns()
  {
//--- Create pattern descriptor structs with relevant ratios
   PATTERN_DESCRIPTOR trendlike1_abcd=          {0,0,0.382,0.382,2.618,2.618,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR trendlike2_abcd=          {0,0,0.5,0.5,2.0,2.0,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR perfect_abcd=             {0,0,0.618,0.618,1.618,1.618,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR ideal1_abcd=              {0,0,0.707,0.707,1.41,1.41,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR ideal2_abcd=              {0,0,0.786,0.786,1.27,1.27,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR rangelike_abcd=           {0,0,0.886,0.886,1.13,1.13,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR alt127_trendlike1_abcd=   {0,0,0.382,0.382,2.618,3.618,0,0,0,0,0,0,1.272,1.272};
   PATTERN_DESCRIPTOR alt127_trendlike2_abcd=   {0,0,0.5,0.5,2.0,3.618,0,0,0,0,0,0,1.272,1.272};
   PATTERN_DESCRIPTOR alt127_perfect_abcd=      {0,0,0.618,0.618,1.618,3.618,0,0,0,0,0,0,1.272,1.272};
   PATTERN_DESCRIPTOR alt127_ideal1_abcd=       {0,0,0.707,0.707,1.41,3.618,0,0,0,0,0,0,1.272,1.272};
   PATTERN_DESCRIPTOR alt127_ideal2_abcd=       {0,0,0.786,0.786,1.27,3.618,0,0,0,0,0,0,1.272,1.272};
   PATTERN_DESCRIPTOR alt127_rangelike_abcd=    {0,0,0.886,0.886,1.13,3.618,0,0,0,0,0,0,1.272,1.272};
   PATTERN_DESCRIPTOR rec_trendlike1_abcd=      {0,0,2.618,2.618,0.382,0.382,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR rec_trendlike2_abcd=      {0,0,2.0,2.0,0.5,0.5,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR rec_perfect_abcd=         {0,0,1.618,1.618,0.618,0.618,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR rec_ideal1_abcd=          {0,0,1.41,1.41,0.707,0.707,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR rec_ideal2_abcd=          {0,0,1.27,1.27,0.786,0.786,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR rec_rangelike_abcd=       {0,0,1.13,1.13,0.886,0.886,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR gartley=      {0.618,0.618,0.382,0.886,1.272,1.618,0.786,0.786,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR bat=          {0.382,0.5,0.382,0.886,1.618,2.618,0.886,0.886,0,0,0,0,0,0 };
   PATTERN_DESCRIPTOR altbat=       {0.382,0.382,0.382,0.886,2.0,3.618,1.13,1.13,0,0,0,0,0,0 };
   PATTERN_DESCRIPTOR fiveo=        {1.13,1.618,1.618,2.24,0.5,0.5,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR butterfly=    {0.786,0.786,0.382,0.886,1.618,2.618,1.272,1.618,0,0,0,0,0,0 };
   PATTERN_DESCRIPTOR crab=         {0.382,0.618,0.382,0.886,2.24,3.618,1.618,1.618,0,0,0,0,0,0 };
   PATTERN_DESCRIPTOR deepcrab=     {0.886,0.886,0.382,0.886,2.0,3.618,1.618,1.618,0,0,0,0,0,0 };
   PATTERN_DESCRIPTOR threedrives=  {1.272,1.618,0.618,0.786,1.272,1.618,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR shark=        {0,0,1.13,1.618,1.618,2.24,0,0,0.886,1.13,0,0,0,0};
   PATTERN_DESCRIPTOR cypher=       {0.382,0.618,0,0,0,0,0,0,0.786,0.786,1.13,1.414,0,0};
   PATTERN_DESCRIPTOR nenstar=      {0.382,0.618,0,0,0,0,0,0,1.272,1.272,1.13,1.414,0,0};
   PATTERN_DESCRIPTOR blackswan=    {1.382,2.618,0.236,0.5,1.128,2,1.128,2.618,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR whiteswan=    {0.382,0.724,2,4.237,0.5,0.886,0.382,0.886,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR one2one=      {0.5,0.786,1.128,3.618,0.382,0.786,0.382,0.786,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR newcypher=    {0.382,0.618,0,0,0,0,0,0,0.786,0.786,1.414,2.14,0,0};
   PATTERN_DESCRIPTOR navarro200=   {0.382,0.786,0.886,1.128,0.886,3.618,0.886,1.128,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR leonardo=     {0.5,0.5,0.382,0.886,1.128,2.618,0.786,0.786,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR kane=         {0.685,0.685,0.382,0.886,0,0,1.460,1.460,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR garfly=       {0.618,0.618,0.382,0.886,1.618,2.24,1.272,1.272,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR maxbat=       {0.382,0.618,0.382,0.886,1.272,2.618,0.886,0.886,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR maxgartley=   {0.382,0.618,0.382,0.886,1.128,2.236,0.618,0.786,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR maxbutterfly= {0.618,0.886,0.382,0.886,1.272,2.618,1.272,1.618,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR gartley113=   {0.618,0.618,0.382,0.886,1.13,1.13,0.786,0.786,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR butterfly113= {0.786,1,0.618,1,1.128,1.618,1.128,1.128,0,0,0,0,0,0 };
   PATTERN_DESCRIPTOR anti_gartley=       {0.618,0.786,1.129,2.618,1.618,1.618,1.272,1.272,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_bat=           {0.382,0.618,1.129,2.618,2.000,2.618,1.129,1.129,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_altbat=        {0.276,0.500,1.129,2.618,2.618,2.618,0.885,0.885,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_fiveo=         {2.000,2.000,0.446,0.618,0.618,0.885,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_butterfly=     {0.382,0.618,1.129,2.618,1.272,1.272,0.618,0.786,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_crab=          {0.276,0.446,1.129,2.618,1.618,2.618,0.618,0.618,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_deepcrab=      {0.276,0.500,1.129,2.618,1.129,1.129,0.618,0.618,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_threedrives=   {0.618,0.786,1.272,1.618,0.618,0.786,0,0,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_shark=         {0.446,0.618,0.618,0.885,0,0,0,0,0.885,1.129,0,0,0,0};
   PATTERN_DESCRIPTOR anti_cypher=        {0,0,0,0,1.618,2.618,0,0,1.272,1.272,0.707,0.885,0,0};
   PATTERN_DESCRIPTOR anti_nenstar=       {0,0,0,0,1.618,2.618,0,0,0.786,0.786,0.707,0.885,0,0};
   PATTERN_DESCRIPTOR anti_blackswan=     {0.500,0.887,2.000,4.237,0.382,0.724,0.382,0.887,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_whiteswan=     {1.129,2.000,0.236,0.500,1.381,2.618,1.129,2.618,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_one2one=       {1.272,2.618,0.276,0.887,1.272,2.000,1.272,2.618,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_newcypher=     {0,0,0,0,1.618,2.618,0,0,1.272,1.272,0.467,0.707,0,0};
   PATTERN_DESCRIPTOR anti_navarro200=    {0.276,1.129,0.887,1.129,1.272,2.618,0.887,1.129,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_leonardo=      {0.382,0.887,1.129,2.618,2.000,2.000,1.272,1.272,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_kane=          {0,0,1.129,2.618,1.460,1.460,0.685,0.685,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_garfly=        {0.446,0.618,1.129,2.618,1.618,1.618,0.786,0.786,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_maxbat=        {0.382,0.786,1.129,2.618,1.618,2.618,1.129,1.129,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_maxgartley=    {0.447,0.887,1.129,2.618,1.618,2.618,1.272,1.618,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_maxbutterfly=  {0.382,0.786,1.129,2.618,1.129,1.618,0.618,0.786,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_gartley113=    {0.885,0.885,1.129,2.618,1.618,1.618,1.272,1.272,0,0,0,0,0,0};
   PATTERN_DESCRIPTOR anti_butterfly113=  {0.618,0.887,1.000,1.618,1.000,1.272,0.887,0.887,0,0,0,0,0,0};

//--- Initialize arrays
   _maxProjectionInstances=4;
   _maxPatternInstances=NUM_PATTERNS*SIZE_PATTERN_BUFFER;
   _maxDrawnProjectionInstances=4;
   if(ArrayResize(_patterns,NUM_PATTERNS)<NUM_PATTERNS)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_patternNames,NUM_PATTERNS)<NUM_PATTERNS)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_patternX,NUM_PATTERNS)<NUM_PATTERNS)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_patternA,NUM_PATTERNS)<NUM_PATTERNS)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_patternB,NUM_PATTERNS)<NUM_PATTERNS)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_patternC,NUM_PATTERNS)<NUM_PATTERNS)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_patternD,NUM_PATTERNS)<NUM_PATTERNS)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_patternCounter,NUM_PATTERNS)<NUM_PATTERNS)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_patternInstances,_maxPatternInstances)<_maxPatternInstances)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_projectionInstances,_maxProjectionInstances)<_maxProjectionInstances)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   if(ArrayResize(_drawnProjectionInstances,_maxDrawnProjectionInstances)<_maxDrawnProjectionInstances)
     {
      printf("Error allocating array: "+IntegerToString(GetLastError()));
      return INIT_FAILED;
     }
   ArrayFill(_patternCounter,0,NUM_PATTERNS,0);
//--- Fill in the pattern arrays
   _patterns[TRENDLIKE1_ABCD]=trendlike1_abcd; _patternNames[TRENDLIKE1_ABCD]="Trendlike AB=CD #1";
   _patterns[TRENDLIKE2_ABCD]=trendlike2_abcd; _patternNames[TRENDLIKE2_ABCD]="Trendlike AB=CD #2";
   _patterns[PERFECT_ABCD]=perfect_abcd; _patternNames[PERFECT_ABCD]="Perfect AB=CD";
   _patterns[IDEAL1_ABCD]=ideal1_abcd; _patternNames[IDEAL1_ABCD]="Ideal AB=CD #1";
   _patterns[IDEAL2_ABCD]=ideal2_abcd; _patternNames[IDEAL2_ABCD]="Ideal AB=CD #2";
   _patterns[RANGELIKE_ABCD]=rangelike_abcd; _patternNames[RANGELIKE_ABCD]="Rangelike AB=CD";
   _patterns[ALT127_TRENDLIKE1_ABCD]=alt127_trendlike1_abcd; _patternNames[ALT127_TRENDLIKE1_ABCD]="Trendlike 1.27 AB=CD #1";
   _patterns[ALT127_TRENDLIKE2_ABCD]=alt127_trendlike2_abcd; _patternNames[ALT127_TRENDLIKE2_ABCD]="Trendlike 1.27 AB=CD #2";
   _patterns[ALT127_PERFECT_ABCD]=alt127_perfect_abcd; _patternNames[ALT127_PERFECT_ABCD]="Perfect 1.27 AB=CD";
   _patterns[ALT127_IDEAL1_ABCD]=alt127_ideal1_abcd; _patternNames[ALT127_IDEAL1_ABCD]="Ideal 1.27 AB=CD #1";
   _patterns[ALT127_IDEAL2_ABCD]=alt127_ideal2_abcd; _patternNames[ALT127_IDEAL2_ABCD]="Ideal 1.27 AB=CD #2";
   _patterns[ALT127_RANGELIKE_ABCD]=alt127_rangelike_abcd; _patternNames[ALT127_RANGELIKE_ABCD]="Rangelike 1.27 AB=CD";
   _patterns[REC_TRENDLIKE1_ABCD]=rec_trendlike1_abcd; _patternNames[REC_TRENDLIKE1_ABCD]="Rec. Trendlike AB=CD #1";
   _patterns[REC_TRENDLIKE2_ABCD]=rec_trendlike2_abcd; _patternNames[REC_TRENDLIKE2_ABCD]="Rec. Trendlike AB=CD #2";
   _patterns[REC_PERFECT_ABCD]=rec_perfect_abcd; _patternNames[REC_PERFECT_ABCD]="Rec. Perfect AB=CD";
   _patterns[REC_IDEAL1_ABCD]=rec_ideal1_abcd; _patternNames[REC_IDEAL1_ABCD]="Rec. Ideal AB=CD #1";
   _patterns[REC_IDEAL2_ABCD]=rec_ideal2_abcd; _patternNames[REC_IDEAL2_ABCD]="Rec. Ideal AB=CD #2";
   _patterns[REC_RANGELIKE_ABCD]=rec_rangelike_abcd; _patternNames[REC_RANGELIKE_ABCD]="Rec. Rangelike AB=CD";
   _patterns[GARTLEY]=gartley; _patternNames[GARTLEY]="Gartley";
   _patterns[BAT]=bat; _patternNames[BAT]="Bat";
   _patterns[ALTBAT]=altbat; _patternNames[ALTBAT]="Alt. Bat";
   _patterns[FIVEO]=fiveo; _patternNames[FIVEO]="5-0";
   _patterns[BUTTERFLY]=butterfly; _patternNames[BUTTERFLY]="Butterfly";
   _patterns[CRAB]=crab; _patternNames[CRAB]="Crab";
   _patterns[DEEPCRAB]=deepcrab; _patternNames[DEEPCRAB]="Deep Crab";
   _patterns[THREEDRIVES]=threedrives; _patternNames[THREEDRIVES]="Three Drives";
   _patterns[CYPHER]=cypher; _patternNames[CYPHER]="Cypher";
   _patterns[SHARK]=shark; _patternNames[SHARK]="Shark";
   _patterns[NENSTAR]=nenstar; _patternNames[NENSTAR]="Nen Star";
   _patterns[BLACKSWAN]=blackswan; _patternNames[BLACKSWAN]="Black Swan";
   _patterns[WHITESWAN]=whiteswan; _patternNames[WHITESWAN]="White Swan";
   _patterns[ONE2ONE]=one2one; _patternNames[ONE2ONE]="One2One";
   _patterns[NEWCYPHER]=newcypher; _patternNames[NEWCYPHER]="New Cypher";
   _patterns[NAVARRO200]=navarro200; _patternNames[NAVARRO200]="Navarro 200";
   _patterns[LEONARDO]=leonardo; _patternNames[LEONARDO]="Leonardo";
   _patterns[KANE]=kane; _patternNames[KANE]="Kane";
   _patterns[GARFLY]=garfly; _patternNames[GARFLY]="Garfly";
   _patterns[MAXBAT]=maxbat; _patternNames[MAXBAT]="Max. Bat";
   _patterns[MAXGARTLEY]=maxgartley; _patternNames[MAXGARTLEY]="Max. Gartley";
   _patterns[MAXBUTTERFLY]=maxbutterfly; _patternNames[MAXBUTTERFLY]="Max. Butterfly";
   _patterns[GARTLEY113]=gartley113; _patternNames[GARTLEY113]="Gartley 113";
   _patterns[BUTTERFLY113]=butterfly113; _patternNames[BUTTERFLY113]="Butterfly 113";
   _patterns[ANTI_GARTLEY]=anti_gartley; _patternNames[ANTI_GARTLEY]="Anti Gartley";
   _patterns[ANTI_BAT]=anti_bat; _patternNames[ANTI_BAT]="Anti Bat";
   _patterns[ANTI_ALTBAT]=anti_altbat; _patternNames[ANTI_ALTBAT]="Anti Alt. Bat";
   _patterns[ANTI_FIVEO]=anti_fiveo; _patternNames[ANTI_FIVEO]="Anti 5-0";
   _patterns[ANTI_BUTTERFLY]=anti_butterfly; _patternNames[ANTI_BUTTERFLY]="Anti Butterfly";
   _patterns[ANTI_CRAB]=anti_crab; _patternNames[ANTI_CRAB]="Anti Crab";
   _patterns[ANTI_DEEPCRAB]=anti_deepcrab; _patternNames[ANTI_DEEPCRAB]="Anti Deep Crab";
   _patterns[ANTI_THREEDRIVES]=anti_threedrives; _patternNames[ANTI_THREEDRIVES]="Anti Three Drives";
   _patterns[ANTI_CYPHER]=anti_cypher; _patternNames[ANTI_CYPHER]="Anti Cypher";
   _patterns[ANTI_SHARK]=anti_shark; _patternNames[ANTI_SHARK]="Anti Shark";
   _patterns[ANTI_NENSTAR]=anti_nenstar; _patternNames[ANTI_NENSTAR]="Anti Nen Star";
   _patterns[ANTI_BLACKSWAN]=anti_blackswan; _patternNames[ANTI_BLACKSWAN]="Anti Black Swan";
   _patterns[ANTI_WHITESWAN]=anti_whiteswan; _patternNames[ANTI_WHITESWAN]="Anti White Swan";
   _patterns[ANTI_ONE2ONE]=anti_one2one; _patternNames[ANTI_ONE2ONE]="Anti One2One";
   _patterns[ANTI_NEWCYPHER]=anti_newcypher; _patternNames[ANTI_NEWCYPHER]="Anti New Cypher";
   _patterns[ANTI_NAVARRO200]=anti_navarro200; _patternNames[ANTI_NAVARRO200]="Anti Navarro 200";
   _patterns[ANTI_LEONARDO]=anti_leonardo; _patternNames[ANTI_LEONARDO]="Anti Leonardo";
   _patterns[ANTI_KANE]=anti_kane; _patternNames[ANTI_KANE]="Anti Kane";
   _patterns[ANTI_GARFLY]=anti_garfly; _patternNames[ANTI_GARFLY]="Anti Garfly";
   _patterns[ANTI_MAXBAT]=anti_maxbat; _patternNames[ANTI_MAXBAT]="Anti Max. Bat";
   _patterns[ANTI_MAXGARTLEY]=anti_maxgartley; _patternNames[ANTI_MAXGARTLEY]="Anti Max. Gartley";
   _patterns[ANTI_MAXBUTTERFLY]=anti_maxbutterfly; _patternNames[ANTI_MAXBUTTERFLY]="Anti Max. Butterfly";
   _patterns[ANTI_GARTLEY113]=anti_gartley113; _patternNames[ANTI_GARTLEY113]="Anti Gartley 113";
   _patterns[ANTI_BUTTERFLY113]=anti_butterfly113; _patternNames[ANTI_BUTTERFLY113]="Anti Butterfly 113";
   return INIT_SUCCEEDED;
  }
//+------------------------------------------------------------------+
//| Helper method creates hexadecimal encoding of datetimes          |
//+------------------------------------------------------------------+
string UniqueIdentifier(datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
  {
   return " "+StringFormat("%x",ADateTime)+StringFormat("%x",BDateTime)+StringFormat("%x",CDateTime)+StringFormat("%x",DDateTime);
  }
//+------------------------------------------------------------------+
//| Helper method creates hexadecimal encoding of datetimes          |
//+------------------------------------------------------------------+
string UniqueIdentifier(datetime XDateTime,datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
  {
   return " "+StringFormat("%x",XDateTime)+StringFormat("%x",ADateTime)+StringFormat("%x",BDateTime)+StringFormat("%x",CDateTime)+StringFormat("%x",DDateTime);
  }
//+------------------------------------------------------------------+