//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#property description "Portfolio Modeller"
#property description "Advanced synthetic optimization and analysis"
#property description "Transcendreamer"
#property strict
#include <Math\Alglib\alglib.mqh>
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#define MAX_SYMBOLS 32
#define MAX_LINES 512
#define FONTNAME "Verdana"
#define FONTSIZE 9
#define SPACING 15
#define XMARGIN 5
#define YMARGIN 25
#define EQUAL '='
#define SPACE ' '
#define NARROW 1
#define BOLD 2
#define HISTOGRAM 2
#define COLOR_INTERVAL clrRed
#define COLOR_FILTER clrMagenta
#define COLOR_BID_ASK clrRed
#define COLOR_MODEL clrRed
#define CLICK_PIXELS 1
#define KEY_LEFT 188
#define KEY_RIGHT 190
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#property indicator_separate_window
#property indicator_buffers MAX_LINES
#property indicator_plots MAX_LINES
#property indicator_level1 0
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
input  string           ______GENERAL______="______GENERAL______";
input  string           Portfolio_Name="";
input  string           Portfolio_Formula="";
enum   ENUM_MODE        {formula,decomposition,consolidation,import,terminal,
                         basic28,fours35,threes35,fours105,threes420,twos210,indices
                        };
input  ENUM_MODE        Generation_Type=fours35;
input  string           Import_File="";

input  string           ______SCALING______="______SCALING______";
input  bool             Downscaling_Total=true;
input  double           Multiplicator_Total=1;
input  double           Portfolio_Value=0;

input  string           ______MODEL______="______MODEL______";
enum   ENUM_METHOD      {fixed,spread,trend,oscillator,hybrid,root,exponent,
                         fitting,principal,antiprincipal,volatility
                        };
input  ENUM_METHOD      Model_Type=fixed;
input  double           Model_Growth=0;
input  double           Model_Amplitude=0;
input  double           Model_Cycles=0;
input  double           Model_Phase=0;
input  bool             Model_Absolute=false;
input  bool             Model_Backward=false;
input  double           Target_RMSE=0;

input  string           ______PERIOD______="______PERIOD______";
input  ENUM_TIMEFRAMES  Timeframe=PERIOD_D1;
input  bool             Use_Time=false;
input  datetime         Start_Time=D'2012.01.01 00:00';
input  datetime         Finish_Time=D'2035.01.01 00:00';
input  int              History_Shift=100;
input  int              Optimization_Length=200;
input  bool             Movable_Lines=false;
input  int              Jumping_Bars=1;

input  string           ______LIMITS______="______LIMITS______";
input  int              Limit_History=1000;
input  int              Limit_Forward=1000;
input  int              Limit_Model=100;
input  int              Request_Bars=2000;

input  string           ______TIMING______="______TIMING______";
input  int              Delay_Seconds=0;
input  int              Sync_Seconds=60;
input  int              Timer_Seconds=0;

input  string           ______FILTERS______="______FILTERS______";
enum   ENUM_FILTER      {disabled,high_low,RMSE_min,RMSE_max,manual};
input  ENUM_FILTER      Filter_Type=disabled;
input  int              Filter_Shift=-10;
enum   ENUM_SIGN        {null,positive,negative};
input  ENUM_SIGN        Inversion_Mode=null;
input  int              Highest_From=1;
input  int              Highest_To=1;
input  int              Lowest_From=1;
input  int              Lowest_To=1;
input  ENUM_SIGN        Position_Highest=positive;
input  ENUM_SIGN        Position_Lowest=positive;
input  int              RMSE_Selection=1;
input  int              Manual_Selection=0;

input  string           ______ANALYSIS______="______ANALYSIS______";
input  int              Main_Period=0;
input  int              Fast_Period=0;
input  int              Slow_Period=0;
enum   ENUM_CHANNELS    {empty,standard,envelopes,transcendent,confidence1,confidence2,corridor,deviation};
input  ENUM_CHANNELS    Channels_Type=empty;
input  double           Channel_Size=2;
enum   ENUM_SIGNALS     {normal,zscore,MACD,WPR};
input  ENUM_SIGNALS     Signal_Transformation=normal;
input  int              Signal_Period=0;

input  string           ______EXPORT______="______EXPORT______";
input  string           CSV_Export_File="";
input  string           CSV_Separator=";";

#ifdef __MQL4__
input  string           ______OHLC______="______OHLC______";
input  bool             OHLC_Offline_Chart=false;
input  ENUM_TIMEFRAMES  Data_Timeframe=PERIOD_M1;
input  int              Chart_Timeframe=2;
input  double           Price_Start=100000;
#endif

input  string           ______CHART______="______CHART______";
input  double           Chart_Grid_Size=0;
input  bool             Realistic_Total=false;
input  bool             Draw_Histogram=false;
input  bool             Draw_Markers=false;
input  bool             Hide_Model=false;
input  bool             Hide_Total=false;
input  bool             Hide_By_Filter=false;
input  bool             Hide_Stream=false;
input  bool             Hide_Zero_Lots=false;
input  bool             Hide_Text_Data=false;
input  int              Text_Indent=0;
input  ENUM_BASE_CORNER Text_Corner=CORNER_LEFT_UPPER;

input  string           ______COLORS______="______COLORS______";
input  color            Main_Color=clrMagenta;
input  color            Signal_Color=clrRed;
input  int              Colors_Offset=96;

input  string           ______OTHER______="______OTHER______";
enum   ENUM_BID_ASK     {none,single,longs,shorts};
input  ENUM_BID_ASK     Show_Bid_Ask=none;
input  double           Commission_Rate=0;
input  string           Chart_Currency="USD";
input  int              Lots_Digits=2;
input  string           FX_Prefix="";
input  string           FX_Postfix="";
input  bool             Print_Details=false;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool     error;
long     chart;
int      window;
ulong    file_position;
string   acc_currency;
datetime saved_time;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool mode_stream;
ENUM_BID_ASK mode_spread;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#ifdef __MQL4__
bool     OHLC_mode;
int      OHLC_handle;
long     OHLC_chart;
#endif
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int      variables,points,components;
int      num_symbols,num_combos,dim_size,num_model,num_total,num_first;
int      num_main,num_slow,num_fast,num_upper,num_lower,num_zscore,num_macd;
int      index_start,index_finish,index_filter;
int      bar_start,bar_finish,bar_filter,bar_trading;
int      draw_begin,draw_end,model_begin,model_end;
datetime time_start,time_finish,time_filter;
double   scale_total,scale_model;
double   bar_range,total_shift;
double   sum_spread,sum_margin,sum_comms,sum_value;
double   rmse,range,rmse2range;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string   COMBINATIONS[MAX_LINES];
string   SYMBOLS[MAX_SYMBOLS];
double   LOTS[MAX_SYMBOLS];
double   MODEL[],ROOTS[];
double   VALUE[MAX_SYMBOLS],RMSE[MAX_LINES];
color    COLORS[MAX_LINES];
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
struct   MASSIVE
  {
   int               total,sign,position;
   int               pointer[MAX_SYMBOLS];
   double            lot[MAX_SYMBOLS];
  };
MASSIVE  PORTFOLIOS[MAX_LINES];
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
struct   STREAM
  {
   double            buffer[];
  };
STREAM   BUFFERS[MAX_LINES];
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
struct   CACHE
  {
   string            symbol;
   double            equity[],data[];
   double            opening,filter;
   double            value;
  };
CACHE    DATA[MAX_SYMBOLS];
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnInit()
  {
   mode_spread=Show_Bid_Ask;
   mode_stream=Hide_Stream;

   SetupCombinations();
   SetupBuffers();

#ifdef __MQL4__
   FindOHLC();
#endif

   if(Timer_Seconds>0)
      EventSetTimer(Timer_Seconds);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   CleanAll();
   if(Timer_Seconds>0)
      EventKillTimer();
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
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[])
  {

   ArraySetAsSeries(time,true);

   if(time[0]!=saved_time && TimeCurrent()>=time[0]+Delay_Seconds)
     {
      UpdateFullChart();
      saved_time=time[0];
     }
   else
     {
      UpdateLastBar();
     }

   return(rates_total);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTimer()
  {
   UpdateFullChart();
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void UpdateFullChart()
  {

   error=false;
   Print(Portfolio_Name+": Starting portfolio calculation...");

   CleanAll();

   SetupCombinations();
   SetupSymbols();

#ifdef __MQL5__
   RequestData();
#endif
   SetupIntervals();
   CalculateEquity();

   for(int n=1; n<=num_combos; n++)
      CalculateOptimization(n);

   CalculateFilters();
   CalculateSummarization();
   CalculateScaling();

   for(int n=1; n<=num_combos; n++)
      DrawPortfolio(n,true);
   DrawPortfolio(num_total,true);

   DrawModel();
   DrawIndicators(true);

   UpdateFormula();
   UpdateStatistics();

   HideByFilter();
   DrawChartGrid();
   UpdateStatus();
   ChartRedraw(chart);

   ExportCSV();

#ifdef __MQL4__
   PrepareOHLC();
   GenerateOHLC(true);
   RefreshOHLC(true);
#endif

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void UpdateLastBar()
  {
   for(int n=1; n<=num_combos; n++)
      DrawPortfolio(n,false);
   DrawPortfolio(num_total,false);
   DrawIndicators(false);
   UpdateStatus();
#ifdef __MQL4__
   GenerateOHLC(false);
   RefreshOHLC(false);
#endif
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetupBuffers()
  {

   IndicatorSetInteger(INDICATOR_DIGITS,2);
   IndicatorSetString(INDICATOR_SHORTNAME,"Portfolio Modeller");

   error=false;
   chart=ChartID();
   window=ChartWindowFind();
   acc_currency=AccountInfoString(ACCOUNT_CURRENCY);

#ifdef __MQL4__
   OHLC_chart=0;
   OHLC_mode=OHLC_Offline_Chart;
#endif

   if(Portfolio_Name=="")
     {
      Alert("Empty portfolio name!");
      error=true;
      return;
     }

   SetPlotName(num_first,Hide_Total?NULL:"Portfolio "+Portfolio_Name);
   SetPlotName(num_total,Hide_Total?NULL:"Total portfolio");
   SetPlotName(num_model,Hide_Model?NULL:"Model function");

   SetIndexBuffer(num_first,BUFFERS[num_first].buffer);
   SetIndexBuffer(num_total,BUFFERS[num_total].buffer);
   SetIndexBuffer(num_model,BUFFERS[num_model].buffer);

   SetPlotStyle(num_first,Hide_Total?DRAW_NONE:Draw_Histogram?DRAW_HISTOGRAM:DRAW_LINE,STYLE_SOLID,NARROW,Main_Color);
   SetPlotStyle(num_total,Hide_Total?DRAW_NONE:Draw_Markers?DRAW_ARROW:DRAW_LINE,STYLE_SOLID,mode_stream?NARROW:BOLD,Main_Color);
   SetPlotStyle(num_model,Hide_Model?DRAW_NONE:DRAW_LINE,STYLE_SOLID,NARROW,COLOR_MODEL);

   int offset=Colors_Offset%128;
   MathSrand(Colors_Offset);

   for(int n=1; n<=num_combos; n++)
     {
      int r=MathRand()%128+offset;
      int g=MathRand()%128+offset;
      int b=MathRand()%128+offset;
      COLORS[n]=color(r+g*256+b*65536);
      SetIndexBuffer(n,BUFFERS[n].buffer);
      SetPlotName(n,mode_stream?NULL:"Portfolio #"+string(n));
      SetPlotStyle(n,DRAW_LINE,STYLE_SOLID,NARROW,COLORS[n]);
     }

   SetPlotName(num_main,(Main_Period==0)?NULL:"Main Average");
   SetPlotName(num_fast,(Fast_Period==0)?NULL:"Fast Average");
   SetPlotName(num_slow,(Slow_Period==0)?NULL:"Slow Average");
   SetPlotName(num_upper,(Channels_Type==empty)?NULL:"Upper Boundary");
   SetPlotName(num_lower,(Channels_Type==empty)?NULL:"Lower Boundary");
   SetPlotName(num_zscore,NULL);
   SetPlotName(num_macd,NULL);

   SetIndexBuffer(num_main,BUFFERS[num_main].buffer,(Main_Period==0)?INDICATOR_CALCULATIONS:INDICATOR_DATA);
   SetIndexBuffer(num_fast,BUFFERS[num_fast].buffer,(Fast_Period==0)?INDICATOR_CALCULATIONS:INDICATOR_DATA);
   SetIndexBuffer(num_slow,BUFFERS[num_slow].buffer,(Slow_Period==0)?INDICATOR_CALCULATIONS:INDICATOR_DATA);
   SetIndexBuffer(num_upper,BUFFERS[num_upper].buffer,(Channels_Type==empty)?INDICATOR_CALCULATIONS:INDICATOR_DATA);
   SetIndexBuffer(num_lower,BUFFERS[num_lower].buffer,(Channels_Type==empty)?INDICATOR_CALCULATIONS:INDICATOR_DATA);
   SetIndexBuffer(num_zscore,BUFFERS[num_zscore].buffer,INDICATOR_CALCULATIONS);
   SetIndexBuffer(num_macd,BUFFERS[num_macd].buffer,INDICATOR_CALCULATIONS);

   SetPlotStyle(num_main,DRAW_LINE,STYLE_DOT,Draw_Histogram?HISTOGRAM:NARROW,Signal_Color);
   SetPlotStyle(num_fast,DRAW_LINE,STYLE_DOT,Draw_Histogram?HISTOGRAM:NARROW,Signal_Color);
   SetPlotStyle(num_slow,DRAW_LINE,STYLE_DOT,Draw_Histogram?HISTOGRAM:NARROW,Signal_Color);
   SetPlotStyle(num_upper,DRAW_LINE,STYLE_DOT,Draw_Histogram?HISTOGRAM:NARROW,Signal_Color);
   SetPlotStyle(num_lower,DRAW_LINE,STYLE_DOT,Draw_Histogram?HISTOGRAM:NARROW,Signal_Color);
   SetPlotStyle(num_zscore,DRAW_NONE,STYLE_DOT,Draw_Histogram?HISTOGRAM:NARROW,Signal_Color);
   SetPlotStyle(num_macd,DRAW_NONE,STYLE_DOT,Draw_Histogram?HISTOGRAM:NARROW,Signal_Color);

   if(Signal_Transformation!=normal)
     {
      SetPlotStyle(num_total,DRAW_NONE,STYLE_DOT,NARROW,Signal_Color);
      for(int n=1; n<=num_combos; n++)
         SetPlotName(n,NULL);
     }

   for(int n=dim_size; n<MAX_LINES; n++)
      SetPlotName(n,NULL);

   for(int i=0; i<MAX_LINES; i++)
      ArraySetAsSeries(BUFFERS[i].buffer,true);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetPlotStyle(int i,int type,int style,int width,color colour)
  {
#ifdef __MQL4__
   SetIndexStyle(i,type,style,width,colour);
#else
   PlotIndexSetInteger(i,PLOT_DRAW_TYPE,type);
   PlotIndexSetInteger(i,PLOT_LINE_STYLE,style);
   PlotIndexSetInteger(i,PLOT_LINE_WIDTH,width);
   PlotIndexSetInteger(i,PLOT_LINE_COLOR,colour);
#endif
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetPlotName(int i,string name)
  {
#ifdef __MQL4__
   SetIndexLabel(i,name);
#else
   PlotIndexSetString(i,PLOT_LABEL,name);
#endif
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CleanAll()
  {

   ZeroMemory(PORTFOLIOS);
   ZeroMemory(DATA);
   ZeroMemory(SYMBOLS);
   ZeroMemory(LOTS);

   for(int n=ObjectsTotal(chart,window,-1); n>=1; n--)
     {
      string name=ObjectName(chart,n-1,window);
      if(StringFind(name,"Formula-label-"+Portfolio_Name+"-")!=-1)
         ObjectDelete(chart,name);
      if(StringFind(name,"Data-label-"+Portfolio_Name+"-")!=-1)
         ObjectDelete(chart,name);
      if(StringFind(name,"Grid-level-"+Portfolio_Name+":")!=-1)
         ObjectDelete(chart,name);
      if(StringFind(name,"Z-level-upper-"+Portfolio_Name)!=-1)
         ObjectDelete(chart,name);
      if(StringFind(name,"Z-level-lower-"+Portfolio_Name)!=-1)
         ObjectDelete(chart,name);
      if(StringFind(name,"Portfolio-bid-"+Portfolio_Name)!=-1)
         ObjectDelete(chart,name);
      if(StringFind(name,"Portfolio-ask-"+Portfolio_Name)!=-1)
         ObjectDelete(chart,name);
      if(StringFind(name,"Portfolio-last-"+Portfolio_Name)!=-1)
         ObjectDelete(chart,name);
      if(StringFind(name,"CHART_"+Portfolio_Name)!=-1)
         ObjectDelete(chart,name);
     }

   if(!Movable_Lines)
     {
      ObjectDelete(chart,"Line-start-bar-"+Portfolio_Name);
      ObjectDelete(chart,"Line-finish-bar-"+Portfolio_Name);
      ObjectDelete(chart,"Line-filter-bar-"+Portfolio_Name);
     }

   GlobalVariableDel("Portfolio-"+Portfolio_Name);
   GlobalVariableDel("Quality-"+Portfolio_Name);
   GlobalVariableDel("Model-"+Portfolio_Name);
   GlobalVariableDel("Upper-"+Portfolio_Name);
   GlobalVariableDel("Lower-"+Portfolio_Name);
   GlobalVariableDel("Main-"+Portfolio_Name);
   GlobalVariableDel("Fast-"+Portfolio_Name);
   GlobalVariableDel("Slow-"+Portfolio_Name);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,const long &lparam,const double &dparam,const string &sparam)
  {

//---

   if(id==CHARTEVENT_KEYDOWN)
      while(Movable_Lines)
        {
         int shift_bars=0;
         if(int(lparam)==KEY_LEFT)
            shift_bars=+Jumping_Bars;
         if(int(lparam)==KEY_RIGHT)
            shift_bars=-Jumping_Bars;
         if(shift_bars==0)
            break;

         bar_start   =shift_bars+iBarShift(_Symbol,_Period,time_start);
         bar_finish  =shift_bars+iBarShift(_Symbol,_Period,time_finish);
         bar_filter  =shift_bars+iBarShift(_Symbol,_Period,time_filter);

         time_start  =iTime(_Symbol,_Period,bar_start);
         time_finish =iTime(_Symbol,_Period,bar_finish);
         time_filter =iTime(_Symbol,_Period,bar_filter);

         ObjectSetInteger(chart,"Line-start-bar-"+Portfolio_Name,OBJPROP_TIME,0,time_start);
         ObjectSetInteger(chart,"Line-finish-bar-"+Portfolio_Name,OBJPROP_TIME,0,time_finish);
         ObjectSetInteger(chart,"Line-filter-bar-"+Portfolio_Name,OBJPROP_TIME,0,time_filter);

         UpdateFullChart();
         break;
        }

//---

   if(id==CHARTEVENT_OBJECT_DRAG)
      if(StringFind(sparam,"-bar-"+Portfolio_Name)!=-1)
        {
         if((TerminalInfoInteger(TERMINAL_KEYSTATE_SHIFT)&0x80)!=0)
            while(Movable_Lines)
              {
               datetime oldTime=0;
               if(sparam=="Line-start-bar-"+Portfolio_Name)
                  oldTime=time_start;
               else
                  if(sparam=="Line-finish-bar-"+Portfolio_Name)
                     oldTime=time_finish;
                  else
                     if(sparam=="Line-filter-bar-"+Portfolio_Name)
                        oldTime=time_filter;
                     else
                        break;

               datetime newTime=(datetime)ObjectGetInteger(chart,sparam,OBJPROP_TIME,0);
               int oldBar=iBarShift(_Symbol,_Period,oldTime);
               int newBar=iBarShift(_Symbol,_Period,newTime);
               int shiftBars=newBar-oldBar;

               if(shiftBars==0)
                  break;

               bar_start   =iBarShift(_Symbol,_Period,time_start)+shiftBars;
               bar_finish  =iBarShift(_Symbol,_Period,time_finish)+shiftBars;
               bar_filter  =iBarShift(_Symbol,_Period,time_filter)+shiftBars;

               time_start  =iTime(_Symbol,_Period,bar_start);
               time_finish =iTime(_Symbol,_Period,bar_finish);
               time_filter =iTime(_Symbol,_Period,bar_filter);

               ObjectSetInteger(chart,"Line-start-bar-"+Portfolio_Name,OBJPROP_TIME,0,time_start);
               ObjectSetInteger(chart,"Line-finish-bar-"+Portfolio_Name,OBJPROP_TIME,0,time_finish);
               ObjectSetInteger(chart,"Line-filter-bar-"+Portfolio_Name,OBJPROP_TIME,0,time_filter);

               break;
              }
         UpdateFullChart();
        }

//---

   if(id==CHARTEVENT_OBJECT_CLICK)
      if(StringFind(sparam,"Data-label-"+Portfolio_Name)!=-1)
        {
         if(mode_spread==none)
           {
            mode_spread=longs;
            UpdateStatus();
           }
         else
            if(mode_spread==longs)
              {
               mode_spread=shorts;
               UpdateStatus();
              }
            else
               if(mode_spread==shorts)
                 {
                  mode_spread=single;
                  UpdateStatus();
                 }
               else
                  if(mode_spread==single)
                    {
                     mode_spread=none;
                     UpdateStatus();
                    }
        }

//---

   if(id==CHARTEVENT_OBJECT_CLICK)
      if(StringFind(sparam,"Formula-label-"+Portfolio_Name)!=-1)
        {
         mode_stream=!mode_stream;
         num_model=mode_stream?num_combos+1:0;
         num_total=mode_stream?0:num_combos+1;
         UpdateFullChart();
        }

//---

   if(id==CHARTEVENT_CLICK)
      if((TerminalInfoInteger(TERMINAL_KEYSTATE_CONTROL)&0x80)!=0)
        {
         double price1,price2;
         datetime time;
         int subwindow=0;

         ChartXYToTimePrice(chart,(int)lparam,(int)dparam-CLICK_PIXELS,subwindow,time,price1);
         ChartXYToTimePrice(chart,(int)lparam,(int)dparam+CLICK_PIXELS,subwindow,time,price2);

         if(subwindow==window)
           {
            int bar=iBarShift(NULL,0,time);
            bool empty_select=true;
            for(int n=1; n<=num_combos; n++)
               if(BUFFERS[n].buffer[bar]>=price2 && BUFFERS[n].buffer[bar]<price1)
                 {
                  SetPlotStyle(n,DRAW_LINE,STYLE_SOLID,NARROW,COLORS[n]);
                  empty_select=false;
                 }
               else
                  SetPlotStyle(n,DRAW_LINE,STYLE_SOLID,NARROW,clrNONE);
            if(empty_select)
               for(int n=1; n<=num_combos; n++)
                  SetPlotStyle(n,DRAW_LINE,STYLE_SOLID,NARROW,COLORS[n]);
           }
        }

//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void RequestData()
  {
   double data1[];
   double data2[];
   for(int k=0; k<components; k++)
      while(true)
        {
         int n=CopyClose(DATA[k].symbol,Timeframe,0,Request_Bars,data1);
         int m=CopyClose(DATA[k].symbol,_Period,0,Request_Bars,data2);
         if(m==Request_Bars)
            if(n==Request_Bars)
               break;
         //string name="CHART_"+Portfolio_Name+"_"+DATA[k].symbol;
         //ObjectCreate(chart,name,OBJ_CHART,window,0,0);
         //ObjectSetInteger(chart,name,OBJPROP_XOFFSET,1);
         //ObjectSetInteger(chart,name,OBJPROP_YOFFSET,1);
         //ObjectSetInteger(chart,name,OBJPROP_XSIZE,1);
         //ObjectSetInteger(chart,name,OBJPROP_YSIZE,1);
         //ObjectSetInteger(chart,name,OBJPROP_PERIOD,_Period);
         //ObjectSetString(chart,name,OBJPROP_SYMBOL,DATA[k].symbol);
        }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetupIntervals()
  {

   if(error)
      return;

   bool reset_lines=false;
   bool use_filter=(Filter_Type==high_low);

//---

   if(Movable_Lines)
     {

      time_start      =(datetime)ObjectGetInteger(chart,"Line-start-bar-"+Portfolio_Name,OBJPROP_TIME,0);
      time_finish     =(datetime)ObjectGetInteger(chart,"Line-finish-bar-"+Portfolio_Name,OBJPROP_TIME,0);
      time_filter     =(datetime)ObjectGetInteger(chart,"Line-filter-bar-"+Portfolio_Name,OBJPROP_TIME,0);

      if(!use_filter)
         time_filter=time_finish;

      index_start    =iBarShift(_Symbol,Timeframe,time_start);
      index_finish   =iBarShift(_Symbol,Timeframe,time_finish);
      index_filter   =iBarShift(_Symbol,Timeframe,time_filter);

      if(time_start==0 || time_finish==0 || time_filter==0)
         reset_lines=true;
     }

//---

   if(!Movable_Lines || reset_lines)
     {
      index_start    =Use_Time?iBarShift(_Symbol,Timeframe,Start_Time):History_Shift+Optimization_Length;
      index_finish   =Use_Time?iBarShift(_Symbol,Timeframe,Finish_Time):History_Shift;
      index_filter   =index_finish+Filter_Shift;

      if(!use_filter)
         index_filter=index_finish;

      if(index_start<0)
         index_start=0;

      if(index_finish<0)
         index_finish=0;

      if(index_filter<0)
         index_filter=0;

      time_start  =iTime(_Symbol,Timeframe,index_start);
      time_finish =iTime(_Symbol,Timeframe,index_finish);
      time_filter =iTime(_Symbol,Timeframe,index_filter);
     }

//---

   datetime time_current=time_start;
   int base_time=PeriodSeconds(Timeframe);
   while(time_current<=time_finish && time_current>=time_start)
     {
      bool check=true;
      for(int k=0; k<components; k++)
         if(iBarShift(DATA[k].symbol,Timeframe,time_current,true)==-1)
            check=false;
      if(check)
        {
         time_start=time_current;
         break;
        }
      time_current+=base_time;
     }

//---

   time_current=time_finish;
   while(time_current<=time_finish && time_current>=time_start)
     {
      bool check=true;
      for(int k=0; k<components; k++)
         if(iBarShift(DATA[k].symbol,Timeframe,time_current,true)==-1)
            check=false;
      if(check)
        {
         time_finish=time_current;
         break;
        }
      time_current-=base_time;
     }

//---

   index_finish=iBarShift(_Symbol,Timeframe,time_finish);
   index_start =iBarShift(_Symbol,Timeframe,time_start);

   if(index_start<=index_finish || time_start>=time_finish)
     {
      Alert("Incorrect interval settings!");
      error=true;
      return;
     }

//---

   PlaceVertical("Line-start-bar-"+Portfolio_Name,time_start,COLOR_INTERVAL,STYLE_DASH,true,Movable_Lines,Movable_Lines);
   PlaceVertical("Line-finish-bar-"+Portfolio_Name,time_finish,COLOR_INTERVAL,STYLE_DASH,true,Movable_Lines,Movable_Lines);
   PlaceVertical("Line-filter-bar-"+Portfolio_Name,time_filter,COLOR_FILTER,STYLE_DOT,true,Movable_Lines,Movable_Lines);

   long periods=use_filter?OBJ_ALL_PERIODS:OBJ_NO_PERIODS;
   ObjectSetInteger(chart,"Line-filter-bar-"+Portfolio_Name,OBJPROP_TIMEFRAMES,periods);

   ObjectSetString(chart,"Line-start-bar-"+Portfolio_Name,OBJPROP_TEXT,TimeToString(time_start));
   ObjectSetString(chart,"Line-finish-bar-"+Portfolio_Name,OBJPROP_TEXT,TimeToString(time_finish));
   ObjectSetString(chart,"Line-filter-bar-"+Portfolio_Name,OBJPROP_TEXT,TimeToString(time_filter));

//---

   int bars       =Bars(_Symbol,_Period);
   bar_start      =iBarShift(_Symbol,_Period,time_start);
   bar_finish     =iBarShift(_Symbol,_Period,time_finish);
   bar_filter     =iBarShift(_Symbol,_Period,time_filter);
   bar_trading    =MathMin(bar_finish,bar_filter);
   draw_begin     =MathMin(bar_start+Limit_History,bars-1);
   draw_end       =MathMax(bar_finish-Limit_Forward,0);
   model_begin    =MathMin(bar_start+Limit_Model,bars-1);
   model_end      =MathMax(bar_finish-Limit_Model,0);

//---

   if(bar_start==-1 || bar_finish==-1 || bar_filter==-1)
     {
      Alert(time_start,"   :   ",time_finish);
      Alert(time_start,"   :   ",time_finish);
      Alert("Data buffers not ready!");
      error=true;
      return;
     }

//---

   if(iTime(_Symbol,_Period,bars-1)<=time_start)
      bar_range=bar_start-bar_finish;
   else
      bar_range=PeriodSeconds(Timeframe)/PeriodSeconds(_Period)*(index_start-index_finish);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetupSymbols()
  {
   if(error)
      return;

   components=0;

   for(int n=1; n<=num_combos; n++)
     {
      ArrayInitialize(PORTFOLIOS[n].pointer,-1);
      SetupFormula(COMBINATIONS[n]);

      for(int i=0; i<num_symbols; i++)
         for(int k=0; k<MAX_SYMBOLS; k++)
           {

            if(SYMBOLS[i]==NULL)
               break;
            if(SYMBOLS[i]=="")
               break;

            if(SYMBOLS[i]==DATA[k].symbol)
              {
               PORTFOLIOS[n].pointer[i]=k;
               PORTFOLIOS[n].lot[i]+=LOTS[i];
               PORTFOLIOS[n].total++;
               break;
              }

            if(DATA[k].symbol==NULL)
              {
               DATA[k].symbol=SYMBOLS[i];
               PORTFOLIOS[n].pointer[i]=k;
               PORTFOLIOS[n].lot[i]=LOTS[i];
               PORTFOLIOS[n].total++;
               components++;
               break;
              }

           }

      if(PORTFOLIOS[n].total==0)
        {
         Alert("Incorrect portfolio combination: ",COMBINATIONS[n]);
         error=true;
         return;
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetupFormula(string formula)
  {

   variables=0;

   string lines[],parts[];
#ifdef __MQL4__
   formula=StringTrimLeft(formula);
   formula=StringTrimRight(formula);
#else
   StringTrimLeft(formula);
   StringTrimRight(formula);
#endif
   variables=StringSplit(formula,SPACE,lines);

   for(int i=0; i<variables; i++)
     {

      if(lines[i]=="")
        {
         Alert("Incorrect portfolio formula: \""+formula+"\"");
         error=true;
         return;
        }

      int n=StringSplit(lines[i],EQUAL,parts);

      if(n==2)
        {
         SYMBOLS[i]=parts[0];
         LOTS[i]=StringToDouble(parts[1]);
        }
      else
         if(n==1)
           {
            SYMBOLS[i]=parts[0];
            LOTS[i]=1;
           }
         else
           {
            Alert("Incorrect portfolio formula: \""+formula+"\"");
            error=true;
            return;
           }

      if(Generation_Type!=consolidation && Generation_Type!=terminal)
         SYMBOLS[i]=FX_Prefix+SYMBOLS[i]+FX_Postfix;

      if(SymbolInfoDouble(SYMBOLS[i],SYMBOL_POINT)==0)
        {
         Alert("Missing symbol in Market Watch: ",SYMBOLS[i]);
         error=true;
         return;
        }

     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateEquity()
  {

   if(error)
      return;

   points=0;
   int base_time=PeriodSeconds(Timeframe);
   int max_points=int((time_finish-time_start)/base_time)+1;
   datetime current_time=Model_Backward?time_finish:time_start;
   if(Model_Backward)
      base_time*=-1;

   for(int k=0; k<components; k++)
      ArrayResize(DATA[k].equity,max_points);

   while(current_time<=time_finish && current_time>=time_start)
     {
      points++;
      for(int k=0; k<components; k++)
        {
         int shift=iBarShift(DATA[k].symbol,Timeframe,current_time,true);
         if(shift==-1)
           {
            points--;
            break;
           }
         double closing=iClose(DATA[k].symbol,Timeframe,shift);
         double value=ContractValue(DATA[k].symbol,current_time,Timeframe,Chart_Currency);
         if(points==1)
            DATA[k].opening=closing;
         DATA[k].equity[points-1]=(closing-DATA[k].opening)*value;
        }
      current_time+=base_time;
     }

   for(int k=0; k<components; k++)
     {
      int shift=iBarShift(DATA[k].symbol,Timeframe,time_filter);
      double close=iClose(DATA[k].symbol,Timeframe,shift);
      DATA[k].value=ContractValue(DATA[k].symbol,time_filter,Timeframe,Chart_Currency);
      DATA[k].filter=(close-DATA[k].opening)*DATA[k].value;
     }

   for(int k=0; k<components; k++)
     {
      ArraySetAsSeries(DATA[k].data,true);
      ArrayResize(DATA[k].data,draw_begin+1);
     }

   for(int j=draw_begin; j>=draw_end; j--)
      for(int k=0; k<components; k++)
        {
         datetime time=iTime(_Symbol,_Period,j);
         int shift=iBarShift(DATA[k].symbol,_Period,time);
         double value=ContractValue(DATA[k].symbol,time,PERIOD_CURRENT,Chart_Currency);
         double closing=iClose(DATA[k].symbol,_Period,shift);
         DATA[k].data[j]=(closing-DATA[k].opening)*value;
        }

   if(points<5)
     {
      Alert("Insufficient history data!");
      error=true;
      return;
     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateOptimization(int number)
  {

   if(error)
      return;

   variables=PORTFOLIOS[number].total;
   ArrayResize(MODEL,points);
   ArrayResize(ROOTS,variables);

//---

   if(Model_Type==fixed)
     {
      for(int i=0; i<variables; i++)
         ROOTS[i]=PORTFOLIOS[number].lot[i];
     }

//---

   if(Model_Type==spread)
     {
      int info,i,j;
      int roots=variables-1;
      CLinearModelShell LM;
      CLRReportShell AR;
      CLSFitReportShell report;
      CMatrixDouble MATRIX(points,variables);

      for(i=0; i<variables; i++)
         for(j=0; j<points; j++)
            MATRIX[j].Set(i,DATA[PORTFOLIOS[number].pointer[i]].equity[j]);

      CAlglib::LRBuildZ(MATRIX,points,variables-1,info,LM,AR);

      if(info<0)
        {
         Alert("Error in regression model!");
         error=true;
         return;
        }

      CAlglib::LRUnpack(LM,ROOTS,roots);
      ArrayResize(ROOTS,variables);
      ROOTS[variables-1]=-1;
     }

//---

   if(Model_Type==trend)
     {
      int info,i,j;
      CLinearModelShell LM;
      CLRReportShell AR;
      CMatrixDouble MATRIX(points,variables+1);

      if(Model_Growth==0)
        {
         Alert("Zero model growth!");
         error=true;
         return;
        }

      for(j=0; j<points; j++)
        {
         double x=(double)j/(points-1)-Model_Phase;
         if(Model_Absolute)
            x=MathAbs(x);
         MODEL[j]=Model_Growth*x;
        }

      double shift=-MODEL[0];
      if(shift!=0)
         for(j=0; j<points; j++)
            MODEL[j]+=shift;

      for(i=0; i<variables; i++)
         for(j=0; j<points; j++)
            MATRIX[j].Set(i,DATA[PORTFOLIOS[number].pointer[i]].equity[j]);

      for(j=0; j<points; j++)
         MATRIX[j].Set(variables,MODEL[j]);

      CAlglib::LRBuildZ(MATRIX,points,variables,info,LM,AR);

      if(info<0)
        {
         Alert("Error in regression model!");
         error=true;
         return;
        }

      CAlglib::LRUnpack(LM,ROOTS,variables);
     }

//---

   if(Model_Type==root)
     {
      int info,i,j;
      CLinearModelShell LM;
      CLRReportShell AR;
      CMatrixDouble MATRIX(points,variables+1);

      if(Model_Growth==0)
        {
         Alert("Zero model growth!");
         error=true;
         return;
        }

      for(j=0; j<points; j++)
        {
         double x=(double)j/(points-1)-Model_Phase;
         int sign=(int)MathSign(x);
         if(Model_Absolute)
            sign=1;
         MODEL[j]=sign*Model_Growth*MathSqrt(MathAbs(x));
        }

      double shift=-MODEL[0];
      if(shift!=0)
         for(j=0; j<points; j++)
            MODEL[j]+=shift;

      for(i=0; i<variables; i++)
         for(j=0; j<points; j++)
            MATRIX[j].Set(i,DATA[PORTFOLIOS[number].pointer[i]].equity[j]);

      for(j=0; j<points; j++)
         MATRIX[j].Set(variables,MODEL[j]);

      CAlglib::LRBuildZ(MATRIX,points,variables,info,LM,AR);

      if(info<0)
        {
         Alert("Error in regression model!");
         error=true;
         return;
        }

      CAlglib::LRUnpack(LM,ROOTS,variables);
     }

//---

   if(Model_Type==exponent)
     {
      int info,i,j;
      CLinearModelShell LM;
      CLRReportShell AR;
      CMatrixDouble MATRIX(points,variables+1);

      if(Model_Growth==0)
        {
         Alert("Zero model growth!");
         error=true;
         return;
        }

      for(j=0; j<points; j++)
        {
         double x=(double)j/(points-1)*Model_Cycles-Model_Phase;
         if(Model_Absolute)
            x=MathAbs(x);
         MODEL[j]=Model_Growth*MathExp(x);
        }

      double shift=-MODEL[0];
      if(shift!=0)
         for(j=0; j<points; j++)
            MODEL[j]+=shift;

      for(i=0; i<variables; i++)
         for(j=0; j<points; j++)
            MATRIX[j].Set(i,DATA[PORTFOLIOS[number].pointer[i]].equity[j]);

      for(j=0; j<points; j++)
         MATRIX[j].Set(variables,MODEL[j]);

      CAlglib::LRBuildZ(MATRIX,points,variables,info,LM,AR);

      if(info<0)
        {
         Alert("Error in regression model!");
         error=true;
         return;
        }

      CAlglib::LRUnpack(LM,ROOTS,variables);
     }

//---

   if(Model_Type==oscillator)
     {
      int info,i,j;
      CLinearModelShell LM;
      CLRReportShell AR;
      CMatrixDouble MATRIX(points,variables+1);

      if(Model_Cycles==0)
        {
         Alert("Zero model cycles!");
         error=true;
         return;
        }

      if(Model_Amplitude==0)
        {
         Alert("Zero model amplitude!");
         error=true;
         return;
        }

      for(j=0; j<points; j++)
        {
         double x=(double)j/(points-1)*Model_Cycles-Model_Phase;
         if(Model_Absolute)
            x=MathAbs(x);
         MODEL[j]=Model_Amplitude*MathSin(2*M_PI*x);
        }

      double shift=-MODEL[0];
      if(shift!=0)
         for(j=0; j<points; j++)
            MODEL[j]+=shift;

      for(i=0; i<variables; i++)
         for(j=0; j<points; j++)
            MATRIX[j].Set(i,DATA[PORTFOLIOS[number].pointer[i]].equity[j]);

      for(j=0; j<points; j++)
         MATRIX[j].Set(variables,MODEL[j]);

      CAlglib::LRBuildZ(MATRIX,points,variables,info,LM,AR);

      if(info<0)
        {
         Alert("Error in regression model!");
         error=true;
         return;
        }

      CAlglib::LRUnpack(LM,ROOTS,variables);
     }

//---

   if(Model_Type==hybrid)
     {
      int info,i,j;
      CLinearModelShell LM;
      CLRReportShell AR;
      CMatrixDouble MATRIX(points,variables+1);

      if(Model_Growth==0)
        {
         Alert("Zero model growth!");
         error=true;
         return;
        }

      if(Model_Cycles==0)
        {
         Alert("Zero model cycles!");
         error=true;
         return;
        }

      if(Model_Amplitude==0)
        {
         Alert("Zero model amplitude!");
         error=true;
         return;
        }

      for(j=0; j<points; j++)
        {
         double x=(double)j/(points-1)*Model_Cycles-Model_Phase;
         if(Model_Absolute)
            x=MathAbs(x);
         MODEL[j]=Model_Amplitude*MathSin(2*M_PI*x)+Model_Growth*x;
        }

      double shift=-MODEL[0];
      if(shift!=0)
         for(j=0; j<points; j++)
            MODEL[j]+=shift;

      for(i=0; i<variables; i++)
         for(j=0; j<points; j++)
            MATRIX[j].Set(i,DATA[PORTFOLIOS[number].pointer[i]].equity[j]);

      for(j=0; j<points; j++)
         MATRIX[j].Set(variables,MODEL[j]);

      CAlglib::LRBuildZ(MATRIX,points,variables,info,LM,AR);

      if(info<0)
        {
         Alert("Error in regression model!");
         error=true;
         return;
        }

      CAlglib::LRUnpack(LM,ROOTS,variables);
     }

//---

   if(Model_Type==fitting)
     {
      int info,i,j;
      CLSFitReportShell report;
      CMatrixDouble MATRIX(points,variables);
      CMatrixDouble CONSTRAIN(1,variables+1);

      CONSTRAIN[0].Set(variables,1);

      for(i=0; i<variables; i++)
         CONSTRAIN[0].Set(i,1);

      for(i=0; i<variables; i++)
         for(j=0; j<points; j++)
            MATRIX[j].Set(i,DATA[PORTFOLIOS[number].pointer[i]].equity[j]);

      for(j=0; j<points; j++)
         MODEL[j]=0;

      CAlglib::LSFitLinearC(MODEL,MATRIX,CONSTRAIN,points,variables,1,info,ROOTS,report);

      if(info<0)
        {
         Alert("Error in linear fitting model!");
         error=true;
         return;
        }
     }

//---

   if(Model_Type==principal)
     {
      int info,i,j;
      double VAR[];
      ArrayResize(VAR,variables);
      CMatrixDouble MATRIX(points,variables);
      CMatrixDouble VECTOR(variables,variables);

      for(i=0; i<variables; i++)
         for(j=0; j<points; j++)
            MATRIX[j].Set(i,DATA[PORTFOLIOS[number].pointer[i]].equity[j]);

      CAlglib::PCABuildBasis(MATRIX,points,variables,info,VAR,VECTOR);

      if(info<0)
        {
         Alert("Error in principal component model!");
         error=true;
         return;
        }

      for(i=0; i<variables; i++)
         ROOTS[i]=VECTOR[i][variables-1];
     }

//---

   if(Model_Type==antiprincipal)
     {
      int info,i,j;
      double VAR[];
      ArrayResize(VAR,variables);
      CMatrixDouble MATRIX(points,variables);
      CMatrixDouble VECTOR(variables,variables);

      for(i=0; i<variables; i++)
         for(j=0; j<points; j++)
            MATRIX[j].Set(i,DATA[PORTFOLIOS[number].pointer[i]].equity[j]);

      CAlglib::PCABuildBasis(MATRIX,points,variables,info,VAR,VECTOR);

      if(info<0)
        {
         Alert("Error in principal component model!");
         error=true;
         return;
        }

      for(i=0; i<variables; i++)
         ROOTS[i]=VECTOR[i][0];
     }

//---

   if(Model_Type==volatility)
     {
      if(Model_Amplitude==0)
        {
         Alert("Zero model amplitude!");
         error=true;
         return;
        }

      for(int i=0; i<variables; i++)
        {
         double mean=0;
         double stdev=0;

         for(int j=0; j<points; j++)
            mean+=DATA[PORTFOLIOS[number].pointer[i]].equity[j];
         mean/=points;

         for(int j=0; j<points; j++)
            stdev+=MathPow(mean-DATA[PORTFOLIOS[number].pointer[i]].equity[j],2);
         stdev=MathSqrt(stdev/points);

         ROOTS[i]=Model_Amplitude/stdev;
         if(PORTFOLIOS[number].lot[i]<0)
            ROOTS[i]*=-1;
        }
     }

//---

   if(Filter_Type==RMSE_max || Filter_Type==RMSE_min || Target_RMSE>0)
     {
      double sumsq=0,count=0;
      for(int j=0; j<points; j++)
        {
         double equity=0;
         for(int i=0; i<variables; i++)
            equity+=DATA[PORTFOLIOS[number].pointer[i]].equity[j]*ROOTS[i];
         sumsq+=MathPow(equity-MODEL[j],2);
         count++;
        }
      RMSE[number]=MathSqrt(sumsq/count);
     }

//---

   if(Target_RMSE>0)
     {
      for(int i=0; i<variables; i++)
         ROOTS[i]=ROOTS[i]*Target_RMSE/RMSE[number];
      RMSE[number]=Target_RMSE;
     }

//---

   for(int i=0; i<variables; i++)
      PORTFOLIOS[number].lot[i]=ROOTS[i];

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateFilters()
  {

   if(error)
      return;

//---

   if(Print_Details)
      for(int n=1; n<=num_combos; n++)
        {
         string formula="";
         variables=PORTFOLIOS[n].total;
         for(int i=0; i<variables; i++)
           {
            string symbol=DATA[PORTFOLIOS[n].pointer[i]].symbol;
            string lots=DoubleToString(PORTFOLIOS[n].lot[i],Lots_Digits);
            formula+=(symbol+CharToString(EQUAL)+lots+CharToString(SPACE));
           }
         Print(Portfolio_Name+": Portfolio #",n,": ",formula);
        }

//---

   if(Filter_Type==disabled)
     {
      for(int n=1; n<=num_combos; n++)
         PORTFOLIOS[n].position=+1;
      for(int n=1; n<=num_combos; n++)
         PORTFOLIOS[n].sign=+1;
      if(Print_Details)
         Print(Portfolio_Name+": All portfolios included as positive");
      return;
     }

//---

   if(Filter_Type==manual)
     {
      if(Manual_Selection>num_combos || Manual_Selection<1)
        {
         Alert("Incorrect manual selection!");
         error=true;
         return;
        }

      for(int n=1; n<=num_combos; n++)
        {
         PORTFOLIOS[n].position=0;
         PORTFOLIOS[n].sign=0;
        }

      PORTFOLIOS[Manual_Selection].position=+1;
      PORTFOLIOS[Manual_Selection].sign=+1;

      if(Print_Details)
         Print("Portfolio #",Manual_Selection," included as positive");

      return;
     }

//---

   if(Filter_Type==RMSE_max || Filter_Type==RMSE_min)
     {
      if(RMSE_Selection>num_combos || RMSE_Selection<1)
        {
         Alert("Incorrect RMSE selection!");
         error=true;
         return;
        }

      double rmse_data[][2];
      ArrayResize(rmse_data,num_combos);
      ArrayInitialize(rmse_data,0);

      for(int n=1; n<=num_combos; n++)
        {
         if(Filter_Type==RMSE_min)
            rmse_data[n-1][0]=+RMSE[n];
         else
            rmse_data[n-1][0]=-RMSE[n];
         rmse_data[n-1][1]=n;
        }

      ArraySort(rmse_data);

      for(int n=1; n<=num_combos; n++)
        {
         PORTFOLIOS[n].position=0;
         PORTFOLIOS[n].sign=1;
        }

      for(int m=1; m<=RMSE_Selection; m++)
        {
         int n=(int)rmse_data[m-1][1];
         PORTFOLIOS[n].position=+1;
         PORTFOLIOS[n].sign=+1;
         if(Print_Details)
            Print(Portfolio_Name+": Portfolio #",n," included positive by RMSE");
        }

      return;
     }

//---

   if(Filter_Type==high_low)
     {
      if(Highest_From>num_combos || Highest_From<1 || Highest_To>num_combos || Highest_To<1 ||
         Lowest_From>num_combos  || Lowest_From<1  || Lowest_To>num_combos  || Lowest_To<1)
        {
         Alert("Incorrect filter selection!");
         error=true;
         return;
        }

      int filter[];
      int invert[];
      double equity[][2];

      ArrayResize(equity,num_combos);
      ArrayResize(filter,num_combos);
      ArrayResize(invert,num_combos);

      ArrayInitialize(filter,0);
      ArrayInitialize(invert,1);
      ArrayInitialize(equity,0);

      for(int n=1; n<=num_combos; n++)
        {
         equity[n-1][0]=0;
         equity[n-1][1]=n;
         variables=PORTFOLIOS[n].total;
         for(int i=0; i<variables; i++)
           {
            double lot=PORTFOLIOS[n].lot[i];
            int pointer=PORTFOLIOS[n].pointer[i];
            equity[n-1][0]+=lot*DATA[pointer].filter;
           }
        }

      if(Inversion_Mode==positive)
         for(int n=1; n<=num_combos; n++)
            if(equity[n-1][0]<0)
              {
               invert[n-1]*=-1;
               equity[n-1][0]*=-1;
               if(Print_Details)
                  Print(Portfolio_Name+": Portfolio #",n," inverted to positive");
              }

      if(Inversion_Mode==negative)
         for(int n=1; n<=num_combos; n++)
            if(equity[n-1][0]>0)
              {
               invert[n-1]*=-1;
               equity[n-1][0]*=-1;
               if(Print_Details)
                  Print(Portfolio_Name+": Portfolio #",n," inverted to negative");
              }

      ArraySort(equity);

      if(Position_Lowest==positive)
         for(int m=Lowest_From; m<=Lowest_To; m++)
           {
            int n=(int)equity[m-1][1];
            filter[n-1]=+1;
            if(Print_Details)
               Print(Portfolio_Name+": Portfolio #",n," selected as positive");
           }

      if(Position_Lowest==negative)
         for(int m=Lowest_From; m<=Lowest_To; m++)
           {
            int n=(int)equity[m-1][1];
            filter[n-1]=-1;
            if(Print_Details)
               Print(Portfolio_Name+": Portfolio #",n," selected as negative");
           }

      if(Position_Highest==positive)
         for(int m=Highest_From; m<=Highest_To; m++)
           {
            int n=(int)equity[num_combos-m][1];
            filter[n-1]=+1;
            if(Print_Details)
               Print(Portfolio_Name+": Portfolio #",n," selected as positive");
           }

      if(Position_Highest==negative)
         for(int m=Highest_From; m<=Highest_To; m++)
           {
            int n=(int)equity[num_combos-m][1];
            filter[n-1]=-1;
            if(Print_Details)
               Print(Portfolio_Name+": Portfolio #",n," selected as negative");
           }

      for(int n=1; n<=num_combos; n++)
        {
         PORTFOLIOS[n].sign=invert[n-1];
         PORTFOLIOS[n].position=filter[n-1];
        }
     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateSummarization()
  {

   if(error)
      return;

//---

   ArrayInitialize(PORTFOLIOS[num_total].pointer,-1);
   ArrayInitialize(PORTFOLIOS[num_total].lot,0);
   PORTFOLIOS[num_total].total=0;
   PORTFOLIOS[num_total].sign=+1;
   PORTFOLIOS[num_total].position=+1;

//---

   for(int n=1; n<=num_combos; n++)
      for(int i=0; i<num_symbols; i++)
         for(int k=0; k<MAX_SYMBOLS; k++)
           {
            int pointer=PORTFOLIOS[n].pointer[i];
            double lot=PORTFOLIOS[n].lot[i];
            double sign=PORTFOLIOS[n].sign;
            double position=PORTFOLIOS[n].position;

            if(pointer==-1)
               break;
            if(position==0)
               break;

            if(PORTFOLIOS[num_total].pointer[k]==pointer)
              {
               PORTFOLIOS[num_total].lot[k]+=lot*position*sign;
               break;
              }

            if(PORTFOLIOS[num_total].pointer[k]==-1)
              {
               PORTFOLIOS[num_total].total++;
               PORTFOLIOS[num_total].pointer[k]=pointer;
               PORTFOLIOS[num_total].lot[k]=lot*position*sign;
               break;
              }
           }

//---

   variables=0;
   string formula="";

//---

   for(int i=0; i<MAX_SYMBOLS; i++)
     {
      int pointer=PORTFOLIOS[num_total].pointer[i];
      if(pointer==-1)
         continue;

      LOTS[variables]=PORTFOLIOS[num_total].lot[i];
      SYMBOLS[variables]=DATA[pointer].symbol;
      VALUE[variables]=DATA[pointer].value;

      string lots=DoubleToString(LOTS[variables],Lots_Digits);
      formula+=SYMBOLS[variables]+CharToString(EQUAL)+lots+CharToString(SPACE);
      variables++;
     }

//---

   PORTFOLIOS[num_total].total=variables;
   if(Print_Details)
      Print(Portfolio_Name+": Summarized portfolio: ",formula);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateScaling()
  {

   if(error)
      return;

//---

   if(Downscaling_Total)
     {
      double sum_volume=0;
      for(int n=1; n<=num_combos; n++)
         if(PORTFOLIOS[n].position!=0)
            sum_volume++;
      if(sum_volume>0)
         for(int i=0; i<variables; i++)
           {
            LOTS[i]/=sum_volume;
            PORTFOLIOS[num_total].lot[i]=LOTS[i];
           }
      else
         Alert("Empty portfolio summarization!");
      if(Print_Details)
         if(sum_volume>0)
            Print(Portfolio_Name+": Downscaling by volume: ",sum_volume);
     }

//---

   if(Portfolio_Value!=0)
     {
      double value_total=0;

      for(int i=0; i<variables; i++)
         value_total+=iClose(SYMBOLS[i],Timeframe,index_filter)*VALUE[i]*MathAbs(LOTS[i]);

      if(value_total==0)
         Alert("Zero portfolio value!");

      else
        {
         double scale_check=MathAbs(Portfolio_Value)/value_total;
         double min_diff=DBL_MAX;

         for(int m=1; m<=20; m++)
           {
            value_total=0;
            for(int i=0; i<variables; i++)
               value_total+=iClose(SYMBOLS[i],Timeframe,index_finish)*VALUE[i]*
                            NormalizeDouble(MathAbs(LOTS[i]*scale_check),Lots_Digits);

            double diff=value_total-MathAbs(Portfolio_Value);
            double abs_diff=MathAbs(diff);

            if(abs_diff<min_diff)
              {
               min_diff=abs_diff;
               scale_total=scale_check;
               scale_model=scale_check;
              }

            if(value_total==0)
               scale_check*=1.5;
            else
              {
               if(diff<0)
                  scale_check*=1.1;
               else
                  scale_check*=0.9;
              }
           }
        }

      if(Portfolio_Value<0)
        {
         scale_total*=-1;
         scale_model*=-1;
        }

      if(Print_Details)
         Print(Portfolio_Name+": Total scaling: ",scale_total);
     }

//---

   if(Portfolio_Value==0)
     {
      scale_total=Multiplicator_Total;
      scale_model=Multiplicator_Total;
      if(Print_Details)
         Print(Portfolio_Name+": Total scaling: ",scale_total);
     }

//---

   for(int n=1; n<=num_combos; n++)
      for(int i=0; i<PORTFOLIOS[n].total; i++)
         PORTFOLIOS[n].lot[i]=NormalizeDouble(PORTFOLIOS[n].lot[i]*scale_total,Lots_Digits);
   string formula="";

   for(int i=0; i<variables; i++)
     {
      LOTS[i]=NormalizeDouble(LOTS[i]*scale_total,Lots_Digits);
      PORTFOLIOS[num_total].lot[i]=LOTS[i];
      string lots=DoubleToString(LOTS[i],Lots_Digits);
      formula+=SYMBOLS[i]+CharToString(EQUAL)+lots+CharToString(SPACE);
     }

   Print(Portfolio_Name+": Finalized portfolio: ",formula);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void UpdateStatistics()
  {

   if(error)
      return;

//---

   double sumsq=0,count=0;
   for(int j=bar_start; j>=bar_finish; j--)
     {
      double x=BUFFERS[num_total].buffer[j];
      double m=BUFFERS[num_model].buffer[j];
      if(x==EMPTY_VALUE)
         continue;
      if(m==EMPTY_VALUE)
         m=0;
      sumsq+=MathPow(x-m,2);
      count++;
     }
   rmse=MathSqrt(sumsq/count);

//---

   double max=-DBL_MAX,min=DBL_MAX;
   for(int j=bar_start; j>=bar_finish; j--)
     {
      double x=BUFFERS[num_total].buffer[j];
      if(x==EMPTY_VALUE)
         continue;
      if(x>max)
         max=x;
      if(x<min)
         min=x;
     }
   range=max-min;
   if(range!=0)
      rmse2range=rmse/range;

//---

   sum_spread=0;
   sum_margin=0;
   sum_comms=0;
   sum_value=0;

   for(int i=0; i<variables; i++)
     {

      sum_spread+=(SymbolInfoDouble(SYMBOLS[i],SYMBOL_ASK)-SymbolInfoDouble(SYMBOLS[i],SYMBOL_BID))
                  *VALUE[i]*MathAbs(LOTS[i]);

      sum_comms+=Commission_Rate/100*VALUE[i]*iClose(SYMBOLS[i],0,0)*MathAbs(LOTS[i]);

      sum_value+=VALUE[i]*iClose(SYMBOLS[i],0,0)*MathAbs(LOTS[i]);

#ifdef __MQL4__
      sum_margin+=MarketInfo(SYMBOLS[i],MODE_MARGINREQUIRED)*MathAbs(LOTS[i]);
#else
      sum_margin+=SymbolInfoDouble(SYMBOLS[i],SYMBOL_MARGIN_INITIAL)*MathAbs(LOTS[i]);
#endif

     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawPortfolio(int number,bool all_bars)
  {

   if(error)
      return;

//---

   if(all_bars)
     {
      variables=PORTFOLIOS[number].total;
      ArrayInitialize(BUFFERS[number].buffer,EMPTY_VALUE);

      for(int j=draw_begin; j>=draw_end; j--)
        {
         double profit=0;
         for(int i=0; i<variables; i++)
           {
            double lot=PORTFOLIOS[number].lot[i];
            double equity=DATA[PORTFOLIOS[number].pointer[i]].data[j];
            int sign=PORTFOLIOS[number].sign;
            profit+=equity*lot*sign;
           }
         BUFFERS[number].buffer[j]=profit;
        }

      if(Realistic_Total)
         if(number==num_total)
           {
            total_shift=BUFFERS[number].buffer[bar_trading];
            for(int j=draw_begin; j>=draw_end; j--)
               BUFFERS[number].buffer[j]-=total_shift;
           }
     }

//---

   else
      if(number==num_total)
        {
         if(draw_end>0)
            return;

         //---

         if(Sync_Seconds>0)
           {
            datetime now_time=TimeCurrent();
            for(int i=0; i<variables; i++)
               if(now_time-SymbolInfoInteger(SYMBOLS[i],SYMBOL_TIME)>Sync_Seconds)
                 {
                  BUFFERS[number].buffer[0]=EMPTY_VALUE;
                  return;
                 }
           }

         //---

         double profit=0;
         for(int i=0; i<variables; i++)
           {
            string symbol=DATA[PORTFOLIOS[number].pointer[i]].symbol;
            double closing=SymbolInfoDouble(symbol,SYMBOL_BID);
            double opening=DATA[PORTFOLIOS[number].pointer[i]].opening;
            double lot=PORTFOLIOS[number].lot[i];
            profit+=(closing-opening)*VALUE[i]*lot;
           }

         //---

         BUFFERS[number].buffer[0]=profit;
         if(Realistic_Total)
            if(number==num_total)
               BUFFERS[number].buffer[0]-=total_shift;
        }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawModel()
  {

   if(error)
      return;
   if(bar_range==0)
      return;
   ArrayInitialize(BUFFERS[num_model].buffer,EMPTY_VALUE);

//---

   for(int j=model_begin; j>=model_end; j--)
     {

      double model=0;
      if(Model_Type==fixed)
         model=0;
      if(Model_Type==spread)
         model=0;
      if(Model_Type==principal)
         model=0;
      if(Model_Type==antiprincipal)
         model=0;
      if(Model_Type==fitting)
         model=0;

      if(Model_Type==hybrid)
        {
         int bar_distance=Model_Backward?(j-bar_finish):(bar_start-j);
         double x=bar_distance/bar_range*Model_Cycles-Model_Phase;
         if(Model_Absolute)
            x=MathAbs(x);
         model=Model_Amplitude*MathSin(2*M_PI*x)+Model_Growth*x;
         model*=scale_model;
        }

      if(Model_Type==oscillator)
        {
         int bar_distance=Model_Backward?(j-bar_finish):(bar_start-j);
         double x=bar_distance/bar_range*Model_Cycles-Model_Phase;
         if(Model_Absolute)
            x=MathAbs(x);
         model=Model_Amplitude*MathSin(2*M_PI*x);
         model*=scale_model;
        }

      if(Model_Type==trend)
        {
         int bar_distance=Model_Backward?(j-bar_finish):(bar_start-j);
         double x=bar_distance/bar_range-Model_Phase;
         if(Model_Absolute)
            x=MathAbs(x);
         model=Model_Growth*x;
         model*=scale_model;
        }

      if(Model_Type==root)
        {
         int bar_distance=Model_Backward?(j-bar_finish):(bar_start-j);
         double x=bar_distance/bar_range-Model_Phase;
         int sign=(int)MathSign(x);
         if(Model_Absolute)
            sign=1;
         model=sign*Model_Growth*MathSqrt(MathAbs(x));
         model*=scale_model;
        }

      if(Model_Type==exponent)
        {
         int bar_distance=Model_Backward?(j-bar_finish):(bar_start-j);
         double x=bar_distance/bar_range*Model_Cycles-Model_Phase;
         if(Model_Absolute)
            x=MathAbs(x);
         model=Model_Growth*MathExp(x);
         model*=scale_model;
        }

      BUFFERS[num_model].buffer[j]=model;
     }

//---

   double model_shift=Model_Backward?
                      BUFFERS[num_model].buffer[bar_finish]:
                      BUFFERS[num_model].buffer[bar_start];

//---

   for(int j=model_begin; j>=model_end; j--)
      BUFFERS[num_model].buffer[j]-=model_shift;

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawIndicators(bool all_bars)
  {

   if(error)
      return;

//---

   if(!all_bars)
     {
      if(draw_end>0)
         return;
      draw_begin=0;
      draw_end=0;
     }
   else
     {
      ArrayInitialize(BUFFERS[num_main].buffer,EMPTY_VALUE);
      ArrayInitialize(BUFFERS[num_fast].buffer,EMPTY_VALUE);
      ArrayInitialize(BUFFERS[num_slow].buffer,EMPTY_VALUE);
      ArrayInitialize(BUFFERS[num_upper].buffer,EMPTY_VALUE);
      ArrayInitialize(BUFFERS[num_lower].buffer,EMPTY_VALUE);
      ArrayInitialize(BUFFERS[num_zscore].buffer,EMPTY_VALUE);
      ArrayInitialize(BUFFERS[num_macd].buffer,EMPTY_VALUE);
      ArrayInitialize(BUFFERS[num_first].buffer,EMPTY_VALUE);
     }

//---

   if(Signal_Transformation==normal)
      for(int j=draw_begin; j>=draw_end; j--)
         BUFFERS[num_first].buffer[j]=BUFFERS[num_total].buffer[j];

//---

   if(Signal_Transformation==MACD)
     {
      if(Signal_Period==0)
        {
         Alert("Zero signal period!");
         error=true;
         return;
        }

      int start_bar = all_bars ? draw_begin-(Signal_Period-1) : 0;

      for(int j=start_bar; j>=draw_end; j--)
        {
         if(BUFFERS[num_total].buffer[j]==EMPTY_VALUE)
            continue;

         double MA=0;
         for(int k=0; k<Signal_Period; k++)
            MA+=BUFFERS[num_total].buffer[j+k];

         MA/=Signal_Period;
         BUFFERS[num_first].buffer[j]=(BUFFERS[num_total].buffer[j]-MA);
        }
     }

//---

   if(Signal_Transformation==WPR)
     {
      if(Signal_Period==0)
        {
         Alert("Zero signal period!");
         error=true;
         return;
        }

      int start_bar = all_bars ? draw_begin-(Signal_Period-1) : 0;

      for(int j=start_bar; j>=draw_end; j--)
        {
         if(BUFFERS[num_total].buffer[j]==EMPTY_VALUE)
            continue;

         double max=-DBL_MAX,min=+DBL_MAX;

         for(int k=0; k<Signal_Period; k++)
           {
            if(BUFFERS[num_total].buffer[j+k]>max)
               max=BUFFERS[num_total].buffer[j+k];
            if(BUFFERS[num_total].buffer[j+k]<min)
               min=BUFFERS[num_total].buffer[j+k];
           }

         if(max-min!=0)
            BUFFERS[num_first].buffer[j]=(BUFFERS[num_total].buffer[j]-min)/(max-min);
        }
     }

//---

   if(Signal_Transformation==zscore)
     {
      if(Signal_Period==0)
        {
         Alert("Zero signal period!");
         error=true;
         return;
        }

      int start_bar = all_bars ? draw_begin-(Signal_Period-1) : 0;

      for(int j=start_bar; j>=draw_end; j--)
        {
         if(BUFFERS[num_total].buffer[j]==EMPTY_VALUE)
            continue;

         double MA=0,SD=0;
         for(int k=0; k<Signal_Period; k++)
            MA+=BUFFERS[num_total].buffer[j+k];
         MA/=Signal_Period;

         for(int k=0; k<Signal_Period; k++)
            SD+=MathPow(BUFFERS[num_total].buffer[j+k]-MA,2);
         SD=MathSqrt(SD/Signal_Period);

         if(SD!=0)
            BUFFERS[num_first].buffer[j]=(BUFFERS[num_total].buffer[j]-MA)/SD;
        }

      PlaceHorizontal("Z-level-upper-"+Portfolio_Name,+2,Signal_Color,STYLE_DOT,true,false,false);
      PlaceHorizontal("Z-level-lower-"+Portfolio_Name,-2,Signal_Color,STYLE_DOT,true,false,false);
     }

//---

   if(Main_Period>0)
     {
      int start_bar=draw_begin-(Main_Period-1);

      if(Signal_Transformation!=normal)
         start_bar-=(Signal_Period-1);

      if(!all_bars)
         start_bar=0;

      for(int j=start_bar; j>=draw_end; j--)
        {
         if(BUFFERS[num_first].buffer[j]==EMPTY_VALUE)
            continue;

         double MA=0;
         for(int k=0; k<Main_Period; k++)
            MA+=BUFFERS[num_first].buffer[j+k];

         MA/=Main_Period;
         BUFFERS[num_main].buffer[j]=MA;
        }
     }

//---

   if(Fast_Period>0)
     {
      int start_bar=draw_begin-(Fast_Period-1);

      if(Signal_Transformation!=normal)
         start_bar-=(Signal_Period-1);

      if(!all_bars)
         start_bar=0;

      for(int j=start_bar; j>=draw_end; j--)
        {
         if(BUFFERS[num_first].buffer[j]==EMPTY_VALUE)
            continue;

         double MA=0;
         for(int k=0; k<Fast_Period; k++)
            MA+=BUFFERS[num_first].buffer[j+k];

         MA/=Fast_Period;
         BUFFERS[num_fast].buffer[j]=MA;
        }
     }

//---

   if(Slow_Period>0)
     {
      int start_bar=draw_begin-(Slow_Period-1);

      if(Signal_Transformation!=normal)
         start_bar-=(Signal_Period-1);

      if(!all_bars)
         start_bar=0;

      for(int j=start_bar; j>=draw_end; j--)
        {
         if(BUFFERS[num_first].buffer[j]==EMPTY_VALUE)
            continue;

         double MA=0;
         for(int k=0; k<Slow_Period; k++)
            MA+=BUFFERS[num_first].buffer[j+k];

         MA/=Slow_Period;
         BUFFERS[num_slow].buffer[j]=MA;
        }
     }

//---

   if(Channels_Type==envelopes)
      if(Main_Period>0)
        {
         int start_bar=draw_begin-(Main_Period-1);

         if(Signal_Transformation!=normal)
            start_bar-=(Signal_Period-1);

         if(!all_bars)
            start_bar=0;

         for(int j=start_bar; j>=draw_end; j--)
           {
            if(BUFFERS[num_first].buffer[j]==EMPTY_VALUE)
               continue;
            double MA=BUFFERS[num_main].buffer[j];
            BUFFERS[num_upper].buffer[j]=MA+Channel_Size;
            BUFFERS[num_lower].buffer[j]=MA-Channel_Size;
           }
        }

//---

   if(Channels_Type==standard)
      if(Main_Period>0)
        {
         int start_bar=draw_begin-(Main_Period-1);

         if(Signal_Transformation!=normal)
            start_bar-=(Signal_Period-1);

         if(!all_bars)
            start_bar=0;

         for(int j=start_bar; j>=draw_end; j--)
           {
            if(BUFFERS[num_first].buffer[j]==EMPTY_VALUE)
               continue;
            double MA=BUFFERS[num_main].buffer[j];

            double SD=0;
            for(int k=0; k<Main_Period; k++)
               SD+=MathPow(BUFFERS[num_first].buffer[j+k]-MA,2);
            SD=MathSqrt(SD/Main_Period);

            BUFFERS[num_upper].buffer[j]=MA+SD*Channel_Size;
            BUFFERS[num_lower].buffer[j]=MA-SD*Channel_Size;
           }
        }

//---

   if(Channels_Type==transcendent)
      if(Main_Period>0)
        {
         int start_bar=draw_begin-(Main_Period-1);

         if(Signal_Transformation!=normal)
            start_bar-=(Signal_Period-1);

         if(!all_bars)
            start_bar=0;

         for(int j=start_bar; j>=draw_end; j--)
           {
            if(BUFFERS[num_first].buffer[j]==EMPTY_VALUE)
               continue;

            double MA=BUFFERS[num_main].buffer[j];
            double sum=0;

            for(int k=0; k<Main_Period-1; k++)
               sum+=MathAbs(BUFFERS[num_first].buffer[j+k]-BUFFERS[num_first].buffer[j+k+1]);
            double delta=sum/MathSqrt(Main_Period);

            BUFFERS[num_upper].buffer[j]=MA+delta*Channel_Size;
            BUFFERS[num_lower].buffer[j]=MA-delta*Channel_Size;
           }
        }

//---

   if(Channels_Type==confidence1 || Channels_Type==confidence2)
      if(all_bars)
        {
         double delta[];
         int sample=draw_begin-bar_finish;
         ArrayResize(delta,sample);

         for(int i=0; i<sample; i++)
            delta[i]=BUFFERS[num_first].buffer[bar_finish+i]-
                     BUFFERS[num_first].buffer[bar_finish+i+1];

         double mean=0;
         if(Channels_Type==confidence1)
           {
            for(int i=0; i<sample; i++)
               mean+=delta[i];
            mean/=sample;
           }

         double standard=0;
         for(int i=0; i<sample; i++)
            standard+=MathPow(delta[i]-mean,2);
         standard=MathSqrt(standard/sample);

         double b=(Signal_Transformation==normal)?BUFFERS[num_model].buffer[bar_finish]:0;

         for(int i=bar_finish; i>=draw_end; i--)
           {
            int x=bar_finish-i;
            BUFFERS[num_upper].buffer[i]=mean*x+standard*MathSqrt(x)*Channel_Size+b;
            BUFFERS[num_lower].buffer[i]=mean*x-standard*MathSqrt(x)*Channel_Size+b;
           }

         b=BUFFERS[num_model].buffer[bar_start];

         for(int i=bar_start; i<=draw_begin; i++)
           {
            int x=i-bar_start;
            BUFFERS[num_upper].buffer[i]=-mean*x+standard*MathSqrt(x)*Channel_Size+b;
            BUFFERS[num_lower].buffer[i]=-mean*x-standard*MathSqrt(x)*Channel_Size+b;
           }
        }

//---

   if(Channels_Type==corridor)
      if(!Hide_Model)
        {
         for(int j=model_begin; j>=model_end; j--)
           {
            double line=BUFFERS[num_model].buffer[j];
            BUFFERS[num_upper].buffer[j]=line+Channel_Size;
            BUFFERS[num_lower].buffer[j]=line-Channel_Size;
           }
        }

//---

   if(Channels_Type==deviation)
      if(!Hide_Model)
        {

         double sumsq=0,count=0;

         for(int j=bar_start; j>=bar_finish; j--)
           {
            double x=BUFFERS[num_total].buffer[j];
            double m=BUFFERS[num_model].buffer[j];
            if(x!=EMPTY_VALUE)
               if(m!=EMPTY_VALUE)
                 {
                  sumsq+=MathPow(x-m,2);
                  count++;
                 }
           }

         double dev=MathSqrt(sumsq/count);

         for(int j=model_begin; j>=model_end; j--)
           {
            double line=BUFFERS[num_model].buffer[j];
            BUFFERS[num_upper].buffer[j]=line+Channel_Size*dev;
            BUFFERS[num_lower].buffer[j]=line-Channel_Size*dev;
           }

        }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void UpdateStatus()
  {

   if(error)
      return;

   double last=BUFFERS[num_first].buffer[0];
   double prev=BUFFERS[num_first].buffer[1];

   sum_spread=0;
   for(int i=0; i<variables; i++)
      sum_spread+=(SymbolInfoDouble(SYMBOLS[i],SYMBOL_ASK)-SymbolInfoDouble(SYMBOLS[i],SYMBOL_BID))
                  *VALUE[i]*MathAbs(LOTS[i]);

   if(!Hide_Text_Data)
     {
      int line_shift=YMARGIN;
      string text=("Name: "+Portfolio_Name);
      string name=("Data-label-"+Portfolio_Name+"-1");
      PlaceLabel(name,Text_Indent+XMARGIN,line_shift,Text_Corner,text,Main_Color,FONTNAME,FONTSIZE);

      line_shift+=SPACING;
      text=("Range: "+DoubleToString(range,2)+" "+Chart_Currency);
      name=("Data-label-"+Portfolio_Name+"-2");
      PlaceLabel(name,Text_Indent+XMARGIN,line_shift,Text_Corner,text,Main_Color,FONTNAME,FONTSIZE);

      line_shift+=SPACING;
      text=("RMSE: "+DoubleToString(rmse,2)+" "+Chart_Currency);
      name=("Data-label-"+Portfolio_Name+"-3");
      PlaceLabel(name,Text_Indent+XMARGIN,line_shift,Text_Corner,text,Main_Color,FONTNAME,FONTSIZE);

      line_shift+=SPACING;
      text=("RMSE/range: "+DoubleToString(rmse2range,4));
      name=("Data-label-"+Portfolio_Name+"-4");
      PlaceLabel(name,Text_Indent+XMARGIN,line_shift,Text_Corner,text,Main_Color,FONTNAME,FONTSIZE);

      line_shift+=SPACING;
      text=("Value: "+DoubleToString(sum_value,2)+" "+Chart_Currency);
      name=("Data-label-"+Portfolio_Name+"-5");
      PlaceLabel(name,Text_Indent+XMARGIN,line_shift,Text_Corner,text,Main_Color,FONTNAME,FONTSIZE);

      line_shift+=SPACING;
      text=("Margin: "+DoubleToString(sum_margin,2)+" "+acc_currency);
      name=("Data-label-"+Portfolio_Name+"-6");
      PlaceLabel(name,Text_Indent+XMARGIN,line_shift,Text_Corner,text,Main_Color,FONTNAME,FONTSIZE);

      line_shift+=SPACING;
      text=("Commission: "+DoubleToString(sum_comms,2)+" "+Chart_Currency);
      name=("Data-label-"+Portfolio_Name+"-7");
      PlaceLabel(name,Text_Indent+XMARGIN,line_shift,Text_Corner,text,Main_Color,FONTNAME,FONTSIZE);

      line_shift+=SPACING;
      text=("Spread: "+DoubleToString(sum_spread,2)+" "+Chart_Currency);
      name=("Data-label-"+Portfolio_Name+"-8");
      PlaceLabel(name,Text_Indent+XMARGIN,line_shift,Text_Corner,text,Main_Color,FONTNAME,FONTSIZE);
     }

   if(mode_spread==longs)
     {
      ObjectDelete(chart,"Portfolio-last-"+Portfolio_Name);
      PlaceHorizontal("Portfolio-ask-"+Portfolio_Name,last+sum_spread+sum_comms,COLOR_BID_ASK,STYLE_SOLID,false,false,false);
      PlaceHorizontal("Portfolio-bid-"+Portfolio_Name,last,COLOR_BID_ASK,STYLE_SOLID,false,false,false);
     }

   if(mode_spread==shorts)
     {
      ObjectDelete(chart,"Portfolio-last-"+Portfolio_Name);
      PlaceHorizontal("Portfolio-ask-"+Portfolio_Name,last,COLOR_BID_ASK,STYLE_SOLID,false,false,false);
      PlaceHorizontal("Portfolio-bid-"+Portfolio_Name,last-sum_spread-sum_comms,COLOR_BID_ASK,STYLE_SOLID,false,false,false);
     }

   if(mode_spread==single)
     {
      ObjectDelete(chart,"Portfolio-bid-"+Portfolio_Name);
      ObjectDelete(chart,"Portfolio-last-"+Portfolio_Name);
      PlaceHorizontal("Portfolio-last-"+Portfolio_Name,last,COLOR_BID_ASK,STYLE_SOLID,false,false,false);
     }

   if(mode_spread==none)
     {
      ObjectDelete(chart,"Portfolio-ask-"+Portfolio_Name);
      ObjectDelete(chart,"Portfolio-bid-"+Portfolio_Name);
      ObjectDelete(chart,"Portfolio-last-"+Portfolio_Name);
     }

   GlobalVariableSet("Portfolio-"+Portfolio_Name,last);
   GlobalVariableSet("Quality-"+Portfolio_Name,rmse2range);

   if(!Hide_Model)
      GlobalVariableSet("Model-"+Portfolio_Name,BUFFERS[num_model].buffer[0]);
   if(Main_Period>0)
      GlobalVariableSet("Main-"+Portfolio_Name,BUFFERS[num_main].buffer[0]);
   if(Fast_Period>0)
      GlobalVariableSet("Fast-"+Portfolio_Name,BUFFERS[num_fast].buffer[0]);
   if(Slow_Period>0)
      GlobalVariableSet("Slow-"+Portfolio_Name,BUFFERS[num_slow].buffer[0]);

   if(Channels_Type!=empty)
     {
      GlobalVariableSet("Upper-"+Portfolio_Name,BUFFERS[num_upper].buffer[0]);
      GlobalVariableSet("Lower-"+Portfolio_Name,BUFFERS[num_lower].buffer[0]);
     }

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double ContractValue(string symbol,datetime time,ENUM_TIMEFRAMES period,string currency)
  {
   double value=SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE);
   string quote=SymbolInfoString(symbol,SYMBOL_CURRENCY_PROFIT);
   if(value==0)
      value=1;

   if(quote!="USD")
     {
      string direct=(FX_Prefix+quote+"USD"+FX_Postfix);
      if(SymbolInfoDouble(direct,SYMBOL_POINT)!=0)
        {
         int shift=iBarShift(direct,period,time);
         double price=iClose(direct,period,shift);
         if(price>0)
            value*=price;
        }
      else
        {
         string indirect=FX_Prefix+"USD"+quote+FX_Postfix;
         int shift=iBarShift(indirect,period,time);
         double price=iClose(indirect,period,shift);
         if(price>0)
            value/=price;
        }
     }

   if(currency!="USD")
     {
      string direct=(FX_Prefix+currency+"USD"+FX_Postfix);
      if(SymbolInfoDouble(direct,SYMBOL_POINT)!=0)
        {
         int shift=iBarShift(direct,period,time);
         double price=iClose(direct,period,shift);
         if(price>0)
            value/=price;
        }
      else
        {
         string indirect=(FX_Prefix+"USD"+currency+FX_Postfix);
         int shift=iBarShift(indirect,period,time);
         double price=iClose(indirect,period,shift);
         if(price>0)
            value*=price;
        }
     }

   return(value);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void UpdateFormula()
  {
   if(!Hide_Text_Data)
      for(int i=0,c=0; i<variables; i++)
         if(!Hide_Zero_Lots || LOTS[i]!=0)
           {
            c++;

            string text=SYMBOLS[i]+
                        CharToString(EQUAL)+
                        (LOTS[i]>=0 ? "+" : "-")+
                        DoubleToString(MathAbs(LOTS[i]),Lots_Digits);

            string name="Formula-label-"+Portfolio_Name+"-"+(string)(i+1);

            PlaceLabel(name,Text_Indent+XMARGIN,YMARGIN+(c+8)*SPACING,
                       Text_Corner,text,Main_Color,FONTNAME,FONTSIZE);

            if(LOTS[i]==0)
               continue;

            double minlot=SymbolInfoDouble(SYMBOLS[i],SYMBOL_VOLUME_MIN);

            if(MathAbs(LOTS[i])<minlot)
               Alert("Minimum trading lot ",minlot," violated for: ",text);
           }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void HideByFilter()
  {
   if(Hide_By_Filter)
      for(int n=1; n<=num_combos; n++)
         if(PORTFOLIOS[n].position==0)
            ArrayInitialize(BUFFERS[n].buffer,EMPTY_VALUE);
   if(mode_stream)
      for(int n=1; n<=num_combos; n++)
         ArrayInitialize(BUFFERS[n].buffer,EMPTY_VALUE);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawChartGrid()
  {
   if(Chart_Grid_Size==0)
      return;

   color colour=(color)ChartGetInteger(chart,CHART_COLOR_GRID,window);

   double max=-DBL_MAX,min=DBL_MAX;
   for(int j=Bars(_Symbol,_Period)-1; j>=0; j--)
      for(int n=0; n<dim_size; n++)
        {
         double X=BUFFERS[n].buffer[j];
         if(X==EMPTY_VALUE)
            continue;
         if(X>max)
            max=X;
         if(X<min)
            min=X;
        }

   double level=0;

   while(level<max)
     {
      level+=Chart_Grid_Size;
      string name="Grid-level-"+Portfolio_Name+":"+DoubleToString(level,2);
      PlaceHorizontal(name,level,colour,STYLE_DOT,true,false,false);
     }

   level=0;

   while(level>min)
     {
      level-=Chart_Grid_Size;
      string name="Grid-level-"+Portfolio_Name+":"+DoubleToString(level,2);
      PlaceHorizontal(name,level,colour,STYLE_DOT,true,false,false);
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PlaceLabel(string name,int x,int y,int corner,string text,int colour,string font,int size)
  {
   ENUM_ANCHOR_POINT anchor=0;
   if(corner==CORNER_LEFT_LOWER)
      anchor=ANCHOR_LEFT_LOWER;
   else
      if(corner==CORNER_LEFT_UPPER)
         anchor=ANCHOR_LEFT_UPPER;
      else
         if(corner==CORNER_RIGHT_LOWER)
            anchor=ANCHOR_RIGHT_LOWER;
         else
            if(corner==CORNER_RIGHT_UPPER)
               anchor=ANCHOR_RIGHT_UPPER;

   ObjectCreate(chart,name,OBJ_LABEL,window,0,0);
   ObjectSetInteger(chart,name,OBJPROP_CORNER,corner);
   ObjectSetInteger(chart,name,OBJPROP_ANCHOR,anchor);
   ObjectSetInteger(chart,name,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(chart,name,OBJPROP_YDISTANCE,y);
   ObjectSetString(chart,name,OBJPROP_TEXT,text);
   ObjectSetString(chart,name,OBJPROP_FONT,font);
   ObjectSetInteger(chart,name,OBJPROP_FONTSIZE,size);
   ObjectSetInteger(chart,name,OBJPROP_COLOR,colour);
   ObjectSetInteger(chart,name,OBJPROP_SELECTABLE,false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PlaceVertical(string name,datetime time,int colour,int style,bool back,bool selectable,bool selected)
  {
   ObjectCreate(chart,name,OBJ_VLINE,window,time,0);
   ObjectSetInteger(chart,name,OBJPROP_TIME,time);
   ObjectSetInteger(chart,name,OBJPROP_COLOR,colour);
   ObjectSetInteger(chart,name,OBJPROP_STYLE,style);
   ObjectSetInteger(chart,name,OBJPROP_BACK,back);
   ObjectSetInteger(chart,name,OBJPROP_SELECTABLE,selectable);
   ObjectSetInteger(chart,name,OBJPROP_SELECTED,selected);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PlaceHorizontal(string name,double price,int colour,int style,bool back,bool selectable,bool selected)
  {
   ObjectCreate(chart,name,OBJ_HLINE,window,0,price);
   ObjectSetDouble(chart,name,OBJPROP_PRICE,price);
   ObjectSetInteger(chart,name,OBJPROP_COLOR,colour);
   ObjectSetInteger(chart,name,OBJPROP_STYLE,style);
   ObjectSetInteger(chart,name,OBJPROP_BACK,back);
   ObjectSetInteger(chart,name,OBJPROP_SELECTABLE,selectable);
   ObjectSetInteger(chart,name,OBJPROP_SELECTED,selected);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void ExportCSV()
  {

   if(error)
      return;
   if(CSV_Export_File=="")
      return;

   string working_name=CSV_Export_File+".csv";
   PrepareFile(working_name);

   for(int j=draw_begin; j>=draw_end; j--)
     {
      string text=TimeToString(iTime(_Symbol,_Period,j));

      for(int n=1; n<=num_combos; n++)
        {
         double value=BUFFERS[n].buffer[j];
         if(value==EMPTY_VALUE)
            continue;
         text=(text+CSV_Separator+DoubleToString(value,2));
        }

      double value=BUFFERS[num_total].buffer[j];
      if(value==EMPTY_VALUE)
         continue;

      text=(text+CSV_Separator+DoubleToString(value,2));
      WriteLine(working_name,text);
     }

   Alert("CSV data export completed.");

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PrepareFile(string file)
  {
   int handle=FileOpen(file,FILE_WRITE,CSV_Separator);
   if(handle==-1)
     {
      Alert("Error opening export file!");
      error=true;
      return;
     }
   FileClose(handle);
   string text="DATE/TIME";
   for(int n=1; n<=num_combos; n++)
      text+=(CSV_Separator+"PORTFOLIO #"+string(n));
   text+=(CSV_Separator+"TOTAL PORTFOLIO");
   WriteLine(file,text);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void WriteLine(string file,string text)
  {
   int handle=FileOpen(file,FILE_READ|FILE_WRITE,CSV_Separator);
   if(handle==-1)
      return;
   FileSeek(handle,0,SEEK_END);
   FileWrite(handle,text);
   FileClose(handle);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#ifdef __MQL4__
void PrepareOHLC()
  {

   if(error)
      return;
   if(!OHLC_mode)
      return;

   if(Data_Timeframe>_Period)
     {
      Alert("Incorrect aggregation timeframe!");
      error=true;
      return;
     }

   string name=(_Symbol+(string)Chart_Timeframe+".hst");

   OHLC_handle=-1;
   OHLC_handle=FileOpenHistory(name,FILE_BIN|FILE_WRITE|FILE_ANSI);
   FileClose(OHLC_handle);

   OHLC_handle=-1;
   OHLC_handle=FileOpenHistory(name,FILE_BIN|FILE_READ|FILE_WRITE|FILE_SHARE_WRITE|FILE_SHARE_READ|FILE_ANSI);

   if(OHLC_handle<0)
     {
      Alert("Error opening OHLC history file!");
      error=true;
      return;
     }

   int data_unused[13];
   FileWriteInteger(OHLC_handle,401,LONG_VALUE);
   FileWriteString(OHLC_handle,"",64);
   FileWriteString(OHLC_handle,_Symbol,12);
   FileWriteInteger(OHLC_handle,Chart_Timeframe,LONG_VALUE);
   FileWriteInteger(OHLC_handle,2,LONG_VALUE);
   FileWriteInteger(OHLC_handle,0,LONG_VALUE);
   FileWriteInteger(OHLC_handle,0,LONG_VALUE);
   FileWriteArray(OHLC_handle,data_unused,0,13);

  }
#endif
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#ifdef __MQL4__
void GenerateOHLC(bool all_bars)
  {

   if(error)
      return;
   if(!OHLC_mode)
      return;

   MqlRates rates;

   int SHIFTS[];
   double OPENINGS[];
   ArrayResize(OPENINGS,variables);
   ArrayResize(SHIFTS,variables);

   for(int i=0; i<variables; i++)
      OPENINGS[i]=DATA[PORTFOLIOS[num_total].pointer[i]].opening;

   int subbars=int(_Period/Data_Timeframe);

   if(!all_bars)
      FileSeek(OHLC_handle,file_position,SEEK_SET);

   for(int j=draw_begin; j>=draw_end; j--)
     {
      double bar_open=0,bar_high=0,bar_low=0,bar_close=0;

      for(int k=0; k<subbars; k++)
        {
         datetime time_x=Time[j]+k*60*Data_Timeframe;
         bool missing=false;
         for(int i=0; i<variables; i++)
           {
            SHIFTS[i]=iBarShift(SYMBOLS[i],Data_Timeframe,time_x,true);
            if(SHIFTS[i]==-1)
               missing=true;
           }
         if(missing)
            continue;

         double sum_open=0,sum_high=0,sum_low=0,sum_close=0;
         for(int i=0; i<variables; i++)
           {
            double value=ContractValue(SYMBOLS[i],time_x,Data_Timeframe,Chart_Currency);
            double open =iOpen(SYMBOLS[i],Data_Timeframe,SHIFTS[i]);
            double close=iClose(SYMBOLS[i],Data_Timeframe,SHIFTS[i]);
            double high =iHigh(SYMBOLS[i],Data_Timeframe,SHIFTS[i]);
            double low  =iLow(SYMBOLS[i],Data_Timeframe,SHIFTS[i]);
            sum_close+=(close-OPENINGS[i])*value*LOTS[i];
            sum_open +=(open -OPENINGS[i])*value*LOTS[i];
            if(LOTS[i]>0)
               sum_high += (high -OPENINGS[i]) *value*LOTS[i];
            else
               sum_low  += (high -OPENINGS[i]) *value*LOTS[i];
            if(LOTS[i]>0)
               sum_low  += (low  -OPENINGS[i]) *value*LOTS[i];
            else
               sum_high += (low  -OPENINGS[i]) *value*LOTS[i];
           }

         if(bar_high==0)
            bar_high=sum_high;
         if(sum_high>bar_high)
            bar_high=sum_high;
         if(bar_low==0)
            bar_low=sum_low;
         if(sum_low<bar_low)
            bar_low=sum_low;
         if(bar_open==0)
            bar_open=sum_open;
         bar_close=sum_close;
        }

      file_position=FileTell(OHLC_handle);
      rates.time =Time[j];
      rates.open =NormalizeDouble(bar_open+Price_Start,2);
      rates.high =NormalizeDouble(bar_high+Price_Start,2);
      rates.low  =NormalizeDouble(bar_low+Price_Start,2);
      rates.close=NormalizeDouble(bar_close+Price_Start,2);
      FileWriteStruct(OHLC_handle,rates);
     }

   FileFlush(OHLC_handle);

  }
#endif
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#ifdef __MQL4__
void FindOHLC()
  {

   long currChart,prevChart=ChartFirst();

   if(ChartSymbol(prevChart)==_Symbol)
      if(ChartPeriod(prevChart)==Chart_Timeframe)
        {
         OHLC_chart=prevChart;
         return;
        }

      else
        {

         int i=0,limit=100;
         while(i<limit)
           {
            currChart=ChartNext(prevChart);

            if(ChartSymbol(currChart)==_Symbol)
               if(ChartPeriod(currChart)==Chart_Timeframe)
                 {
                  OHLC_chart=currChart;
                  return;
                 }

            if(currChart<0)
               break;
            prevChart=currChart;
            i++;
           }

        }

  }
#endif
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#ifdef __MQL4__
void RefreshOHLC(bool all_bars)
  {

   if(error)
      return;

   if(!OHLC_mode)
      return;

   if(OHLC_chart<=0)
     {
      OHLC_chart=ChartOpen(_Symbol,Chart_Timeframe);
      GlobalVariableSet("OHLC_"+Portfolio_Name,OHLC_chart);
     }

   if(all_bars)
     {

      ObjectDelete(OHLC_chart,"Start");
      ObjectDelete(OHLC_chart,"Finish");
      ObjectDelete(OHLC_chart,"Filter");

      ObjectCreate(OHLC_chart,"Start",OBJ_VLINE,0,time_start,0);
      ObjectCreate(OHLC_chart,"Finish",OBJ_VLINE,0,time_finish,0);
      ObjectCreate(OHLC_chart,"Filter",OBJ_VLINE,0,time_filter,0);

      ObjectSetInteger(OHLC_chart,"Start",OBJPROP_STYLE,STYLE_DASH);
      ObjectSetInteger(OHLC_chart,"Finish",OBJPROP_STYLE,STYLE_DASH);
      ObjectSetInteger(OHLC_chart,"Filter",OBJPROP_STYLE,STYLE_DOT);

      ObjectSetInteger(OHLC_chart,"Start",OBJPROP_COLOR,COLOR_INTERVAL);
      ObjectSetInteger(OHLC_chart,"Finish",OBJPROP_COLOR,COLOR_INTERVAL);
      ObjectSetInteger(OHLC_chart,"Filter",OBJPROP_COLOR,COLOR_FILTER);

      ObjectSetInteger(OHLC_chart,"Start",OBJPROP_SELECTABLE,false);
      ObjectSetInteger(OHLC_chart,"Finish",OBJPROP_SELECTABLE,false);
      ObjectSetInteger(OHLC_chart,"Filter",OBJPROP_SELECTABLE,false);

      ObjectSetInteger(OHLC_chart,"Start",OBJPROP_BACK,true);
      ObjectSetInteger(OHLC_chart,"Finish",OBJPROP_BACK,true);
      ObjectSetInteger(OHLC_chart,"Filter",OBJPROP_BACK,true);

      ObjectSetString(OHLC_chart,"Start",OBJPROP_TEXT,TimeToString(time_start));
      ObjectSetString(OHLC_chart,"Finish",OBJPROP_TEXT,TimeToString(time_finish));
      ObjectSetString(OHLC_chart,"Filter",OBJPROP_TEXT,TimeToString(time_filter));

      int anchor=0;
      if(Text_Corner==CORNER_LEFT_LOWER)
         anchor=ANCHOR_LEFT_LOWER;
      else
         if(Text_Corner==CORNER_LEFT_UPPER)
            anchor=ANCHOR_LEFT_UPPER;
         else
            if(Text_Corner==CORNER_RIGHT_LOWER)
               anchor=ANCHOR_RIGHT_LOWER;
            else
               if(Text_Corner==CORNER_RIGHT_UPPER)
                  anchor=ANCHOR_RIGHT_UPPER;
      string label="Portfolio: "+Portfolio_Name;

      ObjectCreate(OHLC_chart,"Name",OBJ_LABEL,0,0,0);
      ObjectSetString(OHLC_chart,"Name",OBJPROP_TEXT,label);
      ObjectSetString(OHLC_chart,"Name",OBJPROP_FONT,FONTNAME);
      ObjectSetInteger(OHLC_chart,"Name",OBJPROP_FONTSIZE,FONTSIZE*2);
      ObjectSetInteger(OHLC_chart,"Name",OBJPROP_COLOR,ChartGetInteger(OHLC_chart,CHART_COLOR_GRID));
      ObjectSetInteger(OHLC_chart,"Name",OBJPROP_CORNER,Text_Corner);
      ObjectSetInteger(OHLC_chart,"Name",OBJPROP_ANCHOR,anchor);
      ObjectSetInteger(OHLC_chart,"Name",OBJPROP_XDISTANCE,XMARGIN);
      ObjectSetInteger(OHLC_chart,"Name",OBJPROP_YDISTANCE,YMARGIN);
      ObjectSetInteger(OHLC_chart,"Name",OBJPROP_SELECTABLE,false);
      ObjectSetInteger(OHLC_chart,"Name",OBJPROP_BACK,true);

     }

   ChartSetSymbolPeriod(OHLC_chart,_Symbol,Chart_Timeframe);

  }
#endif
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetupCombinations()
  {

   for(int i=0; i<MAX_LINES; i++)
      COMBINATIONS[i]="";

//---

   if(Generation_Type==formula)
     {
      if(Portfolio_Formula=="")
        {
         Alert("Empty portfolio formula!");
         error=true;
         return;
        }
      COMBINATIONS[01]=Portfolio_Formula;
      num_combos=1;
      num_symbols=MAX_SYMBOLS;
     }

//---

   if(Generation_Type==decomposition)
     {
      string names[];
      int portfolios=StringSplit(Portfolio_Formula,SPACE,names);
      for(int n=1; n<=portfolios; n++)
         COMBINATIONS[n]=names[n-1];
      num_combos=portfolios;
      num_symbols=1;
     }

//---

   if(Generation_Type==import)
     {
      int handle=FileOpen(Import_File,FILE_READ|FILE_ANSI,CSV_Separator);
      if(handle==-1)
        {
         Alert("Error opening import file!");
         error=true;
         return;
        }
      FileSeek(handle,0,SEEK_SET);
      int portfolios=0;
      while(!FileIsEnding(handle))
        {
         portfolios++;
         string text=FileReadString(handle);
         COMBINATIONS[portfolios]=text;
        }
      FileClose(handle);
      num_combos=portfolios;
      num_symbols=MAX_SYMBOLS;
     }

//---

   if(Generation_Type==consolidation)
     {
      string names[];
      int portfolios=StringSplit(Portfolio_Formula,SPACE,names);
      for(int n=1; n<=portfolios; n++)
        {
         int counter=0;
         for(int k=1; k<=MAX_SYMBOLS; k++)
           {
            string name="Formula-label-"+names[n-1]+"-"+IntegerToString(k);
            if(ObjectFind(chart,name)<0)
               continue;
            COMBINATIONS[n]+=(CharToString(SPACE)+ObjectGetString(chart,name,OBJPROP_TEXT));
            counter++;
           }
         if(counter<1)
           {
            Alert("Portfolio not found: "+names[n-1]);
            saved_time=0;
           }
        }
      num_combos=portfolios;
      num_symbols=MAX_SYMBOLS;
     }

//---

   if(Generation_Type==terminal)
     {
#ifdef __MQL4__
      int total=OrdersTotal();
      if(total>MAX_SYMBOLS)
        {
         Alert("Too many orders: only ",MAX_SYMBOLS," will be used!");
         total=MAX_SYMBOLS;
        }
      for(int i=0; i<total; i++)
        {
         if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            continue;
         if(Portfolio_Formula!="")
            if(StringFind(OrderComment(),Portfolio_Formula)==-1)
               continue;
         string symbol=OrderSymbol();
         double lots=OrderLots();
         string volume=DoubleToString(lots,Lots_Digits);
         int type=OrderType();
         if(type==OP_BUY)
            COMBINATIONS[01]+=symbol+CharToString(EQUAL)+"+"+volume+CharToString(SPACE);
         if(type==OP_SELL)
            COMBINATIONS[01]+=symbol+CharToString(EQUAL)+"-"+volume+CharToString(SPACE);
        }
#else
      int total=PositionsTotal();
      if(total>MAX_SYMBOLS)
        {
         Alert("Too many positions: only ",MAX_SYMBOLS," will be used!");
         total=MAX_SYMBOLS;
        }
      for(int i=0; i<total; i++)
        {
         if(!PositionSelectByTicket(PositionGetTicket(i)))
            continue;
         if(Portfolio_Formula!="")
            if(StringFind(PositionGetString(POSITION_COMMENT),Portfolio_Formula)==-1)
               continue;
         string symbol=PositionGetString(POSITION_SYMBOL);
         double lots=PositionGetDouble(POSITION_VOLUME);
         string volume=DoubleToString(lots,Lots_Digits);
         long type=PositionGetInteger(POSITION_TYPE);
         if(type==POSITION_TYPE_BUY)
            COMBINATIONS[01]+=symbol+CharToString(EQUAL)+"+"+volume+CharToString(SPACE);
         if(type==POSITION_TYPE_SELL)
            COMBINATIONS[01]+=symbol+CharToString(EQUAL)+"-"+volume+CharToString(SPACE);
        }
#endif
      num_combos=1;
      num_symbols=total;
     }

//---

   if(Generation_Type==basic28)
     {
      COMBINATIONS[01]="AUDCAD";
      COMBINATIONS[02]="AUDCHF";
      COMBINATIONS[03]="AUDJPY";
      COMBINATIONS[04]="AUDNZD";
      COMBINATIONS[05]="AUDUSD";
      COMBINATIONS[06]="CADCHF";
      COMBINATIONS[07]="CADJPY";
      COMBINATIONS[08]="CHFJPY";
      COMBINATIONS[09]="EURAUD";
      COMBINATIONS[10]="EURCAD";
      COMBINATIONS[11]="EURCHF";
      COMBINATIONS[12]="EURGBP";
      COMBINATIONS[13]="EURJPY";
      COMBINATIONS[14]="EURNZD";
      COMBINATIONS[15]="EURUSD";
      COMBINATIONS[16]="GBPAUD";
      COMBINATIONS[17]="GBPCAD";
      COMBINATIONS[18]="GBPCHF";
      COMBINATIONS[19]="GBPJPY";
      COMBINATIONS[20]="GBPNZD";
      COMBINATIONS[21]="GBPUSD";
      COMBINATIONS[22]="NZDCAD";
      COMBINATIONS[23]="NZDCHF";
      COMBINATIONS[24]="NZDJPY";
      COMBINATIONS[25]="NZDUSD";
      COMBINATIONS[26]="USDCAD";
      COMBINATIONS[27]="USDCHF";
      COMBINATIONS[28]="USDJPY";
      num_combos=28;
      num_symbols=1;
     }

//---

   if(Generation_Type==fours35)
     {
      COMBINATIONS[01]="USDJPY GBPUSD NZDUSD USDCHF";
      COMBINATIONS[02]="USDCAD GBPUSD NZDUSD USDCHF";
      COMBINATIONS[03]="AUDUSD GBPUSD NZDUSD USDCHF";
      COMBINATIONS[04]="EURUSD GBPUSD NZDUSD USDCHF";
      COMBINATIONS[05]="USDCAD USDJPY NZDUSD USDCHF";
      COMBINATIONS[06]="AUDUSD USDJPY NZDUSD USDCHF";
      COMBINATIONS[07]="EURUSD USDJPY NZDUSD USDCHF";
      COMBINATIONS[08]="AUDUSD USDCAD NZDUSD USDCHF";
      COMBINATIONS[09]="EURUSD USDCAD NZDUSD USDCHF";
      COMBINATIONS[10]="EURUSD AUDUSD NZDUSD USDCHF";
      COMBINATIONS[11]="USDCAD USDJPY GBPUSD USDCHF";
      COMBINATIONS[12]="AUDUSD USDJPY GBPUSD USDCHF";
      COMBINATIONS[13]="EURUSD USDJPY GBPUSD USDCHF";
      COMBINATIONS[14]="AUDUSD USDCAD GBPUSD USDCHF";
      COMBINATIONS[15]="EURUSD USDCAD GBPUSD USDCHF";
      COMBINATIONS[16]="EURUSD AUDUSD GBPUSD USDCHF";
      COMBINATIONS[17]="AUDUSD USDCAD USDJPY USDCHF";
      COMBINATIONS[18]="EURUSD USDCAD USDJPY USDCHF";
      COMBINATIONS[19]="EURUSD AUDUSD USDJPY USDCHF";
      COMBINATIONS[20]="EURUSD AUDUSD USDCAD USDCHF";
      COMBINATIONS[21]="USDCAD USDJPY GBPUSD NZDUSD";
      COMBINATIONS[22]="AUDUSD USDJPY GBPUSD NZDUSD";
      COMBINATIONS[23]="EURUSD USDJPY GBPUSD NZDUSD";
      COMBINATIONS[24]="AUDUSD USDCAD GBPUSD NZDUSD";
      COMBINATIONS[25]="EURUSD USDCAD GBPUSD NZDUSD";
      COMBINATIONS[26]="EURUSD AUDUSD GBPUSD NZDUSD";
      COMBINATIONS[27]="AUDUSD USDCAD USDJPY NZDUSD";
      COMBINATIONS[28]="EURUSD USDCAD USDJPY NZDUSD";
      COMBINATIONS[29]="EURUSD AUDUSD USDJPY NZDUSD";
      COMBINATIONS[30]="EURUSD AUDUSD USDCAD NZDUSD";
      COMBINATIONS[31]="AUDUSD USDCAD USDJPY GBPUSD";
      COMBINATIONS[32]="EURUSD USDCAD USDJPY GBPUSD";
      COMBINATIONS[33]="EURUSD AUDUSD USDJPY GBPUSD";
      COMBINATIONS[34]="EURUSD AUDUSD USDCAD GBPUSD";
      COMBINATIONS[35]="EURUSD AUDUSD USDCAD USDJPY";
      num_combos=35;
      num_symbols=4;
     }

//---

   if(Generation_Type==threes35)
     {
      COMBINATIONS[01]="EURUSD GBPUSD AUDUSD";
      COMBINATIONS[02]="EURUSD GBPUSD NZDUSD";
      COMBINATIONS[03]="EURUSD GBPUSD USDJPY";
      COMBINATIONS[04]="EURUSD GBPUSD USDCAD";
      COMBINATIONS[05]="EURUSD GBPUSD USDCHF";
      COMBINATIONS[06]="EURUSD AUDUSD NZDUSD";
      COMBINATIONS[07]="EURUSD AUDUSD USDJPY";
      COMBINATIONS[08]="EURUSD AUDUSD USDCAD";
      COMBINATIONS[09]="EURUSD AUDUSD USDCHF";
      COMBINATIONS[10]="EURUSD NZDUSD USDJPY";
      COMBINATIONS[11]="EURUSD NZDUSD USDCAD";
      COMBINATIONS[12]="EURUSD NZDUSD USDCHF";
      COMBINATIONS[13]="EURUSD USDJPY USDCAD";
      COMBINATIONS[14]="EURUSD USDJPY USDCHF";
      COMBINATIONS[15]="EURUSD USDCAD USDCHF";
      COMBINATIONS[16]="GBPUSD AUDUSD NZDUSD";
      COMBINATIONS[17]="GBPUSD AUDUSD USDJPY";
      COMBINATIONS[18]="GBPUSD AUDUSD USDCAD";
      COMBINATIONS[19]="GBPUSD AUDUSD USDCHF";
      COMBINATIONS[20]="GBPUSD NZDUSD USDJPY";
      COMBINATIONS[21]="GBPUSD NZDUSD USDCAD";
      COMBINATIONS[22]="GBPUSD NZDUSD USDCHF";
      COMBINATIONS[23]="GBPUSD USDJPY USDCAD";
      COMBINATIONS[24]="GBPUSD USDJPY USDCHF";
      COMBINATIONS[25]="GBPUSD USDCAD USDCHF";
      COMBINATIONS[26]="AUDUSD NZDUSD USDJPY";
      COMBINATIONS[27]="AUDUSD NZDUSD USDCAD";
      COMBINATIONS[28]="AUDUSD NZDUSD USDCHF";
      COMBINATIONS[29]="AUDUSD USDJPY USDCAD";
      COMBINATIONS[30]="AUDUSD USDJPY USDCHF";
      COMBINATIONS[31]="AUDUSD USDCAD USDCHF";
      COMBINATIONS[32]="NZDUSD USDJPY USDCAD";
      COMBINATIONS[33]="NZDUSD USDJPY USDCHF";
      COMBINATIONS[34]="NZDUSD USDCAD USDCHF";
      COMBINATIONS[35]="USDJPY USDCAD USDCHF";
      num_combos=35;
      num_symbols=3;
     }

//---

   if(Generation_Type==fours105)
     {
      COMBINATIONS[1]="AUDCAD CHFJPY EURGBP NZDUSD";
      COMBINATIONS[2]="AUDCAD CHFJPY EURNZD GBPUSD";
      COMBINATIONS[3]="AUDCAD CHFJPY EURUSD GBPNZD";
      COMBINATIONS[4]="AUDCAD EURCHF GBPJPY NZDUSD";
      COMBINATIONS[5]="AUDCAD EURCHF GBPNZD USDJPY";
      COMBINATIONS[6]="AUDCAD EURCHF GBPUSD NZDJPY";
      COMBINATIONS[7]="AUDCAD EURGBP NZDCHF USDJPY";
      COMBINATIONS[8]="AUDCAD EURGBP NZDJPY USDCHF";
      COMBINATIONS[9]="AUDCAD EURJPY GBPCHF NZDUSD";
      COMBINATIONS[10]="AUDCAD EURJPY GBPNZD USDCHF";
      COMBINATIONS[11]="AUDCAD EURJPY GBPUSD NZDCHF";
      COMBINATIONS[12]="AUDCAD EURNZD GBPCHF USDJPY";
      COMBINATIONS[13]="AUDCAD EURNZD GBPJPY USDCHF";
      COMBINATIONS[14]="AUDCAD EURUSD GBPCHF NZDJPY";
      COMBINATIONS[15]="AUDCAD EURUSD GBPJPY NZDCHF";
      COMBINATIONS[16]="AUDCHF CADJPY EURGBP NZDUSD";
      COMBINATIONS[17]="AUDCHF CADJPY EURNZD GBPUSD";
      COMBINATIONS[18]="AUDCHF CADJPY EURUSD GBPNZD";
      COMBINATIONS[19]="AUDCHF EURCAD GBPJPY NZDUSD";
      COMBINATIONS[20]="AUDCHF EURCAD GBPNZD USDJPY";
      COMBINATIONS[21]="AUDCHF EURCAD GBPUSD NZDJPY";
      COMBINATIONS[22]="AUDCHF EURGBP NZDCAD USDJPY";
      COMBINATIONS[23]="AUDCHF EURGBP NZDJPY USDCAD";
      COMBINATIONS[24]="AUDCHF EURJPY GBPCAD NZDUSD";
      COMBINATIONS[25]="AUDCHF EURJPY GBPNZD USDCAD";
      COMBINATIONS[26]="AUDCHF EURJPY GBPUSD NZDCAD";
      COMBINATIONS[27]="AUDCHF EURNZD GBPCAD USDJPY";
      COMBINATIONS[28]="AUDCHF EURNZD GBPJPY USDCAD";
      COMBINATIONS[29]="AUDCHF EURUSD GBPCAD NZDJPY";
      COMBINATIONS[30]="AUDCHF EURUSD GBPJPY NZDCAD";
      COMBINATIONS[31]="AUDJPY CADCHF EURGBP NZDUSD";
      COMBINATIONS[32]="AUDJPY CADCHF EURNZD GBPUSD";
      COMBINATIONS[33]="AUDJPY CADCHF EURUSD GBPNZD";
      COMBINATIONS[34]="AUDJPY EURCAD GBPCHF NZDUSD";
      COMBINATIONS[35]="AUDJPY EURCAD GBPNZD USDCHF";
      COMBINATIONS[36]="AUDJPY EURCAD GBPUSD NZDCHF";
      COMBINATIONS[37]="AUDJPY EURCHF GBPCAD NZDUSD";
      COMBINATIONS[38]="AUDJPY EURCHF GBPNZD USDCAD";
      COMBINATIONS[39]="AUDJPY EURCHF GBPUSD NZDCAD";
      COMBINATIONS[40]="AUDJPY EURGBP NZDCAD USDCHF";
      COMBINATIONS[41]="AUDJPY EURGBP NZDCHF USDCAD";
      COMBINATIONS[42]="AUDJPY EURNZD GBPCAD USDCHF";
      COMBINATIONS[43]="AUDJPY EURNZD GBPCHF USDCAD";
      COMBINATIONS[44]="AUDJPY EURUSD GBPCAD NZDCHF";
      COMBINATIONS[45]="AUDJPY EURUSD GBPCHF NZDCAD";
      COMBINATIONS[46]="AUDNZD CADCHF EURGBP USDJPY";
      COMBINATIONS[47]="AUDNZD CADCHF EURJPY GBPUSD";
      COMBINATIONS[48]="AUDNZD CADCHF EURUSD GBPJPY";
      COMBINATIONS[49]="AUDNZD CADJPY EURCHF GBPUSD";
      COMBINATIONS[50]="AUDNZD CADJPY EURGBP USDCHF";
      COMBINATIONS[51]="AUDNZD CADJPY EURUSD GBPCHF";
      COMBINATIONS[52]="AUDNZD CHFJPY EURCAD GBPUSD";
      COMBINATIONS[53]="AUDNZD CHFJPY EURGBP USDCAD";
      COMBINATIONS[54]="AUDNZD CHFJPY EURUSD GBPCAD";
      COMBINATIONS[55]="AUDNZD EURCAD GBPCHF USDJPY";
      COMBINATIONS[56]="AUDNZD EURCAD GBPJPY USDCHF";
      COMBINATIONS[57]="AUDNZD EURCHF GBPCAD USDJPY";
      COMBINATIONS[58]="AUDNZD EURCHF GBPJPY USDCAD";
      COMBINATIONS[59]="AUDNZD EURJPY GBPCAD USDCHF";
      COMBINATIONS[60]="AUDNZD EURJPY GBPCHF USDCAD";
      COMBINATIONS[61]="AUDUSD CADCHF EURGBP NZDJPY";
      COMBINATIONS[62]="AUDUSD CADCHF EURJPY GBPNZD";
      COMBINATIONS[63]="AUDUSD CADCHF EURNZD GBPJPY";
      COMBINATIONS[64]="AUDUSD CADJPY EURCHF GBPNZD";
      COMBINATIONS[65]="AUDUSD CADJPY EURGBP NZDCHF";
      COMBINATIONS[66]="AUDUSD CADJPY EURNZD GBPCHF";
      COMBINATIONS[67]="AUDUSD CHFJPY EURCAD GBPNZD";
      COMBINATIONS[68]="AUDUSD CHFJPY EURGBP NZDCAD";
      COMBINATIONS[69]="AUDUSD CHFJPY EURNZD GBPCAD";
      COMBINATIONS[70]="AUDUSD EURCAD GBPCHF NZDJPY";
      COMBINATIONS[71]="AUDUSD EURCAD GBPJPY NZDCHF";
      COMBINATIONS[72]="AUDUSD EURCHF GBPCAD NZDJPY";
      COMBINATIONS[73]="AUDUSD EURCHF GBPJPY NZDCAD";
      COMBINATIONS[74]="AUDUSD EURJPY GBPCAD NZDCHF";
      COMBINATIONS[75]="AUDUSD EURJPY GBPCHF NZDCAD";
      COMBINATIONS[76]="CADCHF EURAUD GBPJPY NZDUSD";
      COMBINATIONS[77]="CADCHF EURAUD GBPNZD USDJPY";
      COMBINATIONS[78]="CADCHF EURAUD GBPUSD NZDJPY";
      COMBINATIONS[79]="CADCHF EURJPY GBPAUD NZDUSD";
      COMBINATIONS[80]="CADCHF EURNZD GBPAUD USDJPY";
      COMBINATIONS[81]="CADCHF EURUSD GBPAUD NZDJPY";
      COMBINATIONS[82]="CADJPY EURAUD GBPCHF NZDUSD";
      COMBINATIONS[83]="CADJPY EURAUD GBPNZD USDCHF";
      COMBINATIONS[84]="CADJPY EURAUD GBPUSD NZDCHF";
      COMBINATIONS[85]="CADJPY EURCHF GBPAUD NZDUSD";
      COMBINATIONS[86]="CADJPY EURNZD GBPAUD USDCHF";
      COMBINATIONS[87]="CADJPY EURUSD GBPAUD NZDCHF";
      COMBINATIONS[88]="CHFJPY EURAUD GBPCAD NZDUSD";
      COMBINATIONS[89]="CHFJPY EURAUD GBPNZD USDCAD";
      COMBINATIONS[90]="CHFJPY EURAUD GBPUSD NZDCAD";
      COMBINATIONS[91]="CHFJPY EURCAD GBPAUD NZDUSD";
      COMBINATIONS[92]="CHFJPY EURNZD GBPAUD USDCAD";
      COMBINATIONS[93]="CHFJPY EURUSD GBPAUD NZDCAD";
      COMBINATIONS[94]="EURAUD GBPCAD NZDCHF USDJPY";
      COMBINATIONS[95]="EURAUD GBPCAD NZDJPY USDCHF";
      COMBINATIONS[96]="EURAUD GBPCHF NZDCAD USDJPY";
      COMBINATIONS[97]="EURAUD GBPCHF NZDJPY USDCAD";
      COMBINATIONS[98]="EURAUD GBPJPY NZDCAD USDCHF";
      COMBINATIONS[99]="EURAUD GBPJPY NZDCHF USDCAD";
      COMBINATIONS[100]="EURCAD GBPAUD NZDCHF USDJPY";
      COMBINATIONS[101]="EURCAD GBPAUD NZDJPY USDCHF";
      COMBINATIONS[102]="EURCHF GBPAUD NZDCAD USDJPY";
      COMBINATIONS[103]="EURCHF GBPAUD NZDJPY USDCAD";
      COMBINATIONS[104]="EURJPY GBPAUD NZDCAD USDCHF";
      COMBINATIONS[105]="EURJPY GBPAUD NZDCHF USDCAD";
      num_combos=105;
      num_symbols=4;
     }

//---

   if(Generation_Type==threes420)
     {
      COMBINATIONS[1]="AUDCAD CHFJPY EURGBP";
      COMBINATIONS[2]="AUDCAD CHFJPY EURNZD";
      COMBINATIONS[3]="AUDCAD CHFJPY EURUSD";
      COMBINATIONS[4]="AUDCAD CHFJPY GBPNZD";
      COMBINATIONS[5]="AUDCAD CHFJPY GBPUSD";
      COMBINATIONS[6]="AUDCAD CHFJPY NZDUSD";
      COMBINATIONS[7]="AUDCAD EURCHF GBPJPY";
      COMBINATIONS[8]="AUDCAD EURCHF GBPNZD";
      COMBINATIONS[9]="AUDCAD EURCHF GBPUSD";
      COMBINATIONS[10]="AUDCAD EURCHF NZDJPY";
      COMBINATIONS[11]="AUDCAD EURCHF NZDUSD";
      COMBINATIONS[12]="AUDCAD EURCHF USDJPY";
      COMBINATIONS[13]="AUDCAD EURGBP NZDCHF";
      COMBINATIONS[14]="AUDCAD EURGBP NZDJPY";
      COMBINATIONS[15]="AUDCAD EURGBP NZDUSD";
      COMBINATIONS[16]="AUDCAD EURGBP USDCHF";
      COMBINATIONS[17]="AUDCAD EURGBP USDJPY";
      COMBINATIONS[18]="AUDCAD EURJPY GBPCHF";
      COMBINATIONS[19]="AUDCAD EURJPY GBPNZD";
      COMBINATIONS[20]="AUDCAD EURJPY GBPUSD";
      COMBINATIONS[21]="AUDCAD EURJPY NZDCHF";
      COMBINATIONS[22]="AUDCAD EURJPY NZDUSD";
      COMBINATIONS[23]="AUDCAD EURJPY USDCHF";
      COMBINATIONS[24]="AUDCAD EURNZD GBPCHF";
      COMBINATIONS[25]="AUDCAD EURNZD GBPJPY";
      COMBINATIONS[26]="AUDCAD EURNZD GBPUSD";
      COMBINATIONS[27]="AUDCAD EURNZD USDCHF";
      COMBINATIONS[28]="AUDCAD EURNZD USDJPY";
      COMBINATIONS[29]="AUDCAD EURUSD GBPCHF";
      COMBINATIONS[30]="AUDCAD EURUSD GBPJPY";
      COMBINATIONS[31]="AUDCAD EURUSD GBPNZD";
      COMBINATIONS[32]="AUDCAD EURUSD NZDCHF";
      COMBINATIONS[33]="AUDCAD EURUSD NZDJPY";
      COMBINATIONS[34]="AUDCAD GBPCHF NZDJPY";
      COMBINATIONS[35]="AUDCAD GBPCHF NZDUSD";
      COMBINATIONS[36]="AUDCAD GBPCHF USDJPY";
      COMBINATIONS[37]="AUDCAD GBPJPY NZDCHF";
      COMBINATIONS[38]="AUDCAD GBPJPY NZDUSD";
      COMBINATIONS[39]="AUDCAD GBPJPY USDCHF";
      COMBINATIONS[40]="AUDCAD GBPNZD USDCHF";
      COMBINATIONS[41]="AUDCAD GBPNZD USDJPY";
      COMBINATIONS[42]="AUDCAD GBPUSD NZDCHF";
      COMBINATIONS[43]="AUDCAD GBPUSD NZDJPY";
      COMBINATIONS[44]="AUDCAD NZDCHF USDJPY";
      COMBINATIONS[45]="AUDCAD NZDJPY USDCHF";
      COMBINATIONS[46]="AUDCHF CADJPY EURGBP";
      COMBINATIONS[47]="AUDCHF CADJPY EURNZD";
      COMBINATIONS[48]="AUDCHF CADJPY EURUSD";
      COMBINATIONS[49]="AUDCHF CADJPY GBPNZD";
      COMBINATIONS[50]="AUDCHF CADJPY GBPUSD";
      COMBINATIONS[51]="AUDCHF CADJPY NZDUSD";
      COMBINATIONS[52]="AUDCHF EURCAD GBPJPY";
      COMBINATIONS[53]="AUDCHF EURCAD GBPNZD";
      COMBINATIONS[54]="AUDCHF EURCAD GBPUSD";
      COMBINATIONS[55]="AUDCHF EURCAD NZDJPY";
      COMBINATIONS[56]="AUDCHF EURCAD NZDUSD";
      COMBINATIONS[57]="AUDCHF EURCAD USDJPY";
      COMBINATIONS[58]="AUDCHF EURGBP NZDCAD";
      COMBINATIONS[59]="AUDCHF EURGBP NZDJPY";
      COMBINATIONS[60]="AUDCHF EURGBP NZDUSD";
      COMBINATIONS[61]="AUDCHF EURGBP USDCAD";
      COMBINATIONS[62]="AUDCHF EURGBP USDJPY";
      COMBINATIONS[63]="AUDCHF EURJPY GBPCAD";
      COMBINATIONS[64]="AUDCHF EURJPY GBPNZD";
      COMBINATIONS[65]="AUDCHF EURJPY GBPUSD";
      COMBINATIONS[66]="AUDCHF EURJPY NZDCAD";
      COMBINATIONS[67]="AUDCHF EURJPY NZDUSD";
      COMBINATIONS[68]="AUDCHF EURJPY USDCAD";
      COMBINATIONS[69]="AUDCHF EURNZD GBPCAD";
      COMBINATIONS[70]="AUDCHF EURNZD GBPJPY";
      COMBINATIONS[71]="AUDCHF EURNZD GBPUSD";
      COMBINATIONS[72]="AUDCHF EURNZD USDCAD";
      COMBINATIONS[73]="AUDCHF EURNZD USDJPY";
      COMBINATIONS[74]="AUDCHF EURUSD GBPCAD";
      COMBINATIONS[75]="AUDCHF EURUSD GBPJPY";
      COMBINATIONS[76]="AUDCHF EURUSD GBPNZD";
      COMBINATIONS[77]="AUDCHF EURUSD NZDCAD";
      COMBINATIONS[78]="AUDCHF EURUSD NZDJPY";
      COMBINATIONS[79]="AUDCHF GBPCAD NZDJPY";
      COMBINATIONS[80]="AUDCHF GBPCAD NZDUSD";
      COMBINATIONS[81]="AUDCHF GBPCAD USDJPY";
      COMBINATIONS[82]="AUDCHF GBPJPY NZDCAD";
      COMBINATIONS[83]="AUDCHF GBPJPY NZDUSD";
      COMBINATIONS[84]="AUDCHF GBPJPY USDCAD";
      COMBINATIONS[85]="AUDCHF GBPNZD USDCAD";
      COMBINATIONS[86]="AUDCHF GBPNZD USDJPY";
      COMBINATIONS[87]="AUDCHF GBPUSD NZDCAD";
      COMBINATIONS[88]="AUDCHF GBPUSD NZDJPY";
      COMBINATIONS[89]="AUDCHF NZDCAD USDJPY";
      COMBINATIONS[90]="AUDCHF NZDJPY USDCAD";
      COMBINATIONS[91]="AUDJPY CADCHF EURGBP";
      COMBINATIONS[92]="AUDJPY CADCHF EURNZD";
      COMBINATIONS[93]="AUDJPY CADCHF EURUSD";
      COMBINATIONS[94]="AUDJPY CADCHF GBPNZD";
      COMBINATIONS[95]="AUDJPY CADCHF GBPUSD";
      COMBINATIONS[96]="AUDJPY CADCHF NZDUSD";
      COMBINATIONS[97]="AUDJPY EURCAD GBPCHF";
      COMBINATIONS[98]="AUDJPY EURCAD GBPNZD";
      COMBINATIONS[99]="AUDJPY EURCAD GBPUSD";
      COMBINATIONS[100]="AUDJPY EURCAD NZDCHF";
      COMBINATIONS[101]="AUDJPY EURCAD NZDUSD";
      COMBINATIONS[102]="AUDJPY EURCAD USDCHF";
      COMBINATIONS[103]="AUDJPY EURCHF GBPCAD";
      COMBINATIONS[104]="AUDJPY EURCHF GBPNZD";
      COMBINATIONS[105]="AUDJPY EURCHF GBPUSD";
      COMBINATIONS[106]="AUDJPY EURCHF NZDCAD";
      COMBINATIONS[107]="AUDJPY EURCHF NZDUSD";
      COMBINATIONS[108]="AUDJPY EURCHF USDCAD";
      COMBINATIONS[109]="AUDJPY EURGBP NZDCAD";
      COMBINATIONS[110]="AUDJPY EURGBP NZDCHF";
      COMBINATIONS[111]="AUDJPY EURGBP NZDUSD";
      COMBINATIONS[112]="AUDJPY EURGBP USDCAD";
      COMBINATIONS[113]="AUDJPY EURGBP USDCHF";
      COMBINATIONS[114]="AUDJPY EURNZD GBPCAD";
      COMBINATIONS[115]="AUDJPY EURNZD GBPCHF";
      COMBINATIONS[116]="AUDJPY EURNZD GBPUSD";
      COMBINATIONS[117]="AUDJPY EURNZD USDCAD";
      COMBINATIONS[118]="AUDJPY EURNZD USDCHF";
      COMBINATIONS[119]="AUDJPY EURUSD GBPCAD";
      COMBINATIONS[120]="AUDJPY EURUSD GBPCHF";
      COMBINATIONS[121]="AUDJPY EURUSD GBPNZD";
      COMBINATIONS[122]="AUDJPY EURUSD NZDCAD";
      COMBINATIONS[123]="AUDJPY EURUSD NZDCHF";
      COMBINATIONS[124]="AUDJPY GBPCAD NZDCHF";
      COMBINATIONS[125]="AUDJPY GBPCAD NZDUSD";
      COMBINATIONS[126]="AUDJPY GBPCAD USDCHF";
      COMBINATIONS[127]="AUDJPY GBPCHF NZDCAD";
      COMBINATIONS[128]="AUDJPY GBPCHF NZDUSD";
      COMBINATIONS[129]="AUDJPY GBPCHF USDCAD";
      COMBINATIONS[130]="AUDJPY GBPNZD USDCAD";
      COMBINATIONS[131]="AUDJPY GBPNZD USDCHF";
      COMBINATIONS[132]="AUDJPY GBPUSD NZDCAD";
      COMBINATIONS[133]="AUDJPY GBPUSD NZDCHF";
      COMBINATIONS[134]="AUDJPY NZDCAD USDCHF";
      COMBINATIONS[135]="AUDJPY NZDCHF USDCAD";
      COMBINATIONS[136]="AUDNZD CADCHF EURGBP";
      COMBINATIONS[137]="AUDNZD CADCHF EURJPY";
      COMBINATIONS[138]="AUDNZD CADCHF EURUSD";
      COMBINATIONS[139]="AUDNZD CADCHF GBPJPY";
      COMBINATIONS[140]="AUDNZD CADCHF GBPUSD";
      COMBINATIONS[141]="AUDNZD CADCHF USDJPY";
      COMBINATIONS[142]="AUDNZD CADJPY EURCHF";
      COMBINATIONS[143]="AUDNZD CADJPY EURGBP";
      COMBINATIONS[144]="AUDNZD CADJPY EURUSD";
      COMBINATIONS[145]="AUDNZD CADJPY GBPCHF";
      COMBINATIONS[146]="AUDNZD CADJPY GBPUSD";
      COMBINATIONS[147]="AUDNZD CADJPY USDCHF";
      COMBINATIONS[148]="AUDNZD CHFJPY EURCAD";
      COMBINATIONS[149]="AUDNZD CHFJPY EURGBP";
      COMBINATIONS[150]="AUDNZD CHFJPY EURUSD";
      COMBINATIONS[151]="AUDNZD CHFJPY GBPCAD";
      COMBINATIONS[152]="AUDNZD CHFJPY GBPUSD";
      COMBINATIONS[153]="AUDNZD CHFJPY USDCAD";
      COMBINATIONS[154]="AUDNZD EURCAD GBPCHF";
      COMBINATIONS[155]="AUDNZD EURCAD GBPJPY";
      COMBINATIONS[156]="AUDNZD EURCAD GBPUSD";
      COMBINATIONS[157]="AUDNZD EURCAD USDCHF";
      COMBINATIONS[158]="AUDNZD EURCAD USDJPY";
      COMBINATIONS[159]="AUDNZD EURCHF GBPCAD";
      COMBINATIONS[160]="AUDNZD EURCHF GBPJPY";
      COMBINATIONS[161]="AUDNZD EURCHF GBPUSD";
      COMBINATIONS[162]="AUDNZD EURCHF USDCAD";
      COMBINATIONS[163]="AUDNZD EURCHF USDJPY";
      COMBINATIONS[164]="AUDNZD EURGBP USDCAD";
      COMBINATIONS[165]="AUDNZD EURGBP USDCHF";
      COMBINATIONS[166]="AUDNZD EURGBP USDJPY";
      COMBINATIONS[167]="AUDNZD EURJPY GBPCAD";
      COMBINATIONS[168]="AUDNZD EURJPY GBPCHF";
      COMBINATIONS[169]="AUDNZD EURJPY GBPUSD";
      COMBINATIONS[170]="AUDNZD EURJPY USDCAD";
      COMBINATIONS[171]="AUDNZD EURJPY USDCHF";
      COMBINATIONS[172]="AUDNZD EURUSD GBPCAD";
      COMBINATIONS[173]="AUDNZD EURUSD GBPCHF";
      COMBINATIONS[174]="AUDNZD EURUSD GBPJPY";
      COMBINATIONS[175]="AUDNZD GBPCAD USDCHF";
      COMBINATIONS[176]="AUDNZD GBPCAD USDJPY";
      COMBINATIONS[177]="AUDNZD GBPCHF USDCAD";
      COMBINATIONS[178]="AUDNZD GBPCHF USDJPY";
      COMBINATIONS[179]="AUDNZD GBPJPY USDCAD";
      COMBINATIONS[180]="AUDNZD GBPJPY USDCHF";
      COMBINATIONS[181]="AUDUSD CADCHF EURGBP";
      COMBINATIONS[182]="AUDUSD CADCHF EURJPY";
      COMBINATIONS[183]="AUDUSD CADCHF EURNZD";
      COMBINATIONS[184]="AUDUSD CADCHF GBPJPY";
      COMBINATIONS[185]="AUDUSD CADCHF GBPNZD";
      COMBINATIONS[186]="AUDUSD CADCHF NZDJPY";
      COMBINATIONS[187]="AUDUSD CADJPY EURCHF";
      COMBINATIONS[188]="AUDUSD CADJPY EURGBP";
      COMBINATIONS[189]="AUDUSD CADJPY EURNZD";
      COMBINATIONS[190]="AUDUSD CADJPY GBPCHF";
      COMBINATIONS[191]="AUDUSD CADJPY GBPNZD";
      COMBINATIONS[192]="AUDUSD CADJPY NZDCHF";
      COMBINATIONS[193]="AUDUSD CHFJPY EURCAD";
      COMBINATIONS[194]="AUDUSD CHFJPY EURGBP";
      COMBINATIONS[195]="AUDUSD CHFJPY EURNZD";
      COMBINATIONS[196]="AUDUSD CHFJPY GBPCAD";
      COMBINATIONS[197]="AUDUSD CHFJPY GBPNZD";
      COMBINATIONS[198]="AUDUSD CHFJPY NZDCAD";
      COMBINATIONS[199]="AUDUSD EURCAD GBPCHF";
      COMBINATIONS[200]="AUDUSD EURCAD GBPJPY";
      COMBINATIONS[201]="AUDUSD EURCAD GBPNZD";
      COMBINATIONS[202]="AUDUSD EURCAD NZDCHF";
      COMBINATIONS[203]="AUDUSD EURCAD NZDJPY";
      COMBINATIONS[204]="AUDUSD EURCHF GBPCAD";
      COMBINATIONS[205]="AUDUSD EURCHF GBPJPY";
      COMBINATIONS[206]="AUDUSD EURCHF GBPNZD";
      COMBINATIONS[207]="AUDUSD EURCHF NZDCAD";
      COMBINATIONS[208]="AUDUSD EURCHF NZDJPY";
      COMBINATIONS[209]="AUDUSD EURGBP NZDCAD";
      COMBINATIONS[210]="AUDUSD EURGBP NZDCHF";
      COMBINATIONS[211]="AUDUSD EURGBP NZDJPY";
      COMBINATIONS[212]="AUDUSD EURJPY GBPCAD";
      COMBINATIONS[213]="AUDUSD EURJPY GBPCHF";
      COMBINATIONS[214]="AUDUSD EURJPY GBPNZD";
      COMBINATIONS[215]="AUDUSD EURJPY NZDCAD";
      COMBINATIONS[216]="AUDUSD EURJPY NZDCHF";
      COMBINATIONS[217]="AUDUSD EURNZD GBPCAD";
      COMBINATIONS[218]="AUDUSD EURNZD GBPCHF";
      COMBINATIONS[219]="AUDUSD EURNZD GBPJPY";
      COMBINATIONS[220]="AUDUSD GBPCAD NZDCHF";
      COMBINATIONS[221]="AUDUSD GBPCAD NZDJPY";
      COMBINATIONS[222]="AUDUSD GBPCHF NZDCAD";
      COMBINATIONS[223]="AUDUSD GBPCHF NZDJPY";
      COMBINATIONS[224]="AUDUSD GBPJPY NZDCAD";
      COMBINATIONS[225]="AUDUSD GBPJPY NZDCHF";
      COMBINATIONS[226]="CADCHF EURAUD GBPJPY";
      COMBINATIONS[227]="CADCHF EURAUD GBPNZD";
      COMBINATIONS[228]="CADCHF EURAUD GBPUSD";
      COMBINATIONS[229]="CADCHF EURAUD NZDJPY";
      COMBINATIONS[230]="CADCHF EURAUD NZDUSD";
      COMBINATIONS[231]="CADCHF EURAUD USDJPY";
      COMBINATIONS[232]="CADCHF EURGBP NZDJPY";
      COMBINATIONS[233]="CADCHF EURGBP NZDUSD";
      COMBINATIONS[234]="CADCHF EURGBP USDJPY";
      COMBINATIONS[235]="CADCHF EURJPY GBPAUD";
      COMBINATIONS[236]="CADCHF EURJPY GBPNZD";
      COMBINATIONS[237]="CADCHF EURJPY GBPUSD";
      COMBINATIONS[238]="CADCHF EURJPY NZDUSD";
      COMBINATIONS[239]="CADCHF EURNZD GBPAUD";
      COMBINATIONS[240]="CADCHF EURNZD GBPJPY";
      COMBINATIONS[241]="CADCHF EURNZD GBPUSD";
      COMBINATIONS[242]="CADCHF EURNZD USDJPY";
      COMBINATIONS[243]="CADCHF EURUSD GBPAUD";
      COMBINATIONS[244]="CADCHF EURUSD GBPJPY";
      COMBINATIONS[245]="CADCHF EURUSD GBPNZD";
      COMBINATIONS[246]="CADCHF EURUSD NZDJPY";
      COMBINATIONS[247]="CADCHF GBPAUD NZDJPY";
      COMBINATIONS[248]="CADCHF GBPAUD NZDUSD";
      COMBINATIONS[249]="CADCHF GBPAUD USDJPY";
      COMBINATIONS[250]="CADCHF GBPJPY NZDUSD";
      COMBINATIONS[251]="CADCHF GBPNZD USDJPY";
      COMBINATIONS[252]="CADCHF GBPUSD NZDJPY";
      COMBINATIONS[253]="CADJPY EURAUD GBPCHF";
      COMBINATIONS[254]="CADJPY EURAUD GBPNZD";
      COMBINATIONS[255]="CADJPY EURAUD GBPUSD";
      COMBINATIONS[256]="CADJPY EURAUD NZDCHF";
      COMBINATIONS[257]="CADJPY EURAUD NZDUSD";
      COMBINATIONS[258]="CADJPY EURAUD USDCHF";
      COMBINATIONS[259]="CADJPY EURCHF GBPAUD";
      COMBINATIONS[260]="CADJPY EURCHF GBPNZD";
      COMBINATIONS[261]="CADJPY EURCHF GBPUSD";
      COMBINATIONS[262]="CADJPY EURCHF NZDUSD";
      COMBINATIONS[263]="CADJPY EURGBP NZDCHF";
      COMBINATIONS[264]="CADJPY EURGBP NZDUSD";
      COMBINATIONS[265]="CADJPY EURGBP USDCHF";
      COMBINATIONS[266]="CADJPY EURNZD GBPAUD";
      COMBINATIONS[267]="CADJPY EURNZD GBPCHF";
      COMBINATIONS[268]="CADJPY EURNZD GBPUSD";
      COMBINATIONS[269]="CADJPY EURNZD USDCHF";
      COMBINATIONS[270]="CADJPY EURUSD GBPAUD";
      COMBINATIONS[271]="CADJPY EURUSD GBPCHF";
      COMBINATIONS[272]="CADJPY EURUSD GBPNZD";
      COMBINATIONS[273]="CADJPY EURUSD NZDCHF";
      COMBINATIONS[274]="CADJPY GBPAUD NZDCHF";
      COMBINATIONS[275]="CADJPY GBPAUD NZDUSD";
      COMBINATIONS[276]="CADJPY GBPAUD USDCHF";
      COMBINATIONS[277]="CADJPY GBPCHF NZDUSD";
      COMBINATIONS[278]="CADJPY GBPNZD USDCHF";
      COMBINATIONS[279]="CADJPY GBPUSD NZDCHF";
      COMBINATIONS[280]="CHFJPY EURAUD GBPCAD";
      COMBINATIONS[281]="CHFJPY EURAUD GBPNZD";
      COMBINATIONS[282]="CHFJPY EURAUD GBPUSD";
      COMBINATIONS[283]="CHFJPY EURAUD NZDCAD";
      COMBINATIONS[284]="CHFJPY EURAUD NZDUSD";
      COMBINATIONS[285]="CHFJPY EURAUD USDCAD";
      COMBINATIONS[286]="CHFJPY EURCAD GBPAUD";
      COMBINATIONS[287]="CHFJPY EURCAD GBPNZD";
      COMBINATIONS[288]="CHFJPY EURCAD GBPUSD";
      COMBINATIONS[289]="CHFJPY EURCAD NZDUSD";
      COMBINATIONS[290]="CHFJPY EURGBP NZDCAD";
      COMBINATIONS[291]="CHFJPY EURGBP NZDUSD";
      COMBINATIONS[292]="CHFJPY EURGBP USDCAD";
      COMBINATIONS[293]="CHFJPY EURNZD GBPAUD";
      COMBINATIONS[294]="CHFJPY EURNZD GBPCAD";
      COMBINATIONS[295]="CHFJPY EURNZD GBPUSD";
      COMBINATIONS[296]="CHFJPY EURNZD USDCAD";
      COMBINATIONS[297]="CHFJPY EURUSD GBPAUD";
      COMBINATIONS[298]="CHFJPY EURUSD GBPCAD";
      COMBINATIONS[299]="CHFJPY EURUSD GBPNZD";
      COMBINATIONS[300]="CHFJPY EURUSD NZDCAD";
      COMBINATIONS[301]="CHFJPY GBPAUD NZDCAD";
      COMBINATIONS[302]="CHFJPY GBPAUD NZDUSD";
      COMBINATIONS[303]="CHFJPY GBPAUD USDCAD";
      COMBINATIONS[304]="CHFJPY GBPCAD NZDUSD";
      COMBINATIONS[305]="CHFJPY GBPNZD USDCAD";
      COMBINATIONS[306]="CHFJPY GBPUSD NZDCAD";
      COMBINATIONS[307]="EURAUD GBPCAD NZDCHF";
      COMBINATIONS[308]="EURAUD GBPCAD NZDJPY";
      COMBINATIONS[309]="EURAUD GBPCAD NZDUSD";
      COMBINATIONS[310]="EURAUD GBPCAD USDCHF";
      COMBINATIONS[311]="EURAUD GBPCAD USDJPY";
      COMBINATIONS[312]="EURAUD GBPCHF NZDCAD";
      COMBINATIONS[313]="EURAUD GBPCHF NZDJPY";
      COMBINATIONS[314]="EURAUD GBPCHF NZDUSD";
      COMBINATIONS[315]="EURAUD GBPCHF USDCAD";
      COMBINATIONS[316]="EURAUD GBPCHF USDJPY";
      COMBINATIONS[317]="EURAUD GBPJPY NZDCAD";
      COMBINATIONS[318]="EURAUD GBPJPY NZDCHF";
      COMBINATIONS[319]="EURAUD GBPJPY NZDUSD";
      COMBINATIONS[320]="EURAUD GBPJPY USDCAD";
      COMBINATIONS[321]="EURAUD GBPJPY USDCHF";
      COMBINATIONS[322]="EURAUD GBPNZD USDCAD";
      COMBINATIONS[323]="EURAUD GBPNZD USDCHF";
      COMBINATIONS[324]="EURAUD GBPNZD USDJPY";
      COMBINATIONS[325]="EURAUD GBPUSD NZDCAD";
      COMBINATIONS[326]="EURAUD GBPUSD NZDCHF";
      COMBINATIONS[327]="EURAUD GBPUSD NZDJPY";
      COMBINATIONS[328]="EURAUD NZDCAD USDCHF";
      COMBINATIONS[329]="EURAUD NZDCAD USDJPY";
      COMBINATIONS[330]="EURAUD NZDCHF USDCAD";
      COMBINATIONS[331]="EURAUD NZDCHF USDJPY";
      COMBINATIONS[332]="EURAUD NZDJPY USDCAD";
      COMBINATIONS[333]="EURAUD NZDJPY USDCHF";
      COMBINATIONS[334]="EURCAD GBPAUD NZDCHF";
      COMBINATIONS[335]="EURCAD GBPAUD NZDJPY";
      COMBINATIONS[336]="EURCAD GBPAUD NZDUSD";
      COMBINATIONS[337]="EURCAD GBPAUD USDCHF";
      COMBINATIONS[338]="EURCAD GBPAUD USDJPY";
      COMBINATIONS[339]="EURCAD GBPCHF NZDJPY";
      COMBINATIONS[340]="EURCAD GBPCHF NZDUSD";
      COMBINATIONS[341]="EURCAD GBPCHF USDJPY";
      COMBINATIONS[342]="EURCAD GBPJPY NZDCHF";
      COMBINATIONS[343]="EURCAD GBPJPY NZDUSD";
      COMBINATIONS[344]="EURCAD GBPJPY USDCHF";
      COMBINATIONS[345]="EURCAD GBPNZD USDCHF";
      COMBINATIONS[346]="EURCAD GBPNZD USDJPY";
      COMBINATIONS[347]="EURCAD GBPUSD NZDCHF";
      COMBINATIONS[348]="EURCAD GBPUSD NZDJPY";
      COMBINATIONS[349]="EURCAD NZDCHF USDJPY";
      COMBINATIONS[350]="EURCAD NZDJPY USDCHF";
      COMBINATIONS[351]="EURCHF GBPAUD NZDCAD";
      COMBINATIONS[352]="EURCHF GBPAUD NZDJPY";
      COMBINATIONS[353]="EURCHF GBPAUD NZDUSD";
      COMBINATIONS[354]="EURCHF GBPAUD USDCAD";
      COMBINATIONS[355]="EURCHF GBPAUD USDJPY";
      COMBINATIONS[356]="EURCHF GBPCAD NZDJPY";
      COMBINATIONS[357]="EURCHF GBPCAD NZDUSD";
      COMBINATIONS[358]="EURCHF GBPCAD USDJPY";
      COMBINATIONS[359]="EURCHF GBPJPY NZDCAD";
      COMBINATIONS[360]="EURCHF GBPJPY NZDUSD";
      COMBINATIONS[361]="EURCHF GBPJPY USDCAD";
      COMBINATIONS[362]="EURCHF GBPNZD USDCAD";
      COMBINATIONS[363]="EURCHF GBPNZD USDJPY";
      COMBINATIONS[364]="EURCHF GBPUSD NZDCAD";
      COMBINATIONS[365]="EURCHF GBPUSD NZDJPY";
      COMBINATIONS[366]="EURCHF NZDCAD USDJPY";
      COMBINATIONS[367]="EURCHF NZDJPY USDCAD";
      COMBINATIONS[368]="EURGBP NZDCAD USDCHF";
      COMBINATIONS[369]="EURGBP NZDCAD USDJPY";
      COMBINATIONS[370]="EURGBP NZDCHF USDCAD";
      COMBINATIONS[371]="EURGBP NZDCHF USDJPY";
      COMBINATIONS[372]="EURGBP NZDJPY USDCAD";
      COMBINATIONS[373]="EURGBP NZDJPY USDCHF";
      COMBINATIONS[374]="EURJPY GBPAUD NZDCAD";
      COMBINATIONS[375]="EURJPY GBPAUD NZDCHF";
      COMBINATIONS[376]="EURJPY GBPAUD NZDUSD";
      COMBINATIONS[377]="EURJPY GBPAUD USDCAD";
      COMBINATIONS[378]="EURJPY GBPAUD USDCHF";
      COMBINATIONS[379]="EURJPY GBPCAD NZDCHF";
      COMBINATIONS[380]="EURJPY GBPCAD NZDUSD";
      COMBINATIONS[381]="EURJPY GBPCAD USDCHF";
      COMBINATIONS[382]="EURJPY GBPCHF NZDCAD";
      COMBINATIONS[383]="EURJPY GBPCHF NZDUSD";
      COMBINATIONS[384]="EURJPY GBPCHF USDCAD";
      COMBINATIONS[385]="EURJPY GBPNZD USDCAD";
      COMBINATIONS[386]="EURJPY GBPNZD USDCHF";
      COMBINATIONS[387]="EURJPY GBPUSD NZDCAD";
      COMBINATIONS[388]="EURJPY GBPUSD NZDCHF";
      COMBINATIONS[389]="EURJPY NZDCAD USDCHF";
      COMBINATIONS[390]="EURJPY NZDCHF USDCAD";
      COMBINATIONS[391]="EURNZD GBPAUD USDCAD";
      COMBINATIONS[392]="EURNZD GBPAUD USDCHF";
      COMBINATIONS[393]="EURNZD GBPAUD USDJPY";
      COMBINATIONS[394]="EURNZD GBPCAD USDCHF";
      COMBINATIONS[395]="EURNZD GBPCAD USDJPY";
      COMBINATIONS[396]="EURNZD GBPCHF USDCAD";
      COMBINATIONS[397]="EURNZD GBPCHF USDJPY";
      COMBINATIONS[398]="EURNZD GBPJPY USDCAD";
      COMBINATIONS[399]="EURNZD GBPJPY USDCHF";
      COMBINATIONS[400]="EURUSD GBPAUD NZDCAD";
      COMBINATIONS[401]="EURUSD GBPAUD NZDCHF";
      COMBINATIONS[402]="EURUSD GBPAUD NZDJPY";
      COMBINATIONS[403]="EURUSD GBPCAD NZDCHF";
      COMBINATIONS[404]="EURUSD GBPCAD NZDJPY";
      COMBINATIONS[405]="EURUSD GBPCHF NZDCAD";
      COMBINATIONS[406]="EURUSD GBPCHF NZDJPY";
      COMBINATIONS[407]="EURUSD GBPJPY NZDCAD";
      COMBINATIONS[408]="EURUSD GBPJPY NZDCHF";
      COMBINATIONS[409]="GBPAUD NZDCAD USDCHF";
      COMBINATIONS[410]="GBPAUD NZDCAD USDJPY";
      COMBINATIONS[411]="GBPAUD NZDCHF USDCAD";
      COMBINATIONS[412]="GBPAUD NZDCHF USDJPY";
      COMBINATIONS[413]="GBPAUD NZDJPY USDCAD";
      COMBINATIONS[414]="GBPAUD NZDJPY USDCHF";
      COMBINATIONS[415]="GBPCAD NZDCHF USDJPY";
      COMBINATIONS[416]="GBPCAD NZDJPY USDCHF";
      COMBINATIONS[417]="GBPCHF NZDCAD USDJPY";
      COMBINATIONS[418]="GBPCHF NZDJPY USDCAD";
      COMBINATIONS[419]="GBPJPY NZDCAD USDCHF";
      COMBINATIONS[420]="GBPJPY NZDCHF USDCAD";
      num_combos=420;
      num_symbols=3;
     }

//---

   if(Generation_Type==twos210)
     {
      COMBINATIONS[1]="AUDCAD CHFJPY";
      COMBINATIONS[2]="AUDCAD EURCHF";
      COMBINATIONS[3]="AUDCAD EURGBP";
      COMBINATIONS[4]="AUDCAD EURJPY";
      COMBINATIONS[5]="AUDCAD EURNZD";
      COMBINATIONS[6]="AUDCAD EURUSD";
      COMBINATIONS[7]="AUDCAD GBPCHF";
      COMBINATIONS[8]="AUDCAD GBPJPY";
      COMBINATIONS[9]="AUDCAD GBPNZD";
      COMBINATIONS[10]="AUDCAD GBPUSD";
      COMBINATIONS[11]="AUDCAD NZDCHF";
      COMBINATIONS[12]="AUDCAD NZDJPY";
      COMBINATIONS[13]="AUDCAD NZDUSD";
      COMBINATIONS[14]="AUDCAD USDCHF";
      COMBINATIONS[15]="AUDCAD USDJPY";
      COMBINATIONS[16]="AUDCHF CADJPY";
      COMBINATIONS[17]="AUDCHF EURCAD";
      COMBINATIONS[18]="AUDCHF EURGBP";
      COMBINATIONS[19]="AUDCHF EURJPY";
      COMBINATIONS[20]="AUDCHF EURNZD";
      COMBINATIONS[21]="AUDCHF EURUSD";
      COMBINATIONS[22]="AUDCHF GBPCAD";
      COMBINATIONS[23]="AUDCHF GBPJPY";
      COMBINATIONS[24]="AUDCHF GBPNZD";
      COMBINATIONS[25]="AUDCHF GBPUSD";
      COMBINATIONS[26]="AUDCHF NZDCAD";
      COMBINATIONS[27]="AUDCHF NZDJPY";
      COMBINATIONS[28]="AUDCHF NZDUSD";
      COMBINATIONS[29]="AUDCHF USDCAD";
      COMBINATIONS[30]="AUDCHF USDJPY";
      COMBINATIONS[31]="AUDJPY CADCHF";
      COMBINATIONS[32]="AUDJPY EURCAD";
      COMBINATIONS[33]="AUDJPY EURCHF";
      COMBINATIONS[34]="AUDJPY EURGBP";
      COMBINATIONS[35]="AUDJPY EURNZD";
      COMBINATIONS[36]="AUDJPY EURUSD";
      COMBINATIONS[37]="AUDJPY GBPCAD";
      COMBINATIONS[38]="AUDJPY GBPCHF";
      COMBINATIONS[39]="AUDJPY GBPNZD";
      COMBINATIONS[40]="AUDJPY GBPUSD";
      COMBINATIONS[41]="AUDJPY NZDCAD";
      COMBINATIONS[42]="AUDJPY NZDCHF";
      COMBINATIONS[43]="AUDJPY NZDUSD";
      COMBINATIONS[44]="AUDJPY USDCAD";
      COMBINATIONS[45]="AUDJPY USDCHF";
      COMBINATIONS[46]="AUDNZD CADCHF";
      COMBINATIONS[47]="AUDNZD CADJPY";
      COMBINATIONS[48]="AUDNZD CHFJPY";
      COMBINATIONS[49]="AUDNZD EURCAD";
      COMBINATIONS[50]="AUDNZD EURCHF";
      COMBINATIONS[51]="AUDNZD EURGBP";
      COMBINATIONS[52]="AUDNZD EURJPY";
      COMBINATIONS[53]="AUDNZD EURUSD";
      COMBINATIONS[54]="AUDNZD GBPCAD";
      COMBINATIONS[55]="AUDNZD GBPCHF";
      COMBINATIONS[56]="AUDNZD GBPJPY";
      COMBINATIONS[57]="AUDNZD GBPUSD";
      COMBINATIONS[58]="AUDNZD USDCAD";
      COMBINATIONS[59]="AUDNZD USDCHF";
      COMBINATIONS[60]="AUDNZD USDJPY";
      COMBINATIONS[61]="AUDUSD CADCHF";
      COMBINATIONS[62]="AUDUSD CADJPY";
      COMBINATIONS[63]="AUDUSD CHFJPY";
      COMBINATIONS[64]="AUDUSD EURCAD";
      COMBINATIONS[65]="AUDUSD EURCHF";
      COMBINATIONS[66]="AUDUSD EURGBP";
      COMBINATIONS[67]="AUDUSD EURJPY";
      COMBINATIONS[68]="AUDUSD EURNZD";
      COMBINATIONS[69]="AUDUSD GBPCAD";
      COMBINATIONS[70]="AUDUSD GBPCHF";
      COMBINATIONS[71]="AUDUSD GBPJPY";
      COMBINATIONS[72]="AUDUSD GBPNZD";
      COMBINATIONS[73]="AUDUSD NZDCAD";
      COMBINATIONS[74]="AUDUSD NZDCHF";
      COMBINATIONS[75]="AUDUSD NZDJPY";
      COMBINATIONS[76]="CADCHF EURAUD";
      COMBINATIONS[77]="CADCHF EURGBP";
      COMBINATIONS[78]="CADCHF EURJPY";
      COMBINATIONS[79]="CADCHF EURNZD";
      COMBINATIONS[80]="CADCHF EURUSD";
      COMBINATIONS[81]="CADCHF GBPAUD";
      COMBINATIONS[82]="CADCHF GBPJPY";
      COMBINATIONS[83]="CADCHF GBPNZD";
      COMBINATIONS[84]="CADCHF GBPUSD";
      COMBINATIONS[85]="CADCHF NZDJPY";
      COMBINATIONS[86]="CADCHF NZDUSD";
      COMBINATIONS[87]="CADCHF USDJPY";
      COMBINATIONS[88]="CADJPY EURAUD";
      COMBINATIONS[89]="CADJPY EURCHF";
      COMBINATIONS[90]="CADJPY EURGBP";
      COMBINATIONS[91]="CADJPY EURNZD";
      COMBINATIONS[92]="CADJPY EURUSD";
      COMBINATIONS[93]="CADJPY GBPAUD";
      COMBINATIONS[94]="CADJPY GBPCHF";
      COMBINATIONS[95]="CADJPY GBPNZD";
      COMBINATIONS[96]="CADJPY GBPUSD";
      COMBINATIONS[97]="CADJPY NZDCHF";
      COMBINATIONS[98]="CADJPY NZDUSD";
      COMBINATIONS[99]="CADJPY USDCHF";
      COMBINATIONS[100]="CHFJPY EURAUD";
      COMBINATIONS[101]="CHFJPY EURCAD";
      COMBINATIONS[102]="CHFJPY EURGBP";
      COMBINATIONS[103]="CHFJPY EURNZD";
      COMBINATIONS[104]="CHFJPY EURUSD";
      COMBINATIONS[105]="CHFJPY GBPAUD";
      COMBINATIONS[106]="CHFJPY GBPCAD";
      COMBINATIONS[107]="CHFJPY GBPNZD";
      COMBINATIONS[108]="CHFJPY GBPUSD";
      COMBINATIONS[109]="CHFJPY NZDCAD";
      COMBINATIONS[110]="CHFJPY NZDUSD";
      COMBINATIONS[111]="CHFJPY USDCAD";
      COMBINATIONS[112]="EURAUD GBPCAD";
      COMBINATIONS[113]="EURAUD GBPCHF";
      COMBINATIONS[114]="EURAUD GBPJPY";
      COMBINATIONS[115]="EURAUD GBPNZD";
      COMBINATIONS[116]="EURAUD GBPUSD";
      COMBINATIONS[117]="EURAUD NZDCAD";
      COMBINATIONS[118]="EURAUD NZDCHF";
      COMBINATIONS[119]="EURAUD NZDJPY";
      COMBINATIONS[120]="EURAUD NZDUSD";
      COMBINATIONS[121]="EURAUD USDCAD";
      COMBINATIONS[122]="EURAUD USDCHF";
      COMBINATIONS[123]="EURAUD USDJPY";
      COMBINATIONS[124]="EURCAD GBPAUD";
      COMBINATIONS[125]="EURCAD GBPCHF";
      COMBINATIONS[126]="EURCAD GBPJPY";
      COMBINATIONS[127]="EURCAD GBPNZD";
      COMBINATIONS[128]="EURCAD GBPUSD";
      COMBINATIONS[129]="EURCAD NZDCHF";
      COMBINATIONS[130]="EURCAD NZDJPY";
      COMBINATIONS[131]="EURCAD NZDUSD";
      COMBINATIONS[132]="EURCAD USDCHF";
      COMBINATIONS[133]="EURCAD USDJPY";
      COMBINATIONS[134]="EURCHF GBPAUD";
      COMBINATIONS[135]="EURCHF GBPCAD";
      COMBINATIONS[136]="EURCHF GBPJPY";
      COMBINATIONS[137]="EURCHF GBPNZD";
      COMBINATIONS[138]="EURCHF GBPUSD";
      COMBINATIONS[139]="EURCHF NZDCAD";
      COMBINATIONS[140]="EURCHF NZDJPY";
      COMBINATIONS[141]="EURCHF NZDUSD";
      COMBINATIONS[142]="EURCHF USDCAD";
      COMBINATIONS[143]="EURCHF USDJPY";
      COMBINATIONS[144]="EURGBP NZDCAD";
      COMBINATIONS[145]="EURGBP NZDCHF";
      COMBINATIONS[146]="EURGBP NZDJPY";
      COMBINATIONS[147]="EURGBP NZDUSD";
      COMBINATIONS[148]="EURGBP USDCAD";
      COMBINATIONS[149]="EURGBP USDCHF";
      COMBINATIONS[150]="EURGBP USDJPY";
      COMBINATIONS[151]="EURJPY GBPAUD";
      COMBINATIONS[152]="EURJPY GBPCAD";
      COMBINATIONS[153]="EURJPY GBPCHF";
      COMBINATIONS[154]="EURJPY GBPNZD";
      COMBINATIONS[155]="EURJPY GBPUSD";
      COMBINATIONS[156]="EURJPY NZDCAD";
      COMBINATIONS[157]="EURJPY NZDCHF";
      COMBINATIONS[158]="EURJPY NZDUSD";
      COMBINATIONS[159]="EURJPY USDCAD";
      COMBINATIONS[160]="EURJPY USDCHF";
      COMBINATIONS[161]="EURNZD GBPAUD";
      COMBINATIONS[162]="EURNZD GBPCAD";
      COMBINATIONS[163]="EURNZD GBPCHF";
      COMBINATIONS[164]="EURNZD GBPJPY";
      COMBINATIONS[165]="EURNZD GBPUSD";
      COMBINATIONS[166]="EURNZD USDCAD";
      COMBINATIONS[167]="EURNZD USDCHF";
      COMBINATIONS[168]="EURNZD USDJPY";
      COMBINATIONS[169]="EURUSD GBPAUD";
      COMBINATIONS[170]="EURUSD GBPCAD";
      COMBINATIONS[171]="EURUSD GBPCHF";
      COMBINATIONS[172]="EURUSD GBPJPY";
      COMBINATIONS[173]="EURUSD GBPNZD";
      COMBINATIONS[174]="EURUSD NZDCAD";
      COMBINATIONS[175]="EURUSD NZDCHF";
      COMBINATIONS[176]="EURUSD NZDJPY";
      COMBINATIONS[177]="GBPAUD NZDCAD";
      COMBINATIONS[178]="GBPAUD NZDCHF";
      COMBINATIONS[179]="GBPAUD NZDJPY";
      COMBINATIONS[180]="GBPAUD NZDUSD";
      COMBINATIONS[181]="GBPAUD USDCAD";
      COMBINATIONS[182]="GBPAUD USDCHF";
      COMBINATIONS[183]="GBPAUD USDJPY";
      COMBINATIONS[184]="GBPCAD NZDCHF";
      COMBINATIONS[185]="GBPCAD NZDJPY";
      COMBINATIONS[186]="GBPCAD NZDUSD";
      COMBINATIONS[187]="GBPCAD USDCHF";
      COMBINATIONS[188]="GBPCAD USDJPY";
      COMBINATIONS[189]="GBPCHF NZDCAD";
      COMBINATIONS[190]="GBPCHF NZDJPY";
      COMBINATIONS[191]="GBPCHF NZDUSD";
      COMBINATIONS[192]="GBPCHF USDCAD";
      COMBINATIONS[193]="GBPCHF USDJPY";
      COMBINATIONS[194]="GBPJPY NZDCAD";
      COMBINATIONS[195]="GBPJPY NZDCHF";
      COMBINATIONS[196]="GBPJPY NZDUSD";
      COMBINATIONS[197]="GBPJPY USDCAD";
      COMBINATIONS[198]="GBPJPY USDCHF";
      COMBINATIONS[199]="GBPNZD USDCAD";
      COMBINATIONS[200]="GBPNZD USDCHF";
      COMBINATIONS[201]="GBPNZD USDJPY";
      COMBINATIONS[202]="GBPUSD NZDCAD";
      COMBINATIONS[203]="GBPUSD NZDCHF";
      COMBINATIONS[204]="GBPUSD NZDJPY";
      COMBINATIONS[205]="NZDCAD USDCHF";
      COMBINATIONS[206]="NZDCAD USDJPY";
      COMBINATIONS[207]="NZDCHF USDCAD";
      COMBINATIONS[208]="NZDCHF USDJPY";
      COMBINATIONS[209]="NZDJPY USDCAD";
      COMBINATIONS[210]="NZDJPY USDCHF";
      num_combos=210;
      num_symbols=2;
     }

//---

   if(Generation_Type==indices)
     {
      COMBINATIONS[01]="AUDCAD=+1 AUDCHF=+1 AUDJPY=+1 AUDNZD=+1 AUDUSD=+1 EURAUD=-1 GBPAUD=-1";
      COMBINATIONS[02]="NZDCAD=+1 NZDCHF=+1 NZDJPY=+1 AUDNZD=-1 NZDUSD=+1 EURNZD=-1 GBPNZD=-1";
      COMBINATIONS[03]="GBPCAD=+1 GBPCHF=+1 GBPJPY=+1 EURGBP=-1 GBPUSD=+1 GBPAUD=+1 GBPNZD=+1";
      COMBINATIONS[04]="EURCAD=+1 EURCHF=+1 EURJPY=+1 EURNZD=+1 EURUSD=+1 EURAUD=+1 EURGBP=+1";
      COMBINATIONS[05]="USDCAD=+1 USDCHF=+1 USDJPY=+1 NZDUSD=-1 AUDUSD=-1 EURUSD=-1 GBPUSD=-1";
      COMBINATIONS[06]="AUDCAD=-1 CADCHF=+1 CADJPY=+1 NZDCAD=-1 USDCAD=-1 EURCAD=-1 GBPCAD=-1";
      COMBINATIONS[07]="AUDCHF=-1 CADCHF=-1 CHFJPY=+1 NZDCHF=-1 USDCHF=-1 EURCHF=-1 GBPCHF=+1";
      COMBINATIONS[08]="AUDJPY=-1 CADJPY=-1 CHFJPY=-1 NZDJPY=-1 USDJPY=-1 EURJPY=-1 GBPJPY=-1";
      num_combos=8;
      num_symbols=7;
     }

//---

   num_first=0;
   num_total=num_combos+1;
   num_model=num_combos+2;
   num_main=num_combos+3;
   num_fast=num_combos+4;
   num_slow=num_combos+5;
   num_upper=num_combos+6;
   num_lower=num_combos+7;
   num_zscore=num_combos+8;
   num_macd=num_combos+9;
   dim_size=num_combos+10;

   if(num_combos==0)
     {
      Alert("Zero number of portfolio combinations selected!");
      error=true;
      return;
     }

   if(dim_size>MAX_LINES)
     {
      Alert("Maximum buffers number exceeded!");
      error=true;
      return;
     }

  }
//+------------------------------------------------------------------+