android13/external/strace/xlat/evdev_keycode.h

/* Generated by ./xlat/gen.sh from ./xlat/evdev_keycode.in; do not edit. */

#include "gcc_compat.h"
#include "static_assert.h"

#if defined(KEY_RESERVED) || (defined(HAVE_DECL_KEY_RESERVED) && HAVE_DECL_KEY_RESERVED)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RESERVED) == (0), "KEY_RESERVED != 0");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RESERVED 0
#endif
#if defined(KEY_ESC) || (defined(HAVE_DECL_KEY_ESC) && HAVE_DECL_KEY_ESC)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ESC) == (1), "KEY_ESC != 1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ESC 1
#endif
#if defined(KEY_1) || (defined(HAVE_DECL_KEY_1) && HAVE_DECL_KEY_1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_1) == (2), "KEY_1 != 2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_1 2
#endif
#if defined(KEY_2) || (defined(HAVE_DECL_KEY_2) && HAVE_DECL_KEY_2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_2) == (3), "KEY_2 != 3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_2 3
#endif
#if defined(KEY_3) || (defined(HAVE_DECL_KEY_3) && HAVE_DECL_KEY_3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_3) == (4), "KEY_3 != 4");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_3 4
#endif
#if defined(KEY_4) || (defined(HAVE_DECL_KEY_4) && HAVE_DECL_KEY_4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_4) == (5), "KEY_4 != 5");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_4 5
#endif
#if defined(KEY_5) || (defined(HAVE_DECL_KEY_5) && HAVE_DECL_KEY_5)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_5) == (6), "KEY_5 != 6");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_5 6
#endif
#if defined(KEY_6) || (defined(HAVE_DECL_KEY_6) && HAVE_DECL_KEY_6)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_6) == (7), "KEY_6 != 7");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_6 7
#endif
#if defined(KEY_7) || (defined(HAVE_DECL_KEY_7) && HAVE_DECL_KEY_7)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_7) == (8), "KEY_7 != 8");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_7 8
#endif
#if defined(KEY_8) || (defined(HAVE_DECL_KEY_8) && HAVE_DECL_KEY_8)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_8) == (9), "KEY_8 != 9");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_8 9
#endif
#if defined(KEY_9) || (defined(HAVE_DECL_KEY_9) && HAVE_DECL_KEY_9)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_9) == (10), "KEY_9 != 10");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_9 10
#endif
#if defined(KEY_0) || (defined(HAVE_DECL_KEY_0) && HAVE_DECL_KEY_0)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_0) == (11), "KEY_0 != 11");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_0 11
#endif
#if defined(KEY_MINUS) || (defined(HAVE_DECL_KEY_MINUS) && HAVE_DECL_KEY_MINUS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MINUS) == (12), "KEY_MINUS != 12");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MINUS 12
#endif
#if defined(KEY_EQUAL) || (defined(HAVE_DECL_KEY_EQUAL) && HAVE_DECL_KEY_EQUAL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_EQUAL) == (13), "KEY_EQUAL != 13");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_EQUAL 13
#endif
#if defined(KEY_BACKSPACE) || (defined(HAVE_DECL_KEY_BACKSPACE) && HAVE_DECL_KEY_BACKSPACE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BACKSPACE) == (14), "KEY_BACKSPACE != 14");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BACKSPACE 14
#endif
#if defined(KEY_TAB) || (defined(HAVE_DECL_KEY_TAB) && HAVE_DECL_KEY_TAB)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TAB) == (15), "KEY_TAB != 15");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TAB 15
#endif
#if defined(KEY_Q) || (defined(HAVE_DECL_KEY_Q) && HAVE_DECL_KEY_Q)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_Q) == (16), "KEY_Q != 16");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_Q 16
#endif
#if defined(KEY_W) || (defined(HAVE_DECL_KEY_W) && HAVE_DECL_KEY_W)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_W) == (17), "KEY_W != 17");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_W 17
#endif
#if defined(KEY_E) || (defined(HAVE_DECL_KEY_E) && HAVE_DECL_KEY_E)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_E) == (18), "KEY_E != 18");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_E 18
#endif
#if defined(KEY_R) || (defined(HAVE_DECL_KEY_R) && HAVE_DECL_KEY_R)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_R) == (19), "KEY_R != 19");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_R 19
#endif
#if defined(KEY_T) || (defined(HAVE_DECL_KEY_T) && HAVE_DECL_KEY_T)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_T) == (20), "KEY_T != 20");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_T 20
#endif
#if defined(KEY_Y) || (defined(HAVE_DECL_KEY_Y) && HAVE_DECL_KEY_Y)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_Y) == (21), "KEY_Y != 21");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_Y 21
#endif
#if defined(KEY_U) || (defined(HAVE_DECL_KEY_U) && HAVE_DECL_KEY_U)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_U) == (22), "KEY_U != 22");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_U 22
#endif
#if defined(KEY_I) || (defined(HAVE_DECL_KEY_I) && HAVE_DECL_KEY_I)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_I) == (23), "KEY_I != 23");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_I 23
#endif
#if defined(KEY_O) || (defined(HAVE_DECL_KEY_O) && HAVE_DECL_KEY_O)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_O) == (24), "KEY_O != 24");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_O 24
#endif
#if defined(KEY_P) || (defined(HAVE_DECL_KEY_P) && HAVE_DECL_KEY_P)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_P) == (25), "KEY_P != 25");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_P 25
#endif
#if defined(KEY_LEFTBRACE) || (defined(HAVE_DECL_KEY_LEFTBRACE) && HAVE_DECL_KEY_LEFTBRACE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LEFTBRACE) == (26), "KEY_LEFTBRACE != 26");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LEFTBRACE 26
#endif
#if defined(KEY_RIGHTBRACE) || (defined(HAVE_DECL_KEY_RIGHTBRACE) && HAVE_DECL_KEY_RIGHTBRACE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RIGHTBRACE) == (27), "KEY_RIGHTBRACE != 27");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RIGHTBRACE 27
#endif
#if defined(KEY_ENTER) || (defined(HAVE_DECL_KEY_ENTER) && HAVE_DECL_KEY_ENTER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ENTER) == (28), "KEY_ENTER != 28");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ENTER 28
#endif
#if defined(KEY_LEFTCTRL) || (defined(HAVE_DECL_KEY_LEFTCTRL) && HAVE_DECL_KEY_LEFTCTRL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LEFTCTRL) == (29), "KEY_LEFTCTRL != 29");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LEFTCTRL 29
#endif
#if defined(KEY_A) || (defined(HAVE_DECL_KEY_A) && HAVE_DECL_KEY_A)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_A) == (30), "KEY_A != 30");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_A 30
#endif
#if defined(KEY_S) || (defined(HAVE_DECL_KEY_S) && HAVE_DECL_KEY_S)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_S) == (31), "KEY_S != 31");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_S 31
#endif
#if defined(KEY_D) || (defined(HAVE_DECL_KEY_D) && HAVE_DECL_KEY_D)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_D) == (32), "KEY_D != 32");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_D 32
#endif
#if defined(KEY_F) || (defined(HAVE_DECL_KEY_F) && HAVE_DECL_KEY_F)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F) == (33), "KEY_F != 33");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F 33
#endif
#if defined(KEY_G) || (defined(HAVE_DECL_KEY_G) && HAVE_DECL_KEY_G)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_G) == (34), "KEY_G != 34");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_G 34
#endif
#if defined(KEY_H) || (defined(HAVE_DECL_KEY_H) && HAVE_DECL_KEY_H)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_H) == (35), "KEY_H != 35");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_H 35
#endif
#if defined(KEY_J) || (defined(HAVE_DECL_KEY_J) && HAVE_DECL_KEY_J)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_J) == (36), "KEY_J != 36");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_J 36
#endif
#if defined(KEY_K) || (defined(HAVE_DECL_KEY_K) && HAVE_DECL_KEY_K)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_K) == (37), "KEY_K != 37");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_K 37
#endif
#if defined(KEY_L) || (defined(HAVE_DECL_KEY_L) && HAVE_DECL_KEY_L)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_L) == (38), "KEY_L != 38");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_L 38
#endif
#if defined(KEY_SEMICOLON) || (defined(HAVE_DECL_KEY_SEMICOLON) && HAVE_DECL_KEY_SEMICOLON)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SEMICOLON) == (39), "KEY_SEMICOLON != 39");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SEMICOLON 39
#endif
#if defined(KEY_APOSTROPHE) || (defined(HAVE_DECL_KEY_APOSTROPHE) && HAVE_DECL_KEY_APOSTROPHE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_APOSTROPHE) == (40), "KEY_APOSTROPHE != 40");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_APOSTROPHE 40
#endif
#if defined(KEY_GRAVE) || (defined(HAVE_DECL_KEY_GRAVE) && HAVE_DECL_KEY_GRAVE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_GRAVE) == (41), "KEY_GRAVE != 41");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_GRAVE 41
#endif
#if defined(KEY_LEFTSHIFT) || (defined(HAVE_DECL_KEY_LEFTSHIFT) && HAVE_DECL_KEY_LEFTSHIFT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LEFTSHIFT) == (42), "KEY_LEFTSHIFT != 42");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LEFTSHIFT 42
#endif
#if defined(KEY_BACKSLASH) || (defined(HAVE_DECL_KEY_BACKSLASH) && HAVE_DECL_KEY_BACKSLASH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BACKSLASH) == (43), "KEY_BACKSLASH != 43");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BACKSLASH 43
#endif
#if defined(KEY_Z) || (defined(HAVE_DECL_KEY_Z) && HAVE_DECL_KEY_Z)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_Z) == (44), "KEY_Z != 44");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_Z 44
#endif
#if defined(KEY_X) || (defined(HAVE_DECL_KEY_X) && HAVE_DECL_KEY_X)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_X) == (45), "KEY_X != 45");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_X 45
#endif
#if defined(KEY_C) || (defined(HAVE_DECL_KEY_C) && HAVE_DECL_KEY_C)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_C) == (46), "KEY_C != 46");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_C 46
#endif
#if defined(KEY_V) || (defined(HAVE_DECL_KEY_V) && HAVE_DECL_KEY_V)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_V) == (47), "KEY_V != 47");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_V 47
#endif
#if defined(KEY_B) || (defined(HAVE_DECL_KEY_B) && HAVE_DECL_KEY_B)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_B) == (48), "KEY_B != 48");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_B 48
#endif
#if defined(KEY_N) || (defined(HAVE_DECL_KEY_N) && HAVE_DECL_KEY_N)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_N) == (49), "KEY_N != 49");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_N 49
#endif
#if defined(KEY_M) || (defined(HAVE_DECL_KEY_M) && HAVE_DECL_KEY_M)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_M) == (50), "KEY_M != 50");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_M 50
#endif
#if defined(KEY_COMMA) || (defined(HAVE_DECL_KEY_COMMA) && HAVE_DECL_KEY_COMMA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_COMMA) == (51), "KEY_COMMA != 51");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_COMMA 51
#endif
#if defined(KEY_DOT) || (defined(HAVE_DECL_KEY_DOT) && HAVE_DECL_KEY_DOT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DOT) == (52), "KEY_DOT != 52");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DOT 52
#endif
#if defined(KEY_SLASH) || (defined(HAVE_DECL_KEY_SLASH) && HAVE_DECL_KEY_SLASH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SLASH) == (53), "KEY_SLASH != 53");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SLASH 53
#endif
#if defined(KEY_RIGHTSHIFT) || (defined(HAVE_DECL_KEY_RIGHTSHIFT) && HAVE_DECL_KEY_RIGHTSHIFT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RIGHTSHIFT) == (54), "KEY_RIGHTSHIFT != 54");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RIGHTSHIFT 54
#endif
#if defined(KEY_KPASTERISK) || (defined(HAVE_DECL_KEY_KPASTERISK) && HAVE_DECL_KEY_KPASTERISK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPASTERISK) == (55), "KEY_KPASTERISK != 55");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPASTERISK 55
#endif
#if defined(KEY_LEFTALT) || (defined(HAVE_DECL_KEY_LEFTALT) && HAVE_DECL_KEY_LEFTALT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LEFTALT) == (56), "KEY_LEFTALT != 56");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LEFTALT 56
#endif
#if defined(KEY_SPACE) || (defined(HAVE_DECL_KEY_SPACE) && HAVE_DECL_KEY_SPACE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SPACE) == (57), "KEY_SPACE != 57");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SPACE 57
#endif
#if defined(KEY_CAPSLOCK) || (defined(HAVE_DECL_KEY_CAPSLOCK) && HAVE_DECL_KEY_CAPSLOCK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CAPSLOCK) == (58), "KEY_CAPSLOCK != 58");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CAPSLOCK 58
#endif
#if defined(KEY_F1) || (defined(HAVE_DECL_KEY_F1) && HAVE_DECL_KEY_F1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F1) == (59), "KEY_F1 != 59");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F1 59
#endif
#if defined(KEY_F2) || (defined(HAVE_DECL_KEY_F2) && HAVE_DECL_KEY_F2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F2) == (60), "KEY_F2 != 60");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F2 60
#endif
#if defined(KEY_F3) || (defined(HAVE_DECL_KEY_F3) && HAVE_DECL_KEY_F3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F3) == (61), "KEY_F3 != 61");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F3 61
#endif
#if defined(KEY_F4) || (defined(HAVE_DECL_KEY_F4) && HAVE_DECL_KEY_F4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F4) == (62), "KEY_F4 != 62");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F4 62
#endif
#if defined(KEY_F5) || (defined(HAVE_DECL_KEY_F5) && HAVE_DECL_KEY_F5)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F5) == (63), "KEY_F5 != 63");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F5 63
#endif
#if defined(KEY_F6) || (defined(HAVE_DECL_KEY_F6) && HAVE_DECL_KEY_F6)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F6) == (64), "KEY_F6 != 64");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F6 64
#endif
#if defined(KEY_F7) || (defined(HAVE_DECL_KEY_F7) && HAVE_DECL_KEY_F7)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F7) == (65), "KEY_F7 != 65");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F7 65
#endif
#if defined(KEY_F8) || (defined(HAVE_DECL_KEY_F8) && HAVE_DECL_KEY_F8)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F8) == (66), "KEY_F8 != 66");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F8 66
#endif
#if defined(KEY_F9) || (defined(HAVE_DECL_KEY_F9) && HAVE_DECL_KEY_F9)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F9) == (67), "KEY_F9 != 67");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F9 67
#endif
#if defined(KEY_F10) || (defined(HAVE_DECL_KEY_F10) && HAVE_DECL_KEY_F10)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F10) == (68), "KEY_F10 != 68");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F10 68
#endif
#if defined(KEY_NUMLOCK) || (defined(HAVE_DECL_KEY_NUMLOCK) && HAVE_DECL_KEY_NUMLOCK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMLOCK) == (69), "KEY_NUMLOCK != 69");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMLOCK 69
#endif
#if defined(KEY_SCROLLLOCK) || (defined(HAVE_DECL_KEY_SCROLLLOCK) && HAVE_DECL_KEY_SCROLLLOCK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SCROLLLOCK) == (70), "KEY_SCROLLLOCK != 70");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SCROLLLOCK 70
#endif
#if defined(KEY_KP7) || (defined(HAVE_DECL_KEY_KP7) && HAVE_DECL_KEY_KP7)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP7) == (71), "KEY_KP7 != 71");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP7 71
#endif
#if defined(KEY_KP8) || (defined(HAVE_DECL_KEY_KP8) && HAVE_DECL_KEY_KP8)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP8) == (72), "KEY_KP8 != 72");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP8 72
#endif
#if defined(KEY_KP9) || (defined(HAVE_DECL_KEY_KP9) && HAVE_DECL_KEY_KP9)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP9) == (73), "KEY_KP9 != 73");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP9 73
#endif
#if defined(KEY_KPMINUS) || (defined(HAVE_DECL_KEY_KPMINUS) && HAVE_DECL_KEY_KPMINUS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPMINUS) == (74), "KEY_KPMINUS != 74");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPMINUS 74
#endif
#if defined(KEY_KP4) || (defined(HAVE_DECL_KEY_KP4) && HAVE_DECL_KEY_KP4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP4) == (75), "KEY_KP4 != 75");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP4 75
#endif
#if defined(KEY_KP5) || (defined(HAVE_DECL_KEY_KP5) && HAVE_DECL_KEY_KP5)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP5) == (76), "KEY_KP5 != 76");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP5 76
#endif
#if defined(KEY_KP6) || (defined(HAVE_DECL_KEY_KP6) && HAVE_DECL_KEY_KP6)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP6) == (77), "KEY_KP6 != 77");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP6 77
#endif
#if defined(KEY_KPPLUS) || (defined(HAVE_DECL_KEY_KPPLUS) && HAVE_DECL_KEY_KPPLUS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPPLUS) == (78), "KEY_KPPLUS != 78");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPPLUS 78
#endif
#if defined(KEY_KP1) || (defined(HAVE_DECL_KEY_KP1) && HAVE_DECL_KEY_KP1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP1) == (79), "KEY_KP1 != 79");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP1 79
#endif
#if defined(KEY_KP2) || (defined(HAVE_DECL_KEY_KP2) && HAVE_DECL_KEY_KP2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP2) == (80), "KEY_KP2 != 80");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP2 80
#endif
#if defined(KEY_KP3) || (defined(HAVE_DECL_KEY_KP3) && HAVE_DECL_KEY_KP3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP3) == (81), "KEY_KP3 != 81");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP3 81
#endif
#if defined(KEY_KP0) || (defined(HAVE_DECL_KEY_KP0) && HAVE_DECL_KEY_KP0)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KP0) == (82), "KEY_KP0 != 82");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KP0 82
#endif
#if defined(KEY_KPDOT) || (defined(HAVE_DECL_KEY_KPDOT) && HAVE_DECL_KEY_KPDOT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPDOT) == (83), "KEY_KPDOT != 83");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPDOT 83
#endif
#if defined(KEY_ZENKAKUHANKAKU) || (defined(HAVE_DECL_KEY_ZENKAKUHANKAKU) && HAVE_DECL_KEY_ZENKAKUHANKAKU)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ZENKAKUHANKAKU) == (85), "KEY_ZENKAKUHANKAKU != 85");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ZENKAKUHANKAKU 85
#endif
#if defined(KEY_102ND) || (defined(HAVE_DECL_KEY_102ND) && HAVE_DECL_KEY_102ND)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_102ND) == (86), "KEY_102ND != 86");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_102ND 86
#endif
#if defined(KEY_F11) || (defined(HAVE_DECL_KEY_F11) && HAVE_DECL_KEY_F11)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F11) == (87), "KEY_F11 != 87");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F11 87
#endif
#if defined(KEY_F12) || (defined(HAVE_DECL_KEY_F12) && HAVE_DECL_KEY_F12)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F12) == (88), "KEY_F12 != 88");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F12 88
#endif
#if defined(KEY_RO) || (defined(HAVE_DECL_KEY_RO) && HAVE_DECL_KEY_RO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RO) == (89), "KEY_RO != 89");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RO 89
#endif
#if defined(KEY_KATAKANA) || (defined(HAVE_DECL_KEY_KATAKANA) && HAVE_DECL_KEY_KATAKANA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KATAKANA) == (90), "KEY_KATAKANA != 90");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KATAKANA 90
#endif
#if defined(KEY_HIRAGANA) || (defined(HAVE_DECL_KEY_HIRAGANA) && HAVE_DECL_KEY_HIRAGANA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_HIRAGANA) == (91), "KEY_HIRAGANA != 91");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_HIRAGANA 91
#endif
#if defined(KEY_HENKAN) || (defined(HAVE_DECL_KEY_HENKAN) && HAVE_DECL_KEY_HENKAN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_HENKAN) == (92), "KEY_HENKAN != 92");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_HENKAN 92
#endif
#if defined(KEY_KATAKANAHIRAGANA) || (defined(HAVE_DECL_KEY_KATAKANAHIRAGANA) && HAVE_DECL_KEY_KATAKANAHIRAGANA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KATAKANAHIRAGANA) == (93), "KEY_KATAKANAHIRAGANA != 93");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KATAKANAHIRAGANA 93
#endif
#if defined(KEY_MUHENKAN) || (defined(HAVE_DECL_KEY_MUHENKAN) && HAVE_DECL_KEY_MUHENKAN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MUHENKAN) == (94), "KEY_MUHENKAN != 94");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MUHENKAN 94
#endif
#if defined(KEY_KPJPCOMMA) || (defined(HAVE_DECL_KEY_KPJPCOMMA) && HAVE_DECL_KEY_KPJPCOMMA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPJPCOMMA) == (95), "KEY_KPJPCOMMA != 95");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPJPCOMMA 95
#endif
#if defined(KEY_KPENTER) || (defined(HAVE_DECL_KEY_KPENTER) && HAVE_DECL_KEY_KPENTER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPENTER) == (96), "KEY_KPENTER != 96");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPENTER 96
#endif
#if defined(KEY_RIGHTCTRL) || (defined(HAVE_DECL_KEY_RIGHTCTRL) && HAVE_DECL_KEY_RIGHTCTRL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RIGHTCTRL) == (97), "KEY_RIGHTCTRL != 97");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RIGHTCTRL 97
#endif
#if defined(KEY_KPSLASH) || (defined(HAVE_DECL_KEY_KPSLASH) && HAVE_DECL_KEY_KPSLASH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPSLASH) == (98), "KEY_KPSLASH != 98");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPSLASH 98
#endif
#if defined(KEY_SYSRQ) || (defined(HAVE_DECL_KEY_SYSRQ) && HAVE_DECL_KEY_SYSRQ)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SYSRQ) == (99), "KEY_SYSRQ != 99");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SYSRQ 99
#endif
#if defined(KEY_RIGHTALT) || (defined(HAVE_DECL_KEY_RIGHTALT) && HAVE_DECL_KEY_RIGHTALT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RIGHTALT) == (100), "KEY_RIGHTALT != 100");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RIGHTALT 100
#endif
#if defined(KEY_LINEFEED) || (defined(HAVE_DECL_KEY_LINEFEED) && HAVE_DECL_KEY_LINEFEED)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LINEFEED) == (101), "KEY_LINEFEED != 101");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LINEFEED 101
#endif
#if defined(KEY_HOME) || (defined(HAVE_DECL_KEY_HOME) && HAVE_DECL_KEY_HOME)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_HOME) == (102), "KEY_HOME != 102");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_HOME 102
#endif
#if defined(KEY_UP) || (defined(HAVE_DECL_KEY_UP) && HAVE_DECL_KEY_UP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_UP) == (103), "KEY_UP != 103");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_UP 103
#endif
#if defined(KEY_PAGEUP) || (defined(HAVE_DECL_KEY_PAGEUP) && HAVE_DECL_KEY_PAGEUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PAGEUP) == (104), "KEY_PAGEUP != 104");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PAGEUP 104
#endif
#if defined(KEY_LEFT) || (defined(HAVE_DECL_KEY_LEFT) && HAVE_DECL_KEY_LEFT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LEFT) == (105), "KEY_LEFT != 105");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LEFT 105
#endif
#if defined(KEY_RIGHT) || (defined(HAVE_DECL_KEY_RIGHT) && HAVE_DECL_KEY_RIGHT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RIGHT) == (106), "KEY_RIGHT != 106");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RIGHT 106
#endif
#if defined(KEY_END) || (defined(HAVE_DECL_KEY_END) && HAVE_DECL_KEY_END)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_END) == (107), "KEY_END != 107");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_END 107
#endif
#if defined(KEY_DOWN) || (defined(HAVE_DECL_KEY_DOWN) && HAVE_DECL_KEY_DOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DOWN) == (108), "KEY_DOWN != 108");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DOWN 108
#endif
#if defined(KEY_PAGEDOWN) || (defined(HAVE_DECL_KEY_PAGEDOWN) && HAVE_DECL_KEY_PAGEDOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PAGEDOWN) == (109), "KEY_PAGEDOWN != 109");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PAGEDOWN 109
#endif
#if defined(KEY_INSERT) || (defined(HAVE_DECL_KEY_INSERT) && HAVE_DECL_KEY_INSERT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_INSERT) == (110), "KEY_INSERT != 110");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_INSERT 110
#endif
#if defined(KEY_DELETE) || (defined(HAVE_DECL_KEY_DELETE) && HAVE_DECL_KEY_DELETE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DELETE) == (111), "KEY_DELETE != 111");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DELETE 111
#endif
#if defined(KEY_MACRO) || (defined(HAVE_DECL_KEY_MACRO) && HAVE_DECL_KEY_MACRO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MACRO) == (112), "KEY_MACRO != 112");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MACRO 112
#endif
#if defined(KEY_MUTE) || (defined(HAVE_DECL_KEY_MUTE) && HAVE_DECL_KEY_MUTE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MUTE) == (113), "KEY_MUTE != 113");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MUTE 113
#endif
#if defined(KEY_VOLUMEDOWN) || (defined(HAVE_DECL_KEY_VOLUMEDOWN) && HAVE_DECL_KEY_VOLUMEDOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VOLUMEDOWN) == (114), "KEY_VOLUMEDOWN != 114");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VOLUMEDOWN 114
#endif
#if defined(KEY_VOLUMEUP) || (defined(HAVE_DECL_KEY_VOLUMEUP) && HAVE_DECL_KEY_VOLUMEUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VOLUMEUP) == (115), "KEY_VOLUMEUP != 115");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VOLUMEUP 115
#endif
#if defined(KEY_POWER) || (defined(HAVE_DECL_KEY_POWER) && HAVE_DECL_KEY_POWER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_POWER) == (116), "KEY_POWER != 116");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_POWER 116
#endif
#if defined(KEY_KPEQUAL) || (defined(HAVE_DECL_KEY_KPEQUAL) && HAVE_DECL_KEY_KPEQUAL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPEQUAL) == (117), "KEY_KPEQUAL != 117");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPEQUAL 117
#endif
#if defined(KEY_KPPLUSMINUS) || (defined(HAVE_DECL_KEY_KPPLUSMINUS) && HAVE_DECL_KEY_KPPLUSMINUS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPPLUSMINUS) == (118), "KEY_KPPLUSMINUS != 118");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPPLUSMINUS 118
#endif
#if defined(KEY_PAUSE) || (defined(HAVE_DECL_KEY_PAUSE) && HAVE_DECL_KEY_PAUSE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PAUSE) == (119), "KEY_PAUSE != 119");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PAUSE 119
#endif
#if defined(KEY_SCALE) || (defined(HAVE_DECL_KEY_SCALE) && HAVE_DECL_KEY_SCALE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SCALE) == (120), "KEY_SCALE != 120");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SCALE 120
#endif
#if defined(KEY_KPCOMMA) || (defined(HAVE_DECL_KEY_KPCOMMA) && HAVE_DECL_KEY_KPCOMMA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPCOMMA) == (121), "KEY_KPCOMMA != 121");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPCOMMA 121
#endif
#if defined(KEY_HANGEUL) || (defined(HAVE_DECL_KEY_HANGEUL) && HAVE_DECL_KEY_HANGEUL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_HANGEUL) == (122), "KEY_HANGEUL != 122");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_HANGEUL 122
#endif
#if defined(KEY_HANJA) || (defined(HAVE_DECL_KEY_HANJA) && HAVE_DECL_KEY_HANJA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_HANJA) == (123), "KEY_HANJA != 123");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_HANJA 123
#endif
#if defined(KEY_YEN) || (defined(HAVE_DECL_KEY_YEN) && HAVE_DECL_KEY_YEN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_YEN) == (124), "KEY_YEN != 124");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_YEN 124
#endif
#if defined(KEY_LEFTMETA) || (defined(HAVE_DECL_KEY_LEFTMETA) && HAVE_DECL_KEY_LEFTMETA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LEFTMETA) == (125), "KEY_LEFTMETA != 125");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LEFTMETA 125
#endif
#if defined(KEY_RIGHTMETA) || (defined(HAVE_DECL_KEY_RIGHTMETA) && HAVE_DECL_KEY_RIGHTMETA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RIGHTMETA) == (126), "KEY_RIGHTMETA != 126");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RIGHTMETA 126
#endif
#if defined(KEY_COMPOSE) || (defined(HAVE_DECL_KEY_COMPOSE) && HAVE_DECL_KEY_COMPOSE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_COMPOSE) == (127), "KEY_COMPOSE != 127");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_COMPOSE 127
#endif
#if defined(KEY_STOP) || (defined(HAVE_DECL_KEY_STOP) && HAVE_DECL_KEY_STOP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_STOP) == (128), "KEY_STOP != 128");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_STOP 128
#endif
#if defined(KEY_AGAIN) || (defined(HAVE_DECL_KEY_AGAIN) && HAVE_DECL_KEY_AGAIN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_AGAIN) == (129), "KEY_AGAIN != 129");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_AGAIN 129
#endif
#if defined(KEY_PROPS) || (defined(HAVE_DECL_KEY_PROPS) && HAVE_DECL_KEY_PROPS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PROPS) == (130), "KEY_PROPS != 130");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PROPS 130
#endif
#if defined(KEY_UNDO) || (defined(HAVE_DECL_KEY_UNDO) && HAVE_DECL_KEY_UNDO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_UNDO) == (131), "KEY_UNDO != 131");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_UNDO 131
#endif
#if defined(KEY_FRONT) || (defined(HAVE_DECL_KEY_FRONT) && HAVE_DECL_KEY_FRONT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FRONT) == (132), "KEY_FRONT != 132");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FRONT 132
#endif
#if defined(KEY_COPY) || (defined(HAVE_DECL_KEY_COPY) && HAVE_DECL_KEY_COPY)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_COPY) == (133), "KEY_COPY != 133");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_COPY 133
#endif
#if defined(KEY_OPEN) || (defined(HAVE_DECL_KEY_OPEN) && HAVE_DECL_KEY_OPEN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_OPEN) == (134), "KEY_OPEN != 134");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_OPEN 134
#endif
#if defined(KEY_PASTE) || (defined(HAVE_DECL_KEY_PASTE) && HAVE_DECL_KEY_PASTE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PASTE) == (135), "KEY_PASTE != 135");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PASTE 135
#endif
#if defined(KEY_FIND) || (defined(HAVE_DECL_KEY_FIND) && HAVE_DECL_KEY_FIND)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FIND) == (136), "KEY_FIND != 136");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FIND 136
#endif
#if defined(KEY_CUT) || (defined(HAVE_DECL_KEY_CUT) && HAVE_DECL_KEY_CUT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CUT) == (137), "KEY_CUT != 137");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CUT 137
#endif
#if defined(KEY_HELP) || (defined(HAVE_DECL_KEY_HELP) && HAVE_DECL_KEY_HELP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_HELP) == (138), "KEY_HELP != 138");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_HELP 138
#endif
#if defined(KEY_MENU) || (defined(HAVE_DECL_KEY_MENU) && HAVE_DECL_KEY_MENU)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MENU) == (139), "KEY_MENU != 139");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MENU 139
#endif
#if defined(KEY_CALC) || (defined(HAVE_DECL_KEY_CALC) && HAVE_DECL_KEY_CALC)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CALC) == (140), "KEY_CALC != 140");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CALC 140
#endif
#if defined(KEY_SETUP) || (defined(HAVE_DECL_KEY_SETUP) && HAVE_DECL_KEY_SETUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SETUP) == (141), "KEY_SETUP != 141");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SETUP 141
#endif
#if defined(KEY_SLEEP) || (defined(HAVE_DECL_KEY_SLEEP) && HAVE_DECL_KEY_SLEEP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SLEEP) == (142), "KEY_SLEEP != 142");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SLEEP 142
#endif
#if defined(KEY_WAKEUP) || (defined(HAVE_DECL_KEY_WAKEUP) && HAVE_DECL_KEY_WAKEUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_WAKEUP) == (143), "KEY_WAKEUP != 143");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_WAKEUP 143
#endif
#if defined(KEY_FILE) || (defined(HAVE_DECL_KEY_FILE) && HAVE_DECL_KEY_FILE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FILE) == (144), "KEY_FILE != 144");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FILE 144
#endif
#if defined(KEY_SENDFILE) || (defined(HAVE_DECL_KEY_SENDFILE) && HAVE_DECL_KEY_SENDFILE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SENDFILE) == (145), "KEY_SENDFILE != 145");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SENDFILE 145
#endif
#if defined(KEY_DELETEFILE) || (defined(HAVE_DECL_KEY_DELETEFILE) && HAVE_DECL_KEY_DELETEFILE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DELETEFILE) == (146), "KEY_DELETEFILE != 146");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DELETEFILE 146
#endif
#if defined(KEY_XFER) || (defined(HAVE_DECL_KEY_XFER) && HAVE_DECL_KEY_XFER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_XFER) == (147), "KEY_XFER != 147");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_XFER 147
#endif
#if defined(KEY_PROG1) || (defined(HAVE_DECL_KEY_PROG1) && HAVE_DECL_KEY_PROG1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PROG1) == (148), "KEY_PROG1 != 148");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PROG1 148
#endif
#if defined(KEY_PROG2) || (defined(HAVE_DECL_KEY_PROG2) && HAVE_DECL_KEY_PROG2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PROG2) == (149), "KEY_PROG2 != 149");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PROG2 149
#endif
#if defined(KEY_WWW) || (defined(HAVE_DECL_KEY_WWW) && HAVE_DECL_KEY_WWW)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_WWW) == (150), "KEY_WWW != 150");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_WWW 150
#endif
#if defined(KEY_MSDOS) || (defined(HAVE_DECL_KEY_MSDOS) && HAVE_DECL_KEY_MSDOS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MSDOS) == (151), "KEY_MSDOS != 151");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MSDOS 151
#endif
#if defined(KEY_COFFEE) || (defined(HAVE_DECL_KEY_COFFEE) && HAVE_DECL_KEY_COFFEE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_COFFEE) == (152), "KEY_COFFEE != 152");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_COFFEE 152
#endif
#if defined(KEY_ROTATE_DISPLAY) || (defined(HAVE_DECL_KEY_ROTATE_DISPLAY) && HAVE_DECL_KEY_ROTATE_DISPLAY)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ROTATE_DISPLAY) == (153), "KEY_ROTATE_DISPLAY != 153");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ROTATE_DISPLAY 153
#endif
#if defined(KEY_CYCLEWINDOWS) || (defined(HAVE_DECL_KEY_CYCLEWINDOWS) && HAVE_DECL_KEY_CYCLEWINDOWS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CYCLEWINDOWS) == (154), "KEY_CYCLEWINDOWS != 154");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CYCLEWINDOWS 154
#endif
#if defined(KEY_MAIL) || (defined(HAVE_DECL_KEY_MAIL) && HAVE_DECL_KEY_MAIL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MAIL) == (155), "KEY_MAIL != 155");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MAIL 155
#endif
#if defined(KEY_BOOKMARKS) || (defined(HAVE_DECL_KEY_BOOKMARKS) && HAVE_DECL_KEY_BOOKMARKS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BOOKMARKS) == (156), "KEY_BOOKMARKS != 156");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BOOKMARKS 156
#endif
#if defined(KEY_COMPUTER) || (defined(HAVE_DECL_KEY_COMPUTER) && HAVE_DECL_KEY_COMPUTER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_COMPUTER) == (157), "KEY_COMPUTER != 157");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_COMPUTER 157
#endif
#if defined(KEY_BACK) || (defined(HAVE_DECL_KEY_BACK) && HAVE_DECL_KEY_BACK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BACK) == (158), "KEY_BACK != 158");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BACK 158
#endif
#if defined(KEY_FORWARD) || (defined(HAVE_DECL_KEY_FORWARD) && HAVE_DECL_KEY_FORWARD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FORWARD) == (159), "KEY_FORWARD != 159");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FORWARD 159
#endif
#if defined(KEY_CLOSECD) || (defined(HAVE_DECL_KEY_CLOSECD) && HAVE_DECL_KEY_CLOSECD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CLOSECD) == (160), "KEY_CLOSECD != 160");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CLOSECD 160
#endif
#if defined(KEY_EJECTCD) || (defined(HAVE_DECL_KEY_EJECTCD) && HAVE_DECL_KEY_EJECTCD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_EJECTCD) == (161), "KEY_EJECTCD != 161");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_EJECTCD 161
#endif
#if defined(KEY_EJECTCLOSECD) || (defined(HAVE_DECL_KEY_EJECTCLOSECD) && HAVE_DECL_KEY_EJECTCLOSECD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_EJECTCLOSECD) == (162), "KEY_EJECTCLOSECD != 162");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_EJECTCLOSECD 162
#endif
#if defined(KEY_NEXTSONG) || (defined(HAVE_DECL_KEY_NEXTSONG) && HAVE_DECL_KEY_NEXTSONG)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NEXTSONG) == (163), "KEY_NEXTSONG != 163");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NEXTSONG 163
#endif
#if defined(KEY_PLAYPAUSE) || (defined(HAVE_DECL_KEY_PLAYPAUSE) && HAVE_DECL_KEY_PLAYPAUSE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PLAYPAUSE) == (164), "KEY_PLAYPAUSE != 164");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PLAYPAUSE 164
#endif
#if defined(KEY_PREVIOUSSONG) || (defined(HAVE_DECL_KEY_PREVIOUSSONG) && HAVE_DECL_KEY_PREVIOUSSONG)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PREVIOUSSONG) == (165), "KEY_PREVIOUSSONG != 165");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PREVIOUSSONG 165
#endif
#if defined(KEY_STOPCD) || (defined(HAVE_DECL_KEY_STOPCD) && HAVE_DECL_KEY_STOPCD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_STOPCD) == (166), "KEY_STOPCD != 166");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_STOPCD 166
#endif
#if defined(KEY_RECORD) || (defined(HAVE_DECL_KEY_RECORD) && HAVE_DECL_KEY_RECORD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RECORD) == (167), "KEY_RECORD != 167");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RECORD 167
#endif
#if defined(KEY_REWIND) || (defined(HAVE_DECL_KEY_REWIND) && HAVE_DECL_KEY_REWIND)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_REWIND) == (168), "KEY_REWIND != 168");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_REWIND 168
#endif
#if defined(KEY_PHONE) || (defined(HAVE_DECL_KEY_PHONE) && HAVE_DECL_KEY_PHONE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PHONE) == (169), "KEY_PHONE != 169");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PHONE 169
#endif
#if defined(KEY_ISO) || (defined(HAVE_DECL_KEY_ISO) && HAVE_DECL_KEY_ISO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ISO) == (170), "KEY_ISO != 170");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ISO 170
#endif
#if defined(KEY_CONFIG) || (defined(HAVE_DECL_KEY_CONFIG) && HAVE_DECL_KEY_CONFIG)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CONFIG) == (171), "KEY_CONFIG != 171");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CONFIG 171
#endif
#if defined(KEY_HOMEPAGE) || (defined(HAVE_DECL_KEY_HOMEPAGE) && HAVE_DECL_KEY_HOMEPAGE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_HOMEPAGE) == (172), "KEY_HOMEPAGE != 172");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_HOMEPAGE 172
#endif
#if defined(KEY_REFRESH) || (defined(HAVE_DECL_KEY_REFRESH) && HAVE_DECL_KEY_REFRESH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_REFRESH) == (173), "KEY_REFRESH != 173");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_REFRESH 173
#endif
#if defined(KEY_EXIT) || (defined(HAVE_DECL_KEY_EXIT) && HAVE_DECL_KEY_EXIT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_EXIT) == (174), "KEY_EXIT != 174");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_EXIT 174
#endif
#if defined(KEY_MOVE) || (defined(HAVE_DECL_KEY_MOVE) && HAVE_DECL_KEY_MOVE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MOVE) == (175), "KEY_MOVE != 175");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MOVE 175
#endif
#if defined(KEY_EDIT) || (defined(HAVE_DECL_KEY_EDIT) && HAVE_DECL_KEY_EDIT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_EDIT) == (176), "KEY_EDIT != 176");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_EDIT 176
#endif
#if defined(KEY_SCROLLUP) || (defined(HAVE_DECL_KEY_SCROLLUP) && HAVE_DECL_KEY_SCROLLUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SCROLLUP) == (177), "KEY_SCROLLUP != 177");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SCROLLUP 177
#endif
#if defined(KEY_SCROLLDOWN) || (defined(HAVE_DECL_KEY_SCROLLDOWN) && HAVE_DECL_KEY_SCROLLDOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SCROLLDOWN) == (178), "KEY_SCROLLDOWN != 178");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SCROLLDOWN 178
#endif
#if defined(KEY_KPLEFTPAREN) || (defined(HAVE_DECL_KEY_KPLEFTPAREN) && HAVE_DECL_KEY_KPLEFTPAREN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPLEFTPAREN) == (179), "KEY_KPLEFTPAREN != 179");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPLEFTPAREN 179
#endif
#if defined(KEY_KPRIGHTPAREN) || (defined(HAVE_DECL_KEY_KPRIGHTPAREN) && HAVE_DECL_KEY_KPRIGHTPAREN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KPRIGHTPAREN) == (180), "KEY_KPRIGHTPAREN != 180");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KPRIGHTPAREN 180
#endif
#if defined(KEY_NEW) || (defined(HAVE_DECL_KEY_NEW) && HAVE_DECL_KEY_NEW)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NEW) == (181), "KEY_NEW != 181");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NEW 181
#endif
#if defined(KEY_REDO) || (defined(HAVE_DECL_KEY_REDO) && HAVE_DECL_KEY_REDO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_REDO) == (182), "KEY_REDO != 182");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_REDO 182
#endif
#if defined(KEY_F13) || (defined(HAVE_DECL_KEY_F13) && HAVE_DECL_KEY_F13)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F13) == (183), "KEY_F13 != 183");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F13 183
#endif
#if defined(KEY_F14) || (defined(HAVE_DECL_KEY_F14) && HAVE_DECL_KEY_F14)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F14) == (184), "KEY_F14 != 184");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F14 184
#endif
#if defined(KEY_F15) || (defined(HAVE_DECL_KEY_F15) && HAVE_DECL_KEY_F15)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F15) == (185), "KEY_F15 != 185");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F15 185
#endif
#if defined(KEY_F16) || (defined(HAVE_DECL_KEY_F16) && HAVE_DECL_KEY_F16)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F16) == (186), "KEY_F16 != 186");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F16 186
#endif
#if defined(KEY_F17) || (defined(HAVE_DECL_KEY_F17) && HAVE_DECL_KEY_F17)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F17) == (187), "KEY_F17 != 187");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F17 187
#endif
#if defined(KEY_F18) || (defined(HAVE_DECL_KEY_F18) && HAVE_DECL_KEY_F18)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F18) == (188), "KEY_F18 != 188");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F18 188
#endif
#if defined(KEY_F19) || (defined(HAVE_DECL_KEY_F19) && HAVE_DECL_KEY_F19)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F19) == (189), "KEY_F19 != 189");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F19 189
#endif
#if defined(KEY_F20) || (defined(HAVE_DECL_KEY_F20) && HAVE_DECL_KEY_F20)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F20) == (190), "KEY_F20 != 190");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F20 190
#endif
#if defined(KEY_F21) || (defined(HAVE_DECL_KEY_F21) && HAVE_DECL_KEY_F21)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F21) == (191), "KEY_F21 != 191");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F21 191
#endif
#if defined(KEY_F22) || (defined(HAVE_DECL_KEY_F22) && HAVE_DECL_KEY_F22)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F22) == (192), "KEY_F22 != 192");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F22 192
#endif
#if defined(KEY_F23) || (defined(HAVE_DECL_KEY_F23) && HAVE_DECL_KEY_F23)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F23) == (193), "KEY_F23 != 193");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F23 193
#endif
#if defined(KEY_F24) || (defined(HAVE_DECL_KEY_F24) && HAVE_DECL_KEY_F24)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_F24) == (194), "KEY_F24 != 194");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_F24 194
#endif
#if defined(KEY_PLAYCD) || (defined(HAVE_DECL_KEY_PLAYCD) && HAVE_DECL_KEY_PLAYCD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PLAYCD) == (200), "KEY_PLAYCD != 200");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PLAYCD 200
#endif
#if defined(KEY_PAUSECD) || (defined(HAVE_DECL_KEY_PAUSECD) && HAVE_DECL_KEY_PAUSECD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PAUSECD) == (201), "KEY_PAUSECD != 201");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PAUSECD 201
#endif
#if defined(KEY_PROG3) || (defined(HAVE_DECL_KEY_PROG3) && HAVE_DECL_KEY_PROG3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PROG3) == (202), "KEY_PROG3 != 202");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PROG3 202
#endif
#if defined(KEY_PROG4) || (defined(HAVE_DECL_KEY_PROG4) && HAVE_DECL_KEY_PROG4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PROG4) == (203), "KEY_PROG4 != 203");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PROG4 203
#endif
#if defined(KEY_DASHBOARD) || (defined(HAVE_DECL_KEY_DASHBOARD) && HAVE_DECL_KEY_DASHBOARD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DASHBOARD) == (204), "KEY_DASHBOARD != 204");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DASHBOARD 204
#endif
#if defined(KEY_SUSPEND) || (defined(HAVE_DECL_KEY_SUSPEND) && HAVE_DECL_KEY_SUSPEND)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SUSPEND) == (205), "KEY_SUSPEND != 205");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SUSPEND 205
#endif
#if defined(KEY_CLOSE) || (defined(HAVE_DECL_KEY_CLOSE) && HAVE_DECL_KEY_CLOSE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CLOSE) == (206), "KEY_CLOSE != 206");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CLOSE 206
#endif
#if defined(KEY_PLAY) || (defined(HAVE_DECL_KEY_PLAY) && HAVE_DECL_KEY_PLAY)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PLAY) == (207), "KEY_PLAY != 207");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PLAY 207
#endif
#if defined(KEY_FASTFORWARD) || (defined(HAVE_DECL_KEY_FASTFORWARD) && HAVE_DECL_KEY_FASTFORWARD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FASTFORWARD) == (208), "KEY_FASTFORWARD != 208");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FASTFORWARD 208
#endif
#if defined(KEY_BASSBOOST) || (defined(HAVE_DECL_KEY_BASSBOOST) && HAVE_DECL_KEY_BASSBOOST)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BASSBOOST) == (209), "KEY_BASSBOOST != 209");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BASSBOOST 209
#endif
#if defined(KEY_PRINT) || (defined(HAVE_DECL_KEY_PRINT) && HAVE_DECL_KEY_PRINT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PRINT) == (210), "KEY_PRINT != 210");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PRINT 210
#endif
#if defined(KEY_HP) || (defined(HAVE_DECL_KEY_HP) && HAVE_DECL_KEY_HP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_HP) == (211), "KEY_HP != 211");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_HP 211
#endif
#if defined(KEY_CAMERA) || (defined(HAVE_DECL_KEY_CAMERA) && HAVE_DECL_KEY_CAMERA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CAMERA) == (212), "KEY_CAMERA != 212");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CAMERA 212
#endif
#if defined(KEY_SOUND) || (defined(HAVE_DECL_KEY_SOUND) && HAVE_DECL_KEY_SOUND)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SOUND) == (213), "KEY_SOUND != 213");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SOUND 213
#endif
#if defined(KEY_QUESTION) || (defined(HAVE_DECL_KEY_QUESTION) && HAVE_DECL_KEY_QUESTION)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_QUESTION) == (214), "KEY_QUESTION != 214");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_QUESTION 214
#endif
#if defined(KEY_EMAIL) || (defined(HAVE_DECL_KEY_EMAIL) && HAVE_DECL_KEY_EMAIL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_EMAIL) == (215), "KEY_EMAIL != 215");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_EMAIL 215
#endif
#if defined(KEY_CHAT) || (defined(HAVE_DECL_KEY_CHAT) && HAVE_DECL_KEY_CHAT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CHAT) == (216), "KEY_CHAT != 216");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CHAT 216
#endif
#if defined(KEY_SEARCH) || (defined(HAVE_DECL_KEY_SEARCH) && HAVE_DECL_KEY_SEARCH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SEARCH) == (217), "KEY_SEARCH != 217");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SEARCH 217
#endif
#if defined(KEY_CONNECT) || (defined(HAVE_DECL_KEY_CONNECT) && HAVE_DECL_KEY_CONNECT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CONNECT) == (218), "KEY_CONNECT != 218");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CONNECT 218
#endif
#if defined(KEY_FINANCE) || (defined(HAVE_DECL_KEY_FINANCE) && HAVE_DECL_KEY_FINANCE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FINANCE) == (219), "KEY_FINANCE != 219");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FINANCE 219
#endif
#if defined(KEY_SPORT) || (defined(HAVE_DECL_KEY_SPORT) && HAVE_DECL_KEY_SPORT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SPORT) == (220), "KEY_SPORT != 220");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SPORT 220
#endif
#if defined(KEY_SHOP) || (defined(HAVE_DECL_KEY_SHOP) && HAVE_DECL_KEY_SHOP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SHOP) == (221), "KEY_SHOP != 221");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SHOP 221
#endif
#if defined(KEY_ALTERASE) || (defined(HAVE_DECL_KEY_ALTERASE) && HAVE_DECL_KEY_ALTERASE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ALTERASE) == (222), "KEY_ALTERASE != 222");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ALTERASE 222
#endif
#if defined(KEY_CANCEL) || (defined(HAVE_DECL_KEY_CANCEL) && HAVE_DECL_KEY_CANCEL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CANCEL) == (223), "KEY_CANCEL != 223");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CANCEL 223
#endif
#if defined(KEY_BRIGHTNESSDOWN) || (defined(HAVE_DECL_KEY_BRIGHTNESSDOWN) && HAVE_DECL_KEY_BRIGHTNESSDOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRIGHTNESSDOWN) == (224), "KEY_BRIGHTNESSDOWN != 224");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRIGHTNESSDOWN 224
#endif
#if defined(KEY_BRIGHTNESSUP) || (defined(HAVE_DECL_KEY_BRIGHTNESSUP) && HAVE_DECL_KEY_BRIGHTNESSUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRIGHTNESSUP) == (225), "KEY_BRIGHTNESSUP != 225");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRIGHTNESSUP 225
#endif
#if defined(KEY_MEDIA) || (defined(HAVE_DECL_KEY_MEDIA) && HAVE_DECL_KEY_MEDIA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MEDIA) == (226), "KEY_MEDIA != 226");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MEDIA 226
#endif
#if defined(KEY_SWITCHVIDEOMODE) || (defined(HAVE_DECL_KEY_SWITCHVIDEOMODE) && HAVE_DECL_KEY_SWITCHVIDEOMODE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SWITCHVIDEOMODE) == (227), "KEY_SWITCHVIDEOMODE != 227");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SWITCHVIDEOMODE 227
#endif
#if defined(KEY_KBDILLUMTOGGLE) || (defined(HAVE_DECL_KEY_KBDILLUMTOGGLE) && HAVE_DECL_KEY_KBDILLUMTOGGLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KBDILLUMTOGGLE) == (228), "KEY_KBDILLUMTOGGLE != 228");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KBDILLUMTOGGLE 228
#endif
#if defined(KEY_KBDILLUMDOWN) || (defined(HAVE_DECL_KEY_KBDILLUMDOWN) && HAVE_DECL_KEY_KBDILLUMDOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KBDILLUMDOWN) == (229), "KEY_KBDILLUMDOWN != 229");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KBDILLUMDOWN 229
#endif
#if defined(KEY_KBDILLUMUP) || (defined(HAVE_DECL_KEY_KBDILLUMUP) && HAVE_DECL_KEY_KBDILLUMUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KBDILLUMUP) == (230), "KEY_KBDILLUMUP != 230");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KBDILLUMUP 230
#endif
#if defined(KEY_SEND) || (defined(HAVE_DECL_KEY_SEND) && HAVE_DECL_KEY_SEND)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SEND) == (231), "KEY_SEND != 231");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SEND 231
#endif
#if defined(KEY_REPLY) || (defined(HAVE_DECL_KEY_REPLY) && HAVE_DECL_KEY_REPLY)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_REPLY) == (232), "KEY_REPLY != 232");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_REPLY 232
#endif
#if defined(KEY_FORWARDMAIL) || (defined(HAVE_DECL_KEY_FORWARDMAIL) && HAVE_DECL_KEY_FORWARDMAIL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FORWARDMAIL) == (233), "KEY_FORWARDMAIL != 233");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FORWARDMAIL 233
#endif
#if defined(KEY_SAVE) || (defined(HAVE_DECL_KEY_SAVE) && HAVE_DECL_KEY_SAVE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SAVE) == (234), "KEY_SAVE != 234");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SAVE 234
#endif
#if defined(KEY_DOCUMENTS) || (defined(HAVE_DECL_KEY_DOCUMENTS) && HAVE_DECL_KEY_DOCUMENTS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DOCUMENTS) == (235), "KEY_DOCUMENTS != 235");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DOCUMENTS 235
#endif
#if defined(KEY_BATTERY) || (defined(HAVE_DECL_KEY_BATTERY) && HAVE_DECL_KEY_BATTERY)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BATTERY) == (236), "KEY_BATTERY != 236");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BATTERY 236
#endif
#if defined(KEY_BLUETOOTH) || (defined(HAVE_DECL_KEY_BLUETOOTH) && HAVE_DECL_KEY_BLUETOOTH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BLUETOOTH) == (237), "KEY_BLUETOOTH != 237");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BLUETOOTH 237
#endif
#if defined(KEY_WLAN) || (defined(HAVE_DECL_KEY_WLAN) && HAVE_DECL_KEY_WLAN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_WLAN) == (238), "KEY_WLAN != 238");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_WLAN 238
#endif
#if defined(KEY_UWB) || (defined(HAVE_DECL_KEY_UWB) && HAVE_DECL_KEY_UWB)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_UWB) == (239), "KEY_UWB != 239");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_UWB 239
#endif
#if defined(KEY_UNKNOWN) || (defined(HAVE_DECL_KEY_UNKNOWN) && HAVE_DECL_KEY_UNKNOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_UNKNOWN) == (240), "KEY_UNKNOWN != 240");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_UNKNOWN 240
#endif
#if defined(KEY_VIDEO_NEXT) || (defined(HAVE_DECL_KEY_VIDEO_NEXT) && HAVE_DECL_KEY_VIDEO_NEXT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VIDEO_NEXT) == (241), "KEY_VIDEO_NEXT != 241");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VIDEO_NEXT 241
#endif
#if defined(KEY_VIDEO_PREV) || (defined(HAVE_DECL_KEY_VIDEO_PREV) && HAVE_DECL_KEY_VIDEO_PREV)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VIDEO_PREV) == (242), "KEY_VIDEO_PREV != 242");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VIDEO_PREV 242
#endif
#if defined(KEY_BRIGHTNESS_CYCLE) || (defined(HAVE_DECL_KEY_BRIGHTNESS_CYCLE) && HAVE_DECL_KEY_BRIGHTNESS_CYCLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRIGHTNESS_CYCLE) == (243), "KEY_BRIGHTNESS_CYCLE != 243");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRIGHTNESS_CYCLE 243
#endif
#if defined(KEY_BRIGHTNESS_AUTO) || (defined(HAVE_DECL_KEY_BRIGHTNESS_AUTO) && HAVE_DECL_KEY_BRIGHTNESS_AUTO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRIGHTNESS_AUTO) == (244), "KEY_BRIGHTNESS_AUTO != 244");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRIGHTNESS_AUTO 244
#endif
#if defined(KEY_DISPLAY_OFF) || (defined(HAVE_DECL_KEY_DISPLAY_OFF) && HAVE_DECL_KEY_DISPLAY_OFF)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DISPLAY_OFF) == (245), "KEY_DISPLAY_OFF != 245");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DISPLAY_OFF 245
#endif
#if defined(KEY_WWAN) || (defined(HAVE_DECL_KEY_WWAN) && HAVE_DECL_KEY_WWAN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_WWAN) == (246), "KEY_WWAN != 246");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_WWAN 246
#endif
#ifndef STRACE_WORKAROUND_FOR_KEY_RFKILL
# define STRACE_WORKAROUND_FOR_KEY_RFKILL
# undef KEY_RFKILL
#endif
#if defined(KEY_RFKILL) || (defined(HAVE_DECL_KEY_RFKILL) && HAVE_DECL_KEY_RFKILL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RFKILL) == (247), "KEY_RFKILL != 247");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RFKILL 247
#endif
#if defined(KEY_MICMUTE) || (defined(HAVE_DECL_KEY_MICMUTE) && HAVE_DECL_KEY_MICMUTE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MICMUTE) == (248), "KEY_MICMUTE != 248");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MICMUTE 248
#endif
#if defined(BTN_0) || (defined(HAVE_DECL_BTN_0) && HAVE_DECL_BTN_0)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_0) == (0x100), "BTN_0 != 0x100");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_0 0x100
#endif
#if defined(BTN_1) || (defined(HAVE_DECL_BTN_1) && HAVE_DECL_BTN_1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_1) == (0x101), "BTN_1 != 0x101");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_1 0x101
#endif
#if defined(BTN_2) || (defined(HAVE_DECL_BTN_2) && HAVE_DECL_BTN_2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_2) == (0x102), "BTN_2 != 0x102");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_2 0x102
#endif
#if defined(BTN_3) || (defined(HAVE_DECL_BTN_3) && HAVE_DECL_BTN_3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_3) == (0x103), "BTN_3 != 0x103");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_3 0x103
#endif
#if defined(BTN_4) || (defined(HAVE_DECL_BTN_4) && HAVE_DECL_BTN_4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_4) == (0x104), "BTN_4 != 0x104");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_4 0x104
#endif
#if defined(BTN_5) || (defined(HAVE_DECL_BTN_5) && HAVE_DECL_BTN_5)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_5) == (0x105), "BTN_5 != 0x105");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_5 0x105
#endif
#if defined(BTN_6) || (defined(HAVE_DECL_BTN_6) && HAVE_DECL_BTN_6)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_6) == (0x106), "BTN_6 != 0x106");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_6 0x106
#endif
#if defined(BTN_7) || (defined(HAVE_DECL_BTN_7) && HAVE_DECL_BTN_7)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_7) == (0x107), "BTN_7 != 0x107");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_7 0x107
#endif
#if defined(BTN_8) || (defined(HAVE_DECL_BTN_8) && HAVE_DECL_BTN_8)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_8) == (0x108), "BTN_8 != 0x108");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_8 0x108
#endif
#if defined(BTN_9) || (defined(HAVE_DECL_BTN_9) && HAVE_DECL_BTN_9)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_9) == (0x109), "BTN_9 != 0x109");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_9 0x109
#endif
#if defined(BTN_LEFT) || (defined(HAVE_DECL_BTN_LEFT) && HAVE_DECL_BTN_LEFT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_LEFT) == (0x110), "BTN_LEFT != 0x110");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_LEFT 0x110
#endif
#if defined(BTN_RIGHT) || (defined(HAVE_DECL_BTN_RIGHT) && HAVE_DECL_BTN_RIGHT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_RIGHT) == (0x111), "BTN_RIGHT != 0x111");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_RIGHT 0x111
#endif
#if defined(BTN_MIDDLE) || (defined(HAVE_DECL_BTN_MIDDLE) && HAVE_DECL_BTN_MIDDLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_MIDDLE) == (0x112), "BTN_MIDDLE != 0x112");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_MIDDLE 0x112
#endif
#if defined(BTN_SIDE) || (defined(HAVE_DECL_BTN_SIDE) && HAVE_DECL_BTN_SIDE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_SIDE) == (0x113), "BTN_SIDE != 0x113");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_SIDE 0x113
#endif
#if defined(BTN_EXTRA) || (defined(HAVE_DECL_BTN_EXTRA) && HAVE_DECL_BTN_EXTRA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_EXTRA) == (0x114), "BTN_EXTRA != 0x114");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_EXTRA 0x114
#endif
#if defined(BTN_FORWARD) || (defined(HAVE_DECL_BTN_FORWARD) && HAVE_DECL_BTN_FORWARD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_FORWARD) == (0x115), "BTN_FORWARD != 0x115");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_FORWARD 0x115
#endif
#if defined(BTN_BACK) || (defined(HAVE_DECL_BTN_BACK) && HAVE_DECL_BTN_BACK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_BACK) == (0x116), "BTN_BACK != 0x116");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_BACK 0x116
#endif
#if defined(BTN_TASK) || (defined(HAVE_DECL_BTN_TASK) && HAVE_DECL_BTN_TASK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TASK) == (0x117), "BTN_TASK != 0x117");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TASK 0x117
#endif
#if defined(BTN_TRIGGER) || (defined(HAVE_DECL_BTN_TRIGGER) && HAVE_DECL_BTN_TRIGGER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER) == (0x120), "BTN_TRIGGER != 0x120");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER 0x120
#endif
#if defined(BTN_THUMB) || (defined(HAVE_DECL_BTN_THUMB) && HAVE_DECL_BTN_THUMB)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_THUMB) == (0x121), "BTN_THUMB != 0x121");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_THUMB 0x121
#endif
#if defined(BTN_THUMB2) || (defined(HAVE_DECL_BTN_THUMB2) && HAVE_DECL_BTN_THUMB2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_THUMB2) == (0x122), "BTN_THUMB2 != 0x122");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_THUMB2 0x122
#endif
#if defined(BTN_TOP) || (defined(HAVE_DECL_BTN_TOP) && HAVE_DECL_BTN_TOP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOP) == (0x123), "BTN_TOP != 0x123");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOP 0x123
#endif
#if defined(BTN_TOP2) || (defined(HAVE_DECL_BTN_TOP2) && HAVE_DECL_BTN_TOP2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOP2) == (0x124), "BTN_TOP2 != 0x124");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOP2 0x124
#endif
#if defined(BTN_PINKIE) || (defined(HAVE_DECL_BTN_PINKIE) && HAVE_DECL_BTN_PINKIE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_PINKIE) == (0x125), "BTN_PINKIE != 0x125");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_PINKIE 0x125
#endif
#if defined(BTN_BASE) || (defined(HAVE_DECL_BTN_BASE) && HAVE_DECL_BTN_BASE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_BASE) == (0x126), "BTN_BASE != 0x126");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_BASE 0x126
#endif
#if defined(BTN_BASE2) || (defined(HAVE_DECL_BTN_BASE2) && HAVE_DECL_BTN_BASE2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_BASE2) == (0x127), "BTN_BASE2 != 0x127");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_BASE2 0x127
#endif
#if defined(BTN_BASE3) || (defined(HAVE_DECL_BTN_BASE3) && HAVE_DECL_BTN_BASE3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_BASE3) == (0x128), "BTN_BASE3 != 0x128");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_BASE3 0x128
#endif
#if defined(BTN_BASE4) || (defined(HAVE_DECL_BTN_BASE4) && HAVE_DECL_BTN_BASE4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_BASE4) == (0x129), "BTN_BASE4 != 0x129");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_BASE4 0x129
#endif
#if defined(BTN_BASE5) || (defined(HAVE_DECL_BTN_BASE5) && HAVE_DECL_BTN_BASE5)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_BASE5) == (0x12a), "BTN_BASE5 != 0x12a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_BASE5 0x12a
#endif
#if defined(BTN_BASE6) || (defined(HAVE_DECL_BTN_BASE6) && HAVE_DECL_BTN_BASE6)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_BASE6) == (0x12b), "BTN_BASE6 != 0x12b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_BASE6 0x12b
#endif
#if defined(BTN_DEAD) || (defined(HAVE_DECL_BTN_DEAD) && HAVE_DECL_BTN_DEAD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_DEAD) == (0x12f), "BTN_DEAD != 0x12f");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_DEAD 0x12f
#endif
#if defined(BTN_SOUTH) || (defined(HAVE_DECL_BTN_SOUTH) && HAVE_DECL_BTN_SOUTH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_SOUTH) == (0x130), "BTN_SOUTH != 0x130");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_SOUTH 0x130
#endif
#if defined(BTN_EAST) || (defined(HAVE_DECL_BTN_EAST) && HAVE_DECL_BTN_EAST)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_EAST) == (0x131), "BTN_EAST != 0x131");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_EAST 0x131
#endif
#if defined(BTN_C) || (defined(HAVE_DECL_BTN_C) && HAVE_DECL_BTN_C)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_C) == (0x132), "BTN_C != 0x132");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_C 0x132
#endif
#if defined(BTN_NORTH) || (defined(HAVE_DECL_BTN_NORTH) && HAVE_DECL_BTN_NORTH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_NORTH) == (0x133), "BTN_NORTH != 0x133");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_NORTH 0x133
#endif
#if defined(BTN_WEST) || (defined(HAVE_DECL_BTN_WEST) && HAVE_DECL_BTN_WEST)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_WEST) == (0x134), "BTN_WEST != 0x134");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_WEST 0x134
#endif
#if defined(BTN_Z) || (defined(HAVE_DECL_BTN_Z) && HAVE_DECL_BTN_Z)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_Z) == (0x135), "BTN_Z != 0x135");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_Z 0x135
#endif
#if defined(BTN_TL) || (defined(HAVE_DECL_BTN_TL) && HAVE_DECL_BTN_TL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TL) == (0x136), "BTN_TL != 0x136");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TL 0x136
#endif
#if defined(BTN_TR) || (defined(HAVE_DECL_BTN_TR) && HAVE_DECL_BTN_TR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TR) == (0x137), "BTN_TR != 0x137");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TR 0x137
#endif
#if defined(BTN_TL2) || (defined(HAVE_DECL_BTN_TL2) && HAVE_DECL_BTN_TL2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TL2) == (0x138), "BTN_TL2 != 0x138");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TL2 0x138
#endif
#if defined(BTN_TR2) || (defined(HAVE_DECL_BTN_TR2) && HAVE_DECL_BTN_TR2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TR2) == (0x139), "BTN_TR2 != 0x139");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TR2 0x139
#endif
#if defined(BTN_SELECT) || (defined(HAVE_DECL_BTN_SELECT) && HAVE_DECL_BTN_SELECT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_SELECT) == (0x13a), "BTN_SELECT != 0x13a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_SELECT 0x13a
#endif
#if defined(BTN_START) || (defined(HAVE_DECL_BTN_START) && HAVE_DECL_BTN_START)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_START) == (0x13b), "BTN_START != 0x13b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_START 0x13b
#endif
#if defined(BTN_MODE) || (defined(HAVE_DECL_BTN_MODE) && HAVE_DECL_BTN_MODE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_MODE) == (0x13c), "BTN_MODE != 0x13c");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_MODE 0x13c
#endif
#if defined(BTN_THUMBL) || (defined(HAVE_DECL_BTN_THUMBL) && HAVE_DECL_BTN_THUMBL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_THUMBL) == (0x13d), "BTN_THUMBL != 0x13d");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_THUMBL 0x13d
#endif
#if defined(BTN_THUMBR) || (defined(HAVE_DECL_BTN_THUMBR) && HAVE_DECL_BTN_THUMBR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_THUMBR) == (0x13e), "BTN_THUMBR != 0x13e");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_THUMBR 0x13e
#endif
#if defined(BTN_TOOL_PEN) || (defined(HAVE_DECL_BTN_TOOL_PEN) && HAVE_DECL_BTN_TOOL_PEN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_PEN) == (0x140), "BTN_TOOL_PEN != 0x140");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_PEN 0x140
#endif
#if defined(BTN_TOOL_RUBBER) || (defined(HAVE_DECL_BTN_TOOL_RUBBER) && HAVE_DECL_BTN_TOOL_RUBBER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_RUBBER) == (0x141), "BTN_TOOL_RUBBER != 0x141");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_RUBBER 0x141
#endif
#if defined(BTN_TOOL_BRUSH) || (defined(HAVE_DECL_BTN_TOOL_BRUSH) && HAVE_DECL_BTN_TOOL_BRUSH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_BRUSH) == (0x142), "BTN_TOOL_BRUSH != 0x142");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_BRUSH 0x142
#endif
#if defined(BTN_TOOL_PENCIL) || (defined(HAVE_DECL_BTN_TOOL_PENCIL) && HAVE_DECL_BTN_TOOL_PENCIL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_PENCIL) == (0x143), "BTN_TOOL_PENCIL != 0x143");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_PENCIL 0x143
#endif
#if defined(BTN_TOOL_AIRBRUSH) || (defined(HAVE_DECL_BTN_TOOL_AIRBRUSH) && HAVE_DECL_BTN_TOOL_AIRBRUSH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_AIRBRUSH) == (0x144), "BTN_TOOL_AIRBRUSH != 0x144");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_AIRBRUSH 0x144
#endif
#if defined(BTN_TOOL_FINGER) || (defined(HAVE_DECL_BTN_TOOL_FINGER) && HAVE_DECL_BTN_TOOL_FINGER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_FINGER) == (0x145), "BTN_TOOL_FINGER != 0x145");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_FINGER 0x145
#endif
#if defined(BTN_TOOL_MOUSE) || (defined(HAVE_DECL_BTN_TOOL_MOUSE) && HAVE_DECL_BTN_TOOL_MOUSE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_MOUSE) == (0x146), "BTN_TOOL_MOUSE != 0x146");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_MOUSE 0x146
#endif
#if defined(BTN_TOOL_LENS) || (defined(HAVE_DECL_BTN_TOOL_LENS) && HAVE_DECL_BTN_TOOL_LENS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_LENS) == (0x147), "BTN_TOOL_LENS != 0x147");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_LENS 0x147
#endif
#if defined(BTN_TOOL_QUINTTAP) || (defined(HAVE_DECL_BTN_TOOL_QUINTTAP) && HAVE_DECL_BTN_TOOL_QUINTTAP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_QUINTTAP) == (0x148), "BTN_TOOL_QUINTTAP != 0x148");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_QUINTTAP 0x148
#endif
#if defined(BTN_STYLUS3) || (defined(HAVE_DECL_BTN_STYLUS3) && HAVE_DECL_BTN_STYLUS3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_STYLUS3) == (0x149), "BTN_STYLUS3 != 0x149");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_STYLUS3 0x149
#endif
#if defined(BTN_TOUCH) || (defined(HAVE_DECL_BTN_TOUCH) && HAVE_DECL_BTN_TOUCH)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOUCH) == (0x14a), "BTN_TOUCH != 0x14a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOUCH 0x14a
#endif
#if defined(BTN_STYLUS) || (defined(HAVE_DECL_BTN_STYLUS) && HAVE_DECL_BTN_STYLUS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_STYLUS) == (0x14b), "BTN_STYLUS != 0x14b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_STYLUS 0x14b
#endif
#if defined(BTN_STYLUS2) || (defined(HAVE_DECL_BTN_STYLUS2) && HAVE_DECL_BTN_STYLUS2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_STYLUS2) == (0x14c), "BTN_STYLUS2 != 0x14c");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_STYLUS2 0x14c
#endif
#if defined(BTN_TOOL_DOUBLETAP) || (defined(HAVE_DECL_BTN_TOOL_DOUBLETAP) && HAVE_DECL_BTN_TOOL_DOUBLETAP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_DOUBLETAP) == (0x14d), "BTN_TOOL_DOUBLETAP != 0x14d");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_DOUBLETAP 0x14d
#endif
#if defined(BTN_TOOL_TRIPLETAP) || (defined(HAVE_DECL_BTN_TOOL_TRIPLETAP) && HAVE_DECL_BTN_TOOL_TRIPLETAP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_TRIPLETAP) == (0x14e), "BTN_TOOL_TRIPLETAP != 0x14e");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_TRIPLETAP 0x14e
#endif
#if defined(BTN_TOOL_QUADTAP) || (defined(HAVE_DECL_BTN_TOOL_QUADTAP) && HAVE_DECL_BTN_TOOL_QUADTAP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TOOL_QUADTAP) == (0x14f), "BTN_TOOL_QUADTAP != 0x14f");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TOOL_QUADTAP 0x14f
#endif
#if defined(BTN_GEAR_DOWN) || (defined(HAVE_DECL_BTN_GEAR_DOWN) && HAVE_DECL_BTN_GEAR_DOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_GEAR_DOWN) == (0x150), "BTN_GEAR_DOWN != 0x150");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_GEAR_DOWN 0x150
#endif
#if defined(BTN_GEAR_UP) || (defined(HAVE_DECL_BTN_GEAR_UP) && HAVE_DECL_BTN_GEAR_UP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_GEAR_UP) == (0x151), "BTN_GEAR_UP != 0x151");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_GEAR_UP 0x151
#endif
#if defined(KEY_OK) || (defined(HAVE_DECL_KEY_OK) && HAVE_DECL_KEY_OK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_OK) == (0x160), "KEY_OK != 0x160");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_OK 0x160
#endif
#if defined(KEY_SELECT) || (defined(HAVE_DECL_KEY_SELECT) && HAVE_DECL_KEY_SELECT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SELECT) == (0x161), "KEY_SELECT != 0x161");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SELECT 0x161
#endif
#if defined(KEY_GOTO) || (defined(HAVE_DECL_KEY_GOTO) && HAVE_DECL_KEY_GOTO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_GOTO) == (0x162), "KEY_GOTO != 0x162");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_GOTO 0x162
#endif
#if defined(KEY_CLEAR) || (defined(HAVE_DECL_KEY_CLEAR) && HAVE_DECL_KEY_CLEAR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CLEAR) == (0x163), "KEY_CLEAR != 0x163");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CLEAR 0x163
#endif
#if defined(KEY_POWER2) || (defined(HAVE_DECL_KEY_POWER2) && HAVE_DECL_KEY_POWER2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_POWER2) == (0x164), "KEY_POWER2 != 0x164");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_POWER2 0x164
#endif
#if defined(KEY_OPTION) || (defined(HAVE_DECL_KEY_OPTION) && HAVE_DECL_KEY_OPTION)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_OPTION) == (0x165), "KEY_OPTION != 0x165");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_OPTION 0x165
#endif
#if defined(KEY_INFO) || (defined(HAVE_DECL_KEY_INFO) && HAVE_DECL_KEY_INFO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_INFO) == (0x166), "KEY_INFO != 0x166");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_INFO 0x166
#endif
#if defined(KEY_TIME) || (defined(HAVE_DECL_KEY_TIME) && HAVE_DECL_KEY_TIME)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TIME) == (0x167), "KEY_TIME != 0x167");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TIME 0x167
#endif
#if defined(KEY_VENDOR) || (defined(HAVE_DECL_KEY_VENDOR) && HAVE_DECL_KEY_VENDOR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VENDOR) == (0x168), "KEY_VENDOR != 0x168");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VENDOR 0x168
#endif
#if defined(KEY_ARCHIVE) || (defined(HAVE_DECL_KEY_ARCHIVE) && HAVE_DECL_KEY_ARCHIVE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ARCHIVE) == (0x169), "KEY_ARCHIVE != 0x169");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ARCHIVE 0x169
#endif
#if defined(KEY_PROGRAM) || (defined(HAVE_DECL_KEY_PROGRAM) && HAVE_DECL_KEY_PROGRAM)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PROGRAM) == (0x16a), "KEY_PROGRAM != 0x16a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PROGRAM 0x16a
#endif
#if defined(KEY_CHANNEL) || (defined(HAVE_DECL_KEY_CHANNEL) && HAVE_DECL_KEY_CHANNEL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CHANNEL) == (0x16b), "KEY_CHANNEL != 0x16b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CHANNEL 0x16b
#endif
#if defined(KEY_FAVORITES) || (defined(HAVE_DECL_KEY_FAVORITES) && HAVE_DECL_KEY_FAVORITES)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FAVORITES) == (0x16c), "KEY_FAVORITES != 0x16c");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FAVORITES 0x16c
#endif
#if defined(KEY_EPG) || (defined(HAVE_DECL_KEY_EPG) && HAVE_DECL_KEY_EPG)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_EPG) == (0x16d), "KEY_EPG != 0x16d");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_EPG 0x16d
#endif
#if defined(KEY_PVR) || (defined(HAVE_DECL_KEY_PVR) && HAVE_DECL_KEY_PVR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PVR) == (0x16e), "KEY_PVR != 0x16e");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PVR 0x16e
#endif
#if defined(KEY_MHP) || (defined(HAVE_DECL_KEY_MHP) && HAVE_DECL_KEY_MHP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MHP) == (0x16f), "KEY_MHP != 0x16f");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MHP 0x16f
#endif
#if defined(KEY_LANGUAGE) || (defined(HAVE_DECL_KEY_LANGUAGE) && HAVE_DECL_KEY_LANGUAGE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LANGUAGE) == (0x170), "KEY_LANGUAGE != 0x170");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LANGUAGE 0x170
#endif
#if defined(KEY_TITLE) || (defined(HAVE_DECL_KEY_TITLE) && HAVE_DECL_KEY_TITLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TITLE) == (0x171), "KEY_TITLE != 0x171");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TITLE 0x171
#endif
#if defined(KEY_SUBTITLE) || (defined(HAVE_DECL_KEY_SUBTITLE) && HAVE_DECL_KEY_SUBTITLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SUBTITLE) == (0x172), "KEY_SUBTITLE != 0x172");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SUBTITLE 0x172
#endif
#if defined(KEY_ANGLE) || (defined(HAVE_DECL_KEY_ANGLE) && HAVE_DECL_KEY_ANGLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ANGLE) == (0x173), "KEY_ANGLE != 0x173");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ANGLE 0x173
#endif
#if defined(KEY_ZOOM) || (defined(HAVE_DECL_KEY_ZOOM) && HAVE_DECL_KEY_ZOOM)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ZOOM) == (0x174), "KEY_ZOOM != 0x174");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ZOOM 0x174
#endif
#if defined(KEY_MODE) || (defined(HAVE_DECL_KEY_MODE) && HAVE_DECL_KEY_MODE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MODE) == (0x175), "KEY_MODE != 0x175");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MODE 0x175
#endif
#if defined(KEY_KEYBOARD) || (defined(HAVE_DECL_KEY_KEYBOARD) && HAVE_DECL_KEY_KEYBOARD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KEYBOARD) == (0x176), "KEY_KEYBOARD != 0x176");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KEYBOARD 0x176
#endif
#if defined(KEY_SCREEN) || (defined(HAVE_DECL_KEY_SCREEN) && HAVE_DECL_KEY_SCREEN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SCREEN) == (0x177), "KEY_SCREEN != 0x177");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SCREEN 0x177
#endif
#if defined(KEY_PC) || (defined(HAVE_DECL_KEY_PC) && HAVE_DECL_KEY_PC)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PC) == (0x178), "KEY_PC != 0x178");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PC 0x178
#endif
#if defined(KEY_TV) || (defined(HAVE_DECL_KEY_TV) && HAVE_DECL_KEY_TV)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TV) == (0x179), "KEY_TV != 0x179");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TV 0x179
#endif
#if defined(KEY_TV2) || (defined(HAVE_DECL_KEY_TV2) && HAVE_DECL_KEY_TV2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TV2) == (0x17a), "KEY_TV2 != 0x17a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TV2 0x17a
#endif
#if defined(KEY_VCR) || (defined(HAVE_DECL_KEY_VCR) && HAVE_DECL_KEY_VCR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VCR) == (0x17b), "KEY_VCR != 0x17b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VCR 0x17b
#endif
#if defined(KEY_VCR2) || (defined(HAVE_DECL_KEY_VCR2) && HAVE_DECL_KEY_VCR2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VCR2) == (0x17c), "KEY_VCR2 != 0x17c");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VCR2 0x17c
#endif
#if defined(KEY_SAT) || (defined(HAVE_DECL_KEY_SAT) && HAVE_DECL_KEY_SAT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SAT) == (0x17d), "KEY_SAT != 0x17d");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SAT 0x17d
#endif
#if defined(KEY_SAT2) || (defined(HAVE_DECL_KEY_SAT2) && HAVE_DECL_KEY_SAT2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SAT2) == (0x17e), "KEY_SAT2 != 0x17e");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SAT2 0x17e
#endif
#if defined(KEY_CD) || (defined(HAVE_DECL_KEY_CD) && HAVE_DECL_KEY_CD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CD) == (0x17f), "KEY_CD != 0x17f");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CD 0x17f
#endif
#if defined(KEY_TAPE) || (defined(HAVE_DECL_KEY_TAPE) && HAVE_DECL_KEY_TAPE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TAPE) == (0x180), "KEY_TAPE != 0x180");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TAPE 0x180
#endif
#if defined(KEY_RADIO) || (defined(HAVE_DECL_KEY_RADIO) && HAVE_DECL_KEY_RADIO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RADIO) == (0x181), "KEY_RADIO != 0x181");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RADIO 0x181
#endif
#if defined(KEY_TUNER) || (defined(HAVE_DECL_KEY_TUNER) && HAVE_DECL_KEY_TUNER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TUNER) == (0x182), "KEY_TUNER != 0x182");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TUNER 0x182
#endif
#if defined(KEY_PLAYER) || (defined(HAVE_DECL_KEY_PLAYER) && HAVE_DECL_KEY_PLAYER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PLAYER) == (0x183), "KEY_PLAYER != 0x183");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PLAYER 0x183
#endif
#if defined(KEY_TEXT) || (defined(HAVE_DECL_KEY_TEXT) && HAVE_DECL_KEY_TEXT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TEXT) == (0x184), "KEY_TEXT != 0x184");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TEXT 0x184
#endif
#if defined(KEY_DVD) || (defined(HAVE_DECL_KEY_DVD) && HAVE_DECL_KEY_DVD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DVD) == (0x185), "KEY_DVD != 0x185");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DVD 0x185
#endif
#if defined(KEY_AUX) || (defined(HAVE_DECL_KEY_AUX) && HAVE_DECL_KEY_AUX)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_AUX) == (0x186), "KEY_AUX != 0x186");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_AUX 0x186
#endif
#if defined(KEY_MP3) || (defined(HAVE_DECL_KEY_MP3) && HAVE_DECL_KEY_MP3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MP3) == (0x187), "KEY_MP3 != 0x187");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MP3 0x187
#endif
#if defined(KEY_AUDIO) || (defined(HAVE_DECL_KEY_AUDIO) && HAVE_DECL_KEY_AUDIO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_AUDIO) == (0x188), "KEY_AUDIO != 0x188");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_AUDIO 0x188
#endif
#if defined(KEY_VIDEO) || (defined(HAVE_DECL_KEY_VIDEO) && HAVE_DECL_KEY_VIDEO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VIDEO) == (0x189), "KEY_VIDEO != 0x189");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VIDEO 0x189
#endif
#if defined(KEY_DIRECTORY) || (defined(HAVE_DECL_KEY_DIRECTORY) && HAVE_DECL_KEY_DIRECTORY)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DIRECTORY) == (0x18a), "KEY_DIRECTORY != 0x18a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DIRECTORY 0x18a
#endif
#if defined(KEY_LIST) || (defined(HAVE_DECL_KEY_LIST) && HAVE_DECL_KEY_LIST)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LIST) == (0x18b), "KEY_LIST != 0x18b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LIST 0x18b
#endif
#if defined(KEY_MEMO) || (defined(HAVE_DECL_KEY_MEMO) && HAVE_DECL_KEY_MEMO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MEMO) == (0x18c), "KEY_MEMO != 0x18c");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MEMO 0x18c
#endif
#if defined(KEY_CALENDAR) || (defined(HAVE_DECL_KEY_CALENDAR) && HAVE_DECL_KEY_CALENDAR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CALENDAR) == (0x18d), "KEY_CALENDAR != 0x18d");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CALENDAR 0x18d
#endif
#if defined(KEY_RED) || (defined(HAVE_DECL_KEY_RED) && HAVE_DECL_KEY_RED)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RED) == (0x18e), "KEY_RED != 0x18e");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RED 0x18e
#endif
#if defined(KEY_GREEN) || (defined(HAVE_DECL_KEY_GREEN) && HAVE_DECL_KEY_GREEN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_GREEN) == (0x18f), "KEY_GREEN != 0x18f");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_GREEN 0x18f
#endif
#if defined(KEY_YELLOW) || (defined(HAVE_DECL_KEY_YELLOW) && HAVE_DECL_KEY_YELLOW)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_YELLOW) == (0x190), "KEY_YELLOW != 0x190");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_YELLOW 0x190
#endif
#if defined(KEY_BLUE) || (defined(HAVE_DECL_KEY_BLUE) && HAVE_DECL_KEY_BLUE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BLUE) == (0x191), "KEY_BLUE != 0x191");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BLUE 0x191
#endif
#if defined(KEY_CHANNELUP) || (defined(HAVE_DECL_KEY_CHANNELUP) && HAVE_DECL_KEY_CHANNELUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CHANNELUP) == (0x192), "KEY_CHANNELUP != 0x192");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CHANNELUP 0x192
#endif
#if defined(KEY_CHANNELDOWN) || (defined(HAVE_DECL_KEY_CHANNELDOWN) && HAVE_DECL_KEY_CHANNELDOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CHANNELDOWN) == (0x193), "KEY_CHANNELDOWN != 0x193");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CHANNELDOWN 0x193
#endif
#if defined(KEY_FIRST) || (defined(HAVE_DECL_KEY_FIRST) && HAVE_DECL_KEY_FIRST)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FIRST) == (0x194), "KEY_FIRST != 0x194");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FIRST 0x194
#endif
#if defined(KEY_LAST) || (defined(HAVE_DECL_KEY_LAST) && HAVE_DECL_KEY_LAST)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LAST) == (0x195), "KEY_LAST != 0x195");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LAST 0x195
#endif
#if defined(KEY_AB) || (defined(HAVE_DECL_KEY_AB) && HAVE_DECL_KEY_AB)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_AB) == (0x196), "KEY_AB != 0x196");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_AB 0x196
#endif
#if defined(KEY_NEXT) || (defined(HAVE_DECL_KEY_NEXT) && HAVE_DECL_KEY_NEXT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NEXT) == (0x197), "KEY_NEXT != 0x197");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NEXT 0x197
#endif
#if defined(KEY_RESTART) || (defined(HAVE_DECL_KEY_RESTART) && HAVE_DECL_KEY_RESTART)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RESTART) == (0x198), "KEY_RESTART != 0x198");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RESTART 0x198
#endif
#if defined(KEY_SLOW) || (defined(HAVE_DECL_KEY_SLOW) && HAVE_DECL_KEY_SLOW)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SLOW) == (0x199), "KEY_SLOW != 0x199");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SLOW 0x199
#endif
#if defined(KEY_SHUFFLE) || (defined(HAVE_DECL_KEY_SHUFFLE) && HAVE_DECL_KEY_SHUFFLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SHUFFLE) == (0x19a), "KEY_SHUFFLE != 0x19a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SHUFFLE 0x19a
#endif
#if defined(KEY_BREAK) || (defined(HAVE_DECL_KEY_BREAK) && HAVE_DECL_KEY_BREAK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BREAK) == (0x19b), "KEY_BREAK != 0x19b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BREAK 0x19b
#endif
#if defined(KEY_PREVIOUS) || (defined(HAVE_DECL_KEY_PREVIOUS) && HAVE_DECL_KEY_PREVIOUS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PREVIOUS) == (0x19c), "KEY_PREVIOUS != 0x19c");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PREVIOUS 0x19c
#endif
#if defined(KEY_DIGITS) || (defined(HAVE_DECL_KEY_DIGITS) && HAVE_DECL_KEY_DIGITS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DIGITS) == (0x19d), "KEY_DIGITS != 0x19d");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DIGITS 0x19d
#endif
#if defined(KEY_TEEN) || (defined(HAVE_DECL_KEY_TEEN) && HAVE_DECL_KEY_TEEN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TEEN) == (0x19e), "KEY_TEEN != 0x19e");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TEEN 0x19e
#endif
#if defined(KEY_TWEN) || (defined(HAVE_DECL_KEY_TWEN) && HAVE_DECL_KEY_TWEN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TWEN) == (0x19f), "KEY_TWEN != 0x19f");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TWEN 0x19f
#endif
#if defined(KEY_VIDEOPHONE) || (defined(HAVE_DECL_KEY_VIDEOPHONE) && HAVE_DECL_KEY_VIDEOPHONE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VIDEOPHONE) == (0x1a0), "KEY_VIDEOPHONE != 0x1a0");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VIDEOPHONE 0x1a0
#endif
#if defined(KEY_GAMES) || (defined(HAVE_DECL_KEY_GAMES) && HAVE_DECL_KEY_GAMES)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_GAMES) == (0x1a1), "KEY_GAMES != 0x1a1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_GAMES 0x1a1
#endif
#if defined(KEY_ZOOMIN) || (defined(HAVE_DECL_KEY_ZOOMIN) && HAVE_DECL_KEY_ZOOMIN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ZOOMIN) == (0x1a2), "KEY_ZOOMIN != 0x1a2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ZOOMIN 0x1a2
#endif
#if defined(KEY_ZOOMOUT) || (defined(HAVE_DECL_KEY_ZOOMOUT) && HAVE_DECL_KEY_ZOOMOUT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ZOOMOUT) == (0x1a3), "KEY_ZOOMOUT != 0x1a3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ZOOMOUT 0x1a3
#endif
#if defined(KEY_ZOOMRESET) || (defined(HAVE_DECL_KEY_ZOOMRESET) && HAVE_DECL_KEY_ZOOMRESET)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ZOOMRESET) == (0x1a4), "KEY_ZOOMRESET != 0x1a4");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ZOOMRESET 0x1a4
#endif
#if defined(KEY_WORDPROCESSOR) || (defined(HAVE_DECL_KEY_WORDPROCESSOR) && HAVE_DECL_KEY_WORDPROCESSOR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_WORDPROCESSOR) == (0x1a5), "KEY_WORDPROCESSOR != 0x1a5");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_WORDPROCESSOR 0x1a5
#endif
#if defined(KEY_EDITOR) || (defined(HAVE_DECL_KEY_EDITOR) && HAVE_DECL_KEY_EDITOR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_EDITOR) == (0x1a6), "KEY_EDITOR != 0x1a6");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_EDITOR 0x1a6
#endif
#if defined(KEY_SPREADSHEET) || (defined(HAVE_DECL_KEY_SPREADSHEET) && HAVE_DECL_KEY_SPREADSHEET)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SPREADSHEET) == (0x1a7), "KEY_SPREADSHEET != 0x1a7");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SPREADSHEET 0x1a7
#endif
#if defined(KEY_GRAPHICSEDITOR) || (defined(HAVE_DECL_KEY_GRAPHICSEDITOR) && HAVE_DECL_KEY_GRAPHICSEDITOR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_GRAPHICSEDITOR) == (0x1a8), "KEY_GRAPHICSEDITOR != 0x1a8");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_GRAPHICSEDITOR 0x1a8
#endif
#if defined(KEY_PRESENTATION) || (defined(HAVE_DECL_KEY_PRESENTATION) && HAVE_DECL_KEY_PRESENTATION)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PRESENTATION) == (0x1a9), "KEY_PRESENTATION != 0x1a9");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PRESENTATION 0x1a9
#endif
#if defined(KEY_DATABASE) || (defined(HAVE_DECL_KEY_DATABASE) && HAVE_DECL_KEY_DATABASE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DATABASE) == (0x1aa), "KEY_DATABASE != 0x1aa");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DATABASE 0x1aa
#endif
#if defined(KEY_NEWS) || (defined(HAVE_DECL_KEY_NEWS) && HAVE_DECL_KEY_NEWS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NEWS) == (0x1ab), "KEY_NEWS != 0x1ab");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NEWS 0x1ab
#endif
#if defined(KEY_VOICEMAIL) || (defined(HAVE_DECL_KEY_VOICEMAIL) && HAVE_DECL_KEY_VOICEMAIL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VOICEMAIL) == (0x1ac), "KEY_VOICEMAIL != 0x1ac");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VOICEMAIL 0x1ac
#endif
#if defined(KEY_ADDRESSBOOK) || (defined(HAVE_DECL_KEY_ADDRESSBOOK) && HAVE_DECL_KEY_ADDRESSBOOK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ADDRESSBOOK) == (0x1ad), "KEY_ADDRESSBOOK != 0x1ad");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ADDRESSBOOK 0x1ad
#endif
#if defined(KEY_MESSENGER) || (defined(HAVE_DECL_KEY_MESSENGER) && HAVE_DECL_KEY_MESSENGER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MESSENGER) == (0x1ae), "KEY_MESSENGER != 0x1ae");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MESSENGER 0x1ae
#endif
#if defined(KEY_DISPLAYTOGGLE) || (defined(HAVE_DECL_KEY_DISPLAYTOGGLE) && HAVE_DECL_KEY_DISPLAYTOGGLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DISPLAYTOGGLE) == (0x1af), "KEY_DISPLAYTOGGLE != 0x1af");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DISPLAYTOGGLE 0x1af
#endif
#if defined(KEY_SPELLCHECK) || (defined(HAVE_DECL_KEY_SPELLCHECK) && HAVE_DECL_KEY_SPELLCHECK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SPELLCHECK) == (0x1b0), "KEY_SPELLCHECK != 0x1b0");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SPELLCHECK 0x1b0
#endif
#if defined(KEY_LOGOFF) || (defined(HAVE_DECL_KEY_LOGOFF) && HAVE_DECL_KEY_LOGOFF)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LOGOFF) == (0x1b1), "KEY_LOGOFF != 0x1b1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LOGOFF 0x1b1
#endif
#if defined(KEY_DOLLAR) || (defined(HAVE_DECL_KEY_DOLLAR) && HAVE_DECL_KEY_DOLLAR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DOLLAR) == (0x1b2), "KEY_DOLLAR != 0x1b2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DOLLAR 0x1b2
#endif
#if defined(KEY_EURO) || (defined(HAVE_DECL_KEY_EURO) && HAVE_DECL_KEY_EURO)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_EURO) == (0x1b3), "KEY_EURO != 0x1b3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_EURO 0x1b3
#endif
#if defined(KEY_FRAMEBACK) || (defined(HAVE_DECL_KEY_FRAMEBACK) && HAVE_DECL_KEY_FRAMEBACK)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FRAMEBACK) == (0x1b4), "KEY_FRAMEBACK != 0x1b4");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FRAMEBACK 0x1b4
#endif
#if defined(KEY_FRAMEFORWARD) || (defined(HAVE_DECL_KEY_FRAMEFORWARD) && HAVE_DECL_KEY_FRAMEFORWARD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FRAMEFORWARD) == (0x1b5), "KEY_FRAMEFORWARD != 0x1b5");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FRAMEFORWARD 0x1b5
#endif
#if defined(KEY_CONTEXT_MENU) || (defined(HAVE_DECL_KEY_CONTEXT_MENU) && HAVE_DECL_KEY_CONTEXT_MENU)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CONTEXT_MENU) == (0x1b6), "KEY_CONTEXT_MENU != 0x1b6");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CONTEXT_MENU 0x1b6
#endif
#if defined(KEY_MEDIA_REPEAT) || (defined(HAVE_DECL_KEY_MEDIA_REPEAT) && HAVE_DECL_KEY_MEDIA_REPEAT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MEDIA_REPEAT) == (0x1b7), "KEY_MEDIA_REPEAT != 0x1b7");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MEDIA_REPEAT 0x1b7
#endif
#if defined(KEY_10CHANNELSUP) || (defined(HAVE_DECL_KEY_10CHANNELSUP) && HAVE_DECL_KEY_10CHANNELSUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_10CHANNELSUP) == (0x1b8), "KEY_10CHANNELSUP != 0x1b8");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_10CHANNELSUP 0x1b8
#endif
#if defined(KEY_10CHANNELSDOWN) || (defined(HAVE_DECL_KEY_10CHANNELSDOWN) && HAVE_DECL_KEY_10CHANNELSDOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_10CHANNELSDOWN) == (0x1b9), "KEY_10CHANNELSDOWN != 0x1b9");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_10CHANNELSDOWN 0x1b9
#endif
#if defined(KEY_IMAGES) || (defined(HAVE_DECL_KEY_IMAGES) && HAVE_DECL_KEY_IMAGES)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_IMAGES) == (0x1ba), "KEY_IMAGES != 0x1ba");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_IMAGES 0x1ba
#endif
#if defined(KEY_DEL_EOL) || (defined(HAVE_DECL_KEY_DEL_EOL) && HAVE_DECL_KEY_DEL_EOL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DEL_EOL) == (0x1c0), "KEY_DEL_EOL != 0x1c0");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DEL_EOL 0x1c0
#endif
#if defined(KEY_DEL_EOS) || (defined(HAVE_DECL_KEY_DEL_EOS) && HAVE_DECL_KEY_DEL_EOS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DEL_EOS) == (0x1c1), "KEY_DEL_EOS != 0x1c1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DEL_EOS 0x1c1
#endif
#if defined(KEY_INS_LINE) || (defined(HAVE_DECL_KEY_INS_LINE) && HAVE_DECL_KEY_INS_LINE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_INS_LINE) == (0x1c2), "KEY_INS_LINE != 0x1c2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_INS_LINE 0x1c2
#endif
#if defined(KEY_DEL_LINE) || (defined(HAVE_DECL_KEY_DEL_LINE) && HAVE_DECL_KEY_DEL_LINE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DEL_LINE) == (0x1c3), "KEY_DEL_LINE != 0x1c3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DEL_LINE 0x1c3
#endif
#if defined(KEY_FN) || (defined(HAVE_DECL_KEY_FN) && HAVE_DECL_KEY_FN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN) == (0x1d0), "KEY_FN != 0x1d0");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN 0x1d0
#endif
#if defined(KEY_FN_ESC) || (defined(HAVE_DECL_KEY_FN_ESC) && HAVE_DECL_KEY_FN_ESC)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_ESC) == (0x1d1), "KEY_FN_ESC != 0x1d1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_ESC 0x1d1
#endif
#if defined(KEY_FN_F1) || (defined(HAVE_DECL_KEY_FN_F1) && HAVE_DECL_KEY_FN_F1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F1) == (0x1d2), "KEY_FN_F1 != 0x1d2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F1 0x1d2
#endif
#if defined(KEY_FN_F2) || (defined(HAVE_DECL_KEY_FN_F2) && HAVE_DECL_KEY_FN_F2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F2) == (0x1d3), "KEY_FN_F2 != 0x1d3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F2 0x1d3
#endif
#if defined(KEY_FN_F3) || (defined(HAVE_DECL_KEY_FN_F3) && HAVE_DECL_KEY_FN_F3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F3) == (0x1d4), "KEY_FN_F3 != 0x1d4");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F3 0x1d4
#endif
#if defined(KEY_FN_F4) || (defined(HAVE_DECL_KEY_FN_F4) && HAVE_DECL_KEY_FN_F4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F4) == (0x1d5), "KEY_FN_F4 != 0x1d5");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F4 0x1d5
#endif
#if defined(KEY_FN_F5) || (defined(HAVE_DECL_KEY_FN_F5) && HAVE_DECL_KEY_FN_F5)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F5) == (0x1d6), "KEY_FN_F5 != 0x1d6");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F5 0x1d6
#endif
#if defined(KEY_FN_F6) || (defined(HAVE_DECL_KEY_FN_F6) && HAVE_DECL_KEY_FN_F6)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F6) == (0x1d7), "KEY_FN_F6 != 0x1d7");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F6 0x1d7
#endif
#if defined(KEY_FN_F7) || (defined(HAVE_DECL_KEY_FN_F7) && HAVE_DECL_KEY_FN_F7)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F7) == (0x1d8), "KEY_FN_F7 != 0x1d8");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F7 0x1d8
#endif
#if defined(KEY_FN_F8) || (defined(HAVE_DECL_KEY_FN_F8) && HAVE_DECL_KEY_FN_F8)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F8) == (0x1d9), "KEY_FN_F8 != 0x1d9");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F8 0x1d9
#endif
#if defined(KEY_FN_F9) || (defined(HAVE_DECL_KEY_FN_F9) && HAVE_DECL_KEY_FN_F9)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F9) == (0x1da), "KEY_FN_F9 != 0x1da");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F9 0x1da
#endif
#if defined(KEY_FN_F10) || (defined(HAVE_DECL_KEY_FN_F10) && HAVE_DECL_KEY_FN_F10)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F10) == (0x1db), "KEY_FN_F10 != 0x1db");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F10 0x1db
#endif
#if defined(KEY_FN_F11) || (defined(HAVE_DECL_KEY_FN_F11) && HAVE_DECL_KEY_FN_F11)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F11) == (0x1dc), "KEY_FN_F11 != 0x1dc");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F11 0x1dc
#endif
#if defined(KEY_FN_F12) || (defined(HAVE_DECL_KEY_FN_F12) && HAVE_DECL_KEY_FN_F12)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F12) == (0x1dd), "KEY_FN_F12 != 0x1dd");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F12 0x1dd
#endif
#if defined(KEY_FN_1) || (defined(HAVE_DECL_KEY_FN_1) && HAVE_DECL_KEY_FN_1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_1) == (0x1de), "KEY_FN_1 != 0x1de");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_1 0x1de
#endif
#if defined(KEY_FN_2) || (defined(HAVE_DECL_KEY_FN_2) && HAVE_DECL_KEY_FN_2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_2) == (0x1df), "KEY_FN_2 != 0x1df");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_2 0x1df
#endif
#if defined(KEY_FN_D) || (defined(HAVE_DECL_KEY_FN_D) && HAVE_DECL_KEY_FN_D)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_D) == (0x1e0), "KEY_FN_D != 0x1e0");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_D 0x1e0
#endif
#if defined(KEY_FN_E) || (defined(HAVE_DECL_KEY_FN_E) && HAVE_DECL_KEY_FN_E)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_E) == (0x1e1), "KEY_FN_E != 0x1e1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_E 0x1e1
#endif
#if defined(KEY_FN_F) || (defined(HAVE_DECL_KEY_FN_F) && HAVE_DECL_KEY_FN_F)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_F) == (0x1e2), "KEY_FN_F != 0x1e2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_F 0x1e2
#endif
#if defined(KEY_FN_S) || (defined(HAVE_DECL_KEY_FN_S) && HAVE_DECL_KEY_FN_S)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_S) == (0x1e3), "KEY_FN_S != 0x1e3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_S 0x1e3
#endif
#if defined(KEY_FN_B) || (defined(HAVE_DECL_KEY_FN_B) && HAVE_DECL_KEY_FN_B)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FN_B) == (0x1e4), "KEY_FN_B != 0x1e4");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FN_B 0x1e4
#endif
#if defined(KEY_BRL_DOT1) || (defined(HAVE_DECL_KEY_BRL_DOT1) && HAVE_DECL_KEY_BRL_DOT1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT1) == (0x1f1), "KEY_BRL_DOT1 != 0x1f1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT1 0x1f1
#endif
#if defined(KEY_BRL_DOT2) || (defined(HAVE_DECL_KEY_BRL_DOT2) && HAVE_DECL_KEY_BRL_DOT2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT2) == (0x1f2), "KEY_BRL_DOT2 != 0x1f2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT2 0x1f2
#endif
#if defined(KEY_BRL_DOT3) || (defined(HAVE_DECL_KEY_BRL_DOT3) && HAVE_DECL_KEY_BRL_DOT3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT3) == (0x1f3), "KEY_BRL_DOT3 != 0x1f3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT3 0x1f3
#endif
#if defined(KEY_BRL_DOT4) || (defined(HAVE_DECL_KEY_BRL_DOT4) && HAVE_DECL_KEY_BRL_DOT4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT4) == (0x1f4), "KEY_BRL_DOT4 != 0x1f4");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT4 0x1f4
#endif
#if defined(KEY_BRL_DOT5) || (defined(HAVE_DECL_KEY_BRL_DOT5) && HAVE_DECL_KEY_BRL_DOT5)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT5) == (0x1f5), "KEY_BRL_DOT5 != 0x1f5");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT5 0x1f5
#endif
#if defined(KEY_BRL_DOT6) || (defined(HAVE_DECL_KEY_BRL_DOT6) && HAVE_DECL_KEY_BRL_DOT6)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT6) == (0x1f6), "KEY_BRL_DOT6 != 0x1f6");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT6 0x1f6
#endif
#if defined(KEY_BRL_DOT7) || (defined(HAVE_DECL_KEY_BRL_DOT7) && HAVE_DECL_KEY_BRL_DOT7)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT7) == (0x1f7), "KEY_BRL_DOT7 != 0x1f7");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT7 0x1f7
#endif
#if defined(KEY_BRL_DOT8) || (defined(HAVE_DECL_KEY_BRL_DOT8) && HAVE_DECL_KEY_BRL_DOT8)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT8) == (0x1f8), "KEY_BRL_DOT8 != 0x1f8");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT8 0x1f8
#endif
#if defined(KEY_BRL_DOT9) || (defined(HAVE_DECL_KEY_BRL_DOT9) && HAVE_DECL_KEY_BRL_DOT9)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT9) == (0x1f9), "KEY_BRL_DOT9 != 0x1f9");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT9 0x1f9
#endif
#if defined(KEY_BRL_DOT10) || (defined(HAVE_DECL_KEY_BRL_DOT10) && HAVE_DECL_KEY_BRL_DOT10)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRL_DOT10) == (0x1fa), "KEY_BRL_DOT10 != 0x1fa");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRL_DOT10 0x1fa
#endif
#if defined(KEY_NUMERIC_0) || (defined(HAVE_DECL_KEY_NUMERIC_0) && HAVE_DECL_KEY_NUMERIC_0)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_0) == (0x200), "KEY_NUMERIC_0 != 0x200");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_0 0x200
#endif
#if defined(KEY_NUMERIC_1) || (defined(HAVE_DECL_KEY_NUMERIC_1) && HAVE_DECL_KEY_NUMERIC_1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_1) == (0x201), "KEY_NUMERIC_1 != 0x201");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_1 0x201
#endif
#if defined(KEY_NUMERIC_2) || (defined(HAVE_DECL_KEY_NUMERIC_2) && HAVE_DECL_KEY_NUMERIC_2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_2) == (0x202), "KEY_NUMERIC_2 != 0x202");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_2 0x202
#endif
#if defined(KEY_NUMERIC_3) || (defined(HAVE_DECL_KEY_NUMERIC_3) && HAVE_DECL_KEY_NUMERIC_3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_3) == (0x203), "KEY_NUMERIC_3 != 0x203");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_3 0x203
#endif
#if defined(KEY_NUMERIC_4) || (defined(HAVE_DECL_KEY_NUMERIC_4) && HAVE_DECL_KEY_NUMERIC_4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_4) == (0x204), "KEY_NUMERIC_4 != 0x204");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_4 0x204
#endif
#if defined(KEY_NUMERIC_5) || (defined(HAVE_DECL_KEY_NUMERIC_5) && HAVE_DECL_KEY_NUMERIC_5)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_5) == (0x205), "KEY_NUMERIC_5 != 0x205");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_5 0x205
#endif
#if defined(KEY_NUMERIC_6) || (defined(HAVE_DECL_KEY_NUMERIC_6) && HAVE_DECL_KEY_NUMERIC_6)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_6) == (0x206), "KEY_NUMERIC_6 != 0x206");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_6 0x206
#endif
#if defined(KEY_NUMERIC_7) || (defined(HAVE_DECL_KEY_NUMERIC_7) && HAVE_DECL_KEY_NUMERIC_7)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_7) == (0x207), "KEY_NUMERIC_7 != 0x207");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_7 0x207
#endif
#if defined(KEY_NUMERIC_8) || (defined(HAVE_DECL_KEY_NUMERIC_8) && HAVE_DECL_KEY_NUMERIC_8)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_8) == (0x208), "KEY_NUMERIC_8 != 0x208");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_8 0x208
#endif
#if defined(KEY_NUMERIC_9) || (defined(HAVE_DECL_KEY_NUMERIC_9) && HAVE_DECL_KEY_NUMERIC_9)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_9) == (0x209), "KEY_NUMERIC_9 != 0x209");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_9 0x209
#endif
#if defined(KEY_NUMERIC_STAR) || (defined(HAVE_DECL_KEY_NUMERIC_STAR) && HAVE_DECL_KEY_NUMERIC_STAR)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_STAR) == (0x20a), "KEY_NUMERIC_STAR != 0x20a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_STAR 0x20a
#endif
#if defined(KEY_NUMERIC_POUND) || (defined(HAVE_DECL_KEY_NUMERIC_POUND) && HAVE_DECL_KEY_NUMERIC_POUND)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_POUND) == (0x20b), "KEY_NUMERIC_POUND != 0x20b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_POUND 0x20b
#endif
#if defined(KEY_NUMERIC_A) || (defined(HAVE_DECL_KEY_NUMERIC_A) && HAVE_DECL_KEY_NUMERIC_A)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_A) == (0x20c), "KEY_NUMERIC_A != 0x20c");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_A 0x20c
#endif
#if defined(KEY_NUMERIC_B) || (defined(HAVE_DECL_KEY_NUMERIC_B) && HAVE_DECL_KEY_NUMERIC_B)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_B) == (0x20d), "KEY_NUMERIC_B != 0x20d");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_B 0x20d
#endif
#if defined(KEY_NUMERIC_C) || (defined(HAVE_DECL_KEY_NUMERIC_C) && HAVE_DECL_KEY_NUMERIC_C)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_C) == (0x20e), "KEY_NUMERIC_C != 0x20e");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_C 0x20e
#endif
#if defined(KEY_NUMERIC_D) || (defined(HAVE_DECL_KEY_NUMERIC_D) && HAVE_DECL_KEY_NUMERIC_D)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_D) == (0x20f), "KEY_NUMERIC_D != 0x20f");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_D 0x20f
#endif
#if defined(KEY_CAMERA_FOCUS) || (defined(HAVE_DECL_KEY_CAMERA_FOCUS) && HAVE_DECL_KEY_CAMERA_FOCUS)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CAMERA_FOCUS) == (0x210), "KEY_CAMERA_FOCUS != 0x210");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CAMERA_FOCUS 0x210
#endif
#if defined(KEY_WPS_BUTTON) || (defined(HAVE_DECL_KEY_WPS_BUTTON) && HAVE_DECL_KEY_WPS_BUTTON)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_WPS_BUTTON) == (0x211), "KEY_WPS_BUTTON != 0x211");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_WPS_BUTTON 0x211
#endif
#if defined(KEY_TOUCHPAD_TOGGLE) || (defined(HAVE_DECL_KEY_TOUCHPAD_TOGGLE) && HAVE_DECL_KEY_TOUCHPAD_TOGGLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TOUCHPAD_TOGGLE) == (0x212), "KEY_TOUCHPAD_TOGGLE != 0x212");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TOUCHPAD_TOGGLE 0x212
#endif
#if defined(KEY_TOUCHPAD_ON) || (defined(HAVE_DECL_KEY_TOUCHPAD_ON) && HAVE_DECL_KEY_TOUCHPAD_ON)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TOUCHPAD_ON) == (0x213), "KEY_TOUCHPAD_ON != 0x213");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TOUCHPAD_ON 0x213
#endif
#if defined(KEY_TOUCHPAD_OFF) || (defined(HAVE_DECL_KEY_TOUCHPAD_OFF) && HAVE_DECL_KEY_TOUCHPAD_OFF)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TOUCHPAD_OFF) == (0x214), "KEY_TOUCHPAD_OFF != 0x214");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TOUCHPAD_OFF 0x214
#endif
#if defined(KEY_CAMERA_ZOOMIN) || (defined(HAVE_DECL_KEY_CAMERA_ZOOMIN) && HAVE_DECL_KEY_CAMERA_ZOOMIN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CAMERA_ZOOMIN) == (0x215), "KEY_CAMERA_ZOOMIN != 0x215");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CAMERA_ZOOMIN 0x215
#endif
#if defined(KEY_CAMERA_ZOOMOUT) || (defined(HAVE_DECL_KEY_CAMERA_ZOOMOUT) && HAVE_DECL_KEY_CAMERA_ZOOMOUT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CAMERA_ZOOMOUT) == (0x216), "KEY_CAMERA_ZOOMOUT != 0x216");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CAMERA_ZOOMOUT 0x216
#endif
#if defined(KEY_CAMERA_UP) || (defined(HAVE_DECL_KEY_CAMERA_UP) && HAVE_DECL_KEY_CAMERA_UP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CAMERA_UP) == (0x217), "KEY_CAMERA_UP != 0x217");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CAMERA_UP 0x217
#endif
#if defined(KEY_CAMERA_DOWN) || (defined(HAVE_DECL_KEY_CAMERA_DOWN) && HAVE_DECL_KEY_CAMERA_DOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CAMERA_DOWN) == (0x218), "KEY_CAMERA_DOWN != 0x218");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CAMERA_DOWN 0x218
#endif
#if defined(KEY_CAMERA_LEFT) || (defined(HAVE_DECL_KEY_CAMERA_LEFT) && HAVE_DECL_KEY_CAMERA_LEFT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CAMERA_LEFT) == (0x219), "KEY_CAMERA_LEFT != 0x219");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CAMERA_LEFT 0x219
#endif
#if defined(KEY_CAMERA_RIGHT) || (defined(HAVE_DECL_KEY_CAMERA_RIGHT) && HAVE_DECL_KEY_CAMERA_RIGHT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CAMERA_RIGHT) == (0x21a), "KEY_CAMERA_RIGHT != 0x21a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CAMERA_RIGHT 0x21a
#endif
#if defined(KEY_ATTENDANT_ON) || (defined(HAVE_DECL_KEY_ATTENDANT_ON) && HAVE_DECL_KEY_ATTENDANT_ON)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ATTENDANT_ON) == (0x21b), "KEY_ATTENDANT_ON != 0x21b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ATTENDANT_ON 0x21b
#endif
#if defined(KEY_ATTENDANT_OFF) || (defined(HAVE_DECL_KEY_ATTENDANT_OFF) && HAVE_DECL_KEY_ATTENDANT_OFF)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ATTENDANT_OFF) == (0x21c), "KEY_ATTENDANT_OFF != 0x21c");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ATTENDANT_OFF 0x21c
#endif
#if defined(KEY_ATTENDANT_TOGGLE) || (defined(HAVE_DECL_KEY_ATTENDANT_TOGGLE) && HAVE_DECL_KEY_ATTENDANT_TOGGLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ATTENDANT_TOGGLE) == (0x21d), "KEY_ATTENDANT_TOGGLE != 0x21d");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ATTENDANT_TOGGLE 0x21d
#endif
#if defined(KEY_LIGHTS_TOGGLE) || (defined(HAVE_DECL_KEY_LIGHTS_TOGGLE) && HAVE_DECL_KEY_LIGHTS_TOGGLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LIGHTS_TOGGLE) == (0x21e), "KEY_LIGHTS_TOGGLE != 0x21e");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LIGHTS_TOGGLE 0x21e
#endif
#if defined(BTN_DPAD_UP) || (defined(HAVE_DECL_BTN_DPAD_UP) && HAVE_DECL_BTN_DPAD_UP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_DPAD_UP) == (0x220), "BTN_DPAD_UP != 0x220");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_DPAD_UP 0x220
#endif
#if defined(BTN_DPAD_DOWN) || (defined(HAVE_DECL_BTN_DPAD_DOWN) && HAVE_DECL_BTN_DPAD_DOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_DPAD_DOWN) == (0x221), "BTN_DPAD_DOWN != 0x221");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_DPAD_DOWN 0x221
#endif
#if defined(BTN_DPAD_LEFT) || (defined(HAVE_DECL_BTN_DPAD_LEFT) && HAVE_DECL_BTN_DPAD_LEFT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_DPAD_LEFT) == (0x222), "BTN_DPAD_LEFT != 0x222");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_DPAD_LEFT 0x222
#endif
#if defined(BTN_DPAD_RIGHT) || (defined(HAVE_DECL_BTN_DPAD_RIGHT) && HAVE_DECL_BTN_DPAD_RIGHT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_DPAD_RIGHT) == (0x223), "BTN_DPAD_RIGHT != 0x223");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_DPAD_RIGHT 0x223
#endif
#if defined(KEY_ALS_TOGGLE) || (defined(HAVE_DECL_KEY_ALS_TOGGLE) && HAVE_DECL_KEY_ALS_TOGGLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ALS_TOGGLE) == (0x230), "KEY_ALS_TOGGLE != 0x230");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ALS_TOGGLE 0x230
#endif
#if defined(KEY_ROTATE_LOCK_TOGGLE) || (defined(HAVE_DECL_KEY_ROTATE_LOCK_TOGGLE) && HAVE_DECL_KEY_ROTATE_LOCK_TOGGLE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ROTATE_LOCK_TOGGLE) == (0x231), "KEY_ROTATE_LOCK_TOGGLE != 0x231");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ROTATE_LOCK_TOGGLE 0x231
#endif
#if defined(KEY_BUTTONCONFIG) || (defined(HAVE_DECL_KEY_BUTTONCONFIG) && HAVE_DECL_KEY_BUTTONCONFIG)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BUTTONCONFIG) == (0x240), "KEY_BUTTONCONFIG != 0x240");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BUTTONCONFIG 0x240
#endif
#if defined(KEY_TASKMANAGER) || (defined(HAVE_DECL_KEY_TASKMANAGER) && HAVE_DECL_KEY_TASKMANAGER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_TASKMANAGER) == (0x241), "KEY_TASKMANAGER != 0x241");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_TASKMANAGER 0x241
#endif
#if defined(KEY_JOURNAL) || (defined(HAVE_DECL_KEY_JOURNAL) && HAVE_DECL_KEY_JOURNAL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_JOURNAL) == (0x242), "KEY_JOURNAL != 0x242");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_JOURNAL 0x242
#endif
#if defined(KEY_CONTROLPANEL) || (defined(HAVE_DECL_KEY_CONTROLPANEL) && HAVE_DECL_KEY_CONTROLPANEL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_CONTROLPANEL) == (0x243), "KEY_CONTROLPANEL != 0x243");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_CONTROLPANEL 0x243
#endif
#if defined(KEY_APPSELECT) || (defined(HAVE_DECL_KEY_APPSELECT) && HAVE_DECL_KEY_APPSELECT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_APPSELECT) == (0x244), "KEY_APPSELECT != 0x244");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_APPSELECT 0x244
#endif
#if defined(KEY_SCREENSAVER) || (defined(HAVE_DECL_KEY_SCREENSAVER) && HAVE_DECL_KEY_SCREENSAVER)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SCREENSAVER) == (0x245), "KEY_SCREENSAVER != 0x245");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SCREENSAVER 0x245
#endif
#if defined(KEY_VOICECOMMAND) || (defined(HAVE_DECL_KEY_VOICECOMMAND) && HAVE_DECL_KEY_VOICECOMMAND)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VOICECOMMAND) == (0x246), "KEY_VOICECOMMAND != 0x246");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VOICECOMMAND 0x246
#endif
#if defined(KEY_ASSISTANT) || (defined(HAVE_DECL_KEY_ASSISTANT) && HAVE_DECL_KEY_ASSISTANT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ASSISTANT) == (0x247), "KEY_ASSISTANT != 0x247");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ASSISTANT 0x247
#endif
#ifndef STRACE_WORKAROUND_FOR_KEY_BRIGHTNESS_MIN
# define STRACE_WORKAROUND_FOR_KEY_BRIGHTNESS_MIN
# undef KEY_BRIGHTNESS_MIN
#endif
#if defined(KEY_BRIGHTNESS_MIN) || (defined(HAVE_DECL_KEY_BRIGHTNESS_MIN) && HAVE_DECL_KEY_BRIGHTNESS_MIN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRIGHTNESS_MIN) == (0x250), "KEY_BRIGHTNESS_MIN != 0x250");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRIGHTNESS_MIN 0x250
#endif
#if defined(KEY_BRIGHTNESS_MAX) || (defined(HAVE_DECL_KEY_BRIGHTNESS_MAX) && HAVE_DECL_KEY_BRIGHTNESS_MAX)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_BRIGHTNESS_MAX) == (0x251), "KEY_BRIGHTNESS_MAX != 0x251");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_BRIGHTNESS_MAX 0x251
#endif
#if defined(KEY_KBDINPUTASSIST_PREV) || (defined(HAVE_DECL_KEY_KBDINPUTASSIST_PREV) && HAVE_DECL_KEY_KBDINPUTASSIST_PREV)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KBDINPUTASSIST_PREV) == (0x260), "KEY_KBDINPUTASSIST_PREV != 0x260");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KBDINPUTASSIST_PREV 0x260
#endif
#if defined(KEY_KBDINPUTASSIST_NEXT) || (defined(HAVE_DECL_KEY_KBDINPUTASSIST_NEXT) && HAVE_DECL_KEY_KBDINPUTASSIST_NEXT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KBDINPUTASSIST_NEXT) == (0x261), "KEY_KBDINPUTASSIST_NEXT != 0x261");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KBDINPUTASSIST_NEXT 0x261
#endif
#if defined(KEY_KBDINPUTASSIST_PREVGROUP) || (defined(HAVE_DECL_KEY_KBDINPUTASSIST_PREVGROUP) && HAVE_DECL_KEY_KBDINPUTASSIST_PREVGROUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KBDINPUTASSIST_PREVGROUP) == (0x262), "KEY_KBDINPUTASSIST_PREVGROUP != 0x262");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KBDINPUTASSIST_PREVGROUP 0x262
#endif
#if defined(KEY_KBDINPUTASSIST_NEXTGROUP) || (defined(HAVE_DECL_KEY_KBDINPUTASSIST_NEXTGROUP) && HAVE_DECL_KEY_KBDINPUTASSIST_NEXTGROUP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KBDINPUTASSIST_NEXTGROUP) == (0x263), "KEY_KBDINPUTASSIST_NEXTGROUP != 0x263");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KBDINPUTASSIST_NEXTGROUP 0x263
#endif
#if defined(KEY_KBDINPUTASSIST_ACCEPT) || (defined(HAVE_DECL_KEY_KBDINPUTASSIST_ACCEPT) && HAVE_DECL_KEY_KBDINPUTASSIST_ACCEPT)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KBDINPUTASSIST_ACCEPT) == (0x264), "KEY_KBDINPUTASSIST_ACCEPT != 0x264");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KBDINPUTASSIST_ACCEPT 0x264
#endif
#if defined(KEY_KBDINPUTASSIST_CANCEL) || (defined(HAVE_DECL_KEY_KBDINPUTASSIST_CANCEL) && HAVE_DECL_KEY_KBDINPUTASSIST_CANCEL)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_KBDINPUTASSIST_CANCEL) == (0x265), "KEY_KBDINPUTASSIST_CANCEL != 0x265");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_KBDINPUTASSIST_CANCEL 0x265
#endif
#if defined(KEY_RIGHT_UP) || (defined(HAVE_DECL_KEY_RIGHT_UP) && HAVE_DECL_KEY_RIGHT_UP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RIGHT_UP) == (0x266), "KEY_RIGHT_UP != 0x266");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RIGHT_UP 0x266
#endif
#if defined(KEY_RIGHT_DOWN) || (defined(HAVE_DECL_KEY_RIGHT_DOWN) && HAVE_DECL_KEY_RIGHT_DOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_RIGHT_DOWN) == (0x267), "KEY_RIGHT_DOWN != 0x267");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_RIGHT_DOWN 0x267
#endif
#if defined(KEY_LEFT_UP) || (defined(HAVE_DECL_KEY_LEFT_UP) && HAVE_DECL_KEY_LEFT_UP)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LEFT_UP) == (0x268), "KEY_LEFT_UP != 0x268");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LEFT_UP 0x268
#endif
#if defined(KEY_LEFT_DOWN) || (defined(HAVE_DECL_KEY_LEFT_DOWN) && HAVE_DECL_KEY_LEFT_DOWN)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_LEFT_DOWN) == (0x269), "KEY_LEFT_DOWN != 0x269");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_LEFT_DOWN 0x269
#endif
#if defined(KEY_ROOT_MENU) || (defined(HAVE_DECL_KEY_ROOT_MENU) && HAVE_DECL_KEY_ROOT_MENU)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ROOT_MENU) == (0x26a), "KEY_ROOT_MENU != 0x26a");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ROOT_MENU 0x26a
#endif
#if defined(KEY_MEDIA_TOP_MENU) || (defined(HAVE_DECL_KEY_MEDIA_TOP_MENU) && HAVE_DECL_KEY_MEDIA_TOP_MENU)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_MEDIA_TOP_MENU) == (0x26b), "KEY_MEDIA_TOP_MENU != 0x26b");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_MEDIA_TOP_MENU 0x26b
#endif
#if defined(KEY_NUMERIC_11) || (defined(HAVE_DECL_KEY_NUMERIC_11) && HAVE_DECL_KEY_NUMERIC_11)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_11) == (0x26c), "KEY_NUMERIC_11 != 0x26c");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_11 0x26c
#endif
#if defined(KEY_NUMERIC_12) || (defined(HAVE_DECL_KEY_NUMERIC_12) && HAVE_DECL_KEY_NUMERIC_12)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NUMERIC_12) == (0x26d), "KEY_NUMERIC_12 != 0x26d");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NUMERIC_12 0x26d
#endif
#if defined(KEY_AUDIO_DESC) || (defined(HAVE_DECL_KEY_AUDIO_DESC) && HAVE_DECL_KEY_AUDIO_DESC)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_AUDIO_DESC) == (0x26e), "KEY_AUDIO_DESC != 0x26e");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_AUDIO_DESC 0x26e
#endif
#if defined(KEY_3D_MODE) || (defined(HAVE_DECL_KEY_3D_MODE) && HAVE_DECL_KEY_3D_MODE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_3D_MODE) == (0x26f), "KEY_3D_MODE != 0x26f");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_3D_MODE 0x26f
#endif
#if defined(KEY_NEXT_FAVORITE) || (defined(HAVE_DECL_KEY_NEXT_FAVORITE) && HAVE_DECL_KEY_NEXT_FAVORITE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_NEXT_FAVORITE) == (0x270), "KEY_NEXT_FAVORITE != 0x270");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_NEXT_FAVORITE 0x270
#endif
#if defined(KEY_STOP_RECORD) || (defined(HAVE_DECL_KEY_STOP_RECORD) && HAVE_DECL_KEY_STOP_RECORD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_STOP_RECORD) == (0x271), "KEY_STOP_RECORD != 0x271");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_STOP_RECORD 0x271
#endif
#if defined(KEY_PAUSE_RECORD) || (defined(HAVE_DECL_KEY_PAUSE_RECORD) && HAVE_DECL_KEY_PAUSE_RECORD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_PAUSE_RECORD) == (0x272), "KEY_PAUSE_RECORD != 0x272");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_PAUSE_RECORD 0x272
#endif
#if defined(KEY_VOD) || (defined(HAVE_DECL_KEY_VOD) && HAVE_DECL_KEY_VOD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_VOD) == (0x273), "KEY_VOD != 0x273");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_VOD 0x273
#endif
#if defined(KEY_UNMUTE) || (defined(HAVE_DECL_KEY_UNMUTE) && HAVE_DECL_KEY_UNMUTE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_UNMUTE) == (0x274), "KEY_UNMUTE != 0x274");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_UNMUTE 0x274
#endif
#if defined(KEY_FASTREVERSE) || (defined(HAVE_DECL_KEY_FASTREVERSE) && HAVE_DECL_KEY_FASTREVERSE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_FASTREVERSE) == (0x275), "KEY_FASTREVERSE != 0x275");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_FASTREVERSE 0x275
#endif
#if defined(KEY_SLOWREVERSE) || (defined(HAVE_DECL_KEY_SLOWREVERSE) && HAVE_DECL_KEY_SLOWREVERSE)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_SLOWREVERSE) == (0x276), "KEY_SLOWREVERSE != 0x276");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_SLOWREVERSE 0x276
#endif
#ifndef STRACE_WORKAROUND_FOR_KEY_DATA
# define STRACE_WORKAROUND_FOR_KEY_DATA
# undef KEY_DATA
#endif
#if defined(KEY_DATA) || (defined(HAVE_DECL_KEY_DATA) && HAVE_DECL_KEY_DATA)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_DATA) == (0x277), "KEY_DATA != 0x277");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_DATA 0x277
#endif
#if defined(KEY_ONSCREEN_KEYBOARD) || (defined(HAVE_DECL_KEY_ONSCREEN_KEYBOARD) && HAVE_DECL_KEY_ONSCREEN_KEYBOARD)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((KEY_ONSCREEN_KEYBOARD) == (0x278), "KEY_ONSCREEN_KEYBOARD != 0x278");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define KEY_ONSCREEN_KEYBOARD 0x278
#endif
#if defined(BTN_TRIGGER_HAPPY1) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY1) && HAVE_DECL_BTN_TRIGGER_HAPPY1)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY1) == (0x2c0), "BTN_TRIGGER_HAPPY1 != 0x2c0");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY1 0x2c0
#endif
#if defined(BTN_TRIGGER_HAPPY2) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY2) && HAVE_DECL_BTN_TRIGGER_HAPPY2)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY2) == (0x2c1), "BTN_TRIGGER_HAPPY2 != 0x2c1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY2 0x2c1
#endif
#if defined(BTN_TRIGGER_HAPPY3) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY3) && HAVE_DECL_BTN_TRIGGER_HAPPY3)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY3) == (0x2c2), "BTN_TRIGGER_HAPPY3 != 0x2c2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY3 0x2c2
#endif
#if defined(BTN_TRIGGER_HAPPY4) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY4) && HAVE_DECL_BTN_TRIGGER_HAPPY4)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY4) == (0x2c3), "BTN_TRIGGER_HAPPY4 != 0x2c3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY4 0x2c3
#endif
#if defined(BTN_TRIGGER_HAPPY5) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY5) && HAVE_DECL_BTN_TRIGGER_HAPPY5)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY5) == (0x2c4), "BTN_TRIGGER_HAPPY5 != 0x2c4");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY5 0x2c4
#endif
#if defined(BTN_TRIGGER_HAPPY6) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY6) && HAVE_DECL_BTN_TRIGGER_HAPPY6)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY6) == (0x2c5), "BTN_TRIGGER_HAPPY6 != 0x2c5");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY6 0x2c5
#endif
#if defined(BTN_TRIGGER_HAPPY7) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY7) && HAVE_DECL_BTN_TRIGGER_HAPPY7)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY7) == (0x2c6), "BTN_TRIGGER_HAPPY7 != 0x2c6");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY7 0x2c6
#endif
#if defined(BTN_TRIGGER_HAPPY8) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY8) && HAVE_DECL_BTN_TRIGGER_HAPPY8)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY8) == (0x2c7), "BTN_TRIGGER_HAPPY8 != 0x2c7");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY8 0x2c7
#endif
#if defined(BTN_TRIGGER_HAPPY9) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY9) && HAVE_DECL_BTN_TRIGGER_HAPPY9)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY9) == (0x2c8), "BTN_TRIGGER_HAPPY9 != 0x2c8");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY9 0x2c8
#endif
#if defined(BTN_TRIGGER_HAPPY10) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY10) && HAVE_DECL_BTN_TRIGGER_HAPPY10)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY10) == (0x2c9), "BTN_TRIGGER_HAPPY10 != 0x2c9");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY10 0x2c9
#endif
#if defined(BTN_TRIGGER_HAPPY11) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY11) && HAVE_DECL_BTN_TRIGGER_HAPPY11)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY11) == (0x2ca), "BTN_TRIGGER_HAPPY11 != 0x2ca");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY11 0x2ca
#endif
#if defined(BTN_TRIGGER_HAPPY12) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY12) && HAVE_DECL_BTN_TRIGGER_HAPPY12)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY12) == (0x2cb), "BTN_TRIGGER_HAPPY12 != 0x2cb");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY12 0x2cb
#endif
#if defined(BTN_TRIGGER_HAPPY13) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY13) && HAVE_DECL_BTN_TRIGGER_HAPPY13)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY13) == (0x2cc), "BTN_TRIGGER_HAPPY13 != 0x2cc");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY13 0x2cc
#endif
#if defined(BTN_TRIGGER_HAPPY14) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY14) && HAVE_DECL_BTN_TRIGGER_HAPPY14)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY14) == (0x2cd), "BTN_TRIGGER_HAPPY14 != 0x2cd");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY14 0x2cd
#endif
#if defined(BTN_TRIGGER_HAPPY15) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY15) && HAVE_DECL_BTN_TRIGGER_HAPPY15)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY15) == (0x2ce), "BTN_TRIGGER_HAPPY15 != 0x2ce");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY15 0x2ce
#endif
#if defined(BTN_TRIGGER_HAPPY16) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY16) && HAVE_DECL_BTN_TRIGGER_HAPPY16)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY16) == (0x2cf), "BTN_TRIGGER_HAPPY16 != 0x2cf");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY16 0x2cf
#endif
#if defined(BTN_TRIGGER_HAPPY17) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY17) && HAVE_DECL_BTN_TRIGGER_HAPPY17)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY17) == (0x2d0), "BTN_TRIGGER_HAPPY17 != 0x2d0");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY17 0x2d0
#endif
#if defined(BTN_TRIGGER_HAPPY18) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY18) && HAVE_DECL_BTN_TRIGGER_HAPPY18)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY18) == (0x2d1), "BTN_TRIGGER_HAPPY18 != 0x2d1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY18 0x2d1
#endif
#if defined(BTN_TRIGGER_HAPPY19) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY19) && HAVE_DECL_BTN_TRIGGER_HAPPY19)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY19) == (0x2d2), "BTN_TRIGGER_HAPPY19 != 0x2d2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY19 0x2d2
#endif
#if defined(BTN_TRIGGER_HAPPY20) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY20) && HAVE_DECL_BTN_TRIGGER_HAPPY20)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY20) == (0x2d3), "BTN_TRIGGER_HAPPY20 != 0x2d3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY20 0x2d3
#endif
#if defined(BTN_TRIGGER_HAPPY21) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY21) && HAVE_DECL_BTN_TRIGGER_HAPPY21)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY21) == (0x2d4), "BTN_TRIGGER_HAPPY21 != 0x2d4");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY21 0x2d4
#endif
#if defined(BTN_TRIGGER_HAPPY22) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY22) && HAVE_DECL_BTN_TRIGGER_HAPPY22)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY22) == (0x2d5), "BTN_TRIGGER_HAPPY22 != 0x2d5");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY22 0x2d5
#endif
#if defined(BTN_TRIGGER_HAPPY23) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY23) && HAVE_DECL_BTN_TRIGGER_HAPPY23)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY23) == (0x2d6), "BTN_TRIGGER_HAPPY23 != 0x2d6");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY23 0x2d6
#endif
#if defined(BTN_TRIGGER_HAPPY24) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY24) && HAVE_DECL_BTN_TRIGGER_HAPPY24)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY24) == (0x2d7), "BTN_TRIGGER_HAPPY24 != 0x2d7");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY24 0x2d7
#endif
#if defined(BTN_TRIGGER_HAPPY25) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY25) && HAVE_DECL_BTN_TRIGGER_HAPPY25)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY25) == (0x2d8), "BTN_TRIGGER_HAPPY25 != 0x2d8");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY25 0x2d8
#endif
#if defined(BTN_TRIGGER_HAPPY26) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY26) && HAVE_DECL_BTN_TRIGGER_HAPPY26)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY26) == (0x2d9), "BTN_TRIGGER_HAPPY26 != 0x2d9");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY26 0x2d9
#endif
#if defined(BTN_TRIGGER_HAPPY27) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY27) && HAVE_DECL_BTN_TRIGGER_HAPPY27)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY27) == (0x2da), "BTN_TRIGGER_HAPPY27 != 0x2da");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY27 0x2da
#endif
#if defined(BTN_TRIGGER_HAPPY28) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY28) && HAVE_DECL_BTN_TRIGGER_HAPPY28)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY28) == (0x2db), "BTN_TRIGGER_HAPPY28 != 0x2db");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY28 0x2db
#endif
#if defined(BTN_TRIGGER_HAPPY29) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY29) && HAVE_DECL_BTN_TRIGGER_HAPPY29)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY29) == (0x2dc), "BTN_TRIGGER_HAPPY29 != 0x2dc");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY29 0x2dc
#endif
#if defined(BTN_TRIGGER_HAPPY30) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY30) && HAVE_DECL_BTN_TRIGGER_HAPPY30)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY30) == (0x2dd), "BTN_TRIGGER_HAPPY30 != 0x2dd");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY30 0x2dd
#endif
#if defined(BTN_TRIGGER_HAPPY31) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY31) && HAVE_DECL_BTN_TRIGGER_HAPPY31)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY31) == (0x2de), "BTN_TRIGGER_HAPPY31 != 0x2de");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY31 0x2de
#endif
#if defined(BTN_TRIGGER_HAPPY32) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY32) && HAVE_DECL_BTN_TRIGGER_HAPPY32)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY32) == (0x2df), "BTN_TRIGGER_HAPPY32 != 0x2df");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY32 0x2df
#endif
#if defined(BTN_TRIGGER_HAPPY33) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY33) && HAVE_DECL_BTN_TRIGGER_HAPPY33)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY33) == (0x2e0), "BTN_TRIGGER_HAPPY33 != 0x2e0");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY33 0x2e0
#endif
#if defined(BTN_TRIGGER_HAPPY34) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY34) && HAVE_DECL_BTN_TRIGGER_HAPPY34)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY34) == (0x2e1), "BTN_TRIGGER_HAPPY34 != 0x2e1");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY34 0x2e1
#endif
#if defined(BTN_TRIGGER_HAPPY35) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY35) && HAVE_DECL_BTN_TRIGGER_HAPPY35)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY35) == (0x2e2), "BTN_TRIGGER_HAPPY35 != 0x2e2");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY35 0x2e2
#endif
#if defined(BTN_TRIGGER_HAPPY36) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY36) && HAVE_DECL_BTN_TRIGGER_HAPPY36)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY36) == (0x2e3), "BTN_TRIGGER_HAPPY36 != 0x2e3");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY36 0x2e3
#endif
#if defined(BTN_TRIGGER_HAPPY37) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY37) && HAVE_DECL_BTN_TRIGGER_HAPPY37)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY37) == (0x2e4), "BTN_TRIGGER_HAPPY37 != 0x2e4");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY37 0x2e4
#endif
#if defined(BTN_TRIGGER_HAPPY38) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY38) && HAVE_DECL_BTN_TRIGGER_HAPPY38)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY38) == (0x2e5), "BTN_TRIGGER_HAPPY38 != 0x2e5");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY38 0x2e5
#endif
#if defined(BTN_TRIGGER_HAPPY39) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY39) && HAVE_DECL_BTN_TRIGGER_HAPPY39)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY39) == (0x2e6), "BTN_TRIGGER_HAPPY39 != 0x2e6");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY39 0x2e6
#endif
#if defined(BTN_TRIGGER_HAPPY40) || (defined(HAVE_DECL_BTN_TRIGGER_HAPPY40) && HAVE_DECL_BTN_TRIGGER_HAPPY40)
DIAG_PUSH_IGNORE_TAUTOLOGICAL_COMPARE
static_assert((BTN_TRIGGER_HAPPY40) == (0x2e7), "BTN_TRIGGER_HAPPY40 != 0x2e7");
DIAG_POP_IGNORE_TAUTOLOGICAL_COMPARE
#else
# define BTN_TRIGGER_HAPPY40 0x2e7
#endif

#ifndef XLAT_MACROS_ONLY

# ifdef IN_MPERS

#  error static const struct xlat evdev_keycode in mpers mode

# else

static
const struct xlat evdev_keycode[] = {

 [KEY_RESERVED] = XLAT(KEY_RESERVED),
 [KEY_ESC] = XLAT(KEY_ESC),
 [KEY_1] = XLAT(KEY_1),
 [KEY_2] = XLAT(KEY_2),
 [KEY_3] = XLAT(KEY_3),
 [KEY_4] = XLAT(KEY_4),
 [KEY_5] = XLAT(KEY_5),
 [KEY_6] = XLAT(KEY_6),
 [KEY_7] = XLAT(KEY_7),
 [KEY_8] = XLAT(KEY_8),
 [KEY_9] = XLAT(KEY_9),
 [KEY_0] = XLAT(KEY_0),
 [KEY_MINUS] = XLAT(KEY_MINUS),
 [KEY_EQUAL] = XLAT(KEY_EQUAL),
 [KEY_BACKSPACE] = XLAT(KEY_BACKSPACE),
 [KEY_TAB] = XLAT(KEY_TAB),
 [KEY_Q] = XLAT(KEY_Q),
 [KEY_W] = XLAT(KEY_W),
 [KEY_E] = XLAT(KEY_E),
 [KEY_R] = XLAT(KEY_R),
 [KEY_T] = XLAT(KEY_T),
 [KEY_Y] = XLAT(KEY_Y),
 [KEY_U] = XLAT(KEY_U),
 [KEY_I] = XLAT(KEY_I),
 [KEY_O] = XLAT(KEY_O),
 [KEY_P] = XLAT(KEY_P),
 [KEY_LEFTBRACE] = XLAT(KEY_LEFTBRACE),
 [KEY_RIGHTBRACE] = XLAT(KEY_RIGHTBRACE),
 [KEY_ENTER] = XLAT(KEY_ENTER),
 [KEY_LEFTCTRL] = XLAT(KEY_LEFTCTRL),
 [KEY_A] = XLAT(KEY_A),
 [KEY_S] = XLAT(KEY_S),
 [KEY_D] = XLAT(KEY_D),
 [KEY_F] = XLAT(KEY_F),
 [KEY_G] = XLAT(KEY_G),
 [KEY_H] = XLAT(KEY_H),
 [KEY_J] = XLAT(KEY_J),
 [KEY_K] = XLAT(KEY_K),
 [KEY_L] = XLAT(KEY_L),
 [KEY_SEMICOLON] = XLAT(KEY_SEMICOLON),
 [KEY_APOSTROPHE] = XLAT(KEY_APOSTROPHE),
 [KEY_GRAVE] = XLAT(KEY_GRAVE),
 [KEY_LEFTSHIFT] = XLAT(KEY_LEFTSHIFT),
 [KEY_BACKSLASH] = XLAT(KEY_BACKSLASH),
 [KEY_Z] = XLAT(KEY_Z),
 [KEY_X] = XLAT(KEY_X),
 [KEY_C] = XLAT(KEY_C),
 [KEY_V] = XLAT(KEY_V),
 [KEY_B] = XLAT(KEY_B),
 [KEY_N] = XLAT(KEY_N),
 [KEY_M] = XLAT(KEY_M),
 [KEY_COMMA] = XLAT(KEY_COMMA),
 [KEY_DOT] = XLAT(KEY_DOT),
 [KEY_SLASH] = XLAT(KEY_SLASH),
 [KEY_RIGHTSHIFT] = XLAT(KEY_RIGHTSHIFT),
 [KEY_KPASTERISK] = XLAT(KEY_KPASTERISK),
 [KEY_LEFTALT] = XLAT(KEY_LEFTALT),
 [KEY_SPACE] = XLAT(KEY_SPACE),
 [KEY_CAPSLOCK] = XLAT(KEY_CAPSLOCK),
 [KEY_F1] = XLAT(KEY_F1),
 [KEY_F2] = XLAT(KEY_F2),
 [KEY_F3] = XLAT(KEY_F3),
 [KEY_F4] = XLAT(KEY_F4),
 [KEY_F5] = XLAT(KEY_F5),
 [KEY_F6] = XLAT(KEY_F6),
 [KEY_F7] = XLAT(KEY_F7),
 [KEY_F8] = XLAT(KEY_F8),
 [KEY_F9] = XLAT(KEY_F9),
 [KEY_F10] = XLAT(KEY_F10),
 [KEY_NUMLOCK] = XLAT(KEY_NUMLOCK),
 [KEY_SCROLLLOCK] = XLAT(KEY_SCROLLLOCK),
 [KEY_KP7] = XLAT(KEY_KP7),
 [KEY_KP8] = XLAT(KEY_KP8),
 [KEY_KP9] = XLAT(KEY_KP9),
 [KEY_KPMINUS] = XLAT(KEY_KPMINUS),
 [KEY_KP4] = XLAT(KEY_KP4),
 [KEY_KP5] = XLAT(KEY_KP5),
 [KEY_KP6] = XLAT(KEY_KP6),
 [KEY_KPPLUS] = XLAT(KEY_KPPLUS),
 [KEY_KP1] = XLAT(KEY_KP1),
 [KEY_KP2] = XLAT(KEY_KP2),
 [KEY_KP3] = XLAT(KEY_KP3),
 [KEY_KP0] = XLAT(KEY_KP0),
 [KEY_KPDOT] = XLAT(KEY_KPDOT),

 [KEY_ZENKAKUHANKAKU] = XLAT(KEY_ZENKAKUHANKAKU),
 [KEY_102ND] = XLAT(KEY_102ND),
 [KEY_F11] = XLAT(KEY_F11),
 [KEY_F12] = XLAT(KEY_F12),
 [KEY_RO] = XLAT(KEY_RO),
 [KEY_KATAKANA] = XLAT(KEY_KATAKANA),
 [KEY_HIRAGANA] = XLAT(KEY_HIRAGANA),
 [KEY_HENKAN] = XLAT(KEY_HENKAN),
 [KEY_KATAKANAHIRAGANA] = XLAT(KEY_KATAKANAHIRAGANA),
 [KEY_MUHENKAN] = XLAT(KEY_MUHENKAN),
 [KEY_KPJPCOMMA] = XLAT(KEY_KPJPCOMMA),
 [KEY_KPENTER] = XLAT(KEY_KPENTER),
 [KEY_RIGHTCTRL] = XLAT(KEY_RIGHTCTRL),
 [KEY_KPSLASH] = XLAT(KEY_KPSLASH),
 [KEY_SYSRQ] = XLAT(KEY_SYSRQ),
 [KEY_RIGHTALT] = XLAT(KEY_RIGHTALT),
 [KEY_LINEFEED] = XLAT(KEY_LINEFEED),
 [KEY_HOME] = XLAT(KEY_HOME),
 [KEY_UP] = XLAT(KEY_UP),
 [KEY_PAGEUP] = XLAT(KEY_PAGEUP),
 [KEY_LEFT] = XLAT(KEY_LEFT),
 [KEY_RIGHT] = XLAT(KEY_RIGHT),
 [KEY_END] = XLAT(KEY_END),
 [KEY_DOWN] = XLAT(KEY_DOWN),
 [KEY_PAGEDOWN] = XLAT(KEY_PAGEDOWN),
 [KEY_INSERT] = XLAT(KEY_INSERT),
 [KEY_DELETE] = XLAT(KEY_DELETE),
 [KEY_MACRO] = XLAT(KEY_MACRO),
 [KEY_MUTE] = XLAT(KEY_MUTE),
 [KEY_VOLUMEDOWN] = XLAT(KEY_VOLUMEDOWN),
 [KEY_VOLUMEUP] = XLAT(KEY_VOLUMEUP),
 [KEY_POWER] = XLAT(KEY_POWER),
 [KEY_KPEQUAL] = XLAT(KEY_KPEQUAL),
 [KEY_KPPLUSMINUS] = XLAT(KEY_KPPLUSMINUS),
 [KEY_PAUSE] = XLAT(KEY_PAUSE),
 [KEY_SCALE] = XLAT(KEY_SCALE),

 [KEY_KPCOMMA] = XLAT(KEY_KPCOMMA),
 [KEY_HANGEUL] = XLAT(KEY_HANGEUL),
 [KEY_HANJA] = XLAT(KEY_HANJA),
 [KEY_YEN] = XLAT(KEY_YEN),
 [KEY_LEFTMETA] = XLAT(KEY_LEFTMETA),
 [KEY_RIGHTMETA] = XLAT(KEY_RIGHTMETA),
 [KEY_COMPOSE] = XLAT(KEY_COMPOSE),

 [KEY_STOP] = XLAT(KEY_STOP),
 [KEY_AGAIN] = XLAT(KEY_AGAIN),
 [KEY_PROPS] = XLAT(KEY_PROPS),
 [KEY_UNDO] = XLAT(KEY_UNDO),
 [KEY_FRONT] = XLAT(KEY_FRONT),
 [KEY_COPY] = XLAT(KEY_COPY),
 [KEY_OPEN] = XLAT(KEY_OPEN),
 [KEY_PASTE] = XLAT(KEY_PASTE),
 [KEY_FIND] = XLAT(KEY_FIND),
 [KEY_CUT] = XLAT(KEY_CUT),
 [KEY_HELP] = XLAT(KEY_HELP),
 [KEY_MENU] = XLAT(KEY_MENU),
 [KEY_CALC] = XLAT(KEY_CALC),
 [KEY_SETUP] = XLAT(KEY_SETUP),
 [KEY_SLEEP] = XLAT(KEY_SLEEP),
 [KEY_WAKEUP] = XLAT(KEY_WAKEUP),
 [KEY_FILE] = XLAT(KEY_FILE),
 [KEY_SENDFILE] = XLAT(KEY_SENDFILE),
 [KEY_DELETEFILE] = XLAT(KEY_DELETEFILE),
 [KEY_XFER] = XLAT(KEY_XFER),
 [KEY_PROG1] = XLAT(KEY_PROG1),
 [KEY_PROG2] = XLAT(KEY_PROG2),
 [KEY_WWW] = XLAT(KEY_WWW),
 [KEY_MSDOS] = XLAT(KEY_MSDOS),
 [KEY_COFFEE] = XLAT(KEY_COFFEE),
 [KEY_ROTATE_DISPLAY] = XLAT(KEY_ROTATE_DISPLAY),
 [KEY_CYCLEWINDOWS] = XLAT(KEY_CYCLEWINDOWS),
 [KEY_MAIL] = XLAT(KEY_MAIL),
 [KEY_BOOKMARKS] = XLAT(KEY_BOOKMARKS),
 [KEY_COMPUTER] = XLAT(KEY_COMPUTER),
 [KEY_BACK] = XLAT(KEY_BACK),
 [KEY_FORWARD] = XLAT(KEY_FORWARD),
 [KEY_CLOSECD] = XLAT(KEY_CLOSECD),
 [KEY_EJECTCD] = XLAT(KEY_EJECTCD),
 [KEY_EJECTCLOSECD] = XLAT(KEY_EJECTCLOSECD),
 [KEY_NEXTSONG] = XLAT(KEY_NEXTSONG),
 [KEY_PLAYPAUSE] = XLAT(KEY_PLAYPAUSE),
 [KEY_PREVIOUSSONG] = XLAT(KEY_PREVIOUSSONG),
 [KEY_STOPCD] = XLAT(KEY_STOPCD),
 [KEY_RECORD] = XLAT(KEY_RECORD),
 [KEY_REWIND] = XLAT(KEY_REWIND),
 [KEY_PHONE] = XLAT(KEY_PHONE),
 [KEY_ISO] = XLAT(KEY_ISO),
 [KEY_CONFIG] = XLAT(KEY_CONFIG),
 [KEY_HOMEPAGE] = XLAT(KEY_HOMEPAGE),
 [KEY_REFRESH] = XLAT(KEY_REFRESH),
 [KEY_EXIT] = XLAT(KEY_EXIT),
 [KEY_MOVE] = XLAT(KEY_MOVE),
 [KEY_EDIT] = XLAT(KEY_EDIT),
 [KEY_SCROLLUP] = XLAT(KEY_SCROLLUP),
 [KEY_SCROLLDOWN] = XLAT(KEY_SCROLLDOWN),
 [KEY_KPLEFTPAREN] = XLAT(KEY_KPLEFTPAREN),
 [KEY_KPRIGHTPAREN] = XLAT(KEY_KPRIGHTPAREN),
 [KEY_NEW] = XLAT(KEY_NEW),
 [KEY_REDO] = XLAT(KEY_REDO),

 [KEY_F13] = XLAT(KEY_F13),
 [KEY_F14] = XLAT(KEY_F14),
 [KEY_F15] = XLAT(KEY_F15),
 [KEY_F16] = XLAT(KEY_F16),
 [KEY_F17] = XLAT(KEY_F17),
 [KEY_F18] = XLAT(KEY_F18),
 [KEY_F19] = XLAT(KEY_F19),
 [KEY_F20] = XLAT(KEY_F20),
 [KEY_F21] = XLAT(KEY_F21),
 [KEY_F22] = XLAT(KEY_F22),
 [KEY_F23] = XLAT(KEY_F23),
 [KEY_F24] = XLAT(KEY_F24),

 [KEY_PLAYCD] = XLAT(KEY_PLAYCD),
 [KEY_PAUSECD] = XLAT(KEY_PAUSECD),
 [KEY_PROG3] = XLAT(KEY_PROG3),
 [KEY_PROG4] = XLAT(KEY_PROG4),
 [KEY_DASHBOARD] = XLAT(KEY_DASHBOARD),
 [KEY_SUSPEND] = XLAT(KEY_SUSPEND),
 [KEY_CLOSE] = XLAT(KEY_CLOSE),
 [KEY_PLAY] = XLAT(KEY_PLAY),
 [KEY_FASTFORWARD] = XLAT(KEY_FASTFORWARD),
 [KEY_BASSBOOST] = XLAT(KEY_BASSBOOST),
 [KEY_PRINT] = XLAT(KEY_PRINT),
 [KEY_HP] = XLAT(KEY_HP),
 [KEY_CAMERA] = XLAT(KEY_CAMERA),
 [KEY_SOUND] = XLAT(KEY_SOUND),
 [KEY_QUESTION] = XLAT(KEY_QUESTION),
 [KEY_EMAIL] = XLAT(KEY_EMAIL),
 [KEY_CHAT] = XLAT(KEY_CHAT),
 [KEY_SEARCH] = XLAT(KEY_SEARCH),
 [KEY_CONNECT] = XLAT(KEY_CONNECT),
 [KEY_FINANCE] = XLAT(KEY_FINANCE),
 [KEY_SPORT] = XLAT(KEY_SPORT),
 [KEY_SHOP] = XLAT(KEY_SHOP),
 [KEY_ALTERASE] = XLAT(KEY_ALTERASE),
 [KEY_CANCEL] = XLAT(KEY_CANCEL),
 [KEY_BRIGHTNESSDOWN] = XLAT(KEY_BRIGHTNESSDOWN),
 [KEY_BRIGHTNESSUP] = XLAT(KEY_BRIGHTNESSUP),
 [KEY_MEDIA] = XLAT(KEY_MEDIA),

 [KEY_SWITCHVIDEOMODE] = XLAT(KEY_SWITCHVIDEOMODE),

 [KEY_KBDILLUMTOGGLE] = XLAT(KEY_KBDILLUMTOGGLE),
 [KEY_KBDILLUMDOWN] = XLAT(KEY_KBDILLUMDOWN),
 [KEY_KBDILLUMUP] = XLAT(KEY_KBDILLUMUP),

 [KEY_SEND] = XLAT(KEY_SEND),
 [KEY_REPLY] = XLAT(KEY_REPLY),
 [KEY_FORWARDMAIL] = XLAT(KEY_FORWARDMAIL),
 [KEY_SAVE] = XLAT(KEY_SAVE),
 [KEY_DOCUMENTS] = XLAT(KEY_DOCUMENTS),

 [KEY_BATTERY] = XLAT(KEY_BATTERY),

 [KEY_BLUETOOTH] = XLAT(KEY_BLUETOOTH),
 [KEY_WLAN] = XLAT(KEY_WLAN),
 [KEY_UWB] = XLAT(KEY_UWB),

 [KEY_UNKNOWN] = XLAT(KEY_UNKNOWN),

 [KEY_VIDEO_NEXT] = XLAT(KEY_VIDEO_NEXT),
 [KEY_VIDEO_PREV] = XLAT(KEY_VIDEO_PREV),
 [KEY_BRIGHTNESS_CYCLE] = XLAT(KEY_BRIGHTNESS_CYCLE),
 [KEY_BRIGHTNESS_AUTO] = XLAT(KEY_BRIGHTNESS_AUTO),
 [KEY_DISPLAY_OFF] = XLAT(KEY_DISPLAY_OFF),

 [KEY_WWAN] = XLAT(KEY_WWAN),

#ifndef STRACE_WORKAROUND_FOR_KEY_RFKILL
# define STRACE_WORKAROUND_FOR_KEY_RFKILL
/*
* KEY_RFKILL and KEY_NUMERIC_A constants were introduced by Linux kernel
* commits v2.6.33~17^2~2 and v4.1-rc1~150^2~1^10~6, respectively.
* Apparently, RHEL6 introduced an alternative KEY_RFKILL constant
* with the same value as upstream KEY_NUMERIC_A.
* Downstream vendors are *not* allowed to do this.
* Ignore the system value of KEY_RFKILL.
*/
# undef KEY_RFKILL
#endif
 [KEY_RFKILL] = XLAT(KEY_RFKILL),

 [KEY_MICMUTE] = XLAT(KEY_MICMUTE),

 [BTN_0] = XLAT(BTN_0),
 [BTN_1] = XLAT(BTN_1),
 [BTN_2] = XLAT(BTN_2),
 [BTN_3] = XLAT(BTN_3),
 [BTN_4] = XLAT(BTN_4),
 [BTN_5] = XLAT(BTN_5),
 [BTN_6] = XLAT(BTN_6),
 [BTN_7] = XLAT(BTN_7),
 [BTN_8] = XLAT(BTN_8),
 [BTN_9] = XLAT(BTN_9),

 [BTN_LEFT] = XLAT(BTN_LEFT),
 [BTN_RIGHT] = XLAT(BTN_RIGHT),
 [BTN_MIDDLE] = XLAT(BTN_MIDDLE),
 [BTN_SIDE] = XLAT(BTN_SIDE),
 [BTN_EXTRA] = XLAT(BTN_EXTRA),
 [BTN_FORWARD] = XLAT(BTN_FORWARD),
 [BTN_BACK] = XLAT(BTN_BACK),
 [BTN_TASK] = XLAT(BTN_TASK),

 [BTN_TRIGGER] = XLAT(BTN_TRIGGER),
 [BTN_THUMB] = XLAT(BTN_THUMB),
 [BTN_THUMB2] = XLAT(BTN_THUMB2),
 [BTN_TOP] = XLAT(BTN_TOP),
 [BTN_TOP2] = XLAT(BTN_TOP2),
 [BTN_PINKIE] = XLAT(BTN_PINKIE),
 [BTN_BASE] = XLAT(BTN_BASE),
 [BTN_BASE2] = XLAT(BTN_BASE2),
 [BTN_BASE3] = XLAT(BTN_BASE3),
 [BTN_BASE4] = XLAT(BTN_BASE4),
 [BTN_BASE5] = XLAT(BTN_BASE5),
 [BTN_BASE6] = XLAT(BTN_BASE6),
 [BTN_DEAD] = XLAT(BTN_DEAD),

 [BTN_SOUTH] = XLAT(BTN_SOUTH),
 [BTN_EAST] = XLAT(BTN_EAST),
 [BTN_C] = XLAT(BTN_C),
 [BTN_NORTH] = XLAT(BTN_NORTH),
 [BTN_WEST] = XLAT(BTN_WEST),
 [BTN_Z] = XLAT(BTN_Z),
 [BTN_TL] = XLAT(BTN_TL),
 [BTN_TR] = XLAT(BTN_TR),
 [BTN_TL2] = XLAT(BTN_TL2),
 [BTN_TR2] = XLAT(BTN_TR2),
 [BTN_SELECT] = XLAT(BTN_SELECT),
 [BTN_START] = XLAT(BTN_START),
 [BTN_MODE] = XLAT(BTN_MODE),
 [BTN_THUMBL] = XLAT(BTN_THUMBL),
 [BTN_THUMBR] = XLAT(BTN_THUMBR),

 [BTN_TOOL_PEN] = XLAT(BTN_TOOL_PEN),
 [BTN_TOOL_RUBBER] = XLAT(BTN_TOOL_RUBBER),
 [BTN_TOOL_BRUSH] = XLAT(BTN_TOOL_BRUSH),
 [BTN_TOOL_PENCIL] = XLAT(BTN_TOOL_PENCIL),
 [BTN_TOOL_AIRBRUSH] = XLAT(BTN_TOOL_AIRBRUSH),
 [BTN_TOOL_FINGER] = XLAT(BTN_TOOL_FINGER),
 [BTN_TOOL_MOUSE] = XLAT(BTN_TOOL_MOUSE),
 [BTN_TOOL_LENS] = XLAT(BTN_TOOL_LENS),
 [BTN_TOOL_QUINTTAP] = XLAT(BTN_TOOL_QUINTTAP),
 [BTN_STYLUS3] = XLAT(BTN_STYLUS3),
 [BTN_TOUCH] = XLAT(BTN_TOUCH),
 [BTN_STYLUS] = XLAT(BTN_STYLUS),
 [BTN_STYLUS2] = XLAT(BTN_STYLUS2),
 [BTN_TOOL_DOUBLETAP] = XLAT(BTN_TOOL_DOUBLETAP),
 [BTN_TOOL_TRIPLETAP] = XLAT(BTN_TOOL_TRIPLETAP),
 [BTN_TOOL_QUADTAP] = XLAT(BTN_TOOL_QUADTAP),

 [BTN_GEAR_DOWN] = XLAT(BTN_GEAR_DOWN),
 [BTN_GEAR_UP] = XLAT(BTN_GEAR_UP),

 [KEY_OK] = XLAT(KEY_OK),
 [KEY_SELECT] = XLAT(KEY_SELECT),
 [KEY_GOTO] = XLAT(KEY_GOTO),
 [KEY_CLEAR] = XLAT(KEY_CLEAR),
 [KEY_POWER2] = XLAT(KEY_POWER2),
 [KEY_OPTION] = XLAT(KEY_OPTION),
 [KEY_INFO] = XLAT(KEY_INFO),
 [KEY_TIME] = XLAT(KEY_TIME),
 [KEY_VENDOR] = XLAT(KEY_VENDOR),
 [KEY_ARCHIVE] = XLAT(KEY_ARCHIVE),
 [KEY_PROGRAM] = XLAT(KEY_PROGRAM),
 [KEY_CHANNEL] = XLAT(KEY_CHANNEL),
 [KEY_FAVORITES] = XLAT(KEY_FAVORITES),
 [KEY_EPG] = XLAT(KEY_EPG),
 [KEY_PVR] = XLAT(KEY_PVR),
 [KEY_MHP] = XLAT(KEY_MHP),
 [KEY_LANGUAGE] = XLAT(KEY_LANGUAGE),
 [KEY_TITLE] = XLAT(KEY_TITLE),
 [KEY_SUBTITLE] = XLAT(KEY_SUBTITLE),
 [KEY_ANGLE] = XLAT(KEY_ANGLE),
 [KEY_ZOOM] = XLAT(KEY_ZOOM),
 [KEY_MODE] = XLAT(KEY_MODE),
 [KEY_KEYBOARD] = XLAT(KEY_KEYBOARD),
 [KEY_SCREEN] = XLAT(KEY_SCREEN),
 [KEY_PC] = XLAT(KEY_PC),
 [KEY_TV] = XLAT(KEY_TV),
 [KEY_TV2] = XLAT(KEY_TV2),
 [KEY_VCR] = XLAT(KEY_VCR),
 [KEY_VCR2] = XLAT(KEY_VCR2),
 [KEY_SAT] = XLAT(KEY_SAT),
 [KEY_SAT2] = XLAT(KEY_SAT2),
 [KEY_CD] = XLAT(KEY_CD),
 [KEY_TAPE] = XLAT(KEY_TAPE),
 [KEY_RADIO] = XLAT(KEY_RADIO),
 [KEY_TUNER] = XLAT(KEY_TUNER),
 [KEY_PLAYER] = XLAT(KEY_PLAYER),
 [KEY_TEXT] = XLAT(KEY_TEXT),
 [KEY_DVD] = XLAT(KEY_DVD),
 [KEY_AUX] = XLAT(KEY_AUX),
 [KEY_MP3] = XLAT(KEY_MP3),
 [KEY_AUDIO] = XLAT(KEY_AUDIO),
 [KEY_VIDEO] = XLAT(KEY_VIDEO),
 [KEY_DIRECTORY] = XLAT(KEY_DIRECTORY),
 [KEY_LIST] = XLAT(KEY_LIST),
 [KEY_MEMO] = XLAT(KEY_MEMO),
 [KEY_CALENDAR] = XLAT(KEY_CALENDAR),
 [KEY_RED] = XLAT(KEY_RED),
 [KEY_GREEN] = XLAT(KEY_GREEN),
 [KEY_YELLOW] = XLAT(KEY_YELLOW),
 [KEY_BLUE] = XLAT(KEY_BLUE),
 [KEY_CHANNELUP] = XLAT(KEY_CHANNELUP),
 [KEY_CHANNELDOWN] = XLAT(KEY_CHANNELDOWN),
 [KEY_FIRST] = XLAT(KEY_FIRST),
 [KEY_LAST] = XLAT(KEY_LAST),
 [KEY_AB] = XLAT(KEY_AB),
 [KEY_NEXT] = XLAT(KEY_NEXT),
 [KEY_RESTART] = XLAT(KEY_RESTART),
 [KEY_SLOW] = XLAT(KEY_SLOW),
 [KEY_SHUFFLE] = XLAT(KEY_SHUFFLE),
 [KEY_BREAK] = XLAT(KEY_BREAK),
 [KEY_PREVIOUS] = XLAT(KEY_PREVIOUS),
 [KEY_DIGITS] = XLAT(KEY_DIGITS),
 [KEY_TEEN] = XLAT(KEY_TEEN),
 [KEY_TWEN] = XLAT(KEY_TWEN),
 [KEY_VIDEOPHONE] = XLAT(KEY_VIDEOPHONE),
 [KEY_GAMES] = XLAT(KEY_GAMES),
 [KEY_ZOOMIN] = XLAT(KEY_ZOOMIN),
 [KEY_ZOOMOUT] = XLAT(KEY_ZOOMOUT),
 [KEY_ZOOMRESET] = XLAT(KEY_ZOOMRESET),
 [KEY_WORDPROCESSOR] = XLAT(KEY_WORDPROCESSOR),
 [KEY_EDITOR] = XLAT(KEY_EDITOR),
 [KEY_SPREADSHEET] = XLAT(KEY_SPREADSHEET),
 [KEY_GRAPHICSEDITOR] = XLAT(KEY_GRAPHICSEDITOR),
 [KEY_PRESENTATION] = XLAT(KEY_PRESENTATION),
 [KEY_DATABASE] = XLAT(KEY_DATABASE),
 [KEY_NEWS] = XLAT(KEY_NEWS),
 [KEY_VOICEMAIL] = XLAT(KEY_VOICEMAIL),
 [KEY_ADDRESSBOOK] = XLAT(KEY_ADDRESSBOOK),
 [KEY_MESSENGER] = XLAT(KEY_MESSENGER),
 [KEY_DISPLAYTOGGLE] = XLAT(KEY_DISPLAYTOGGLE),
 [KEY_SPELLCHECK] = XLAT(KEY_SPELLCHECK),
 [KEY_LOGOFF] = XLAT(KEY_LOGOFF),

 [KEY_DOLLAR] = XLAT(KEY_DOLLAR),
 [KEY_EURO] = XLAT(KEY_EURO),

 [KEY_FRAMEBACK] = XLAT(KEY_FRAMEBACK),
 [KEY_FRAMEFORWARD] = XLAT(KEY_FRAMEFORWARD),
 [KEY_CONTEXT_MENU] = XLAT(KEY_CONTEXT_MENU),
 [KEY_MEDIA_REPEAT] = XLAT(KEY_MEDIA_REPEAT),
 [KEY_10CHANNELSUP] = XLAT(KEY_10CHANNELSUP),
 [KEY_10CHANNELSDOWN] = XLAT(KEY_10CHANNELSDOWN),
 [KEY_IMAGES] = XLAT(KEY_IMAGES),

 [KEY_DEL_EOL] = XLAT(KEY_DEL_EOL),
 [KEY_DEL_EOS] = XLAT(KEY_DEL_EOS),
 [KEY_INS_LINE] = XLAT(KEY_INS_LINE),
 [KEY_DEL_LINE] = XLAT(KEY_DEL_LINE),

 [KEY_FN] = XLAT(KEY_FN),
 [KEY_FN_ESC] = XLAT(KEY_FN_ESC),
 [KEY_FN_F1] = XLAT(KEY_FN_F1),
 [KEY_FN_F2] = XLAT(KEY_FN_F2),
 [KEY_FN_F3] = XLAT(KEY_FN_F3),
 [KEY_FN_F4] = XLAT(KEY_FN_F4),
 [KEY_FN_F5] = XLAT(KEY_FN_F5),
 [KEY_FN_F6] = XLAT(KEY_FN_F6),
 [KEY_FN_F7] = XLAT(KEY_FN_F7),
 [KEY_FN_F8] = XLAT(KEY_FN_F8),
 [KEY_FN_F9] = XLAT(KEY_FN_F9),
 [KEY_FN_F10] = XLAT(KEY_FN_F10),
 [KEY_FN_F11] = XLAT(KEY_FN_F11),
 [KEY_FN_F12] = XLAT(KEY_FN_F12),
 [KEY_FN_1] = XLAT(KEY_FN_1),
 [KEY_FN_2] = XLAT(KEY_FN_2),
 [KEY_FN_D] = XLAT(KEY_FN_D),
 [KEY_FN_E] = XLAT(KEY_FN_E),
 [KEY_FN_F] = XLAT(KEY_FN_F),
 [KEY_FN_S] = XLAT(KEY_FN_S),
 [KEY_FN_B] = XLAT(KEY_FN_B),

 [KEY_BRL_DOT1] = XLAT(KEY_BRL_DOT1),
 [KEY_BRL_DOT2] = XLAT(KEY_BRL_DOT2),
 [KEY_BRL_DOT3] = XLAT(KEY_BRL_DOT3),
 [KEY_BRL_DOT4] = XLAT(KEY_BRL_DOT4),
 [KEY_BRL_DOT5] = XLAT(KEY_BRL_DOT5),
 [KEY_BRL_DOT6] = XLAT(KEY_BRL_DOT6),
 [KEY_BRL_DOT7] = XLAT(KEY_BRL_DOT7),
 [KEY_BRL_DOT8] = XLAT(KEY_BRL_DOT8),
 [KEY_BRL_DOT9] = XLAT(KEY_BRL_DOT9),
 [KEY_BRL_DOT10] = XLAT(KEY_BRL_DOT10),

 [KEY_NUMERIC_0] = XLAT(KEY_NUMERIC_0),
 [KEY_NUMERIC_1] = XLAT(KEY_NUMERIC_1),
 [KEY_NUMERIC_2] = XLAT(KEY_NUMERIC_2),
 [KEY_NUMERIC_3] = XLAT(KEY_NUMERIC_3),
 [KEY_NUMERIC_4] = XLAT(KEY_NUMERIC_4),
 [KEY_NUMERIC_5] = XLAT(KEY_NUMERIC_5),
 [KEY_NUMERIC_6] = XLAT(KEY_NUMERIC_6),
 [KEY_NUMERIC_7] = XLAT(KEY_NUMERIC_7),
 [KEY_NUMERIC_8] = XLAT(KEY_NUMERIC_8),
 [KEY_NUMERIC_9] = XLAT(KEY_NUMERIC_9),
 [KEY_NUMERIC_STAR] = XLAT(KEY_NUMERIC_STAR),
 [KEY_NUMERIC_POUND] = XLAT(KEY_NUMERIC_POUND),
 [KEY_NUMERIC_A] = XLAT(KEY_NUMERIC_A),
 [KEY_NUMERIC_B] = XLAT(KEY_NUMERIC_B),
 [KEY_NUMERIC_C] = XLAT(KEY_NUMERIC_C),
 [KEY_NUMERIC_D] = XLAT(KEY_NUMERIC_D),

 [KEY_CAMERA_FOCUS] = XLAT(KEY_CAMERA_FOCUS),
 [KEY_WPS_BUTTON] = XLAT(KEY_WPS_BUTTON),

 [KEY_TOUCHPAD_TOGGLE] = XLAT(KEY_TOUCHPAD_TOGGLE),
 [KEY_TOUCHPAD_ON] = XLAT(KEY_TOUCHPAD_ON),
 [KEY_TOUCHPAD_OFF] = XLAT(KEY_TOUCHPAD_OFF),

 [KEY_CAMERA_ZOOMIN] = XLAT(KEY_CAMERA_ZOOMIN),
 [KEY_CAMERA_ZOOMOUT] = XLAT(KEY_CAMERA_ZOOMOUT),
 [KEY_CAMERA_UP] = XLAT(KEY_CAMERA_UP),
 [KEY_CAMERA_DOWN] = XLAT(KEY_CAMERA_DOWN),
 [KEY_CAMERA_LEFT] = XLAT(KEY_CAMERA_LEFT),
 [KEY_CAMERA_RIGHT] = XLAT(KEY_CAMERA_RIGHT),

 [KEY_ATTENDANT_ON] = XLAT(KEY_ATTENDANT_ON),
 [KEY_ATTENDANT_OFF] = XLAT(KEY_ATTENDANT_OFF),
 [KEY_ATTENDANT_TOGGLE] = XLAT(KEY_ATTENDANT_TOGGLE),
 [KEY_LIGHTS_TOGGLE] = XLAT(KEY_LIGHTS_TOGGLE),

 [BTN_DPAD_UP] = XLAT(BTN_DPAD_UP),
 [BTN_DPAD_DOWN] = XLAT(BTN_DPAD_DOWN),
 [BTN_DPAD_LEFT] = XLAT(BTN_DPAD_LEFT),
 [BTN_DPAD_RIGHT] = XLAT(BTN_DPAD_RIGHT),

 [KEY_ALS_TOGGLE] = XLAT(KEY_ALS_TOGGLE),
 [KEY_ROTATE_LOCK_TOGGLE] = XLAT(KEY_ROTATE_LOCK_TOGGLE),

 [KEY_BUTTONCONFIG] = XLAT(KEY_BUTTONCONFIG),
 [KEY_TASKMANAGER] = XLAT(KEY_TASKMANAGER),
 [KEY_JOURNAL] = XLAT(KEY_JOURNAL),
 [KEY_CONTROLPANEL] = XLAT(KEY_CONTROLPANEL),
 [KEY_APPSELECT] = XLAT(KEY_APPSELECT),
 [KEY_SCREENSAVER] = XLAT(KEY_SCREENSAVER),
 [KEY_VOICECOMMAND] = XLAT(KEY_VOICECOMMAND),
 [KEY_ASSISTANT] = XLAT(KEY_ASSISTANT),

#ifndef STRACE_WORKAROUND_FOR_KEY_BRIGHTNESS_MIN
# define STRACE_WORKAROUND_FOR_KEY_BRIGHTNESS_MIN
/*
* KEY_BRIGHTNESS_MIN and KEY_BRIGHTNESS_MAX constants were introduced
* by Linux kernel commit v3.16-rc1~30^2~6^2~1^2~7.
* Apparently, RHEL7 introduced an alternative KEY_BRIGHTNESS_MIN constant
* with the same value as upstream KEY_BRIGHTNESS_MAX.
* Downstream vendors are *not* allowed to do this.
* Ignore the system value of KEY_BRIGHTNESS_MIN.
*/
# undef KEY_BRIGHTNESS_MIN
#endif
 [KEY_BRIGHTNESS_MIN] = XLAT(KEY_BRIGHTNESS_MIN),

 [KEY_BRIGHTNESS_MAX] = XLAT(KEY_BRIGHTNESS_MAX),

 [KEY_KBDINPUTASSIST_PREV] = XLAT(KEY_KBDINPUTASSIST_PREV),
 [KEY_KBDINPUTASSIST_NEXT] = XLAT(KEY_KBDINPUTASSIST_NEXT),
 [KEY_KBDINPUTASSIST_PREVGROUP] = XLAT(KEY_KBDINPUTASSIST_PREVGROUP),
 [KEY_KBDINPUTASSIST_NEXTGROUP] = XLAT(KEY_KBDINPUTASSIST_NEXTGROUP),
 [KEY_KBDINPUTASSIST_ACCEPT] = XLAT(KEY_KBDINPUTASSIST_ACCEPT),
 [KEY_KBDINPUTASSIST_CANCEL] = XLAT(KEY_KBDINPUTASSIST_CANCEL),

 [KEY_RIGHT_UP] = XLAT(KEY_RIGHT_UP),
 [KEY_RIGHT_DOWN] = XLAT(KEY_RIGHT_DOWN),
 [KEY_LEFT_UP] = XLAT(KEY_LEFT_UP),
 [KEY_LEFT_DOWN] = XLAT(KEY_LEFT_DOWN),

 [KEY_ROOT_MENU] = XLAT(KEY_ROOT_MENU),
 [KEY_MEDIA_TOP_MENU] = XLAT(KEY_MEDIA_TOP_MENU),
 [KEY_NUMERIC_11] = XLAT(KEY_NUMERIC_11),
 [KEY_NUMERIC_12] = XLAT(KEY_NUMERIC_12),

 [KEY_AUDIO_DESC] = XLAT(KEY_AUDIO_DESC),
 [KEY_3D_MODE] = XLAT(KEY_3D_MODE),
 [KEY_NEXT_FAVORITE] = XLAT(KEY_NEXT_FAVORITE),
 [KEY_STOP_RECORD] = XLAT(KEY_STOP_RECORD),
 [KEY_PAUSE_RECORD] = XLAT(KEY_PAUSE_RECORD),
 [KEY_VOD] = XLAT(KEY_VOD),
 [KEY_UNMUTE] = XLAT(KEY_UNMUTE),
 [KEY_FASTREVERSE] = XLAT(KEY_FASTREVERSE),
 [KEY_SLOWREVERSE] = XLAT(KEY_SLOWREVERSE),

#ifndef STRACE_WORKAROUND_FOR_KEY_DATA
# define STRACE_WORKAROUND_FOR_KEY_DATA
/*
* Linux kernel commit v4.9-rc8~12^2 has changed the value of KEY_DATA
* constant introduced by commit v4.7-rc6~32^2~6^2 because the old value
* was already used by KEY_FASTREVERSE.
* Looks like the best way to handle this situation is to pretend that
* the old value of KEY_DATA didn't exist.
*/
# undef KEY_DATA
#endif
 [KEY_DATA] = XLAT(KEY_DATA),

 [KEY_ONSCREEN_KEYBOARD] = XLAT(KEY_ONSCREEN_KEYBOARD),

 [BTN_TRIGGER_HAPPY1] = XLAT(BTN_TRIGGER_HAPPY1),
 [BTN_TRIGGER_HAPPY2] = XLAT(BTN_TRIGGER_HAPPY2),
 [BTN_TRIGGER_HAPPY3] = XLAT(BTN_TRIGGER_HAPPY3),
 [BTN_TRIGGER_HAPPY4] = XLAT(BTN_TRIGGER_HAPPY4),
 [BTN_TRIGGER_HAPPY5] = XLAT(BTN_TRIGGER_HAPPY5),
 [BTN_TRIGGER_HAPPY6] = XLAT(BTN_TRIGGER_HAPPY6),
 [BTN_TRIGGER_HAPPY7] = XLAT(BTN_TRIGGER_HAPPY7),
 [BTN_TRIGGER_HAPPY8] = XLAT(BTN_TRIGGER_HAPPY8),
 [BTN_TRIGGER_HAPPY9] = XLAT(BTN_TRIGGER_HAPPY9),
 [BTN_TRIGGER_HAPPY10] = XLAT(BTN_TRIGGER_HAPPY10),
 [BTN_TRIGGER_HAPPY11] = XLAT(BTN_TRIGGER_HAPPY11),
 [BTN_TRIGGER_HAPPY12] = XLAT(BTN_TRIGGER_HAPPY12),
 [BTN_TRIGGER_HAPPY13] = XLAT(BTN_TRIGGER_HAPPY13),
 [BTN_TRIGGER_HAPPY14] = XLAT(BTN_TRIGGER_HAPPY14),
 [BTN_TRIGGER_HAPPY15] = XLAT(BTN_TRIGGER_HAPPY15),
 [BTN_TRIGGER_HAPPY16] = XLAT(BTN_TRIGGER_HAPPY16),
 [BTN_TRIGGER_HAPPY17] = XLAT(BTN_TRIGGER_HAPPY17),
 [BTN_TRIGGER_HAPPY18] = XLAT(BTN_TRIGGER_HAPPY18),
 [BTN_TRIGGER_HAPPY19] = XLAT(BTN_TRIGGER_HAPPY19),
 [BTN_TRIGGER_HAPPY20] = XLAT(BTN_TRIGGER_HAPPY20),
 [BTN_TRIGGER_HAPPY21] = XLAT(BTN_TRIGGER_HAPPY21),
 [BTN_TRIGGER_HAPPY22] = XLAT(BTN_TRIGGER_HAPPY22),
 [BTN_TRIGGER_HAPPY23] = XLAT(BTN_TRIGGER_HAPPY23),
 [BTN_TRIGGER_HAPPY24] = XLAT(BTN_TRIGGER_HAPPY24),
 [BTN_TRIGGER_HAPPY25] = XLAT(BTN_TRIGGER_HAPPY25),
 [BTN_TRIGGER_HAPPY26] = XLAT(BTN_TRIGGER_HAPPY26),
 [BTN_TRIGGER_HAPPY27] = XLAT(BTN_TRIGGER_HAPPY27),
 [BTN_TRIGGER_HAPPY28] = XLAT(BTN_TRIGGER_HAPPY28),
 [BTN_TRIGGER_HAPPY29] = XLAT(BTN_TRIGGER_HAPPY29),
 [BTN_TRIGGER_HAPPY30] = XLAT(BTN_TRIGGER_HAPPY30),
 [BTN_TRIGGER_HAPPY31] = XLAT(BTN_TRIGGER_HAPPY31),
 [BTN_TRIGGER_HAPPY32] = XLAT(BTN_TRIGGER_HAPPY32),
 [BTN_TRIGGER_HAPPY33] = XLAT(BTN_TRIGGER_HAPPY33),
 [BTN_TRIGGER_HAPPY34] = XLAT(BTN_TRIGGER_HAPPY34),
 [BTN_TRIGGER_HAPPY35] = XLAT(BTN_TRIGGER_HAPPY35),
 [BTN_TRIGGER_HAPPY36] = XLAT(BTN_TRIGGER_HAPPY36),
 [BTN_TRIGGER_HAPPY37] = XLAT(BTN_TRIGGER_HAPPY37),
 [BTN_TRIGGER_HAPPY38] = XLAT(BTN_TRIGGER_HAPPY38),
 [BTN_TRIGGER_HAPPY39] = XLAT(BTN_TRIGGER_HAPPY39),
 [BTN_TRIGGER_HAPPY40] = XLAT(BTN_TRIGGER_HAPPY40),
 XLAT_END
};

# endif /* !IN_MPERS */

#endif /* !XLAT_MACROS_ONLY */