for(int i=0;i<limit;i++){
      if(Close[i]<High[i]){
         double pullbackHighest_DotPreis=Close[i]<High[i];
         pullbackHighest_Dot[i]=pullbackHighest_DotPreis;
      }else if(Close[i]>Low[i]){
         double pullbackLowest_DotPreis=Close[i]>Low[i];
         pullbackLowest_Dot[i]=pullbackLowest_DotPreis;
      }
   }

//+------------------------------------------------------------------+
//|                                   sellHigherLow_buyLowerhigh.mq4 |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2020, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 clrAqua
#property indicator_color2 clrMagenta
#property indicator_width1 2
#property indicator_width2 2

double pullbackLowest_Dot[];
double pullbackHighest_Dot[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   //pullbackLowest_Dot
   SetIndexBuffer(0,pullbackLowest_Dot);
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,159);
   SetIndexLabel(0,"Sell Signal");
   //pullbackHighest_Dot
   SetIndexBuffer(1,pullbackHighest_Dot);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,159);
   SetIndexLabel(1,"Sell Signal");
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   //counting Bars
   int counted_bars, limit;
   counted_bars=IndicatorCounted();
   limit=Bars-counted_bars;
   
   //Erklärung mit Code
   for(int i=0;i<limit;i++){
      if(Close[i]<High[i]){
         double pullbackHighest_DotPreis=Close[i]<High[i];
         pullbackHighest_Dot[i]=pullbackHighest_DotPreis;
      }else if(Close[i]>Low[i]){
         double pullbackLowest_DotPreis=Close[i]>Low[i];
         pullbackLowest_Dot[i]=pullbackLowest_DotPreis;
      }
   }
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

string sVariable;
int iVariable;


sVariable = "20000";

iVariable = StrToInteger(sVariable);
Print iVariable;

int iVariable;




iVariable = StrToInteger("20000");
Print iVariable;

//=============================================================================
#property version     "EightMAmMAdV"
#property description "( MA * MA ) / Value"
#property link        "daniel-rudloff@web.de"

//#property strict
//=============================================================================
#property indicator_chart_window         // in Hauptfenster testen
#property indicator_buffers 1            // ein Buffer zum Malen
#property indicator_color1 clrDodgerBlue // Farbe der Linie
#property indicator_width1  1            // Dicke der Linie
//=============================================================================

//=============================================================================================================
// B E S C H R E I B U N G / I N F O S
//=============================================================================================================

extern string esBeschrCW1="? -chart window-";
extern string esBeschrCW2="Scheint im Haupt-";
extern string esBeschrCW3="und im Unterfenster";
extern string esBeschrCW4="zu funktionieren.";
extern string esBeschrCW5="Ist im Unterfenster";
extern string esBeschrCW6="aber etwas";
extern string esBeschrCW7="unübersichtlich. ?";

//=============================================================================================================
// G L O B A L E   E I N S T E L L U N G E N
//=============================================================================================================
//-------------------------------------------------------------------------------------------------------------
extern string MTO="? MA/OpZ Multi/Div";
extern double MAtoOpZ = 100000.0; // ?
//-------------------------------------------------------------------------------------------------------------
extern string LZ_DIMD=
"----------------------------------";

extern string esMXMD ="MAs x MAs / div";

extern double MAs_div = 2.0;

extern string LZ_MD=
"----------------------------------";

extern double Multi = 1.0;

extern bool AutoMulti = false;


extern string LZ_D=
"----------------------------------";

extern string LZ_test=
"----------------------------------";

extern string esIP1 ="if Period = 0";
extern string esIP2 ="MA ist not used";

extern string LZIPMAo=
"----------------------------------";

extern int               MA_A_Period = 2;
input ENUM_MA_METHOD     MA_A_Method = MODE_SMA;
input ENUM_APPLIED_PRICE MA_A_Price  = PRICE_CLOSE;

extern string LZ_MAA=
"----------------------------------";

extern int               MA_B_Period = 2;
input ENUM_MA_METHOD     MA_B_Method = MODE_SMA;
input ENUM_APPLIED_PRICE MA_B_Price  = PRICE_CLOSE;

extern string LZ_MAB=
"----------------------------------";

extern int               MA_C_Period = 2;
input ENUM_MA_METHOD     MA_C_Method = MODE_SMA;
input ENUM_APPLIED_PRICE MA_C_Price  = PRICE_CLOSE;

extern string LZ_MAC=
"----------------------------------";

extern int               MA_D_Period = 0;
input ENUM_MA_METHOD     MA_D_Method = MODE_SMA;
input ENUM_APPLIED_PRICE MA_D_Price  = PRICE_CLOSE;

extern string LZ_MAD=
"----------------------------------";

extern int               MA_E_Period = 0;
input ENUM_MA_METHOD     MA_E_Method = MODE_SMA;
input ENUM_APPLIED_PRICE MA_E_Price  = PRICE_CLOSE;

extern string LZ_MAE=
"----------------------------------";

extern int               MA_F_Period = 0;
input ENUM_MA_METHOD     MA_F_Method = MODE_SMA;
input ENUM_APPLIED_PRICE MA_F_Price  = PRICE_CLOSE;

extern string LZ_MAF=
"----------------------------------";

extern int               MA_G_Period = 0;
input ENUM_MA_METHOD     MA_G_Method = MODE_SMA;
input ENUM_APPLIED_PRICE MA_G_Price  = PRICE_CLOSE;

extern string LZ_MAG=
"----------------------------------";

extern int               MA_H_Period = 0;
input ENUM_MA_METHOD     MA_H_Method = MODE_SMA;
input ENUM_APPLIED_PRICE MA_H_Price  = PRICE_CLOSE;

//=============================================================================================================
// G L O B A L E S
//=============================================================================================================string IndisName = "PrPlusMAd2";  // Indikatorname
string IndisName="EightMAmMAdV"; // Indikatorname
//-------------------------------------------------------------------------------------------------------------
double BUF_EightMAmMAdV[];  // Name des Mal-Buffers
//-------------------------------------------------------------------------------------------------------------

double 

Pr_Hi,Pr_Op,Pr_Cl,Pr_Lo,Pr_HL,Pr_HCL,Pr_HOCL,Pr_ME,Pr_TY,Pr_WE,

MA_A,MA_B,MA_C,MA_D,MA_E,MA_F,MA_G,MA_H,

MA_A_PR,MA_B_PR,MA_C_PR,MA_D_PR,MA_E_PR,MA_F_PR,MA_G_PR,MA_H_PR,

A,B,C,D,E,F,G,H,

MAmMA,MmMd,MmM_Mul,MAmMA_div


;


//-------------------------------------------------------------------------------------------------------------
int
i,MAcount;
//=============================================================================================================
// I N I T / D E I N I T
//=============================================================================================================
int OnInit(void){

  IndicatorShortName(IndisName // === Anzeige des Indikatornamens und der Werte
    
                      
                     );
   
  IndicatorDigits(_Digits); // Anzahl der anzuzeigenden Nachkommastellen
  IndicatorBuffers(1);      // Gesamtanzahl aller Buffer
  SetIndexBuffer(0,BUF_EightMAmMAdV); // 1. Buffer mit Buffername
  SetIndexLabel(0,"EightMAmMAdV");    // Beschreibung im Datenfenster
  SetIndexStyle(0,DRAW_LINE); // Art der Darstellung
   
  return(INIT_SUCCEEDED);}
//-------------------------------------------------------------------------------------------------------------
void OnDeinit(const int reason){}// nothing to do here
//=============================================================================================================
// O N C A L C U L A T E
//=============================================================================================================int OnCalculate(const int rates_total,
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[]){
//-------------------------------------------------------------------------------------------------------------
for(i=1;i<rates_total;i++){ // ?
//=============================================================================================================
// D E K L A R A T I O N   P R I C E
//=============================================================================================================

Pr_Hi=iHigh (NULL,NULL,i);
Pr_Op=iOpen (NULL,NULL,i);
Pr_Cl=iClose(NULL,NULL,i);
Pr_Lo=iLow  (NULL,NULL,i);

Pr_HL = Pr_Hi + Pr_Lo;
Pr_ME = Pr_HL / 2.0;

Pr_HCL = Pr_Hi + Pr_Cl + Pr_Lo;
Pr_TY = Pr_HCL / 3.0;     
    
Pr_HOCL = Pr_Hi + Pr_Cl + Pr_Op + Pr_Lo;
Pr_WE = Pr_HOCL / 4.0;

//=============================================================================================================
// M O V I N G   A V E R A G E S
//=============================================================================================================

MAcount = 0;

// Zuweisung MA_A
if(MA_A_Period<1)MA_A=1.0;
if(MA_A_Period>=1){
  if(MA_A_Price==PRICE_HIGH    )MA_A_PR=Pr_Hi;
  if(MA_A_Price==PRICE_CLOSE   )MA_A_PR=Pr_Cl;
  if(MA_A_Price==PRICE_OPEN    )MA_A_PR=Pr_Op;
  if(MA_A_Price==PRICE_LOW     )MA_A_PR=Pr_Lo;
  if(MA_A_Price==PRICE_MEDIAN  )MA_A_PR=Pr_ME;
  if(MA_A_Price==PRICE_TYPICAL )MA_A_PR=Pr_TY;
  if(MA_A_Price==PRICE_WEIGHTED)MA_A_PR=Pr_WE;
  
  MA_A=iMA(_Symbol,_Period,MA_A_Period,0,MA_A_Method,MA_A_PR,i);
  
  A = MA_A * MAtoOpZ;
  
  if(AutoMulti==true)MAcount++;}


// Zuweisung MA_B
if(MA_B_Period<1)MA_B=1.0;
if(MA_B_Period>=1){
  if(MA_B_Price==PRICE_HIGH    )MA_B_PR=Pr_Hi;
  if(MA_B_Price==PRICE_OPEN    )MA_B_PR=Pr_Op;
  if(MA_B_Price==PRICE_CLOSE   )MA_B_PR=Pr_Cl;
  if(MA_B_Price==PRICE_LOW     )MA_B_PR=Pr_Lo;
  if(MA_B_Price==PRICE_MEDIAN  )MA_B_PR=Pr_ME;
  if(MA_B_Price==PRICE_TYPICAL )MA_B_PR=Pr_TY;
  if(MA_B_Price==PRICE_WEIGHTED)MA_B_PR=Pr_WE;
  
  MA_B=iMA(_Symbol,_Period,MA_B_Period,0,MA_B_Method,MA_B_PR,i);
  
  B = MA_B * MAtoOpZ;
  
  if(AutoMulti==true)MAcount++;}


// Zuweisung Price MA_C
if(MA_C_Period<1)MA_C=1.0;
if(MA_C_Period>=1){
  if(MA_C_Price==PRICE_HIGH    )MA_C_PR=Pr_Hi;
  if(MA_C_Price==PRICE_OPEN    )MA_C_PR=Pr_Op;
  if(MA_C_Price==PRICE_CLOSE   )MA_C_PR=Pr_Cl;
  if(MA_C_Price==PRICE_LOW     )MA_C_PR=Pr_Lo;
  if(MA_C_Price==PRICE_MEDIAN  )MA_C_PR=Pr_ME;
  if(MA_C_Price==PRICE_TYPICAL )MA_C_PR=Pr_TY;
  if(MA_C_Price==PRICE_WEIGHTED)MA_C_PR=Pr_WE;
  
  MA_C=iMA(_Symbol,_Period,MA_C_Period,0,MA_C_Method,MA_C_PR,i);
  
  C = MA_C * MAtoOpZ;
  
  if(AutoMulti==true)MAcount++;}


// Zuweisung MA_D
if(MA_D_Period<1)MA_D=1.0;
if(MA_D_Period>=1){
  if(MA_D_Price==PRICE_HIGH    )MA_D_PR=Pr_Hi;
  if(MA_D_Price==PRICE_OPEN    )MA_D_PR=Pr_Op;
  if(MA_D_Price==PRICE_CLOSE   )MA_D_PR=Pr_Cl;
  if(MA_D_Price==PRICE_LOW     )MA_D_PR=Pr_Lo;
  if(MA_D_Price==PRICE_MEDIAN  )MA_D_PR=Pr_ME;
  if(MA_D_Price==PRICE_TYPICAL )MA_D_PR=Pr_TY;
  if(MA_D_Price==PRICE_WEIGHTED)MA_D_PR=Pr_WE;
  
  MA_D=iMA(_Symbol,_Period,MA_D_Period,0,MA_D_Method,MA_D_PR,i);
  
  D = MA_D * MAtoOpZ;
  
  if(AutoMulti==true)MAcount++;}


// Zuweisung MA_E
if(MA_E_Period<1)MA_E=1.0;
if(MA_E_Period>=1){
  if(MA_E_Price==PRICE_HIGH    )MA_E_PR=Pr_Hi;
  if(MA_E_Price==PRICE_OPEN    )MA_E_PR=Pr_Op;
  if(MA_E_Price==PRICE_CLOSE   )MA_E_PR=Pr_Cl;
  if(MA_E_Price==PRICE_LOW     )MA_E_PR=Pr_Lo;
  if(MA_E_Price==PRICE_MEDIAN  )MA_E_PR=Pr_ME;
  if(MA_E_Price==PRICE_TYPICAL )MA_E_PR=Pr_TY;
  if(MA_E_Price==PRICE_WEIGHTED)MA_E_PR=Pr_WE;
  
  MA_E=iMA(_Symbol,_Period,MA_E_Period,0,MA_E_Method,MA_E_PR,i);
  
  E = MA_E * MAtoOpZ;
  
  if(AutoMulti==true)MAcount++;}


// Zuweisung Price MA_F
if(MA_F_Period<1)MA_F=1.0;
if(MA_F_Period>=1){
  if(MA_F_Price==PRICE_HIGH    )MA_F_PR=Pr_Hi;
  if(MA_F_Price==PRICE_OPEN    )MA_F_PR=Pr_Op;
  if(MA_F_Price==PRICE_CLOSE   )MA_F_PR=Pr_Cl;
  if(MA_F_Price==PRICE_LOW     )MA_F_PR=Pr_Lo;
  if(MA_F_Price==PRICE_MEDIAN  )MA_F_PR=Pr_ME;
  if(MA_F_Price==PRICE_TYPICAL )MA_F_PR=Pr_TY;
  if(MA_F_Price==PRICE_WEIGHTED)MA_F_PR=Pr_WE;
  
  MA_F=iMA(_Symbol,_Period,MA_F_Period,0,MA_F_Method,MA_F_PR,i);
  
  F = MA_F * MAtoOpZ;
  
  if(AutoMulti==true)MAcount++;}


// Zuweisung Price G
if(MA_G_Period<1)MA_G=1.0;
if(MA_G_Period>=1){
  if(MA_G_Price==PRICE_HIGH    )MA_G_PR=Pr_Hi;
  if(MA_G_Price==PRICE_OPEN    )MA_G_PR=Pr_Op;
  if(MA_G_Price==PRICE_CLOSE   )MA_G_PR=Pr_Cl;
  if(MA_G_Price==PRICE_LOW     )MA_G_PR=Pr_Lo;
  if(MA_G_Price==PRICE_MEDIAN  )MA_G_PR=Pr_ME;
  if(MA_G_Price==PRICE_TYPICAL )MA_G_PR=Pr_TY;
  if(MA_G_Price==PRICE_WEIGHTED)MA_G_PR=Pr_WE;
  
  MA_G=iMA(_Symbol,_Period,MA_G_Period,0,MA_G_Method,MA_G_PR,i);
  
  G = MA_G * MAtoOpZ;
  
  if(AutoMulti==true)MAcount++;}


// Zuweisung Price H
if(MA_H_Period<1)MA_H=1.0;
if(MA_H_Period>=1){
  if(MA_H_Price==PRICE_HIGH    )MA_H_PR=Pr_Hi;
  if(MA_H_Price==PRICE_OPEN    )MA_H_PR=Pr_Op;
  if(MA_H_Price==PRICE_CLOSE   )MA_H_PR=Pr_Cl;
  if(MA_H_Price==PRICE_LOW     )MA_H_PR=Pr_Lo;
  if(MA_H_Price==PRICE_MEDIAN  )MA_H_PR=Pr_ME;
  if(MA_H_Price==PRICE_TYPICAL )MA_H_PR=Pr_TY;
  if(MA_H_Price==PRICE_WEIGHTED)MA_H_PR=Pr_WE;
  
  MA_H=iMA(_Symbol,_Period,MA_H_Period,0,MA_H_Method,MA_H_PR,i);
  
  H = MA_H * MAtoOpZ;
  
  if(AutoMulti==true)MAcount++;}


//=============================================================================================================
// M A s x M A s
//=============================================================================================================
MAmMA=A*B*C*D*E*F*G*H;
//=============================================================================================================
// ( M A s * M A s ) / D I V
//=============================================================================================================
MAmMA_div = MAmMA / MAs_div;
//=============================================================================================================
// A U T O   M U L T I ?
//=============================================================================================================
// ?
if(AutoMulti==true){

  Print("AutoMulti Zum Testen aus");
}


MmM_Mul = MAmMA_div * Multi;

//=============================================================================================================
// B U F F E R   Z U W E I S U N G
//=============================================================================================================


BUF_EightMAmMAdV[i] = MmM_Mul / MAtoOpZ;




//=============================================================================================================
// E N D E   F U N K T I O N E N
//=============================================================================================================
}
return(NULL);}