SU3D[v5]

//+------------------------------------------------------------------+
//|                                                     Su3D[v4].mq4 |
//|                                      Copyright © 2008, Sgibnev   |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "25.03.2009"

//+------------------------------------------------------------------+
//| ÓÑÒÀÍÎÂÊÀ ÂÐÅÌÅÍÈ ÄÅÉÑÒÂÈß ÝÊÑÏÅÐÒÀ ÄÎ:                          +                                                 |
//+------------------------------------------------------------------+
double Days = 25;
double Months = 03;
double Years = 2009;

//double Account1 =40263; 
//double Account2 =183199671;
//double Account3 =183202028;
 

//---- Âíåøíèå ïåðåìåííûå (äîñòóïíûå â îêíå ñâîéñòâ ýêñïåðòà) - ìîæíî óñòàíîâèòü çíà÷åíèÿ ïî óìîë÷àíèþ
extern string 		Symbols 	         	= "GBPUSDH1, AUDCADH1, EURJPYH1, EURUSDH1, USDJPYH1";
extern int        Charts                     = 1;
extern string 		Rick   	           = "TotalEquityRisk 1-5";
extern double     TotalEquityRisk     =3 ;
extern string 		Trade 	           = "Long&Short=0, Only Long=1, Only Short=-1";
extern int      	TradeDirection		        	= 0;		// Ðàçðåøåííîå íàïðàâëåíèå òîðãîâëè: 0 - Buy & Sell, 1 - Buy Only, -1 - Sell Only

int               Profit                     =1; 
//string 		Properties 	            	= "=========== Properties ===========";
double		LotExponent;	
int			PipStep;	
int			TakeProfit						= 25;		// Íåîáõîäèìàÿ äëÿ çàêðûòèÿ ïîçèöèé ïðèáûëü
int			MaxTrades						= 18;		// Ìàêñèìàëüíîå êîë-âî äîëèâîê
int			StopLoss				      	= 15;		// Ïðè óáûòêå ïîñëåäíåé äîëèâêè ðàçìåðîì LastStopLoss ïóíêòîâ âñÿ ñåðèÿ çàêðûâàåòñÿ

int 			Expert_Id 						= 2009;	// Óíèêàëüíûé èäåíòèôèêàòîð ýêñïåðòà. Åñëè íà 2-õ ãðàôèêàõ ñ îäèíàêîâûì Ñèìâîëîì È ÒàéìÔðåéìîì äîëæíî ðàáîòàòü 2 ýêñïåðòà, íàäî óñòàíîâèòü èì ðàçíûå Expert_Id
//int      	TradeDirection		        	= 0;		// Ðàçðåøåííîå íàïðàâëåíèå òîðãîâëè: 0 - Buy & Sell, 1 - Buy Only, -1 - Sell Only
double      StartLot_b, StartLot_s;	// Ñòàðòîâûé ëîò


double RBCImax = 40,FTLMmax = 10,STLMmax = 100,STLMmin = 20,PCCImax = 20;  //M5 
double FTLM,STLM,PCCI,RBCI,SATL,FATL,RFTL,RSTL;
double aSATL[4],aFATL[4],aRFTL[4],aRSTL[4],aFTLM[4],aSTLM[4],aPCCI[4],aRBCI[4];
double tFATL,tRFTL,tSATL,tRSTL,tFTLM,tRBCI,tSTLM,tPCCI;
double atFATL[2];


bool L1 = True,L2A = True,L2B = True, L3 = True,L4 = True,L5 = True,L6 = True,L7 = True,L8 =True;
bool S1 = True,S2A = True,S2B = True,S3 = True,S4 = True,S5 = True,S6 = True,S7 = True,S8 = True;

   int shift;


//========================================================
string 	Trade_Properties 		= "--------Trade-Properties-------";
int 		Slippage 				= 5;
int 		PauseBeforeTrade		= 5;
int 		MaxWaitingTime			= 300;
color 	OrderBuyColor 			= Lime;
color 	OrderSellColor 		= Red;

 string 	Allow_Flags		 		= "-----------Allow-Flags---------";
 bool		Allow_Info				= false;
 bool		Allow_LogFile			= false;
 bool		Allow_TradeLogFile	= false;
 bool		Allow_ErrorMail		= true;
 bool		Allow_ErrorLogFile	= false;

 string 	Info_Properties 		= "--------Info-Properties--------";
 bool		EnglishInfo				= true;
 int		Font_Size_Variant		= 2; //îò 1 äî 10
 color 	Standart_Color 		= White;
 color 	Warning_Color 			= Magenta;
 color 	Price_Up_Color 		= Lime;
color 	Price_Down_Color 		= Red;

string	strComment, strPeriod, TradeInfoLib_Font = "Arial";
double	TradeInfoLib_FontSize, TradeInfoLib_HeadFontSize;

string	_Symbol, ExpertName;
int		_Period, _MagicNumber, _Digits;
double	_Point, _StopLevel, _Spread;
datetime StartTime;

/////////////////////////////////////////////////////////////////////////////////
string stringServer						= "";
string stringReal							= "";
string stringDemo							= "";
string stringTradeAllow					= "";
string stringTradeNotAllow				= "";
string stringLoaded						= "";

string stringOpenedPosition			= "";
string stringOpenedOrder				= "";
string stringPointBefore				= "";

string stringGlobalStop					= "";
string stringGlobalStop1				= "";
string stringGlobalStop2				= "";
string stringNoBars						= "";

string stringInvalidParameters		= "";///////////////////////////////
string stringInvalidOrderType			= "";//////////////////////////////////////
string stringInvalidVolume				= "";
string stringIncorrectAbove			= "";
string stringIncorrectBelow			= "";
string stringIncorrectTooBeside		= " ";
string stringInvalidExpiration		= " ";
string stringIncorrectExpiration		= "";

string stringSendingOrder				= "";
string stringSendingOrder1				= "";
string stringSendingPosition			= "";
string stringSendingPosition1			= "";

string stringCheck						= "";
string stringCheckError					= "";
string stringCheckOK						= "";

string stringNoConnection				= "";
string stringStopped						= "";
string stringTimeOut						= "";
string stringSuccessfully				= "";
/////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
/**/ void TradeInfoLib_Initialization ( int TradeInfoLib_ExpertId, string TradeInfoLib_ExpertName )
/////////////////////////////////////////////////////////////////////////////////
// Èíèöèàëèçàöèÿ ïåðåìåííûõ, ñîçäàíèå îáúåêòîâ äëÿ âûâîäà èíôîðìàöèè,
// çàïèñü â ëîã èíôîðìàöèè îá èíèöèàëèçàöèè.
// Ãåíåðàöèÿ êîììåíòàðèÿ ê îðäåðàì ( êîòîðûå áóäóò îòêðûòû ñ ïîìîùüþ ô-öèè _OrderSend )
//
// Íåîáõîäèìî âûçâàòü ô-öèþ èç init() ýêñïåðòà
/////////////////////////////////////////////////////////////////////////////////
{

		/////////////////////////////////////////////////////////////////////////////////
		if ( EnglishInfo )
		{
				stringServer						= "Server ";
				stringReal							= "REAL ACCOUNT #";
				stringDemo							= "Demo account #";
				stringTradeAllow					= "TRADE IS ALLOWED!";
				stringTradeNotAllow				= "Trade is not allowed";
				stringLoaded						= "Expert loaded successfully...";

				stringOpenedPosition				= " - position opened by this expert:";
				stringOpenedOrder					= " - order opened by this expert:";
				stringPointBefore					= "Ïóíêòîâ äî ñðàáàòûâàíèÿ - ";///////////////////////////////

				stringGlobalStop					= "Expert was stopped!";
				stringGlobalStop1					= "Global variable";
				stringGlobalStop2					= "must be >= 0!";
				stringNoBars						= "Ñëèøêîì ìàëî áàðîâ íà ãðàôèêå!";///////////////////////////

				stringInvalidParameters			= "Invalid trade parameters";
				stringInvalidOrderType			= "Invalid OrderType";
				stringInvalidVolume				= " - invalid volume!!!";
				stringIncorrectAbove				= " - Incorrect (above";
				stringIncorrectBelow				= " - Incorrect (below";
				stringIncorrectTooBeside		= " - Incorrect (too beside to";
				stringInvalidExpiration			= " - Äëÿ ìàðêåò-îðäåðà íåëüçÿ óñòàíîâèòü âðåìÿ èñòå÷åíèÿ!!!";//////
				stringIncorrectExpiration		= " - Âðåìÿ èñòå÷åíèÿ íåëüçÿ óñòàíîâèòü â ïðîøëîì!!!";/////////////

				stringSendingOrder				= "Sending ";
				stringSendingOrder1				= "-order...";
				stringSendingPosition			= "Sending ";
				stringSendingPosition1			= " position...";

				stringCheck							= "Checking.....";
				stringCheckError					= "Checking.....Error!";
				stringCheckOK						= "Checking.....OK...";

				stringNoConnection				= "No connection with trade server";
				stringStopped						= "Expert was stopped by user";
				stringTimeOut						= "Limit of waiting time";
				stringSuccessfully				= "Successfully...";
		}
		/////////////////////////////////////////////////////////////////////////////////
//		if (false) { _MagicNumber(1,"",1); _OrderSend("",1,1.1,1.1,1,1.1,1.1); _OrderModify(1,1.1,1.1,1.1,0); _OrderClose(1,1.1,1.1,1); _OrderDelete(1); _Reverse(1); _TrailingStop(1,1); intPeriod(1); }
	int _GetLastError;

//---- ïðè òåñòèðîâàíèè âñå "êðàñèâîñòè" âûêëþ÷àåì
	if ( IsTesting() )
	{
		if ( !IsVisualMode() ) Allow_Info = false;
		Allow_LogFile			= false;
		Allow_TradeLogFile	= false;
		Allow_ErrorMail		= false;
		Allow_ErrorLogFile	= false;
	}

//---- Èíèöèàëèçèðóåì ãëîáàëüíûå ïåðåìåííûå áèáëèîòåêè (îáúÿâëåííûå âíå ô-öèé)
	StartTime	= 0;
	_Symbol		= Symbol();
	_Period		= Period();
	_Digits		= MarketInfo( _Symbol, MODE_DIGITS );
	_Point		= MarketInfo( _Symbol, MODE_POINT );
	_StopLevel	= NormalizeDouble ( ( MarketInfo( _Symbol, MODE_STOPLEVEL ) + 1 ) * _Point, _Digits );
	_Spread		= NormalizeDouble ( MarketInfo ( _Symbol, MODE_SPREAD ) * _Point, _Digits );
	strPeriod	= strPeriod( _Period );
	_MagicNumber= _MagicNumber( TradeInfoLib_ExpertId, _Period );


	if ( TradeInfoLib_ExpertName == "" )
		ExpertName = WindowExpertName();
	else
		ExpertName = TradeInfoLib_ExpertName;

	strComment	= ExpertName + " (" + _Symbol + ", " + strPeriod + ")";
//---- Ñîçäà¸ì ýêñïåðòó ëè÷íóþ ãëîáàëüíóþ ïåðåìåííóþ
	while ( !IsStopped() )
	{
		if ( GlobalVariableSet( strComment + "-return!", 0.0 ) > 0 ) { break; }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{ Print( TradeInfoLib_ExpertId, ", ", TradeInfoLib_ExpertName, " ) - GlobalVariableSet ( \"", strComment, "-return!\", 0.0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" ); }

		Sleep(100);
	}
	
//---- Óñòàíàâëèâàåì ãëîáàëüíóþ ïåðåìåííóþ TradeIsBusy â 0
	TradeIsNotBusy();

//---- Ñîçäà¸ì îáúåêòû äëÿ âûâîäà èíôîðìàöèè
	int v_shag = 16;
	int h_shag = 350;
	switch ( Font_Size_Variant )
	{
		case 1:	TradeInfoLib_FontSize = 5;		TradeInfoLib_HeadFontSize = 5;	v_shag = 8;		h_shag = 180; break;
		case 2:	TradeInfoLib_FontSize = 6;		TradeInfoLib_HeadFontSize = 7;	v_shag = 9;		h_shag = 200; break;
		case 3:	TradeInfoLib_FontSize = 7;		TradeInfoLib_HeadFontSize = 8;	v_shag = 11;	h_shag = 230; break;
		case 4:	TradeInfoLib_FontSize = 8;		TradeInfoLib_HeadFontSize = 9;	v_shag = 13;	h_shag = 270; break;
		case 5:	TradeInfoLib_FontSize = 9;		TradeInfoLib_HeadFontSize = 11;	v_shag = 15;	h_shag = 310; break;
		case 6:	TradeInfoLib_FontSize = 10;	TradeInfoLib_HeadFontSize = 12;	v_shag = 16;	h_shag = 350; break;
		case 7:	TradeInfoLib_FontSize = 11;	TradeInfoLib_HeadFontSize = 13;	v_shag = 18;	h_shag = 390; break;
		case 8:	TradeInfoLib_FontSize = 12;	TradeInfoLib_HeadFontSize = 14;	v_shag = 20;	h_shag = 430; break;
		case 9:	TradeInfoLib_FontSize = 13;	TradeInfoLib_HeadFontSize = 15;	v_shag = 22;	h_shag = 480; break;
		case 10:	TradeInfoLib_FontSize = 14;	TradeInfoLib_HeadFontSize = 16;	v_shag = 24;	h_shag = 530; break;
		default:	TradeInfoLib_FontSize = 10;	TradeInfoLib_HeadFontSize = 12;	v_shag = 16;	h_shag = 350; break;
	}

	_LabelCreate ( "ExpertLog_00", 4, 15				);
	_LabelCreate ( "ExpertLog_01", 4, 15 + v_shag	);
	_LabelCreate ( "ExpertLog_02", 4, 15 + v_shag*2 );
	_LabelCreate ( "ExpertLog_03", 4, 15 + v_shag*3 );
	_LabelCreate ( "ExpertLog_04", 4, 15 + v_shag*4 );

	_LabelCreate ( "ExpertLog_10", h_shag, 15					);
	_LabelCreate ( "ExpertLog_11", h_shag, 15 + v_shag		);
	_LabelCreate ( "ExpertLog_12", h_shag, 15 + v_shag*2	);
	_LabelCreate ( "ExpertLog_13", h_shag, 15 + v_shag*3	);
	_LabelCreate ( "ExpertLog_14", h_shag, 15 + v_shag*4	);

//---- Âûâîäèì èíôîðìàöèþ îá èíèöèàëèçàöèè è çàïèñûâàåì å¸ â ôàéë
	string	AccountStatus	= stringReal;
	int		AccountColor	= 1;
	if ( IsDemo() )
	{
		AccountStatus	= stringDemo;
		AccountColor	= 0;
	}
	string	TradeStatus	= stringTradeAllow;
	int		TradeColor	= 1;
	if ( !IsTradeAllowed() )
	{
		TradeStatus	= stringTradeNotAllow;
		TradeColor	= 0;
	}
	clear_info ();
	_FileWrite	( 		"\n"																									);
	_FileWrite	( 		"++---------Initialization---------++"														);
	_info			( 1,	stringServer + ServerAddress()											, 0				);
	_info			( 2,	AccountStatus + AccountNumber() + " ( " + AccountName() + " )"	, AccountColor );
	_info			( 3,	TradeStatus																		, TradeColor	);
	_info			( 4,	stringLoaded																	, 0				);
	_FileWrite	( 		"++--------------------------------++\n"													);

//---- Ñïèì ñåêóíäó, ÷òîá ýòó ñàìóþ èíôîðìàöèþ ìîæíî áûëî ïðî÷èòàòü =)
	Sleep(1000);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ bool IsOK()
/////////////////////////////////////////////////////////////////////////////////
// Ïðîâåðêà ëè÷íîé ãëîáàëüíîé ïåðåìåííîé ýêñïåðòà, êîëè÷åñòâà áàðîâ íà ãðàôèêå è Ðàçðåøåíèÿ òîðãîâàòü
//  ñëó÷àå óñïåøíîé ïðîâåðêè âîçâðàùàåò true, èíà÷å - false. Ïðè òåñòèðîâàíèè âîçâðàùàåò true.
// Ðåêîìåíäóåòñÿ â ñëó÷àå IsOK() == false ïðåêðàùàòü ðàáîòó ýêñïåðòà.
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() )
	{
		if ( IsVisualMode() ) clear_info();
		return(true);
	}

	_StopLevel	= NormalizeDouble ( ( MarketInfo( _Symbol, MODE_STOPLEVEL ) + 1 ) * _Point, _Digits );
	_Spread		= NormalizeDouble ( MarketInfo ( _Symbol, MODE_SPREAD ) * _Point, _Digits );

	clear_info();

	if ( GlobalVariableGet ( strComment + "-return!" ) < 0 )
	{
		_info( 1, stringGlobalStop, 1 );
		_info( 2, stringGlobalStop1 + "\"" + strComment + "-return!\" " + stringGlobalStop2, 1 );
		return(false);
	}
	if ( Bars < 100 )
	{
		_info( 1, stringNoBars, 1 );
		return(false);
	}
return(true);
}
/////////////////////////////////////////////////////////////////////////////////
/**/ void TradeInfoLib_Deinitialization()
/////////////////////////////////////////////////////////////////////////////////
// Óäàëåíèå îáúåêòîâ, ñîçäàíûõ áèáëèîòåêîé. Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò true, èíà÷å - false.
//
// Íåîáõîäèìî âñòàâèòü â deinit() ýêñïåðòà.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;
	
//---- Óäàëÿåì ëè÷íóþ ãëîáàëüíóþ ïåðåìåííóþ ýêñïåðòà
	if( !GlobalVariableDel( strComment + "-return!" ) )
	{
		_GetLastError = GetLastError();
		Print( "SU3D[v5]", strComment, "-return!\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}

	if ( !Allow_Info ) { return(0); }

//---- È âñå îáúåêòû äëÿ âûâîäà èíôîðìàöèè
	if ( !ObjectDelete ( "ExpertLog_00" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "00", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_01" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "01", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_02" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "02", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_03" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "03", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_04" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "04", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_10" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "10", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_11" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "11", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_12" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "12", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_13" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "13", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_14" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "14", _GetLastError );
	}
}
void TradeInfoLib_Deinit_print ( string ExpertLog_Number, int Error )
{
	Print( "SU3D[v5]", ExpertLog_Number, "\" ) - Error #", Error, " ( ", ErrorDescription( Error ), " )" );
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _info ( int LogNumber, string Text = "", int ColorVariant = 0, bool File_Log = true )
/////////////////////////////////////////////////////////////////////////////////
// Âûâîä èíôîðìàöèè íà ýêðàí, çàïèñü å¸ æå â ëîã-ôàéë ýêñïåðòà è â ëîã-ôàéë ÌÒ.
//
// LogNumber - íîìåð ñòðîêè íà ýêðàíå, â êîòîðóþ áóäåò âûâåäåíà èíôîðìàöèÿ:
// îò 1 äî 4 (4 ñòðîêè íà ëåâîé ïîëîâèíå ýêðàíà) è îò 10 äî 14 (5 ñòðîê - íà ïðàâîé) 
//
// Text - ñîáñòâåííî, òåêñò, âûâîäèìûé íà ýêðàí è çàïèñûâàåìûé â ëîã-ôàéëû
//
// ColorVariant - öâåò âûâîäà èíôîðìàöèè íà ýêðàí: 0 - Standart_Color, 1 - Warning_Color,
// 2 - Price_Up_Color, 3 - Price_Down_Color. Âñå 4 öâåòà ïðåäîïðåäåëÿþòñÿ âõîäÿùèìè ïåðåìåííûìè.
//
// File_Log - ôëàã, ðàçðåøàþùèé (çàïðåùàþùèé) çàïèñü èíôîðìàöèè â ëîã-ôàéë ýêñïåðòà:
// 1(true) - çàïèñü ðàçðåøåíà (ïî óìîë÷àíèþ), 0(false) - çàïèñü çàïðåùåíà.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

	if ( Allow_Info )
	{
		string _infoLabelName;
		double _infoFontSize = TradeInfoLib_FontSize;
		switch ( LogNumber )
		{
			case 0:  _infoLabelName = "ExpertLog_00";	_infoFontSize = TradeInfoLib_HeadFontSize;	break;
			case 1:  _infoLabelName = "ExpertLog_01";																break;
			case 2:  _infoLabelName = "ExpertLog_02";																break;
			case 3:  _infoLabelName = "ExpertLog_03";																break;
			case 4:  _infoLabelName = "ExpertLog_04";																break;
			case 10: _infoLabelName = "ExpertLog_10";	_infoFontSize = TradeInfoLib_HeadFontSize;	break;
			case 11: _infoLabelName = "ExpertLog_11";																break;
			case 12: _infoLabelName = "ExpertLog_12";																break;
			case 13: _infoLabelName = "ExpertLog_13";																break;
			case 14: _infoLabelName = "ExpertLog_14";																break;
			default: _infoLabelName = "ExpertLog_01";																break;
		}
		color _infoColor;
		switch ( ColorVariant )
		{
			case 1:	_infoColor = Warning_Color;		break;
			case 2:	_infoColor = Price_Up_Color;		break;
			case 3:	_infoColor = Price_Down_Color;	break;
			default:	_infoColor = Standart_Color;		break;
		}

		if ( !ObjectSetText( "ExpertLog_00", "Expert log ( " + TimeToStr( TimeLocal(), TIME_SECONDS) + " )", TradeInfoLib_HeadFontSize, TradeInfoLib_Font, Standart_Color ) )
		{
			_GetLastError = GetLastError();
			Print( "( ", LogNumber, ", \"", Text, "\", ", ColorVariant, ", ", File_Log, " ) - ObjectSetText( \"ExpertLog_00\", \"Expert log ( ", TimeToStr( TimeLocal(), TIME_SECONDS), " )\", ", TradeInfoLib_HeadFontSize, ", ", TradeInfoLib_Font, ", ", Standart_Color, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}

		if ( !ObjectSetText( _infoLabelName, Text, _infoFontSize, TradeInfoLib_Font, _infoColor) )
		{
			_GetLastError = GetLastError();
			Print( "( ", LogNumber, ", \"", Text, "\", ", ColorVariant, ", ", File_Log, " ) - ObjectSetText( \"", _infoLabelName,"\", \"", Text, "\", ", _infoFontSize, ", ", TradeInfoLib_Font, ", ", _infoColor, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}
	}

	if ( Text != "" && File_Log ) { _FileWrite ( Text ); }
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void clear_info ()
/////////////////////////////////////////////////////////////////////////////////
// Î÷èñòêà ýêðàíà îò èíôîðìàöèè, âûâåäåííîé áèáëèîòåêîé íà ýêðàí.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

	if ( !Allow_Info ) { return(0); }

	if ( !ObjectSetText ( "ExpertLog_00", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "00", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_01", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "01", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_02", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "02", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_03", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "03", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_04", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "04", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_10", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "10", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_11", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "11", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_12", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "12", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_13", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "13", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_14", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "14", _GetLastError ); }
}
void clear_info_print ( string ExpertLog_Number, int Error )
{ Print( " ", ExpertLog_Number, " \", \"\", 10 ) - Error #", Error, " ( ", ErrorDescription( Error ), " )" ); }

/////////////////////////////////////////////////////////////////////////////////
/**/ void _LabelCreate ( string _LabelName, int _LabelXDistance, int _LabelYDistance, int _LabelCorner = 0 )
/////////////////////////////////////////////////////////////////////////////////
// Ñëóæåáíàÿ ô-öèÿ…
// Ñîçäàíèå îáúåêòà "Òåêñòîâàÿ ìåòêà" ñ èìåíåì _LabelName.
// Êîîðäèíàòû: õ = _LabelXDistance, ó = _LabelYDistance, óãîë - _LabelCorner.
/////////////////////////////////////////////////////////////////////////////////
{
	if ( !Allow_Info ) { return(false); }

	int _GetLastError;

	if ( !ObjectCreate( _LabelName, OBJ_LABEL, 0, 0, 0 ) )
	{
		_GetLastError = GetLastError();
		if ( _GetLastError != 4200 )
		{
			Print( "( \"", _LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectCreate( \"", _LabelName, "\", OBJ_LABEL,0,0,0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			return(-1);
		}
	}
	if ( !ObjectSet( _LabelName, OBJPROP_CORNER, _LabelCorner ) )
	{
		_GetLastError = GetLastError();
		Print(_LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectSet( \"", _LabelName, "\", OBJPROP_CORNER, ", _LabelCorner, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
	if ( !ObjectSet( _LabelName, OBJPROP_XDISTANCE, _LabelXDistance ) )
	{
		_GetLastError = GetLastError();
		Print(_LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectSet( \"", _LabelName, "\", OBJPROP_XDISTANCE, ", _LabelXDistance, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
	if ( !ObjectSet( _LabelName, OBJPROP_YDISTANCE, _LabelYDistance ) )
	{
		_GetLastError = GetLastError();
		Print(_LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectSet( \"", _LabelName, "\", OBJPROP_YDISTANCE, ", _LabelYDistance, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
	if ( !ObjectSetText ( _LabelName, "", 10 ) )
	{
		_GetLastError = GetLastError();
		Print(_LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectSetText( \"", _LabelName, "\", \"\", 10 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _FileWrite ( string text )
/////////////////////////////////////////////////////////////////////////////////
// Çàïèñü text â ëîã-ôàéë.
// (…\MetaTrader 4\experts\files\_ExpertLogs\Èìÿ ýêñïåðòà( Ñèìâîë, Ïåðèîä )\ãîä.ìåñÿö.äåíü.txt )
/////////////////////////////////////////////////////////////////////////////////
{
	if ( !Allow_LogFile ) { return(0); }

	int _GetLastError;

	string file_name = "_ExpertLogs\\" + strComment + "\\" + TimeToStr( TimeLocal(), TIME_DATE ) + ".txt";
	int file_handle = FileOpen ( file_name, FILE_READ | FILE_WRITE, " " );
	
	if ( file_handle > 0 )
	{
		if ( FileSeek ( file_handle, 0, SEEK_END ) )
		{
			if ( text != "\n" && text != "\r\n" ) { text = TimeToStr( TimeLocal(), TIME_SECONDS ) + " - - - " + text; }
			if ( FileWrite ( file_handle, text ) < 0 )
			{
				_GetLastError = GetLastError();
				Print( " _FileWrite( \"" + text + "\" ) - FileWrite ( ", file_handle, ", ", text, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			}
		}
		else
		{
			_GetLastError = GetLastError();
			Print( " _FileWrite( \"" + text + "\" ) - FileSeek ( " + file_handle + ", 0, SEEK_END ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}
		FileClose ( file_handle );
	}
	else
	{
		_GetLastError = GetLastError();
		Print( " _FileWrite( \"" + text + "\" ) - FileOpen( ", file_name, ", FILE_READ | FILE_WRITE, \" \" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _MagicNumber( int Expert_Id, int _Period )
/////////////////////////////////////////////////////////////////////////////////
// Ô-öèÿ ãåíåðèðóåò MagicNumber, óíèêàëüíûé äëÿ ñâÿçêè Expert_Id - _Period.
// 
// Òàêèì îáðàçîì, äàæå ñ îäèíàêîâûì Expert_Id ýêñïåðòû, ðàáîòàþùèå íà ðàçíûõ ÒÔ áóäóò èñïîëüçîâàòü ðàçíûå MagicNumber.
// Íàïðèìåð, ïðè Expert_Id = 1230 è _Period = PERIOD_H1,  MagicNumber áóäåò 12305
// À ýòîò æå ýêñïåðò, íî íà ãðàôèêå ñ ïåðèîäîì PERIOD_W1 áóäåò èìåòü MagicNumber = 12308
/////////////////////////////////////////////////////////////////////////////////
{
	return( Expert_Id );

	// ñòàðûé òåêñò ôóíêöèè:
	int Period_Id = 0;
	switch ( _Period )
	{
		case PERIOD_MN1: Period_Id = 9; break;
		case PERIOD_W1:  Period_Id = 8; break;
		case PERIOD_D1:  Period_Id = 7; break;
		case PERIOD_H4:  Period_Id = 6; break;
		case PERIOD_H1:  Period_Id = 5; break;
		case PERIOD_M30: Period_Id = 4; break;
		case PERIOD_M15: Period_Id = 3; break;
		case PERIOD_M5:  Period_Id = 2; break;
		case PERIOD_M1:  Period_Id = 1; break;
		default: Print( " _MagicNumber( ", Expert_Id, ", ", _Period, " ) - Invalid Period!" );
	}
	return(Expert_Id * 10 + Period_Id);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ bool _IsExpertOrder ( int _MagicNumber )
/////////////////////////////////////////////////////////////////////////////////
// Ïîèñê ïîçèöèè/îðäåðà ñ çàäàííûì _MagicNumber è ñ òåêóùèì Ñèìâîëîì.
// Åñëè òàêîé åñòü, âûâîäèò èíôîðìàöèþ è âîçâðàùàåò true, åñëè íåò - âîçâðàùàåò false.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

	int _OrdersTotal = OrdersTotal();
	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
		if ( !OrderSelect( z, SELECT_BY_POS ) )
		{
			_GetLastError = GetLastError();
			Print( " _IsExpertOrder( ", _MagicNumber, " ) - OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}
		if ( OrderMagicNumber() == _MagicNumber && OrderSymbol() == _Symbol )
		{
			if ( !Allow_Info ) { return(true); }

			int		_OrderTicket			= OrderTicket();
			int		_OrderType				= OrderType();
			string	_OrderSymbol			= OrderSymbol();
			double	_OrderLots				= NormalizeDouble( OrderLots(), 2 );
			double	_OrderOpenPrice		= NormalizeDouble( OrderOpenPrice(), _Digits );
			double	_OrderStopLoss			= NormalizeDouble( OrderStopLoss(), _Digits );
			double	_OrderProfit			= OrderProfit();

			_info ( 10, "" );
			_info ( 11, "" );
			_info ( 12, "" );
			_info ( 13, "" );
			_info ( 14, "" );

			if ( _OrderType <= OP_SELL )
			{
				double ProfitLoss = _OrderProfit + OrderSwap() + OrderCommission();
				double Point_Cost = LotCost( _OrderSymbol ) * _OrderLots;

				int _profit_color = 0;
				if ( ProfitLoss > 0 ) { _profit_color = 2; }
				if ( ProfitLoss < 0 ) { _profit_color = 3; }

				double ProfitLossPoints = MathAbs( _OrderProfit / Point_Cost );

				double MaxLossPoints;
				if ( _OrderType == OP_BUY )
				{ MaxLossPoints = ( _OrderStopLoss - _OrderOpenPrice ) / _Point; }
				else
				{ MaxLossPoints = ( _OrderOpenPrice - _OrderStopLoss ) / _Point; }
				double MaxLoss = MaxLossPoints * Point_Cost + OrderSwap() + OrderCommission();

				string ifNoStopLoss = DoubleToStr( MaxLoss, 2 ) + " " + AccountCurrency() + " (" + DoubleToStr( MathAbs( MaxLossPoints ), 0 ) + " points)";
				int _maxloss_color = 0;
				if ( MaxLossPoints > 0 ) { _maxloss_color = 2; }
				if ( MaxLossPoints < 0 ) { _maxloss_color = 3; }
				if ( _OrderStopLoss <= 0 ) { _maxloss_color = 1; ifNoStopLoss = "Ñòîï Ëîññ ÍÅ ÓÑÒÀÍÎÂËÅÍ!"; }
				
				_info ( 1, stringOpenedPosition, 0, 0 );
				_info ( 2, "#" + _OrderTicket + " - " + strOrderType ( _OrderType )	+ ",  " + DoubleToStr( _OrderLots, 2 ) + " lot(s)", 0, 0 );
				_info ( 3, "Ïðèáûëü/Óáûòîê:  " + DoubleToStr( ProfitLoss, 2 ) + " " + AccountCurrency() + " (" + DoubleToStr( ProfitLossPoints, 0 ) + " points)"		, _profit_color	, 0 );
				_info ( 4, "Äî ÑòîïËîññà:  " + " " + " " + " " + " " + ifNoStopLoss, _maxloss_color	, 0 );
			}
			else
			{
				int		_before_color	= 0;
				double	Price				= NormalizeDouble( MarketInfo( _OrderSymbol, MODE_BID ), _Digits );
				string	tmp_str			= ", Bid = " + DoubleToStr( Price, _Digits );
				if ( _OrderType == OP_BUYLIMIT || _OrderType == OP_BUYSTOP )
				{
					Price = NormalizeDouble( MarketInfo( _OrderSymbol, MODE_ASK ), _Digits );
					tmp_str = ", Ask = " + DoubleToStr( Price, _Digits );
				}

				if ( MathAbs( _OrderOpenPrice - Price ) / _Point <= 10 ) { _before_color = 1; }
			
				_info ( 1, _OrderSymbol + stringOpenedOrder																	, 0				, 0 );	
				_info ( 2, "¹ " + _OrderTicket + " - " + strOrderType ( _OrderType )								, 0				, 0 );
				_info ( 3, "Open Price = " + DoubleToStr( _OrderOpenPrice, _Digits )  + tmp_str					, 0				, 0 );
				_info	( 4, stringPointBefore + DoubleToStr( MathAbs( _OrderOpenPrice - Price ) / _Point, 0 ) , _before_color, 0 );
			}
			return(true);
		}
	}
return(false);
}

int _ExpertOrders = 0; int _MarketOrders = 0; int _PendingOrders = 0;
int _BuyTicket = 0; double _BuyLots = 0.0; double _BuyOpenPrice = 0.0; double _BuyStopLoss = 0.0; double _BuyTakeProfit = 0.0; datetime _BuyOpenTime = -1; double _BuyProfit = 0.0; double _BuySwap = 0.0; double _BuyCommission = 0.0; string _BuyComment = ""; 
int _SellTicket = 0; double _SellLots = 0.0; double _SellOpenPrice = 0.0; double _SellStopLoss = 0.0; double _SellTakeProfit = 0.0; datetime _SellOpenTime = -1; double _SellProfit = 0.0; double _SellSwap = 0.0; double _SellCommission = 0.0; string _SellComment = ""; 
int _BuyStopTicket = 0; double _BuyStopLots = 0.0; double _BuyStopOpenPrice = 0.0; double _BuyStopStopLoss = 0.0; double _BuyStopTakeProfit = 0.0; datetime _BuyStopOpenTime = -1; string _BuyStopComment = ""; datetime _BuyStopExpiration = -1;
int _SellStopTicket = 0; double _SellStopLots = 0.0; double _SellStopOpenPrice = 0.0; double _SellStopStopLoss = 0.0; double _SellStopTakeProfit = 0.0; datetime _SellStopOpenTime = -1; string _SellStopComment = ""; datetime _SellStopExpiration = -1;
int _BuyLimitTicket = 0; double _BuyLimitLots = 0.0; double _BuyLimitOpenPrice = 0.0; double _BuyLimitStopLoss = 0.0; double _BuyLimitTakeProfit = 0.0; datetime _BuyLimitOpenTime = -1; string _BuyLimitComment = ""; datetime _BuyLimitExpiration = -1;
int _SellLimitTicket = 0; double _SellLimitLots = 0.0; double _SellLimitOpenPrice = 0.0; double _SellLimitStopLoss = 0.0; double _SellLimitTakeProfit = 0.0; datetime _SellLimitOpenTime = -1; string _SellLimitComment = ""; datetime _SellLimitExpiration = -1;

/////////////////////////////////////////////////////////////////////////////////
/**/ void _ExpertOrdersInit( int _MagicNumber )
/////////////////////////////////////////////////////////////////////////////////
// Ìîæíî èñïîëüçîâàòü, åñëè ýêñïåðò óñòàíàâëèâàåò ìàêñèìóì ÎÄÈÍ îðäåð îäíîãî òèïà (OP_BUY, OP_SELL, è ò.ä.)
// Ïðèñâàèâàåò çíà÷åíèÿ ïåðåìåííûì, ïåðå÷èñëåííûì âûøå. Èõ ìîæíî èñïîëüçîâàòü èç ýêñïåðòà äëÿ óïðîùåíèÿ êîäà.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

	_ExpertOrders = 0; _MarketOrders = 0; _PendingOrders = 0;
	_BuyTicket = 0; _BuyLots = 0.0; _BuyOpenPrice = 0.0; _BuyStopLoss = 0.0; _BuyTakeProfit = 0.0; _BuyOpenTime = -1; _BuyProfit = 0.0; _BuySwap = 0.0; _BuyCommission = 0.0; _BuyComment = "";
	_SellTicket = 0; _SellLots = 0.0; _SellOpenPrice = 0.0; _SellStopLoss = 0.0; _SellTakeProfit = 0.0; _SellOpenTime = -1; _SellProfit = 0.0; _SellSwap = 0.0; _SellCommission = 0.0; _SellComment = "";
	_BuyStopTicket = 0; _BuyStopLots = 0.0; _BuyStopOpenPrice = 0.0; _BuyStopStopLoss = 0.0; _BuyStopTakeProfit = 0.0; _BuyStopOpenTime = -1; _BuyStopComment = ""; _BuyStopExpiration = -1;
	_SellStopTicket = 0; _SellStopLots = 0.0; _SellStopOpenPrice = 0.0; _SellStopStopLoss = 0.0; _SellStopTakeProfit = 0.0; _SellStopOpenTime = -1; _SellStopComment = ""; _SellStopExpiration = -1;
	_BuyLimitTicket = 0; _BuyLimitLots = 0.0; _BuyLimitOpenPrice = 0.0; _BuyLimitStopLoss = 0.0; _BuyLimitTakeProfit = 0.0; _BuyLimitOpenTime = -1; _BuyLimitComment = ""; _BuyLimitExpiration = -1;
	_SellLimitTicket = 0; _SellLimitLots = 0.0; _SellLimitOpenPrice = 0.0; _SellLimitStopLoss = 0.0; _SellLimitTakeProfit = 0.0; _SellLimitOpenTime = -1; _SellLimitComment = ""; _SellLimitExpiration = -1;

	int _OrdersTotal = OrdersTotal();
	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
		if ( !OrderSelect( z, SELECT_BY_POS ) )
		{
			_GetLastError = GetLastError();
			Print( " _ExpertOrdersInit( ", _MagicNumber, " ) - OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}
		if ( OrderMagicNumber() == _MagicNumber && OrderSymbol() == _Symbol )
		{
			int		_OrderType			= OrderType();
			int		_OrderTicket		= OrderTicket();
			double	_OrderLots			= NormalizeDouble( OrderLots(), 2 );
			double	_OrderOpenPrice	= NormalizeDouble( OrderOpenPrice(), _Digits );
			double	_OrderStopLoss		= NormalizeDouble( OrderStopLoss(), _Digits );
			double	_OrderTakeProfit	= NormalizeDouble( OrderTakeProfit(), _Digits );
			datetime	_OrderOpenTime		= OrderOpenTime();
			double	_OrderProfit		= NormalizeDouble( OrderProfit(), 2 );
			double	_OrderSwap			= NormalizeDouble( OrderSwap(), 2 );
			double	_OrderCommission	= NormalizeDouble( OrderCommission(), 2 );
			string	_OrderComment		= OrderComment();
			datetime	_OrderExpiration	= OrderExpiration();

			if ( _OrderType == OP_BUY			) { _MarketOrders ++; _BuyTicket = _OrderTicket; _BuyLots = _OrderLots; _BuyOpenPrice = _OrderOpenPrice; _BuyStopLoss = _OrderStopLoss; _BuyTakeProfit = _OrderTakeProfit; _BuyOpenTime = _OrderOpenTime; _BuyProfit = _OrderProfit; _BuySwap = _OrderSwap; _BuyCommission = _OrderCommission; _BuyComment = _OrderComment; }
			if ( _OrderType == OP_SELL			) { _MarketOrders ++; _SellTicket = _OrderTicket; _SellLots = _OrderLots; _SellOpenPrice = _OrderOpenPrice; _SellStopLoss = _OrderStopLoss; _SellTakeProfit = _OrderTakeProfit; _SellOpenTime = _OrderOpenTime; _SellProfit = _OrderProfit; _SellSwap = _OrderSwap; _SellCommission = _OrderCommission; _SellComment = _OrderComment; }
			if ( _OrderType == OP_BUYSTOP		) { _PendingOrders ++; _BuyStopTicket = _OrderTicket; _BuyStopLots = _OrderLots; _BuyStopOpenPrice = _OrderOpenPrice; _BuyStopStopLoss = _OrderStopLoss; _BuyStopTakeProfit = _OrderTakeProfit; _BuyStopOpenTime = _OrderOpenTime; _BuyStopComment = _OrderComment; _BuyStopExpiration = _OrderExpiration; }
			if ( _OrderType == OP_SELLSTOP	) { _PendingOrders ++; _SellStopTicket = _OrderTicket; _SellStopLots = _OrderLots; _SellStopOpenPrice = _OrderOpenPrice; _SellStopStopLoss = _OrderStopLoss; _SellStopTakeProfit = _OrderTakeProfit; _SellStopOpenTime = _OrderOpenTime; _SellStopComment = _OrderComment; _SellStopExpiration = _OrderExpiration; }
			if ( _OrderType == OP_BUYLIMIT	) { _PendingOrders ++; _BuyLimitTicket = _OrderTicket; _BuyLimitLots = _OrderLots; _BuyLimitOpenPrice = _OrderOpenPrice; _BuyLimitStopLoss = _OrderStopLoss; _BuyLimitTakeProfit = _OrderTakeProfit; _BuyLimitOpenTime = _OrderOpenTime; _BuyLimitComment = _OrderComment; _BuyLimitExpiration = _OrderExpiration; }
			if ( _OrderType == OP_SELLLIMIT	) { _PendingOrders ++; _SellLimitTicket = _OrderTicket; _SellLimitLots = _OrderLots; _SellLimitOpenPrice = _OrderOpenPrice; _SellLimitStopLoss = _OrderStopLoss; _SellLimitTakeProfit = _OrderTakeProfit; _SellLimitOpenTime = _OrderOpenTime; _SellLimitComment = _OrderComment; _SellLimitExpiration = _OrderExpiration; }
		}
	}
	_ExpertOrders = _MarketOrders + _PendingOrders;
}

// ô-öèÿ minri, äîðàáîòàííàÿ ìíîé
/////////////////////////////////////////////////////////////////////////////////
/**/ double LotCost ( string _Symbol )
/////////////////////////////////////////////////////////////////////////////////
{
	if ( MarketInfo ( _Symbol, MODE_BID ) <= 0 ) { return(-1.0); }
	double Cost = -1.0;

	string FirstPart  = StringSubstr( _Symbol, 0, 3 );
	string SecondPart = StringSubstr( _Symbol, 3, 3 );

	double Base = MarketInfo ( _Symbol, MODE_LOTSIZE ) * MarketInfo ( _Symbol, MODE_POINT );
	if ( SecondPart == "USD" )
	{ Cost = Base; }
	else
	{
		if ( FirstPart == "USD" )
		{ Cost = Base / MarketInfo ( _Symbol, MODE_BID ); }
		else
		{
			if ( MarketInfo( "USD" + SecondPart, MODE_BID ) > 0 )
			{ Cost = Base / MarketInfo( "USD" + SecondPart, MODE_BID ); }
			else
			{ Cost = Base * MarketInfo( SecondPart + "USD", MODE_BID ); }
		}
	}
	return( NormalizeDouble(Cost, 2) );
}

string	Send_Symbol = "", Send_Comment = "";
int		Send_OrderType = 0, Send_Slippage = 0, Send_MagicNumber = 0, Send_StartTickCount = 0, Send_GetLastError = 0;
double	Send_Volume = 0.0, Send_OpenPrice = 0.0, Send_StopLoss = 0.0, Send_TakeProfit = 0.0;
datetime	Send_Expiration = 0;
color		Send_Color = CLR_NONE;
int		Send_Result = -1;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderSend ( string _Symbol, int _OrderType, double _Volume, double _OpenPrice, int _Slippage = -1, double _StopLoss = 0.0, double _TakeProfit = 0.0, string _Comment = "", int _MagicNumber = 0, datetime _Expiration = 0, color _Color = -2 )
/////////////////////////////////////////////////////////////////////////////////
// Ñòàíäàðòíàÿ ô-öèÿ OrderSend + ïðîâåðêà çíà÷åíèé.
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò OrderTicket, ïðè îøèáêå óñòàíîâêè âîçâðàùàåò "-1",
// ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-2". Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-3".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Send_Symbol = _Symbol; Send_Comment = _Comment;
	Send_OrderType = _OrderType; Send_Slippage = _Slippage; Send_MagicNumber = _MagicNumber; Send_StartTickCount = GetTickCount();
	Send_Volume = _Volume; Send_OpenPrice = _OpenPrice; Send_StopLoss = _StopLoss; Send_TakeProfit = _TakeProfit;
	Send_Expiration = _Expiration;
	Send_Color = _Color;
	Send_Result = -1;
	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ
	_OrderSend_SetValue();

//---- Âûâîäèì èíôîðìàöèþ
	_OrderSend_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _OrderSend_Check() == false ) { return(-2); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(1);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû,
	if ( GetTickCount() - Send_StartTickCount > 1000 )
	{
//---- îáíîâëÿåì ïåðåìåííûå
		_OrderSend_RefreshValue();
//---- è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
		if ( _OrderSend_Check() == false ) { TradeIsNotBusy(); return(-2); }
	}

//---- Ñîáñòâåííî, îòêðûâàåìñÿ
	Send_Result = OrderSend ( Send_Symbol, Send_OrderType, Send_Volume, Send_OpenPrice, Send_Slippage, Send_StopLoss, Send_TakeProfit, Send_Comment, Send_MagicNumber, Send_Expiration, Send_Color );
	Send_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( Send_Result < 0 || Send_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Send_GetLastError, "OrderSend" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê,
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 1, "Error", Send_GetLastError, ErrorDescription( Send_GetLastError ), "OrderSend(...)", "Error #" + Send_GetLastError + " ( " + ErrorDescription( Send_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê,
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè îòêðûëàñü ïîçèöèÿ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -4.
	int _GetLastError;
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( OrderSelect( Send_Result, SELECT_BY_TICKET ) ) { break; }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 ) { _Print_ ( 1, "OrderSelect( " + Send_Result + ", SELECT_BY_TICKET )", "Error #" + _GetLastError + " ( " + ErrorDescription( _GetLastError ) + " )" ); continue; }
		Processing_Error ( 0, "OrderSend" );
		_Return_ ( 1, "Error", 0, "Îðäåð íå áûë óñòàíîâëåí/Ïîçèöèÿ íå áûëà îòêðûòà", "OrderSend(...)", "Îðäåð íå áûë óñòàíîâëåí/Ïîçèöèÿ íå áûëà îòêðûòà" );
		return(-4);
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderSend_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 1, "OK", 0, "", "OrderSend(...)", "OK. Ticket " + Send_Result );
//---- è âûõîäèì, âîçâðàùàÿ ¹ òèêåòà.
return(Send_Result);
}

void _OrderSend_SetValue ()
{
//---- Ïðîâåðÿåì _Slippage
	if ( Send_Slippage < 0 ) { Send_Slippage = Slippage; }
//---- Åñëè _Comment íå çàäàâàëñÿ, íàïèøåì "Èìÿ_Ýêñïåðòà( Ñèìâîë, Òàéìôðåéì )"
	if ( Send_Comment == "" ) { Send_Comment = strComment; }
//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Send_Color < -1 )
	{
		Send_Color = OrderSellColor;
		if ( Send_OrderType == OP_BUY || Send_OrderType == OP_BUYLIMIT || Send_OrderType == OP_BUYSTOP )
		{ Send_Color = OrderBuyColor; }
	}
	else
	{
		if ( Send_Color < 0 ) Send_Color = CLR_NONE;
	}

//---- Âûñòàâëÿåì öåíó îòêðûòèÿ è óäàëÿåì âðåìÿ èñòå÷åíèÿ äëÿ BUY è SELL ïîçèöèé
	if ( Send_OrderType == OP_BUY ) { Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits ); Send_Expiration = 0; }
	if ( Send_OrderType == OP_SELL ) { Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits ); Send_Expiration = 0; }

//	Send_Volume = NormalizeDouble( Send_Volume, 2 );
	Send_OpenPrice = NormalizeDouble( Send_OpenPrice, _Digits );
	Send_StopLoss = NormalizeDouble( Send_StopLoss, _Digits );
	Send_TakeProfit = NormalizeDouble( Send_TakeProfit, _Digits );
}
void _OrderSend_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }
	string str_tmp = stringSendingOrder + strOrderType ( Send_OrderType ) + stringSendingOrder1;
	if ( Send_OrderType <= OP_SELL )
	{ str_tmp = stringSendingPosition + strOrderType ( Send_OrderType ) + stringSendingPosition1; }
	int _OrderType_ColorVariant = 3;
	if ( Send_OrderType == OP_BUY || Send_OrderType == OP_BUYLIMIT || Send_OrderType == OP_BUYSTOP ) { _OrderType_ColorVariant = 2; }

	_FileWrite ( "- - - - - - - - - - - - - - - - - OrderSend Start- - - - - - - - - - - - - - - - - - -" );
	_info ( 10, str_tmp, _OrderType_ColorVariant );
	_info ( 1, "Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
	_info ( 2, "Stop Loss = " + DoubleToStr( Send_StopLoss, _Digits ) );
	_info ( 3, "Take Profit = " + DoubleToStr( Send_TakeProfit, _Digits ) );
	_info ( 4, "Lot(s) = " + DoubleToStr( Send_Volume, 2 ) );

	_info ( 11, "Comment = " + Send_Comment, 0, 0 );
	_info ( 12, "MagicNumber = " + Send_MagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
	
	if ( Send_Expiration > 0 ) { _FileWrite ( "Expiration Time = " + TimeToStr( Send_Expiration, TIME_DATE | TIME_SECONDS ) ); }
}
bool _OrderSend_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

	if ( _OrderCheck( Send_Symbol, Send_OrderType, Send_Volume, Send_OpenPrice, Send_StopLoss, Send_TakeProfit, Send_Expiration ) < 0 )
	{
		if ( Allow_Info )	{ _info ( 13, stringCheckError, 1, 0 ); }
		if ( Allow_LogFile ) { _FileWrite( "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!" ); }
		_Return_ ( 1, "Error", 0, stringInvalidParameters, "_OrderSend_Check()", stringInvalidParameters );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }

return(true);
}
void _OrderSend_RefreshValue ()
{
	bool refreshed = false;
//---- Îáíîâëÿåì öåíó îòêðûòèÿ äëÿ BUY è SELL ïîçèöèé
	if ( Send_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Send_OpenPrice, _Digits ) != NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits ) )
		{
			Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderSend Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
			}
		}
	}
	if ( Send_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Send_OpenPrice, _Digits ) != NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits ) )
		{
			Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderSend Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
			}
		}
	}
}
void _OrderSend_SetArrow ()
{
	if ( Send_Color == CLR_NONE ) { return(0); }
	string arrow_description = Send_Comment + "\nId " + Send_MagicNumber;
	string end_name;
	switch ( Send_OrderType )
	{
		case OP_BUY:			end_name = " buy "; break;
		case OP_SELL:			end_name = " sell "; break;
		case OP_BUYLIMIT:		end_name = " buy limit "; break;
		case OP_SELLLIMIT:	end_name = " sell limit "; break;
		case OP_BUYSTOP:		end_name = " buy stop "; break;
		case OP_SELLSTOP:		end_name = " sell stop "; break;
	}
	string open_name = "#" + Send_Result + end_name + DoubleToStr( Send_Volume, 2 ) + " " + Send_Symbol + " at " + DoubleToStr( Send_OpenPrice, _Digits );
	string sl_name = open_name + " stop loss at " + DoubleToStr( Send_StopLoss, _Digits );
	string tp_name = open_name + " take profit at " + DoubleToStr( Send_TakeProfit, _Digits );

	ObjectSetText( open_name, arrow_description, 10 );
	if ( NormalizeDouble( Send_StopLoss		, _Digits ) > 0 ) ObjectSetText( sl_name, arrow_description, 10 );
	if ( NormalizeDouble( Send_TakeProfit	, _Digits ) > 0 ) ObjectSetText( tp_name, arrow_description, 10 );
	GetLastError();
}

string	Modify_Symbol = "", Modify_OrderComment = "";
int		Modify_OrderTicket = 0, Modify_OrderType = 0, Modify_OrderMagicNumber = 0, Modify_StartTickCount = 0, Modify_GetLastError = 0;
double	Modify_OrderLots = 0.0, Modify_OrderOpenPrice = 0.0, Modify_OrderStopLoss = 0.0, Modify_OrderTakeProfit = 0.0;
double	Modify_New_OpenPrice = 0.0, Modify_New_StopLoss = 0.0, Modify_New_TakeProfit = 0.0;
datetime	Modify_OrderExpiration = 0, Modify_New_Expiration = 0;
color		Modify_Color = CLR_NONE;
bool		Modify_Result = false;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderModify ( int _OrderTicket, double New_OpenPrice = 0.0, double New_StopLoss = 0.0, double New_TakeProfit = 0.0, datetime New_Expiration = 0, color _Color = -2 )
/////////////////////////////////////////////////////////////////////////////////
// Ñòàíäàðòíàÿ ô-öèÿ OrderModify + ïðîâåðêè.
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò "1", ïðè îøèáêå ìîäèôèêàöèè âîçâðàùàåò "-1",
// ïðè îøèáêå âûáîðà îðäåðà âîçâðàùàåò "-2", ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-3".
// Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-4", åñëè íåò ïàðàìåòðîâ äëÿ ìîäèôèêàöèè, âîçâðàùàåò "0".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Modify_Symbol = ""; Modify_OrderComment = "";
	Modify_OrderTicket = _OrderTicket; Modify_OrderType = 0; Modify_OrderMagicNumber = 0; Modify_StartTickCount = GetTickCount();
	Modify_OrderLots = 0.0; Modify_OrderOpenPrice = 0.0; Modify_OrderStopLoss = 0.0; Modify_OrderTakeProfit = 0.0;
	Modify_New_OpenPrice = NormalizeDouble( New_OpenPrice, _Digits ); Modify_New_StopLoss = NormalizeDouble( New_StopLoss, _Digits ); Modify_New_TakeProfit = NormalizeDouble( New_TakeProfit, _Digits );
	Modify_OrderExpiration = 0; Modify_New_Expiration = New_Expiration;
	Modify_Color = _Color;
	Modify_Result = false;
	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _OrderModify_SetValue() == false ) { return(-2); }

//---- Âûâîäèì èíôîðìàöèþ
	_OrderModify_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	int Check = _OrderModify_Check();
	if ( Check < 0 ) { return(Check); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(2);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Modify_StartTickCount > 1000 )
	{
		if ( _OrderModify_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		Check = _OrderModify_Check();
		if ( Check < 0 ) { TradeIsNotBusy(); return(Check); }
	}

//---- Ñîáñòâåííî, ìîäèôèêàöèÿ
	Modify_Result = OrderModify( Modify_OrderTicket, Modify_New_OpenPrice, Modify_New_StopLoss, Modify_New_TakeProfit, Modify_New_Expiration, Modify_Color );
	Modify_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Modify_Result || Modify_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Modify_GetLastError, "OrderModify" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 2, "Error", Modify_GetLastError, ErrorDescription( Modify_GetLastError ), "OrderModify(...)", "Error #" + Modify_GetLastError + " ( " + ErrorDescription( Modify_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè èçìåíèëèñü ïàðàìåòðû ïîçèöèè è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -4.
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( !OrderSelect( Modify_OrderTicket, SELECT_BY_TICKET ) )
		{
			Modify_GetLastError = GetLastError();
			_Print_ ( 2, "OrderSelect( " + Modify_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Modify_GetLastError + " ( " + ErrorDescription( Modify_GetLastError ) + " )" );
			continue;
		}
		if ( 	NormalizeDouble( Modify_OrderOpenPrice,  _Digits ) != NormalizeDouble( OrderOpenPrice(),  _Digits ) ||
				NormalizeDouble( Modify_OrderStopLoss,   _Digits ) != NormalizeDouble( OrderStopLoss(),   _Digits ) ||
				NormalizeDouble( Modify_OrderTakeProfit, _Digits ) != NormalizeDouble( OrderTakeProfit(), _Digits ) ||
				Modify_OrderExpiration != OrderExpiration() )
		{ break; }
		else
		{
			Processing_Error ( 0, "OrderModify" );
			_Return_ ( 2, "Error", 0, "Îðäåð íå áûë ìîäèôèöèðîâàí/Ïîçèöèÿ íå áûëà ìîäèôèöèðîâàíà", "OrderModify(...)", "Îðäåð íå áûë ìîäèôèöèðîâàí/Ïîçèöèÿ íå áûëà ìîäèôèöèðîâàíà" );
			return(-4);
		}
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderModify_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 2, "OK", 0, "", "OrderModify(...)", "OK" );

//---- è âûõîäèì, âîçâðàùàÿ 1.
return(1);
}

bool _OrderModify_SetValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Modify_OrderTicket, SELECT_BY_TICKET ) )
	{
		Modify_GetLastError = GetLastError();
		_Return_ ( 2,  "Error", Modify_GetLastError, ErrorDescription( Modify_GetLastError ), "OrderSelect( " + Modify_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Modify_GetLastError + " ( " + ErrorDescription( Modify_GetLastError ) + " )" );
		return(false);
	}

	Modify_Symbol				= OrderSymbol();
	Modify_OrderType			= OrderType();
	Modify_OrderLots			= NormalizeDouble ( OrderLots(), 2 );
	Modify_OrderOpenPrice	= NormalizeDouble ( OrderOpenPrice(), _Digits );
	Modify_OrderStopLoss		= NormalizeDouble ( OrderStopLoss(), _Digits );
	Modify_OrderTakeProfit	= NormalizeDouble ( OrderTakeProfit(), _Digits );
	Modify_OrderExpiration	= OrderExpiration();
	Modify_OrderMagicNumber = OrderMagicNumber();
	Modify_OrderComment		= OrderComment();

//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Modify_Color < -1 )
	{
		Modify_Color = OrderSellColor;
		if ( Modify_OrderType == OP_BUY || Modify_OrderType == OP_BUYLIMIT || Modify_OrderType == OP_BUYSTOP )
		{ Modify_Color = OrderBuyColor; }
	}
	else
	{
		if ( Modify_Color < 0 ) Modify_Color = CLR_NONE;
	}

//---- Åñëè ïàðàìåòðû äëÿ èçìåíåíèÿ íå çàäàâàëèñü, çàïîëíÿåì èõ ïàðàìåòðàìè îðäåðà
	if ( Modify_New_OpenPrice  < 0 )	{ Modify_New_OpenPrice	= NormalizeDouble( Modify_OrderOpenPrice, _Digits ); }
	if ( Modify_New_StopLoss   < 0 )	{ Modify_New_StopLoss	= NormalizeDouble( Modify_OrderStopLoss, 	_Digits ); }
	if ( Modify_New_TakeProfit < 0 )	{ Modify_New_TakeProfit	= NormalizeDouble( Modify_OrderTakeProfit, _Digits ); }
	if ( Modify_New_Expiration < 0 )	{ Modify_New_Expiration	= Modify_OrderExpiration; }

	if ( Modify_OrderType <= OP_SELL )
	{ Modify_New_OpenPrice = NormalizeDouble( Modify_OrderOpenPrice, _Digits ); Modify_New_Expiration = 0; }
	
return(true);
}
void _OrderModify_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }

	string str_tmp = "Ìîäèôèöèðóåì îðäåð ¹ ";
	if ( Modify_OrderType <= OP_SELL ) { str_tmp = "Ìîäèôèöèðóåì ïîçèöèþ ¹ "; }

	int _OpenPrice_ColorVariant = 0;
	bool _OpenPrice_FileWrite = false;
	if ( Modify_New_OpenPrice > Modify_OrderOpenPrice ) { _OpenPrice_ColorVariant = 2; _OpenPrice_FileWrite = true; }
	if ( Modify_New_OpenPrice < Modify_OrderOpenPrice ) { _OpenPrice_ColorVariant = 3; _OpenPrice_FileWrite = true; }
	int _StopLoss_ColorVariant = 0;
	bool _StopLoss_FileWrite = false;
	if ( Modify_New_StopLoss > Modify_OrderStopLoss ) { _StopLoss_ColorVariant = 2; _StopLoss_FileWrite = true; }
	if ( Modify_New_StopLoss < Modify_OrderStopLoss ) { _StopLoss_ColorVariant = 3; _StopLoss_FileWrite = true; }
	int _TakeProfit_ColorVariant = 0;
	bool _TakeProfit_FileWrite = false;
	if ( Modify_New_TakeProfit > Modify_OrderTakeProfit ) { _TakeProfit_ColorVariant = 2; _TakeProfit_FileWrite = true; }
	if ( Modify_New_TakeProfit < Modify_OrderTakeProfit ) { _TakeProfit_ColorVariant = 3; _TakeProfit_FileWrite = true; }

	_FileWrite ( " - - - - - - - - - - - - - - - - OrderModify Start - - - - - - - - - - - - - - - - - -" );
	_info ( 10, str_tmp + Modify_OrderTicket + ", " +  strOrderType( Modify_OrderType ) + "..." );
	_info ( 1, "Old Open Price = " + DoubleToStr( Modify_OrderOpenPrice, _Digits ), _OpenPrice_ColorVariant, _OpenPrice_FileWrite );
	_info ( 2, "Old Stop Loss = " + DoubleToStr( Modify_OrderStopLoss, _Digits ), _StopLoss_ColorVariant, _StopLoss_FileWrite );
	_info ( 3, "Old Take Profit = " + DoubleToStr( Modify_OrderTakeProfit, _Digits ), _TakeProfit_ColorVariant, _TakeProfit_FileWrite );
	_info ( 4, "" );

	_info ( 11, "New Open Price = " + DoubleToStr( Modify_New_OpenPrice, _Digits ), _OpenPrice_ColorVariant, _OpenPrice_FileWrite );
	_info ( 12, "New Stop Loss = " + DoubleToStr( Modify_New_StopLoss, _Digits ), _StopLoss_ColorVariant, _StopLoss_FileWrite );
	_info ( 13, "New Take Profit = " + DoubleToStr( Modify_New_TakeProfit, _Digits ), _TakeProfit_ColorVariant, _TakeProfit_FileWrite );
	_info ( 14, "" );

	if ( Modify_New_Expiration > 0 ) { _FileWrite ( "New Expiration Time = " + TimeToStr( Modify_New_Expiration, TIME_DATE | TIME_SECONDS ) ); }
}
int _OrderModify_Check ()
{
	if ( Allow_Info )	{ _info ( 14, stringCheck, 0, 0 ); }

//---- Åñëè íå÷åãî ìåíÿòü - âûõîäèì
	if ( 	NormalizeDouble( Modify_New_OpenPrice, _Digits ) == NormalizeDouble( Modify_OrderOpenPrice, _Digits ) &&
			NormalizeDouble( Modify_New_StopLoss, _Digits ) == NormalizeDouble( Modify_OrderStopLoss, _Digits ) &&
			NormalizeDouble( Modify_New_TakeProfit, _Digits ) == NormalizeDouble( Modify_OrderTakeProfit, _Digits ) &&
			Modify_New_Expiration == Modify_OrderExpiration )
	{
		if ( Allow_Info ) { _info ( 14, "Ïðîâåðÿåì ïàðàìåòðû.....Íåò íè îäíîãî ïàðàìåòðà äëÿ èçìåíåíèÿ. Ìîäèôèêàöèÿ îòìåíåíà..." ); }
		if ( Allow_LogFile ) { _FileWrite( "Íåò íè îäíîãî ïàðàìåòðà äëÿ èçìåíåíèÿ. Ìîäèôèêàöèÿ îòìåíåíà..." ); }
		_Return_ ( 2,  "Error", 0, "Íåò íè îäíîãî ïàðàìåòðà äëÿ èçìåíåíèÿ", "_OrderModify_Check()", "Íåò íè îäíîãî ïàðàìåòðà äëÿ èçìåíåíèÿ" );
		return(-1);
	}

//---- Ïðîâåðÿåì âñå ïàðàìåòðû OrderModify ( êðîìå _OrderTicket è _Color ),
//---- è åñëè åñòü îøèáêà - âûõîäèì
/*	if ( _OrderCheck( Modify_Symbol, Modify_OrderType, Modify_OrderLots, Modify_New_OpenPrice, Modify_New_StopLoss, Modify_New_TakeProfit, Modify_New_Expiration ) < 0 )
	{
		if ( Allow_Info )	{ _info ( 14, stringCheckError, 1, 0 ); }
		if ( Allow_LogFile ) { _FileWrite( "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!" ); }
		_Return_ ( 2,  "Error", 0, "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!", "_OrderModify_Check()", "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!" );
		return(-3);
	}
*/
	if ( Allow_Info ) { _info ( 14, stringCheckOK, 0, 0 ); }

return(1);
}
bool _OrderModify_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Modify_OrderTicket, SELECT_BY_TICKET ) )
	{
		Modify_GetLastError = GetLastError();
		_Return_ ( 2,  "Error", Modify_GetLastError, ErrorDescription( Modify_GetLastError ), "OrderSelect( " + Modify_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Modify_GetLastError + " ( " + ErrorDescription( Modify_GetLastError ) + " )" );
		return(false);
	}

	Modify_OrderLots			= NormalizeDouble ( OrderLots(), 2 );
	Modify_OrderOpenPrice	= NormalizeDouble ( OrderOpenPrice(), _Digits );
	Modify_OrderStopLoss		= NormalizeDouble ( OrderStopLoss(), _Digits );
	Modify_OrderTakeProfit	= NormalizeDouble ( OrderTakeProfit(), _Digits );
	Modify_OrderExpiration	= OrderExpiration();

	if ( Modify_New_OpenPrice  < 0 )	{ Modify_New_OpenPrice	= NormalizeDouble( Modify_OrderOpenPrice, _Digits ); }
	if ( Modify_New_StopLoss   < 0 )	{ Modify_New_StopLoss	= NormalizeDouble( Modify_OrderStopLoss, _Digits ); }
	if ( Modify_New_TakeProfit < 0 )	{ Modify_New_TakeProfit	= NormalizeDouble( Modify_OrderTakeProfit, _Digits ); }
	if ( Modify_New_Expiration < 0 )	{ Modify_New_Expiration	= Modify_OrderExpiration; }

return(true);
}
void _OrderModify_SetArrow ()
{
	if ( Modify_Color == CLR_NONE ) { return(0); }

	string arrow_description = Modify_OrderComment + "\nId " + Modify_OrderMagicNumber;
	string end_name;
	switch ( Modify_OrderType )
	{
		case OP_BUY:			end_name = " buy"; break;
		case OP_SELL:			end_name = " sell"; break;
		case OP_BUYLIMIT:		end_name = " buy limit"; break;
		case OP_SELLLIMIT:	end_name = " sell limit"; break;
		case OP_BUYSTOP:		end_name = " buy stop"; break;
		case OP_SELLSTOP:		end_name = " sell stop"; break;
	}
	end_name = end_name + " modified " + TimeToStr( CurTime() );
	
	string open_name = "#" + Modify_OrderTicket + end_name;
	string sl_name = "#" + Modify_OrderTicket + " sl modified ";
	string tp_name = "#" + Modify_OrderTicket + " tp modified ";

	if ( NormalizeDouble( Modify_New_OpenPrice, _Digits ) != NormalizeDouble( Modify_OrderOpenPrice, _Digits ) )
	{
		sl_name = sl_name + TimeToStr( CurTime() );
		tp_name = tp_name + TimeToStr( CurTime() );
	
		ObjectSetText( open_name, arrow_description, 10 );
	}
	if ( NormalizeDouble( Modify_New_StopLoss, _Digits ) != NormalizeDouble( Modify_OrderStopLoss, _Digits ) )
	{
		ObjectSetText( sl_name, arrow_description, 10 );
	}
	if ( NormalizeDouble( Modify_New_TakeProfit, _Digits ) != NormalizeDouble( Modify_OrderTakeProfit, _Digits ) )
	{
		ObjectSetText( tp_name, arrow_description, 10 );
	}
	GetLastError();
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderCheck ( string _Symbol, int _OrderType, double _Volume, double _OpenPrice, double _StopLoss, double _TakeProfit, datetime _Expiration )
/////////////////////////////////////////////////////////////////////////////////
// Ïðîâåðÿåò ðàññòîÿíèÿ OP,SL,TP, îáú¸ì è âðåìÿ èñòå÷åíèÿ äëÿ ô-öèé _OrderSend è _OrderModify.
// Ïðè óñïåøíîé ïðîâåðêå âîçâðàùàåò "1", ïðè îøèáêå âîçâðàùàåò "-1".
/////////////////////////////////////////////////////////////////////////////////
{
	int		_return				= 1;
	double	_Ask					= NormalizeDouble( MarketInfo( _Symbol, MODE_ASK ), _Digits );
	double	_Bid					= NormalizeDouble( MarketInfo( _Symbol, MODE_BID ), _Digits );
	
	string	_Ask_str				= DoubleToStr( _Ask, _Digits );
	string	_Bid_str				= DoubleToStr( _Bid, _Digits );
	string	_OpenPrice_str		= DoubleToStr( _OpenPrice, _Digits );
	string	_StopLoss_str		= DoubleToStr( _StopLoss, _Digits );
	string	_TakeProfit_str	= DoubleToStr( _TakeProfit, _Digits );
	string	_Expiration_str	= TimeToStr( _Expiration, TIME_DATE|TIME_SECONDS );

// _OrderType äîëæåí áûòü îò 0 äî 5
	if ( _OrderType < 0 || _OrderType > 5 )
	{
		_info ( 4, stringInvalidOrderType + " ( " + _OrderType + " )!!!", 1 );
		Send_GetLastError = 3;
		_return = -1;
	}

// Îáü¸ì äîëæåí áûòü >= 0.1
	if ( NormalizeDouble( MarketInfo( _Symbol, MODE_MINLOT ) - _Volume, 4 ) > 0.0 || NormalizeDouble( _Volume - MarketInfo( _Symbol, MODE_MAXLOT ), 4 ) > 0.0 )
	{
		_info ( 4, "Lot(s) = " + DoubleToStr( _Volume, 4 ) + stringInvalidVolume, 1 );
		Send_GetLastError = 131;
		_return = -1;
	}



// Ïðîâåðêè âñåõ "äëèííûõ" îðäåðîâ/ïîçèöèé
	if ( _OrderType == OP_BUY || _OrderType == OP_BUYLIMIT || _OrderType == OP_BUYSTOP )
	{
// - _StopLoss (åñëè åñòü) äîëæåí áûòü íèæå _OpenPrice
		if ( NormalizeDouble( _StopLoss, _Digits ) > 0 && NormalizeDouble( (_OpenPrice - _Spread) - _StopLoss, _Digits ) < NormalizeDouble( _StopLevel, _Digits )  )
		{
			if ( NormalizeDouble( _OpenPrice - _StopLoss, _Digits ) < 0 )
			{
				_info ( 2, "Stop Loss = " + _StopLoss_str + stringIncorrectAbove + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
// - - ìèíèìàëüíûé îòñòóï - _StopLevel
			else
			{
				_info ( 2, "Stop Loss = " + _StopLoss_str + stringIncorrectTooBeside + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
			Send_GetLastError = 130;
			_return = -1;
		}
// - _TakeProfit (åñëè åñòü) äîëæåí áûòü âûøå _OpenPrice
		if ( NormalizeDouble( _TakeProfit, _Digits ) > 0 && NormalizeDouble( _TakeProfit - (_OpenPrice - _Spread), _Digits ) < NormalizeDouble( _StopLevel, _Digits )  )
		{
			if ( NormalizeDouble( _TakeProfit - _OpenPrice, _Digits ) < 0 )
			{
				_info ( 3, "Take Profit = " + _TakeProfit_str + stringIncorrectBelow + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
// - - ìèíèìàëüíûé îòñòóï - _StopLevel
			else
			{
				_info ( 3, "Take Profit = " + _TakeProfit_str + stringIncorrectTooBeside + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
			Send_GetLastError = 130;
			_return = -1;
		}
	}

// Ïðîâåðêè âñåõ "êîðîòêèõ" îðäåðîâ/ïîçèöèé
	if ( _OrderType == OP_SELL || _OrderType == OP_SELLLIMIT || _OrderType == OP_SELLSTOP )
	{
// - _StopLoss (åñëè åñòü) äîëæåí áûòü âûøå _OpenPrice
		if ( NormalizeDouble( _StopLoss, _Digits ) > 0 && NormalizeDouble( _StopLoss - (_OpenPrice + _Spread), _Digits ) < NormalizeDouble( _StopLevel, _Digits )  )
		{
			if ( NormalizeDouble( _StopLoss - _OpenPrice, _Digits ) < 0 )
			{
				_info ( 2, "Stop Loss = " + _StopLoss_str + stringIncorrectBelow + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
// - - ìèíèìàëüíûé îòñòóï - _StopLevel
			else
			{
				_info ( 2, "Stop Loss = " + _StopLoss_str + stringIncorrectTooBeside + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
			Send_GetLastError = 130;
			_return = -1;
		}
// - _TakeProfit (åñëè åñòü) äîëæåí áûòü íèæå _OpenPrice
		if ( NormalizeDouble( _TakeProfit, _Digits ) > 0 && NormalizeDouble( (_OpenPrice + _Spread) - _TakeProfit, _Digits ) < NormalizeDouble( _StopLevel, _Digits )  )
		{
			if ( NormalizeDouble( _OpenPrice - _TakeProfit, _Digits ) < 0 )
			{
				_info ( 3, "Take Profit = " + _TakeProfit_str + stringIncorrectAbove + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
// - - ìèíèìàëüíûé îòñòóï - _StopLevel
			else
			{
				_info ( 3, "Take Profit = " + _TakeProfit_str + stringIncorrectTooBeside + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
			Send_GetLastError = 130;
			_return = -1;
		}
	}

// - Âðåìÿ èñòå÷åíèÿ
// - - Ìàðêåò-îðäåðà - âðåìÿ èñòå÷åíèÿ äîëæíî áûòü = 0
	if ( _OrderType <= OP_SELL )
	{
		if ( _Expiration != 0 )
		{
			_info ( 4, "Expiration Time = " + _Expiration_str + stringInvalidExpiration, 1 );
			Send_GetLastError = 3;
			_return = -1;
		}
	}
// - - Îòëîæåííûå îðäåðà - âðåìÿ èñòå÷åíèÿ (åñëè åñòü) äîëæíî áûòü > òåêóùåãî ñåðâåðíîãî âðåìåíè
	else
	{
		if ( _Expiration > 0 && _Expiration <= CurTime() )
		{
			_info ( 4, "Expiration Time = " + _Expiration_str + stringIncorrectExpiration, 1 );
			Send_GetLastError = 3;
			_return = -1;
		}
	}

// åñëè åñòü õîòü îäíà îøèáêà, âîçâðàùàåì -1
// åñëè âñå ïðîâåðêè ïðîøëè óñïåøíî, âîçâðàùàåì 1
return(_return);
}

string	Close_OrderSymbol = "", Close_ProfitLoss = "", Close_OrderComment = "";
int		Close_OrderTicket = 0, Close_OrderType = 0, Close_OrderMagicNumber = 0, Close_Slippage = 0, Close_StartTickCount = 0, Close_GetLastError = 0;
double	Close_Volume = 0.0, Close_OrderLots = 0.0, Close_OrderOpenPrice = 0.0, Close_ClosePrice = 0.0;
color		Close_Color = CLR_NONE;
bool		Close_Result = false;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderClose ( int _OrderTicket, double _Volume = 0.0, double ClosePrice = 0.0, int _Slippage = -1, color _Color = -2 )
/////////////////////////////////////////////////////////////////////////////////
// Ñòàíäàðòíàÿ ô-öèÿ OrderClose + ïðîâåðêè.
//
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò "1", ïðè îøèáêå çàêðûòèÿ âîçâðàùàåò "-1",
// ïðè îøèáêå âûáîðà îðäåðà âîçâðàùàåò "-2", ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-3".
// Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-4".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Close_OrderSymbol = ""; Close_ProfitLoss = ""; Close_OrderComment = "";
	Close_OrderTicket = _OrderTicket; Close_OrderType = 0; Close_OrderMagicNumber = 0; Close_Slippage = _Slippage; Close_StartTickCount = GetTickCount();
	Close_Volume = _Volume; Close_OrderLots = 0.0; Close_OrderOpenPrice = 0.0; Close_ClosePrice = ClosePrice;
	Close_Color = _Color;
	Close_Result = false;
	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _OrderClose_SetValue() == false ) { return(-2); }

//---- Âûâîäèì èíôîðìàöèþ
	_OrderClose_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _OrderClose_Check() == false ) { return(-3); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(3);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Close_StartTickCount > 1000 )
	{
		if ( _OrderClose_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		if ( _OrderClose_Check() == false ) { TradeIsNotBusy(); return(-3); }
	}

//---- Ñîáñòâåííî, çàêðûâàåìñÿ
	Close_Result = OrderClose( Close_OrderTicket, Close_Volume, Close_ClosePrice, Close_Slippage, Close_Color );
	Close_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Close_Result || Close_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Close_GetLastError, "OrderClose" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 3, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderClose(...)", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}

//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè çàêðûëàñü ïîçèöèÿ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -5
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
		{
			if ( OrderCloseTime() <= 0 )
			{
				Processing_Error ( 0, "OrderClose" );
				_Return_ ( 3, "Error", 0, "Ïîçèöèÿ íå áûëà çàêðûòà", "OrderClose(...)", "Ïîçèöèÿ íå áûëà çàêðûòà" );
				return(-5);
			}
			else
			{ break; }
		}
		Close_GetLastError = GetLastError();
		_Print_ ( 3, "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderClose_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 3, "OK", 0, "", "OrderClose(...)", "OK" );

//---- è âûõîäèì, âîçâðàùàÿ 1.
return(1);
}

bool _OrderClose_SetValue ()
{
//---- Ïðîâåðÿåì _Slippage
	if ( Close_Slippage < 0 ) { Close_Slippage = Slippage; }

//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
	{
		Close_GetLastError = GetLastError();
		_Return_ ( 3, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
		return(false);
	}

	Close_OrderSymbol			= OrderSymbol();
	Close_OrderType			= OrderType();
	Close_ProfitLoss			= DoubleToStr( OrderProfit() + OrderSwap() + OrderCommission(), 2 );
	Close_OrderComment		= OrderComment();
	Close_OrderMagicNumber	= OrderMagicNumber();

Close_OrderOpenPrice = OrderOpenPrice();
//---- Ïðîâåðÿåì Close_Volume - åñëè áîëüøå OrderLots èëè ìåíüøå 0.1, ñòàâèì OrderLots.
	Close_OrderLots = NormalizeDouble( OrderLots(), _Digits );
	if ( NormalizeDouble( Close_Volume, 2 ) > NormalizeDouble( Close_OrderLots, 2 ) || NormalizeDouble( Close_Volume, 2 ) < NormalizeDouble( MarketInfo( _Symbol, MODE_MINLOT ), 2 ) )
	{ Close_Volume = NormalizeDouble( Close_OrderLots, 2 ); }

//---- Âûñòàâëÿåì Close_ClosePrice
	if ( Close_OrderType == OP_SELL ) { Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_ASK ), _Digits ); }
	if ( Close_OrderType == OP_BUY ) { Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_BID ), _Digits ); }

//---- Íîðìàëèçóåì ïåðåìåííûå
	Close_Volume = NormalizeDouble( Close_Volume, 2 );

//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Close_Color < -1 )
	{
		Close_Color = OrderSellColor;
		if ( Close_OrderType == OP_BUY || Close_OrderType == OP_BUYLIMIT || Close_OrderType == OP_BUYSTOP )
		{ Close_Color = OrderBuyColor; }
	}
	else
	{
		if ( Close_Color < 0 ) Close_Color = CLR_NONE;
	}
	return(true);
}
void _OrderClose_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }
	int _OrderType_ColorVariant = 3;
	if ( Close_OrderType == OP_BUY || Close_OrderType == OP_BUYLIMIT || Close_OrderType == OP_BUYSTOP ) { _OrderType_ColorVariant = 2; }

	_FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Start - - - - - - - - - - - - - - - - - -" );
	_info ( 10, "Çàêðûâàåì ïîçèöèþ ¹ " + Close_OrderTicket + ", " + strOrderType ( Close_OrderType ) + "...", _OrderType_ColorVariant );
	_info ( 1, "Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
	_info ( 2, "Lot(s) = " + DoubleToStr( Close_Volume, 2 ) );
	_info ( 3, "Profit/Loss = " + Close_ProfitLoss );
	_info ( 4, "" );

	_info ( 11, "Comment = " + Close_OrderComment, 0, 0 );
	_info ( 12, "MagicNumber = " + Close_OrderMagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
}
bool _OrderClose_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

	if ( Close_OrderType > OP_SELL )
	{
		if ( Allow_Info || Allow_LogFile )
		{
			_info ( 13, stringCheckError, 1, 0 );
			_info ( 4, "Îøèáî÷íûé OrderType() - " + Close_OrderType + ". Çàêðûòà ìîæåò áûòü òîëüêî OP_BUY èëè OP_SELL ïîçèöèÿ.", 1 );
		}
		_Return_ ( 3, "Error", 0, "Îøèáî÷íûé OrderType()", "_OrderClose_Check()", "Îøèáî÷íûé OrderType()" );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }
return(true);
}
bool _OrderClose_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
	{
		Close_GetLastError = GetLastError();
		_Return_ ( 3, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
		return(false);
	}

	bool refreshed = false;
	Close_OrderType = OrderType();
	Close_OrderLots = NormalizeDouble( OrderLots(), _Digits );

//---- Îáíîâëÿåì Close_ClosePrice
	if ( Close_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Close_ClosePrice, _Digits ) != NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_ASK ), _Digits ) )
		{
			Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_ASK ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Refresh - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
			}
		}
	}
	if ( Close_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Close_ClosePrice, _Digits ) != NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_BID ), _Digits ) )
		{
			Close_ClosePrice = NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_BID ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Refresh - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
			}
		}
	}

//---- Ïðîâåðÿåì Close_Volume - åñëè áîëüøå OrderLots èëè ìåíüøå 0.1, ñòàâèì OrderLots.
	if ( NormalizeDouble( Close_Volume, 2 ) > NormalizeDouble( Close_OrderLots, 2 ) || NormalizeDouble( Close_Volume, 2 ) < NormalizeDouble( MarketInfo( _Symbol, MODE_MINLOT ), 2 ) )
	{
		Close_Volume = NormalizeDouble( Close_OrderLots, 2 );
		if ( Allow_Info || Allow_LogFile )
		{
			if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Refresh - - - - - - - - - - - - - - - - -" ); refreshed = true; }
			_info ( 2, "Refreshed Lot(s) = " + DoubleToStr( Close_Volume, 2 ) );
		}
	}
return(true);
}
void _OrderClose_SetArrow ()
{
	if ( Close_Color == CLR_NONE ) { return(0); }
	string arrow_description = Close_OrderComment + "\nId " + Close_OrderMagicNumber;
	string end_name;
	switch ( Close_OrderType )
	{
		case OP_BUY:	end_name = " buy "; break;
		case OP_SELL:	end_name = " sell "; break;
	}
	string close_name = "#" + Close_OrderTicket + end_name + DoubleToStr( Close_Volume, 2 ) + " " + Close_OrderSymbol + " at " + DoubleToStr( Close_OrderOpenPrice, _Digits ) + " close at " + DoubleToStr( Close_ClosePrice, _Digits );

	ObjectSetText( close_name, arrow_description, 10 );
	GetLastError();
}

string	Delete_OrderComment = "";
int		Delete_OrderTicket = 0, Delete_OrderType = 0, Delete_OrderMagicNumber = 0, Delete_StartTickCount = 0, Delete_GetLastError = 0;
bool		Delete_Result = false;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderDelete ( int _OrderTicket )
/////////////////////////////////////////////////////////////////////////////////
// Ñòàíäàðòíàÿ ô-öèÿ OrderDelete + ïðîâåðêè.
//
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò "1", ïðè îøèáêå óäàëåíèÿ âîçâðàùàåò "-1",
// ïðè îøèáêå âûáîðà îðäåðà âîçâðàùàåò "-2", ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-3".
// Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-4".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Delete_OrderComment = "";
	Delete_OrderTicket = _OrderTicket; Delete_OrderType = 0; Delete_OrderMagicNumber = 0; Delete_StartTickCount = GetTickCount();
	Delete_Result = false;
	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _OrderDelete_SetValue() == false ) { return(-2); }

//---- Âûâîäèì èíôîðìàöèþ
	_OrderDelete_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _OrderDelete_Check() == false ) { return(-3); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(3);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Delete_StartTickCount > 1000 )
	{
		if ( _OrderDelete_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		if ( _OrderDelete_Check() == false ) { TradeIsNotBusy(); return(-3); }
	}

//---- Ñîáñòâåííî, óäàëÿåì
	Delete_Result = OrderDelete( Delete_OrderTicket );
	Delete_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Delete_Result || Delete_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Delete_GetLastError, "OrderDelete" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 4, "Error", Delete_GetLastError, ErrorDescription( Delete_GetLastError ), "OrderDelete(...)", "Error #" + Delete_GetLastError + " ( " + ErrorDescription( Delete_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}

//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè óäàë¸í îðäåð è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -5
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		int _OrdersTotal = OrdersTotal();
		for ( int z = _OrdersTotal - 1; z >= 0; z -- )
		{
			if ( OrderSelect( z, SELECT_BY_POS ) )
			{
				if ( OrderTicket() == Delete_OrderTicket )
				{
					Processing_Error ( 0, "OrderDelete" );
					_Return_ ( 4, "Error", 0, "Îðäåð íå áûë óäàë¸í", "OrderDelete(...)", "Îðäåð íå áûë óäàë¸í" );
					return(-5);
				}
				if ( z == 0 ) { x = 5; break; }
			}
			else
			{
				Delete_GetLastError = GetLastError();
				_Print_ ( 4, "OrderSelect( " + z + ", SELECT_BY_POS )", "Error #" + Delete_GetLastError + " ( " + ErrorDescription( Delete_GetLastError ) + " )" );
			}
		}
	}

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 4, "OK", 0, "", "OrderDelete(...)", "OK" );
//---- è âûõîäèì, âîçâðàùàÿ 1.
return(1);
}

bool _OrderDelete_SetValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Delete_OrderTicket, SELECT_BY_TICKET ) )
	{
		Delete_GetLastError = GetLastError();
		_Print_ ( 4, "OrderSelect( " + Delete_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Delete_GetLastError + " ( " + ErrorDescription( Delete_GetLastError ) + " )" );
		return(false);
	}

	Delete_OrderType			= OrderType();
	Delete_OrderComment		= OrderComment();
	Delete_OrderMagicNumber	= OrderMagicNumber();

return(true);
}
void _OrderDelete_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }
	int _OrderType_ColorVariant = 3;
	if ( Delete_OrderType == OP_BUY || Delete_OrderType == OP_BUYLIMIT || Delete_OrderType == OP_BUYSTOP ) { _OrderType_ColorVariant = 2; }

	_FileWrite ( " - - - - - - - - - - - - - - - - OrderDelete Start - - - - - - - - - - - - - - - - - -" );
	_info ( 10, "Óäàëÿåì îðäåð ¹ " + Delete_OrderTicket + ", " + strOrderType ( Delete_OrderType ) + "...", _OrderType_ColorVariant );
	_info ( 1, "" );
	_info ( 2, "" );
	_info ( 3, "" );
	_info ( 4, "" );

	_info ( 11, "Comment = " + Delete_OrderComment, 0, 0 );
	_info ( 12, "MagicNumber = " + Delete_OrderMagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
}
bool _OrderDelete_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

//---- Ïðîâåðÿåì _OrderType
	if ( Delete_OrderType <= OP_SELL )
	{
		if ( Allow_Info || Allow_LogFile )
		{
			_info ( 13, stringCheckError, 1, 0 );
			_info ( 14, "Îøèáî÷íûé OrderType() - " + Delete_OrderType + ". Óäàë¸í ìîæåò áûòü òîëüêî îòëîæåííûé îðäåð.", 1 );
		}
		_Return_ ( 4, "Error", 0, "Îøèáî÷íûé OrderType", "_OrderDelete_Check()", "Îøèáî÷íûé OrderType" );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }

return(true);
}
bool _OrderDelete_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Delete_OrderTicket, SELECT_BY_TICKET ) )
	{
		Delete_GetLastError = GetLastError();
		_Print_ ( 4, "OrderSelect( " + Delete_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Delete_GetLastError + " ( " + ErrorDescription( Delete_GetLastError ) + " )" );
		return(false);
	}

	Delete_OrderType = OrderType();
return(true);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _Reverse ( int _OrderTicket, int _Slippage = -1, color _CloseColor = CLR_NONE, color _SendColor = CLR_NONE )
/////////////////////////////////////////////////////////////////////////////////
// Ïåðåâîðîò. Ïîçèöèÿ ñ _OrderTicket çàêðûâàåòñÿ è îòêðûâàåòñÿ íîâàÿ ñ òàêèì æå ëîòîì íàâñòðå÷ó + ïðîâåðêè.
//
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò "1", ïðè òîðãîâîé îøèáêå âîçâðàùàåò "-1",
// ïðè îøèáêå âûáîðà îðäåðà âîçâðàùàåò "-2", ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-3".
// Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-4".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Close_OrderSymbol = ""; Close_ProfitLoss = ""; Close_OrderComment = "";
	Close_OrderTicket = _OrderTicket; Close_OrderType = 0; Close_OrderMagicNumber = 0; Close_Slippage = _Slippage; Close_StartTickCount = GetTickCount();
	Close_Volume = 0.0; Close_OrderLots = 0.0; Close_ClosePrice = 0.0;
	Close_Color = _CloseColor;
	Close_Result = false;

	Send_Symbol = ""; Send_Comment = "";
	Send_OrderType = 0; Send_Slippage = _Slippage; Send_MagicNumber = 0;
	Send_Volume = 0.0; Send_OpenPrice = 0.0; Send_StopLoss = 0.0; Send_TakeProfit = 0.0;
	Send_Expiration = 0;
	Send_Color = _SendColor;
	Send_Result = -1;

	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _Reverse_SetValue() == false ) { return(-2); }

//---- Âûâîäèì èíôîðìàöèþ
	_Reverse_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _Reverse_Check() == false ) { return(-3); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(5);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Close_StartTickCount > 1000 )
	{
		if ( _Reverse_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		if ( _Reverse_Check() == false ) { TradeIsNotBusy(); return(-3); }
	}

//---- Ñîáñòâåííî, çàêðûâàåìñÿ
	Close_Result = OrderClose( Close_OrderTicket, Close_Volume, Close_ClosePrice, Close_Slippage, Close_Color );
	Close_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Close_Result || Close_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Close_GetLastError, "Reverse" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 5, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "Reverse(...)", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè çàêðûëàñü ïîçèöèÿ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -5
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
		{
			if ( OrderCloseTime() <= 0 )
			{
				Processing_Error ( 0, "OrderClose" );
				_Return_ ( 5, "Error", 0, "Ïîçèöèÿ íå áûëà çàêðûòà", "Reverse(...)", "Ïîçèöèÿ íå áûëà çàêðûòà" );
				return(-5);
			}
			else
			{ break; }
		}
		Close_GetLastError = GetLastError();
		_Print_ ( 5, "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderClose_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_Return_ ( 5, "OK", 0, "", "OrderClose(...)", "OK" );

//---- è îòêðûâàåìñÿ íàâñòðå÷ó
	Send_Result = OrderSend ( Send_Symbol, Send_OrderType, Send_Volume, Send_OpenPrice, Send_Slippage, Send_StopLoss, Send_TakeProfit, Send_Comment, Send_MagicNumber, Send_Expiration, Send_Color );
	Send_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( Send_Result < 0 || Send_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Send_GetLastError, "Reverse" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê,
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 5, "Error", Send_GetLastError, ErrorDescription( Send_GetLastError ), "Revers(...)", "Error #" + Send_GetLastError + " ( " + ErrorDescription( Send_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê,
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè îòêðûëàñü ïîçèöèÿ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -4.
	int _GetLastError;
	for ( x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( OrderSelect( Send_Result, SELECT_BY_TICKET ) ) { break; }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 ) { _Print_ ( 6, "OrderSelect( " + Send_Result + ", SELECT_BY_TICKET )", "Error #" + _GetLastError + " ( " + ErrorDescription( _GetLastError ) + " )" ); continue; }
		Processing_Error ( 0, "Reverse" );
		_Return_ ( 6, "Error", 0, "Îðäåð íå áûë óñòàíîâëåí/Ïîçèöèÿ íå áûëà îòêðûòà", "Reverse(...)", "Îðäåð íå áûë óñòàíîâëåí/Ïîçèöèÿ íå áûëà îòêðûòà" );
		return(-4);
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderSend_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 6, "OK", 0, "", "OrderSend(...)", "OK. Ticket " + Send_Result );
//---- è âûõîäèì, âîçâðàùàÿ ¹ òèêåòà.
return(Send_Result);
}

bool _Reverse_SetValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
	{
		Close_GetLastError = GetLastError();
		_Return_ ( 5, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
		return(false);
	}
	Close_OrderSymbol			= OrderSymbol();
	Close_OrderType			= OrderType();
	Close_Volume				= NormalizeDouble( OrderLots(), _Digits );
	Close_ProfitLoss			= DoubleToStr( OrderProfit() + OrderSwap() + OrderCommission(), 2 );
	Close_OrderComment		= OrderComment();
	Close_OrderMagicNumber	= OrderMagicNumber();

//---- Âûñòàâëÿåì Close_ClosePrice
	if ( Close_OrderType == OP_SELL ) { Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_ASK ), _Digits ); }
	if ( Close_OrderType == OP_BUY ) { Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_BID ), _Digits ); }

	Send_Symbol			= Close_OrderSymbol;
	Send_Comment		= Close_OrderComment;
	Send_MagicNumber	= Close_OrderMagicNumber;
	Send_Volume			= Close_Volume;
	Send_StopLoss		= 0.0;
	Send_TakeProfit	= 0.0;
	Send_Expiration	= 0;

	if ( Close_OrderType == OP_BUY ) { Send_OrderType = OP_SELL; }
	if ( Close_OrderType == OP_SELL ) { Send_OrderType = OP_BUY; }

//---- Âûñòàâëÿåì öåíó îòêðûòèÿ è óäàëÿåì âðåìÿ èñòå÷åíèÿ äëÿ BUY è SELL ïîçèöèé
	if ( Send_OrderType == OP_BUY ) { Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits ); }
	if ( Send_OrderType == OP_SELL ) { Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits ); }


//---- Ïðîâåðÿåì _Slippage
	if ( Send_Slippage < 0 ) { Send_Slippage = Slippage; }
	if ( Close_Slippage < 0 ) { Close_Slippage = Slippage; }
//---- Åñëè _Comment íå çàäàâàëñÿ, íàïèøåì "Èìÿ_Ýêñïåðòà( Ñèìâîë, Òàéìôðåéì )"
	if ( Send_Comment == "" ) { Send_Comment = strComment; }
//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Send_Color < -1 )
	{
		Send_Color = OrderSellColor;
		if ( Send_OrderType == OP_BUY || Send_OrderType == OP_BUYLIMIT || Send_OrderType == OP_BUYSTOP )
		{ Send_Color = OrderBuyColor; }
	}
	else
	{
		if ( Send_Color < 0 ) Send_Color = CLR_NONE;
	}
	if ( Close_Color < -1 )
	{
		Close_Color = OrderSellColor;
		if ( Close_OrderType == OP_BUY || Close_OrderType == OP_BUYLIMIT || Close_OrderType == OP_BUYSTOP )
		{ Close_Color = OrderBuyColor; }
	}
	else
	{
		if ( Close_Color < 0 ) Close_Color = CLR_NONE;
	}
	return(true);
}
void _Reverse_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }

	_FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Start  - - - - - - - - - - - - - - - - - -" );
	_info ( 10, "Ïåðåâîðîò ïîçèöèè ¹ " + Close_OrderTicket + ", " + strOrderType ( Close_OrderType ) + "..." );
	_info ( 1, "Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
	_info ( 2, "Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
	_info ( 3, "Lot(s) = " + DoubleToStr( Close_Volume, 1 ) );
	_info ( 4, "" );

	_info ( 11, "Comment = " + Close_OrderComment, 0, 0 );
	_info ( 12, "MagicNumber = " + Close_OrderMagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
}

bool _Reverse_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

//---- Ïðîâåðÿåì _OrderType
	if ( Close_OrderType > OP_SELL )
	{
		if ( Allow_Info || Allow_LogFile )
		{
			_info ( 13, stringCheckError, 1, 0 );
			_info ( 4, "Îøèáî÷íûé OrderType() - " + Close_OrderType + ". Çàêðûòà ìîæåò áûòü òîëüêî OP_BUY èëè OP_SELL ïîçèöèÿ.", 1 );
		}
		_Return_ ( 5, "Error", 0, "Îøèáî÷íûé OrderType()", "_Reverse_Check()", "Îøèáî÷íûé OrderType()" );
		return(false);
	}

//---- Ïðîâåðÿåì âñå ïàðàìåòðû OrderSend ( êðîìå Send_Symbol, _Slippage, _Comment, Send_MagicNumber è Send_Color ),
//---- è åñëè åñòü îøèáêà - âûõîäèì
	if ( _OrderCheck( Send_Symbol, Send_OrderType, Send_Volume, Send_OpenPrice, Send_StopLoss, Send_TakeProfit, Send_Expiration ) < 0 )
	{
		if ( Allow_Info )	{ _info ( 13, stringCheckError, 1, 0 ); }
		if ( Allow_LogFile ) { _FileWrite( "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!" ); }
		_Return_ ( 6, "Error", 0, stringInvalidParameters, "_Reverse_Check()", "Error" );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }
return(true);
}
bool _Reverse_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
	{
		Close_GetLastError = GetLastError();
		_Return_ ( 5, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
		return(false);
	}

	bool refreshed = false;
	Close_OrderType = OrderType();
	Close_Volume	 = NormalizeDouble( OrderLots(), _Digits );

//---- Îáíîâëÿåì Close_ClosePrice
	if ( Close_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Close_ClosePrice, _Digits ) != NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_ASK ), _Digits ) )
		{
			Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_ASK ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
			}
		}
	}
	if ( Close_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Close_ClosePrice, _Digits ) != NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_BID ), _Digits ) )
		{
			Close_ClosePrice = NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_BID ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
			}
		}
	}

	Send_Volume = NormalizeDouble( Close_Volume, 2 );
	if ( Close_OrderType == OP_BUY ) { Send_OrderType = OP_SELL; }
	if ( Close_OrderType == OP_SELL ) { Send_OrderType = OP_BUY; }

//---- Îáíîâëÿåì öåíó îòêðûòèÿ äëÿ BUY è SELL ïîçèöèé
	if ( Send_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Send_OpenPrice, _Digits ) != NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits ) )
		{
			Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 2, "Refreshed Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
			}
		}
	}
	if ( Send_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Send_OpenPrice, _Digits ) != NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits ) )
		{
			Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 2, "Refreshed Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
			}
		}
	}
return(true);
}

string	Trailing_Symbol = "", Trailing_OrderComment = "";
int		Trailing_OrderTicket = 0, Trailing_TrailingStop = 0, Trailing_BreakEven_After = 0, Trailing_OrderType = 0, Trailing_OrderMagicNumber = 0, Trailing_StartTickCount = 0, Trailing_GetLastError = 0;
double	Trailing_OrderOpenPrice = 0.0, Trailing_OrderStopLoss = 0.0, Trailing_OrderTakeProfit = 0.0, Trailing_New_StopLoss = 0.0, Trailing_Bid = 0.0, Trailing_Ask = 0.0;
datetime	Trailing_OrderExpiration = 0;
color		Trailing_Color = CLR_NONE;
bool		Trailing_Result = false;

double Trailing_Luft = 0.0;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _TrailingStop ( int _OrderTicket, int TrailingStop, color _Color = -2, int BreakEven_After = 0, int LuftPoints = -1 )
/////////////////////////////////////////////////////////////////////////////////
// TrailingStop + âûâîä èíôîðìàöèè
// Ïðè óñïåøíîì ñìåù¸íèè âîçâðàùàåò "1", ïðè îòñòóòñòâèè íåîáõîäèìîñòè äâèãàòü - "0", ïðè îøèáêå "-1", ïðè îøèáêå ¹ îðäåðà, âîçâðàùàåò "-2"
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Trailing_Symbol = ""; Trailing_OrderComment = "";
	Trailing_OrderTicket = _OrderTicket; Trailing_TrailingStop = TrailingStop; Trailing_BreakEven_After = BreakEven_After; Trailing_OrderType = 0; Trailing_OrderMagicNumber = 0; Trailing_StartTickCount = GetTickCount();
	Trailing_OrderOpenPrice = 0.0; Trailing_OrderStopLoss = 0.0; Trailing_OrderTakeProfit = 0.0; Trailing_New_StopLoss = 0.0; Trailing_Bid = 0.0; Trailing_Ask = 0.0;
	Trailing_OrderExpiration = 0;
	Trailing_Color = _Color;
	Trailing_Result = false;
	StartTime = TimeLocal();

	if ( Trailing_TrailingStop <= 0 ) { return(0); }

	if ( LuftPoints < 0 ) { Trailing_Luft = _Spread; } else { Trailing_Luft = LuftPoints * _Point; }

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _TrailingStop_SetValue() == false ) { return(-2); }

//---- Åñëè ïîçèöèÿ íå ïðèáûëüíàÿ, èëè ñòîïëîññ íå äîñòàòî÷íî äàëåêî îò öåíû äëÿ èçìåíåíèÿ, âûõîäèì
	if ( _TrailingStop_NoChange() == false ) { return(0); }

//---- Âûâîäèì èíôîðìàöèþ
	_TrailingStop_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _TrailingStop_Check() == false ) { return(-1); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(7);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Trailing_StartTickCount > 1000 )
	{
		if ( _TrailingStop_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		if ( _TrailingStop_Check() == false ) { TradeIsNotBusy(); return(-1); }
	}

//---- Ñîáñòâåííî, äâèãàåì
	Trailing_Result = OrderModify( Trailing_OrderTicket, Trailing_OrderOpenPrice, Trailing_New_StopLoss, Trailing_OrderTakeProfit, Trailing_OrderExpiration, Trailing_Color );
	Trailing_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Trailing_Result || Trailing_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Trailing_GetLastError, "TrailingStop" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 7, "Error", Trailing_GetLastError, ErrorDescription( Trailing_GetLastError ), "OrderModify(...)", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè èçìåíèëñÿ ñòîïëîññ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -4.
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( !OrderSelect( Trailing_OrderTicket, SELECT_BY_TICKET ) )
		{
			Trailing_GetLastError = GetLastError();
			_Print_ ( 7, "OrderSelect( " + Trailing_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
			continue;
		}
		if ( NormalizeDouble( Trailing_OrderStopLoss, _Digits ) != NormalizeDouble( OrderStopLoss(), _Digits ) )
		{ break; }
		else
		{
			Processing_Error ( 0, "TrailingStop" );
			_Return_ ( 7, "Error", 0, "Ñòîïëîññ íå áûë ìîäèôèöèðîâàí", "OrderModify(...)", "Ñòîïëîññ íå áûë ìîäèôèöèðîâàí" );
			return(-4);
		}
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_TrailingStop_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 7, "OK", 0, "", "OrderModify(...)", "OK" );

//---- è âûõîäèì, âîçâðàùàÿ 1.
return(1);
}

bool _TrailingStop_SetValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Trailing_OrderTicket, SELECT_BY_TICKET ) )
	{
		Trailing_GetLastError = GetLastError();
		_Return_ ( 7,  "Error", Trailing_GetLastError, ErrorDescription( Trailing_GetLastError ), "OrderSelect( " + Trailing_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
		return(false);
	}

	Trailing_Symbol				= OrderSymbol();
	Trailing_OrderComment		= OrderComment();
	Trailing_OrderType			= OrderType();
	Trailing_OrderMagicNumber	= OrderMagicNumber();
	Trailing_OrderOpenPrice		= NormalizeDouble ( OrderOpenPrice(), _Digits );
	Trailing_OrderStopLoss		= NormalizeDouble ( OrderStopLoss(), _Digits );
	Trailing_OrderTakeProfit	= NormalizeDouble ( OrderTakeProfit(), _Digits );
	Trailing_OrderExpiration	= OrderExpiration();

	Trailing_Bid					= NormalizeDouble( MarketInfo ( Trailing_Symbol, MODE_BID ), _Digits );
	Trailing_Ask					= NormalizeDouble( MarketInfo ( Trailing_Symbol, MODE_ASK ), _Digits );

//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Trailing_Color < -1 )
	{
		Trailing_Color = OrderSellColor;
		if ( Trailing_OrderType == OP_BUY || Trailing_OrderType == OP_BUYLIMIT || Trailing_OrderType == OP_BUYSTOP )
		{ Trailing_Color = OrderBuyColor; }
	}
	else
	{
		if ( Trailing_Color < 0 ) Trailing_Color = CLR_NONE;
	}

//---- Ñ÷èòàåì êóäà óñòàíàâëèâàòü íîâûé ñòîïëîññ
	if ( Trailing_OrderType == OP_BUY ) { Trailing_New_StopLoss = NormalizeDouble( Trailing_Bid - Trailing_TrailingStop * _Point, _Digits ); }
	if ( Trailing_OrderType == OP_SELL ) { Trailing_New_StopLoss = NormalizeDouble( Trailing_Ask + Trailing_TrailingStop * _Point, _Digits ); }

return(true);
}
bool _TrailingStop_NoChange ()
{
	if ( Trailing_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Trailing_Bid - Trailing_OrderOpenPrice, _Digits ) <= NormalizeDouble( Trailing_BreakEven_After * _Point, _Digits ) ) { return(false); }
		if ( NormalizeDouble( Trailing_OrderStopLoss, _Digits ) > 0 && NormalizeDouble( Trailing_New_StopLoss - Trailing_OrderStopLoss, _Digits ) <= NormalizeDouble( Trailing_Luft, _Digits ) ) { return(false); }
	}
	if ( Trailing_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Trailing_OrderOpenPrice - Trailing_Ask, _Digits ) <= NormalizeDouble( Trailing_BreakEven_After * _Point, _Digits ) ) { return(false); }
		if ( NormalizeDouble( Trailing_OrderStopLoss, _Digits ) > 0 && NormalizeDouble( Trailing_OrderStopLoss - Trailing_New_StopLoss, _Digits ) <= NormalizeDouble( Trailing_Luft, _Digits ) ) { return(false); }
	}
return(true);
}
void _TrailingStop_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }

	_FileWrite ( "- - - - - - - - - - - - - - - - TrailingStop Start - - - - - - - - - - - - - - - - - -" );

	_info ( 10, "Trailing Stop (" + Trailing_TrailingStop + " points) äëÿ ïîçèöèè ¹ " + Trailing_OrderTicket + ", " + strOrderType ( Trailing_OrderType ) + "..." );
	_info ( 1, "Old Stop Loss = " + DoubleToStr( Trailing_OrderStopLoss, _Digits ) );
	_info ( 2, "New Stop Loss = " + DoubleToStr( Trailing_New_StopLoss, _Digits ) );
	_info ( 3, "" );
	_info ( 4, "" );

	_info ( 11, "Comment = " + Trailing_OrderComment, 0, 0 );
	_info ( 12, "MagicNumber = " + Trailing_OrderMagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
}
bool _TrailingStop_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

//---- Åñëè TrailingStop õî÷åò óñòàíîâèòü ÑË íà ðàññòîÿíèå, ìåíüøåå ìèíèìàëüíî âîçìîæíîãî, âûõîäèì.
	if ( Trailing_TrailingStop < MarketInfo( Trailing_Symbol, MODE_STOPLEVEL ) )
	{
		if ( Allow_Info ) { _info ( 13, "Ïðîâåðÿåì ïàðàìåòðû.....Íåëüçÿ óñòàíîâèòü ÑòîïËîññ òàê áëèçêî!", 1, 0 ); }
		if ( Allow_LogFile ) { _FileWrite( "Íåëüçÿ óñòàíîâèòü ÑòîïËîññ òàê áëèçêî! TrailingStop îòìåíåí..." ); }
		_Return_ ( 7, "Error", 0, "Íåëüçÿ óñòàíîâèòü ÑòîïËîññ òàê áëèçêî", "_TrailingStop_Check()", "Íåëüçÿ óñòàíîâèòü ÑòîïËîññ òàê áëèçêî" );
		return(false);
	}

	if ( Trailing_OrderType > OP_SELL )
	{
		if ( Allow_Info || Allow_LogFile )
		{
			_info ( 13, stringCheckError, 1, 0 );
			_info ( 14, "Îøèáî÷íûé OrderType() - " + Trailing_OrderType + ". Ô-öèÿ TrailingStop ïðåäíàçíà÷åíà òîëüêî äëÿ OP_BUY èëè OP_SELL ïîçèöèé.", 1 );
		}
		_Return_ ( 7, "Error", 0, "Îøèáî÷íûé OrderType()", "_TrailingStop_Check()", "Îøèáî÷íûé OrderType()" );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }

return(true);
}
bool _TrailingStop_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Trailing_OrderTicket, SELECT_BY_TICKET ) )
	{
		Trailing_GetLastError = GetLastError();
		_Return_ ( 7,  "Error", Trailing_GetLastError, ErrorDescription( Trailing_GetLastError ), "OrderSelect( " + Trailing_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
		return(false);
	}

	Trailing_Symbol				= OrderSymbol();
	Trailing_OrderComment		= OrderComment();
	Trailing_OrderType			= OrderType();
	Trailing_OrderMagicNumber	= OrderMagicNumber();
	Trailing_OrderOpenPrice		= NormalizeDouble ( OrderOpenPrice(), _Digits );
	Trailing_OrderStopLoss		= NormalizeDouble ( OrderStopLoss(), _Digits );
	Trailing_OrderTakeProfit	= NormalizeDouble ( OrderTakeProfit(), _Digits );
	Trailing_OrderExpiration	= OrderExpiration();

	Trailing_Bid					= NormalizeDouble( MarketInfo ( Trailing_Symbol, MODE_BID ), _Digits );
	Trailing_Ask					= NormalizeDouble( MarketInfo ( Trailing_Symbol, MODE_ASK ), _Digits );

	bool refreshed = false;
//---- Îáíîâëÿåì íîâûé óðîâåíü ñòîïëîññà
	if ( Trailing_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Trailing_New_StopLoss, _Digits ) != NormalizeDouble( Trailing_Bid - Trailing_TrailingStop * _Point, _Digits ) )
		{
			Trailing_New_StopLoss = NormalizeDouble( Trailing_Bid - Trailing_TrailingStop * _Point, _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - TrailingStop Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 2, "Refreshed New Stop Loss = " + DoubleToStr( Trailing_New_StopLoss, _Digits ) );
			}
		}
	}
	if ( Trailing_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Trailing_New_StopLoss, _Digits ) != NormalizeDouble( Trailing_Ask + Trailing_TrailingStop * _Point, _Digits ) )
		{
			Trailing_New_StopLoss = NormalizeDouble( Trailing_Ask + Trailing_TrailingStop * _Point, _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - TrailingStop Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 2, "Refreshed New Stop Loss = " + DoubleToStr( Trailing_New_StopLoss, _Digits ) );
			}
		}
	}
return(true);
}
void _TrailingStop_SetArrow ()
{
	if ( Trailing_Color == CLR_NONE ) { return(0); }

	string arrow_description = Trailing_OrderComment + "\nId " + Trailing_OrderMagicNumber + "\nModified by TrailingStop";

	string sl_name = "#" + Trailing_OrderTicket + " sl modified ";
	string new_arrow = "#" + Trailing_OrderTicket + " old sl" + TimeToStr( Time[1] );

	ObjectSetText( sl_name, arrow_description, 10 );
	GetLastError();
/*	if ( ObjectCreate( new_arrow, OBJ_ARROW, 0, Time[1], Trailing_OrderStopLoss ) )
	{
		if ( !ObjectSet( new_arrow, OBJPROP_ARROWCODE, 4 ) )
		{
			Trailing_GetLastError = GetLastError();
			_Print_ ( 7, "ObjectSet( " + new_arrow + ", OBJPROP_ARROWCODE, 4 )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
		}
		if ( !ObjectSetText( new_arrow, arrow_description, 10 ) )
		{
			Trailing_GetLastError = GetLastError();
			_Print_ ( 7, "ObjectSetText( " + new_arrow + ", " + arrow_description + ", 10 )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
		}
	}*/
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _Check_( int FunctionId )
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(0); }
	int _return = 0;
//---- Ïðîâåðÿåì ñîåäèíåíèå ñ ñåðâåðîì. Åñëè IsConnected == false - âûõîäèì
	int _IsConnected = _IsConnected();
	if ( _IsConnected < 0 )
	{
		if ( _IsConnected == -1 ) { _return = -300; _Return_( FunctionId, "Error", 0, stringNoConnection, "_IsConnected()", stringNoConnection ); }
		if ( _IsConnected == -2 ) { _return = -302; _Return_( FunctionId, "Error", 0, stringStopped, "_IsConnected()", stringStopped ); }
		if ( _IsConnected == -3 ) { _return = -303; _Return_( FunctionId, "Error", 0, stringTimeOut, "_IsConnected()", stringTimeOut ); }
		return(_return);
	}

//---- Ïðîâåðÿåì IsTradeAllowed. Åñëè IsTradeAllowed == false - âûõîäèì
	int _IsTradeAllowed = _IsTradeAllowed();
	if ( _IsTradeAllowed < 0 )
	{
		if ( _IsTradeAllowed == -1 ) { _return = -301; _Return_( FunctionId, "Error", 0, stringTradeNotAllow, "_IsTradeAllowed()", stringTradeNotAllow ); }
		if ( _IsTradeAllowed == -2 ) { _return = -302; _Return_( FunctionId, "Error", 0, stringStopped, "_IsTradeAllowed()", stringStopped ); }
		if ( _IsTradeAllowed == -3 ) { _return = -303; _Return_( FunctionId, "Error", 0, stringTimeOut, "_IsTradeAllowed()", stringTimeOut ); }
		return(_return);
	}

//---- Æä¸ì îñâîáîæäåíèÿ òîðãîâîãî ïîòîêà è çàíèìàåì åãî
	int _TradeIsBusy = TradeIsBusy();
	if ( _TradeIsBusy < 0 )
	{
		if ( _TradeIsBusy == -2 ) { _return = -302; _Return_( FunctionId, "Error", 0, stringStopped, "TradeIsBusy()", stringStopped ); }
		if ( _TradeIsBusy == -3 ) { _return = -303; _Return_( FunctionId, "Error", 0, stringTimeOut, "TradeIsBusy()", stringTimeOut ); }
		return(_return);
	}

//---- Ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè
	int _PauseBeforeTrade = _PauseBeforeTrade();
	if ( _PauseBeforeTrade < 0 )
	{
		if ( _PauseBeforeTrade == -2 ) { _return = -302; _Return_( FunctionId, "Error", 0, stringStopped, "_PauseBeforeTrade()", stringStopped ); }
		if ( _PauseBeforeTrade == -3 ) { _return = -303; _Return_( FunctionId, "Error", 0, stringTimeOut, "_PauseBeforeTrade()", stringTimeOut ); }
		TradeIsNotBusy();
		return(_return);
	}
return(_return);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _Return_ ( int FunctionId, string TradeLog_Result, int TradeLog_GetLastError, string TradeLog_ErrorDescription, string SubFunction, string SubFunctionResult )
/////////////////////////////////////////////////////////////////////////////////
{
	_TradeLog_ 	( FunctionId, TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription );
	_Print_ 		( FunctionId, SubFunction, SubFunctionResult );

	switch ( FunctionId )
	{
		case 1:  _FileWrite ( "- - - - - - - - - - - - - - - - - OrderSend Finish - - - - - - - - - - - - - - - - - -" ); break;
		case 2:  _FileWrite ( "- - - - - - - - - - - - - - - - - OrderModify Finish - - - - - - - - - - - - - - - - -" ); break;
		case 3:  _FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Finish  - - - - - - - - - - - - - - - - -" ); break;
		case 4:  _FileWrite ( "- - - - - - - - - - - - - - - - - OrderDelete Finish - - - - - - - - - - - - - - - - -" ); break;
		case 5:	break;
		case 6:  _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Finish - - - - - - - - - - - - - - - - - -" ); break;
		case 7:  _FileWrite ( "- - - - - - - - - - - - - - - - - TrailingStop Finish  - - - - - - - - - - - - - - - -" ); break;
		default: Print( " _Return_( ", FunctionId, ", ", TradeLog_Result, ", ", TradeLog_GetLastError, ", ", TradeLog_ErrorDescription, ", ", SubFunction, ", ", SubFunctionResult, " ) - Unknown function with Id ", FunctionId );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _TradeLog_( int FunctionId, string TradeLog_Result, int TradeLog_GetLastError, string TradeLog_ErrorDescription )
/////////////////////////////////////////////////////////////////////////////////
{
	switch ( FunctionId )
	{
		case 1:  _TradeLog ( Send_Result, Send_MagicNumber, Send_Comment, "OrderSend ( \"" + Send_Symbol + "\", " + Send_OrderType + ", " + DoubleToStr( Send_Volume, 2 ) + ", " + DoubleToStr( Send_OpenPrice, _Digits ) + ", " + Send_Slippage + ", " + DoubleToStr( Send_StopLoss, _Digits ) + ", " + DoubleToStr( Send_TakeProfit, _Digits ) + ", " + Send_Comment + ", " + Send_MagicNumber + ", " + Send_Expiration + ", " + Send_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Send_StartTickCount ) / 1000 ); break;
		case 2:  _TradeLog ( Modify_OrderTicket, Modify_OrderMagicNumber, Modify_OrderComment, "OrderModify ( " + Modify_OrderTicket + ", " + DoubleToStr( Modify_New_OpenPrice, _Digits ) + ", " + DoubleToStr( Modify_New_StopLoss, _Digits ) + ", " + DoubleToStr( Modify_New_TakeProfit, _Digits ) + ", " + Modify_New_Expiration + ", " + Modify_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Modify_StartTickCount ) / 1000 ); break;
		case 3:  _TradeLog ( Close_OrderTicket, Close_OrderMagicNumber, Close_OrderComment, "OrderClose( " + Close_OrderTicket + ", " + DoubleToStr( Close_Volume, 2 ) + ", " + Close_Slippage + ", " + Close_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Close_StartTickCount ) / 1000 ); break;
		case 4:  _TradeLog ( Delete_OrderTicket, Delete_OrderMagicNumber, Delete_OrderComment, "OrderDelete( " + Delete_OrderTicket + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Delete_StartTickCount ) / 1000 ); break;
		case 5:  _TradeLog ( Close_OrderTicket, Close_OrderMagicNumber, Close_OrderComment, "Reverse( " + Close_OrderTicket + ", " + Close_Slippage + ", " + Close_Color + ", " + Send_Color + " )" + " - - - " + "OrderClose( " + Close_OrderTicket + ", " + DoubleToStr( Close_Volume, 2 ) + ", " + Close_Slippage + ", " + Close_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Close_StartTickCount ) / 1000 ); break;
		case 6:  _TradeLog ( Send_Result, Send_MagicNumber, Send_Comment, "Reverse( " + Close_OrderTicket + ", " + Close_Slippage + ", " + Close_Color + ", " + Send_Color + " )" + " - - - " + "OrderSend ( \"" + Send_Symbol + "\", " + Send_OrderType + ", " + DoubleToStr( Send_Volume, 2 ) + ", " + DoubleToStr( Send_OpenPrice, _Digits ) + ", " + Send_Slippage + ", " + DoubleToStr( Send_StopLoss, _Digits ) + ", " + DoubleToStr( Send_TakeProfit, _Digits ) + ", " + Send_Comment + ", " + Send_MagicNumber + ", " + Send_Expiration + ", " + Send_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Close_StartTickCount ) / 1000 ); break;
		case 7:  _TradeLog ( Trailing_OrderTicket, Trailing_OrderMagicNumber, Trailing_OrderComment, "TrailingStop ( " + Trailing_OrderTicket + ", " + Trailing_TrailingStop + ", " + Trailing_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Trailing_StartTickCount ) / 1000 ); break;
		default: Print( " _TradeLog_( ", FunctionId, ", ", TradeLog_Result, ", ", TradeLog_GetLastError, ", ", TradeLog_ErrorDescription, " ) - Unknown function with Id ", FunctionId );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _Print_( int FunctionId, string SubFunction, string SubFunctionResult )
/////////////////////////////////////////////////////////////////////////////////
{
	switch ( FunctionId )
	{
		
		case 1:  Print( "OrderSend - ",SubFunctionResult,". Account ", AccountNumber()," - OK" ); break;
		case 2:  Print( "OrderModify ( ", Modify_OrderTicket, ", ", DoubleToStr( Modify_New_OpenPrice, _Digits ), ", ", DoubleToStr( Modify_New_StopLoss, _Digits ), ", ", DoubleToStr( Modify_New_TakeProfit, _Digits ), ", ", Modify_New_Expiration, ", ", Modify_Color, " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Modify_StartTickCount ) / 1000, " sec." ); break;
		case 3:  Print( "OrderClose( ",Close_OrderTicket, " )" ); break;
		case 4:  Print( "OrderDelete( ", Delete_OrderTicket, " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Delete_StartTickCount ) / 1000, " sec." ); break;
		case 5:  Print( "Reverse( " + Close_OrderTicket + ", " + Close_Slippage + ", " + Close_Color + ", " + Send_Color + " ) - - - " + "OrderClose( ", Close_OrderTicket, ", ", Close_Volume, ", ", Close_Slippage, ", ", Close_Color, " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Close_StartTickCount ) / 1000, " sec." ); break;
		case 6:  Print( "Reverse( " + Close_OrderTicket + ", " + Close_Slippage + ", " + Close_Color + ", " + Send_Color + " ) - - - " + "OrderSend ( ", Send_Symbol, ", ", Send_OrderType, ", ", DoubleToStr( Send_Volume, 2 ), ", ", DoubleToStr( Send_OpenPrice, _Digits ), ", ", Send_Slippage, ", ", DoubleToStr( Send_StopLoss, _Digits ), ", ", DoubleToStr( Send_TakeProfit, _Digits ), ", ", Send_Comment, ", ", Send_MagicNumber, ", ", Send_Expiration, ", ", Send_Color, " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Close_StartTickCount ) / 1000, " sec." ); break;
		case 7:  Print( "TrailingStop ( " + Trailing_OrderTicket + ", " + Trailing_TrailingStop + ", " + Trailing_Color + " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Trailing_StartTickCount ) / 1000, " sec." ); break;
		default: Print( "Print_( ", FunctionId, ", ", SubFunction, ", ", SubFunctionResult, " ) - Unknown function with Id ", FunctionId );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int TradeIsBusy()
/////////////////////////////////////////////////////////////////////////////////
// Óñòàíàâëèâàåì ãëîáàëüíóþ ïåðåìåííóþ TradeIsBusy â 1
// Åñëè óñïåøíî, âîçâðàùàåì 1
// Åñëè _IsStopped(), âîçâðàùàåì -2
// Åñëè _IsTimeOut(), âîçâðàùàåì -3
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(1); }
	int _GetLastError;

	while( true )
	{
		if ( _IsStopped() ) { return(-2); }
		if ( _IsTimeOut() ) { return(-3); }
		if ( GlobalVariableCheck( "TradeIsBusy" ) ) { break; }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " TradeIsBusy() - GlobalVariableCheck ( \"TradeIsBusy\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			Sleep(100);
			continue;
		}

		if ( GlobalVariableSet ( "TradeIsBusy", 1.0 ) > 0 ) { return(1); }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " TradeIsBusy() - GlobalVariableSet ( \"TradeIsBusy\", 0.0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			Sleep(100);
			continue;
		}
		Sleep(100);
	}
	while( true )
	{
		if ( _IsStopped() ) { return(-2); }
		if ( _IsTimeOut() ) { return(-3); }
		if ( GlobalVariableSetOnCondition( "TradeIsBusy", 1.0, 0.0 ) ) { return(1); }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " TradeIsBusy() - GlobalVariableSetOnCondition ( \"TradeIsBusy\", 1.0, 0.0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}

		_info ( 14, "Æä¸ì, ïîêà äðóãîé ýêñïåðò çàêîí÷èò òîðãîâàòü...", 0, 0 );
		Sleep(1000);
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _PauseBeforeTrade ()
/////////////////////////////////////////////////////////////////////////////////
// Åñëè ñî âðåìåíè ïîñëåäíåé òîðãîâîé îïåðàöèè ïðîøëî ìåíüøå PauseBeforeTrade ñåê, æä¸ì...
// Óñòàíàâëèâàåì ãëîáàëüíóþ ïåðåìåííóþ LastTradeTime â ëîêàëüíîå âðåìÿ
// Åñëè óñïåøíî, âîçâðàùàåì 1
// Åñëè IsStopped(), âîçâðàùàåì -2
// Åñëè _IsTimeOut(), âîçâðàùàåì -3
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(1); }
	int _GetLastError;
	GetLastError();

	while( true )
	{
		if ( _IsStopped() ) { TradeIsNotBusy(); return(-2); }
		if ( _IsTimeOut() ) { TradeIsNotBusy(); return(-3); }
		if ( GlobalVariableCheck( "LastTradeTime" ) ) break;
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " _PauseBeforeTrade() - GlobalVariableCheck ( \"LastTradeTime\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}

		if ( GlobalVariableSet ( "LastTradeTime", TimeLocal() ) > 0 )
		{
			_info ( 14, "" );
			return(1);
		}
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 ) Print( " _PauseBeforeTrade() - GlobalVariableSet ( \"LastTradeTime\", ", TimeLocal(), " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	
		Sleep(100);
	}

	double _LastTradeTime, RealPauseBeforeTrade, RequirementPauseBeforeTrade;

	while( true )
	{
		if ( _IsStopped() ) { TradeIsNotBusy(); return(-2); }
		if ( _IsTimeOut() ) { TradeIsNotBusy(); return(-3); }

		_LastTradeTime = GlobalVariableGet ( "LastTradeTime" );
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " _PauseBeforeTrade() - GlobalVariableGet ( \"LastTradeTime\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}

		RealPauseBeforeTrade				= TimeLocal() - _LastTradeTime;
		RequirementPauseBeforeTrade	= PauseBeforeTrade;
		if ( RealPauseBeforeTrade < RequirementPauseBeforeTrade )
		{
			_info ( 14, "Ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè. Îñòàëîñü " + DoubleToStr( RequirementPauseBeforeTrade - RealPauseBeforeTrade, 0 ) + " ñåê.", 0, 0 );
			Sleep(1000);
		}
		else
		{
			break;
		}
	}

	while( true )
	{
		if ( _IsStopped() ) { TradeIsNotBusy(); return(-2); }
		if ( _IsTimeOut() ) { TradeIsNotBusy(); return(-3); }
		if ( GlobalVariableSet ( "LastTradeTime", TimeLocal() ) > 0 )
		{
			_info( 14, "" );
			return(1);
		}

		_GetLastError = GetLastError();
		if ( _GetLastError != 0 ) Print( " _PauseBeforeTrade() - GlobalVariableSet ( \"LastTradeTime\", ", TimeLocal(), " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );

		Sleep(100);
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void TradeIsNotBusy ()
/////////////////////////////////////////////////////////////////////////////////
// Óñòàíàâëèâàåì ãëîáàëüíóþ ïåðåìåííóþ TradeIsBusy â 0
// Ðàáîòàåì "äî óïîðà", ò.å. ïîêà íå âûïîëíèì
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(0); }
	int _GetLastError;
	GetLastError();
	while( true )
	{
		if ( GlobalVariableCheck( "TradeIsBusy" ) )
		{
			if ( GlobalVariableGet( "TradeIsBusy" ) == 0.0 ) return(1);
			_GetLastError = GetLastError();
			if ( _GetLastError != 0 )
			{
				Print( " TradeIsNotBusy() - GlobalVariableGet ( \"TradeIsBusy\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				continue;
			}

			if ( GlobalVariableSet( "TradeIsBusy", 0.0 ) > 0 ) return(1);
			_GetLastError = GetLastError();
			if ( _GetLastError != 0 )
			{ Print( " TradeIsNotBusy() - GlobalVariableSet ( \"TradeIsBusy\", 0.0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" ); }

			Sleep(100);
		}
		else
		{
			_GetLastError = GetLastError();
			if ( _GetLastError != 0 )
			{
				Print( " TradeIsNotBusy() - GlobalVariableCheck ( \"TradeIsBusy\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				continue;
			}
			return(1);
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _IsConnected ()
/////////////////////////////////////////////////////////////////////////////////
// Åñëè IsConnected() == true, âîçâðàùàåì 1
// Åñëè IsConnected() == false, âîçâðàùàåì -1
// Åñëè IsStopped(), âîçâðàùàåì -2
// Åñëè _IsTimeOut(), âîçâðàùàåì -3
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(1); }
	for ( int z = 0; z < 50; z ++ )
	{
		if ( IsConnected() ) { return(1); }
		if ( _IsStopped() ) { return(-2); }
		if ( _IsTimeOut() ) { return(-3); }
		Sleep(100);
	}
	_info ( 14, stringNoConnection + "!", 1 );
return(-1);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _IsTradeAllowed ()
/////////////////////////////////////////////////////////////////////////////////
// Åñëè IsTradeAllowed() == true, âîçâðàùàåì 1
// Åñëè IsTradeAllowed() == false, âîçâðàùàåì -1
// Åñëè IsStopped(), âîçâðàùàåì -2
// Åñëè _IsTimeOut(), âîçâðàùàåì -3
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(1); }
	for ( int z = 0; z < 50; z ++ )
	{
		if ( IsTradeAllowed() ) { return(1); }
		if ( _IsStopped() ) { return(-2); }
		if ( _IsTimeOut() ) { return(-3); }
		Sleep(100);
	}
	_info ( 14, stringTradeNotAllow + "!", 1 );
return(-1);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ bool _IsStopped ()
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsStopped() )
	{
		_info ( 14, stringStopped + "!", 1 );
		return(true);
	}
	return(false);
}
/////////////////////////////////////////////////////////////////////////////////
/**/ bool _IsTimeOut ()
/////////////////////////////////////////////////////////////////////////////////
{
	if ( TimeLocal() - StartTime > MaxWaitingTime && MaxWaitingTime > 0 && StartTime > 0 )
	{
		_info ( 4, stringTimeOut + "!", 1 );
		return(true);
	}
	return(false);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void Processing_Error ( int ErrorCode, string Function )
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

/*ERR_ORDER_LOCKED - â îáðàáîòêå íàõîäÿòñÿ äðóãèå îðäåðû, ñåðâåð íå ïðèíèìàåò íîâûõ çàÿâîê
ERR_OFF_QUOTES - íåò öåí, èìååò ñìûñë ïîâòîðèòü îïåðàöèþ ÷åðåç íåêîòîðîå ïðîäîëæèòåëüíîå âðåìÿ
ERR_PRICE_CHANGED - öåíà ÿâíî èçìåíèëàñü, íóæíî âçÿòü ïîñëåäíþþ ðûíî÷íóþ è ïîïðîáîâàòü ñíîâà
ERR_INVALID_PRICE - ÿâíàÿ îøèáêà â ýêñïåðòå ñ íåïðàâèëüíûìè öåíàìè, íè î êàêîé òîðãîâëå ðå÷ü íå ìîæåò èäòè. íóæíî îñòàíàâëèâàòüñÿ è ïðîâåðÿòü êîä ýêñïåðòà
ERR_REQUOTE - ÷èñòûé ðåêâîò, íåîáõîäèìî òóò æå áåç çàäåðæåê âçÿòü ðûíî÷íóþ öåíó è ñíîâà ïðîâåñòè òðåéä

*/	string ErrorDescription = ErrorDescription( ErrorCode );
	int ErrorAction = 0;
	if ( ErrorCode == 4   ||
		  ErrorCode == 6	 ||
		  ErrorCode == 8	 ||
		  ErrorCode == 132  ||
		  ErrorCode == 137  ||
		  ErrorCode == 141  ||
		  ErrorCode == 146 ) ErrorAction = 1;

	if ( ErrorCode == 5   ||
		  ErrorCode == 64  ||
		  ErrorCode == 65 ) ErrorAction = 2;

	string ActionStr = "Ýêñïåðò ïðîäîëæàåò ðàáîòó...";

	switch ( ErrorAction )
	{
		case 1:
		{
/*			ActionStr = "Ýêñïåðòû íå áóäóò òîðãîâàòü 5 ìèíóò...";
			while ( !IsStopped() )
			{
				if ( GlobalVariableSet ( "LastTradeTime", TimeLocal() + 300 ) > 0 ) { break; }
				_GetLastError = GetLastError();
				Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - GlobalVariableSet ( \"LastTradeTime\", ", TimeLocal() + 300, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				Sleep(100);
			}
*/			break;
		}
		case 2:
		{
			ActionStr = "Ýêñïåðò ïðåêðàùàåò ðîáîòó...";
			while ( !IsStopped() )
			{
				if ( GlobalVariableSet ( strComment + "-return!", -ErrorCode ) > 0 ) { break; }
				_GetLastError = GetLastError();
				Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - GlobalVariableSet ( \"", strComment, "-return!\", ", -ErrorCode, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				Sleep(100);
			}
			break;
		}
	}

	clear_info();
	_info ( 1, Function + " Error!!!", 1 );
	_info ( 2, "GetLastError = " + ErrorCode, 1 );
	_info ( 3, ErrorDescription, 1 );
	_info ( 4, ActionStr, 1 );

	string subject = strComment + " - Error #" + ErrorCode + " ( " + ErrorDescription + " )!";
	string mail_text = "Account#" + AccountNumber() + "  " + strComment + " - " + Function + "() Error #" + ErrorCode;
	string log_text =
	"+--------------------Expert-Information----------------------------+\n" +
	"+ ExpertName		= " + ExpertName + "\n" +
	"+ ChartSymbol		= " + _Symbol + "\n" +
	"+ ChartPeriod		= " + strPeriod + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+--------------------Error-Information-----------------------------+\n" +
	"+ LocalTime		= " + TimeToStr( TimeLocal(), TIME_DATE | TIME_SECONDS ) + "\n" +
	"+ Function		= " + Function + "\n" +
	"+ GetLastError		= " + ErrorCode + "\n" +
	"+ ErrorDescription	= " + ErrorDescription + "\n" +
	"+ Action		= " + ActionStr + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+--------------------Market-Information----------------------------+\n" +
	"+ Bid			= " + DoubleToStr( MarketInfo( _Symbol, MODE_BID ), _Digits ) + "\n" +
	"+ Ask			= " + DoubleToStr( MarketInfo( _Symbol, MODE_ASK ), _Digits ) + "\n" +
	"+ Spread		= " + DoubleToStr( _Spread, _Digits ) + "\n" +
	"+ StopLevel		= " + DoubleToStr( _StopLevel, _Digits ) + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+-------------------LastBar-Information----------------------------+\n" +
	"+ Time [0]		= " + TimeToStr( iTime( _Symbol, _Period, 0 ) )  + "\n" +
	"+ Open [0]		= " + DoubleToStr( iOpen( _Symbol, _Period, 0 ), _Digits ) + "\n" +
	"+ High [0]		= " + DoubleToStr( iHigh( _Symbol, _Period, 0 ), _Digits ) + "\n" +
	"+ Low  [0]		= " + DoubleToStr( iLow ( _Symbol, _Period, 0 ), _Digits ) + "\n" +
	"+ Close[0]		= " + DoubleToStr( iClose( _Symbol, _Period, 0 ), _Digits ) + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+--------------------Server-Information----------------------------+\n" +
	"+ ServerAddress		= " + ServerAddress()		+ "\n" +
	"+ ServerTime		= " + TimeToStr( CurTime(), TIME_DATE | TIME_SECONDS ) + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+--------------------Account-Information---------------------------+\n" +
	"+ AccountNumber		= " + AccountNumber()								+ "\n" +
	"+ AccountName		= " + AccountName()										+ "\n" +
	"+ AccountEquity		= " + DoubleToStr( AccountEquity(), 2 )		+ "\n" +
	"+ AccountFreeMargin	= " + DoubleToStr( AccountFreeMargin(), 2 )	+ "\n" +
	"+ AccountMargin		= " + DoubleToStr( AccountMargin(), 2 )		+ "\n" +
	"+ \n" +
	"+ AccountBalance	= " + DoubleToStr( AccountBalance(), 2 )			+ "\n" +
	"+ AccountProfit		= " + DoubleToStr( AccountProfit(), 2 )		+ "\n" +
	"+ AccountCredit		= " + DoubleToStr( AccountCredit(), 2 )		+ "\n" +
	"+ AccountCurrency	= " + AccountCurrency()								+ "\n" +
	"+ AccountLeverage	= " + AccountLeverage()								+ "\n" +
	"+------------------------------------------------------------------+\n";

	if ( Allow_ErrorMail && !IsTesting() )
	{
		if ( IsConnected() )
		{
			SendMail( mail_text, "" );
			_GetLastError = GetLastError();
			if ( _GetLastError > 0 )
			{ Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - SendMail ( ", subject, ", ", mail_text, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" ); }
		}
		else
		{
			Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - No connection with server. SendMail canceled" );
		}
	}
	
	if ( Allow_ErrorLogFile )
	{
		string file_name = "_ErrorLogs\\" + strComment + "\\" + TimeToStr( TimeLocal(), TIME_DATE ) + ".txt";
		int file_handle = FileOpen ( file_name, FILE_READ | FILE_WRITE, " " );
	
		if ( file_handle > 0 )
		{
			if ( FileSeek ( file_handle, 0, SEEK_END ) )
			{
				if ( FileWrite ( file_handle, subject + "\n", log_text, "\n\n" ) < 0 )
				{
					_GetLastError = GetLastError();
					Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - FileWrite (...) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				}
			}
			else
			{
				_GetLastError = GetLastError();
				Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - FileSeek ( " + file_handle + ", 0, SEEK_END ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			}
			FileClose ( file_handle );
		}
		else
		{
			_GetLastError = GetLastError();
			Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - FileOpen( ", file_name, ", FILE_READ | FILE_WRITE, \" \" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _TradeLog ( int Ticket, int MagicNumber, string _Comment, string Action, string Result = "OK", int Error = 0, string ErrorDescription = "", int WorkTime = 0 )
/////////////////////////////////////////////////////////////////////////////////
// Çàïèñü â ëîã-ôàéë èíôîðìàöèè î òîðãîâîé îïåðàöèè.
//
// Èìÿ ïðîåêòèðóåòñÿ ñ èñïîëüçîâàíèåì òåêóùåé äàòû.
// È âûãëÿäèò òàê ( äëÿ ïðèìåðà: äàòà çàïèñè - 2005.08.03):
// ...\MetaTrader 4\experts\files\_TradeLog\2005.08.03.csv
// Äëÿ óäîáî÷èòàåìîñòè ëîãîâ ìîæíî èñïîëüçîâàòü ìàêðîñ TradeLog_Format, ïðèâîäÿùèé ëîã â "ïðèëè÷íûé" âèä.
// Èíñòðóêöèè ïî èñïîëüçîâàíèþ â ñîîòâåòñòâóþùåé ãëàâå.
/////////////////////////////////////////////////////////////////////////////////
{
	if ( !Allow_TradeLogFile ) { return(0); }

	int _GetLastError;

	string file_name = "_TradeLogs\\" + TimeToStr( TimeLocal(), TIME_DATE ) + ".csv";
	int file_handle = FileOpen ( file_name, FILE_READ | FILE_WRITE );
	if ( file_handle > 0 )
	{
		if ( FileSeek ( file_handle, 0, SEEK_END ) )
		{
			string Error_str = DoubleToStr( Error, 0 );
			if ( FileWrite ( file_handle, TimeToStr( TimeLocal(), TIME_SECONDS ), ExpertName, _Symbol, _Period, "( " + strPeriod + " )", Ticket, MagicNumber, _Comment, Action, Result, ErrorDescription, Error_str, WorkTime ) < 0 )
			{
				_GetLastError = GetLastError();
				Print( " _TradeLog ( ", Ticket, ", ", MagicNumber, ", ", _Comment, ", ", Action, ", ", Result, ", ", Error, " ) - FileWrite ( ", TimeToStr( TimeLocal(), TIME_SECONDS ), ", ", ExpertName, ", ", _Symbol, ", ", _Period, ", ( " + strPeriod + " ), ", Ticket, ", ", MagicNumber, ", ", _Comment, ", ", Action, ", ", Result, ", ", Error, ", ", ErrorDescription, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			}
		}
		else
		{
			_GetLastError = GetLastError();
			Print( " _TradeLog ( ", Ticket, ", ", MagicNumber, ", ", _Comment, ", ", Action, ", ", Result, ", ", Error, " ) - FileSeek ( " + file_handle + ", 0, SEEK_END ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}
		FileClose ( file_handle );
	}
	else
	{
		_GetLastError = GetLastError();
		Print( " _TradeLog ( ", Ticket, ", ", MagicNumber, ", ", _Comment, ", ", Action, ", ", Result, ", ", Error, " ) - FileOpen( \"", file_name, "\", FILE_READ | FILE_WRITE ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void ReportToCSV( string file_name = "", int magic = -1, string comment = "-1", string symbol = "-1", int magic1 = -1 )
/////////////////////////////////////////////////////////////////////////////////
{
	int Tickets[], _HistoryTotal = OrdersHistoryTotal(), _HistoryValidate = 0, _GetLastError;
	ArrayResize( Tickets, _HistoryTotal );

	for ( int i = 0; i < _HistoryTotal; i++ )
	{
		if ( !OrderSelect( i, SELECT_BY_POS, MODE_HISTORY ) ) continue;
		if ( symbol != "-1" && OrderSymbol() != _Symbol ) continue;
		if ( comment != "-1" && StringFind( OrderComment(), comment, 0 ) < 0 ) continue;
		if ( magic != -1 && OrderMagicNumber() != magic )
		{
			if ( magic1 != -1 && OrderMagicNumber() != magic1 ) continue;
		}

		Tickets[_HistoryValidate] = OrderTicket();
		_HistoryValidate ++;
	}

	if ( _HistoryValidate <= 0 )
	{
		Print( "ReportToCSV: Íåò îðäåðîâ, îòâå÷àþùèõ óñëîâèÿì!" );
		return;
	}

	ArrayResize( Tickets, _HistoryValidate );
	ArraySort( Tickets );

	if ( file_name == "" ) file_name = "_Reports\\" + strComment + ".csv";
	int file_handle = FileOpen ( file_name, FILE_WRITE );
	if ( file_handle < 0 )
	{
		_GetLastError = GetLastError();
		Print( " ReportToCSV ( ", magic, ", ", comment, " ) - FileOpen( \"", file_name, "\", FILE_WRITE ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		return(-1);
	}

	FileWrite( file_handle, 
		"Ticket", 
		"OpenTime", 
		"Type", 
		"Lots", 
		"Symbol", 
		"OpenPrice", 
		"StopLoss", 
		"TakeProfit", 
		"CloseTime", 
		"ClosePrice", 
		"Swap", 
		"Profit", 
		"Comment" );

	for ( i = 0; i < _HistoryValidate; i++ )
	{
		if ( !OrderSelect( Tickets[i], SELECT_BY_TICKET ) ) continue;
		FileWrite( file_handle, 
			Tickets[i], 
			TimeToStr( OrderOpenTime() ), 
			strOrderType( OrderType() ), 
			DoubleToStr( OrderLots(), 2 ), 
			Symbol(), 
			DoubleToStr( OrderOpenPrice()	, _Digits ), 
			DoubleToStr( OrderStopLoss()	, _Digits ), 
			DoubleToStr( OrderTakeProfit(), _Digits ), 
			TimeToStr( OrderCloseTime() ), 
			DoubleToStr( OrderClosePrice(), _Digits ), 
			DoubleToStr( OrderSwap(), 2 ), 
			DoubleToStr( OrderProfit(), 2 ), 
			OrderComment() );
	}
	FileClose( file_handle );
}

/////////////////////////////////////////////////////////////////////////////////
/**/ string strOrderType( int intOrderType )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò OrderType â âèäå òåêñòà
/////////////////////////////////////////////////////////////////////////////////
{
	switch ( intOrderType )
	{
		case OP_BUY:			return("Buy"					);
		case OP_SELL:			return("Sell"					);
		case OP_BUYLIMIT:		return("BuyLimit"				);
		case OP_BUYSTOP:		return("BuyStop"				);
		case OP_SELLLIMIT:	return("SellLimit"			);
		case OP_SELLSTOP:		return("SellStop"				);
		default:					return("UnknownOrderType"	);
	}
}
/////////////////////////////////////////////////////////////////////////////////
/**/ int intOrderType( string strOrderType )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò OrderType â âèäå òåêñòà
/////////////////////////////////////////////////////////////////////////////////
{
	if ( strOrderType == "Buy"			) { return(OP_BUY			); }
	if ( strOrderType == "Sell"		) { return(OP_SELL		); }
	if ( strOrderType == "BuyLimit"	) { return(OP_BUYLIMIT	); }
	if ( strOrderType == "BuyStop"	) { return(OP_BUYSTOP	); }
	if ( strOrderType == "SellLimit"	) { return(OP_SELLLIMIT	); }
	if ( strOrderType == "SellStop"	) { return(OP_SELLSTOP	); }
	return(-1);
}
/////////////////////////////////////////////////////////////////////////////////
/**/ int intOrderType2( string strOrderType )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò OrderType â âèäå òåêñòà
/////////////////////////////////////////////////////////////////////////////////
{
	if ( strOrderType == "Buy"			) { return(OP_BUY			); }
	if ( strOrderType == "Sell"		) { return(OP_SELL		); }
	if ( strOrderType == "Buy-limit"	) { return(OP_BUYLIMIT	); }
	if ( strOrderType == "Buy-stop"	) { return(OP_BUYSTOP	); }
	if ( strOrderType == "Sell-limit") { return(OP_SELLLIMIT	); }
	if ( strOrderType == "Sell-stop"	) { return(OP_SELLSTOP	); }
	return(-1);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ string strPeriod( int intPeriod )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò Period â âèäå òåêñòà
/////////////////////////////////////////////////////////////////////////////////
{
	switch ( intPeriod )
	{
		case PERIOD_MN1: return("Monthly");
		case PERIOD_W1:  return("Weekly");
		case PERIOD_D1:  return("Daily");
		case PERIOD_H4:  return("H4");
		case PERIOD_H1:  return("H1");
		case PERIOD_M30: return("M30");
		case PERIOD_M15: return("M15");
		case PERIOD_M5:  return("M5");
		case PERIOD_M1:  return("M1");
		default:		     return("UnknownPeriod");
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int intPeriod( string strPeriod )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò Period â âèäå öåëîãî ÷èñëà
/////////////////////////////////////////////////////////////////////////////////
{
	if ( strPeriod == "Monthly"	)	{ return(PERIOD_MN1	); }
	if ( strPeriod == "Weekly"		)	{ return(PERIOD_W1	); }
	if ( strPeriod == "Daily"		)	{ return(PERIOD_D1	); }
	if ( strPeriod == "H4"			)	{ return(PERIOD_H4	); }
	if ( strPeriod == "H1"			)	{ return(PERIOD_H1	); }
	if ( strPeriod == "M30"			)	{ return(PERIOD_M30	); }
	if ( strPeriod == "M15"			)	{ return(PERIOD_M15	); }
	if ( strPeriod == "M5"			)	{ return(PERIOD_M5	); }
	if ( strPeriod == "M1"			)	{ return(PERIOD_M1	); }
	return(-1);
}


//---- ô-öèÿ èç stdlib.mq4 ñêîïèðîâàíà 10.08.2006 (build 208)
string ErrorDescription(int error_code)
  {
   string error_string;
//----
   switch(error_code)
     {
      //---- codes returned from trade server
      case 0:
      case 1:   error_string="no error";                                                  break;
      case 2:   error_string="common error";                                              break;
      case 3:   error_string="invalid trade parameters";                                  break;
      case 4:   error_string="trade server is busy";                                      break;
      case 5:   error_string="old version of the client terminal";                        break;
      case 6:   error_string="no connection with trade server";                           break;
      case 7:   error_string="not enough rights";                                         break;
      case 8:   error_string="too frequent requests";                                     break;
      case 9:   error_string="malfunctional trade operation (never returned error)";      break;
      case 64:  error_string="account disabled";                                          break;
      case 65:  error_string="invalid account";                                           break;
      case 128: error_string="trade timeout";                                             break;
      case 129: error_string="invalid price";                                             break;
      case 130: error_string="invalid stops";                                             break;
      case 131: error_string="invalid trade volume";                                      break;
      case 132: error_string="market is closed";                                          break;
      case 133: error_string="trade is disabled";                                         break;
      case 134: error_string="not enough money";                                          break;
      case 135: error_string="price changed";                                             break;
      case 136: error_string="off quotes";                                                break;
      case 137: error_string="broker is busy (never returned error)";                     break;
      case 138: error_string="requote";                                                   break;
      case 139: error_string="order is locked";                                           break;
      case 140: error_string="long positions only allowed";                               break;
      case 141: error_string="too many requests";                                         break;
      case 145: error_string="modification denied because order too close to market";     break;
      case 146: error_string="trade context is busy";                                     break;
      case 147: error_string="expirations are denied by broker";                          break;
      case 148: error_string="amount of open and pending orders has reached the limit";   break;
      //---- mql4 errors
      case 4000: error_string="no error (never generated code)";                                                 break;
      case 4001: error_string="wrong function pointer";                                   break;
      case 4002: error_string="array index is out of range";                              break;
      case 4003: error_string="no memory for function call stack";                        break;
      case 4004: error_string="recursive stack overflow";                                 break;
      case 4005: error_string="not enough stack for parameter";                           break;
      case 4006: error_string="no memory for parameter string";                           break;
      case 4007: error_string="no memory for temp string";                                break;
      case 4008: error_string="not initialized string";                                   break;
      case 4009: error_string="not initialized string in array";                          break;
      case 4010: error_string="no memory for array\' string";                             break;
      case 4011: error_string="too long string";                                          break;
      case 4012: error_string="remainder from zero divide";                               break;
      case 4013: error_string="zero divide";                                              break;
      case 4014: error_string="unknown command";                                          break;
      case 4015: error_string="wrong jump (never generated error)";                       break;
      case 4016: error_string="not initialized array";                                    break;
      case 4017: error_string="dll calls are not allowed";                                break;
      case 4018: error_string="cannot load library";                                      break;
      case 4019: error_string="cannot call function";                                     break;
      case 4020: error_string="expert function calls are not allowed";                    break;
      case 4021: error_string="not enough memory for temp string returned from function"; break;
      case 4022: error_string="system is busy (never generated error)";                   break;
      case 4050: error_string="invalid function parameters count";                        break;
      case 4051: error_string="invalid function parameter value";                         break;
      case 4052: error_string="string function internal error";                           break;
      case 4053: error_string="some array error";                                         break;
      case 4054: error_string="incorrect series array using";                             break;
      case 4055: error_string="custom indicator error";                                   break;
      case 4056: error_string="arrays are incompatible";                                  break;
      case 4057: error_string="global variables processing error";                        break;
      case 4058: error_string="global variable not found";                                break;
      case 4059: error_string="function is not allowed in testing mode";                  break;
      case 4060: error_string="function is not confirmed";                                break;
      case 4061: error_string="send mail error";                                          break;
      case 4062: error_string="string parameter expected";                                break;
      case 4063: error_string="integer parameter expected";                               break;
      case 4064: error_string="double parameter expected";                                break;
      case 4065: error_string="array as parameter expected";                              break;
      case 4066: error_string="requested history data in update state";                   break;
      case 4099: error_string="end of file";                                              break;
      case 4100: error_string="some file error";                                          break;
      case 4101: error_string="wrong file name";                                          break;
      case 4102: error_string="too many opened files";                                    break;
      case 4103: error_string="cannot open file";                                         break;
      case 4104: error_string="incompatible access to a file";                            break;
      case 4105: error_string="no order selected";                                        break;
      case 4106: error_string="unknown symbol";                                           break;
      case 4107: error_string="invalid price parameter for trade function";               break;
      case 4108: error_string="invalid ticket";                                           break;
      case 4109: error_string="trade is not allowed in the expert properties";            break;
      case 4110: error_string="longs are not allowed in the expert properties";           break;
      case 4111: error_string="shorts are not allowed in the expert properties";          break;
      case 4200: error_string="object is already exist";                                  break;
      case 4201: error_string="unknown object property";                                  break;
      case 4202: error_string="object is not exist";                                      break;
      case 4203: error_string="unknown object type";                                      break;
      case 4204: error_string="no object name";                                           break;
      case 4205: error_string="object coordinates error";                                 break;
      case 4206: error_string="no specified subwindow";                                   break;
      default:   error_string="unknown error";
     }
//----
   return(error_string);
  }

//+------------------------------------------------------------------+
//| ÎÒÑËÅÆÈÂÀÍÈÅ ÑÎÁÛÒÈÉ
//+------------------------------------------------------------------+

// ìàññèâ îòêðûòûõ ïîçèöèé ñîñòîÿíèåì íà ïðåäûäóùèé òèê
int pre_OrdersArray[][2]; // [êîëè÷åñòâî ïîçèöèé][¹ òèêåòà, òèï ïîçèöèè]

// ïåðåìåííûå ñîáûòèé
int eventBuyClosed_SL  = 0, eventBuyClosed_TP  = 0;
int eventSellClosed_SL = 0, eventSellClosed_TP = 0;
int eventBuyLimitDeleted_Exp  = 0, eventBuyStopDeleted_Exp  = 0;
int eventSellLimitDeleted_Exp = 0, eventSellStopDeleted_Exp = 0;
int eventBuyLimitOpened  = 0, eventBuyStopOpened  = 0;
int eventSellLimitOpened = 0, eventSellStopOpened = 0;

void CheckEvents( int magic = 0 )
{
	// ôëàã ïåðâîãî çàïóñêà
	static bool first = true;
	// êîä ïîñëåäíåé îøèáêè
	int _GetLastError = 0;
	// îáùåå êîëè÷åñòâî ïîçèöèé
	int _OrdersTotal = OrdersTotal();
	// êîë-âî ïîçèöèé, ñîîòâåòñòâóþùèõ êðèòåðèÿì (òåêóùèé èíñòðóìåíò è çàäàííûé MagicNumber),
	// ñîñòîÿíèåì íà òåêóùèé òèê
	int now_OrdersTotal = 0;
	// êîë-âî ïîçèöèé, ñîîòâåòñòâóþùèõ êðèòåðèÿì, ñîñòîÿíèåì íà ïðåäûäóùèé òèê
	static int pre_OrdersTotal = 0;
	// ìàññèâ îòêðûòûõ ïîçèöèé ñîñòîÿíèåì íà òåêóùèé òèê
	int now_OrdersArray[][2]; // [¹ â ñïèñêå][¹ òèêåòà, òèï ïîçèöèè]
	// òåêóùèé íîìåð ïîçèöèè â ìàññèâå now_OrdersArray (äëÿ ïåðåáîðà)
	int now_CurOrder = 0;
	// òåêóùèé íîìåð ïîçèöèè â ìàññèâå pre_OrdersArray (äëÿ ïåðåáîðà)
	int pre_CurOrder = 0;

	// ìàññèâ äëÿ õðàíåíèÿ êîëè÷åñòâà çàêðûòûõ ïîçèöèé êàæäîãî òèïà
	int now_ClosedOrdersArray[6][3]; // [òèï îðäåðà][òèï çàêðûòèÿ]
	// ìàññèâ äëÿ õðàíåíèÿ êîëè÷åñòâà ñðàáîòàâøèõ îòëîæåííûõ îðäåðîâ
	int now_OpenedPendingOrders[4]; // [òèï îðäåðà]

	// âðåìåííûå ôëàãè
	bool OrderClosed = true, PendingOrderOpened = false;
	// âðåìåííûå ïåðåìåííûå
	int ticket = 0, type = -1, close_type = -1;

	//îáíóëÿåì ïåðåìåííûå ñîáûòèé
	eventBuyClosed_SL  = 0; eventBuyClosed_TP  = 0;
	eventSellClosed_SL = 0; eventSellClosed_TP = 0;
	eventBuyLimitDeleted_Exp  = 0; eventBuyStopDeleted_Exp  = 0;
	eventSellLimitDeleted_Exp = 0; eventSellStopDeleted_Exp = 0;
	eventBuyLimitOpened  = 0; eventBuyStopOpened  = 0;
	eventSellLimitOpened = 0; eventSellStopOpened = 0;

	// èçìåíÿåì ðàçìåð ìàññèâà îòêðûòûõ ïîçèöèé ïîä òåêóùåå êîë-âî
	ArrayResize( now_OrdersArray, MathMax( _OrdersTotal, 1 ) );
	// îáíóëÿåì ìàññèâ
	ArrayInitialize( now_OrdersArray, 0.0 );

	// îáíóëÿåì ìàññèâû çàêðûòûõ ïîçèöèé è ñðàáîòàâøèõ îðäåðîâ
	ArrayInitialize( now_ClosedOrdersArray, 0.0 );
	ArrayInitialize( now_OpenedPendingOrders, 0.0 );

	//+------------------------------------------------------------------+
	//| Ïåðåáèðàåì âñå ïîçèöèè è çàïèñûâàåì â ìàññèâ òîëüêî òå, êîòîðûå
	//| ñîîòâåòñòâóþò êðèòåðèÿì
	//+------------------------------------------------------------------+
	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
		if ( !OrderSelect( z, SELECT_BY_POS ) )
		{
			_GetLastError = GetLastError();
			Print( "OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", _GetLastError );
			continue;
		}
		// Ñ÷èòàåì êîëè÷åñòâî îðäåðîâ ïî òåêóùåìó ñèìâîëó è ñ çàäàííûì MagicNumber
		if ( OrderMagicNumber() == magic && OrderSymbol() == Symbol() )
		{
			now_OrdersArray[now_OrdersTotal][0] = OrderTicket();
			now_OrdersArray[now_OrdersTotal][1] = OrderType();
			now_OrdersTotal ++;
		}
	}
	// èçìåíÿåì ðàçìåð ìàññèâà îòêðûòûõ ïîçèöèé ïîä êîë-âî ïîçèöèé, ñîîòâåòñòâóþùèõ êðèòåðèÿì
	ArrayResize( now_OrdersArray, MathMax( now_OrdersTotal, 1 ) );

	//+------------------------------------------------------------------+
	//| Ïåðåáèðàåì ñïèñîê ïîçèöèé ïðåäûäóùåãî òèêà, è ñ÷èòàåì ñêîëüêî çàêðûëîñü ïîçèöèé è
	//| ñðàáîòàëî îòëîæåííûõ îðäåðîâ
	//+------------------------------------------------------------------+
	for ( pre_CurOrder = 0; pre_CurOrder < pre_OrdersTotal; pre_CurOrder ++ )
	{
		// çàïîìèíàåì òèêåò è òèï îðäåðà
		ticket = pre_OrdersArray[pre_CurOrder][0];
		type   = pre_OrdersArray[pre_CurOrder][1];
		// ïðåäïîëîãàåì, ÷òî åñëè ýòî ïîçèöèÿ, òî îíà çàêðûëàñü
		OrderClosed = true;
		// ïðåäïîëàãàåì, ÷òî åñëè ýòî áûë îòëîæåííûé îðäåð, òî îí íå ñðàáîòàë
		PendingOrderOpened = false;

		// ïåðåáèðàåì âñå ïîçèöèè èç òåêóùåãî ñïèñêà îòêðûòûõ ïîçèöèé
		for ( now_CurOrder = 0; now_CurOrder < now_OrdersTotal; now_CurOrder ++ )
		{
			// åñëè ïîçèöèÿ ñ òàêèì òèêåòîì åñòü â ñïèñêå,
			if ( ticket == now_OrdersArray[now_CurOrder][0] )
			{
				// çíà÷èò ïîçèöèÿ íå áûëà çàêðûòà (îðäåð íå áûë óäàë¸í)
				OrderClosed = false;

				// åñëè å¸ òèï ïîìåíÿëñÿ,
				if ( type != now_OrdersArray[now_CurOrder][1] )
				{
					// çíà÷èò ýòî áûë îòëîæåííûé îðäåð, è îí ñðàáîòàë
					PendingOrderOpened = true;
				}
				break;
			}
		}
		// åñëè áûëà çàêðûòà ïîçèöèÿ (óäàë¸í îðäåð),
		if ( OrderClosed )
		{
			// âûáèðàåì å¸
			if ( !OrderSelect( ticket, SELECT_BY_TICKET ) )
			{
				_GetLastError = GetLastError();
				Print( "OrderSelect( ", ticket, ", SELECT_BY_TICKET ) - Error #", _GetLastError );
				continue;
			}
			// è îïðåäåëÿåì, ÊÀÊ çàêðûëàñü ïîçèöèÿ (óäàëèëñÿ îðäåð):
			if ( type < 2 )
			{
				// Áàé è Ñåëë: 0 - âðó÷íóþ, 1 - ÑË, 2 - ÒÏ
				close_type = 0;
				if ( StringFind( OrderComment(), "[sl]" ) >= 0 ) close_type = 1;
				if ( StringFind( OrderComment(), "[tp]" ) >= 0 ) close_type = 2;
			}
			else
			{
				// Îòëîæåííûå îðäåðà: 0 - âðó÷íóþ, 1 - âðåìÿ èñòå÷åíèÿ
				close_type = 0;
				if ( StringFind( OrderComment(), "expiration" ) >= 0 ) close_type = 1;
			}
			
			// è çàïèñûâàåì â ìàññèâ çàêðûòûõ îðäåðîâ, ÷òî îðäåð ñ òèïîì type 
			// çàêðûëñÿ ïðè îáñòîÿòåëüñòâàõ close_type
			now_ClosedOrdersArray[type][close_type] ++;
			continue;
		}
		// åñëè ñðàáîòàë îòëîæåííûé îðäåð,
		if ( PendingOrderOpened )
		{
			// çàïèñûâàåì â ìàññèâ ñðàáîòàâøèõ îðäåðîâ, ÷òî îðäåð ñ òèïîì type ñðàáîòàë
			now_OpenedPendingOrders[type-2] ++;
			continue;
		}
	}

	//+------------------------------------------------------------------+
	//| Âñþ íåîáõîäèìóþ èíôîðìàöèþ ñîáðàëè - íàçíà÷àåì ïåðåìåííûì ñîáûòèé íóæíûå çíà÷åíèÿ
	//+------------------------------------------------------------------+
	// åñëè ýòî íå ïåðâûé çàïóñê ýêñïåðòà
	if ( !first )
	{
		// ïåðåáèðàåì âñå ýëåìåíòû ìàññèâà ñðàáàòûâàíèÿ îòëîæåííûõ îðäåðîâ
		for ( type = 2; type < 6; type ++ )
		{
			// è åñëè ýëåìåíò íå ïóñòîé (îðäåð òàêîãî òèïà ñðàáîòàë), ìåíÿåì çíà÷åíèå ïåðåìåííîé
			if ( now_OpenedPendingOrders[type-2] > 0 )
				SetOpenEvent( type );
		}

		// ïåðåáèðàåì âñå ýëåìåíòû ìàññèâà çàêðûòûõ ïîçèöèé
		for ( type = 0; type < 6; type ++ )
		{
			for ( close_type = 0; close_type < 3; close_type ++ )
			{
				// è åñëè ýëåìåíò íå ïóñòîé (áûëà çàêðûòà ïîçèöèÿ), ìåíÿåì çíà÷åíèå ïåðåìåííîé
				if ( now_ClosedOrdersArray[type][close_type] > 0 )
					SetCloseEvent( type, close_type );
			}
		}
	}
	else
	{
		first = false;
	}

	//---- ñîõðàíÿåì ìàññèâ òåêóùèõ ïîçèöèé â ìàññèâ ïðåäûäóùèõ ïîçèöèé
	ArrayResize( pre_OrdersArray, MathMax( now_OrdersTotal, 1 ) );
	for ( now_CurOrder = 0; now_CurOrder < now_OrdersTotal; now_CurOrder ++ )
	{
		pre_OrdersArray[now_CurOrder][0] = now_OrdersArray[now_CurOrder][0];
		pre_OrdersArray[now_CurOrder][1] = now_OrdersArray[now_CurOrder][1];
	}
	pre_OrdersTotal = now_OrdersTotal;
}
void SetOpenEvent( int SetOpenEvent_type )
{
	switch ( SetOpenEvent_type )
	{
		case OP_BUYLIMIT: eventBuyLimitOpened ++; return(0);
		case OP_BUYSTOP: eventBuyStopOpened ++; return(0);
		case OP_SELLLIMIT: eventSellLimitOpened ++; return(0);
		case OP_SELLSTOP: eventSellStopOpened ++; return(0);
	}
}
void SetCloseEvent( int SetCloseEvent_type, int SetCloseEvent_close_type )
{
	switch ( SetCloseEvent_type )
	{
		case OP_BUY:
		{
			if ( SetCloseEvent_close_type == 1 ) eventBuyClosed_SL ++;
			if ( SetCloseEvent_close_type == 2 ) eventBuyClosed_TP ++;
			return(0);
		}
		case OP_SELL:
		{
			if ( SetCloseEvent_close_type == 1 ) eventSellClosed_SL ++;
			if ( SetCloseEvent_close_type == 2 ) eventSellClosed_TP ++;
			return(0);
		}
		case OP_BUYLIMIT:
		{
			if ( SetCloseEvent_close_type == 1 ) eventBuyLimitDeleted_Exp ++;
			return(0);
		}
		case OP_BUYSTOP:
		{
			if ( SetCloseEvent_close_type == 1 ) eventBuyStopDeleted_Exp ++;
			return(0);
		}
		case OP_SELLLIMIT:
		{
			if ( SetCloseEvent_close_type == 1 ) eventSellLimitDeleted_Exp ++;
			return(0);
		}
		case OP_SELLSTOP:
		{
			if ( SetCloseEvent_close_type == 1 ) eventSellStopDeleted_Exp ++;
			return(0);
		}
	}
}

bool LoadVariables( string& variables[], string file_name = "" )
{
	if ( IsTesting() ) return(true);

	int all = ArraySize( variables ), cur;
	for ( cur = 0; cur < all; cur ++ ) variables[cur] = "";

	if ( file_name == "" ) file_name = StringConcatenate( "_ExpertSaves\\", WindowExpertName(), " (", Symbol(), ", ", strPeriod( Period() ), ", ", _MagicNumber, ").dat" );
	int handle  = FileOpen( file_name, FILE_CSV | FILE_READ ), _GetLastError = 0;
	if ( handle < 0 )
	{
		_GetLastError = GetLastError();
		if ( _GetLastError != 4103 ) Print( " LoadVariables() - FileOpen( \"", file_name, "\", FILE_CSV | FILE_READ ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		return(false);
	}

	for ( cur = 0; cur < all; cur ++ )
	{
		variables[cur] = FileReadString( handle );
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " LoadVariables() - FileReadString( ", handle, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			FileClose( handle );
			return(false);
		}
	}

	FileClose( handle );
	return(true);
}
void SaveVariables( string variables[], string file_name = "" )
{
	if ( IsTesting() ) return(true);

	if ( file_name == "" ) file_name = StringConcatenate( "_ExpertSaves\\", WindowExpertName(), " (", Symbol(), ", ", strPeriod( Period() ), ", ", _MagicNumber, ").dat" );
	int handle  = FileOpen( file_name, FILE_CSV | FILE_WRITE ), _GetLastError = 0;
	if ( handle < 0 )
	{
		_GetLastError = GetLastError();
		Print( " SaveVariables() - FileOpen( \"", file_name, "\", FILE_CSV | FILE_WRITE ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		return(-1);
	}

	int all = ArraySize( variables ), cur;
	for ( cur = 0; cur < all; cur ++ )
	{
		if ( FileWrite( handle, variables[cur] ) < 0 )
		{
			_GetLastError = GetLastError();
			Print( " SaveVariables() - FileWrite( ", handle, ", ", variables[cur], " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			break;
		}
	}

	FileClose( handle );
}


//=====START=================================================
int init()
{
	TradeInfoLib_Initialization ( Expert_Id, "SU3D[v5]" );
	return(0);
}

int deinit()
{
	TradeInfoLib_Deinitialization();
	return(0);
}

int start()
{


if (Symbol()== "GBPUSD" && Period()==60) {PipStep = 50; LotExponent=1.35;}
if (Symbol()== "EURUSD" && Period()==60) {PipStep = 40; LotExponent=1.35;}
if (Symbol()== "EURJPY" && Period()==60) {PipStep = 50; LotExponent=1.45;}
if (Symbol()== "USDJPY" && Period()==60) {PipStep = 40; LotExponent=1.35;}
if (Symbol()== "AUDCAD" && Period()==60) {PipStep = 30; LotExponent=1.35;}


if (TotalEquityRisk>5) TotalEquityRisk = 5;

//EURAUD TotalEquityRisk = 2; PipStep = 70; LotExponent=1.25; MaxTrades=18;++18000_89929
//EURCHF TotalEquityRisk = 5; PipStep = 40; LotExponent=1.35;MaxTrades=18;++14000_9577
//GBPCHF TotalEquityRisk = 3; PipStep = 60; LotExponent=1.25;MaxTrades=18;+++14000_89044
//AUDCHF TotalEquityRisk = 4; PipStep = 60; LotExponent=1.35; MaxTrades=18;+ 18000_56855
//AUDJPY TotalEquityRisk = 2; PipStep = 60; LotExponent=1.25; MaxTrades=18;+ 18000_54701
//AUDCAD TotalEquityRisk = 5; PipStep = 30; LotExponent=1.35; MaxTrades=18;+++10000_239558
//CADCHF TotalEquityRisk = 4; PipStep = 50; LotExponent=1.25; MaxTrades=18;12000_34508
//CADJPY TotalEquityRisk = 2; PipStep = 60; LotExponent=1.35; MaxTrades=18;16000_36902
//NZDJPY TotalEquityRisk = 3; PipStep = 50; LotExponent=1.25; MaxTrades=18;16000_55597 

if (Symbol()!= "GBPUSD" 
&& Symbol()!= "AUDCAD"
&& Symbol()!= "EURJPY" 
&& Symbol()!= "USDJPY" 
&& Symbol()!= "EURUSD") 
{Comment("=============================","\n",
"EXPERT STOPPED! Invalid Symbol",
"\n","=============================");
Print ("EXPERT STOPPED! Invalid Symbol");   
return(0);
}

if (Period()!=60)
{Comment("=============================","\n",
   "EXPERT STOPPED! Invalid Period ",
"\n","=============================");
Print ("EXPERT STOPPED! Invalid Period");   
   return(0);
}

StartLot_b = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts),3));
StartLot_s = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts),3));


 if ((StartLot_b < 0.02) || (StartLot_s < 0.02))
    {
     Comment("=============================","\n",
     "EXPERT STOPPED!","\n",
      "Ballans = $",AccountBalance(),"\n",
      "Ballans not less =$", (((10-TotalEquityRisk)*100000*Charts)*0.02)," for work on ",Charts," ñharts, ","Symbol - ", Symbol(),",",Period(),"\n",
      "=============================");
      
      Print ("EXPERT STOPPED! Ballans = $",AccountBalance()," Ballans not less =$", (((10-TotalEquityRisk)*100000*Charts)*0.02)," for work on ",Charts," ñharts"); 
      
      return(0);  
      }
//===================Date&Time===============================  
  if(Year()< 2008 )  return(0);// C êàêîãî ãîäà ðàáîòàåò ýêñïåðò!!!
  if (Year()== Years 
  && Month()>= Months// Åñëè âðåìÿ áîëåå âûõîä
  && Day()>= Days
   )  
     {
      Comment("\n","\n","\n","\n","=============================","\n",
      "Current time is ",TimeToStr(CurTime()),"\n",
      "WORK OF THE EXPERT UP TO ",Years,".","0",Months,".","0",Days,"\n",
      "For the help to mailto: sgibnev@bk.ru","\n","=============================");
      Print ("WORK OF THE EXPERT UP TO ",Years,".","0",Months,".","0",Days);
      
      return(0);  
       } 

//==================================================
  
//	if ( IsTesting()!= true )
//	if (IsVisualMode()!= true)
//	if (AccountNumber() != Account1 && AccountNumber() != Account2 && AccountNumber() != Account3) 
//	  	{	
				
//		Comment("=============================","\n",
 //    "EXPERT STOPPED! Invalid Account","\n",
 //    "For the help to mailto: sgibnev@bk.ru",
 //   "\n","=============================");
 //    Print ("EXPERT STOPPED! Invalid Account");   
 //    return(0);  
//	}


//====================================================

	if ( !IsOK() ) { return(0); }

	int _GetLastError, _OrdersTotal = OrdersTotal();

	double l, op;
	double max_lot_b = 0.0, level_b = 0.0, summ_lot_b = 0.0, ave_price_b = 0.0; int count_b = 0; static int last_b = 0;
	double max_lot_s = 0.0, level_s = 0.0, summ_lot_s = 0.0, ave_price_s = 0.0; int count_s = 0; static int last_s = 0;


	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
	//=============================
		 

	
		//================================================	
		if ( !OrderSelect( z, SELECT_BY_POS, MODE_TRADES ) )
		{
			_GetLastError = GetLastError();
			Print( "OrderSelect( ", z, ", SELECT_BY_POS, MODE_TRADES ) - Error #", _GetLastError );
			continue;
		}
		if ( OrderMagicNumber() != _MagicNumber || OrderSymbol() != _Symbol ) continue;

		l = OrderLots();
		op = OrderOpenPrice();

		if ( OrderType() == OP_BUY )
		{
			count_b ++;
			summ_lot_b += l;
			ave_price_b += op*l;
			if ( l > max_lot_b )
			{
				max_lot_b = l;
				level_b = op;
			}
		}

		if ( OrderType() == OP_SELL )
		{
			count_s ++;
			summ_lot_s += l;
			ave_price_s += op*l;
			if ( l > max_lot_s )
			{
				max_lot_s = l;
				level_s = op;
			}
		}
	}

	// check fo close
	if ( max_lot_b > 0.0 )
	{
		ave_price_b = NormalizeDouble( ave_price_b/summ_lot_b, _Digits );
		if ( NormalizeDouble( Bid - ave_price_b - TakeProfit*_Point, _Digits ) >= 0.0 )
		{
			if ( !CloseAll( OP_BUY ) ) return(-1);
			max_lot_b = 0.0;
		}
		if ( StopLoss > 0 && count_b >= MaxTrades )
		{
			if ( NormalizeDouble( level_b - Bid - StopLoss*_Point, _Digits ) >= 0.0 )
			{
				Print( "StopLoss for BUY!" );
				if ( !CloseAll( OP_BUY ) ) return(-1);
				max_lot_b = 0.0;
			}
		}
	}
	if ( max_lot_s > 0.0 )
	{
		ave_price_s = NormalizeDouble( ave_price_s/summ_lot_s, _Digits );
		if ( NormalizeDouble( ave_price_s - Ask - TakeProfit*_Point, _Digits ) >= 0.0 )
		{
			if ( !CloseAll( OP_SELL ) ) return(-1);
			max_lot_s = 0.0;
		}
		if ( StopLoss > 0 && count_s >= MaxTrades )
		{
			if ( NormalizeDouble( Ask - level_s - StopLoss*_Point, _Digits ) >= 0.0 )
			{
				Print( "StopLoss for SELL!" );
				if ( !CloseAll( OP_SELL ) ) return(-1);
				max_lot_s = 0.0;
			}
		}
	}

  if ( aSTLM[1]>0 && count_s>0) StartLot_b = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts/TotalEquityRisk/Profit*2),2));
  //  if ( L2A && count_s>0) StartLot_b = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts*TotalEquityRisk),3));
//  if ( L3 && count_s>0) StartLot_b = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts*TotalEquityRisk),3));
  
 if ( aSTLM[1]<0 && count_b>0) StartLot_s = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts/TotalEquityRisk/Profit*2),2));
//  if ( S2A && count_b>0) StartLot_s = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts*TotalEquityRisk),3));
//  if ( S3 && count_b>0) StartLot_s = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts*TotalEquityRisk),3));



//+------------------------------------------------------------------+
//|                                                       stdlib.mqh |
//|                      Copyright © 2004, MetaQuotes Software Corp. |
//|                                       http://www.metaquotes.net/ |
//+------------------------------------------------------------------+
RSTL = 
0.001754385964912*Open[shift]
 +0.001754385964912*Open[shift+1]
 +0.001754385964912*Open[shift+2]
 +0.001754385964912*Open[shift+3]
 +0.001754385964912*Open[shift+4]
 +0.001754385964912*Open[shift+5]
 +0.001754385964912*Open[shift+6]
 +0.001754385964912*Open[shift+7]
 +0.001754385964912*Open[shift+8]
 +0.001754385964912*Open[shift+9]
 +0.001754385964912*Open[shift+10]
 +0.001754385964912*Open[shift+11]
 +0.001754385964912*Open[shift+12]
 +0.001754385964912*Open[shift+13]
 +0.001754385964912*Open[shift+14]
 +0.001754385964912*Open[shift+15]
 +0.001754385964912*Open[shift+16]
 +0.001754385964912*Open[shift+17]
 +0.001754385964912*Open[shift+18]
 +0.001754385964912*Open[shift+19]
 +0.001754385964912*Open[shift+20]
 +0.001754385964912*Open[shift+21]
 +0.001754385964912*Open[shift+22]
 +0.001754385964912*Open[shift+23]
 +0.001754385964912*Open[shift+24]
 +0.001754385964912*Open[shift+25]
 +0.001754385964912*Open[shift+26]
 +0.001754385964912*Open[shift+27]
 +0.001754385964912*Open[shift+28]
 +0.001754385964912*Open[shift+29]
 +0.001754385964912*Open[shift+30]
 +0.001754385964912*Open[shift+31]
 +0.001754385964912*Open[shift+32]
 +0.001754385964912*Open[shift+33]
 +0.001754385964912*Open[shift+34]
 +0.001754385964912*Open[shift+35]
 +0.001754385964912*Open[shift+36]
 +0.001754385964912*Open[shift+37]
 +0.001754385964912*Open[shift+38]
 +0.001754385964912*Open[shift+39]
 +0.001754385964912*Open[shift+40]
 +0.001754385964912*Open[shift+41]
 +0.001754385964912*Open[shift+42]
 +0.001754385964912*Open[shift+43]
 +0.001754385964912*Open[shift+44]
 +0.001754385964912*Open[shift+45]
 +0.001754385964912*Open[shift+46]
 +0.001754385964912*Open[shift+47]
 +0.001754385964912*Open[shift+48]
 +0.001754385964912*Open[shift+49]
 +0.001754385964912*Open[shift+50]
 +0.001754385964912*Open[shift+51]
 +0.001754385964912*Open[shift+52]
 +0.001754385964912*Open[shift+53]
 +0.001754385964912*Open[shift+54]
 +0.001754385964912*Open[shift+55]
 +0.001754385964912*Open[shift+56]
 +0.001754385964912*Open[shift+57]
 +0.001754385964912*Open[shift+58]
 +0.001754385964912*Open[shift+59]
 +0.001754385964912*Open[shift+60]
 +0.001754385964912*Open[shift+61]
 +0.001754385964912*Open[shift+62]
 +0.001754385964912*Open[shift+63]
 +0.001754385964912*Open[shift+64]
 +0.001754385964912*Open[shift+65]
 +0.001754385964912*Open[shift+66]
 +0.001754385964912*Open[shift+67]
 +0.001754385964912*Open[shift+68]
 +0.001754385964912*Open[shift+69]
 +0.001754385964912*Open[shift+70]
 +0.001754385964912*Open[shift+71]
 +0.001754385964912*Open[shift+72]
 +0.001754385964912*Open[shift+73]
 +0.001754385964912*Open[shift+74]
 +0.001754385964912*Open[shift+75]
 +0.001754385964912*Open[shift+76]
 +0.001754385964912*Open[shift+77]
 +0.001754385964912*Open[shift+78]
 +0.001754385964912*Open[shift+79]
 +0.001754385964912*Open[shift+80]
 +0.001754385964912*Open[shift+81]
 +0.001754385964912*Open[shift+82]
 +0.001754385964912*Open[shift+83]
 +0.001754385964912*Open[shift+84]
 +0.001754385964912*Open[shift+85]
 +0.001754385964912*Open[shift+86]
 +0.001754385964912*Open[shift+87]
 +0.001754385964912*Open[shift+88]
 +0.001754385964912*Open[shift+89]
 +0.001754385964912*Open[shift+90]
 +0.001754385964912*Open[shift+91]
 +0.001754385964912*Open[shift+92]
 +0.001754385964912*Open[shift+93]
 +0.001754385964912*Open[shift+94]
 +0.001754385964912*Open[shift+95]
 +0.001754385964912*Open[shift+96]
 +0.001754385964912*Open[shift+97]
 +0.001754385964912*Open[shift+98]
 +0.001754385964912*Open[shift+99]
 +0.001754385964912*Open[shift+100]
 +0.001754385964912*Open[shift+101]
 +0.001754385964912*Open[shift+102]
 +0.001754385964912*Open[shift+103]
 +0.001754385964912*Open[shift+104]
 +0.001754385964912*Open[shift+105]
 +0.001754385964912*Open[shift+106]
 +0.001754385964912*Open[shift+107]
 +0.001754385964912*Open[shift+108]
 +0.001754385964912*Open[shift+109]
 +0.001754385964912*Open[shift+110]
 +0.001754385964912*Open[shift+111]
 +0.001754385964912*Open[shift+112]
 +0.001754385964912*Open[shift+113]
 +0.001754385964912*Open[shift+114]
 +0.001754385964912*Open[shift+115]
 +0.001754385964912*Open[shift+116]
 +0.001754385964912*Open[shift+117]
 +0.001754385964912*Open[shift+118]
 +0.001754385964912*Open[shift+119]
 +0.001754385964912*Open[shift+120]
 +0.001754385964912*Open[shift+121]
 +0.001754385964912*Open[shift+122]
 +0.001754385964912*Open[shift+123]
 +0.001754385964912*Open[shift+124]
 +0.001754385964912*Open[shift+125]
 +0.001754385964912*Open[shift+126]
 +0.001754385964912*Open[shift+127]
 +0.001754385964912*Open[shift+128]
 +0.001754385964912*Open[shift+129]
 +0.001754385964912*Open[shift+130]
 +0.001754385964912*Open[shift+131]
 +0.001754385964912*Open[shift+132]
 +0.001754385964912*Open[shift+133]
 +0.001754385964912*Open[shift+134]
 +0.001754385964912*Open[shift+135]
 +0.001754385964912*Open[shift+136]
 +0.001754385964912*Open[shift+137]
 +0.001754385964912*Open[shift+138]
 +0.001754385964912*Open[shift+139]
 +0.001754385964912*Open[shift+140]
 +0.001754385964912*Open[shift+141]
 +0.001754385964912*Open[shift+142]
 +0.001754385964912*Open[shift+143]
 +0.001754385964912*Open[shift+144]
 +0.001754385964912*Open[shift+145]
 +0.001754385964912*Open[shift+146]
 +0.001754385964912*Open[shift+147]
 +0.001754385964912*Open[shift+148]
 +0.001754385964912*Open[shift+149]
 +0.001754385964912*Open[shift+150]
 +0.001754385964912*Open[shift+151]
 +0.001754385964912*Open[shift+152]
 +0.001754385964912*Open[shift+153]
 +0.001754385964912*Open[shift+154]
 +0.001754385964912*Open[shift+155]
 +0.001754385964912*Open[shift+156]
 +0.001754385964912*Open[shift+157]
 +0.001754385964912*Open[shift+158]
 +0.001754385964912*Open[shift+159]
 +0.001754385964912*Open[shift+160]
 +0.001754385964912*Open[shift+161]
 +0.001754385964912*Open[shift+162]
 +0.001754385964912*Open[shift+163]
 +0.001754385964912*Open[shift+164]
 +0.001754385964912*Open[shift+165]
 +0.001754385964912*Open[shift+166]
 +0.001754385964912*Open[shift+167]
 +0.001754385964912*Open[shift+168]
 +0.001754385964912*Open[shift+169]
 +0.001754385964912*Open[shift+170]
 +0.001754385964912*Open[shift+171]
 +0.001754385964912*Open[shift+172]
 +0.001754385964912*Open[shift+173]
 +0.001754385964912*Open[shift+174]
 +0.001754385964912*Open[shift+175]
 +0.001754385964912*Open[shift+176]
 +0.001754385964912*Open[shift+177]
 +0.001754385964912*Open[shift+178]
 +0.001754385964912*Open[shift+179]
 +0.001754385964912*Open[shift+180]
 +0.001754385964912*Open[shift+181]
 +0.001754385964912*Open[shift+182]
 +0.001754385964912*Open[shift+183]
 +0.001754385964912*Open[shift+184]
 +0.001754385964912*Open[shift+185]
 +0.001754385964912*Open[shift+186]
 +0.001754385964912*Open[shift+187]
 +0.001754385964912*Open[shift+188]
 +0.001754385964912*Open[shift+189]
 +0.001754385964912*Open[shift+190]
 +0.001754385964912*Open[shift+191]
 +0.001754385964912*Open[shift+192]
 +0.001754385964912*Open[shift+193]
 +0.001754385964912*Open[shift+194]
 +0.001754385964912*Open[shift+195]
 +0.001754385964912*Open[shift+196]
 +0.001754385964912*Open[shift+197]
 +0.001754385964912*Open[shift+198]
 +0.001754385964912*Open[shift+199]
 +0.001754385964912*Open[shift+200]
 +0.001754385964912*Open[shift+201]
 +0.001754385964912*Open[shift+202]
 +0.001754385964912*Open[shift+203]
 +0.001754385964912*Open[shift+204]
 +0.001754385964912*Open[shift+205]
 +0.001754385964912*Open[shift+206]
 +0.001754385964912*Open[shift+207]
 +0.001754385964912*Open[shift+208]
 +0.001754385964912*Open[shift+209]
 +0.001754385964912*Open[shift+210]
 +0.001754385964912*Open[shift+211]
 +0.001754385964912*Open[shift+212]
 +0.001754385964912*Open[shift+213]
 +0.001754385964912*Open[shift+214]
 +0.001754385964912*Open[shift+215]
 +0.001754385964912*Open[shift+216]
 +0.001754385964912*Open[shift+217]
 +0.001754385964912*Open[shift+218]
 +0.001754385964912*Open[shift+219]
 +0.001754385964912*Open[shift+220]
 +0.001754385964912*Open[shift+221]
 +0.001754385964912*Open[shift+222]
 +0.001754385964912*Open[shift+223]
 +0.001754385964912*Open[shift+224]
 +0.001754385964912*Open[shift+225]
 +0.001754385964912*Open[shift+226]
 +0.001754385964912*Open[shift+227]
 +0.001754385964912*Open[shift+228]
 +0.001754385964912*Open[shift+229]
 +0.001754385964912*Open[shift+230]
 +0.001754385964912*Open[shift+231]
 +0.001754385964912*Open[shift+232]
 +0.001754385964912*Open[shift+233]
 +0.001754385964912*Open[shift+234]
 +0.001754385964912*Open[shift+235]
 +0.001754385964912*Open[shift+236]
 +0.001754385964912*Open[shift+237]
 +0.001754385964912*Open[shift+238]
 +0.001754385964912*Open[shift+239]
 +0.001754385964912*Open[shift+240]
 +0.001754385964912*Open[shift+241]
 +0.001754385964912*Open[shift+242]
 +0.001754385964912*Open[shift+243]
 +0.001754385964912*Open[shift+244]
 +0.001754385964912*Open[shift+245]
 +0.001754385964912*Open[shift+246]
 +0.001754385964912*Open[shift+247]
 +0.001754385964912*Open[shift+248]
 +0.001754385964912*Open[shift+249]
 +0.001754385964912*Open[shift+250]
 +0.001754385964912*Open[shift+251]
 +0.001754385964912*Open[shift+252]
 +0.001754385964912*Open[shift+253]
 +0.001754385964912*Open[shift+254]
 +0.001754385964912*Open[shift+255]
 +0.001754385964912*Open[shift+256]
 +0.001754385964912*Open[shift+257]
 +0.001754385964912*Open[shift+258]
 +0.001754385964912*Open[shift+259]
 +0.001754385964912*Open[shift+260]
 +0.001754385964912*Open[shift+261]
 +0.001754385964912*Open[shift+262]
 +0.001754385964912*Open[shift+263]
 +0.001754385964912*Open[shift+264]
 +0.001754385964912*Open[shift+265]
 +0.001754385964912*Open[shift+266]
 +0.001754385964912*Open[shift+267]
 +0.001754385964912*Open[shift+268]
 +0.001754385964912*Open[shift+269]
 +0.001754385964912*Open[shift+270]
 +0.001754385964912*Open[shift+271]
 +0.001754385964912*Open[shift+272]
 +0.001754385964912*Open[shift+273]
 +0.001754385964912*Open[shift+274]
 +0.001754385964912*Open[shift+275]
 +0.001754385964912*Open[shift+276]
 +0.001754385964912*Open[shift+277]
 +0.001754385964912*Open[shift+278]
 +0.001754385964912*Open[shift+279]
 +0.001754385964912*Open[shift+280]
 +0.001754385964912*Open[shift+281]
 +0.001754385964912*Open[shift+282]
 +0.001754385964912*Open[shift+283]
 +0.001754385964912*Open[shift+284]
 +0.001754385964912*Open[shift+285]
 +0.001754385964912*Open[shift+286]
 +0.001754385964912*Open[shift+287]
 +0.001754385964912*Open[shift+288]
 +0.001754385964912*Open[shift+289]
 +0.001754385964912*Open[shift+290]
 +0.001754385964912*Open[shift+291]
 +0.001754385964912*Open[shift+292]
 +0.001754385964912*Open[shift+293]
 +0.001754385964912*Open[shift+294]
 +0.001754385964912*Open[shift+295]
 +0.001754385964912*Open[shift+296]
 +0.001754385964912*Open[shift+297]
 +0.001754385964912*Open[shift+298]
 +0.001754385964912*Open[shift+299]
 +0.001754385964912*Open[shift+300]
 +0.001754385964912*Open[shift+301]
 +0.001754385964912*Open[shift+302]
 +0.001754385964912*Open[shift+303]
 +0.001754385964912*Open[shift+304]
 +0.001754385964912*Open[shift+305]
 +0.001754385964912*Open[shift+306]
 +0.001754385964912*Open[shift+307]
 +0.001754385964912*Open[shift+308]
 +0.001754385964912*Open[shift+309]
 +0.001754385964912*Open[shift+310]
 +0.001754385964912*Open[shift+311]
 +0.001754385964912*Open[shift+312]
 +0.001754385964912*Open[shift+313]
 +0.001754385964912*Open[shift+314]
 +0.001754385964912*Open[shift+315]
 +0.001754385964912*Open[shift+316]
 +0.001754385964912*Open[shift+317]
 +0.001754385964912*Open[shift+318]
 +0.001754385964912*Open[shift+319]
 +0.001754385964912*Open[shift+320]
 +0.001754385964912*Open[shift+321]
 +0.001754385964912*Open[shift+322]
 +0.001754385964912*Open[shift+323]
 +0.001754385964912*Open[shift+324]
 +0.001754385964912*Open[shift+325]
 +0.001754385964912*Open[shift+326]
 +0.001754385964912*Open[shift+327]
 +0.001754385964912*Open[shift+328]
 +0.001754385964912*Open[shift+329]
 +0.001754385964912*Open[shift+330]
 +0.001754385964912*Open[shift+331]
 +0.001754385964912*Open[shift+332]
 +0.001754385964912*Open[shift+333]
 +0.001754385964912*Open[shift+334]
 +0.001754385964912*Open[shift+335]
 +0.001754385964912*Open[shift+336]
 +0.001754385964912*Open[shift+337]
 +0.001754385964912*Open[shift+338]
 +0.001754385964912*Open[shift+339]
 +0.001754385964912*Open[shift+340]
 +0.001754385964912*Open[shift+341]
 +0.001754385964912*Open[shift+342]
 +0.001754385964912*Open[shift+343]
 +0.001754385964912*Open[shift+344]
 +0.001754385964912*Open[shift+345]
 +0.001754385964912*Open[shift+346]
 +0.001754385964912*Open[shift+347]
 +0.001754385964912*Open[shift+348]
 +0.001754385964912*Open[shift+349]
 +0.001754385964912*Open[shift+350]
 +0.001754385964912*Open[shift+351]
 +0.001754385964912*Open[shift+352]
 +0.001754385964912*Open[shift+353]
 +0.001754385964912*Open[shift+354]
 +0.001754385964912*Open[shift+355]
 +0.001754385964912*Open[shift+356]
 +0.001754385964912*Open[shift+357]
 +0.001754385964912*Open[shift+358]
 +0.001754385964912*Open[shift+359]
 +0.001754385964912*Open[shift+360]
 +0.001754385964912*Open[shift+361]
 +0.001754385964912*Open[shift+362]
 +0.001754385964912*Open[shift+363]
 +0.001754385964912*Open[shift+364]
 +0.001754385964912*Open[shift+365]
 +0.001754385964912*Open[shift+366]
 +0.001754385964912*Open[shift+367]
 +0.001754385964912*Open[shift+368]
 +0.001754385964912*Open[shift+369]
 +0.001754385964912*Open[shift+370]
 +0.001754385964912*Open[shift+371]
 +0.001754385964912*Open[shift+372]
 +0.001754385964912*Open[shift+373]
 +0.001754385964912*Open[shift+374]
 +0.001754385964912*Open[shift+375]
 +0.001754385964912*Open[shift+376]
 +0.001754385964912*Open[shift+377]
 +0.001754385964912*Open[shift+378]
 +0.001754385964912*Open[shift+379]
 +0.001754385964912*Open[shift+380]
 +0.001754385964912*Open[shift+381]
 +0.001754385964912*Open[shift+382]
 +0.001754385964912*Open[shift+383]
 +0.001754385964912*Open[shift+384]
 +0.001754385964912*Open[shift+385]
 +0.001754385964912*Open[shift+386]
 +0.001754385964912*Open[shift+387]
 +0.001754385964912*Open[shift+388]
 +0.001754385964912*Open[shift+389]
 +0.001754385964912*Open[shift+390]
 +0.001754385964912*Open[shift+391]
 +0.001754385964912*Open[shift+392]
 +0.001754385964912*Open[shift+393]
 +0.001754385964912*Open[shift+394]
 +0.001754385964912*Open[shift+395]
 +0.001754385964912*Open[shift+396]
 +0.001754385964912*Open[shift+397]
 +0.001754385964912*Open[shift+398]
 +0.001754385964912*Open[shift+399]
 +0.001754385964912*Open[shift+400]
 +0.001754385964912*Open[shift+401]
 +0.001754385964912*Open[shift+402]
 +0.001754385964912*Open[shift+403]
 +0.001754385964912*Open[shift+404]
 +0.001754385964912*Open[shift+405]
 +0.001754385964912*Open[shift+406]
 +0.001754385964912*Open[shift+407]
 +0.001754385964912*Open[shift+408]
 +0.001754385964912*Open[shift+409]
 +0.001754385964912*Open[shift+410]
 +0.001754385964912*Open[shift+411]
 +0.001754385964912*Open[shift+412]
 +0.001754385964912*Open[shift+413]
 +0.001754385964912*Open[shift+414]
 +0.001754385964912*Open[shift+415]
 +0.001754385964912*Open[shift+416]
 +0.001754385964912*Open[shift+417]
 +0.001754385964912*Open[shift+418]
 +0.001754385964912*Open[shift+419]
 +0.001754385964912*Open[shift+420]
 +0.001754385964912*Open[shift+421]
 +0.001754385964912*Open[shift+422]
 +0.001754385964912*Open[shift+423]
 +0.001754385964912*Open[shift+424]
 +0.001754385964912*Open[shift+425]
 +0.001754385964912*Open[shift+426]
 +0.001754385964912*Open[shift+427]
 +0.001754385964912*Open[shift+428]
 +0.001754385964912*Open[shift+429]
 +0.001754385964912*Open[shift+430]
 +0.001754385964912*Open[shift+431]
 +0.001754385964912*Open[shift+432]
 +0.001754385964912*Open[shift+433]
 +0.001754385964912*Open[shift+434]
 +0.001754385964912*Open[shift+435]
 +0.001754385964912*Open[shift+436]
 +0.001754385964912*Open[shift+437]
 +0.001754385964912*Open[shift+438]
 +0.001754385964912*Open[shift+439]
 +0.001754385964912*Open[shift+440]
 +0.001754385964912*Open[shift+441]
 +0.001754385964912*Open[shift+442]
 +0.001754385964912*Open[shift+443]
 +0.001754385964912*Open[shift+444]
 +0.001754385964912*Open[shift+445]
 +0.001754385964912*Open[shift+446]
 +0.001754385964912*Open[shift+447]
 +0.001754385964912*Open[shift+448]
 +0.001754385964912*Open[shift+449]
 +0.001754385964912*Open[shift+450]
 +0.001754385964912*Open[shift+451]
 +0.001754385964912*Open[shift+452]
 +0.001754385964912*Open[shift+453]
 +0.001754385964912*Open[shift+454]
 +0.001754385964912*Open[shift+455]
 +0.001754385964912*Open[shift+456]
 +0.001754385964912*Open[shift+457]
 +0.001754385964912*Open[shift+458]
 +0.001754385964912*Open[shift+459]
 +0.001754385964912*Open[shift+460]
 +0.001754385964912*Open[shift+461]
 +0.001754385964912*Open[shift+462]
 +0.001754385964912*Open[shift+463]
 +0.001754385964912*Open[shift+464]
 +0.001754385964912*Open[shift+465]
 +0.001754385964912*Open[shift+466]
 +0.001754385964912*Open[shift+467]
 +0.001754385964912*Open[shift+468]
 +0.001754385964912*Open[shift+469]
 +0.001754385964912*Open[shift+470]
 +0.001754385964912*Open[shift+471]
 +0.001754385964912*Open[shift+472]
 +0.001754385964912*Open[shift+473]
 +0.001754385964912*Open[shift+474]
 +0.001754385964912*Open[shift+475]
 +0.001754385964912*Open[shift+476]
 +0.001754385964912*Open[shift+477]
 +0.001754385964912*Open[shift+478]
 +0.001754385964912*Open[shift+479]
 +0.001754385964912*Open[shift+480]
 +0.001754385964912*Open[shift+481]
 +0.001754385964912*Open[shift+482]
 +0.001754385964912*Open[shift+483]
 +0.001754385964912*Open[shift+484]
 +0.001754385964912*Open[shift+485]
 +0.001754385964912*Open[shift+486]
 +0.001754385964912*Open[shift+487]
 +0.001754385964912*Open[shift+488]
 +0.001754385964912*Open[shift+489]
 +0.001754385964912*Open[shift+490]
 +0.001754385964912*Open[shift+491]
 +0.001754385964912*Open[shift+492]
 +0.001754385964912*Open[shift+493]
 +0.001754385964912*Open[shift+494]
 +0.001754385964912*Open[shift+495]
 +0.001754385964912*Open[shift+496]
 +0.001754385964912*Open[shift+497]
 +0.001754385964912*Open[shift+498]
 +0.001754385964912*Open[shift+499]
 +0.001754385964912*Open[shift+500]
 +0.001754385964912*Open[shift+501]
 +0.001754385964912*Open[shift+502]
 +0.001754385964912*Open[shift+503]
 +0.001754385964912*Open[shift+504]
 +0.001754385964912*Open[shift+505]
 +0.001754385964912*Open[shift+506]
 +0.001754385964912*Open[shift+507]
 +0.001754385964912*Open[shift+508]
 +0.001754385964912*Open[shift+509]
 +0.001754385964912*Open[shift+510]
 +0.001754385964912*Open[shift+511]
 +0.001754385964912*Open[shift+512]
 +0.001754385964912*Open[shift+513]
 +0.001754385964912*Open[shift+514]
 +0.001754385964912*Open[shift+515]
 +0.001754385964912*Open[shift+516]
 +0.001754385964912*Open[shift+517]
 +0.001754385964912*Open[shift+518]
 +0.001754385964912*Open[shift+519]
 +0.001754385964912*Open[shift+520]
 +0.001754385964912*Open[shift+521]
 +0.001754385964912*Open[shift+522]
 +0.001754385964912*Open[shift+523]
 +0.001754385964912*Open[shift+524]
 +0.001754385964912*Open[shift+525]
 +0.001754385964912*Open[shift+526]
 +0.001754385964912*Open[shift+527]
 +0.001754385964912*Open[shift+528]
 +0.001754385964912*Open[shift+529]
 +0.001754385964912*Open[shift+530]
 +0.001754385964912*Open[shift+531]
 +0.001754385964912*Open[shift+532]
 +0.001754385964912*Open[shift+533]
 +0.001754385964912*Open[shift+534]
 +0.001754385964912*Open[shift+535]
 +0.001754385964912*Open[shift+536]
 +0.001754385964912*Open[shift+537]
 +0.001754385964912*Open[shift+538]
 +0.001754385964912*Open[shift+539]
 +0.001754385964912*Open[shift+540]
 +0.001754385964912*Open[shift+541]
 +0.001754385964912*Open[shift+542]
 +0.001754385964912*Open[shift+543]
 +0.001754385964912*Open[shift+544]
 +0.001754385964912*Open[shift+545]
 +0.001754385964912*Open[shift+546]
 +0.001754385964912*Open[shift+547]
 +0.001754385964912*Open[shift+548]
 +0.001754385964912*Open[shift+549]
 +0.001754385964912*Open[shift+550]
 +0.001754385964912*Open[shift+551]
 +0.001754385964912*Open[shift+552]
 +0.001754385964912*Open[shift+553]
 +0.001754385964912*Open[shift+554]
 +0.001754385964912*Open[shift+555]
 +0.001754385964912*Open[shift+556]
 +0.001754385964912*Open[shift+557]
 +0.001754385964912*Open[shift+558]
 +0.001754385964912*Open[shift+559]
 +0.001754385964912*Open[shift+560]
 +0.001754385964912*Open[shift+561]
 +0.001754385964912*Open[shift+562]
 +0.001754385964912*Open[shift+563]
 +0.001754385964912*Open[shift+564]
 +0.001754385964912*Open[shift+565]
 +0.001754385964912*Open[shift+566]
 +0.001754385964912*Open[shift+567]
 +0.001754385964912*Open[shift+568]
 +0.001754385964912*Open[shift+569];
  

RFTL = 
-0.0025097319*Open[shift+0]
+0.0513007762*Open[shift+1]
+0.1142800493*Open[shift+2]
+0.1699342860*Open[shift+3]
+0.2025269304*Open[shift+4]
+0.2025269304*Open[shift+5]
+0.1699342860*Open[shift+6]
+0.1142800493*Open[shift+7]
+0.0513007762*Open[shift+8]
-0.0025097319*Open[shift+9]
-0.0353166244*Open[shift+10]
-0.0433375629*Open[shift+11]
-0.0311244617*Open[shift+12]
-0.0088618137*Open[shift+13]
+0.0120580088*Open[shift+14]
+0.0233183633*Open[shift+15]
+0.0221931304*Open[shift+16]
+0.0115769653*Open[shift+17]
-0.0022157966*Open[shift+18]
-0.0126536111*Open[shift+19]
-0.0157416029*Open[shift+20]
-0.0113395830*Open[shift+21]
-0.0025905610*Open[shift+22]
+0.0059521459*Open[shift+23]
+0.0105212252*Open[shift+24]
+0.0096970755*Open[shift+25]
+0.0046585685*Open[shift+26]
-0.0017079230*Open[shift+27]
-0.0063513565*Open[shift+28]
-0.0074539350*Open[shift+29]
-0.0050439973*Open[shift+30]
-0.0007459678*Open[shift+31]
+0.0032271474*Open[shift+32]
+0.0051357867*Open[shift+33]
+0.0044454862*Open[shift+34]
+0.0018784961*Open[shift+35]
-0.0011065767*Open[shift+36]
-0.0031162862*Open[shift+37]
-0.0033443253*Open[shift+38]
-0.0022163335*Open[shift+39]
+0.0002573669*Open[shift+40]
+0.0003650790*Open[shift+41]
+0.0060440751*Open[shift+42]
+0.0018747783*Open[shift+43];	

	FATL = 
0.4360409450*Open[shift+0]
+0.3658689069*Open[shift+1]
+0.2460452079*Open[shift+2]
+0.1104506886*Open[shift+3]
-0.0054034585*Open[shift+4]
-0.0760367731*Open[shift+5]
-0.0933058722*Open[shift+6]
-0.0670110374*Open[shift+7]
-0.0190795053*Open[shift+8]
+0.0259609206*Open[shift+9]
+0.0502044896*Open[shift+10]
+0.0477818607*Open[shift+11]
+0.0249252327*Open[shift+12]
-0.0047706151*Open[shift+13]
-0.0272432537*Open[shift+14]
-0.0338917071*Open[shift+15]
-0.0244141482*Open[shift+16]
-0.0055774838*Open[shift+17]
+0.0128149838*Open[shift+18]
+0.0226522218*Open[shift+19]
+0.0208778257*Open[shift+20]
+0.0100299086*Open[shift+21]
-0.0036771622*Open[shift+22]
-0.0136744850*Open[shift+23]
-0.0160483392*Open[shift+24]
-0.0108597376*Open[shift+25]
-0.0016060704*Open[shift+26]
+0.0069480557*Open[shift+27]
+0.0110573605*Open[shift+28]
+0.0095711419*Open[shift+29]
+0.0040444064*Open[shift+30]
-0.0023824623*Open[shift+31]
-0.0067093714*Open[shift+32]
-0.0072003400*Open[shift+33]
-0.0047717710*Open[shift+34]
+0.0005541115*Open[shift+35]
+0.0007860160*Open[shift+36]
+0.0130129076*Open[shift+37]
+0.0040364019*Open[shift+38];

SATL = 
0.0982862174*Open[shift+0]
+0.0975682269*Open[shift+1]
+0.0961401078*Open[shift+2]
+0.0940230544*Open[shift+3]
+0.0912437090*Open[shift+4]
+0.0878391006*Open[shift+5]
+0.0838544303*Open[shift+6]
+0.0793406350*Open[shift+7]
+0.0743569346*Open[shift+8]
+0.0689666682*Open[shift+9]
+0.0632381578*Open[shift+10]
+0.0572428925*Open[shift+11]
+0.0510534242*Open[shift+12]
+0.0447468229*Open[shift+13]
+0.0383959950*Open[shift+14]
+0.0320735368*Open[shift+15]
+0.0258537721*Open[shift+16]
+0.0198005183*Open[shift+17]
+0.0139807863*Open[shift+18]
+0.0084512448*Open[shift+19]
+0.0032639979*Open[shift+20]
-0.0015350359*Open[shift+21]
-0.0059060082*Open[shift+22]
-0.0098190256*Open[shift+23]
-0.0132507215*Open[shift+24]
-0.0161875265*Open[shift+25]
-0.0186164872*Open[shift+26]
-0.0205446727*Open[shift+27]
-0.0219739146*Open[shift+28]
-0.0229204861*Open[shift+29]
-0.0234080863*Open[shift+30]
-0.0234566315*Open[shift+31]
-0.0231017777*Open[shift+32]
-0.0223796900*Open[shift+33]
-0.0213300463*Open[shift+34]
-0.0199924534*Open[shift+35]
-0.0184126992*Open[shift+36]
-0.0166377699*Open[shift+37]
-0.0147139428*Open[shift+38]
-0.0126796776*Open[shift+39]
-0.0105938331*Open[shift+40]
-0.0084736770*Open[shift+41]
-0.0063841850*Open[shift+42]
-0.0043466731*Open[shift+43]
-0.0023956944*Open[shift+44]
-0.0005535180*Open[shift+45]
+0.0011421469*Open[shift+46]
+0.0026845693*Open[shift+47]
+0.0040471369*Open[shift+48]
+0.0052380201*Open[shift+49]
+0.0062194591*Open[shift+50]
+0.0070340085*Open[shift+51]
+0.0076266453*Open[shift+52]
+0.0080376628*Open[shift+53]
+0.0083037666*Open[shift+54]
+0.0083694798*Open[shift+55]
+0.0082901022*Open[shift+56]
+0.0080741359*Open[shift+57]
+0.0077543820*Open[shift+58]
+0.0073260526*Open[shift+59]
+0.0068163569*Open[shift+60]
+0.0062325477*Open[shift+61]
+0.0056078229*Open[shift+62]
+0.0049516078*Open[shift+63]
+0.0161380976*Open[shift+64];


PCCI = Open[shift]-FATL ;

FTLM = FATL - RSTL ;
STLM = SATL - RSTL ;
RBCI = FATL - SATL ;

aRBCI[4]=aRBCI[3] ; 
aRBCI[3]=aRBCI[2] ; 
aRBCI[2]=aRBCI[1] ; 
aRBCI[1]=RBCI ;

aSATL[4]=aSATL[3] ; 
aSATL[3]=aSATL[2] ; 
aSATL[2]=aSATL[1] ; 
aSATL[1]=SATL ;

aFATL[4]=aFATL[4] ; 
aFATL[3]=aFATL[2] ; 
aFATL[2]=aFATL[1] ; 
aFATL[1]=FATL ;

aRFTL[4]=aRFTL[3] ; 
aRFTL[3]=aRFTL[2] ; 
aRFTL[2]=aRFTL[1] ; 
aRFTL[1]=RFTL ;

aRSTL[4]=aRSTL[3] ; 
aRSTL[3]=aRSTL[2] ; 
aRSTL[2]=aRSTL[1] ; 
aRSTL[1]=RSTL ;

aFTLM[4]=aFTLM[3] ; 
aFTLM[3]=aFTLM[2] ; 
aFTLM[2]=aFTLM[1] ; 
aFTLM[1]=FTLM ;

aSTLM[4]=aSTLM[3] ; 
aSTLM[3]=aSTLM[2] ; 
aSTLM[2]=aSTLM[1] ; 
aSTLM[1]=STLM ;


aPCCI[4]=aPCCI[3] ; 
aPCCI[3]=aPCCI[2] ; 
aPCCI[2]=aPCCI[1] ; 
aPCCI[1]=PCCI ;
//===================ARCTAN==================
tFATL = MathArctan(MathAbs(aFATL[1]-aFATL[2])/0.0005)*180/3.1415926;
tRFTL = MathArctan(MathAbs(aRFTL[1]-aRFTL[2])/0.0005)*180/3.1415926;
tSATL = MathArctan(MathAbs(aSATL[1]-aSATL[2])/0.0005)*180/3.1415926;
tRSTL = MathArctan(MathAbs(aRSTL[1]-aRSTL[2])/0.0005)*180/3.1415926;
tFTLM = MathArctan(MathAbs(aFTLM[1]-aFTLM[2])/0.0005)*180/3.1415926;
tRBCI = MathArctan(MathAbs(aRBCI[1]-aRBCI[2])/0.0005)*180/3.1415926;
tSTLM = MathArctan(MathAbs(aSTLM[1]-aSTLM[2])/0.0005)*180/3.1415926;
tPCCI = MathArctan(MathAbs(aPCCI[1]-aPCCI[2])/0.0005)*180/3.1415926;
       
atFATL[2]=atFATL[1];
atFATL[1]=tFATL;





//========== S I G N A L S ========

//================== 1 ============

//================ 5 ================       
L5=


aPCCI[1]<0
//&& aPCCI[2]<0
//&& aPCCI[1]<aPCCI[2]
&& aRBCI[1]<0
//aSTLM[1]>0
//&& aSATL[1]>aSATL[2]
//&& MathAbs(aRBCI[1])>(RBCImax*Point)
//&& MathAbs(aPCCI[1])>(PCCImax*Point)
;
S5=
aPCCI[1]>0
//&& aPCCI[2]>0
//&& aPCCI[1]>aPCCI[2]
&& aRBCI[1]>0
//aSTLM[1]<0
//&& aSATL[1]<aSATL[2]
//&& MathAbs(aRBCI[1])>(RBCImax*Point)
//&& MathAbs(aPCCI[1])>(PCCImax*Point)
;
//================ 6 ===============


Comment 
(
//"\n","\n","\n","\n",
"----------------------------------------------------------------","\n",
"Charts = ",Charts,"\n",
"TotalEquityRisk  = ",TotalEquityRisk,"\n",
"----------------------------------------------------------------","\n",
"Symbol - ", Symbol(),",",Period(),"\n",
"----------------------------------------------------------------","\n",
"AccountNumber # ",AccountNumber(),"\n",
"AccountName - ",AccountName(),"\n",
"----------------------------------------------------------------","\n",
"Ballans = $",NormalizeDouble(AccountBalance(),2),"\n",
"Equity  = $",AccountEquity (),"\n",
//"Margin  = $",AccountMargin (),"\n",
"----------------------------------------------------------------","\n",
"StartLot    LONG = ",NormalizeDouble(StartLot_b,2),"\n",
"ORDERS  LONG = ",count_b,"\n","\n",
"StartLot   SHORT = ",NormalizeDouble(StartLot_s,2),"\n",
"ORDERS SHORT = ",count_s,"\n",
"----------------------------------------------------------------","\n",
"Current time is   ",TimeToStr(CurTime()),"\n",
"EXPERT UP TO ",Years,".","0",Months,".",Days,"\n",
//"Account1=",Account1,", Account2=",Account2,", Account3=",Account3,"\n",
"----------------------------------------------------------------","\n",
"For the help to mailto: sgibnev@bk.ru");


	if ( TradeDirection >= 0    
      &&   count_b < MaxTrades)
	{
		if ( count_b == 0 )
		{
			if (Time[0] > last_b 
//&& L1
//|| L2A
 //|| L3

// || L8
			      )
					{
if(L1 == true) Print("L1 by order opened"," StartLot=", StartLot_b);
if(L2A == true) Print("L2A by order opened"," StartLot=", StartLot_b);
if(L5 == true) Print("L5 by order opened"," StartLot=", StartLot_b);
if(L6 == true) Print("L6 by order opened"," StartLot=", StartLot_b);

//  StartLot = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts),3));

 

			  
			
        //Print( "LastStopLoss for SELL!" );
	    //	if ( !CloseAll( OP_SELL ) ) return(-1);
		//	max_lot_s = 0.0;
		

		
			}
		}
		else

		{
		   //PipStep = PipStep+StepMode;
			if ( level_b -(PipStep*Point)>= Ask ) OpenBuy( LotExponent*max_lot_b );
	       		}
	}

	// check fo sell
	if (TradeDirection <= 0 
      &&  count_s < MaxTrades)
	{
		if ( count_s == 0 )
		{
			if ( Time[0] > last_s 
// && S1
 //|| S2A

			)
				
			{
if(S1 == true) Print("S1 sell order opened"," StartLot=", StartLot_s);
if(S2A == true) Print("S2A sell order opened"," StartLot=", StartLot_s);
if(S5 == true) Print("S5 sell order opened"," StartLot=", StartLot_s);
if(S6 == true) Print("S6 sell order opened"," StartLot=", StartLot_s);
 
 // StartLot = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts),3));

		
		//	 StartLot = (NormalizeDouble(AccountEquity()/((10-TotalEquityRisk)*100000),2));
		
         // Print( "LastStopLoss for BUY!" );
	//	if ( !CloseAll( OP_BUY ) ) return(-1);

		
	//	max_lot_b = 0.0;
                      
           
			}
		}
		else
		
		{
			//if (StepMode>0)OpenSell(PipStep*LotExponent*count_s);
			
			if ( level_s +(PipStep*Point)<= Bid ) OpenSell(LotExponent*max_lot_s);
	//	if (StepMode>0)	PipStepShort = (StepMode*count_s*LotExponent);
		
		}
	}

	return(0);
}
		
			
void OpenBuy( double Lot )
{
	double _OpenPriceLevel, _StopLossLevel = 0.0, _TakeProfitLevel = 0.0;
	_OpenPriceLevel = NormalizeDouble( Ask, _Digits );
	_TakeProfitLevel = 0.0; //NormalizeDouble( Ask + (TakeProfit + 25)*_Point, _Digits );

	double 	lot_min		= MarketInfo( _Symbol, MODE_MINLOT  );
	double 	lot_max		= MarketInfo( _Symbol, MODE_MAXLOT  );
	double 	lot_step		= MarketInfo( _Symbol, MODE_LOTSTEP );

	Lot = NormalizeDouble( Lot / lot_step, 0 ) * lot_step;
	if ( Lot < lot_min ) Lot = lot_min;
	if ( Lot > lot_max ) Lot = lot_max;

	double needmargin = AccountFreeMarginCheck( Symbol(), OP_BUY, Lot );

	if ( needmargin < 5 || GetLastError() == 134 )
	{
		Print( "We have no money!!!" );
		return(-1);
	}

	if ( _OrderSend ( _Symbol, OP_BUY, Lot, _OpenPriceLevel, Slippage, _StopLossLevel, _TakeProfitLevel, "", _MagicNumber ) < 0 )
		Alert( strComment, ": Error opening Long position!" );
}

void OpenSell( double Lot )
{
	double _OpenPriceLevel, _StopLossLevel = 0.0, _TakeProfitLevel = 0.0;
	_OpenPriceLevel = NormalizeDouble( Bid, _Digits );
	_TakeProfitLevel = 0.0; //NormalizeDouble( Bid - (TakeProfit + 25)*_Point, _Digits );

	double 	lot_min		= MarketInfo( _Symbol, MODE_MINLOT  );
	double 	lot_max		= MarketInfo( _Symbol, MODE_MAXLOT  );
	double 	lot_step		= MarketInfo( _Symbol, MODE_LOTSTEP );

	Lot = NormalizeDouble( Lot / lot_step, 0 ) * lot_step;
	if ( Lot < lot_min ) Lot = lot_min;
	if ( Lot > lot_max ) Lot = lot_max;

	double needmargin = AccountFreeMarginCheck( Symbol(), OP_SELL, Lot );

	if ( needmargin < 5 || GetLastError() == 134 )
	{
		Print( "We have no money!!!" );
		return(-1);
	}

	if ( _OrderSend ( _Symbol, OP_SELL, Lot, _OpenPriceLevel, Slippage, _StopLossLevel, _TakeProfitLevel, "", _MagicNumber ) < 0 )
		Alert( strComment, ": Error opening SHORT position!" );
}

bool CloseAll( int type = -1 )
{
	bool result = true;
	int _GetLastError, _OrdersTotal = OrdersTotal();
	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
		if ( !OrderSelect( z, SELECT_BY_POS, MODE_TRADES ) )
		{
			_GetLastError = GetLastError();
			Print( "OrderSelect( ", z, ", SELECT_BY_POS, MODE_TRADES ) - Error #", _GetLastError );
			result = false;
			continue;
		}
		if ( OrderMagicNumber() != _MagicNumber || OrderSymbol() != _Symbol ) continue;
		if ( OrderType() > 1 ) continue;
		if ( type >= 0 && OrderType() != type ) continue;

		if ( _OrderClose( OrderTicket() ) < 0 ) result = false;
	}
	return(result);
}