Useful #define statements - script para MetaTrader 5

Definição de variáveis

// Candle (define g_rates as: MqlRates g_rates[];)
#define  CANDLELOW(i)    g_rates[i].low
#define  CANDLEHIGH(i)   g_rates[i].high
#define  CANDLEOPEN(i)   g_rates[i].open
#define  CANDLECLOSE(i)  g_rates[i].close
#define CANDLETIME(i)   g_rates[i].time

Além disso, você pode obter os valores ASK e BID usando MqlTick, como fiz abaixo, ou pode chamar SymbolInfoDouble(_Symbol,SYMBOL_ASK), se preferir. Isso não faz nenhuma diferença no valor retornado.

// Preços (define g_tick como: MqlTick g_tick;))
#define  ASK             g_tick.ask
#define  BID             g_tick.bid

Por fim, as matrizes também são definidas para médias móveis, atr ou qualquer outra matriz adicional de que você precise. Exemplo: para usar o Average True Range da vela 1, use ATR(1).
IMPORTANTE: presume-se que as matrizes sejam AsSeries ( por exemplo,ArraySetAsSeries(g_MA20_arr, true); ). Isso é fundamental nas declarações #define mostradas posteriormente.

// defina essas matrizes como: double g_MA20_arr[];
// Médias móveis e ATR
#define  MOVAVG20(i)     g_MA20_arr[i]
#define  MOVAVG40(i)     g_MA40_arr[i]
#define  MOVAVG50(i)     g_MA50_arr[i]
#define  MOVAVG200(i)    g_MA200_arr[i]
#define  ATR(i)          g_atr_arr[i]

Depois de definir as instruções acima, você não precisará alterar mais nada. Outras instruções #define que se ajustem ao seu EA também podem ser adicionadas, se necessário.

Recursos da vela

As velas têm recursos que são úteis ao desenvolver um EA, especialmente se o EA for baseado em ação de preço. Os nomes das definições a seguir indicam o que elas representam. WICK refere-se à sombra do candle superior e TAIL à sombra do candle inferior. Exemplo: para obter o preço no meio do corpo do último candle, use CANDLEBODYMIDDLE(1).

// características da vela
#define  CANDLEBODYTOP(i)      fmax(CANDLEOPEN(i),CANDLECLOSE(i))
#define  CANDLEBODYBOT(i)      fmin(CANDLEOPEN(i),CANDLECLOSE(i))
#define  CANDLEMEDIAN(i)       (0.5*(CANDLEHIGH(i)+CANDLELOW(i)))
#define  CANDLEWEIGHTED(i)     (0.25*(CANDLEHIGH(i)+CANDLELOW(i)+2*CANDLECLOSE(i)))
#define  CANDLETYPICAL(i)      (1./3.*(CANDLEHIGH(i)+CANDLELOW(i)+CANDLECLOSE(i)))
#define  CANDLEBODYMIDDLE(i)   (0.5*(CANDLEBODYTOP(i)+CANDLEBODYBOT(i)))
#define  CANDLESIZE(i)         (CANDLEHIGH(i)-CANDLELOW(i))
#define  CANDLEBODYSIZE(i)     fabs(CANDLECLOSE(i)-CANDLEOPEN(i))
#define  CANDLEWICKSIZE(i)     (CANDLEHIGH(i)-CANDLEBODYTOP(i))
#define  CANDLETAILSIZE(i)     (CANDLEBODYBOT(i)-CANDLELOW(i))

Além disso, definimos dois tamanhos usando o ATR como referência. Exemplo: se você quiser saber o tamanho do candle 4 em relação ao Atr, use ATRCANDLESIZE(4).

#define  ATRCANDLESIZE(i)      (CANDLESIZE(i)/ATR(i))
#define  ATRCANDLEBODYSIZE(i)  (CANDLEBODYSIZE(i)/ATR(i))

Além disso, diz-se que os candles que estão subindo (close>open) têm direção +1, enquanto os candles que estão descendo têm direção -1. Se close==open, direção = 0. Exemplo: if(CANDLEDIRECTION(10)==1) Print("Candle 10 is an up candle");

#define  CANDLEDIRECTION(i)    (CANDLECLOSE(i)>CANDLEOPEN(i)?1:(CANDLECLOSE(i)<CANDLEOPEN(i)?-1:0))

São definidos dois tipos de "execuções": UP e DOWN. A runUP é definida em um candle de subida como Close-Low, caso contrário, 0. A runDOWN é definida em um candle de descida como High-Close, caso contrário, 0; "Runs" são úteis para capturar movimentos fortes no preço em uma direção. Por exemplo, para obter a subida do candle 3, use CANDLERUNUP(3).

#define  CANDLERUNUP(i)        ((CANDLECLOSE(i)>CANDLEOPEN(i))?(CANDLECLOSE(i)-CANDLELOW(i)):0)
#define  CANDLERUNDOWN(i)      ((CANDLECLOSE(i)<CANDLEOPEN(i))?(CANDLEHIGH(i)-CANDLECLOSE(i)):0)

Consultas sobre recursos de velas

Essas definições são variáveis booleanas que nos informam o comportamento de uma ou de um grupo de velas. Elas usam declarações #define anteriores para torná-las curtas.

isCANDLERIGHTDIR(i,dir) será verdadeira se a direção da vela (i) for igual a dir; caso contrário, será falsa;

Há dois tipos de fractais: um que usa cinco velas e outro (o fractal fraco) que usa três velas. Nas #definições de fractal abaixo, o candle(i) é o candle do meio que tem a maior alta (TOP) ou a menor baixa (BOT). Certifique-se de que haja dados para as velas i-2,i-1,i,i+1,i+2 para os fractais de cinco velas. Há também outras variações usando a desigualdade estrita ">" ou "<", e usando "<=" ou ">=". Por fim, há #definições para identificar fractais superiores (TOP) ou inferiores (BOT). Observando as definições, você pode descobrir qual definição usar.

is3CANDLEGAPUP(i,gap,size) é usado para encontrar um gap UP (em que a máxima de um candle está abaixo da mínima de dois candles posteriores). Candle(i) será o mais novo dos três candles em questão. Novamente, supõe-se que os candles sejam "AsSeries". "gap" é o preço-delta mínimo do gap, e "size" é o preço-delta mínimo do tamanho do corpo do candle do meio.

is3CANDLEGAPDOWN(i,gap,size) é usado para encontrar um gap DOWN usando a mesma lógica.

is3CANDLEGAPUPTREND(i,gap,size) é igual a is3CANDLEGAPUP(i,gap,size), mas acrescenta uma condição adicional para ser verdadeira: a mais antiga das três velas deve ter direção positiva.

Há duas maneiras de verificar se um candle é um doji: isCANDLEDOJIPOINTS(i,n) e isCANDLEDOJIFRACTION(i,f). A primeira versão usa n*_Point e a segunda usa f*CANDLESIZE(i) para determinar se o candle é ou não (verdadeiro ou falso) um Doji.

Exemplo: se você quiser saber se o candle 20 é um topo fractal não estrito (usando igualdades), use isCANDLEFRACTALEQTOP(20), e o resultado será verdadeiro ou falso.

Como você pode ver, as definições são uma forma compactada das consultas, tornando o código do seu EA mais curto e mais fácil de ler.

// consultas sobre recursos de velas (booleano)
#define  isCANDLEUP(i)               (CANDLEDIRECTION(i)==1)
#define  isCANDLEDOWN(i)             (CANDLEDIRECTION(i)==-1)
#define  isCANDLEFLAT(i)             (CANDLEDIRECTION(i)==0)
#define  isCANDLEWICKLESS(i)         (CANDLEWICKSIZE(i)==0)
#define  isCANDLETAILLESS(i)         (CANDLETAILSIZE(i)==0)
#define  isCANDLESOLID(i)            (CANDLEWICKSIZE(i)==0 && CANDLETAILSIZE(i)==0)
#define  isCANDLERIGHTDIR(i,dir)     (dir*(CANDLECLOSE(i) - CANDLEOPEN(i))>0)
#define  isCANDLEFRACTALTOP(i)       (CANDLEHIGH(i) > CANDLEHIGH(i-1) && CANDLEHIGH(i-1) > CANDLEHIGH(i-2) && CANDLEHIGH(i) > CANDLEHIGH(i+1) && CANDLEHIGH(i+1) > CANDLEHIGH(i+2))
#define  isCANDLEFRACTALBOT(i)       (CANDLELOW(i) < CANDLELOW(i-1) && CANDLELOW(i-1) < CANDLELOW(i-2) && CANDLELOW(i) < CANDLELOW(i+1) && CANDLELOW(i+1) < CANDLELOW(i+2))
#define  isCANDLEFRACTALEQTOP(i)     (CANDLEHIGH(i) >= CANDLEHIGH(i-1) && CANDLEHIGH(i-1) >= CANDLEHIGH(i-2) && CANDLEHIGH(i) >= CANDLEHIGH(i+1) && CANDLEHIGH(i+1) >= CANDLEHIGH(i+2))
#define  isCANDLEFRACTALEQBOT(i)     (CANDLELOW(i) <= CANDLELOW(i-1) && CANDLELOW(i-1) <= CANDLELOW(i-2) && CANDLELOW(i) <= CANDLELOW(i+1) && CANDLELOW(i+1) <= CANDLELOW(i+2))
#define  isCANDLEWEAKFRACTALTOP(i)   (CANDLEHIGH(i) > CANDLEHIGH(i-1) && CANDLEHIGH(i) > CANDLEHIGH(i+1))
#define  isCANDLEWEAKFRACTALBOT(i)   (CANDLELOW(i) < CANDLELOW(i-1) && CANDLELOW(i) < CANDLELOW(i+1))
#define  isCANDLEWEAKFRACTALEQBOT(i) (CANDLELOW(i) <= CANDLELOW(i-1) && CANDLELOW(i) <= CANDLELOW(i+1))
#define  isCANDLEWEAKFRACTALEQTOP(i) (CANDLEHIGH(i) >= CANDLEHIGH(i-1) && CANDLEHIGH(i) >= CANDLEHIGH(i+1))
#define  is3CANDLEGAPUP(i,gap,size)  (CANDLELOW(i)-CANDLEHIGH(i+2)>gap && CANDLEBODYSIZE(i+1)>=size)
#define  is3CANDLEGAPDOWN(i,gap,size) (CANDLELOW(i+2)-CANDLEHIGH(i)>gap && CANDLEBODYSIZE(i+1)>=size)
#define  is3CANDLEGAPUPTREND(i,gap,size)  (CANDLELOW(i)-CANDLEHIGH(i+2)>gap && CANDLEBODYSIZE(i+1)>=size &&  isCANDLEUP(i+2))
#define  is3CANDLEGAPDOWNTREND(i,gap,size) (CANDLELOW(i+2)-CANDLEHIGH(i)>gap && CANDLEBODYSIZE(i+1)>=size &&  isCANDLEDOWN(i+2))
#define  isCANDLEDOJIPOINTS(i,n)     (CANDLEBODYSIZE(i) <= n*_Point)
#define  isCANDLEDOJIFRACTION(i,f)   (CANDLEBODYSIZE(i) <= f*CANDLESIZE(i))

Funções e operações matemáticas

Agora definimos algumas funções e operações matemáticas que são úteis no EA. Algumas delas são específicas para os EAs que desenvolvi, mas você pode alterá-las ou excluí-las, se desejar.

BRACKET(x,minV,maxV) retornará um valor de x dentro do intervalo [minV,maxV]. Isso é útil para restringir as variáveis de entrada no EA.

CONVEXCOMB(a,x1,x2) é uma combinação convexa de x1 e x2 como a*x1+x2. Essa função é útil ao calcular um valor intermediário entre x1 e x2, mas você deseja mais do que apenas a média (a=0,5).

EVALLINE(x,x1,y1,x2,y2,ymin,ymax) é a avaliação de uma linha reta definida por dois pontos [x1,y1] e [x2,y2]. Uma vez avaliada em x, ela retorna um valor entre colchetes dentro de [ymin, ymax].

MAPAB11(x,A,B) mapeia o valor x de um colchete [A,B] para um colchete [-1,1]. MAP11AB(x,A,B) mapeia o valor x de um colchete [-1,1] para um colchete [A,B]. Essas duas funções são úteis para trabalhar com variáveis normalizadas no intervalo de [-1,1].

As últimas quatro funções são usadas em meus EAs e podem não ser necessariamente úteis de forma genérica para todos, mas eu as deixei aqui, por precaução.

#define  BRACKET(x,minV,maxV)                 (x<minV?minV:(x>maxV?maxV:x))
#define  CONVEXCOMB(a,x1,x2)                  (a*x1+(1.0-a)*x2)
#define  EVALLINE(x,x1,y1,x2,y2,ymin,ymax)    BRACKET((y2-y1)/(x2-x1)*(x-x1)+y1,ymin,ymax)
#define  MAPAB11(x,A,B)                       (2./(B-A)*(BRACKET(x,A,B)-A)-1.)
#define  MAP11AB(x,A,B)                       ((B-A)/2.*(BRACKET(x,-1,1)-1)+B)
#define  SIGMOID(x,a)                         (1.0/(1.0 + exp(-a*x)))
#define  NN1(x,w,b)                           (w*x+b)
#define  EVALPOLY(X,X0,X1,Y0,Y1,EX,ymin,ymax) BRACKET(Y1*pow((X-X0)/(X1-X0),EX)+Y0,ymin,ymax)
#define  EVALPOLY2P(X,X0,X1,Y0,Y1,EX,ymn,ymx) BRACKET((Y1-Y0)*pow((X-X0)/(X1-X0),EX)+Y0,ymn,ymx)

Além disso, como função e operações, há cálculos de diferenças (como um substituto para inclinações).

MA20DIFF(i,n) fornece a diferença entre os dois valores da média móvel de 20 períodos separados por n velas. O restante das funções segue a mesma lógica. Exemplo: para calcular a diferença entre a média móvel de 200 períodos no candle 3 e no candle 13, use MA200DIFF(3,10).

#define  MA20DIFF(i,n)                        (MOVAVG20(i)-MOVAVG20(i+n))
#define  MA40DIFF(i,n)                        (MOVAVG40(i)-MOVAVG40(i+n))
#define  MA50DIFF(i,n)                        (MOVAVG50(i)-MOVAVG50(i+n))
#define  MA200DIFF(i,n)                       (MOVAVG200(i)-MOVAVG200(i+n))
#define  CANDLECLOSEDIFF(i,n)                 (CANDLECLOSE(i)-CANDLECLOSE(i+n))
#define  CANDLEOPENDIFF(i,n)                  (CANDLEOPEN(i)-CANDLEOPEN(i+n))
#define  CANDLEHIGHDIFF(i,n)                  (CANDLEHIGH(i)-CANDLEHIGH(i+n))
#define  CANDLELOWDIFF(i,n)                   (CANDLELOW(i)-CANDLELOW(i+n))
#define  CANDLEMEDIANDIFF(i,n)                (CANDLEMEDIAN(i)-CANDLEMEDIAN(i+n))
#define  CANDLEWEIGHTEDDIFF(i,n)              (CANDLEWEIGHTED(i)-CANDLEWEIGHTED(i+n))
#define  CANDLETYPICALDIFF(i,n)               (CANDLETYPICAL(i)-CANDLETYPICAL(i+n))
#define  CANDLEBODYMIDDLEDIFF(i,n)            (CANDLEBODYMIDDLE(i)-CANDLEBODYMIDDLE(i+n))

As consultas também são incluídas como funções matemáticas. O bracketing e a convexidade são verificados abaixo.

#define  isINBRACKET(x,minV,maxV)             (x<=maxV && x>=minV)
#define  isINBRACKETSTRICT(x,minV,maxV)       (x<maxV && x> minV)
#define  isOUTBRACKET(x,minV,maxV)            (x>=maxV || x<=minV)
#define  isOUTBRACKETSTRICT(x,minV,maxV)      (x> maxV || x< minV)
#define  isCONVEX(yl,yc,yr)                   (yl>=yc && yc<=yr)
#define  isCONCAVE(yl,yc,yr)                  (yl<=yc && yc>=yr)
#define  isCONVEXTSTRICT(yl,yc,yr)            (yl>yc && yc<yr)
#define  isCONCAVESTRICT(yl,yc,yr)            (yl<yc && yc> yr)

Constantes

Defino algumas constantes que utilizo. Você pode optar por usá-las.

// Constantes
#define  PIVALUE                              (M_PI)
#define  MINSTOPPOINTS                        (30)
#define  MINFREEZEPOINTS                      (30)
#define  STOPLEVEL                            (fmax(MINSTOPPOINTS,(double)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL))*_Point)
#define  FREEZELEVEL                          (fmax(MINFREEZEPOINTS,(double)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL))*_Point)

Depuração

Qualquer programador experiente sabe que a melhor ferramenta para depurar seu código é a instrução Print. As definições a seguir permitem configurar instruções Print em todo o seu programa e ativá-las ou desativá-las, dependendo do valor do nível de depuração no qual você está interessado.

Primeiro, você precisa definir o nível de depuração usando #define DEBUG_LEVEL0, #define DEBUG_LEVEL1 ou #define DEBUG_LEVEL2. Ao usar DEBUG_LEVEL0, não haverá impressão na guia Diário do terminal do Metatrader 5. Com DEBUG_LEVEL1, somente as instruções PRINTVARn estarão ativas e serão impressas na guia Diário. Com DEBUG_LEVEL2, ambas as instruções PRINTVARn e VPRINTVARn serão impressas na guia Diário. O DEBUG_LEVEL2 é o caso "V "erboso que usa VPRINTVARn.

PRINTVARn imprimirá n variáveis. Por exemplo, se você quiser imprimir i, x e z, use PRINTVAR3(i,x,z); para imprimir uma cadeia de caracteres, use PRINTTEXT("any string"); a impressão incluirá o nome da função e o número da linha do arquivo em que a instrução PRINTVARn foi inserida.

// Depuração com o Print 
// No início de seu código, defina o nível de depuração x={0,1,2} como: #define DEBUG_LEVELx 
#ifdef  DEBUG_LEVEL0
#define  PRINTTEXT(text)
#define  PRINTVAR(x1)
#define  PRINTVAR1(x1)
#define  PRINTVAR2(x1,x2)
#define  PRINTVAR3(x1,x2,x3)
#define  PRINTVAR4(x1,x2,x3,x4)
#define  PRINTVAR5(x1,x2,x3,x4,x5)
#define  PRINTVAR6(x1,x2,x3,x4,x5,x6)

#define  VPRINTTEXT(text)
#define  VPRINTVAR(x1)
#define  VPRINTVAR1(x1)
#define  VPRINTVAR2(x1,x2)
#define  VPRINTVAR3(x1,x2,x3)
#define  VPRINTVAR4(x1,x2,x3,x4)
#define  VPRINTVAR5(x1,x2,x3,x4,x5)
#define  VPRINTVAR6(x1,x2,x3,x4,x5,x6)

#endif
                                                                                                
#ifdef  DEBUG_LEVEL1
#define  PRINTTEXT(text)           Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :",text)
#define  PRINTVAR(x1)              Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  PRINTVAR1(x1)             Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  PRINTVAR2(x1,x2)          Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2))
#define  PRINTVAR3(x1,x2,x3)       Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3))
#define  PRINTVAR4(x1,x2,x3,x4)    Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4))
#define  PRINTVAR5(x1,x2,x3,x4,x5) Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5))
#define  PRINTVAR6(x1,x2,x3,x4,x5,x6) Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5),", " #x6 + "=", (x6))

#define  VPRINTTEXT(text)
#define  VPRINTVAR(x1)
#define  VPRINTVAR1(x1)
#define  VPRINTVAR2(x1,x2)
#define  VPRINTVAR3(x1,x2,x3)
#define  VPRINTVAR4(x1,x2,x3,x4)
#define  VPRINTVAR5(x1,x2,x3,x4,x5)
#define  VPRINTVAR6(x1,x2,x3,x4,x5,x6)
#endif

#ifdef   DEBUG_LEVEL2
#define  PRINTTEXT(text)           Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :",text)
#define  PRINTVAR(x1)              Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  PRINTVAR1(x1)             Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  PRINTVAR2(x1,x2)          Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2))
#define  PRINTVAR3(x1,x2,x3)       Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3))
#define  PRINTVAR4(x1,x2,x3,x4)    Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4))
#define  PRINTVAR5(x1,x2,x3,x4,x5) Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5))
#define  PRINTVAR6(x1,x2,x3,x4,x5,x6) Print("*/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5),", " #x6 + "=", (x6))

#define  VPRINTTEXT(text)           Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :",text)
#define  VPRINTVAR(x1)              Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  VPRINTVAR1(x1)             Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1))
#define  VPRINTVAR2(x1,x2)          Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2))
#define  VPRINTVAR3(x1,x2,x3)       Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3))
#define  VPRINTVAR4(x1,x2,x3,x4)    Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4))
#define  VPRINTVAR5(x1,x2,x3,x4,x5) Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5))
#define  VPRINTVAR6(x1,x2,x3,x4,x5,x6) Print("V/*/*/* ",__FUNCTION__,"(",__LINE__,") :", #x1 + "=", (x1),", " #x2 + "=", (x2),", " #x3 + "=", (x3),", " #x4 + "=", (x4),", " #x5 + "=", (x5),", " #x6 + "=", (x6))
#endif