 void lettersAllOn() {
     delay(none);
     log('lettersAllOn - START');
-    for (int i = 0; i < sizeof(letters); i++) {
-        log('lettersAllOn ', i);
-        digitalWrite(letters[i], PATTERN_ON);
-        delay(none);
-    }
+    digitalWrite(letters[0], PATTERN_ON); delay(none);
+    digitalWrite(letters[1], PATTERN_ON); delay(none);
+    digitalWrite(letters[2], PATTERN_ON); delay(none);
+    digitalWrite(letters[3], PATTERN_ON); delay(none);
+    digitalWrite(letters[4], PATTERN_ON); delay(none);
+    digitalWrite(letters[5], PATTERN_ON); delay(none);
+    digitalWrite(letters[6], PATTERN_ON); delay(none);
+    digitalWrite(letters[7], PATTERN_ON); delay(none);
+    digitalWrite(letters[8], PATTERN_ON); delay(none);
 }
 
 void lettersAllOff() {
     delay(none);
     log('lettersAllOff - START');
-    for (int i = 0; i < sizeof(letters); i++) {
-        log('lettersAllOff i: ', i);
-        digitalWrite(letters[i], PATTERN_OFF);
-        delay(none);
-    }
+    digitalWrite(letters[0], PATTERN_OFF); delay(none);
+    digitalWrite(letters[1], PATTERN_OFF); delay(none);
+    digitalWrite(letters[2], PATTERN_OFF); delay(none);
+    digitalWrite(letters[3], PATTERN_OFF); delay(none);
+    digitalWrite(letters[4], PATTERN_OFF); delay(none);
+    digitalWrite(letters[5], PATTERN_OFF); delay(none);
+    digitalWrite(letters[6], PATTERN_OFF); delay(none);
+    digitalWrite(letters[7], PATTERN_OFF); delay(none);
+    digitalWrite(letters[8], PATTERN_OFF); delay(none);
 }
 
 void backgroundAllOn() {
     delay(none);
     log('backgroundAllOn - START');
-    for (int i = 0; i < sizeof(background); i++) {
-        log('backgroundAllOn ', i);
-        digitalWrite(background[i], PATTERN_ON);
-        delay(none);
-    }
+    digitalWrite(background[0], PATTERN_ON); delay(none);
+    digitalWrite(background[1], PATTERN_ON); delay(none);
+    digitalWrite(background[2], PATTERN_ON); delay(none);
+    digitalWrite(background[3], PATTERN_ON); delay(none);
+    digitalWrite(background[4], PATTERN_ON); delay(none);
+    digitalWrite(background[5], PATTERN_ON); delay(none);
 }
 
 void backgroundAllOff() {
     delay(none);
     log('backgroundAllOff - START');
-    for (int i = 0; i < sizeof(background); i++) {
-        log('backgroundAllOff i: ', i);
-        digitalWrite(background[i], PATTERN_OFF);
-        delay(none);
-    }
+    digitalWrite(background[0], PATTERN_OFF); delay(none);
+    digitalWrite(background[1], PATTERN_OFF); delay(none);
+    digitalWrite(background[2], PATTERN_OFF); delay(none);
+    digitalWrite(background[3], PATTERN_OFF); delay(none);
+    digitalWrite(background[4], PATTERN_OFF); delay(none);
+    digitalWrite(background[5], PATTERN_OFF); delay(none);
 }
 
 void lettersOnLeftToRight() {
     delay(none);
     log('lettersOnLeftToRight - START');
-    for (int i = 0; i < sizeof(letters); i++) {
-        log('lettersOnLeftToRight i: ', i);
-        digitalWrite(letters[i], PATTERN_ON);
-        delay(normal);
-    }
+    digitalWrite(letters[0], PATTERN_ON); delay(normal);
+    digitalWrite(letters[1], PATTERN_ON); delay(normal);
+    digitalWrite(letters[2], PATTERN_ON); delay(normal);
+    digitalWrite(letters[3], PATTERN_ON); delay(normal);
+    digitalWrite(letters[4], PATTERN_ON); delay(normal);
+    digitalWrite(letters[5], PATTERN_ON); delay(normal);
+    digitalWrite(letters[6], PATTERN_ON); delay(normal);
+    digitalWrite(letters[7], PATTERN_ON); delay(normal);
+    digitalWrite(letters[8], PATTERN_ON); delay(normal);
 }
 
 void backgroundOnLeftToRight() {
     delay(none);
-    // turn the background on from left to right
     log('backgroundOnLeftToRight - START');
-    for (int i = 0; i < sizeof(background); i++) {
-        log('backgroundOnLeftToRight i: ', i);
-        digitalWrite(background[i], PATTERN_ON);
-        delay(minimal);
-    }
+    digitalWrite(background[0], PATTERN_ON); delay(minimal);
+    digitalWrite(background[1], PATTERN_ON); delay(minimal);
+    digitalWrite(background[2], PATTERN_ON); delay(minimal);
+    digitalWrite(background[3], PATTERN_ON); delay(minimal);
+    digitalWrite(background[4], PATTERN_ON); delay(minimal);
+    digitalWrite(background[5], PATTERN_ON); delay(minimal);
 }
 
 void backgroundOffRightToLeft() {
     delay(none);
     log('backgroundOffRightToLeft - START');
-    for (int i = sizeof(background) - 1; i >= 0; i--) {
-        digitalWrite(background[i], PATTERN_OFF);
-        delay(minimal);
-    }
+    digitalWrite(background[5], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[4], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[3], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[2], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[1], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[0], PATTERN_OFF); delay(minimal);
 }
 
 void backgroundOnOutsideIn() {
     delay(none);
     log('backgroundOnOutsideIn - START');
-    for (int i = 0, j = sizeof(background) - 1; i < (sizeof(background) / 2); i++, j--) {
-        log('backgroundOnOutsideIn i: ', i);
-        digitalWrite(background[i], PATTERN_ON);
-        delay(none);
-        log('backgroundOnOutsideIn j: ', j);
-        digitalWrite(background[j], PATTERN_ON);
-        delay(minimal);
-    }
+    digitalWrite(background[0], PATTERN_ON); delay(none);
+    digitalWrite(background[5], PATTERN_ON); delay(minimal);
+    digitalWrite(background[1], PATTERN_ON); delay(none);
+    digitalWrite(background[4], PATTERN_ON); delay(minimal);
+    digitalWrite(background[2], PATTERN_ON); delay(none);
+    digitalWrite(background[3], PATTERN_ON); delay(minimal);
 }
 
 void backgroundOffInsideOut() {
     delay(none);
     log('backgroundOffInsideOut - START');
-    for (int i = (sizeof(background) / 2) - 1, j = i + 1; i >= 0; i--, j++) {
-        log('backgroundOffInsideOut i: ', i);
-        digitalWrite(background[i], PATTERN_OFF);
-        delay(none);
-        log('backgroundOffInsideOut j: ', j);
-        digitalWrite(background[j], PATTERN_OFF);
-        delay(minimal);
-    }
+    digitalWrite(background[3], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[2], PATTERN_OFF); delay(none);
+    digitalWrite(background[4], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[1], PATTERN_OFF); delay(none);
+    digitalWrite(background[5], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[0], PATTERN_OFF); delay(none);
 }
 
 void backgroundOffOutsideIn() {
     delay(none);
     log('backgroundOffOutsideIn - START');
-    for (int i = 0, j = sizeof(background) - 1; i < (sizeof(background) / 2); i++, j--) {
-        log('backgroundOffOutsideIn i: ', i);
-        digitalWrite(background[i], PATTERN_OFF);
-        delay(none);
-        log('backgroundOffOutsideIn j: ', j);
-        digitalWrite(background[j], PATTERN_OFF);
-        delay(minimal);
-    }
+    digitalWrite(background[0], PATTERN_OFF); delay(none);
+    digitalWrite(background[5], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[1], PATTERN_OFF); delay(none);
+    digitalWrite(background[4], PATTERN_OFF); delay(minimal);
+    digitalWrite(background[2], PATTERN_OFF); delay(none);
+    digitalWrite(background[3], PATTERN_OFF); delay(minimal);
 }
 
 void backgroundOnInsideOut() {
     delay(none);
     log('backgroundOnInsideOut - START');
-    for (int i = (sizeof(background) / 2) - 1, j = i + 1; i >= 0; i--, j++) {
-        log('backgroundOnInsideOut i: ', i);
-        digitalWrite(background[i], PATTERN_ON);
-        delay(none);
-        log('backgroundOnInsideOut j: ', j);
-        digitalWrite(background[j], PATTERN_ON);
-        delay(minimal);
-    }
+    digitalWrite(background[3], PATTERN_ON); delay(minimal);
+    digitalWrite(background[2], PATTERN_ON); delay(none);
+    digitalWrite(background[4], PATTERN_ON); delay(minimal);
+    digitalWrite(background[1], PATTERN_ON); delay(none);
+    digitalWrite(background[5], PATTERN_ON); delay(minimal);
+    digitalWrite(background[0], PATTERN_ON); delay(none);
 }
 
 void allOff() {
     delay(none);
-    for (int i = 0; i < sizeof(Lights); i++) {
-        digitalWrite(Lights[i], PATTERN_OFF);
-        delay(none);
-    }
+    digitalWrite(Lights[0], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[1], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[2], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[3], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[4], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[5], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[6], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[7], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[8], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[9], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[10], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[11], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[12], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[13], PATTERN_OFF); delay(none);
+    digitalWrite(Lights[14], PATTERN_OFF); delay(none);
 }
 
 void allOn() {
     delay(none);
-    for (int i = 0; i < sizeof(Lights); i++) {
-        digitalWrite(Lights[i], PATTERN_ON);
-        delay(none);
-    }
+    digitalWrite(Lights[0], PATTERN_ON); delay(none);
+    digitalWrite(Lights[1], PATTERN_ON); delay(none);
+    digitalWrite(Lights[2], PATTERN_ON); delay(none);
+    digitalWrite(Lights[3], PATTERN_ON); delay(none);
+    digitalWrite(Lights[4], PATTERN_ON); delay(none);
+    digitalWrite(Lights[5], PATTERN_ON); delay(none);
+    digitalWrite(Lights[6], PATTERN_ON); delay(none);
+    digitalWrite(Lights[7], PATTERN_ON); delay(none);
+    digitalWrite(Lights[8], PATTERN_ON); delay(none);
+    digitalWrite(Lights[9], PATTERN_ON); delay(none);
+    digitalWrite(Lights[10], PATTERN_ON); delay(none);
+    digitalWrite(Lights[11], PATTERN_ON); delay(none);
+    digitalWrite(Lights[12], PATTERN_ON); delay(none);
+    digitalWrite(Lights[13], PATTERN_ON); delay(none);
+    digitalWrite(Lights[14], PATTERN_ON); delay(none);
 }
 
 // Patterns

    int possibility = random(0, 100);

    if (possibility > 95) { // rare things, only happen 5% of the time
        switch (random(0, 2)) {
        case 0:
            flickerPattern(random(0, 2), random(0, 2));
            blinkMin = 0;
            break;
        case 1:
            blinkAllOnRandom();
            blinkMax = 3;
            break;
        }
    } else if (possibility > 70) { // less rare things, happen 25% of the time
        if (random(0, 200) == 0) {
            runBackgroundPattern();

    classicBackground();
}

void _runTracer() {
  
}

void runTracer() {
    digitalWrite(background[0], PATTERN_ON); delay(none);
    digitalWrite(background[1], PATTERN_ON); delay(none);
    digitalWrite(background[2], PATTERN_ON); delay(none);
    digitalWrite(background[3], PATTERN_ON); delay(none);
    digitalWrite(background[4], PATTERN_ON); delay(none);
    digitalWrite(background[5], PATTERN_ON); delay(none);

    digitalWrite(letters[0], PATTERN_ON); delay(250); digitalWrite(letters[0], PATTERN_OFF); delay(250);
    digitalWrite(letters[1], PATTERN_ON); delay(250); digitalWrite(letters[1], PATTERN_OFF); delay(250);
    digitalWrite(letters[2], PATTERN_ON); delay(250); digitalWrite(letters[2], PATTERN_OFF); delay(250); 
    digitalWrite(letters[3], PATTERN_ON); delay(250); digitalWrite(letters[3], PATTERN_OFF); delay(250);
    digitalWrite(letters[4], PATTERN_ON); delay(250); digitalWrite(letters[4], PATTERN_OFF); delay(250);
    digitalWrite(letters[5], PATTERN_ON); delay(250); digitalWrite(letters[5], PATTERN_OFF); delay(250);
    digitalWrite(letters[6], PATTERN_ON); delay(250); digitalWrite(letters[6], PATTERN_OFF); delay(250);
    digitalWrite(letters[7], PATTERN_ON); delay(250); digitalWrite(letters[7], PATTERN_OFF); delay(250);
    digitalWrite(letters[8], PATTERN_ON); delay(250); digitalWrite(letters[8], PATTERN_OFF); delay(250);
    
    digitalWrite(Lights[0], PATTERN_ON); delay(none); 
    digitalWrite(Lights[1], PATTERN_ON); delay(none); 
    digitalWrite(Lights[2], PATTERN_ON); delay(none); 
    digitalWrite(Lights[3], PATTERN_ON); delay(none); 
    digitalWrite(Lights[4], PATTERN_ON); delay(none); 
    digitalWrite(Lights[5], PATTERN_ON); delay(none); 
    digitalWrite(Lights[6], PATTERN_ON); delay(none); 
    digitalWrite(Lights[7], PATTERN_ON); delay(none); 
    digitalWrite(Lights[8], PATTERN_ON); delay(none); 
    delay(250);
    digitalWrite(Lights[0], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[1], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[2], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[3], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[4], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[5], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[6], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[7], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[8], PATTERN_OFF); delay(none); 
    delay(250);
    digitalWrite(Lights[0], PATTERN_ON); delay(none); 
    digitalWrite(Lights[1], PATTERN_ON); delay(none); 
    digitalWrite(Lights[2], PATTERN_ON); delay(none); 
    digitalWrite(Lights[3], PATTERN_ON); delay(none); 
    digitalWrite(Lights[4], PATTERN_ON); delay(none); 
    digitalWrite(Lights[5], PATTERN_ON); delay(none); 
    digitalWrite(Lights[6], PATTERN_ON); delay(none); 
    digitalWrite(Lights[7], PATTERN_ON); delay(none); 
    digitalWrite(Lights[8], PATTERN_ON); delay(none); 
    delay(250);
    digitalWrite(Lights[0], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[1], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[2], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[3], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[4], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[5], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[6], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[7], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[8], PATTERN_OFF); delay(none); 
    delay(250);
    digitalWrite(Lights[0], PATTERN_ON); delay(none); 
    digitalWrite(Lights[1], PATTERN_ON); delay(none); 
    digitalWrite(Lights[2], PATTERN_ON); delay(none); 
    digitalWrite(Lights[3], PATTERN_ON); delay(none); 
    digitalWrite(Lights[4], PATTERN_ON); delay(none); 
    digitalWrite(Lights[5], PATTERN_ON); delay(none); 
    digitalWrite(Lights[6], PATTERN_ON); delay(none); 
    digitalWrite(Lights[7], PATTERN_ON); delay(none); 
    digitalWrite(Lights[8], PATTERN_ON); delay(none); 
    delay(250);
    digitalWrite(Lights[0], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[1], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[2], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[3], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[4], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[5], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[6], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[7], PATTERN_OFF); delay(none); 
    digitalWrite(Lights[8], PATTERN_OFF); delay(none); 
    delay(250);
    delay(250);
}

void runLetterPattern() {
    // if new patterns are added, add a new case statement, and bump up the max random value by one
    switch (random(0, 2)) {
    case 0: { lettersOnLeftToRight(); break; }
    case 1: { blinkLetters(random(5, 10)); break; }
    // case 2: {  blinkLettersOnRandom(); break; }
    default: { break; }
    }
}

void runBackgroundPattern() {
    switch (random(0, 4)) {
    case 0: { classicBackground(); break; }
    case 1: { insideOutOutsideInBackground(); break; }
    case 2: { racingOnLeftToRightBackground(); break; }
    case 3: { blinkBackground(random(5, 10)); backgroundAllOn(); break; }
//    case 4: { blinkBackgroundOnRandom(); break; }
    }
}

