int NOTE_B0 = 31;
int NOTE_C1 = 33;
int NOTE_CS1 = 35;
int NOTE_D1 = 37;
int NOTE_DS1 = 39;
int NOTE_E1 = 41;
int NOTE_F1 = 44;
int NOTE_FS1 = 46;
int NOTE_G1 = 49;
int NOTE_GS1 = 52;
int NOTE_A1 = 55;
int NOTE_AS1 = 58;
int NOTE_B1 = 62;
int NOTE_C2 = 65;
int NOTE_CS2 = 69;
int NOTE_D2 = 73;
int NOTE_DS2 = 78;
int NOTE_E2 = 82;
int NOTE_F2 = 87;
int NOTE_FS2 = 93;
int NOTE_G2 = 98;
int NOTE_GS2 = 104;
int NOTE_A2 = 110;
int NOTE_AS2 = 117;
int NOTE_B2 = 123;
int NOTE_C3 = 131;
int NOTE_CS3 = 139;
int NOTE_D3 = 147;
int NOTE_DS3 = 156;
int NOTE_E3 = 165;
int NOTE_F3 = 175;
int NOTE_FS3 = 185;
int NOTE_G3 = 196;
int NOTE_GS3 = 208;
int NOTE_A3 = 220;
int NOTE_AS3 = 233;
int NOTE_B3 = 247;
int NOTE_C4 = 262;
int NOTE_CS4 = 277;
int NOTE_D4 = 294;
int NOTE_DS4 = 311;
int NOTE_E4 = 330;
int NOTE_F4 = 349;
int NOTE_FS4 = 370;
int NOTE_G4 = 392;
int NOTE_GS4 = 415;
int NOTE_A4 = 440;
int NOTE_AS4 = 466;
int NOTE_B4 = 494;
int NOTE_C5 = 523;
int NOTE_CS5 = 554;
int NOTE_D5 = 587;
int NOTE_DS5 = 622;
int NOTE_E5 = 659;
int NOTE_F5 = 698;
int NOTE_FS5 = 740;
int NOTE_G5 = 784;
int NOTE_GS5 = 831;
int NOTE_A5 = 880;
int NOTE_AS5 = 932;
int NOTE_B5 = 988;
int NOTE_C6 = 1047;
int NOTE_CS6 = 1109;
int NOTE_D6 = 1175;
int NOTE_DS6 = 1245;
int NOTE_E6 = 1319;
int NOTE_F6 = 1397;
int NOTE_FS6 = 1480;
int NOTE_G6 = 1568;
int NOTE_GS6 = 1661;
int NOTE_A6 = 1760;
int NOTE_AS6 = 1865;
int NOTE_B6 = 1976;
int NOTE_C7 = 2093;
int NOTE_CS7 = 2217;
int NOTE_D7 = 2349;
int NOTE_DS7 = 2489;
int NOTE_E7 = 2637;
int NOTE_F7 = 2794;
int NOTE_FS7 = 2960;
int NOTE_G7 = 3136;
int NOTE_GS7 = 3322;
int NOTE_A7 = 3520;
int NOTE_AS7 = 3729;
int NOTE_B7 = 3951;
int NOTE_C8 = 4186;
int NOTE_CS8 = 4435;
int NOTE_D8 = 4699;
int NOTE_DS8 = 4978;
// Pitch Declarations

/*
void song() {
  float noteSpeed = 1.20; // Speed Factor
  int bpm = 0; // INSERT BPM
  int timeMeasure = 60000 / bpm;

  int melody[] = {
    0, // Buffer
    
  };

  float beat[] = {
    2, // Buffer

  }; int numBeats = sizeof(beat) / sizeof(beat[0]);

  for (int next = 0; next < numBeats; next++) {
    float inBetween = (timeMeasure * beat[next]) / 4;

    tone(13, melody[next], inBetween);
    float notePause = inBetween * noteSpeed; 

    delay(notePause);
    noTone(13);
  }
} // INSERT SONG TITLE
*/

void song1() {
  float noteSpeed = 1.20; // Speed Factor
  int bpm = 70;
  int timeMeasure = 60000 / (bpm * noteSpeed);

  int melody[] = {
    0, // Buffer
    NOTE_AS4, NOTE_G5, NOTE_F5, NOTE_DS5, NOTE_G5, NOTE_F5, NOTE_DS5, NOTE_G5,
    NOTE_F5, NOTE_DS5, NOTE_AS4, NOTE_AS4, NOTE_GS5, NOTE_F5, NOTE_DS5, NOTE_AS5,
    NOTE_D5, NOTE_D5, NOTE_G5, NOTE_F5, NOTE_D5, NOTE_DS5, NOTE_F5, NOTE_AS5, 
    NOTE_G5, NOTE_F5, NOTE_DS5, NOTE_G5, NOTE_F5, NOTE_G5, NOTE_AS5, NOTE_G5,
    NOTE_AS5, NOTE_C6, NOTE_G5, NOTE_F5, NOTE_DS5, NOTE_AS4, NOTE_D5, NOTE_C6,
    NOTE_D6, NOTE_D6, NOTE_AS5, NOTE_C6, NOTE_G5, NOTE_GS5, NOTE_DS5, NOTE_C5,
    NOTE_D5, NOTE_G5, NOTE_DS5
  };

  float beat[] = {
    2, // Buffer, 
    1, 2, 3, 1, 2, 3, 1, 2,
    2, 2, 5, 1, 2, 3, 1, 2,
    3, 1, 2, 2, 2, 4, 1, 1,
    2, 3, 1, 2, 3, 1, 2, 2,
    2, 6, 2, 2, 2, 2, 3, 1,
    2, 2, 2, 5, 1, 2, 2, 2,
    4, 2, 7
  }; int numBeats = sizeof(beat) / sizeof(beat[0]);

  for (int next = 0; next < numBeats; next++) {
    float inBetween = (timeMeasure * beat[next]) / 4;

    tone(13, melody[next], inBetween);
    float notePause = inBetween * noteSpeed;

    delay(notePause);
    noTone(13);
  }
} // Disney - Le Festin


void song2() {
  float noteSpeed = 1.00; // Speed Factor
  int bpm = 81;
  int timeMeasure = 60000 / (bpm * noteSpeed);

  int melody[] = {
    0, // Buffer
    NOTE_G3, NOTE_B3, NOTE_D4, NOTE_FS4, NOTE_G4, NOTE_C4, NOTE_G3, NOTE_B3,
    NOTE_A3, NOTE_A3, NOTE_G3, NOTE_D3, NOTE_B3, NOTE_D4, NOTE_FS4, NOTE_G4,
    NOTE_A4, NOTE_B4, NOTE_G4, NOTE_A4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_B4,
    NOTE_C5, NOTE_D5, NOTE_D5, NOTE_C5, NOTE_B4, NOTE_A4, NOTE_G4, NOTE_C5,
    NOTE_B4, NOTE_A4, NOTE_G4, NOTE_D4, NOTE_E4, NOTE_G4, NOTE_FS4, NOTE_G4,
    NOTE_B4, NOTE_D5, NOTE_FS5, NOTE_G5, NOTE_C5, NOTE_D5, NOTE_A4, NOTE_B4,
    NOTE_B4, NOTE_D5, NOTE_FS5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_A5, NOTE_B5,
    NOTE_D6, NOTE_G5, NOTE_G5, NOTE_FS5, NOTE_G5, NOTE_B5, NOTE_C5, NOTE_B5,
    NOTE_C6, NOTE_A5, NOTE_B5, NOTE_G5
  };

  float beat[] = {
    2, // Buffer
    6, 2, 1, 2, 1, 3, 3, 2,
    1, 2, 1, 6, 2, 1, 2, 1,
    4, 1, 1, 6, 6, 2, 1, 2,
    1, 6, 2, 1, 2, 1, 6, 2,
    1, 2, 1, 3, 3, 3, 3, 6,
    2, 1, 2, 1, 9, 2, 1, 6,
    2, 1, 2, 1, 6, 2, 1, 2,
    1, 6, 2, 1, 2, 1, 6, 2,
    1, 2, 1, 7

  }; int numBeats = sizeof(beat) / sizeof(beat[0]);

  for (int next = 0; next < numBeats; next++) {
    float inBetween = (timeMeasure * beat[next]) / 4;

    tone(13, melody[next], inBetween);
    float notePause = inBetween * noteSpeed;

    delay(notePause);
    noTone(13);
  }
} // Disney - Beauty and The Beast


void song3() {
  float noteSpeed = 1.05; // Speed Factor
  int bpm = 106; // INSERT BPM
  int timeMeasure = 60000 / (bpm * noteSpeed);

  int melody[] = {
    0, // Buffer
    NOTE_C4, 0, NOTE_A3, NOTE_C4, 0, NOTE_G3, NOTE_A3, NOTE_C4,
    0, NOTE_D4, 0, NOTE_G3, NOTE_A3, NOTE_G3, NOTE_C4, 0,
    NOTE_A3, NOTE_C4, 0, NOTE_G3, NOTE_A3, NOTE_C4, 0, NOTE_D4,
    0, NOTE_G3, NOTE_A3, NOTE_C4, NOTE_G4, 0, NOTE_G4, 0,
    NOTE_G4, 0, NOTE_G4, NOTE_F4, NOTE_E4, 0, NOTE_E4, NOTE_F4,
    NOTE_G4, 0, NOTE_E4, 0, NOTE_D4, 0, NOTE_C4, NOTE_D4,
    NOTE_E4, NOTE_C4, NOTE_G3, NOTE_G4, NOTE_A4, NOTE_G4, 0, NOTE_G4, 
    NOTE_A4, NOTE_G4, 0, NOTE_C5, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_G4,
    NOTE_A4, 0, NOTE_G4, NOTE_B4, 0, NOTE_C5
  };

  float beat[] = {
    2, // Buffer
    2, 4, 2, 2, 2, 2, 2, 2,
    4, 2, 4, 1, 1, 2, 2, 4,
    2, 2, 2, 2, 2, 2, 4, 2, 
    7, 0.5, 0.5, 4, 1, 1, 1, 1,
    1, 6, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 3, 2, 2,
    2, 2, 2, 1, 1, 1, 1, 1,
    1, 1, 1, 2, 2, 2, 2, 1,
    1, 1, 1, 1, 1, 2
  }; int numBeats = sizeof(beat) / sizeof(beat[0]);

  for (int next = 0; next < numBeats; next++) {
    float inBetween = (timeMeasure * beat[next]) / 4;

    tone(13, melody[next], inBetween);
    float notePause = inBetween * noteSpeed;

    delay(notePause);
    noTone(13);
  }
} // DDLC - Your Reality


void song4() {
  float noteSpeed = 1.05; // Speed Factor
  int bpm = 72; // INSERT BPM
  int timeMeasure = 60000 / (bpm * noteSpeed);

  int melody[] = {
    0, // Buffer
    NOTE_D5, 0, NOTE_D5, 0, NOTE_D5, 0, NOTE_C5, 0,
    NOTE_C5, 0, NOTE_C5, 0, NOTE_AS4, 0, NOTE_AS4, 0,
    NOTE_AS4, 0, NOTE_A4, NOTE_G4, NOTE_FS4, NOTE_D2, NOTE_A2, NOTE_D3,
    NOTE_FS3, NOTE_A3, NOTE_D4, 0, NOTE_D4, NOTE_G4, NOTE_AS4, NOTE_D5,
    NOTE_D5, NOTE_C5, NOTE_AS4, NOTE_A4, NOTE_AS4, NOTE_G4, NOTE_AS4, NOTE_D5,
    NOTE_G5, NOTE_G5, NOTE_G5, NOTE_F5, NOTE_DS5, NOTE_F5, NOTE_A4, NOTE_D5,
    NOTE_F5, NOTE_A5, NOTE_G5, NOTE_F5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_F5,
    NOTE_E5, NOTE_D5, NOTE_C5, NOTE_AS4, NOTE_C5, NOTE_D5, NOTE_C5, NOTE_G4,
    NOTE_A4, NOTE_G4, NOTE_F4, NOTE_E4, NOTE_D4, NOTE_C4, NOTE_A3, NOTE_G3,
    NOTE_F3, NOTE_E3, NOTE_D3, NOTE_C3, NOTE_A2
  };

  float beat[] = {
    2, // Buffer
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 4, 1, 1, 1,
    1, 2, 2, 4, 2, 2, 2, 4,
    2, 2, 2, 2, 6, 2, 2, 2, 
    4, 2, 2, 2, 2, 6, 2, 2,
    2, 4, 2, 2, 2, 2, 4, 2,
    4, 2, 2, 2, 2, 2, 2, 2,
    1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 8
  }; int numBeats = sizeof(beat) / sizeof(beat[0]);

  for (int next = 0; next < numBeats; next++) {
    float inBetween = (timeMeasure * beat[next]) / 4;

    tone(13, melody[next], inBetween);
    float notePause = inBetween * noteSpeed;

    delay(notePause);
    noTone(13);
  }
} // Studio Ghibli - Howl's Moving Castle


void song5() {
  float noteSpeed = 1.20; // Speed Factor
  int bpm = 65; // INSERT BPM
  int timeMeasure = 60000 / (bpm * noteSpeed);

  int melody[] = {
    0, // Buffer
    NOTE_CS4, 0, NOTE_CS4, 0, NOTE_CS4, 0, NOTE_CS4, NOTE_AS3,
    0, NOTE_AS3, NOTE_DS3, 0, NOTE_DS3, 0, NOTE_DS3, 0,
    NOTE_DS3, NOTE_GS3, 0, NOTE_AS3, NOTE_GS3, NOTE_CS4, 0, NOTE_CS4,
    0, NOTE_CS4, 0, NOTE_CS4, NOTE_AS3, 0, NOTE_GS3, NOTE_DS3,
    0, NOTE_DS3, 0, NOTE_DS3, 0, NOTE_DS3, NOTE_GS2, 0,
    NOTE_CS4, NOTE_AS3, 0, NOTE_AS3, 0, NOTE_DS3, 0, NOTE_DS3,
    0, NOTE_GS3, 0, NOTE_GS3, NOTE_AS3, NOTE_C4, NOTE_GS4, NOTE_F4,
    NOTE_C4, NOTE_CS4, NOTE_AS3, NOTE_F4, NOTE_GS3, NOTE_AS3, NOTE_C4, NOTE_GS4,
    NOTE_F4, NOTE_C4, NOTE_AS3, 0, NOTE_F4, NOTE_CS4, NOTE_DS4, NOTE_GS4,
    NOTE_F4, NOTE_GS4, NOTE_F4, NOTE_AS4, NOTE_C5, NOTE_AS4, NOTE_F4, NOTE_F4,
    NOTE_F4, NOTE_CS4, NOTE_F4, NOTE_CS4, NOTE_C4, NOTE_CS4, NOTE_CS4, NOTE_C4,
    NOTE_GS3, NOTE_GS4, NOTE_CS4, NOTE_C4, NOTE_CS4, NOTE_CS4, NOTE_C4, NOTE_AS3,
    NOTE_F4, NOTE_DS4, NOTE_CS4, NOTE_GS3, NOTE_FS3, NOTE_F3, NOTE_DS3, NOTE_CS3
  };

  float beat[] = {
    2, // Buffer
    1, 1, 1, 1, 0.5, 0.5, 1, 4.5,
    0.5, 1, 1, 1, 1, 1, 0.5, 0.5, 
    1, 3.5, 0.5, 1, 1, 1, 1, 1,
    1, 0.5, 0.5, 1, 4.5, 0.5, 1, 1,
    1, 1, 1, 0.5, 0.5, 1, 1, 7,
    4, 1, 2, 1, 2, 1, 2, 1,
    1, 1, 6, 2, 2, 2, 2, 1,
    2, 1, 6, 6, 2, 2, 2, 2,
    2, 2, 2, 2, 1, 1, 6, 2,
    1, 2, 1, 1, 1, 2, 1, 1,
    2, 1, 2, 1, 2, 2, 1, 1,
    3, 2, 1, 2, 2, 1, 1, 4,
    2, 4, 2, 1, 1, 1, 1, 2
  }; int numBeats = sizeof(beat) / sizeof(beat[0]);

  for (int next = 0; next < numBeats; next++) {
    float inBetween = (timeMeasure * beat[next]) / 4;

    tone(13, melody[next], inBetween);
    float notePause = inBetween * noteSpeed; 

    delay(notePause);
    noTone(13);
  }
} // The Chords - Sh Boom (Alt Take) x Beabadoobee - Glue Song


void song6() {
  float noteSpeed = 1.40; // Speed Factor
  int bpm = 95; // INSERT BPM
  int timeMeasure = 60000 / (bpm * noteSpeed);

  int melody[] = {
    0, // Buffer
    NOTE_E4, NOTE_G4, NOTE_G4, NOTE_G4, NOTE_D4, NOTE_D4, NOTE_E4, NOTE_D4,
    NOTE_D4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_D4, NOTE_C4, NOTE_E4, NOTE_C4,
    NOTE_C5, NOTE_C4, NOTE_C5, NOTE_B4, NOTE_C4, NOTE_B4, NOTE_G4, NOTE_C4,
    NOTE_G4, NOTE_C4, NOTE_E4, NOTE_D4, NOTE_C4, NOTE_C5, NOTE_C4, NOTE_C5,
    NOTE_B4, NOTE_C4, NOTE_B4, NOTE_G4, NOTE_C4, NOTE_G4, NOTE_C4, NOTE_E4,
    NOTE_F4, NOTE_E4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_G4, NOTE_G4, NOTE_E4,
    NOTE_D4, NOTE_D4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_D4
  };

  float beat[] = {
    2, // Buffer
    1, 1, 1, 2, 2, 4, 2, 2,
    4, 2, 2, 2, 1, 1, 2, 3,
    
    1, 1, 1, 1, 1, 1, 3, 1,
    1, 1, 2, 1, 1, 1, 1, 1,
    1, 1, 1, 3, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 2, 1,
    1, 4, 2, 1, 1, 4,

  }; int numBeats = sizeof(beat) / sizeof(beat[0]);

  for (int next = 0; next < numBeats; next++) {
    float inBetween = (timeMeasure * beat[next]) / 4;

    tone(13, melody[next], inBetween);
    float notePause = inBetween * noteSpeed; 

    delay(notePause);
    noTone(13);
  }
} // Vanessa Carlton - A Thousand Miles





void setup() {
  randomSeed(analogRead(A0));
  int determineSong = random(6, 7);
  switch (determineSong) {
    case 1: 
    song1();
    break;

    case 2:
    song2();
    break;

    case 3:
    song3();
    break;

    case 4:
    song4();
    break;

    case 5:
    song5();
    break;

    case 6:
    song6();
    break;

    default:
    return 0;
  }
}

void loop() {
  
}