Merge remote-tracking branch 'upstream/master'

* upstream/master: (1239 commits)
  Update ez.c
  removes planck/rev3 temporarily
  Move hand_swap_config to ez.c, removes error for infinity
  Update Makefile
  ergodox: Update algernon's keymap to v1.9
  Added VS Code dir to .gitignore
  Support the Pegasus Hoof controller.
  [Jack & Erez] Simplifies and documents TO
  add readme
  use wait_ms instead of _delay_ms
  add messenger
  init keymap
  Add example keymap
  Adding whiskey_tango_foxtrot_capslock ergodox keymap
  Unicode map framework. Allow unicode up to 0xFFFFF using separate mapping table
  CIE 1931 dim curve
  Apply the dim curve to the RGB output
  Update the Cluecard readme files
  Tune snake and knight intervals for Cluecard
  Tunable RGB light intervals
  ...

12 files changed, 1227 insertions, 0 deletions

diff --git a/quantum/process_keycode/process_chording.c b/quantum/process_keycode/process_chording.c
new file mode 100644
index 000000000..d7814629f
--- /dev/null
+++ b/quantum/process_keycode/process_chording.c
@@ -0,0 +1,60 @@
+#include "process_chording.h"
+
+bool keys_chord(uint8_t keys[]) {
+  uint8_t keys_size = sizeof(keys)/sizeof(keys[0]);
+  bool pass = true;
+  uint8_t in = 0;
+  for (uint8_t i = 0; i < chord_key_count; i++) {
+    bool found = false;
+    for (uint8_t j = 0; j < keys_size; j++) {
+      if (chord_keys[i] == (keys[j] & 0xFF)) {
+        in++; // detects key in chord
+        found = true;
+        break;
+      }
+    }
+    if (found)
+      continue;
+    if (chord_keys[i] != 0)  {
+      pass = false; // makes sure rest are blank
+    }
+  }
+  return (pass && (in == keys_size));
+}
+
+bool process_chording(uint16_t keycode, keyrecord_t *record) {
+  if (keycode >= QK_CHORDING && keycode <= QK_CHORDING_MAX) {
+    if (record->event.pressed) {
+      if (!chording) {
+        chording = true;
+        for (uint8_t i = 0; i < CHORDING_MAX; i++)
+          chord_keys[i] = 0;
+        chord_key_count = 0;
+        chord_key_down = 0;
+      }
+      chord_keys[chord_key_count] = (keycode & 0xFF);
+      chord_key_count++;
+      chord_key_down++;
+      return false;
+    } else {
+      if (chording) {
+        chord_key_down--;
+        if (chord_key_down == 0) {
+          chording = false;
+          // Chord Dictionary
+          if (keys_chord((uint8_t[]){KC_ENTER, KC_SPACE})) {
+            register_code(KC_A);
+            unregister_code(KC_A);
+            return false;
+          }
+          for (uint8_t i = 0; i < chord_key_count; i++) {
+            register_code(chord_keys[i]);
+            unregister_code(chord_keys[i]);
+            return false;
+          }
+        }
+      }
+    }
+  }
+  return true;
+}
\ No newline at end of file
diff --git a/quantum/process_keycode/process_chording.h b/quantum/process_keycode/process_chording.h
new file mode 100644
index 000000000..49c97db3b
--- /dev/null
+++ b/quantum/process_keycode/process_chording.h
@@ -0,0 +1,16 @@
+#ifndef PROCESS_CHORDING_H
+#define PROCESS_CHORDING_H
+
+#include "quantum.h"
+
+// Chording stuff
+#define CHORDING_MAX 4
+bool chording = false;
+
+uint8_t chord_keys[CHORDING_MAX] = {0};
+uint8_t chord_key_count = 0;
+uint8_t chord_key_down = 0;
+
+bool process_chording(uint16_t keycode, keyrecord_t *record);
+
+#endif
\ No newline at end of file
diff --git a/quantum/process_keycode/process_leader.c b/quantum/process_keycode/process_leader.c
new file mode 100644
index 000000000..e53d221e7
--- /dev/null
+++ b/quantum/process_keycode/process_leader.c
@@ -0,0 +1,38 @@
+#include "process_leader.h"
+
+__attribute__ ((weak))
+void leader_start(void) {}
+
+__attribute__ ((weak))
+void leader_end(void) {}
+
+// Leader key stuff
+bool leading = false;
+uint16_t leader_time = 0;
+
+uint16_t leader_sequence[5] = {0, 0, 0, 0, 0};
+uint8_t leader_sequence_size = 0;
+
+bool process_leader(uint16_t keycode, keyrecord_t *record) {
+  // Leader key set-up
+  if (record->event.pressed) {
+    if (!leading && keycode == KC_LEAD) {
+      leader_start();
+      leading = true;
+      leader_time = timer_read();
+      leader_sequence_size = 0;
+      leader_sequence[0] = 0;
+      leader_sequence[1] = 0;
+      leader_sequence[2] = 0;
+      leader_sequence[3] = 0;
+      leader_sequence[4] = 0;
+      return false;
+    }
+    if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {
+      leader_sequence[leader_sequence_size] = keycode;
+      leader_sequence_size++;
+      return false;
+    }
+  }
+  return true;
+}
\ No newline at end of file
diff --git a/quantum/process_keycode/process_leader.h b/quantum/process_keycode/process_leader.h
new file mode 100644
index 000000000..c83db8abb
--- /dev/null
+++ b/quantum/process_keycode/process_leader.h
@@ -0,0 +1,23 @@
+#ifndef PROCESS_LEADER_H
+#define PROCESS_LEADER_H
+
+#include "quantum.h"
+
+bool process_leader(uint16_t keycode, keyrecord_t *record);
+
+void leader_start(void);
+void leader_end(void);
+
+#ifndef LEADER_TIMEOUT
+  #define LEADER_TIMEOUT 200
+#endif
+#define SEQ_ONE_KEY(key) if (leader_sequence[0] == (key) && leader_sequence[1] == 0 && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
+#define SEQ_TWO_KEYS(key1, key2) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0)
+#define SEQ_THREE_KEYS(key1, key2, key3) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == 0 && leader_sequence[4] == 0)
+#define SEQ_FOUR_KEYS(key1, key2, key3, key4) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == (key4) && leader_sequence[4] == 0)
+#define SEQ_FIVE_KEYS(key1, key2, key3, key4, key5) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == (key3) && leader_sequence[3] == (key4) && leader_sequence[4] == (key5))
+
+#define LEADER_EXTERNS() extern bool leading; extern uint16_t leader_time; extern uint16_t leader_sequence[5]; extern uint8_t leader_sequence_size
+#define LEADER_DICTIONARY() if (leading && timer_elapsed(leader_time) > LEADER_TIMEOUT)
+
+#endif
\ No newline at end of file
diff --git a/quantum/process_keycode/process_midi.c b/quantum/process_keycode/process_midi.c
new file mode 100644
index 000000000..577dad43a
--- /dev/null
+++ b/quantum/process_keycode/process_midi.c
@@ -0,0 +1,68 @@
+#include "process_midi.h"
+
+bool midi_activated = false;
+uint8_t midi_starting_note = 0x0C;
+int midi_offset = 7;
+
+bool process_midi(uint16_t keycode, keyrecord_t *record) {
+    if (keycode == MI_ON && record->event.pressed) {
+      midi_activated = true;
+#ifdef AUDIO_ENABLE
+      music_scale_user();
+#endif
+      return false;
+    }
+
+    if (keycode == MI_OFF && record->event.pressed) {
+      midi_activated = false;
+      midi_send_cc(&midi_device, 0, 0x7B, 0);
+      return false;
+    }
+
+    if (midi_activated) {
+      if (record->event.key.col == (MATRIX_COLS - 1) && record->event.key.row == (MATRIX_ROWS - 1)) {
+          if (record->event.pressed) {
+              midi_starting_note++; // Change key
+              midi_send_cc(&midi_device, 0, 0x7B, 0);
+          }
+          return false;
+      }
+      if (record->event.key.col == (MATRIX_COLS - 2) && record->event.key.row == (MATRIX_ROWS - 1)) {
+          if (record->event.pressed) {
+              midi_starting_note--; // Change key
+              midi_send_cc(&midi_device, 0, 0x7B, 0);
+          }
+          return false;
+      }
+      if (record->event.key.col == (MATRIX_COLS - 3) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
+          midi_offset++; // Change scale
+          midi_send_cc(&midi_device, 0, 0x7B, 0);
+          return false;
+      }
+      if (record->event.key.col == (MATRIX_COLS - 4) && record->event.key.row == (MATRIX_ROWS - 1) && record->event.pressed) {
+          midi_offset--; // Change scale
+          midi_send_cc(&midi_device, 0, 0x7B, 0);
+          return false;
+      }
+      // basic
+      // uint8_t note = (midi_starting_note + SCALE[record->event.key.col + midi_offset])+12*(MATRIX_ROWS - record->event.key.row);
+      // advanced
+      // uint8_t note = (midi_starting_note + record->event.key.col + midi_offset)+12*(MATRIX_ROWS - record->event.key.row);
+      // guitar
+      uint8_t note = (midi_starting_note + record->event.key.col + midi_offset)+5*(MATRIX_ROWS - record->event.key.row);
+      // violin
+      // uint8_t note = (midi_starting_note + record->event.key.col + midi_offset)+7*(MATRIX_ROWS - record->event.key.row);
+
+      if (record->event.pressed) {
+        // midi_send_noteon(&midi_device, record->event.key.row, midi_starting_note + SCALE[record->event.key.col], 127);
+        midi_send_noteon(&midi_device, 0, note, 127);
+      } else {
+        // midi_send_noteoff(&midi_device, record->event.key.row, midi_starting_note + SCALE[record->event.key.col], 127);
+        midi_send_noteoff(&midi_device, 0, note, 127);
+      }
+
+      if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
+        return false;
+    }
+  return true;
+}
diff --git a/quantum/process_keycode/process_midi.h b/quantum/process_keycode/process_midi.h
new file mode 100644
index 000000000..acd4fc1b1
--- /dev/null
+++ b/quantum/process_keycode/process_midi.h
@@ -0,0 +1,207 @@
+#ifndef PROCESS_MIDI_H
+#define PROCESS_MIDI_H
+
+#include "quantum.h"
+
+bool process_midi(uint16_t keycode, keyrecord_t *record);
+
+#define MIDI(n) ((n) | 0x6000)
+#define MIDI12 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000, 0x6000
+
+#define CHNL(note, channel) (note + (channel << 8))
+
+#define SCALE (int8_t []){ 0 + (12*0), 2 + (12*0), 4 + (12*0), 5 + (12*0), 7 + (12*0), 9 + (12*0), 11 + (12*0), \
+                           0 + (12*1), 2 + (12*1), 4 + (12*1), 5 + (12*1), 7 + (12*1), 9 + (12*1), 11 + (12*1), \
+                           0 + (12*2), 2 + (12*2), 4 + (12*2), 5 + (12*2), 7 + (12*2), 9 + (12*2), 11 + (12*2), \
+                           0 + (12*3), 2 + (12*3), 4 + (12*3), 5 + (12*3), 7 + (12*3), 9 + (12*3), 11 + (12*3), \
+                           0 + (12*4), 2 + (12*4), 4 + (12*4), 5 + (12*4), 7 + (12*4), 9 + (12*4), 11 + (12*4), }
+
+#define N_CN1  (0x600C + (12 * -1) + 0 )
+#define N_CN1S (0x600C + (12 * -1) + 1 )
+#define N_DN1F (0x600C + (12 * -1) + 1 )
+#define N_DN1  (0x600C + (12 * -1) + 2 )
+#define N_DN1S (0x600C + (12 * -1) + 3 )
+#define N_EN1F (0x600C + (12 * -1) + 3 )
+#define N_EN1  (0x600C + (12 * -1) + 4 )
+#define N_FN1  (0x600C + (12 * -1) + 5 )
+#define N_FN1S (0x600C + (12 * -1) + 6 )
+#define N_GN1F (0x600C + (12 * -1) + 6 )
+#define N_GN1  (0x600C + (12 * -1) + 7 )
+#define N_GN1S (0x600C + (12 * -1) + 8 )
+#define N_AN1F (0x600C + (12 * -1) + 8 )
+#define N_AN1  (0x600C + (12 * -1) + 9 )
+#define N_AN1S (0x600C + (12 * -1) + 10)
+#define N_BN1F (0x600C + (12 * -1) + 10)
+#define N_BN1  (0x600C + (12 * -1) + 11)
+#define N_C0   (0x600C + (12 *  0) + 0 )
+#define N_C0S  (0x600C + (12 *  0) + 1 )
+#define N_D0F  (0x600C + (12 *  0) + 1 )
+#define N_D0   (0x600C + (12 *  0) + 2 )
+#define N_D0S  (0x600C + (12 *  0) + 3 )
+#define N_E0F  (0x600C + (12 *  0) + 3 )
+#define N_E0   (0x600C + (12 *  0) + 4 )
+#define N_F0   (0x600C + (12 *  0) + 5 )
+#define N_F0S  (0x600C + (12 *  0) + 6 )
+#define N_G0F  (0x600C + (12 *  0) + 6 )
+#define N_G0   (0x600C + (12 *  0) + 7 )
+#define N_G0S  (0x600C + (12 *  0) + 8 )
+#define N_A0F  (0x600C + (12 *  0) + 8 )
+#define N_A0   (0x600C + (12 *  0) + 9 )
+#define N_A0S  (0x600C + (12 *  0) + 10)
+#define N_B0F  (0x600C + (12 *  0) + 10)
+#define N_B0   (0x600C + (12 *  0) + 11)
+#define N_C1   (0x600C + (12 *  1) + 0 )
+#define N_C1S  (0x600C + (12 *  1) + 1 )
+#define N_D1F  (0x600C + (12 *  1) + 1 )
+#define N_D1   (0x600C + (12 *  1) + 2 )
+#define N_D1S  (0x600C + (12 *  1) + 3 )
+#define N_E1F  (0x600C + (12 *  1) + 3 )
+#define N_E1   (0x600C + (12 *  1) + 4 )
+#define N_F1   (0x600C + (12 *  1) + 5 )
+#define N_F1S  (0x600C + (12 *  1) + 6 )
+#define N_G1F  (0x600C + (12 *  1) + 6 )
+#define N_G1   (0x600C + (12 *  1) + 7 )
+#define N_G1S  (0x600C + (12 *  1) + 8 )
+#define N_A1F  (0x600C + (12 *  1) + 8 )
+#define N_A1   (0x600C + (12 *  1) + 9 )
+#define N_A1S  (0x600C + (12 *  1) + 10)
+#define N_B1F  (0x600C + (12 *  1) + 10)
+#define N_B1   (0x600C + (12 *  1) + 11)
+#define N_C2   (0x600C + (12 *  2) + 0 )
+#define N_C2S  (0x600C + (12 *  2) + 1 )
+#define N_D2F  (0x600C + (12 *  2) + 1 )
+#define N_D2   (0x600C + (12 *  2) + 2 )
+#define N_D2S  (0x600C + (12 *  2) + 3 )
+#define N_E2F  (0x600C + (12 *  2) + 3 )
+#define N_E2   (0x600C + (12 *  2) + 4 )
+#define N_F2   (0x600C + (12 *  2) + 5 )
+#define N_F2S  (0x600C + (12 *  2) + 6 )
+#define N_G2F  (0x600C + (12 *  2) + 6 )
+#define N_G2   (0x600C + (12 *  2) + 7 )
+#define N_G2S  (0x600C + (12 *  2) + 8 )
+#define N_A2F  (0x600C + (12 *  2) + 8 )
+#define N_A2   (0x600C + (12 *  2) + 9 )
+#define N_A2S  (0x600C + (12 *  2) + 10)
+#define N_B2F  (0x600C + (12 *  2) + 10)
+#define N_B2   (0x600C + (12 *  2) + 11)
+#define N_C3   (0x600C + (12 *  3) + 0 )
+#define N_C3S  (0x600C + (12 *  3) + 1 )
+#define N_D3F  (0x600C + (12 *  3) + 1 )
+#define N_D3   (0x600C + (12 *  3) + 2 )
+#define N_D3S  (0x600C + (12 *  3) + 3 )
+#define N_E3F  (0x600C + (12 *  3) + 3 )
+#define N_E3   (0x600C + (12 *  3) + 4 )
+#define N_F3   (0x600C + (12 *  3) + 5 )
+#define N_F3S  (0x600C + (12 *  3) + 6 )
+#define N_G3F  (0x600C + (12 *  3) + 6 )
+#define N_G3   (0x600C + (12 *  3) + 7 )
+#define N_G3S  (0x600C + (12 *  3) + 8 )
+#define N_A3F  (0x600C + (12 *  3) + 8 )
+#define N_A3   (0x600C + (12 *  3) + 9 )
+#define N_A3S  (0x600C + (12 *  3) + 10)
+#define N_B3F  (0x600C + (12 *  3) + 10)
+#define N_B3   (0x600C + (12 *  3) + 11)
+#define N_C4   (0x600C + (12 *  4) + 0 )
+#define N_C4S  (0x600C + (12 *  4) + 1 )
+#define N_D4F  (0x600C + (12 *  4) + 1 )
+#define N_D4   (0x600C + (12 *  4) + 2 )
+#define N_D4S  (0x600C + (12 *  4) + 3 )
+#define N_E4F  (0x600C + (12 *  4) + 3 )
+#define N_E4   (0x600C + (12 *  4) + 4 )
+#define N_F4   (0x600C + (12 *  4) + 5 )
+#define N_F4S  (0x600C + (12 *  4) + 6 )
+#define N_G4F  (0x600C + (12 *  4) + 6 )
+#define N_G4   (0x600C + (12 *  4) + 7 )
+#define N_G4S  (0x600C + (12 *  4) + 8 )
+#define N_A4F  (0x600C + (12 *  4) + 8 )
+#define N_A4   (0x600C + (12 *  4) + 9 )
+#define N_A4S  (0x600C + (12 *  4) + 10)
+#define N_B4F  (0x600C + (12 *  4) + 10)
+#define N_B4   (0x600C + (12 *  4) + 11)
+#define N_C5   (0x600C + (12 *  5) + 0 )
+#define N_C5S  (0x600C + (12 *  5) + 1 )
+#define N_D5F  (0x600C + (12 *  5) + 1 )
+#define N_D5   (0x600C + (12 *  5) + 2 )
+#define N_D5S  (0x600C + (12 *  5) + 3 )
+#define N_E5F  (0x600C + (12 *  5) + 3 )
+#define N_E5   (0x600C + (12 *  5) + 4 )
+#define N_F5   (0x600C + (12 *  5) + 5 )
+#define N_F5S  (0x600C + (12 *  5) + 6 )
+#define N_G5F  (0x600C + (12 *  5) + 6 )
+#define N_G5   (0x600C + (12 *  5) + 7 )
+#define N_G5S  (0x600C + (12 *  5) + 8 )
+#define N_A5F  (0x600C + (12 *  5) + 8 )
+#define N_A5   (0x600C + (12 *  5) + 9 )
+#define N_A5S  (0x600C + (12 *  5) + 10)
+#define N_B5F  (0x600C + (12 *  5) + 10)
+#define N_B5   (0x600C + (12 *  5) + 11)
+#define N_C6   (0x600C + (12 *  6) + 0 )
+#define N_C6S  (0x600C + (12 *  6) + 1 )
+#define N_D6F  (0x600C + (12 *  6) + 1 )
+#define N_D6   (0x600C + (12 *  6) + 2 )
+#define N_D6S  (0x600C + (12 *  6) + 3 )
+#define N_E6F  (0x600C + (12 *  6) + 3 )
+#define N_E6   (0x600C + (12 *  6) + 4 )
+#define N_F6   (0x600C + (12 *  6) + 5 )
+#define N_F6S  (0x600C + (12 *  6) + 6 )
+#define N_G6F  (0x600C + (12 *  6) + 6 )
+#define N_G6   (0x600C + (12 *  6) + 7 )
+#define N_G6S  (0x600C + (12 *  6) + 8 )
+#define N_A6F  (0x600C + (12 *  6) + 8 )
+#define N_A6   (0x600C + (12 *  6) + 9 )
+#define N_A6S  (0x600C + (12 *  6) + 10)
+#define N_B6F  (0x600C + (12 *  6) + 10)
+#define N_B6   (0x600C + (12 *  6) + 11)
+#define N_C7   (0x600C + (12 *  7) + 0 )
+#define N_C7S  (0x600C + (12 *  7) + 1 )
+#define N_D7F  (0x600C + (12 *  7) + 1 )
+#define N_D7   (0x600C + (12 *  7) + 2 )
+#define N_D7S  (0x600C + (12 *  7) + 3 )
+#define N_E7F  (0x600C + (12 *  7) + 3 )
+#define N_E7   (0x600C + (12 *  7) + 4 )
+#define N_F7   (0x600C + (12 *  7) + 5 )
+#define N_F7S  (0x600C + (12 *  7) + 6 )
+#define N_G7F  (0x600C + (12 *  7) + 6 )
+#define N_G7   (0x600C + (12 *  7) + 7 )
+#define N_G7S  (0x600C + (12 *  7) + 8 )
+#define N_A7F  (0x600C + (12 *  7) + 8 )
+#define N_A7   (0x600C + (12 *  7) + 9 )
+#define N_A7S  (0x600C + (12 *  7) + 10)
+#define N_B7F  (0x600C + (12 *  7) + 10)
+#define N_B7   (0x600C + (12 *  7) + 11)
+#define N_C8   (0x600C + (12 *  8) + 0 )
+#define N_C8S  (0x600C + (12 *  8) + 1 )
+#define N_D8F  (0x600C + (12 *  8) + 1 )
+#define N_D8   (0x600C + (12 *  8) + 2 )
+#define N_D8S  (0x600C + (12 *  8) + 3 )
+#define N_E8F  (0x600C + (12 *  8) + 3 )
+#define N_E8   (0x600C + (12 *  8) + 4 )
+#define N_F8   (0x600C + (12 *  8) + 5 )
+#define N_F8S  (0x600C + (12 *  8) + 6 )
+#define N_G8F  (0x600C + (12 *  8) + 6 )
+#define N_G8   (0x600C + (12 *  8) + 7 )
+#define N_G8S  (0x600C + (12 *  8) + 8 )
+#define N_A8F  (0x600C + (12 *  8) + 8 )
+#define N_A8   (0x600C + (12 *  8) + 9 )
+#define N_A8S  (0x600C + (12 *  8) + 10)
+#define N_B8F  (0x600C + (12 *  8) + 10)
+#define N_B8   (0x600C + (12 *  8) + 11)
+#define N_C8   (0x600C + (12 *  8) + 0 )
+#define N_C8S  (0x600C + (12 *  8) + 1 )
+#define N_D8F  (0x600C + (12 *  8) + 1 )
+#define N_D8   (0x600C + (12 *  8) + 2 )
+#define N_D8S  (0x600C + (12 *  8) + 3 )
+#define N_E8F  (0x600C + (12 *  8) + 3 )
+#define N_E8   (0x600C + (12 *  8) + 4 )
+#define N_F8   (0x600C + (12 *  8) + 5 )
+#define N_F8S  (0x600C + (12 *  8) + 6 )
+#define N_G8F  (0x600C + (12 *  8) + 6 )
+#define N_G8   (0x600C + (12 *  8) + 7 )
+#define N_G8S  (0x600C + (12 *  8) + 8 )
+#define N_A8F  (0x600C + (12 *  8) + 8 )
+#define N_A8   (0x600C + (12 *  8) + 9 )
+#define N_A8S  (0x600C + (12 *  8) + 10)
+#define N_B8F  (0x600C + (12 *  8) + 10)
+#define N_B8   (0x600C + (12 *  8) + 11)
+
+#endif
\ No newline at end of file
diff --git a/quantum/process_keycode/process_music.c b/quantum/process_keycode/process_music.c
new file mode 100644
index 000000000..2d52e47a7
--- /dev/null
+++ b/quantum/process_keycode/process_music.c
@@ -0,0 +1,176 @@
+#include "process_music.h"
+
+bool music_activated = false;
+uint8_t starting_note = 0x0C;
+int offset = 7;
+
+// music sequencer
+static bool music_sequence_recording = false;
+static bool music_sequence_recorded = false;
+static bool music_sequence_playing = false;
+static float music_sequence[16] = {0};
+static uint8_t music_sequence_count = 0;
+static uint8_t music_sequence_position = 0;
+
+static uint16_t music_sequence_timer = 0;
+static uint16_t music_sequence_interval = 100;
+
+bool process_music(uint16_t keycode, keyrecord_t *record) {
+
+    if (keycode == AU_ON && record->event.pressed) {
+      audio_on();
+      return false;
+    }
+
+    if (keycode == AU_OFF && record->event.pressed) {
+      audio_off();
+      return false;
+    }
+
+    if (keycode == AU_TOG && record->event.pressed) {
+        if (is_audio_on())
+        {
+            audio_off();
+        }
+        else
+        {
+            audio_on();
+        }
+      return false;
+    }
+
+    if (keycode == MU_ON && record->event.pressed) {
+        music_on();
+        return false;
+    }
+
+    if (keycode == MU_OFF && record->event.pressed) {
+        music_off();
+        return false;
+    }
+
+    if (keycode == MU_TOG && record->event.pressed) {
+        if (music_activated)
+        {
+            music_off();
+        }
+        else
+        {
+            music_on();
+        }
+        return false;
+    }
+
+    if (keycode == MUV_IN && record->event.pressed) {
+        voice_iterate();
+        music_scale_user();
+        return false;
+    }
+
+    if (keycode == MUV_DE && record->event.pressed) {
+        voice_deiterate();
+        music_scale_user();
+        return false;
+    }
+
+    if (music_activated) {
+
+      if (keycode == KC_LCTL && record->event.pressed) { // Start recording
+        stop_all_notes();
+        music_sequence_recording = true;
+        music_sequence_recorded = false;
+        music_sequence_playing = false;
+        music_sequence_count = 0;
+        return false;
+      }
+
+      if (keycode == KC_LALT && record->event.pressed) { // Stop recording/playing
+        stop_all_notes();
+        if (music_sequence_recording) { // was recording
+          music_sequence_recorded = true;
+        }
+        music_sequence_recording = false;
+        music_sequence_playing = false;
+        return false;
+      }
+
+      if (keycode == KC_LGUI && record->event.pressed && music_sequence_recorded) { // Start playing
+        stop_all_notes();
+        music_sequence_recording = false;
+        music_sequence_playing = true;
+        music_sequence_position = 0;
+        music_sequence_timer = 0;
+        return false;
+      }
+
+      if (keycode == KC_UP) {
+        if (record->event.pressed)
+            music_sequence_interval-=10;
+        return false;
+      }
+
+      if (keycode == KC_DOWN) {
+        if (record->event.pressed)
+            music_sequence_interval+=10;
+        return false;
+      }
+
+      float freq = ((float)220.0)*pow(2.0, -5.0)*pow(2.0,(starting_note + SCALE[record->event.key.col + offset])/12.0+(MATRIX_ROWS - record->event.key.row));
+      if (record->event.pressed) {
+        play_note(freq, 0xF);
+        if (music_sequence_recording) {
+          music_sequence[music_sequence_count] = freq;
+          music_sequence_count++;
+        }
+      } else {
+        stop_note(freq);
+      }
+
+      if (keycode < 0xFF) // ignores all normal keycodes, but lets RAISE, LOWER, etc through
+        return false;
+    }
+  return true;
+}
+
+bool is_music_on(void) {
+    return (music_activated != 0);
+}
+
+void music_toggle(void) {
+    if (!music_activated) {
+        music_on();
+    } else {
+        music_off();
+    }
+}
+
+void music_on(void) {
+    music_activated = 1;
+    music_on_user();
+}
+
+void music_off(void) {
+    music_activated = 0;
+    stop_all_notes();
+}
+
+
+__attribute__ ((weak))
+void music_on_user() {}
+
+__attribute__ ((weak))
+void audio_on_user() {}
+
+__attribute__ ((weak))
+void music_scale_user() {}
+
+void matrix_scan_music(void) {
+  if (music_sequence_playing) {
+    if ((music_sequence_timer == 0) || (timer_elapsed(music_sequence_timer) > music_sequence_interval)) {
+      music_sequence_timer = timer_read();
+      stop_note(music_sequence[(music_sequence_position - 1 < 0)?(music_sequence_position - 1 + music_sequence_count):(music_sequence_position - 1)]);
+      play_note(music_sequence[music_sequence_position], 0xF);
+      music_sequence_position = (music_sequence_position + 1) % music_sequence_count;
+    }
+  }
+}
diff --git a/quantum/process_keycode/process_music.h b/quantum/process_keycode/process_music.h
new file mode 100644
index 000000000..318b3e387
--- /dev/null
+++ b/quantum/process_keycode/process_music.h
@@ -0,0 +1,27 @@
+#ifndef PROCESS_MUSIC_H
+#define PROCESS_MUSIC_H
+
+#include "quantum.h"
+
+bool process_music(uint16_t keycode, keyrecord_t *record);
+
+bool is_music_on(void);
+void music_toggle(void);
+void music_on(void);
+void music_off(void);
+
+void audio_on_user(void);
+void music_on_user(void);
+void music_scale_user(void);
+
+void matrix_scan_music(void);
+
+#ifndef SCALE
+#define SCALE (int8_t []){ 0 + (12*0), 2 + (12*0), 4 + (12*0), 5 + (12*0), 7 + (12*0), 9 + (12*0), 11 + (12*0), \
+                           0 + (12*1), 2 + (12*1), 4 + (12*1), 5 + (12*1), 7 + (12*1), 9 + (12*1), 11 + (12*1), \
+                           0 + (12*2), 2 + (12*2), 4 + (12*2), 5 + (12*2), 7 + (12*2), 9 + (12*2), 11 + (12*2), \
+                           0 + (12*3), 2 + (12*3), 4 + (12*3), 5 + (12*3), 7 + (12*3), 9 + (12*3), 11 + (12*3), \
+                           0 + (12*4), 2 + (12*4), 4 + (12*4), 5 + (12*4), 7 + (12*4), 9 + (12*4), 11 + (12*4), }
+#endif
+
+#endif
\ No newline at end of file
diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c
new file mode 100644
index 000000000..6ae362c4c
--- /dev/null
+++ b/quantum/process_keycode/process_tap_dance.c
@@ -0,0 +1,136 @@
+#include "quantum.h"
+#include "action_tapping.h"
+
+static uint16_t last_td;
+static int8_t highest_td = -1;
+
+void qk_tap_dance_pair_finished (qk_tap_dance_state_t *state, void *user_data) {
+  qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
+
+  if (state->count == 1) {
+    register_code16 (pair->kc1);
+  } else if (state->count == 2) {
+    register_code16 (pair->kc2);
+  }
+}
+
+void qk_tap_dance_pair_reset (qk_tap_dance_state_t *state, void *user_data) {
+  qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data;
+
+  if (state->count == 1) {
+    unregister_code16 (pair->kc1);
+  } else if (state->count == 2) {
+    unregister_code16 (pair->kc2);
+  }
+}
+
+static inline void _process_tap_dance_action_fn (qk_tap_dance_state_t *state,
+                                                 void *user_data,
+                                                 qk_tap_dance_user_fn_t fn)
+{
+  if (fn) {
+    fn(state, user_data);
+  }
+}
+
+static inline void process_tap_dance_action_on_each_tap (qk_tap_dance_action_t *action)
+{
+  _process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_each_tap);
+}
+
+static inline void process_tap_dance_action_on_dance_finished (qk_tap_dance_action_t *action)
+{
+  if (action->state.finished)
+    return;
+  action->state.finished = true;
+  _process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_dance_finished);
+}
+
+static inline void process_tap_dance_action_on_reset (qk_tap_dance_action_t *action)
+{
+  _process_tap_dance_action_fn (&action->state, action->user_data, action->fn.on_reset);
+}
+
+bool process_tap_dance(uint16_t keycode, keyrecord_t *record) {
+  uint16_t idx = keycode - QK_TAP_DANCE;
+  qk_tap_dance_action_t *action;
+
+  if (last_td && last_td != keycode) {
+    (&tap_dance_actions[last_td - QK_TAP_DANCE])->state.interrupted = true;
+  }
+
+  switch(keycode) {
+  case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
+    if ((int16_t)idx > highest_td)
+      highest_td = idx;
+    action = &tap_dance_actions[idx];
+
+    action->state.pressed = record->event.pressed;
+    if (record->event.pressed) {
+      action->state.keycode = keycode;
+      action->state.count++;
+      action->state.timer = timer_read();
+      process_tap_dance_action_on_each_tap (action);
+
+      if (last_td && last_td != keycode) {
+        qk_tap_dance_action_t *paction = &tap_dance_actions[last_td - QK_TAP_DANCE];
+        paction->state.interrupted = true;
+        process_tap_dance_action_on_dance_finished (paction);
+        reset_tap_dance (&paction->state);
+      }
+
+      last_td = keycode;
+    }
+
+    break;
+
+  default:
+    if (!record->event.pressed)
+      return true;
+
+    if (highest_td == -1)
+      return true;
+
+    for (int i = 0; i <= highest_td; i++) {
+      action = &tap_dance_actions[i];
+      if (action->state.count == 0)
+        continue;
+      action->state.interrupted = true;
+      process_tap_dance_action_on_dance_finished (action);
+      reset_tap_dance (&action->state);
+    }
+    break;
+  }
+
+  return true;
+}
+
+void matrix_scan_tap_dance () {
+  if (highest_td == -1)
+    return;
+
+  for (int i = 0; i <= highest_td; i++) {
+    qk_tap_dance_action_t *action = &tap_dance_actions[i];
+
+    if (action->state.count && timer_elapsed (action->state.timer) > TAPPING_TERM) {
+      process_tap_dance_action_on_dance_finished (action);
+      reset_tap_dance (&action->state);
+    }
+  }
+}
+
+void reset_tap_dance (qk_tap_dance_state_t *state) {
+  qk_tap_dance_action_t *action;
+
+  if (state->pressed)
+    return;
+
+  action = &tap_dance_actions[state->keycode - QK_TAP_DANCE];
+
+  process_tap_dance_action_on_reset (action);
+
+  state->count = 0;
+  state->interrupted = false;
+  state->finished = false;
+  last_td = 0;
+}
diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h
new file mode 100644
index 000000000..f753cbba6
--- /dev/null
+++ b/quantum/process_keycode/process_tap_dance.h
@@ -0,0 +1,72 @@
+#ifndef PROCESS_TAP_DANCE_H
+#define PROCESS_TAP_DANCE_H
+
+#ifdef TAP_DANCE_ENABLE
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+typedef struct
+{
+  uint8_t count;
+  uint16_t keycode;
+  uint16_t timer;
+  bool interrupted;
+  bool pressed;
+  bool finished;
+} qk_tap_dance_state_t;
+
+#define TD(n) (QK_TAP_DANCE + n)
+
+typedef void (*qk_tap_dance_user_fn_t) (qk_tap_dance_state_t *state, void *user_data);
+
+typedef struct
+{
+  struct {
+    qk_tap_dance_user_fn_t on_each_tap;
+    qk_tap_dance_user_fn_t on_dance_finished;
+    qk_tap_dance_user_fn_t on_reset;
+  } fn;
+  qk_tap_dance_state_t state;
+  void *user_data;
+} qk_tap_dance_action_t;
+
+typedef struct
+{
+  uint16_t kc1;
+  uint16_t kc2;
+} qk_tap_dance_pair_t;
+
+#define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) { \
+    .fn = { NULL, qk_tap_dance_pair_finished, qk_tap_dance_pair_reset }, \
+    .user_data = (void *)&((qk_tap_dance_pair_t) { kc1, kc2 }),  \
+  }
+
+#define ACTION_TAP_DANCE_FN(user_fn) {  \
+    .fn = { NULL, user_fn, NULL }, \
+    .user_data = NULL, \
+  }
+
+#define ACTION_TAP_DANCE_FN_ADVANCED(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset) { \
+    .fn = { user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset }, \
+    .user_data = NULL, \
+  }
+
+extern qk_tap_dance_action_t tap_dance_actions[];
+
+/* To be used internally */
+
+bool process_tap_dance(uint16_t keycode, keyrecord_t *record);
+void matrix_scan_tap_dance (void);
+void reset_tap_dance (qk_tap_dance_state_t *state);
+
+void qk_tap_dance_pair_finished (qk_tap_dance_state_t *state, void *user_data);
+void qk_tap_dance_pair_reset (qk_tap_dance_state_t *state, void *user_data);
+
+#else
+
+#define TD(n) KC_NO
+
+#endif
+
+#endif
diff --git a/quantum/process_keycode/process_unicode.c b/quantum/process_keycode/process_unicode.c
new file mode 100644
index 000000000..37dd471ff
--- /dev/null
+++ b/quantum/process_keycode/process_unicode.c
@@ -0,0 +1,239 @@
+#include "process_unicode.h"
+
+static uint8_t input_mode;
+
+__attribute__((weak))
+uint16_t hex_to_keycode(uint8_t hex)
+{
+  if (hex == 0x0) {
+    return KC_0;
+  } else if (hex < 0xA) {
+    return KC_1 + (hex - 0x1);
+  } else {
+    return KC_A + (hex - 0xA);
+  }
+}
+
+void set_unicode_input_mode(uint8_t os_target)
+{
+  input_mode = os_target;
+}
+
+uint8_t get_unicode_input_mode(void) {
+  return input_mode;
+}
+
+__attribute__((weak))
+void unicode_input_start (void) {
+  switch(input_mode) {
+  case UC_OSX:
+    register_code(KC_LALT);
+    break;
+  case UC_LNX:
+    register_code(KC_LCTL);
+    register_code(KC_LSFT);
+    register_code(KC_U);
+    unregister_code(KC_U);
+    unregister_code(KC_LSFT);
+    unregister_code(KC_LCTL);
+    break;
+  case UC_WIN:
+    register_code(KC_LALT);
+    register_code(KC_PPLS);
+    unregister_code(KC_PPLS);
+    break;
+  }
+  wait_ms(UNICODE_TYPE_DELAY);
+}
+
+__attribute__((weak))
+void unicode_input_finish (void) {
+  switch(input_mode) {
+  case UC_OSX:
+  case UC_WIN:
+    unregister_code(KC_LALT);
+    break;
+  case UC_LNX:
+    register_code(KC_SPC);
+    unregister_code(KC_SPC);
+    break;
+  }
+}
+
+void register_hex(uint16_t hex) {
+  for(int i = 3; i >= 0; i--) {
+    uint8_t digit = ((hex >> (i*4)) & 0xF);
+    register_code(hex_to_keycode(digit));
+    unregister_code(hex_to_keycode(digit));
+  }
+}
+
+bool process_unicode(uint16_t keycode, keyrecord_t *record) {
+  if (keycode > QK_UNICODE && record->event.pressed) {
+    uint16_t unicode = keycode & 0x7FFF;
+    unicode_input_start();
+    register_hex(unicode);
+    unicode_input_finish();
+  }
+  return true;
+}
+
+#ifdef UNICODEMAP_ENABLE
+__attribute__((weak))
+const uint32_t PROGMEM unicode_map[] = {
+};
+
+// 5 digit max because of linux limitation
+void register_hex32(uint32_t hex) {
+  for(int i = 4; i >= 0; i--) {
+    uint8_t digit = ((hex >> (i*4)) & 0xF);
+    register_code(hex_to_keycode(digit));
+    unregister_code(hex_to_keycode(digit));
+  }
+}
+
+bool process_unicode_map(uint16_t keycode, keyrecord_t *record) {
+  if ((keycode & QK_UNICODE_MAP) == QK_UNICODE_MAP && record->event.pressed) {
+    const uint32_t* map = unicode_map;
+    uint16_t index = keycode & 0x7FF;
+    unicode_input_start();
+    register_hex32(pgm_read_dword_far(&map[index]));
+    unicode_input_finish();
+  }
+  return true;
+}
+#endif
+
+#ifdef UCIS_ENABLE
+qk_ucis_state_t qk_ucis_state;
+
+void qk_ucis_start(void) {
+  qk_ucis_state.count = 0;
+  qk_ucis_state.in_progress = true;
+
+  qk_ucis_start_user();
+}
+
+__attribute__((weak))
+void qk_ucis_start_user(void) {
+  unicode_input_start();
+  register_hex(0x2328);
+  unicode_input_finish();
+}
+
+static bool is_uni_seq(char *seq) {
+  uint8_t i;
+
+  for (i = 0; seq[i]; i++) {
+    uint16_t code;
+    if (('1' <= seq[i]) && (seq[i] <= '0'))
+      code = seq[i] - '1' + KC_1;
+    else
+      code = seq[i] - 'a' + KC_A;
+
+    if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != code)
+      return false;
+  }
+
+  return (qk_ucis_state.codes[i] == KC_ENT ||
+          qk_ucis_state.codes[i] == KC_SPC);
+}
+
+__attribute__((weak))
+void qk_ucis_symbol_fallback (void) {
+  for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
+    uint8_t code = qk_ucis_state.codes[i];
+    register_code(code);
+    unregister_code(code);
+    wait_ms(UNICODE_TYPE_DELAY);
+  }
+}
+
+void register_ucis(const char *hex) {
+  for(int i = 0; hex[i]; i++) {
+    uint8_t kc = 0;
+    char c = hex[i];
+
+    switch (c) {
+    case '0':
+      kc = KC_0;
+      break;
+    case '1' ... '9':
+      kc = c - '1' + KC_1;
+      break;
+    case 'a' ... 'f':
+      kc = c - 'a' + KC_A;
+      break;
+    case 'A' ... 'F':
+      kc = c - 'A' + KC_A;
+      break;
+    }
+
+    if (kc) {
+      register_code (kc);
+      unregister_code (kc);
+      wait_ms (UNICODE_TYPE_DELAY);
+    }
+  }
+}
+
+bool process_ucis (uint16_t keycode, keyrecord_t *record) {
+  uint8_t i;
+
+  if (!qk_ucis_state.in_progress)
+    return true;
+
+  if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH &&
+      !(keycode == KC_BSPC || keycode == KC_ESC || keycode == KC_SPC || keycode == KC_ENT)) {
+    return false;
+  }
+
+  if (!record->event.pressed)
+    return true;
+
+  qk_ucis_state.codes[qk_ucis_state.count] = keycode;
+  qk_ucis_state.count++;
+
+  if (keycode == KC_BSPC) {
+    if (qk_ucis_state.count >= 2) {
+      qk_ucis_state.count -= 2;
+      return true;
+    } else {
+      qk_ucis_state.count--;
+      return false;
+    }
+  }
+
+  if (keycode == KC_ENT || keycode == KC_SPC || keycode == KC_ESC) {
+    bool symbol_found = false;
+
+    for (i = qk_ucis_state.count; i > 0; i--) {
+      register_code (KC_BSPC);
+      unregister_code (KC_BSPC);
+      wait_ms(UNICODE_TYPE_DELAY);
+    }
+
+    if (keycode == KC_ESC) {
+      qk_ucis_state.in_progress = false;
+      return false;
+    }
+
+    unicode_input_start();
+    for (i = 0; ucis_symbol_table[i].symbol; i++) {
+      if (is_uni_seq (ucis_symbol_table[i].symbol)) {
+        symbol_found = true;
+        register_ucis(ucis_symbol_table[i].code + 2);
+        break;
+      }
+    }
+    if (!symbol_found) {
+      qk_ucis_symbol_fallback();
+    }
+    unicode_input_finish();
+
+    qk_ucis_state.in_progress = false;
+    return false;
+  }
+  return true;
+}
+#endif
diff --git a/quantum/process_keycode/process_unicode.h b/quantum/process_keycode/process_unicode.h
new file mode 100644
index 000000000..a6c7e4584
--- /dev/null
+++ b/quantum/process_keycode/process_unicode.h
@@ -0,0 +1,165 @@
+#ifndef PROCESS_UNICODE_H
+#define PROCESS_UNICODE_H
+
+#include "quantum.h"
+
+#define UC_OSX 0
+#define UC_LNX 1
+#define UC_WIN 2
+#define UC_BSD 3
+
+#ifndef UNICODE_TYPE_DELAY
+#define UNICODE_TYPE_DELAY 10
+#endif
+
+void set_unicode_input_mode(uint8_t os_target);
+uint8_t get_unicode_input_mode(void);
+void unicode_input_start(void);
+void unicode_input_finish(void);
+void register_hex(uint16_t hex);
+
+bool process_unicode(uint16_t keycode, keyrecord_t *record);
+
+#ifdef UNICODEMAP_ENABLE
+bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
+#endif
+
+#ifdef UCIS_ENABLE
+#ifndef UCIS_MAX_SYMBOL_LENGTH
+#define UCIS_MAX_SYMBOL_LENGTH 32
+#endif
+
+typedef struct {
+  char *symbol;
+  char *code;
+} qk_ucis_symbol_t;
+
+typedef struct {
+  uint8_t count;
+  uint16_t codes[UCIS_MAX_SYMBOL_LENGTH];
+  bool in_progress:1;
+} qk_ucis_state_t;
+
+extern qk_ucis_state_t qk_ucis_state;
+
+#define UCIS_TABLE(...) {__VA_ARGS__, {NULL, NULL}}
+#define UCIS_SYM(name, code) {name, #code}
+
+extern const qk_ucis_symbol_t ucis_symbol_table[];
+
+void qk_ucis_start(void);
+void qk_ucis_start_user(void);
+void qk_ucis_symbol_fallback (void);
+void register_ucis(const char *hex);
+bool process_ucis (uint16_t keycode, keyrecord_t *record);
+
+#endif
+
+#define UC_BSPC UC(0x0008)
+
+#define UC_SPC  UC(0x0020)
+
+#define UC_EXLM UC(0x0021)
+#define UC_DQUT UC(0x0022)
+#define UC_HASH UC(0x0023)
+#define UC_DLR  UC(0x0024)
+#define UC_PERC UC(0x0025)
+#define UC_AMPR UC(0x0026)
+#define UC_QUOT UC(0x0027)
+#define UC_LPRN UC(0x0028)
+#define UC_RPRN UC(0x0029)
+#define UC_ASTR UC(0x002A)
+#define UC_PLUS UC(0x002B)
+#define UC_COMM UC(0x002C)
+#define UC_DASH UC(0x002D)
+#define UC_DOT  UC(0x002E)
+#define UC_SLSH UC(0x002F)
+
+#define UC_0    UC(0x0030)
+#define UC_1    UC(0x0031)
+#define UC_2    UC(0x0032)
+#define UC_3    UC(0x0033)
+#define UC_4    UC(0x0034)
+#define UC_5    UC(0x0035)
+#define UC_6    UC(0x0036)
+#define UC_7    UC(0x0037)
+#define UC_8    UC(0x0038)
+#define UC_9    UC(0x0039)
+
+#define UC_COLN UC(0x003A)
+#define UC_SCLN UC(0x003B)
+#define UC_LT   UC(0x003C)
+#define UC_EQL  UC(0x003D)
+#define UC_GT   UC(0x003E)
+#define UC_QUES UC(0x003F)
+#define UC_AT   UC(0x0040)
+
+#define UC_A    UC(0x0041)
+#define UC_B    UC(0x0042)
+#define UC_C    UC(0x0043)
+#define UC_D    UC(0x0044)
+#define UC_E    UC(0x0045)
+#define UC_F    UC(0x0046)
+#define UC_G    UC(0x0047)
+#define UC_H    UC(0x0048)
+#define UC_I    UC(0x0049)
+#define UC_J    UC(0x004A)
+#define UC_K    UC(0x004B)
+#define UC_L    UC(0x004C)
+#define UC_M    UC(0x004D)
+#define UC_N    UC(0x004E)
+#define UC_O    UC(0x004F)
+#define UC_P    UC(0x0050)
+#define UC_Q    UC(0x0051)
+#define UC_R    UC(0x0052)
+#define UC_S    UC(0x0053)
+#define UC_T    UC(0x0054)
+#define UC_U    UC(0x0055)
+#define UC_V    UC(0x0056)
+#define UC_W    UC(0x0057)
+#define UC_X    UC(0x0058)
+#define UC_Y    UC(0x0059)
+#define UC_Z    UC(0x005A)
+
+#define UC_LBRC UC(0x005B)
+#define UC_BSLS UC(0x005C)
+#define UC_RBRC UC(0x005D)
+#define UC_CIRM UC(0x005E)
+#define UC_UNDR UC(0x005F)
+
+#define UC_GRV  UC(0x0060)
+
+#define UC_a    UC(0x0061)
+#define UC_b    UC(0x0062)
+#define UC_c    UC(0x0063)
+#define UC_d    UC(0x0064)
+#define UC_e    UC(0x0065)
+#define UC_f    UC(0x0066)
+#define UC_g    UC(0x0067)
+#define UC_h    UC(0x0068)
+#define UC_i    UC(0x0069)
+#define UC_j    UC(0x006A)
+#define UC_k    UC(0x006B)
+#define UC_l    UC(0x006C)
+#define UC_m    UC(0x006D)
+#define UC_n    UC(0x006E)
+#define UC_o    UC(0x006F)
+#define UC_p    UC(0x0070)
+#define UC_q    UC(0x0071)
+#define UC_r    UC(0x0072)
+#define UC_s    UC(0x0073)
+#define UC_t    UC(0x0074)
+#define UC_u    UC(0x0075)
+#define UC_v    UC(0x0076)
+#define UC_w    UC(0x0077)
+#define UC_x    UC(0x0078)
+#define UC_y    UC(0x0079)
+#define UC_z    UC(0x007A)
+
+#define UC_LCBR UC(0x007B)
+#define UC_PIPE UC(0x007C)
+#define UC_RCBR UC(0x007D)
+#define UC_TILD UC(0x007E)
+#define UC_DEL  UC(0x007F)
+
+#endif