Here is my code please change 
GetEntrySignal_xxx to GetEntrySignal_050 and increment all others by 1
GetExitSignal_xxx to GetExitSignal_050 and increment all others by 1
CreateExitSignal(xx to CreateExitSignal(50 and increment all others by 1
CreateEntrySignal(xx to CreateEntrySignal(50 and increment all others by 1

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_000()
  {
   // Bears Power (20), Level: 0.0000
   double ind0val1  = iBearsPower(NULL, 0, 20, PRICE_CLOSE, 1);
   double ind0val2  = iBearsPower(NULL, 0, 20, PRICE_CLOSE, 2);
   bool   ind0long  = ind0val1 < 0.0000 - sigma && ind0val2 > 0.0000 + sigma;
   bool   ind0short = ind0val1 > 0.0000 + sigma && ind0val2 < 0.0000 - sigma;
   // Bollinger Bands (Close, 41, 2.61)
   double ind1upBand1 = iBands(NULL, 0, 41, 2.61, 0, PRICE_CLOSE, MODE_UPPER, 1);
   double ind1dnBand1 = iBands(NULL, 0, 41, 2.61, 0, PRICE_CLOSE, MODE_LOWER, 1);
   double ind1upBand2 = iBands(NULL, 0, 41, 2.61, 0, PRICE_CLOSE, MODE_UPPER, 2);
   double ind1dnBand2 = iBands(NULL, 0, 41, 2.61, 0, PRICE_CLOSE, MODE_LOWER, 2);
   bool   ind1long    = Open(0) < ind1upBand1 - sigma && Open(1) > ind1upBand2 + sigma;
   bool   ind1short   = Open(0) > ind1dnBand1 + sigma && Open(1) < ind1dnBand2 - sigma;

   return CreateEntrySignal(0, ind0long && ind1long, ind0short && ind1short, 125, 242, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_000()
  {
   // Williams' Percent Range (45), Level: -17.0
   double ind2val1  = iWPR(NULL, 0, 45, 1);
   double ind2val2  = iWPR(NULL, 0, 45, 2);
   bool   ind2long  = ind2val1 > -17.0 + sigma && ind2val2 < -17.0 - sigma;
   bool   ind2short = ind2val1 < -100 - -17.0 - sigma && ind2val2 > -100 - -17.0 + sigma;

   return CreateExitSignal(0, ind2long, ind2short, 125, 242, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_001()
  {
   // MACD Signal (Close, 23, 24, 12)
   double ind0val1  = iMACD(NULL, 0, 23, 24, 12, PRICE_CLOSE, MODE_MAIN, 1) - iMACD(NULL, 0, 23, 24, 12, PRICE_CLOSE ,MODE_SIGNAL, 1);
   double ind0val2  = iMACD(NULL, 0, 23, 24, 12, PRICE_CLOSE, MODE_MAIN, 2) - iMACD(NULL, 0, 23, 24, 12, PRICE_CLOSE ,MODE_SIGNAL, 2);
   bool   ind0long  = ind0val1 < 0 - sigma && ind0val2 > 0 + sigma;
   bool   ind0short = ind0val1 > 0 + sigma && ind0val2 < 0 - sigma;
   // Bulls Power (1), Level: 0.0002
   double ind1val1  = iBullsPower(NULL, 0, 1, PRICE_CLOSE, 1);
   double ind1val2  = iBullsPower(NULL, 0, 1, PRICE_CLOSE, 2);
   bool   ind1long  = ind1val1 < 0.0002 - sigma && ind1val2 > 0.0002 + sigma;
   bool   ind1short = ind1val1 > -0.0002 + sigma && ind1val2 < -0.0002 - sigma;

   return CreateEntrySignal(1, ind0long && ind1long, ind0short && ind1short, 221, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_001()
  {
   // Williams' Percent Range (44), Level: -13.0
   double ind2val1  = iWPR(NULL, 0, 44, 1);
   double ind2val2  = iWPR(NULL, 0, 44, 2);
   bool   ind2long  = ind2val1 > -13.0 + sigma && ind2val2 < -13.0 - sigma;
   bool   ind2short = ind2val1 < -100 - -13.0 - sigma && ind2val2 > -100 - -13.0 + sigma;

   return CreateExitSignal(1, ind2long, ind2short, 221, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_002()
  {
   // Moving Averages Crossover (Simple, Simple, 14, 32)
   double ind0val1  = iMA(NULL, 0, 14, 0, MODE_SMA, PRICE_CLOSE, 1);
   double ind0val2  = iMA(NULL, 0, 32, 0, MODE_SMA, PRICE_CLOSE, 1);
   double ind0val3  = iMA(NULL, 0, 14, 0, MODE_SMA, PRICE_CLOSE, 2);
   double ind0val4  = iMA(NULL, 0, 32, 0, MODE_SMA, PRICE_CLOSE, 2);
   bool   ind0long  = ind0val1 < ind0val2 - sigma && ind0val3 > ind0val4 + sigma;
   bool   ind0short = ind0val1 > ind0val2 + sigma && ind0val3 < ind0val4 - sigma;
   // Bulls Power (43), Level: 0.0000
   double ind1val1  = iBullsPower(NULL, 0, 43, PRICE_CLOSE, 1);
   double ind1val2  = iBullsPower(NULL, 0, 43, PRICE_CLOSE, 2);
   bool   ind1long  = ind1val1 > 0.0000 + sigma && ind1val2 < 0.0000 - sigma;
   bool   ind1short = ind1val1 < 0.0000 - sigma && ind1val2 > 0.0000 + sigma;

   return CreateEntrySignal(2, ind0long && ind1long, ind0short && ind1short, 246, 103, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_002()
  {
   // Moving Average of Oscillator (Close, 16, 33, 4), Level: -0.0004
   double ind2val1  = iOsMA(NULL, 0, 16, 33, 4, PRICE_CLOSE, 1);
   double ind2val2  = iOsMA(NULL, 0, 16, 33, 4, PRICE_CLOSE, 2);
   bool   ind2long  = ind2val1 < -0.0004 - sigma && ind2val2 > -0.0004 + sigma;
   bool   ind2short = ind2val1 > 0.0004 + sigma && ind2val2 < 0.0004 - sigma;

   return CreateExitSignal(2, ind2long, ind2short, 246, 103, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_003()
  {
   // Moving Averages Crossover (Simple, Simple, 5, 36)
   double ind0val1  = iMA(NULL, 0, 5, 0, MODE_SMA, PRICE_CLOSE, 1);
   double ind0val2  = iMA(NULL, 0, 36, 0, MODE_SMA, PRICE_CLOSE, 1);
   double ind0val3  = iMA(NULL, 0, 5, 0, MODE_SMA, PRICE_CLOSE, 2);
   double ind0val4  = iMA(NULL, 0, 36, 0, MODE_SMA, PRICE_CLOSE, 2);
   bool   ind0long  = ind0val1 > ind0val2 + sigma && ind0val3 < ind0val4 - sigma;
   bool   ind0short = ind0val1 < ind0val2 - sigma && ind0val3 > ind0val4 + sigma;
   // Momentum (Close, 20)
   double ind1val1  = iMomentum(NULL, 0, 20, PRICE_CLOSE, 1);
   double ind1val2  = iMomentum(NULL, 0, 20, PRICE_CLOSE, 2);
   double ind1val3  = iMomentum(NULL, 0, 20, PRICE_CLOSE, 3);
   bool   ind1long  = ind1val1 > ind1val2 + sigma && ind1val2 < ind1val3 - sigma;
   bool   ind1short = ind1val1 < ind1val2 - sigma && ind1val2 > ind1val3 + sigma;

   return CreateEntrySignal(3, ind0long && ind1long, ind0short && ind1short, 291, 106, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_003()
  {
   // Momentum (Close, 14), Level: 99.0000
   double ind2val1  = iMomentum(NULL, 0, 14, PRICE_CLOSE, 1);
   bool   ind2long  = ind2val1 < 99.0000 - sigma;
   bool   ind2short = ind2val1 > 200 - 99.0000 + sigma;

   return CreateExitSignal(3, ind2long, ind2short, 291, 106, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_004()
  {
   // Envelopes (Close, Simple, 27, 0.82)
   double ind0upBand1 = iEnvelopes(NULL, 0, 27, MODE_SMA, 0, PRICE_CLOSE, 0.82, MODE_UPPER, 1);
   double ind0dnBand1 = iEnvelopes(NULL, 0, 27, MODE_SMA, 0, PRICE_CLOSE, 0.82, MODE_LOWER, 1);
   double ind0upBand2 = iEnvelopes(NULL, 0, 27, MODE_SMA, 0, PRICE_CLOSE, 0.82, MODE_UPPER, 2);
   double ind0dnBand2 = iEnvelopes(NULL, 0, 27, MODE_SMA, 0, PRICE_CLOSE, 0.82, MODE_LOWER, 2);
   bool   ind0long    = Open(0) < ind0upBand1 - sigma && Open(1) > ind0upBand2 + sigma;
   bool   ind0short   = Open(0) > ind0dnBand1 + sigma && Open(1) < ind0dnBand2 - sigma;

   return CreateEntrySignal(4, ind0long, ind0short, 172, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_004()
  {
   // Bears Power (9), Level: 0.0022
   double ind1val1  = iBearsPower(NULL, 0, 9, PRICE_CLOSE, 1);
   bool   ind1long  = ind1val1 > 0.0022 + sigma;
   bool   ind1short = ind1val1 < -0.0022 - sigma;

   return CreateExitSignal(4, ind1long, ind1short, 172, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_005()
  {
   // RSI (Close, 42)
   double ind0val1  = iRSI(NULL, 0, 42, PRICE_CLOSE, 1);
   double ind0val2  = iRSI(NULL, 0, 42, PRICE_CLOSE, 2);
   bool   ind0long  = ind0val1 > ind0val2 + sigma;
   bool   ind0short = ind0val1 < ind0val2 - sigma;
   // Commodity Channel Index (Typical, 50), Level: 0
   double ind1val1  = iCCI(NULL, 0, 50, PRICE_TYPICAL, 1);
   double ind1val2  = iCCI(NULL, 0, 50, PRICE_TYPICAL, 2);
   bool   ind1long  = ind1val1 < 0 - sigma && ind1val2 > 0 + sigma;
   bool   ind1short = ind1val1 > 0 + sigma && ind1val2 < 0 - sigma;

   return CreateEntrySignal(5, ind0long && ind1long, ind0short && ind1short, 196, 107, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_005()
  {
   // Accelerator Oscillator, Level: -0.0034
   double ind2val1  = iAC(NULL, 0, 1);
   bool   ind2long  = ind2val1 < -0.0034 - sigma;
   bool   ind2short = ind2val1 > 0.0034 + sigma;

   return CreateExitSignal(5, ind2long, ind2short, 196, 107, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_006()
  {
   // MACD Signal (Close, 10, 17, 8)
   double ind0val1  = iMACD(NULL, 0, 10, 17, 8, PRICE_CLOSE, MODE_MAIN, 1) - iMACD(NULL, 0, 10, 17, 8, PRICE_CLOSE ,MODE_SIGNAL, 1);
   double ind0val2  = iMACD(NULL, 0, 10, 17, 8, PRICE_CLOSE, MODE_MAIN, 2) - iMACD(NULL, 0, 10, 17, 8, PRICE_CLOSE ,MODE_SIGNAL, 2);
   bool   ind0long  = ind0val1 > 0 + sigma && ind0val2 < 0 - sigma;
   bool   ind0short = ind0val1 < 0 - sigma && ind0val2 > 0 + sigma;
   // Stochastic (7, 5, 2), Level: 58.0
   double ind1val1  = iStochastic(NULL, 0, 7, 5, 2, MODE_SMA, STO_LOWHIGH, MODE_MAIN, 1);
   double ind1val2  = iStochastic(NULL, 0, 7, 5, 2, MODE_SMA, STO_LOWHIGH, MODE_MAIN, 2);
   bool   ind1long  = ind1val1 < 58.0 - sigma && ind1val2 > 58.0 + sigma;
   bool   ind1short = ind1val1 > 100 - 58.0 + sigma && ind1val2 < 100 - 58.0 - sigma;

   return CreateEntrySignal(6, ind0long && ind1long, ind0short && ind1short, 107, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_006()
  {
   // Moving Averages Crossover (Simple, Simple, 15, 49)
   double ind2val1  = iMA(NULL, 0, 15, 0, MODE_SMA, PRICE_CLOSE, 1);
   double ind2val2  = iMA(NULL, 0, 49, 0, MODE_SMA, PRICE_CLOSE, 1);
   double ind2val3  = iMA(NULL, 0, 15, 0, MODE_SMA, PRICE_CLOSE, 2);
   double ind2val4  = iMA(NULL, 0, 49, 0, MODE_SMA, PRICE_CLOSE, 2);
   bool   ind2long  = ind2val1 > ind2val2 + sigma && ind2val3 < ind2val4 - sigma;
   bool   ind2short = ind2val1 < ind2val2 - sigma && ind2val3 > ind2val4 + sigma;

   return CreateExitSignal(6, ind2long, ind2short, 107, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_007()
  {
   // Moving Averages Crossover (Simple, Simple, 13, 37)
   double ind0val1  = iMA(NULL, 0, 13, 0, MODE_SMA, PRICE_CLOSE, 1);
   double ind0val2  = iMA(NULL, 0, 37, 0, MODE_SMA, PRICE_CLOSE, 1);
   double ind0val3  = iMA(NULL, 0, 13, 0, MODE_SMA, PRICE_CLOSE, 2);
   double ind0val4  = iMA(NULL, 0, 37, 0, MODE_SMA, PRICE_CLOSE, 2);
   bool   ind0long  = ind0val1 > ind0val2 + sigma && ind0val3 < ind0val4 - sigma;
   bool   ind0short = ind0val1 < ind0val2 - sigma && ind0val3 > ind0val4 + sigma;
   // ADX (13)
   double ind1val1  = iADX(NULL, 0, 13, PRICE_CLOSE, 0, 1);
   double ind1val2  = iADX(NULL, 0, 13, PRICE_CLOSE, 0, 2);
   bool   ind1long  = ind1val1 < ind1val2 - sigma;
   bool   ind1short = ind1long;

   return CreateEntrySignal(7, ind0long && ind1long, ind0short && ind1short, 237, 123, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_007()
  {
   // Envelopes (Close, Simple, 8, 0.80)
   double ind2upBand1 = iEnvelopes(NULL, 0, 8, MODE_SMA, 0, PRICE_CLOSE, 0.80, MODE_UPPER, 1);
   double ind2dnBand1 = iEnvelopes(NULL, 0, 8, MODE_SMA, 0, PRICE_CLOSE, 0.80, MODE_LOWER, 1);
   double ind2upBand2 = iEnvelopes(NULL, 0, 8, MODE_SMA, 0, PRICE_CLOSE, 0.80, MODE_UPPER, 2);
   double ind2dnBand2 = iEnvelopes(NULL, 0, 8, MODE_SMA, 0, PRICE_CLOSE, 0.80, MODE_LOWER, 2);
   bool   ind2long    = Open(0) < ind2dnBand1 - sigma && Open(1) > ind2dnBand2 + sigma;
   bool   ind2short   = Open(0) > ind2upBand1 + sigma && Open(1) < ind2upBand2 - sigma;

   return CreateExitSignal(7, ind2long, ind2short, 237, 123, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_008()
  {
   // MACD Signal (Close, 14, 25, 5)
   double ind0val1  = iMACD(NULL, 0, 14, 25, 5, PRICE_CLOSE, MODE_MAIN, 1) - iMACD(NULL, 0, 14, 25, 5, PRICE_CLOSE ,MODE_SIGNAL, 1);
   double ind0val2  = iMACD(NULL, 0, 14, 25, 5, PRICE_CLOSE, MODE_MAIN, 2) - iMACD(NULL, 0, 14, 25, 5, PRICE_CLOSE ,MODE_SIGNAL, 2);
   bool   ind0long  = ind0val1 < 0 - sigma && ind0val2 > 0 + sigma;
   bool   ind0short = ind0val1 > 0 + sigma && ind0val2 < 0 - sigma;
   // Bulls Power (31), Level: 0.0000
   double ind1val1  = iBullsPower(NULL, 0, 31, PRICE_CLOSE, 1);
   double ind1val2  = iBullsPower(NULL, 0, 31, PRICE_CLOSE, 2);
   bool   ind1long  = ind1val1 > 0.0000 + sigma && ind1val2 < 0.0000 - sigma;
   bool   ind1short = ind1val1 < 0.0000 - sigma && ind1val2 > 0.0000 + sigma;

   return CreateEntrySignal(8, ind0long && ind1long, ind0short && ind1short, 181, 374, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_008()
  {
   // Williams' Percent Range (37), Level: -7.0
   double ind2val1  = iWPR(NULL, 0, 37, 1);
   double ind2val2  = iWPR(NULL, 0, 37, 2);
   bool   ind2long  = ind2val1 > -7.0 + sigma && ind2val2 < -7.0 - sigma;
   bool   ind2short = ind2val1 < -100 - -7.0 - sigma && ind2val2 > -100 - -7.0 + sigma;

   return CreateExitSignal(8, ind2long, ind2short, 181, 374, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_009()
  {
   // Directional Indicators (17)
   double ind0val1  = iADX(NULL, 0, 17, PRICE_CLOSE, 1, 1);
   double ind0val2  = iADX(NULL ,0 ,17, PRICE_CLOSE, 2, 1);
   double ind0val3  = iADX(NULL, 0, 17, PRICE_CLOSE, 1, 2);
   double ind0val4  = iADX(NULL ,0 ,17, PRICE_CLOSE, 2, 2);
   bool   ind0long  = ind0val1 > ind0val2 + sigma && ind0val3 < ind0val4 - sigma;
   bool   ind0short = ind0val1 < ind0val2 - sigma && ind0val3 > ind0val4 + sigma;
   // DeMarker (28)
   double ind1val1  = iDeMarker(NULL, 0, 28, 1);
   double ind1val2  = iDeMarker(NULL, 0, 28, 2);
   double ind1val3  = iDeMarker(NULL, 0, 28, 3);
   bool   ind1long  = ind1val1 > ind1val2 + sigma && ind1val2 < ind1val3 - sigma;
   bool   ind1short = ind1val1 < ind1val2 - sigma && ind1val2 > ind1val3 + sigma;

   return CreateEntrySignal(9, ind0long && ind1long, ind0short && ind1short, 227, 102, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_009()
  {
   // Stochastic Signal (3, 1, 1)
   double ind2val1  = iStochastic(NULL, 0, 3, 1, 1, MODE_SMA, 0, MODE_MAIN,   1);
   double ind2val2  = iStochastic(NULL, 0, 3, 1, 1, MODE_SMA, 0, MODE_SIGNAL, 1);
   bool   ind2long  = ind2val1 < ind2val2 - sigma;
   bool   ind2short = ind2val1 > ind2val2 + sigma;

   return CreateExitSignal(9, ind2long, ind2short, 227, 102, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_010()
  {
   // MACD (Close, 25, 29, 9)
   double ind0val1  = iMACD(NULL, 0, 25, 29, 9, PRICE_CLOSE, MODE_MAIN, 1);
   double ind0val2  = iMACD(NULL, 0, 25, 29, 9, PRICE_CLOSE, MODE_MAIN, 2);
   bool   ind0long  = ind0val1 > 0 + sigma && ind0val2 < 0 - sigma;
   bool   ind0short = ind0val1 < 0 - sigma && ind0val2 > 0 + sigma;
   // Moving Average (Simple, Close, 15, 0)
   double ind1val1  = iMA(NULL, 0, 15, 0, MODE_SMA, PRICE_CLOSE, 1);
   double ind1val2  = iMA(NULL, 0, 15, 0, MODE_SMA, PRICE_CLOSE, 2);
   double ind1val3  = iMA(NULL, 0, 15, 0, MODE_SMA, PRICE_CLOSE, 3);
   bool   ind1long  = ind1val1 > ind1val2 + sigma && ind1val2 < ind1val3 - sigma;
   bool   ind1short = ind1val1 < ind1val2 - sigma && ind1val2 > ind1val3 + sigma;

   return CreateEntrySignal(10, ind0long && ind1long, ind0short && ind1short, 233, 144, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_010()
  {
   // RSI (Close, 31), Level: 15
   double ind2val1  = iRSI(NULL, 0, 31, PRICE_CLOSE, 1);
   double ind2val2  = iRSI(NULL, 0, 31, PRICE_CLOSE, 2);
   bool   ind2long  = ind2val1 < 15 - sigma && ind2val2 > 15 + sigma;
   bool   ind2short = ind2val1 > 100 - 15 + sigma && ind2val2 < 100 - 15 - sigma;

   return CreateExitSignal(10, ind2long, ind2short, 233, 144, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_011()
  {
   // MACD Signal (Close, 6, 26, 12)
   double ind0val1  = iMACD(NULL, 0, 6, 26, 12, PRICE_CLOSE, MODE_MAIN, 1) - iMACD(NULL, 0, 6, 26, 12, PRICE_CLOSE ,MODE_SIGNAL, 1);
   double ind0val2  = iMACD(NULL, 0, 6, 26, 12, PRICE_CLOSE, MODE_MAIN, 2) - iMACD(NULL, 0, 6, 26, 12, PRICE_CLOSE ,MODE_SIGNAL, 2);
   bool   ind0long  = ind0val1 > 0 + sigma && ind0val2 < 0 - sigma;
   bool   ind0short = ind0val1 < 0 - sigma && ind0val2 > 0 + sigma;
   // Stochastic Signal (12, 5, 10)
   double ind1val1  = iStochastic(NULL, 0, 12, 5, 10, MODE_SMA, 0, MODE_MAIN,   1);
   double ind1val2  = iStochastic(NULL, 0, 12, 5, 10, MODE_SMA, 0, MODE_SIGNAL, 1);
   double ind1val3  = iStochastic(NULL, 0, 12, 5, 10, MODE_SMA, 0, MODE_MAIN,   2);
   double ind1val4  = iStochastic(NULL, 0, 12, 5, 10, MODE_SMA, 0, MODE_SIGNAL, 2);
   bool   ind1long  = ind1val1 < ind1val2 - sigma && ind1val3 > ind1val4 + sigma;
   bool   ind1short = ind1val1 > ind1val2 + sigma && ind1val3 < ind1val4 - sigma;

   return CreateEntrySignal(11, ind0long && ind1long, ind0short && ind1short, 284, 204, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_011()
  {
   // RSI (Close, 17), Level: 68
   double ind2val1  = iRSI(NULL, 0, 17, PRICE_CLOSE, 1);
   double ind2val2  = iRSI(NULL, 0, 17, PRICE_CLOSE, 2);
   bool   ind2long  = ind2val1 > 68 + sigma && ind2val2 < 68 - sigma;
   bool   ind2short = ind2val1 < 100 - 68 - sigma && ind2val2 > 100 - 68 + sigma;

   return CreateExitSignal(11, ind2long, ind2short, 284, 204, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_012()
  {
   // Bollinger Bands (Close, 38, 3.24)
   double ind0upBand1 = iBands(NULL, 0, 38, 3.24, 0, PRICE_CLOSE, MODE_UPPER, 1);
   double ind0dnBand1 = iBands(NULL, 0, 38, 3.24, 0, PRICE_CLOSE, MODE_LOWER, 1);
   bool   ind0long  = Open(0) > ind0upBand1 + sigma;
   bool   ind0short = Open(0) < ind0dnBand1 - sigma;
   // Bears Power (42), Level: 0.0000
   double ind1val1  = iBearsPower(NULL, 0, 42, PRICE_CLOSE, 1);
   double ind1val2  = iBearsPower(NULL, 0, 42, PRICE_CLOSE, 2);
   bool   ind1long  = ind1val1 > 0.0000 + sigma && ind1val2 < 0.0000 - sigma;
   bool   ind1short = ind1val1 < 0.0000 - sigma && ind1val2 > 0.0000 + sigma;

   return CreateEntrySignal(12, ind0long && ind1long, ind0short && ind1short, 240, 187, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_012()
  {
   // Envelopes (Close, Simple, 6, 0.34)
   double ind2upBand1 = iEnvelopes(NULL, 0, 6, MODE_SMA, 0, PRICE_CLOSE, 0.34, MODE_UPPER, 1);
   double ind2dnBand1 = iEnvelopes(NULL, 0, 6, MODE_SMA, 0, PRICE_CLOSE, 0.34, MODE_LOWER, 1);
   double ind2upBand2 = iEnvelopes(NULL, 0, 6, MODE_SMA, 0, PRICE_CLOSE, 0.34, MODE_UPPER, 2);
   double ind2dnBand2 = iEnvelopes(NULL, 0, 6, MODE_SMA, 0, PRICE_CLOSE, 0.34, MODE_LOWER, 2);
   bool   ind2long    = Open(0) < ind2upBand1 - sigma && Open(1) > ind2upBand2 + sigma;
   bool   ind2short   = Open(0) > ind2dnBand1 + sigma && Open(1) < ind2dnBand2 - sigma;

   return CreateExitSignal(12, ind2long, ind2short, 240, 187, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_013()
  {
   // Alligator (Smoothed, Median, 38, 13, 13, 6, 6, 4)
   double ind0val1  = iAlligator(NULL, 0, 38, 13, 13, 6, 6, 4, MODE_SMMA, PRICE_MEDIAN, MODE_GATORLIPS,  1);
   double ind0val2  = iAlligator(NULL, 0, 38, 13, 13, 6, 6, 4, MODE_SMMA, PRICE_MEDIAN, MODE_GATORJAW,   1);
   double ind0val3  = iAlligator(NULL, 0, 38, 13, 13, 6, 6, 4, MODE_SMMA, PRICE_MEDIAN, MODE_GATORLIPS,  2);
   double ind0val4  = iAlligator(NULL, 0, 38, 13, 13, 6, 6, 4, MODE_SMMA, PRICE_MEDIAN, MODE_GATORJAW,   2);
   bool   ind0long  = ind0val1 > ind0val2 + sigma && ind0val3 < ind0val4 - sigma;
   bool   ind0short = ind0val1 < ind0val2 - sigma && ind0val3 > ind0val4 + sigma;

   return CreateEntrySignal(13, ind0long, ind0short, 279, 192, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_013()
  {
   // Candle Color (7, 5)
   bool ind1long  = false;
   bool ind1short = false;
   {
      int consecutiveBullish = 0;
      int consecutiveBearish = 0;
      double pipVal = pip * 7;

      for (int b = 5 + 2; b > 0; b--)
        {
         consecutiveBullish = Close(b) - Open(b) >= pipVal ? consecutiveBullish + 1 : 0;
         consecutiveBearish = Open(b) - Close(b) >= pipVal ? consecutiveBearish + 1 : 0;
        }

      ind1long  = consecutiveBullish >= 5;
      ind1short = consecutiveBearish >= 5;
   }

   return CreateExitSignal(13, ind1long, ind1short, 279, 192, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_014()
  {
   // Momentum (Close, 3), Level: 100.0000
   double ind0val1  = iMomentum(NULL, 0, 3, PRICE_CLOSE, 1);
   double ind0val2  = iMomentum(NULL, 0, 3, PRICE_CLOSE, 2);
   bool   ind0long  = ind0val1 < 100.0000 - sigma && ind0val2 > 100.0000 + sigma;
   bool   ind0short = ind0val1 > 200 - 100.0000 + sigma && ind0val2 < 200 - 100.0000 - sigma;
   // Envelopes (Close, Simple, 31, 0.62)
   double ind1upBand1 = iEnvelopes(NULL, 0, 31, MODE_SMA, 0, PRICE_CLOSE, 0.62, MODE_UPPER, 1);
   double ind1dnBand1 = iEnvelopes(NULL, 0, 31, MODE_SMA, 0, PRICE_CLOSE, 0.62, MODE_LOWER, 1);
   bool   ind1long  = Open(0) > ind1upBand1 + sigma;
   bool   ind1short = Open(0) < ind1dnBand1 - sigma;

   return CreateEntrySignal(14, ind0long && ind1long, ind0short && ind1short, 179, 362, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_014()
  {
   // DeMarker (37), Level: 0.75
   double ind2val1  = iDeMarker(NULL, 0, 37, 1);
   double ind2val2  = iDeMarker(NULL, 0, 37, 2);
   bool   ind2long  = ind2val1 > 0.75 + sigma && ind2val2 < 0.75 - sigma;
   bool   ind2short = ind2val1 < 1 - 0.75 - sigma && ind2val2 > 1 - 0.75 + sigma;

   return CreateExitSignal(14, ind2long, ind2short, 179, 362, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_015()
  {
   // MACD (Close, 21, 41, 9)
   double ind0val1  = iMACD(NULL, 0, 21, 41, 9, PRICE_CLOSE, MODE_MAIN, 1);
   double ind0val2  = iMACD(NULL, 0, 21, 41, 9, PRICE_CLOSE, MODE_MAIN, 2);
   bool   ind0long  = ind0val1 < 0 - sigma && ind0val2 > 0 + sigma;
   bool   ind0short = ind0val1 > 0 + sigma && ind0val2 < 0 - sigma;
   // MACD (Close, 7, 46, 9)
   double ind1val1  = iMACD(NULL, 0, 7, 46, 9, PRICE_CLOSE, MODE_MAIN, 1);
   bool   ind1long  = ind1val1 > 0 + sigma;
   bool   ind1short = ind1val1 < 0 - sigma;

   return CreateEntrySignal(15, ind0long && ind1long, ind0short && ind1short, 239, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_015()
  {
   // Commodity Channel Index (Typical, 47), Level: 159
   double ind2val1  = iCCI(NULL, 0, 47, PRICE_TYPICAL, 1);
   double ind2val2  = iCCI(NULL, 0, 47, PRICE_TYPICAL, 2);
   bool   ind2long  = ind2val1 > 159 + sigma && ind2val2 < 159 - sigma;
   bool   ind2short = ind2val1 < -159 - sigma && ind2val2 > -159 + sigma;

   return CreateExitSignal(15, ind2long, ind2short, 239, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_016()
  {
   // Stochastic Signal (14, 7, 9)
   double ind0val1  = iStochastic(NULL, 0, 14, 7, 9, MODE_SMA, 0, MODE_MAIN,   1);
   double ind0val2  = iStochastic(NULL, 0, 14, 7, 9, MODE_SMA, 0, MODE_SIGNAL, 1);
   double ind0val3  = iStochastic(NULL, 0, 14, 7, 9, MODE_SMA, 0, MODE_MAIN,   2);
   double ind0val4  = iStochastic(NULL, 0, 14, 7, 9, MODE_SMA, 0, MODE_SIGNAL, 2);
   bool   ind0long  = ind0val1 < ind0val2 - sigma && ind0val3 > ind0val4 + sigma;
   bool   ind0short = ind0val1 > ind0val2 + sigma && ind0val3 < ind0val4 - sigma;
   // Bulls Power (40)
   double ind1val1  = iBullsPower(NULL, 0, 40, PRICE_CLOSE, 1);
   double ind1val2  = iBullsPower(NULL, 0, 40, PRICE_CLOSE, 2);
   bool   ind1long  = ind1val1 > ind1val2 + sigma;
   bool   ind1short = ind1val1 < ind1val2 - sigma;

   return CreateEntrySignal(16, ind0long && ind1long, ind0short && ind1short, 222, 118, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_016()
  {
   // Envelopes (Close, Simple, 24, 0.96)
   double ind2upBand1 = iEnvelopes(NULL, 0, 24, MODE_SMA, 0, PRICE_CLOSE, 0.96, MODE_UPPER, 1);
   double ind2dnBand1 = iEnvelopes(NULL, 0, 24, MODE_SMA, 0, PRICE_CLOSE, 0.96, MODE_LOWER, 1);
   bool   ind2long  = Open(0) < ind2dnBand1 - sigma;
   bool   ind2short = Open(0) > ind2upBand1 + sigma;

   return CreateExitSignal(16, ind2long, ind2short, 222, 118, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_017()
  {
   // ADX (24), Level: 36.0
   double ind0val1  = iADX(NULL, 0, 24, PRICE_CLOSE, 0, 1);
   double ind0val2  = iADX(NULL, 0, 24, PRICE_CLOSE, 0, 2);
   bool   ind0long  = ind0val1 > 36.0 + sigma && ind0val2 < 36.0 - sigma;
   bool   ind0short = ind0long;
   // MACD (Close, 16, 32, 9)
   double ind1val1  = iMACD(NULL, 0, 16, 32, 9, PRICE_CLOSE, MODE_MAIN, 1);
   double ind1val2  = iMACD(NULL, 0, 16, 32, 9, PRICE_CLOSE, MODE_MAIN, 2);
   double ind1val3  = iMACD(NULL, 0, 16, 32, 9, PRICE_CLOSE, MODE_MAIN, 3);
   bool   ind1long  = ind1val1 < ind1val2 - sigma && ind1val2 > ind1val3 + sigma;
   bool   ind1short = ind1val1 > ind1val2 + sigma && ind1val2 < ind1val3 - sigma;

   return CreateEntrySignal(17, ind0long && ind1long, ind0short && ind1short, 131, 246, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_017()
  {
   // MACD Signal (Close, 20, 39, 13)
   double ind2val1  = iMACD(NULL, 0, 20, 39, 13, PRICE_CLOSE, MODE_MAIN, 1) - iMACD(NULL, 0, 20, 39, 13, PRICE_CLOSE ,MODE_SIGNAL, 1);
   double ind2val2  = iMACD(NULL, 0, 20, 39, 13, PRICE_CLOSE, MODE_MAIN, 2) - iMACD(NULL, 0, 20, 39, 13, PRICE_CLOSE ,MODE_SIGNAL, 2);
   bool   ind2long  = ind2val1 > 0 + sigma && ind2val2 < 0 - sigma;
   bool   ind2short = ind2val1 < 0 - sigma && ind2val2 > 0 + sigma;

   return CreateExitSignal(17, ind2long, ind2short, 131, 246, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_018()
  {
   // Envelopes (Close, Simple, 34, 0.82)
   double ind0upBand1 = iEnvelopes(NULL, 0, 34, MODE_SMA, 0, PRICE_CLOSE, 0.82, MODE_UPPER, 1);
   double ind0dnBand1 = iEnvelopes(NULL, 0, 34, MODE_SMA, 0, PRICE_CLOSE, 0.82, MODE_LOWER, 1);
   double ind0upBand2 = iEnvelopes(NULL, 0, 34, MODE_SMA, 0, PRICE_CLOSE, 0.82, MODE_UPPER, 2);
   double ind0dnBand2 = iEnvelopes(NULL, 0, 34, MODE_SMA, 0, PRICE_CLOSE, 0.82, MODE_LOWER, 2);
   bool   ind0long    = Open(0) < ind0upBand1 - sigma && Open(1) > ind0upBand2 + sigma;
   bool   ind0short   = Open(0) > ind0dnBand1 + sigma && Open(1) < ind0dnBand2 - sigma;

   return CreateEntrySignal(18, ind0long, ind0short, 239, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_018()
  {
   // Bollinger Bands (Close, 16, 1.91)
   double ind1upBand1 = iBands(NULL, 0, 16, 1.91, 0, PRICE_CLOSE, MODE_UPPER, 1);
   double ind1dnBand1 = iBands(NULL, 0, 16, 1.91, 0, PRICE_CLOSE, MODE_LOWER, 1);
   bool   ind1long  = Open(0) > ind1upBand1 + sigma;
   bool   ind1short = Open(0) < ind1dnBand1 - sigma;

   return CreateExitSignal(18, ind1long, ind1short, 239, 0, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetEntrySignal_019()
  {
   // Momentum (Close, 10), Level: 100.0000
   double ind0val1  = iMomentum(NULL, 0, 10, PRICE_CLOSE, 1);
   double ind0val2  = iMomentum(NULL, 0, 10, PRICE_CLOSE, 2);
   bool   ind0long  = ind0val1 > 100.0000 + sigma && ind0val2 < 100.0000 - sigma;
   bool   ind0short = ind0val1 < 200 - 100.0000 - sigma && ind0val2 > 200 - 100.0000 + sigma;
   // RSI (Close, 4), Level: 24
   double ind1val1  = iRSI(NULL, 0, 4, PRICE_CLOSE, 1);
   bool   ind1long  = ind1val1 < 24 - sigma;
   bool   ind1short = ind1val1 > 100 - 24 + sigma;

   return CreateEntrySignal(19, ind0long && ind1long, ind0short && ind1short, 287, 361, false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Signal GetExitSignal_019()
  {
   // Bollinger Bands (Close, 37, 3.68)
   double ind2upBand1 = iBands(NULL, 0, 37, 3.68, 0, PRICE_CLOSE, MODE_UPPER, 1);
   double ind2dnBand1 = iBands(NULL, 0, 37, 3.68, 0, PRICE_CLOSE, MODE_LOWER, 1);
   bool   ind2long  = Open(0) > ind2upBand1 + sigma;
   bool   ind2short = Open(0) < ind2dnBand1 - sigma;

   return CreateExitSignal(19, ind2long, ind2short, 287, 361, false);
  }