//+---------------------------------------------------------------------+
//|                                                Blessing 3 v3.9.6.09 |
//|                                                   February 09, 2014 |
//|                     Copyright ?2007-2011, J Talon LLC/FiFtHeLeMeNt |
//|     In no event will authors be liable for any damages whatsoever.  |
//|                         Use at your own risk.                       |
//|                                                                     |
//|  This EA is dedicated to Mike McKeough, a member of the Blessing    |
//|  Development Group, who passed away on Saturday, 31st July 2010.    |
//|  His contributions to the development of this EA have helped make   |
//|  it what it is today, and we will miss his enthusiasm, dedication   |
//|  and desire to make this the best EA possible.                      |
//|  Rest In Peace.                                                     |
//+---------------------------------------------------------------------+

#property copyright "Copyright ?2007-2014, J Talon LLC/FiFtHeLeMeNt"
#property link      "http://www.jtatoday.com"
//#property strict
//#include <stdlib.mqh>
//#include <stderror.mqh>
//#include <WinUser32.mqh>

#define A 1 //All (Basket + Hedge)
#define B 2 //Basket
#define H 3 //Hedge
#define T 4 //Ticket
#define P 5 //Pending

//+-----------------------------------------------------------------+
//| External Parameters Set                                         |
//+-----------------------------------------------------------------+

extern string   Version_3_9_6       = "EA Settings:";
extern string   TradeComment        = "Blessing 3.9.6.09";
// Enter a unique number to identify this EA
extern int      EANumber            = 1;
// Setting this to true will close all open orders immediately
extern bool     EmergencyCloseAll   = false;

extern string   LabelAcc            = "Account Trading Settings:";
// Setting this to true will stop the EA trading after any open trades have been closed
extern bool     ShutDown            = false;
// percent of account balance lost before trading stops
extern double   StopTradePercent    = 10;
// set to true for nano "penny a pip" account (contract size is $10,000)
extern bool     NanoAccount         = false;
// Percentage of account you want to trade on this pair
extern double   PortionPC           = 100;
// If Basket open: 0=no Portion change;1=allow portion to increase; -1=allow increase and decrease 
extern int		PortionChange		= 1;		      
// Percent of portion for max drawdown level.
extern double   MaxDDPercent        = 50;
// Maximum allowed spread while placing trades
extern double   MaxSpread           = 5;
// Will shutdown over holiday period 
extern bool     UseHolidayShutdown  = true;
// List of holidays, each seperated by a comma, [day]/[mth]-[day]/[mth], dates inclusive
extern string   Holidays            = "18/12-01/01";
// will sound alarms
extern bool     PlaySounds          = false;
// Alarm sound to be played
extern string   AlertSound          = "Alert.wav";

extern string   LabelIES            = "Indicator / Entry Settings:";
// Stop/Limits for entry if true, Buys/Sells if false
extern bool     B3Traditional       = true;
// Market condition 0=uptrend 1=downtrend 2=range 3=off
extern int      ForceMarketCond     = 3;
// true = ANY entry can be used to open orders, false = ALL entries used to open orders
extern bool     UseAnyEntry         = false;
// 0 = Off, 1 = will base entry on MA channel, 2 = will trade in reverse
extern int      MAEntry             = 1;
// 0 = Off, 1 = will base entry on CCI indicator, 2 = will trade in reverse
extern int      CCIEntry            = 0;
// 0 = Off, 1 = will base entry on BB, 2 = will trade in reverse
extern int      BollingerEntry      = 0;
// 0 = Off, 1 = will base entry on Stoch, 2 = will trade in reverse
extern int      StochEntry          = 0;
// 0 = Off, 1 = will base entry on MACD, 2 = will trade in reverse
extern int      MACDEntry           = 0;

extern string   LabelLS             = "Lot Size Settings:";
// Money Management
extern bool     UseMM               = true;
// Adjusts MM base lot for large accounts
extern double   LAF                 = 0.5;
// Starting lots if Money Management is off
extern double   Lot                 = 0.01;
// Multiplier on each level
extern double   Multiplier          = 1.4;

extern string   LabelGS             = "Grid Settings:";
// Auto calculation of TakeProfit and Grid size;
extern bool     AutoCal             = false;
extern string   LabelATRTFr         = "0:Chart, 1:M1, 2:M5, 3:M15, 4:M30, 5:H1, 6:H4, 7:D1, 8:W1, 9:MN1";
// TimeFrame for ATR calculation
extern int      ATRTF               = 0;
// Number of periods for the ATR calculation
extern int      ATRPeriods          = 21;
// Widens/Squishes Grid on increments/decrements of .1
extern double   GAF                 = 1.0;
// Time Grid in seconds, to avoid opening of lots of levels in fast market
extern int      EntryDelay          = 2400;
// In pips, used in conjunction with logic to offset first trade entry
extern double   EntryOffset         = 5;
// True = use RSI/MA calculation for next grid order
extern bool     UseSmartGrid        = true;

extern string   LabelTS             = "Trading Settings:";
// Maximum number of trades to place (stops placing orders when reaches MaxTrades)
extern int      MaxTrades           = 15;
// Close All level, when reaches this level, doesn't wait for TP to be hit
extern int      BreakEvenTrade      = 12;
// Pips added to Break Even Point before BE closure
extern double   BEPlusPips          = 2;
// True = will close the oldest open trade after CloseTradesLevel is reached
extern bool     UseCloseOldest      = false;
// will start closing oldest open trade at this level
extern int      CloseTradesLevel    = 5;
// Will close the oldest trade whether it has potential profit or not
extern bool     ForceCloseOldest    = true;
// Maximum number of oldest trades to close
extern int      MaxCloseTrades      = 4;
// After Oldest Trades have closed, Forces Take Profit to BE +/- xx Pips
extern double   CloseTPPips         = 10;
// Force Take Profit to BE +/- xx Pips
extern double   ForceTPPips         = 0;
// Ensure Take Profit is at least BE +/- xx Pips
extern double   MinTPPips           = 0;

extern string   LabelHS             = "Hedge Settings:";
// Enter the Symbol of the same/correlated pair EXACTLY as used by your broker.
extern string   HedgeSymbol         = "";
// Number of days for checking Hedge Correlation
extern int      CorrPeriod          = 30;
// Turns DD hedge on/off
extern bool     UseHedge            = true;
// DD = start hedge at set DD;Level = Start at set level
extern string   DDorLevel           = "DD";
// DD Percent or Level at which Hedge starts
extern double   HedgeStart          = 20;
// Hedge Lots = Open Lots * hLotMult
extern double   hLotMult            = 0.8;
// DD Hedge maximum pip loss - also hedge trailing stop
extern double   hMaxLossPips        = 30;
// true = fixed SL at hMaxLossPips
extern bool     hFixedSL            = false;
// Hedge Take Profit
extern double   hTakeProfit         = 30;
// Increase to HedgeStart to stop early re-entry of the hedge
extern double   hReEntryPC          = 5;
// True = Trailing Stop will stop at BE;False = Hedge will continue into profit
extern bool     StopTrailAtBE       = true;
// False = Trailing Stop is Fixed;True = Trailing Stop will reduce after BE is reached
extern bool     ReduceTrailStop     = true;

extern string   LabelES             = "Exit Settings:";
// Turns on TP move and Profit Trailing Stop Feature
extern bool     MaximizeProfit      = false;
// Locks in Profit at this percent of Total Profit Potential
extern double   ProfitSet           = 70;
// Moves TP this amount in pips
extern double   MoveTP              = 30;
// Number of times you want TP to move before stopping movement
extern int      TotalMoves          = 2;
// Use Stop Loss and/or Trailing Stop Loss
extern bool     UseStopLoss         = false;
// Pips for fixed StopLoss from BE, 0=off
extern double   SLPips              = 30;
// Pips for trailing stop loss from BE + TSLPips: +ve = fixed trail; -ve = reducing trail; 0=off
extern double   TSLPips             = 10;
// Minimum trailing stop pips if using reducing TS
extern double   TSLPipsMin          = 3;
// Transmits a SL in case of internet loss
extern bool     UsePowerOutSL       = false;
// Power Out Stop Loss in pips
extern double   POSLPips            = 600;
// Close trades in FIFO order
extern bool     UseFIFO             = false;

extern string   LabelEE             = "Early Exit Settings:";
// Reduces ProfitTarget by a percentage over time and number of levels open
extern bool     UseEarlyExit        = false;
// Number of Hours to wait before EE over time starts
extern double   EEStartHours        = 3;
// true = StartHours from FIRST trade: false = StartHours from LAST trade
extern bool     EEFirstTrade        = true;
// Percentage reduction per hour (0 = OFF)
extern double   EEHoursPC           = 0.5;
// Number of Open Trades before EE over levels starts
extern int      EEStartLevel        = 5;
// Percentage reduction at each level (0 = OFF)
extern double   EELevelPC           = 10;
// true = Will allow the basket to close at a loss : false = Minimum profit is Break Even
extern bool     EEAllowLoss         = false;

extern string   LabelAdv            = "Advanced Settings Change sparingly";

extern string   LabelGrid           = "Grid Size Settings:";
// Specifies number of open trades in each block (separated by a comma)
extern string   SetCountArray       = "4,4";
// Specifies number of pips away to issue limit order (separated by a comma)
extern string   GridSetArray        = "25,50,100";
// Take profit for each block (separated by a comma)
extern string   TP_SetArray         = "50,100,200";

extern string   LabelMA             = "MA Entry Settings:";
// Period of MA (H4 = 100, H1 = 400)
extern int      MAPeriod            = 100;
// Distance from MA to be treated as Ranging Market
extern double   MADistance          = 10;

extern string   LabelCCI            = "CCI Entry Settings:";
// Period for CCI calculation
extern int      CCIPeriod           = 14;

extern string   LabelBBS            = "Bollinger Bands Entry Settings:";
// Period for Bollinger
extern int      BollPeriod          = 10;
// Up/Down spread
extern double   BollDistance        = 10;
// Standard deviation multiplier for channel
extern double   BollDeviation       = 2.0;

extern string   LabelSto            = "Stochastic Entry Settings:";
// Determines Overbought and Oversold Zones
extern int      BuySellStochZone    = 20;
// Stochastic KPeriod
extern int      KPeriod             = 10;
// Stochastic DPeriod
extern int      DPeriod             = 2;
// Stochastic Slowing
extern int      Slowing             = 2;

extern string   LabelMACD           = "MACD Entry Settings:";
extern string   LabelMACDTF         = "0:Chart, 1:M1, 2:M5, 3:M15, 4:M30, 5:H1, 6:H4, 7:D1, 8:W1, 9:MN1";
// Time frame for MACD calculation
extern int      MACD_TF             = 0;
// MACD EMA Fast Period
extern int      FastPeriod          = 12;
// MACD EMA Slow Period
extern int      SlowPeriod          = 26;
// MACD EMA Signal Period
extern int      SignalPeriod        = 9;
// 0=close, 1=open, 2=high, 3=low, 4=HL/2, 5=HLC/3 6=HLCC/4
extern int      MACDPrice           = 0;

extern string   LabelSG             = "Smart Grid Settings:";
extern string   LabelSGTF           = "0:Chart, 1:M1, 2:M5, 3:M15, 4:M30, 5:H1, 6:H4, 7:D1, 8:W1, 9:MN1";
// Timeframe for RSI calculation - should be less than chart TF.
extern int      RSI_TF              = 3;
// Period for RSI calculation
extern int      RSI_Period          = 14;
// 0=close, 1=open, 2=high, 3=low, 4=HL/2, 5=HLC/3 6=HLCC/4
extern int      RSI_Price           = 0;
// Period for MA of RSI calculation
extern int      RSI_MA_Period       = 10;
// 0=Simple MA, 1=Exponential MA, 2=Smoothed MA, 3=Linear Weighted MA
extern int      RSI_MA_Method       = 0;

extern string   LabelOS             = "Other Settings:";
// true = Recoup any Hedge/CloseOldest losses: false = Use original profit target.
extern bool     RecoupClosedLoss    = true;
// Largest Assumed Basket size.  Lower number = higher start lots
extern int      Level               = 7;
// Adjusts opening and closing orders by "slipping" this amount
extern int      slip                = 99;
// true = will save equity statistics
extern bool     SaveStats           = false;
// seconds between stats entries - off by default
extern int      StatsPeriod         = 3600;
// true for backtest - false for forward/live to ACCUMULATE equity traces
extern bool     StatsInitialise     = true;

extern string   LabelUE             = "Email Settings:";
extern bool     UseEmail            = false;
extern string   LabelEDD            = "At what DD% would you like Email warnings (Max: 49, Disable: 0)?";
extern double   EmailDD1            = 20;
extern double   EmailDD2            = 30;
extern double   EmailDD3            = 40;
extern string   LabelEH             = "Number of hours before DD timer resets";
// Minimum number of hours between emails
extern double   EmailHours          = 24;

extern string   LabelDisplay        = "Used to Adjust Overlay";
// Turns the display on and off
extern bool     displayOverlay      = true;
// Turns off copyright and icon
extern bool     displayLogo         = true;
// Turns off the CCI display
extern bool     displayCCI          = true;
// Show BE, TP and TS lines
extern bool     displayLines        = true;
// Moves display left and right
extern int      displayXcord        = 100;
// Moves display up and down
extern int      displayYcord        = 22;
// Moves CCI display left and right
extern int      displayCCIxCord     = 10;
//Display font
extern string   displayFont         = "Arial Bold";
// Changes size of display characters
extern int      displayFontSize     = 9;
// Changes space between lines
extern int      displaySpacing      = 14;
// Ratio to increase label width spacing
extern double   displayRatio        = 1;
// default color of display characters
extern color    displayColor        = DeepSkyBlue;
// default color of profit display characters
extern color    displayColorProfit  = Green;
// default color of loss display characters
extern color    displayColorLoss    = Red;
// default color of ForeGround Text display characters
extern color    displayColorFGnd    = White;

extern bool     Debug               = true;

extern string   LabelOpt            = "These values can only be used while optimizing";
// Set to true if you want to be able to optimize the grid settings.
extern bool     UseGridOpt          = false;
// These values will replace the normal SetCountArray,
// GridSetArray and TP_SetArray during optimization.
// The default values are the same as the normal array defaults
// REMEMBER:
// There must be one more value for GridArray and TPArray
// than there is for SetArray
extern int      SetArray1           = 4;
extern int      SetArray2           = 4;
extern int      SetArray3           = 0;
extern int      SetArray4           = 0;
extern int      GridArray1          = 25;
extern int      GridArray2          = 50;
extern int      GridArray3          = 100;
extern int      GridArray4          = 0;
extern int      GridArray5          = 0;
extern int      TPArray1            = 50;
extern int      TPArray2            = 100;
extern int      TPArray3            = 200;
extern int      TPArray4            = 0;
extern int      TPArray5            = 0;

//+-----------------------------------------------------------------+
//| Internal Parameters Set                                         |
//+-----------------------------------------------------------------+
int         ca;
int         Magic,hMagic;
int         CbT,CpT,ChT;
double      Pip,hPip;
int         POSLCount;
double      SLbL;
int         Moves;
double      MaxDD;
double      SLb;
int         AccountType;
double      StopTradeBalance;
double      InitialAB;
bool        Testing,Visual;
bool        AllowTrading;
bool        EmergencyWarning;
double      MaxDDPer;
int         Error,y;
int         Set1Level,Set2Level,Set3Level,Set4Level;
int         EmailCount;
string      sTF;
datetime    EmailSent;
int         GridArray[,2];
double      Lots[],MinLotSize,LotStep,LotDecimal;
int         LotMult,MinMult;
bool        PendLot;
string      CS,UAE;
int         HolShutDown;
datetime    HolArray[,4];
datetime    HolFirst,HolLast,NextStats,OTbF;
double      RSI[];
int         Digit[,2],TF[10]={0,1,5,15,30,60,240,1440,10080,43200};

double      Email[3];
double      EETime,PbC,PhC,hDDStart,PbMax,PbMin,PhMax,PhMin,LastClosedPL,ClosedPips,SLh,hLvlStart,StatLowEquity,StatHighEquity;
int         hActive,EECount,TbF,CbC/*count of closed?*/,CaL,FileHandle;
bool        TradesOpen,FileClosed,HedgeTypeDD,hThisChart,hPosCorr,dLabels,FirstRun;
string      FileName,ID,StatFile;
double      TPb,StopLevel,TargetPips,LbF,bTS,PortionBalance;

//+-----------------------------------------------------------------+
//| expert initialization function                                  |
//+-----------------------------------------------------------------+
int init()
{	
	CS = "Waiting for next tick .";     // To display comments while testing, simply use CS = .... and
	Comment(CS);                        // it will be displayed by the line at the end of the start() block.
	CS = "";
	Testing = IsTesting();
	Visual  = IsVisualMode();
	FirstRun = true;
	AllowTrading = true;
	if(EANumber<1)
	{	
		EANumber = 1;
	}
	if(Testing)
	{
		EANumber = 0;
	}
	Magic = GenerateMagicNumber();
	hMagic = JenkinsHash(Magic);
	FileName = "B3_"+Magic+".dat";
	if(Debug)
	{	
		Print("Magic Number: "+DTS(Magic,0));
		Print("Hedge Number: "+DTS(hMagic,0));
		Print("FileName: "+FileName);
	}
	Pip = Point;
	if(Digits%2 == 1)
	{
		Pip *= 10;
	}	
	if(NanoAccount)
	{
		AccountType = 10;
	}
	else
	{
		AccountType = 1;
	}
	MoveTP      = ND(MoveTP*Pip,Digits);
	EntryOffset = ND(EntryOffset*Pip,Digits);
	MADistance  = ND(MADistance*Pip,Digits);
	BollDistance= ND(BollDistance*Pip,Digits);
	POSLPips    = ND(POSLPips*Pip,Digits);
	hMaxLossPips= ND(hMaxLossPips*Pip,Digits);
	hTakeProfit = ND(hTakeProfit*Pip,Digits);
	CloseTPPips = ND(CloseTPPips*Pip,Digits);
	ForceTPPips = ND(ForceTPPips*Pip,Digits);
	MinTPPips   = ND(MinTPPips*Pip,Digits);
	BEPlusPips  = ND(BEPlusPips*Pip,Digits);
	SLPips      = ND(SLPips*Pip,Digits);
	TSLPips     = ND(TSLPips*Pip,Digits);
	TSLPipsMin  = ND(TSLPipsMin*Pip,Digits);
	slip *= Pip/Point;

	if(UseHedge)
	{	
		if(HedgeSymbol == "")
		{
			HedgeSymbol = Symbol();
		}
		if(HedgeSymbol == Symbol())
		{
			hThisChart = true;
		}
		else 
		{
			hThisChart = false;
		}
		
		hPip = MarketInfo(HedgeSymbol,MODE_POINT);
		int hDigits = MarketInfo(HedgeSymbol,MODE_DIGITS);
		if(hDigits%2 == 1)
		{
			hPip *= 10;
		}
		if(CheckCorr() > 0.9 || hThisChart)
		{
			hPosCorr = true;
		}
		else if(CheckCorr() < -0.9)
		{
			hPosCorr = false;
		}
		else
		{	
			AllowTrading = false;
			UseHedge = false;
			Print("The Hedge Symbol you have entered ("+HedgeSymbol+") is not closely correlated to "+Symbol());
		}
		if(StringSubstr(DDorLevel,0,1) == "D"||StringSubstr(DDorLevel,0,1) == "d")
		{
			HedgeTypeDD = true;
		}
		else if(StringSubstr(DDorLevel,0,1) == "L"||StringSubstr(DDorLevel,0,1) == "l")
		{
			HedgeTypeDD = false;
		}
		else 
		{
			UseHedge = false;
		}
		if(HedgeTypeDD)
		{	
			HedgeStart /= 100;
			hDDStart = HedgeStart;
		}
	}
	StopTradePercent /=100;
	ProfitSet /=100;
	EEHoursPC /=100;
	EELevelPC /=100;
	hReEntryPC /=100;
	PortionPC /=100;

	InitialAB = AccountBalance();
	StopTradeBalance = InitialAB * (1 - StopTradePercent);
	if(Testing)
	{
		ID = "B3Test.";
	}
	else 
	{
		ID = DTS(Magic,0)+".";
	}
	HideTestIndicators(true);

	MinLotSize = MarketInfo(Symbol(), MODE_MINLOT);
	if(MinLotSize > Lot)
	{	
		Print("Lot is less than your brokers minimum lot size");
		AllowTrading = false;
	}
	LotStep = MarketInfo(Symbol(),MODE_LOTSTEP);
	double MinLot = MathMin(MinLotSize,LotStep);
	LotMult = ND(MathMax(Lot,MinLotSize)/MinLot,0);
	MinMult = LotMult;
	Lot = MinLot;
	if(MinLot < 0.01)
	{
		LotDecimal = 3;
	}
	else if(MinLot < 0.1)
	{
		LotDecimal = 2;
	}
	else if(MinLot < 1)
	{
		LotDecimal = 1;
	}
	else 
	{
		LotDecimal = 0;
	}

	FileHandle = FileOpen(FileName, FILE_BIN|FILE_READ);
	if(FileHandle != -1)
	{	
		TbF = FileReadInteger(FileHandle,LONG_VALUE);
		FileClose(FileHandle);
		Error = GetLastError();
		if(OrderSelect(TbF,SELECT_BY_TICKET))
		{	
			OTbF = OrderOpenTime();
			LbF = OrderLots();
			LotMult = MathMax(1,LbF/MinLot);
			PbC = FindClosedPL(B);
			PhC = FindClosedPL(H);
			TradesOpen = true;
			if(Debug)
			{
				Print(FileName+" File Read: "+TbF+" Lots: "+DTS(LbF,LotDecimal));
			}
		}
		else
		{	
			FileDelete(FileName);
			TbF = 0;
			OTbF = 0;
			LbF = 0;
			Error = GetLastError();
			if(Error == ERR_NO_ERROR)
			{	
				if(Debug)
				{
					Print(FileName+" File Deleted");
				}
			}
			else 
			{
				Print("Error deleting file: "+FileName+" "+Error+" "+ErrorDescription(Error));
			}
		}
	}
	
	GlobalVariableSet(ID+"LotMult", LotMult);
	if(Debug)
	{
		Print("MinLotSize: "+DTS(MinLotSize,2)+" LotStep: "+DTS(LotStep,2)+" MinLot: "+DTS(MinLot,2)+" StartLot: "+DTS(Lot,2)+
		" LotMult: "+DTS(LotMult,0)+" Lot Decimal: "+DTS(LotDecimal,0));
	}
	EmergencyWarning = EmergencyCloseAll;

	if(IsOptimization())
	{
		Debug =false;
	}
	if(UseAnyEntry)
	{
		UAE = "||";
	}
	else
	{
		UAE = "&&";
	}
	if(ForceMarketCond<0 || ForceMarketCond>3)
	{	
		ForceMarketCond = 3;
	}
	if(MAEntry<0 || MAEntry>2)
	{
		MAEntry = 0;
	}
	if(CCIEntry<0 || CCIEntry>2)
	{
		CCIEntry = 0;
	}
	if(BollingerEntry<0 || BollingerEntry>2)
	{
		BollingerEntry = 0;
	}
	if(StochEntry<0 || StochEntry>2)
	{
		StochEntry = 0;
	}
	if(MACDEntry<0 || MACDEntry>2)
	{
		MACDEntry = 0;
	}
	if(MaxCloseTrades == 0)
	{
		MaxCloseTrades = MaxTrades;
	}

	ArrayResize(Digit,6);
	for(y = 0; y < ArrayRange(Digit,0); y++)
	{	
		if( y > 0)
		{
			Digit[y,0] = MathPow(10,y);
		}
		Digit[y,1] = y;
		if(Debug)
		{
			Print("Digit: "+y+" ["+Digit[y,0]+","+Digit[y,1]+"]");
		}
	}
	LabelCreate();
	dLabels=false;

	//+-----------------------------------------------------------------+
	//| Set Lot Array                                                   |
	//+-----------------------------------------------------------------+
	ArrayResize(Lots, MaxTrades);
	for(y = 0; y < MaxTrades; y++)
	{	
		if(y==0 || Multiplier<1)
		{
			Lots[y] = Lot;
		}
		else 
		{
			Lots[y] = ND(MathMax(Lots[y-1]*Multiplier,Lots[y-1]+LotStep), LotDecimal);
		}
		if(Debug)
		{
			Print("Lot Size for level "+DTS(y+1,0)+" : "+DTS(Lots[y]*MathMax(LotMult,1),LotDecimal));
		}
	}
	if(Multiplier < 1)
	{
		Multiplier = 1;
	}

	//+-----------------------------------------------------------------+
	//| Set Grid and TP array                                           |
	//+-----------------------------------------------------------------+
	int GridSet,GridTemp,GridTP,GridIndex,GridLevel,GridError;
	if(!AutoCal)
	{	
		//int GridSet,GridTemp,GridTP,GridIndex,GridLevel,GridError;
		ArrayResize(GridArray, MaxTrades);
		if(IsOptimization() && UseGridOpt)
		{	
			if(SetArray1 > 0)
			{	
				SetCountArray = DTS(SetArray1,0);
				GridSetArray  = DTS(GridArray1,0);
				TP_SetArray   = DTS(TPArray1,0);
			}
			if(SetArray2 > 0 || (SetArray1>0 && GridArray2>0))
			{	
				if(SetArray2>0)
				{
					SetCountArray=SetCountArray+","+DTS(SetArray2,0);
				}
				GridSetArray=GridSetArray+","+DTS(GridArray2,0);
				TP_SetArray=TP_SetArray+","+DTS(TPArray2,0);
			}
			if(SetArray3>0||(SetArray2>0&&GridArray3>0))
			{	
				if(SetArray3>0)
				{
					SetCountArray=SetCountArray+","+DTS(SetArray3,0);
				}
				GridSetArray=GridSetArray+","+DTS(GridArray3,0);
				TP_SetArray=TP_SetArray+","+DTS(TPArray3,0);
			}
			if(SetArray4>0||(SetArray3>0&&GridArray4>0))
			{	
				if(SetArray4>0)
				{
					SetCountArray=SetCountArray+","+DTS(SetArray4,0);
				}
				GridSetArray=GridSetArray+","+DTS(GridArray4,0);
				TP_SetArray=TP_SetArray+","+DTS(TPArray4,0);
			}
			if(SetArray4>0&&GridArray5>0)
			{	
				GridSetArray=GridSetArray+","+DTS(GridArray5,0);
				TP_SetArray=TP_SetArray+","+DTS(TPArray5,0);
			}
		}
		while(GridIndex < MaxTrades)
		{	
			if(StringFind(SetCountArray,",") == -1 && GridIndex==0)
			{	
				GridError = 1;
				break;
			}
			else 
			{
				GridSet = StrToInteger(StringSubstr(SetCountArray,0,StringFind(SetCountArray,",")));
			}
			if(GridSet > 0)
			{	
				SetCountArray = StringSubstr(SetCountArray,StringFind(SetCountArray,",")+1);
				GridTemp = StrToInteger(StringSubstr(GridSetArray,0,StringFind(GridSetArray,",")));
				GridSetArray = StringSubstr(GridSetArray,StringFind(GridSetArray,",")+1);
				GridTP = StrToInteger(StringSubstr(TP_SetArray,0,StringFind(TP_SetArray,",")));
				TP_SetArray = StringSubstr(TP_SetArray,StringFind(TP_SetArray,",")+1);
			}
			else
			{
				GridSet = MaxTrades;
			}
			if(GridTemp == 0 || GridTP == 0)
			{	
				GridError = 2;
				break;
			}

			for(GridLevel = GridIndex; GridLevel<=MathMin(GridIndex+GridSet-1,MaxTrades-1); GridLevel++)
			{	
				GridArray[GridLevel,0] = GridTemp;
				GridArray[GridLevel,1] = GridTP;
				if(Debug)
				{
					Print("GridArray "+(GridLevel+1)+"  : ["+GridArray[GridLevel,0]+","+GridArray[GridLevel,1]+"]");
				}
			}
			GridIndex = GridLevel;
		}
		if(GridError>0||GridArray[0,0]==0||GridArray[0,1]==0)
		{	
			if(GridError==1)
			{
				Print("Grid Array Error. Each value should be separated by a comma.");
			}
			else 
			{
				Print("Grid Array Error. Check that there is one more 'Grid' and 'TP' number than there are 'Set' numbers, separated by commas.");
			}
			AllowTrading=false;
		}
	}
	else
	{	
		while(GridIndex < 4)
		{	
			GridSet = StrToInteger(StringSubstr(SetCountArray,0,StringFind(SetCountArray,",")));
			SetCountArray = StringSubstr(SetCountArray,StringFind(SetCountArray,DTS(GridSet,0))+2);
			if(GridIndex==0 && GridSet<1)
			{	
				GridError = 1;
				break;
			}
			if(GridSet>0)
			{	
				GridLevel += GridSet;
			}
			else if(GridLevel < MaxTrades)
			{	
				GridLevel = MaxTrades;
			}
			else 
			{
				GridLevel = MaxTrades+1;
			}
			if(GridIndex == 0)
			{	
				Set1Level = GridLevel;
			}
			else if(GridIndex==1 && GridLevel<=MaxTrades)
			{
				Set2Level=GridLevel;
			}
			else if(GridIndex==2&&GridLevel<=MaxTrades)
			{
				Set3Level=GridLevel;
			}
			else if(GridIndex==3&&GridLevel<=MaxTrades)
			{
				Set4Level=GridLevel;
			}
			GridIndex++;
		}
		if(GridError==1||Set1Level==0)
		{	
			Print("Error setting up the Grid Levels. Check that the SetCountArray has valid numbers, separated by a comma.");
			AllowTrading=false;
		}
	}

	//+-----------------------------------------------------------------+
	//| Set holidays array                                              |
	//+-----------------------------------------------------------------+
	if(UseHolidayShutdown)
	{	
		int HolTemp,NumHols,NumBS,HolCounter;
		string HolTempStr;
		if(StringFind(Holidays,",",0)==-1)
		{
			NumHols=1;
		}
		else
		{	
			NumHols=1;
			while(HolTemp!=-1)
			{	
				HolTemp=StringFind(Holidays,",",HolTemp+1);
				if(HolTemp!=-1)
				{
					NumHols+=1;
				}
			}
		}
		HolTemp=0;
		while(HolTemp!=-1)
		{	
			HolTemp=StringFind(Holidays,"/",HolTemp+1);
			if(HolTemp!=-1)
			{
				NumBS+=1;
			}
		}
		if(NumBS!=NumHols*2)
		{	
			Print("Holidays Error, number of back-slashes ("+NumBS+") should be equal to 2* number of Holidays ("+NumHols+
					", and separators should be a comma.");
			AllowTrading=false;
		}
		else
		{	
			HolTemp=0;
			ArrayResize(HolArray,NumHols);
			while(HolTemp!=-1)
			{	
				if(HolTemp==0)
				{
					HolTempStr=StringTrimLeft(StringTrimRight(StringSubstr(Holidays,0,StringFind(Holidays,",",HolTemp))));
				}
				else 
				{
					HolTempStr=StringTrimLeft(StringTrimRight(StringSubstr(Holidays,HolTemp+1,
					StringFind(Holidays,",",HolTemp+1)-StringFind(Holidays,",",HolTemp)-1)));
				}
				HolTemp=StringFind(Holidays,",",HolTemp+1);
				HolArray[HolCounter,0]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),
					StringFind(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),"/")+1));
				HolArray[HolCounter,1]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),0,
					StringFind(StringSubstr(HolTempStr,0,StringFind(HolTempStr,"-",0)),"/")));
				HolArray[HolCounter,2]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),
					StringFind(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),"/")+1));
				HolArray[HolCounter,3]=StrToInteger(StringSubstr(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),0,
					StringFind(StringSubstr(HolTempStr,StringFind(HolTempStr,"-",0)+1),"/")));
				HolCounter+=1;
			}
		}
		for(HolTemp=0;HolTemp<HolCounter;HolTemp++)
		{	
			int Start1,Start2,Temp0,Temp1,Temp2,Temp3;
			for(int Item1=HolTemp+1;Item1<HolCounter;Item1++)
			{	
				Start1=HolArray[HolTemp,0]*100+HolArray[HolTemp,1];
				Start2=HolArray[Item1,0]*100+HolArray[Item1,1];
				if(Start1>Start2)
				{	
					Temp0=HolArray[Item1,0];
					Temp1=HolArray[Item1,1];
					Temp2=HolArray[Item1,2];
					Temp3=HolArray[Item1,3];
					HolArray[Item1,0]=HolArray[HolTemp,0];
					HolArray[Item1,1]=HolArray[HolTemp,1];
					HolArray[Item1,2]=HolArray[HolTemp,2];
					HolArray[Item1,3]=HolArray[HolTemp,3];
					HolArray[HolTemp,0]=Temp0;
					HolArray[HolTemp,1]=Temp1;
					HolArray[HolTemp,2]=Temp2;
					HolArray[HolTemp,3]=Temp3;
				}
			}
		}
		if(Debug)
		{	
			for(HolTemp=0;HolTemp<HolCounter;HolTemp++)
			{
				Print("Holidays - From: ",HolArray[HolTemp,1],"/",HolArray[HolTemp,0]," - ",HolArray[HolTemp,3],"/",HolArray[HolTemp,2]);
			}
		}
	}

	//+-----------------------------------------------------------------+
	//| Set email parameters                                            |
	//+-----------------------------------------------------------------+
	if(UseEmail)
	{	
		if(Period()==43200)
		{
			sTF="MN1";
		}
		else if(Period()==10800)
		{
			sTF="W1";
		}
		else if(Period()==1440)
		{
			sTF="D1";
		}
		else if(Period()==240)
		{
			sTF="H4";
		}
		else if(Period()==60)
		{
			sTF="H1";
		}
		else if(Period()==30)
		{
			sTF="M30";
		}
		else if(Period()==15)
		{
			sTF="M15";
		}
		else if(Period()==5)
		{
			sTF="M5";
		}
		else if(Period()==1)
		{
			sTF="M1";
		}
		Email[0]=MathMax(MathMin(EmailDD1,MaxDDPercent-1),0)/100;
		Email[1]=MathMax(MathMin(EmailDD2,MaxDDPercent-1),0)/100;
		Email[2]=MathMax(MathMin(EmailDD3,MaxDDPercent-1),0)/100;
		ArraySort(Email,WHOLE_ARRAY,0,MODE_ASCEND);
		for(int z=0;z<=2;z++)
		{	
			for(y=0;y<=2;y++)
			{	
				if(Email[y]==0)
				{	
					Email[y]=Email[y+1];
					Email[y+1]=0;
				}
			}
			if(Debug)
			{
				Print("Email ["+(z+1)+"] : "+Email[z]);
			}
		}
	}

	//+-----------------------------------------------------------------+
	//| Set SmartGrid parameters                                        |
	//+-----------------------------------------------------------------+
	if(UseSmartGrid)
	{	
		ArrayResize(RSI,RSI_Period+RSI_MA_Period);
		ArraySetAsSeries(RSI,true);
	}

	//+---------------------------------------------------------------+
	//| Initialize Statistics                                         |
	//+---------------------------------------------------------------+
	if(SaveStats)
	{	
		StatFile = "B3"+Symbol()+"_"+Period()+"_"+EANumber+".csv";
		NextStats = TimeCurrent();
		Stats(StatsInitialise,false,AccountBalance()*PortionPC,0);
	}
	
	return(0);
}

//+-----------------------------------------------------------------+
//| expert deinitialization function                                |
//+-----------------------------------------------------------------+
int deinit()
{	
	switch(UninitializeReason())
	{	
		case REASON_REMOVE:
		case REASON_CHARTCLOSE:
		case REASON_CHARTCHANGE:
			if(CpT>0)
			{
				while(CpT>0)
				{
					CpT-=ExitTrades(P,displayColorLoss,"Blessing Removed");
				}
			}
			GlobalVariablesDeleteAll(ID);
		case REASON_RECOMPILE:
		case REASON_PARAMETERS:
		case REASON_ACCOUNT:
			if(!Testing)
			{
				LabelDelete();
			}
			Comment("");
	}
	return(0);
}

//+-----------------------------------------------------------------+
//| expert start function                                           |
//+-----------------------------------------------------------------+
int start()
{	
	int     CbB          = 0;     // Count buy
	int     CbS          = 0;     // Count sell
	int     CpBL         = 0;     // Count buy limit
	int     CpSL         = 0;     // Count sell limit
	int     CpBS         = 0;     // Count buy stop
	int     CpSS         = 0;     // Count sell stop
	double  LbB          = 0;     // Count buy lots
	double  LbS          = 0;     // Count sell lots
	double  LbT          = 0;     // total lots out
	double  OPpBL        = 0;     // Buy limit open price
	double  OPpSL        = 0;     // Sell limit open price
	double  SLbB         = 0;     // stop losses are set to zero if POSL off
	double  SLbS         = 0;     // stop losses are set to zero if POSL off
	double  BCb,BCh,BCa;         // Broker costs (swap + commission)
	double  ProfitPot    = 0;     // The Potential Profit of a basket of Trades
	double  PipValue,PipVal2,ASK,BID;
	double  OrderLot;
	double  OPbL,OPhO;           // last open price
	int     OTbL;                // last open time
	double  g2,tp2,Entry,RSI_MA,LhB,LhS,LhT,OPbO,OTbO,OThO,TbO,ThO;
	int     Ticket,ChB,ChS,IndEntry;
	double  Pb,Ph,PaC,PbPips,PbTarget,DrawDownPC,BEb,BEh,BEa;
	bool    BuyMe,SellMe,Success,SetPOSL;
	string  IndicatorUsed;

	//+-----------------------------------------------------------------+
	//| Count Open Orders, Lots and Totals                              |
	//+-----------------------------------------------------------------+
	PipVal2 = MarketInfo(Symbol(),MODE_TICKVALUE)/MarketInfo(Symbol(),MODE_TICKSIZE);
	PipValue = PipVal2 * Pip;
	StopLevel = MarketInfo(Symbol(),MODE_STOPLEVEL) * Point;
	ASK = ND(MarketInfo(Symbol(),MODE_ASK),MarketInfo(Symbol(),MODE_DIGITS));
	BID = ND(MarketInfo(Symbol(),MODE_BID),MarketInfo(Symbol(),MODE_DIGITS));
	if(ASK == 0 || BID == 0)
	{
		return(0);
	}

	for(y = 0; y < OrdersTotal(); y++)
	{	
		if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))
		{
			continue;
		}
		int Type = OrderType();

		if(OrderMagicNumber() == hMagic)
		{	
			Ph  += OrderProfit();
			BCh += OrderSwap()+OrderCommission();
			BEh += OrderLots()*OrderOpenPrice();
			if(OrderOpenTime()<OThO || OThO==0)
			{	
				OThO = OrderOpenTime();
				ThO  = OrderTicket();
				OPhO = OrderOpenPrice();
			}
			if(Type == OP_BUY)
			{	
				ChB++;
				LhB += OrderLots();
			}
			else if(Type == OP_SELL)
			{	
				ChS++;
				LhS += OrderLots();
			}
			continue;
		}

		if(OrderMagicNumber()!=Magic || OrderSymbol()!=Symbol())
		{
			continue;
		}
		if(OrderTakeProfit() > 0)
		{
			ModifyOrder(OrderOpenPrice(),OrderStopLoss());
		}
		if( Type <= OP_SELL )
		{	
			Pb  += OrderProfit();
			BCb += OrderSwap()+OrderCommission();
			BEb += OrderLots()*OrderOpenPrice();
			if(OrderOpenTime() >= OTbL)
			{	
				OTbL = OrderOpenTime();
				OPbL = OrderOpenPrice();
			}
			if(OrderOpenTime()<OTbF || TbF==0)
			{		
				OTbF = OrderOpenTime();
				TbF  = OrderTicket();
				LbF  = OrderLots();
			}
			if(OrderOpenTime()<OTbO || OTbO==0)
			{	
				OTbO = OrderOpenTime();
				TbO  = OrderTicket();
				OPbO = OrderOpenPrice();
			}
			if(UsePowerOutSL&&((POSLPips>0&&OrderStopLoss()==0)||(POSLPips==0&&OrderStopLoss()>0)))
			{
				SetPOSL = true;
			}
			if(Type == OP_BUY)
			{	
				CbB++;
				LbB += OrderLots();
				continue;
			}
			else
			{	
				CbS++;
				LbS += OrderLots();
				continue;
			}
		}
		else
		{	
			if( Type == OP_BUYLIMIT)
			{	
				CpBL++;
				OPpBL = OrderOpenPrice();
				continue;
			}
			else if(Type == OP_SELLLIMIT)
			{	
				CpSL++;
				OPpSL = OrderOpenPrice();
				continue;
			}
			else if(Type == OP_BUYSTOP)
			{
				CpBS++;
			}
			else 
			{
				CpSS++;
			}
		}
	}
	CbT = CbB + CbS;
	LbT = LbB + LbS;
	Pb = ND(Pb+BCb,2);
	ChT = ChB + ChS;
	LhT = LhB + LhS;
	Ph = ND(Ph + BCh,2);
	CpT = CpBL+CpSL+CpBS+CpSS;
	BCa = BCb+BCh;

	//+-----------------------------------------------------------------+
	//| Calculate Min/Max Profit and Break Even Points                  |
	//+-----------------------------------------------------------------+
	if(LbT > 0)
	{		
		BEb = ND(BEb/LbT, Digits);
		if(BCa < 0)
		{
			if (LbB != LbS)
			{
				BEb -= ND(BCa/PipVal2/(LbB-LbS),Digits);
			}
			else
			{
				Print("LbB == LbS, I do NOT konw how to deal it!"); 
			}
		}
		if(Pb>PbMax || PbMax==0)
		{
			PbMax = Pb;
		}
		if(Pb<PbMin || PbMin==0)
		{
			PbMin = Pb;
		}
		if(!TradesOpen)
		{	
			FileHandle = FileOpen(FileName,FILE_BIN|FILE_WRITE);
			if( FileHandle > -1)
			{	
				FileWriteInteger(FileHandle, TbF);
				FileClose(FileHandle);
				TradesOpen = true;
				if(Debug)
				{
					Print(FileName+" File Written: "+TbF);
				}
			}
		}
	}
	else if(TradesOpen)
	{	
		TPb = 0;
		PbMax = 0;
		PbMin = 0;
		OTbF = 0;
		TbF = 0;
		LbF = 0;
		PbC = 0;
		PhC = 0;
		PaC = 0;
		ClosedPips = 0;
		CbC = 0;
		CaL = 0;
		bTS = 0;
		if(HedgeTypeDD)
		{
			hDDStart = HedgeStart;
		}
		else 
		{
			hLvlStart = HedgeStart;
		}
		EmailCount = 0;
		EmailSent = 0;
		FileHandle = FileOpen(FileName,FILE_BIN|FILE_READ);
		if(FileHandle > -1)
		{	
			FileClose(FileHandle);
			Error = GetLastError();
			FileDelete(FileName);
			Error = GetLastError();
			if(Error == ERR_NO_ERROR)
			{	
				if(Debug)
				{
					Print(FileName+" File Deleted");
				}
				TradesOpen = false;
			}
			else 
			{
				Print("Error deleting file: "+FileName+" "+Error+" "+ErrorDescription(Error));
			}
		}
		else 
		{
			TradesOpen = false;
		}
	}
	if(LhT>0)
	{	
		BEh = ND(BEh/LhT,Digits);
		if(Ph>PhMax || PhMax==0)
		{
			PhMax = Ph;
		}
		if(Ph<PhMin || PhMin==0)
		{
			PhMin = Ph;
		}
	}
	else
	{	
		PhMax = 0;
		PhMin = 0;
		SLh = 0;
	}

	//+-----------------------------------------------------------------+
	//| Check if trading is allowed                                     |
	//+-----------------------------------------------------------------+
	if(CbT==0 && ChT==0 && ShutDown)
	{	
		if(CpT>0)
		{	
			ExitTrades(P,displayColorLoss,"Blessing is shutting down");
			return(0);
		}
		if(AllowTrading)
		{	
			Print("Blessing has ShutDown. Set ShutDown = 'false' to continue trading");
			if(PlaySounds)
			{
				PlaySound(AlertSound);
			}
			AllowTrading = false;
		}
		if(UseEmail&&EmailCount<4&&!Testing)
		{	
			SendMail("Blessing EA","Blessing has shut down on "+Symbol()+" "+sTF+
					". Trading has been suspended. To resume trading, set ShutDown to false.");
			Error = GetLastError();
			if(Error>0)
			{
				Print("Error sending Email: "+Error+" "+ErrorDescription(Error));
			}
			else 
			{
				EmailCount = 4;
			}
		}
	}

	static bool LDelete;
	if(!AllowTrading)
	{	
		if(!LDelete)
		{	
			LDelete = true;
			LabelDelete();
			if(ObjectFind("B3LStop")==-1)
			{
				CreateLabel("B3LStop","Trading has been stopped on this pair.",10,0,0,3,displayColorLoss);
			}
			if(Testing)
			{
				string Tab = "Tester Journal";
			}
			else 
			{
				Tab = "Terminal Experts";
			}

			if(ObjectFind("B3LExpt")==-1)
			{
				CreateLabel("B3LExpt","Check the "+Tab+" tab for the reason why.",10,0,0,6,displayColorLoss);
			}
			if(ObjectFind("B3LResm")==-1)
			{
				CreateLabel("B3LResm","Reset Blessing to resume trading.",10,0,0,9,displayColorLoss);
			}
		}
		return(0);
	}
	else
	{	
		LDelete=false;
		ObjDel("B3LStop");
		ObjDel("B3LExpt");
		ObjDel("B3LResm");
	}

	//+-----------------------------------------------------------------+
	//| Calculate Drawdown and Equity Protection                        |
	//+-----------------------------------------------------------------+
	double NewPortionBalance = ND(AccountBalance()*PortionPC,2);
	if(CbT==0 || PortionChange<0 || (PortionChange>0 && NewPortionBalance>PortionBalance))
	{
		PortionBalance = NewPortionBalance;
	}
	if(Pb+Ph < 0)
	{
		DrawDownPC = -(Pb+Ph)/PortionBalance;
	}
	if(!FirstRun&&DrawDownPC >= MaxDDPercent/100)
	{	
		ExitTrades(A,displayColorLoss,"Equity Stop Loss Reached");
		if(PlaySounds)
		{
			PlaySound(AlertSound);
		}
		return(0);
	}
	if(-(Pb+Ph) > MaxDD)
	{
		MaxDD = -(Pb+Ph);
	}
	MaxDDPer = MathMax(MaxDDPer,DrawDownPC*100);
	if(SaveStats)
	{
		Stats(false,TimeCurrent()<NextStats,PortionBalance,Pb+Ph);
	}

	//+-----------------------------------------------------------------+
	//| Calculate  Stop Trade Percent                                   |
	//+-----------------------------------------------------------------+
	double StepAB = InitialAB*(1+StopTradePercent);
	double StepSTB = AccountBalance()*(1-StopTradePercent);
	double NextISTB = StepAB*(1-StopTradePercent);
	if(StepSTB>NextISTB)
	{	
		InitialAB = StepAB;
		StopTradeBalance = StepSTB;
	}
	double InitialAccountMultiPortion = StopTradeBalance*PortionPC;
	if(PortionBalance < InitialAccountMultiPortion)
	{	
		if(CbT==0)
		{	
			AllowTrading=false;
			if(PlaySounds)PlaySound(AlertSound);
			Print("Portion Balance dropped below stop trade percent");
			MessageBox("Reset Blessing, account balance dropped below stop trade percent on "+Symbol()+Period(),"Blessing 3: Warning",48);
			return(0);
		}
		else if(!ShutDown && !RecoupClosedLoss)
		{	
			ShutDown = true;
			if(PlaySounds)
			{
				PlaySound(AlertSound);
			}
			Print("Portion Balance dropped below stop trade percent");
			return(0);
		}
	}

	//+-----------------------------------------------------------------+
	//| Calculation of Trend Direction                                  |
	//+-----------------------------------------------------------------+
	int Trend;
	string ATrend;
	double ima_0 = iMA(Symbol(),0,MAPeriod,0,MODE_EMA,PRICE_CLOSE,0);
	if(ForceMarketCond == 3)
	{	
		if(BID > ima_0+MADistance)
		{
			Trend = 0;
		}
		else if(ASK < ima_0-MADistance)
		{

			Trend = 1;
		}
		else
		{
			Trend = 2;
		}
	}
	else
	{	
		Trend = ForceMarketCond;
		if(Trend != 0 && BID > ima_0+MADistance)
		{
			ATrend = "U";
		}
		if(Trend != 1 && ASK < ima_0-MADistance)
		{
			ATrend = "D";
		}
		if(Trend != 2 && (BID<ima_0+MADistance&&ASK>ima_0-MADistance))
		{
			ATrend = "R";
		}
	}
	//+-----------------------------------------------------------------+
	//| Hedge/Basket/ClosedTrades Profit Management                     |
	//+-----------------------------------------------------------------+
	double Pa = Pb;
	PaC = PbC+PhC;
	if(hActive==1 && ChT==0)
	{	
		PhC = FindClosedPL(H);
		hActive = 0;
		return(0);
	}
	else if(hActive==0 && ChT>0)
	{
		hActive=1;
	}
	if(LbT > 0)
	{	
		if(PbC>0 || (PbC<0&&RecoupClosedLoss))
		{	
			Pa += PbC;
			BEb -= ND(PbC/PipVal2/(LbB-LbS), Digits);
		}
		if(PhC>0 || (PhC<0&&RecoupClosedLoss))
		{	
			Pa += PhC;
			BEb -= ND(PhC/PipVal2/(LbB-LbS), Digits);
		}
		if(Ph>0 || (Ph<0&&RecoupClosedLoss))
		{
			Pa += Ph;
		}
	}

	//+-----------------------------------------------------------------+
	//| Close oldest open trade after CloseTradesLevel reached          |
	//+-----------------------------------------------------------------+
	if(UseCloseOldest && CbT>=CloseTradesLevel && CbC<MaxCloseTrades)
	{	
		if(!FirstRun && TPb>0 && (ForceCloseOldest||(CbB>0&&OPbO>TPb) || (CbS>0&&OPbO<TPb)))
		{	
			y = ExitTrades(T,DarkViolet,"Close Oldest Trade",TbO);
			if(y == 1)
			{	
				OrderSelect(TbO,SELECT_BY_TICKET);
				PbC += OrderProfit()+OrderSwap()+OrderCommission();
				ca = 0;
				CbC++;
				return(0);
			}
		}
	}

	//+-----------------------------------------------------------------+
	//| ATR for Auto Grid Calculation and Grid Set Block                |
	//+-----------------------------------------------------------------+
	double GridTP;
	if(AutoCal)
	{	
		double GridATR = iATR(NULL,TF[ATRTF],ATRPeriods,0)/Pip;
		if((CbT+CbC>Set4Level) && Set4Level>0)
		{	
			g2 = GridATR*12;    //GS*2*2*2*1.5
			tp2 = GridATR*18;   //GS*2*2*2*1.5*1.5
		}
		else if((CbT+CbC>Set3Level) && Set3Level>0)
		{	
			g2 = GridATR*8;     //GS*2*2*2
			tp2 = GridATR*12;   //GS*2*2*2*1.5
		}
		else if((CbT+CbC>Set2Level) && Set2Level>0)
		{	
			g2 = GridATR*4;     //GS*2*2
			tp2 = GridATR*8;    //GS*2*2*2
		}
		else if((CbT+CbC>Set1Level) && Set1Level>0)
		{	
			g2 = GridATR*2;     //GS*2
			tp2 = GridATR*4;    //GS*2*2
		}
		else
		{	
			g2 = GridATR;
			tp2 = GridATR*2;
		}
		GridTP = GridATR*2;
	}
	else
	{	
		y = MathMax(MathMin(CbT+CbC,MaxTrades)-1,0);
		g2 = GridArray[y,0];
		tp2 = GridArray[y,1];
		GridTP = GridArray[0,1];
	}
	g2 = ND(MathMax(g2*GAF*Pip,Pip), Digits);
	tp2 = ND(tp2*GAF*Pip, Digits);
	GridTP = ND(GridTP*GAF*Pip, Digits);


	//+-----------------------------------------------------------------+
	//| Money Management and Lot size coding                            |
	//+-----------------------------------------------------------------+
	if(UseMM)
	{	
		if(CbT>0)
		{	
			if(GlobalVariableCheck(ID+"LotMult"))
			{
				LotMult = GlobalVariableGet(ID+"LotMult");
			}
			if(LbF != LotSize(Lots[0]*LotMult))
			{	
				LotMult=LbF/Lots[0];
				GlobalVariableSet(ID+"LotMult",LotMult);
				Print("LotMult reset to "+DTS(LotMult,0));
			}
		}
		if(CbT==0)
		{	
			double Contracts,Factor,Lotsize;
			Contracts = PortionBalance/10000;
			if(Multiplier <= 1)
			{
				Factor = Level;
			}
			else 
			{
				Factor = (MathPow(Multiplier,Level)-Multiplier)/(Multiplier-1);
			}
			Lotsize = LAF*AccountType*Contracts/(1+Factor);
			LotMult = MathMax(MathFloor(Lotsize/Lot),MinMult);
			GlobalVariableSet(ID+"LotMult",LotMult);
		}
	}
	else if(CbT==0)
	{
		LotMult = MinMult;
	}
	
	//+-----------------------------------------------------------------+
	//| Calculate Take Profit                                           |
	//+-----------------------------------------------------------------+
	static double BCaL,BEbL;
	double nLots = LbB - LbS;
	if(CbT>0 && (TPb==0||CbT+ChT!=CaL||BEbL!=BEb||BCa!=BCaL||FirstRun))
	{	
		string sCalcTP = "Set New TP:  BE: "+DTS(BEb,Digits);
		double NewTP,BasePips;
		CaL = CbT + ChT;
		BCaL = BCa;
		BEbL = BEb;
		Print("++++++++++++nLots: "+nLots+" LbB:"+LbB+" LbS:"+LbS+" ++++++++++");
		if (nLots != 0)
		{
			BasePips = ND(Lot*LotMult*GridTP*(CbT+CbC)/nLots, Digits);
			Print("BasePips: "+ BasePips);
		}
		else
		{
			Print("nLots is 0 !!! I do NOT kown how to deal it!");
		}
		if(CbB > 0)
		{	
			if(ForceTPPips > 0)
			{	
				NewTP = BEb+ForceTPPips;
				sCalcTP=sCalcTP+" +Force TP ("+DTS(ForceTPPips,Digits)+") ";
			}
			else if(CbC>0&&CloseTPPips>0)
			{	
				NewTP=BEb+CloseTPPips;
				sCalcTP=sCalcTP+" +Close TP ("+DTS(CloseTPPips,Digits)+") ";
			}
			else if(BEb+BasePips>OPbL+tp2)
			{	
				NewTP=BEb+BasePips;
				sCalcTP=sCalcTP+" +Base TP: ("+DTS(BasePips,Digits)+") ";
			}
			else
			{	
				NewTP=OPbL+tp2;
				sCalcTP=sCalcTP+" +Grid TP: ("+DTS(tp2,Digits)+") ";
			}
			if(MinTPPips>0)
			{	
				NewTP=MathMax(NewTP,BEb+MinTPPips);
				sCalcTP=sCalcTP+" >Minimum TP: ";
			}
			NewTP+=MoveTP*Moves;
			if(BreakEvenTrade>0&&CbT+CbC>=BreakEvenTrade)
			{	
				NewTP=BEb+BEPlusPips;
				sCalcTP=sCalcTP+" >BreakEven: ("+DTS(BEPlusPips,Digits)+") ";
			}
			sCalcTP=(sCalcTP+"Buy: TakeProfit: ");
		}
		else if(CbS>0)
		{	
			if(ForceTPPips>0)
			{	
				NewTP=BEb-ForceTPPips;
				sCalcTP=sCalcTP+" -Force TP ("+DTS(ForceTPPips,Digits)+") ";
			}
			else if(CbC>0&&CloseTPPips>0)
			{	
				NewTP=BEb-CloseTPPips;
				sCalcTP=sCalcTP+" -Close TP ("+DTS(CloseTPPips,Digits)+") ";
			}
			else if(BEb+BasePips<OPbL-tp2)
			{	
				NewTP=BEb+BasePips;
				sCalcTP=sCalcTP+" -Base TP: ("+DTS(BasePips,Digits)+") ";
			}
			else
			{	NewTP=OPbL-tp2;
				sCalcTP=sCalcTP+" -Grid TP: ("+DTS(tp2,Digits)+") ";
			}
			if(MinTPPips>0)
			{	NewTP=MathMin(NewTP,BEb-MinTPPips);
				sCalcTP=sCalcTP+" >Minimum TP: ";
			}
			NewTP-=MoveTP*Moves;
			if(BreakEvenTrade>0&&CbT+CbC>=BreakEvenTrade)
			{	NewTP=BEb-BEPlusPips;
				sCalcTP=sCalcTP+" >BreakEven: ("+DTS(BEPlusPips,Digits)+") ";
			}
			sCalcTP=(sCalcTP+"Sell: TakeProfit: ");
		}
		if(TPb!=NewTP)
		{	TPb=NewTP;
			if(nLots>0)TargetPips=ND(TPb-BEb,Digits);
			else TargetPips=ND(BEb-TPb,Digits);
			Print(sCalcTP+DTS(NewTP,Digits));
			return(0);
		}
	}
	PbTarget=TargetPips/Pip;
	ProfitPot=ND(TargetPips*PipVal2*MathAbs(nLots),2);
	if(CbB>0)PbPips=ND((BID-BEb)/Pip,1);
	if(CbS>0)PbPips=ND((BEb-ASK)/Pip,1);

	//+-----------------------------------------------------------------+
	//| Adjust BEb/TakeProfit if Hedge is active                        |
	//+-----------------------------------------------------------------+
	double hAsk=MarketInfo(HedgeSymbol,MODE_ASK);
	double hBid=MarketInfo(HedgeSymbol,MODE_BID);
	double hSpread=hAsk-hBid;
	if(hThisChart)nLots+=LhB-LhS;
	if(hActive==1)
	{	double TPa,PhPips;
		if(nLots==0)
		{	BEa=0;
			TPa=0;
		}
		else if(hThisChart)
		{	if(nLots>0)
			{	if(CbB>0)BEa=ND((BEb*LbT-(BEh-hSpread)*LhT)/(LbT-LhT),Digits);
				else BEa=ND(((BEb-(ASK-BID))*LbT-BEh*LhT)/(LbT-LhT),Digits);
				TPa=ND(BEa+TargetPips,Digits);
			}
			else
			{	if(CbS>0)BEa=ND((BEb*LbT-(BEh+hSpread)*LhT)/(LbT-LhT),Digits);
				else BEa=ND(((BEb+ASK-BID)*LbT-BEh*LhT)/(LbT-LhT),Digits);
				TPa=ND(BEa-TargetPips,Digits);
			}
		}
		else
		{
		}
		if(ChB>0)PhPips=ND((hBid-BEh)/hPip,1);
		if(ChS>0)PhPips=ND((BEh-hAsk)/hPip,1);
	}
	else
	{	BEa=BEb;
		TPa=TPb;
	}
	//+-----------------------------------------------------------------+
	//| Calculate Early Exit Percentage                                 |
	//+-----------------------------------------------------------------+
	if(UseEarlyExit&&CbT>0)
	{	double EEpc,EEopt,EEStartTime,TPaF;
		if(EEFirstTrade)EEopt=OTbF;
		else EEopt=OTbL;
		if(DayOfWeek()<TimeDayOfWeek(EEopt))EEStartTime=2*24*3600;
		EEStartTime+=EEopt+EEStartHours*3600;
		if(EEHoursPC>0&&TimeCurrent()>=EEStartTime)EEpc=EEHoursPC*(TimeCurrent()-EEStartTime)/3600;
		if(EELevelPC>0&&(CbT+CbC)>=EEStartLevel)EEpc+=EELevelPC*(CbT+CbC-EEStartLevel+1);
		EEpc=1-EEpc;
		if(!EEAllowLoss&&EEpc<0)EEpc=0;
		PbTarget*=EEpc;
		TPaF=ND((TPa-BEa)*EEpc+BEa,Digits);
		if(displayOverlay&&displayLines&&(hActive!=1||(hActive==1&&hThisChart))&&(!Testing||(Testing&&Visual))&&EEpc<1
			&&(CbT+CbC+ChT>EECount||EETime!=Time[0])&&((EEHoursPC>0&&EEopt+EEStartHours*3600<Time[0])||(EELevelPC>0&&CbT+CbC>=EEStartLevel)))
		{	EETime=Time[0];
			EECount=CbT+CbC+ChT;
			if(ObjectFind("B3LEELn")<0)
			{	ObjectCreate("B3LEELn",OBJ_TREND,0,0,0);
				ObjectSet("B3LEELn",OBJPROP_COLOR,Yellow);
				ObjectSet("B3LEELn",OBJPROP_WIDTH,1);
				ObjectSet("B3LEELn",OBJPROP_STYLE,0);
				ObjectSet("B3LEELn",OBJPROP_RAY,false);
			}
			if(EEHoursPC>0)ObjectMove("B3LEELn",0,MathFloor(EEopt/3600+EEStartHours)*3600,TPa);
			else ObjectMove("B3LEELn",0,MathFloor(EEopt/3600)*3600,TPaF);
			ObjectMove("B3LEELn",1,Time[1],TPaF);
			if(ObjectFind("B3VEELn")<0)
			{	ObjectCreate("B3VEELn",OBJ_TEXT,0,0,0);
				ObjectSet("B3VEELn",OBJPROP_COLOR,Yellow);
				ObjectSet("B3VEELn",OBJPROP_WIDTH,1);
				ObjectSet("B3VEELn",OBJPROP_STYLE,0);
			}
			ObjSetTxt("B3VEELn","              "+DTS(TPaF,Digits),-1,Yellow);
			ObjectSet("B3VEELn",OBJPROP_PRICE1,TPaF+2*Pip);
			ObjectSet("B3VEELn",OBJPROP_TIME1,Time[1]);
		}
		else if((!displayLines||EEpc==1||(!EEAllowLoss&&EEpc==0)||(EEHoursPC>0&&EEopt+EEStartHours*3600>=Time[0])))
		{	ObjDel("B3LEELn");
			ObjDel("B3VEELn");
		}
	}
	else
	{	TPaF=TPa;
		EETime=0;
		EECount=0;
		ObjDel("B3LEELn");
		ObjDel("B3VEELn");
	}

	//+-----------------------------------------------------------------+
	//| Maximize Profit with Moving TP and setting Trailing Profit Stop |
	//+-----------------------------------------------------------------+
	if(MaximizeProfit)
	{	if(CbT==0)
		{	SLbL=0;
			Moves=0;
			SLb=0;
		}
		if(!FirstRun&&CbT>0)
		{	if(Pb+Ph<0&&SLb>0)SLb=0;
			if(SLb>0&&((nLots>0&&BID<SLb)||(nLots<0&&ASK>SLb)))
			{	ExitTrades(A,displayColorProfit,"Profit Trailing Stop Reached ("+DTS(ProfitSet*100,2)+"%)");
				return(0);
			}
			if(PbTarget>0)
			{	double TPbMP=ND(BEa+(TPa-BEa)*ProfitSet,Digits);
				if((nLots>0&&BID>TPbMP)||(nLots<0&&ASK<TPbMP))SLb=TPbMP;
			}
			if(SLb>0&&SLb!=SLbL&&MoveTP>0&&TotalMoves>Moves)
			{	TPb=0;
				Moves++;
				if(Debug)Print("MoveTP");
				SLbL=SLb;
				if(PlaySounds)PlaySound(AlertSound);
				return(0);
			}
		}
	}
	if(!FirstRun&&TPaF>0)
	{	if((nLots>0&&BID>=TPaF)||(nLots<0&&ASK<=TPaF))
		{	ExitTrades(A,displayColorProfit,"Profit Target Reached @ "+DTS(TPaF,Digits));
			return(0);
		}
	}
	if(!FirstRun&&UseStopLoss)
	{	double bSL;
		if(SLPips>0)
		{	if(nLots>0)
			{	bSL=BEa-SLPips;
				if(BID<=bSL)
				{	ExitTrades(A,displayColorProfit,"Stop Loss Reached");
					return(0);
				}
			}
			else if(nLots<0)
			{	bSL=BEa+SLPips;
				if(ASK>=bSL)
				{	ExitTrades(A,displayColorProfit,"Stop Loss Reached");
					return(0);
				}
			}
		}
		if(TSLPips!=0)
		{	if(nLots>0)
			{	if(TSLPips>0&&BID>BEa+TSLPips)bTS=MathMax(bTS,BID-TSLPips);
				if(TSLPips<0&&BID>BEa-TSLPips)bTS=MathMax(bTS,BID-MathMax(TSLPipsMin,-TSLPips*(1-(BID-BEa+TSLPips)/(-TSLPips*2))));
				if(bTS>0&&BID<=bTS)
				{	ExitTrades(A,displayColorProfit,"Trailing Stop Reached");
					return(0);
				}
			}
			else if(nLots<0)
			{	if(TSLPips>0&&ASK<BEa-TSLPips)
				{	if(bTS>0)bTS=MathMin(bTS,ASK+TSLPips);
				   else bTS=ASK+TSLPips;
				}
				if(TSLPips<0&&ASK<BEa+TSLPips)bTS=MathMin(bTS,ASK+MathMax(TSLPipsMin,-TSLPips*(1-(BEa-ASK+TSLPips)/(-TSLPips*2))));
				if(bTS>0&&ASK>=bTS)
				{	ExitTrades(A,displayColorProfit,"Trailing Stop Reached");
					return(0);
				}
			}
		}
	}

	//+-----------------------------------------------------------------+
	//| Check for and Delete hanging pending orders                     |
	//+-----------------------------------------------------------------+
	if(CbT==0&&!PendLot)
	{	PendLot=true;
		for(y=OrdersTotal()-1;y>=0;y--)
		{	if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
			if(OrderMagicNumber()!=Magic||OrderType()<=OP_SELL)continue;
			if(ND(OrderLots(),LotDecimal)>ND(Lots[0]*LotMult,LotDecimal))
			{	PendLot=false;
				while(IsTradeContextBusy())Sleep(100);
				if(IsStopped())return(-1);
				Success=OrderDelete(OrderTicket());
				if(Success)
				{	PendLot=true;
					if(Debug)Print("Delete pending > Lot");
				}
			}
		}
		return(0);
	}
	else if((CbT>0||(CbT==0&&CpT>0&&!B3Traditional))&&PendLot)
	{	PendLot=false;
		for(y=OrdersTotal()-1;y>=0;y--)
		{	if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
			if(OrderMagicNumber()!=Magic||OrderType()<=OP_SELL)continue;
			if(ND(OrderLots(),LotDecimal)==ND(Lots[0]*LotMult,LotDecimal))
			{	PendLot=true;
				while(IsTradeContextBusy())Sleep(100);
				if(IsStopped())return(-1);
				Success=OrderDelete(OrderTicket());
				if(Success)
				{	PendLot=false;
					if(Debug)Print("Delete pending = Lot");
				}
			}
		}
		return(0);
	}

	//+-----------------------------------------------------------------+
	//| Check ca, Breakeven Trades and Emergency Close All              |
	//+-----------------------------------------------------------------+
	switch(ca)
	{	case B:  if(CbT==0&&CpT==0)ca=0;break;
		case H:  if(ChT==0)ca=0;break;
		case A:  if(CbT==0&&CpT==0&&ChT==0)ca=0;break;
		case P:  if(CpT==0)ca=0;break;
		case T:  break;
		default: break;
	}
	if(ca>0)
	{	ExitTrades(ca,displayColorLoss,"Close All ("+DTS(ca,0)+")");
		return(0);
	}
	if(CbT==0&&ChT>0)
	{	ExitTrades(H,displayColorLoss,"Basket Closed");
		return(0);
	}
	if(EmergencyCloseAll)
	{	ExitTrades(A,displayColorLoss,"Emergency Close All Trades");
		EmergencyCloseAll=false;
		return(0);
	}

	//+-----------------------------------------------------------------+
	//| Check Holiday Shutdown                                          |
	//+-----------------------------------------------------------------+
	if(UseHolidayShutdown)
	{	if(HolShutDown>0&&TimeCurrent()>=HolLast&&HolLast>0)
		{	Print("Blessing has resumed after the holidays. From: "+TimeToStr(HolFirst,TIME_DATE)+" To: "+TimeToStr(HolLast,TIME_DATE));
			HolShutDown=0;
			LabelDelete();
			LabelCreate();
			if(PlaySounds)PlaySound(AlertSound);
		}
		if(HolShutDown==3)
		{	if(ObjectFind("B3LStop")==-1)
				CreateLabel("B3LStop","Trading has been stopped on this pair for the holidays.",10,0,0,3,displayColorLoss);
			if(ObjectFind("B3LResm")==-1)
				CreateLabel("B3LResm","Blessing will resume trading after "+TimeToStr(HolLast,TIME_DATE)+".",10,0,0,9,displayColorLoss);
			return(0);
		}
		else if((HolShutDown==0&&TimeCurrent()>=HolLast)||HolFirst==0)
		{	for(y=0;y<ArraySize(HolArray);y++)
			{	HolFirst=StrToTime(Year()+"."+HolArray[y,0]+"."+HolArray[y,1]);
				HolLast=StrToTime(Year()+"."+HolArray[y,2]+"."+HolArray[y,3]+" 23:59:59");
				if(TimeCurrent()<HolFirst)
				{	if(HolFirst>HolLast)HolLast=StrToTime(DTS(Year()+1,0)+"."+HolArray[y,2]+"."+HolArray[y,3]+" 23:59:59");
					break;
				}
				if(TimeCurrent()<HolLast)
				{	if(HolFirst>HolLast)HolFirst=StrToTime(DTS(Year()-1,0)+"."+HolArray[y,0]+"."+HolArray[y,1]);
					break;
				}
				if(TimeCurrent()>HolFirst&&HolFirst>HolLast)
				{	HolLast=StrToTime(DTS(Year()+1,0)+"."+HolArray[y,2]+"."+HolArray[y,3]+" 23:59:59");
					if(TimeCurrent()<HolLast)break;
				}
			}
			if(TimeCurrent()>=HolFirst&&TimeCurrent()<=HolLast)
			{	Comment("");
				HolShutDown=1;
			}
		}
		else if(HolShutDown==0&&TimeCurrent()>=HolFirst&&TimeCurrent()<HolLast)HolShutDown=1;
		if(HolShutDown==1&&CbT==0)
		{	Print("Blessing has shut down for the holidays. From: "+TimeToStr(HolFirst,TIME_DATE)+
					" To: "+TimeToStr(HolLast,TIME_DATE));
			if(CpT>0)
			{	y=ExitTrades(P,displayColorLoss,"Holiday Shutdown");
				if(y==CpT)ca=0;
			}
			HolShutDown=2;
			ObjDel("B3LClos");
		}
		else if(HolShutDown==1)
		{	if(ObjectFind("B3LClos")==-1)CreateLabel("B3LClos","",5,0,0,23,displayColorLoss);
			ObjSetTxt("B3LClos","Blessing will shutdown for the holidays when this basket closes",5);
		}
		if(HolShutDown==2)
		{	LabelDelete();
			if(PlaySounds)PlaySound(AlertSound);
			HolShutDown=3;
		}
		if(HolShutDown==3)
		{	if(ObjectFind("B3LStop")==-1)
				CreateLabel("B3LStop","Trading has been stopped on this pair for the holidays.",10,0,0,3,displayColorLoss);
			if(ObjectFind("B3LResm")==-1)
				CreateLabel("B3LResm","Blessing will resume trading after "+TimeToStr(HolLast,TIME_DATE)+".",10,0,0,9,displayColorLoss);
			Comment("");
			return(0);
		}
	}

	//+-----------------------------------------------------------------+
	//| Power Out Stop Loss Protection                                  |
	//+-----------------------------------------------------------------+
	if(SetPOSL)
	{	if(UsePowerOutSL&&POSLPips>0)
		{	double POSL=MathMin(PortionBalance*(MaxDDPercent+1)/100/PipVal2/LbT,POSLPips);
			SLbB=ND(BEb-POSL,Digits);
			SLbS=ND(BEb+POSL,Digits);
		}
		else
		{	SLbB=0;
			SLbS=0;
		}
		for(y=0;y<OrdersTotal();y++)
		{	if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
			if(OrderMagicNumber()!=Magic||OrderSymbol()!=Symbol()||OrderType()>OP_SELL)continue;
			if(OrderType()==OP_BUY&&OrderStopLoss()!=SLbB)
			{	Success=ModifyOrder(OrderOpenPrice(),SLbB,Purple);
				if(Debug&&Success)Print("Order: "+OrderTicket()+" Sync POSL Buy");
			}
			else if(OrderType()==OP_SELL&&OrderStopLoss()!=SLbS)
			{	Success=ModifyOrder(OrderOpenPrice(),SLbS,Purple);
				if(Debug&&Success)Print("Order: "+OrderTicket()+" Sync POSL Sell");
			}
		}
	}

	//+-----------------------------------------------------------------+  << This must be the first Entry check.
	//| Moving Average Indicator for Order Entry                        |  << Add your own Indicator Entry checks
	//+-----------------------------------------------------------------+  << after the Moving Average Entry.
	if(MAEntry>0&&CbT==0&&CpT<2)
	{	if(BID>ima_0+MADistance&&(!B3Traditional||(B3Traditional&&Trend!=2)))
		{	if(MAEntry==1)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
			else if(MAEntry==2)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
		}
		else if(ASK<ima_0-MADistance&&(!B3Traditional||(B3Traditional&&Trend!=2)))
		{	if(MAEntry==1)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
			else if(MAEntry==2)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
		}
		else if(B3Traditional&&Trend==2)
		{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
			if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
		}
		else
		{	BuyMe=false;
			SellMe=false;
		}
		if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
		IndEntry++;
		IndicatorUsed=IndicatorUsed+" MA ";
	}

	//+----------------------------------------------------------------+
	//| CCI of 5M,15M,30M,1H for Market Condition and Order Entry      |
	//+----------------------------------------------------------------+
	if(CCIEntry>0)
	{	double cci_01=iCCI(Symbol(),PERIOD_M5,CCIPeriod,PRICE_CLOSE,0);
		double cci_02=iCCI(Symbol(),PERIOD_M15,CCIPeriod,PRICE_CLOSE,0);
		double cci_03=iCCI(Symbol(),PERIOD_M30,CCIPeriod,PRICE_CLOSE,0);
		double cci_04=iCCI(Symbol(),PERIOD_H1,CCIPeriod,PRICE_CLOSE,0);
		double cci_11=iCCI(Symbol(),PERIOD_M5,CCIPeriod,PRICE_CLOSE,1);
		double cci_12=iCCI(Symbol(),PERIOD_M15,CCIPeriod,PRICE_CLOSE,1);
		double cci_13=iCCI(Symbol(),PERIOD_M30,CCIPeriod,PRICE_CLOSE,1);
		double cci_14=iCCI(Symbol(),PERIOD_H1,CCIPeriod,PRICE_CLOSE,1);
	}
	if(CCIEntry>0&&CbT==0&&CpT<2)
	{	if(cci_11>0&&cci_12>0&&cci_13>0&&cci_14>0&&cci_01>0&&cci_02>0&&cci_03>0&&cci_04>0)
		{	if(ForceMarketCond==3)Trend=0;
			if(CCIEntry==1)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
			else if(CCIEntry==2)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
		}
		else if(cci_11<0&&cci_12<0&&cci_13<0&&cci_14<0&&cci_01<0&&cci_02<0&&cci_03<0&&cci_04<0)
		{	if(ForceMarketCond==3)Trend=1;
			if(CCIEntry==1)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
			else if(CCIEntry==2)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
		}
		else if(!UseAnyEntry&&IndEntry>0)
		{	BuyMe=false;
			SellMe=false;
		}
		if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
		IndEntry++;
		IndicatorUsed=IndicatorUsed+" CCI ";
	}

	//+----------------------------------------------------------------+
	//| Bollinger Band Indicator for Order Entry                       |
	//+----------------------------------------------------------------+
	if(BollingerEntry>0&&CbT==0&&CpT<2)
	{	double ma=iMA(Symbol(),0,BollPeriod,0,MODE_SMA,PRICE_OPEN,0);
		double stddev=iStdDev(Symbol(),0,BollPeriod,0,MODE_SMA,PRICE_OPEN,0);
		double bup=ma+(BollDeviation*stddev);
		double bdn=ma-(BollDeviation*stddev);
		double bux=bup+BollDistance;
		double bdx=bdn-BollDistance;
		if(ASK<bdx)
		{	if(BollingerEntry==1)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
			else if(BollingerEntry==2)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
		}
		else if(BID>bux)
		{	if(BollingerEntry==1)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
			else if(BollingerEntry==2)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
		}
		else if(!UseAnyEntry&&IndEntry>0)
		{	BuyMe=false;
			SellMe=false;
		}
		if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
		IndEntry++;
		IndicatorUsed=IndicatorUsed+" BBands ";
	}

	//+----------------------------------------------------------------+
	//| Stochastic Indicator for Order Entry                           |
	//+----------------------------------------------------------------+
	if(StochEntry>0&&CbT==0&&CpT<2)
	{	int zoneBUY=BuySellStochZone;
		int zoneSELL=100-BuySellStochZone;
		double stoc_0=iStochastic(NULL,0,KPeriod,DPeriod,Slowing,MODE_LWMA,1,0,1);
		double stoc_1=iStochastic(NULL,0,KPeriod,DPeriod,Slowing,MODE_LWMA,1,1,1);
		if(stoc_0<zoneBUY&&stoc_1<zoneBUY)
		{	if(StochEntry==1)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
			else if(StochEntry==2)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
		}
		else if(stoc_0>zoneSELL&&stoc_1>zoneSELL)
		{	if(StochEntry==1)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
			else if(StochEntry==2)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
		}
		else if(!UseAnyEntry&&IndEntry>0)
		{	BuyMe=false;
			SellMe=false;
		}
		if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
		IndEntry++;
		IndicatorUsed=IndicatorUsed+" Stoch ";
	}

	//+----------------------------------------------------------------+
	//| MACD Indicator for Order Entry                                 |
	//+----------------------------------------------------------------+
	if(MACDEntry>0&&CbT==0&&CpT<2)
	{	double MACDm=iMACD(NULL,TF[MACD_TF],FastPeriod,SlowPeriod,SignalPeriod,MACDPrice,0,0);
		double MACDs=iMACD(NULL,TF[MACD_TF],FastPeriod,SlowPeriod,SignalPeriod,MACDPrice,1,0);
		if(MACDm>MACDs)
		{	if(MACDEntry==1)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
			else if(MACDEntry==2)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
		}
		else if(MACDm<MACDs)
		{	if(MACDEntry==1)
			{	if(ForceMarketCond!=0&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&SellMe)))SellMe=true;
				else SellMe=false;
				if(!UseAnyEntry&&IndEntry>0&&BuyMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))BuyMe=false;
			}
			else if(MACDEntry==2)
			{	if(ForceMarketCond!=1&&(UseAnyEntry||IndEntry==0||(!UseAnyEntry&&IndEntry>0&&BuyMe)))BuyMe=true;
				else BuyMe=false;
				if(!UseAnyEntry&&IndEntry>0&&SellMe&&(!B3Traditional||(B3Traditional&&Trend!=2)))SellMe=false;
			}
		}
		else if(!UseAnyEntry&&IndEntry>0)
		{	BuyMe=false;
			SellMe=false;
		}
		if(IndEntry>0)IndicatorUsed=IndicatorUsed+UAE;
		IndEntry++;
		IndicatorUsed=IndicatorUsed+" MACD ";
	}

	//+-----------------------------------------------------------------+  << This must be the last Entry check before
	//| UseAnyEntry Check && Force Market Condition Buy/Sell Entry      |  << the Trade Selection Logic. Add checks for
	//+-----------------------------------------------------------------+  << additional indicators before this block.
	if((!UseAnyEntry&&IndEntry>1&&BuyMe&&SellMe)||FirstRun)
	{	BuyMe=false;
		SellMe=false;
	}
	if(ForceMarketCond<2&&IndEntry==0&&CbT==0&&!FirstRun)
	{	if(ForceMarketCond==0)BuyMe=true;
		if(ForceMarketCond==1)SellMe=true;
		IndicatorUsed=" FMC ";
	}

	//+-----------------------------------------------------------------+
	//| Trade Selection Logic                                           |
	//+-----------------------------------------------------------------+
	OrderLot=LotSize(Lots[StrToInteger(DTS(MathMin(CbT+CbC,MaxTrades-1),0))]*LotMult);
	if(CbT==0&&CpT<2&&!FirstRun)
	{	if(B3Traditional)
		{	if(BuyMe)
			{	if(CpBS==0&&CpSL==0&&((Trend!=2||MAEntry==0)||(Trend==2&&MAEntry==1)))
				{	Entry=g2-MathMod(ASK,g2)+EntryOffset;
					if(Entry>StopLevel)
					{	Ticket=SendOrder(Symbol(),OP_BUYSTOP,OrderLot,Entry,0,Magic,CLR_NONE);
						if(Ticket>0)
						{	if(Debug)Print("Indicator Entry - ("+IndicatorUsed+") BuyStop MC = "+Trend);
							CpBS++;
						}
					}
				}
				if(CpBL==0&&CpSS==0&&((Trend!=2||MAEntry==0)||(Trend==2&&MAEntry==2)))
				{	Entry=MathMod(ASK,g2)+EntryOffset;
					if(Entry>StopLevel)
					{	Ticket=SendOrder(Symbol(),OP_BUYLIMIT,OrderLot,-Entry,0,Magic,CLR_NONE);
						if(Ticket>0)
						{	if(Debug)Print("Indicator Entry - ("+IndicatorUsed+") BuyLimit MC = "+Trend);
							CpBL++;
						}
					}
				}
			}
			if(SellMe)
			{	if(CpSL==0&&CpBS==0&&((Trend!=2||MAEntry==0)||(Trend==2&&MAEntry==2)))
				{	Entry=g2-MathMod(BID,g2)+EntryOffset;
					if(Entry>StopLevel)
					{	Ticket=SendOrder(Symbol(),OP_SELLLIMIT,OrderLot,Entry,0,Magic,CLR_NONE);
						if(Ticket>0&&Debug)Print("Indicator Entry - ("+IndicatorUsed+") SellLimit MC = "+Trend);
					}
				}
				if(CpSS==0&&CpBL==0&&((Trend!=2||MAEntry==0)||(Trend==2&&MAEntry==1)))
				{	Entry=MathMod(BID,g2)+EntryOffset;
					if(Entry>StopLevel)
					{	Ticket=SendOrder(Symbol(),OP_SELLSTOP,OrderLot,-Entry,0,Magic,CLR_NONE);
						if(Ticket>0&&Debug)Print("Indicator Entry - ("+IndicatorUsed+") SellStop MC = "+Trend);
					}
				}
			}
		}
		else
		{	if(BuyMe)
			{	Ticket=SendOrder(Symbol(),OP_BUY,OrderLot,0,slip,Magic,Blue);
				if(Ticket>0&&Debug)Print("Indicator Entry - ("+IndicatorUsed+") Buy");
			}
			else if(SellMe)
			{	Ticket=SendOrder(Symbol(),OP_SELL,OrderLot,0,slip,Magic,displayColorLoss);
				if(Ticket>0&&Debug)Print("Indicator Entry - ("+IndicatorUsed+") Sell");
			}
		}
		if(Ticket>0)return(0);
	}
	else if(TimeCurrent()-EntryDelay>OTbL&&CbT+CbC<MaxTrades&&!FirstRun)
	{	if(UseSmartGrid)
		{	if(RSI[1]!=iRSI(NULL,TF[RSI_TF],RSI_Period,RSI_Price,1))
				for(y=0;y<RSI_Period+RSI_MA_Period;y++)RSI[y]=iRSI(NULL,TF[RSI_TF],RSI_Period,RSI_Price,y);
			else RSI[0]=iRSI(NULL,TF[RSI_TF],RSI_Period,RSI_Price,0);
			RSI_MA=iMAOnArray(RSI,0,RSI_MA_Period,0,RSI_MA_Method,0);
		}
		if(CbB>0)
		{	if(OPbL>ASK)Entry=OPbL-(MathRound((OPbL-ASK)/g2)+1)*g2;
			else Entry=OPbL-g2;
			double OPbN;
			if(UseSmartGrid)
			{	if(ASK<OPbL-g2)
				{	if(RSI[0]>RSI_MA)
					{	Ticket=SendOrder(Symbol(),OP_BUY,OrderLot,0,slip,Magic,Blue);
						if(Ticket>0&&Debug)Print("SmartGrid Buy RSI: "+RSI[0]+" > MA: "+RSI_MA);
					}
					OPbN=0;
				}
				else OPbN=OPbL-g2;
			}
			else if(CpBL==0)
			{	if(ASK-Entry<=StopLevel)Entry=OPbL-(MathFloor((OPbL-ASK+StopLevel)/g2)+1)*g2;
				Ticket=SendOrder(Symbol(),OP_BUYLIMIT,OrderLot,Entry-ASK,0,Magic,SkyBlue);
				if(Ticket>0&&Debug)Print("BuyLimit grid");
			}
			else if(CpBL==1&&Entry-OPpBL>g2/2&&ASK-Entry>StopLevel)
			{	for(y=OrdersTotal();y>=0;y--)
				{	if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
					if(OrderMagicNumber()!=Magic||OrderSymbol()!=Symbol()||OrderType()!=OP_BUYLIMIT)continue;
					Success=ModifyOrder(Entry,0,SkyBlue);
					if(Success&&Debug)Print("Mod BuyLimit Entry");
				}
			}
		}
		else if(CbS>0)
		{	if(BID>OPbL)Entry=OPbL+(MathRound((-OPbL+BID)/g2)+1)*g2;
			else Entry=OPbL+g2;
			if(UseSmartGrid)
			{	if(BID>OPbL+g2)
				{	if(RSI[0]<RSI_MA)
					{	Ticket=SendOrder(Symbol(),OP_SELL,OrderLot,0,slip,Magic,displayColorLoss);
						if(Ticket>0&&Debug)Print("SmartGrid Sell RSI: "+RSI[0]+" < MA: "+RSI_MA);
					}
					OPbN=0;
				}
				else OPbN=OPbL+g2;
			}
			else if(CpSL==0)
			{	if(Entry-BID<=StopLevel)Entry=OPbL+(MathFloor((-OPbL+BID+StopLevel)/g2)+1)*g2;
				Ticket=SendOrder(Symbol(),OP_SELLLIMIT,OrderLot,Entry-BID,0,Magic,Coral);
				if(Ticket>0&&Debug)Print("SellLimit grid");
			}
			else if(CpSL==1&&OPpSL-Entry>g2/2&&Entry-BID>StopLevel)
			{	for(y=OrdersTotal()-1;y>=0;y--)
				{	if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
					if(OrderMagicNumber()!=Magic||OrderSymbol()!=Symbol()||OrderType()!=OP_SELLLIMIT)continue;
					Success=ModifyOrder(Entry,0,Coral);
					if(Success&&Debug)Print("Mod SellLimit Entry");
				}
			}
		}
		if(Ticket>0)return(0);
	}

	//+-----------------------------------------------------------------+
	//| Hedge Trades Set-Up and Monitoring                              |
	//+-----------------------------------------------------------------+
	if((UseHedge&&CbT>0)||ChT>0)
	{	int hLevel=CbT+CbC;
		if(HedgeTypeDD)
		{	if(hDDStart==0&&ChT>0)hDDStart=MathMax(HedgeStart,DrawDownPC+hReEntryPC);
			if(hDDStart>HedgeStart&&hDDStart>DrawDownPC+hReEntryPC)hDDStart=DrawDownPC+hReEntryPC;
			if(hActive==2)
			{	hActive=0;
				hDDStart=MathMax(HedgeStart,DrawDownPC+hReEntryPC);
			}
		}
		if(hActive==0)
		{	if(!hThisChart&&((hPosCorr&&CheckCorr()<0.9)||(!hPosCorr&&CheckCorr()>-0.9)))
			{	if(ObjectFind("B3LhCor")==-1)
					CreateLabel("B3LhCor","The correlation with the hedge pair has dropped below 90%.",0,0,190,10,displayColorLoss);
			}
			else ObjDel("B3LhCor");
			if(hLvlStart>hLevel+1||(!HedgeTypeDD&&hLvlStart==0))hLvlStart=MathMax(HedgeStart,hLevel+1);
			if((HedgeTypeDD&&DrawDownPC>hDDStart)||(!HedgeTypeDD&&hLevel>=hLvlStart))
			{	OrderLot=LotSize(LbT*hLotMult);
				if((CbB>0&&!hPosCorr)||(CbS>0&&hPosCorr))
				{	Ticket=SendOrder(HedgeSymbol,OP_BUY,OrderLot,0,slip,hMagic,MidnightBlue);
					if(Ticket>0)
					{	if(hMaxLossPips>0)SLh=hAsk-hMaxLossPips;
						if(Debug)Print("Hedge Buy : Stoploss @ "+DTS(SLh,Digits));
					}
				}
				if((CbB>0&&hPosCorr)||(CbS>0&&!hPosCorr))
				{	Ticket=SendOrder(HedgeSymbol,OP_SELL,OrderLot,0,slip,hMagic,Maroon);
					if(Ticket>0)
					{	if(hMaxLossPips>0)SLh=hBid+hMaxLossPips;
						if(Debug)Print("Hedge Sell : Stoploss @ "+DTS(SLh,Digits));
					}
				}
				if(Ticket>0)
				{	hActive=1;
					if(HedgeTypeDD)hDDStart+=hReEntryPC;
					hLvlStart=hLevel+1;
					return(0);
				}
			}
		}
		else if(hActive==1)
		{	if(HedgeTypeDD&&hDDStart>HedgeStart&&hDDStart<DrawDownPC+hReEntryPC)hDDStart=DrawDownPC+hReEntryPC;
			if(hLvlStart==0)
			{	if(HedgeTypeDD)hLvlStart=hLevel+1;
				else hLvlStart=MathMax(HedgeStart,hLevel+1);
			}
			if(hLevel>=hLvlStart)
			{	OrderLot=LotSize(Lots[CbT+CbC-1]*LotMult*hLotMult);
				if(OrderLot>0&&((CbB>0&&!hPosCorr)||(CbS>0&&hPosCorr)))
				{	Ticket=SendOrder(HedgeSymbol,OP_BUY,OrderLot,0,slip,hMagic,MidnightBlue);
					if(Ticket>0&&Debug)Print("Hedge Buy");
				}
				if(OrderLot>0&&((CbB>0&&hPosCorr)||(CbS>0&&!hPosCorr)))
				{	Ticket=SendOrder(HedgeSymbol,OP_SELL,OrderLot,0,slip,hMagic,Maroon);
					if(Ticket>0&&Debug)Print("Hedge Sell");
				}
				if(Ticket>0)
				{	hLvlStart=hLevel+1;
					return(0);
				}
			}
			y=0;
			if(!FirstRun&&hMaxLossPips>0)
			{	if(ChB>0)
				{	if(hFixedSL)
					{	if(SLh==0)SLh=hBid-hMaxLossPips;
					}
					else
					{	if(SLh==0||(SLh<BEh&&SLh<hBid-hMaxLossPips))SLh=hBid-hMaxLossPips;
						else if(StopTrailAtBE&&hBid-hMaxLossPips>=BEh)SLh=BEh;
						else if(SLh>=BEh&&!StopTrailAtBE)
						{	if(!ReduceTrailStop)SLh=MathMax(SLh,hBid-hMaxLossPips);
							else SLh=MathMax(SLh,hBid-MathMax(StopLevel,hMaxLossPips*(1-(hBid-hMaxLossPips-BEh)/(hMaxLossPips*2))));
						}
					}
					if(hBid<=SLh)y=ExitTrades(H,DarkViolet,"Hedge Stop Loss");
				}
				else if(ChS>0)
				{	if(hFixedSL)
					{	if(SLh==0)SLh=hAsk+hMaxLossPips;
					}
					else
					{	if(SLh==0||(SLh>BEh&&SLh>hAsk+hMaxLossPips))SLh=hAsk+hMaxLossPips;
						else if(StopTrailAtBE&&hAsk+hMaxLossPips<=BEh)SLh=BEh;
						else if(SLh<=BEh&&!StopTrailAtBE)
						{	if(!ReduceTrailStop)SLh=MathMin(SLh,hAsk+hMaxLossPips);
							else SLh=MathMin(SLh,hAsk+MathMax(StopLevel,hMaxLossPips*(1-(BEh-hAsk-hMaxLossPips)/(hMaxLossPips*2))));
						}
					}
					if(hAsk>=SLh)y=ExitTrades(H,DarkViolet,"Hedge Stop Loss");
				}
			}
			if(y==0&&hTakeProfit>0)
			{	if(ChB>0&&hBid>OPhO+hTakeProfit)y=ExitTrades(T,DarkViolet,"Hedge Take Profit reached",ThO);
				if(ChS>0&&hAsk<OPhO-hTakeProfit)y=ExitTrades(T,DarkViolet,"Hedge Take Profit reached",ThO);
			}
			if(y>0)
			{	PhC=FindClosedPL(H);
				if(y==ChT)
				{	if(HedgeTypeDD)hActive=2;
					else hActive=0;
				}
				return(0);
			}
		}
	}

	//+-----------------------------------------------------------------+
	//| Check DD% and send Email                                        |
	//+-----------------------------------------------------------------+
	if((UseEmail||PlaySounds)&&!Testing)
	{	if(EmailCount<2&&Email[EmailCount]>0&&DrawDownPC>Email[EmailCount])
		{	GetLastError();
			if(UseEmail)
			{	SendMail("Blessing EA","Blessing has exceeded a drawdown of "+Email[EmailCount]*100+"% on "+Symbol()+" "+sTF);
				Error=GetLastError();
				if(Error>0)Print("Email DD: "+DTS(DrawDownPC*100,2)+" Error: "+Error+" "+ErrorDescription(Error));
				else if(Debug)Print("DrawDown Email sent on "+Symbol()+" "+sTF+ " DD: "+DTS(DrawDownPC*100,2));
				EmailSent=TimeCurrent();
				EmailCount++;
			}
			if(PlaySounds)PlaySound(AlertSound);
		}
		else if(EmailCount>0&&EmailCount<3&&DrawDownPC<Email[EmailCount]&&TimeCurrent()>EmailSent+EmailHours*3600)EmailCount--;
	}

	//+-----------------------------------------------------------------+
	//| Display Overlay Code                                            |
	//+-----------------------------------------------------------------+
	if((Testing&&Visual)||!Testing)
	{	if(displayOverlay)
		{	color Colour;
			int dDigits;
			ObjSetTxt("B3VTime",TimeToStr(TimeCurrent(),TIME_SECONDS));
			DrawLabel("B3VSTAm",InitialAccountMultiPortion,167,2,displayColorLoss);
			if(UseHolidayShutdown)
			{	ObjSetTxt("B3VHolF",TimeToStr(HolFirst,TIME_DATE));
				ObjSetTxt("B3VHolT",TimeToStr(HolLast,TIME_DATE));
			}
			DrawLabel("B3VPBal",PortionBalance,167);
			if(DrawDownPC>0.4)Colour=displayColorLoss;
			else if(DrawDownPC>0.3)Colour=Orange;
			else if(DrawDownPC>0.2)Colour=Yellow;
			else if(DrawDownPC>0.1)Colour=displayColorProfit;
			else Colour=displayColor;
			DrawLabel("B3VDrDn",DrawDownPC*100,315,2,Colour);
			if(UseHedge&&HedgeTypeDD)ObjSetTxt("B3VhDDm",DTS(hDDStart*100,2));
			else if(UseHedge&&!HedgeTypeDD)
			{	DrawLabel("B3VhLvl",CbT+CbC,318,0);
				ObjSetTxt("B3VhLvT",DTS(hLvlStart,0));
			}
			ObjSetTxt("B3VSLot",DTS(Lot*LotMult,2));
			if(ProfitPot>=0)DrawLabel("B3VPPot",ProfitPot,190);
			else
			{	ObjSetTxt("B3VPPot",DTS(ProfitPot,2),0,displayColorLoss);
				dDigits=Digit[ArrayBsearch(Digit,-ProfitPot,WHOLE_ARRAY,0,MODE_ASCEND),1];
				ObjSet("B3VPPot",186-dDigits*7);
			}
			if(UseEarlyExit&&EEpc<1)
			{	if(ObjectFind("B3SEEPr")==-1)CreateLabel("B3SEEPr","/",0,0,220,12);
				if(ObjectFind("B3VEEPr")==-1)CreateLabel("B3VEEPr","",0,0,229,12);
				ObjSetTxt("B3VEEPr",DTS(PbTarget*PipValue*MathAbs(LbB-LbS),2));
			}
			else
			{	ObjDel("B3SEEPr");
				ObjDel("B3VEEPr");
			}
			if(SLb>0)DrawLabel("B3VPrSL",SLb,190,Digits);
			else if(bSL>0)DrawLabel("B3VPrSL",bSL,190,Digits);
			else if(bTS>0)DrawLabel("B3VPrSL",bTS,190,Digits);
			else DrawLabel("B3VPrSL",0,190,2);
			if(Pb>=0)
			{	DrawLabel("B3VPnPL",Pb,190,2,displayColorProfit);
				ObjSetTxt("B3VPPip",DTS(PbPips,1),0,displayColorProfit);
				ObjSet("B3VPPip",229);
			}
			else
			{	ObjSetTxt("B3VPnPL",DTS(Pb,2),0,displayColorLoss);
				dDigits=Digit[ArrayBsearch(Digit,-Pb,WHOLE_ARRAY,0,MODE_ASCEND),1];
				ObjSet("B3VPnPL",186-dDigits*7);
				ObjSetTxt("B3VPPip",DTS(PbPips,1),0,displayColorLoss);
				ObjSet("B3VPPip",225);
			}
			if(PbMax>=0)DrawLabel("B3VPLMx",PbMax,190,2,displayColorProfit);
			else
			{	ObjSetTxt("B3VPLMx",DTS(PbMax,2),0,displayColorLoss);
				dDigits=Digit[ArrayBsearch(Digit,-PbMax,WHOLE_ARRAY,0,MODE_ASCEND),1];
				ObjSet("B3VPLMx",186-dDigits*7);
			}
			if(PbMin<0)ObjSet("B3VPLMn",225);
			else ObjSet("B3VPLMn",229);
			ObjSetTxt("B3VPLMn",DTS(PbMin,2),0,displayColorLoss);
			if(CbT+CbC<BreakEvenTrade&&CbT+CbC<MaxTrades)Colour=displayColor;
			else if(CbT+CbC<MaxTrades)Colour=Orange;
			else Colour=displayColorLoss;
			if(CbB>0)
			{	ObjSetTxt("B3LType","Buy:");
				DrawLabel("B3VOpen",CbB,207,0,Colour);
			}
			else if(CbS>0)
			{	ObjSetTxt("B3LType","Sell:");
				DrawLabel("B3VOpen",CbS,207,0,Colour);
			}
			else
			{	ObjSetTxt("B3LType","");
				ObjSetTxt("B3VOpen",DTS(0,0),0,Colour);
				ObjSet("B3VOpen",207);
			}
			ObjSetTxt("B3VLots",DTS(LbT,2));
			ObjSetTxt("B3VMove",DTS(Moves,0));
			DrawLabel("B3VMxDD",MaxDD,107);
			DrawLabel("B3VDDPC",MaxDDPer,229);
			if(Trend==0)
			{	ObjSetTxt("B3LTrnd","Trend is UP",10,displayColorProfit);
				if(ObjectFind("B3ATrnd")==-1)CreateLabel("B3ATrnd","",0,0,160,20,displayColorProfit,"Wingdings");
				ObjectSetText("B3ATrnd","?",displayFontSize+9,"Wingdings",displayColorProfit);
				ObjSet("B3ATrnd",160);
				ObjectSet("B3ATrnd",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
				if(StringLen(ATrend)>0)
				{	if(ObjectFind("B3AATrn")==-1)CreateLabel("B3AATrn","",0,0,200,20,displayColorProfit,"Wingdings");
					if(ATrend=="D")
					{	ObjectSetText("B3AATrn","?",displayFontSize+9,"Wingdings",displayColorLoss);
						ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20+5);
					}
					else if(ATrend=="R")
					{	ObjSetTxt("B3AATrn","R",10,Orange);
						ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
					}
				}
				else ObjDel("B3AATrn");
			}
			else if(Trend==1)
			{	ObjSetTxt("B3LTrnd","Trend is DOWN",10,displayColorLoss);
				if(ObjectFind("B3ATrnd")==-1)CreateLabel("B3ATrnd","",0,0,210,20,displayColorLoss,"WingDings");
				ObjectSetText("B3ATrnd","?",displayFontSize+9,"Wingdings",displayColorLoss);
				ObjSet("B3ATrnd",210);
				ObjectSet("B3ATrnd",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20+5);
				if(StringLen(ATrend)>0)
				{	if(ObjectFind("B3AATrn")==-1)CreateLabel("B3AATrn","",0,0,250,20,displayColorProfit,"Wingdings");
					if(ATrend=="U")
					{	ObjectSetText("B3AATrn","?",displayFontSize+9,"Wingdings",displayColorProfit);
						ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
					}
					else if(ATrend=="R")
					{	ObjSetTxt("B3AATrn","R",10,Orange);
						ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
					}
				}
				else ObjDel("B3AATrn");
			}
			else if(Trend==2)
			{	ObjSetTxt("B3LTrnd","Trend is Ranging",10,Orange);
				ObjDel("B3ATrnd");
				if(StringLen(ATrend)>0)
				{	if(ObjectFind("B3AATrn")==-1)CreateLabel("B3AATrn","",0,0,220,20,displayColorProfit,"Wingdings");
					if(ATrend=="U")
					{	ObjectSetText("B3AATrn","?",displayFontSize+9,"Wingdings",displayColorProfit);
						ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20);
					}
					else if(ATrend=="D")
					{	ObjectSetText("B3AATrn","?",displayFontSize+8,"Wingdings",displayColorLoss);
						ObjectSet("B3AATrn",OBJPROP_YDISTANCE,displayYcord+displaySpacing*20+5);
					}
				}
				else ObjDel("B3AATrn");
			}
			if(PaC!=0)
			{	if(ObjectFind("B3LClPL")==-1)CreateLabel("B3LClPL","Closed P/L",0,0,312,11);
				if(ObjectFind("B3VClPL")==-1)CreateLabel("B3VClPL","",0,0,327,12);
				if(PaC>=0)DrawLabel("B3VClPL",PaC,327,2,displayColorProfit);
				else
				{	ObjSetTxt("B3VClPL",DTS(PaC,2),0,displayColorLoss);
					dDigits=Digit[ArrayBsearch(Digit,-PaC,WHOLE_ARRAY,0,MODE_ASCEND),1];
					ObjSet("B3VClPL",323-dDigits*7);
				}
			}
			else
			{	ObjDel("B3LClPL");
				ObjDel("B3VClPL");
			}
			if(hActive==1)
			{	if(ObjectFind("B3LHdge")==-1)CreateLabel("B3LHdge","Hedge",0,0,323,13);
				if(ObjectFind("B3VhPro")==-1)CreateLabel("B3VhPro","",0,0,312,14);
				if(Ph>=0)DrawLabel("B3VhPro",Ph,312,2,displayColorProfit);
				else
				{	ObjSetTxt("B3VhPro",DTS(Ph,2),0,displayColorLoss);
					dDigits=Digit[ArrayBsearch(Digit,-Ph,WHOLE_ARRAY,0,MODE_ASCEND),1];
					ObjSet("B3VhPro",308-dDigits*7);
				}
				if(ObjectFind("B3VhPMx")==-1)CreateLabel("B3VhPMx","",0,0,312,15);
				if(PhMax>=0)DrawLabel("B3VhPMx",PhMax,312,2,displayColorProfit);
				else
				{	ObjSetTxt("B3VhPMx",DTS(PhMax,2),0,displayColorLoss);
					dDigits=Digit[ArrayBsearch(Digit,-PhMax,WHOLE_ARRAY,0,MODE_ASCEND),1];
					ObjSet("B3VhPMx",308-dDigits*7);
				}
				if(ObjectFind("B3ShPro")==-1)CreateLabel("B3ShPro","/",0,0,342,15);
				if(ObjectFind("B3VhPMn")==-1)CreateLabel("B3VhPMn","",0,0,351,15,displayColorLoss);
				if(PhMin<0)ObjSet("B3VhPMn",347);
				else ObjSet("B3VhPMn",351);
				ObjSetTxt("B3VhPMn",DTS(PhMin,2),0,displayColorLoss);
				if(ObjectFind("B3LhTyp")==-1)CreateLabel("B3LhTyp","",0,0,292,16);
				if(ObjectFind("B3VhOpn")==-1)CreateLabel("B3VhOpn","",0,0,329,16);
				if(ChB>0)
				{	ObjSetTxt("B3LhTyp","Buy:");
					DrawLabel("B3VhOpn",ChB,329,0);
				}
				else if(ChS>0)
				{	ObjSetTxt("B3LhTyp","Sell:");
					DrawLabel("B3VhOpn",ChS,329,0);
				}
				else
				{	ObjSetTxt("B3LhTyp","");
					ObjSetTxt("B3VhOpn",DTS(0,0));
					ObjSet("B3VhOpn",329);
				}
				if(ObjectFind("B3ShOpn")==-1)CreateLabel("B3ShOpn","/",0,0,342,16);
				if(ObjectFind("B3VhLot")==-1)CreateLabel("B3VhLot","",0,0,351,16);
				ObjSetTxt("B3VhLot",DTS(LhT,2));
			}
			else
			{	ObjDel("B3LHdge");
				ObjDel("B3VhPro");
				ObjDel("B3VhPMx");
				ObjDel("B3ShPro");
				ObjDel("B3VhPMn");
				ObjDel("B3LhTyp");
				ObjDel("B3VhOpn");
				ObjDel("B3ShOpn");
				ObjDel("B3VhLot");
			}
		}
		if(displayLines)
		{	if(BEb>0)
			{	if(ObjectFind("B3LBELn")==-1)CreateLine("B3LBELn",DodgerBlue,1,0);
				ObjectMove("B3LBELn",0,Time[1],BEb);
			}
			else ObjDel("B3LBELn");
			if(TPa>0)
			{	if(ObjectFind("B3LTPLn")==-1)CreateLine("B3LTPLn",Gold,1,0);
				ObjectMove("B3LTPLn",0,Time[1],TPa);
			}
			else if(TPb>0&&nLots!=0)
			{	if(ObjectFind("B3LTPLn")==-1)CreateLine("B3LTPLn",Gold,1,0);
				ObjectMove("B3LTPLn",0,Time[1],TPb);
			}
			else ObjDel("B3LTPLn");
			if(OPbN>0)
			{	if(ObjectFind("B3LOPLn")==-1)CreateLine("B3LOPLn",Red,1,4);
				ObjectMove("B3LOPLn",0,Time[1],OPbN);
			}
			else ObjDel("B3LOPLn");
			if(bSL>0)
			{	if(ObjectFind("B3LSLbT")==-1)CreateLine("B3LSLbT",Red,1,3);
				ObjectMove("B3LSLbT",0,Time[1],bSL);
			}
			else ObjDel("B3LSLbT");
			if(bTS>0)
			{	if(ObjectFind("B3LTSbT")==-1)CreateLine("B3LTSbT",Gold,1,3);
				ObjectMove("B3LTSbT",0,Time[1],bTS);
			}
			else ObjDel("B3LTSbT");
			if(hActive==1&&BEa>0)
			{	if(ObjectFind("B3LNBEL")==-1)CreateLine("B3LNBEL",Crimson,1,0);
				ObjectMove("B3LNBEL",0,Time[1],BEa);
			}
			else ObjDel("B3LNBEL");
			if(TPbMP>0)
			{	if(ObjectFind("B3LMPLn")==-1)CreateLine("B3LMPLn",Gold,1,4);
				ObjectMove("B3LMPLn",0,Time[1],TPbMP);
			}
			else ObjDel("B3LMPLn");
			if(SLb>0)
			{	if(ObjectFind("B3LTSLn")==-1)CreateLine("B3LTSLn",Gold,1,2);
				ObjectMove("B3LTSLn",0,Time[1],SLb);
			}
			else ObjDel("B3LTSLn");
			if(hThisChart&&BEh>0)
			{	if(ObjectFind("B3LhBEL")==-1)CreateLine("B3LhBEL",SlateBlue,1,0);
				ObjectMove("B3LhBEL",0,Time[1],BEh);
			}
			else ObjDel("B3LhBEL");
			if(hThisChart&&SLh>0)
			{	if(ObjectFind("B3LhSLL")==-1)CreateLine("B3LhSLL",SlateBlue,1,3);
				ObjectMove("B3LhSLL",0,Time[1],SLh);
			}
			else ObjDel("B3LhSLL");
		}
		else
		{	ObjDel("B3LBELn");
			ObjDel("B3LTPLn");
			ObjDel("B3LOPLn");
			ObjDel("B3LSLbT");
			ObjDel("B3LTSbT");
			ObjDel("B3LNBEL");
			ObjDel("B3LMPLn");
			ObjDel("B3LTSLn");
			ObjDel("B3LhBEL");
			ObjDel("B3LhSLL");
		}
		if(CCIEntry&&displayCCI)
		{	if(cci_01>0&&cci_11>0)ObjectSetText("B3VCm05","?",displayFontSize+6,"Wingdings",displayColorProfit);
			else if(cci_01<0&&cci_11<0)ObjectSetText("B3VCm05","?",displayFontSize+6,"Wingdings",displayColorLoss);
			else ObjectSetText("B3VCm05","?",displayFontSize+6,"Wingdings",Orange);
			if(cci_02>0&&cci_12>0)ObjectSetText("B3VCm15","?",displayFontSize+6,"Wingdings",displayColorProfit);
			else if(cci_02<0&&cci_12<0)ObjectSetText("B3VCm15","?",displayFontSize+6,"Wingdings",displayColorLoss);
			else ObjectSetText("B3VCm15","?",displayFontSize+6,"Wingdings",Orange);
			if(cci_03>0&&cci_13>0)ObjectSetText("B3VCm30","?",displayFontSize+6,"Wingdings",displayColorProfit);
			else if(cci_03<0&&cci_13<0)ObjectSetText("B3VCm30","?",displayFontSize+6,"Wingdings",displayColorLoss);
			else ObjectSetText("B3VCm30","?",displayFontSize+6,"Wingdings",Orange);
			if(cci_04>0&&cci_14>0)ObjectSetText("B3VCm60","?",displayFontSize+6,"Wingdings",displayColorProfit);
			else if(cci_04<0&&cci_14<0)ObjectSetText("B3VCm60","?",displayFontSize+6,"Wingdings",displayColorLoss);
			else ObjectSetText("B3VCm60","?",displayFontSize+6,"Wingdings",Orange);
		}
		if(Debug)
		{	string dSpace;
			for(y=0;y<=175;y++)dSpace=dSpace+" ";
			string dMess="\n\n"+dSpace+"Ticket   Magic     Type Lots OpenPrice  Costs  Profit  Potential";
			for(y=0;y<OrdersTotal();y++)
			{	if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
				if(OrderMagicNumber()!=Magic&&OrderMagicNumber()!=hMagic)continue;
				dMess=(dMess+"\n"+dSpace+" "+OrderTicket()+"  "+DTS(OrderMagicNumber(),0)+"   "+OrderType());
				dMess=(dMess+"   "+DTS(OrderLots(),LotDecimal)+"  "+DTS(OrderOpenPrice(),Digits));
				dMess=(dMess+"     "+DTS(OrderSwap()+OrderCommission(),2));
				dMess=(dMess+"    "+DTS(OrderProfit()+OrderSwap()+OrderCommission(),2));
				if(OrderMagicNumber()!=Magic)continue;
				if(OrderType()==OP_BUY)dMess=(dMess+"      "+DTS(OrderLots()*(TPb-OrderOpenPrice())*PipVal2+OrderSwap()+OrderCommission(),2));
				if(OrderType()==OP_SELL)dMess=(dMess+"      "+DTS(OrderLots()*(OrderOpenPrice()-TPb)*PipVal2+OrderSwap()+OrderCommission(),2));
			}
			if(!dLabels)
			{	dLabels=true;
				CreateLabel("B3LPipV","Pip Value",0,2,0,0);
				CreateLabel("B3VPipV","",0,2,100,0);
				CreateLabel("B3LDigi","Digits Value",0,2,0,1);
				CreateLabel("B3VDigi","",0,2,100,1);
				ObjSetTxt("B3VDigi",DTS(Digits,0));
				CreateLabel("B3LPoin","Point Value",0,2,0,2);
				CreateLabel("B3VPoin","",0,2,100,2);
				ObjSetTxt("B3VPoin",DTS(Point,Digits));
				CreateLabel("B3LSprd","Spread Value",0,2,0,3);
				CreateLabel("B3VSprd","",0,2,100,3);
				CreateLabel("B3LBid","Bid Value",0,2,0,4);
				CreateLabel("B3VBid","",0,2,100,4);
				CreateLabel("B3LAsk","Ask Value",0,2,0,5);
				CreateLabel("B3VAsk","",0,2,100,5);
				CreateLabel("B3LLotP","Lot Step",0,2,200,0);
				CreateLabel("B3VLotP","",0,2,300,0);
				ObjSetTxt("B3VLotP",DTS(MarketInfo(Symbol(),MODE_LOTSTEP),LotDecimal));
				CreateLabel("B3LLotX","Lot Max",0,2,200,1);
				CreateLabel("B3VLotX","",0,2,300,1);
				ObjSetTxt("B3VLotX",DTS(MarketInfo(Symbol(),MODE_MAXLOT),0));
				CreateLabel("B3LLotN","Lot Min",0,2,200,2);
				CreateLabel("B3VLotN","",0,2,300,2);
				ObjSetTxt("B3VLotN",DTS(MarketInfo(Symbol(),MODE_MINLOT),LotDecimal));
				CreateLabel("B3LLotD","Lot Decimal",0,2,200,3);
				CreateLabel("B3VLotD","",0,2,300,3);
				ObjSetTxt("B3VLotD",DTS(LotDecimal,0));
				CreateLabel("B3LAccT","Account Type",0,2,200,4);
				CreateLabel("B3VAccT","",0,2,300,4);
				ObjSetTxt("B3VAccT",DTS(AccountType,0));
				CreateLabel("B3LPnts","Pip",0,2,200,5);
				CreateLabel("B3VPnts","",0,2,300,5);
				ObjSetTxt("B3VPnts",DTS(Pip,Digits));
				CreateLabel("B3LTicV","Tick Value",0,2,400,0);
				CreateLabel("B3VTicV","",0,2,500,0);
				CreateLabel("B3LTicS","Tick Size",0,2,400,1);
				CreateLabel("B3VTicS","",0,2,500,1);
				ObjSetTxt("B3VTicS",DTS(MarketInfo(Symbol(),MODE_TICKSIZE),Digits));
				CreateLabel("B3LLev","Leverage",0,2,400,2);
				CreateLabel("B3VLev","",0,2,500,2);
				ObjSetTxt("B3VLev",DTS(AccountLeverage(),0)+":1");
				CreateLabel("B3LSGTF","SmartGrid",0,2,400,3);
				if(UseSmartGrid)CreateLabel("B3VSGTF","True",0,2,500,3);
				else CreateLabel("B3VSGTF","False",0,2,500,3);
				CreateLabel("B3LCOTF","Close Oldest",0,2,400,4);
				if(UseCloseOldest)CreateLabel("B3VCOTF","True",0,2,500,4);
				else CreateLabel("B3VCOTF","False",0,2,500,4);
				CreateLabel("B3LUHTF","Hedge",0,2,400,5);
				if(UseHedge&&HedgeTypeDD)CreateLabel("B3VUHTF","DrawDown",0,2,500,5);
				else if(UseHedge&&!HedgeTypeDD)CreateLabel("B3VUHTF","Level",0,2,500,5);
				else CreateLabel("B3VUHTF","False",0,2,500,5);
			}
			ObjSetTxt("B3VPipV",DTS(PipValue,2));
			ObjSetTxt("B3VSprd",DTS(ASK-BID,Digits));
			ObjSetTxt("B3VBid",DTS(BID,Digits));
			ObjSetTxt("B3VAsk",DTS(ASK,Digits));
			ObjSetTxt("B3VTicV",DTS(MarketInfo(Symbol(),MODE_TICKVALUE),Digits));
		}
		if(EmergencyWarning)
		{	if(ObjectFind("B3LClos")==-1)CreateLabel("B3LClos","",5,0,0,23,displayColorLoss);
			ObjSetTxt("B3LClos","WARNING: EmergencyCloseAll is set to TRUE",5,displayColorLoss);
		}
		else if(ShutDown)
		{	if(ObjectFind("B3LClos")==-1)CreateLabel("B3LClos","",5,0,0,23,displayColorLoss);
			ObjSetTxt("B3LClos","Blessing will stop trading when this basket closes.",5,displayColorLoss);
		}
		else if(HolShutDown!=1)ObjDel("B3LClos");
	}
	WindowRedraw();
	FirstRun=false;
	Comment(CS,dMess);
	return(0);
}

//+-----------------------------------------------------------------+
//| Check Lot Size Funtion                                          |
//+-----------------------------------------------------------------+
double LotSize(double NewLot)
{	NewLot=ND(NewLot,LotDecimal);
	NewLot=MathMin(NewLot,MarketInfo(Symbol(),MODE_MAXLOT));
	NewLot=MathMax(NewLot,MinLotSize);
	return(NewLot);
}

//+-----------------------------------------------------------------+
//| Open Order Funtion                                              |
//+-----------------------------------------------------------------+
int SendOrder(string OSymbol,int OCmd,double OLot,double OPrice,double OSlip,int OMagic,color OColor=CLR_NONE)
{	if(FirstRun)return(-1);
	int Ticket;
	int retryTimes=5,i=0;
	int OType=MathMod(OCmd,2);
	double OrderPrice;
	if(AccountFreeMarginCheck(OSymbol,OType,OLot)<=0)return(-1);
	if(MaxSpread>0&&MarketInfo(OSymbol,MODE_SPREAD)*Point/Pip>MaxSpread)return(-1);
	while(i<5)
	{	i+=1;
		while(IsTradeContextBusy())Sleep(100);
		if(IsStopped())return(-1);
		if(OType==0)OrderPrice=ND(MarketInfo(OSymbol,MODE_ASK)+OPrice,MarketInfo(OSymbol,MODE_DIGITS));
		else OrderPrice=ND(MarketInfo(OSymbol,MODE_BID)+OPrice,MarketInfo(OSymbol,MODE_DIGITS));
		Ticket=OrderSend(OSymbol,OCmd,OLot,OrderPrice,OSlip,0,0,TradeComment,OMagic,0,OColor);
		if(Ticket<0)
		{	Error=GetLastError();
			if(Error!=0)Print("Error opening order: "+Error+" "+ErrorDescription(Error)
				+" Symbol: "+OSymbol
				+" TradeOP: "+OCmd
				+" OType: "+OType
				+" Ask: "+DTS(MarketInfo(OSymbol,MODE_ASK),Digits)
				+" Bid: "+DTS(MarketInfo(OSymbol,MODE_BID),Digits)
				+" OPrice: "+DTS(OPrice,Digits)
				+" Price: "+DTS(OrderPrice,Digits)
				+" Lots: "+DTS(OLot,2)
				);
			switch(Error)
			{	case ERR_TRADE_DISABLED:
					AllowTrading=false;
					Print("Your broker has not allowed EAs on this account");
					i=retryTimes;
					break;
				case ERR_OFF_QUOTES:
				case ERR_INVALID_PRICE:
					Sleep(5000);
				case ERR_PRICE_CHANGED:
				case ERR_REQUOTE:
					RefreshRates();
				case ERR_SERVER_BUSY:
				case ERR_NO_CONNECTION:
				case ERR_BROKER_BUSY:
				case ERR_TRADE_CONTEXT_BUSY:
					i++;
					break;
				case 149://ERR_TRADE_HEDGE_PROHIBITED:
					UseHedge=false;
					if(Debug)Print("Hedge trades are not allowed on this pair");
					i=retryTimes;
					break;
				default:
					i=retryTimes;
			}
		}
		else
		{	if(PlaySounds)PlaySound(AlertSound);
			break;
		}
	}
	return(Ticket);
}

//+-----------------------------------------------------------------+
//| Modify Order Function                                           |
//+-----------------------------------------------------------------+
bool ModifyOrder(double OrderOP,double OrderSL,color Color=CLR_NONE)
{	bool Success=false;
	int retryTimes=5,i=0;
	while(i<5&&!Success)
	{	i++;
		while(IsTradeContextBusy())Sleep(100);
		if(IsStopped())return(-1);
		Success=OrderModify(OrderTicket(),OrderOP,OrderSL,0,0,Color);
		if(!Success)
		{	Error=GetLastError();
			if(Error>1)
			{	Print(" Error Modifying Order:",OrderTicket(),", ",Error," :" +ErrorDescription(Error),", Ask:",Ask,
					", Bid:",Bid," OrderPrice: ",OrderOP," StopLevel: ",StopLevel,", SL: ",OrderSL,", OSL: ",OrderStopLoss());
				switch(Error)
				{	case ERR_TRADE_MODIFY_DENIED:
						Sleep(10000);
					case ERR_OFF_QUOTES:
					case ERR_INVALID_PRICE:
						Sleep(5000);
					case ERR_PRICE_CHANGED:
					case ERR_REQUOTE:
						RefreshRates();
					case ERR_SERVER_BUSY:
					case ERR_NO_CONNECTION:
					case ERR_BROKER_BUSY:
					case ERR_TRADE_CONTEXT_BUSY:
					case ERR_TRADE_TIMEOUT:
						i+=1;
						break;
					default:
						i=retryTimes;
						break;
				}
			}
			else Success=true;
		}
		else break;
	}
	return(Success);
}

//+-------------------------------------------------------------------------+
//| Exit Trade Function - Type: All Basket Hedge Ticket Pending             |
//+-------------------------------------------------------------------------+
int ExitTrades(int Type,color Color,string Reason,int OTicket=0)
{	
	static int OTicketNo;
	bool Success;
	int Tries,Closed,CloseCount;
	int CloseTrades[,2];
	double OPrice;
	string s;
	ca=Type;
	if(Type==T)
	{	
		if(OTicket==0)
		{
			OTicket=OTicketNo;
		}
		else 
		{
			OTicketNo=OTicket;
		}
	}
	for(y=OrdersTotal()-1;y>=0;y--)
	{	if(!OrderSelect(y,SELECT_BY_POS,MODE_TRADES))continue;
		if(Type==B&&OrderMagicNumber()!=Magic)continue;
		else if(Type==H&&OrderMagicNumber()!=hMagic)continue;
		else if(Type==A&&OrderMagicNumber()!=Magic&&OrderMagicNumber()!=hMagic)continue;
		else if(Type==T&&OrderTicket()!=OTicket)continue;
		else if(Type==P&&(OrderMagicNumber()!=Magic||OrderType()<=OP_SELL))continue;
		ArrayResize(CloseTrades,CloseCount+1);
		CloseTrades[CloseCount,0]=OrderOpenTime();
		CloseTrades[CloseCount,1]=OrderTicket();
		CloseCount++;
	}
	if(CloseCount>0)
	{	if(!UseFIFO)ArraySort(CloseTrades,WHOLE_ARRAY,0,MODE_DESCEND);
		else if(CloseCount!=ArraySort(CloseTrades))Print("Error sorting CloseTrades Array");
		for(y=0;y<CloseCount;y++)
		{	if(!OrderSelect(CloseTrades[y,1],SELECT_BY_TICKET))continue;
			while(IsTradeContextBusy())Sleep(100);
			if(IsStopped())return(-1);
			if(OrderType()>OP_SELL)Success=OrderDelete(OrderTicket(),Color);
			else
			{	if(OrderType()==OP_BUY)OPrice=ND(MarketInfo(OrderSymbol(),MODE_BID),MarketInfo(OrderSymbol(),MODE_DIGITS));
				else OPrice=ND(MarketInfo(OrderSymbol(),MODE_ASK),MarketInfo(OrderSymbol(),MODE_DIGITS));
				Success=OrderClose(OrderTicket(),OrderLots(),OPrice,slip,Color);
			}
			if(Success)Closed++;
			else
			{	Error=GetLastError();Print("Order ",OrderTicket()," failed to close. Error:",ErrorDescription(Error));
				switch(Error)
				{	case ERR_NO_ERROR:
					case ERR_NO_RESULT:
						Success=true;
						break;
					case ERR_OFF_QUOTES:
					case ERR_INVALID_PRICE:
						Sleep(5000);
					case ERR_PRICE_CHANGED:
					case ERR_REQUOTE:
						RefreshRates();
					case ERR_SERVER_BUSY:
					case ERR_NO_CONNECTION:
					case ERR_BROKER_BUSY:
					case ERR_TRADE_CONTEXT_BUSY:
						Print("Try: "+(Tries+1)+" of 5: Order ",OrderTicket()," failed to close. Error:",ErrorDescription(Error));
						Tries++;
						break;
					case ERR_TRADE_TIMEOUT:
					default:
						Print("Try: "+(Tries+1)+" of 5: Order ",OrderTicket()," failed to close. Fatal Error:",ErrorDescription(Error));
						Tries=5;
						ca=0;
						break;
				}
			}
		}
		if(Closed==CloseCount||Closed==0)ca=0;
	}
	else ca=0;
	if(Closed>0)
	{	if(Closed!=1)s="s";
		Print("Closed "+Closed+" position"+s+" because ",Reason);
		if(PlaySounds)PlaySound(AlertSound);
	}
	return(Closed);
}

//+-----------------------------------------------------------------+
//| Find Hedge Profit                                               |
//+-----------------------------------------------------------------+
double FindClosedPL(int Type)
{	
	double ClosedProfit;
	if(Type==B&&UseCloseOldest)
		CbC=0;
	if(OTbF>0)
	{	
		for(y=OrdersHistoryTotal()-1;y>=0;y--)
		{	
			if(!OrderSelect(y,SELECT_BY_POS,MODE_HISTORY))
				continue;

			if(OrderOpenTime()<OTbF)
				continue;
			if(Type==B&&OrderMagicNumber()==Magic&&OrderType()<=OP_SELL)
			{	
				ClosedProfit+=OrderProfit()+OrderSwap()+OrderCommission();
				if(UseCloseOldest)
					CbC++;
			}
			if(Type==H&&OrderMagicNumber()==hMagic)
				ClosedProfit+=OrderProfit()+OrderSwap()+OrderCommission();
		}
	}
	return(ClosedProfit);
}

//+-----------------------------------------------------------------+
//| Check Correlation                                               |
//+-----------------------------------------------------------------+
double CheckCorr()
{	double BaseDiff,HedgeDiff,BasePow,HedgePow,Mult;
	for(y=CorrPeriod-1;y>=0;y--)
	{	BaseDiff=iClose(Symbol(),1440,y)-iMA(Symbol(),1440,CorrPeriod,0,MODE_SMA,PRICE_CLOSE,y);
		HedgeDiff=iClose(HedgeSymbol,1440,y)-iMA(HedgeSymbol,1440,CorrPeriod,0,MODE_SMA,PRICE_CLOSE,y);
		Mult+=BaseDiff*HedgeDiff;
		BasePow+=MathPow(BaseDiff,2);
		HedgePow+=MathPow(HedgeDiff,2);
	}
	if(BasePow*HedgePow>0)return(Mult/MathSqrt(BasePow*HedgePow));
	else return(0);
}

//+------------------------------------------------------------------+
//|  Save Equity / Balance Statistics                                |
//+------------------------------------------------------------------+
void Stats(bool NewFile,bool IsTick,double Balance,double DrawDown)
{	
	double Equity=Balance+DrawDown;
	datetime TimeNow=TimeCurrent();
	if(IsTick)
	{	
		if(Equity<StatLowEquity)
		{
			StatLowEquity=Equity;
		}
		if(Equity>StatHighEquity)
		{
			StatHighEquity=Equity;
		}
	}
	else
	{	
		while(TimeNow>=NextStats)
		{	
			NextStats+=StatsPeriod;
		}
		int StatHandle;
		if(NewFile)
		{	
			StatHandle=FileOpen(StatFile,FILE_WRITE|FILE_CSV,',');
			Print("Stats "+StatFile+" "+StatHandle);
			FileWrite(StatHandle,"Date","Time","Balance","Equity Low","Equity High",TradeComment);
		}
		else
		{	
			StatHandle=FileOpen(StatFile,FILE_READ|FILE_WRITE|FILE_CSV,',');
			FileSeek(StatHandle,0,SEEK_END);
		}
		if(StatLowEquity==0)
		{	
			StatLowEquity=Equity;
			StatHighEquity=Equity;
		}
		FileWrite(StatHandle,TimeToStr(TimeNow,TIME_DATE),TimeToStr(TimeNow,TIME_SECONDS),DTS(Balance,0),DTS(StatLowEquity,0),DTS(StatHighEquity,0));
		FileClose(StatHandle);
		StatLowEquity=Equity;
		StatHighEquity=Equity;
	}
}

//+-----------------------------------------------------------------+
//| Magic Number Generator                                          |
//+-----------------------------------------------------------------+
int GenerateMagicNumber()
{	if(EANumber>99)return(EANumber);
	return(JenkinsHash(EANumber+"_"+Symbol()+"__"+Period()));
}

int JenkinsHash(string Input)
{	int MagicNo;
	for(y=0;y<StringLen(Input);y++)
	{	MagicNo+=StringGetChar(Input,y);
		MagicNo+=(MagicNo<<10);
		MagicNo^=(MagicNo>>6);
	}
	MagicNo+=(MagicNo<<3);
	MagicNo^=(MagicNo>>11);
	MagicNo+=(MagicNo<<15);
	MagicNo=MathAbs(MagicNo);
	return(MagicNo);
}

//+-----------------------------------------------------------------+
//| Normalize Double                                                |
//+-----------------------------------------------------------------+
double ND(double Value,int Precision){return(NormalizeDouble(Value,Precision));}

//+-----------------------------------------------------------------+
//| Double To String                                                |
//+-----------------------------------------------------------------+
string DTS(double Value,int Precision){return(DoubleToStr(Value,Precision));}

//+-----------------------------------------------------------------+
//| Create Label Function (OBJ_LABEL ONLY)                          |
//+-----------------------------------------------------------------+
void CreateLabel(string Name,string Text,int FontSize,int Corner,int XOffset,double YLine,color Colour=CLR_NONE,string Font="")
{	int XDistance,YDistance;
	if(Font=="")Font=displayFont;
	FontSize+=displayFontSize;
	YDistance=displayYcord+displaySpacing*YLine;
	if(Corner==0)XDistance=displayXcord+(XOffset*displayFontSize/9*displayRatio);
	else if(Corner==1)XDistance=displayCCIxCord+XOffset*displayRatio;
	else if(Corner==2)XDistance=displayXcord+(XOffset*displayFontSize/9*displayRatio);
	else if(Corner==3)
	{	XDistance=XOffset*displayRatio;
		YDistance=YLine;
	}
	else if(Corner==5)
	{	XDistance=XOffset*displayRatio;
		YDistance=14*YLine;
		Corner=1;
	}
	if(Colour==CLR_NONE)Colour=displayColor;
	ObjectCreate(Name,OBJ_LABEL,0,0,0);
	ObjectSetText(Name,Text,FontSize,Font,Colour);
	ObjectSet(Name,OBJPROP_CORNER,Corner);
	ObjectSet(Name,OBJPROP_XDISTANCE,XDistance);
	ObjectSet(Name,OBJPROP_YDISTANCE,YDistance);
}

//+-----------------------------------------------------------------+
//| Create Line Function (OBJ_HLINE ONLY)                           |
//+-----------------------------------------------------------------+
void CreateLine(string Name,color Colour,int Width,int Style)
{	ObjectCreate(Name,OBJ_HLINE,0,0,0);
	ObjectSet(Name,OBJPROP_COLOR,Colour);
	ObjectSet(Name,OBJPROP_WIDTH,Width);
	ObjectSet(Name,OBJPROP_STYLE,Style);
}

//+------------------------------------------------------------------+
//| Draw Label Function (OBJ_LABEL ONLY)                             |
//+------------------------------------------------------------------+
void DrawLabel(string Name,double Value,int XOffset,int Decimal=2,color Colour=CLR_NONE)
{	int dDigits;
	dDigits=Digit[ArrayBsearch(Digit,Value,WHOLE_ARRAY,0,MODE_ASCEND),1];
	ObjectSet(Name,OBJPROP_XDISTANCE,displayXcord+(XOffset-7*dDigits)*displayFontSize/9*displayRatio);
	ObjSetTxt(Name,DTS(Value,Decimal),0,Colour);
}

//+-----------------------------------------------------------------+
//| Object Set Function                                             |
//+-----------------------------------------------------------------+
void ObjSet(string Name,int XCoord){ObjectSet(Name,OBJPROP_XDISTANCE,displayXcord+XCoord*displayFontSize/9*displayRatio);}

//+-----------------------------------------------------------------+
//| Object Set Text Function                                        |
//+-----------------------------------------------------------------+
void ObjSetTxt(string Name,string Text,int FontSize=0,color Colour=CLR_NONE,string Font="")
{	FontSize+=displayFontSize;
	if(Font=="")Font=displayFont;
	if(Colour==CLR_NONE)Colour=displayColor;
	ObjectSetText(Name,Text,FontSize,Font,Colour);
}

//+------------------------------------------------------------------+
//| Delete Overlay Label Function                                    |
//+------------------------------------------------------------------+
void LabelDelete(){for(y=ObjectsTotal();y>=0;y--){if(StringSubstr(ObjectName(y),0,2)=="B3")ObjectDelete(ObjectName(y));}}

//+------------------------------------------------------------------+
//| Delete Object Function                                           |
//+------------------------------------------------------------------+
void ObjDel(string Name){if(ObjectFind(Name)!=-1)ObjectDelete(Name);}

//+-----------------------------------------------------------------+
//| Create Object List Function                                     |
//+-----------------------------------------------------------------+
void LabelCreate()
{	if(displayOverlay&&((Testing&&Visual)||!Testing))
	{	int dDigits;
		string ObjText;
		color ObjClr;
		CreateLabel("B3LMNum","Magic: ",8-displayFontSize,5,59,1,displayColorFGnd,"Tahoma");
		CreateLabel("B3VMNum",DTS(Magic,0),8-displayFontSize,5,5,1,displayColorFGnd,"Tahoma");
		CreateLabel("B3LComm","Trade Comment: "+TradeComment,8-displayFontSize,5,5,1.8,displayColorFGnd,"Tahoma");
		if(displayLogo)
		{	CreateLabel("B3LLogo","Q",27,3,10,10,Crimson,"Wingdings");
			CreateLabel("B3LCopy","?"+DTS(Year(),0)+", J Talon LLC/FiFtHeLeMeNt",10-displayFontSize,3,5,3,Silver,"Arial");
		}
		CreateLabel("B3LTime","Broker Time is:",0,0,0,0);
		CreateLabel("B3VTime","",0,0,125,0);
		CreateLabel("B3Line1","=========================",0,0,0,1);
		CreateLabel("B3LEPPC","Equity Protection % Set:",0,0,0,2);
		dDigits=Digit[ArrayBsearch(Digit,MaxDDPercent,WHOLE_ARRAY,0,MODE_ASCEND),1];
		CreateLabel("B3VEPPC",DTS(MaxDDPercent,2),0,0,167-7*dDigits,2);
		CreateLabel("B3PEPPC","%",0,0,193,2);
		CreateLabel("B3LSTPC","Stop Trade % Set:",0,0,0,3);
		dDigits=Digit[ArrayBsearch(Digit,StopTradePercent*100,WHOLE_ARRAY,0,MODE_ASCEND),1];
		CreateLabel("B3VSTPC",DTS(StopTradePercent*100,2),0,0,167-7*dDigits,3);
		CreateLabel("B3PSTPC","%",0,0,193,3);
		CreateLabel("B3LSTAm","Stop Trade Amount:",0,0,0,4);
		CreateLabel("B3VSTAm","",0,0,167,4,displayColorLoss);
		CreateLabel("B3LAPPC","Account Portion:",0,0,0,5);
		dDigits=Digit[ArrayBsearch(Digit,PortionPC*100,WHOLE_ARRAY,0,MODE_ASCEND),1];
		CreateLabel("B3VAPPC",DTS(PortionPC*100,2),0,0,167-7*dDigits,5);
		CreateLabel("B3PAPPC","%",0,0,193,5);
		CreateLabel("B3LPBal","Portion Balance:",0,0,0,6);
		CreateLabel("B3VPBal","",0,0,167,6);
		CreateLabel("B3LAPCR","Account % Risked:",0,0,228,6);
		CreateLabel("B3VAPCR",DTS(MaxDDPercent*PortionPC,2),0,0,347,6);
		CreateLabel("B3PAPCR","%",0,0,380,6);
		if(UseMM)
		{	ObjText="Money Management is On";
			ObjClr=displayColorProfit;
		}
		else
		{	ObjText="Money Management is Off";
			ObjClr=displayColorLoss;
		}
		CreateLabel("B3LMMOO",ObjText,0,0,0,7,ObjClr);
		if(UsePowerOutSL)
		{	ObjText="Power Off Stop Loss is On";
			ObjClr=displayColorProfit;
		}
		else
		{	ObjText="Power Off Stop Loss is Off";
			ObjClr=displayColorLoss;
		}
		CreateLabel("B3LPOSL",ObjText,0,0,0,8,ObjClr);
		CreateLabel("B3LDrDn","Draw Down %:",0,0,228,8);
		CreateLabel("B3VDrDn","",0,0,315,8);
		if(UseHedge)
		{	if(HedgeTypeDD)
			{	CreateLabel("B3LhDDn","Hedge",0,0,190,8);
				CreateLabel("B3ShDDn","/",0,0,342,8);
				CreateLabel("B3VhDDm","",0,0,347,8);
			}
			else
			{	CreateLabel("B3LhLvl","Hedge Level:",0,0,228,9);
				CreateLabel("B3VhLvl","",0,0,318,9);
				CreateLabel("B3ShLvl","/",0,0,328,9);
				CreateLabel("B3VhLvT","",0,0,333,9);
			}
		}
		CreateLabel("B3Line2","======================",0,0,0,9);
		CreateLabel("B3LSLot","Starting Lot Size:",0,0,0,10);
		CreateLabel("B3VSLot","",0,0,130,10);
		if(MaximizeProfit)
		{	ObjText="Profit Maximizer is On";
			ObjClr=displayColorProfit;
		}
		else
		{	ObjText="Profit Maximizer is Off";
			ObjClr=displayColorLoss;
		}
		CreateLabel("B3LPrMx",ObjText,0,0,0,11,ObjClr);
		CreateLabel("B3LBask","Basket",0,0,200,11);
		CreateLabel("B3LPPot","Profit Potential:",0,0,30,12);
		CreateLabel("B3VPPot","",0,0,190,12);
		CreateLabel("B3LPrSL","Profit Trailing Stop:",0,0,30,13);
		CreateLabel("B3VPrSL","",0,0,190,13);
		CreateLabel("B3LPnPL","Portion P/L / Pips:",0,0,30,14);
		CreateLabel("B3VPnPL","",0,0,190,14);
		CreateLabel("B3SPnPL","/",0,0,220,14);
		CreateLabel("B3VPPip","",0,0,229,14);
		CreateLabel("B3LPLMM","Profit/Loss Max/Min:",0,0,30,15);
		CreateLabel("B3VPLMx","",0,0,190,15);
		CreateLabel("B3SPLMM","/",0,0,220,15);
		CreateLabel("B3VPLMn","",0,0,225,15);
		CreateLabel("B3LOpen","Open Trades / Lots:",0,0,30,16);
		CreateLabel("B3LType","",0,0,170,16);
		CreateLabel("B3VOpen","",0,0,207,16);
		CreateLabel("B3SOpen","/",0,0,220,16);
		CreateLabel("B3VLots","",0,0,229,16);
		CreateLabel("B3LMvTP","Move TP by:",0,0,0,17);
		CreateLabel("B3VMvTP",DTS(MoveTP/Pip,0),0,0,100,17);
		CreateLabel("B3LMves","# Moves:",0,0,150,17);
		CreateLabel("B3VMove","",0,0,229,17);
		CreateLabel("B3SMves","/",0,0,242,17);
		CreateLabel("B3VMves",DTS(TotalMoves,0),0,0,249,17);
		CreateLabel("B3LMxDD","Max DD:",0,0,0,18);
		CreateLabel("B3VMxDD","",0,0,107,18);
		CreateLabel("B3LDDPC","Max DD %:",0,0,150,18);
		CreateLabel("B3VDDPC","",0,0,229,18);
		CreateLabel("B3PDDPC","%",0,0,257,18);
		if(ForceMarketCond<3)CreateLabel("B3LFMCn","Market trend is forced",0,0,0,19);
		CreateLabel("B3LTrnd","",0,0,0,20);
		if(CCIEntry>0&&displayCCI)
		{	CreateLabel("B3LCCIi","CCI",2,1,12,1);
			CreateLabel("B3LCm05","m5",2,1,25,2.2);
			CreateLabel("B3VCm05","?",6,1,0,2,Orange,"Wingdings");
			CreateLabel("B3LCm15","m15",2,1,25,3.4);
			CreateLabel("B3VCm15","?",6,1,0,3.2,Orange,"Wingdings");
			CreateLabel("B3LCm30","m30",2,1,25,4.6);
			CreateLabel("B3VCm30","?",6,1,0,4.4,Orange,"Wingdings");
			CreateLabel("B3LCm60","h1",2,1,25,5.8);
			CreateLabel("B3VCm60","?",6,1,0,5.6,Orange,"Wingdings");
		}
		if(UseHolidayShutdown)
		{	CreateLabel("B3LHols","Next Holiday Period",0,0,240,2);
			CreateLabel("B3LHolD","From: (yyyy.mm.dd) To:",0,0,232,3);
			CreateLabel("B3VHolF","",0,0,232,4);
			CreateLabel("B3VHolT","",0,0,300,4);
		}
	}
}

//+-----------------------------------------------------------------+
//| expert end function                                             |
//+-----------------------------------------------------------------+

string ErrorDescription(int error){
	return error;

}
//0. I once rewritten an online open source code Blessing to make a transaction. The original Blessing is a one-way strategy of contrarian and I changed to two-way, long-short and simultaneous trading.
//1. First of all, my trading strategy is Martingale's bucking trend, which is a worthless strategy that has been devalued by many big cows.
//2. Both positions are opened simultaneously. According to MA800 to determine the center of gravity, MA800 is allowed to open positions within 200 points.
//3. The position can be continuously profitable.
//4. Converse positions are added according to the rules.
//5. If the negative position loss value reaches a certain percentage of the net value, a lock order is established; the loss is locked.
//6. According to the MA800's judgment of the price center of gravity, when the price returns to the neutral zone, unlock and resume the contrarian trade.
//When unlocking, lock orders tend to make profits. This part of the profit is included in the profit value of the adverse position. When the contrarian position starts to make profits, the position is closed according to the law.
//7. Locking method, I generally lock according to the percentage of the net value of the one-way combination position (for example, all BUY) float value (absolute value).
//And, I also found that once locked is not the best solution, although it is already possible to achieve annual doubling, a better approach is to layer lock.
//8. My current practice is to use locks to lock losses, wait for callbacks, and then unlock to continue trading. The method of unlocking is more complicated.
// To refer to MA (usually SMA800) and CCI, the effect is still very good. It does not mean that the price is unlocked until the price returns to position, but unlocked as soon as the MA returns to the proper position. Lock orders are profitable when unlocked, with the focus being on unlocking the price as soon as it comes back.
//9. As for why I don’t stop loss at the time of loss, this is determined by the characteristics of the system. The grid's counter-trend adding strategy, each position is equivalent to a bullet.
//Always keep, stop loss destroys the balance of the system.
//10. I usually trade only a few varieties, such as Europe, America and Australia. According to my real-time analog disk and back-testing of 10-year historical data, the results are very good.
//Float loss can always be controlled within the preset percentage, and it will not explode, and the profit effect can reach 2-4 times of the year.
// During the period of the lock, it will lose time, but it will not lose profits.
//This strategy may be too simple. The strategy that can often make money is simple and willful.

ho un errore '1' - expression not boolean	Blessing EA.mq4	2981	26
come lo correggo?