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[])
{

   int i = MathMax(barsToCount,FiboBars);
      while (i >= 0) 
      
      {
//+---------------------------------------------------------------------------------------------------+
//| Fibo Calculations                                                                                 |
//+---------------------------------------------------------------------------------------------------+

      int FiBo_H_bar = iHighest(NULL,0,MODE_HIGH,FiboBars,i);
      int FiBo_L_bar = iLowest(NULL,0,MODE_LOW,FiboBars,i);
      FiBo_High = iHigh(NULL,0,FiBo_H_bar);
      FiBo_Low = iLow(NULL,0,FiBo_L_bar);
      FiBo_S1 = FiBo_Low+(FiBo_High-FiBo_Low)*0.764;
      FiBo_S2 = FiBo_Low+(FiBo_High-FiBo_Low)*0.618;
      FiBo_S3 = FiBo_Low+(FiBo_High-FiBo_Low)*0.500;
      FiBo_S4 = FiBo_Low+(FiBo_High-FiBo_Low)*0.382;
      FiBo_S5 = FiBo_Low+(FiBo_High-FiBo_Low)*0.236;
      FiBo_R1 = FiBo_High-(FiBo_High-FiBo_Low)*0.764;
      FiBo_R2 = FiBo_High-(FiBo_High-FiBo_Low)*0.618;
      FiBo_R3 = FiBo_High-(FiBo_High-FiBo_Low)*0.500;
      FiBo_R4 = FiBo_High-(FiBo_High-FiBo_Low)*0.382;
      FiBo_R5 = FiBo_High-(FiBo_High-FiBo_Low)*0.236;
         
//+---------------------------------------------------------------------------------------------------+
//| Signal Calculations                                                                          |
//+---------------------------------------------------------------------------------------------------+

   int _barShiftx = iBarShift(NULL, CS_TIMEFRAME, iTime(NULL,CS_TIMEFRAME,i));

// Trend detection (only for Bullish and Bearish Harami, Shooting Star and Hammer)
// Market Trend Up
      if((iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx)>iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+1)) &&
         (iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+1)>iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+2)) &&
         (iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+2)>iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+3)))
         {
         Up=true;
         }
      else
         {
         Up=false;
         }
         
// Market Trend Down
      if((iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx)<iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+1)) &&
         (iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+1)<iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+2)) &&
         (iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+2)<iMA(NULL,CS_TIMEFRAME,5,0,MODE_EMA,PRICE_CLOSE,_barShiftx+3)))
         {
         Down=true;
         }
      else
         {
         Down=false;
         }
         
// Trend detection for final signals
// Trend UP
      if ( (UseTrend_1 && (LR_line1[barsToCount-1]<LR_line1[0])) || (!UseTrend_1 && !UseTrend_2 && !UseTrend_3) )
         {
         Trend1_Up = true;
         } 
      else
         {
         Trend1_Up = false;
         }
      if ( (UseTrend_2 && (LR_line2[barsToCount-1]<LR_line2[0])) || (!UseTrend_1 && !UseTrend_2 && !UseTrend_3) )
         {
         Trend2_Up = true;
         } 
      else
         {
         Trend2_Up = false;
         }
      if ( (UseTrend_3 && (LR_line3[barsToCount-1]<LR_line3[0])) || (!UseTrend_1 && !UseTrend_2 && !UseTrend_3) )
         {
         Trend3_Up = true;
         } 
      else
         {
         Trend3_Up = false;
         }
// Trend DOWN
      if ( (UseTrend_1 && (LR_line1[barsToCount-1]>LR_line1[0])) || (!UseTrend_1 && !UseTrend_2 && !UseTrend_3) )
         {
         Trend1_Down = true;
         } 
      else
         {
         Trend1_Down = false;
         }
      if ( (UseTrend_2 && (LR_line2[barsToCount-1]>LR_line2[0])) || (!UseTrend_1 && !UseTrend_2 && !UseTrend_3) )
         {
         Trend2_Down = true;
         } 
      else
         {
         Trend2_Down = false;
         }
      if ( (UseTrend_3 && (LR_line3[barsToCount-1]>LR_line3[0])) || (!UseTrend_1 && !UseTrend_2 && !UseTrend_3) )
         {
         Trend3_Down = true;
         } 
      else
         {
         Trend3_Down = false;
         }

// Candlestick signals

// A_Bullish signals

//--- Bullish Harami Up
      if( (Down)
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)>iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)>iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)) 
       && (BullHaramiAlert) )
         {
         BullHarami=true;
         }
      else
         {
         BullHarami=false;
         }
         
//--- Bullish Penetrating lines of gobies
      if( (iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)>iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)>iClose(NULL,CS_TIMEFRAME,_barShiftx+2))
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+2))
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (BullCrossAlert) )
         {
         BullCross=true;
         }
      else
         {
         BullCross=false;
         }
         
//--- Bullish Engulfing (2 bars)
      if( (iClose(NULL,CS_TIMEFRAME,_barShiftx+2)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)<iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (BullEngulfAlert) )
         {
         BullEngulf=True;
         }
      else
         {
         BullEngulf=False;
         }
         
//--- Bullish Piercing (2 bars) just looking if there's no BullEngulf
      if(!BullEngulf)
        {
         if( (iClose(NULL,CS_TIMEFRAME,_barShiftx+2)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)) 
          && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)) 
          && ((iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)<iClose(NULL,CS_TIMEFRAME,_barShiftx+2))) 
          && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)>iClose(NULL,CS_TIMEFRAME,_barShiftx+2)+((iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)-iClose(NULL,CS_TIMEFRAME,_barShiftx+2))/2)) 
          && (BullPierceAlert) )
            {
            BullPierce=True;
            }
         else
            {
            BullPierce=False;
            }
        }

//--- Bullish Morning Star (3 bars)
      if( (iClose(NULL,CS_TIMEFRAME,_barShiftx+3)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+3)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)<iClose(NULL,CS_TIMEFRAME,_barShiftx+3)) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+2)<iClose(NULL,CS_TIMEFRAME,_barShiftx+3)) 
       && ((iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)>iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+2))) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)>=iClose(NULL,CS_TIMEFRAME,_barShiftx+3))
       && (MorningStarAlert) )
         {
         MorningStar=True;
         }
      else
         {
         MorningStar=False;
         }
         
//--- Bullish Hammer
      if( (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)-iLow(NULL,CS_TIMEFRAME,_barShiftx+1)>MathMax(iHigh(NULL,CS_TIMEFRAME,_barShiftx+1)-iClose(NULL,CS_TIMEFRAME,_barShiftx+1),iClose(NULL,CS_TIMEFRAME,_barShiftx+1)-iOpen(NULL,CS_TIMEFRAME,_barShiftx+1))*3) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)-iLow(NULL,CS_TIMEFRAME,_barShiftx+1)>MathMax(iHigh(NULL,CS_TIMEFRAME,_barShiftx+1)-iClose(NULL,CS_TIMEFRAME,_barShiftx+1),iClose(NULL,CS_TIMEFRAME,_barShiftx+1)-iOpen(NULL,CS_TIMEFRAME,_barShiftx+1))*3)
       && (BullHammerAlert) )
         {
         Hammer=True;
         }
      else
         {
         Hammer=False;
         }

// B_Bearish signals

//--- Bearish Harami Down
      if( (Up)
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)<iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)<iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+1))
       && (BearHaramiAlert) )
         {
         BearHarami=true;
         }
      else
         {
         BearHarami=false;
         }
         
//--- Bearish Penetrating lines of cubs
      if( (iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)<iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)<iClose(NULL,CS_TIMEFRAME,_barShiftx+2))
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+2))
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (BearCrossAlert) )
         {
         BearCross=true;
         }
      else
         {
         BearCross=false;
         }

//--- Bearish Engulfing (2 bars)
      if( (iClose(NULL,CS_TIMEFRAME,_barShiftx+2)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)>iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && ((iClose(NULL,CS_TIMEFRAME,_barShiftx+1)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)))
       && (BearEngulfAlert) )
         {
         BearEngulf=True;
         }
      else
         {
         BearEngulf=False;
         }
         
//--- Bearish Dark Cloud (2 bars) just looking if there's no BearEngulf
      if(!BearEngulf)
        {
         if( (iClose(NULL,CS_TIMEFRAME,_barShiftx+2)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)) 
          && ((iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)>iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
          && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)<iClose(NULL,CS_TIMEFRAME,_barShiftx+2)-((iClose(NULL,CS_TIMEFRAME,_barShiftx+2)-iOpen(NULL,CS_TIMEFRAME,_barShiftx+2))/2)))
          && (DarkCloudAlert) )
            {
            DarkCloud=True;
            }
         else
            {
            DarkCloud=False;
            }
        }

//--- Bearish Evening Star (3 bars)
      if( (iClose(NULL,CS_TIMEFRAME,_barShiftx+3)>iOpen(NULL,CS_TIMEFRAME,_barShiftx+3)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+2)>iClose(NULL,CS_TIMEFRAME,_barShiftx+3)) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+2)>iClose(NULL,CS_TIMEFRAME,_barShiftx+3)) 
       && ((iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)<iClose(NULL,CS_TIMEFRAME,_barShiftx+2)) 
       && (iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)<iOpen(NULL,CS_TIMEFRAME,_barShiftx+2))) 
       && (iClose(NULL,CS_TIMEFRAME,_barShiftx+1)<iClose(NULL,CS_TIMEFRAME,_barShiftx+3)) 
       && (EveningStarAlert) )
         {
         EveningStar=True;
         }
      else
         {
         EveningStar=False;
         }
         
//---  Shooting Star
      if( (Up)
       && (iHigh(NULL,CS_TIMEFRAME,_barShiftx+1)-iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)>MathMax(iClose(NULL,CS_TIMEFRAME,_barShiftx+1)-iLow(NULL,CS_TIMEFRAME,_barShiftx+1),iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)-iClose(NULL,CS_TIMEFRAME,_barShiftx+1))*3)
       && (iHigh(NULL,CS_TIMEFRAME,_barShiftx+1)-iClose(NULL,CS_TIMEFRAME,_barShiftx+1)>MathMax(iClose(NULL,CS_TIMEFRAME,_barShiftx+1)-iLow(NULL,CS_TIMEFRAME,_barShiftx+1),iOpen(NULL,CS_TIMEFRAME,_barShiftx+1)-iClose(NULL,CS_TIMEFRAME,_barShiftx+1))*3) 
       && (ShooterAlert) )
         {
          Shooter=True;
         }
      else
         {
          Shooter=False;
         }

// Confirmation of signals

      if( (BullHarami || BullCross || BullEngulf || BullPierce || MorningStar) )
      
        {
         CSP_Buy=true;
        }
      else
        {
         CSP_Buy=false; 
        }
        

      if( (BearHarami || BearCross || BearEngulf || DarkCloud || EveningStar || Shooter) ) 
      
        {
         CSP_Sell=true;
        }
      else
        {
         CSP_Sell=false; 
        }

//--- Hammer confirmation separately
      if(Hammer)
        {
         if((Down))
           {
            CSP_Buy=true;
           }
         else
           {
            CSP_Buy=false;
           }
           
         if((Up))
           {
            CSP_Sell=true;
           }
         else
           {
            CSP_Sell=false;
           }
        }
   
// Check touch S/R

//---  Bounce off Support
   SR1_low = false; SR2_low = false; SR3_low = false;
   for (int j = i; j < i+2; j++)
      if ( (UseSR_1&&(((iLow(NULL,0,j) - mabel02[j])/_point)<Distance)&&((iOpen(NULL,0,j)>mabel02[j]))&&((iClose(NULL,0,j)>mabel02[j])))||(!UseSR_1&&!UseSR_2&&!UseSR_3) ) 
      {
      SR1_low = true;
      }
      else
      {
      SR1_low = false;
      }
      
   for (int j = i; j < i+2; j++)
      if ( (UseSR_2&&(((iLow(NULL,0,j) - mabel12[j])/_point)<Distance)&&((iOpen(NULL,0,j)>mabel12[j]))&&((iClose(NULL,0,j)>mabel12[j])))||(!UseSR_1&&!UseSR_2&&!UseSR_3) ) 
      {
      SR2_low = true;
      }
      else
      {
      SR2_low = false;
      }
      
   for (int j = i; j < i+2; j++)
      if ( (UseSR_3&&(((iLow(NULL,0,j) - mabel22[j])/_point)<Distance)&&((iOpen(NULL,0,j)>mabel22[j]))&&((iClose(NULL,0,j)>mabel22[j])))||(!UseSR_1&&!UseSR_2&&!UseSR_3) ) 
      {
      SR3_low = true;
      }
      else
      {
      SR3_low = false;
      }
  
// Bounce off Resistance
   SR1_high = false; SR2_high = false; SR3_high = false;
   for (int j = i; j < i+2; j++)
      if ( (UseSR_1&&(((mabel01[j]-iHigh(NULL,0,j))/_point)<Distance)&&((iOpen(NULL,0,j) < mabel01[j]))&&((iClose(NULL,0,j)<mabel01[j])))||(!UseSR_1&&!UseSR_2&&!UseSR_3) ) 
      {
      SR1_high = true;
      }
      else
      {
      SR1_high = false;
      }

   for (int j = i; j < i+2; j++)
      if ( (UseSR_2&&(((mabel11[j]-iHigh(NULL,0,j))/_point)<Distance)&&((iOpen(NULL,0,j) < mabel11[j]))&&((iClose(NULL,0,j)<mabel11[j])))||(!UseSR_1&&!UseSR_2&&!UseSR_3) )
      {
      SR2_high = true;
      }
      else
      {
      SR2_high = false;
      }

   for (int j = i; j < i+2; j++)
      if ( (UseSR_3&&(((mabel21[j]-iHigh(NULL,0,j))/_point)<Distance)&&((iOpen(NULL,0,j) < mabel21[j]))&&((iClose(NULL,0,j)<mabel21[j])))||(!UseSR_1&&!UseSR_2&&!UseSR_3) ) 
      {
      SR3_high = true;
      }
      else
      {
      SR3_high = false;
      }
   
// Multi timeframe calculations for Raff and SR lines

            for(int z=0;z<=2;z++)    
               {
                 shift[z]=iBarShift(NULL,per[z],iTime(NULL,Period(),i),true);

                 switch(z)
                 {
                   case 0:
                     {
                     
//---  Drawing Raff based on Timeframe 1
                     // variables
                           double a0,b0,c0,
                                  sumy0=0.0,
                                  sumx0=0.0,
                                  sumxy0=0.0,
                                  sumx20=0.0,
                                  h0=0.0,l0=0.0;   
                           int x0;
   
                              // calculate linear regression
                              for(int y0=0; y0<barsToCount; y0++)
                              {
                              int _barShift0 = iBarShift(NULL, TF_1, iTime(NULL,TF_1,y0));
                                 sumy0+=iClose(NULL,TF_1,_barShift0);
                                 sumxy0+=iClose(NULL,TF_1,_barShift0)*y0;
                                 sumx0+=y0;
                                 sumx20+=y0*y0;
                              }
                              
                              c0=MathMax(1,sumx20*barsToCount-sumx0*sumx0);
                              
                              if(c0==0.0)
                              {
                                 Alert("Error in linear regression!");
                                 return(0);
                              }
                              
                           // Line equation    
                              b0=(sumxy0*barsToCount-sumx0*sumy0)/c0;
                              a0=(sumy0-sumx0*b0)/barsToCount;
                              
                           // Linear regression line in buffer with PRICE_CLOSE
                                for(x0=0;x0<barsToCount;x0++)
                                {
                                  int _barShift00 = iBarShift(NULL, TF_1, iTime(NULL,TF_1,x0));
                                  LR_line1[x0]=a0+b0*x0;
                                  if(iClose(NULL,TF_1,_barShift00)-LR_line1[x0] > h0) h0 = iClose(NULL,TF_1,_barShift00)-LR_line1[x0];
                                  if(LR_line1[x0] - iClose(NULL,TF_1,_barShift00)> l0) l0 = LR_line1[x0] - iClose(NULL,TF_1,_barShift00);
                                }  
                              
//---  Drawing support - resistance lines based on Timeframe 1
                              for(x0=0;x0<barsToCount;x0++)
                              if (h0>l0)
                                {
                                  Sup_line1[x0]=a0-h0+b0*x0;
                                  Res_line1[x0]=a0+h0+b0*x0;
                                } 
                              else
                                {
                                  Sup_line1[x0]=a0-l0+b0*x0;
                                  Res_line1[x0]=a0+l0+b0*x0;
                                }
                              
                              LR_line1[x0]  = 0.0;
                              Sup_line1[x0] = 0.0;
                              Res_line1[x0] = 0.0;
                              
                             // Drawing SR based on Timeframe 1
                             if (iFractals(NULL, per[z], MODE_UPPER,shift[z]) > 0) 
                              mabel01[i] = iHigh(NULL,per[z],shift[z]);
                             else
                              mabel01[i] = mabel01[i+1]; 
                   
                             if (iFractals(NULL, per[z], MODE_LOWER,shift[z]) > 0) 
                              mabel02[i] = iLow(NULL,per[z],shift[z]);
                             else
                              mabel02[i] = mabel02[i+1];
                              high0 = mabel01[i];
                              low0 = mabel02[i];   
                              
                           }
                         break;
                         
                   case 1:
                     {
                     
//--- Drawing Raff based on Timeframe 2
                     // variables
                           double a1,b1,c1,
                                  sumy1=0.0,
                                  sumx1=0.0,
                                  sumxy1=0.0,
                                  sumx21=0.0,
                                  h1=0.0,l1=0.0;   
                           int x1;
   
                              // calculate linear regression
                              for(int y1=0; y1<barsToCount; y1++)
                              {
                              int _barShift1 = iBarShift(NULL, TF_2, iTime(NULL,TF_2,y1));
                                 sumy1+=iClose(NULL,TF_2,_barShift1);
                                 sumxy1+=iClose(NULL,TF_2,_barShift1)*y1;
                                 sumx1+=y1;
                                 sumx21+=y1*y1;
                              }
                              
                              c1=MathMax(1,sumx21*barsToCount-sumx1*sumx1);
                              
                              if(c1==0.0)
                              {
                                 Alert("Error in linear regression!");
                                 return(0);
                              }
                              
                           // Line equation    
                              b1=(sumxy1*barsToCount-sumx1*sumy1)/c1;
                              a1=(sumy1-sumx1*b1)/barsToCount;
                              
                           // Linear regression line in buffer with PRICE_CLOSE
                                for(x1=0;x1<barsToCount;x1++)
                                {
                                  int _barShift11 = iBarShift(NULL, TF_2, iTime(NULL,TF_2,x1));
                                  LR_line2[x1]=a1+b1*x1;
                                  if(iClose(NULL,TF_2,_barShift11)-LR_line2[x1] > h1) h1 = iClose(NULL,TF_2,_barShift11)-LR_line2[x1];
                                  if(LR_line2[x1] - iClose(NULL,TF_2,_barShift11)> l1) l1 = LR_line2[x1] - iClose(NULL,TF_2,_barShift11);
                                }  
                              
//---  Drawing support - resistance lines based on Timeframe 2
                              for(x1=0;x1<barsToCount;x1++)
                              if (h1>l1)
                                {
                                  Sup_line2[x1]=a1-h1+b1*x1;
                                  Res_line2[x1]=a1+h1+b1*x1;
                                } 
                              else
                                {
                                  Sup_line2[x1]=a1-l1+b1*x1;
                                  Res_line2[x1]=a1+l1+b1*x1;
                                }
                              
                              LR_line2[x1]  = 0.0;
                              Sup_line2[x1] = 0.0;
                              Res_line2[x1] = 0.0;
                              
                              // Drawing SR based on Timeframe 2
                              if (iFractals(NULL, per[z], MODE_UPPER,shift[z]) > 0) 
                               mabel11[i] = iHigh(NULL,per[z],shift[z]);
                              else
                               mabel11[i] = mabel11[i+1]; 
                     
                              if (iFractals(NULL, per[z], MODE_LOWER,shift[z]) > 0) 
                               mabel12[i] = iLow(NULL,per[z],shift[z]);
                              else
                               mabel12[i] = mabel12[i+1];
                               high1 = mabel11[i];
                               low1 = mabel12[i];
                              
                           }
                         break;    
                         
                   case 2:
                     {
                     
//--- Drawing Raff based on Timeframe 3
                     // variables
                           double a2,b2,c2,
                                  sumy2=0.0,
                                  sumx2=0.0,
                                  sumxy2=0.0,
                                  sumx22=0.0,
                                  h2=0.0,l2=0.0;   
                                  int x2;
   
                              // calculate linear regression
                              for(int y2=0; y2<barsToCount; y2++)
                              {
                              int _barShift2 = iBarShift(NULL, TF_3, iTime(NULL,TF_3,y2));
                                 sumy2+=iClose(NULL,TF_3,_barShift2);
                                 sumxy2+=iClose(NULL,TF_3,_barShift2)*y2;
                                 sumx2+=y2;
                                 sumx22+=y2*y2;
                              }
                              
                              c2=sumx22*barsToCount-sumx2*sumx2;
                              
                              if(c2==0.0)
                              {
                                 Alert("Error in linear regression!");
                                 return(0);
                              }
                              
                           // Line equation    
                              b2=(sumxy2*barsToCount-sumx2*sumy2)/c2;
                              a2=(sumy2-sumx2*b2)/barsToCount;
                              
                           // Linear regression line in buffer with PRICE_CLOSE
                                for(x2=0;x2<barsToCount;x2++)
                                {
                                  int _barShift22 = iBarShift(NULL, TF_3, iTime(NULL,TF_3,x2));
                                  LR_line3[x2]=a2+b2*x2;
                                  if(iClose(NULL,TF_3,_barShift22)-LR_line3[x2] > h2) h2 = iClose(NULL,TF_3,_barShift22)-LR_line3[x2];
                                  if(LR_line3[x2] - iClose(NULL,TF_3,_barShift22)> l2) l2 = LR_line3[x2] - iClose(NULL,TF_3,_barShift22);
                                }  
                              
//---  Drawing support - resistance lines based on Timeframe 3
                              for(x2=0;x2<barsToCount;x2++)
                              if (h2>l2)
                                {
                                  Sup_line3[x2]=a2-h2+b2*x2;
                                  Res_line3[x2]=a2+h2+b2*x2;
                                } 
                              else
                                {
                                  Sup_line3[x2]=a2-l2+b2*x2;
                                  Res_line3[x2]=a2+l2+b2*x2;
                                }
                              
                              LR_line3[x2]  = 0.0;
                              Sup_line3[x2] = 0.0;
                              Res_line3[x2] = 0.0;
                              
                              // Drawing SR based on Timeframe 3
                              if (iFractals(NULL, per[z], MODE_UPPER,shift[z]) > 0) 
                               mabel21[i] = iHigh(NULL,per[z],shift[z]);
                              else
                               mabel21[i] = mabel21[i+1]; 
                     
                              if  (iFractals(NULL, per[z], MODE_LOWER,shift[z]) > 0) 
                               mabel22[i] = iLow(NULL,per[z],shift[z]);
                              else
                               mabel22[i] = mabel22[i+1];
                               high2 = mabel21[i];
                               low2 = mabel22[i];
                              
                           }
                         break;                         
         }
       }


//+---------------------------------------------------------------------------------------------------+
//|                                        Signals                                                    |
//+---------------------------------------------------------------------------------------------------+
{
      if ( i<barsToCount )
      if ( CSP_Buy )
      if ( Trend1_Up || Trend2_Up || Trend3_Up )  
      if ( SR1_low || SR2_low || SR3_low )       
           
      {
      Buy[i] = Low[i]-15*Point;
      }
//+---------------------------------------------------------------------------------------------------+
      if ( i<barsToCount )
      if ( CSP_Sell )
      if ( Trend1_Down || Trend2_Down || Trend3_Down )              
      if ( SR1_high || SR2_high || SR3_high )       

      {
      Sell[i] = High[i]+15*Point;
      }
}