Need help on unable to loan EA on IG MT4

Dellan · December 30, 2022

Deal all,

I'm new to forex and EA, trying to execute the EA to run a backtesting, but it show error unable to load file, need help regarding this issue.

Due to unable upload EA file, hence I paste the code bellow (is an EA i create by using AlgoWizard "Simple").

//+------------------------------------------------------------------+
//| New strategy EA
//|
//| Generated by StrategyQuant 3.9.132 at 12/30/2022 14:11
//|
//| Backtested on EURUSD / D1, 2021.12.28 - 2022.12.28
//|
//| This EA uses 3rd party library OrderReliable for industry-strength
//| order handling. OrderReliable library is normally distributed under
//| GPL license. Its author provided it under MIT license limited to
//| usage only within strategies generated by StrategyQuant.
//|
//| This means that this library doesn't restrict you to use your EA
//| generated by SQ comercially in any way you want.
//| But if you'll use any method from OrderReliable library outside
//| of this EA in your own EAs or projects, its use will be governed
//| by its standard GPL license.
//|
//| Scroll to the very bottom of this source code for the full text
//| of OrderReliable license.
//+------------------------------------------------------------------+

#property copyright "StrategyQuant.com"
#property link "http://www.StrategyQuant.com"
#property strict

#include <stdlib.mqh>
#include <stderror.mqh>

const int SLPTTYPE_RANGE = 0;
const int SLPTTYPE_LEVEL = 1;

//+------------------------------------------------------------------+
// -- Variables
//+------------------------------------------------------------------+

extern string CustomComment = "New strategy";
extern int MagicNumber = 11111;
bool LongEntrySignal = false;
bool ShortEntrySignal = false;
bool LongExitSignal = false;
bool ShortExitSignal = false;
extern int MABarOpensPeriod = 10;

//+------------------------------------------------------------------+
// Money Management variables
//+------------------------------------------------------------------+

extern string smm = "----------- Money Management - Fixed size -----------";
extern double mmLots = 0.1;

//+------------------------------------------------------------------+
// Trading Options variables
//+------------------------------------------------------------------+

extern string sdtw = "----------- Dont Trade On Weekends -----------";
extern bool DontTradeOnWeekends = false;
extern string FridayCloseTime = "23:00";
extern string SundayOpenTime = "23:00";
extern string seod = "----------- Exit At End Of Day -----------";
extern bool ExitAtEndOfDay = false;
extern string EODExitTime = "23:55";

extern string seof = "----------- Exit On Friday -----------";
extern bool ExitOnFriday = false;
extern string FridayExitTime = "23:00";

extern string sltr = "----------- Limit Time Range -----------";
extern bool LimitTimeRange = false;
extern string SignalTimeRangeFrom = "08:00";
extern string SignalTimeRangeTo = "16:00";
extern bool ExitAtEndOfRange = false;
extern int OrderTypeToExit = 0;

extern string smmmdfmp = "----------- Max distance from market price -----------";
extern bool LimitMaxDistanceFromMarketPrice = false; //Limit max distance
extern double MaxDistanceFromMarketPct = 6; //Max distance %

extern string smtpd = "----------- Max Trades Per Day -----------";
extern int MaxTradesPerDay = 0;
extern string smmslpt = "----------- Min/Max SL/PT -----------";
extern int MinimumSL = 0; //Minimum SL in pips
extern int MinimumPT = 0; //Minimum PT in pips
extern int MaximumSL = 0; //Maximum SL in pips
extern int MaximumPT = 0; //Maximum PT in pips

extern string slts = "----------- Use Tick size from SQ (for CFDs) -----------";
// For exotic pairs (usually non forex CFDs) the default method of computing
// tick size in EA might not work correctly.
// By turning this on and specifying MainChartTickSizeSQ value you can let EA
// use the correct tick size
extern bool UseSQTickSize = false;
extern double MainChartTickSizeSQ = 1.0E-4;

//+------------------------------------------------------------------+
// OrderReliable library variables
//+------------------------------------------------------------------+
string OrderReliableVersion = "v36";
string OrderReliable_Fname = "OrderReliable (Function Name Not Set)";

int    retry_attempts        = 100; // general retry attempts
int    retry_attempts_bad_price = 3; // retry attempts if the error is bad price
double    sleep_time            = 2.0;
double    sleep_maximum        = 20.0;

int ErrorLevel = 3;

bool   UseLimitToMarket    = false;
bool   UseForTesting        = false;
bool   AddSpreadToComment   = false;

//+------------------------------------------------------------------+
// -- SQ internal variables
// add word "extern" in front of the variable you want
// to make configurable
//+------------------------------------------------------------------+
int sqMaxEntrySlippage = 5; //Max tolerated entry slippage in pips. Zero means unlimited slippage
int sqMaxCloseSlippage = 0; //Max tolerated close slippage in pips. Zero means unlimited slippage
bool autoCorrectMaxSlippage = true; //If set to true, it will automatically adjust max slippage according to symbol digits (*10 for 3 and 5 digit symbols)

//Some brokers have problems with updating position counts. Set this timeout to non-zero value if you experience this.
//For example EnterReverseAtMarket doesn't work well for Admiral Markets, because OrdersTotal() returns 1 even after the order has been closed.
uint orderSelectTimeout = 0; //in ms

double sqMinDistance = 0.0;

//+------------------------------------------------------------------+
// Verbose mode values:
// 0 - don't print messages to log at all
// 1 - print messages to log only when trading (not when backtesting)
// 2 - print messages to log always
//+------------------------------------------------------------------+
int sqVerboseMode = 2;

extern bool sqDisplayInfoPanel = true;
extern bool ModifyInsteadOfReplacing = true;

extern int OpenBarDelay = 0; // open bar delay in minutes
// it can be used for Daily strategies to trigger trading a few minutes later -
// because brokers sometimes have technical delay after midnight and we have to postpone order execution

int sqLabelCorner = 1;
int sqOffsetHorizontal = 5;
int sqOffsetVertical = 20;
color sqLabelColor = White;

datetime _sqLastOpenBarTime = 0;
bool _sqIsBarOpen = false;
double gPointCoef = 0;
int _ticket;
bool cond[100];

double initialBalance = 0;

bool openingOrdersAllowed = true;
bool firstCall = true;
bool strategyUsesATM = false;

//////////
//+------------------------------------------------------------------+
// -- Functions
//+------------------------------------------------------------------+

void OnTick() {

sqInitStart();

sqManageOrders(MagicNumber);

openingOrdersAllowed = sqHandleTradingOptions();

//------------------------
// Rule: Trading signals
//------------------------
if (sqIsBarOpen()) {
// init signals only on bar open
LongEntrySignal = (sqGetValue("NULL",0, PRICE_OPEN, 0) > sqMA(NULL,0, MABarOpensPeriod, 0, 1, PRICE_CLOSE, 1));

ShortEntrySignal = (sqGetValue("NULL",0, PRICE_OPEN, 0) < sqMA(NULL,0, MABarOpensPeriod, 0, 1, PRICE_CLOSE, 1));

LongExitSignal = (sqGetValue("NULL",0, PRICE_OPEN, 0) < sqMA(NULL,0, MABarOpensPeriod, 0, 1, PRICE_CLOSE, 1));

ShortExitSignal = (sqGetValue("NULL",0, PRICE_OPEN, 0) > sqMA(NULL,0, MABarOpensPeriod, 0, 1, PRICE_CLOSE, 1));

}

//------------------------
// Rule: Long entry
//------------------------
if (sqIsBarOpen()
&& ((LongEntrySignal
&& (!(ShortEntrySignal)))
&& (!(LongExitSignal))))
{
// Action #1
_ticket = sqOpenOrder(OP_BUY, "Current", mmLots, 0, MagicNumber, "", 0, false, false, CLR_NONE);

if(_ticket > 0 && OrderSelect(_ticket, SELECT_BY_TICKET)) {
// set or initialize all order exit methods (SL, PT, Trailing Stop, Exit After Bars, etc.)
// StopLoss & ProfitTarget

}

//------------------------
// Rule: Short entry
//------------------------
if (sqIsBarOpen()
&& ((ShortEntrySignal
&& (!(LongEntrySignal)))
&& (!(ShortExitSignal))))
{
// Action #1
_ticket = sqOpenOrder(OP_SELL, "Current", mmLots, 0, MagicNumber, "", 0, false, false, CLR_NONE);

if(_ticket > 0 && OrderSelect(_ticket, SELECT_BY_TICKET)) {
// set or initialize all order exit methods (SL, PT, Trailing Stop, Exit After Bars, etc.)
// StopLoss & ProfitTarget

}

//------------------------
// Rule: Long exit
//------------------------
if (sqIsBarOpen()
&& (LongExitSignal
&& sqMarketPositionIsLong(MagicNumber, "Any", "")))
{
// Action #1
sqClosePosition(OrderLots(), // size: SQ.Formulas.CloseSize.FullPosition
MagicNumber, // magic number
"Any", // symbol
1, // direction
"" // comment
);

}

//------------------------
// Rule: Short exit
//------------------------
if (sqIsBarOpen()
&& (ShortExitSignal
&& sqMarketPositionIsShort(MagicNumber, "Any", "")))
{
// Action #1
sqClosePosition(OrderLots(), // size: SQ.Formulas.CloseSize.FullPosition
MagicNumber, // magic number
"Any", // symbol
-1, // direction
"" // comment
);

}

return;
}

//+------------------------------------------------------------------+

int OnInit() {
VerboseLog("--------------------------------------------------------");
VerboseLog("Starting the EA");

if(!checkComments()){
return(INIT_FAILED);
}

gPointCoef = calculatePointCoef(Symbol());

VerboseLog("--------------------------------------------------------");

if(sqDisplayInfoPanel) {
sqInitInfoPanel();
}

SQTime = new CSQTime();

if(!IsTesting() && !IsOptimization()) {
initTimer();
}

initialBalance = AccountInfoDouble(ACCOUNT_BALANCE);

objDontTradeOnWeekends = new CDontTradeOnWeekends();
objExitAtEndOfDay = new CExitAtEndOfDay();
objExitOnFriday = new CExitOnFriday();
objLimitTimeRange = new CLimitTimeRange();
objMaxDistanceFromMarket = new CMaxDistanceFromMarket();
objMaxTradesPerDay = new CMaxTradesPerDay();
objMinMaxSLPT = new CMinMaxSLPT();

double minDistanceMT = NormalizeDouble(MarketInfo(Symbol(), MODE_STOPLEVEL) * MarketInfo(Symbol(), MODE_POINT), Digits);
double minDistanceSQ = NormalizeDouble(sqMinDistance * sqGetPointCoef(Symbol()), Digits);

if(minDistanceSQ < minDistanceMT){
VerboseLog("--------------------------------------------------------");
VerboseLog("Warning! Min distance of this symbol is greater than min distance set in SQ! The backtest results may differ");
VerboseLog("MT min distance: ", DoubleToStr(minDistanceMT), ", SQ min distance: ", DoubleToStr(minDistanceSQ));
VerboseLog("--------------------------------------------------------");
}

//Show all subchart symbols in market watch

return(0);
}

//+------------------------------------------------------------------+

void OnDeinit(const int reason) {
sqDeinitInfoPanel();

delete SQTime;
delete objDontTradeOnWeekends;
delete objExitAtEndOfDay;
delete objExitOnFriday;
delete objLimitTimeRange;
delete objMaxDistanceFromMarket;
delete objMaxTradesPerDay;
delete objMinMaxSLPT;

return;
}

//+------------------------------------------------------------------+

bool checkComments(){
if(StringLen(CustomComment) > 30){
Alert("Strategy initialization error - Comment CustomComment is longer than 30 characters");
return false;
}
return true;
}

//+------------------------------------------------------------------+

void initTimer(){
int period = 20 * 3600; //20 hours
period += MathRand() % (10 * 3600); //add another 0-10 hours randomly

if(!EventSetTimer(period)){
VerboseLog("Cannot set timer. Error code: ", IntegerToString(GetLastError()));
}
}

//+------------------------------------------------------------------+

void OnTimer(){
//clear unused variables
int deletedCount = 0;

VerboseLog("Clearing variables...");

for(int a=GlobalVariablesTotal() - 1; a>=0; a--){
string variableName = GlobalVariableName(a);

if(GlobalVariableCheck(variableName)){
string variableNameParts[];
int parts = StringSplit(variableName, '_', variableNameParts);

if(parts != 3 || variableNameParts[0] != getVariablePrefix()) continue;

int ticketNo = StrToInteger(variableNameParts[1]);

bool variableUsed = false;

for(int i=0; i < OrdersTotal(); i++) {
if(OrderSelect(i, SELECT_BY_POS) == true) {
if(OrderTicket() == ticketNo){
variableUsed = true;
break;
}
}
}

ResetLastError();

if(!variableUsed){
if(GlobalVariableDel(variableName)){
deletedCount++;
}
else {
VerboseLog("Cannot delete variable. Error code: ", IntegerToString(GetLastError()));
}
}
}
}

VerboseLog(IntegerToString(deletedCount), " variables cleared");
}

//+------------------------------------------------------------------+

bool sqHandleTradingOptions() {
bool continueWithBarUpdate = true;

if(!objDontTradeOnWeekends.onBarUpdate()) continueWithBarUpdate = false;
if(!objExitAtEndOfDay.onBarUpdate()) continueWithBarUpdate = false;
if(!objExitOnFriday.onBarUpdate()) continueWithBarUpdate = false;
if(!objLimitTimeRange.onBarUpdate()) continueWithBarUpdate = false;
if(!objMaxDistanceFromMarket.onBarUpdate()) continueWithBarUpdate = false;
if(!objMaxTradesPerDay.onBarUpdate()) continueWithBarUpdate = false;
if(!objMinMaxSLPT.onBarUpdate()) continueWithBarUpdate = false;

return(continueWithBarUpdate);
}

//+------------------------------------------------------------------+

bool checkMagicNumber(int magicNo){
if(magicNo == MagicNumber){
return true;
}
return false;
}

//+------------------------------------------------------------------+

double sqGetMarketTickSize(string symbol){
symbol = correctSymbol(symbol);

if(symbol == Symbol()){
return MainChartTickSizeSQ;
}

return -1;
}

//+------------------------------------------------------------------+

double sqGetGlobalSL(string symbol, int orderType, double price) {
return(sqGetSLLevel(symbol, orderType, price, 1, 0));
}

//+------------------------------------------------------------------+

double sqGetGlobalPT(string symbol, int orderType, double price) {
return(sqGetPTLevel(symbol, orderType, price, 1, 0));
}

//+------------------------------------------------------------------+

double sqGetIndicatorByIdentification(string idHash, int shift) {

return(0);
}

//+------------------------------------------------------------------+

double sqGetValueByIdentification(string idHash) {

if(idHash == (string) sqStringHash("0")) {
return (0);
}

return(0);
}

//----------------------------------------------------------------------------

void sqManageOrders(int magicNumber) {
if(_sqIsBarOpen) {
for(int i=OrdersTotal()-1; i>=0; i--) {
if (OrderSelect(i,SELECT_BY_POS)==true) {
if(OrderMagicNumber() != magicNumber || isMarketClosed(OrderSymbol())) {
continue;
}

int ticket = OrderTicket();

if(OrderType() == OP_BUY || OrderType() == OP_SELL) {
// handle Exit Methods only for live orders

sqManageSL2BE(ticket);
sqManageTrailingStop(ticket);
sqManageExitAfterXBars(ticket);
}

sqManageOrderExpiration(ticket);
}

if(OrdersTotal() <= 0) return;
}
}
}

//----------------------------------------------------------------------------

void sqResetGlobalVariablesForTicket(int ticket) {
sqSetGlobalVariable(ticket, "sqOrderExpiration", 0);
sqSetGlobalVariable(ticket, "sqOrderOpenTime", Time[0]);

sqSetGlobalVariable(ticket, "MoveSL2BE", 0);
sqSetGlobalVariable(ticket, "SL2BEAddPips", 0);
sqSetGlobalVariable(ticket, "TrailingStop", 0);
sqSetGlobalVariable(ticket, "TrailingActivation", 0);
sqSetGlobalVariable(ticket, "ExitAfterBars", 0);

}

//+------------------------------------------------------------------+

void sqInitStart() {
// changed recognition of bar open to support also range/renko charts
if(_sqLastOpenBarTime == 0) {
_sqLastOpenBarTime = Time[0];
_sqIsBarOpen = true;
}
else {
if(_sqLastOpenBarTime != Time[0]) {
bool processBarOpen = true;

if(OpenBarDelay > 0) {
// set bar to open after X minutes from real open
processBarOpen = false;

long diffInSeconds = TimeCurrent() - Time[0];
if(diffInSeconds >= OpenBarDelay * 60) {
processBarOpen = true;
}
}

if(processBarOpen) {
_sqIsBarOpen = true;
_sqLastOpenBarTime = Time[0];
}
}
else {
_sqIsBarOpen = false;
}
}

if(_sqIsBarOpen && Bars<30) {
Print("NOT ENOUGH DATA: Less Bars than 30");
return;
}

if(!IsTesting() && !IsOptimization()) {
sqTextFillOpens();
if(_sqIsBarOpen) {
sqTextFillTotals();
}
}
}

//+------------------------------------------------------------------+

bool sqIsBarOpen() {
return(_sqIsBarOpen);
}

//+------------------------------------------------------------------+

int sqGetOrderExpiration(int ticket) {
return (int) sqGetGlobalVariable(ticket, "sqOrderExpiration");
}

//+------------------------------------------------------------------+

void sqSetOrderExpiration(int ticket, int bars) {
sqSetGlobalVariable(ticket, "sqOrderExpiration", bars);
}

//+------------------------------------------------------------------+

void sqManageOrderExpiration(int ticket) {
int tempValue = 0;
int barsOpen = 0;

// Stop/Limit Order Expiration
if(OrderType() != OP_BUY && OrderType() != OP_SELL) {
// handle only pending orders
tempValue = sqGetOrderExpiration(ticket);
if(tempValue > 0) {
barsOpen = sqGetOpenBarsForOrder(ticket, tempValue+10);
if(barsOpen >= tempValue) {
Verbose("Order with ticket: ", IntegerToString(ticket), " expired");
sqDeletePendingOrder(ticket);
}
}
}
}

//----------------------------------------------------------------------------

double sqIndicatorHighest(int period, int nthValue, string indicatorIdentification) {
if(period > 1000) {
Alert("Period used for sqIndicatorHighest function is too high. Max value is 1000");
period = 1000;
}

if(nthValue < 0 || nthValue >= period) {
return(-1);
}

double indicatorValues[1000];
int i;

for(i=0; i<1000; i++) {
indicatorValues[i] = -2147483647;
}

for(i=0; i<period; i++) {
indicatorValues[i] = sqGetIndicatorByIdentification(indicatorIdentification, i);
}

ArraySort(indicatorValues, WHOLE_ARRAY,0,MODE_DESCEND);

if(nthValue < 0 || nthValue >= period) {
return(-1);
}

return(indicatorValues[nthValue]);
}

//----------------------------------------------------------------------------

double sqIndicatorLowest(int period, int nthValue, string indicatorIdentification) {
if(period > 1000) {
Alert("Period used for sqIndicatorLowest function is too high. Max value is 1000");
period = 1000;
}

if(nthValue < 0 || nthValue >= period) {
return(-1);
}

double indicatorValues[1000];
int i;

for(i=0; i<1000; i++) {
indicatorValues[i] = 2147483647;
}

for(i=0; i<period; i++) {
indicatorValues[i] = sqGetIndicatorByIdentification(indicatorIdentification, i);
}

ArraySort(indicatorValues,WHOLE_ARRAY,0,MODE_ASCEND);

if(nthValue < 0 || nthValue >= period) {
return(-1);
}

return(indicatorValues[nthValue]);
}

//----------------------------------------------------------------------------

double sqIndicatorAverage(int period, int maMethod, string indicatorIdentification) {
double indicatorValues[10000];

for(int i=0; i<period; i++) {
indicatorValues[i] = sqGetIndicatorByIdentification(indicatorIdentification, i);
}

double maValue = iMAOnArray(indicatorValues, period, period, 0, maMethod, 0);

return(maValue);
}

//----------------------------------------------------------------------------

double sqIndicatorRecent(int barsBack, string indicatorIdentification) {
return(sqGetIndicatorByIdentification(indicatorIdentification, barsBack));
}

//----------------------------------------------------------------------------

bool sqIsRising(string indicatorIdentification, int bars, bool allowSameValues, int shift) {
bool atLeastOnce = false;

double previousValue = NormalizeDouble(sqGetIndicatorByIdentification(indicatorIdentification, bars+shift-1), 6);

for(int i=1; i<bars; i++) {
double currentValue = NormalizeDouble(sqGetIndicatorByIdentification(indicatorIdentification, bars+shift-1-i), 6);

if(currentValue < previousValue) {
// indicator was falling
return(false);
}
if(currentValue == previousValue && allowSameValues == false) {
// indicator was the same, not allowed
return(false);
}
if(currentValue > previousValue) {
atLeastOnce = true;
}

previousValue = currentValue;
}

if(atLeastOnce) {
return(true);
}

// indicator was not rising once
return(false);
}

//----------------------------------------------------------------------------

bool sqIsFalling(string indicatorIdentification, int bars, bool allowSameValues, int shift) {
bool atLeastOnce = false;

double previousValue = NormalizeDouble(sqGetIndicatorByIdentification(indicatorIdentification, bars+shift-1), 6);

for(int i=1; i<bars; i++) {
double currentValue = NormalizeDouble(sqGetIndicatorByIdentification(indicatorIdentification, bars+shift-1-i), 6);

if(currentValue > previousValue) {
// indicator was rising
return(false);
}
if(currentValue == previousValue && allowSameValues == false) {
// indicator was the same, not allowed
return(false);
}
if(currentValue < previousValue) {
atLeastOnce = true;
}

previousValue = currentValue;
}

if(atLeastOnce) {
return(true);
}

// indicator was not falling once
return(false);
}

//+------------------------------------------------------------------+

string getVariablePrefix(){
return IsTesting() ? "SQX(Test)" : "SQX";
}

//+------------------------------------------------------------------+

void sqSetGlobalVariable(int ticket, string name, double value) {
GlobalVariableSet(getVariablePrefix()+"_"+IntegerToString(ticket)+"_"+name, value);
}

//+------------------------------------------------------------------+

double sqGetGlobalVariable(int ticket, string name) {
return (GlobalVariableGet(getVariablePrefix()+"_"+IntegerToString(ticket)+"_"+name));
}

//+------------------------------------------------------------------+

int sqStringHash(string str){
int i, h=0, k;
for (i=0; i<StringLen(str); i++){
k = StringGetChar(str, i);
h = (h << 5) + h + k;
}
return(h);
}

//+------------------------------------------------------------------+

void sqClosePosition(double size, int magicNumber, string symbol, int direction, string comment) {
Verbose("Closing order with Magic Number: ", IntegerToString(magicNumber), ", symbol: ", symbol, ", direction: ", IntegerToString(direction), ", comment: ", comment);

if(!sqSelectOrder(magicNumber, symbol, direction, comment, false, false)) {
Verbose("Order cannot be found");
} else {
if(OrderType() == OP_BUY || OrderType() == OP_SELL) {
sqClosePositionAtMarket(size);
} else {
sqDeletePendingOrder(OrderTicket());
}
}

Verbose("Closing order finished ----------------");
}

//+------------------------------------------------------------------+

void sqClosePendingOrder(int magicNumber, string symbol, int direction, string comment) {
Verbose("Closing pending order with Magic Number: ", IntegerToString(magicNumber), ", symbol: ", symbol, ", direction: ", IntegerToString(direction), ", comment: ", comment);

if(!sqSelectOrder(magicNumber, symbol, direction, comment, false, false, true)) {
Verbose("Order cannot be found");
} else {
sqDeletePendingOrder(OrderTicket());
}

Verbose("Closing pending order finished ----------------");
}

//+------------------------------------------------------------------+

void sqCloseAllPendingOrders(int magicNumber, string symbol, int direction, string comment) {
Verbose("Closing pending orders with Magic Number: ", IntegerToString(magicNumber), ", symbol: ", symbol, ", direction: ", IntegerToString(direction), ", comment: ", comment);

while(sqSelectOrder(magicNumber, symbol, direction, comment, false, false, true)) {
sqDeletePendingOrder(OrderTicket());
}

Verbose("Closing pending orders finished ----------------");
}

//+------------------------------------------------------------------+

int sqGetOpenBarsForOrder(int ticket, int expBarsPeriod) {
datetime opTime;

if (OrderType() == OP_BUY || OrderType() == OP_SELL) { //live order
opTime = OrderOpenTime();
}
else { //pending order
opTime = (datetime) sqGetGlobalVariable(ticket, "sqOrderOpenTime");
}

int numberOfBars = 0;
int limit = MathMin(expBarsPeriod + 10, Bars);

for(int i=0; i<limit; i++) {
if(opTime < Time[i]) {
numberOfBars++;
}
}

return(numberOfBars);
}

//+------------------------------------------------------------------+

void Verbose(string st1, string st2="", string s3="", string s4="", string s5="", string s6="", string s7="", string s8="", string s9="", string s10="", string s11="", string s12="", string s13="", string s14="" ) {
if(sqVerboseMode == 0) {
return;
}

if(sqVerboseMode == 1 && (IsTesting() || IsOptimization())) {
return;
}

Print("- SQ LOG ", TimeToStr(TimeCurrent()), " ", st1, st2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13, s14);
}

//+------------------------------------------------------------------+

void VerboseLog(string s1, string s2="", string s3="", string s4="", string s5="", string s6="", string s7="", string s8="", string s9="", string s10="", string s11="", string s12="" ) {
if(sqVerboseMode != 1) {
Log(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12);
}

Verbose(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12);
}

//+------------------------------------------------------------------+

void Log(string s1, string s2="", string s3="", string s4="", string s5="", string s6="", string s7="", string s8="", string s9="", string s10="", string s11="", string s12="" ) {
Print(TimeToStr(TimeCurrent()), " ", s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12);
}

//+------------------------------------------------------------------+

void sqLog(string st1, string st2="", string s3="", string s4="", string s5="", string s6="", string s7="", string s8="", string s9="", string s10="", string s11="", string s12="" ) {
Print(TimeToStr(TimeCurrent()), " ", st1, st2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12);
}

//+------------------------------------------------------------------+

void sqLogToFile(string fileName, string st1, string st2="", string s3="", string s4="", string s5="", string s6="", string s7="", string s8="", string s9="", string s10="", string s11="", string s12="" ) {
int handle = FileOpen(fileName, FILE_READ | FILE_WRITE, ";");
if(handle>0) {
FileSeek(handle,0,SEEK_END);
FileWrite(handle, TimeToStr(TimeCurrent()), " ", st1, st2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12);
FileClose(handle);
}
}

//+------------------------------------------------------------------+

bool sqSelectOrder(int magicNumber, string symbol, int direction, string comment, bool goFromNewest=true, bool skipPending=true, bool skipFilled=false) {
int cc = 0;

if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

if(goFromNewest){
for (cc = OrdersTotal() - 1; cc >= 0; cc--) {
if(orderFits(cc, magicNumber, symbol, direction, comment, skipPending, skipFilled)){
return true;
}
}
}
else {
for (cc = 0; cc < OrdersTotal(); cc++) {
if(orderFits(cc, magicNumber, symbol, direction, comment, skipPending, skipFilled)){
return true;
}
}
}
return(false);
}

//+------------------------------------------------------------------+

bool orderFits(int index, int magicNumber, string symbol, int direction, string comment, bool skipPending=true, bool skipFilled=false){
if (OrderSelect(index, SELECT_BY_POS)) {
// skip pending orders
if(skipPending && (OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP || OrderType() == OP_SELLLIMIT)) {
return false;
}
// skip filled orders
if(skipFilled && (OrderType() == OP_BUY || OrderType() == OP_SELL)) {
return false;
}

if(direction != 0) {
if(direction > 0 && (OrderType() != OP_BUY && OrderType() != OP_BUYSTOP && OrderType() != OP_BUYLIMIT)) return false;
if(direction < 0 && (OrderType() != OP_SELL && OrderType() != OP_SELLSTOP && OrderType() != OP_SELLLIMIT)) return false;
}

if(magicNumber != 0) {
if(!checkMagicNumber(OrderMagicNumber()) || OrderMagicNumber() != magicNumber) return false;
}

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) return false;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) return false;
}

// otherwise we found the order
return(true);
}
else return false;
}

//+------------------------------------------------------------------+

void sqCloseAllPositions(string symbol, int magicNumber, int direction, string comment) {
int count = 100; // maximum number of positions to close
int lastTicket = -1;

while(count > 0) {
count--;
if(!sqSelectOrder(magicNumber, symbol, direction, comment, false, false)) {
// no position found
break;
}

if(lastTicket == OrderTicket()) {
// trying to close the same position one more time, there must be some error
break;
}
lastTicket = OrderTicket();

if(OrderType() == OP_BUY || OrderType() == OP_SELL) {
sqClosePositionAtMarket(OrderLots());
} else {
sqDeletePendingOrder(OrderTicket());
}
}
}

//+------------------------------------------------------------------+

void sqCloseBestPosition(string symbol, int magicNumber, int direction, string comment) {
double maxPL = -100000000;
int ticket = 0;

if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP ||OrderType() == OP_SELLLIMIT) {
continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(OrderProfit() > maxPL) {
// found order with better profit
maxPL = OrderProfit();
ticket = OrderTicket();
Verbose("Better position found, ticket: ", IntegerToString(ticket),", PL: ", DoubleToString(maxPL));
}
}
}

if(ticket > 0) {
if(OrderSelect(ticket, SELECT_BY_TICKET)) {
sqClosePositionAtMarket(OrderLots());
}
}
}

//+------------------------------------------------------------------+

void sqCloseWorstPosition(string symbol, int magicNumber, int direction, string comment) {
double minPL = 100000000;
int ticket = 0;

if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP ||OrderType() == OP_SELLLIMIT) {
continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(OrderProfit() < minPL) {
// found order with worse profit
minPL = OrderProfit();
ticket = OrderTicket();
Verbose("Worse position found, ticket: ", IntegerToString(ticket),", PL: ", DoubleToString(minPL));
}
}
}

if(ticket > 0) {
if(OrderSelect(ticket, SELECT_BY_TICKET)) {
sqClosePositionAtMarket(OrderLots());
}
}
}

//+------------------------------------------------------------------+

int sqGetMarketPosition(string symbol, int magicNumber, string comment) {
if(sqSelectOrder(magicNumber, symbol, 0, comment, false)) {
if(OrderType() == OP_BUY) {
return(1);
} else {
return(-1);
}
}
return(0);
}

//+------------------------------------------------------------------+

bool sqMarketPositionIsShort(int magicNo, string symbol, string comment){
return sqSelectOrder(magicNo, symbol, -1, comment, false);
}

//+------------------------------------------------------------------+

bool sqMarketPositionIsNotShort(int magicNo, string symbol, string comment){
if(sqSelectOrder(magicNo, symbol, -1, comment, false)) {
return false;
   }

   return true;
}

//+------------------------------------------------------------------+

bool sqMarketPositionIsLong(int magicNo, string symbol, string comment){
return sqSelectOrder(magicNo, symbol, 1, comment, false);
}

//+------------------------------------------------------------------+

bool sqMarketPositionIsNotLong(int magicNo, string symbol, string comment){
if(sqSelectOrder(magicNo, symbol, 1, comment, false)) {
return false;
   }

   return true;
}

//+------------------------------------------------------------------+

bool sqMarketPositionIsFlat(int magicNo, string symbol, string comment){
return sqGetMarketPosition(symbol, magicNo, comment) == 0;
}

//+------------------------------------------------------------------+

double sqGetOrderOpenPrice(string symbol, int magicNumber, int direction, string comment) {
if(sqSelectOrder(magicNumber, symbol, direction, comment, false)) {
return(OrderOpenPrice());
}
return(-1);
}

//+------------------------------------------------------------------+

double sqGetOrderStopLoss(string symbol, int magicNumber, int direction, string comment) {
if(sqSelectOrder(magicNumber, symbol, direction, comment, false)) {
return(OrderStopLoss());
}
return(-1);
}

//+------------------------------------------------------------------+

double sqGetOrderProfitTarget(string symbol, int magicNumber, int direction, string comment) {
if(sqSelectOrder(magicNumber, symbol, direction, comment, false)) {
return(OrderTakeProfit());
}
return(-1);
}

//+------------------------------------------------------------------+

double sqGetMarketPositionSize(string symbol, int magicNumber, int direction, string comment) {
double lots = 0;

if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP ||OrderType() == OP_SELLLIMIT) {
continue;
}

if(direction != 0) {
if(direction > 0 && OrderType() != OP_BUY) continue;
if(direction < 0 && OrderType() != OP_SELL) continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) continue;
}

lots += OrderLots();
}
}

return(lots);
}

//+------------------------------------------------------------------+

double sqGetOpenPL(string symbol, int magicNumber, int direction, string comment) {
double pl = 0;

if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP ||OrderType() == OP_SELLLIMIT) {
continue;
}

if(direction != 0) {
if(direction > 0 && OrderType() != OP_BUY) continue;
if(direction < 0 && OrderType() != OP_SELL) continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) continue;
}

pl += OrderProfit();
}
}

return(pl);
}

//+------------------------------------------------------------------+

double sqGetOpenPLInPips(string symbol, int magicNumber, int direction, string comment) {
double pl = 0;

if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP ||OrderType() == OP_SELLLIMIT) {
continue;
}

if(direction != 0) {
if(direction > 0 && OrderType() != OP_BUY) continue;
if(direction < 0 && OrderType() != OP_SELL) continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) continue;
}

if(OrderType() == OP_BUY) {
pl += sqGetBid(OrderSymbol()) - OrderOpenPrice();
} else {
pl += OrderOpenPrice() - sqGetAsk(OrderSymbol());
}
}
}

return(sqConvertToPips(OrderSymbol(), pl));
}

//+------------------------------------------------------------------+

double sqGetClosedPLInPips(string symbol, int magicNumber, int direction, string comment, int shift) {
int index = 0;

for(int i=OrdersHistoryTotal(); i>=0; i--) {
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==true ) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP ||OrderType() == OP_SELLLIMIT) {
continue;
}

if(direction != 0) {
if(direction > 0 && OrderType() != OP_BUY) continue;
if(direction < 0 && OrderType() != OP_SELL) continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) continue;
}

if(index == shift) {
if(OrderType() == OP_BUY) {
return(sqConvertToPips(OrderSymbol(), OrderClosePrice() - OrderOpenPrice()));
} else {
return(sqConvertToPips(OrderSymbol(), OrderOpenPrice() - OrderClosePrice()));
}
}

index++;
}
}

return(0);
}

//+------------------------------------------------------------------+

double sqGetClosedPLInMoney(string symbol, int magicNumber, int direction, string comment, int shift) {
int index = 0;

for(int i=OrdersHistoryTotal(); i>=0; i--) {
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==true ) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP ||OrderType() == OP_SELLLIMIT) {
continue;
}

if(direction != 0) {
if(direction > 0 && OrderType() != OP_BUY) continue;
if(direction < 0 && OrderType() != OP_SELL) continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) continue;
}

if(index == shift) {
return(OrderProfit());
}

index++;
}
}

return(0);
}

//+------------------------------------------------------------------+

int sqGetMarketPositionCount(string symbol, int magicNumber, int direction, string comment) {
int count = 0;

if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP ||OrderType() == OP_SELLLIMIT) {
continue;
}

if(direction != 0) {
if(direction > 0 && OrderType() != OP_BUY) continue;
if(direction < 0 && OrderType() != OP_SELL) continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) continue;
}

count++;
}
}

return(count);
}

//+------------------------------------------------------------------+

int sqGetBarsSinceOpen(string symbol, int magicNumber, int direction, string comment) {
if(sqSelectOrder(magicNumber, symbol, direction, comment, false, false)) {
datetime opTime = OrderOpenTime();

int numberOfBars = 0;
int limit = MathMin(10000, Bars);

for(int i=0; i<limit; i++) {
if(opTime < Time[i]) {
numberOfBars++;
}
}

return(numberOfBars);
}

return(-1);
}

//+------------------------------------------------------------------+

int sqGetBarsSinceClose(string symbol, int magicNumber, int direction, string comment) {
if(sqSelectOrderInHistory(magicNumber, symbol, direction, comment)) {
datetime clTime = OrderCloseTime();

int numberOfBars = 0;
int limit = MathMin(10000, Bars);

for(int i=0; i<limit; i++) {
if(clTime < Time[i]) {
numberOfBars++;
}
}

return(numberOfBars);
}

return(-1);
}

//+------------------------------------------------------------------+

int sqGetLastOrderType(string symbol, int magicNumber, string comment) {
if(sqSelectOrderInHistory(magicNumber, symbol, 0, comment)) {
if(OrderType() == OP_BUY || OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT) {
return(1);
} else {
return(-1);
}
}

return(0);
}

//+------------------------------------------------------------------+

bool sqSelectOrderInHistory(int magicNumber, string symbol, int direction, string comment) {
for (int cc = OrdersHistoryTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS,MODE_HISTORY)) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP || OrderType() == OP_SELLLIMIT) {
continue;
}

if(direction != 0) {
if(direction > 0 && OrderType() != OP_BUY) continue;
if(direction < 0 && OrderType() != OP_SELL) continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) continue;
}

// otherwise we found the order
return(true);
}
}

return(false);
}

//+------------------------------------------------------------------+

bool sqSelectPendingOrderByType(int magicNumber, string symbol, int orderType, string comment) {
if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {
if(OrderType() == OP_BUY || OrderType() == OP_SELL) {
continue;
}

if(orderType != 0) {
if(OrderType() != orderType) continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) continue;
}

// otherwise we found the order
return(true);
}
}

return(false);
}

//+------------------------------------------------------------------+

bool sqSelectPendingOrderByDir(int magicNumber, string symbol, int direction, string comment) {
if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {
if(OrderType() == OP_BUY || OrderType() == OP_SELL) {
continue;
}

if(direction != 0) {
int orderDirection = sqGetDirectionFromOrderType(OrderType());
if(orderDirection != direction) continue;
}

if(magicNumber != 0) {
if(OrderMagicNumber() != magicNumber) continue;
}
else if(!checkMagicNumber(OrderMagicNumber())) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

if(comment != "") {
if(StringFind(OrderComment(), comment) == -1) continue;
}

// otherwise we found the order
return(true);
}
}

return(false);
}
//+------------------------------------------------------------------+

bool sqClosePositionAtMarket(double size) {
int ticket = OrderTicket();

Verbose("Closing order with ticket: ", IntegerToString(ticket));

int orderType = OrderType();

if(orderType != OP_BUY && orderType != OP_SELL) {
Verbose("Trying to close non-live order");
return(false);
}
if(!sqCheckConnected()) {
return(false);
}

bool result;

double price = sqGetClosePrice(orderType, OrderSymbol(), 0);
result = OrderCloseReliable(ticket, size, price, correctSlippage(sqMaxCloseSlippage, OrderSymbol()));
if(result) {
Verbose("Order deleted successfuly");
return(true);
}

return(false);
}

//+------------------------------------------------------------------+

double sqGetAsk(string symbol) {
if(symbol == "NULL" || symbol == "Current") {
return(NormalizeDouble(Ask, Digits));
} else {
return(NormalizeDouble(MarketInfo(correctSymbol(symbol),MODE_ASK), Digits));
}
}

//+------------------------------------------------------------------+

double sqGetBid(string symbol) {
if(symbol == "NULL" || symbol == "Current") {
return(NormalizeDouble(Bid, Digits));
} else {
return(NormalizeDouble(MarketInfo(correctSymbol(symbol),MODE_BID), Digits));
}
}

//+------------------------------------------------------------------+

bool sqDeleteOrder(int ticket){
if(!OrderSelect(ticket, SELECT_BY_TICKET)){
Verbose("Warning! Cannot delete order - order with ticket ", IntegerToString(ticket), " can't be selected");
return false;
}

if(sqIsPendingOrder(OrderType())){
return OrderDeleteReliable(ticket);
}
else {
return OrderCloseReliableMKT(ticket, OrderLots(), sqGetDirectionFromOrderType(OrderType()) == 1 ? Bid : Ask, correctSlippage(0, OrderSymbol()));
}
}

//+------------------------------------------------------------------+

bool sqDeletePendingOrder(int ticket) {
Verbose(" Deleting pending order, ticket: " + IntegerToString(ticket));

int orderType = OrderType();

if(orderType == OP_BUY || orderType == OP_SELL) {
Verbose("Trying to delete non-pending order");
return(false);
}
if(!sqCheckConnected()) {
return(false);
}

bool result = OrderDeleteReliable(ticket);
if(result) {
Verbose("Order deleted successfuly");
return(true);
}

return(false);
}

//+------------------------------------------------------------------+

int sqOpenOrder(int orderType, string symbol, double size, double price, int magicNumber, string comment, datetime expirationInTime, bool replaceExisting, bool allowDuplicateTrades, color arrowColor, const bool isExitLevel = false) {
if(size <= 0) return (0);

string correctedSymbol = correctSymbol(symbol);

if(isMarketClosed(correctedSymbol)){
return 0;
}

double ask = sqGetAsk(correctedSymbol);
double bid = sqGetBid(correctedSymbol);

int direction = sqGetDirectionFromOrderType(orderType);

double marketPrice = direction == 1 ? ask : bid;

price = (orderType == OP_BUY || orderType == OP_SELL) ? marketPrice : price;
price = sqFixMarketPrice(price, correctedSymbol);

if(LimitMaxDistanceFromMarketPrice && (orderType != OP_BUY && orderType != OP_SELL)){
double pctDistance = NormalizeDouble(MathAbs(price-marketPrice) / marketPrice * 100, 2);
if(pctDistance > NormalizeDouble(MaxDistanceFromMarketPct, 2)){
Verbose("Order skipped - too far from market price. Open price: ", DoubleToStr(price), ", Market price: ", DoubleToStr(marketPrice), ", Max distance: ", DoubleToStr(MaxDistanceFromMarketPct), "%");
return(0);
}
}

openingOrdersAllowed = openingOrdersAllowed && sqHandleTradingOptions();

if(!openingOrdersAllowed) return(0);

Verbose("Opening order type ", OrderTypeToString(orderType)," with price ", DoubleToString(price), ". Current market prices: ", DoubleToString(ask), " / ", DoubleToString(bid));

// check if live order exists
if(!isExitLevel && sqSelectOrder(magicNumber, correctedSymbol, 0, comment) && !allowDuplicateTrades) {
Verbose("Order with these parameters already exists and duplicate trades are not allowed. Canceling order...");
Verbose("----------------------------------");
return(0);
}

// check if pending order exists
if(!isExitLevel){
while(sqSelectOrder(magicNumber, correctedSymbol, direction, comment, false, false, true)) {
if(replaceExisting) {

if(!strategyUsesATM && ModifyInsteadOfReplacing && size == OrderLots()) {
// modify existing pending order
if(OrderModifyReliable(OrderTicket(), price, 0, 0, expirationInTime)) {
// reset global variables for this order
sqResetGlobalVariablesForTicket(OrderTicket());
return ( OrderTicket() );

} else {
Verbose("Modifying order failed, deleting it");
sqDeletePendingOrder(OrderTicket());
return(0);
}
} else {
// delete existing pending order
sqDeletePendingOrder(OrderTicket());
}

} else {
Verbose("Pending Order with these parameters already exists, and replace is not allowed. Canceling order...", " ----------------");
return(0);
}
}
}

if(!checkOrderPriceValid(orderType, correctedSymbol, price, marketPrice)){
return 0;
}

//check free margin
if(AccountFreeMarginCheck(correctedSymbol, isLongOrder(orderType) ? OP_BUY : OP_SELL, size) <= 0 || GetLastError()==134) {
Alert("Balance too low for trading!");
return(0);
}

string commentToUse = "";
if(comment != ""){
commentToUse = comment;
}
else {
commentToUse = CustomComment;
}

int ticket = OrderSendReliable(correctedSymbol, orderType, size, price, correctSlippage(sqMaxEntrySlippage, correctedSymbol), 0, 0, commentToUse, magicNumber, expirationInTime, arrowColor);

if(ticket > 0) {
// reset global variables for this order
sqResetGlobalVariablesForTicket(ticket);
}

return(ticket);
}

//+------------------------------------------------------------------+

bool isLongOrder(int orderType){
return orderType == OP_BUY || orderType == OP_BUYLIMIT || orderType == OP_BUYSTOP;
}

//----------------------------------------------------------------------------

int correctSlippage(int slippage, string symbol = NULL){
if(slippage <= 0) return 100000;

if(autoCorrectMaxSlippage){
int realDigits = (int) MarketInfo(correctSymbol(symbol), MODE_DIGITS);
if(realDigits > 0 && realDigits != 2 && realDigits != 4) {
return slippage * 10;
}
}

return slippage;
}

//----------------------------------------------------------------------------

bool checkOrderPriceValid(int orderType, string symbol, double price, double marketPrice){
if(orderType == OP_BUY || orderType == OP_SELL){
if(marketPrice == price){
return true;
}
else {
Verbose("Based on its logic, the strategy tried to place order a market order at incorrect price. Market price: ", DoubleToString(marketPrice), ", order price: ", DoubleToString(price), " (this is NOT an error)");
return false;
}
}

return checkStopPriceValid(orderType, symbol, price, marketPrice, "stop/limit order");
}

//----------------------------------------------------------------------------

bool checkStopPriceValid(int orderType, string symbol, double price, double marketPrice, string name){
int stopLevel = (int) MarketInfo(symbol, MODE_STOPLEVEL);
double point = MarketInfo(symbol, MODE_POINT);
double minDistance = point * stopLevel;
double minDistanceSQ = sqMinDistance * sqGetPointCoef(symbol);

if(minDistanceSQ > minDistance){
minDistance = minDistanceSQ;
}

double priceLevel;

if(orderType == OP_BUYLIMIT || orderType == OP_SELLSTOP){
priceLevel = marketPrice - minDistance;

if(price <= priceLevel){
return true;
}
else {
Verbose("Based on its logic, the strategy tried to place ", name, " at incorrect price. Market price: ", DoubleToString(marketPrice), ", max. price allowed: ", DoubleToString(priceLevel), ", ", name, " price: ", DoubleToString(price), " (this is NOT an error)");
return false;
}
}
else if(orderType == OP_BUYSTOP || orderType == OP_SELLLIMIT){
priceLevel = marketPrice + minDistance;

if(price >= priceLevel){
return true;
}
else {
Verbose("Based on its logic, the strategy tried to place ", name, " at incorrect price. Market price: ", DoubleToString(marketPrice), ", min. price allowed: ", DoubleToString(priceLevel), ", ", name," price: ", DoubleToString(price), " (this is NOT an error)");
return false;
}
}
else return true;
}

//+------------------------------------------------------------------+

int sqGetDirectionFromOrderType(int orderType) {
if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
return(1);
} else {
return(-1);
}
}

//+------------------------------------------------------------------+

bool sqIsPendingOrder(int orderType) {
if(orderType != OP_BUY && orderType != OP_SELL) {
return(true);
}
return(false);
}

//+------------------------------------------------------------------+

void sqSetSLandPT(int ticket, double sl, double pt) {
if(sl == 0 && pt == 0) return;

if(!OrderSelect(ticket, SELECT_BY_TICKET)) {
Verbose("Cannot select order with ticket: ",IntegerToString(ticket));
return;
}

if(sl == OrderOpenPrice()) {
Verbose("SL is the same as order price, cannot set it, so we'll delete the order!");
if(!sqDeleteOrder(ticket)) {
Verbose("Warning! Cannot delete order and SL/PT was not set! Error: ", IntegerToString(GetLastError()));
}

return;
}

if(pt == OrderOpenPrice()) {
pt = 0;
}

if(sl > 0 || pt > 0) {
bool result = sqOrderModify(ticket, OrderOpenPrice(), sqFixMarketPrice(sl, OrderSymbol()), sqFixMarketPrice(pt, OrderSymbol()));
if(!result) {
Verbose("Cannot set SL / PT for this order, deleting it!");
if(!sqDeleteOrder(ticket)){
Verbose("Warning! Cannot delete order and SL/PT was not set! Error: ", IntegerToString(GetLastError()));
}
}
}
}

//+------------------------------------------------------------------+

bool sqOrderModifySL(int ticket,double stopLoss, int type) {
if(!OrderSelect(ticket, SELECT_BY_TICKET)) {
Verbose("Cannot select order with ticket: ",IntegerToString(ticket));
}

if(type == SLPTTYPE_RANGE) {
// convert range to price level
if(sqGetDirectionFromOrderType(OrderType()) == 1) {
// it is long order
stopLoss = OrderOpenPrice() - stopLoss;
} else {
stopLoss = OrderOpenPrice() + stopLoss;
}
}

return(sqOrderModify(ticket, OrderOpenPrice(), sqFixMarketPrice(stopLoss, OrderSymbol()), OrderTakeProfit()));
}

//+------------------------------------------------------------------+

bool sqOrderModifyPT(int ticket,double profitTarget, int type) {
if(!OrderSelect(ticket, SELECT_BY_TICKET)) {
Verbose("Cannot select order with ticket: ",IntegerToString(ticket));
}

if(type == SLPTTYPE_RANGE) {
// convert range to price level
if(sqGetDirectionFromOrderType(OrderType()) == 1) {
// it is long order
profitTarget = OrderOpenPrice() + profitTarget;
} else {
profitTarget = OrderOpenPrice() - profitTarget;
}
}

return(sqOrderModify(ticket, OrderOpenPrice(), OrderStopLoss(), sqFixMarketPrice(profitTarget, OrderSymbol())));
}

//+------------------------------------------------------------------+

bool sqOrderModify(int ticket, double price, double stopLoss, double profitTarget) {
if(!OrderSelect(ticket, SELECT_BY_TICKET)) {
Verbose("Cannot select order with ticket: ",IntegerToString(ticket));
}

int digits = (int) MarketInfo(OrderSymbol(), MODE_DIGITS);
if (digits > 0) {
stopLoss = NormalizeDouble(stopLoss, digits);
profitTarget = NormalizeDouble(profitTarget, digits);
}

Verbose("Modifying order with ticket: ", IntegerToString(ticket), ", SL: ", DoubleToString(stopLoss), " and PT: ", DoubleToString(profitTarget));

int orderType = OrderType();

if(!sqCheckConnected()) {
return(false);
}

bool result;
double closestPossibleSL, closestPossiblePT;

double point = MarketInfo(OrderSymbol(), MODE_POINT);
double minStopLevel = MarketInfo(OrderSymbol(),MODE_STOPLEVEL);

if(stopLoss > 0) {
// check if SL isn't too close to price
if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
if(orderType == OP_BUY) {
closestPossibleSL = NormalizeDouble(Bid-minStopLevel*point, digits);
} else {
closestPossibleSL = NormalizeDouble(OrderOpenPrice()-minStopLevel*point, digits);
}

if(stopLoss > closestPossibleSL) {
Verbose("Cannot modify SL, it cannot be closer than minimum allowed: ", DoubleToString(stopLoss), " > ", DoubleToString(closestPossibleSL));
return(false);
}

} else {
if(orderType == OP_SELL) {
closestPossibleSL = NormalizeDouble(Ask+minStopLevel*point, digits);
} else {
closestPossibleSL = NormalizeDouble(OrderOpenPrice()+minStopLevel*point, digits);
}

if(stopLoss < closestPossibleSL) {
Verbose("Cannot modify SL, it cannot be closer than minimum allowed: ", DoubleToString(stopLoss), " < ", DoubleToString(closestPossibleSL));
return(false);
}
}
}

if(profitTarget > 0) {
// check if PT isn't too close to price
if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
if(orderType == OP_BUY) {
closestPossiblePT = NormalizeDouble(Bid+minStopLevel*point, digits);
} else {
closestPossiblePT = NormalizeDouble(OrderOpenPrice()+minStopLevel*point, digits);
}

if(profitTarget < closestPossiblePT) {
Verbose("Cannot modify PT, it cannot be closer than minimum allowed: ", DoubleToString(profitTarget), " < ", DoubleToString(closestPossiblePT));
return(false);
}

} else {
if(orderType == OP_SELL) {
closestPossiblePT = NormalizeDouble(Ask-minStopLevel*point, digits);
} else {
closestPossiblePT = NormalizeDouble(OrderOpenPrice()-minStopLevel*point, digits);
}

if(profitTarget > closestPossiblePT) {
Verbose("Cannot modify PT, it cannot be closer than minimum allowed: ", DoubleToString(profitTarget), " > ", DoubleToString(closestPossiblePT));
return(false);
}
}
}

result = OrderModifyReliable(ticket, price, sqFixMarketPrice(stopLoss, OrderSymbol()), sqFixMarketPrice(profitTarget, OrderSymbol()), OrderExpiration());
if(result) {
Verbose("Order modified successfuly");
return(true);
}

return(false);
}

//+------------------------------------------------------------------+

double sqGetPrice(int orderType, string symbol, double price) {
if(price == 0 && (orderType == OP_BUY || orderType == OP_SELL)) {
// get newest Ask/Bid price for market order
RefreshRates();
if(orderType == OP_BUY) {
price = sqGetAsk(symbol);
} else {
price = sqGetBid(symbol);
}
}

int digits = (int) MarketInfo(symbol, MODE_DIGITS);

if (digits > 0) price = NormalizeDouble(price, digits);

return(price);
}

//+------------------------------------------------------------------+

double sqGetClosePrice(int orderType, string symbol, double price) {
if(price == 0 && (orderType == OP_BUY || orderType == OP_SELL)) {
// get newest Ask/Bid price for market order
RefreshRates();
if(orderType == OP_BUY) {
price = sqGetBid(symbol);
} else {
price = sqGetAsk(symbol);
}
}

int digits = (int) MarketInfo(symbol, MODE_DIGITS);

if (digits > 0) price = NormalizeDouble(price, digits);

return(price);
}

//+------------------------------------------------------------------+

bool sqCheckConnected() {
if (!IsConnected()) {
Verbose("Not connected!");
return(false);
}
if (IsStopped()) {
Verbose("EA stopped!");
return(false);
}

return(true);
}

//+------------------------------------------------------------------+

int sleepPeriod = 500; // 0.5 s
int maxSleepPeriod = 20000; // 20 s.

void sqSleep() {
//if(IsTesting()) return;

Sleep(sleepPeriod);

int periods = maxSleepPeriod / sleepPeriod;

for(int i=0; i<periods; i++) {
if (MathRand() > 16383) {
// 50% chance of quitting
break;
}

Sleep(sleepPeriod);
}
}

//+------------------------------------------------------------------+

string sqGetOrderTypeAsString(int type) {
switch(type) {
case OP_BUY: return("Buy");
case OP_SELL: return("Sell");
case OP_BUYLIMIT: return("Buy Limit");
case OP_BUYSTOP: return("Buy Stop");
case OP_SELLLIMIT: return("Sell Limit");
case OP_SELLSTOP: return("Sell Stop");
}

return("Unknown");
}

//+------------------------------------------------------------------+

void sqInitInfoPanel() {
ObjectCreate("line1", OBJ_LABEL, 0, 0, 0);
ObjectSet("line1", OBJPROP_CORNER, sqLabelCorner);
ObjectSet("line1", OBJPROP_YDISTANCE, sqOffsetVertical + 0 );
ObjectSet("line1", OBJPROP_XDISTANCE, sqOffsetHorizontal);
ObjectSetText("line1", "New strategy", 9, "Tahoma", sqLabelColor);

ObjectCreate("linec", OBJ_LABEL, 0, 0, 0);
ObjectSet("linec", OBJPROP_CORNER, sqLabelCorner);
ObjectSet("linec", OBJPROP_YDISTANCE, sqOffsetVertical + 16 );
ObjectSet("linec", OBJPROP_XDISTANCE, sqOffsetHorizontal);
ObjectSetText("linec", "Generated by StrategyQuant EA Wizard", 8, "Tahoma", sqLabelColor);

ObjectCreate("line2", OBJ_LABEL, 0, 0, 0);
ObjectSet("line2", OBJPROP_CORNER, sqLabelCorner);
ObjectSet("line2", OBJPROP_YDISTANCE, sqOffsetVertical + 28);
ObjectSet("line2", OBJPROP_XDISTANCE, sqOffsetHorizontal);
ObjectSetText("line2", "------------------------------------------", 8, "Tahoma", sqLabelColor);

ObjectCreate("lines", OBJ_LABEL, 0, 0, 0);
ObjectSet("lines", OBJPROP_CORNER, sqLabelCorner);
ObjectSet("lines", OBJPROP_YDISTANCE, sqOffsetVertical + 44);
ObjectSet("lines", OBJPROP_XDISTANCE, sqOffsetHorizontal);
ObjectSetText("lines", "Last Signal: -", 9, "Tahoma", sqLabelColor);

ObjectCreate("lineopl", OBJ_LABEL, 0, 0, 0);
ObjectSet("lineopl", OBJPROP_CORNER, sqLabelCorner);
ObjectSet("lineopl", OBJPROP_YDISTANCE, sqOffsetVertical + 60);
ObjectSet("lineopl", OBJPROP_XDISTANCE, sqOffsetHorizontal);
ObjectSetText("lineopl", "Open P/L: -", 8, "Tahoma", sqLabelColor);

ObjectCreate("linea", OBJ_LABEL, 0, 0, 0);
ObjectSet("linea", OBJPROP_CORNER, sqLabelCorner);
ObjectSet("linea", OBJPROP_YDISTANCE, sqOffsetVertical + 76);
ObjectSet("linea", OBJPROP_XDISTANCE, sqOffsetHorizontal);
ObjectSetText("linea", "Account Balance: -", 8, "Tahoma", sqLabelColor);

ObjectCreate("lineto", OBJ_LABEL, 0, 0, 0);
ObjectSet("lineto", OBJPROP_CORNER, sqLabelCorner);
ObjectSet("lineto", OBJPROP_YDISTANCE, sqOffsetVertical + 92);
ObjectSet("lineto", OBJPROP_XDISTANCE, sqOffsetHorizontal);
ObjectSetText("lineto", "Total profits/losses so far: -/-", 8, "Tahoma", sqLabelColor);

ObjectCreate("linetp", OBJ_LABEL, 0, 0, 0);
ObjectSet("linetp", OBJPROP_CORNER, sqLabelCorner);
ObjectSet("linetp", OBJPROP_YDISTANCE, sqOffsetVertical + 108);
ObjectSet("linetp", OBJPROP_XDISTANCE, sqOffsetHorizontal);
ObjectSetText("linetp", "Total P/L so far: -", 8, "Tahoma", sqLabelColor);
}

//+------------------------------------------------------------------+

void sqDeinitInfoPanel() {
ObjectDelete("line1");
ObjectDelete("linec");
ObjectDelete("line2");
ObjectDelete("lines");
ObjectDelete("lineopl");
ObjectDelete("linea");
ObjectDelete("lineto");
ObjectDelete("linetp");
}

//+------------------------------------------------------------------+

void sqTextFillOpens() {
ObjectSetText("lineopl", "Open P/L: "+DoubleToStr(sqGetOpenPLInMoney(0), 2), 8, "Tahoma", sqLabelColor);
ObjectSetText("linea", "Account Balance: "+DoubleToStr(AccountBalance(), 2) , 8, "Tahoma", sqLabelColor);
}

//+------------------------------------------------------------------+

void sqTextFillTotals() {
ObjectSetText("lineto", "Total profits/losses so far: "+DoubleToStr(sqGetTotalProfits(0, 100))+"/"+DoubleToStr(sqGetTotalLosses(0, 100)), 8, "Tahoma", sqLabelColor);
ObjectSetText("linetp", "Total P/L so far: "+DoubleToStr(sqGetTotalClosedPLInMoney(0, 1000), 2), 8, "Tahoma", sqLabelColor);
}

//+------------------------------------------------------------------+

double sqGetOpenPLInMoney(int orderMagicNumber) {
double pl = 0;

if(orderSelectTimeout > 0){
Sleep(orderSelectTimeout);
}

for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (!OrderSelect(cc, SELECT_BY_POS) ) continue;
if(OrderType() != OP_BUY && OrderType() != OP_SELL) continue;
if(OrderSymbol() != Symbol()) continue;
if(orderMagicNumber != 0 && OrderMagicNumber() != orderMagicNumber) continue;

pl += OrderProfit();
}

return(pl);
}

//+------------------------------------------------------------------+

int sqGetTotalProfits(int orderMagicNumber, int numberOfLastOrders) {
double pl = 0;
int count = 0;
int profits = 0;

for(int i=OrdersHistoryTotal(); i>=0; i--) {
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==true && OrderSymbol() == Symbol()) {

if(orderMagicNumber == 0 || OrderMagicNumber() == orderMagicNumber) {
// return the P/L of last order
// or return the P/L of last order with given Magic Number
count++;

if(OrderType() == OP_BUY) {
pl = (OrderClosePrice() - OrderOpenPrice());
} else {
pl = (OrderOpenPrice() - OrderClosePrice());
}

if(pl > 0) {
profits++;
}

if(count >= numberOfLastOrders) break;
}
}
}

return(profits);
}

//+------------------------------------------------------------------+

int sqGetTotalLosses(int orderMagicNumber, int numberOfLastOrders) {
double pl = 0;
int count = 0;
int losses = 0;

for(int i=OrdersHistoryTotal(); i>=0; i--) {
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==true && OrderSymbol() == Symbol()) {

if(orderMagicNumber == 0 || OrderMagicNumber() == orderMagicNumber) {
// return the P/L of last order
// or return the P/L of last order with given Magic Number
count++;

if(OrderType() == OP_BUY) {
pl = (OrderClosePrice() - OrderOpenPrice());
} else {
pl = (OrderOpenPrice() - OrderClosePrice());
}

if(pl < 0) {
losses++;
}

if(count >= numberOfLastOrders) break;
}
}
}

return(losses);
}

//+------------------------------------------------------------------+

double sqGetTotalClosedPLInMoney(int orderMagicNumber, int numberOfLastOrders) {
double pl = 0;
int count = 0;

for(int i=OrdersHistoryTotal(); i>=0; i--) {
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==true && OrderSymbol() == Symbol()) {
if(orderMagicNumber == 0 || OrderMagicNumber() == orderMagicNumber) {
// return the P/L of last order or the P/L of last order with given Magic Number

count++;
pl = pl + OrderProfit();

if(count >= numberOfLastOrders) break;
}
}
}

return(pl);
}

//+------------------------------------------------------------------+

double sqGetSLLevel(string symbol, int orderType, double price, int valueInPips, double value) {
return(sqGetSLPTLevel(-1.0, symbol, orderType, price, valueInPips, value));
}

//+------------------------------------------------------------------+

double sqGetPTLevel(string symbol, int orderType, double price, int valueInPips, double value) {
return(sqGetSLPTLevel(1.0, symbol, orderType, price, valueInPips, value));
}

//+------------------------------------------------------------------+

/**
* valueType: 1 - pips, 2 - real pips (ATR range), 3 - price level
*/
double sqGetSLPTLevel(double SLorPT, string symbol, int orderType, double price, int valueType, double value) {
string correctedSymbol = correctSymbol(symbol);
double pointCoef = sqGetPointCoef(symbol);

if(valueType == 1) {
// convert from pips to real points
value = sqConvertToRealPips(correctedSymbol, value);
}

if(price == 0) {
// price can be zero for market order
if(orderType == OP_BUY) {
price = sqGetAsk(correctedSymbol);
} else {
price = sqGetBid(correctedSymbol);
}
}

double slptValue = value;

if(valueType != 3) {
if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
slptValue = price + (SLorPT * value);
} else {
slptValue = price - (SLorPT * value);
}
}

// check that SL / PT is within predefined boundaries
double minSLPTValue, maxSLPTValue;

if(SLorPT < 0) {
// it is SL

if(MinimumSL <= 0) {
minSLPTValue = slptValue;
} else {
if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
minSLPTValue = price + (SLorPT * MinimumSL * pointCoef);
slptValue = MathMin(slptValue, minSLPTValue);

} else {

minSLPTValue = price - (SLorPT * MinimumSL * pointCoef);
slptValue = MathMax(slptValue, minSLPTValue);
}

}

if(MaximumSL <= 0) {
maxSLPTValue = slptValue;
} else {
if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
maxSLPTValue = price + (SLorPT * MaximumSL * pointCoef);
slptValue = MathMax(slptValue, maxSLPTValue);

} else {
maxSLPTValue = price - (SLorPT * MaximumSL * pointCoef);
slptValue = MathMin(slptValue, maxSLPTValue);
}

}

} else {
// it is PT

if(MinimumPT <= 0) {
minSLPTValue = slptValue;
} else {
if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
minSLPTValue = price + (SLorPT * MinimumPT * pointCoef);
slptValue = MathMax(slptValue, minSLPTValue);

} else {
minSLPTValue = price - (SLorPT * MinimumPT * pointCoef);
slptValue = MathMin(slptValue, minSLPTValue);
}

}

if(MaximumPT <= 0) {
maxSLPTValue = slptValue;
} else {

if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
maxSLPTValue = price + (SLorPT * MaximumPT * pointCoef);
slptValue = MathMin(slptValue, maxSLPTValue);

} else {

maxSLPTValue = price - (SLorPT * MaximumPT * pointCoef);
slptValue = MathMax(slptValue, maxSLPTValue);
}
}
}

return (slptValue);
}

//+------------------------------------------------------------------+

double sqConvertToPips(string symbol, double value) {
if(symbol == "NULL" || symbol == "Current") {
return(value / gPointCoef);
}

// recognize point coeficient
double ticksize = sqGetMarketTickSize(symbol);
if(ticksize < 0){
ticksize = calculatePointCoef(symbol);
}

return(value / ticksize);
}

//+------------------------------------------------------------------+

double sqConvertToRealPips(string symbol, double value) {
if(symbol == "NULL" || symbol == "Current" || symbol == "Same as main chart") {
return NormalizeDouble(gPointCoef * value, 6);
}

double pointCoef = sqGetPointCoef(symbol);

return NormalizeDouble(pointCoef * value, 6);
}

//+------------------------------------------------------------------+

double sqGetPointCoef(string symbol) {
if(symbol == "NULL" || symbol == "Current" || symbol == "Same as main chart") {
return(gPointCoef);
}

return calculatePointCoef(symbol);
}

//+------------------------------------------------------------------+

double calculatePointCoef(string symbol){
string correctedSymbol = correctSymbol(symbol);

if(UseSQTickSize) {
double ticksize = sqGetMarketTickSize(correctedSymbol);
if(ticksize >= 0){
return ticksize;
}
}

int realDigits = (int) MarketInfo(correctedSymbol, MODE_DIGITS);
if(realDigits > 0 && realDigits != 2 && realDigits != 4) {
realDigits -= 1;
}
return 1.0 / MathPow(10, realDigits);
}

//+------------------------------------------------------------------+

bool sqDoublesAreEqual(double n1, double n2) {
string st1 = DoubleToStr(n1, Digits);
string st2 = DoubleToStr(n2, Digits);

return (st1 == st2);
}

//+------------------------------------------------------------------+

double sqHighest(string symbol, int timeframe, int computedFrom, int period, int shift) {
double maxnum = -100000000;
double val;

for(int i=shift; i<shift+period; i++) {
val = sqGetValue(symbol, timeframe, computedFrom, i);

if(val > maxnum) {
maxnum = val;
}
}

return(maxnum);
}

//+------------------------------------------------------------------+

double sqHighestIndex(string symbol, int timeframe, int computedFrom, int period, int shift) {
double maxnum = -100000000;
int index = 0;
double val;

for(int i=shift; i<shift+period; i++) {
val = sqGetValue(symbol, timeframe, computedFrom, i);

if(val > maxnum) {
maxnum = val;
index = i;
}
}

return(index);
}

//+------------------------------------------------------------------+

double sqLowest(string symbol, int timeframe, int computedFrom, int period, int shift) {
double minnum = 100000000;
double val;

for(int i=shift; i<shift+period; i++) {
val = sqGetValue(symbol, timeframe, computedFrom, i);

if(val < minnum) {
minnum = val;
}
}

return(minnum);
}

//+------------------------------------------------------------------+

double sqLowestIndex(string symbol, int timeframe, int computedFrom, int period, int shift) {
double minnum = 100000000;
int index = 0;
double val;

for(int i=shift; i<shift+period; i++) {
val = sqGetValue(symbol, timeframe, computedFrom, i);

if(val < minnum) {
minnum = val;
index = i;
}
}

return(index);
}

//+------------------------------------------------------------------+

double sqGetValue(string symbol, int timeframe, int computedFrom, int shift) {
double val = 0;

if(symbol == "NULL" || symbol == "Current") {
switch(computedFrom) {
case PRICE_OPEN: val = iOpen(NULL, timeframe, shift); break;
case PRICE_HIGH: return iHigh(NULL, timeframe, shift); break;
case PRICE_LOW: val = iLow(NULL, timeframe, shift); break;
case PRICE_CLOSE: val = iClose(NULL, timeframe, shift); break;
case PRICE_MEDIAN: val = (iHigh(NULL, timeframe, shift)+iLow(NULL, timeframe, shift))/2; break;
case PRICE_TYPICAL: val = (iHigh(NULL, timeframe, shift)+iLow(NULL, timeframe, shift)+iClose(NULL, timeframe, shift))/3; break;
case PRICE_WEIGHTED: val = (iHigh(NULL, timeframe, shift)+iLow(NULL, timeframe, shift)+iClose(NULL, timeframe, shift)+iClose(NULL, timeframe, shift))/4; break;
}

} else {
switch(computedFrom) {
case PRICE_OPEN: val = iOpen(symbol, timeframe, shift); break;
case PRICE_HIGH: val = iHigh(symbol, timeframe, shift); break;
case PRICE_LOW: val = iLow(symbol, timeframe, shift); break;
case PRICE_CLOSE: val = iClose(symbol, timeframe, shift); break;
case PRICE_MEDIAN: val = (iHigh(symbol, timeframe, shift)+iLow(symbol, timeframe, shift))/2; break;
case PRICE_TYPICAL: val = (iHigh(symbol, timeframe, shift)+iLow(symbol, timeframe, shift)+iClose(symbol, timeframe, shift))/3; break;
case PRICE_WEIGHTED: val = (iHigh(symbol, timeframe, shift)+iLow(symbol, timeframe, shift)+iClose(symbol, timeframe, shift)+iClose(symbol, timeframe, shift))/4; break;
}
}

return roundValue(val);
}

//+------------------------------------------------------------------+

void sqDrawUpArrow(int shift) {
string name = StringConcatenate("Arrow_", MathRand());

ObjectCreate(name, OBJ_ARROW, 0, Time[shift], Low[shift]-100*Point); //draw an up arrow
ObjectSet(name, OBJPROP_STYLE, STYLE_SOLID);
ObjectSet(name, OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
ObjectSet(name, OBJPROP_COLOR, Green);
}

//+------------------------------------------------------------------+

void sqDrawDownArrow(int shift) {
string name = StringConcatenate("Arrow_", MathRand());

ObjectCreate(name, OBJ_ARROW, 0, Time[shift], High[shift]+100*Point); //draw an down arrow
ObjectSet(name, OBJPROP_STYLE, STYLE_SOLID);
ObjectSet(name, OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
ObjectSet(name, OBJPROP_COLOR, Red);
}

//+------------------------------------------------------------------+

void sqDrawVerticalLine(int shift) {
string name = StringConcatenate("VerticalLine", MathRand());

ObjectCreate(name, OBJ_VLINE, 0, Time[shift], 0); //draw a vertical line
ObjectSet(name,OBJPROP_COLOR, Red);
ObjectSet(name,OBJPROP_WIDTH, 1);
ObjectSet(name,OBJPROP_STYLE, STYLE_DOT);
}

//+------------------------------------------------------------------+

double sqDaily(string symbol, int tf, string mode, int shift) {
return sqGetOHLC(symbol, PERIOD_D1, mode, shift);
}

//+------------------------------------------------------------------+

double sqWeekly(string symbol, int tf, string mode, int shift) {
return sqGetOHLC(symbol, PERIOD_W1, mode, shift);
}

//+------------------------------------------------------------------+

double sqMonthly(string symbol, int tf, string mode, int shift) {
return sqGetOHLC(symbol, PERIOD_MN1, mode, shift);
}

//+------------------------------------------------------------------+

double sqGetOHLC(string symbol, int tf, string mode, int shift){
if(symbol == "NULL" || symbol == "Current") {
if(mode == "Open") {
return(iOpen(NULL, tf, shift));
}
if(mode == "Close") {
return(iClose(NULL, tf, shift));
}
if(mode == "High") {
return(iHigh(NULL, tf, shift));
}
if(mode == "Low") {
return(iLow(NULL, tf, shift));
}
}
else {
if(mode == "Open") {
return(iOpen(symbol, tf, shift));
}
if(mode == "Close") {
return(iClose(symbol, tf, shift));
}
if(mode == "High") {
return(iHigh(symbol, tf, shift));
}
if(mode == "Low") {
return(iLow(symbol, tf, shift));
}
}

return(-1);
}

//+------------------------------------------------------------------+

int getHHMM(string time){
string result[];
int k = StringSplit(time, ':', result);

if(k == 2){
int hour = StrToInteger(StringSubstr(result[0], 0, 1) == "0" ? StringSubstr(result[0], 1, 1) : result[0]);
int minute = StrToInteger(StringSubstr(result[1], 0, 1) == "0" ? StringSubstr(result[1], 1, 1) : result[1]);
return (hour * 100) + minute;
}
else {
Print("Incorrect time value format. Value: '" + time + "'");
return 0;
}
}

//+------------------------------------------------------------------+

int sqGetDate(int day, int month, int year) {
return (year - 1900) * 10000 + month * 100 + day;
}

//+------------------------------------------------------------------+

int sqGetBarDate(datetime dt) {
return (TimeYear(dt) - 1900) * 10000 + TimeMonth(dt) * 100 + TimeDay(dt);
}

//+------------------------------------------------------------------+

double sqGetTime(int hour, int minute, int second) {
return 100 * hour + minute + 0.01 * second;
}

//+------------------------------------------------------------------+

int getSQTime(datetime time){
int minutesToday = (int) ((ulong) time / 60) % (24 * 60);
int hours = minutesToday / 60;
int minutes = minutesToday % 60;

return hours*100 + minutes;
}

//+------------------------------------------------------------------+

double sqSafeDivide(double var1, double var2) {
if(var2 == 0) return(100000000);
return(var1/var2);
}

//+------------------------------------------------------------------+
//+ Candle Pattern functions
//+------------------------------------------------------------------+

bool sqBearishEngulfing(string symbol, int timeframe, int shift) {
double O = sqOpen(symbol, timeframe, shift);
double O1 = sqOpen(symbol, timeframe, shift+1);
double C = sqClose(symbol, timeframe, shift);
double C1 = sqClose(symbol, timeframe, shift+1);

double ocDiff = NormalizeDouble(O-C, _Digits);
double o1c1Diff = NormalizeDouble(C1-O1, _Digits);

if ((C1>O1)&&(O>C)&&(O>=C1)&&(O1>=C)&&(ocDiff>o1c1Diff)) {
return(true);
}

return(false);
}

//+------------------------------------------------------------------+

bool sqBullishEngulfing(string symbol, int timeframe, int shift) {
double O = sqOpen(symbol, timeframe, shift);
double O1 = sqOpen(symbol, timeframe, shift+1);
double C = sqClose(symbol, timeframe, shift);
double C1 = sqClose(symbol, timeframe, shift+1);

double coDiff = NormalizeDouble(C-O, _Digits);
double o1c1Diff = NormalizeDouble(O1-C1, _Digits);

if ((O1>C1)&&(C>O)&&(C>=O1)&&(C1>=O)&&(coDiff>o1c1Diff)) {
return(true);
}

return(false);
}

//+------------------------------------------------------------------+

bool sqDarkCloudCover(string symbol, int timeframe, int shift) {
double L = sqLow(symbol, timeframe, shift);
double H = sqHigh(symbol, timeframe, shift);

double O = sqOpen(symbol, timeframe, shift);
double O1 = sqOpen(symbol, timeframe, shift+1);
double C = sqClose(symbol, timeframe, shift);
double C1 = sqClose(symbol, timeframe, shift+1);

double tickSize = sqGetPointCoef(symbol);

    double Piercing_Line_Ratio = 0.5f;
    double Piercing_Candle_Length = 10.0f;

    double HL = NormalizeDouble(H-L, _Digits);
    double OC = NormalizeDouble(O-C, _Digits);
    double OC_HL = HL != 0 ? NormalizeDouble(OC/HL, 6) : 0;
    double O1C1_D2 = NormalizeDouble((O1+C1)/2, _Digits);
    double PCL_MTS = NormalizeDouble(Piercing_Candle_Length*tickSize, _Digits);

    if(C1 > O1 && O1C1_D2 > C && O > C && C > O1 && OC_HL > Piercing_Line_Ratio && HL >= PCL_MTS) {
        return true;
    }

return(false);
}

//+------------------------------------------------------------------+

bool sqDoji(string symbol, int timeframe, int shift) {
double diff = NormalizeDouble(MathAbs(sqOpen(symbol, timeframe, shift) - sqClose(symbol, timeframe, shift)), _Digits);
double coef = NormalizeDouble(sqGetPointCoef(symbol) * 0.6, _Digits);

if(diff < coef) {
return(true);
}

return(false);
}

//+------------------------------------------------------------------+

bool sqHammer(string symbol, int timeframe, int shift) {
double H = sqHigh(symbol, timeframe, shift);
double L = sqLow(symbol, timeframe, shift);
double L1 = sqLow(symbol, timeframe, shift+1);
double L2 = sqLow(symbol, timeframe, shift+2);
double L3 = sqLow(symbol, timeframe, shift+3);

double O = sqOpen(symbol, timeframe, shift);
double C = sqClose(symbol, timeframe, shift);
double CL = NormalizeDouble(H-L, _Digits);

double BodyLow, BodyHigh;
double Candle_WickBody_Percent = 0.9;
double CandleLength = 12;

if (O > C) {
BodyHigh = O;
BodyLow = C;
} else {
BodyHigh = C;
BodyLow = O;
}

double LW = NormalizeDouble(BodyLow - L, _Digits);
double UW = NormalizeDouble(H - BodyHigh, _Digits);
double BLa = NormalizeDouble(MathAbs(O - C), _Digits);
double BL90 = NormalizeDouble(BLa * Candle_WickBody_Percent, _Digits);

double pipValue = sqGetPointCoef(symbol);

double LW_D2 = NormalizeDouble(LW / 2, _Digits);
double LW_D3 = NormalizeDouble(LW / 3, _Digits);
double LW_D4 = NormalizeDouble(LW / 4, _Digits);
double BL90_M2 = NormalizeDouble(2 * BL90, _Digits);
double CL_MPV = NormalizeDouble(CandleLength * pipValue, _Digits);

if(L <= L1 && L < L2 && L < L3) {
        if(LW_D2 > UW && LW > BL90_M2 && CL >= CL_MPV && O != C && LW_D3 <= UW && LW_D4 <= UW) {
       return(true);
}
if(LW_D3 > UW && LW > BL90_M2 && CL >= CL_MPV && O != C && LW_D4 <= UW) {
   return(true);
}
if(LW_D4 > UW && LW > BL90_M2 && CL >= CL_MPV && O != C) {
       return(true);
}
}

return(false);
}

//+------------------------------------------------------------------+

bool sqPiercingLine(string symbol, int timeframe, int shift) {
double L = sqLow(symbol, timeframe, shift);
double H = sqHigh(symbol, timeframe, shift);

double O = sqOpen(symbol, timeframe, shift);
double O1 = sqOpen(symbol, timeframe, shift+1);
double C = sqClose(symbol, timeframe, shift);
double C1 = sqClose(symbol, timeframe, shift+1);

double tickSize = sqGetPointCoef(symbol);

    double Piercing_Line_Ratio = 0.5f;
    double Piercing_Candle_Length = 10.0f;

    double HL = NormalizeDouble(H-L, _Digits);
    double CO = NormalizeDouble(C-O, _Digits);
    double CO_HL = HL != 0 ? NormalizeDouble(CO/HL, 6) : 0;
    double O1C1_D2 = NormalizeDouble((O1+C1)/2, _Digits);
    double PCL_MTS = NormalizeDouble(Piercing_Candle_Length*tickSize, _Digits);

    if(C1 < O1 && O1C1_D2 < C && O < C && C < O1 && CO_HL > Piercing_Line_Ratio && HL >= PCL_MTS) {
        return true;
    }

return(false);
}

//+------------------------------------------------------------------+

bool sqShootingStar(string symbol, int timeframe, int shift) {
double L = sqLow(symbol, timeframe, shift);
double H = sqHigh(symbol, timeframe, shift);
double H1 = sqHigh(symbol, timeframe, shift + 1);
double H2 = sqHigh(symbol, timeframe, shift + 2);
double H3 = sqHigh(symbol, timeframe, shift + 3);

double O = sqOpen(symbol, timeframe, shift);
double C = sqClose(symbol, timeframe, shift);
double CL = NormalizeDouble(H - L, _Digits);

double BodyLow, BodyHigh;
double Candle_WickBody_Percent = 0.9;
double CandleLength = 12;

if (O > C) {
BodyHigh = O;
BodyLow = C;
} else {
BodyHigh = C;
BodyLow = O;
}

double LW = NormalizeDouble(BodyLow - L, _Digits);
double UW = NormalizeDouble(H - BodyHigh, _Digits);
double BLa = NormalizeDouble(MathAbs(O - C), _Digits);
double BL90 = NormalizeDouble(BLa * Candle_WickBody_Percent, _Digits);

double pipValue = sqGetPointCoef(symbol);

double UW_D2 = NormalizeDouble(UW / 2, _Digits);
double UW_D3 = NormalizeDouble(UW / 3, _Digits);
double UW_D4 = NormalizeDouble(UW / 4, _Digits);
double BL90_M2 = NormalizeDouble(2 * BL90, _Digits);
double CL_MPV = NormalizeDouble(CandleLength * pipValue, _Digits);

if(H >= H1 && H > H2 && H > H3) {
if(UW_D2 > LW && UW > BL90_M2 && CL >= CL_MPV && O != C && UW_D3 <= LW && UW_D4 <= LW) {
return(true);
}
if(UW_D3 > LW && UW > BL90_M2 && CL >= CL_MPV && O != C && UW_D4 <= LW) {
return(true);
}
if(UW_D4 > LW && UW > BL90_M2 && CL >= CL_MPV && O != C) {
return(true);
}
}

return(false);
}

//+------------------------------------------------------------------+

double sqOpen(string symbol, int timeframe, int shift) {
if(symbol == "NULL") {
return (iOpen(NULL, timeframe, shift));
} else {
return (iOpen(symbol, timeframe, shift));
}
}

//+------------------------------------------------------------------+

double sqHigh(string symbol, int timeframe, int shift) {
if(symbol == "NULL") {
return (iHigh(NULL, timeframe, shift));
} else {
return (iHigh(symbol, timeframe, shift));
}
}

//+------------------------------------------------------------------+

double sqLow(string symbol, int timeframe, int shift) {
if(symbol == "NULL") {
return (iLow(NULL, timeframe, shift));
} else {
return (iLow(symbol, timeframe, shift));
}
}

//+------------------------------------------------------------------+

double sqClose(string symbol, int timeframe, int shift) {
if(symbol == "NULL") {
return (iClose(NULL, timeframe, shift));
} else {
return (iClose(symbol, timeframe, shift));
}
}

//+------------------------------------------------------------------+

double sqTrueRange(string symbol, int timeframe, int shift) {

double close1 = sqClose(symbol, timeframe, shift+1);
double high = sqHigh(symbol, timeframe, shift+1);
double low = sqLow(symbol, timeframe, shift+1);

double TrueHigh, TrueLow;

   if(close1 > high) {
       TrueHigh = close1;
   } else {
       TrueHigh = high;
   }

   if(close1 < low) {
       TrueLow = close1;
   } else {
       TrueLow = low;
   }

   double TrueRange = TrueHigh - TrueLow;

   return (TrueRange);
}

//+------------------------------------------------------------------+

bool sqTradeRecentlyClosed(string symbol, int magicNumber, bool checkThisBar, bool checkThisMinute) {
int ordersChecked = 0;

string strCurrentTimeMinutes = TimeToStr( TimeCurrent(), TIME_DATE|TIME_MINUTES);

for (int cc = OrdersHistoryTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS,MODE_HISTORY)) {

// skip pending orders
if(OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLSTOP || OrderType() == OP_SELLLIMIT) {
continue;
}

if(magicNumber != 0 && OrderMagicNumber() != magicNumber) continue;

if(symbol != "Any") {
if(OrderSymbol() != correctSymbol(symbol)) continue;
}

ordersChecked++;
           if(ordersChecked > 10) {
               // check only the very last 10 orders
               break;
           }

           if(checkThisBar) {
               if(OrderCloseTime() >= Time[0]) {
                   // order finished this bar
                   return(true);
               }
           }

if(checkThisMinute) {
string strCloseTimeMinutes = TimeToStr( OrderCloseTime(), TIME_DATE|TIME_MINUTES);

               if(strCurrentTimeMinutes == strCloseTimeMinutes) {
                   // order finished this minute
                   return(true);
               }
           }
       }
}

return(false);
}

//+------------------------------------------------------------------+

double roundDown(double value, int decimals) {
   double p = 0;

   switch(decimals) {
       case 0: return (int) value;
       case 1: p = 10; break;
       case 2: p = 100; break;
       case 3: p = 1000; break;
       case 4: p = 10000; break;
       case 5: p = 100000; break;
       case 6: p = 1000000; break;
       default: p = MathPow(10, decimals);
   }

   value = value * p;
   double tmp = MathFloor(value + 0.00000001);
   return NormalizeDouble(tmp/p, decimals);
}

//+------------------------------------------------------------------+

class CSQTime {
public:

datetime setHHMM(datetime time, string hhmm) {
string date = TimeToStr(time,TIME_DATE);//"yyyy.mm.dd"
return (StrToTime(date + " " + hhmm));
}

//+------------------------------------------------------------------+

datetime correctDayStart(datetime time) {
MqlDateTime strTime;
TimeToStruct(time, strTime);
strTime.hour = 0;
strTime.min = 0;
strTime.sec = 0;
return (StructToTime(strTime));
}

//+------------------------------------------------------------------+

datetime getDateInMs(datetime time) {
MqlDateTime strTime;
TimeToStruct(time, strTime);
strTime.hour = 0;
strTime.min = 0;
strTime.sec = 0;
return (StructToTime(strTime));
}

//+------------------------------------------------------------------+

datetime correctDayEnd(datetime time) {
MqlDateTime strTime;
TimeToStruct(time, strTime);
strTime.hour = 23;
strTime.min = 59;
strTime.sec = 59;
return (StructToTime(strTime));
}

//+------------------------------------------------------------------+

datetime setDayOfMonth(datetime time, int day) {
       MqlDateTime strTime;
       TimeToStruct(time, strTime);
       strTime.day = day;
       return (StructToTime(strTime));
}

//+------------------------------------------------------------------+

int getMonth(datetime time) {
return TimeMonth(time);
}

//+------------------------------------------------------------------+

int getDaysInMonth(datetime time) {
MqlDateTime strTime;
TimeToStruct(time, strTime);
   if(strTime.mon==2) {
       return 28+isLeapYear(strTime.year);
   }

   return 31-((strTime.mon-1)%7)%2;
}

//+------------------------------------------------------------------+

   bool isLeapYear(const int _year){
   if(_year%4 == 0){
       if(_year%400 == 0)return true;
       if(_year%100 > 0)return true;
   }
   return false;
   }

//+------------------------------------------------------------------+

datetime addDays(datetime time, int days) {
int oneDay = 60 * 60 * 24;

return (time + (days * oneDay));
}

//+------------------------------------------------------------------+

datetime setDayOfWeek(datetime time, int desiredDow) {
int dow = convertToSQDOW(TimeDayOfWeek(time));
desiredDow = convertToSQDOW(desiredDow);

int diffInDays = desiredDow - dow;

//Print("DiffInDays: ", diffInDays, ", dow: ", dow, ", desiredDow: ", desiredDow);

return addDays(time, diffInDays);
}

//+------------------------------------------------------------------+

/**
* converts from MT DOW format: 0 = Sunday, 1 = Monday ... 6 = Saturday
* to SQ DOW format: 1 = Monday, 2 = Tuesday ... 7 = Sunday
*/
int convertToSQDOW(int dow) {
if(dow == 0) dow = 7;

return(dow);
}
};

// create variable for class instance (required)
CSQTime* SQTime;

//+------------------------------------------------------------------+

bool sqEvaluateFuzzySignal(int conditionsCount, int minTrueConditions) {

   bool signalValue = false;
int trueConditionsCount = 0;

if(minTrueConditions <= 0) {
   minTrueConditions = 1;
}

   for(int i=0; i<conditionsCount; i++) {
       bool value = cond[i];

       if(value) {
           trueConditionsCount++;
       }

       if(trueConditionsCount >= minTrueConditions) {
           signalValue = true;
           break;
       }
   }

   return(signalValue);
}

//+------------------------------------------------------------------+

string correctSymbol(string symbol){
if(symbol == "NULL" || symbol == "Current" || symbol == "Same as main chart") {
return Symbol();
}
else return symbol;
}

//+------------------------------------------------------------------+

double sqFixMarketPrice(double price, string symbol){
symbol = correctSymbol(symbol);

double tickSize = MarketInfo(symbol, MODE_TICKSIZE);

if(tickSize == 0){
return price;
}

int digits = (int) MarketInfo(symbol, MODE_DIGITS);
double finalPrice = tickSize * MathRound(NormalizeDouble(price, digits) / tickSize);
return NormalizeDouble(finalPrice, digits);
}
//+------------------------------------------------------------------+

bool sqIsUptrend(string symbol, int timeframe, int method) {
if(method == 0) {
return (iClose(symbol, timeframe, 1) > sqMA(symbol, timeframe, 200, 0, MODE_SMA, PRICE_CLOSE, 1));
}
return(false);
}

//+------------------------------------------------------------------+

bool sqIsDowntrend(string symbol, int timeframe, int method) {
if(method == 0) {
return (iClose(symbol, timeframe, 1) < sqMA(symbol, timeframe, 200, 0, MODE_SMA, PRICE_CLOSE, 1));
}
return(false);
}

//+------------------------------------------------------------------+

int sqGetMonthLastTradingDay(string symbol, int timeframe, bool includeWeekends) {
datetime barTime = iTime(symbol, timeframe, 0);
datetime lastTradingDate = SQTime.setDayOfMonth(barTime, SQTime.getDaysInMonth(barTime));

   if(!includeWeekends) {
       if(TimeDayOfWeek(lastTradingDate) == 6) {
           lastTradingDate = SQTime.addDays(lastTradingDate, -1);

       } else if(TimeDayOfWeek(lastTradingDate) == 0) {
           lastTradingDate = SQTime.addDays(lastTradingDate, -2);
       }
   }

return TimeDay(lastTradingDate);
}

//+------------------------------------------------------------------+

datetime monthFirstTradingDay = 0;

bool sqIsMonthFirstTradingDay(string symbol, int timeframe, bool includeWeekends) {
   datetime date = SQTime.getDateInMs(iTime(symbol, timeframe, 0));

   if(monthFirstTradingDay == 0) {
       monthFirstTradingDay = date;
   }

   if(SQTime.getMonth(monthFirstTradingDay)!=SQTime.getMonth(date)) {
       if(!includeWeekends) {
           if(TimeDayOfWeek(date) != 6 && TimeDayOfWeek(date) != 0) {
               monthFirstTradingDay = date;
           }
       } else {
           monthFirstTradingDay = date;
       }
   }

return monthFirstTradingDay==date;
}

//+------------------------------------------------------------------+

bool isMarketClosed(string symbol){
return !IsTesting() && !IsOptimization() && MarketInfo(symbol, MODE_TRADEALLOWED) == 0;
}

//+------------------------------------------------------------------+

double fixLotSize(string symbol, double size){
string correctedSymbol = correctSymbol(symbol);
double Smallest_Lot = MarketInfo(correctedSymbol, MODE_MINLOT);
double Largest_Lot = MarketInfo(correctedSymbol, MODE_MAXLOT);
double LotStep = MarketInfo(correctedSymbol, MODE_LOTSTEP);

double mod = MathMod(size, LotStep);
double finalSize = size;

if(MathAbs(mod - LotStep) > 0.000001){
finalSize -= mod;
}

if(finalSize < Smallest_Lot){
Verbose("Calculated lot size (", DoubleToStr(finalSize), ") is lower than minimum possible (", DoubleToStr(Smallest_Lot), "). Using minimum lot size...");
return Smallest_Lot;
}
else if(finalSize > Largest_Lot){
Verbose("Calculated lot size (", DoubleToStr(finalSize), ") is larger than maximum possible (", DoubleToStr(Largest_Lot), "). Using maximum lot size...");
return Largest_Lot;
}
else {
return finalSize;
}
}

double roundValue(double value){
return NormalizeDouble(value + 0.0000000001, 6);
}

//+------------------------------------------------------------------+

int sqFixRanges(int value, int min, int max, int defaultVal) {
if(value < min || value > max) {
return (defaultVal);
}

return value;
}

//+------------------------------------------------------------------+

double sqBarRange(string symbol, int timeframe, int shift) {
double range;
if(symbol == "NULL" || symbol == "Current") {
range = iHigh(NULL, timeframe, shift) - iLow(NULL, timeframe, shift);
} else {
range = iHigh(symbol, timeframe, shift) - iLow(symbol, timeframe, shift);
}

return roundValue(range);
}

//+------------------------------------------------------------------+

double sqHeikenAshi(string symbol, int timeframe, string mode, int shift) {
if(symbol == "NULL" || symbol == "Current") {
if(mode == "Open") {
return(NormalizeDouble(iCustom(NULL, timeframe, "SqHeikenAshi", 0,0,0,0, 2, shift), 6));
}
if(mode == "Close") {
return(NormalizeDouble(iCustom(NULL, timeframe, "SqHeikenAshi", 0,0,0,0, 3, shift), 6));
}
if(mode == "High") {
return(NormalizeDouble(MathMax(iCustom( NULL, timeframe, "SqHeikenAshi", 0,0,0,0, 0, shift), iCustom( NULL, timeframe, "SqHeikenAshi", 0,0,0,0, 1, shift)), 6));
}
if(mode == "Low") {
return(NormalizeDouble(MathMin(iCustom( NULL, timeframe, "SqHeikenAshi", 0,0,0,0, 0, shift), iCustom( NULL, timeframe, "SqHeikenAshi", 0,0,0,0, 1, shift)), 6));
}

} else {
if(mode == "Open") {
return(NormalizeDouble(iCustom( symbol, timeframe, "SqHeikenAshi", 0,0,0,0, 2, shift), 6));
}
if(mode == "Close") {
return(NormalizeDouble(iCustom( symbol, timeframe, "SqHeikenAshi", 0,0,0,0, 3, shift), 6));
}
if(mode == "High") {
return(NormalizeDouble(MathMax(iCustom( symbol, timeframe, "SqHeikenAshi", 0,0,0,0, 0, shift), iCustom( symbol, timeframe, "SqHeikenAshi", 0,0,0,0, 1, shift)), 6));
}
if(mode == "Low") {
return(NormalizeDouble(MathMin(iCustom( symbol, timeframe, "SqHeikenAshi", 0,0,0,0, 0, shift), iCustom( symbol, timeframe, "SqHeikenAshi", 0,0,0,0, 1, shift)), 6));
}
}

return(-1);
}

//+------------------------------------------------------------------+

double sqBiggestRange(string symbol, int timeframe, int period, int shift) {
double maxnum = -100000000;
double range;

for(int i=shift; i<shift+period; i++) {
if(symbol == "NULL" || symbol == "Current") {
range = iHigh(NULL, timeframe, i) - iLow(NULL, timeframe, i);
} else {
range = iHigh(symbol, timeframe, i) - iLow(symbol, timeframe, i);
}

if(range > maxnum) {
maxnum = range;
}
}

return roundValue(maxnum);
}

//+------------------------------------------------------------------+

double sqSmallestRange(string symbol, int timeframe, int period, int shift) {
double minnum = 100000000;
double range;

for(int i=shift; i<shift+period; i++) {
if(symbol == "NULL" || symbol == "Current") {
range = iHigh(NULL, timeframe, i) - iLow(NULL, timeframe, i);
} else {
range = iHigh(symbol, timeframe, i) - iLow(symbol, timeframe, i);
}

if(range < minnum) {
minnum = range;
}
}

return roundValue(minnum);
}

//+------------------------------------------------------------------+

double sqMA(string symbol, int timeframe, int ma_period, int ma_shift, int ma_method, int applied_price, int shift) {

ma_method = sqFixRanges(ma_method, 0, 3, 0);
applied_price = sqFixRanges(applied_price, 0, 6, 0);

return roundValue(iMA(symbol, timeframe, ma_period, ma_shift, ma_method, applied_price, shift));
}

//+------------------------------------------------------------------+

double sqTEMA(string symbol, int timeframe, int ma_period, int applied_price, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqTEMA", ma_period, applied_price, 0, shift));
}

//+------------------------------------------------------------------+

double sqIchimoku(string symbol, int timeframe, int tenkanPeriod, int kijunPeriod, int senkouPeriod, int line, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqIchimoku", tenkanPeriod, kijunPeriod, senkouPeriod, line, shift));
}

//+------------------------------------------------------------------+

double sqAroon(string symbol, int timeframe, int period, int line, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqAroon", period, false, false, line, shift));
}

//+------------------------------------------------------------------+

double sqBBWidthRatio(string symbol, int timeframe, int period, double deviation, int appliedPrice, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqBBWidthRatio", period, deviation, appliedPrice, 0, shift));
}

//+------------------------------------------------------------------+

double sqAvgVolume(string symbol, int timeframe, int period, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqAvgVolume", period, 1, shift));
}

//+------------------------------------------------------------------+

double sqFibo(string symbol, int timeframe, int fiboRange, double fiboLevel) {
fiboRange = sqFixRanges(fiboRange, 1, 7, 1);

return roundValue(iCustom(symbol, timeframe, "SqFibo", fiboRange, fiboLevel, 0, 0, 0));
}

//+------------------------------------------------------------------+

double sqLinReg(string symbol, int timeframe, int period, int line, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqLinReg", period, line, 0, shift));
}

//+------------------------------------------------------------------+

double sqPivots(string symbol, int timeframe, int startHour, int startMinute, int line, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqPivots", startHour, startMinute, line, shift));
}

//+------------------------------------------------------------------+

double sqQQE(string symbol, int timeframe, int rsiPeriod, int sF, double wF, int line, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqQQE", rsiPeriod, sF, wF, line, shift));
}

//+------------------------------------------------------------------+

double sqKeltnerChannel(string symbol, int timeframe, int period, double Deviation, int line, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqKeltnerChannel", period, Deviation, line, shift));
}

//+------------------------------------------------------------------+

double sqMTKeltnerChannel(string symbol, int timeframe, int period, double Deviation, int line, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqMTKeltnerChannel", period, Deviation, line, shift));
}

//+------------------------------------------------------------------+

double sqRSI(string symbol, int timeframe, int period, int applied_price, int shift) {
return roundValue(iRSI(symbol, timeframe, period, applied_price, shift));
}

//+------------------------------------------------------------------+

double sqCCI(string symbol, int timeframe, int period, int applied_price, int shift) {
return roundValue(iCCI(symbol, timeframe, period, applied_price, shift));
}

//+------------------------------------------------------------------+

double sqAC(string symbol, int timeframe, int shift) {
return roundValue(iAC(symbol, timeframe, shift));
}

//+------------------------------------------------------------------+

double sqADX(string symbol, int timeframe, int period, int line, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqADX", period, line, shift));
}

//+------------------------------------------------------------------+

double sqATR(string symbol, int timeframe, int period, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqATR", period, 0, shift));
}

//+------------------------------------------------------------------+

double sqAO(string symbol, int timeframe, int shift) {
return roundValue(iAO(symbol, timeframe, shift));
}

//+------------------------------------------------------------------+

double sqBearsPower(string symbol, int timeframe, int period, int applied_price, int shift) {
return roundValue(iBearsPower(symbol, timeframe, period, applied_price, shift));
}

//+------------------------------------------------------------------+

double sqBullsPower(string symbol, int timeframe, int period, int applied_price, int shift) {
return roundValue(iBullsPower(symbol, timeframe, period, applied_price, shift));
}

//+------------------------------------------------------------------+

double sqDeMarker(string symbol, int timeframe, int period, int shift) {
return roundValue(iDeMarker(symbol, timeframe, period, shift));
}

//+------------------------------------------------------------------+

double sqMACD(string symbol, int timeframe, int fast_ema_period, int slow_ema_period, int signal_period, int applied_price, int mode, int shift) {
return roundValue(iMACD(symbol, timeframe, fast_ema_period, slow_ema_period, signal_period, applied_price, mode, shift));
}

//+------------------------------------------------------------------+

double sqMomentum(string symbol, int timeframe, int period, int applied_price, int shift) {
return roundValue(iMomentum(symbol, timeframe, period, applied_price, shift));
}

//+------------------------------------------------------------------+

double sqStochastic(string symbol, int timeframe, int Kperiod, int Dperiod, int slowing, int method, int price_field, int mode, int shift) {
price_field = sqFixRanges(price_field, 0, 1, 0);
method = sqFixRanges(method, 0, 3, 0);

return roundValue(iCustom(symbol, timeframe, "SqStochastic", Kperiod, Dperiod, slowing, method, price_field, mode, shift));
}

//+------------------------------------------------------------------+

double sqOsMA(string symbol, int timeframe, int fast_ema_period, int slow_ema_period, int signal_period, int applied_price, int shift) {
return roundValue(iOsMA(symbol, timeframe, fast_ema_period, slow_ema_period, signal_period, applied_price, shift));
}

//+------------------------------------------------------------------+

double sqBands(string symbol, int timeframe, int period, double deviation, int bands_shift, int applied_price, int mode, int shift) {
return roundValue(iBands(symbol, timeframe, period, deviation, bands_shift, applied_price, mode+1, shift));
}

//+------------------------------------------------------------------+

double sqBBRange(string symbol, int timeframe, int period, double deviation, int applied_price, int shift) {
return roundValue(iBands(symbol, timeframe, period, deviation, 0, applied_price, 1, shift) - iBands(symbol, timeframe, period, deviation, 0, applied_price, 2, shift));
}

//+------------------------------------------------------------------+

double sqSAR(string symbol, int timeframe, double step, double maximum, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqParabolicSAR", step, maximum, 0, shift));
//return roundValue(iSAR(symbol, timeframe, step, maximum, shift));
}

//+------------------------------------------------------------------+

double sqStdDev(string symbol, int timeframe, int ma_period, int ma_shift, int ma_method, int applied_price, int shift) {
return roundValue(iStdDev(symbol, timeframe, ma_period, ma_shift, ma_method, applied_price, shift));
}

//+------------------------------------------------------------------+

double sqHighestInRange(string symbol, int timeframe, string timeFrom, string timeTo, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqHighestInRange", timeFrom, timeTo, 0, shift));
}

//+------------------------------------------------------------------+

double sqLowestInRange(string symbol, int timeframe, string timeFrom, string timeTo, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqLowestInRange", timeFrom, timeTo, 0, shift));
}

//+------------------------------------------------------------------+

double sqFractal(string symbol, int timeframe, int fractal, int bufferIndex, int shift) {
return roundValue(iCustom(symbol, timeframe, "SqFractal", fractal, bufferIndex, shift));
}

//+------------------------------------------------------------------+

bool sqIchimokuChikouSpanCross(int bullishOrBearish, string symbol, int timeframe, int tenkanPeriod, int kijunPeriod, int senkouPeriod, int shift, int signalStrength) {
double chikouSpan1 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 4, shift+1);
   double chikouSpan0 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 4, shift);
   double c = iClose(symbol, timeframe, shift);
   double kumoTop = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 2, shift);
   double kumoBottom = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 3, shift);
   if(kumoBottom > kumoTop) {
       double temp = kumoBottom;
       kumoBottom = kumoTop;
       kumoTop = temp;
   }

signalStrength = sqFixRanges(signalStrength, 0, 2, 1);

   bool signal;

   if(bullishOrBearish == -1) {
   // bearish;
   signal = (chikouSpan1 >= c) && (chikouSpan0 < c) && (chikouSpan1 > chikouSpan0);

       if(signalStrength == 2) {
           // for strong signal the cross should happen below kumo cloud
           signal = signal && (c < kumoBottom);

       } else if(signalStrength == 1) {
           // for neutral signal the cross should happen in kumo cloud
           signal = signal && (c < kumoTop);

       } else if(signalStrength == 0) {
           // do nothing, if there is cross signal is always at least weak

       } else {
           return false;;
       }

       return signal;

   } else if(bullishOrBearish == 1) {
   // bullish
   signal = (chikouSpan1 <= c) && (chikouSpan0 > c) && (chikouSpan1 < chikouSpan0);

   if(signalStrength == 2) {
           // for strong signal the cross should happen above kumo cloud
           signal = signal && (c > kumoTop);

       } else if(signalStrength == 1) {
           // for neutral signal the cross should happen in kumo cloud
           signal = signal && (c > kumoBottom);

       } else if(signalStrength == 0) {
           // do nothing, if there is cross signal is always at least weak

       } else {
           return false;
       }

       return signal;

   } else {
           return false;
   }
}

//+------------------------------------------------------------------+

bool sqIchimokuSenkouSpanCross(int bullishOrBearish, string symbol, int timeframe, int tenkanPeriod, int kijunPeriod, int senkouPeriod, int shift, int signalStrength) {
   double senkouSpanA1 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 2, shift+1);
   double senkouSpanA0 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 2, shift);
   double senkouSpanB1 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 3, shift+1);
   double senkouSpanB0 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 3, shift);
   double c = iClose(symbol, timeframe, shift);

   double kumoTop = MathMax(senkouSpanA0, senkouSpanB0);
   double kumoBottom = MathMin(senkouSpanA0, senkouSpanB0);

   bool signal;

signalStrength = sqFixRanges(signalStrength, 0, 2, 1);

   if(bullishOrBearish == -1) {
   // bearish;
   signal = (senkouSpanA1 > senkouSpanB1) && (senkouSpanA0 < senkouSpanB0);

       if(signalStrength == 2) {
           // for strong signal the cross should happen below kumo cloud
           signal = signal && (c < kumoBottom);

       } else if(signalStrength == 1) {
           // for neutral signal the cross should happen in kumo cloud
           signal = signal && (c < kumoTop);

       } else if(signalStrength == 0) {
           // do nothing, if there is cross signal is always at least weak

       } else {
           return false;;
       }

       return signal;

   } else if(bullishOrBearish == 1) {
   // bullish
   signal = (senkouSpanA1 < senkouSpanB1) && (senkouSpanA0 > senkouSpanB0);

   if(signalStrength == 2) {
           // for strong signal the cross should happen above kumo cloud
           signal = signal && (c > kumoTop);

       } else if(signalStrength == 1) {
           // for neutral signal the cross should happen in kumo cloud
           signal = signal && (c > kumoBottom);

       } else if(signalStrength == 0) {
           // do nothing, if there is cross signal is always at least weak

       } else {
           return false;
       }

       return signal;

   } else {
           return false;
   }
}

//+------------------------------------------------------------------+

bool sqIchimokuKijunSenCross(int bullishOrBearish, string symbol, int timeframe, int tenkanPeriod, int kijunPeriod, int senkouPeriod, int shift, int signalStrength) {
   double o = iOpen(symbol, timeframe, shift);
   double c = iClose(symbol, timeframe, shift);
   double kijun = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 1, shift);

   double kumoTop = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 2, shift);
   double kumoBottom = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 3, shift);
   if(kumoBottom > kumoTop) {
       double temp = kumoBottom;
       kumoBottom = kumoTop;
       kumoTop = temp;
   }

   bool signal;

signalStrength = sqFixRanges(signalStrength, 0, 2, 1);

   if(bullishOrBearish == -1) {
   // bearish;
   signal = (o > kijun) && c < kijun;

       if(signalStrength == 2) {
           // for strong signal the cross should happen below kumo cloud
           signal = signal && (kijun < kumoBottom);

       } else if(signalStrength == 1) {
           // for neutral signal the cross should happen in kumo cloud
           signal = signal && (kijun < kumoTop);

       } else if(signalStrength == 0) {
           // do nothing, if there is cross signal is always at least weak

       } else {
           return false;;
       }

       return signal;

   } else if(bullishOrBearish == 1) {
   // bullish
   signal = (o < kijun) && c > kijun;

       if(signalStrength == 2) {
           // for strong signal the cross should happen above kumo cloud
           signal = signal && (kijun > kumoTop);

       } else if(signalStrength == 1) {
           // for neutral signal the cross should happen in kumo cloud
           signal = signal && (kijun > kumoBottom);

       } else if(signalStrength == 0) {
           // do nothing, if there is cross signal is always at least weak

       } else {
           return false;
       }

       return signal;

   } else {
           return false;
   }
}

//+------------------------------------------------------------------+

bool sqIchimokuTenkanKijunCross(int bullishOrBearish, string symbol, int timeframe, int tenkanPeriod, int kijunPeriod, int senkouPeriod, int shift, int signalStrength) {
double tenkan1 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 0, shift+1);
double tenkan0 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 0, shift);

double kijun1 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 1, shift+1);
double kijun0 = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 1, shift);

   double kumoTop = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 2, shift);
   double kumoBottom = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 3, shift);
   if(kumoBottom > kumoTop) {
       double temp = kumoBottom;
       kumoBottom = kumoTop;
       kumoTop = temp;
   }

   bool signal;

signalStrength = sqFixRanges(signalStrength, 0, 2, 1);

   if(bullishOrBearish == -1) {
   // bearish;
   signal = (tenkan1 > kijun1) && tenkan0 < kijun0;

       if(signalStrength == 2) {
           // for strong signal the cross should happen below kumo cloud
           signal = signal && (tenkan0 < kumoBottom);

       } else if(signalStrength == 1) {
           // for neutral signal the cross should happen in kumo cloud
           signal = signal && (tenkan0 < kumoTop);

       } else if(signalStrength == 0) {
           // do nothing, if there is cross signal is always at least weak

       } else {
           return false;;
       }

       return signal;

   } else if(bullishOrBearish == 1) {
   // bullish
   signal = (tenkan1 < kijun1) && tenkan0 > kijun0;

       if(signalStrength == 2) {
           // for strong signal the cross should happen above kumo cloud
           signal = signal && (tenkan0 > kumoTop);

       } else if(signalStrength == 1) {
           // for neutral signal the cross should happen in kumo cloud
           signal = signal && (tenkan0 > kumoBottom);

       } else if(signalStrength == 0) {
           // do nothing, if there is cross signal is always at least weak

       } else {
           return false;
       }

       return signal;

   } else {
           return false;
   }
}

//+------------------------------------------------------------------+

bool sqIchimokuKumoBreakout(int bullishOrBearish, string symbol, int timeframe, int tenkanPeriod, int kijunPeriod, int senkouPeriod, int shift) {
double o = iOpen(symbol, timeframe, shift);
double c = iClose(symbol, timeframe, shift);

   double kumoTop = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 2, shift);
   double kumoBottom = sqIchimoku(symbol, timeframe, tenkanPeriod, kijunPeriod, senkouPeriod, 3, shift);
   if(kumoBottom > kumoTop) {
       double temp = kumoBottom;
       kumoBottom = kumoTop;
       kumoTop = temp;
   }

   bool signal;

   if(bullishOrBearish == -1) {
   // bearish;
   signal = (o > kumoBottom) && c < kumoBottom;

       return signal;

   } else if(bullishOrBearish == 1) {
   // bullish
   signal = (o < kumoTop) && c > kumoTop;

       return signal;

   } else {
           return false;
   }
}

//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
// ExitMethods includes
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+

// Move Stop Loss to Break Even
void sqManageSL2BE(int ticket) {

double val = sqGetGlobalVariable(ticket, "MoveSL2BE");
if(val == 0) {
return;
}

if(!OrderSelect(ticket, SELECT_BY_TICKET)) {
return;
}

double moveSLAtValue = sqGetValueByIdentification((string) val);

if(moveSLAtValue > 0) {
double newSL = 0;
int error;

int valueType = (int) sqGetGlobalVariable(ticket, "MoveSL2BEType");
int orderType = OrderType();
int digits = (int) MarketInfo(OrderSymbol(), MODE_DIGITS);

if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
if(valueType == SLPTTYPE_RANGE) {
moveSLAtValue = Bid - moveSLAtValue;
}
} else {
if(valueType == SLPTTYPE_RANGE) {
moveSLAtValue = Ask + moveSLAtValue;
}
}

moveSLAtValue = NormalizeDouble(moveSLAtValue, digits);
double addPips = NormalizeDouble(sqGetValueByIdentification((string) sqGetGlobalVariable(ticket, "SL2BEAddPips")), digits);

double currentSL = OrderStopLoss();

if(orderType == OP_BUY) {
newSL = NormalizeDouble(OrderOpenPrice() + addPips, digits);

if ((OrderOpenPrice() <= moveSLAtValue || sqDoublesAreEqual(OrderOpenPrice(), moveSLAtValue)) && (currentSL == 0 || currentSL < newSL) && !sqDoublesAreEqual(currentSL, newSL)) {
Verbose("Moving SL 2 BE for order with ticket: ", IntegerToString(OrderTicket()), " to :", DoubleToString(newSL));
if(!sqOrderModify(OrderTicket(), OrderOpenPrice(), newSL, OrderTakeProfit())) {
error = GetLastError();
Verbose("Failed, error: ", IntegerToString(error), " - ", ErrorDescription(error),", Ask: ", DoubleToString(Ask), ", Bid: ", DoubleToString(Bid), " Current SL: ", DoubleToString(currentSL));
}
}

} else { // orderType == OP_SELL
newSL = NormalizeDouble(OrderOpenPrice() - addPips, digits);

if ((OrderOpenPrice() >= moveSLAtValue || sqDoublesAreEqual(OrderOpenPrice(), moveSLAtValue)) && (currentSL == 0 || currentSL > newSL) && !sqDoublesAreEqual(currentSL, newSL)) {
Verbose("Moving SL 2 BE for order with ticket: ", IntegerToString(OrderTicket()), " to :", DoubleToString(newSL));
if(!sqOrderModify(OrderTicket(), OrderOpenPrice(), newSL, OrderTakeProfit())) {
error = GetLastError();
Verbose("Failed, error: ", IntegerToString(error), " - ", ErrorDescription(error),", Ask: ", DoubleToString(Ask), ", Bid: ", DoubleToString(Bid), " Current SL: ", DoubleToString(currentSL));
}
}
}
}
}
// Trailing Stop
void sqManageTrailingStop(int ticket) {

double val = sqGetGlobalVariable(ticket, "TrailingStop");
if(val == 0) {
return;
}

if(!OrderSelect(ticket, SELECT_BY_TICKET)) {
return;
}

double tsValue = sqGetValueByIdentification((string) val);

if(tsValue > 0) {
double plValue;
int error;

int valueType = (int) sqGetGlobalVariable(ticket, "TrailingStopType");
int orderType = OrderType();
int digits = (int) MarketInfo(OrderSymbol(), MODE_DIGITS);

if(orderType == OP_BUY || orderType == OP_BUYSTOP || orderType == OP_BUYLIMIT) {
if(valueType == SLPTTYPE_RANGE) {
tsValue = Bid - tsValue;
}
} else {
if(valueType == SLPTTYPE_RANGE) {
tsValue = Ask + tsValue;
}
}

tsValue = NormalizeDouble(tsValue, digits);

double tsActivation = NormalizeDouble(sqGetValueByIdentification((string) sqGetGlobalVariable(ticket, "TrailingActivation")), digits);
double currentSL = OrderStopLoss();

if(orderType == OP_BUY) {
plValue = NormalizeDouble(Bid - OrderOpenPrice(), digits);

if ((plValue >= tsActivation || sqDoublesAreEqual(plValue, tsActivation)) && (currentSL == 0 || currentSL < tsValue) && !sqDoublesAreEqual(currentSL, tsValue)) {
Verbose("Moving trailing stop for order with ticket: ", IntegerToString(OrderTicket()), " to :", DoubleToString(tsValue));
if(!sqOrderModify(OrderTicket(), OrderOpenPrice(), tsValue, OrderTakeProfit())) {
error = GetLastError();
Verbose("Failed, error: ", IntegerToString(error), " - ", ErrorDescription(error),", Ask: ", DoubleToString(Ask), ", Bid: ", DoubleToString(Bid), " Current SL: ", DoubleToString(currentSL));
}
}
} else { // orderType == OP_SELL
plValue = NormalizeDouble(OrderOpenPrice() - Ask, digits);

if ((plValue >= tsActivation || sqDoublesAreEqual(plValue, tsActivation)) && (currentSL == 0 || currentSL > tsValue) && !sqDoublesAreEqual(currentSL, tsValue)) {
Verbose("Moving trailing stop for order with ticket: ", IntegerToString(OrderTicket()), " to :", DoubleToString(tsValue));
if(!sqOrderModify(OrderTicket(), OrderOpenPrice(), tsValue, OrderTakeProfit())) {
error = GetLastError();
Verbose("Failed, error: ", IntegerToString(error), " - ", ErrorDescription(error),", Ask: ", DoubleToString(Ask), ", Bid: ", DoubleToString(Bid), " Current SL: ", DoubleToString(currentSL));
}
}
}
}
}
void sqManageExitAfterXBars(int ticket) {
int exitBars = (int) sqGetGlobalVariable(ticket, "ExitAfterBars");
if(exitBars > 0) {
if (sqGetOpenBarsForOrder(ticket, exitBars+10) >= exitBars) {
Verbose("Exit After ", IntegerToString(exitBars), "bars - closing order with ticket: ", IntegerToString(OrderTicket()));
sqClosePositionAtMarket(OrderLots());
}
}
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
// Trading Options includes
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+

class CTradingOption {
public:
virtual bool onBarUpdate() = 0;
};

//+------------------------------------------------------------------+

class CDontTradeOnWeekends: public CTradingOption {
private:
datetime thisFridayCloseTime;
datetime thisSundayOpenTime;

public:
CDontTradeOnWeekends() {
thisFridayCloseTime = D'1970.01.01';
thisSundayOpenTime = D'1970.01.01';
}

//+----------------------------------------------+

virtual bool onBarUpdate() {
if(!DontTradeOnWeekends) {
return true;
}

if(!sqIsBarOpen()) {
return(true);
}

datetime currentTime = TimeCurrent();

if(thisFridayCloseTime < 100) {
initTimes(currentTime, 0);
}

if(currentTime < thisFridayCloseTime) {
// trade normally
return true;
}

if(currentTime < thisSundayOpenTime) {
       // do not allow opening new positions until sunday.
            // returning false means there will be no more processing on this tick.
            // this is what we want because we don't want to be trading after close of all positions
            return false;
       }
else {
// new week starting
initTimes(currentTime, DayOfWeek() == 0 ? 1 : 0);

return true;
}
}

//+----------------------------------------------+

void initTimes(datetime currentTime, int addDays) {
if(addDays > 0) {
           thisFridayCloseTime = SQTime.addDays(currentTime, addDays);
   } else {
           thisFridayCloseTime = currentTime;
   }

   // set time of EOD
   thisFridayCloseTime = SQTime.setDayOfWeek(thisFridayCloseTime, (FridayCloseTime == "00:00" || FridayCloseTime == "0:00") ? SATURDAY : FRIDAY);
   thisFridayCloseTime = SQTime.setHHMM(thisFridayCloseTime, FridayCloseTime);

   thisSundayOpenTime = SQTime.setDayOfWeek(currentTime, SUNDAY);
thisSundayOpenTime = SQTime.setHHMM(thisSundayOpenTime, SundayOpenTime);
}
};

// create variable for class instance (required)
CDontTradeOnWeekends* objDontTradeOnWeekends;class CExitAtEndOfDay : public CTradingOption {
private:
   datetime dailyEODExitTime;
   datetime EODTime;
   bool closedThisDay;

public:
CExitAtEndOfDay() {
dailyEODExitTime = D'1970.01.01';
EODTime = D'1970.01.01';
closedThisDay = false;
}

//+----------------------------------------------+

virtual bool onBarUpdate() {
if(!ExitAtEndOfDay) {
return(true);
}

onTick();

if(!sqIsBarOpen()) {
return(true);
}

datetime currentTime = TimeCurrent();

   if(currentTime > EODTime) {
   //it is a new day
       initTimesForCurrentDay(currentTime);
   }

   if(currentTime >= dailyEODExitTime) {
       // returning false means there will be no more processing on this tick
   // this is what we want because we don't want to be trading after close of all positions
       return(false);
   }

   return(true);
}

   //------------------------------------------------------------------------

virtual void onTick() {
if(!ExitAtEndOfDay) {
       return;
   }

datetime currentTime = TimeCurrent();
datetime currentTimeDayStart = SQTime.correctDayStart(currentTime);
               datetime currentTimeDayEnd = SQTime.correctDayEnd(currentTime);

if(!closedThisDay && currentTime >= dailyEODExitTime) {
// we should close all positions at midnight, so close them at the first tick of a new day
       for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {

if(!checkMagicNumber(OrderMagicNumber())) continue;

bool isLiveOrder = OrderType() == OP_BUY || OrderType() == OP_SELL;

//Close all orders at the end of a day. When there is a data gap, on the first tick of new day close all pending orders and orders filled before current day start
if(currentTimeDayEnd == EODTime || !isLiveOrder || OrderOpenTime() < currentTimeDayStart) {
if(isLiveOrder){
sqClosePositionAtMarket(OrderLots());
}
else {
sqDeletePendingOrder(OrderTicket());
}
}
}
}

           closedThisDay = true;
   }

}

//+----------------------------------------------+

void initTimesForCurrentDay(datetime currentTime) {
// set end time of the current day (so that we now when new day starts)
EODTime = SQTime.correctDayEnd(currentTime);

   // set time of EOD
   if(EODExitTime == "00:00" || EODExitTime == "0:00"){
   dailyEODExitTime = EODTime;
   }
   else {
   dailyEODExitTime = SQTime.setHHMM(currentTime, EODExitTime);
   }

           closedThisDay = false;
}
};

// create variable for class instance (required)
CExitAtEndOfDay* objExitAtEndOfDay;

class CExitOnFriday : public CTradingOption {
private:
datetime thisFridayExitTime;
datetime thisSundayBeginTime;
datetime EOFDayTime;
bool closedThisWeek;

public:
CExitOnFriday() {
thisFridayExitTime = D'1970.01.01';
thisSundayBeginTime = D'1970.01.01';
closedThisWeek = false;
}

//+----------------------------------------------+

virtual bool onBarUpdate() {
if(!ExitOnFriday) {
return true;
}

onTick();

if(!sqIsBarOpen()) {
return(true);
}

datetime currentTime = TimeCurrent();

if(thisFridayExitTime < 100) {
initFridayExitTime(currentTime, 0);
}

if(currentTime < thisFridayExitTime) {
// trade normally
return true;
}

if(currentTime < thisSundayBeginTime) {
       // do not allow opening new positions until sunday.
            // returning false means there will be no more processing on this tick.
            // this is what we want because we don't want to be trading after close of all positions
            return false;
       }
else {
// new week starting
initFridayExitTime(currentTime, DayOfWeek() == 0 ? 1 : 0);

return true;
}
}

   //------------------------------------------------------------------------

virtual void onTick() {
if(!ExitOnFriday) {
           return;
}

datetime currentTime = TimeCurrent();
datetime currentTimeDayStart = SQTime.correctDayStart(currentTime);
               datetime currentTimeDayEnd = SQTime.correctDayEnd(currentTime);

       if(!closedThisWeek && currentTime >= thisFridayExitTime) {
                // time is over friday closing time, we should close the positions
                for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {

if(!checkMagicNumber(OrderMagicNumber())) continue;

bool isLiveOrder = OrderType() == OP_BUY || OrderType() == OP_SELL;

//Close all orders at the end of Friday. When there is a data gap, on the first tick of new day close all pending orders and orders filled before current day start
if(currentTimeDayEnd == EOFDayTime || !isLiveOrder || OrderOpenTime() < currentTimeDayStart) {
if(isLiveOrder){
sqClosePositionAtMarket(OrderLots());
}
else {
sqDeletePendingOrder(OrderTicket());
}
}
}
}

                closedThisWeek = true;
       }
}

//+----------------------------------------------+

void initFridayExitTime(datetime currentTime, int addDays) {
if(addDays > 0) {
           thisFridayExitTime = SQTime.addDays(currentTime, addDays);
   } else {
           thisFridayExitTime = currentTime;
   }

   // set time of EOD
   thisFridayExitTime = SQTime.setDayOfWeek(thisFridayExitTime, (FridayExitTime == "00:00" || FridayExitTime == "0:00") ? SATURDAY : FRIDAY);
   thisFridayExitTime = SQTime.setHHMM(thisFridayExitTime, FridayExitTime);

EOFDayTime = SQTime.correctDayEnd(thisFridayExitTime);

   thisSundayBeginTime = SQTime.setDayOfWeek(currentTime, SUNDAY);
   thisSundayBeginTime = SQTime.correctDayStart(thisSundayBeginTime);

closedThisWeek = false;
}
};

// create variable for class instance (required)
CExitOnFriday* objExitOnFriday;

class CLimitTimeRange : public CTradingOption {
private:
datetime dailySignalTimeRangeFrom;
datetime dailySignalTimeRangeTo;
bool closedThisDay;

public:
CLimitTimeRange() {
closedThisDay = false;
}

//+----------------------------------------------+

virtual bool onBarUpdate() {
   if(!LimitTimeRange) {
       return true;
   }

onTick();

if(!sqIsBarOpen()) {
return true;
}

   datetime currentTime = TimeCurrent();

   if(currentTime > dailySignalTimeRangeTo) {
       // it is new day
       initTimesForCurrentDay(currentTime);
   }

   if(currentTime < dailySignalTimeRangeFrom || currentTime >= dailySignalTimeRangeTo) {
       // time is outside given range
       // returning false means there will be no more processing on this tick
          // this is what we want because we don't want to be trading outside of this time range

       return false;
   }

   return true;
   }

//------------------------------------------------------------------------

virtual void onTick() {
if(!LimitTimeRange) {
       return;
   }

datetime currentTime = TimeCurrent();
if(!closedThisDay && ExitAtEndOfRange && currentTime >= dailySignalTimeRangeTo) {
       for (int cc = OrdersTotal() - 1; cc >= 0; cc--) {
if (OrderSelect(cc, SELECT_BY_POS)) {

if(!checkMagicNumber(OrderMagicNumber())) continue;

bool isLiveOrder = OrderType() == OP_BUY || OrderType() == OP_SELL;

if(isLiveOrder){
if(OrderTypeToExit != 2) { // not pending only
sqClosePositionAtMarket(OrderLots());
}
}
else {
if(OrderTypeToExit != 1) { // not live only
sqDeletePendingOrder(OrderTicket());
}
}
}
}

       closedThisDay = true;
   }
}

//------------------------------------------------------------------------

void initTimesForCurrentDay(datetime currentTime) {
    // set time of range open
    dailySignalTimeRangeFrom = SQTime.setHHMM(currentTime, SignalTimeRangeFrom);

   dailySignalTimeRangeTo = SQTime.setHHMM(currentTime, SignalTimeRangeTo);

int timeFrom = getHHMM(SignalTimeRangeFrom);
int timeTo = getHHMM(SignalTimeRangeTo);

if(timeFrom >= timeTo){
if(getSQTime(currentTime) < timeTo){
dailySignalTimeRangeFrom = SQTime.addDays(dailySignalTimeRangeFrom, -1);
}
else {
dailySignalTimeRangeTo = SQTime.addDays(dailySignalTimeRangeTo, 1);
}
}
else {
if(currentTime > dailySignalTimeRangeTo) {
               dailySignalTimeRangeFrom = SQTime.addDays(dailySignalTimeRangeFrom, 1);
               dailySignalTimeRangeTo = SQTime.addDays(dailySignalTimeRangeTo, 1);
           }
}

closedThisDay = false;
}
};

// create variable for class instance (required)
CLimitTimeRange* objLimitTimeRange;

class CMaxDistanceFromMarket : public CTradingOption {
private:

public:
CMaxDistanceFromMarket() {
}

//+----------------------------------------------+

virtual bool onBarUpdate() {
return true;
}
};

// create variable for class instance (required)
CMaxDistanceFromMarket* objMaxDistanceFromMarket;

class CMaxTradesPerDay : public CTradingOption {
private:
int lastHistoryPositionChecked;
datetime openTimeToday;
datetime EODTime;
bool reachedLimitToday;

public:
CMaxTradesPerDay() {
EODTime = D'1970.01.01';
lastHistoryPositionChecked = 0;
}

//+----------------------------------------------+

virtual bool onBarUpdate() {
if(MaxTradesPerDay <= 0) {
return true;
}

datetime currentTime = TimeCurrent();

if(currentTime > EODTime) {
// it is new day
initTimeForCurrentDay(currentTime);
}

       if(reachedLimitToday) {
       return false;
       }

if(getNumberOfTradesToday() >= MaxTradesPerDay) {
reachedLimitToday = true;
return(false);
}

return true;
}

//------------------------------------------------------------------------

void initTimeForCurrentDay(datetime currentTime) {
// set end time of the current day (so that we now when new day starts)
EODTime = SQTime.correctDayEnd(currentTime);

openTimeToday = SQTime.correctDayStart(currentTime);

reachedLimitToday = false;
}

//------------------------------------------------------------------------

       int getNumberOfTradesToday() {
           int todayTradesCount = 0;
           int i = 0;

           // count closed trades that started today
           int startAt = lastHistoryPositionChecked -10;
           if(startAt < 0) {
               startAt = 0;
           }

for(i=startAt;i<OrdersHistoryTotal();i++) {
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==true && checkMagicNumber(OrderMagicNumber())) {
lastHistoryPositionChecked = i;

if(OrderOpenTime() >= openTimeToday) {
todayTradesCount++;
}
}
}

for(i=0; i<OrdersTotal(); i++) {
if (OrderSelect(i,SELECT_BY_POS)==true && checkMagicNumber(OrderMagicNumber())) {

if(OrderOpenTime() >= openTimeToday) {
todayTradesCount++;
}
}
}

return todayTradesCount;
}
};

// create variable for class instance (required)
CMaxTradesPerDay* objMaxTradesPerDay;

class CMinMaxSLPT : public CTradingOption {
private:

public:
CMinMaxSLPT() {
}

//+----------------------------------------------+

virtual bool onBarUpdate() {
return true;
}
};

// create variable for class instance (required)
CMinMaxSLPT* objMinMaxSLPT;
// Money Management - Fixed Size used

//=============================================================================
// OrderReliable.mqh
//
// Copyright ? 2006, Derk Wehler (derkwehler@gmail.com)
//
// This file is simply LibOrderReliable as a header file instead of a library
//
// In order to read this code most clearly in the Metaeditor, it is advised
// that you set your tab settings to 4 (instead of the default 3):
// Tools->Options->General Tab, set Tab Size to 4, uncheck "Insert spaces"
//
// ***************************************************************************
// OrderReliable library MIT license
//
// Copyright (c) 2006 Derk Wehler
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// LICENSE LIMITATION
// This MIT license is limited only for use of OrderReliable within
// strategies generated by StrategyQuant. Any method from this library
// that will be used outside of this source code will be governed
// by GPL license.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
// ***************************************************************************

// ***************************************************************************
//
// A library for MT4 expert advisors, intended to give more reliable
// order handling.   This library only concerns the mechanics of sending
// orders to the Metatrader server, dealing with transient connectivity
// problems better than the standard order sending functions. It is
// essentially an error-checking wrapper around the existing transaction
// functions. This library provides nothing to help actual trade strategies,
// but ought to be valuable for nearly all expert advisors which trade 'live'.
//
//
//=============================================================================
//
// Contents:
//
//       OrderSendReliable()
//           This is intended to be a drop-in replacement for OrderSend()
//           which, one hopes is more resistant to various forms of errors
//           prevalent with MetaTrader.
//
//       OrderSendReliable2Step()
//           This function is intended to be used when brokers do not allow
//           initial stoploss and take-profit settings as part of the initial
//           market order. After successfully playing an order, it will then
//           Call OrderModifyReliable() to update the SL and TP settings.
//
//       OrderModifyReliable()
//           A replacement for OrderModify with more error handling.
//
//       OrderCloseReliable()
//           A replacement for OrderClose with more error handling.
//
//       OrderCloseReliableMKT()
//           This function is intended for closing orders ASAP; the
//           principal difference is that in its internal retry-loop,
//           it uses the new "Bid" and "Ask" real-time variables as opposed
//           to the OrderCloseReliable() which uses only the price given upon
//           entry to the routine. More likely to get the order closed if
// price moves, but more likely to "slip"
//
//       OrderDeleteReliable()
//           A replacement for OrderDelete with more error handling.
//
//===========================================================================
// CHANGE LOG BEGUN 28 March, 2014
// Prior to this, Source OffSite was used to save changes
// Start with revision 32, which is what SOS had as last change
//
// v32, 28 Mar 14:
// Small bug fixes for Build 600 changes
//
// v33, 25 Apr 16:
// Tiny adjustment made to GetOrderDetails() for non-forex pairs
//
// v34, 21 Jun 16:
// Changed SleepRandomTime() to just sleep 200ms
//
// v35, 20 Jul 16: (important)
// Added MySymbolConst2Val(), MySymbolVal2String(), necessary for correct
// functioning of GetOrderDetails()
//
// v36, 23 Apr 19: (Mark Fric, SQ)
// Added separate retry_attempts_bad_price variable that can configure repeat
// attempts for ERR_INVALID_PRICE and ERR_INVALID_STOPS errors
//
//   14.10.2020 (Tomas Brynda) - added ERR_MARKET_CLOSED on user requested
//   "important when using Daily strategies
//   during roll over market is closed for several seconds"
//
//===========================================================================

//=============================================================================
//                           OrderSendReliable()
//
// This is intended to be a drop-in replacement for OrderSend() which,
// one hopes, is more resistant to various forms of errors prevalent
// with MetaTrader.
//
//   RETURN VALUE:
// Ticket number or -1 under some error conditions.
//
// FEATURES:
// * Re-trying under some error conditions, sleeping a random
// time defined by an exponential probability distribution.
//
// * Automatic normalization of Digits
//
// * Automatically makes sure that stop levels are more than
// the minimum stop distance, as given by the server. If they
// are too close, they are adjusted.
//
// * Automatically converts stop orders to market orders
// when the stop orders are rejected by the server for
// being to close to market. NOTE: This intentionally
// applies only to OP_BUYSTOP and OP_SELLSTOP,
// OP_BUYLIMIT and OP_SELLLIMIT are not converted to market
// orders and so for prices which are too close to current
// this function is likely to loop a few times and return
// with the "invalid stops" error message.
// Note, the commentary in previous versions erroneously said
// that limit orders would be converted. Note also
// that entering a BUYSTOP or SELLSTOP new order is distinct
// from setting a stoploss on an outstanding order; use
// OrderModifyReliable() for that.
//
// * Displays various error messages on the log for debugging.
//
// ORIGINAL AUTHOR AND DATE:
// Matt Kennel, 2006-05-28
//
//=============================================================================
int OrderSendReliable(string symbol, int cmd, double volume, double price,
int slippage, double stoploss, double takeprofit,
string comment="", int magic=0, datetime expiration=0,
color arrow_color=CLR_NONE)
{
   OrderReliable_Fname = "OrderSendReliable";
   int ticket = -1;

price = NormalizeDouble(price, Digits);
   takeprofit = NormalizeDouble(takeprofit, Digits);
   stoploss = NormalizeDouble(stoploss, Digits);

   // ========================================================================
   // If testing or optimizing, there is no need to use this lib, as the
   // orders are not real-world, and always get placed optimally. By
   // refactoring this option to be in this library, one no longer needs
   // to create similar code in each EA.
   if (!UseForTesting)
   {
       if (IsOptimization() || IsTesting())
       {
           ticket = OrderSend(symbol, cmd, volume, price, slippage, stoploss,
           takeprofit, comment, magic, expiration, arrow_color);
           return(ticket);
       }
   }
   // ========================================================================

   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   // Get information about this order
   double realPoint = MarketInfo(symbol, MODE_POINT);
   double adjPoint = realPoint;
   if (adjPoint == 0.00001 || adjPoint == 0.001)
       adjPoint *= 10;
   int digits;
   double point, M = 0;
   double bid, ask;
   double sl, tp;
   double priceNow = 0;
   double hasSlippedBy = 0;

   GetOrderDetails(0, symbol, cmd, digits, point, sl, tp, bid, ask, false);
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

   OrderReliablePrint("Attempted " + OrderTypeToString(cmd) + " " + symbol + ": " + DoubleToStr(volume, 3) + " lots @" +
   DoubleToStr(price, digits+1) + " sl:" + DoubleToStr(stoploss, digits+1) + " tp:" + DoubleToStr(takeprofit, digits+1));

   // Normalize all price / stoploss / takeprofit to the proper # of digits.
   price = NormalizeDouble(price, digits);
   stoploss = NormalizeDouble(stoploss, digits);
   takeprofit = NormalizeDouble(takeprofit, digits);

// Check stop levels, adjust if necessary
EnsureValidStops(symbol, cmd, price, stoploss, takeprofit);

   int cnt, cnt_bad_price;
   GetLastError(); // clear the global variable.
   int err = 0;
   bool exit_loop = false;
   bool limit_to_market = false;
   bool fixed_invalid_price = false;

   // Concatenate to comment if enabled
   double symSpr = MarketInfo(symbol, MODE_ASK) - MarketInfo(symbol, MODE_BID);
   if (AddSpreadToComment)
       comment = comment + " (Spr: " + DoubleToStr(symSpr / adjPoint, 1) + ")";

   // Limit/Stop order...............................................................
   if (cmd > OP_SELL)
   {
       cnt = 0;
       cnt_bad_price = 0;
       while (!exit_loop)
       {
           // = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : =
           // Calculating our own slippage internally should not need to be done for pending orders; see market orders below
           // = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : =

           OrderReliablePrint("About to call OrderSend(), comment = " + comment);
           ticket = OrderSend(symbol, cmd, volume, price, slippage, stoploss,
           takeprofit, comment, magic, expiration, arrow_color);
           err = GetLastError();

           switch (err)
           {
               case ERR_NO_ERROR:
                   exit_loop = true;
                   break;

               // retryable errors
               case ERR_SERVER_BUSY:
               case ERR_NO_CONNECTION:
               case ERR_OFF_QUOTES:
               case ERR_BROKER_BUSY:
               case ERR_TRADE_CONTEXT_BUSY:
               case ERR_TRADE_TIMEOUT:
               case ERR_TRADE_DISABLED:
               case ERR_PRICE_CHANGED:
               case ERR_REQUOTE:
               case ERR_MARKET_CLOSED:
                   cnt++;
                   break;

               case ERR_INVALID_PRICE:
               case ERR_INVALID_STOPS:
                   cnt++;
                   cnt_bad_price++;
                   break;

               case ERR_INVALID_TRADE_PARAMETERS:
               default:
                   // an apparently serious error.
                   exit_loop = true;
                   break;

} // end switch

if (cnt > retry_attempts)
exit_loop = true;

if (cnt_bad_price > retry_attempts_bad_price)
exit_loop = true;

           if (exit_loop)
           {
               if (!limit_to_market)
               {
                   if (err != ERR_NO_ERROR && err != ERR_NO_RESULT)
                       OrderReliablePrint("Non-retryable error: " + OrderReliableErrTxt(err));
                   else if (cnt > retry_attempts)
                       OrderReliablePrint("Retry attempts maxed at " + IntegerToString(retry_attempts) +"("+IntegerToString(retry_attempts_bad_price)+")");
               }
           }
           else
           {
               OrderReliablePrint("Result of attempt " + IntegerToString(cnt) + " of " + IntegerToString(retry_attempts)+"("+IntegerToString(retry_attempts_bad_price)+")" + ": Retryable error: " + OrderReliableErrTxt(err));

               SleepRandomTime(sleep_time, sleep_maximum);
               RefreshRates();
           }
       }

       // We have now exited from loop.
       if (err == ERR_NO_ERROR || err == ERR_NO_RESULT)
       {
           OrderReliablePrint("Ticket #" + IntegerToString(ticket) + ": Successful " + OrderTypeToString(cmd) + " order placed with comment = " + comment + ", details follow.");
           if (!OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
               OrderReliablePrint("Could Not Select Ticket #" + IntegerToString(ticket));
           sqOrderPrint();
           return(ticket); // SUCCESS!
       }
       if (!limit_to_market)
       {
           OrderReliablePrint("Failed to execute stop or limit order after " + IntegerToString(retry_attempts) + " retries");
           OrderReliablePrint("Failed trade: " + OrderTypeToString(cmd) + " " + DoubleToStr(volume, 2) + " lots " + symbol +
           "@" + DoubleToStr(price) + " tp@" + DoubleToStr(takeprofit) + " sl@" + DoubleToStr(stoploss));
           OrderReliablePrint("Last error: " + OrderReliableErrTxt(err));

           OrderReliablePrint("");
           return(-1);
       }
   } // end

   if (limit_to_market)
   {
       OrderReliablePrint("Going from stop/limit order to market order because market is too close.");
       cmd %= 2;
       if (cmd == OP_BUY)   price = ask;
       else                price = bid;
   }

   // We now have a market order.
   err = GetLastError(); // so we clear the global variable.
   err = 0;
   ticket = -1;
   exit_loop = false;

   // Market order..........................................................
   if (cmd == OP_BUY || cmd == OP_SELL)
   {
       cnt = 0;
       cnt_bad_price = 0;
       while (!exit_loop)
       {
           // = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : =
           // Get current price and calculate slippage
           RefreshRates();
           if (cmd == OP_BUY)
           {
               M = 1.0;
               priceNow = NormalizeDouble(MarketInfo(symbol, MODE_ASK), (int) MarketInfo(symbol, MODE_DIGITS));   // Open @ Ask
               hasSlippedBy = (priceNow - price) / point;   // (Adjusted Point)
           }
           else if (cmd == OP_SELL)
           {
               M = -1.0;
               priceNow = NormalizeDouble(MarketInfo(symbol, MODE_BID), (int) MarketInfo(symbol, MODE_DIGITS));   // Open @ Bid
               hasSlippedBy = (price - priceNow) / point;   // (Adjusted Point)
           }

           // Check if slippage is more than caller's maximum allowed
           if (priceNow != price && hasSlippedBy > slippage)
           {
               // Actual price has slipped against us more than user allowed
               // Log error message, sleep, and try again
               OrderReliablePrint("Actual Price (Ask for buy, Bid for sell) = " + DoubleToStr(priceNow, Digits+1) + "; Slippage from Requested Price = " + DoubleToStr(hasSlippedBy, 1) + " pips. Retrying...");
               err = ERR_PRICE_CHANGED;
           }
           else
           {
               if (priceNow != price)
               {
                   // If the price has slipped "acceptably" (either negative or within
                   // "Slippage" param), then we need to adjust the SL and TP accordingly
                   if (stoploss != 0)       stoploss += M * hasSlippedBy;
                   if (takeprofit != 0)   takeprofit += M * hasSlippedBy;
                   OrderReliablePrint("Actual Price (Ask for buy, Bid for sell) = " + DoubleToStr(priceNow, Digits+1) + "; Requested Price = " + DoubleToStr(price, Digits) + "; Slippage from Requested Price = " + DoubleToStr(hasSlippedBy, 1) + " pips (\'positive slippage\'). Attempting order at market");
               }
               OrderReliablePrint("About to call OrderSend(), comment = " + comment);
               ticket = OrderSend(symbol, cmd, volume, priceNow, (int)(slippage - hasSlippedBy),
                               stoploss, takeprofit, comment, magic,   expiration, arrow_color);
               err = GetLastError();
           }
           // = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : =

           switch (err)
           {
               case ERR_NO_ERROR:
                   exit_loop = true;
                   break;

               case ERR_INVALID_PRICE:
                   if (cmd == OP_BUY)
                       OrderReliablePrint("INVALID PRICE ERROR - Requested Price: " + DoubleToStr(price, Digits) + "; Ask = " + DoubleToStr(MarketInfo(symbol, MODE_ASK), Digits));
                   else
                       OrderReliablePrint("INVALID PRICE ERROR - Requested Price: " + DoubleToStr(price, Digits) + "; Bid = " + DoubleToStr(MarketInfo(symbol, MODE_BID), Digits));
                   cnt++; // a retryable error
                   cnt_bad_price++;
                   break;

               case ERR_INVALID_STOPS:
                   OrderReliablePrint("INVALID STOPS on attempted " + OrderTypeToString(cmd) + " : " + DoubleToStr(volume, 2) + " lots " + " @ " + DoubleToStr(price, Digits) + ", SL = " + DoubleToStr(stoploss, Digits) + ", TP = " + DoubleToStr(takeprofit, Digits));
                   cnt++; // a retryable error
                   cnt_bad_price++;
                   break;

               case ERR_SERVER_BUSY:
               case ERR_NO_CONNECTION:
               case ERR_OFF_QUOTES:
               case ERR_BROKER_BUSY:
               case ERR_TRADE_CONTEXT_BUSY:
               case ERR_TRADE_TIMEOUT:
               case ERR_TRADE_DISABLED:
               case ERR_PRICE_CHANGED:
               case ERR_REQUOTE:
               case ERR_MARKET_CLOSED:
                   cnt++; // a retryable error
                   break;

               default:
                   // an apparently serious, unretryable error.
                   exit_loop = true;
                   break;
           }

if (cnt > retry_attempts)
exit_loop = true;

if (cnt_bad_price > retry_attempts_bad_price)
exit_loop = true;

           if (exit_loop)
           {
               if (err != ERR_NO_ERROR && err != ERR_NO_RESULT)
                   OrderReliablePrint("Non-retryable error: " + OrderReliableErrTxt(err));
               if (cnt > retry_attempts)
                   OrderReliablePrint("Retry attempts maxed at " + IntegerToString(retry_attempts) +"("+IntegerToString(retry_attempts_bad_price)+")");
           }
           else
           {
               OrderReliablePrint("Result of attempt " + IntegerToString(cnt) + " of " + IntegerToString(retry_attempts) +"("+IntegerToString(retry_attempts_bad_price)+")" + ": Retryable error: " + OrderReliableErrTxt(err));

               SleepRandomTime(sleep_time, sleep_maximum);
               RefreshRates();
           }
       }

       // We have now exited from loop; if successful, return ticket #
       if (err == ERR_NO_ERROR || err == ERR_NO_RESULT)
       {
           OrderReliablePrint("Ticket #" + IntegerToString(ticket) + ": Successful " + OrderTypeToString(cmd) + " order placed with comment = " + comment + ", details follow.");
           if (!OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
               OrderReliablePrint("Could Not Select Ticket #" + IntegerToString(ticket));
           sqOrderPrint();
           return(ticket); // SUCCESS!
       }

       // If not successful, log and return -1
       OrderReliablePrint("Failed to execute OP_BUY/OP_SELL, after " + IntegerToString(retry_attempts) + " retries");
       OrderReliablePrint("Failed trade: " + OrderTypeToString(cmd) + " " + DoubleToStr(volume, 2) + " lots " + symbol +
       "@" + DoubleToStr(price) + " tp@" + DoubleToStr(takeprofit) + " sl@" + DoubleToStr(stoploss));
       OrderReliablePrint("Last error: " + OrderReliableErrTxt(err));
   }
   return(-1);
}

//=============================================================================
//                           OrderSendReliable2Step()
//
// Some brokers don't allow the SL and TP settings as part of the initial
// market order (Water House Capital). Therefore, this routine will first
// place the market order with no stop-loss and take-profit but later
// update the order accordingly
//
//   RETURN VALUE:
// Same as OrderSendReliable; the ticket number
//
// NOTES:
// Order will not be updated if an error continues during
// OrderSendReliableMKT. No additional information will be logged
// since OrderSendReliableMKT would have already logged the error
// condition
//
// ORIGINAL AUTHOR AND DATE:
// Jack Tomlinson, 2007-05-29
//
//=============================================================================
int OrderSendReliable2Step(string symbol, int cmd, double volume, double price,
int slippage, double stoploss, double takeprofit,
string comment="", int magic=0, datetime expiration=0,
color arrow_color=CLR_NONE)
{
   OrderReliable_Fname = "OrderSendReliable2Step";
   int ticket = -1;
   double slipped = 0;

price = NormalizeDouble(price, Digits);
   takeprofit = NormalizeDouble(takeprofit, Digits);
   stoploss = NormalizeDouble(stoploss, Digits);

   // ========================================================================
   // If testing or optimizing, there is no need to use this lib, as the
   // orders are not real-world, and always get placed optimally. By
   // refactoring this option to be in this library, one no longer needs
   // to create similar code in each EA.
   if (!UseForTesting)
   {
       if (IsOptimization() || IsTesting())
       {
           ticket = OrderSend(symbol, cmd, volume, price, slippage, 0, 0,
                           comment, magic, 0, arrow_color);

           if (!OrderModify(ticket, price, stoploss, takeprofit, expiration, arrow_color))
               OrderReliablePrint("Order Modify of Ticket #" + IntegerToString(ticket) + " FAILED");

           return(ticket);
       }
   }
   // ========================================================================


   OrderReliablePrint("Doing OrderSendReliable, followed by OrderModifyReliable:");

ticket = OrderSendReliable(symbol, cmd, volume, price, slippage,
0, 0, comment, magic, expiration, arrow_color);

   if (stoploss != 0 || takeprofit != 0)
   {
       if (ticket >= 0)
       {
           double theOpenPrice = price;
           if (OrderSelect(ticket, SELECT_BY_TICKET))
           {
               slipped = OrderOpenPrice() - price;
               theOpenPrice = OrderOpenPrice();
           }
           else
               OrderReliablePrint("Failed to select ticket #" + IntegerToString(ticket) + " after successful 2step placement; cannot recalculate SL & TP");
           if (slipped > 0)
           {
               OrderReliablePrint("2step order slipped by: " + DoubleToStr(slipped, Digits) + "; SL & TP modified by same amount");
               if (takeprofit != 0)   takeprofit += slipped;
               if (stoploss != 0)       stoploss += slipped;
           }
           OrderModifyReliable(ticket, theOpenPrice, stoploss, takeprofit, expiration, arrow_color);
       }
   }
   else
       OrderReliablePrint("Skipping OrderModifyReliable because no SL or TP specified.");

return(ticket);
}

//=============================================================================
//                           OrderModifyReliable()
//
// This is intended to be a drop-in replacement for OrderModify() which,
// one hopes, is more resistant to various forms of errors prevalent
// with MetaTrader.
//
// RETURN VALUE:
// TRUE if successful, FALSE otherwise
//
// FEATURES:
// * Re-trying under some error conditions, sleeping a random
// time defined by an exponential probability distribution.
//
// * Displays various error messages on the log for debugging.
//
//
// ORIGINAL AUTHOR AND DATE:
// Matt Kennel, 2006-05-28
//
//=============================================================================
bool OrderModifyReliable(int ticket, double price, double stoploss,
double takeprofit, datetime expiration,
color arrow_color=CLR_NONE)
{
   OrderReliable_Fname = "OrderModifyReliable";
   bool result = false;
   bool non_retryable_error = false;

   // ========================================================================
   // If testing or optimizing, there is no need to use this lib, as the
   // orders are not real-world, and always get placed optimally. By
   // refactoring this option to be in this library, one no longer needs
   // to create similar code in each EA.
   if (!UseForTesting)
   {
       if (IsOptimization() || IsTesting())
       {
           result = OrderModify(ticket, price, stoploss,
           takeprofit, expiration, arrow_color);
           return(result);
       }
   }
   // ========================================================================

   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   // Get information about this order
   string symbol = "ALLOCATE";       // This is so it has memory space allocated
   int type;
   int digits;
   double point;
   double bid, ask;
   double sl, tp;
   GetOrderDetails(ticket, symbol, type, digits, point, sl, tp, bid, ask);
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


   OrderReliablePrint("Attempted modify of #" + IntegerToString(ticket) + " price:" + DoubleToStr(price, digits+1) +
   " sl:" + DoubleToStr(stoploss, digits+1) + " tp:" + DoubleToStr(takeprofit, digits+1) +
   " exp:" + TimeToStr(expiration));

   // Below, we call "EnsureValidStops". If the order we are modifying
   // is a pending order, then we should use the price passed in. But
   // if it's an open order, the price passed in is irrelevant; we need
   // to use the appropriate bid or ask, so get those...
   double prc = price;
   if (type == OP_BUY)           prc = bid;
   else if (type == OP_SELL)   prc = ask;

   // With the requisite info, we can do error checking on SL & TP
   prc = NormalizeDouble(prc, digits);
   price = NormalizeDouble(price, digits);
   stoploss = NormalizeDouble(stoploss, digits);
   takeprofit = NormalizeDouble(takeprofit, digits);

   // If SL/TP are not changing then send in zeroes to EnsureValidStops(),
   // so that it does not bother to try to change them
   double newSL = stoploss;
   double newTP = takeprofit;
   if (stoploss == sl)       newSL = 0;
   if (takeprofit == tp)   newTP = 0;
   EnsureValidStops(symbol, type, prc, newSL, newTP, false);
   if (stoploss != sl)       stoploss = newSL;
   if (takeprofit != tp)   takeprofit = newTP;

   int cnt = 0;
   int cnt_bad_price = 0;
   int err = GetLastError(); // so we clear the global variable.
   err = 0;
   bool exit_loop = false;

   while (!exit_loop)
   {
       result = OrderModify(ticket, price, stoploss,
       takeprofit, expiration, arrow_color);
       err = GetLastError();

       if (result == true)
           exit_loop = true;
       else
       {
           switch (err)
           {
               case ERR_NO_ERROR:
                   exit_loop = true;
                   OrderReliablePrint("ERR_NO_ERROR received, but OrderClose() returned false; exiting");
                   break;

               case ERR_NO_RESULT:
                   // Modification to same value as before
                   // See below for reported result
                   exit_loop = true;
                   break;

               // Shouldn't be any reason stops are invalid (and yet I've seen it); try again
               case ERR_INVALID_PRICE:
               case ERR_INVALID_STOPS:
                   OrderReliablePrint("OrderModifyReliable, ERR_INVALID_STOPS, Broker\'s Min Stop Level (in pips) = " + DoubleToStr(MarketInfo(symbol, MODE_STOPLEVEL) * Point / AdjPoint(symbol), 1));
//                   EnsureValidStops(symbol, price, stoploss, takeprofit);
cnt_bad_price++;

               case ERR_COMMON_ERROR:
               case ERR_SERVER_BUSY:
               case ERR_NO_CONNECTION:
               case ERR_TOO_FREQUENT_REQUESTS:
               case ERR_TRADE_TIMEOUT:       // for modify this is a retryable error, I hope.
               case ERR_OFF_QUOTES:
               case ERR_BROKER_BUSY:
               case ERR_TOO_MANY_REQUESTS:
               case ERR_TRADE_CONTEXT_BUSY:
               case ERR_TRADE_DISABLED:
               case ERR_MARKET_CLOSED:
                   cnt++;    // a retryable error
                   break;

               case ERR_TRADE_MODIFY_DENIED:
                   // This one may be important; have to Ensure Valid Stops AND valid price (for pends)
                   break;

               case ERR_PRICE_CHANGED:
               case ERR_REQUOTE:
                   RefreshRates();
                   continue;    // we can apparently retry immediately according to MT docs.

               default:
                   // an apparently serious, unretryable error.
                   exit_loop = true;
                   non_retryable_error = true;
                   break;

} // end switch
}

if (cnt > retry_attempts)
exit_loop = true;

if (cnt_bad_price > retry_attempts_bad_price)
exit_loop = true;

       if (!exit_loop)
       {
           OrderReliablePrint("Result of attempt " + IntegerToString(cnt) + " of " + IntegerToString(retry_attempts)+"("+IntegerToString(retry_attempts_bad_price)+")" + ": Retryable error: " + OrderReliableErrTxt(err));

           SleepRandomTime(sleep_time, sleep_maximum);
           RefreshRates();
       }
       else
       {
           if (cnt > retry_attempts)
               OrderReliablePrint("Retry attempts maxed at " + IntegerToString(retry_attempts));
           else if (non_retryable_error)
               OrderReliablePrint("Non-retryable error: " + OrderReliableErrTxt(err));
       }
   }

   // we have now exited from loop.
   if (err == ERR_NO_RESULT)
   {
       OrderReliablePrint("Server reported modify order did not actually change parameters.");
       OrderReliablePrint("Redundant modification: " + IntegerToString(ticket) + " " + symbol +
       "@" + DoubleToStr(price) + " tp@" + DoubleToStr(takeprofit) + " sl@" + DoubleToStr(stoploss));
       OrderReliablePrint("Suggest modifying code logic to avoid.");
   }

   if (result)
   {
       OrderReliablePrint("Ticket #" + IntegerToString(ticket) + ": Modification successful, updated trade details follow.");
       if (!OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
           OrderReliablePrint("Could Not Select Ticket #" + IntegerToString(ticket));
       sqOrderPrint();
   }
   else
   {
       OrderReliablePrint("Failed to execute modify after " + IntegerToString(retry_attempts) + " retries");
       OrderReliablePrint("Failed modification: " + IntegerToString(ticket) + " " + symbol +
      "@" + DoubleToStr(price) + " tp@" + DoubleToStr(takeprofit) + " sl@" + DoubleToStr(stoploss));
       OrderReliablePrint("Last error: " + OrderReliableErrTxt(err));
   }

   return(result);
}

//=============================================================================
// OrderCloseReliable()
//
// This is intended to be a drop-in replacement for OrderClose() which,
// one hopes, is more resistant to various forms of errors prevalent
// with MetaTrader.
//
// RETURN VALUE:
// TRUE if successful, FALSE otherwise
//
// FEATURES:
// * Re-trying under some error conditions, sleeping a random
// time defined by an exponential probability distribution.
//
// * Displays various error messages on the log for debugging.
//
// ORIGINAL AUTHOR AND DATE:
// Derk Wehler, 2006-07-19
//
//=============================================================================
bool OrderCloseReliable(int ticket, double volume, double price,
                       int slippage, color arrow_color=CLR_NONE)
{
   OrderReliable_Fname = "OrderCloseReliable";
   bool result = false;
   bool non_retryable_error = false;

   // ========================================================================
   // If testing or optimizing, there is no need to use this lib, as the
   // orders are not real-world, and always get placed optimally. By
   // refactoring this option to be in this library, one no longer needs
   // to create similar code in each EA.
   if (!UseForTesting)
   {
       if (IsOptimization() || IsTesting())
       {
           result = OrderClose(ticket, volume, price, slippage, arrow_color);
           return(result);
       }
   }
   // ========================================================================

   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   // Get information about this order
   string symbol = "ALLOCATE";       // This is so it has memory space allocated
   int type;
   int digits;
   double point;
   double bid, ask;
   double sl, tp;
   GetOrderDetails(ticket, symbol, type, digits, point, sl, tp, bid, ask);
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

   OrderReliablePrint("Attempted close of #" + IntegerToString(ticket) + " initial price:" + DoubleToStr(price, digits+1) +
   " lots:" + DoubleToStr(volume, 3) + " slippage:" + IntegerToString(slippage));

   if (type != OP_BUY && type != OP_SELL)
   {
       OrderReliablePrint("Error: Trying to close ticket #" + IntegerToString(ticket) + ", which is " + OrderTypeToString(type) + ", not OP_BUY or OP_SELL");
       return(false);
   }

   int cnt = 0;
   int err = GetLastError(); // so we clear the global variable.
   err = 0;
   bool exit_loop = false;
   double priceNow = 0;
   double hasSlippedBy = 0;

   while (!exit_loop)
   {
       // = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : =
       // Get current price and calculate slippage
       RefreshRates();
       if (type == OP_BUY)
       {
           priceNow = NormalizeDouble(MarketInfo(symbol, MODE_BID), (int) MarketInfo(symbol, MODE_DIGITS));   // Close @ Bid
           hasSlippedBy = (price - priceNow) / point;   // (Adjusted Point)
       }
       else if (type == OP_SELL)
       {
           priceNow = NormalizeDouble(MarketInfo(symbol, MODE_ASK), (int) MarketInfo(symbol, MODE_DIGITS));   // Close @ Ask
           hasSlippedBy = (priceNow - price) / point;   // (Adjusted Point)
       }

       // Check if slippage is more than caller's maximum allowed
       if (priceNow != price && hasSlippedBy > slippage)
       {
           // Actual price has slipped against us more than user allowed
           // Log error message, sleep, and try again
           OrderReliablePrint("Actual Price (Bid for buy, Ask for sell) Value = " + DoubleToStr(priceNow, Digits) + "; Slippage from Requested Price = " + DoubleToStr(hasSlippedBy, 1) + " pips. Retrying...");
           result = false;
           err = ERR_PRICE_CHANGED;
       }
       else
       {
           result = OrderClose(ticket, volume, priceNow, (int)(slippage - hasSlippedBy), arrow_color);
           err = GetLastError();
       }
       // = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : = : =

       if (result == true)
           exit_loop = true;
       else
       {
           switch (err)
           {
               case ERR_NO_ERROR:
                   exit_loop = true;
                   OrderReliablePrint("ERR_NO_ERROR received, but OrderClose() returned false; exiting");
                   OrderReliablePrint("If order did not actually close, error code is apparently wrong");
                   break;

               case ERR_NO_RESULT:
                   exit_loop = true;
                   OrderReliablePrint("ERR_NO_RESULT received, but OrderClose() returned false; exiting");
                   OrderReliablePrint("If order did not actually close, error code is apparently wrong");
                   break;

               case ERR_INVALID_PRICE:
                   OrderReliablePrint("ERR_INVALID_PRICE received, but should not occur since we are refreshing rates");
                   cnt++;    // a retryable error
                   break;

               case ERR_PRICE_CHANGED:
               case ERR_COMMON_ERROR:
               case ERR_SERVER_BUSY:
               case ERR_NO_CONNECTION:
               case ERR_TOO_FREQUENT_REQUESTS:
               case ERR_TRADE_TIMEOUT:       // for close this is a retryable error, I hope.
               case ERR_TRADE_DISABLED:
               case ERR_OFF_QUOTES:
               case ERR_BROKER_BUSY:
               case ERR_REQUOTE:
               case ERR_TOO_MANY_REQUESTS:
               case ERR_TRADE_CONTEXT_BUSY:
               case ERR_MARKET_CLOSED:
                   cnt++;    // a retryable error
                   break;

               default:
                   // Any other error is an apparently serious, unretryable error.
                   exit_loop = true;
                   non_retryable_error = true;
                   break;

} // end switch
}

if (cnt > retry_attempts)
exit_loop = true;

       if (exit_loop)
       {
           if (cnt > retry_attempts)
               OrderReliablePrint("Retry attempts maxed at " + IntegerToString(retry_attempts));
           else if (non_retryable_error)
               OrderReliablePrint("Non-retryable error: " + OrderReliableErrTxt(err));
       }
       else
       {
           OrderReliablePrint("Result of attempt " + IntegerToString(cnt) + " of " + IntegerToString(retry_attempts) + ": Retryable error: " + OrderReliableErrTxt(err));

           SleepRandomTime(sleep_time, sleep_maximum);
       }
   }

   // We have now exited from loop
   if (result || err == ERR_NO_RESULT || err == ERR_NO_ERROR)
   {
       if (!OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
           OrderReliablePrint("Successful close of Ticket #" + IntegerToString(ticket) + " [ Last error: " + OrderReliableErrTxt(err) + " ]");
       else if (OrderCloseTime() > 0)   // Then it closed ok
           OrderReliablePrint("Successful close of Ticket #" + IntegerToString(ticket) + " [ Last error: " + OrderReliableErrTxt(err) + " ]");
       else
       {
           OrderReliablePrint("Close result reported success (or failure, but w/ERR_NO_ERROR); yet order remains! Must re-try close from EA logic!");
           OrderReliablePrint("Close Failed: Ticket #" + IntegerToString(ticket) + ", Price: " +
              DoubleToString(price) + ", Slippage: " + DoubleToString(slippage));
           OrderReliablePrint("Last error: " + OrderReliableErrTxt(err));
           result = false;
       }
   }
   else
   {
       OrderReliablePrint("Failed to execute close after " + IntegerToString(cnt-1) + " retries");
       OrderReliablePrint("Failed close: Ticket #" + IntegerToString(ticket) + " @ Price: " + DoubleToString(priceNow) +
      " (Requested Price: " + DoubleToString(price) + "), Slippage: " + IntegerToString(slippage));
       OrderReliablePrint("Last error: " + OrderReliableErrTxt(err));
   }


   return(result);
}

//=============================================================================
// OrderCloseReliableMKT()
//
//   This function is intended for closing orders ASAP; the principal
// difference is that in its internal retry-loop, it uses the new "Bid"
// and "Ask" real-time variables as opposed to the OrderCloseReliable(),
// which uses only the price given upon entry to the routine. More likely
// to get the order closed if price moves, but more likely to "slip"
//
// RETURN VALUE:
// TRUE if successful, FALSE otherwise
//
// FEATURES:
// * Re-trying under some error conditions, sleeping a random
// time defined by an exponential probability distribution.
//
// * Displays various error messages on the log for debugging.
//
// ORIGINAL AUTHOR AND DATE:
// Derk Wehler, 2009-04-03
//
//=============================================================================
bool OrderCloseReliableMKT(int ticket, double volume, double price,
                       int slippage, color arrow_color=CLR_NONE)
{
   OrderReliable_Fname = "OrderCloseReliableMKT";
   bool result = false;
   bool non_retryable_error = false;

   // ========================================================================
   // If testing or optimizing, there is no need to use this lib, as the
   // orders are not real-world, and always get placed optimally. By
   // refactoring this option to be in this library, one no longer needs
   // to create similar code in each EA.
   if (!UseForTesting)
   {
       if (IsOptimization() || IsTesting())
       {
           result = OrderClose(ticket, volume, price, slippage, arrow_color);
           return(result);
       }
   }
   // ========================================================================

   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   // Get information about this order
   string symbol = "ALLOCATE";       // This is so it has memory space allocated
   int type;
   int digits;
   double point;
   double bid, ask;
   double sl, tp;
   GetOrderDetails(ticket, symbol, type, digits, point, sl, tp, bid, ask);
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

   OrderReliablePrint("Attempted close of #" + IntegerToString(ticket) + " initial price:" + DoubleToStr(price, digits+1) +
   " lots:" + DoubleToStr(price, 3) + " slippage:" + IntegerToString(slippage));

   if (type != OP_BUY && type != OP_SELL)
   {
       OrderReliablePrint("Error: Trying to close ticket #" + IntegerToString(ticket) + ", which is " + OrderTypeToString(type) + ", not OP_BUY or OP_SELL");
       return(false);
   }

   int cnt = 0;
   int err = GetLastError(); // so we clear the global variable.
   err = 0;
   bool exit_loop = false;
   double pnow = 0;
   int slippagenow = 0;

   while (!exit_loop)
   {
       if (type == OP_BUY)
       {
           pnow = NormalizeDouble(MarketInfo(symbol, MODE_ASK), (int) MarketInfo(symbol, MODE_DIGITS)); // we are buying at Ask
           if (pnow > price)
           {
               // Do not allow slippage to go negative; will cause error
               slippagenow = (int) MathMax(0, slippage - (pnow - price) / point);
           }
       }
       else if (type == OP_SELL)
       {
           pnow = NormalizeDouble(MarketInfo(symbol, MODE_BID), (int) MarketInfo(symbol, MODE_DIGITS)); // we are buying at Ask
           if (pnow < price)
           {
               // Do not allow slippage to go negative; will cause error
               slippagenow = (int) MathMax(0, slippage - (price - pnow) / point);
           }
       }

result = OrderClose(ticket, volume, pnow, slippagenow, arrow_color);
err = GetLastError();

       if (result == true)
           exit_loop = true;
       else
       {
           switch (err)
           {
               case ERR_NO_ERROR:
                   exit_loop = true;
                   OrderReliablePrint("ERR_NO_ERROR received, but OrderClose() returned false; exiting");
                   break;

               case ERR_NO_RESULT:
                   exit_loop = true;
                   OrderReliablePrint("ERR_NO_RESULT received, but OrderClose() returned false; exiting");
                   break;

               case ERR_COMMON_ERROR:
               case ERR_SERVER_BUSY:
               case ERR_NO_CONNECTION:
               case ERR_TOO_FREQUENT_REQUESTS:
               case ERR_TRADE_TIMEOUT:       // for close this is a retryable error, I hope.
               case ERR_TRADE_DISABLED:
               case ERR_PRICE_CHANGED:
               case ERR_INVALID_PRICE:
               case ERR_OFF_QUOTES:
               case ERR_BROKER_BUSY:
               case ERR_REQUOTE:
               case ERR_TOO_MANY_REQUESTS:
               case ERR_TRADE_CONTEXT_BUSY:
               case ERR_MARKET_CLOSED:
                   cnt++;    // a retryable error
                   break;

               default:
                   // Any other error is an apparently serious, unretryable error.
                   exit_loop = true;
                   non_retryable_error = true;
                   break;

} // end switch
}

if (cnt > retry_attempts)
exit_loop = true;

       if (!exit_loop)
       {
           OrderReliablePrint("Result of attempt " + IntegerToString(cnt) + " of " + IntegerToString(retry_attempts)+ ": Retryable error: " + OrderReliableErrTxt(err));

           SleepRandomTime(sleep_time, sleep_maximum);
       }

       if (exit_loop)
       {
           if (cnt > retry_attempts)
               OrderReliablePrint("Retry attempts maxed at " + IntegerToString(retry_attempts));
           else if (non_retryable_error)
               OrderReliablePrint("Non-retryable error: " + OrderReliableErrTxt(err));
       }
   }

   // we have now exited from loop.
   if (result)
   {
       if (!OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
           OrderReliablePrint("Successful close of Ticket #" + IntegerToString(ticket) + " [ Last error: " + OrderReliableErrTxt(err) + " ]");
       else if (OrderCloseTime() > 0)   // Then it closed ok
           OrderReliablePrint("Successful close of Ticket #" + IntegerToString(ticket) + " [ Last error: " + OrderReliableErrTxt(err) + " ]");
       else
       {
           OrderReliablePrint("Close result reported success, but order remains! Must re-try close from EA logic!");
           OrderReliablePrint("Close Failed: Ticket #" + IntegerToString(ticket) + ", Price: " +
              DoubleToString(price) + ", Slippage: " + IntegerToString(slippage));
           OrderReliablePrint("Last error: " + OrderReliableErrTxt(err));
           result = false;
       }
   }
   else
   {
       OrderReliablePrint("Failed to execute close after " + IntegerToString(retry_attempts) + " retries");
       OrderReliablePrint("Failed close: Ticket #" + IntegerToString(ticket) + " @ Price: " +
          DoubleToString(pnow) + " (Initial Price: " + DoubleToString(price) + "), Slippage: " +
          IntegerToString(slippagenow) + " (Initial Slippage: " + IntegerToString(slippage) + ")");
       OrderReliablePrint("Last error: " + OrderReliableErrTxt(err));
   }


   return(result);
}

//=============================================================================
// OrderDeleteReliable()
//
// This is intended to be a drop-in replacement for OrderDelete() which,
// one hopes, is more resistant to various forms of errors prevalent
// with MetaTrader.
//
// RETURN VALUE:
// TRUE if successful, FALSE otherwise
//
//
// FEATURES:
// * Re-trying under some error conditions, sleeping a random
// time defined by an exponential probability distribution.
//
// * Displays various error messages on the log for debugging.
//
// ORIGINAL AUTHOR AND DATE:
// Derk Wehler, 2006-12-21
//
//=============================================================================
bool OrderDeleteReliable(int ticket, color clr=CLR_NONE)
{
   OrderReliable_Fname = "OrderDeleteReliable";
   bool result = false;
   bool non_retryable_error = false;

   // ========================================================================
   // If testing or optimizing, there is no need to use this lib, as the
   // orders are not real-world, and always get placed optimally. By
   // refactoring this option to be in this library, one no longer needs
   // to create similar code in each EA.
   if (!UseForTesting)
   {
       if (IsOptimization() || IsTesting())
       {
           result = OrderDelete(ticket, clr);
           return(result);
       }
   }
   // ========================================================================



   OrderReliablePrint("Attempted deletion of pending order, #" + IntegerToString(ticket));

   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   // Get information about this order
   string symbol = "ALLOCATE";       // This is so it has memory space allocated
   int type;
   int digits;
   double point;
   double bid, ask;
   double sl, tp;
   GetOrderDetails(ticket, symbol, type, digits, point, sl, tp, bid, ask);
   // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

   if (type == OP_BUY || type == OP_SELL)
   {
       OrderReliablePrint("error: Trying to close ticket #" + IntegerToString(ticket) +
       ", which is " + OrderTypeToString(type) +
       ", not OP_BUYSTOP, OP_SELLSTOP, OP_BUYLIMIT, or OP_SELLLIMIT");
       return(false);
   }

   int cnt = 0;
   int err = GetLastError(); // so we clear the global variable.
   err = 0;
   bool exit_loop = false;

   while (!exit_loop)
   {
       result = OrderDelete(ticket, clr);
       err = GetLastError();

       if (result == true)
           exit_loop = true;
       else
       {
           switch (err)
           {
               case ERR_NO_ERROR:
                   exit_loop = true;
                   OrderReliablePrint("ERR_NO_ERROR received, but OrderDelete() returned false; exiting");
                   break;

               case ERR_NO_RESULT:
                   exit_loop = true;
                   OrderReliablePrint("ERR_NO_RESULT received, but OrderDelete() returned false; exiting");
                   break;

               case ERR_COMMON_ERROR:
               case ERR_SERVER_BUSY:
               case ERR_NO_CONNECTION:
               case ERR_TOO_FREQUENT_REQUESTS:
               case ERR_TRADE_TIMEOUT:       // for delete this is a retryable error, I hope.
               case ERR_TRADE_DISABLED:
               case ERR_OFF_QUOTES:
               case ERR_PRICE_CHANGED:
               case ERR_BROKER_BUSY:
               case ERR_REQUOTE:
               case ERR_TOO_MANY_REQUESTS:
               case ERR_TRADE_CONTEXT_BUSY:
               case ERR_MARKET_CLOSED:
                   cnt++;    // a retryable error
                   break;

               default:   // Any other error is an apparently serious, unretryable error.
                   exit_loop = true;
                   non_retryable_error = true;
                   break;

} // end switch
}

if (cnt > retry_attempts)
exit_loop = true;

       if (!exit_loop)
       {
           OrderReliablePrint("Result of attempt " + IntegerToString(cnt) + " of " + IntegerToString(retry_attempts) + ": Retryable error: " + OrderReliableErrTxt(err));
           SleepRandomTime(sleep_time, sleep_maximum);
       }
       else
       {
           if (cnt > retry_attempts)
               OrderReliablePrint("Retry attempts maxed at " + IntegerToString(retry_attempts));
           else if (non_retryable_error)
               OrderReliablePrint("Non-retryable error: " + OrderReliableErrTxt(err));
       }
   }

   // we have now exited from loop.
   if (result)
   {
       OrderReliablePrint("Successful deletion of Ticket #" + IntegerToString(ticket));

       return(true); // SUCCESS!
   }
   else
   {
       OrderReliablePrint("Failed to execute delete after " + IntegerToString(retry_attempts) + " retries");
       OrderReliablePrint("Failed deletion: Ticket #" + IntegerToString(ticket));
       OrderReliablePrint("Last error: " + OrderReliableErrTxt(err));
   }


   return(result);
}

//=============================================================================
//=============================================================================
// Utility Functions
//=============================================================================
//=============================================================================

string OrderReliableErrTxt(int err)
{
return (IntegerToString(err) + " :: " + ErrorDescription(err));
}

// Defaut level is 3
// Use level = 1 to Print all but "Retry" messages
// Use level = 0 to Print nothing
void OrderReliableSetErrorLevel(int level)
{
ErrorLevel = level;
}

void OrderReliablePrint(string s)
{
   // Print to log prepended with stuff;
   if (ErrorLevel >= 99 || (!(IsTesting() || IsOptimization())))
   {
       if (ErrorLevel > 0)
           Print(OrderReliable_Fname + " " + OrderReliableVersion + ": " + s);
   }
}

void sqOrderPrint() {
Print("Ticket: "+IntegerToString(OrderTicket())+" - "+
"OpenTime: "+TimeToString(OrderOpenTime(), TIME_DATE | TIME_MINUTES | TIME_SECONDS)+","+
"Type: "+IntegerToString(OrderType())+","+
"Size: "+DoubleToString(OrderLots())+","+
"Symbol: "+OrderSymbol()+","+
"OpenPrice: "+DoubleToString(OrderOpenPrice())+","+
"SL: "+DoubleToString(OrderStopLoss())+","+
"PT: "+DoubleToString(OrderTakeProfit()));

Print("Ticket: "+IntegerToString(OrderTicket())+" (continue) - "+
"CloseTime: "+TimeToString(OrderCloseTime(), TIME_DATE | TIME_MINUTES | TIME_SECONDS)+","+
"ClosePrice: "+DoubleToString(OrderClosePrice())+","+
"Commission: "+DoubleToString(OrderCommission())+","+
"Swap: "+DoubleToString(OrderSwap())+","+
"Profit: "+DoubleToString(OrderProfit())+","+
"Comment: "+OrderComment()+","+
"MagicNumber: "+IntegerToString(OrderMagicNumber()));
}

string OrderTypeToString(int type)
{
   if (type == OP_BUY)        return("BUY");
   if (type == OP_SELL)        return("SELL");
   if (type == OP_BUYSTOP)    return("BUY STOP");
   if (type == OP_SELLSTOP)   return("SELL STOP");
   if (type == OP_BUYLIMIT)    return("BUY LIMIT");
   if (type == OP_SELLLIMIT)   return("SELL LIMIT");
   return("None (" + IntegerToString(type) + ")");
}

//=============================================================================
// EnsureValidStops()
//
// Most MQ4 brokers have a minimum stop distance, which is the number of
// pips from price where a pending order can be placed or where a SL & TP
// can be placed. THe purpose of this function is to detect when the
// requested SL or TP is too close, and to move it out automatically, so
// that we do not get ERR_INVALID_STOPS errors.
//
// FUNCTION COMPLETELY OVERHAULED:
// Derk Wehler, 2008-11-08
//
//=============================================================================
void EnsureValidStops(string symbol, int cmd, double price, double& sl, double& tp, bool isNewOrder=true)
{
   string prevName = OrderReliable_Fname;
   OrderReliable_Fname = "EnsureValidStops";

   double point = MarketInfo(symbol, MODE_POINT);

   // We only use point for StopLevel, and StopLevel is reported as 10 times
   // what you expect on a 5-digit broker, so leave it as is.
   //if (point == 0.001 || point == 0.00001)
   //   point *= 10;

   double    orig_sl = sl;
   double    orig_tp = tp;
   double    new_sl, new_tp;
   int    min_stop_level = (int) MarketInfo(symbol, MODE_STOPLEVEL);
   double    servers_min_stop = min_stop_level * point;
   double    spread = MarketInfo(symbol, MODE_ASK) - MarketInfo(symbol, MODE_BID);
   //Print(" EnsureValidStops: Symbol = " + symbol + ", servers_min_stop = " + servers_min_stop);

   // Skip if no S/L (zero)
   if (sl != 0)
   {
       if (cmd % 2 == 0)   // we are long
       {
           // for pending orders, sl/tp can bracket price by servers_min_stop
           new_sl = price - servers_min_stop;
           //Print(" EnsureValidStops: new_sl [", new_sl, "] = price [", price, "] - servers_min_stop [", servers_min_stop, "]");

           // for market order, sl/tp must bracket bid/ask
           if (cmd == OP_BUY && isNewOrder)
           {
               new_sl -= spread;
               //Print(" EnsureValidStops: Minus spread [", spread, "]");
           }
           sl = MathMin(sl, new_sl);
       }
       else   // we are short
       {
           new_sl = price + servers_min_stop;   // we are short
           //Print(" EnsureValidStops: new_sl [", new_sl, "] = price [", price, "] + servers_min_stop [", servers_min_stop, "]");

           // for market order, sl/tp must bracket bid/ask
           if (cmd == OP_SELL && isNewOrder)
           {
               new_sl += spread;
               //Print(" EnsureValidStops: Plus spread [", spread, "]");
           }

           sl = MathMax(sl, new_sl);
       }
       sl = NormalizeDouble(sl, (int) MarketInfo(symbol, MODE_DIGITS));
   }

   // Skip if no T/P (zero)
   if (tp != 0)
   {
       // check if we have to adjust the stop
       if (MathAbs(price - tp) <= servers_min_stop)
       {
           if (cmd % 2 == 0)   // we are long
           {
               new_tp = price + servers_min_stop;   // we are long
               tp = MathMax(tp, new_tp);
           }
           else   // we are short
           {
               new_tp = price - servers_min_stop;   // we are short
               tp = MathMin(tp, new_tp);
           }
           tp = NormalizeDouble(tp, (int) MarketInfo(symbol, MODE_DIGITS));
       }
   }

   // notify if changed
   if (sl != orig_sl)
       OrderReliablePrint("SL was too close to brokers min distance (" + IntegerToString(min_stop_level) + "); moved SL to: " + DoubleToString(sl));
   if (tp != orig_tp)
       OrderReliablePrint("TP was too close to brokers min distance (" + IntegerToString(min_stop_level) + "); moved TP to: " + DoubleToString(tp));

   OrderReliable_Fname = prevName;
}

//=============================================================================
// EnsureValidPendPrice()
//
// This function is called if OrderSendReliable gets an ERR_INVALID_PRICE
// or ERR_INVALID_STOPS error when attempting to place a pending order.
// We assume these are signs that the brokers minumum stop distance, which
// is what is used for pending distances as well, is too small and the price
// is too close to the pending's requested price. Therefore we want to do
// one of two things:
//
// If UseLimitToMarket is enabled, then see if the actual and requested
// prices are close enough to be within the requested slippage, and if so
// return true to indicate a swap to a market order.
//
// Otherwise, we move the requested price far enough from current price to
// (hopefully) place the pending order, and return false (price, sl & tp
// are all I/O params). If this does not work, and the the same error is
// received, and the function is called again, it attempts to move the
// entry price (and sl & tp) out one more pip at a time.
//
// RETURN VALUE:
// True if calling function should convert this to market order,
// otherwise False
//
// ORIGINAL AUTHOR AND DATE:
// Derk Wehler, 2011-05-17
//
//=============================================================================
bool EnsureValidPendPrice(int err, bool& fixed, string symbol, int cmd, double& price,
double& stoploss, double& takeprofit, int slippage, double point, int digits)
{
OrderReliable_Fname = "EnsureValidPendPrice";

   double    servers_min_stop = MarketInfo(symbol, MODE_STOPLEVEL) * Point;
   double    old_price, priceNow = 0, hasSlippedBy;

   // Assume buy pendings relate to Ask, and sell pendings relate to Bid
   if (cmd % 2 == OP_BUY)
       priceNow = NormalizeDouble(MarketInfo(symbol, MODE_ASK), (int) MarketInfo(symbol, MODE_DIGITS));
   else if (cmd % 2 == OP_SELL)
       priceNow = NormalizeDouble(MarketInfo(symbol, MODE_BID), (int) MarketInfo(symbol, MODE_DIGITS));

   // If we are too close to put in a limit/stop order so go to market.
   if (MathAbs(priceNow - price) <= servers_min_stop)
   {
       if (UseLimitToMarket)
       {
           hasSlippedBy = MathAbs(priceNow - price) / point;   // (Adjusted Point)

           // Check if slippage is more than caller's maximum allowed
           if (priceNow != price && hasSlippedBy > slippage)
           {
               // Actual price is too far from requested price to do market order,
               // and too close to place pending order (because of broker's minimum
               // stop distance). Therefore, report the problem and try again...
               OrderReliablePrint("Actual price (Ask for buy, Bid for sell) = " + DoubleToStr(priceNow, Digits) + ", and requested pend price = " + DoubleToStr(priceNow, Digits) + "; slippage between the two = ?" + DoubleToStr(hasSlippedBy, 1) + " pips, which is larger than user specified. Cannot Convert to Market Order.");
           }
           else
           {
               // Price has moved close enough (within slippage) to requested
               // pending price that we can go ahead and enter a market position
               return(true);
           }
       }
       else
       {
           if (fixed)
           {
               if (cmd == OP_BUYSTOP || cmd == OP_SELLLIMIT)
               {
                   price += point;
                   if (stoploss > 0) stoploss += point;
                   if (takeprofit > 0) takeprofit += point;
                   OrderReliablePrint("Pending " + OrderTypeToString(cmd) + " Order still has \'" + ErrorDescription(err) + "\', adding 1 pip; new price = " + DoubleToStr(price, Digits));
                   if (stoploss > 0 || takeprofit > 0)
                       OrderReliablePrint("NOTE: SL (now " + DoubleToStr(stoploss, digits) + ") & TP (now " + DoubleToStr(takeprofit, digits) + ") were adjusted proportionately");
               }
               else if (cmd == OP_BUYLIMIT || cmd == OP_SELLSTOP)
               {
                   price -= point;
                   if (stoploss > 0) stoploss -= point;
                   if (takeprofit > 0) takeprofit -= point;
                   OrderReliablePrint("Pending " + OrderTypeToString(cmd) + " Order still has \'" + ErrorDescription(err) + "\', subtracting 1 pip; new price = " + DoubleToStr(price, digits));
                   if (stoploss > 0 || takeprofit > 0)
                       OrderReliablePrint("NOTE: SL (now " + DoubleToStr(stoploss, digits) + ") & TP (now " + DoubleToStr(takeprofit, digits) + ") were adjusted proportionately");
               }
           }
           else
           {
               if (cmd == OP_BUYLIMIT)
               {
                   old_price = price;
                   price = priceNow - servers_min_stop;
                   if (stoploss > 0) stoploss += (price - old_price);
                   if (takeprofit > 0) takeprofit += (price - old_price);
                   OrderReliablePrint("Pending " + OrderTypeToString(cmd) + " has \'" + ErrorDescription(err) + "\'; new price = " + DoubleToStr(price, digits));
                   if (stoploss > 0 || takeprofit > 0)
                       OrderReliablePrint("NOTE: SL (now " + DoubleToStr(stoploss, digits) + ") & TP (now " + DoubleToStr(takeprofit, digits) + ") were adjusted proportionately");
               }
               else if (cmd == OP_BUYSTOP)
               {
                   old_price = price;
                   price = priceNow + servers_min_stop;
                   if (stoploss > 0) stoploss += (price - old_price);
                   if (takeprofit > 0) takeprofit += (price - old_price);
                   OrderReliablePrint("Pending " + OrderTypeToString(cmd) + " has \'" + ErrorDescription(err) + "\'; new price = " + DoubleToStr(price, digits));
                   if (stoploss > 0 || takeprofit > 0)
                       OrderReliablePrint("NOTE: SL (now " + DoubleToStr(stoploss, digits) + ") & TP (now " + DoubleToStr(takeprofit, digits) + ") were adjusted proportionately");
               }
               else if (cmd == OP_SELLSTOP)
               {
                   old_price = price;
                   price = priceNow - servers_min_stop;
                   if (stoploss > 0) stoploss -= (old_price - price);
                   if (takeprofit > 0) takeprofit -= (old_price - price);
                   OrderReliablePrint("Pending SellStop has \'" + ErrorDescription(err) + "\'; new price = " + DoubleToStr(price, digits));
                   if (stoploss > 0 || takeprofit > 0)
                       OrderReliablePrint("NOTE: SL (now " + DoubleToStr(stoploss, digits) + ") & TP (now " + DoubleToStr(takeprofit, digits) + ") were adjusted proportionately");
               }
               else if (cmd == OP_SELLLIMIT)
               {
                   old_price = price;
                   price = priceNow + servers_min_stop;
                   if (stoploss > 0) stoploss -= (old_price - price);
                   if (takeprofit > 0) takeprofit -= (old_price - price);
                   OrderReliablePrint("Pending SellLimit has \'" + ErrorDescription(err) + "\'; new price = " + DoubleToStr(price, digits));
                   if (stoploss > 0 || takeprofit > 0)
                       OrderReliablePrint("NOTE: SL (now " + DoubleToStr(stoploss, digits) + ") & TP (now " + DoubleToStr(takeprofit, digits) + ") were adjusted proportionately");
               }
               fixed = true;
           }
           EnsureValidStops(symbol, cmd, price, stoploss, takeprofit);
       }
   }
   return(false);
}

//=============================================================================
// SleepRandomTime()
//
// This sleeps a random amount of time defined by an exponential
// probability distribution. The mean time, in Seconds is given
// in 'mean_time'.
//
// This is the back-off strategy used by Ethernet. This will
// quantize in fiftieths of seconds, so don't call this with a too
// small a number. This returns immediately if we are backtesting
// and does not sleep.
//
//=============================================================================
void SleepRandomTime(double mean_time, double max_time)
{
   // No need for pauses on tester
   if (IsTesting())
       return;
/*
   // 19Jun16 : Noticed for a long time that when an order fails,
   // it fails all 10 tries. So try a different tack here and just
   // sleep a set time per try.
   Sleep(200);
   return;
*/

   double tenths = MathCeil(mean_time / 0.1);
   if (tenths <= 0)
       return;

int maxtenths = (int) MathRound(max_time / 0.1); // 250
double p = 1.0 - 1.0 / tenths; // 0.975

// Always sleep at least some minimum
Sleep(20);

   // Now loop through and sleep 1/10th second a max of
   // (10 * mean_time) times. But break out "randomly".
   for (int i = 0; i < maxtenths; i++)
   {
       if (MathRand() > p*32768)
           break;

       // MathRand() returns in 0..32767
       Sleep(20);
   }
}

//=============================================================================
// Adjusted Point funtion
//=============================================================================
double AdjPoint(string sym="")
{
   if (sym == "")
       sym = Symbol();
   double ticksize = MarketInfo(sym, MODE_TICKSIZE);
   if (ticksize == 0.00001 || ticksize == 0.001)
       ticksize *= 10;
   return(ticksize);
}

//=============================================================================
// LimitToMarket()
//
// Setting to toggle what OrderSendReliable does with Stop or Limit orders
// that are requested to be placed too close to the current price.
//
// When set True, it will turn any such conundrum from a stop/limit order
// into a simple market order
//
// When set False, the library will alter the price of the Stop/Limit order\
// just far enough to be able to place the order as a pending order.
//
//=============================================================================
void LimitToMarket(bool limit2market)
{
UseLimitToMarket = limit2market;
}

//=============================================================================
// OrderReliableUseForTesting()
//
// Setting to toggle whether this OrderReliable library is used in testing
// and optimization. By default, it is set to false, and will thus just pass
// orders straight through.
//
// When set true, it will use the full functions as normally all the time,
// including testing / optimization.
//
//=============================================================================
void OrderReliableUseForTesting(bool use)
{
UseForTesting = use;
}

//=============================================================================
// OrderReliableAddSpreadToComment()
//
// Setting to toggle whether this to add the current spread to the trade
// commment, so that user can monitor variable spread situations on a
// per trade basis.
//
//=============================================================================
void OrderReliableAddSpreadToComment(bool use)
{
AddSpreadToComment = use;
}

//=============================================================================
// GetOrderDetails()
//
// For some OrderReliable functions (such as Modify), we need to know some
// things about the order (such as direction and symbol). To do this, we
// need to select the order. However, the caller may already have an order
// selected so we need to be responsible and put it back when done.
//
// Return false if there is a problem, true otherwise.
//
//=============================================================================
bool GetOrderDetails(int ticket, string& symb, int& type, int& digits,
                   double& point, double& sl, double& tp, double& bid,
                   double& ask, bool exists=true)
{
   // If this is existing order, select it and get symbol and type
   if (exists)
   {
       int lastTicket = OrderTicket();
       if (!OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
       {
           OrderReliablePrint("OrderSelect() error: " + ErrorDescription(GetLastError()));
           return(false);
       }
       symb = OrderSymbol();
       type = OrderType();
       tp = OrderTakeProfit();
       sl = OrderStopLoss();

       // Select back the prior ticket num in case caller was using it.
       if (lastTicket >= 0)
       {
           if (!OrderSelect(lastTicket, SELECT_BY_TICKET, MODE_TRADES))
               OrderReliablePrint("Could Not Select Ticket #" + IntegerToString(lastTicket));
       }
   }

   // Get bid, ask, point & digits
   bid = NormalizeDouble(MarketInfo(symb, MODE_BID), (int) MarketInfo(symb, MODE_DIGITS));
   ask = NormalizeDouble(MarketInfo(symb, MODE_ASK), (int) MarketInfo(symb, MODE_DIGITS));
   point = MarketInfo(symb, MODE_POINT);
   if (point == 0.001 || point == 0.00001)
       point *= 10;

   digits = (int) MarketInfo(symb, MODE_DIGITS);

   // If this is a forex pair (i.e. symbol length == 6), then digits should not be zero
   if (digits == 0 && StringLen(MySymbolVal2String(MySymbolConst2Val(Symbol()))) == 6)
   {
       string prevName = OrderReliable_Fname;
       OrderReliable_Fname = "GetDigits";
       OrderReliablePrint("error: MarketInfo(symbol (" + symb + "), MODE_DIGITS) == 0");
       OrderReliable_Fname = prevName;
       return(false);
   }
   else if (exists)
   {
       tp = NormalizeDouble(tp, digits);
       sl = NormalizeDouble(sl, digits);
       bid = NormalizeDouble(bid, digits);
       ask = NormalizeDouble(ask, digits);
   }

   return(true);
}

//=============================================================================
// 20Jul16: Not sure what BS this is; all this ised to work, but not sure how.
// DerksUtils includes OrderReliable, but not vice versa... So copied these
// functions from DerksUtils and changed the names. Also, abive, where used,
// it WAS: StringLen(MySymbolVal2String(Symbol())) == 6), which was wrong.
//=============================================================================
int MySymbolConst2Val(string symbol)
{
   // Handle problem of trailing chars on mini accounts.
   string mySymbol = StringSubstr(symbol,0,6);

   if (mySymbol == "AUDCAD")    return(1);
   if (mySymbol == "AUDJPY")    return(2);
   if (mySymbol == "AUDNZD")    return(3);
   if (mySymbol == "AUDUSD")    return(4);
   if (mySymbol == "CADJPY")    return(5);
   if (mySymbol == "CHFJPY")    return(6);
   if (mySymbol == "EURAUD")    return(7);
   if (mySymbol == "EURCAD")    return(8);
   if (mySymbol == "EURCHF")    return(9);
   if (mySymbol == "EURGBP")    return(10);
   if (mySymbol == "EURJPY")    return(11);
   if (mySymbol == "EURUSD")    return(12);
   if (mySymbol == "GBPCHF")    return(13);
   if (mySymbol == "GBPJPY")    return(14);
   if (mySymbol == "GBPUSD")    return(15);
   if (mySymbol == "NZDJPY")    return(16);
   if (mySymbol == "NZDUSD")    return(17);
   if (mySymbol == "USDCAD")    return(18);
   if (mySymbol == "USDCHF")    return(19);
   if (mySymbol == "USDJPY")   return(20);

   // These symbols were added 26Sep10
   if (mySymbol == "AUDCHF")    return(22);
   if (mySymbol == "AUDDKK")    return(23);
   if (mySymbol == "AUDNOK")    return(24);
   if (mySymbol == "AUDSEK")    return(25);
   if (mySymbol == "CADCHF")    return(26);
   if (mySymbol == "CHFNOK")    return(27);
   if (mySymbol == "EURDKK")   return(28);
   if (mySymbol == "EURNZD")    return(29);
   if (mySymbol == "EURPLN")    return(30);
   if (mySymbol == "EURSEK")   return(31);
   if (mySymbol == "EURSGD")    return(32);
   if (mySymbol == "EURZAR")   return(33);
   if (mySymbol == "GBPAUD")    return(34);
   if (mySymbol == "GBPCAD")    return(35);
   if (mySymbol == "GBPNOK")    return(36);
   if (mySymbol == "GBPNZD")    return(37);
   if (mySymbol == "GBPSGD")    return(38);
   if (mySymbol == "NOKJPY")    return(39);
   if (mySymbol == "NZDCAD")    return(40);
   if (mySymbol == "NZDCHF")    return(41);
   if (mySymbol == "NZDGBP")    return(42);
   if (mySymbol == "SEKJPY")    return(43);
   if (mySymbol == "USDAED")   return(44);
   if (mySymbol == "USDBHD")   return(45);
   if (mySymbol == "USDDKK")   return(46);
   if (mySymbol == "USDEGP")   return(47);
   if (mySymbol == "USDHKD")   return(48);
   if (mySymbol == "USDJOD")   return(49);
   if (mySymbol == "USDKWD")   return(50);
   if (mySymbol == "USDMXN")   return(51);
   if (mySymbol == "USDNOK")   return(52);
   if (mySymbol == "USDPLN")   return(53);
   if (mySymbol == "USDQAR")   return(54);
   if (mySymbol == "USDSAR")   return(55);
   if (mySymbol == "USDSEK")   return(56);
   if (mySymbol == "USDSGD")   return(57);
   if (mySymbol == "USDTHB")   return(58);
   if (mySymbol == "USDZAR")   return(59);
   if (mySymbol == "XAGUSD")   return(60);
   if (mySymbol == "XAUUSD")   return(61);

   // Originally, this was "other"; kept
   // the same for backward compatability
   return(21);
}

string MySymbolVal2String(int val)
{
   if (val == 1)    return("AUDCAD");
   if (val == 2)    return("AUDJPY");
   if (val == 3)    return("AUDNZD");
   if (val == 4)    return("AUDUSD");
   if (val == 5)    return("CADJPY");
   if (val == 6)    return("CHFJPY");
   if (val == 7)    return("EURAUD");
   if (val == 😎    return("EURCAD");
   if (val == 9)    return("EURCHF");
   if (val == 10)    return("EURGBP");
   if (val == 11)    return("EURJPY");
   if (val == 12)    return("EURUSD");
   if (val == 13)    return("GBPCHF");
   if (val == 14)    return("GBPJPY");
   if (val == 15)    return("GBPUSD");
   if (val == 16)    return("NZDJPY");
   if (val == 17)    return("NZDUSD");
   if (val == 18)    return("USDCAD");
   if (val == 19)    return("USDCHF");
   if (val == 20)   return("USDJPY");

   // These symbols were added 26Sep10
   if (val == 22)   return("AUDCHF");
   if (val == 23)   return("AUDDKK");
   if (val == 24)   return("AUDNOK");
   if (val == 25)   return("AUDSEK");
   if (val == 26)   return("CADCHF");
   if (val == 27)   return("CHFNOK");
   if (val == 28)   return("EURDKK");
   if (val == 29)   return("EURNZD");
   if (val == 30)   return("EURPLN");
   if (val == 31)   return("EURSEK");
   if (val == 32)   return("EURSGD");
   if (val == 33)   return("EURZAR");
   if (val == 34)   return("GBPAUD");
   if (val == 35)   return("GBPCAD");
   if (val == 36)   return("GBPNOK");
   if (val == 37)   return("GBPNZD");
   if (val == 38)   return("GBPSGD");
   if (val == 39)   return("NOKJPY");
   if (val == 40)   return("NZDCAD");
   if (val == 41)   return("NZDCHF");
   if (val == 42)   return("NZDGBP");
   if (val == 43)   return("SEKJPY");
   if (val == 44)   return("USDAED");
   if (val == 45)   return("USDBHD");
   if (val == 46)   return("USDDKK");
   if (val == 47)   return("USDEGP");
   if (val == 48)   return("USDHKD");
   if (val == 49)   return("USDJOD");
   if (val == 50)   return("USDKWD");
   if (val == 51)   return("USDMXN");
   if (val == 52)   return("USDNOK");
   if (val == 53)   return("USDPLN");
   if (val == 54)   return("USDQAR");
   if (val == 55)   return("USDSAR");
   if (val == 56)   return("USDSEK");
   if (val == 57)   return("USDSGD");
   if (val == 58)   return("USDTHB");
   if (val == 59)   return("USDZAR");
   if (val == 60)   return("XAGUSD");
   if (val == 61)   return("XAUUSD");

   return("Unrecognized Pair");
}

//+----------------------------- Include from /MetaTrader4/CustomFunctions/GreaterCount.mq4 -------------------------------------+

//+------------------------------------------------------------------+

bool sqIsGreaterCount(string indicatorIdentificationLeft,string indicatorIdentificationRight, int bars,bool NotStrict,int shift) {

bool atLeastOnce = false;

for(int i=0; i<bars; i++) { /// bars != Bars in mq4

       double leftIndicator = NormalizeDouble(sqGetIndicatorByIdentification(indicatorIdentificationLeft,shift+i), 5); /// precision = 5. It returns more acccurate backtest synchronisation
       double rightIndicator = NormalizeDouble(sqGetIndicatorByIdentification(indicatorIdentificationRight,shift+i), 5);

       if(leftIndicator<rightIndicator){

           return (false);
       }
       if(leftIndicator==rightIndicator && NotStrict == false){

           return (false);
       }
       if(leftIndicator>rightIndicator){

           atLeastOnce = true;
       }
   }
   return(atLeastOnce);
}

//+----------------------------- Include from /MetaTrader4/CustomFunctions/LowerCount.mq4 -------------------------------------+

//+------------------------------------------------------------------+

bool sqIsLowerCount(string indicatorIdentificationLeft,string indicatorIdentificationRight, int bars,bool NotStrict,int shift) {

bool atLeastOnce = false;

for(int i=0; i<bars; i++) { /// bars != Bars in mq4

       double leftIndicator = NormalizeDouble(sqGetIndicatorByIdentification(indicatorIdentificationLeft,shift+i), 5); /// precision = 5. It returns more acccurate backtest synchronisation
       double rightIndicator = NormalizeDouble(sqGetIndicatorByIdentification(indicatorIdentificationRight,shift+i), 5);

       if(leftIndicator>rightIndicator){

           return (false);
       }
       if(leftIndicator==rightIndicator && NotStrict == false){

           return (false);
       }
       if(leftIndicator<rightIndicator){

           atLeastOnce = true;
       }
   }
   return(atLeastOnce);
}

//+----------------------------- Include from /MetaTrader4/CustomFunctions/SessionOHLC.mq4 -------------------------------------+

double SessionOpen(string symbol, int tf, int startHours, int startMinutes, int daysAgo){
return getSessionPrice(symbol, tf, 1, startHours, startMinutes, startHours, startMinutes, daysAgo);
}

//+------------------------------------------------------------------+

double SessionHigh(string symbol, int tf, int startHours, int startMinutes, int endHours, int endMinutes, int daysAgo){
return getSessionPrice(symbol, tf, 2, startHours, startMinutes, endHours, endMinutes, daysAgo);
}

//+------------------------------------------------------------------+

double SessionLow(string symbol, int tf, int startHours, int startMinutes, int endHours, int endMinutes, int daysAgo){
return getSessionPrice(symbol, tf, 3, startHours, startMinutes, endHours, endMinutes, daysAgo);
}

//+------------------------------------------------------------------+

double SessionClose(string symbol, int tf, int endHours, int endMinutes, int daysAgo){
return getSessionPrice(symbol, tf, 4, endHours, endMinutes, endHours, endMinutes, daysAgo);
}

//+------------------------------------------------------------------+

double getSessionPrice(string symbol, int tf, int type, int startHours, int startMinutes, int endHours, int endMinutes, int daysAgo){
string correctedSymbol = correctSymbol(symbol);
return iCustom(correctedSymbol, tf, "SqSessionOHLC", type, startHours, startMinutes, endHours, endMinutes, daysAgo, 0, 0);
}
//+----------------------------- Include from /MetaTrader4/CustomFunctions/SRPercRankAboveLevelXBars.mqh -------------------------------------+

//+------------------------------------------------------------------+

bool sqSRPercRankAboveLevelXBars(int mode,int lenght,int ATRPeriod,double Level, int bars,int shift) {

bool atLeastOnce = false;

for(int i=0; i<bars; i++) { /// bars != Bars in mq4

       if(NormalizeDouble(iCustom(NULL,0,"SqSRPercentRank",mode,lenght,ATRPeriod,0,shift+i),5)<Level){

           return (false);
       }
       if(NormalizeDouble(iCustom(NULL,0,"SqSRPercentRank",mode,lenght,ATRPeriod,0,shift+i),5)>Level){

           atLeastOnce = true;
       }
   }
   return(atLeastOnce);
}
//+----------------------------- Include from /MetaTrader4/CustomFunctions/SRPercRankBelowLevelXBars.mqh -------------------------------------+

bool sqSRPercRankBelowLevelXBars(int mode,int lenght,int ATRPeriod,double Level, int bars,int shift) {
bool atLeastOnce = false;

for(int i=0; i<bars; i++) { /// bars != Bars in mq4

       if(NormalizeDouble(iCustom(NULL,0,"SqSRPercentRank",mode,lenght,ATRPeriod,0,shift+i),5)>Level){

           return (false);
       }
       if(NormalizeDouble(iCustom(NULL,0,"SqSRPercentRank",mode,lenght,ATRPeriod,0,shift+i),5)<Level){

           atLeastOnce = true;
       }
   }
   return(atLeastOnce);
}
//+----------------------------- Include from /MetaTrader4/CustomFunctions/CustomFunctions.mq4 -------------------------------------+

//+------------------------------------------------------------------+
//+ Custom functions
//+
//+ Here you can define your own custom functions that can be used
//+ in Algo Wizard.
//+ The functions can perform some action (for example draw on chart
//+ or manipulate with orders) or they can return value that
//+ can be used in comparison.
//+
//+ Note! All the functions below must be in valid MQL code!
//+ Contents of this file will be appended to your EA code.
//+
//+------------------------------------------------------------------+

double exampleFunction(double value) {
return(2 * value);
}

//+------------------------------------------------------------------+

Thousand thanks in advance

Edited December 30, 2022 by Dellan

AntonL-IG · May 17, 2023

Hi @Dellan,

Due to the variables involved with expert advisors we are not able to provide much help unfortunately. It could be a corrupt file or possibly it could only work on a specific account type or base currency or even a particular symbol naming convention. For support running the EA we would suggest speaking to the creator of the expert advisor.

All the best!

saltwater · August 15, 2023

Hi, just wondering if you fixed this?

Need help on unable to loan EA on IG MT4

Question

Dellan

Link to comment

2 answers to this question

Recommended Posts

AntonL-IG

Link to comment

saltwater

Link to comment

Create an account or sign in to comment

Create an account

Sign in

Posts

Markets

IG services

Trading platforms

About Us

Contact us

IG Community