int CLOCK = 5;
int LATCH = 6;
int DATA  = 4;

void ledWrite(int datoByte, int datoByte2, int dela){ //int led2,
  shiftOut(DATA, CLOCK, MSBFIRST, datoByte);
  shiftOut(DATA, CLOCK, MSBFIRST, datoByte2);
  digitalWrite(LATCH, HIGH);
  digitalWrite(LATCH, LOW);
  delay(dela);
}

void setup() 
{
  pinMode(CLOCK, OUTPUT);
  pinMode(LATCH, OUTPUT);
  pinMode(DATA, OUTPUT);
}

void loop() 
{
  int repeticiones = 2;

  //SECUENCIA AVANZAR A LA IZQUIERDA UNO A UNO
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 1;
    int datoByte2 = 0;
    int bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitAnterior = bitRead(datoByte, 7);
      ledWrite(datoByte, datoByte2, 200);
      datoByte2 = datoByte2 << 1;  
      datoByte2 = bitWrite(datoByte2, 0,  bitAnterior);
      datoByte = datoByte << 1;
    }
  }

  //SECUENCIA AVANZAR A LA DERECHA UNO A UNO
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 0;
    int datoByte2 = 128;
    int bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitAnterior = bitRead(datoByte2, 0);
      ledWrite(datoByte, datoByte2, 200);
      datoByte = datoByte >> 1;  
      datoByte = bitWrite(datoByte, 7,  bitAnterior);
      datoByte2 = datoByte2 >> 1;
    }
  }

  //SECUENCIA AVANZAR A LA IZQUIERDA Y A LA DERECHA UNO A UNO
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 1;
    int datoByte2 = 0;
    int bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitAnterior = bitRead(datoByte, 7);
      ledWrite(datoByte, datoByte2, 100);
      datoByte2 = datoByte2 << 1;  
      datoByte2 = bitWrite(datoByte2, 0,  bitAnterior);
      datoByte = datoByte << 1;
    }
    datoByte = 0;
    datoByte2 = 128;
    bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitAnterior = bitRead(datoByte2, 0);
      ledWrite(datoByte, datoByte2, 100);
      datoByte = datoByte >> 1;  
      datoByte = bitWrite(datoByte, 7,  bitAnterior);
      datoByte2 = datoByte2 >> 1;
    }
  }

  //SECUENCIA AVANZAR A LA IZQUIERDA UNO A UNO*****
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 1;
    int datoByte2 = 0;
    int bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitAnterior = bitRead(datoByte, 7);
      ledWrite(~datoByte, ~datoByte2, 200);
      datoByte2 = datoByte2 << 1;  
      datoByte2 = bitWrite(datoByte2, 0,  bitAnterior);
      datoByte = datoByte << 1;
    }
  }

  //SECUENCIA AVANZAR A LA DERECHA UNO A UNO******
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 0;
    int datoByte2 = 128;
    int bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitAnterior = bitRead(datoByte2, 0);
      ledWrite(~datoByte, ~datoByte2, 200);
      datoByte = datoByte >> 1;  
      datoByte = bitWrite(datoByte, 7,  bitAnterior);
      datoByte2 = datoByte2 >> 1;
    }
  }

  //SECUENCIA AVANZAR A LA IZQUIERDA Y A LA DERECHA UNO A UNO****
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 1;
    int datoByte2 = 0;
    int bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitAnterior = bitRead(datoByte, 7);
      ledWrite(~datoByte, ~datoByte2, 200);
      datoByte2 = datoByte2 << 1;  
      datoByte2 = bitWrite(datoByte2, 0,  bitAnterior);
      datoByte = datoByte << 1;
    }
    datoByte = 0;
    datoByte2 = 128;
    bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitAnterior = bitRead(datoByte2, 0);
      ledWrite(~datoByte, ~datoByte2, 200);
      datoByte = datoByte >> 1;  
      datoByte = bitWrite(datoByte, 7,  bitAnterior);
      datoByte2 = datoByte2 >> 1;
    }
  }

  //SECUENCIA LLENADO A LA IZQUIERDA
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 0;
    int datoByte2 = 0;
    int bitAnterior = 0;
    for (int i = 0; i <= 16; i++) {
      bitAnterior = bitRead(datoByte, 7);
      ledWrite(datoByte, datoByte2, 200);
      datoByte2 = datoByte2 << 1;  
      datoByte2 = bitWrite(datoByte2, 0,  bitAnterior);
      datoByte = (datoByte << 1) ;
      bitWrite(datoByte, 0,  1);
    }
  }

  //SECUENCIA LLENADO A LA DERECHA
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 0;
    int datoByte2 = 128;
    int bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitWrite(datoByte2, 7,  1);
      bitAnterior = bitRead(datoByte2, 0);
      ledWrite(datoByte, datoByte2, 200);
      datoByte = datoByte >> 1;  
      datoByte = bitWrite(datoByte, 7,  bitAnterior);
      datoByte2 = datoByte2 >> 1;
    }
  }

  //SECUENCIA LLENADO Y VACIADO INICIANDO DERECHA
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 0;
    int datoByte2 = 0;
    int bitAnterior = 0;
    for (int i = 0; i <= 16; i++) {
      bitAnterior = bitRead(datoByte, 7);
      ledWrite(datoByte, datoByte2, 100);
      datoByte2 = datoByte2 << 1;  
      datoByte2 = bitWrite(datoByte2, 0,  bitAnterior);
      datoByte = (datoByte << 1) ;
      bitWrite(datoByte, 0,  1);
    }
    for (int i = 0; i <= 15; i++) {
      bitWrite(datoByte2, 7,  0);
      bitAnterior = bitRead(datoByte2, 0);
      ledWrite(datoByte, datoByte2, 100);
      datoByte = datoByte >> 1;  
      datoByte = bitWrite(datoByte, 7,  bitAnterior);
      datoByte2 = datoByte2 >> 1;
    }
  }

  //SECUENCIA LLENADO Y VACIADO INICIANDO IZQUIERDA
  for (int m = 0; m < repeticiones; m++) {
    int datoByte = 0;
    int datoByte2 = 128;
    int bitAnterior = 0;
    for (int i = 0; i <= 15; i++) {
      bitWrite(datoByte2, 7,  1);
      bitAnterior = bitRead(datoByte2, 0);
      ledWrite(datoByte, datoByte2, 100);
      datoByte = datoByte >> 1;  
      datoByte = bitWrite(datoByte, 7,  bitAnterior);
      datoByte2 = datoByte2 >> 1;
    }
    for (int i = 0; i <= 16; i++) {
      bitAnterior = bitRead(datoByte, 7);
      ledWrite(datoByte, datoByte2, 100);
      datoByte2 = datoByte2 << 1;  
      datoByte2 = bitWrite(datoByte2, 0,  bitAnterior);
      datoByte = (datoByte << 1) ;
      bitWrite(datoByte, 0,  0);
    }
  }

  //APILAR LUCES A LA IZQUIERDA
  ledWrite( B00000001, B00000000,60);
  ledWrite( B00000010, B00000000,60);
  ledWrite( B00000100, B00000000,60);
  ledWrite( B00001000, B00000000,60);
  ledWrite( B00010000, B00000000,60);
  ledWrite( B00100000, B00000000,60);
  ledWrite( B01000000, B00000000,60);
  ledWrite( B10000000, B00000000,60);
  ledWrite( B00000000, B00000001,60);
  ledWrite( B00000000, B00000010,60);
  ledWrite( B00000000, B00000100,60);
  ledWrite( B00000000, B00001000,60);
  ledWrite( B00000000, B00010000,60);
  ledWrite( B00000000, B00100000,60);
  ledWrite( B00000000, B01000000,60);
  ledWrite( B00000000, B10000000,60);
  ledWrite( B00000001, B10000000,60);
  ledWrite( B00000010, B10000000,60);
  ledWrite( B00000100, B10000000,60);
  ledWrite( B00001000, B10000000,60);
  ledWrite( B00010000, B10000000,60);
  ledWrite( B00100000, B10000000,60);
  ledWrite( B01000000, B10000000,60);
  ledWrite( B10000000, B10000000,60);
  ledWrite( B00000000, B10000001,60);
  ledWrite( B00000000, B10000010,60);
  ledWrite( B00000000, B10000100,60);
  ledWrite( B00000000, B10001000,60);
  ledWrite( B00000000, B10010000,60);
  ledWrite( B00000000, B10100000,60);
  ledWrite( B00000000, B11000000,60);
  ledWrite( B00000001, B11000000,60);
  ledWrite( B00000010, B11000000,60);
  ledWrite( B00000100, B11000000,60);
  ledWrite( B00001000, B11000000,60);
  ledWrite( B00010000, B11000000,60);
  ledWrite( B00100000, B11000000,60);
  ledWrite( B01000000, B11000000,60);
  ledWrite( B10000000, B11000000,60);
  ledWrite( B00000000, B11000001,60);
  ledWrite( B00000000, B11000010,60);
  ledWrite( B00000000, B11000100,60);
  ledWrite( B00000000, B11001000,60);
  ledWrite( B00000000, B11010000,60);
  ledWrite( B00000000, B11100000,60);
  ledWrite( B00000001, B11100000,60);
  ledWrite( B00000010, B11100000,60);
  ledWrite( B00000100, B11100000,60);
  ledWrite( B00001000, B11100000,60);
  ledWrite( B00010000, B11100000,60);
  ledWrite( B00100000, B11100000,60);
  ledWrite( B01000000, B11100000,60);
  ledWrite( B10000000, B11100000,60);
  ledWrite( B00000000, B11100001,60);
  ledWrite( B00000000, B11100010,60);
  ledWrite( B00000000, B11100100,60);
  ledWrite( B00000000, B11101000,60);
  ledWrite( B00000000, B11110000,60);
  ledWrite( B00000001, B11110000,60);
  ledWrite( B00000010, B11110000,60);
  ledWrite( B00000100, B11110000,60);
  ledWrite( B00001000, B11110000,60);
  ledWrite( B00010000, B11110000,60);
  ledWrite( B00100000, B11110000,60);
  ledWrite( B01000000, B11110000,60);
  ledWrite( B10000000, B11110000,60);
  ledWrite( B00000000, B11110001,60);
  ledWrite( B00000000, B11110010,60);
  ledWrite( B00000000, B11110100,60);
  ledWrite( B00000000, B11111000,60);
  ledWrite( B00000001, B11111000,60);
  ledWrite( B00000010, B11111000,60);
  ledWrite( B00000100, B11111000,60);
  ledWrite( B00001000, B11111000,60);
  ledWrite( B00010000, B11111000,60);
  ledWrite( B00100000, B11111000,60);
  ledWrite( B01000000, B11111000,60);
  ledWrite( B10000000, B11111000,60);
  ledWrite( B00000000, B11111001,60);
  ledWrite( B00000000, B11111010,60);
  ledWrite( B00000000, B11111100,60);
  ledWrite( B00000001, B11111100,60);
  ledWrite( B00000010, B11111100,60);
  ledWrite( B00000100, B11111100,60);
  ledWrite( B00001000, B11111100,60);
  ledWrite( B00010000, B11111100,60);
  ledWrite( B00100000, B11111100,60);
  ledWrite( B01000000, B11111100,60);
  ledWrite( B10000000, B11111100,60);
  ledWrite( B00000000, B11111101,60);
  ledWrite( B00000000, B11111110,60);
  ledWrite( B00000001, B11111110,60);
  ledWrite( B00000010, B11111110,60);
  ledWrite( B00000100, B11111110,60);
  ledWrite( B00001000, B11111110,60);
  ledWrite( B00010000, B11111110,60);
  ledWrite( B00100000, B11111110,60);
  ledWrite( B01000000, B11111110,60);
  ledWrite( B10000000, B11111110,60);
  ledWrite( B00000000, B11111111,60);
  ledWrite( B00000001, B11111111,60);
  ledWrite( B00000010, B11111111,60);
  ledWrite( B00000100, B11111111,60);
  ledWrite( B00001000, B11111111,60);
  ledWrite( B00010000, B11111111,60);
  ledWrite( B00100000, B11111111,60);
  ledWrite( B01000000, B11111111,60);
  ledWrite( B10000000, B11111111,60);
  ledWrite( B10000001, B11111111,60);
  ledWrite( B10000010, B11111111,60);
  ledWrite( B10000100, B11111111,60);
  ledWrite( B10001000, B11111111,60);
  ledWrite( B10010000, B11111111,60);
  ledWrite( B10100000, B11111111,60);
  ledWrite( B11000000, B11111111,60);
  ledWrite( B11000001, B11111111,60);
  ledWrite( B11000010, B11111111,60);
  ledWrite( B11000100, B11111111,60);
  ledWrite( B11001000, B11111111,60);
  ledWrite( B11010000, B11111111,60);
  ledWrite( B11100000, B11111111,60);
  ledWrite( B11100001, B11111111,60);
  ledWrite( B11100010, B11111111,60);
  ledWrite( B11100100, B11111111,60);
  ledWrite( B11101000, B11111111,60);
  ledWrite( B11110000, B11111111,60);
  ledWrite( B11110001, B11111111,60);
  ledWrite( B11110010, B11111111,60);
  ledWrite( B11110100, B11111111,60);
  ledWrite( B11111000, B11111111,60);
  ledWrite( B11111001, B11111111,60);
  ledWrite( B11111010, B11111111,60);
  ledWrite( B11111100, B11111111,60);
  ledWrite( B11111101, B11111111,60);
  ledWrite( B11111110, B11111111,60);
  ledWrite( B11111111, B11111111,2000);

  //ALTERNAR ENCENDIDO EN CADA MITAD - PARPADEO
  ledWrite(B11111111, B00000000, 100);
  ledWrite(B00000000, B11111111, 100);
  ledWrite(B11111111, B00000000, 100);
  ledWrite(B00000000, B11111111, 100);
  ledWrite(B11111111, B00000000, 100);
  ledWrite(B00000000, B11111111, 100);
  ledWrite(B11111111, B00000000, 100);
  ledWrite(B00000000, B11111111, 100);
  ledWrite(B11111111, B00000000, 100);
  ledWrite(B00000000, B11111111, 100);
  ledWrite(B11111111, B00000000, 100);
  ledWrite(B00000000, B11111111, 100);
  ledWrite(B11111111, B00000000, 100);
  ledWrite(B00000000, B11111111, 100);
  ledWrite(B11111111, B11111111, 50);
  ledWrite(B00000000, B00000000, 50);
  ledWrite(B11111111, B11111111, 50);
  ledWrite(B00000000, B00000000, 50);
  ledWrite(B11111111, B11111111, 50);
  ledWrite(B00000000, B00000000, 100);
  ledWrite(B11111111, B11111111, 50);
  ledWrite(B00000000, B00000000, 50);
  ledWrite(B11111111, B11111111, 50);
  ledWrite(B00000000, B00000000, 100);
  ledWrite(B11111111, B11111111, 50);
  ledWrite(B00000000, B00000000, 50);
  ledWrite(B11111111, B11111111, 50);
  ledWrite(B00000000, B00000000, 50);
  ledWrite(B11111111, B11111111, 50);
  ledWrite(B00000000, B00000000, 50);
  ledWrite(B11111111, B11111111, 50);
  ledWrite(B00000000, B00000000, 50);
  ledWrite(B11111111, B11111111, 300);

  //APILAR LUCES A LA DERECHA
  ledWrite(B00000000, B10000000, 60);
  ledWrite(B00000000, B01000000, 60);
  ledWrite(B00000000, B00100000, 60);
  ledWrite(B00000000, B00010000, 60);
  ledWrite(B00000000, B00001000, 60);
  ledWrite(B00000000, B00000100, 60);
  ledWrite(B00000000, B00000010, 60);
  ledWrite(B00000000, B00000001, 60);
  ledWrite(B10000000, B00000000, 60);
  ledWrite(B01000000, B00000000, 60);
  ledWrite(B00100000, B00000000, 60);
  ledWrite(B00010000, B00000000, 60);
  ledWrite(B00001000, B00000000, 60);
  ledWrite(B00000100, B00000000, 60);
  ledWrite(B00000010, B00000000, 60);
  ledWrite(B00000001, B00000000, 60);
  ledWrite(B00000001, B10000000, 60);
  ledWrite(B00000001, B01000000, 60);
  ledWrite(B00000001, B00100000, 60);
  ledWrite(B00000001, B00010000, 60);
  ledWrite(B00000001, B00001000, 60);
  ledWrite(B00000001, B00000100, 60);
  ledWrite(B00000001, B00000010, 60);
  ledWrite(B00000001, B00000001, 60);
  ledWrite(B10000001, B00000000, 60);
  ledWrite(B01000001, B00000000, 60);
  ledWrite(B00100001, B00000000, 60);
  ledWrite(B00010001, B00000000, 60);
  ledWrite(B00001001, B00000000, 60);
  ledWrite(B00000101, B00000000, 60);
  ledWrite(B00000011, B00000000, 60);
  ledWrite(B00000011, B10000000, 60);
  ledWrite(B00000011, B01000000, 60);
  ledWrite(B00000011, B00100000, 60);
  ledWrite(B00000011, B00010000, 60);
  ledWrite(B00000011, B00001000, 60);
  ledWrite(B00000011, B00000100, 60);
  ledWrite(B00000011, B00000010, 60);
  ledWrite(B00000011, B00000001, 60);
  ledWrite(B10000011, B00000000, 60);
  ledWrite(B01000011, B00000000, 60);
  ledWrite(B00100011, B00000000, 60);
  ledWrite(B00010011, B00000000, 60);
  ledWrite(B00001011, B00000000, 60);
  ledWrite(B00000111, B00000000, 60);
  ledWrite(B00000111, B10000000, 60);
  ledWrite(B00000111, B01000000, 60);
  ledWrite(B00000111, B00100000, 60);
  ledWrite(B00000111, B00010000, 60);
  ledWrite(B00000111, B00001000, 60);
  ledWrite(B00000111, B00000100, 60);
  ledWrite(B00000111, B00000010, 60);
  ledWrite(B00000111, B00000001, 60);
  ledWrite(B10000111, B00000000, 60);
  ledWrite(B01000111, B00000000, 60);
  ledWrite(B00100111, B00000000, 60);
  ledWrite(B00010111, B00000000, 60);
  ledWrite(B00001111, B00000000, 60);
  ledWrite(B00001111, B10000000, 60);
  ledWrite(B00001111, B01000000, 60);
  ledWrite(B00001111, B00100000, 60);
  ledWrite(B00001111, B00010000, 60);
  ledWrite(B00001111, B00001000, 60);
  ledWrite(B00001111, B00000100, 60);
  ledWrite(B00001111, B00000010, 60);
  ledWrite(B00001111, B00000001, 60);
  ledWrite(B10001111, B00000000, 60);
  ledWrite(B01001111, B00000000, 60);
  ledWrite(B00101111, B00000000, 60);
  ledWrite(B00011111, B00000000, 60);
  ledWrite(B00011111, B10000000, 60);
  ledWrite(B00011111, B01000000, 60);
  ledWrite(B00011111, B00100000, 60);
  ledWrite(B00011111, B00010000, 60);
  ledWrite(B00011111, B00001000, 60);
  ledWrite(B00011111, B00000100, 60);
  ledWrite(B00011111, B00000010, 60);
  ledWrite(B00011111, B00000001, 60);
  ledWrite(B10011111, B00000000, 60);
  ledWrite(B01011111, B00000000, 60);
  ledWrite(B00111111, B00000000, 60);
  ledWrite(B00111111, B10000000, 60);
  ledWrite(B00111111, B01000000, 60);
  ledWrite(B00111111, B00100000, 60);
  ledWrite(B00111111, B00010000, 60);
  ledWrite(B00111111, B00001000, 60);
  ledWrite(B00111111, B00000100, 60);
  ledWrite(B00111111, B00000010, 60);
  ledWrite(B00111111, B00000001, 60);
  ledWrite(B10111111, B00000000, 60);
  ledWrite(B01111111, B00000000, 60);
  ledWrite(B01111111, B10000000, 60);
  ledWrite(B01111111, B01000000, 60);
  ledWrite(B01111111, B00100000, 60);
  ledWrite(B01111111, B00010000, 60);
  ledWrite(B01111111, B00001000, 60);
  ledWrite(B01111111, B00000100, 60);
  ledWrite(B01111111, B00000010, 60);
  ledWrite(B01111111, B00000001, 60);
  ledWrite(B11111111, B00000000, 60);
  ledWrite(B11111111, B10000000, 60);
  ledWrite(B11111111, B01000000, 60);
  ledWrite(B11111111, B00100000, 60);
  ledWrite(B11111111, B00010000, 60);
  ledWrite(B11111111, B00001000, 60);
  ledWrite(B11111111, B00000100, 60);
  ledWrite(B11111111, B00000010, 60);
  ledWrite(B11111111, B00000001, 60);
  ledWrite(B11111111, B10000001, 60);
  ledWrite(B11111111, B01000001, 60);
  ledWrite(B11111111, B00100001, 60);
  ledWrite(B11111111, B00010001, 60);
  ledWrite(B11111111, B00001001, 60);
  ledWrite(B11111111, B00000101, 60);
  ledWrite(B11111111, B00000011, 60);
  ledWrite(B11111111, B10000011, 60);
  ledWrite(B11111111, B01000011, 60);
  ledWrite(B11111111, B00100011, 60);
  ledWrite(B11111111, B00010011, 60);
  ledWrite(B11111111, B00001011, 60);
  ledWrite(B11111111, B00000111, 60);
  ledWrite(B11111111, B10000111, 60);
  ledWrite(B11111111, B01000111, 60);
  ledWrite(B11111111, B00100111, 60);
  ledWrite(B11111111, B00010111, 60);
  ledWrite(B11111111, B00001111, 60);
  ledWrite(B11111111, B10001111, 60);
  ledWrite(B11111111, B01001111, 60);
  ledWrite(B11111111, B00101111, 60);
  ledWrite(B11111111, B00011111, 60);
  ledWrite(B11111111, B10011111, 60);
  ledWrite(B11111111, B01011111, 60);
  ledWrite(B11111111, B00111111, 60);  
  ledWrite(B11111111, B10111111, 60);
  ledWrite(B11111111, B01111111, 60);
  ledWrite(B11111111, B11111111, 2000); 

  //ENTRADA Y SALIDA DE LUCES DE DERECHA A IZQUIERDA
  ledWrite(B00000000, B00000000, 100);
  ledWrite(B00000001, B00000000, 100);
  ledWrite(B00000011, B00000000, 100);
  ledWrite(B00000111, B00000000, 100);
  ledWrite(B00001111, B00000000, 100);
  ledWrite(B00011111, B00000000, 100);
  ledWrite(B00111111, B00000000, 100);
  ledWrite(B01111111, B00000000, 100);
  ledWrite(B11111111, B00000000, 100);
  ledWrite(B11111111, B00000001, 100);
  ledWrite(B11111111, B00000011, 100);
  ledWrite(B11111111, B00000111, 100);
  ledWrite(B11111111, B00001111, 100);
  ledWrite(B11111111, B00011111, 100);
  ledWrite(B11111111, B00111111, 100);
  ledWrite(B11111111, B01111111, 100);
  ledWrite(B11111111, B11111111, 100);
  ledWrite(B11111110, B11111111, 100);
  ledWrite(B11111100, B11111111, 100);
  ledWrite(B11111000, B11111111, 100);
  ledWrite(B11110000, B11111111, 100);
  ledWrite(B11100000, B11111111, 100);
  ledWrite(B11000000, B11111111, 100);
  ledWrite(B10000000, B11111111, 100);
  ledWrite(B00000000, B11111111, 100);
  ledWrite(B00000000, B11111110, 100);
  ledWrite(B00000000, B11111100, 100);
  ledWrite(B00000000, B11111000, 100);
  ledWrite(B00000000, B11110000, 100);
  ledWrite(B00000000, B11100000, 100);
  ledWrite(B00000000, B11000000, 100);
  ledWrite(B00000000, B10000000, 100);
  ledWrite(B00000000, B00000000, 100);

  //ENTRADA Y SALIDA DE LUCES DE IZQUIERDA A DERECJA
  ledWrite(B00000000, B00000000, 100);
  ledWrite(B00000000, B10000000, 100);
  ledWrite(B00000000, B11000000, 100);
  ledWrite(B00000000, B11100000, 100);
  ledWrite(B00000000, B11110000, 100);
  ledWrite(B00000000, B11111000, 100);
  ledWrite(B00000000, B11111100, 100);
  ledWrite(B00000000, B11111110, 100);
  ledWrite(B00000000, B11111111, 100);
  ledWrite(B10000000, B11111111, 100);
  ledWrite(B11000000, B11111111, 100);
  ledWrite(B11100000, B11111111, 100);
  ledWrite(B11110000, B11111111, 100);
  ledWrite(B11111000, B11111111, 100);
  ledWrite(B11111100, B11111111, 100);
  ledWrite(B11111110, B11111111, 100);
  ledWrite(B11111111, B11111111, 100);
  ledWrite(B11111111, B01111111, 100);
  ledWrite(B11111111, B00111111, 100);
  ledWrite(B11111111, B00011111, 100);
  ledWrite(B11111111, B00001111, 100);
  ledWrite(B11111111, B00000111, 100);
  ledWrite(B11111111, B00000011, 100);
  ledWrite(B11111111, B00000001, 100);
  ledWrite(B11111111, B00000000, 100);
  ledWrite(B01111111, B00000000, 100);
  ledWrite(B00111111, B00000000, 100);
  ledWrite(B00011111, B00000000, 100);
  ledWrite(B00001111, B00000000, 100);
  ledWrite(B00000111, B00000000, 100);
  ledWrite(B00000011, B00000000, 100);
  ledWrite(B00000001, B00000000, 100);
  ledWrite(B00000000, B00000000, 100);

 //ENTRADA Y SALIDA DE LUCES DE IZQUIERDA A DERECJA GRUPO DE CUATRO
  ledWrite(B00000000, B00000000, 100);
  ledWrite(B00000000, B10000000, 100);
  ledWrite(B00000000, B11000000, 100);
  ledWrite(B00000000, B11100000, 100);
  ledWrite(B00000000, B11110000, 100);
  ledWrite(B00000000, B01111000, 100);
  ledWrite(B00000000, B00111100, 100);
  ledWrite(B00000000, B00011110, 100);
  ledWrite(B00000000, B00001111, 100);
  ledWrite(B10000000, B10000111, 100);
  ledWrite(B11000000, B11000011, 100);
  ledWrite(B11100000, B11100001, 100);
  ledWrite(B11110000, B11110000, 100);
  ledWrite(B01111000, B01111000, 100);
  ledWrite(B00111100, B00111100, 100);
  ledWrite(B00011110, B00011110, 100);
  ledWrite(B00001111, B00001111, 100);
  ledWrite(B10000111, B00000111, 100);
  ledWrite(B11000011, B00000011, 100);
  ledWrite(B11100001, B00000001, 100);
  ledWrite(B11110000, B00000000, 100);
  ledWrite(B01111000, B00000000, 100);
  ledWrite(B00111100, B00000000, 100);
  ledWrite(B00011110, B00000000, 100);
  ledWrite(B00001111, B00000000, 100);
  ledWrite(B00000111, B00000000, 100);
  ledWrite(B00000011, B00000000, 100);
  ledWrite(B00000001, B00000000, 100);
  ledWrite(B00000000, B00000000, 100);

  /*
  for (int m = 0; m <= repeticiones; m++) {
    datoByte = 1;
    for (int i = 0; i <= 6; i++) {
      ledWrite(datoByte, 200);
      datoByte <<= 1;
    }
    for (int i = 7; i >= 1; i--) {
      ledWrite(datoByte, 200);
      datoByte >>= 1;
    }
  }

  for (int m = 0; m <= repeticiones; m++) {
    datoByte = 1;
    for (int i = 0; i <= 7; i++) {
      ledWrite(datoByte, 200);
      datoByte <<= 1;
    }
  }

  for (int m = 0; m <= repeticiones; m++) {
    datoByte = 256;
    for (int i = 8; i >= 0; i--) {
      ledWrite(~datoByte, 200);
      datoByte >>= 1;
    }
  }

  for (int m = 0; m <= repeticiones; m++) {
    datoByte = 1;
    for (int i = 0; i <= 6; i++) {
      ledWrite(~datoByte, 200);
      datoByte <<= 1;
    }
    for (int i = 7; i >= 1; i--) {
      ledWrite(~datoByte, 200);
      datoByte >>= 1;
    }
  }

  for (int m = 0; m <= repeticiones; m++) {
    for (int i = 0; i <= 7; i++) {
      datoByte = bitSet(datoByte, i);
      ledWrite(~datoByte, 100);
    }
    for (int i = 7; i >= -1; i--) {
      datoByte = bitClear(datoByte, i);
      ledWrite(~datoByte, 100);
    }
  }

  for (int m = 0; m <= repeticiones; m++) {
    for (int i = 8; i >= 0; i--) {
      datoByte = bitSet(datoByte, i);
      ledWrite(datoByte, 100);
    }
    for (int i = 0; i <= 8; i++) {
      datoByte = bitClear(datoByte, i);
      ledWrite(datoByte, 100);
    }
  }

  for (int m = 0; m <= repeticiones; m++) {
    for (int i = 0; i <= 8; i++) {
      datoByte = bitSet(datoByte, i);
      ledWrite(datoByte, 100);
    }
    for (int i = 0; i <= 8; i++) {
      datoByte = bitClear(datoByte, i);
      ledWrite(datoByte, 100);
    }
  }

  for (int m = 0; m <= repeticiones; m++) {
    for (int i = 0; i <= 7; i++) {
      datoByte = bitSet(datoByte, i);
      ledWrite(datoByte, 100);
    }
    for (int i = 7; i >= -1; i--) {
      datoByte = bitClear(datoByte, i);
      ledWrite(datoByte, 100);
    }
  }

  datoByte = 0;
  ledWrite(datoByte, 300);
  for (int i = 3; i >= 0; i--) {
    datoByte = bitSet(datoByte, i) | bitSet(datoByte, 7 - i);
    ledWrite(datoByte, 300);
  }

  for (int m = 0; m <= repeticiones; m++) {
    datoByte = 0;
    for (int i = 0; i <= 4; i++) {
      if (i > 0) datoByte = bitSet(datoByte, i - 1) | bitSet(datoByte, 8 - i);
      ledWrite(datoByte, 300);
    }
    for (int i = 4; i >= 0; i--) {
      if (i < 5) datoByte = bitClear(datoByte, i - 1) | bitClear(datoByte, 8 - i);
      ledWrite(datoByte, 300);
    }
  }
  /*
    datoByte = 1; // Esta no debe descomentarse porque quise reemplazar las secuencias siguientes con ciclos for, pero no alcancé
    for(int j = 0; j <= 8; j++){
    for(int i = 0; i <= j; i - j){
      ledWrite(datoByte, 200);
      datoByte <<= 1;
     if(j > 0) datoByte |= datoByte2;
    }
    datoByte2 *= 2;
    }
  */
  /*
  for (int i = 0; i <= repeticiones; i++) {
    ledWrite(B00000000, 100);
    ledWrite(B10000000, 100);
    ledWrite(B01000000, 100);
    ledWrite(B00100000, 100);
    ledWrite(B00010000, 100);
    ledWrite(B00001000, 100);
    ledWrite(B00000100, 100);
    ledWrite(B00000010, 100);
    ledWrite(B00000001, 100);
    ledWrite(B10000001, 100);
    ledWrite(B01000001, 100);
    ledWrite(B00100001, 100);
    ledWrite(B00010001, 100);
    ledWrite(B00001001, 100);
    ledWrite(B00000101, 100);
    ledWrite(B00000011, 100);
    ledWrite(B10000011, 100);
    ledWrite(B01000011, 100);
    ledWrite(B00100011, 100);
    ledWrite(B00010011, 100);
    ledWrite(B00001011, 100);
    ledWrite(B00000111, 100);
    ledWrite(B10000111, 100);
    ledWrite(B01000111, 100);
    ledWrite(B00100111, 100);
    ledWrite(B00010111, 100);
    ledWrite(B00001111, 100);
    ledWrite(B10001111, 100);
    ledWrite(B01001111, 100);
    ledWrite(B00101111, 100);
    ledWrite(B00011111, 100);
    ledWrite(B10011111, 100);
    ledWrite(B01011111, 100);
    ledWrite(B10111111, 100);
    ledWrite(B01111111, 100);
    ledWrite(B11111111, 500);
    datoByte = 0xFF;
    for (int i = 0; i <= 7; i++) {
      datoByte = bitClear(datoByte, i);
      ledWrite(datoByte, 200);
    }
    ledWrite(B00000000, 100);
    ledWrite(B00000001, 100);
    ledWrite(B00000010, 100);
    ledWrite(B00000100, 100);
    ledWrite(B00001000, 100);
    ledWrite(B00010000, 100);
    ledWrite(B00100000, 100);
    ledWrite(B01000000, 100);
    ledWrite(B10000000, 100);
    ledWrite(B10000001, 100);
    ledWrite(B10000010, 100);
    ledWrite(B10000100, 100);
    ledWrite(B10001000, 100);
    ledWrite(B10010000, 100);
    ledWrite(B10100000, 100);
    ledWrite(B11000000, 100);
    ledWrite(B11000001, 100);
    ledWrite(B11000010, 100);
    ledWrite(B11000100, 100);
    ledWrite(B11001000, 100);
    ledWrite(B11010000, 100);
    ledWrite(B11100000, 100);
    ledWrite(B11100001, 100);
    ledWrite(B11100010, 100);
    ledWrite(B11100100, 100);
    ledWrite(B11101000, 100);
    ledWrite(B11110000, 100);
    ledWrite(B11110001, 100);
    ledWrite(B11110010, 100);
    ledWrite(B11110100, 100);
    ledWrite(B11111000, 100);
    ledWrite(B11111001, 100);
    ledWrite(B11111010, 100);
    ledWrite(B11111100, 100);
    ledWrite(B11111101, 100);
    ledWrite(B11111110, 100);
    ledWrite(B11111111, 100);
    ledWrite(B11111111, 500);
    for (int i = 7; i >= 0; i--) {
      datoByte = bitClear(datoByte, i);
      ledWrite(datoByte, 200);
    }
  }

  ledWrite(B11110000, 100);
  ledWrite(B00001111, 100);
  ledWrite(B11110000, 100);
  ledWrite(B00001111, 100);
  ledWrite(B11110000, 100);
  ledWrite(B00001111, 100);
  ledWrite(B11110000, 100);
  ledWrite(B00001111, 100);
  ledWrite(B11110000, 100);
  ledWrite(B00001111, 100);
  ledWrite(B11110000, 100);
  ledWrite(B00001111, 100);
  ledWrite(B11110000, 100);
  ledWrite(B00001111, 100);

  ledWrite(B11111111, 50);
  ledWrite(B00000000, 50);
  ledWrite(B11111111, 50);
  ledWrite(B00000000, 50);
  ledWrite(B11111111, 50);
  ledWrite(B00000000, 100);
  ledWrite(B11111111, 50);
  ledWrite(B00000000, 50);
  ledWrite(B11111111, 50);
  ledWrite(B00000000, 100);
  ledWrite(B11111111, 50);
  ledWrite(B00000000, 50);
  ledWrite(B11111111, 50);
  ledWrite(B00000000, 50);
  ledWrite(B11111111, 50);
  ledWrite(B00000000, 50);
  ledWrite(B11111111, 50);
  ledWrite(B00000000, 50);
  ledWrite(B11111111, 300);
  datoByte = 0xFF;
  for (int i = 0; i <= 7; i++) {
    datoByte = bitClear(datoByte, i);
    ledWrite(datoByte, 100);
  }

  for (int i = 0; i <= repeticiones; i++) {
    ledWrite(0, 500);
    ledWrite(B10000001, 300);
    ledWrite(B01000010, 300);
    ledWrite(B00100100, 300);
    ledWrite(B00011000, 300);
    ledWrite(B10011001, 300);
    ledWrite(B01011010, 300);
    ledWrite(B00111100, 300);
    ledWrite(B10111101, 300);
    ledWrite(B01111110, 300);
    ledWrite(B11111111, 500);
    ledWrite(B01111110, 300);
    ledWrite(B10111101, 300);
    ledWrite(B00111100, 300);
    ledWrite(B01011010, 300);
    ledWrite(B10011001, 300);
    ledWrite(B00011000, 300);
    ledWrite(B00100100, 300);
    ledWrite(B01000010, 300);
    ledWrite(B10000001, 300);
  }

  for (int i = 0; i <= repeticiones; i++) {
    ledWrite(B00000000, 200);
    ledWrite(B00000001, 200);
    ledWrite(B00000011, 200);
    ledWrite(B00000111, 200);
    ledWrite(B00001111, 200);
    ledWrite(B00011111, 200);
    ledWrite(B00111111, 200);
    ledWrite(B01111111, 200);
    ledWrite(B11111111, 200);
    ledWrite(B11111110, 200);
    ledWrite(B11111100, 200);
    ledWrite(B11111000, 200);
    ledWrite(B11110001, 200);
    ledWrite(B11100011, 200);
    ledWrite(B11000111, 200);
    ledWrite(B10001111, 200);
    ledWrite(B00011111, 200);
    ledWrite(B00111111, 200);
    ledWrite(B01111111, 200);
    ledWrite(B11111111, 200);
    ledWrite(B11111110, 200);
    ledWrite(B11111100, 200);
    ledWrite(B11111000, 200);
    ledWrite(B11110000, 200);
    ledWrite(B11100000, 200);
    ledWrite(B11000000, 200);
    ledWrite(B10000000, 200);
  }

  for (int i = 0; i <= repeticiones; i++) {
    ledWrite(B00000000, 300);
    ledWrite(B10000001, 300);
    ledWrite(B01000010, 300);
    ledWrite(B00100100, 300);
    ledWrite(B00011000, 300);
    ledWrite(B00100100, 300);
    ledWrite(B01000010, 300);
    ledWrite(B10000001, 300);
  }

  for (int i = 0; i <= repeticiones; i++) {
    ledWrite(B00011000, 300);
    ledWrite(B00100100, 300);
    ledWrite(B01000010, 300);
    ledWrite(B10000001, 300);
    ledWrite(B10011001, 300);
    ledWrite(B10100101, 300);
    ledWrite(B11000011, 300);
    ledWrite(B11011011, 300);
    ledWrite(B11011011, 300);
    ledWrite(B11100111, 300);
    ledWrite(B11111111, 300);
    ledWrite(B00000000, 500);
    ledWrite(B11111111, 200);
    ledWrite(B00000000, 500);
    ledWrite(B11111111, 200);
    ledWrite(B00000000, 500);
    ledWrite(B11111111, 200);
    ledWrite(B00000000, 500);
  }

  for (int m = 0; m <= repeticiones; m++) {
    datoByte = 1792;
    for (int i = 0; i <= 9; i++) {
      ledWrite(datoByte, 200);
      datoByte >>= 1;
    }
  }

  for (int m = 0; m <= repeticiones; m++) {
    datoByte = 0;
    for (int i = 0; i <= 9; i++) {
      if (i < 3) datoByte |= 1;
      ledWrite(datoByte, 200);
      datoByte <<= 1;
    }
  }

  for (int m = 0; m <= repeticiones; m++) {
    datoByte = 1792;
    for (int i = 0; i <= 9; i++) {
      ledWrite(datoByte, 200);
      datoByte >>= 1;
    }
    datoByte = 1;
    for (int i = 9; i >= 0; i--) {
      ledWrite(datoByte, 200);
      datoByte <<= 1;
      if (i > 8) bitSet(datoByte, 0);
    }
  }

  for (int m = 0; m <= repeticiones * 20; m++) {
    ledWrite(int(random(0, 255)), 100);
  }

  for (int m = 0; m <= repeticiones; m++) {
    ledWrite(B00000001, 200);
    ledWrite(B00000010, 200);
    ledWrite(B00000100, 200);
    ledWrite(B00001000, 200);
    ledWrite(B00010000, 200);
    ledWrite(B00100000, 200);
    ledWrite(B01000000, 200);
    ledWrite(B10000000, 200);
    ledWrite(B11000000, 200);
    ledWrite(B10100000, 200);
    ledWrite(B10010000, 200);
    ledWrite(B10001000, 200);
    ledWrite(B10000100, 200);
    ledWrite(B00000000, 200);
    ledWrite(B10000010, 200);
    ledWrite(B10000001, 200);
    ledWrite(B10000011, 200);
    ledWrite(B10000101, 200);
    ledWrite(B10001001, 200);
    ledWrite(B10010001, 200);
    ledWrite(B10100001, 200);
    ledWrite(B11000001, 200);
    ledWrite(B11100001, 200);
    ledWrite(B11010001, 200);
    ledWrite(B11001001, 200);
    ledWrite(B11000101, 200);
    ledWrite(B11000011, 200);
    ledWrite(B11000111, 200);
    ledWrite(B11001011, 200);
    ledWrite(B11010011, 200);
    ledWrite(B11100011, 200);
    ledWrite(B11110011, 200);
    ledWrite(B11101011, 200);
    ledWrite(B11100111, 200);
    ledWrite(B11101111, 200);
    ledWrite(B11110111, 200);
    ledWrite(B11111111, 200);
  }

  for (int m = 0; m <= repeticiones; m++) {
    ledWrite(B00000000, 300);
    ledWrite(B00001000, 300);
    ledWrite(B00001100, 300);
    ledWrite(B00001010, 300);
    ledWrite(B00001001, 300);
    ledWrite(B00001101, 300);
    ledWrite(B00001011, 300);
    ledWrite(B00001111, 300);
    ledWrite(B00011111, 300);
    ledWrite(B00101111, 300);
    ledWrite(B01001111, 300);
    ledWrite(B10001111, 300);
    ledWrite(B10011111, 300);
    ledWrite(B10101111, 300);
    ledWrite(B11001111, 300);
    ledWrite(B11011111, 300);
    ledWrite(B11101111, 300);
    ledWrite(B11111111, 300);
  }

  for (int m = 0; m <= repeticiones; m++) {
    ledWrite(B00000000, 300);
    ledWrite(B00000001, 300);
    ledWrite(B00000010, 300);
    ledWrite(B00000100, 300);
    ledWrite(B00001000, 300);
    ledWrite(B00001100, 300);
    ledWrite(B00001010, 300);
    ledWrite(B00001001, 300);
    ledWrite(B00011001, 300);
    ledWrite(B00101001, 300);
    ledWrite(B01001001, 300);
    ledWrite(B10001001, 300);
    ledWrite(B10001101, 300);
    ledWrite(B10001011, 300);
    ledWrite(B10011011, 300);
    ledWrite(B10101011, 300);
    ledWrite(B11001011, 300);
    ledWrite(B11001111, 300);
    ledWrite(B11011111, 300);
    ledWrite(B11101111, 300);
    ledWrite(B11111111, 300);
  }

  for (int m = 0; m <= repeticiones * 20; m++) {
    ledWrite(B10101010, 200);
    ledWrite(B01010101, 200);
  }

  for (int m = 0; m <= repeticiones * 20; m++) {
    ledWrite(B00111100, 200);
    ledWrite(B11000011, 200);
  }

  for (int m = 0; m <= repeticiones * 5; m++) {
    ledWrite(B01111111, 100);
    ledWrite(B10111111, 100);
    ledWrite(B11011111, 100);
    ledWrite(B11101111, 100);
    ledWrite(B11110111, 100);
    ledWrite(B11111011, 100);
    ledWrite(B11111101, 100);
    ledWrite(B11111110, 100);
    ledWrite(B11111101, 100);
    ledWrite(B11111011, 100);
    ledWrite(B11110111, 100);
    ledWrite(B11101111, 100);
    ledWrite(B11011111, 100);
    ledWrite(B10111111, 100);
  }

  for (int m = 0; m <= repeticiones * 5; m++) {
    ledWrite(B01111111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B01111111, 200);
    ledWrite(B11111111, 50);
    ledWrite(B01111111, 100);
    ledWrite(B11111111, 50);

    ledWrite(B10111111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B10111111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B10111111, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11011111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11011111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11011111, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11101111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11101111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11101111, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11110111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11110111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11110111, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11111011, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111011, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111011, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11111101, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111101, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111101, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11111110, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111110, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111110, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11111101, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111101, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111101, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11111011, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111011, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11111011, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11110111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11110111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11110111, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11101111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11101111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11101111, 100);
    ledWrite(B11111111, 50);

    ledWrite(B11011111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11011111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B11011111, 100);
    ledWrite(B11111111, 50);

    ledWrite(B10111111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B10111111, 100);
    ledWrite(B11111111, 50);
    ledWrite(B10111111, 100);
    ledWrite(B11111111, 50);
  }
  */
}