extern int
kvs_put(char *key, char *val)
{
kvs_bucket_t *bucket;
int i;
debug3("mpi/pmi2: in kvs_put");
bucket = &kvs_hash[HASH(key)];
if (! no_dup_keys) {
for (i = 0; i < bucket->count; i ++) {
if (! xstrcmp(key, bucket->pairs[KEY_INDEX(i)])) {
/* replace the k-v pair */
xfree(bucket->pairs[VAL_INDEX(i)]);
bucket->pairs[VAL_INDEX(i)] = xstrdup(val);
debug("mpi/pmi2: put kvs %s=%s", key, val);
return SLURM_SUCCESS;
}
}
}
if (bucket->count * 2 >= bucket->size) {
bucket->size += (TASKS_PER_BUCKET * 2);
xrealloc(bucket->pairs, bucket->size * sizeof(char *));
}
/* add the k-v pair */
i = bucket->count;
bucket->pairs[KEY_INDEX(i)] = xstrdup(key);
bucket->pairs[VAL_INDEX(i)] = xstrdup(val);
bucket->count ++;
debug3("mpi/pmi2: put kvs %s=%s", key, val);
return SLURM_SUCCESS;
}
/*
* No escape of ';' supported for now, hence no ';' in value.
* TODO: concat command processing
*/
extern int
client_req_parse_body(client_req_t *req)
{
int i = 0, rc = SLURM_SUCCESS;
char *key, *val;
/* skip cmd */
i = req->parse_idx;
while (i < req->buf_len) {
/* search for key */
key = &req->buf[i];
while (req->buf[i] != '=' && i < req->buf_len) {
i ++;
}
if (i >= req->buf_len) {
error("mpi/pmi2: no value for key %s in req", key);
rc = SLURM_ERROR;
break;
}
req->buf[i] = '\0'; /* make it nul terminated */
i ++;
debug3("mpi/pmi2: client req key %s", key);
/* search for val */
val = &req->buf[i];
while (req->buf[i] != req->sep &&
req->buf[i] != req->term &&
i < req->buf_len) {
i ++;
}
if (i >= req->buf_len) {
error("mpi/pmi2: value not properly terminated in "
"client request");
rc = SLURM_ERROR;
break;
}
req->buf[i] = '\0'; /* make it nul terminated */
i ++;
debug3("mpi/pmi2: client req val %s", val);
/*
* append pair.
* there may be duplicate keys in the pairs, such as in the
* spawn cmd. Hence the order of the pairs is of significance.
*/
if (2 * (req->pairs_cnt + 2) > req->pairs_size) {
req->pairs_size += REQ_PAIR_SIZE_INC;
xrealloc(req->pairs, req->pairs_size * sizeof(char *));
}
req->pairs[KEY_INDEX(req->pairs_cnt)] = key;
req->pairs[VAL_INDEX(req->pairs_cnt)] = val;
req->pairs_cnt ++;
}
/* add a pair of NULL at the end, without increasing req->pairs_cnt */
req->pairs[KEY_INDEX(req->pairs_cnt)] = NULL;
req->pairs[VAL_INDEX(req->pairs_cnt)] = NULL;
return rc;
}
static entry_t * trans_entry(trans_t * trans, uint64 key) {
uint32 index;
ASSERT(trans_is_ok(trans));
if (UseModulo) {
index = KEY_INDEX(key) % (trans->mask + 1);
} else {
index = KEY_INDEX(key) & trans->mask;
}
ASSERT(index<=trans->mask);
return &trans->table[index];
}
/* read one byte from the keyboard if it's allowed */
static int
ukbd_read(keyboard_t *kbd, int wait)
{
ukbd_state_t *state;
int usbcode;
#ifdef UKBD_EMULATE_ATSCANCODE
int keycode;
int scancode;
#endif
state = (ukbd_state_t *)kbd->kb_data;
#ifdef UKBD_EMULATE_ATSCANCODE
if (state->ks_buffered_char[0]) {
scancode = state->ks_buffered_char[0];
if (scancode & SCAN_PREFIX) {
state->ks_buffered_char[0] = scancode & ~SCAN_PREFIX;
return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
} else {
state->ks_buffered_char[0] = state->ks_buffered_char[1];
state->ks_buffered_char[1] = 0;
return scancode;
}
}
#endif /* UKBD_EMULATE_ATSCANCODE */
usbcode = ukbd_getc(state, wait);
if (!KBD_IS_ACTIVE(kbd) || (usbcode == -1)) {
return -1;
}
++kbd->kb_count;
#ifdef UKBD_EMULATE_ATSCANCODE
keycode = ukbd_trtab[KEY_INDEX(usbcode)];
if (keycode == NN) {
return -1;
}
scancode = keycode2scancode(keycode, state->ks_ndata.modifiers,
usbcode & KEY_RELEASE);
if (scancode & SCAN_PREFIX) {
if (scancode & SCAN_PREFIX_CTL) {
state->ks_buffered_char[0] =
0x1d | (scancode & SCAN_RELEASE); /* Ctrl */
state->ks_buffered_char[1] = scancode & ~SCAN_PREFIX;
} else if (scancode & SCAN_PREFIX_SHIFT) {
state->ks_buffered_char[0] =
0x2a | (scancode & SCAN_RELEASE); /* Shift */
state->ks_buffered_char[1] =
scancode & ~SCAN_PREFIX_SHIFT;
} else {
state->ks_buffered_char[0] = scancode & ~SCAN_PREFIX;
state->ks_buffered_char[1] = 0;
}
return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
}
return scancode;
#else /* !UKBD_EMULATE_ATSCANCODE */
return usbcode;
#endif /* UKBD_EMULATE_ATSCANCODE */
}
extern int
node_attr_put(char *key, char *val)
{
nag_req_t *req = NULL, **pprev = NULL;
client_resp_t *resp = NULL;
int rc = SLURM_SUCCESS;
debug3("mpi/pmi2: node_attr_put: %s=%s", key, val);
if (na_cnt * 2 >= na_size) {
na_size += NODE_ATTR_SIZE_INC;
xrealloc(node_attr, na_size * sizeof(char*));
}
node_attr[KEY_INDEX(na_cnt)] = xstrdup(key);
node_attr[VAL_INDEX(na_cnt)] = xstrdup(val);
na_cnt ++;
/* process pending requests */
pprev = &nag_req_list;
req = *pprev;
while (req != NULL) {
if (strncmp(key, req->key, PMI2_MAX_KEYLEN)) {
pprev = &req->next;
req = *pprev;
} else {
debug("mpi/pmi2: found pending request from rank %d",
req->rank);
/* send response msg */
if (! resp) {
resp = client_resp_new();
client_resp_append(resp,
CMD_KEY"="
GETNODEATTRRESP_CMD";"
RC_KEY"=0;"
FOUND_KEY"="TRUE_VAL";"
VALUE_KEY"=%s;", val);
}
rc = client_resp_send(resp, req->fd);
if (rc != SLURM_SUCCESS) {
error("mpi/pmi2: failed to send '"
GETNODEATTRRESP_CMD "' to task %d",
req->rank);
}
/* remove the request */
*pprev = req->next;
_free_nag_req(req);
req = *pprev;
}
}
if (resp) {
client_resp_free (resp);
}
debug3("mpi/pmi2: out node_attr_put");
return SLURM_SUCCESS;
}
void material_get_info( material_info_t *info, const board_t *board, int ThreadId )
{
uint64 key;
entry_t *entry;
ASSERT(info != NULL);
ASSERT(board != NULL);
// probe
if( UseTable )
{
Material[ThreadId]->read_nb++;
key = board->material_key;
entry = &Material[ThreadId]->table[KEY_INDEX(key) & Material[ThreadId]->mask];
if( entry->lock == KEY_LOCK(key) )
{
// found
Material[ThreadId]->read_hit++;
*info = *entry;
return;
}
}
// calculation
material_comp_info(info, board);
// store
if( UseTable )
{
Material[ThreadId]->write_nb++;
if( entry->lock == 0 )
{
Material[ThreadId]->used++;
}
else
{
Material[ThreadId]->write_collision++;
}
*entry = *info;
entry->lock = KEY_LOCK(key);
}
}
/* returned value not dup-ed */
static char *
_client_req_get_val(client_req_t *req, const char *key)
{
int i;
for (i = 0; i < req->pairs_cnt; i ++) {
if (! xstrcmp(key, req->pairs[KEY_INDEX(i)]))
return req->pairs[VAL_INDEX(i)];
}
return NULL;
}
void material_get_info(material_info_t * info)
{
uint64 key;
entry_t * entry;
ASSERT(info!=NULL);
// probe
if (UseTable) {
Material->read_nb++;
key = Lock;
entry = &Material->table[KEY_INDEX(key)&Material->mask];
if (entry->lock == KEY_LOCK(key)) {
// found
Material->read_hit++;
*info = *entry;
return;
}
}
// calculation
material_comp_info(info);
// store
if (UseTable) {
Material->write_nb++;
if (entry->lock == 0) { // HACK: assume free entry
Material->used++;
} else {
Material->write_collision++;
}
*entry = *info;
entry->lock = KEY_LOCK(key);
}
}
void pawn_get_info(pawn_info_t * info, const board_t * board, int ThreadId) {
uint64 key;
entry_t * entry;
ASSERT(info!=NULL);
ASSERT(board!=NULL);
// probe
if (UseTable) {
Pawn[ThreadId]->read_nb++;
key = board->pawn_key;
entry = &Pawn[ThreadId]->table[KEY_INDEX(key)&Pawn[ThreadId]->mask];
if (entry->lock == KEY_LOCK(key)) {
// found
Pawn[ThreadId]->read_hit++;
*info = *entry;
return;
}
}
// calculation
pawn_comp_info(info,board);
// store
if (UseTable) {
Pawn[ThreadId]->write_nb++;
if (entry->lock == 0) { // HACK: assume free entry
Pawn[ThreadId]->used++;
} else {
Pawn[ThreadId]->write_collision++;
}
*entry = *info;
entry->lock = KEY_LOCK(key);
}
}
extern int
kvs_clear(void)
{
kvs_bucket_t *bucket;
int i, j;
for (i = 0; i < hash_size; i ++){
bucket = &kvs_hash[i];
for (j = 0; j < bucket->count; j ++) {
xfree (bucket->pairs[KEY_INDEX(j)]);
xfree (bucket->pairs[VAL_INDEX(j)]);
}
}
xfree(kvs_hash);
return SLURM_SUCCESS;
}
/* returned value not dup-ed */
extern char *
node_attr_get(char *key)
{
int i;
char *val = NULL;
debug3("mpi/pmi2: node_attr_get: key=%s", key);
for (i = 0; i < na_cnt; i ++) {
if (! strcmp(key, node_attr[KEY_INDEX(i)])) {
val = node_attr[VAL_INDEX(i)];
break;
}
}
debug3("mpi/pmi2: out node_attr_get: val=%s", val);
return val;
}
/*
* returned value is not dup-ed
*/
extern char *
kvs_get(char *key)
{
kvs_bucket_t *bucket;
char *val = NULL;
int i;
debug3("mpi/pmi2: in kvs_get, key=%s", key);
bucket = &kvs_hash[HASH(key)];
if (bucket->count > 0) {
for(i = 0; i < bucket->count; i ++) {
if (! xstrcmp(key, bucket->pairs[KEY_INDEX(i)])) {
val = bucket->pairs[VAL_INDEX(i)];
break;
}
}
}
debug3("mpi/pmi2: out kvs_get, val=%s", val);
return val;
}
/* read char from the keyboard */
static u_int
ukbd_read_char(keyboard_t *kbd, int wait)
{
ukbd_state_t *state;
u_int action;
int usbcode;
int keycode;
#ifdef UKBD_EMULATE_ATSCANCODE
int scancode;
#endif
state = (ukbd_state_t *)kbd->kb_data;
next_code:
/* do we have a composed char to return? */
if (!(state->ks_flags & COMPOSE) && (state->ks_composed_char > 0)) {
action = state->ks_composed_char;
state->ks_composed_char = 0;
if (action > UCHAR_MAX) {
return ERRKEY;
}
return action;
}
#ifdef UKBD_EMULATE_ATSCANCODE
/* do we have a pending raw scan code? */
if (state->ks_mode == K_RAW) {
if (state->ks_buffered_char[0]) {
scancode = state->ks_buffered_char[0];
if (scancode & SCAN_PREFIX) {
state->ks_buffered_char[0] =
scancode & ~SCAN_PREFIX;
return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
} else {
state->ks_buffered_char[0] =
state->ks_buffered_char[1];
state->ks_buffered_char[1] = 0;
return scancode;
}
}
}
#endif /* UKBD_EMULATE_ATSCANCODE */
/* see if there is something in the keyboard port */
/* XXX */
usbcode = ukbd_getc(state, wait);
if (usbcode == -1) {
return NOKEY;
}
++kbd->kb_count;
#ifdef UKBD_EMULATE_ATSCANCODE
/* USB key index -> key code -> AT scan code */
keycode = ukbd_trtab[KEY_INDEX(usbcode)];
if (keycode == NN) {
return NOKEY;
}
/* return an AT scan code for the K_RAW mode */
if (state->ks_mode == K_RAW) {
scancode = keycode2scancode(keycode, state->ks_ndata.modifiers,
usbcode & KEY_RELEASE);
if (scancode & SCAN_PREFIX) {
if (scancode & SCAN_PREFIX_CTL) {
state->ks_buffered_char[0] =
0x1d | (scancode & SCAN_RELEASE);
state->ks_buffered_char[1] =
scancode & ~SCAN_PREFIX;
} else if (scancode & SCAN_PREFIX_SHIFT) {
state->ks_buffered_char[0] =
0x2a | (scancode & SCAN_RELEASE);
state->ks_buffered_char[1] =
scancode & ~SCAN_PREFIX_SHIFT;
} else {
state->ks_buffered_char[0] =
scancode & ~SCAN_PREFIX;
state->ks_buffered_char[1] = 0;
}
return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
}
return scancode;
}
#else /* !UKBD_EMULATE_ATSCANCODE */
/* return the byte as is for the K_RAW mode */
if (state->ks_mode == K_RAW) {
return usbcode;
}
/* USB key index -> key code */
keycode = ukbd_trtab[KEY_INDEX(usbcode)];
if (keycode == NN) {
return NOKEY;
}
#endif /* UKBD_EMULATE_ATSCANCODE */
switch (keycode) {
case 0x38: /* left alt (compose key) */
if (usbcode & KEY_RELEASE) {
if (state->ks_flags & COMPOSE) {
state->ks_flags &= ~COMPOSE;
if (state->ks_composed_char > UCHAR_MAX)
state->ks_composed_char = 0;
}
} else {
if (!(state->ks_flags & COMPOSE)) {
state->ks_flags |= COMPOSE;
state->ks_composed_char = 0;
}
}
break;
/* XXX: I don't like these... */
case 0x5c: /* print screen */
if (state->ks_flags & ALTS)
keycode = 0x54; /* sysrq */
break;
case 0x68: /* pause/break */
if (state->ks_flags & CTLS)
keycode = 0x6c; /* break */
break;
}
/* return the key code in the K_CODE mode */
if (usbcode & KEY_RELEASE)
keycode |= SCAN_RELEASE;
if (state->ks_mode == K_CODE) {
return keycode;
}
/* compose a character code */
if (state->ks_flags & COMPOSE) {
switch (keycode) {
/* key pressed, process it */
case 0x47: case 0x48: case 0x49: /* keypad 7,8,9 */
state->ks_composed_char *= 10;
state->ks_composed_char += keycode - 0x40;
if (state->ks_composed_char > UCHAR_MAX) {
return ERRKEY;
}
goto next_code;
case 0x4B: case 0x4C: case 0x4D: /* keypad 4,5,6 */
state->ks_composed_char *= 10;
state->ks_composed_char += keycode - 0x47;
if (state->ks_composed_char > UCHAR_MAX) {
return ERRKEY;
}
goto next_code;
case 0x4F: case 0x50: case 0x51: /* keypad 1,2,3 */
state->ks_composed_char *= 10;
state->ks_composed_char += keycode - 0x4E;
if (state->ks_composed_char > UCHAR_MAX) {
return ERRKEY;
}
goto next_code;
case 0x52: /* keypad 0 */
state->ks_composed_char *= 10;
if (state->ks_composed_char > UCHAR_MAX) {
return ERRKEY;
}
goto next_code;
/* key released, no interest here */
case SCAN_RELEASE | 0x47:
case SCAN_RELEASE | 0x48:
case SCAN_RELEASE | 0x49: /* keypad 7,8,9 */
case SCAN_RELEASE | 0x4B:
case SCAN_RELEASE | 0x4C:
case SCAN_RELEASE | 0x4D: /* keypad 4,5,6 */
case SCAN_RELEASE | 0x4F:
case SCAN_RELEASE | 0x50:
case SCAN_RELEASE | 0x51: /* keypad 1,2,3 */
case SCAN_RELEASE | 0x52: /* keypad 0 */
goto next_code;
case 0x38: /* left alt key */
break;
default:
if (state->ks_composed_char > 0) {
state->ks_flags &= ~COMPOSE;
state->ks_composed_char = 0;
return ERRKEY;
}
break;
}
}
/* keycode to key action */
action = genkbd_keyaction(kbd, SCAN_CHAR(keycode),
keycode & SCAN_RELEASE, &state->ks_state,
&state->ks_accents);
if (action == NOKEY) {
goto next_code;
} else {
return action;
}
/* NOTREACHED */
}
void keyboardHandler(struct isrregs *r) {
//first setup our static variables
static Escapes escapes = {
0, //E0
0, //E1
0, //LSHIFT
0, //RSHIFT
0, //LCTRL
0, //RCTRL
0, //LALT
0, //RALT
};
static keyLEDs leds = {
0, //scroll
0, //caps
0, //num
};
//receive byte from keyboard
KeyScanCode scancode = getKeyboardOutput();
//first determine if the key being pressed is an escape
static uint8_t escapeCode = ESCAPE_NONE;
if (!scancode.released) {
switch (scancode.keycode) {
case KEY_CAPSLOCK:
if (leds.caps) {
leds.caps = 0;
}
else {
leds.caps = 1;
}
updateKeyboardLEDs(leds);
return;
case KEY_NUMLOCK:
if (leds.num) {
leds.num = 0;
}
else {
leds.num = 1;
}
updateKeyboardLEDs(leds);
return;
case KEY_SCROLL:
if (leds.scroll) {
leds.scroll = 0;
}
else {
leds.scroll = 1;
}
updateKeyboardLEDs(leds);
return;
case KEY_LSHIFT:
escapes.LSHIFT = 1;
return;
case KEY_RSHIFT:
escapes.RSHIFT = 1;
return;
case KEY_LCTRL:
escapes.LCTRL = 1;
return;
case KEY_LALT:
escapes.LALT = 1;
return;
}
escapeCode = ESCAPE_NONE;
//determine what escape code we should be registering
if (escapes.LSHIFT || escapes.RSHIFT) {
escapeCode = ESCAPE_SHIFT;
if (leds.caps) {
escapeCode = ESCAPE_SHIFT_CAPS;
}
}
else {
if (leds.caps) {
escapeCode = ESCAPE_CAPS;
}
}
//override all other codes if we get E0 or E1
if (escapes.E0) {
escapeCode = ESCAPE_E0;
}
if (escapes.E1) {
escapeCode = ESCAPE_E1;
}
//if the value isn't an escape, register that we pressed down the given key
KEYPRESS_INDEX(scancode.keycode, escapeCode) = 1;
//check to see if an ascii value can be displayed
if (KEY_INDEX(scancode.keycode, escapeCode)) {
DisplayChar(KEY_INDEX(scancode.keycode, escapeCode));
}
else {
//DisplayInteger(scancode.keycode);
//DisplayChar(':');
//DisplayInteger(KEY_INDEX(scancode.keycode, escapeCode));
//DisplayChar(':');
//DisplayInteger(escapeCode);
//DisplayChar(' ');
}
}
else {
switch (scancode.keycode) {
case KEY_ESCAPE0:
case KEY_ESCAPE0_OLD:
escapes.E0 = 1;
return;
case KEY_ESCAPE1:
case KEY_ESCAPE1_OLD:
escapes.E1 = 1;
return;
case KEY_LSHIFT:
escapes.LSHIFT = 0;
return;
case KEY_RSHIFT:
escapes.RSHIFT = 0;
return;
case KEY_LCTRL:
escapes.LCTRL = 0;
return;
case KEY_LALT:
escapes.LALT = 0;
return;
}
KEYPRESS_INDEX(scancode.keycode, escapeCode) = 0;
}
//upon finishing, we reset the escapes to zero
escapes.E0 = 0;
escapes.E1 = 0;
return;
}
//functions
void initKeyboardHandler() {
//add handler to list of IRQs
irq_install_handler(1, keyboardHandler);
//initialize keyboard listing with keymappings and keypresses
//zero it first
for (int i = 0; i < 1024; i++) {
KeyboardList[i] = 0;
Keyboard_bPressed[i] = 0;
}
//keymappings with no escapes
KEY_INDEX(0x00, ESCAPE_NONE) = (uint8_t) 0; //NULL
KEY_INDEX(0x01, ESCAPE_NONE) = (uint8_t) 0; //ESC
KEY_INDEX(0x02, ESCAPE_NONE) = (uint8_t) '1';
KEY_INDEX(0x03, ESCAPE_NONE) = (uint8_t) '2';
KEY_INDEX(0x04, ESCAPE_NONE) = (uint8_t) '3';
KEY_INDEX(0x05, ESCAPE_NONE) = (uint8_t) '4';
KEY_INDEX(0x06, ESCAPE_NONE) = (uint8_t) '5';
KEY_INDEX(0x07, ESCAPE_NONE) = (uint8_t) '6';
KEY_INDEX(0x08, ESCAPE_NONE) = (uint8_t) '7';
KEY_INDEX(0x09, ESCAPE_NONE) = (uint8_t) '8';
KEY_INDEX(0x0A, ESCAPE_NONE) = (uint8_t) '9';
KEY_INDEX(0x0B, ESCAPE_NONE) = (uint8_t) '0';
KEY_INDEX(0x0C, ESCAPE_NONE) = (uint8_t) '-';
KEY_INDEX(0x0D, ESCAPE_NONE) = (uint8_t) '=';
KEY_INDEX(0x0E, ESCAPE_NONE) = (uint8_t) '\b';
KEY_INDEX(0x0F, ESCAPE_NONE) = (uint8_t) '\t';
KEY_INDEX(0x10, ESCAPE_NONE) = (uint8_t) 'q';
KEY_INDEX(0x11, ESCAPE_NONE) = (uint8_t) 'w';
KEY_INDEX(0x12, ESCAPE_NONE) = (uint8_t) 'e';
KEY_INDEX(0x13, ESCAPE_NONE) = (uint8_t) 'r';
KEY_INDEX(0x14, ESCAPE_NONE) = (uint8_t) 't';
KEY_INDEX(0x15, ESCAPE_NONE) = (uint8_t) 'y';
KEY_INDEX(0x16, ESCAPE_NONE) = (uint8_t) 'u';
KEY_INDEX(0x17, ESCAPE_NONE) = (uint8_t) 'i';
KEY_INDEX(0x18, ESCAPE_NONE) = (uint8_t) 'o';
KEY_INDEX(0x19, ESCAPE_NONE) = (uint8_t) 'p';
KEY_INDEX(0x1A, ESCAPE_NONE) = (uint8_t) '[';
KEY_INDEX(0x1B, ESCAPE_NONE) = (uint8_t) ']';
KEY_INDEX(0x1C, ESCAPE_NONE) = (uint8_t) '\n';
KEY_INDEX(0x1D, ESCAPE_NONE) = (uint8_t) 0; //LCTRL
KEY_INDEX(0x1E, ESCAPE_NONE) = (uint8_t) 'a';
KEY_INDEX(0x1F, ESCAPE_NONE) = (uint8_t) 's';
KEY_INDEX(0x20, ESCAPE_NONE) = (uint8_t) 'd';
KEY_INDEX(0x21, ESCAPE_NONE) = (uint8_t) 'f';
KEY_INDEX(0x22, ESCAPE_NONE) = (uint8_t) 'g';
KEY_INDEX(0x23, ESCAPE_NONE) = (uint8_t) 'h';
KEY_INDEX(0x24, ESCAPE_NONE) = (uint8_t) 'j';
KEY_INDEX(0x25, ESCAPE_NONE) = (uint8_t) 'k';
KEY_INDEX(0x26, ESCAPE_NONE) = (uint8_t) 'l';
KEY_INDEX(0x27, ESCAPE_NONE) = (uint8_t) ';';
KEY_INDEX(0x28, ESCAPE_NONE) = (uint8_t) '\'';
KEY_INDEX(0x29, ESCAPE_NONE) = (uint8_t) '`';
KEY_INDEX(0x2A, ESCAPE_NONE) = (uint8_t) 0; //LSHFT
KEY_INDEX(0x2B, ESCAPE_NONE) = (uint8_t) '\\';
KEY_INDEX(0x2C, ESCAPE_NONE) = (uint8_t) 'z';
KEY_INDEX(0x2D, ESCAPE_NONE) = (uint8_t) 'x';
KEY_INDEX(0x2E, ESCAPE_NONE) = (uint8_t) 'c';
KEY_INDEX(0x2F, ESCAPE_NONE) = (uint8_t) 'v';
KEY_INDEX(0x30, ESCAPE_NONE) = (uint8_t) 'b';
KEY_INDEX(0x31, ESCAPE_NONE) = (uint8_t) 'n';
KEY_INDEX(0x32, ESCAPE_NONE) = (uint8_t) 'm';
KEY_INDEX(0x33, ESCAPE_NONE) = (uint8_t) ',';
KEY_INDEX(0x34, ESCAPE_NONE) = (uint8_t) '.';
KEY_INDEX(0x35, ESCAPE_NONE) = (uint8_t) '/';
KEY_INDEX(0x36, ESCAPE_NONE) = (uint8_t) 0; //RSHFT
KEY_INDEX(0x37, ESCAPE_NONE) = (uint8_t) '*';
KEY_INDEX(0x38, ESCAPE_NONE) = (uint8_t) 0; //LALT
KEY_INDEX(0x39, ESCAPE_NONE) = (uint8_t) ' ';
KEY_INDEX(0x3A, ESCAPE_NONE) = (uint8_t) 0; //CAPSLOCK
KEY_INDEX(0x3B, ESCAPE_NONE) = (uint8_t) 0; //F1
KEY_INDEX(0x3C, ESCAPE_NONE) = (uint8_t) 0; //F2
KEY_INDEX(0x3D, ESCAPE_NONE) = (uint8_t) 0; //F3
KEY_INDEX(0x3E, ESCAPE_NONE) = (uint8_t) 0; //F4
KEY_INDEX(0x3F, ESCAPE_NONE) = (uint8_t) 0; //F5
KEY_INDEX(0x40, ESCAPE_NONE) = (uint8_t) 0; //F6
KEY_INDEX(0x41, ESCAPE_NONE) = (uint8_t) 0; //F7
KEY_INDEX(0x42, ESCAPE_NONE) = (uint8_t) 0; //F8
KEY_INDEX(0x43, ESCAPE_NONE) = (uint8_t) 0; //F9
KEY_INDEX(0x44, ESCAPE_NONE) = (uint8_t) 0; //F10
KEY_INDEX(0x45, ESCAPE_NONE) = (uint8_t) 0; //NUMLOCK
KEY_INDEX(0x46, ESCAPE_NONE) = (uint8_t) 0; //SCROLL LOCK
KEY_INDEX(0x47, ESCAPE_NONE) = (uint8_t) '7'; //KPAD7
KEY_INDEX(0x48, ESCAPE_NONE) = (uint8_t) '8'; //KPAD8
KEY_INDEX(0x49, ESCAPE_NONE) = (uint8_t) '9'; //KPAD9
KEY_INDEX(0x4A, ESCAPE_NONE) = (uint8_t) '-'; //KPAD-
KEY_INDEX(0x4B, ESCAPE_NONE) = (uint8_t) '4'; //KPAD4
KEY_INDEX(0x4C, ESCAPE_NONE) = (uint8_t) '5'; //KPAD5
KEY_INDEX(0x4D, ESCAPE_NONE) = (uint8_t) '6'; //KPAD6
KEY_INDEX(0x4E, ESCAPE_NONE) = (uint8_t) '+'; //KPAD+
KEY_INDEX(0x4F, ESCAPE_NONE) = (uint8_t) '1'; //KPAD1
KEY_INDEX(0x50, ESCAPE_NONE) = (uint8_t) '2'; //KPAD2
KEY_INDEX(0x51, ESCAPE_NONE) = (uint8_t) '3'; //KPAD3
KEY_INDEX(0x52, ESCAPE_NONE) = (uint8_t) '0'; //KPAD0
KEY_INDEX(0x53, ESCAPE_NONE) = (uint8_t) '.'; //KPAD.
KEY_INDEX(0x54, ESCAPE_NONE) = (uint8_t) 0; //NULL
KEY_INDEX(0x55, ESCAPE_NONE) = (uint8_t) 0; //FUNC
KEY_INDEX(0x56, ESCAPE_NONE) = (uint8_t) 0; //blank
KEY_INDEX(0x57, ESCAPE_NONE) = (uint8_t) 0; //F11
KEY_INDEX(0x58, ESCAPE_NONE) = (uint8_t) 0; //F12
KEY_INDEX(0x59, ESCAPE_NONE) = (uint8_t) 0;
KEY_INDEX(0x5A, ESCAPE_NONE) = (uint8_t) 0;
KEY_INDEX(0x5B, ESCAPE_NONE) = (uint8_t) 0;
KEY_INDEX(0x5C, ESCAPE_NONE) = (uint8_t) 0;
KEY_INDEX(0x5D, ESCAPE_NONE) = (uint8_t) 0;
KEY_INDEX(0x5E, ESCAPE_NONE) = (uint8_t) 0;
KEY_INDEX(0x5F, ESCAPE_NONE) = (uint8_t) 0;
//escaped with shift
KEY_INDEX(0x00, ESCAPE_SHIFT) = (uint8_t) 0; //NULL
KEY_INDEX(0x01, ESCAPE_SHIFT) = (uint8_t) 0; //ESC
KEY_INDEX(0x02, ESCAPE_SHIFT) = (uint8_t) '!';
KEY_INDEX(0x03, ESCAPE_SHIFT) = (uint8_t) '@';
KEY_INDEX(0x04, ESCAPE_SHIFT) = (uint8_t) '#';
KEY_INDEX(0x05, ESCAPE_SHIFT) = (uint8_t) '$';
KEY_INDEX(0x06, ESCAPE_SHIFT) = (uint8_t) '%';
KEY_INDEX(0x07, ESCAPE_SHIFT) = (uint8_t) '^';
KEY_INDEX(0x08, ESCAPE_SHIFT) = (uint8_t) '&';
KEY_INDEX(0x09, ESCAPE_SHIFT) = (uint8_t) '*';
KEY_INDEX(0x0A, ESCAPE_SHIFT) = (uint8_t) '(';
KEY_INDEX(0x0B, ESCAPE_SHIFT) = (uint8_t) ')';
KEY_INDEX(0x0C, ESCAPE_SHIFT) = (uint8_t) '_';
KEY_INDEX(0x0D, ESCAPE_SHIFT) = (uint8_t) '+';
KEY_INDEX(0x0E, ESCAPE_SHIFT) = (uint8_t) '\b';
KEY_INDEX(0x0F, ESCAPE_SHIFT) = (uint8_t) '\t';
KEY_INDEX(0x10, ESCAPE_SHIFT) = (uint8_t) 'Q';
KEY_INDEX(0x11, ESCAPE_SHIFT) = (uint8_t) 'W';
KEY_INDEX(0x12, ESCAPE_SHIFT) = (uint8_t) 'E';
KEY_INDEX(0x13, ESCAPE_SHIFT) = (uint8_t) 'R';
KEY_INDEX(0x14, ESCAPE_SHIFT) = (uint8_t) 'T';
KEY_INDEX(0x15, ESCAPE_SHIFT) = (uint8_t) 'Y';
KEY_INDEX(0x16, ESCAPE_SHIFT) = (uint8_t) 'U';
KEY_INDEX(0x17, ESCAPE_SHIFT) = (uint8_t) 'I';
KEY_INDEX(0x18, ESCAPE_SHIFT) = (uint8_t) 'O';
KEY_INDEX(0x19, ESCAPE_SHIFT) = (uint8_t) 'P';
KEY_INDEX(0x1A, ESCAPE_SHIFT) = (uint8_t) '{';
KEY_INDEX(0x1B, ESCAPE_SHIFT) = (uint8_t) '}';
KEY_INDEX(0x1C, ESCAPE_SHIFT) = (uint8_t) '\n';
KEY_INDEX(0x1D, ESCAPE_SHIFT) = (uint8_t) 0; //LCTRL
KEY_INDEX(0x1E, ESCAPE_SHIFT) = (uint8_t) 'A';
KEY_INDEX(0x1F, ESCAPE_SHIFT) = (uint8_t) 'S';
KEY_INDEX(0x20, ESCAPE_SHIFT) = (uint8_t) 'D';
KEY_INDEX(0x21, ESCAPE_SHIFT) = (uint8_t) 'F';
KEY_INDEX(0x22, ESCAPE_SHIFT) = (uint8_t) 'G';
KEY_INDEX(0x23, ESCAPE_SHIFT) = (uint8_t) 'H';
KEY_INDEX(0x24, ESCAPE_SHIFT) = (uint8_t) 'J';
KEY_INDEX(0x25, ESCAPE_SHIFT) = (uint8_t) 'K';
KEY_INDEX(0x26, ESCAPE_SHIFT) = (uint8_t) 'L';
KEY_INDEX(0x27, ESCAPE_SHIFT) = (uint8_t) ':';
KEY_INDEX(0x28, ESCAPE_SHIFT) = (uint8_t) '"';
KEY_INDEX(0x29, ESCAPE_SHIFT) = (uint8_t) '~';
KEY_INDEX(0x2A, ESCAPE_SHIFT) = (uint8_t) 0; //LSHFT
KEY_INDEX(0x2B, ESCAPE_SHIFT) = (uint8_t) '|';
KEY_INDEX(0x2C, ESCAPE_SHIFT) = (uint8_t) 'Z';
KEY_INDEX(0x2D, ESCAPE_SHIFT) = (uint8_t) 'X';
KEY_INDEX(0x2E, ESCAPE_SHIFT) = (uint8_t) 'C';
KEY_INDEX(0x2F, ESCAPE_SHIFT) = (uint8_t) 'V';
KEY_INDEX(0x30, ESCAPE_SHIFT) = (uint8_t) 'B';
KEY_INDEX(0x31, ESCAPE_SHIFT) = (uint8_t) 'N';
KEY_INDEX(0x32, ESCAPE_SHIFT) = (uint8_t) 'M';
KEY_INDEX(0x33, ESCAPE_SHIFT) = (uint8_t) '<';
KEY_INDEX(0x34, ESCAPE_SHIFT) = (uint8_t) '>';
KEY_INDEX(0x35, ESCAPE_SHIFT) = (uint8_t) '?';
KEY_INDEX(0x36, ESCAPE_SHIFT) = (uint8_t) 0; //RSHFT
KEY_INDEX(0x37, ESCAPE_SHIFT) = (uint8_t) 0;
KEY_INDEX(0x38, ESCAPE_SHIFT) = (uint8_t) 0; //LALT
KEY_INDEX(0x39, ESCAPE_SHIFT) = (uint8_t) ' ';
KEY_INDEX(0x3A, ESCAPE_SHIFT) = (uint8_t) 0; //CAPSLOCK
KEY_INDEX(0x3B, ESCAPE_SHIFT) = (uint8_t) 0; //F1
KEY_INDEX(0x3C, ESCAPE_SHIFT) = (uint8_t) 0; //F2
KEY_INDEX(0x3D, ESCAPE_SHIFT) = (uint8_t) 0; //F3
KEY_INDEX(0x3E, ESCAPE_SHIFT) = (uint8_t) 0; //F4
KEY_INDEX(0x3F, ESCAPE_SHIFT) = (uint8_t) 0; //F5
KEY_INDEX(0x40, ESCAPE_SHIFT) = (uint8_t) 0; //F6
KEY_INDEX(0x41, ESCAPE_SHIFT) = (uint8_t) 0; //F7
KEY_INDEX(0x42, ESCAPE_SHIFT) = (uint8_t) 0; //F8
KEY_INDEX(0x43, ESCAPE_SHIFT) = (uint8_t) 0; //F9
KEY_INDEX(0x44, ESCAPE_SHIFT) = (uint8_t) 0; //F10
KEY_INDEX(0x45, ESCAPE_SHIFT) = (uint8_t) 0; //NUMLOCK
KEY_INDEX(0x46, ESCAPE_SHIFT) = (uint8_t) 0; //SCROLL LOCK
KEY_INDEX(0x47, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD7
KEY_INDEX(0x48, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD8
KEY_INDEX(0x49, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD9
KEY_INDEX(0x4A, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD-
KEY_INDEX(0x4B, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD4
KEY_INDEX(0x4C, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD5
KEY_INDEX(0x4D, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD6
KEY_INDEX(0x4E, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD+
KEY_INDEX(0x4F, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD1
KEY_INDEX(0x50, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD2
KEY_INDEX(0x51, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD3
KEY_INDEX(0x52, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD0
KEY_INDEX(0x53, ESCAPE_SHIFT) = (uint8_t) 0; //KPAD.
KEY_INDEX(0x54, ESCAPE_SHIFT) = (uint8_t) 0; //NULL
KEY_INDEX(0x55, ESCAPE_SHIFT) = (uint8_t) 0; //FUNC
KEY_INDEX(0x56, ESCAPE_SHIFT) = (uint8_t) 0; //blank
KEY_INDEX(0x57, ESCAPE_SHIFT) = (uint8_t) 0; //F11
KEY_INDEX(0x58, ESCAPE_SHIFT) = (uint8_t) 0; //F12
KEY_INDEX(0x59, ESCAPE_SHIFT) = (uint8_t) 0;
KEY_INDEX(0x5A, ESCAPE_SHIFT) = (uint8_t) 0;
KEY_INDEX(0x5B, ESCAPE_SHIFT) = (uint8_t) 0;
KEY_INDEX(0x5C, ESCAPE_SHIFT) = (uint8_t) 0;
KEY_INDEX(0x5D, ESCAPE_SHIFT) = (uint8_t) 0;
KEY_INDEX(0x5E, ESCAPE_SHIFT) = (uint8_t) 0;
KEY_INDEX(0x5F, ESCAPE_SHIFT) = (uint8_t) 0;
//escaped with caps lock
KEY_INDEX(0x00, ESCAPE_CAPS) = (uint8_t) 0; //NULL
KEY_INDEX(0x01, ESCAPE_CAPS) = (uint8_t) 0; //ESC
KEY_INDEX(0x02, ESCAPE_CAPS) = (uint8_t) '1';
KEY_INDEX(0x03, ESCAPE_CAPS) = (uint8_t) '2';
KEY_INDEX(0x04, ESCAPE_CAPS) = (uint8_t) '3';
KEY_INDEX(0x05, ESCAPE_CAPS) = (uint8_t) '4';
KEY_INDEX(0x06, ESCAPE_CAPS) = (uint8_t) '5';
KEY_INDEX(0x07, ESCAPE_CAPS) = (uint8_t) '6';
KEY_INDEX(0x08, ESCAPE_CAPS) = (uint8_t) '7';
KEY_INDEX(0x09, ESCAPE_CAPS) = (uint8_t) '8';
KEY_INDEX(0x0A, ESCAPE_CAPS) = (uint8_t) '9';
KEY_INDEX(0x0B, ESCAPE_CAPS) = (uint8_t) '0';
KEY_INDEX(0x0C, ESCAPE_CAPS) = (uint8_t) '-';
KEY_INDEX(0x0D, ESCAPE_CAPS) = (uint8_t) '=';
KEY_INDEX(0x0E, ESCAPE_CAPS) = (uint8_t) '\b';
KEY_INDEX(0x0F, ESCAPE_CAPS) = (uint8_t) '\t';
KEY_INDEX(0x10, ESCAPE_CAPS) = (uint8_t) 'Q';
KEY_INDEX(0x11, ESCAPE_CAPS) = (uint8_t) 'W';
KEY_INDEX(0x12, ESCAPE_CAPS) = (uint8_t) 'E';
KEY_INDEX(0x13, ESCAPE_CAPS) = (uint8_t) 'R';
KEY_INDEX(0x14, ESCAPE_CAPS) = (uint8_t) 'T';
KEY_INDEX(0x15, ESCAPE_CAPS) = (uint8_t) 'Y';
KEY_INDEX(0x16, ESCAPE_CAPS) = (uint8_t) 'U';
KEY_INDEX(0x17, ESCAPE_CAPS) = (uint8_t) 'I';
KEY_INDEX(0x18, ESCAPE_CAPS) = (uint8_t) 'O';
KEY_INDEX(0x19, ESCAPE_CAPS) = (uint8_t) 'P';
KEY_INDEX(0x1A, ESCAPE_CAPS) = (uint8_t) '[';
KEY_INDEX(0x1B, ESCAPE_CAPS) = (uint8_t) ']';
KEY_INDEX(0x1C, ESCAPE_CAPS) = (uint8_t) '\n';
KEY_INDEX(0x1D, ESCAPE_CAPS) = (uint8_t) 0; //LCTRL
KEY_INDEX(0x1E, ESCAPE_CAPS) = (uint8_t) 'A';
KEY_INDEX(0x1F, ESCAPE_CAPS) = (uint8_t) 'S';
KEY_INDEX(0x20, ESCAPE_CAPS) = (uint8_t) 'D';
KEY_INDEX(0x21, ESCAPE_CAPS) = (uint8_t) 'F';
KEY_INDEX(0x22, ESCAPE_CAPS) = (uint8_t) 'G';
KEY_INDEX(0x23, ESCAPE_CAPS) = (uint8_t) 'H';
KEY_INDEX(0x24, ESCAPE_CAPS) = (uint8_t) 'J';
KEY_INDEX(0x25, ESCAPE_CAPS) = (uint8_t) 'K';
KEY_INDEX(0x26, ESCAPE_CAPS) = (uint8_t) 'L';
KEY_INDEX(0x27, ESCAPE_CAPS) = (uint8_t) ';';
KEY_INDEX(0x28, ESCAPE_CAPS) = (uint8_t) '\'';
KEY_INDEX(0x29, ESCAPE_CAPS) = (uint8_t) '`';
KEY_INDEX(0x2A, ESCAPE_CAPS) = (uint8_t) 0; //LSHFT
KEY_INDEX(0x2B, ESCAPE_CAPS) = (uint8_t) '\\';
KEY_INDEX(0x2C, ESCAPE_CAPS) = (uint8_t) 'Z';
KEY_INDEX(0x2D, ESCAPE_CAPS) = (uint8_t) 'X';
KEY_INDEX(0x2E, ESCAPE_CAPS) = (uint8_t) 'C';
KEY_INDEX(0x2F, ESCAPE_CAPS) = (uint8_t) 'V';
KEY_INDEX(0x30, ESCAPE_CAPS) = (uint8_t) 'B';
KEY_INDEX(0x31, ESCAPE_CAPS) = (uint8_t) 'N';
KEY_INDEX(0x32, ESCAPE_CAPS) = (uint8_t) 'M';
KEY_INDEX(0x33, ESCAPE_CAPS) = (uint8_t) ',';
KEY_INDEX(0x34, ESCAPE_CAPS) = (uint8_t) '.';
KEY_INDEX(0x35, ESCAPE_CAPS) = (uint8_t) '/';
KEY_INDEX(0x36, ESCAPE_CAPS) = (uint8_t) 0; //RSHFT
KEY_INDEX(0x37, ESCAPE_CAPS) = (uint8_t) '*';
KEY_INDEX(0x38, ESCAPE_CAPS) = (uint8_t) 0; //LALT
KEY_INDEX(0x39, ESCAPE_CAPS) = (uint8_t) ' ';
KEY_INDEX(0x3A, ESCAPE_CAPS) = (uint8_t) 0; //CAPSLOCK
KEY_INDEX(0x3B, ESCAPE_CAPS) = (uint8_t) 0; //F1
KEY_INDEX(0x3C, ESCAPE_CAPS) = (uint8_t) 0; //F2
KEY_INDEX(0x3D, ESCAPE_CAPS) = (uint8_t) 0; //F3
KEY_INDEX(0x3E, ESCAPE_CAPS) = (uint8_t) 0; //F4
KEY_INDEX(0x3F, ESCAPE_CAPS) = (uint8_t) 0; //F5
KEY_INDEX(0x40, ESCAPE_CAPS) = (uint8_t) 0; //F6
KEY_INDEX(0x41, ESCAPE_CAPS) = (uint8_t) 0; //F7
KEY_INDEX(0x42, ESCAPE_CAPS) = (uint8_t) 0; //F8
KEY_INDEX(0x43, ESCAPE_CAPS) = (uint8_t) 0; //F9
KEY_INDEX(0x44, ESCAPE_CAPS) = (uint8_t) 0; //F10
KEY_INDEX(0x45, ESCAPE_CAPS) = (uint8_t) 0; //NUMLOCK
KEY_INDEX(0x46, ESCAPE_CAPS) = (uint8_t) 0; //SCROLL LOCK
KEY_INDEX(0x47, ESCAPE_CAPS) = (uint8_t) '7'; //KPAD7
KEY_INDEX(0x48, ESCAPE_CAPS) = (uint8_t) '8'; //KPAD8
KEY_INDEX(0x49, ESCAPE_CAPS) = (uint8_t) '9'; //KPAD9
KEY_INDEX(0x4A, ESCAPE_CAPS) = (uint8_t) '-'; //KPAD-
KEY_INDEX(0x4B, ESCAPE_CAPS) = (uint8_t) '4'; //KPAD4
KEY_INDEX(0x4C, ESCAPE_CAPS) = (uint8_t) '5'; //KPAD5
KEY_INDEX(0x4D, ESCAPE_CAPS) = (uint8_t) '6'; //KPAD6
KEY_INDEX(0x4E, ESCAPE_CAPS) = (uint8_t) '+'; //KPAD+
KEY_INDEX(0x4F, ESCAPE_CAPS) = (uint8_t) '1'; //KPAD1
KEY_INDEX(0x50, ESCAPE_CAPS) = (uint8_t) '2'; //KPAD2
KEY_INDEX(0x51, ESCAPE_CAPS) = (uint8_t) '3'; //KPAD3
KEY_INDEX(0x52, ESCAPE_CAPS) = (uint8_t) '0'; //KPAD0
KEY_INDEX(0x53, ESCAPE_CAPS) = (uint8_t) '.'; //KPAD.
KEY_INDEX(0x54, ESCAPE_CAPS) = (uint8_t) 0; //NULL
KEY_INDEX(0x55, ESCAPE_CAPS) = (uint8_t) 0; //FUNC
KEY_INDEX(0x56, ESCAPE_CAPS) = (uint8_t) 0; //blank
KEY_INDEX(0x57, ESCAPE_CAPS) = (uint8_t) 0; //F11
KEY_INDEX(0x58, ESCAPE_CAPS) = (uint8_t) 0; //F12
KEY_INDEX(0x59, ESCAPE_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5A, ESCAPE_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5B, ESCAPE_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5C, ESCAPE_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5D, ESCAPE_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5E, ESCAPE_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5F, ESCAPE_CAPS) = (uint8_t) 0;
//escaped with shift and caps lock
KEY_INDEX(0x00, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //NULL
KEY_INDEX(0x01, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //ESC
KEY_INDEX(0x02, ESCAPE_SHIFT_CAPS) = (uint8_t) '!';
KEY_INDEX(0x03, ESCAPE_SHIFT_CAPS) = (uint8_t) '@';
KEY_INDEX(0x04, ESCAPE_SHIFT_CAPS) = (uint8_t) '#';
KEY_INDEX(0x05, ESCAPE_SHIFT_CAPS) = (uint8_t) '$';
KEY_INDEX(0x06, ESCAPE_SHIFT_CAPS) = (uint8_t) '%';
KEY_INDEX(0x07, ESCAPE_SHIFT_CAPS) = (uint8_t) '^';
KEY_INDEX(0x08, ESCAPE_SHIFT_CAPS) = (uint8_t) '&';
KEY_INDEX(0x09, ESCAPE_SHIFT_CAPS) = (uint8_t) '*';
KEY_INDEX(0x0A, ESCAPE_SHIFT_CAPS) = (uint8_t) '(';
KEY_INDEX(0x0B, ESCAPE_SHIFT_CAPS) = (uint8_t) ')';
KEY_INDEX(0x0C, ESCAPE_SHIFT_CAPS) = (uint8_t) '_';
KEY_INDEX(0x0D, ESCAPE_SHIFT_CAPS) = (uint8_t) '+';
KEY_INDEX(0x0E, ESCAPE_SHIFT_CAPS) = (uint8_t) '\b';
KEY_INDEX(0x0F, ESCAPE_SHIFT_CAPS) = (uint8_t) '\t';
KEY_INDEX(0x10, ESCAPE_SHIFT_CAPS) = (uint8_t) 'q';
KEY_INDEX(0x11, ESCAPE_SHIFT_CAPS) = (uint8_t) 'w';
KEY_INDEX(0x12, ESCAPE_SHIFT_CAPS) = (uint8_t) 'e';
KEY_INDEX(0x13, ESCAPE_SHIFT_CAPS) = (uint8_t) 'r';
KEY_INDEX(0x14, ESCAPE_SHIFT_CAPS) = (uint8_t) 't';
KEY_INDEX(0x15, ESCAPE_SHIFT_CAPS) = (uint8_t) 'y';
KEY_INDEX(0x16, ESCAPE_SHIFT_CAPS) = (uint8_t) 'u';
KEY_INDEX(0x17, ESCAPE_SHIFT_CAPS) = (uint8_t) 'i';
KEY_INDEX(0x18, ESCAPE_SHIFT_CAPS) = (uint8_t) 'o';
KEY_INDEX(0x19, ESCAPE_SHIFT_CAPS) = (uint8_t) 'p';
KEY_INDEX(0x1A, ESCAPE_SHIFT_CAPS) = (uint8_t) '{';
KEY_INDEX(0x1B, ESCAPE_SHIFT_CAPS) = (uint8_t) '}';
KEY_INDEX(0x1C, ESCAPE_SHIFT_CAPS) = (uint8_t) '\n';
KEY_INDEX(0x1D, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //LCTRL
KEY_INDEX(0x1E, ESCAPE_SHIFT_CAPS) = (uint8_t) 'a';
KEY_INDEX(0x1F, ESCAPE_SHIFT_CAPS) = (uint8_t) 's';
KEY_INDEX(0x20, ESCAPE_SHIFT_CAPS) = (uint8_t) 'd';
KEY_INDEX(0x21, ESCAPE_SHIFT_CAPS) = (uint8_t) 'f';
KEY_INDEX(0x22, ESCAPE_SHIFT_CAPS) = (uint8_t) 'g';
KEY_INDEX(0x23, ESCAPE_SHIFT_CAPS) = (uint8_t) 'h';
KEY_INDEX(0x24, ESCAPE_SHIFT_CAPS) = (uint8_t) 'j';
KEY_INDEX(0x25, ESCAPE_SHIFT_CAPS) = (uint8_t) 'k';
KEY_INDEX(0x26, ESCAPE_SHIFT_CAPS) = (uint8_t) 'l';
KEY_INDEX(0x27, ESCAPE_SHIFT_CAPS) = (uint8_t) ':';
KEY_INDEX(0x28, ESCAPE_SHIFT_CAPS) = (uint8_t) '"';
KEY_INDEX(0x29, ESCAPE_SHIFT_CAPS) = (uint8_t) '~';
KEY_INDEX(0x2A, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //LSHFT
KEY_INDEX(0x2B, ESCAPE_SHIFT_CAPS) = (uint8_t) '|';
KEY_INDEX(0x2C, ESCAPE_SHIFT_CAPS) = (uint8_t) 'z';
KEY_INDEX(0x2D, ESCAPE_SHIFT_CAPS) = (uint8_t) 'x';
KEY_INDEX(0x2E, ESCAPE_SHIFT_CAPS) = (uint8_t) 'c';
KEY_INDEX(0x2F, ESCAPE_SHIFT_CAPS) = (uint8_t) 'v';
KEY_INDEX(0x30, ESCAPE_SHIFT_CAPS) = (uint8_t) 'b';
KEY_INDEX(0x31, ESCAPE_SHIFT_CAPS) = (uint8_t) 'n';
KEY_INDEX(0x32, ESCAPE_SHIFT_CAPS) = (uint8_t) 'm';
KEY_INDEX(0x33, ESCAPE_SHIFT_CAPS) = (uint8_t) '<';
KEY_INDEX(0x34, ESCAPE_SHIFT_CAPS) = (uint8_t) '>';
KEY_INDEX(0x35, ESCAPE_SHIFT_CAPS) = (uint8_t) '?';
KEY_INDEX(0x36, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //RSHFT
KEY_INDEX(0x37, ESCAPE_SHIFT_CAPS) = (uint8_t) 0;
KEY_INDEX(0x38, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //LALT
KEY_INDEX(0x39, ESCAPE_SHIFT_CAPS) = (uint8_t) ' ';
KEY_INDEX(0x3A, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //CAPSLOCK
KEY_INDEX(0x3B, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F1
KEY_INDEX(0x3C, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F2
KEY_INDEX(0x3D, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F3
KEY_INDEX(0x3E, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F4
KEY_INDEX(0x3F, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F5
KEY_INDEX(0x40, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F6
KEY_INDEX(0x41, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F7
KEY_INDEX(0x42, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F8
KEY_INDEX(0x43, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F9
KEY_INDEX(0x44, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F10
KEY_INDEX(0x45, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //NUMLOCK
KEY_INDEX(0x46, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //SCROLL LOCK
KEY_INDEX(0x47, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD7
KEY_INDEX(0x48, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD8
KEY_INDEX(0x49, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD9
KEY_INDEX(0x4A, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD-
KEY_INDEX(0x4B, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD4
KEY_INDEX(0x4C, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD5
KEY_INDEX(0x4D, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD6
KEY_INDEX(0x4E, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD+
KEY_INDEX(0x4F, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD1
KEY_INDEX(0x50, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD2
KEY_INDEX(0x51, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD3
KEY_INDEX(0x52, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD0
KEY_INDEX(0x53, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //KPAD.
KEY_INDEX(0x54, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //NULL
KEY_INDEX(0x55, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //FUNC
KEY_INDEX(0x56, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //blank
KEY_INDEX(0x57, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F11
KEY_INDEX(0x58, ESCAPE_SHIFT_CAPS) = (uint8_t) 0; //F12
KEY_INDEX(0x59, ESCAPE_SHIFT_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5A, ESCAPE_SHIFT_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5B, ESCAPE_SHIFT_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5C, ESCAPE_SHIFT_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5D, ESCAPE_SHIFT_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5E, ESCAPE_SHIFT_CAPS) = (uint8_t) 0;
KEY_INDEX(0x5F, ESCAPE_SHIFT_CAPS) = (uint8_t) 0;
KEY_INDEX(0x35, ESCAPE_E0) = (uint8_t) '//';
KEY_INDEX(0x48, ESCAPE_E0) = (uint8_t) '^';
KEY_INDEX(0x4B, ESCAPE_E0) = (uint8_t) '<';
KEY_INDEX(0x4D, ESCAPE_E0) = (uint8_t) '>';
KEY_INDEX(0x50, ESCAPE_E0) = (uint8_t) 'V';
}
